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

C/C++ Source or Header | 1992-08-18 | 13.5 KB | 768 lines

/*
**    $Id: termReview.c,v 1.7 92/08/15 20:14:56 olsen Sta Locker: olsen $
**    $Revision: 1.7 $
**    $Date: 92/08/15 20:14:56 $
**
**    Support routines for the review buffer (not the log book!)
**
**    Copyright ⌐ 1990-1992 by Olaf `Olsen' Barthel & MXM
**        All Rights Reserved
*/

#include "termGlobal.h"

    /* Scroller gadget flags. */

#define PROP_FLAGS    (AUTOKNOB | FREEVERT | PROPBORDERLESS | PROPNEWLOOK)

    /* Number of context lines to keep between pages. */

#define CONTEXT_LINES    1

    /* Local routines. */

STATIC VOID        ReviewUpdatePot(VOID);
STATIC VOID __stdargs    ReviewWrites(STRPTR String,...);
STATIC VOID __regargs    PrintReviewLine(STRPTR Buffer,LONG Line);
STATIC VOID __regargs    RefreshReview(LONG Top);
STATIC BYTE        ReviewQuery(VOID);
STATIC UBYTE __regargs    GetReviewChar(BYTE WaitForIt);

    /* Local variables. */

STATIC struct IBox     ReviewBox;
STATIC struct IOStdReq    *ReviewWriteRequest,
            *ReviewReadRequest;

STATIC struct MsgPort    *ReviewWritePort;

STATIC LONG         ReviewWidth = -1,ReviewHeight,
             ReviewX,ReviewY;
STATIC UBYTE         ReviewChar;
STATIC LONG         ReviewColumns,ReviewLines,ReviewTop,ReviewGlobalLines;
STATIC LONG         ReviewBody = -1,ReviewPot = -1;

STATIC struct Image     ReviewPropImage;

STATIC struct PropInfo ReviewPropInfo =
{
    PROP_FLAGS,
    0,MAXPOT,
    0,MAXBODY,
    0,0,
    0,0,
    0,0
};

STATIC struct Gadget ReviewPropGadget =
{
    NULL,
    0,0,
    0,0,
    GFLG_GADGHCOMP | GFLG_RELRIGHT | GFLG_RELHEIGHT,
    GACT_IMMEDIATE | GACT_FOLLOWMOUSE,
    GTYP_PROPGADGET,
    &ReviewPropImage,
    NULL,
    NULL,
    0,
    (APTR)&ReviewPropInfo,
    0,
    NULL
};

    /* ReviewUpdatePot():
     *
     *    Update size and position of the scroller gadget.
     */

STATIC VOID
ReviewUpdatePot()
{
    if(ReviewGlobalLines)
    {
        LONG    Body,
            Pot,
            Hidden;

        Hidden = MAX(ReviewGlobalLines - ReviewLines,0);

        if(ReviewTop > Hidden)
            ReviewTop = 0;

        if(Hidden > 0)
        {
            Body    = (UWORD)(((ULONG)(ReviewLines - CONTEXT_LINES) * MAXBODY) / (ReviewGlobalLines - CONTEXT_LINES));
            Pot    = (UWORD)(((ULONG)ReviewTop * MAXPOT) / Hidden);
        }
        else
        {
            Body    = MAXBODY;
            Pot    = 0;
        }

        if(Body != ReviewBody || Pot != ReviewPot)
        {
            NewModifyProp(&ReviewPropGadget,ReviewWindow,NULL,PROP_FLAGS,0,Pot,0,Body,1);

            ReviewBody    = Body;
            ReviewPot    = Pot;
        }
    }
}

    /* ReviewUp(LONG Count):
     *
     *    Move the contents of the review buffer up.
     */

STATIC VOID __regargs
ReviewUp(LONG Count)
{
    if(Count == 1)
    {
        if(ReviewTop)
        {
            ReviewTop--;

            ReviewWrites("\033[T");

            ObtainSemaphore(BufferSemaphore);

            PrintReviewLine(BufferLines[ReviewTop],1);

            ReviewUpdatePot();

            ReleaseSemaphore(BufferSemaphore);
        }
    }
    else
    {
        LONG NewTop = ReviewTop;

        if(NewTop >= Count)
            NewTop -= Count;
        else
            NewTop = 0;

        if(NewTop != ReviewTop)
        {
            ReviewTop = NewTop;

            RefreshReview(ReviewTop);

            ReviewUpdatePot();
        }
    }
}

    /* ReviewDown(LONG Count):
     *
     *    Move the contents of the review buffer down.
     */

STATIC VOID __regargs
ReviewDown(LONG Count)
{
    if(Count == 1)
    {
        if(ReviewTop + ReviewLines < Lines)
        {
            LONG Last;

            ReviewTop++;

            ReviewWrites("\033[S");

            ObtainSemaphore(BufferSemaphore);

            if((Last = ReviewTop + ReviewLines) < Lines)
                PrintReviewLine(BufferLines[Last],ReviewLines + 1);

            ReviewUpdatePot();

            ReleaseSemaphore(BufferSemaphore);
        }
    }
    else
    {
        LONG NewTop = ReviewTop;

        if((NewTop + Count + ReviewLines) > Lines)
        {
            if((NewTop = Lines - ReviewLines) < 0)
                NewTop = 0;
        }
        else
            NewTop += Count;

        if(NewTop != ReviewTop)
        {
            ReviewTop = NewTop;

            RefreshReview(ReviewTop);

            ReviewUpdatePot();
        }
    }
}

    /* ReviewWrites(STRPTR String,...):
     *
     *    Write a string into the review buffer window.
     */

STATIC VOID __stdargs
ReviewWrites(STRPTR String,...)
{
    va_list    VarArgs;

    va_start(VarArgs,String);
    VSPrintf(SharedBuffer,String,VarArgs);
    va_end(VarArgs);

    ReviewWriteRequest -> io_Command    = CMD_WRITE;
    ReviewWriteRequest -> io_Data        = SharedBuffer;
    ReviewWriteRequest -> io_Length        = -1;

    DoIO(ReviewWriteRequest);
}

    /* PrintReviewLine(STRPTR Buffer,LONG Line):
     *
     *    Write the contents of a buffer line into the review buffer window.
     */

STATIC VOID __regargs
PrintReviewLine(STRPTR Buffer,LONG Line)
{
    WORD Length = ((ULONG *)Buffer)[-1];

    if(Length > ReviewColumns)
        Length = ReviewColumns;

    ReviewWrites("\033[%ldH",Line);

    ReviewWriteRequest -> io_Command    = CMD_WRITE;
    ReviewWriteRequest -> io_Data        = Buffer;
    ReviewWriteRequest -> io_Length        = Length;

    DoIO(ReviewWriteRequest);

    ReviewWrites("\033[0K");
}

    /* RefreshReview(LONG Top):
     *
     *    Refresh the contents of the review buffer window.
     */

STATIC VOID __regargs
RefreshReview(LONG Top)
{
    LONG i,Last,Line = 0;

    ReviewGlobalLines = Lines;

    ObtainSemaphore(BufferSemaphore);

    if((Last = Top + ReviewLines + 1) >= Lines)
        Last = Lines;

    for(i = Top ; i < Last ; i++)
        PrintReviewLine(BufferLines[i],++Line);

    if(Line <= ReviewLines)
        ReviewWrites("\033[0J");

    ReleaseSemaphore(BufferSemaphore);
}

    /* ReviewQuery():
     *
     *    Update the current review buffer window dimensions.
     */

STATIC BYTE
ReviewQuery()
{
    struct ConUnit    *Unit = (struct ConUnit *)ReviewWriteRequest -> io_Unit;
    BYTE         Refresh = FALSE;

    if(ReviewColumns != Unit -> cu_XMax)
    {
        Refresh = TRUE;

        ReviewColumns = Unit -> cu_XMax;
    }

    if(ReviewLines != Unit -> cu_YMax)
    {
        LONG Delta = ABS(Unit -> cu_YMax - ReviewLines);

        Refresh = TRUE;

        if(ReviewLines)
        {
            if(Unit -> cu_YMax > ReviewLines)
            {
                if((ReviewTop = ReviewTop - Delta) < 0)
                    ReviewTop = 0;
            }
            else
                ReviewTop += Delta;
        }

        ReviewLines = Unit -> cu_YMax;
    }

    if(Refresh)
        ReviewUpdatePot();

    return(Refresh);
}

    /* GetReviewChar(BYTE WaitForIt):
     *
     *    Get the next character present at the console read port.
     */

STATIC UBYTE __regargs
GetReviewChar(BYTE WaitForIt)
{
    UBYTE Char;

    if(!WaitForIt)
    {
        if(!CheckIO(ReviewReadRequest))
            return(0);
    }

    WaitIO(ReviewReadRequest);

    Char = ReviewChar;

    ReviewReadRequest -> io_Command    = CMD_READ;
    ReviewReadRequest -> io_Data    = &ReviewChar;
    ReviewReadRequest -> io_Length    = 1;

    SendIO(ReviewReadRequest);

    return(Char);
}

    /* DeleteReview():
     *
     *    Delete the review buffer.
     */

VOID
DeleteReview()
{
    struct MenuItem *Item;

    if(Item = FindThisItem(MEN_REVIEW_WINDOW))
        Item -> Flags &= ~CHECKED;

    if(ReviewWriteRequest)
    {
        if(ReviewWriteRequest -> io_Device)
        {
            ReviewWriteRequest -> io_Command = CMD_CLEAR;

            DoIO(ReviewWriteRequest);

            CloseDevice(ReviewWriteRequest);
        }

        DeleteIORequest(ReviewWriteRequest);

        ReviewWriteRequest = NULL;
    }

    if(ReviewReadRequest)
    {
        if(ReviewReadRequest -> io_Device)
        {
            if(!CheckIO(ReviewReadRequest))
                AbortIO(ReviewReadRequest);

            WaitIO(ReviewReadRequest);
        }

        FreeVec(ReviewReadRequest);

        ReviewReadRequest = NULL;
    }

    ReviewPot = ReviewBody = -1;

    if(ReviewWindow)
    {
        ReviewWidth    = ReviewWindow -> Width;
        ReviewHeight    = ReviewWindow -> Height;
        ReviewX        = ReviewWindow -> LeftEdge;
        ReviewY        = ReviewWindow -> TopEdge;

        CloseWindow(ReviewWindow);

        ReviewWindow = NULL;
    }

    if(ReviewWritePort)
    {
        DeleteMsgPort(ReviewWritePort);

        ReviewWritePort = NULL;
    }

    if(ReviewPort)
    {
        DeleteMsgPort(ReviewPort);

        ReviewPort = NULL;
    }
}

    /* CreateReview():
     *
     *    Create the review buffer.
     */

BYTE
CreateReview()
{
    if(ReviewWidth == -1)
    {
        ReviewWidth        = Screen -> Width;
        ReviewHeight        = Screen -> WBorTop + Screen -> WBorBottom + 1 + Screen -> Font -> ta_YSize + 5 * Screen -> Font -> ta_YSize;
        ReviewX            = 0;
        ReviewY            = Screen -> BarHeight + 1;

        ReviewBox . Left    = 0;
        ReviewBox . Top        = Screen -> BarHeight + 1;
        ReviewBox . Width    = Screen -> Width;
        ReviewBox . Height    = Screen -> Height - (Screen -> BarHeight + 1);
    }

    ReviewPropGadget . TopEdge    = Screen -> WBorTop + Screen -> Font -> ta_YSize + 2;
    ReviewPropGadget . LeftEdge    = -15;
    ReviewPropGadget . Width    = 14;
    ReviewPropGadget . Height    = -(ReviewPropGadget . TopEdge + Screen -> WBorBottom + 9);

    if(ReviewWindow = OpenWindowTags(NULL,
        WA_Left,        ReviewX,
        WA_Top,            ReviewY,
        WA_Width,        ReviewWidth,
        WA_Height,        ReviewHeight,
        WA_MinWidth,        Screen -> WBorLeft + Screen -> WBorRight + 15 * 8,
        WA_MinHeight,        Screen -> WBorTop + Screen -> WBorBottom + 1 + 2 * Screen -> Font -> ta_YSize,
        WA_MaxWidth,        Screen -> Width,
        WA_MaxHeight,        Screen -> Height,
        WA_DragBar,        TRUE,
        WA_CloseGadget,        TRUE,
        WA_DepthGadget,        TRUE,
        WA_SizeGadget,        TRUE,
        WA_IDCMP,        IDCMP_GADGETDOWN | IDCMP_MOUSEMOVE,
        WA_Title,        LocaleString(MSG_TERMREVIEW_REVIEWBUFFER_TXT),
        WA_CustomScreen,    Screen,
        WA_SimpleRefresh,    TRUE,
        WA_RMBTrap,        TRUE,
        WA_Activate,        TRUE,
        WA_Zoom,        &ReviewBox,
    TAG_DONE))
    {
        AddGadget(ReviewWindow,&ReviewPropGadget,-1);
        RefreshGadgets(&ReviewPropGadget,ReviewWindow,NULL);

        SetFont(ReviewWindow -> RPort,CurrentFont);

        if(ReviewWritePort = CreateMsgPort())
        {
            if(ReviewPort = CreateMsgPort())
            {
                if(ReviewWriteRequest = CreateIORequest(ReviewPort,sizeof(struct IOStdReq)))
                {
                    if(ReviewReadRequest = (struct IOStdReq *)AllocVec(sizeof(struct IOStdReq),MEMF_PUBLIC | MEMF_CLEAR))
                    {
                        ReviewWriteRequest -> io_Data = ReviewWindow;

                        if(!OpenDevice("console.device",CONU_SNIPMAP,ReviewWriteRequest,CONFLAG_NODRAW_ON_NEWSIZE))
                        {
                            struct MenuItem    *Item;
                            BYTE         Pen;

                            if(Item = FindThisItem(MEN_REVIEW_WINDOW))
                                Item -> Flags |= CHECKED;

                            switch(Config . ColourMode)
                            {
                                case COLOUR_EIGHT:
                                case COLOUR_SIXTEEN:    Pen = 7;
                                            break;

                                default:        Pen = 1;
                                            break;
                            }

                            CopyMem(ReviewWriteRequest,ReviewReadRequest,sizeof(struct IOStdReq));

                            ReviewReadRequest -> io_Message . mn_ReplyPort = ReviewPort;

                            ReviewWrites("\033[0 p\033[11;12{\033[3%ldm",Pen);

                            ReviewQuery();

                            ObtainSemaphore(BufferSemaphore);

                            if((ReviewTop = Lines - ReviewLines) < 0)
                                ReviewTop = 0;

                            ReleaseSemaphore(BufferSemaphore);

                            RefreshReview(ReviewTop);

                            ReviewUpdatePot();

                            ReviewReadRequest -> io_Command    = CMD_READ;
                            ReviewReadRequest -> io_Data    = &ReviewChar;
                            ReviewReadRequest -> io_Length    = 1;

                            SendIO(ReviewReadRequest);

                            return(TRUE);
                        }
                    }
                }
            }
        }
    }

    DeleteReview();

    return(FALSE);
}

    /* UpdateReview():
     *
     *    Update the contents of the review buffer window.
     */

VOID
UpdateReview(BYTE Force)
{
    if(ReviewPort)
    {
        if(Force || (Lines >= ReviewGlobalLines && ReviewGlobalLines <= ReviewLines))
            RefreshReview(ReviewTop);

        ReviewGlobalLines = Lines;

        ReviewUpdatePot();
    }
}

    /* HandleReview():
     *
     *    Process console and user input.
     */

BYTE
HandleReview()
{
    BYTE Result = FALSE;

    if(ReviewWindow)
    {
        struct IntuiMessage *Message;

        if(Message = (struct IntuiMessage *)GetMsg(ReviewWindow -> UserPort))
        {
            ReplyMsg((struct Message *)Message);

            if(ReviewGlobalLines > ReviewLines)
            {
                UWORD Hidden;

                Hidden        = MAX(ReviewGlobalLines - ReviewLines,0);
                ReviewTop    = (((ULONG)Hidden * ReviewPropInfo . VertPot) + (MAXPOT / 2)) >> 16;

                RefreshReview(ReviewTop);
            }

            Result = TRUE;
        }
    }

    if(ReviewPort)
    {
        UBYTE Char;

        if(Char = GetReviewChar(FALSE))
        {
            if(Char == CSI)
            {
                WORD Count = 0;

                Char = GetReviewChar(TRUE);

                switch(Char)
                {
                    case 'A':    ReviewUp(1);
                            break;

                    case 'B':    ReviewDown(1);
                            break;

                    case 'T':    ReviewUp(ReviewLines);
                            break;

                    case 'S':    ReviewDown(ReviewLines);
                            break;

                    default:    SharedBuffer[Count++] = Char;

                            while(Char = GetReviewChar(FALSE))
                            {
                                SharedBuffer[Count++] = Char;

                                if(Char == 'v' || Char == '|')
                                    break;
                            }

                            SharedBuffer[Count] = 0;

                            if(!strcmp(SharedBuffer,"0 v"))
                            {
                                if(!ClipInput)
                                {
                                    if(!OpenClip())
                                        ClipInput = ClipXerox = TRUE;
                                    else
                                        ClipInput = ClipXerox = FALSE;
                                }
                            }
                            else
                            {
                                if(!strncmp(SharedBuffer,"11",2))
                                {
                                    DeleteReview();

                                    return(Result);
                                }

                                if(!strncmp(SharedBuffer,"12",2))
                                {
                                    if(ReviewQuery())
                                        RefreshReview(ReviewTop);
                                }
                            }

                            break;
                }
            }
            else
            {
                if(Config . StripBit8)
                    Char &= 0x7F;

                if(Status == STATUS_HOLDING)
                {
                    if(Char == XOF)
                    {
                        SerWrite(&Char,1);

                        Status = STATUS_READY;
                    }
                    else
                        DoBeep();
                }
                else
                {
                        /* Convert chars
                         * as approriate.
                         */

                    if(Char == '\n')
                    {
                        switch(Config . SendLF)
                        {
                            case LF_IGNORE:    break;

                            case LF_ASLF:    goto SendIt;

                            case LF_ASLFCR:    SerWrite("\n\r",2);
                                    break;
                        }

                        return(TRUE);
                    }

                    if(Char == '\r')
                    {
                        switch(Config . SendCR)
                        {
                            case CR_IGNORE:    break;

                            case CR_ASCR:    goto SendIt;

                            case CR_ASCRLF:    SerWrite("\r\n",2);
                                    break;
                        }

                        return(TRUE);
                    }

                        /* Stop in/output. */

                    if(Char == XON)
                    {
                        if(Config . PassThrough)
                        {
                            SerWrite(&Char,1);

                            return(TRUE);
                        }
                        else
                        {
                            if(Config . xONxOFF)
                                Status = STATUS_HOLDING;
                        }
                    }

                        /* Restart in/output. */

                    if(Char == XOF)
                    {
                        if(Config . PassThrough)
                        {
                            SerWrite(&Char,1);

                            return(TRUE);
                        }
                    }

                        /* Convert special
                         * Amiga characters into
                         * alien IBM dialect.
                         */

SendIt:                    if(Config . Font == FONT_IBM)
                    {
                        if(IBMConversion[Char])
                            SerWrite(&IBMConversion[Char],1);
                        else
                            SerWrite(&Char,1);
                    }
                    else
                        SerWrite(&Char,1);
                }
            }

            return(TRUE);
        }
    }

    return(Result);
}