home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Sample Code / Music Architecture / Embedding Instruments / BigEasy / BigEasyStandardControls.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-17  |  12.1 KB  |  623 lines  |  [TEXT/KAHL]
  1. /*
  2.     File:        BigEasyStandardControls.c
  3.  
  4.     Contains:    xxx put contents here xxx
  5.  
  6.     Written by:    xxx put writers here xxx
  7.  
  8.     Copyright:    © 1990-1991 by Apple Computer, Inc., all rights reserved.
  9.  
  10.     This file is used in these builds: Warhol
  11.  
  12.     Change History (most recent first):
  13.  
  14.          <9>      4/3/92    dvb        Allow nil for default style.
  15.          <8>     1/20/92    dvb        Latest BigEasy revs.
  16.          <7>    11/12/91    dvb        General fixation
  17.          <6>      9/6/91    MD        don't HLock a Ptr
  18.          <5>     5/28/91    JB        Added prototypes for BigEasy Proc Ptrs
  19.          <4>     5/23/91    PH        THINK C 5
  20.          <3>     4/25/91    JB        Changing to new THINK_C interface files
  21.          <2>    11/17/90    dvb        Return unprocessed key-actions
  22.          <4>      8/4/90    dvb        Fix unused picture thing
  23.          <3>      8/2/90    dvb        Fix prototypes
  24.          <2>     7/31/90    dvb        Fix include paths
  25.  
  26.     To Do:
  27. */
  28.  
  29. /*
  30.   * file: BigEasyControls.c
  31.   *
  32.   * started 25 May 1990 12:07:24 Friday at 310 Nobel
  33.   * 
  34.   * david van brink
  35.   *
  36.   */
  37.  
  38.  
  39.  
  40.  
  41. /************************************
  42. * Inclusions
  43. ************************************/
  44.  
  45. #include <QuickDraw.h>
  46. #include <Memory.h>
  47. #include <Resources.h>
  48. #include <OSUtils.h>
  49. #include <OSUtils.h>
  50. #include <OSUtils.h>
  51. #include <Events.h>
  52. #include <desk.h>
  53.  
  54. #define privateEasyControls
  55. #include "BigEasy2.h"
  56. #include "BigEasyGrafish.h"
  57. #include "BigEasyTextish.h"
  58. #include "BigEasyControls.h"
  59. #include "BigEasyStandardControls.h"
  60.  
  61.  
  62. /************************************
  63. * Constants
  64. ************************************/
  65.  
  66. #define kSlop 10
  67. #define kBarVMargin 4
  68. #define kSliderCursor 200
  69.  
  70. /************************************
  71.     Default Styles
  72. ************************************/
  73.  
  74. static tSliderStyle dDefaultSliderStyle =
  75.     {
  76.     longNum,
  77.     120,15,
  78.     80,13,
  79.     nil
  80.     };
  81.  
  82.  
  83. /************************************
  84. * Prototypes
  85. ************************************/
  86. static void MaybeRaisedRect(short c,Rect *r,Boolean b);
  87.  
  88. static void NewSlider(easyControlPtr ec);
  89. static void DisposeSlider(easyControlPtr ec);
  90. static void DrawSlider(easyControlPtr );
  91. static void TrackSlider(easyControlPtr,Point p);
  92. static void KeySlider(easyControlPtr,short k,short m,Boolean *tookKey);
  93. static void DrawSliderValue(easyControlPtr );
  94. static void HitTestSlider(void);
  95. static void SetSliderValue(struct easyControlRecord *ec,long value);
  96.  
  97. static void NewToggle(easyControlPtr ec);
  98. static void DisposeToggle(easyControlPtr ec);
  99. static void DrawToggle(easyControlPtr );
  100. static void DrawToggleValue(easyControlPtr );
  101. static void HitTestToggle(easyControlPtr,Point p);
  102. static void TrackToggle(easyControlPtr,Point p,short *trackResult,short mods);
  103. static void KeyToggle(easyControlPtr,short k,short mods,Boolean *tookKey);
  104. static void SetToggleValue(easyControlPtr,long);
  105. static void Idle(easyControlPtr,long *);
  106.  
  107. easyControlType toggleType =
  108.     {
  109.     NewToggle,
  110.     DisposeToggle,
  111.     DrawToggle,
  112.     HitTestToggle,
  113.     TrackToggle,
  114.     KeyToggle,
  115.     SetToggleValue,
  116.     Idle,
  117.     DrawToggleValue
  118.     };
  119.  
  120. easyControlType sliderType =
  121.     {
  122.     NewSlider,
  123.     DisposeSlider,
  124.     DrawSlider,
  125.     (becHitTestProcPtr)HitTestSlider,
  126.     (becTrackProcPtr)TrackSlider,
  127.     KeySlider,
  128.     SetSliderValue,
  129.     Idle,
  130.     DrawSliderValue
  131.     };
  132.  
  133.  
  134.  
  135. /************************************
  136. * Routines
  137. ************************************/
  138.  
  139. void MaybeRaisedRect(short c,Rect *r,Boolean b)
  140. /*
  141.   * if background, draw a flat rect,
  142.   * else a raised rect.
  143.   */
  144.     {
  145.     if(b)
  146.         {
  147.         Fore555(c);
  148.         PaintRect(r);
  149.         }
  150.     else
  151.         RaisedRect(r,c);
  152.     }
  153.  
  154.  
  155.  
  156. /*
  157.   * Sliders
  158.   *
  159.   * Sliders copy their style into a handle, stored
  160.   * in the slide field of the easyControl.
  161.   */
  162.  
  163. void TrackSlider(ec,p)
  164.  /*
  165.    * Track the mouse within the slider as long
  166.    * as the button is held down, all the while
  167.    * updating the value and drawing the bar.
  168.    */
  169.     register easyControlPtr ec;
  170.     Point p;
  171.     {
  172.      tSliderStyle *st;
  173.      Point lastP;
  174.      long oldValue;
  175.      long value;
  176.      long vRange, rRange,rounding;
  177.      double fVRange, fRRange, fRounding;        /* for floating point sliders    */
  178.      Rect slopRect;
  179.      long q;
  180.      Boolean zingCursor;
  181.      Handle tempH;
  182.  
  183.      GoCursor(kSliderCursor);
  184.      zingCursor = true;
  185.  
  186.      st = *(tSliderStyle **)ec->style;
  187.      HLock(tempH = RecoverHandle((Ptr)st));
  188.      oldValue = ec->value;
  189.  
  190.      slopRect = ec->rect;
  191.      InsetRect(&slopRect,-kSlop,-kSlop);
  192.  
  193.      if(st->numberType == floatNum)
  194.          {
  195.          fVRange = AsFloat(ec->high) - AsFloat(ec->low);
  196.          fRRange = st->sWidth - 2;
  197.          fRounding = (fRRange / fVRange) / 2;
  198.          }
  199.      else
  200.          {
  201.          vRange = ec->high - ec->low;
  202.          rRange = st->sWidth - 2;
  203.          rounding = (rRange / vRange) / 2;
  204.          }
  205.  
  206.      if(ec->initActionProc)                    /* Call initAction proc once        */
  207.         (*ec->initActionProc)(ec->value,ec->refcon);
  208.     while(Button())
  209.          {
  210.         q = TickCount()+2;
  211.         while(TickCount() < q)
  212.             SystemTask();
  213.  
  214.  
  215.         if(ec->actionProc)                    /* Call action proc every time        */
  216.             (*ec->actionProc)(ec->value,ec->refcon);
  217.  
  218.         lastP.h = p.h+1;                        /* Guarantee do first time through    */
  219.         GetMouse(&p);
  220.          if( (p.h != lastP.h) || (p.v != lastP.v) )
  221.              {
  222.              if(PtInRect(p,&slopRect))
  223.                  {
  224.                  if(!zingCursor)
  225.                      {
  226.                      GoCursor(kSliderCursor);
  227.                      zingCursor = true;
  228.                      }
  229.                  if(st->numberType == floatNum)
  230.                      ;
  231.                  else
  232.                     value = ec->low + (long)(p.h - ec->rect.left + rounding + 1) * vRange/rRange;
  233.                 }
  234.             else
  235.                 {
  236.                 value = oldValue;
  237.                 if(zingCursor)
  238.                     {
  239.                     InitCursor();
  240.                     zingCursor = false;
  241.                     }
  242.                 }
  243.  
  244.             if(value < ec->low)
  245.                 value = ec->low;
  246.             else if(value > ec->high)
  247.                 value = ec->high;
  248.  
  249.             if(value != ec->value)
  250.                 {
  251.                 ec->value = value;
  252.                 DrawSliderValue(ec);
  253.  
  254.                 if(ec->valueProc)                /* Call value proc for new value    */
  255. /*                    (*ec->valueProc)(ec); */
  256.                     (*ec->valueProc)((easyControl)RecoverHandle((Ptr)ec));
  257.                 }
  258.             lastP = p;
  259.             }
  260.          }
  261.      if(ec->doneActionProc)                    /* Call doneAction proc once        */
  262.         (*ec->doneActionProc)(ec->value,ec->refcon);
  263.  
  264.      HUnlock(tempH);
  265.      InitCursor();
  266.      }
  267.  
  268. void DrawSlider(ec)
  269. /*
  270.   * Draw the slider passed.
  271.   */
  272.     register easyControlPtr ec;
  273.     {
  274.     register tSliderStyle *st;
  275.     Rect r;
  276.     Handle tempH;
  277.  
  278.     st = *(tSliderStyle **)ec->style;
  279.     HLock(tempH = RecoverHandle((Ptr)st));
  280.     r = ec->rect;
  281. /*    r.right = r.left + st->sWidth;
  282.     r.bottom = r.top + st->sHeight;*/
  283.  
  284.     if(ec->flags & easyControlActive)
  285.         PenPat((Pattern *)dBlackPat);
  286.     else
  287.         PenPat((Pattern *)&dGrayPat);
  288.  
  289.     Fore555(ec->color[controlFrame]);
  290.     PenSize(1,1);
  291.     FrameRect(&r);
  292.     InsetRect(&r,1,1);
  293.     Fore555(ec->color[controlBackground]);
  294.     PaintRect(&r);
  295.  
  296.     DrawSliderValue(ec);
  297.     HUnlock(tempH);
  298.     }
  299.  
  300.  
  301. void DrawSliderValue(ec)
  302.     register easyControlPtr ec;
  303.     {
  304.     Rect bar,r;
  305.     register tSliderStyle *st;
  306.  
  307.     st = *(tSliderStyle **)ec->style;        /* already locked by caller    */
  308.  
  309.     if(ec->value < ec->low)
  310.         ec->value = ec->low;
  311.     else if(ec->value > ec->high)
  312.         ec->value = ec->high;
  313.  
  314.     bar.top = ec->rect.top + kBarVMargin;
  315.     bar.bottom = ec->rect.top + st->sHeight - kBarVMargin;
  316.     bar.left = ec->rect.left + 1;
  317.     bar.right = ec->rect.left + 1 + (long)(ec->value - ec->low) * (long)(st->sWidth - 2) /
  318.             (long)(ec->high - ec->low);
  319.  
  320.     if(ec->flags & easyControlActive)
  321.         PenPat((Pattern *)&dBlackPat);
  322.     else
  323.         PenPat((Pattern *)&dGrayPat);
  324.  
  325.     RaisedRect(&bar,ec->color[controlPart1]);
  326.  
  327.     bar.left = bar.right;
  328.     bar.right = ec->rect.left + st->sWidth - 1;
  329.     if(ec->variation & drawRightSlider)
  330.         RaisedRect(&bar,ec->color[controlPart2]);
  331.     else
  332.         {
  333.         Fore555(ec->color[controlBackground]);
  334.         PaintRect(&bar);
  335.         }
  336.  
  337.     if(st->tHeight)                        /* tHeight = 0 means no text    */
  338.         {
  339.         r.left = ec->rect.left;
  340.         r.top = ec->rect.top + st->sHeight - 1;
  341.         r.right = r.left + st->tWidth;
  342.         r.bottom = r.top + st->tHeight;
  343.         Fore555(ec->color[controlFrame]);
  344.         FrameRect(&r);
  345.         InsetRect(&r,1,1);
  346.         Fore555(ec->color[controlBackground]);
  347.         PaintRect(&r);
  348.         MoveTo(r.left + 2,r.bottom - (st->tHeight - 9)/2);
  349.         Fore555(ec->color[controlFrame]);
  350.         if(st->drawValue)
  351.             (*st->drawValue)((easyControl)RecoverHandle((Ptr)ec));
  352.         else
  353.             {
  354.             if(st->numberType == longNum)
  355.                 DrawNum(ec->value);
  356.             else if(st->numberType == fixedNum)
  357.                 DrawFixed(ec->value,4);
  358.             else if(st->numberType == fracNum)
  359.                 DrawFrac(ec->value,8);
  360.             else
  361.                 DrawString((StringPtr)"\pxyz");
  362.             }
  363.         }
  364.     }
  365.  
  366. void NewSlider(ec)
  367. /*
  368.   * Do allocations for a new easyControl slider type
  369.   */
  370.     easyControlPtr ec;
  371.     {
  372.     Handle h;
  373.     register tSliderStyle *st;
  374.  
  375. /*
  376.   * Copy the style information to our very own handle
  377.   */
  378.     if(ec->style == 0)
  379.         ec->style = &dDefaultSliderStyle;
  380.     h = NewHandle(sizeof(tSliderStyle));
  381.     BlockMove(ec->style,*h,sizeof(tSliderStyle));
  382.     ec->style = h;
  383.     st = (tSliderStyle *)*h;
  384.     st->sWidth = ec->rect.right - ec->rect.left;
  385.     st->sHeight = ec->rect.bottom - ec->rect.top;
  386.  
  387.     ec->low = 0;
  388.     ec->high = 100;
  389.     }
  390.  
  391. void DisposeSlider(ec)
  392. /*
  393.   * Deallocate the slider
  394.   */
  395.     register easyControlPtr ec;
  396.     {
  397.     DisposHandle((Handle)ec->style);
  398.     }
  399.  
  400. void SetSliderValue(struct easyControlRecord *ec,long value)
  401.     {
  402.     ec->value = value;    
  403.     }
  404.  
  405. void HitTestSlider()
  406.     {
  407.     }
  408.  
  409. void NewToggle(ec)
  410.     easyControlPtr ec;
  411.     {
  412.     ec->low = 0;
  413.     ec->high = 1;
  414.     }
  415.  
  416. void DisposeToggle(ec)
  417.     easyControlPtr ec;
  418.     {
  419.     #pragma unused(ec)
  420.     }
  421.  
  422. void DrawToggle(ec)
  423.     easyControlPtr ec;
  424.     {
  425.     Rect r;
  426.  
  427.     r = ec->rect;
  428.     Fore555(ec->color[0]);
  429.     PenSize(1,1);
  430.     FrameRect(&r);
  431.     DrawToggleValue(ec);
  432.     }
  433.  
  434. void DrawToggleValue(ec)
  435.     easyControlPtr ec;
  436.     {
  437.     register tToggleStyle *st;
  438.     Rect r;
  439.     short c;
  440.     PicHandle p;
  441.  
  442.     r = ec->rect;
  443.     InsetRect(&r,1,1);
  444.  
  445.     if((ec->variation & checkboxToggle) && !(ec->flags & easyControlTracking))    /* checkbox version ? */
  446.         {
  447.         MaybeRaisedRect(ec->color[controlBackground],&r,ec->flags & easyControlBack);
  448.         if(ec->value)
  449.             {
  450.             Fore555(ec->color[controlFrame]);
  451.             PenSize(2,2);
  452.             MoveTo(r.left,r.top);
  453.             LineTo(r.right-2,r.bottom-2);
  454.             MoveTo(r.left,r.bottom-2);
  455.             LineTo(r.right-2,r.top);
  456.             }
  457.         }
  458.     else
  459.         {
  460.         if((!ec->value) ^ (ec->variation & checkboxToggle != 0))
  461.             c = ec->color[controlBackground];
  462.         else
  463.             c = ec->color[controlPart1];
  464.         
  465.         if(ec->flags & easyControlBack)
  466.             {
  467.             Fore555(c);
  468.             PaintRect(&r);
  469.             }
  470.         else
  471.             {
  472.             RaisedRect(&r,c);
  473.         
  474.             st = ec->style;
  475.             if(st && st->p)                    /* res ID zero doesn't draw */
  476.                 {
  477.                 p = (PicHandle)GetResource('PICT',st->p);
  478.                 if(p)
  479.                     {
  480.                     r = (**p).picFrame;
  481.                     OffsetRect(&r,((ec->rect.left  + ec->rect.right) - (r.left + r.right))/2,
  482.                             ((ec->rect.top + ec->rect.bottom) - (r.top + r.bottom))/2);
  483.                     DrawPicture(p,&r);
  484.                     }
  485.                 else                        /* missing picture */
  486.                     {
  487.                     GoBlack();
  488.                     PenSize(1,1);
  489.                     MoveTo(ec->rect.left,ec->rect.top);
  490.                     LineTo(ec->rect.right-1,ec->rect.bottom-1);
  491.                     }
  492.                 }
  493.             }
  494.         }
  495.     }
  496.  
  497. void TrackToggle(register easyControlPtr ec,Point p,
  498.             short *trackResult,short mods)
  499.     {
  500.     long oldValue,newValue;
  501.     register Boolean inRect;
  502.     long dummylong;
  503.     
  504.     #pragma unused(mods)
  505.  
  506.     oldValue = ec->value;
  507.     newValue = !ec->value;
  508.  
  509.     if(ec->variation & dontTrackToggle)
  510.         {
  511.         ec->value = newValue;
  512.         DrawToggleValue(ec);
  513.         if(!(ec->variation & toggleToggle))
  514.             Delay(5,&dummylong);
  515.         inRect = true;
  516.         }
  517.     else
  518.         do
  519.             {
  520.             SystemTask();
  521.             GetMouse(&p);
  522.             inRect = PtInRect(p,&ec->rect);
  523.             if(inRect)
  524.                 newValue = !oldValue;
  525.             else
  526.                 newValue = oldValue;
  527.             if(newValue != ec->value)
  528.                 {
  529.                 ec->value = newValue;
  530.                 DrawToggleValue(ec);
  531.                 }
  532.             } while(Button());
  533.  
  534.     if(!(ec->variation & toggleToggle) && (ec->value))        /* if it's not toggle-ish, reset it    */
  535.         {
  536.         ec->value = 0;
  537.         DrawToggleValue(ec);
  538.         }
  539.  
  540.     *trackResult = inRect;
  541.     }
  542.  
  543. void SetToggleValue(easyControlPtr ec,long v)
  544.     {
  545.     ec->value = v;
  546.     DrawToggleValue(ec);
  547.     }
  548.  
  549. void HitTestToggle(easyControlPtr ec,Point p)
  550.     {
  551.     #pragma unused(ec)
  552.     #pragma unused(p)
  553.     }
  554.  
  555. void Idle(ec,r)
  556.     easyControlPtr ec;
  557.     long *r;
  558.     {
  559.     if(*r & 1)
  560.         Fore555(ec->color[1]);
  561.     else
  562.         Fore555(ec->color[0]);
  563.  
  564.     PenSize(1,1);
  565.     FrameRect(&ec->rect);
  566.     }
  567.  
  568. void KeySlider(register easyControlPtr ec,short k,short m,register Boolean *tookKey)
  569.     {
  570.     register short step;
  571.  
  572.     *tookKey = true;
  573.  
  574.     if(m&shiftKey)
  575.         step = 10;
  576.     else
  577.         step = 1;
  578.     switch(k)
  579.         {
  580.         case 28:
  581.             ec->value-=step;
  582.             break;
  583.         case 29:
  584.             ec->value+=step;
  585.             break;
  586.         default:
  587.             *tookKey = false;
  588.         }
  589.     DrawSliderValue(ec);
  590.     }
  591.  
  592. void KeyToggle(easyControlPtr ec,short k,short m,Boolean *tookKey)
  593.     {
  594. #pragma unused (m)
  595.  
  596.     long dummylong;
  597.     
  598.     if(k == ' ')        /* spacebar only */
  599.         {
  600.         *tookKey = true;
  601.  
  602.         if(ec->variation & toggleToggle)
  603.             {
  604.             ec->value = !ec->value;
  605.             DrawToggleValue(ec);
  606.             }
  607.         else
  608.             {
  609.             ec->value = 1;
  610.             DrawToggleValue(ec);
  611.             Delay(5,&dummylong);
  612.             ec->value = 0;
  613.             DrawToggleValue(ec);
  614.             }
  615.     
  616.         if(ec->valueProc)
  617.             (*ec->valueProc)((easyControl)RecoverHandle((Ptr)ec));
  618.         }
  619.     else
  620.         *tookKey = false;
  621.     }
  622.  
  623.