Otherware/Otherware_1_SB_Development.iso/amiga/comms/comprgs/term232.lha/Source_Code/termSource/termRaster.c

C/C++ Source or Header | 1992-08-18 | 6.8 KB | 405 lines

/*
**    $Id: termRaster.c,v 1.6 92/08/15 20:14:54 olsen Sta Locker: olsen $
**    $Revision: 1.6 $
**    $Date: 92/08/15 20:14:54 $
**
**    Screen character (raster) buffering routines
**
**    Copyright ⌐ 1990-1992 by Olaf `Olsen' Barthel & MXM
**        All Rights Reserved
*/

#include "termGlobal.h"

    /* DeleteRaster():
     *
     *    Free the contents of the character raster.
     */

VOID
DeleteRaster()
{
    if(Raster)
    {
        FreeVec(Raster);

        Raster = NULL;
    }

    if(RasterAttr)
    {
        FreeVec(RasterAttr);

        RasterAttr = NULL;
    }
}

    /* CreateRaster():
     *
     *    Create the character raster.
     */

BYTE
CreateRaster()
{
        /* Width of the screen * 2 (in characters).
         * extra for Double width
         */

    RasterWidth    = (Window -> Width / TextFontWidth) * 2;

        /* Height of the character raster. */

    RasterHeight    = Window -> Height / TextFontHeight;

        /* Allocate the raster. */

    if(Raster = (UBYTE *)AllocVec(RasterWidth * RasterHeight,MEMF_ANY|MEMF_CLEAR))
    {
            /* Allocate the raster attributes. */

        if(RasterAttr = (UBYTE *)AllocVec(RasterHeight,MEMF_ANY|MEMF_CLEAR))
            return(TRUE);
        else
        {
            FreeVec(Raster);

            Raster = NULL;
        }
    }

    return(FALSE);
}

    /* RasterEraseScreen(BYTE Mode):
     *
     *    Erase parts of the screen.
     */

VOID __regargs
RasterEraseScreen(BYTE Mode)
{
    WORD    First,
        Last;

    switch(Mode)
    {
        case 1:    First    = 0;
            Last    = CursorY * RasterWidth + CursorX + 1;

            memset(&RasterAttr[0],SCALE_NORMAL,CursorY + 1);

            break;

        case 2:    First    = 0;
            Last    = RasterHeight * RasterWidth - 1;

            memset(&RasterAttr[0],SCALE_NORMAL,RasterHeight);

            break;

        default:First    = CursorY * RasterWidth + CursorX;
            Last    = RasterHeight * RasterWidth - 1;

            memset(&RasterAttr[CursorY],SCALE_NORMAL,RasterHeight - CursorY);

            break;
    }

    if(Last > First)
        memset(&Raster[First],' ',Last - First);
}

    /* RasterEraseLine(BYTE Mode):
     *
     *    Erase parts of the current cursor line.
     */

VOID __regargs
RasterEraseLine(BYTE Mode)
{
    WORD    First,
        Last;

    switch(Mode)
    {
            /* From beginning to current cursor position. */

        case 1:    First    = CursorY * RasterWidth;
            Last    = First + CursorX + 1;

            break;

            /* Entire line. */

        case 2:    First    = CursorY * RasterWidth;
            Last    = First + RasterWidth - 1;

            break;

            /* From current cursor position towards end. */

        default:First    = CursorY * RasterWidth + CursorX;
            Last    = (CursorY + 1) * RasterWidth - 1;

            break;
    }

    if(Last > First)
        memset(&Raster[First],' ',Last - First);
}

    /* RasterEraseCharacters(WORD Chars):
     *
     *    Erase a number of characters in the current cursor
     *    line.
     */

VOID __regargs
RasterEraseCharacters(WORD Chars)
{
    if(CursorX < RasterWidth - 1)
    {
        WORD     First,
             Diff;
        UBYTE    *To,
            *From;

        First    = CursorY * RasterWidth + CursorX;
        To    = &Raster[First];

        if(CursorX + Chars >= RasterWidth)
        {
            Diff = RasterWidth - 1 - CursorX;

            while(Diff-- > 0)
                *To++ = ' ';
        }
        else
        {
            From    = &Raster[First + Chars];
            Diff    = RasterWidth - (CursorX + 1 + Chars);

            while(Diff--)
            {
                *To++ = *From;

                *From++ = ' ';
            }
        }
    }
}

    /* RasterClearLine(WORD Lines):
     *
     *    Clear and remove a number of lines.
     */

VOID __regargs
RasterClearLine(WORD Lines,WORD Top)
{
    if(Lines)
    {
        WORD RegionBottom;

        if(RegionSet)
            RegionBottom = Bottom;
        else
            RegionBottom = LastLine + 1;

        if(Top + Lines >= RegionBottom)
            RasterEraseScreen(0);
        else
        {
            WORD     Max;
            UBYTE    *From,
                *To;

            Max    = (RegionBottom - (Top + Lines)) * RasterWidth;

            From    = &Raster[(Top + Lines) * RasterWidth];
            To    = &Raster[ Top          * RasterWidth];

            while(Max--)
            {
                *To++ = *From;

                *From++ = ' ';
            }

            memset(&RasterAttr[RegionBottom - Lines],SCALE_NORMAL,Lines);
        }
    }
}

    /* RasterInsertLine(WORD Lines):
     *
     *    Insert a number of lines at the current cursor line.
     */

VOID __regargs
RasterInsertLine(WORD Lines,WORD Top)
{
    if(Lines)
    {
        WORD RegionBottom;

        if(RegionSet)
            RegionBottom = Bottom;
        else
            RegionBottom = LastLine + 1;

        if(Top + Lines > RegionBottom)
            RasterEraseScreen(0);
        else
        {
            WORD     From,To,
                 Max;
            UBYTE    *FromPtr,
                *ToPtr;

            Max    = (RegionBottom - Lines - Top) * RasterWidth;

            From    = (RegionBottom - Lines) * RasterWidth - 1;
            To    =  RegionBottom          * RasterWidth - 1;

            FromPtr    = &Raster[From];
            ToPtr    = &Raster[To];

            while(Max--)
                *ToPtr-- = *FromPtr--;

            memset(&Raster[Top * RasterWidth],' ',Lines * RasterWidth);
        }
    }
}

    /* RasterScrollRegion(WORD Direction,WORD RasterTop,WORD RasterBottom,WORD RasterLines):
     *
     *    Scroll the contents of the character raster up/down.
     */

VOID __regargs
RasterScrollRegion(WORD Direction,WORD RasterTop,WORD RasterBottom,WORD RasterLines)
{
    WORD Dir = ABS(Direction);

    if(Dir >= RasterLines)
    {
            /* All that is needed is to delete the lines. */

        memset(&Raster[RasterTop * RasterWidth],' ',RasterLines * RasterWidth);
    }
    else
    {
        WORD     First,
             Last,
             Max,
             i;
        UBYTE    *From,
            *To;

        Max = (RasterLines - Dir) * RasterWidth;

        if(Direction < 0)
        {
            First    = (RasterTop + RasterLines - Dir) * RasterWidth - 1;
            Last    = (RasterTop + RasterLines    ) * RasterWidth - 1;

            From    = &Raster[First];
            To    = &Raster[Last];

            while(Max--)
                *To-- = *From--;

            for(i = RasterBottom ; i >= (RasterTop + Dir) ; i--)
                RasterAttr[i] = RasterAttr[i - Dir];

            memset(&Raster[RasterTop * RasterWidth],' ',RasterWidth * Dir);

            memset(&RasterAttr[RasterTop],SCALE_NORMAL,Dir);
        }
        else
        {
            First    = RasterTop * RasterWidth + RasterWidth * Dir;
            Last    = RasterTop * RasterWidth;

            From    = &Raster[First];
            To    = &Raster[Last];

            while(Max--)
                *To++ = *From++;

            memset(&Raster[(RasterBottom - Dir) * RasterWidth],' ',RasterWidth * Dir);

            for(i = RasterTop ; i <= (RasterBottom - Dir) ; i++)
                RasterAttr[i] = RasterAttr[i + Dir];

            memset(&RasterAttr[RasterBottom - Dir],SCALE_NORMAL,Dir);
        }
    }
}

    /* RasterShiftChar(WORD Size):
     *
     *    Shift the characters following the current cursor
     *    position Size characters to the right.
     */

VOID __regargs
RasterShiftChar(WORD Size)
{
    WORD     i,
         First;
    UBYTE    *From,
        *To;

    if(CursorX + Size >= RasterWidth - 1)
    {
        i    = RasterWidth - 1 - CursorX;
        To    = &Raster[CursorY * RasterWidth + CursorX];

        while(i-- > 0)
            *To++ = ' ';
    }
    else
    {
        First    = (CursorY + 1) * RasterWidth - 1;
        To    = &Raster[First];

        From    = &Raster[First - Size];
        i    = RasterWidth - Size;

        while(i-- > CursorX)
            *To-- = *From--;

        To    = &Raster[CursorY * RasterWidth + CursorX];

        while(Size--)
            *To++ = ' ';
    }
}

    /* RasterPutString(UBYTE *String,WORD Length):
     *
     *    Put a string into the character raster.
     */

VOID __regargs
RasterPutString(UBYTE *String,WORD Length)
{
    if(Length == 1)
    {
        if(CursorX + 1 < RasterWidth)
            Raster[CursorY * RasterWidth + CursorX] = String[0];
    }
    else
    {
        if(CursorX + Length >= RasterWidth)
            Length = RasterWidth - 1 - CursorX;

        if(Length > 0)
            memcpy(&Raster[CursorY * RasterWidth + CursorX],String,Length);
    }
}