home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / System / Sample JGNE⁄cdev 1.2.1 / (MyControlPanel.π) / MyControlPanel.c
Encoding:
Text File  |  1994-06-07  |  33.3 KB  |  1,060 lines  |  [TEXT/KAHL]
  1. /*
  2.     MyControlPanel.c
  3.  
  4.     Written by Ken Worley, 06/03/94, using Symantec Think C 7.0.
  5.     Copyright 1994.
  6.     AOL KNEworley
  7.     internet KNEworley@aol.com
  8.     
  9.     Feel free to use this code in a control panel of your own, but give me proper
  10.     credit in your documentation or about box.  Feel free to distribute this
  11.     code in its entirety to anyone, but never do so without the copyright notice
  12.     above nor without its accompanying files.  This code is NOT in the public
  13.     domain.  Use of this code in a commercial product requires my permission.
  14.     
  15.     This control panel is designed (at this time) to work in the Sample JGNE/cdev
  16.     project/package.
  17.     
  18.     This control panel uses no global variables, so it's not necessary
  19.     to set up and restore A4.  All of our 'global' data is in the shared data
  20.     structure myData (in a pointer to a block in the system heap).
  21.     
  22.     The Control Panel Manager sends messages to your control panel through
  23.     its main routine when it is opened, closed, or manipulated in any way that you
  24.     would need to respond to.
  25.     
  26.     The routines already set up here will handle ALL of the messages that
  27.     would be received.  Most of them, at the present time, don't do anything
  28.     since this is only an example.  By simply inserting code into the routines,
  29.     however, you can add functionality.
  30.     
  31.     The three most common messages received are:
  32.     
  33.         initDev        We receive this when the user opens our control panel (or
  34.                     selects it in the scrolling list of control panels in System 6).
  35.         
  36.         closeDev    We receive this when the user closes the control panel (or
  37.                     selects a different control panel in System 6).
  38.                     
  39.         hitDev        The user has manipulated a control in the control panel (i.e.
  40.                     pressed a button or clicked in a text field, etc.)
  41.                     
  42.         Other messages are received when the user selects items in the Edit menu,
  43.         when the control panel is sent to the background or brought to the foreground,
  44.         when the user types, and when the control panel needs to be updated.  Controls
  45.         in the panel's DITL (item list) are updated automatically.
  46.         
  47.     The cdevValue parameter of main is a mechanism that allows you to store data
  48.     across calls to the control panel.  Normally, when an initDev message is received,
  49.     we would allocate a new handle and return the handle as the function's
  50.     return value (unless an error occurred).  The next time main is called by the
  51.     Control Panel Manager, the same value is passed back to us in cdevValue so that
  52.     we can access the memory.
  53.     
  54.     Normally, we don't need to actually allocate anything here, but
  55.     we still use the mechanism to retain the address of our shared data structure
  56.     between calls.  When a closeDev message is received, we dispose of
  57.     the memory block and return cdevUnset to indicate no handle is allocated.
  58.     
  59.     If, however, the INIT wasn't loaded/run at startup time, our shared data
  60.     structure was never allocated.  If this happens, we allocate storage for
  61.     it here so that the control panel can still run normally and preferences
  62.     can be stored.
  63.     
  64.     Other possible return values are:
  65.     
  66.         cdevUnset    Control Panel Manager need not keep track of any memory
  67.         cdevGenErr    generic error - no error dialog is shown but panel does not load
  68.         cdevMemErr    not enough memory to continue - error dialog shown
  69.         cdevResErr    a resource is unavailable - error dialog shown
  70.         A handle to some memory for the Control Panel Manager to keep track of
  71.             between calls.
  72.     
  73.     Instead of allocating new memory, we look up the address of our shared memory
  74.     structure in a resource created by the extension code.  We use the cdevValue
  75.     mechanism to save that as long as the control panel is open.  This memory
  76.     was initially allocated by the extension code (which stored the address
  77.     in the resource).  This resource is of type 'memA'.
  78.     
  79.     I use a resource of type 'pref' to hold the control panel's "preferences."  At
  80.     this time, the resource is a struct containing only two fields:  On and
  81.     ShowIcon.  'On' indicates whether the patch should take action when trapped to and
  82.     'ShowIcon' indicates whether the extension's icon should be shown at system
  83.     startup time.
  84.     
  85.     If the user opens the control panel when the INIT hasn't run yet, the on/off
  86.     setting is automatically set to off when the control panel is opened.  That
  87.     way, when the user turns it on, a dialog is shown warning that changes take
  88.     effect on restart.  This will happen EVERY time the control panel is opened
  89.     until it is actually loaded at startup time.  So, if the user turns the control
  90.     panel on (and it wasn't loaded at startup), then closes it and opens it again,
  91.     it will once again be off.  It didn't turn off again, though, until the control
  92.     panel was opened again.  Seemed like a good thing to do at the time...
  93.     
  94.     Because of the fact that we release our resource every time the control panel is
  95.     closed, if you need to access values manipulated by the control panel in the
  96.     patch code for example, you may want to duplicate the final values in the
  97.     shared data structure.  It would be most convenient to do this in the CloseCP
  98.     routine just before the resource is released.  I store the on/off status of
  99.     the control panel in the field 'CPon' in the shared data.  The patch code uses
  100.     this field to determine if it should take any action.  The control panel also
  101.     refers to the field 'patched' to determine if the patch was installed at
  102.     system startup.
  103.     
  104.     Any resources used by a control panel must be in the range -4064 thru -4033.
  105.     The only exception has to do with balloon help.  Of that range, -4064 thru -4049
  106.     is reserved for standard resources (and some optional resources).  You can use
  107.     -4048 thru -4033 for any resources you include for use with your control panel.
  108.     This is from the New Inside Macintosh: More Macintosh Toolbox (chapter 8).
  109.     
  110.     Coordinates in your control panel dialog:
  111.     
  112.         System 7 lets you use almost any size control panel you wish.  System 6 and
  113.         earlier (which uses the Control Panel desk accessory) requires the control
  114.         panel to be in the rectangle (-1, 87, 255, 322).  In both cases, the origin
  115.         of your control panel should be at (-1, 87).  This leaves space for the
  116.         scrolling list of icons in the Control Panel desk accessory and is left
  117.         off in System 7.
  118.     
  119.     The 'nrct' resource:
  120.     
  121.         This resource contains coordinates for rectangles within your control
  122.         panel.  The Control Panel Manager will draw a 2-pixel box around each
  123.         rectangle defined in this resource.  You may include only one rectangle
  124.         if you like (to surround the entire control panel), or you can define 
  125.         several to separate different sets of controls.  This example includes
  126.         three rectangles:  one surrounds the on and off radio buttons, another
  127.         surrounds the PICT at the top of the control panel, and another
  128.         surrounds the rest of the controls/items.  This resource should have an
  129.         ID number of -4064.  If the rectangles you define do not form a rectangle
  130.         when put together, the extra space is filled in with a gray pattern.
  131.     
  132.     The 'DITL' resource:
  133.     
  134.         This is a standard dialog item list resource that defines all the controls
  135.         and other items in your control panel.  The ID numbers you give each item
  136.         are used to identify those items in your code that responds to the hitDev
  137.         message.  This resource should have an ID number of -4064.
  138.         
  139.         NOTE:  According to the New Inside Macintosh:  More Macintosh Toolbox,
  140.         chapter 8 (Control Panels), if you use a font other than the standard 
  141.         application font (if you define an 'finf' resource), you must define
  142.         text as user items rather than static text items in order for the
  143.         control panel to run in the Control Panel Desk Accessory in System 6
  144.         and earlier.
  145.         
  146.     The 'ICN#' (and related) resources:
  147.         
  148.         This is simply the icon that represents the control panel in the finder.
  149.         The ICN# resource actually refers to other resources that define icons
  150.         for different screen depths and statuses.  It is sometimes referred to
  151.         as an 'icon family' resource.  This resource must have an ID number of
  152.         -4064 and must be purgeable.
  153.         
  154.         The Mac does NOT automatically draw your control panel's icon on the
  155.         screen during startup.  We use a routine called ShowIconFamily in our
  156.         extension code to do this.
  157.     
  158.     The 'mach' resource:
  159.     
  160.         This resource indicates to the Control Panel Manager what type of machine
  161.         this control panel runs on or if it needs to check with the control panel
  162.         for that.  It has these possible values (in hex, 4 bytes):
  163.         
  164.             0000 FFFF    Call control panel with macDev message.  The control panel
  165.                         will return true if it can run on this machine and false if
  166.                         it cannot.  This example code will simply return true if
  167.                         called with the macDev message.
  168.             
  169.             3FFF 0000    Runs on Mac II systems only.
  170.             
  171.             7FFF 0400    Runs on all Macs with an ADB (Apple Desktop Bus).
  172.             
  173.             FFFF 0000    Runs on all Macs.
  174.     
  175.     The 'finf' resource:
  176.     
  177.         This resource specifies a font other than the standard application font
  178.         to be used for drawing the text in your control panel.  This only works
  179.         in System 7.  In earlier systems, define text as user items instead of
  180.         static text items and draw the text in whatever font you wish.  This
  181.         resource should have an ID number of -4049.
  182.         
  183.         For purposes of this example, I did use static text items and an 'finf'
  184.         resource.  In system 6 and earlier, text will be drawn in the standard
  185.         application font.
  186.         
  187.     Of course, your control panel will need to include a file reference (FREF)
  188.     resource, bundle (BNDL) resource, and signature resource.  Refer to your
  189.     development system documentation or Inside Macintosh for information on
  190.     these resources.
  191. */
  192.  
  193.  
  194. #define    LOCKP    HLock( (Handle)myData->CPprefsRsrc )    /* lock handle to prefs rsrc */
  195. #define    UNLOCKP    HUnlock( (Handle)myData->CPprefsRsrc )    /* unlock same */
  196.  
  197. #include "SharedData.h"            /* Includes the definition of the data */
  198.                                 /* structure shared with the extension */
  199.                                 /* and task code */
  200.  
  201. /* about box item defines */
  202.  
  203. #define    kAboutDialogClrID        -4048
  204. #define    kAboutDialogBWID        -4045
  205. #define kAboutOKButton        1
  206. #define kAboutTextFld        2
  207.  
  208. /* changes after restart dialog defines */
  209.  
  210. #define kRestartDialogID    -4047
  211. #define kRestartOKButton    1
  212. #define kRestartText        2
  213.  
  214. /* control panel unavailable dialog defines */
  215.  
  216. #define kUnavailDialogID    -4046
  217. #define kUnavailOKButton    1
  218. #define kUnavailText        2
  219.  
  220. /* control panel item defines */
  221.  
  222. #define    kCPAboutButton        1
  223. #define kCPShowIconBox        2
  224. #define kCPOnRadioButton    3
  225. #define kCPOffRadioButton    4
  226. #define kCPShiftBox            5
  227. #define kCPCommandBox        6
  228. #define kCPOptionBox        7
  229. #define kCPControlBox        8
  230.  
  231.  
  232. /* prototypes */
  233.  
  234. pascal long    main( short message, short item, short numItems, short cpID,
  235.     EventRecord *evt, long cdevValue, DialogPtr theCP );
  236. myDataPtr    InitCP( DialogPtr theCP );
  237. void    CloseCP( myDataPtr myData );
  238. void    Hit( myDataPtr myData, short whichItem );
  239. void    Twiddle( myDataPtr myData );
  240. void    Update( myDataPtr myData );
  241. void    Activate( myDataPtr myData );
  242. void    Deactivate( myDataPtr myData );
  243. void    KeyPress( myDataPtr myData, EventRecord *event );
  244. void    Undo( myDataPtr myData );
  245. void    Cut( myDataPtr myData );
  246. void    Copy( myDataPtr myData );
  247. void    Paste( myDataPtr myData );
  248. void    Clear( myDataPtr myData );
  249. void    About( myDataPtr myData );
  250. void    DoRestartDialog( void );
  251. void    DoUnavailDialog( void );
  252. void    GetSysInformation( myDataPtr myData );
  253.  
  254. /* Functions */
  255.  
  256. pascal long    main( short message, short item, short numItems, short cpID,
  257.     EventRecord *evt, long cdevValue, DialogPtr theCP )
  258. {
  259.     myDataPtr        myData;        /* address of my shared data structure */
  260.     long            result;        /* result to return */
  261.     char            theChar;    /* used to handle some key presses */
  262.  
  263.     /*    This function gets called every time any action is taken in this control
  264.      *    panel (including opening & closing).  If this isn't the first call to
  265.      *    the control panel (just opening), the value we need for myData should
  266.      *    be passed to us in cdevValue.
  267.      */
  268.          if ( message == initDev )
  269.              myData = NULL;
  270.          else
  271.              myData = (myDataPtr)cdevValue;
  272.     
  273.     /*    The macDev message is sent if the Mac wants to see if we should be
  274.      *    showing in the Control Panel.  Since we want to be run on any machine,
  275.      *    we do no checking; we just return true.
  276.      */
  277.      
  278.         if ( message == macDev )
  279.             return 1L;
  280.     
  281.     /*    Here, we decide what to do based on the 'message' received from the
  282.      *    Control Panel.
  283.      */
  284.      
  285.          result = (long)myData;    /* Unless there's an error, always return myData */
  286.          
  287.         switch ( message )
  288.         {
  289.             case initDev:    /* initialize - user opened this control panel */
  290.                 myData = InitCP( theCP );
  291.                 if ( myData )
  292.                 {
  293.                     result = (long)myData;
  294.                 }
  295.                 else
  296.                 {
  297.                     DoUnavailDialog();
  298.                     result = cdevGenErr;
  299.                 }
  300.                 break;
  301.  
  302.             case closeDev:    /* close - last call to this device before closing */
  303.                 CloseCP( myData );
  304.                 break;
  305.                 
  306.             case hitDev:    /* user has pressed mouse button on an item */
  307.                 Hit( myData, item - numItems );
  308.                 break;
  309.                 
  310.             case nulDev:    /* nothing else to report - so twiddle */
  311.                 Twiddle( myData );
  312.                 break;
  313.                 
  314.             case updateDev:    /* update panel window (redraw controls, etc.) */
  315.                 Update( myData );
  316.                 break;
  317.                 
  318.             case activDev:    /* becoming active after being in background */
  319.                 Activate( myData );
  320.                 break;
  321.                 
  322.             case deactivDev:    /* becoming inactive after being in foreground */
  323.                 Deactivate( myData );
  324.                 break;
  325.                 
  326.             case keyEvtDev:    /* user has pressed a key */
  327.                 /* Check to see if the command key was down for menu equivalents */
  328.                     if ( ( evt->what != autoKey ) && ( evt->modifiers & cmdKey ) )
  329.                     {
  330.                         theChar = ( evt->message & charCodeMask );
  331.                         switch ( theChar )
  332.                         {
  333.                             case 'z':            /* menu command equivalents */
  334.                             case 'Z':
  335.                                 Undo( myData );        /* undo */
  336.                                 break;
  337.                             case 'x':
  338.                             case 'X':
  339.                                 Cut( myData );        /* cut */
  340.                                 break;
  341.                             case 'c':
  342.                             case 'C':
  343.                                 Copy( myData );        /* copy */
  344.                                 break;
  345.                             case 'v':
  346.                             case 'V':
  347.                                 Paste( myData );    /* paste */
  348.                                 break;
  349.                         }
  350.                     }
  351.                     else
  352.                     {
  353.                         KeyPress( myData, evt );    /* process other keystroke */
  354.                     }
  355.                 break;
  356.                 
  357.             case undoDev:    /* user picked UNDO from the Edit menu */
  358.                 Undo( myData );
  359.                 break;
  360.                 
  361.             case cutDev:    /* user picked CUT from the Edit menu */
  362.                 Cut( myData );
  363.                 break;
  364.                 
  365.             case copyDev:    /* user picked COPY from the Edit menu */
  366.                 Copy( myData );
  367.                 break;
  368.                 
  369.             case pasteDev:    /* user picked PASTE from the Edit menu */
  370.                 Paste( myData );
  371.                 break;
  372.                 
  373.             case clearDev:    /* user picked CLEAR from the Edit menu */
  374.                 Clear( myData );
  375.                 break;
  376.         }
  377.     return result;
  378. }
  379.  
  380.  
  381. myDataPtr    InitCP( DialogPtr theCP )
  382. {
  383.     short        itemType;        /* these 3 local vars that can be used to */
  384.     Handle        itemHandle;        /* manipulate items in the control     */
  385.     Rect        itemRect;        /* panel dialog */
  386.     myDataPtr    myData;            /* a pointer to our shared data structure */
  387.     
  388.     memAddrHdl    memAddr;        /* Handle to the rsrc containing the addr of our */
  389.                                 /* shared memory data structure */
  390.     CPprefsPtr    myPrefs;        /* pointer to our preferences resource struct */
  391.     
  392.     /*    At this point, the control panel has just been opened. */
  393.     
  394.     /*    Attempt to load the resource containing the addr of our shared memory struct */
  395.     
  396.         memAddr = (memAddrHdl)Get1Resource( kMemAddrType, kMemAddrID );
  397.         
  398.         if ( !memAddr )        /* could not load resource - INIT didn't run */
  399.         {
  400.             /* allocate memory for myData */
  401.             
  402.             myData = (myDataPtr)NewPtrSys( sizeof( myDataStruct ) );
  403.             
  404.             if ( myData )
  405.             {
  406.                 myData->INITrun = false;
  407.                 GetSysInformation( myData );
  408.             }
  409.             else
  410.             {
  411.                 return NULL;    //error cannot allocate storage for myData
  412.             }
  413.         }
  414.         else    /* addr rsrc was loaded - check to see if it's valid */
  415.         {
  416.             myData = (myDataPtr)((*memAddr)->theAddr); /* get addr of shared memory */
  417.             ReleaseResource( (Handle)memAddr );    /* release the rsrc - we have the info */
  418.             
  419.             /* check the checkValue field of the shared data to make sure */
  420.             /* we REALLY have the real shared data */
  421.             
  422.             if ( myData->checkValue != 0x12341234 )    // INIT didn't run
  423.             {
  424.                 /* allocate memory for myData */
  425.                 
  426.                 myData = (myDataPtr)NewPtrSys( sizeof( myDataStruct ) );
  427.                 
  428.                 if ( myData )
  429.                     myData->INITrun = false;
  430.                 else
  431.                     return NULL;    //error cannot alloc storage for myData
  432.             }
  433.         }
  434.             
  435.     /*    Load the control panel preferences resource.  Leave it unlocked except when
  436.      *    when we need to lock it.  When the control panel is closed, the resource
  437.      *    will be released.
  438.      */
  439.         
  440.         myData->CPprefsRsrc =
  441.             (CPprefsHandle)Get1Resource( kCPprefsRsrcType, kCPprefsRsrcID );
  442.         
  443.         if ( myData->CPprefsRsrc )
  444.         {
  445.             LOCKP;                                /* it's there - lock it down and */
  446.             myPrefs = (*(myData->CPprefsRsrc));    /* dereference for easy access */
  447.                                                 /* since it's locked */
  448.         }
  449.         else    /* it's not there - create a new resource */
  450.         {
  451.             myData->CPprefsRsrc =
  452.                 (CPprefsHandle)NewHandleClear( sizeof( CPprefsStruct ) );
  453.             
  454.             if ( myData->CPprefsRsrc )
  455.             {
  456.                 LOCKP;                                    /* lock the new handle */
  457.                 myPrefs = (*(myData->CPprefsRsrc));    /* dereference for easy access */
  458.                                                         /* since it's locked */
  459.                 
  460.                 myPrefs->On = true;                    /* default is to set both of */
  461.                 myPrefs->ShowIcon = true;            /* these to true */
  462.                 myPrefs->modifiers = controlKey + optionKey + shiftKey;    /* defaults */
  463.                 
  464.                 AddResource( (Handle)myData->CPprefsRsrc, kCPprefsRsrcType,
  465.                     kCPprefsRsrcID, "\pPreferences" );
  466.             }
  467.             else    /* unable to create new Handle for resource */
  468.             {
  469.                 return NULL;            /* exit with an error */
  470.             }
  471.         }
  472.     
  473.     // If the INIT was not run, set the control panel to "off".  When the user
  474.     // turns the control panel back "on," the changes on restart dialog will be
  475.     // shown.
  476.     
  477.         if ( !myData->INITrun )
  478.         {
  479.             myPrefs->On = false;
  480.         }
  481.         
  482.     /*    Save the dialog ptr value for access globally through myData */
  483.     
  484.         myData->CPdlg = theCP;
  485.         
  486.     /*    Set all controls to their correct values. */
  487.     
  488.         /* Get the ON button item */
  489.         
  490.             GetDItem( myData->CPdlg, kCPOnRadioButton,
  491.                 &itemType, &itemHandle, &itemRect );
  492.                 
  493.             if ( myPrefs->On )
  494.                 SetCtlValue( (ControlHandle)itemHandle, 1 );
  495.             else
  496.                 SetCtlValue( (ControlHandle)itemHandle, 0 );
  497.                 
  498.         /* Get the OFF button item */
  499.         
  500.             GetDItem( myData->CPdlg, kCPOffRadioButton,
  501.                 &itemType, &itemHandle, &itemRect );
  502.                 
  503.             if ( myPrefs->On )
  504.                 SetCtlValue( (ControlHandle)itemHandle, 0 );
  505.             else
  506.                 SetCtlValue( (ControlHandle)itemHandle, 1 );
  507.                 
  508.         /* Get the Show Icon check box item */
  509.         
  510.             GetDItem( myData->CPdlg, kCPShowIconBox,
  511.                 &itemType, &itemHandle, &itemRect );
  512.             
  513.             if ( myPrefs->ShowIcon )
  514.                 SetCtlValue( (ControlHandle)itemHandle, 1 );
  515.             else
  516.                 SetCtlValue( (ControlHandle)itemHandle, 0 );
  517.  
  518.         /* Get the Shift key check box item */
  519.         
  520.             GetDItem( myData->CPdlg, kCPShiftBox,
  521.                 &itemType, &itemHandle, &itemRect );
  522.             
  523.             if ( myPrefs->modifiers & shiftKey )
  524.                 SetCtlValue( (ControlHandle)itemHandle, 1 );
  525.             else
  526.                 SetCtlValue( (ControlHandle)itemHandle, 0 );
  527.  
  528.         /* Get the Command key check box item */
  529.         
  530.             GetDItem( myData->CPdlg, kCPCommandBox,
  531.                 &itemType, &itemHandle, &itemRect );
  532.             
  533.             if ( myPrefs->modifiers & cmdKey )
  534.                 SetCtlValue( (ControlHandle)itemHandle, 1 );
  535.             else
  536.                 SetCtlValue( (ControlHandle)itemHandle, 0 );
  537.  
  538.         /* Get the Option key check box item */
  539.         
  540.             GetDItem( myData->CPdlg, kCPOptionBox,
  541.                 &itemType, &itemHandle, &itemRect );
  542.             
  543.             if ( myPrefs->modifiers & optionKey )
  544.                 SetCtlValue( (ControlHandle)itemHandle, 1 );
  545.             else
  546.                 SetCtlValue( (ControlHandle)itemHandle, 0 );
  547.  
  548.         /* Get the Control key check box item */
  549.         
  550.             GetDItem( myData->CPdlg, kCPControlBox,
  551.                 &itemType, &itemHandle, &itemRect );
  552.             
  553.             if ( myPrefs->modifiers & controlKey )
  554.                 SetCtlValue( (ControlHandle)itemHandle, 1 );
  555.             else
  556.                 SetCtlValue( (ControlHandle)itemHandle, 0 );
  557.  
  558.     /*    Unlock the prefs rsrc, but don't allow it to be purged */
  559.     
  560.         HNoPurge( (Handle)myData->CPprefsRsrc );
  561.         UNLOCKP;
  562.  
  563.     return myData;
  564. }
  565.  
  566.  
  567. void    CloseCP( myDataPtr myData )
  568. {
  569.     /*    Here, we would want to destroy anything we created while the control panel
  570.      *    was "up."  The only thing left should be the shared data structure (which
  571.      *    we only destroy if the INIT didn't run and we had to create storage
  572.      *    for the data here).  Leaving things lying around in memory can only lead
  573.      *    to system bombs.  If we wanted to save any settings to disk, this would
  574.      *    be the place to do it.
  575.      */
  576.      
  577.      CPprefsHandle        prefsHandle;
  578.  
  579.      /* Write our preferences resource back to the resource file */
  580.      
  581.          prefsHandle = myData->CPprefsRsrc;
  582.          ChangedResource( (Handle)prefsHandle );
  583.          WriteResource( (Handle)prefsHandle );
  584.      
  585.      /* Save the on/off status of the control panel in the CPon field of the */
  586.      /* shared data structure. */
  587.      
  588.          myData->CPon = (*prefsHandle)->On;
  589.      
  590.      /* Save the modifier keys marked in the control panel also */
  591.      
  592.          myData->CPmodifiers = (*prefsHandle)->modifiers;
  593.          
  594.      /* Unlock the resource and release it.  We'll reload it next time we're opened. */
  595.      
  596.          UNLOCKP;
  597.          ReleaseResource( (Handle)prefsHandle );
  598.          myData->CPprefsRsrc = NULL;
  599.          prefsHandle = NULL;
  600.      
  601.      /* If the INIT didn't run and myData was created here, destroy it now */
  602.      
  603.          if ( !myData->INITrun )
  604.              DisposPtr( (Ptr)myData );
  605. }
  606.  
  607.  
  608. void    Hit( myDataPtr myData, short whichItem )
  609. {
  610.     /*    The user has pressed a button or clicked in a text editing field in the
  611.      *    control panel.  Handle the 'hit' here.
  612.      */
  613.      
  614.     short        itemType;        /* these 3 local vars that can be used to */
  615.     Handle        itemHandle;        /* manipulate items in the control     */
  616.     Rect        itemRect;        /* panel dialog */
  617.  
  618.     CPprefsHandle    prefsHandle;    /* used to more conveniently access the prefs rsrc */
  619.     
  620.     LOCKP;
  621.     prefsHandle = myData->CPprefsRsrc;
  622.     
  623.     switch ( whichItem )
  624.     {
  625.         case kCPAboutButton:
  626.             About( myData );
  627.             break;
  628.             
  629.         case kCPOnRadioButton:
  630.             if ( !(*prefsHandle)->On )    /* if off */
  631.             {
  632.                 GetDItem( myData->CPdlg, kCPOnRadioButton,
  633.                     &itemType, &itemHandle, &itemRect );
  634.                 SetCtlValue( (ControlHandle)itemHandle, 1 );
  635.                 
  636.                 GetDItem( myData->CPdlg, kCPOffRadioButton,
  637.                     &itemType, &itemHandle, &itemRect );
  638.                 SetCtlValue( (ControlHandle)itemHandle, 0 );
  639.                 
  640.                 (*prefsHandle)->On = true;
  641.                 
  642.                 // if the task was not installed, or the INIT didn't run,
  643.                 // warn user that changes won't take effect until restart
  644.                 
  645.                     if ( !myData->taskInstalled || !myData->INITrun )
  646.                         DoRestartDialog();
  647.             }
  648.             break;
  649.             
  650.         case kCPOffRadioButton:
  651.             if ( (*prefsHandle)->On )    /* if on */
  652.             {
  653.                 GetDItem( myData->CPdlg, kCPOnRadioButton,
  654.                     &itemType, &itemHandle, &itemRect );
  655.                 SetCtlValue( (ControlHandle)itemHandle, 0 );
  656.                 
  657.                 GetDItem( myData->CPdlg, kCPOffRadioButton,
  658.                     &itemType, &itemHandle, &itemRect );
  659.                 SetCtlValue( (ControlHandle)itemHandle, 1 );
  660.                 
  661.                 (*prefsHandle)->On = false;
  662.             }
  663.             break;
  664.  
  665.         case kCPShowIconBox:
  666.             GetDItem( myData->CPdlg, kCPShowIconBox,
  667.                 &itemType, &itemHandle, &itemRect );
  668.  
  669.             if ( (*prefsHandle)->ShowIcon )    /* if on */
  670.             {
  671.                 SetCtlValue( (ControlHandle)itemHandle, 0 );        /* turn it off */
  672.                 (*prefsHandle)->ShowIcon = false;
  673.             }
  674.             else
  675.             {
  676.                 SetCtlValue( (ControlHandle)itemHandle, 1 );        /* turn it on */
  677.                 (*prefsHandle)->ShowIcon = true;
  678.             }
  679.             break;
  680.  
  681.         case kCPShiftBox:
  682.             GetDItem( myData->CPdlg, kCPShiftBox,
  683.                 &itemType, &itemHandle, &itemRect );
  684.  
  685.             if ( (*prefsHandle)->modifiers & shiftKey )    /* if on */
  686.                 SetCtlValue( (ControlHandle)itemHandle, 0 );        /* turn it off */
  687.             else                                        /* else */
  688.                 SetCtlValue( (ControlHandle)itemHandle, 1 );        /* turn it on */
  689.                 
  690.             (*prefsHandle)->modifiers ^= shiftKey;        /* reverse shift key bit */
  691.             
  692.             break;
  693.  
  694.         case kCPCommandBox:
  695.             GetDItem( myData->CPdlg, kCPCommandBox,
  696.                 &itemType, &itemHandle, &itemRect );
  697.  
  698.             if ( (*prefsHandle)->modifiers & cmdKey )    /* if on */
  699.                 SetCtlValue( (ControlHandle)itemHandle, 0 );        /* turn it off */
  700.             else                                        /* else */
  701.                 SetCtlValue( (ControlHandle)itemHandle, 1 );        /* turn it on */
  702.             
  703.             (*prefsHandle)->modifiers ^= cmdKey;        /* reverse command key bit */
  704.             break;
  705.  
  706.         case kCPOptionBox:
  707.             GetDItem( myData->CPdlg, kCPOptionBox,
  708.                 &itemType, &itemHandle, &itemRect );
  709.  
  710.             if ( (*prefsHandle)->modifiers & optionKey )    /* if on */
  711.                 SetCtlValue( (ControlHandle)itemHandle, 0 );        /* turn it off */
  712.             else                                            /* else */
  713.                 SetCtlValue( (ControlHandle)itemHandle, 1 );        /* turn it on */
  714.                 
  715.             (*prefsHandle)->modifiers ^= optionKey;        /* reverse option key bit */
  716.             
  717.             break;
  718.  
  719.         case kCPControlBox:
  720.             GetDItem( myData->CPdlg, kCPControlBox,
  721.                 &itemType, &itemHandle, &itemRect );
  722.  
  723.             if ( (*prefsHandle)->modifiers & controlKey )    /* if on */
  724.                 SetCtlValue( (ControlHandle)itemHandle, 0 );        /* turn it off */
  725.             else                                            /* else */
  726.                 SetCtlValue( (ControlHandle)itemHandle, 1 );        /* turn it on */
  727.                 
  728.             (*prefsHandle)->modifiers ^= controlKey;    /* reverse control key bit */
  729.             
  730.             break;
  731.     }
  732.     UNLOCKP;
  733. }
  734.  
  735.  
  736. void    Twiddle( myDataPtr myData )
  737. {
  738.     /*    The user isn't doing anything at the moment, so take this time to do
  739.      *    odds and ends (if needed) in this idle time.
  740.      */
  741.  
  742.  
  743. }
  744.  
  745.  
  746. void    Update( myDataPtr myData )
  747. {
  748.     /*    We need to redraw the panel because something has screwed it up (like
  749.      *    another window moved from in front of it).  This is the same as in any
  750.      *    application except we don't call BeginUpdate() and EndUpdate().  The
  751.      *    Dialog Manager should take care of redrawing any controls.
  752.      */
  753.      
  754. }
  755.  
  756.  
  757. void    Activate( myDataPtr myData )
  758. {
  759.     /*    We're becoming active either because we were just opened, or we were in
  760.      *    the background and we're being brought to the foreground.  Take care of
  761.      *    hiliting text fields or list items or whatever.
  762.      */
  763.      
  764. }
  765.  
  766.  
  767. void    Deactivate( myDataPtr myData )
  768. {
  769.     /*    We're becoming inactive because we're being sent to the background.  Take
  770.      *    care of unhiliting text fields, list items, or whatever.
  771.      */
  772.  
  773. }
  774.  
  775.  
  776. void    KeyPress( myDataPtr myData, EventRecord *event )
  777. {
  778.     /*    The user has pressed a key on the keyboard (or a combination of keys).  In
  779.      *    any case, a keyboard event has been generated.  The main routine has already
  780.      *    checked for command key menu equivalents, so any real typing is handled
  781.      *    here (possibly by passing it on to textEdit if you have text fields).
  782.      *    I saw a note from Symantec in their cdev example that said text fields don't
  783.      *    seem to work correctly in control panels, so they convert theirs to user
  784.      *    items (at least while the panel's open).  I haven't tried it.
  785.      */
  786.  
  787. }
  788.  
  789.  
  790. void    Undo( myDataPtr myData )
  791. {
  792.     /*    User has selected UNDO from the Edit menu.  Undo the last action here if
  793.      *    it's appropriate and you've implemented an undo.  Otherwise, ignore.
  794.      */
  795.  
  796.     SysBeep( 3 );
  797. }
  798.  
  799.  
  800. void    Cut( myDataPtr myData )
  801. {
  802.     /*    User has selected CUT from the Edit menu.  If you have a text field that
  803.      *    is active, pass this along to textEdit.  Otherwise, ignore.
  804.      */
  805.     
  806.     SysBeep( 3 );
  807. }
  808.  
  809.  
  810. void    Copy( myDataPtr myData )
  811. {
  812.     /*    User has selected COPY from the Edit menu.  If you have a text field that
  813.      *    is active, pass this along to textEdit.  Otherwise, ignore.
  814.      */
  815.     
  816.     SysBeep( 3 );
  817. }
  818.  
  819.  
  820. void    Paste( myDataPtr myData )
  821. {
  822.     /*    User has selected PASTE from the Edit menu.  If you have a text field that
  823.      *    is active, pass this along to textEdit.  Otherwise, ignore.
  824.      */
  825.     
  826.     SysBeep( 3 );
  827. }
  828.  
  829.  
  830. void    Clear( myDataPtr myData )
  831. {
  832.     /*    User has selected CLEAR from the Edit menu.  If you have a text field that
  833.      *    is active, pass this along to textEdit.  Otherwise, ignore.
  834.      */
  835.     
  836.     SysBeep( 3 );
  837. }
  838.  
  839. void    About( myDataPtr myData )
  840. {
  841.     /*    This routine displays an about box for this control panel. */
  842.     
  843.     WindowPtr        winMgrPort;        /* store current window mgr port here */
  844.     WindowPtr        currentPort;    /* store the current port here */
  845.     DialogPtr        aboutDlg;        /* to store our dialog in */
  846.     
  847.     short        itemType;        /* these 3 local variables are used to */
  848.     Handle        itemHandle;        /* manipulate items in the dialog.     */
  849.     Rect        itemRect;
  850.  
  851.     short        itemHit;        /* use with ModalDialog */
  852.     Point        refPt;            /* a reference point */
  853.     
  854.     /*    Get the window manager port and the current port (our control panel)
  855.      *    Then convert the upper left corner of the control panel to a global
  856.      *    point for referencing our about dialog.
  857.      */
  858.      
  859.          GetWMgrPort( &winMgrPort );
  860.          GetPort( ¤tPort );
  861.          
  862.          SetPt( &refPt, 0, 0 );
  863.          LocalToGlobal( &refPt );
  864.          refPt.h += 93;        /* move to right over actual panel */
  865.          
  866.     /*    Now, load our dialog resource, move it on top of the control panel,
  867.      *    make it the current port, then make it visible (the resource should
  868.      *    mark the dialog as NOT initially visible.
  869.      */
  870.         
  871.         if ( myData->hasColor )
  872.             aboutDlg = GetNewDialog( kAboutDialogClrID, NULL, (WindowPtr)-1L );
  873.         else
  874.             aboutDlg = GetNewDialog( kAboutDialogBWID, NULL, (WindowPtr)-1L );
  875.         
  876.         /* This is an example - move your about dialog wherever you want */
  877.         
  878.         MoveWindow( aboutDlg, refPt.h, refPt.v, true );
  879.         
  880.         SetPort( aboutDlg );
  881.         
  882.         ShowWindow( aboutDlg );
  883.     
  884.      /*    Get the OK button item and draw a bold border around it to show that
  885.       *    it's the default button.
  886.       */
  887.      
  888.          GetDItem( aboutDlg, kAboutOKButton, &itemType, &itemHandle, &itemRect );
  889.          InsetRect( &itemRect, -4, -4 );
  890.          PenSize( 3, 3 );
  891.          FrameRoundRect( &itemRect, 16, 16 );
  892.          PenSize( 1, 1 );
  893.      
  894.      /*    Loop and call ModalDialog until the user presses the OK button */
  895.      
  896.          ModalDialog( NULL, &itemHit );
  897.          while ( itemHit != kAboutOKButton )
  898.              ModalDialog( NULL, &itemHit );
  899.          
  900.      /*    Now get rid of the dialog and set the port back to the control panel */
  901.      
  902.          DisposDialog( aboutDlg );
  903.          SetPort( currentPort );
  904. }
  905.  
  906. void    DoRestartDialog( void )
  907. {
  908.     /*    This routine displays a dialog that tells the user that changes made
  909.      *    won't take effect until after the computer is restarted.
  910.      */
  911.     
  912.     WindowPtr        winMgrPort;        /* store current window mgr port here */
  913.     WindowPtr        currentPort;    /* store the current port here */
  914.     DialogPtr        theDlg;            /* to store our dialog in */
  915.     
  916.     short        itemType;        /* these 3 local variables are used to */
  917.     Handle        itemHandle;        /* manipulate items in the dialog.     */
  918.     Rect        itemRect;
  919.  
  920.     short        itemHit;        /* use with ModalDialog */
  921.     Point        refPt;            /* a reference point */
  922.     
  923.     /*    Get the window manager port and the current port (our control panel)
  924.      *    Then convert the upper left corner of the control panel to a global
  925.      *    point for referencing our dialog.
  926.      */
  927.      
  928.          GetWMgrPort( &winMgrPort );
  929.          GetPort( ¤tPort );
  930.          
  931.          SetPt( &refPt, 0, 0 );
  932.          LocalToGlobal( &refPt );
  933.          refPt.h += 107;        /* move to right over actual panel */
  934.          refPt.v += 80;        /* also move it down some */
  935.          
  936.     /*    Now, load our dialog resource, move it on top of the control panel,
  937.      *    make it the current port, then make it visible (the resource should
  938.      *    mark the dialog as NOT initially visible.
  939.      */
  940.     
  941.         theDlg = GetNewDialog( kRestartDialogID, NULL, (WindowPtr)-1L );
  942.         
  943.         /* This is an example - move your about dialog wherever you want */
  944.         
  945.         MoveWindow( theDlg, refPt.h, refPt.v, true );
  946.         
  947.         SetPort( theDlg );
  948.         
  949.         SysBeep( 3 );
  950.         ShowWindow( theDlg );
  951.     
  952.      /*    Get the OK button item and draw a bold border around it to show that
  953.       *    it's the default button.
  954.       */
  955.      
  956.          GetDItem( theDlg, kRestartOKButton, &itemType, &itemHandle, &itemRect );
  957.          InsetRect( &itemRect, -4, -4 );
  958.          PenSize( 3, 3 );
  959.          FrameRoundRect( &itemRect, 16, 16 );
  960.          PenSize( 1, 1 );
  961.      
  962.      /*    Loop and call ModalDialog until the user presses the OK button */
  963.      
  964.          ModalDialog( NULL, &itemHit );
  965.          while ( itemHit != kRestartOKButton )
  966.              ModalDialog( NULL, &itemHit );
  967.          
  968.      /*    Now get rid of the dialog and set the port back to the control panel */
  969.      
  970.          DisposDialog( theDlg );
  971.          SetPort( currentPort );
  972. }
  973.  
  974.  
  975. void    DoUnavailDialog( void )
  976. {
  977.     /*    This routine displays a dialog that tells the user that the control
  978.      *    panel cannot be accessed because it needs to be loaded at startup.
  979.      */
  980.     
  981.     WindowPtr        winMgrPort;        /* store current window mgr port here */
  982.     WindowPtr        currentPort;    /* store the current port here */
  983.     DialogPtr        theDlg;            /* to store our dialog in */
  984.     
  985.     short        itemType;        /* these 3 local variables are used to */
  986.     Handle        itemHandle;        /* manipulate items in the dialog.     */
  987.     Rect        itemRect;
  988.  
  989.     short        itemHit;        /* use with ModalDialog */
  990.     Point        refPt;            /* a reference point */
  991.     
  992.     /*    Get the window manager port and the current port (our control panel)
  993.      *    Then convert the upper left corner of the control panel to a global
  994.      *    point for referencing our dialog.
  995.      */
  996.      
  997.          GetWMgrPort( &winMgrPort );
  998.          GetPort( ¤tPort );
  999.          
  1000.          SetPt( &refPt, 0, 0 );
  1001.          LocalToGlobal( &refPt );
  1002.          refPt.h += 107;        /* move to right over actual panel */
  1003.          refPt.v += 80;        /* also move it down some */
  1004.          
  1005.     /*    Now, load our dialog resource, move it on top of the control panel,
  1006.      *    make it the current port, then make it visible (the resource should
  1007.      *    mark the dialog as NOT initially visible.
  1008.      */
  1009.     
  1010.         theDlg = GetNewDialog( kUnavailDialogID, NULL, (WindowPtr)-1L );
  1011.         
  1012.         /* This is an example - move your about dialog wherever you want */
  1013.         
  1014.         MoveWindow( theDlg, refPt.h, refPt.v, true );
  1015.         
  1016.         SetPort( theDlg );
  1017.         
  1018.         SysBeep( 3 );
  1019.         ShowWindow( theDlg );
  1020.     
  1021.      /*    Get the OK button item and draw a bold border around it to show that
  1022.       *    it's the default button.
  1023.       */
  1024.      
  1025.          GetDItem( theDlg, kUnavailOKButton, &itemType, &itemHandle, &itemRect );
  1026.          InsetRect( &itemRect, -4, -4 );
  1027.          PenSize( 3, 3 );
  1028.          FrameRoundRect( &itemRect, 16, 16 );
  1029.          PenSize( 1, 1 );
  1030.      
  1031.      /*    Loop and call ModalDialog until the user presses the OK button */
  1032.      
  1033.          ModalDialog( NULL, &itemHit );
  1034.          while ( itemHit != kUnavailOKButton )
  1035.              ModalDialog( NULL, &itemHit );
  1036.          
  1037.      /*    Now get rid of the dialog and set the port back to the control panel */
  1038.      
  1039.          DisposDialog( theDlg );
  1040.          SetPort( currentPort );
  1041. }
  1042.  
  1043. void    GetSysInformation( myDataPtr myData )
  1044. {
  1045.     SysEnvRec        env;
  1046.             
  1047.     /* Find out if this machine has color QuickDraw and find system vers. */
  1048.     
  1049.         SysEnvirons( 2, &env );
  1050.         
  1051.         myData->hasColor = env.hasColorQD;
  1052.         
  1053.         if ( env.systemVersion >= 0x0700 )
  1054.             myData->sysVersion = 7;
  1055.         else if ( env.systemVersion >= 0x0600 )
  1056.             myData->sysVersion = 6;
  1057.         else
  1058.             myData->sysVersion = 0;    /* we don't care about anything < 6 */
  1059. }
  1060.