home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic 5 Developer's Kit / vb5 dev kit.iso / dev / ftp4w26a / samples / c / cw2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-10  |  16.0 KB  |  559 lines
  1.  
  2. /* **************************************************************
  3.  *
  4.  *
  5.  *      C W   :    P r o c e d u r e s
  6.  * 
  7.  *
  8.  * **************************************************************** */
  9.  
  10.  
  11.  
  12. #include <windows.h>
  13. #include <windowsx.h>
  14. #include <stdarg.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18.  
  19.  
  20. extern HINSTANCE       hInst;             
  21. extern HWND            hwnd;
  22.  
  23.  
  24. /* **************************************************************
  25.  *    G a u g e
  26.  *             B y     Santanu Lahiri (winFTP)
  27.  * **************************************************************/
  28.  
  29.  
  30. static LONG lTotalBytes=0;
  31. static DWORD lFileSize=0;
  32. static LONG lXferBytes=0;
  33. static int  nPercentXfer;
  34. static HWND hWndXfer=NULL;
  35. static LPSTR szXferWnd = "XferWindow";
  36.  
  37.  
  38. HPEN hPenDark;
  39. HPEN hPenLight;
  40. HBRUSH  hbrGray1;
  41. int  nWndx=10;                // the x axis multiplier
  42. int  nWndy=15;                // the y axis multiplier
  43.  
  44.  
  45.  
  46. LRESULT CALLBACK WndXferProc (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
  47.  
  48.  
  49. int nCwUnregisterClasses(void)
  50. {
  51.   UnregisterClass (szXferWnd, hInst);
  52. return 0;
  53. }
  54.  
  55.  
  56. int nCwRegisterClasses(void)
  57. {
  58. WNDCLASS   wc;    // struct to define a window class
  59.  
  60.   hbrGray1 = CreateSolidBrush (RGB (192,192,192));
  61.   memset(&wc, 0x00, sizeof(wc));
  62.   wc.cbClsExtra = 0;
  63.   wc.cbWndExtra = 0;
  64.   wc.hInstance = hInst;
  65.   wc.hCursor = LoadCursor ((HINSTANCE) NULL, IDC_ARROW);
  66.   wc.style = CS_HREDRAW | CS_VREDRAW;
  67.   wc.lpfnWndProc   = WndXferProc;
  68.   wc.hIcon         = LoadIcon (hInst, IDI_APPLICATION);
  69.   wc.hbrBackground = hbrGray1;
  70.   wc.lpszMenuName  = NULL;      /* Menu Name is App Name */
  71.   wc.lpszClassName = szXferWnd; /* Class Name is App Name */
  72.   if (RegisterClass (&wc)==0) return -1;
  73. return 0;
  74. }
  75.  
  76.  
  77. void CreateButtonPens()
  78. {
  79.   hPenDark  = CreatePen (PS_SOLID, 1, RGB (128,128,128));
  80.   hPenLight = CreatePen (PS_SOLID, 1, RGB (224,224,224));
  81. }
  82.  
  83. void DeleteButtonPens()
  84. {
  85.   DeleteObject (hPenDark);
  86.   DeleteObject (hPenLight);
  87. }
  88.  
  89.  
  90. void BoxIt (HDC hDC, int left, int top, int width, int height, BOOL flag)
  91. {
  92.   POINT Pt;
  93.   HPEN hPenOld;
  94.   
  95.   hPenOld = SelectObject (hDC, flag? hPenDark : hPenLight);
  96.   MoveToEx (hDC, (left*nWndx)/4, ((top+height)*nWndy)/8, &Pt);
  97.   LineTo (hDC, (left*nWndx)/4, (top*nWndy)/8);
  98.   LineTo (hDC, ((left+width)*nWndx)/4, (top*nWndy)/8);
  99.   if (flag) SelectObject (hDC,hPenLight); 
  100.   else SelectObject (hDC,hPenDark);
  101.   LineTo (hDC, ((left+width)*nWndx)/4, ((top+height)*nWndy)/8);
  102.   LineTo (hDC, (left*nWndx)/4, ((top+height)*nWndy)/8);
  103.   SelectObject (hDC, hPenOld);
  104. }
  105.  
  106.  
  107. void PaintXfer (HDC hDC)
  108. {
  109.   RECT rc;
  110.   char szBuf[10];
  111.  
  112.   CreateButtonPens();
  113.   SelectObject (hDC, GetStockObject (WHITE_BRUSH));
  114.   Rectangle (hDC, (nWndx*20)/4, (nWndy*10)/8, (nWndx*122)/4, (nWndy*20)/8);
  115.   rc.left = (nWndx*21)/4;  rc.right = (nWndx*(nPercentXfer+21))/4;
  116.   rc.top  = (nWndy*11)/8;  rc.bottom= (nWndy*19)/8;
  117.   FillRect (hDC, &rc, GetStockObject (GRAY_BRUSH));
  118.   rc.right = (nWndx*121)/4;
  119.   SetBkMode (hDC, TRANSPARENT);
  120.   wsprintf (szBuf, "%d%%", nPercentXfer);
  121.   DrawText (hDC, szBuf, lstrlen (szBuf), &rc, DT_CENTER | DT_VCENTER);
  122.   SetBkMode (hDC, OPAQUE);
  123.   BoxIt (hDC, 18, 8, 106, 14, FALSE);
  124.   DeleteButtonPens();
  125. }
  126.  
  127.  
  128.  
  129. void OnPaintXfer (HWND hWnd)
  130. {
  131.   HDC hDC;
  132.   PAINTSTRUCT ps;
  133.   
  134.   hDC = BeginPaint (hWnd, &ps);
  135.   PaintXfer (hDC);
  136.   EndPaint (hWnd, &ps);
  137. }
  138.  
  139. void SetXmitBytes (LONG lBytes, LONG lTotal)
  140. {
  141.   int nOld;
  142.   
  143.   lXferBytes = lBytes;
  144.   if (lTotalBytes==0)  lTotalBytes = lTotal;
  145.   if ((lTotalBytes==0)||(hWndXfer==NULL)) return;
  146.   nOld = nPercentXfer;
  147.   nPercentXfer = (int) ((lBytes*100)/lTotalBytes);
  148.   if (nOld!=nPercentXfer) 
  149.   {
  150.     HDC hDC;
  151.   
  152.     hDC = GetDC (hWndXfer);
  153.     PaintXfer (hDC);
  154.     ReleaseDC (hWndXfer, hDC);
  155.   }
  156. }
  157.  
  158.  
  159.  
  160. LRESULT CALLBACK WndXferProc (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  161. {
  162.   switch (Msg)
  163.   {
  164.     case WM_GETMINMAXINFO: 
  165.     {
  166.       MINMAXINFO FAR *lpmmi=(MINMAXINFO FAR *) lParam;
  167.       lpmmi->ptMaxSize.x = (nWndx*140)/4;
  168.       lpmmi->ptMaxSize.y = (nWndy*45)/8;
  169.       lpmmi->ptMaxTrackSize.x = (nWndx*140)/4;
  170.       lpmmi->ptMaxTrackSize.y = (nWndy*45)/8;
  171.       lpmmi->ptMinTrackSize.x = (nWndx*140)/4;
  172.       lpmmi->ptMinTrackSize.y = (nWndy*45)/8;
  173.     } break;
  174.     case WM_PAINT: OnPaintXfer (hWnd); return 0L;
  175.   }
  176.   return (LRESULT) DefWindowProc (hWnd, Msg, wParam, lParam);
  177. }
  178.  
  179.  
  180. void CreateXferWindow()
  181. {
  182.   if (hWndXfer!=NULL) return;
  183.   hWndXfer = CreateWindowEx ( WS_EX_TOPMOST, 
  184.        szXferWnd, "",  WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CAPTION,
  185.        CW_USEDEFAULT, CW_USEDEFAULT, (nWndx*140)/4, (nWndy*40)/8, (HWND) NULL, 
  186.        (HMENU) NULL, hInst,  NULL);
  187.   if (hWndXfer==NULL) MessageBeep (65535u);
  188.   lTotalBytes = 0L;
  189.   lXferBytes  = 0L;
  190.   nPercentXfer = 0L;
  191. }
  192.  
  193.  
  194. void DeleteXferWindow()
  195. {
  196.   if (hWndXfer==NULL) return;
  197.   DestroyWindow (hWndXfer);
  198.   lTotalBytes  = lXferBytes = 0l;
  199.   nPercentXfer = 0;
  200.   hWndXfer = NULL;
  201. }
  202.  
  203. void SetXferWindowText (LPSTR lpStr)
  204. {
  205.   SetWindowText (hWndXfer, lpStr);
  206. }
  207.  
  208. void SetXferTotalBytes (LONG Total)
  209. {
  210.   lTotalBytes = Total;
  211. }
  212.  
  213.  
  214. /* **************************************************************
  215.  *    S c r o l l e r 
  216.  * **************************************************************/
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223.  
  224. #ifdef GLOBAL_ALLOC
  225. #  define Calloc(n,s)  (void far *)GlobalAllocPtr(GMEM_SHARE | GMEM_ZEROINIT,n*s)
  226. #  define Free(p)                 GlobalFreePtr (p)
  227. #else
  228. #  define Calloc(n,s)  (void *) (LocalLock (LocalAlloc (LPTR, n*s)))
  229. #  define Free(p)      (LocalUnlock (LocalPtrHandle(p)), LocalFree (LocalPtrHandle(p)) )
  230. #  define LocalPtrHandle(p) ( (LOCALHANDLE) LOWORD((void far *)p) )
  231. #endif
  232. #define MEMORY_ERROR()   \
  233. { MessageBox (hScrollWnd, "Can not allocate memory !!","Error",MB_OK); return; }
  234. #define SHORT int
  235. #define TP_LEFTMARGIN       15      /* 15 pixels left to the left */
  236.  
  237. /* ------------------------------------------------------- */
  238. /*        Prototypes et variables communs au module        */
  239. /* ------------------------------------------------------- */
  240. static void TpGetCharDimension (HWND hWnd, int *pxChar, int *pyChar);
  241. static int  TpGetLinesOnScreen (HWND hWnd);
  242. static int  TpGetCharsOnScreen (HWND hWnd);
  243. static int  TpGetNewVertScrollRange (HWND hWnd, int nNombreLignes);
  244. static int  TpGetNewHorzScrollRange (HWND hWnd, int nNombreLignes);
  245.  
  246. void DoAddLine (LPSTR szBuf);
  247. void TpDoPaint(HWND hWnd);
  248.  
  249. static char **lpMsg=NULL;  /* tableau sur les pointeurs de chaines     */
  250. static int    nCurMsg;     /* nombre de messages dans le tableau lpMsg */
  251. static int    nMaxMsg=200; /* nombre maximum de lignes                 */
  252. static HWND   hScrollWnd;  /* handle de fenetre scroller (TpWmCreate)  */
  253.  
  254. /* ------------------------------------------------------- */
  255. /*          Affichage d'un texte a l'ecran                 */
  256. /* ------------------------------------------------------- */
  257. /* Attention : Pas de test de debordement                  */
  258.  
  259.  
  260. #include <stdarg.h>
  261.  
  262. int Ecris(LPSTR szFormat,...)
  263. {
  264. va_list vaArgs;
  265. static char szBuf[256];
  266.    va_start(vaArgs,szFormat);
  267.    if (vsprintf (szBuf,szFormat,vaArgs)!=EOF) DoAddLine (szBuf);
  268.    va_end(vaArgs);
  269. return 0;
  270. } /* Ecris */
  271.  
  272.  
  273. /*la meme .... */
  274. int DoPrintf (LPSTR szFormat,...)
  275. {
  276. va_list vaArgs;
  277. static char szBuf[256];
  278.    va_start(vaArgs,szFormat);
  279.    if (vsprintf (szBuf,szFormat,vaArgs)!=EOF) DoAddLine (szBuf);
  280.    va_end(vaArgs);
  281. return 0;
  282. } /* DoPrintf */
  283.  
  284.  
  285. /* Ajout d'une ligne dans le scroller */
  286. void DoAddLine (LPSTR lpBuf)
  287. {
  288. LPSTR lp;
  289. int   nScrollPos;
  290.   /* added in some error checking to try to eliminate GPFs */
  291.   if (lpBuf==NULL || lpBuf[0]==0)   return;
  292.   if (lpMsg==NULL)
  293.     {
  294.       lpMsg = Calloc (nMaxMsg, sizeof (LPSTR));
  295.       nCurMsg = 0;
  296.       if (lpMsg==NULL)   MEMORY_ERROR();
  297.     }
  298.   if (nCurMsg>=nMaxMsg)
  299.     {
  300.       Free (lpMsg[0]);
  301.       memmove (lpMsg, lpMsg+1, (nMaxMsg-1)*sizeof (LPSTR));
  302.       nCurMsg = nMaxMsg-1;
  303.     }
  304.   lp = lpMsg[nCurMsg] = Calloc (lstrlen (lpBuf) + 1, 1);
  305.   if (lp!=NULL) 
  306.   {
  307.      nCurMsg++;
  308.      lstrcpy (lp, lpBuf);
  309.      nScrollPos = TpGetNewVertScrollRange (hScrollWnd, nCurMsg);
  310.      /* changement des scrollers */
  311.      SetScrollRange (hScrollWnd, SB_VERT, 0, nScrollPos, FALSE);
  312.      SetScrollPos   (hScrollWnd, SB_VERT, nScrollPos, TRUE);
  313.      SetScrollRange (hScrollWnd, SB_HORZ, 0, 
  314.                     TpGetNewHorzScrollRange (hScrollWnd, nCurMsg), FALSE);
  315.      InvalidateRect (hScrollWnd, NULL, TRUE);
  316.   }  /* lp not NULL */
  317.   else  MEMORY_ERROR();
  318. } /* DoAddLine */
  319.  
  320.  
  321.  
  322. /* ----------------------------------------------------------- */
  323. /* Petites fonctions de calcul                                 */
  324. /* ----------------------------------------------------------- */
  325.  
  326. /* Donne la dimension en pixels d'un caractere */
  327. static void TpGetCharDimension (HWND hWnd, int *pxChar, int *pyChar)
  328. { 
  329. TEXTMETRIC tm;
  330. HDC   hDC;
  331.   /* computes yChar */
  332.   hDC = GetDC (hWnd);
  333.   GetTextMetrics (hDC, &tm);
  334.   ReleaseDC (hWnd, hDC);
  335.   /* Choisir sa methode de calcul: */  
  336.   /* *pxChar = tm.tmMaxCharWidth;  */
  337.   /* *pxChar = tm.tmAveCharWidth;  */
  338.   *pxChar = (tm.tmAveCharWidth + tm.tmMaxCharWidth) / 2; 
  339.   *pyChar = tm.tmHeight + tm.tmExternalLeading;
  340.   if (*pyChar==0)  *pyChar=8;  /* si pas de police definie */
  341.   if (*pxChar==0)  *pxChar=8;  /* si pas de police definie */
  342. } /* TpGetCharDimension */
  343.  
  344.  
  345. /* Donne le nombres de lignes que l'ecran peut afficher */
  346. static int TpGetLinesOnScreen (HWND hWnd)
  347. {
  348. RECT  rect;
  349. int   yChar, xChar;
  350.   /* computes character size */
  351.   TpGetCharDimension (hWnd, & xChar, & yChar);
  352.   GetClientRect (hWnd, &rect);
  353. return   (rect.bottom - rect.top) / yChar ;
  354. } /* TpGetLinesOnScreen */
  355.  
  356.  
  357. /* Donne le nombres de caracteres que l'ecran peut afficher */
  358. static int TpGetCharsOnScreen (HWND hWnd)
  359. {
  360. RECT  rect;
  361. int   yChar, xChar;
  362.   /* computes character size */
  363.   TpGetCharDimension (hWnd, & xChar, & yChar);
  364.   GetClientRect (hWnd, &rect);
  365. return   (rect.right - rect.left - TP_LEFTMARGIN) / xChar ;
  366. } /* TpGetCharsOnScreen */
  367.  
  368.  
  369. /* Calcule le maximum du scroller vertical (de 0 a ...) */
  370. static int TpGetNewVertScrollRange (HWND hWnd, int nNombreLignes)
  371. {
  372. return max (nNombreLignes - TpGetLinesOnScreen (hWnd), 0);
  373. } /* TpGetNewVertScrollRange */
  374.  
  375.  
  376. /* Calcule le maximum du scroller horizontal (de 0 a ...) */
  377. static int TpGetNewHorzScrollRange (HWND hWnd, int nNombreLignes)
  378. {
  379. int   nMaxLen=1;
  380. int   Ark;
  381.   /* computes character size */
  382.   if (lpMsg!=NULL)
  383.       for (Ark=0 ;  Ark<nNombreLignes ; Ark++)
  384.          if (lpMsg[Ark] != NULL   &&  lstrlen (lpMsg[Ark])>nMaxLen)
  385.             nMaxLen = lstrlen (lpMsg[Ark]);
  386. return max (1, nMaxLen - TpGetCharsOnScreen (hWnd));
  387. } /* TpGetNewHorzScrollRange */
  388.  
  389.  
  390. /* ----------------------------------------------------------- */
  391. /* Gestion des Messages de la fenΩtre de Scroll                */
  392. /* ----------------------------------------------------------- */
  393.  
  394. /* reception de message WM_CREATE -> inits + sauvegarde de hWnd */
  395. void TpDoWmCreate (HWND hWnd)
  396. {
  397.   /* Gestion de la fenΩtre scroller */
  398.   SetScrollPos (hWnd, SB_VERT, 0, TRUE);
  399.   SetScrollRange (hWnd, SB_VERT, 0, 1, TRUE);
  400.   SetScrollPos (hWnd, SB_HORZ, 0, TRUE);
  401.   SetScrollRange (hWnd, SB_HORZ, 0, 1, TRUE);
  402.   ShowScrollBar (hWnd, SB_BOTH, FALSE);
  403.   hScrollWnd = hWnd;
  404. } /* TpDoWmCreate */
  405.  
  406.  
  407. /* Reception de message WM_SIZE -> redefinition du scroller */
  408. void TpDoWmSize (HWND hWnd)
  409. {
  410. int nScrollPos;
  411.   nScrollPos = min (GetScrollPos (hWnd, SB_VERT), nCurMsg);
  412.   /* Compute the scroll bar maximum and position */
  413.   SetScrollRange (hWnd, SB_VERT, 0, 
  414.                   TpGetNewVertScrollRange(hWnd,nCurMsg), FALSE);
  415.   SetScrollPos (hWnd, SB_VERT, nScrollPos, FALSE);
  416.   SetScrollRange (hWnd, SB_HORZ, 0, 
  417.                   TpGetNewHorzScrollRange(hWnd,nCurMsg), FALSE);
  418.   SetScrollPos (hWnd, SB_VERT, 0, FALSE);
  419.   /* Force the whole thing to repaint */
  420.   InvalidateRect(hWnd, NULL, TRUE);
  421. } /* TpDoWmSize */
  422.  
  423.  
  424. /* WM_VSCROLL ou WM_HSCROLL-> deplacement dans la fenetre */
  425. void TpDoWmScroll (HWND hWnd, int nScroll, WPARAM wParam, LPARAM lParam)
  426. {
  427. SHORT nScrollInc;
  428. SHORT nScrollPos;
  429. SHORT nScrollMin;
  430. SHORT nScrollMax;
  431. SHORT yChar, xChar;
  432.  
  433.   TpGetCharDimension (hWnd, & xChar, & yChar);
  434.   /* Get the current position */
  435.   nScrollPos = GetScrollPos (hWnd, nScroll);
  436.   GetScrollRange (hWnd, nScroll, &nScrollMin, &nScrollMax);
  437.   /* Decode the various forms of scrolling */
  438.   switch (wParam)
  439.     {
  440.       case SB_TOP:
  441.           nScrollInc = -nScrollPos;
  442.           break;
  443.       case SB_BOTTOM:
  444.           nScrollInc = nScrollMax - nScrollPos;
  445.           break;
  446.       case SB_LINEUP:
  447.           nScrollInc = -1;
  448.           break;
  449.       case SB_LINEDOWN:
  450.           nScrollInc = 1;
  451.           break;
  452.       case SB_PAGEUP:
  453.           nScrollInc = -min((nScrollPos-nScrollMin), TpGetLinesOnScreen(hWnd));
  454.           break;
  455.       case SB_PAGEDOWN:
  456.           nScrollInc = min ((nScrollMax-nScrollPos), TpGetLinesOnScreen(hWnd));
  457.           break;
  458.       case SB_THUMBTRACK:
  459.           nScrollInc = LOWORD(lParam) - nScrollPos;
  460.           break;
  461.       default:
  462.           nScrollInc = 0;
  463.           break;
  464.     } /* switch wParam */
  465.   /* Now do the scroll if range has not been excedeed */
  466.   if (nScrollPos+nScrollInc<=nScrollMax  &&  nScrollPos+nScrollInc>=0)
  467.     {
  468.       if (nScroll==SB_VERT)   
  469.                 ScrollWindow (hWnd, 0, -yChar * nScrollInc, NULL, NULL);
  470.       if (nScroll==SB_HORZ)   
  471.                 ScrollWindow (hWnd, -xChar * nScrollInc, 0, NULL, NULL);
  472.       SetScrollPos (hWnd, nScroll, nScrollPos + nScrollInc, TRUE);
  473.       UpdateWindow (hWnd);
  474.     }
  475.    else MessageBeep ((unsigned) -1);
  476. }  /* TpDoWmScroll */
  477.  
  478.  
  479. /* reception de WM_CLOSE -> liberation memoire */
  480. void TpDoWmClose (HWND hWnd)
  481. {
  482. int nI;
  483.   if (lpMsg!=NULL) 
  484.   {
  485.     for (nI=0; nI<nMaxMsg; nI++) 
  486.     {
  487.       if (lpMsg[nI]!=NULL) Free (lpMsg[nI]);
  488.       lpMsg[nI] = NULL;
  489.     }
  490.     Free (lpMsg);
  491.     lpMsg=NULL;
  492.   }
  493.   nCurMsg = 0;
  494.   SetScrollPos (hWnd, SB_HORZ, 0, TRUE);
  495.   SetScrollPos (hWnd, SB_VERT, 0, TRUE);
  496.   SetScrollRange (hWnd, SB_HORZ, 0, 1, TRUE);
  497.   SetScrollRange (hWnd, SB_VERT, 0, 1, TRUE);
  498.   hScrollWnd = NULL;
  499. } /* TpDoWmClose */
  500.  
  501.  
  502. /* Reception d'un message WM_PAINT -> Dessin de la fenetre */
  503. void TpDoWmPaint(HWND hWnd)
  504. {
  505. PAINTSTRUCT ps;
  506. SHORT nScrollPos;
  507. SHORT nStart;
  508. SHORT nEnd;
  509. HFONT hFont;
  510. HFONT hOldFont;
  511. SHORT       nHorzPos;
  512. SHORT       nPos;
  513. SHORT       yChar, xChar;
  514. static BOOL bVertScrollBar=FALSE;
  515. static BOOL bHorzScrollBar=FALSE;
  516. BOOL        bTotaliteALEcran;
  517.  
  518.   /* calculs preliminaires : on affiche de nStart a nEnd */
  519.   BeginPaint(hWnd, &ps);
  520.   /* Get a font to use */
  521.   hFont = GetStockObject (ANSI_VAR_FONT);
  522.   hOldFont = SelectObject (ps.hdc, hFont);
  523.  
  524.   SetBkMode(ps.hdc, TRANSPARENT);
  525.   nScrollPos = GetScrollPos (hWnd, SB_VERT);
  526.   TpGetCharDimension (hWnd, & xChar, & yChar);
  527.   nStart = max (0, nScrollPos);
  528.   nEnd   = min (nCurMsg, nScrollPos + TpGetLinesOnScreen (hWnd));
  529.   nHorzPos = GetScrollPos (hWnd, SB_HORZ) * xChar;
  530.  
  531.   /* doit on afficher ou supprimer le scrollbar */
  532.   bTotaliteALEcran = (nStart==0  &&  nEnd==nCurMsg);
  533.   if (bVertScrollBar &&  bTotaliteALEcran)
  534.      ShowScrollBar (hWnd, SB_VERT, bVertScrollBar=FALSE);
  535.   else if (! bVertScrollBar &&  ! bTotaliteALEcran)
  536.      ShowScrollBar (hWnd, SB_VERT, bVertScrollBar=TRUE);
  537.  
  538.   bTotaliteALEcran = (TpGetNewHorzScrollRange(hWnd, nCurMsg)==1);
  539.   if (bHorzScrollBar &&  bTotaliteALEcran)   
  540.      ShowScrollBar (hWnd, SB_HORZ, bHorzScrollBar=FALSE);
  541.   else if (! bHorzScrollBar &&  ! bTotaliteALEcran)
  542.      ShowScrollBar (hWnd, SB_HORZ, bHorzScrollBar=TRUE);
  543.  
  544.   /* Loop through and draw all lines */
  545.   if (lpMsg!=NULL)
  546.      for (nPos=0 ;  nStart < nEnd ; ++nStart, nPos+=yChar)
  547.        if (lpMsg[nStart]!=NULL) 
  548.          {
  549.            TextOut (ps.hdc, TP_LEFTMARGIN-nHorzPos, nPos, 
  550.                     lpMsg[nStart], lstrlen (lpMsg[nStart])); 
  551.          }
  552.             
  553.   /* Delete the font that is no longer needed */
  554.   DeleteObject (SelectObject (ps.hdc, hOldFont));
  555.   EndPaint(hWnd, &ps);
  556. } /* TpDoWmPaint */
  557.  
  558.  
  559.