home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Code Resources / Controls GH / Slider Control GH / Slider.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-23  |  24.2 KB  |  910 lines  |  [TEXT/KAHL]
  1. #define __FOR__CDEV__
  2.  
  3. typedef pascal void (*IndicatorAction) (void);
  4.  
  5. /************** Slider.c v1.1 *********
  6. ******* code for a slider type control CDEF
  7. *******©1993 Glenn R. Howes
  8. ******* all rights reserved *****/
  9.  
  10. #include "utilities.h"
  11. pascal long main(short variation, ControlHandle me,
  12.                 short msg, long param)
  13. {
  14.     long result = 0L;
  15.  
  16.  
  17.     switch (msg)
  18.     {
  19.         case testCntl: // determine if mouse down is in control
  20.             result = TestMe(me, HiWord(param), LoWord(param));
  21.         break;
  22.         case calcCRgns: // 24-bit means of requesting shape of control or part
  23.             result = CalcStripRegion(me, (RgnHandle)param);
  24.         break;
  25.         case initCntl: // 1st message, allocate private data
  26.             InitMe(me);
  27.         break;
  28.         case dispCntl: // last message, dispose private data
  29.             if ((*me)->contrlData)
  30.                 DisposeHandle((*me)->contrlData);
  31.         break;
  32.         case posCntl: // given new point (and old point from the thumbCntl msg)
  33.                     // set the controls new value
  34.             PositionMe(me, HiWord(param), LoWord(param));
  35.         break;
  36.         case thumbCntl: // request for info for use in dragging thumb outline
  37.                         // also gives point at which drag starts
  38.             ProvideDragInfo(me, (ThumbInfo*)param);
  39.         break;
  40.         case dragCntl:
  41.             if (param)
  42.             {
  43.                 DragMe(me, LoWord(param));
  44.                 
  45. /************
  46. **    if we are being used by a CDEV or other modal dialog, we have to fool
  47. **  the dialog manager into sending the item hit message through to the application
  48. **  so, we return a 0 in those cases. We play around with other routines so that 
  49. **  the default dragging when it is called is invisible to the user.
  50. **  If we are being used by an application which can manually call TrackControl, we
  51. **  can do things the right way and just check the slider's value after the call
  52. **  to TrackControl. I suppose I ought to just have one version of this code and
  53. **  use variation codes, but that is neither here nor there.
  54. *************/
  55.  
  56.  
  57. #ifndef __FOR__CDEV__
  58.                 result = 1L;
  59. #endif
  60.             }
  61.         break;
  62.  
  63.         break;
  64.         case calcCntlRgn: // 32-bit clean message asking for whole cntl region
  65.             CalcRegion( me, (RgnHandle)param, FALSE);
  66.             result = 1L;
  67.         break;
  68.         case calcThumbRgn: // 32-bit clean message asking for shape of thumb
  69.             result =  CalcRegion( me, (RgnHandle)param, TRUE);
  70.             result =  1L;
  71.         break;
  72.         case drawCntl: // draw control or part of control
  73.             DrawMe(me, LoWord(param));
  74.         break;
  75.     }
  76.     
  77.     
  78.     return (result);
  79. }
  80. /********************** DragMe ******************
  81. ** Here's the situation, there has been a mouse down in my
  82. ** slider's thumb. I will move the thumb back & forth or
  83. ** up and down until the mouse is released. If there is a
  84. ** action proc, I will update the control's value and call it.
  85. ** If there is a proc stored in the low memory global DragHook,
  86. ** I'll call that too.
  87. ** 
  88. ** I've really violated the zeroth rule of programming
  89. ** "Never write the same code twice" here and I apologize. If I had
  90. ** the time I would modularize all the part drawing
  91. **************************************************/
  92. void DragMe(ControlHandle me, short part)
  93. {
  94.     Point            newPoint, lastPoint, offsetPoint;
  95.     unsigned long    currTime, lastTime, pinnedPoint;
  96.     Point            entry;
  97.     Rect            ctlRect, mouseRect, updateRect, newRect, lastRect;
  98.     Boolean            erase, fill,frame, vertical;
  99.     short            thumbLen, halfThumb;
  100.     short            diameter;
  101.     Pattern            grayPattern;
  102.     RgnHandle        savedClip = 0L, thumbRegion =0L, nonThumbRegion =0L;
  103.     Rect            bigRect;
  104.     IndicatorAction    action = (*me)->contrlAction;
  105.  
  106.     CopyRect(&(*me)->contrlRect, &ctlRect);
  107.     thumbLen = CalcThumbLen(&ctlRect);
  108.     halfThumb = thumbLen >> 1;
  109.     diameter = CalcRounding(&ctlRect);
  110.     GetMouse(&lastPoint);
  111.     CalcThumbRects(me, (*me)->contrlValue, &lastRect);
  112.     offsetPoint.h = lastPoint.h - lastRect.left;
  113.     offsetPoint.v = lastPoint.v - lastRect.top;
  114.     GetIndPattern(grayPattern, 0, 1);// standard black for frame and top region
  115.     vertical = ((ctlRect.bottom - ctlRect.top) // if we are a vertical control
  116.             >= (ctlRect.right - ctlRect.left));
  117.             
  118.     savedClip = NewRgn();
  119.     thumbRegion = NewRgn();
  120.     nonThumbRegion = NewRgn();
  121.     if (savedClip && thumbRegion && nonThumbRegion)
  122.     {
  123.         GetClip(savedClip);
  124.         OpenRgn();
  125.         FrameRoundRect(&lastRect, diameter, diameter);
  126.         CloseRgn(thumbRegion);
  127.         SetRect(&bigRect, -16000,-16000,16000,16000);
  128.         OpenRgn();
  129.         FrameRect(&bigRect);
  130.         CloseRgn(nonThumbRegion);
  131.         XorRgn(nonThumbRegion,thumbRegion,nonThumbRegion);
  132.         DisposeRgn(thumbRegion);
  133.         thumbRegion = 0L;
  134.     }
  135.     
  136.     while(WaitMouseUp())
  137.     {
  138.         erase = fill = frame = FALSE;
  139.         CalcThumbLen(&ctlRect);
  140.         GetMouse(&newPoint);
  141.         
  142.         
  143.         CopyRect(&ctlRect, &mouseRect);
  144.         CopyRect(&ctlRect, &updateRect);
  145.         CopyRect(&ctlRect, &newRect);
  146.  
  147.         if (vertical)
  148.         {
  149.             updateRect.left += 1;
  150.             updateRect.right -=1;
  151.             
  152.             mouseRect.top += offsetPoint.v;
  153.             mouseRect.bottom -= (thumbLen - offsetPoint.v);
  154.             *((long *)(&newPoint)) = PinRect(&mouseRect,newPoint);
  155.  
  156.             newRect.top = newPoint.v - offsetPoint.v;
  157.             newRect.bottom = newRect.top + thumbLen;
  158.  
  159.             if (newPoint.v == lastPoint.v) // haven't moved
  160.             {
  161.                 continue; // go back to WaitMouseUp
  162.             }
  163.             if (nonThumbRegion) // shift the mask to cover the new thumb rectangle
  164.                 OffsetRgn(nonThumbRegion,0,newPoint.v - lastPoint.v);
  165.                 
  166.             if (newPoint.v > lastPoint.v) // moved down
  167.             {
  168.                 fill = TRUE;
  169.                 updateRect.top = lastRect.top;
  170.                 updateRect.bottom = newRect.top + halfThumb;
  171.             }
  172.             else // moved up
  173.             {
  174.                 erase = TRUE;
  175.                 updateRect.bottom = lastRect.bottom;
  176.                 updateRect.top = newRect.bottom - halfThumb;
  177.                 if (lastRect.bottom >= ctlRect.bottom -4)
  178.                 {
  179.                     frame = TRUE;
  180.                 }
  181.             }
  182.             
  183.         }
  184.         else
  185.         {
  186.             updateRect.top += 1;
  187.             updateRect.bottom -=1;
  188.             
  189.             mouseRect.left += offsetPoint.h;
  190.             mouseRect.right -= (thumbLen - offsetPoint.h -1);
  191.             *((long *)(&newPoint))  = PinRect(&mouseRect,newPoint);
  192.  
  193.             newRect.left = newPoint.h - offsetPoint.h;
  194.             newRect.right = newRect.left + thumbLen;
  195.  
  196.             if (newPoint.h == lastPoint.h) // haven't moved
  197.             {
  198.                 continue; // go back to WaitMouseUp
  199.             }
  200.             
  201.             if (nonThumbRegion)
  202.                 OffsetRgn(nonThumbRegion,newPoint.h - lastPoint.h,0);
  203.             if (newPoint.h < lastPoint.h) // moved left
  204.             {
  205.                 fill = TRUE;
  206.                 updateRect.right = lastPoint.h - offsetPoint.h
  207.                                     + thumbLen;
  208.                 updateRect.left = newRect.left + halfThumb;
  209.             }
  210.             else // moved right
  211.             {
  212.                 erase = TRUE;
  213.                 updateRect.left = lastPoint.h - offsetPoint.h;
  214.                 updateRect.right = newRect.left + halfThumb;
  215.                 if (lastRect.left <= ctlRect.left + 4)
  216.                 {
  217.                     frame = TRUE;
  218.                 }
  219.             }
  220.         }
  221.         lastPoint.v = newPoint.v;
  222.         lastPoint.h = newPoint.h;
  223.         
  224.         lastTime = TickCount();
  225.         if (nonThumbRegion)
  226.             SetClip(nonThumbRegion);
  227.         do
  228.         {
  229.             currTime = TickCount();
  230.         }while (currTime == lastTime); // to avoid flicker drawing done at most once a tick
  231.         
  232.         if (erase)
  233.         {
  234.             EraseRect(&updateRect);
  235.         }
  236.         else if (fill)
  237.         {
  238.             
  239.             FillRoundRect(&updateRect,diameter, diameter, grayPattern);
  240.         }
  241.         
  242.         if (frame)
  243.         {
  244.             FrameRoundRect(&ctlRect, diameter,diameter);
  245.         }
  246.         if (savedClip)
  247.             SetClip(savedClip);
  248.         DrawMyIndicator(me, &newRect);
  249.         CopyRect(&newRect, &lastRect);
  250.         
  251.         
  252.         if (action && action != (ProcPtr) -1L)
  253.         {
  254.             newPoint.h = lastRect.left + halfThumb;
  255.             newPoint.v = lastRect.top + halfThumb;
  256.             MapPt2Value(me, &newPoint, &(*me)->contrlValue);
  257.             action();
  258.         }
  259.         
  260.         if (DragHook && DragHook != (ProcPtr) -1L) // DragHook is a low memory global
  261.         {
  262.             ((IndicatorAction) DragHook)();
  263.         }
  264.         
  265.     } 
  266.     // the user has let up on the mouse
  267.     // time to clean up
  268.     newPoint.h = lastRect.left + halfThumb;
  269.     newPoint.v = lastRect.top + halfThumb;
  270.     MapPt2Value(me, &newPoint, &(*me)->contrlValue);
  271.     if(savedClip)
  272.     {
  273.         SetClip(savedClip);
  274.         DisposeRgn(savedClip);
  275.     }
  276.     if (nonThumbRegion)
  277.         DisposeRgn(nonThumbRegion);
  278.     
  279.     DrawMe(me, 0); // snap the thumb into the nearest quantum
  280. }
  281. /******************* ProvideDragInfo ***********
  282. **** a mouse down has occurred in the thumb and we are
  283. **** asked to proide information used by the toolbox routine
  284. **** DragGrayRgn to confine the drag to a given rectangle 
  285. ****  the limit rect is the rect in which the region will move
  286. ****  the slop rect is the rect in which the mouse can be and the
  287. ****  gray outline will still be visible.
  288. ****  Notice that I'm taking into account the position within the
  289. ****  thumb so that the region doesn't go beyond the control****/
  290. void ProvideDragInfo(ControlHandle me, ThumbInfo *param)
  291. { 
  292.     Rect            ctlRect, thumbRect;
  293.     PrivateHandle    privData;
  294.     Point            entry;
  295.     privData = (PrivateHandle)(*me)->contrlData;
  296.     
  297.     // the original mousedown point is stored in the top,left corner of
  298.     // the thumbinfo's limitRect field
  299.     
  300.     entry.h = param->limitRect.left;
  301.     entry.v = param->limitRect.top;
  302.  
  303.     CopyRect(&(*me)->contrlRect, &ctlRect);
  304.     
  305.  
  306.     CalcThumbRects(me, (*me)->contrlValue, &thumbRect);
  307.     
  308.     if (privData)
  309.     {
  310.         (*privData)->lastPoint.h = entry.h;
  311.         (*privData)->lastPoint.v = entry.v;
  312.         (*privData)->offsetPoint.h = entry.h - thumbRect.left;
  313.         (*privData)->offsetPoint.v = entry.v - thumbRect.top;
  314.         CopyRect(&thumbRect, &(*privData)->lastRect);
  315.         (*privData)->lastTime = TickCount();
  316.     }
  317.     
  318.     
  319.     if ((ctlRect.bottom - ctlRect.top) // if we are a vertical control
  320.         >= (ctlRect.right - ctlRect.left))
  321.     {
  322.         ctlRect.bottom -= (thumbRect.bottom - entry.v);
  323.         ctlRect.top += (entry.v - thumbRect.top);
  324.         
  325.         CopyRect(&ctlRect, ¶m->limitRect);
  326.     
  327.         param->axis = 2; // confine to vertical
  328.     }
  329.     else // if we are a horizontal control
  330.     {
  331.         ctlRect.right -= (thumbRect.right - entry.h) -1;
  332.         ctlRect.left += (entry.h - thumbRect.left);
  333.         
  334.         CopyRect(&ctlRect, ¶m->limitRect);
  335.     
  336.         param->axis = 1; // confine to horizontal
  337.  
  338.     }
  339. /*******
  340. ** here's the scoop, if we are being used by a CDEV, or a modal dialog
  341. ** we have to force the dialog manager into recognizing that the thumb
  342. ** has been moved
  343. ***************/
  344.     #ifdef __FOR__CDEV__
  345.     SetRect(¶m->slopRect,-32000,-32000,32000,32000);
  346.     CopyRect(&(*me)->contrlRect, ¶m->limitRect);
  347.     return;
  348.     #endif
  349.     InsetRect(&ctlRect, -5, -5); // make slop bigger than ctl rect
  350.     CopyRect(&ctlRect, ¶m->slopRect);
  351. }
  352. /************ PositionMe *************
  353. ******** I've been dragged, with the sequence 
  354. ****** TestMe, ProvideDragInfo, and now PositionMe
  355. ****** so the delta values are changes from the original mousedown *****/
  356. void PositionMe(ControlHandle me, short deltaV, short deltaH)
  357. {
  358.     Point    newPoint;
  359. /******** 
  360. ** if we are using our own drag routines, we have already set the value of
  361. ** of the control, so we don't need to set it now.
  362. ********/
  363. #ifdef __FOR__CDEV__
  364.     return;
  365. #endif
  366.     MapValue2Point(me, (*me)->contrlValue, &newPoint);
  367.     newPoint.v += deltaV;
  368.     newPoint.h += deltaH;
  369.     
  370.     MapPt2Value(me, &newPoint, &(*me)->contrlValue);
  371.     DrawMe(me, 0);
  372. }
  373. /************ MapPt2Value *****************
  374. ***** given a point within the control, map it to a control value
  375. ******/
  376. void MapPt2Value(ControlHandle me, Point *aPoint, short *value)
  377. {
  378.     Rect    ctlRect;
  379.     short    width, height, thumbLen, halfThumb;
  380.     long    min, max, locValue;
  381.     
  382.     CopyRect(&(*me)->contrlRect, &ctlRect);
  383.     min = (*me)->contrlMin;
  384.     max = (*me)->contrlMax;
  385.     
  386.     width = ctlRect.right - ctlRect.left;
  387.     height = ctlRect.bottom - ctlRect.top;
  388.     
  389.     thumbLen = CalcThumbLen(&ctlRect);
  390.     halfThumb = thumbLen /2;
  391.     
  392.     if (width > height)
  393.     {
  394.         ctlRect.right -= halfThumb;
  395.         ctlRect.left += halfThumb;
  396.         width -= thumbLen;
  397.         if (ctlRect.right < aPoint->h) aPoint->h = ctlRect.right;
  398.         else if (ctlRect.left > aPoint->h) aPoint->h = ctlRect.left;
  399.     
  400.         locValue = min + ((max-min)*(aPoint->h-ctlRect.left))/width;
  401.     }
  402.     else
  403.     {
  404.         ctlRect.bottom -= halfThumb;
  405.         ctlRect.top += halfThumb;
  406.         height -= thumbLen;
  407.         if (ctlRect.bottom < aPoint->v) aPoint->v = ctlRect.bottom;
  408.         else if (ctlRect.top > aPoint->v) aPoint->v = ctlRect.top;
  409.         
  410.         locValue = min + ((max-min)*(ctlRect.bottom-aPoint->v))/height;
  411.     }
  412.     *value = locValue;
  413. }
  414. /*********** MapValue2Point *********
  415. ******* given a control value, convert it to a point within
  416. ******* the control corresponding to where the center of the thumb
  417. ******* must be **********/
  418. void MapValue2Point(ControlHandle me, short value, Point *aPoint)
  419. {
  420.     Rect    ctlRect;
  421.     long    width, height;
  422.     long    min, max;
  423.     short    thumbLen, halfThumb;
  424.     CopyRect(&(*me)->contrlRect, &ctlRect);
  425.     min = (*me)->contrlMin;
  426.     max = (*me)->contrlMax;
  427.     
  428.     thumbLen = CalcThumbLen(&ctlRect);
  429.     halfThumb = thumbLen /2;
  430.     
  431.     width = ctlRect.right - ctlRect.left;
  432.     height = ctlRect.bottom - ctlRect.top;
  433.     
  434.     if (value > max)
  435.         value = max;
  436.     else if (value < min) 
  437.         value = min;
  438.  
  439.     if (width > height) // horizontal control
  440.     {
  441.         width -= thumbLen;
  442.         aPoint->h = ctlRect.left + halfThumb + (width*value)/(max-min);
  443.         aPoint->v = ctlRect.top + height /2;
  444.     }
  445.     else
  446.     {
  447.         height -= thumbLen;
  448.         aPoint->v = ctlRect.bottom - halfThumb -(height * value)/(max-min);
  449.         aPoint->h = ctlRect.left + width /2;
  450.     }
  451. }
  452.  
  453. /************* CalcStripRegion *******
  454. ******* when in 24-bit mode, we will get a region handle whose
  455. ******* 31st bit is used to indicate if the app wants the region
  456. ******* of the thumb (on) or the whole control (off).
  457. ******* We are supposed to strip off the bit and return the 
  458. ******* calculated region ******/
  459. long CalcStripRegion(ControlHandle me, RgnHandle theRegion)
  460. {
  461.     char    calcThumb;
  462.     if (Using32Bit()) // WHY IS THIS GETTING CALLED¿
  463.     {
  464.         return (CalcRegion(me, theRegion, FALSE));
  465.     }
  466.     else
  467.     {
  468.         calcThumb = (long)theRegion >> 31L; // getting high bit, on = calc thumb
  469.         theRegion = (RgnHandle)(0x7FFFFFFFL & (long)theRegion); 
  470.         // stripping out high bit only see tech note “joy of 32 bit clean”
  471.         return (CalcRegion(me, theRegion, calcThumb)); // calc the region
  472.     }
  473. }
  474. /*************** CalcRegion ******
  475. ******* figure the region of the control, or the thumb if the 
  476. ******* calcThumb parameter is non-zero **********/
  477. long CalcRegion(ControlHandle me, RgnHandle theRegion, char calcThumb)
  478. {
  479.     RgnHandle    myRegion, curClip;
  480.     Rect        ctlRect, thumbRect;
  481.     short        diameter;
  482.     
  483. #ifdef __FOR__CDEV__
  484.     return ((long)theRegion);
  485. #endif
  486.     
  487.     CopyRect(&(*me)->contrlRect, &ctlRect);
  488.     
  489.     myRegion = NewRgn();
  490.     if(curClip = NewRgn())
  491.     {
  492.         GetClip(curClip);
  493.         ClipRect(&ctlRect);
  494.     }
  495.     
  496.     if (myRegion)
  497.     {
  498.         OpenRgn();
  499.         
  500.         diameter = CalcRounding(&ctlRect);
  501.         if (calcThumb)
  502.         {
  503.             CalcThumbRects(me, (*me)->contrlValue, &thumbRect);
  504.             FrameRoundRect(&thumbRect, diameter,diameter);
  505.         }
  506.         else
  507.         {
  508.             FrameRoundRect(&ctlRect, diameter, diameter);
  509.         }
  510.  
  511.         CloseRgn(myRegion);
  512.         InsetRgn(myRegion, -1, -1); // make it a little bigger to take into account
  513.                                     // width of lines
  514.         UnionRgn(theRegion, myRegion, theRegion);
  515.         DisposeRgn(myRegion);
  516.     }
  517.     if (curClip) 
  518.     {
  519.         SetClip(curClip);
  520.         DisposeRgn(curClip);
  521.     }
  522.     return ((long)theRegion);
  523. }
  524. /************ TestMe ****************
  525. ******* is the point within the control, and if so,
  526. ******* what part, there are 3 parts: thumb, pageup, 
  527. pagedown **********/
  528. long TestMe(ControlHandle me, short v, short h)
  529. {
  530.     Point            testPoint;
  531.     long            result = 0L;
  532.     Rect            ctlRect, whiteRect, grayRect, roundThumb;
  533.     
  534.     testPoint.h = h; testPoint.v = v;
  535.     
  536.     if(PtInRect(testPoint, &(*me)->contrlRect) && (*me)->contrlHilite < 255) 
  537.     // quick determination of (mouse in rect and control undimmed)
  538.     {
  539.         CopyRect(&(*me)->contrlRect, &ctlRect);
  540.         CalcGrayRect(me, &grayRect, &whiteRect);
  541.         CalcThumbRects(me,(*me)->contrlValue, &roundThumb);
  542.         if (PtInRect(testPoint, &roundThumb))
  543.         {
  544.             result = inThumb;
  545.         }
  546.         /*
  547.         else if (PtInRect(testPoint, &grayRect))
  548.         {
  549.             result = inPageUp;
  550.         }
  551.         else
  552.         {
  553.             result = inPageDown;
  554.         } */
  555.     }
  556.     return (result);
  557. }
  558. /*************** DrawMe **********
  559. ******* Draw the control or the control's thumb *****/
  560. void DrawMe(ControlHandle me, short part)
  561. {
  562.     Rect            grayRect, whiteRect, thumbRect, tempRect;
  563.     PenState        oldState;
  564.     PrivateHandle    privData;
  565.     RgnHandle        oldRegion = 0L, thumbRegion = 0L, ctlRegion =0L;
  566.     short            diameter;
  567.     
  568.     GetPenState(&oldState);
  569.     PenNormal();
  570.     privData = (PrivateHandle)(*me)->contrlData;
  571.     CalcGrayRect(me, &grayRect, &whiteRect);
  572.     CalcThumbRects(me, (*me)->contrlValue, &thumbRect);
  573.  
  574.     switch (part)
  575.     {
  576.         case 255: // change in dimming
  577.             EraseRect(&grayRect);
  578.         case 0: // draw whole thing
  579.             EraseRect(&whiteRect);
  580.             DrawMyFrame(me,&grayRect);
  581.             DrawMyIndicator(me, &thumbRect);
  582.         break;
  583.         case 129: // redraw generic indicator
  584.                 // I'm using the regions to stop the flashing of drawing 
  585.                 // the gray rect and then drawing the white thumb over it
  586.             oldRegion = NewRgn();
  587.             thumbRegion = NewRgn();
  588.             ctlRegion = NewRgn();
  589.             if (ctlRegion && thumbRegion && oldRegion && privData)
  590.             {
  591.                 diameter = CalcRounding(&(*me)->contrlRect);
  592.                 GetClip(oldRegion);
  593.                 CopyRect(&thumbRect, &tempRect);
  594.                 // InsetRect(&tempRect, -2,-2);
  595.                 OpenRgn();
  596.                     FrameRoundRect(&(*me)->contrlRect, diameter, diameter);
  597.                 CloseRgn(ctlRegion);
  598.                 OpenRgn();
  599.                     FrameRoundRect(&thumbRect, diameter, diameter);
  600.                 CloseRgn(thumbRegion);
  601.                 XorRgn(ctlRegion, thumbRegion, thumbRegion);
  602.                 SetClip(thumbRegion);
  603.                 CleanOldThumb(me, &thumbRect);
  604.                 SetClip(ctlRegion);
  605.                 DrawMyIndicator(me, &thumbRect);
  606.                 SetClip(oldRegion);
  607.             }
  608.             else // we had a memory allocation problem, draw whole thing
  609.             {
  610.                 EraseRect(&whiteRect);
  611.                 DrawMyFrame(me,&grayRect);
  612.                 DrawMyIndicator(me, &thumbRect);
  613.             }
  614.             if (thumbRegion) DisposeRgn(thumbRegion);
  615.             if (ctlRegion) DisposeRgn(ctlRegion);
  616.             if (oldRegion) DisposeRgn(oldRegion);
  617.             break;
  618.         default:
  619.         case inPageUp:
  620.         case inPageDown:
  621.         break;
  622.     }
  623.     if (privData)
  624.         (*privData)->oldValue = (*me)->contrlValue;
  625.     SetPenState(&oldState);
  626. }
  627. /*************** CleanOldThumb *************
  628. ***** We've gotten a message to draw the thumb, which
  629. ***** implies we have to eradicate the old thumb *******/
  630. void CleanOldThumb(ControlHandle me, Rect *thumbRect)
  631. {
  632.     PrivateHandle    privData;
  633.     short            oldValue, currValue;
  634.     short            diameter;
  635.     Rect            grayRect, ctlRect, oldThumb, whiteRect;
  636.     Boolean         upAndDown;
  637.     Pattern            grayPattern;
  638.     
  639.     privData = (PrivateHandle)(*me)->contrlData; // privData has already been tested
  640.     currValue = (*me)->contrlValue;
  641.     oldValue = (*privData)->oldValue;
  642.     
  643.     //if (currValue == oldValue) return;
  644.     
  645.     (*me)->contrlValue = oldValue;
  646.     CalcGrayRect(me, &grayRect, &whiteRect);
  647.     (*me)->contrlValue = currValue;
  648.     
  649.     CopyRect(&(*me)->contrlRect, &ctlRect);
  650.     diameter = CalcRounding(&ctlRect);
  651.     upAndDown = ((ctlRect.right - ctlRect.left) <= (ctlRect.bottom - ctlRect.top));
  652.     
  653.     CalcThumbRects(me, oldValue, &oldThumb);
  654.     GetIndPattern(grayPattern, 0, 1);// black
  655.     PenPat(grayPattern);
  656.  
  657.     if (oldValue > currValue)
  658.     {
  659.         if (upAndDown)
  660.         {
  661.             oldThumb.bottom = thumbRect->bottom;
  662.         }
  663.         else
  664.         {
  665.             oldThumb.left = thumbRect->left;
  666.         }
  667.         FillRoundRect(&oldThumb, diameter, diameter, grayPattern);
  668.     }
  669.     else
  670.     {
  671.         if (upAndDown)
  672.         {
  673.             oldThumb.top = thumbRect->top;
  674.         }
  675.         else
  676.         {
  677.             oldThumb.right = thumbRect->right;
  678.         }
  679.         EraseRoundRect(&oldThumb, diameter, diameter);
  680.     }
  681.     FrameRoundRect(&ctlRect, diameter, diameter);
  682. }
  683. /********** DrawMyIndicator ************
  684. ******* Draw the thumb, the thumbRect must be previously
  685. ******* calculated ******/
  686. void DrawMyIndicator(ControlHandle me, Rect *thumbRect)
  687. {
  688.     Rect        ctlRect;
  689.     Boolean     useColorQD, dimmed = FALSE;
  690.     RGBColor    newColor, oldColor;
  691.     Pattern        grayPattern;
  692.     Boolean        upAndDown;
  693.     short        diameter;
  694.     PrivateHandle    privData;
  695.     
  696.     privData = (PrivateHandle)(*me)->contrlData;
  697.     
  698.     if ((*me)->contrlMin >= (*me)->contrlMax) dimmed = TRUE;
  699.     if ((*me)->contrlHilite == 255) dimmed = TRUE;
  700.     
  701.     
  702.     if (!dimmed)
  703.     {
  704.         CopyRect(&(*me)->contrlRect, &ctlRect);
  705.         diameter = CalcRounding (&ctlRect);
  706.         
  707.     
  708.         // calculate the rectangles used in drawing
  709.         useColorQD = UseColorQD(me, thumbRect);
  710.         // start actual drawing
  711.         if(useColorQD && privData)
  712.         {
  713.             GetForeColor(&oldColor);
  714.             RGBForeColor(&(*privData)->thumbColor);    // real medium gray
  715.             GetIndPattern(grayPattern, 0, 1);// standard black for fill
  716.             FillRoundRect(thumbRect, diameter, diameter, grayPattern);
  717.             RGBForeColor(&oldColor);
  718.         }
  719.         else
  720.         {
  721.             GetIndPattern(grayPattern, 0, 4);// standard gray for fill
  722.             FillRoundRect(thumbRect, diameter, diameter, grayPattern);
  723.         }
  724.         FrameRoundRect(thumbRect, diameter, diameter);
  725.     }
  726. }
  727. /***************** CalcThumbRects ******
  728. **** should be CalcThumbRect, just figure what the bounding rect of
  729. *** the thumb should be given the value *******/
  730. void CalcThumbRects(ControlHandle me, short value, 
  731.         Rect *roundThumb)
  732. {
  733.     long    width, height, thumbLen;
  734.     Point    valuePoint;
  735.     Rect    ctlRect;
  736.     
  737.     CopyRect(&(*me)->contrlRect, &ctlRect);
  738.     CopyRect(&ctlRect, roundThumb);
  739.     
  740.     height = ctlRect.bottom - ctlRect.top;
  741.     width = ctlRect.right - ctlRect.left;
  742.     
  743.     MapValue2Point(me, value, &valuePoint);
  744.     thumbLen = CalcThumbLen(&ctlRect);
  745.     // calculate the rectangles used in drawing
  746.     if (height >= width)
  747.     {
  748.         roundThumb->top = valuePoint.v - thumbLen/2;
  749.         roundThumb->bottom = roundThumb->top+thumbLen;
  750.         
  751.     }
  752.     else
  753.     {
  754.         roundThumb->right = valuePoint.h + thumbLen/2;
  755.         roundThumb->left = roundThumb->right - thumbLen;
  756.     }
  757. }
  758. /********** CalcThumbLen *********
  759. **** figure how high or wide the thumb should be (given
  760. **** that some moron might have made the control too small ***/
  761. short CalcThumbLen(Rect *ctlRect)
  762. {
  763.     short    height, width;
  764.     short    result;
  765.     height = ctlRect->bottom - ctlRect->top;
  766.     width = ctlRect->right - ctlRect->left;
  767.     if (width > height)
  768.     {
  769.         result = (width > 20)?20:width;
  770.     }
  771.     else
  772.     {
  773.         result = (height > 20)?20:height;
  774.     }
  775.     return (result);
  776. }
  777. /********* DrawMyFrame **********
  778. ******* Draw the black portion of the control (pageup)
  779. ******* and frame the whole thing ********/
  780. void DrawMyFrame(ControlHandle me, Rect *grayRect)
  781. {    
  782.     Rect        ctlRect;
  783.     Boolean     useColorQD, dimmed = FALSE;
  784.     RGBColor    newColor, oldColor;
  785.     Pattern        grayPattern;
  786.     PrivateHandle    privData;
  787.     short         min, max, diameter;
  788.     privData = (PrivateHandle)(*me)->contrlData;
  789.     
  790.     CopyRect(&(*me)->contrlRect, &ctlRect);
  791.     useColorQD = UseColorQD(me, &ctlRect);
  792.     min = (*me)->contrlMin;
  793.     max = (*me)->contrlMax;
  794.     diameter = CalcRounding (&ctlRect);
  795.     if (min >= max) 
  796.     {
  797.         dimmed = TRUE;
  798.     }
  799.     if ((*me)->contrlHilite == 255) dimmed = TRUE;
  800.     
  801.     if (!dimmed)
  802.     {
  803.         GetIndPattern(grayPattern, 0, 1);// standard black for frame and top region
  804.         FillRoundRect(grayRect,diameter, diameter, grayPattern);
  805.         PenPat(grayPattern);
  806.     }
  807.  
  808.     FrameRoundRect(&ctlRect, diameter, diameter);
  809. }
  810. /*********** CalcGrayRect
  811. ***** figure out the rectangle which enclose the pageup and pagedown
  812. ***** parts of the control (they meet in the middle of the thumb) ***/
  813. void    CalcGrayRect(ControlHandle me, Rect *grayRect, Rect *whiteRect)
  814. {
  815.     long    height, width, value, max, min;
  816.     Point    valuePoint;  
  817.     short    thumbLen, halfThumb;
  818.     
  819.     
  820.     value = (*me)->contrlValue;
  821.     min = (*me)->contrlMin;
  822.     max = (*me)->contrlMax;
  823.     if (value > max) // too big, who let this in?
  824.         value = max;
  825.     else if (value < min) // too small
  826.         value = min;
  827.     MapValue2Point(me,value, &valuePoint);
  828.     
  829.     CopyRect(&(*me)->contrlRect, grayRect);
  830.     CopyRect(grayRect, whiteRect);
  831.     thumbLen = CalcThumbLen(grayRect);
  832.     halfThumb = thumbLen /2;
  833.     width = grayRect->right - grayRect->left;
  834.     height = grayRect->bottom - grayRect->top;
  835.     if (width > height) // we are going side to side
  836.     {
  837.         grayRect->left = valuePoint.h - halfThumb;
  838.         whiteRect->right = valuePoint.h;
  839.     }
  840.     else
  841.     { // halfThumb is because quickdraw sort of bales out
  842.         // when round rects are small 
  843.         grayRect->bottom = valuePoint.v + halfThumb;
  844.         whiteRect->top = valuePoint.v;
  845.     }
  846. }
  847. /******* CalcRounding *******
  848. ****** are we big enough to use round rectangles 
  849. if so use 16 diameter rounding, if not use square corners ****/
  850. short CalcRounding(Rect *ctlRect)
  851. {
  852.     short    width, height;
  853.     width = ctlRect->right - ctlRect->left;
  854.     height = ctlRect->bottom - ctlRect->top;
  855.     if (width > height)
  856.     {
  857.         if (width > 64)
  858.             return (16);
  859.     }
  860.     else
  861.     {
  862.         if (height > 64)
  863.             return (16);
  864.     }
  865.     return (0);
  866. }
  867.  
  868. /******** InitMe ********
  869. ****** allocate my global memory, test for color and load color table
  870. ****** information ****/
  871. void InitMe(ControlHandle me)
  872. {
  873.     PrivateHandle    privDataH;
  874.     AuxCtlHandle        acHndl;
  875.     CCTabHandle        tableH;
  876.     short            tabLen;
  877.     RGBColor        *tempColor;
  878.     privDataH = (PrivateHandle)NewHandleClear(sizeof(Private));
  879.     if (privDataH)
  880.     {
  881.  
  882.         if ((*privDataH)->useColorQD = TestForColor())
  883.         {// we are using color, find the highlight color
  884.  
  885.             tempColor = &(*privDataH)->thumbColor; 
  886.             tempColor->blue = tempColor->green = tempColor->red = 30583; // gray
  887.             GetAuxCtl(me, &acHndl);
  888.             if (acHndl)
  889.             {
  890.                 tableH = (*acHndl)->acCTable;
  891.                 tabLen = (*tableH)->ctSize;
  892.                 while(tabLen >= 0)
  893.                 {
  894.                 /*    if ((*tableH)->ctTable[tabLen].value == cThumbColor)
  895.                     {
  896.                         BlockMove(&(*tableH)->ctTable[tabLen].rgb, 
  897.                             &(*privDataH)->thumbColor, sizeof(RGBColor));
  898.                     } */
  899.                     tabLen--;
  900.                 }
  901.             }
  902.         }
  903.         // we need to know if we can call GetDeviceList to tell whether 
  904.         // or not our control is on a deep color screen
  905.         (*privDataH)->devicesAvailable = TrapAvailable(0xAA29);
  906.         
  907.         (*privDataH)->oldValue = (*me)->contrlValue;
  908.     }
  909.     (*me)->contrlData = (Handle)privDataH;
  910. }