home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 11 Util / 11-Util.zip / AVBROWSE.ZIP / AVIO.C next >
C/C++ Source or Header  |  1989-02-08  |  17KB  |  572 lines
  1. /*
  2.     avio.c -- AVIO action routines
  3.  
  4.     Implements scrollbars, sets up an AVIO Presentation Space
  5. */
  6. #define  INCL_AVIO
  7. #define     INCL_DEV
  8. #define  INCL_VIO
  9. #define  INCL_WINWINDOWMGR
  10. #define  INCL_WINSYS
  11. #define  INCL_WINMESSAGEMGR
  12. #define  INCL_WINTRACKRECT
  13. #define  INCL_WINFRAMEMGR
  14. #define  INCL_WINSCROLLBARS
  15. #include <os2.h>
  16. #include <string.h>    /* One strlen() call in the Blast() macro */
  17. #include "avio.h"    /* Get Avio-prefixed routine prototypes   */
  18. /*
  19.     Constants
  20. */
  21. char    Blank[2] = { 0x20, 0x07 };    /* <Space> + EGA white attribute */
  22. /*
  23.     Macros to make the code more readable
  24. */
  25. /* Upper and Lower Bound Calculations */
  26. #define    Abs(a)        (((a) > 0) ? (a) : (-(a)))
  27. #define    Min(a,b)    (((a) < (b)) ? (a) : (b))
  28. #define    Max(a,b)    (((a) > (b)) ? (a) : (b))
  29. #define LowerBound(pos, disp, lbound) Max(pos - disp, lbound)
  30. #define UpperBound(pos, disp, ubound) Min(pos + disp, ubound)
  31.  
  32. /* Scroll Bar Abbreviations */
  33. #define DisableSB(hSB)    WinSetParent(hSB, HWND_OBJECT, TRUE)
  34. #define EnableSB(hSB)     WinSetParent(hSB, hWndFrame,   TRUE)
  35. #define SetScroll(h, pos, max) \
  36.     WinSendMsg(h, SBM_SETSCROLLBAR, MPFROM2SHORT(pos, 0), MPFROM2SHORT(0, max))
  37.  
  38. /* Scrollbar redraw macros */
  39. #define UpdateOn(c, hsb)    if (!(++c)) WinEnableWindowUpdate(hsb, TRUE)
  40. #define UpdateOff(c, hsb)    if (!(c--)) WinEnableWindowUpdate(hsb, FALSE)
  41. #define    UpdateFrame(sb)    \
  42.     WinSendMsg(hWndFrame, WM_UPDATEFRAME, MPFROMLONG(sb), 0L)
  43.  
  44. /* Scrolling Macros */
  45. #define ClearScreen()    ScrollUp(-1)    /* Scroll up an "infinite" # lines */
  46. #define ScrollDown(n)    VioScrollDn(0, 0, -1, -1, n, Blank, hVPS)
  47. #define ScrollUp(n)    VioScrollUp(0, 0, -1, -1, n, Blank, hVPS)
  48.  
  49. /* RectL -> SWP conversion macros */
  50. #define    lcx(r)        ((r.xRight - r.xLeft) + 1)
  51. #define    lcy(r)        ((r.yTop - r.yBottom) + 1)
  52.  
  53. /* Miscellaneous macros */
  54. #define Blast(l, x, y)    VioWrtCharStr(l, Min(strlen(l), cxChScreen), x, y, hVPS)
  55. #define CalcChars(sPg, sCh) \
  56.     ((sCh) ? (Max(((sPg) / (sCh)), 0)) : 0)
  57. #define    SetCellSize(h,w) VioSetDeviceCellSize(h, w, hVPS)
  58. #define    Value(value)    WinQuerySysValue(HWND_DESKTOP, value)
  59. /*
  60.     File-Local Variables
  61. */
  62. HDC    hDC;        /* Device Context */
  63. HVPS    hVPS;        /* Virtual PS */
  64. int    iTopLine;    /* PS Line of window corner */
  65. int    iCurCol;     /* Current column of window corner */
  66. int    cxChPage;    /* Width and height of our window, in characters */
  67. int    cyChPage;
  68. int    iMaxHorz;    /* Scroll bar upper bounds */
  69. int    iMaxVert;    
  70. BOOL    fNeedHorz;    /* Do we need the scroll bars or not? */
  71. BOOL    fNeedVert;
  72. HWND    hWndHorzSB;    /* Window handles of ScrollBar windows */
  73. HWND    hWndVertSB;
  74. extern    HWND    hWndFrame;    /* Client, frame windows */
  75. extern    HWND    hWndClient;
  76. PFNWP    pfnOldClient;    /* Old Client Window Procedure pointer */
  77. PFNWP    pfnOldFrame;    /* Old Frame  Window Procedure pointer */
  78. SHORT    cyChPS;        /* Number of rows in AVIO PS */
  79. SHORT    cxChPS;        /* Number of cols in AVIO PS */
  80. SHORT    cyChScreen;        /* Number of rows in display space */
  81. SHORT    cxChScreen;        /* Number of cols in display space */
  82. PFNQL    pfnQueryLine;
  83. /*
  84.     Measurements used to help make the window look nice
  85. */
  86. LONG    cxConstant, cyConstant;            /* Miscellaneous frame lens */
  87. int    cxMaxFrame, cyMaxFrame;            /* Maximum frame widths */
  88. LONG    lChWidth,   lChHeight;
  89. SHORT    cxMaxClient, cyMaxClient;        /* Client area bounds  */
  90. BOOL    fCreatedPS;                /* AVIO PS created */
  91. int    cHUpdate = -1;                /* Keep track of updates */
  92. int    cVUpdate = -1;
  93. /*
  94.    Local prototypes
  95. */
  96. void FixScroll(BOOL, BOOL, HWND, ULONG, int *, int, int *);
  97. void UpdateScrollBars(RECTL);
  98. void Refresh(void);
  99. void Update(USHORT, USHORT, USHORT);
  100. /*
  101.     The actual routines
  102. */
  103. void AvioInit(PLBINFO plbi) {
  104. /*
  105.     Initialize Presentation Space, Device Context, Scroll Bars
  106. */
  107.     VIOCURSORINFO vci;
  108.     /*
  109.     Initialize the line buffer info 
  110.     */
  111.     cyChScreen    = plbi->sRows;
  112.     cxChScreen    = plbi->sCols;
  113.     cyChPS    = plbi->sPSrows;
  114.     cxChPS    = plbi->sPScols;
  115.     pfnQueryLine = plbi->pfnQL;
  116.     /*
  117.     One Time Initializations...
  118.     */
  119.     if (!fCreatedPS) {
  120.     /*
  121.        Create the AVIO Presentation Space, with one attribute byte
  122.     */
  123.     hDC = WinOpenWindowDC(hWndClient);    /* Open the device context */
  124.     VioCreatePS(&hVPS, cyChPS, cxChPS, 0, 1, 0);
  125.     VioAssociate(hDC, hVPS);        /* Link the PS with the DC */
  126.     /*
  127.         Turn off the cursor (set invisible attribute)
  128.     */
  129.     VioGetCurType(&vci, hVPS);
  130.     vci.attr = -1;
  131.     VioSetCurType(&vci, hVPS);
  132.     /*
  133.         Measure the frame components
  134.     */
  135.     cxConstant = 0;
  136.     cyConstant = Value(SV_CYTITLEBAR) + Value(SV_CYMENU);
  137.         /*
  138.         Snag scroll bar info
  139.     */
  140.     hWndHorzSB    = WinWindowFromID(hWndFrame,  FID_HORZSCROLL);
  141.     hWndVertSB    = WinWindowFromID(hWndFrame,  FID_VERTSCROLL);
  142.     fNeedHorz    = fNeedVert    = TRUE;
  143.     /*
  144.         Setup the Client and Frame routines
  145.     */
  146.     pfnOldFrame    = WinSubclassWindow(hWndFrame,  AvioFrameWndProc);
  147.     pfnOldClient    = WinSubclassWindow(hWndClient, AvioClientWndProc);
  148.     fCreatedPS    = TRUE;
  149.     }
  150.     /*
  151.     Repaint the screen
  152.     */
  153.     iTopLine = iCurCol = 0;
  154.     AvioStartup(plbi->fLargeFont);
  155. }
  156.  
  157. void AvioStartup(BOOL fLargeFont) {
  158. /*
  159.     Clear the screen, set the font, redraw the area
  160. */
  161.     RECTL rclFrame;
  162.  
  163.     ClearScreen();
  164.     AvioLargeFont(fLargeFont);
  165.     WinQueryWindowRect(hWndFrame, &rclFrame);
  166.     UpdateScrollBars(rclFrame);
  167.     Update(0, cyChPS, 0);
  168. }
  169.  
  170. void AvioScroll(USHORT SB_Command, USHORT Position, BOOL Horizontal) {
  171. /*
  172.     Process the scroll bar messages
  173.  
  174.     These routines are symmetric; in fact, SB_LINELEFT = SB_LINEUP, etc...
  175.     so one might note that this could be condensed.  It's left expanded for
  176.     speed and clarity.  The scrollbar values are bounded to stay inside
  177.     the Presentation Space.
  178. */
  179.     if (Horizontal) {  /* Horizontal Scroll Bar */
  180.     switch (SB_Command) {
  181.         case SB_LINELEFT:
  182.         iCurCol = LowerBound(iCurCol, 1, 0); break;
  183.         case SB_LINERIGHT:
  184.         iCurCol = UpperBound(iCurCol, 1, iMaxHorz); break;
  185.         case SB_PAGELEFT:
  186.         iCurCol = LowerBound(iCurCol, cxChPage, 0); break;
  187.         case SB_PAGERIGHT:
  188.         iCurCol = UpperBound(iCurCol, cxChPage, iMaxHorz); break;
  189.         case SB_SLIDERTRACK:
  190.         iCurCol = (SHORT) Position;
  191.         default: break;
  192.     }
  193.     if (SB_Command != SB_SLIDERTRACK)
  194.         SetScroll(hWndHorzSB, iCurCol, iMaxHorz);
  195.  
  196.     } else { /* Vertical Scroll Bar */
  197.     switch (SB_Command) {
  198.         case SB_LINEUP:
  199.         iTopLine = LowerBound(iTopLine, 1, 0); break;
  200.         case SB_LINEDOWN:
  201.         iTopLine = UpperBound(iTopLine, 1, iMaxVert); break;
  202.         case SB_PAGEUP:
  203.         iTopLine = LowerBound(iTopLine, cyChPage, 0); break;
  204.         case SB_PAGEDOWN:
  205.         iTopLine = UpperBound(iTopLine, cyChPage, iMaxVert);break;
  206.         case SB_SLIDERTRACK:
  207.         iTopLine = (SHORT) Position;
  208.         default: break;
  209.     }
  210.     if (SB_Command != SB_SLIDERTRACK)
  211.         SetScroll(hWndVertSB, iTopLine, iMaxVert);
  212.     }
  213.     Refresh();
  214. }
  215.  
  216. MRESULT AvioSize(HWND hWnd, USHORT msg, MPARAM mp1, MPARAM mp2) {
  217. /*
  218.     Do the default AVIO sizing, and kyfe a few values
  219. */
  220.     RECTL rclFrame;
  221.  
  222.     if (!fCreatedPS) return 0L;
  223.     /*
  224.     Update the scroll bars, and the screen
  225.     */
  226.     WinQueryWindowRect(hWndFrame, &rclFrame);
  227.     UpdateScrollBars(rclFrame);
  228.     /*
  229.     Now, do the normal AVIO processing
  230.     */
  231.     return WinDefAVioWindowProc(hWnd, msg, mp1, mp2);
  232. }
  233.  
  234. void Update(USHORT usLineNum, USHORT usHowMany, USHORT usStartLine) {
  235. /*
  236.     Updates N lines starting from START line on screen.
  237.     Starts at saved line LINENUM.
  238. */
  239.     USHORT    i;                /* Loop index variable */
  240.     USHORT    usWhichLine = usLineNum;    /* Line number to be queried */
  241.     char    *szLine;
  242.  
  243.     for (i = usStartLine; i < (usStartLine + usHowMany); i++) {
  244.     szLine = (*pfnQueryLine)(usWhichLine++);    /* Get the line */
  245.     if (szLine) Blast(szLine, i, 0);        /* Print it out */
  246.     }
  247. }
  248.  
  249. void Refresh(void) {
  250. /*
  251.     Do the origin shifting and screen updating
  252. */
  253.     SHORT  Delta;
  254.     int static iOldTopLine = 0;
  255.  
  256.     VioSetOrg(0, iCurCol, hVPS); /* Get the free AVIO horizontal shift */
  257.     Delta = iTopLine - iOldTopLine; /* Compute vertical shift */
  258.     if (Abs(Delta) < cyChPS) {
  259.     if (Delta < 0) {     /* Scroll Up -- make Delta positive*/
  260.         ScrollDown(-Delta);
  261.         Update(iTopLine, -Delta, 0);
  262.     } else {        /* Scroll Down by Delta */
  263.         ScrollUp(Delta);
  264.         Update(iTopLine + cyChPS - Delta, Delta, cyChPS - Delta);
  265.     }
  266.     } else AvioRedraw();    /* Redo the entire screen */
  267.     iOldTopLine = iTopLine;
  268. }
  269.  
  270. void AvioClose(void) {
  271. /*
  272.     Termination routines
  273. */
  274.     /*
  275.     Destroy the Presentation Space
  276.     */
  277.     VioAssociate(NULL, hVPS);
  278.     VioDestroyPS(hVPS);
  279.     fCreatedPS = FALSE;
  280. }
  281.  
  282. void AvioPaint(HWND hWnd) {
  283. /*
  284.     Paint the AVIO presentation space by telling it to show itself.
  285.     A possible optimization here is to repaint only the update region.
  286. */
  287.     static HPS     hPS;
  288.     static RECTL RectL;
  289.  
  290.     hPS = WinBeginPaint(hWnd, (HPS) NULL, &RectL);
  291.     VioShowPS(cyChPS, cxChPS, 0, hVPS);
  292.     WinEndPaint(hPS);
  293. } 
  294.  
  295. MRESULT AvioMinMax(PSWP pSWP) {
  296. /*
  297.     Handle WM_MINMAX messages, to make sure frame doesn't get too big
  298. */
  299.     if (pSWP->fs & (SWP_MAXIMIZE | SWP_RESTORE)) {
  300.     if (pSWP->fs & SWP_MAXIMIZE) {
  301.         /*
  302.         Save cx, cy values for later origin displacement
  303.         */
  304.         int Oldcx = pSWP->cx;
  305.         int Oldcy = pSWP->cy;
  306.         /*
  307.         Displace, and change to maximum size
  308.         */
  309.         pSWP->x += (Oldcx -
  310.         (pSWP->cx = cxMaxFrame + (int) (Value(SV_CXSIZEBORDER) << 1)));
  311.         pSWP->y += (Oldcy -
  312.         (pSWP->cy = cyMaxFrame + (int) (Value(SV_CYSIZEBORDER) << 1)));
  313.     }
  314.     /*
  315.         Now, fix the scroll bars
  316.     */
  317.     AvioAdjustFramePos(pSWP);
  318.     return TRUE;
  319.     }
  320.     return FALSE;
  321. }
  322.  
  323. void AvioClear(void) { ClearScreen(); }
  324.  
  325. void AvioAdjustFramePos(PSWP pSWP) {
  326. /*
  327.     Trap WM_ADJUSTWINDOWPOS messages to the frame with this routine.
  328.     Keep the window sized right, and control scrollbar visibility.
  329. */
  330.     RECTL rclFrame;
  331.  
  332.     if (!(pSWP->cx && pSWP->cy)) return;     /* Null area... */
  333.     if (pSWP->fs & SWP_MINIMIZE) return;    /* Iconic... */
  334.     /*
  335.     Make sure the dimensions are in range
  336.     */
  337.     pSWP->cx = Min(pSWP->cx, (cxMaxFrame + (SHORT)(Value(SV_CXSIZEBORDER)<<1)));
  338.     pSWP->cy = Min(pSWP->cy, (cyMaxFrame + (SHORT)(Value(SV_CYSIZEBORDER)<<1)));
  339.     /*
  340.     Update the scroll bars
  341.     */
  342.     rclFrame.xLeft    = (LONG) pSWP->x;
  343.     rclFrame.xRight    = (LONG) (pSWP->x + pSWP->cx - 1);
  344.     rclFrame.yBottom    = (LONG) pSWP->y;
  345.     rclFrame.yTop    = (LONG) (pSWP->y + pSWP->cy - 1);
  346.     UpdateScrollBars(rclFrame);
  347.  
  348.     return; 
  349. }
  350.  
  351. void AvioTrackFrame(HWND hWnd, MPARAM mpTrackFlags) {
  352. /*
  353.     Takes action on WM_TRACKFRAME message
  354. */
  355.     static TRACKINFO tiTrackInfo;
  356.     /*
  357.     Get the tracking information in the TrackInfo structure
  358.     */
  359.     WinSendMsg(hWnd, WM_QUERYTRACKINFO, mpTrackFlags, &tiTrackInfo);
  360.     WinTrackRect(hWnd, NULL, &tiTrackInfo);
  361. }
  362.  
  363. void AvioQueryTrackInfo(PTRACKINFO pTI) {
  364. /*
  365.     Routine which processes WM_QUERYTRACKINFO messages to the frame.
  366.     Call this routine after the default one to change various parameters.
  367.  
  368.     Note:  In reality, since we have a menu bar, we should make the
  369.     minimum width of the window something such that it does not "fold."
  370. */
  371.     BOOL fMove;
  372.     /*
  373.     Get the grid set up for byte alignment (unless moving)
  374.     */
  375.     fMove = ((pTI->fs & TF_MOVE) == TF_MOVE);
  376.     pTI->fs     |= TF_GRID;
  377.     pTI->cxGrid  = (SHORT) lChWidth;
  378.     pTI->cyGrid  = (fMove) ? 1 : ((SHORT) lChHeight);
  379.     /*
  380.     Bound the frame.
  381.     Maximum:    Sizing Border, Scrollbars, Title, Menus, client region
  382.     */
  383.     pTI->ptlMaxTrackSize.x = (LONG) (pTI->cxBorder << 1) + (LONG) cxMaxFrame;
  384.     pTI->ptlMaxTrackSize.y = (LONG) (pTI->cyBorder << 1) + (LONG) cyMaxFrame;
  385. }
  386.  
  387. void AvioRedraw(void) {
  388. /*
  389.     Clear, then redraw the entire Presentation Space
  390. */
  391.     ClearScreen();
  392.     Update(iTopLine, cyChPS, 0);
  393. }
  394.  
  395. MRESULT CALLBACK AvioClientWndProc
  396.     (HWND hWnd, USHORT msg, MPARAM mp1, MPARAM mp2) {
  397. /*
  398.      Window Procedure which traps messages to the Client area
  399. */
  400.      switch (msg) {
  401.       case WM_PAINT:        /* Paint the AVIO way! */
  402.         AvioPaint(hWnd);
  403.         break;
  404.  
  405.       case WM_SIZE:            /* Size the AVIO way!  */
  406.         return AvioSize(hWnd, msg, mp1, mp2);
  407.         break;
  408.  
  409.       case WM_HSCROLL:
  410.         AvioScroll(HIUSHORT(mp2), LOUSHORT(mp2), TRUE);
  411.         break;
  412.  
  413.       case WM_VSCROLL:
  414.         AvioScroll(HIUSHORT(mp2), LOUSHORT(mp2), FALSE);
  415.         break;
  416.  
  417.       case WM_ERASEBACKGROUND:
  418.         break;
  419.  
  420.       case WM_TRACKFRAME:
  421.         AvioTrackFrame(hWnd, mp1);
  422.         break;
  423.  
  424.       case WM_MINMAXFRAME:        /* Limit Maximized window size */
  425.         AvioMinMax((PSWP) mp1);
  426.  
  427.         /* fall through */
  428.  
  429.       default: return (*pfnOldClient)(hWnd, msg, mp1, mp2);
  430.      }
  431.      return 0;
  432. }
  433.  
  434. MRESULT CALLBACK AvioFrameWndProc(HWND hWnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  435. /*
  436.     Force the frame to stay small enough (no larger than the PS)
  437. */
  438. {
  439.     BOOL rc;        /* Return code from WM_QUERYTRACKINFO */
  440.  
  441.     switch(msg) {
  442.     case WM_ADJUSTWINDOWPOS:    /* Calculate scroll bar adjustments */
  443.         AvioAdjustFramePos(mp1);
  444.         break;
  445.  
  446.     case WM_QUERYTRACKINFO:        /* Get default, then process message */
  447.         rc = (BOOL) (*pfnOldFrame)(hWnd, msg, mp1, mp2);
  448.             AvioQueryTrackInfo((PTRACKINFO) mp2);
  449.         return rc;
  450.  
  451.     default: break;
  452.     }
  453.     return (*pfnOldFrame)(hWnd, msg, mp1, mp2);
  454. }
  455.  
  456. void UpdateScrollBars(RECTL rclClient) {
  457. /*
  458.     This routine fixes up the scroll bars when the window is resized, or
  459.     when the font size is changed.
  460.  
  461.     Parameters:    The dimensions of the frame window
  462.     Result:    Updates the scrollbars, enabling/disabling as needed
  463. */
  464.     BOOL    fNeededHorz = fNeedHorz;  /* Did we need the scrollbars then? */
  465.     BOOL    fNeededVert = fNeedVert;
  466.     /*
  467.     Compute the client rectangle, without the scrollbars
  468.     */
  469.     WinCalcFrameRect(hWndFrame, &rclClient, TRUE);
  470.     /*
  471.     Compute page width -- do we need the horizontal scroll bar?
  472.     */
  473.     cxChPage     = (int) CalcChars(lcx(rclClient), lChWidth);
  474.     fNeedHorz = ((iMaxHorz = Max(cxChScreen - cxChPage,  0)) > 0);
  475.     /*
  476.     Compute page height -- do we need the vertical scroll bar?
  477.     */
  478.     cyChPage     = (int) CalcChars(lcy(rclClient), lChHeight);
  479.     fNeedVert = ((iMaxVert = Max(cyChScreen - cyChPage, 0)) > 0);
  480.     /*
  481.     Maintain scrollbar integrity
  482.     */
  483.     iCurCol    = Min(iCurCol, iMaxHorz);
  484.     iTopLine    = Min(iTopLine, iMaxVert);
  485.     /*
  486.     Now, update the scrollbars as necessary
  487.     */
  488.     FixScroll(fNeededHorz, fNeedHorz, hWndHorzSB,
  489.           FCF_HORZSCROLL, &iCurCol, iMaxHorz, &cHUpdate);
  490.  
  491.     FixScroll(fNeededVert, fNeedVert, hWndVertSB,
  492.           FCF_VERTSCROLL, &iTopLine, iMaxVert, &cVUpdate);
  493.     /*
  494.     Now, update the screen to be visually consistent
  495.     */
  496.     Refresh();
  497. }
  498.  
  499. void FixScroll(fNeeded, fNeed, hWnd, flScroll, piPos, iMax, pc)
  500. /*
  501.     This routine makes the necessary scrollbar adjustments, and
  502.     also enables/disables them.
  503. */
  504. BOOL    fNeeded;        /* Whether we used to need the scrollbar */
  505. BOOL    fNeed;            /* Whether we need the scrollbar now */
  506. HWND    hWnd;            /* Handle to the scrollbar window */
  507. ULONG    flScroll;        /* FCF_xxxxSCROLL flag (for the scrollbar) */
  508. int    *piPos;         /* Current location of scrollbar thumb */
  509. int    iMax;            /* New maximum for the scrollbar */
  510. int    *pc;            /* Counter for WinEnableWindowUpdate recursion */
  511. {
  512.     if (fNeed) {    /* Enable the scroll bar -- we didn't need it before */
  513.     if (!fNeeded) {
  514.         EnableSB(hWnd);
  515.         UpdateOff((*pc), hWnd);
  516.         UpdateFrame(flScroll);
  517.         UpdateOn((*pc), hWnd);
  518.     }
  519.     SetScroll(hWnd, (*piPos) = Min((*piPos), iMax), iMax);
  520.     } else {        /* Disable the scroll bar, we no longer need it */
  521.     if (fNeeded) {
  522.         DisableSB(hWnd);
  523.         UpdateOff((*pc), hWnd);
  524.         UpdateFrame(flScroll);
  525.         UpdateOn((*pc), hWnd);
  526.     }
  527.     }
  528. }
  529.  
  530. void AvioLargeFont(BOOL fLargeFont) {
  531.     static BOOL fFirst = TRUE;                    // Need to init?
  532.     static LONG lSmallHt, lSmallWd, lLargeHt, lLargeWd;     // Font sizes
  533.     SWP swp;
  534.  
  535.     if (fFirst) {
  536.     /*
  537.         The first time through, get the small and large font sizes
  538.     */
  539.     DevQueryCaps(hDC, CAPS_CHAR_HEIGHT,        1L, &lLargeHt);
  540.     DevQueryCaps(hDC, CAPS_CHAR_WIDTH,        1L, &lLargeWd);
  541.     DevQueryCaps(hDC, CAPS_SMALL_CHAR_HEIGHT,    1L, &lSmallHt);
  542.     DevQueryCaps(hDC, CAPS_SMALL_CHAR_WIDTH,    1L, &lSmallWd);
  543.     fFirst = FALSE;
  544.     }
  545.     /*
  546.     Set the character size with VioSetDeviceCellSize
  547.     */
  548.     SetCellSize( (SHORT) (lChHeight = ((fLargeFont) ? lLargeHt : lSmallHt)),
  549.          (SHORT) (lChWidth  = ((fLargeFont) ? lLargeWd : lSmallWd)) );
  550.     /*
  551.     Compute maximum size of client area
  552.     */
  553.     cxMaxClient    = (cxChPS * (SHORT) lChWidth);
  554.     cxMaxFrame    = cxMaxClient + (SHORT) cxConstant;
  555.     cyMaxClient = (cyChPS * (SHORT) lChHeight);
  556.     cyMaxFrame  = cyMaxClient + (SHORT) cyConstant;
  557.     /*
  558.     Send a WM_ADJUSTFRAMEPOS message
  559.     */
  560.     WinQueryWindowPos(hWndFrame, &swp);
  561.     if (swp.fs & SWP_MAXIMIZE) {
  562.     AvioMinMax(&swp);
  563.     WinSetMultWindowPos(hWndFrame, &swp, 1);
  564.     } else {
  565.     swp.fs = SWP_ACTIVATE | SWP_MOVE | SWP_SHOW | SWP_SIZE;
  566.     WinSetWindowPos(hWndFrame, NULL, swp.x, swp.y,
  567.         Min(cxMaxFrame, swp.cx), Min(cyMaxFrame, swp.cy), swp.fs);
  568.     }
  569.     AvioAdjustFramePos(&swp);        /* Fix up the frame, scroll bars */
  570.     AvioPaint(hWndClient);        /* Repaint with new characters   */
  571. }
  572.