home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / gbmos2pm.zip / gbmv2 / scroll.c < prev    next >
C/C++ Source or Header  |  1998-04-22  |  15KB  |  541 lines
  1. /*
  2.  
  3. scroll.c - Automatic scroller overview control
  4.  
  5. */
  6.  
  7. #define    INCL_DOS
  8. #define    INCL_WIN
  9. #define    INCL_GPI
  10. #include <os2.h>
  11. #include <string.h>
  12. #include <stdlib.h>
  13. #define    _SCROLL_
  14. #include "scroll.h"
  15.  
  16. /*...vscroll\46\h:0:*/
  17.  
  18. typedef struct /* sc */
  19.     {
  20.     ULONG flStyle;            /* Window style supplied at create   */
  21.     SIZEL sizlScroll;        /* Our size                          */
  22.     RECTL rclWindow;        /* The window part of scroller       */
  23.     SIZEL sizlChild;        /* Size of child window              */
  24.     HWND hwndChild;            /* Thing to scroll over (or NULL)    */
  25.     HWND hwndHScroll;        /* Handle to horizontal scrollbar    */
  26.     HWND hwndVScroll;        /* Handle to vertical scrollbar      */
  27.     HWND hwndCorner;        /* The little bottom right corner    */
  28.     SHORT xPosn, cxRange, cxWindow;    /* X slider (if hwndChild not NULL)  */
  29.     SHORT yPosn, cyRange, cyWindow;    /* Y slider (if hwndChild not NULL)  */
  30.     SCROLLCOLORS sccols;        /* Colors to use for non-convered    */
  31.     } SCROLL;
  32.  
  33. /*...sScrollWndProc:0:*/
  34. /*...sCalcHScroll    \45\ calculate window size and scrollbar range:0:*/
  35. static VOID CalcHScroll(SCROLL *psc)
  36.     {
  37.     psc -> cxWindow = (SHORT) (psc -> rclWindow.xRight - psc -> rclWindow.xLeft);
  38.     psc -> cxRange  = max(0, (SHORT) (psc -> sizlChild.cx - psc -> cxWindow));
  39.     }
  40. /*...e*/
  41. /*...sCalcVScroll:0:*/
  42. static VOID CalcVScroll(SCROLL *psc)
  43.     {
  44.     psc -> cyWindow = (SHORT) (psc -> rclWindow.yTop - psc -> rclWindow.yBottom);
  45.     psc -> cyRange  = max(0, (SHORT) (psc -> sizlChild.cy - psc -> cyWindow));
  46.     }
  47. /*...e*/
  48. /*...sDisableHScroll \45\ make scrollbar unusable \40\used when hwndChild \61\\61\ NULL\41\:0:*/
  49. static VOID DisableHScroll(SCROLL *psc)
  50.     {
  51.     WinSendMsg(psc -> hwndHScroll, SBM_SETSCROLLBAR,
  52.            MPFROMSHORT(0), MPFROM2SHORT(0, 0));
  53.     WinSendMsg(psc -> hwndHScroll, SBM_SETTHUMBSIZE,
  54.            MPFROM2SHORT(1, 1), NULL);
  55.     }
  56. /*...e*/
  57. /*...sDisableVScroll:0:*/
  58. static VOID DisableVScroll(SCROLL *psc)
  59.     {
  60.     WinSendMsg(psc -> hwndVScroll, SBM_SETSCROLLBAR,
  61.            MPFROMSHORT(0), MPFROM2SHORT(0, 0));
  62.     WinSendMsg(psc -> hwndVScroll, SBM_SETTHUMBSIZE,
  63.            MPFROM2SHORT(1, 1), NULL);
  64.     }
  65. /*...e*/
  66. /*...sUpdateHScroll  \45\ update a scrollbar \40\used when hwndChild \33\\61\ NULL\41\:0:*/
  67. static VOID UpdateHScroll(SCROLL *psc)
  68.     {
  69.     WinSendMsg(psc -> hwndHScroll, SBM_SETSCROLLBAR,
  70.            MPFROMSHORT(psc -> xPosn), MPFROM2SHORT(0, psc -> cxRange));
  71.     WinSendMsg(psc -> hwndHScroll, SBM_SETTHUMBSIZE,
  72.            MPFROM2SHORT(psc -> cxWindow, psc -> sizlChild.cx), NULL);
  73.     }
  74. /*...e*/
  75. /*...sUpdateVScroll:0:*/
  76. static VOID UpdateVScroll(SCROLL *psc)
  77.     {
  78.     WinSendMsg(psc -> hwndVScroll, SBM_SETSCROLLBAR,
  79.            MPFROMSHORT(psc -> yPosn), MPFROM2SHORT(0, psc -> cyRange));
  80.     WinSendMsg(psc -> hwndVScroll, SBM_SETTHUMBSIZE,
  81.            MPFROM2SHORT(psc -> cyWindow, psc -> sizlChild.cy), NULL);
  82.     }
  83. /*...e*/
  84. /*...sKeepHScroll    \45\ adjust posn to keep roughly in same place:0:*/
  85. static VOID KeepHScroll(SCROLL *psc)
  86.     {
  87.     SHORT cxRangeOld = SHORT2FROMMR(WinSendMsg(psc -> hwndHScroll,
  88.                     SBM_QUERYRANGE, NULL, NULL));
  89.  
  90.     psc -> xPosn = ( cxRangeOld != 0 ) ?
  91.         (SHORT) ((psc -> xPosn * (LONG) psc -> cxRange) / cxRangeOld) : 0;
  92.     }
  93. /*...e*/
  94. /*...sKeepVScroll:0:*/
  95. static VOID KeepVScroll(SCROLL *psc)
  96.     {
  97.     SHORT cyRangeOld = SHORT2FROMMR(WinSendMsg(psc -> hwndVScroll,
  98.                     SBM_QUERYRANGE, NULL, NULL));
  99.  
  100.     psc -> yPosn = ( cyRangeOld != 0 ) ?
  101.         (SHORT) ((psc -> yPosn * (LONG) psc -> cyRange) / cyRangeOld) : 0;
  102.     }
  103. /*...e*/
  104. /*...sMoveChild      \45\ place child according to posn:0:*/
  105. /*
  106. Only called when hwndChild != NULL.
  107. */
  108.  
  109. static VOID MoveChild(SCROLL *psc)
  110.     {
  111.     SHORT xPosn    = (SHORT) (psc -> rclWindow.xLeft   - psc -> xPosn);
  112.     SHORT yPosn    = (SHORT) (psc -> rclWindow.yBottom - (psc -> cyRange - psc -> yPosn));
  113.     SHORT cxMargin = (SHORT) (psc -> cxWindow - psc -> sizlChild.cx);
  114.     SHORT cyMargin = (SHORT) (psc -> cyWindow - psc -> sizlChild.cy);
  115.  
  116.     if ( (psc -> flStyle & SCS_HCENTRE) != 0 && cxMargin > 0 )
  117.         xPosn += (cxMargin >> 1);
  118.     if ( (psc -> flStyle & SCS_VCENTRE) != 0 && cyMargin > 0 )
  119.         yPosn += (cyMargin >> 1);
  120.  
  121.     WinSetWindowPos(psc -> hwndChild, (HWND) NULL, xPosn, yPosn, 0, 0, SWP_MOVE);
  122.     WinUpdateWindow(psc -> hwndChild);
  123.     }
  124. /*...e*/
  125.  
  126. /*...sNotify         \45\ inform owner of something:0:*/
  127. static MRESULT Notify(HWND hwnd, USHORT usNotification, MPARAM mp2)
  128.     {
  129.     HWND hwndOwner = WinQueryWindow(hwnd, QW_OWNER);
  130.     USHORT usId    = WinQueryWindowUShort(hwnd, QWS_ID);
  131.  
  132.     return ( WinSendMsg(hwndOwner,
  133.                 WM_CONTROL,
  134.                 MPFROM2SHORT(usId, usNotification),
  135.                 mp2
  136.                 ) );
  137.     }
  138. /*...e*/
  139. /*...sPageWidth      \45\ get owner to give us a left\47\right page step:0:*/
  140. static SHORT PageWidth(HWND hwnd, SCROLL *psc)
  141.     {
  142.     SHORT cxPage = ( psc -> flStyle & SCS_HPAGE ) ?
  143.         SHORT1FROMMR(Notify(hwnd, SCN_HPAGE, MPFROM2SHORT(psc -> cxRange, psc -> cxWindow))) :
  144.         psc -> cxRange / 10;
  145.  
  146.     return ( max(1, cxPage) );
  147.     }
  148. /*...e*/
  149. /*...sPageHeight     \45\ get owner to give us an up\47\down page step:0:*/
  150. static SHORT PageHeight(HWND hwnd, SCROLL *psc)
  151.     {
  152.     SHORT cyPage = ( psc -> flStyle & SCS_VPAGE ) ?
  153.         SHORT1FROMMR(Notify(hwnd, SCN_VPAGE, MPFROM2SHORT(psc -> cyRange, psc -> cyWindow))) :
  154.         psc -> cyRange / 10;
  155.  
  156.     return ( max(1, cyPage) );
  157.     }
  158. /*...e*/
  159.  
  160. MRESULT _System ScrollWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  161.     {
  162.     SCROLL *psc = WinQueryWindowPtr(hwnd, 0);
  163.  
  164.     switch ( (int) msg )
  165.         {
  166. /*...sWM_CREATE       \45\ create window and scroll bars:16:*/
  167. case WM_CREATE:
  168.     {
  169.     SHORT cxScrollBar = (SHORT) WinQuerySysValue(HWND_DESKTOP, SV_CXVSCROLL);
  170.     SHORT cyScrollBar = (SHORT) WinQuerySysValue(HWND_DESKTOP, SV_CYHSCROLL);
  171.     CREATESTRUCT *pcrst = PVOIDFROMMP(mp2);
  172.  
  173.     if ( (psc = (SCROLL *) malloc(sizeof(SCROLL))) == NULL )
  174.         return ( (MRESULT) 1 );
  175.  
  176.     psc -> sizlScroll.cx = pcrst -> cx;
  177.     psc -> sizlScroll.cy = pcrst -> cy;
  178.     psc -> flStyle         = pcrst -> flStyle;
  179.     psc -> hwndChild       = (HWND) NULL;
  180.  
  181.     switch ( (int) (psc -> flStyle & (SCS_HSCROLL|SCS_VSCROLL)) )
  182.         {
  183. /*...sboth bars:32:*/
  184. case (SCS_HSCROLL|SCS_VSCROLL):
  185.     psc -> hwndHScroll = WinCreateWindow(hwnd, WC_SCROLLBAR, NULL, WS_VISIBLE|SBS_HORZ|SBS_THUMBSIZE,
  186.         0, 0, pcrst -> cx - cxScrollBar, cyScrollBar,
  187.         hwnd, HWND_BOTTOM, SCID_HSCROLL, NULL, NULL);
  188.     psc -> hwndVScroll = WinCreateWindow(hwnd, WC_SCROLLBAR, NULL, WS_VISIBLE|SBS_VERT|SBS_THUMBSIZE,
  189.         pcrst -> cx - cxScrollBar, cyScrollBar, cxScrollBar, pcrst -> cy - cyScrollBar,
  190.         hwnd, HWND_BOTTOM, SCID_VSCROLL, NULL, NULL);
  191.     psc -> hwndCorner = WinCreateWindow(hwnd, WC_STATIC, NULL, WS_VISIBLE|SS_BKGNDRECT,
  192.         pcrst -> cx - cxScrollBar, 0, cxScrollBar, cyScrollBar,
  193.         hwnd, HWND_BOTTOM, SCID_SQUARE, NULL, NULL);
  194.     psc -> rclWindow.xLeft   = 0;
  195.     psc -> rclWindow.xRight  = pcrst -> cx - cxScrollBar;
  196.     psc -> rclWindow.yBottom = cyScrollBar;
  197.     psc -> rclWindow.yTop    = pcrst -> cy;
  198.     break;
  199. /*...e*/
  200. /*...sjust horizontal bar:32:*/
  201. case SCS_HSCROLL:
  202.     psc -> hwndHScroll = WinCreateWindow(hwnd, WC_SCROLLBAR, "", WS_VISIBLE|SBS_HORZ|SBS_THUMBSIZE,
  203.         0, 0, pcrst -> cx, cyScrollBar,
  204.         hwnd, HWND_BOTTOM, SCID_HSCROLL, NULL, NULL);
  205.     psc -> rclWindow.xLeft   = 0;
  206.     psc -> rclWindow.xRight  = pcrst -> cx;
  207.     psc -> rclWindow.yBottom = cyScrollBar;
  208.     psc -> rclWindow.yTop    = pcrst -> cy;
  209.     break;
  210. /*...e*/
  211. /*...sjust vertical bar:32:*/
  212. case SCS_VSCROLL:
  213.     psc -> hwndVScroll = WinCreateWindow(hwnd, WC_SCROLLBAR, "", WS_VISIBLE|SBS_VERT|SBS_THUMBSIZE, 
  214.         pcrst -> cx - cxScrollBar, 0, cxScrollBar, pcrst -> cy,
  215.         hwnd, HWND_BOTTOM, SCID_VSCROLL, NULL, NULL);
  216.     psc -> rclWindow.xLeft   = 0;
  217.     psc -> rclWindow.xRight  = pcrst -> cx - cxScrollBar;
  218.     psc -> rclWindow.yBottom = 0;
  219.     psc -> rclWindow.yTop    = pcrst -> cy;
  220.     break;
  221. /*...e*/
  222. /*...sneither:32:*/
  223. case 0:
  224.     psc -> rclWindow.xLeft   = 0;
  225.     psc -> rclWindow.xRight  = pcrst -> cx;
  226.     psc -> rclWindow.yBottom = 0;
  227.     psc -> rclWindow.yTop    = pcrst -> cy;
  228.     break;
  229. /*...e*/
  230.         }
  231.  
  232.     if ( psc -> flStyle & SCS_HSCROLL )
  233.         DisableHScroll(psc);
  234.  
  235.     if ( psc -> flStyle & SCS_VSCROLL )
  236.         DisableVScroll(psc);
  237.  
  238.     psc -> sccols.lColorBlank = CLR_PALEGRAY;
  239.  
  240.     WinSetWindowPtr(hwnd, 0, psc);
  241.  
  242.     return ( (MRESULT) 0 );
  243.     }
  244. /*...e*/
  245. /*...sWM_DESTROY      \45\ destroy window:16:*/
  246. case WM_DESTROY:
  247.     free((void *) psc);
  248.     return ( (MRESULT) 0 );
  249. /*...e*/
  250. /*...sWM_PAINT        \45\ paint background:16:*/
  251. case WM_PAINT:
  252.     {
  253.     RECTL rclUpdate;
  254.     HPS hps = WinBeginPaint(hwnd, (HPS) NULL, &rclUpdate);
  255.  
  256.     GpiSetColor(hps, psc -> sccols.lColorBlank);
  257.     GpiMove(hps, (POINTL *) &rclUpdate);
  258.     GpiBox(hps, DRO_FILL, ((POINTL *) &rclUpdate) + 1, 0L, 0L);
  259.  
  260.     WinEndPaint(hps);
  261.  
  262.     return ( (MRESULT) 0 );
  263.     }
  264. /*...e*/
  265. /*...sWM_SIZE         \45\ window size changed:16:*/
  266. case WM_SIZE:
  267.     {
  268.     SWP swp;
  269.     SHORT cxScrollBar = (SHORT) WinQuerySysValue(HWND_DESKTOP, SV_CXVSCROLL);
  270.     SHORT cyScrollBar = (SHORT) WinQuerySysValue(HWND_DESKTOP, SV_CYHSCROLL);
  271.  
  272.     WinQueryWindowPos(hwnd, &swp);
  273.     psc -> sizlScroll.cx = swp.cx;
  274.     psc -> sizlScroll.cy = swp.cy;
  275.  
  276.     /* Resize all the component windows */
  277.  
  278.     switch ( (int) (psc -> flStyle & (SCS_HSCROLL|SCS_VSCROLL)) )
  279.         {
  280. /*...sboth bars:32:*/
  281. case (SCS_HSCROLL|SCS_VSCROLL):
  282.     WinSetWindowPos(psc -> hwndHScroll, (HWND) NULL,
  283.             0, 0, swp.cx - cxScrollBar, cyScrollBar,
  284.             SWP_MOVE | SWP_SIZE);
  285.     WinSetWindowPos(psc -> hwndVScroll, (HWND) NULL,
  286.             swp.cx - cxScrollBar, cyScrollBar, cxScrollBar, swp.cy - cyScrollBar,
  287.             SWP_MOVE | SWP_SIZE);
  288.     WinSetWindowPos(psc -> hwndCorner, (HWND) NULL,
  289.             swp.cx - cxScrollBar, 0, cxScrollBar, cyScrollBar,
  290.             SWP_MOVE | SWP_SIZE);
  291.  
  292.     psc -> rclWindow.xLeft   = 0;
  293.     psc -> rclWindow.xRight  = swp.cx - cxScrollBar;
  294.     psc -> rclWindow.yBottom = cyScrollBar;
  295.     psc -> rclWindow.yTop    = swp.cy;
  296.     break;
  297. /*...e*/
  298. /*...sjust horizontal bar:32:*/
  299. case SCS_HSCROLL:
  300.     WinSetWindowPos(psc -> hwndHScroll, (HWND) NULL,
  301.             0, 0, swp.cx, cyScrollBar,
  302.             SWP_MOVE | SWP_SIZE);
  303.     psc -> rclWindow.xLeft   = 0;
  304.     psc -> rclWindow.xRight  = swp.cx;
  305.     psc -> rclWindow.yBottom = cyScrollBar;
  306.     psc -> rclWindow.yTop    = swp.cy;
  307.     break;
  308. /*...e*/
  309. /*...sjust vertical bar:32:*/
  310. case SCS_VSCROLL:
  311.     WinSetWindowPos(psc -> hwndVScroll, (HWND) NULL,
  312.             swp.cx - cxScrollBar, 0, cxScrollBar, swp.cy,
  313.             SWP_MOVE | SWP_SIZE);
  314.     psc -> rclWindow.xLeft   = 0;
  315.     psc -> rclWindow.xRight  = swp.cx - cxScrollBar;
  316.     psc -> rclWindow.yBottom = 0;
  317.     psc -> rclWindow.yTop    = swp.cy;
  318.     break;
  319. /*...e*/
  320. /*...sneither:32:*/
  321. case 0:
  322.     psc -> rclWindow.xLeft   = 0;
  323.     psc -> rclWindow.xRight  = swp.cx;
  324.     psc -> rclWindow.yBottom = 0;
  325.     psc -> rclWindow.yTop    = swp.cy;
  326.     break;
  327. /*...e*/
  328.         }
  329.  
  330.     /* Try to keep showing the same part of the child */
  331.  
  332.     if ( psc -> hwndChild != (HWND) NULL )
  333.         {
  334.         if ( psc -> flStyle & SCS_HSCROLL )
  335.             {
  336.             CalcHScroll(psc);
  337.             KeepHScroll(psc);
  338.             UpdateHScroll(psc);
  339.             }
  340.     
  341.         if ( psc -> flStyle & SCS_VSCROLL )
  342.             {
  343.             CalcVScroll(psc);
  344.             KeepVScroll(psc);
  345.             UpdateVScroll(psc);
  346.             }
  347.  
  348.         MoveChild(psc);
  349.         }
  350.  
  351.     /* Else scrollbar(s) will already be disabled */
  352.  
  353.     }
  354.     break;
  355. /*...e*/
  356. /*...sWM_HSCROLL      \45\ horizontal scrollbar moved:16:*/
  357. case WM_HSCROLL:
  358.     if ( psc -> hwndChild != (HWND) NULL && (psc -> flStyle & SCS_HSCROLL) != 0 )
  359.         {
  360.         SHORT xPosnOld = psc -> xPosn;
  361.     
  362.         switch ( SHORT2FROMMP(mp2) )
  363.             {
  364.             case SB_LINELEFT:    psc -> xPosn--;
  365.                         break;
  366.             case SB_PAGELEFT:    psc -> xPosn -= PageWidth(hwnd, psc);
  367.                         break;
  368.             case SB_SLIDERPOSITION:    if ( psc -> flStyle & SCS_HSLOW )
  369.                             psc -> xPosn = SHORT1FROMMP(mp2);
  370.                         break;
  371.             case SB_SLIDERTRACK:    if ( (psc -> flStyle & SCS_HSLOW) == 0 )
  372.                             psc -> xPosn = SHORT1FROMMP(mp2);
  373.                         break;
  374.             case SB_PAGERIGHT:    psc -> xPosn += PageWidth(hwnd, psc);
  375.                         break;
  376.             case SB_LINERIGHT:    psc -> xPosn++;    
  377.                         break;
  378.             }
  379.     
  380.         if ( psc -> xPosn < 0 )
  381.             psc -> xPosn = 0;
  382.         else if ( psc -> xPosn > psc -> cxRange )
  383.             psc -> xPosn = psc -> cxRange;
  384.     
  385.         if ( psc -> xPosn != xPosnOld )
  386.             {
  387.             UpdateHScroll(psc);
  388.             MoveChild(psc);
  389.             }
  390.         }
  391.     break;
  392. /*...e*/
  393. /*...sWM_VSCROLL      \45\ vertical scrollbar moved:16:*/
  394. case WM_VSCROLL:
  395.     if ( psc -> hwndChild != (HWND) NULL && (psc -> flStyle & SCS_VSCROLL) != 0 )
  396.         {
  397.         SHORT yPosnOld = psc -> yPosn;
  398.     
  399.         switch ( SHORT2FROMMP(mp2) )
  400.             {
  401.             case SB_LINELEFT:    psc -> yPosn--;
  402.                         break;
  403.             case SB_PAGELEFT:    psc -> yPosn -= PageHeight(hwnd, psc);
  404.                         break;
  405.             case SB_SLIDERPOSITION:    if ( psc -> flStyle & SCS_VSLOW )
  406.                             psc -> yPosn = SHORT1FROMMP(mp2);
  407.                         break;
  408.             case SB_SLIDERTRACK:    if ( (psc -> flStyle & SCS_VSLOW) == 0 )
  409.                             psc -> yPosn = SHORT1FROMMP(mp2);
  410.                         break;
  411.             case SB_PAGERIGHT:    psc -> yPosn += PageHeight(hwnd, psc);
  412.                         break;
  413.             case SB_LINERIGHT:    psc -> yPosn++;    
  414.                         break;
  415.             }
  416.     
  417.         if ( psc -> yPosn < 0 )
  418.             psc -> yPosn = 0;
  419.         else if ( psc -> yPosn > psc -> cyRange )
  420.             psc -> yPosn = psc -> cyRange;
  421.     
  422.         if ( psc -> yPosn != yPosnOld )
  423.             {
  424.             UpdateVScroll(psc);
  425.             MoveChild(psc);
  426.             }
  427.         }
  428.     break;
  429. /*...e*/
  430.  
  431.         /* Scroll specific messages SCM_* */
  432.  
  433. /*...sSCM_CHILD       \45\ child window has changed:16:*/
  434. case SCM_CHILD:
  435.     {
  436.     if ( (psc -> hwndChild = HWNDFROMMP(mp1)) != (HWND) NULL )
  437.         {
  438.         SWP swp;
  439.  
  440.         WinQueryWindowPos(psc -> hwndChild, &swp);
  441.         psc -> sizlChild.cx = swp.cx;
  442.         psc -> sizlChild.cy = swp.cy;
  443.         psc -> xPosn        = 0;
  444.         psc -> yPosn        = 0;
  445.  
  446.         if ( psc -> flStyle & SCS_HSCROLL )
  447.             {
  448.             CalcHScroll(psc);
  449.             UpdateHScroll(psc);
  450.             }
  451.  
  452.         if ( psc -> flStyle & SCS_VSCROLL )
  453.             {
  454.             CalcVScroll(psc);
  455.             UpdateVScroll(psc);
  456.             }
  457.  
  458.         MoveChild(psc);
  459.         }
  460.     else
  461.         {
  462.         if ( psc -> flStyle & SCS_HSCROLL )
  463.             DisableHScroll(psc);
  464.  
  465.         if ( psc -> flStyle & SCS_VSCROLL )
  466.             DisableVScroll(psc);
  467.         }
  468.  
  469.     return ( (MRESULT) 0 );
  470.     }
  471. /*...e*/
  472. /*...sSCM_SIZE        \45\ size of child window has changed:16:*/
  473. case SCM_SIZE:
  474.     {
  475.     if ( psc -> hwndChild != (HWND) NULL )
  476.         {
  477.         SWP swp;
  478.     
  479.         WinQueryWindowPos(psc -> hwndChild, &swp);
  480.         psc -> sizlChild.cx = swp.cx;
  481.         psc -> sizlChild.cy = swp.cy;
  482.     
  483.         if ( psc -> flStyle & SCS_HSCROLL )
  484.             {
  485.             CalcHScroll(psc);
  486.             KeepHScroll(psc);
  487.             UpdateHScroll(psc);
  488.             }
  489.     
  490.         if ( psc -> flStyle & SCS_VSCROLL )
  491.             {
  492.             CalcVScroll(psc);
  493.             KeepVScroll(psc);
  494.             UpdateVScroll(psc);
  495.             }
  496.     
  497.         MoveChild(psc);
  498.         }
  499.  
  500.     return ( (MRESULT) 0 );
  501.     }
  502. /*...e*/
  503. /*...sSCM_SETCOLORS   \45\ set colors:16:*/
  504. case SCM_SETCOLORS:
  505.     {
  506.     SCROLLCOLORS *psccols = PVOIDFROMMP(mp1);
  507.  
  508.     psc -> sccols = *psccols;
  509.  
  510.     WinInvalidateRect(hwnd, NULL, TRUE);
  511.  
  512.     return ( (MRESULT) 0 );
  513.     }
  514. /*...e*/
  515. /*...sSCM_QUERYCOLORS \45\ query colors:16:*/
  516. case SCM_QUERYCOLORS:
  517.     {
  518.     SCROLLCOLORS *psccols = PVOIDFROMMP(mp1);
  519.  
  520.     *psccols = psc -> sccols;
  521.     return ( (MRESULT) 0 );
  522.     }
  523. /*...e*/
  524.         }
  525.     return ( WinDefWindowProc(hwnd, msg, mp1, mp2) );
  526.     }
  527. /*...e*/
  528. /*...sRegisterScrollClass:0:*/
  529. BOOL RegisterScrollClass(HAB hab)
  530.     {
  531.     return WinRegisterClass(
  532.         hab,            /* Handle of programs anchor block   */
  533.         WC_SCROLL,        /* Name of window class              */
  534.         ScrollWndProc,        /* Window procedure for scroller     */
  535.         CS_SIZEREDRAW |        /* Redraw if resized                 */
  536.         CS_CLIPCHILDREN,    /* Only draw where children aren't   */
  537.         sizeof(SCROLL *)    /* Amount of local data required     */
  538.         );
  539.     }
  540. /*...e*/
  541.