home *** CD-ROM | disk | FTP | other *** search
/ CICA 1993 August / CICA.cdr / unzipped / nt / wvnsrc75 / wvscreen.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-06  |  17.0 KB  |  616 lines
  1. /*-- First Line of WVSCREEN.C -- Contains Screen-related functions.  */
  2.  
  3. #include "windows.h"
  4. #include "wvglob.h"
  5. #include "winvn.h"
  6.  
  7. /*--- function ScreenDown ----------------------------------------------
  8.  *
  9.  *  Advance a pointer "nLines" lines through the textlines.
  10.  *  However, do not go so far that less than LinesOnScreen lines
  11.  *  are left past the pointer.
  12.  *
  13.  *  This is used to implement "PageDown" and "LineDown" functions.
  14.  *
  15.  *    Entry    nLines         Number of lines to move the pointer.
  16.  *             LinesOnScreen  is the number of lines on the screen.
  17.  *             BlockPtr       Pointer to block containing line.
  18.  *             LinePtr        Pointer to the given line.
  19.  *
  20.  *    Exit     BlockPtr and LinePtr (may) have been moved to a new line.
  21.  *             LinesAdvanced  is the number of lines actually moved--can be
  22.  *                            less than nLines if we hit the top of the
  23.  *                            last screen.
  24.  */
  25. void
  26. ScreenDown (nLines, LinesOnScreen, BlockPtr, LinePtr, LinesAdvanced)
  27.      int nLines;
  28.      int LinesOnScreen;
  29.      TypBlock far **BlockPtr;
  30.      TypLine far **LinePtr;
  31.      int *LinesAdvanced;
  32. {
  33.   TypBlock far *MyBlock = *BlockPtr;
  34.   TypLine far *MyLine = *LinePtr;
  35.   int LinesGone;
  36.   int TestAdvance;
  37.   HANDLE hBlock, hBlockGarbage;
  38.   unsigned int Offset, OffsetGarbage;
  39.   TypLineID LineIDGarbage, MyLineID;
  40.  
  41.   /* Skip forward nLines, plus one screen's worth, just to see      */
  42.   /* if there are enough lines ahead of us in the document.         */
  43.  
  44.   PtrToOffset (MyBlock, MyLine, &hBlock, &Offset, &MyLineID);
  45.   TestAdvance = nLines + LinesOnScreen - 1;
  46.   for (LinesGone = TestAdvance; LinesGone && NextLine (&MyBlock, &MyLine);
  47.        LinesGone--);
  48.   UnlockLine (MyBlock, MyLine, &hBlockGarbage, &OffsetGarbage, &LineIDGarbage);
  49.  
  50.   nLines -= LinesGone;
  51.   if (nLines < 0)
  52.     nLines = 0;
  53.   *LinesAdvanced = nLines;
  54.  
  55.   LockLine (hBlock, Offset, MyLineID, &MyBlock, &MyLine);
  56.   while (nLines--)
  57.     {
  58.       NextLine (BlockPtr, LinePtr);
  59.     }
  60. }
  61.  
  62. /*--- function ScreenUp ----------------------------------------------
  63.  *
  64.  *  Back up a pointer "nLines" lines through the textlines.
  65.  *  However, do not go past the beginning of the document.
  66.  *
  67.  *  This is used to implement "PageUp" and "LineUp" functions.
  68.  *
  69.  *    Entry    nLines         Number of lines to move the pointer.
  70.  *             BlockPtr       Pointer to block containing line.
  71.  *             LinePtr        Pointer to the given line.
  72.  *
  73.  *    Exit     BlockPtr and LinePtr (may) have been moved to a new line.
  74.  *             LinesBackedUp  is the number of lines actually moved--can be
  75.  *                            less than nLines if we hit beginning of doc.
  76.  */
  77. void
  78. ScreenUp (nLines, BlockPtr, LinePtr, LinesBackedUp)
  79.      int nLines;
  80.      TypBlock far **BlockPtr;
  81.      TypLine far **LinePtr;
  82.      int *LinesBackedUp;
  83. {
  84.   *LinesBackedUp = 0;
  85.  
  86.   while (nLines-- && PrevLine (BlockPtr, LinePtr))
  87.     {
  88.       (*LinesBackedUp)++;
  89.     }
  90. }
  91.  
  92. /*--- function ScrollIt ----------------------------------------------
  93.  *
  94.  *  Perform a scrolling action.
  95.  *
  96.  *    Entry    Document points to a document
  97.  *             wParam   is the wParam argument given from a WM_VSCROLL
  98.  *                      window message.  (One of the SB_ symbols.)
  99.  *             lParam   is the lParam argument.
  100.  */
  101. void
  102. NewScrollIt (Document, wParam, lParam)
  103.      TypDoc *Document;
  104.      WORD wParam;
  105.      DWORD lParam;
  106. {
  107.   TypBlock far *BlockPtr, far * NewBlockPtr;
  108.   TypLine far *LinePtr, far * NewLinePtr;
  109.   int LinesGone;
  110.   unsigned int LineOrd;
  111.   RECT Rect;
  112.  
  113.   switch (wParam)
  114.     {
  115.     case SB_LINEUP:
  116.       /* Move up a line by scrolling the window down one line     */
  117.       /* and introducing 1 new line at the top.                   */
  118.  
  119.    if (Document->TopLineOrd > 0) {
  120.       LinesGone = 1;
  121.     }
  122.     else LinesGone = 0;
  123.  
  124.     doscrollup:;
  125.       if (LinesGone)
  126.     {
  127.       Rect.left = 0;
  128.       Rect.right = Document->ScXWidth;
  129.       Document->TopLineOrd -= LinesGone;
  130.  
  131.       ScrollWindow (Document->hDocWnd, 0, LinesGone * LineHeight, NULL, NULL);
  132.  
  133.       Rect.top = TopSpace;
  134.       Rect.bottom = TopSpace + LinesGone * LineHeight;
  135.  
  136.       InvalidateRect (Document->hDocWnd, &Rect, FALSE);
  137.  
  138.       /* Make sure garbage at bottom is erased in WM_PAINT processing */
  139.       Rect.top = TopSpace + Document->ScYLines * LineHeight;
  140.       Rect.bottom = Document->ScYHeight;
  141.       InvalidateRect (Document->hDocWnd, &Rect, FALSE);
  142.     }
  143.       break;
  144.  
  145.     case SB_LINEDOWN:
  146.  
  147.    if (Document->TopLineOrd < (Document->TotalLines - Document->ScYLines)) {
  148.       LinesGone = 1;
  149.     }
  150.    else LinesGone = 0;
  151.  
  152.     doscrolldown:;
  153.       if (LinesGone)
  154.     {
  155.       Document->TopLineOrd += LinesGone;
  156.       Rect.left = 0;
  157.       Rect.right = Document->ScXWidth;
  158.       ScrollWindow (Document->hDocWnd, 0, -LinesGone * LineHeight, NULL, NULL);
  159.       Rect.top = TopSpace + (Document->ScYLines - LinesGone) * LineHeight;
  160.       Rect.bottom = Document->ScYHeight;
  161.       InvalidateRect (Document->hDocWnd, &Rect, FALSE);
  162.       /* Make sure garbage at top is erased in WM_PAINT processing */
  163.       Rect.top = 0;
  164.       Rect.bottom = TopSpace;
  165.       InvalidateRect (Document->hDocWnd, &Rect, FALSE);
  166.     }
  167.       break;
  168.  
  169.     case SB_PAGEUP:
  170. /*      LockLine (Document->hCurTopScBlock, Document->TopScOffset, Document->TopScLineID, &BlockPtr, &LinePtr); */
  171. /*      ScreenUp (Document->ScYLines - 1, &BlockPtr, &LinePtr, &LinesGone); */
  172.       LinesGone= Document->TopLineOrd - (Document->ScYLines - 1);
  173.       if (LinesGone > 0) {
  174.     LinesGone = Document->ScYLines - 1;
  175.       }
  176.     else {
  177.     LinesGone = Document->TopLineOrd;
  178.     }
  179.  
  180.       Document->TopLineOrd -= LinesGone;
  181.       InvalidateRect (Document->hDocWnd, NULL, FALSE);
  182.       break;
  183.  
  184.     case SB_PAGEDOWN:
  185.  
  186.       if ((Document->TotalLines - (Document->TopLineOrd + Document->ScYLines)) > Document->ScYLines)
  187.     LinesGone = Document->ScYLines - 1;
  188.       else
  189.         LinesGone = Document->TotalLines
  190.                     - (Document->TopLineOrd + Document->ScYLines );
  191.  
  192.       Document->TopLineOrd += LinesGone;
  193.       InvalidateRect (Document->hDocWnd, NULL, FALSE);
  194.       break;
  195.  
  196.     case SB_THUMBPOSITION:
  197.       LineOrd = LOWORD (lParam);
  198. /*       if (!FindLineOrd (Document, LineOrd, &BlockPtr, &LinePtr))
  199.     {
  200.       return;
  201.     }
  202. */
  203.     doposition:;
  204.       Document->TopLineOrd = LineOrd;
  205.       InvalidateRect (Document->hDocWnd, NULL, FALSE);
  206.       break;
  207.  
  208.     case SB_THUMBTRACK:
  209.  
  210.       LineOrd = LOWORD (lParam);
  211. /*      if (!FindLineOrd (Document, LineOrd, &BlockPtr, &LinePtr))
  212.     {
  213.       return;
  214.     }
  215. */
  216.       LinesGone = LineOrd - Document->TopLineOrd;
  217.       if (LinesGone > 0)
  218.     {
  219.       if (LinesGone >= (Document->ScYLines - 1))
  220.         {
  221.           goto doposition;
  222.         }
  223.       else
  224.         {
  225.           goto doscrolldown;
  226.         }
  227.     }
  228.       else if (LinesGone < 0)
  229.     {
  230.       LinesGone = -LinesGone;
  231.       if (LinesGone >= (Document->ScYLines - 1))
  232.         {
  233.           goto doposition;
  234.         }
  235.       else
  236.         {
  237.           goto doscrollup;
  238.         }
  239.     }
  240.  
  241.       break;
  242.  
  243.     default:
  244.       return;
  245.       break;
  246.     }
  247.  
  248. /*  UnlockLine (BlockPtr, LinePtr, &(Document->hCurTopScBlock),
  249.           &(Document->TopScOffset), &(Document->TopScLineID));
  250. */
  251.  
  252. }
  253. /*--- function ScrollIt ----------------------------------------------
  254.  *
  255.  *  Perform a scrolling action.
  256.  *
  257.  *    Entry    Document points to a document
  258.  *             wParam   is the wParam argument given from a WM_VSCROLL
  259.  *                      window message.  (One of the SB_ symbols.)
  260.  *             lParam   is the lParam argument.
  261.  */
  262. void
  263. ScrollIt (Document, wParam, lParam)
  264.      TypDoc *Document;
  265.      WORD wParam;
  266.      DWORD lParam;
  267. {
  268.   TypBlock far *BlockPtr, far * NewBlockPtr;
  269.   TypLine far *LinePtr, far * NewLinePtr;
  270.   int LinesGone;
  271.   unsigned int LineOrd;
  272.   RECT Rect;
  273.   int window_lineheight;
  274.  
  275.   if (Document->DocType == DOCTYPE_ARTICLE)
  276.    window_lineheight = ArtLineHeight;
  277.   else
  278.    window_lineheight = LineHeight;
  279.  
  280.   switch (wParam)
  281.     {
  282.     case SB_LINEUP:
  283.       /* Move up a line by scrolling the window down one line     */
  284.       /* and introducing 1 new line at the top.                   */
  285.       LockLine (Document->hCurTopScBlock, Document->TopScOffset, Document->TopScLineID, &BlockPtr, &LinePtr); 
  286.  
  287.       ScreenUp (1, &BlockPtr, &LinePtr, &LinesGone);
  288.     doscrollup:;
  289.       if (LinesGone)
  290.     {
  291.       Rect.left = 0;
  292.       Rect.right = Document->ScXWidth;
  293.       Document->TopLineOrd -= LinesGone;
  294. #if 0
  295.       Rect.top = TopSpace;
  296.       Rect.bottom = Document->ScYHeight;
  297.       ScrollWindow (Document->hDocWnd, 0, LinesGone * window_lineheight, &Rect, &Rect);
  298. #endif
  299.       ScrollWindow (Document->hDocWnd, 0, LinesGone * window_lineheight, NULL, NULL);
  300. #ifdef MAC
  301.       Rect.top = 0;
  302.       Rect.bottom = LinesGone * window_lineheight;
  303. #else
  304.       Rect.top = TopSpace;
  305.       Rect.bottom = TopSpace + LinesGone * window_lineheight;
  306. #endif
  307.       InvalidateRect (Document->hDocWnd, &Rect, FALSE);
  308.       /* Make sure garbage at bottom is erased in WM_PAINT processing */
  309.       Rect.top = TopSpace + Document->ScYLines * window_lineheight;
  310.       Rect.bottom = Document->ScYHeight;
  311.       InvalidateRect (Document->hDocWnd, &Rect, FALSE);
  312.     }
  313.       break;
  314.  
  315.     case SB_LINEDOWN:
  316.       LockLine (Document->hCurTopScBlock, Document->TopScOffset, Document->TopScLineID, &BlockPtr, &LinePtr);
  317.       ScreenDown (1, Document->ScYLines, &BlockPtr, &LinePtr, &LinesGone);
  318.     doscrolldown:;
  319.       if (LinesGone)
  320.     {
  321.       Document->TopLineOrd += LinesGone;
  322.       Rect.left = 0;
  323.       Rect.right = Document->ScXWidth;
  324. #if 0
  325.       Rect.top = TopSpace;
  326.       Rect.bottom = Document->ScYHeight;
  327.       ScrollWindow (Document->hDocWnd, 0, -LinesGone * window_lineheight, &Rect, &Rect);
  328. #endif
  329.       ScrollWindow (Document->hDocWnd, 0, -LinesGone * window_lineheight, NULL, NULL);
  330. #ifdef MAC
  331.       Rect.top = (Document->ScYLines - LinesGone) * window_lineheight;
  332.       Rect.bottom = Document->ScYHeight;
  333. #else
  334.       Rect.top = TopSpace + (Document->ScYLines - LinesGone) * window_lineheight;
  335.       Rect.bottom = Document->ScYHeight;
  336. #endif
  337.       InvalidateRect (Document->hDocWnd, &Rect, FALSE);
  338.       /* Make sure garbage at top is erased in WM_PAINT processing */
  339.       Rect.top = 0;
  340.       Rect.bottom = TopSpace;
  341.       InvalidateRect (Document->hDocWnd, &Rect, FALSE);
  342.     }
  343.       break;
  344.  
  345.     case SB_PAGEUP:
  346.       LockLine (Document->hCurTopScBlock, Document->TopScOffset, Document->TopScLineID, &BlockPtr, &LinePtr);
  347.       ScreenUp (Document->ScYLines - 1, &BlockPtr, &LinePtr, &LinesGone);
  348.       Document->TopLineOrd -= LinesGone;
  349.       InvalidateRect (Document->hDocWnd, NULL, FALSE);
  350.       break;
  351.  
  352.     case SB_PAGEDOWN:
  353.       LockLine (Document->hCurTopScBlock, Document->TopScOffset, Document->TopScLineID, &BlockPtr, &LinePtr);
  354.       ScreenDown (Document->ScYLines - 1, Document->ScYLines,
  355.           &BlockPtr, &LinePtr, &LinesGone);
  356.       Document->TopLineOrd += LinesGone;
  357.       InvalidateRect (Document->hDocWnd, NULL, FALSE);
  358.       break;
  359.  
  360.     case SB_THUMBPOSITION:
  361.       LineOrd = LOWORD (lParam);
  362.       if (!FindLineOrd (Document, LineOrd, &BlockPtr, &LinePtr))
  363.     {
  364.       return;
  365.     }
  366.     doposition:;
  367.       Document->TopLineOrd = LineOrd;
  368.       InvalidateRect (Document->hDocWnd, NULL, FALSE);
  369.       break;
  370.  
  371.     case SB_THUMBTRACK:
  372.  
  373.       LineOrd = LOWORD (lParam);
  374.       if (!FindLineOrd (Document, LineOrd, &BlockPtr, &LinePtr))
  375.     {
  376.       return;
  377.     }
  378.       LinesGone = LineOrd - Document->TopLineOrd;
  379.       if (LinesGone > 0)
  380.     {
  381.       if (LinesGone >= (Document->ScYLines - 1))
  382.         {
  383.           goto doposition;
  384.         }
  385.       else
  386.         {
  387.           goto doscrolldown;
  388.         }
  389.     }
  390.       else if (LinesGone < 0)
  391.     {
  392.       LinesGone = -LinesGone;
  393.       if (LinesGone >= (Document->ScYLines - 1))
  394.         {
  395.           goto doposition;
  396.         }
  397.       else
  398.         {
  399.           goto doscrollup;
  400.         }
  401.     }
  402.  
  403.       break;
  404.  
  405.     default:
  406.       return;
  407.       break;
  408.     }
  409.  
  410.   UnlockLine (BlockPtr, LinePtr, &(Document->hCurTopScBlock),
  411.           &(Document->TopScOffset), &(Document->TopScLineID));
  412. #ifdef MAC
  413. /* SendMessage(Document->hDocWnd,WM_PAINT,0,0L); */
  414.   MyUpdateWindow (Document->hDocWnd);
  415. #endif
  416.  
  417. }
  418.  
  419.  
  420. /*--- function LineOnScreen ----------------------------------------
  421.  *
  422.  *  Determine whether a given line is displayed on the screen.
  423.  *  If it is, give the ordinal line number on the screen.
  424.  *
  425.  *  Entry   Doc         points to the document.
  426.  *          hTargBlock  is the handle of the block containing the line.
  427.  *          TargOffset  is the offset of the target line.
  428.  *          TargLineID  is the line's ID.
  429.  *
  430.  *  Exit    returns -1 if the line is not on the screen, else
  431.  *          the ordinal line number (0 = top line, etc.)
  432.  */
  433. int
  434. LineOnScreen (Doc, hTargBlock, TargOffset, TargLineID)
  435.      TypDoc *Doc;
  436.      HANDLE hTargBlock;
  437.      unsigned int TargOffset;
  438.      TypLineID TargLineID;
  439. {
  440.   TypBlock far *CurBlockPtr, far * TargBlockPtr;
  441.   TypLine far *CurLinePtr, far * TargLinePtr;
  442.   int iline;
  443.   BOOL found = FALSE;
  444.   HANDLE hBlock;
  445.   unsigned int Offset;
  446.   TypLineID MyLineID;
  447.  
  448.   LockLine (Doc->hCurTopScBlock, Doc->TopScOffset, Doc->TopScLineID, &CurBlockPtr, &CurLinePtr);
  449.   LockLine (hTargBlock, TargOffset, TargLineID, &TargBlockPtr, &TargLinePtr);
  450.  
  451.   for (iline = 0; !found && iline < Doc->ScYLines; iline++)
  452.     {
  453.       found = (TargLinePtr == CurLinePtr);
  454.       if (!found)
  455.     {
  456.       NextLine (&CurBlockPtr, &CurLinePtr);
  457.     }
  458.     }
  459.  
  460.   UnlockLine (CurBlockPtr, CurLinePtr, &hBlock, &Offset, &MyLineID);
  461.   UnlockLine (TargBlockPtr, TargLinePtr, &hBlock, &Offset, &MyLineID);
  462.  
  463.   if (!found)
  464.     iline = 0;
  465.   return (iline - 1);
  466. }
  467.  
  468. /*--- function NextWindow ----------------------------------------------
  469.  *
  470.  *  Makes another window the active window with input focus.
  471.  *  This function would typically be used to implement a keystroke
  472.  *  (usually F6) that switches windows.
  473.  *
  474.  *    Entry    Doc   points to the current document.
  475.  */
  476. void
  477. NextWindow (Doc)
  478.      TypDoc *Doc;
  479. {
  480.   int idoc;
  481.   int trydoctype;
  482.   TypDoc *NewDoc;
  483.  
  484.   /* First, locate the current window in our data structures.       */
  485.  
  486.   switch (Doc->DocType)
  487.     {
  488.     case DOCTYPE_NET:
  489.       idoc = 0;
  490.       trydoctype = DOCTYPE_GROUP;
  491.       break;
  492.     case DOCTYPE_GROUP:
  493.       for (idoc = 0; idoc < MAXGROUPWNDS && Doc != &(GroupDocs[idoc]); idoc++);
  494.       if (idoc >= MAXGROUPWNDS)
  495.     {
  496.       MessageBox (Doc->hDocWnd, "Error finding next window", "System error", MB_ICONHAND | MB_OK);
  497.     }
  498.       trydoctype = DOCTYPE_GROUP;
  499.       idoc++;
  500.       break;
  501.     case DOCTYPE_ARTICLE:
  502.       for (idoc = 0; idoc < MAXARTICLEWNDS && Doc != &(ArticleDocs[idoc]); idoc++);
  503.       if (idoc >= MAXARTICLEWNDS)
  504.     {
  505.       MessageBox (Doc->hDocWnd, "Error finding next window", "System error", MB_ICONHAND | MB_OK);
  506.     }
  507.       trydoctype = DOCTYPE_ARTICLE;
  508.       idoc++;
  509.       break;
  510.     }
  511.  
  512.   /* Now, find the next window in the sequence.                     */
  513.  
  514.   if (trydoctype == DOCTYPE_GROUP)
  515.     {
  516.       for (; idoc < MAXGROUPWNDS; idoc++)
  517.     {
  518.       if (GroupDocs[idoc].InUse)
  519.         {
  520.           NewDoc = ActiveGroupDoc = &(GroupDocs[idoc]);
  521.           goto foundit;
  522.         }
  523.     }
  524.       idoc = 0;
  525.     }
  526.  
  527.   /* Not found yet--try to find an Article doc.                     */
  528.  
  529.   for (; idoc < MAXARTICLEWNDS; idoc++)
  530.     {
  531.       if (ArticleDocs[idoc].InUse)
  532.     {
  533.       NewDoc = ActiveArticleDoc = &(ArticleDocs[idoc]);
  534.       goto foundit;
  535.     }
  536.     }
  537.  
  538.   /* Still not found--just make the Net document the next one.      */
  539.  
  540.   NewDoc = &NetDoc;
  541.  
  542. foundit:;
  543.  
  544.   SetActiveWindow (NewDoc->hDocWnd);
  545.   SetFocus (NewDoc->hDocWnd);
  546.  
  547. }
  548.  
  549. /*--- function AdjustScTop -----------------------------------
  550.  *
  551.  *  Adjust the top line of the screen so that a given line is sure
  552.  *  to appear on the screen.
  553.  *  Don't do anything if the document is one screen's length or smaller.
  554.  *
  555.  *    Entry
  556.  *             BlockPtr and LinePtr  point to the line we want to
  557.  *                      make sure is visible.
  558.  *
  559.  *    Exit     Doc's TopSc fields have been set to ensure that
  560.  *               the line will appear on the screen.
  561.  *             The line has been unlocked.
  562.  */
  563.  
  564. void
  565. AdjustTopSc (BlockPtr, LinePtr)
  566.      TypBlock far *BlockPtr;
  567.      TypLine far *LinePtr;
  568. {
  569.   unsigned int lineord;
  570.   TypDoc *Doc;
  571.   HANDLE hBlock;
  572.   unsigned int Offset;
  573.   TypLineID MyLineID;
  574.  
  575.   Doc = BlockPtr->OwnerDoc;
  576.   if (Doc->TotalLines > Doc->ScYLines)
  577.     {
  578.       lineord = WhatLine (BlockPtr, LinePtr);
  579.  
  580.       while (lineord > Doc->TotalLines - Doc->ScYLines)
  581.     {
  582.       PrevLine (&BlockPtr, &LinePtr);
  583.       lineord--;
  584.     }
  585.       Doc->TopLineOrd = lineord;
  586.       UnlockLine (BlockPtr, LinePtr, &(Doc->hCurTopScBlock),
  587.           &(Doc->TopScOffset), &(Doc->TopScLineID));
  588.     }
  589.   else
  590.     {
  591.       UnlockLine (BlockPtr, LinePtr, &hBlock, &Offset, &MyLineID);
  592.     }
  593. }
  594.  
  595. /*--- function ScreenToTop -------------------------------------
  596.  *
  597.  *  Sets a document so that the screen is scrolled to the top.
  598.  *
  599.  *  Entry   Doc     points to the document.
  600.  *
  601.  *  Exit     The document has been set to display starting at
  602.  *               the first line.
  603.  */
  604.  
  605. void
  606. ScreenToTop (TypDoc * Doc)
  607. {
  608.   Doc->hCurTopScBlock = Doc->hFirstBlock;
  609.   Doc->TopScOffset = sizeof (TypBlock);
  610.   Doc->TopScLineID = 0;
  611.   Doc->TopLineOrd = 0;
  612.  
  613. }
  614.  
  615. /*-- Last Line of WVSCREEN.C ----------------- */
  616.