Return to avio.c CVS log

Up to [OS/2 SDKs] / pmsdk / samples / comtalk

Annotation of pmsdk/samples/comtalk/avio.c, revision 1.1

1.1     ! root        1: /*
        !             2:        avio.c -- AVIO handling routines
        !             3:        For a cleaner implementation, look at the BROWSE application.
        !             4: 
        !             5:        Implements scrollbars, sets up an AVIO Presentation Space
        !             6:        Intrinsically linked with a circular queue routine
        !             7: 
        !             8:        Created by Microsoft Corporation, 1989
        !             9: */
        !            10: 
        !            11: #define  INCL_AVIO
        !            12: #define         INCL_DEV
        !            13: #define  INCL_VIO
        !            14: #define         INCL_WIN
        !            15: #include <os2.h>
        !            16: #include "global.h"
        !            17: #include "circleq.h"   /* Get Circular Buffer routines */
        !            18: #include "avio.h"      /* Prototype our routines */
        !            19: #include <stdio.h>     /* Needed to open LOG file */
        !            20: /*
        !            21:     Constants
        !            22: */
        !            23: #define AVIO_PS_ROWS   25      /* Dimensions of the AVIO PS */
        !            24: #define AVIO_PS_COLUMNS        MAXLINELEN
        !            25: #define        CATTRBYTES      1       /* 1 or 3 attribute bytes/cell */
        !            26: #define        DEFPAGEWIDTH    5       /* Default pagesizes */
        !            27: #define        DEFPAGEHEIGHT   5
        !            28: 
        !            29: char   Blank[2] = { 0x20, 0x07 };
        !            30: 
        !            31: /*
        !            32:     Macros to make the code more readable
        !            33: */
        !            34: /* Upper and Lower Bound Calculations */
        !            35: #define        Abs(a)          (((a) > 0) ? (a) : (-(a)))
        !            36: #define LowerBound(pos, disp, lbound) Max(pos - disp, lbound)
        !            37: #define UpperBound(pos, disp, ubound) Min(pos + disp, ubound)
        !            38: 
        !            39: /* Scroll Bar Abbreviations */
        !            40: 
        !            41: #define        DisableSB(hSB)  WinSetParent(hSB,  HWND_OBJECT, FALSE)
        !            42: #define        EnableSB(hSB)   WinSetParent(hSB, hWndSBParent, FALSE)
        !            43: #define        HBarHeight()    (fNeedHorz ? lHSBHeight : 0L)
        !            44: #define        VBarWidth()     (fNeedVert ? lVSBWidth  : 0L)
        !            45: #define SetScroll(h, pos, max) \
        !            46:     WinSendMsg(h, SBM_SETSCROLLBAR, MPFROM2SHORT(pos, 0), MPFROM2SHORT(0, max))
        !            47: #define        UpdateFrame(sb) \
        !            48:     WinSendMsg(hWndSBParent, WM_UPDATEFRAME, MPFROMLONG(sb), 0L)
        !            49: #define        UpdateOff(w)    WinEnableWindowUpdate(w, FALSE)
        !            50: #define        UpdateOn(w)     WinEnableWindowUpdate(w, TRUE)
        !            51: 
        !            52: /* Scrolling Macros */
        !            53: #define        ClearScreen()   ScrollUp(-1)
        !            54: #define ScrollDown(n)  VioScrollDn(0, 0, -1, -1, n, Blank, hVPS)
        !            55: #define        ScrollUp(n)     VioScrollUp(0, 0, -1, -1, n, Blank, hVPS)
        !            56: #define        SetCursor(x, y) VioSetCurPos((USHORT) x, (USHORT) y, hVPS)
        !            57: 
        !            58: /* Miscellaneous */
        !            59: /*
        !            60:     If partial ANSI emulation is desired, use:
        !            61:        VioSetCurPos((USHORT) x, (USHORT) y, hVPS); \
        !            62:        VioWrtTTY(l->szText, l->cch, hVPS)
        !            63: */
        !            64: #define Blast(l, x, y) VioWrtCharStr(l->szText, l->cch, x, y, hVPS)
        !            65: /*
        !            66:     Calculate the number of characters in a page
        !            67:     For nicer behavior, you can do rounding here
        !            68: */
        !            69: #define CalcChars(pPg, pCh, default) \
        !            70:        ((pCh) ? (Max((int) ((pPg) / ((SHORT) pCh)), 0)) : (default))
        !            71: #define        Value(value)    WinQuerySysValue(HWND_DESKTOP, value)
        !            72: /*
        !            73:     File-Local Variables
        !            74: */
        !            75: HDC    hDC;            /* Device Context */
        !            76: HVPS   hVPS;           /* Virtual PS */
        !            77: int    iTopLine;       /* PS Line of window corner */
        !            78: int    iCurCol;        /* Current column of window corner */
        !            79: int    cchPgWidth;     /* Width and height of our window */
        !            80: int    cchPgHeight;
        !            81: int    cchMaxHorz;     /* Scroll bar upper bounds */
        !            82: int    cchMaxVert;     
        !            83: BOOL   fNeedHorz;      /* Do we need the scroll bars or not? */
        !            84: BOOL   fNeedVert;
        !            85: HWND   hWndHScroll;    /* Window handles of ScrollBar windows */
        !            86: HWND   hWndVScroll;
        !            87: HWND   hWndSBParent;   /* Could mooch off the value in main(), but won't */
        !            88: /*
        !            89:     Measurements used to help make the window look nice
        !            90: */
        !            91: LONG   lChWidth,   lChHeight;                  /* Character size */
        !            92: LONG   lHSBHeight, lVSBWidth;                  /* Scrollbar measurements */
        !            93: LONG   lMiscWidth, lMiscHeight;                /* Border, titlebar, ... */
        !            94: int    iMaxWidth,  iMaxHeight;                 /* Client area bounds  */
        !            95: int    iMaxFrameWidth, iMaxFrameHeight;        /* Frame window bounds */
        !            96: BOOL   fCreated;                               /* AVIO PS created */
        !            97: int    rc;                                     /* Return code */
        !            98: VIOCURSORINFO vci;
        !            99: /*
        !           100:    Local prototypes
        !           101: */
        !           102: void GetMeasurements(void);
        !           103: void Update(USHORT, USHORT, USHORT, BOOL);
        !           104: void Refresh(BOOL);
        !           105: void WantCursor(BOOL);
        !           106: void SetScrollPos(void);
        !           107: void SetScrollPosHorz(void);
        !           108: void SetScrollPosVert(void);
        !           109: /*
        !           110:     The actual routines
        !           111: */
        !           112: void GetMeasurements(void) {
        !           113: /*
        !           114:     Get display parameters
        !           115: */
        !           116:     /*
        !           117:        Scroll bar widths and heights
        !           118:     */
        !           119:     lHSBHeight = Value(SV_CYHSCROLL);
        !           120:     lVSBWidth  = Value(SV_CXVSCROLL);
        !           121:     /*
        !           122:        Non-PS widths and heights
        !           123:     */ 
        !           124:     lMiscHeight        = (Value(SV_CYSIZEBORDER) << 1) /* A border on each side */
        !           125:                + Value(SV_CYTITLEBAR)          /* The title bar...      */
        !           126:                + Value(SV_CYMENU)              /* ...and the menu bar   */
        !           127:                + Value(SV_CYBYTEALIGN);        /* ...and alignment      */
        !           128:                
        !           129:     lMiscWidth = (Value(SV_CXSIZEBORDER) << 1);/* A border on each side */
        !           130:     /*
        !           131:        Height and width of characters
        !           132:     */
        !           133:     rc = DevQueryCaps(hDC, CAPS_CHAR_HEIGHT, 1L, &lChHeight);
        !           134:     rc = DevQueryCaps(hDC, CAPS_CHAR_WIDTH,  1L, &lChWidth);
        !           135:     /*
        !           136:        Compute size of client and frame windows
        !           137:     */
        !           138:     iMaxWidth          = (AVIO_PS_COLUMNS      * (int) lChWidth);
        !           139:     iMaxHeight         = (AVIO_PS_ROWS         * (int) lChHeight);
        !           140:     iMaxFrameWidth     = (iMaxWidth            + (int) lMiscWidth);
        !           141:     iMaxFrameHeight    = (iMaxHeight           + (int) lMiscHeight);
        !           142:     /*
        !           143:        Compute cursor attributes
        !           144:     */
        !           145:     vci.yStart = (USHORT) 0;
        !           146:     vci.cEnd   = (USHORT) lChHeight - 1;
        !           147:     vci.cx     = 0;
        !           148: }
        !           149: 
        !           150: void AvioInit(HWND hWndFrame, HWND hWndClient) {
        !           151: /*
        !           152:     Initialize Presentation Space, Device Context, Scroll Bars
        !           153: */
        !           154:     /*
        !           155:        Create the AVIO Presentation Space
        !           156:     */
        !           157:     hDC = WinOpenWindowDC(hWndClient);
        !           158:     VioCreatePS(&hVPS, AVIO_PS_ROWS, AVIO_PS_COLUMNS, 0, CATTRBYTES, 0);
        !           159:     VioAssociate(hDC, hVPS);
        !           160:     fCreated = TRUE;
        !           161:     /*
        !           162:        Turn on the cursor and home it
        !           163:     */
        !           164:     WantCursor(TRUE);
        !           165:     SetCursor(0, 0);
        !           166:     /*
        !           167:        Snag scroll bar info
        !           168:     */
        !           169:     hWndHScroll  = WinWindowFromID(hWndFrame,  FID_HORZSCROLL);
        !           170:     hWndVScroll  = WinWindowFromID(hWndFrame,  FID_VERTSCROLL);
        !           171:     hWndSBParent = WinQueryWindow(hWndHScroll, QW_PARENT, FALSE);
        !           172:     fNeedHorz   = fNeedVert  = TRUE;
        !           173:     /*
        !           174:        Get character height in pixels, etc...
        !           175:     */
        !           176:     GetMeasurements();
        !           177: }
        !           178: 
        !           179: void AvioStartup(HWND hWndClient) {
        !           180:     SWP swp;
        !           181:     /*
        !           182:        Initialize the queue
        !           183:     */
        !           184:     QueInit();
        !           185:     /*
        !           186:        Initialize the screen
        !           187:     */
        !           188:     ClearScreen();
        !           189:     WinQueryWindowPos(hWndClient, &swp);
        !           190:     AvioSize(hWndClient, WM_NULL, NULL, MPFROM2SHORT(swp.cx, swp.cy));
        !           191: }
        !           192: 
        !           193: void AvioScroll(USHORT SB_Command, USHORT usPosition, BOOL fHorizontal) {
        !           194: /*
        !           195:     Process the scroll bar messages
        !           196: 
        !           197:     These routines are symmetric; in fact, SB_LINELEFT = SB_LINEUP, etc...
        !           198:     so one might note that this could be condensed.  It's left expanded for
        !           199:     speed and clarity.  I bound the values each way so that we stay inside
        !           200:     the AVIO presentation space.
        !           201: */
        !           202:     if (fHorizontal) {  /* Horizontal Scroll Bar */
        !           203:        switch (SB_Command) {
        !           204:            case SB_LINELEFT:
        !           205:                iCurCol = LowerBound(iCurCol, 1, 0); break;
        !           206:            case SB_LINERIGHT:
        !           207:                iCurCol = UpperBound(iCurCol, 1, cchMaxHorz); break;
        !           208:            case SB_PAGELEFT:
        !           209:                iCurCol = LowerBound(iCurCol, cchPgWidth, 0); break;
        !           210:            case SB_PAGERIGHT:
        !           211:                iCurCol = UpperBound(iCurCol, cchPgWidth, cchMaxHorz); break;
        !           212:            case SB_SLIDERTRACK:
        !           213:                iCurCol = (SHORT) usPosition;
        !           214:            default: break;
        !           215:        }
        !           216:        if (SB_Command != SB_SLIDERTRACK)
        !           217:            SetScroll(hWndHScroll, iCurCol, cchMaxHorz);
        !           218: 
        !           219:     } else { /* Vertical Scroll Bar */
        !           220:        switch (SB_Command) {
        !           221:            case SB_LINEUP:
        !           222:                iTopLine = LowerBound(iTopLine, 1, 0); break;
        !           223:            case SB_LINEDOWN:
        !           224:                iTopLine = UpperBound(iTopLine, 1, cchMaxVert); break;
        !           225:            case SB_PAGEUP:
        !           226:                iTopLine = LowerBound(iTopLine, cchPgHeight, 0); break;
        !           227:            case SB_PAGEDOWN:
        !           228:                iTopLine = UpperBound(iTopLine, cchPgHeight, cchMaxVert); break;
        !           229:            case SB_SLIDERTRACK:
        !           230:                iTopLine = (SHORT) usPosition;
        !           231:            default: break;
        !           232:        }
        !           233:        if (SB_Command != SB_SLIDERTRACK)
        !           234:            SetScroll(hWndVScroll, iTopLine, cchMaxVert);
        !           235:     }
        !           236:     Refresh(FALSE);
        !           237: }
        !           238: 
        !           239: MRESULT AvioSize(HWND hWnd, USHORT msg, MPARAM mp1, MPARAM mp2) {
        !           240: /*
        !           241:     Do the default AVIO sizing, and kyfe a few values
        !           242: */
        !           243:     if (!fCreated) return 0L;
        !           244:     /*
        !           245:        Compute height and width of page in characters
        !           246: 
        !           247:        The scrollbars have already been subtracted out,
        !           248:        since we are called by the client area.
        !           249:     */
        !           250:     cchPgHeight = CalcChars(SHORT2FROMMP(mp2), lChHeight, DEFPAGEHEIGHT); 
        !           251:     cchPgWidth  = CalcChars(SHORT1FROMMP(mp2), lChWidth,  DEFPAGEWIDTH);
        !           252:     /*
        !           253:        Adjust scrollbar maximums
        !           254:     */
        !           255:     cchMaxVert = Max(AVIO_PS_ROWS    - cchPgHeight, 0);
        !           256:     cchMaxHorz = Max(AVIO_PS_COLUMNS -  cchPgWidth, 0);
        !           257:     /*
        !           258:        Maintain scrollbar integrity
        !           259:     */
        !           260:     fNeedHorz = (cchMaxHorz > 0);
        !           261:     fNeedVert = (cchMaxVert > 0);
        !           262:     SetScroll(hWndHScroll, iCurCol  = Min(iCurCol, cchMaxHorz), cchMaxHorz);
        !           263:     SetScroll(hWndVScroll, iTopLine = Min(iTopLine,cchMaxVert), cchMaxVert);
        !           264:     /*
        !           265:        Do the Scroll Bar shifting
        !           266:     */
        !           267:     Refresh(FALSE);
        !           268:     /*
        !           269:        Now, do the normal AVIO processing
        !           270:     */
        !           271:     return WinDefAVioWindowProc(hWnd, msg, mp1, mp2);
        !           272: }
        !           273: 
        !           274: void Update
        !           275:     (USHORT usLineNum, USHORT usHowMany, USHORT usStartLine, BOOL fForced) {
        !           276: /*
        !           277:     Updates usHowMany lines starting from usStartLine on screen.
        !           278:     Starts at saved line usLineNum.  If fForced is set, all lines
        !           279:     in range are displayed; otherwise it's lazy.
        !           280: */
        !           281:     USHORT     i;                              /* Loop index */
        !           282:     USHORT     usWhichLine = usLineNum;        /* Line to be queried */
        !           283:     Line       l;                              /* Line to be output */
        !           284: 
        !           285:     for (i = usStartLine; i < (usStartLine + usHowMany); i++) {
        !           286:        l = QueQuery(usWhichLine++);            /* Get the line */
        !           287:        if (!l->fDrawn || fForced) {
        !           288:            if (l->cch) Blast(l, i, 0);         /* Print it out */
        !           289:            if (!l->fComplete) SetCursor(i, l->cch);
        !           290:            l->fDrawn = TRUE;
        !           291:        }
        !           292:     }
        !           293: }
        !           294: 
        !           295: void Refresh(BOOL fRedraw) {
        !           296: /*
        !           297:     fRedraw forces full redraw if set 
        !           298: */
        !           299:     SHORT  sDelta;
        !           300:     int static iOldTopLine = -AVIO_PS_ROWS;
        !           301: 
        !           302:     VioSetOrg(0, iCurCol, hVPS); /* Get the free AVIO horizontal shift */
        !           303:     sDelta = iTopLine - iOldTopLine; /* Compute vertical shift */
        !           304:     if ((Abs(sDelta) < AVIO_PS_ROWS) && !fRedraw) {
        !           305:        if (sDelta < 0) {       /* Scroll Up -- make sDelta positive*/
        !           306:            ScrollDown(-sDelta);
        !           307:            Update(iTopLine, -sDelta, 0, TRUE);
        !           308:        } else {                /* Scroll Down by sDelta */
        !           309:            ScrollUp(sDelta);
        !           310:            Update(iTopLine + cchPgHeight - sDelta, sDelta,
        !           311:                                cchPgHeight - sDelta, TRUE);
        !           312:        }
        !           313:     } else AvioRedraw();       /* Redo the entire screen */
        !           314:     iOldTopLine = iTopLine;
        !           315: }
        !           316: 
        !           317: void AvioClose (void) {
        !           318: /*
        !           319:     Termination routines
        !           320: */
        !           321:     /*
        !           322:        Destroy the Presentation Space
        !           323:     */
        !           324:     VioAssociate(NULL, hVPS);
        !           325:     VioDestroyPS(hVPS);
        !           326:     fCreated = FALSE;
        !           327: }
        !           328: 
        !           329: void AvioPaint(HWND hWnd) {
        !           330:     static HPS   hPS;
        !           331:     static RECTL rcl;
        !           332: 
        !           333:     hPS = WinBeginPaint(hWnd, NULL, &rcl);
        !           334:     VioShowPS(AVIO_PS_ROWS, AVIO_PS_COLUMNS, 0, hVPS);
        !           335:     WinEndPaint(hPS);
        !           336: } 
        !           337: 
        !           338: MRESULT AvioMinMax(PSWP pSWP) {
        !           339: /*
        !           340:     Control Maximizing
        !           341: */
        !           342:     if (pSWP->fs & (SWP_MAXIMIZE | SWP_RESTORE)) {
        !           343:        if (pSWP->fs & SWP_MAXIMIZE) {
        !           344:            /*
        !           345:                Save cx, cy values for later origin displacement
        !           346:            */
        !           347:            int iOldcx = pSWP->cx;
        !           348:            int iOldcy = pSWP->cy;
        !           349:            /*
        !           350:                Displace, and change to maximum size
        !           351:            */
        !           352:            pSWP->x += (iOldcx - (pSWP->cx = iMaxFrameWidth));
        !           353:            pSWP->y += (iOldcy - (pSWP->cy = iMaxFrameHeight));
        !           354:        }
        !           355:        /*
        !           356:            Now, fix the scroll bars
        !           357:        */
        !           358:        AvioAdjustFrame(pSWP);
        !           359:        return TRUE;
        !           360:     }
        !           361:     return FALSE;
        !           362: }
        !           363: 
        !           364: void AvioClear(void) { ClearScreen(); }
        !           365: 
        !           366: void AvioAdjustFrame(PSWP pSWP) {
        !           367: /*
        !           368:     Trap WM_ADJUSTWINDOWPOS messages to the frame with this routine.
        !           369:     Keep the window sized right, and control scrollbar visibility.
        !           370: */
        !           371:     BOOL fNeededHorz = fNeedHorz;
        !           372:     BOOL fNeededVert = fNeedVert;
        !           373: /*
        !           374:     Do scrollbar enable/disable calculations (but don't update the screen)
        !           375: */
        !           376:     if (pSWP->fs & SWP_MINIMIZE) fNeedHorz = fNeedVert = FALSE;
        !           377:     if ((pSWP->cx * pSWP->cy) == 0) return;
        !           378:     /*
        !           379:        Do we need them?
        !           380:     */
        !           381:     fNeedVert = (pSWP->cy < (SHORT) (iMaxFrameHeight));
        !           382:     fNeedHorz = (pSWP->cx < (SHORT) (iMaxFrameWidth  + VBarWidth()));
        !           383:     fNeedVert = (pSWP->cy < (SHORT) (iMaxFrameHeight + HBarHeight()));
        !           384: /*
        !           385:     Do width calculations to make sure we're staying small enough.
        !           386:     The Tracking Rectangle shouldn't allow us to get too big.
        !           387: */
        !           388:     /*
        !           389:        Check if we're stretching too far
        !           390:     */
        !           391:     pSWP->cx = Min(pSWP->cx, iMaxFrameWidth  + (int) VBarWidth());
        !           392:     pSWP->cy = Min(pSWP->cy, iMaxFrameHeight + (int) HBarHeight());
        !           393:     /*
        !           394:        ...if so, fix, then add them!
        !           395:     */
        !           396:     AvioSize(NULL, WM_NULL, NULL, MPFROM2SHORT(
        !           397:        pSWP->cx - (int) (lMiscWidth + VBarWidth()),
        !           398:        pSWP->cy - (int) (lMiscHeight + HBarHeight()) ));
        !           399: 
        !           400:     if (fNeedHorz) {
        !           401:        if (!fNeededHorz) {
        !           402:            EnableSB(hWndHScroll);
        !           403:            UpdateOff(hWndHScroll);
        !           404:            UpdateFrame(FCF_HORZSCROLL);
        !           405:            UpdateOn(hWndHScroll);
        !           406:        }
        !           407:     } else {
        !           408:        if (fNeededHorz) {
        !           409:            DisableSB(hWndHScroll);
        !           410:            UpdateOff(hWndHScroll);
        !           411:            UpdateFrame(FCF_HORZSCROLL);
        !           412:            UpdateOn(hWndHScroll);
        !           413:        }
        !           414:     }
        !           415:     if (fNeedVert) {
        !           416:        if (!fNeededVert) {
        !           417:             EnableSB(hWndVScroll);
        !           418:             UpdateOff(hWndVScroll);
        !           419:             UpdateFrame(FCF_VERTSCROLL);
        !           420:             UpdateOn(hWndVScroll);
        !           421:        }
        !           422:     } else {
        !           423:        if (fNeededVert) {
        !           424:             DisableSB(hWndVScroll);
        !           425:             UpdateOff(hWndVScroll);
        !           426:             UpdateFrame(FCF_VERTSCROLL);
        !           427:             UpdateOn(hWndVScroll);
        !           428:        }
        !           429:     }
        !           430: }
        !           431: 
        !           432: void AvioTrackFrame(HWND hWnd, MPARAM mpTrackFlags) {
        !           433: /*
        !           434:     Takes action on WM_TRACKFRAME message
        !           435: */
        !           436:     static TRACKINFO tiTrackInfo;
        !           437:     /*
        !           438:        Get the tracking information in the TrackInfo structure
        !           439:     */
        !           440:     WinSendMsg(hWnd, WM_QUERYTRACKINFO, mpTrackFlags, &tiTrackInfo);
        !           441:     WinTrackRect(hWnd, NULL, &tiTrackInfo);
        !           442: }
        !           443: 
        !           444: void AvioQueryTrackInfo(PTRACKINFO pTI) {
        !           445: /*
        !           446:     Forces the frame to be byte aligned and bounded
        !           447: */
        !           448:     BOOL fMove;
        !           449:     /*
        !           450:        Get the grid set up for byte alignment
        !           451: 
        !           452:        Set cxGrid to half a character width, because sizing
        !           453:        from the keyboard tries to move by half characters.
        !           454:        Also, make sure we can move the window freely.
        !           455:     */
        !           456:     fMove = ((pTI->fs & TF_MOVE) == TF_MOVE);
        !           457:     pTI->fs     |= TF_GRID;
        !           458:     pTI->cxGrid  = (fMove) ? 1 : ((SHORT) (lChWidth << 1));
        !           459:     pTI->cyGrid  = (fMove) ? 1 : ((SHORT) lChHeight);
        !           460:     /*
        !           461:        Bound the frame now
        !           462:     */
        !           463:     pTI->ptlMinTrackSize.x = (pTI->cxBorder << 1) + lMiscWidth;
        !           464:     pTI->ptlMinTrackSize.y = (pTI->cyBorder << 1) + lMiscHeight;
        !           465:     pTI->ptlMaxTrackSize.x = iMaxFrameWidth  + lVSBWidth +  (pTI->cxBorder <<1);
        !           466:     pTI->ptlMaxTrackSize.y = iMaxFrameHeight + lHSBHeight + (pTI->cyBorder <<1);
        !           467: }
        !           468: 
        !           469: BOOL AvioUpdateLines(BOOL fPage, BOOL *fPaging) {
        !           470: /*
        !           471:     Update the display
        !           472: */
        !           473:     int        cLines;
        !           474: 
        !           475:     cLines = QueUpdateHead(AVIO_PS_ROWS, fPage, *fPaging);
        !           476:     if (cLines == AVIO_PS_ROWS) *fPaging = TRUE;
        !           477:     if (cLines > 0) {
        !           478:        ScrollUp(cLines);
        !           479:         Update(iTopLine + AVIO_PS_ROWS - cLines, cLines,
        !           480:                        AVIO_PS_ROWS - cLines, TRUE);
        !           481:     }
        !           482:     Update(iTopLine, cchPgHeight, 0, FALSE);
        !           483:     return TRUE;
        !           484: }
        !           485: 
        !           486: void AvioRedraw(void) {
        !           487: /*
        !           488:     Clear, then redraw the entire Presentation Space
        !           489: */
        !           490:     ClearScreen();
        !           491:     Update(iTopLine, cchPgHeight, 0, TRUE);
        !           492: }
        !           493: 
        !           494: void WantCursor(BOOL fYes) {
        !           495: /*
        !           496:     Do the underscore cursor
        !           497: */
        !           498:     vci.attr   = (USHORT) (fYes ? 0 : -1);
        !           499:     vci.yStart = 0;
        !           500:     vci.cEnd   = (USHORT) lChHeight - 1;
        !           501:     vci.cx     = 0;
        !           502:     VioSetCurType(&vci, hVPS);
        !           503: }
        !           504: 
        !           505: void AvioPageUp(void) {
        !           506: /*
        !           507:     Execute the Page Up instruction
        !           508: */
        !           509:     int cLines;
        !           510: 
        !           511:     cLines = QuePageUp(AVIO_PS_ROWS);
        !           512:     ScrollDown(cLines);
        !           513:     Update(iTopLine, cLines, 0, TRUE);
        !           514: }
        !           515: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.