home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / System / SmartDragWindow 1.0.1 / SmartDragWindow INIT / Sourcery / SmartDragWindow CDEV.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-18  |  12.0 KB  |  409 lines  |  [TEXT/CWIE]
  1. #include "SmartDragWindow INIT.h"
  2. #include "DialogUtils.h"
  3. #include "SoundUtils.h"
  4.  
  5.  
  6. enum {
  7.     // Dialog item numbers
  8.     kDragPane_SmartDragOnRadio = 1,
  9.     kDragPane_SmartDragOffRadio,
  10.     
  11.     kDragPane_SnapToMonitorCheck,
  12.     kDragPane_SnapToWindowCheck,
  13.     kDragPane_SnapToGridCheck,
  14.     kDragPane_SnapWhenResizingCheck,
  15.     
  16.     kDragPane_SnapDistanceInput,
  17.     kDragPane_SnapGridSizeInput,
  18.     
  19.     kDragPane_WitchBrewBtn
  20. };
  21.  
  22. enum {
  23.     // Maximum snap distance, size grid user can input
  24.     kMaxSnapValue = 80
  25. };
  26.  
  27.  
  28. #define kSmartDragNoINITErr                kSmartDragRsrcID
  29. #define kSmartDragVersionConflictErr    -4034
  30.  
  31.  
  32. #ifdef powerc
  33.         // for Metrowerks' linker, this defines the mixed-mode interface for main().
  34.     ProcInfoType __procinfo = kPascalStackBased
  35.          | RESULT_SIZE(kFourByteCode)
  36.          | STACK_ROUTINE_PARAMETER(1,  SIZE_CODE(sizeof(short)))
  37.          | STACK_ROUTINE_PARAMETER(2,  SIZE_CODE(sizeof(short)))
  38.          | STACK_ROUTINE_PARAMETER(3,  SIZE_CODE(sizeof(short)))
  39.          | STACK_ROUTINE_PARAMETER(4,  SIZE_CODE(sizeof(short)))
  40.          | STACK_ROUTINE_PARAMETER(5,  SIZE_CODE(sizeof(EventRecord *)))
  41.          | STACK_ROUTINE_PARAMETER(6,  SIZE_CODE(sizeof(long)))
  42.          | STACK_ROUTINE_PARAMETER(7,  SIZE_CODE(sizeof(DialogPtr)));
  43. #endif
  44.  
  45. // ---------------------------------------------------------------------------
  46.  
  47. static void SetupPanelItems(DialogPtr CPDialog);
  48. static void CleanupPanelItems(DialogPtr CPDialog);
  49. static void HandlePanelHit(DialogPtr CPDialog, EventRecord *theEvent, short itemHit);
  50. static void HandlePanelKeyDown(DialogPtr CPDialog, EventRecord *theEvent, short itemHit);
  51. static void HandlePanelIdle(DialogPtr CPDialog, EventRecord *theEvent, short itemHit);
  52. static void HandlePanelActivate(DialogPtr CPDialog, short message);
  53.  
  54. // ---------------------------------------------------------------------------
  55.  
  56. static SmartDragGlobals *gINITGlobals;        // Pointer to the INIT's globals
  57. static SmartDragGlobals **gPrefsResource;    // Our prefs resource
  58.  
  59. // ---------------------------------------------------------------------------
  60.  
  61. pascal long main(short message, short Item, short numItems, short CPanelID,
  62.                  EventRecord *theEvent, register long cdevValue, DialogPtr CPDialog) {
  63.     long    oldA4;
  64.     long    versionCheck;
  65.     OSErr    err;
  66.     SelectorFunctionUPP    smartDragGestaltUPP;
  67.  
  68.     // We use globals so we need to use register A4
  69.     oldA4 = SetCurrentA4();
  70.  
  71.     // Adjust item numbers (old vestige from System 6 control panel)
  72.     Item -= numItems;
  73.  
  74.     if (message == initDev) {
  75.         InitSoundUtils();
  76.     
  77.         // Load in prefs
  78.         gPrefsResource = (SmartDragGlobals**)Get1Resource(
  79.             kSmartDragPrefRsrcType, kSmartDragRsrcID);
  80.         if (gPrefsResource == NULL) {
  81.             cdevValue = cdevResErr;
  82.             goto exitPoint;
  83.         }
  84.         
  85.         // Make sure the prefs match our globals
  86.         if (GetHandleSize((Handle)gPrefsResource) != sizeof(SmartDragGlobals)) {
  87.             (void)Alert(kSmartDragVersionConflictErr, NULL);
  88.             cdevValue = cdevGenErr;
  89.             goto exitPoint;
  90.         }
  91.         
  92.         // Contact the INIT - is it loaded?
  93.         err = Gestalt(kSmartDragSignature, (long*)&smartDragGestaltUPP);
  94.         if (err != noErr) {
  95.             (void)Alert(kSmartDragNoINITErr, NULL);
  96.             cdevValue = cdevGenErr;
  97.             goto exitPoint;
  98.         }
  99.         
  100.         // We've gotten here, so it's loaded. Get the INIT's version
  101.         err = CallSelectorFunctionProc(smartDragGestaltUPP,
  102.             gestaltVersion, (long*)&versionCheck);
  103.         if (err != noErr || versionCheck != kSmartDragVersion) {
  104.             (void)Alert(kSmartDragVersionConflictErr, NULL);
  105.             cdevValue = cdevGenErr;
  106.             goto exitPoint;
  107.         }
  108.         
  109.         // Get the address of the INIT's globals so we can update
  110.         // it when the user changes the settings in the control panel.
  111.         err = CallSelectorFunctionProc(smartDragGestaltUPP,
  112.             kGestaltGetSmartDragGlobals, (long*)&gINITGlobals);
  113.         if (err != noErr) {
  114.             cdevValue = cdevGenErr;
  115.             goto exitPoint;
  116.         }
  117.         
  118.         // Setup the dialog items in the control panel
  119.         SetupPanelItems(CPDialog);
  120.         
  121.         // Pass an arbitrary value so subsequent cdev messages know
  122.         // that the initDev message has been handled successfully.
  123.         cdevValue = 237;
  124.     }
  125.     else if (cdevValue == 237) {
  126.         switch(message) {
  127.             case closeDev: {
  128.                 CleanupPanelItems(CPDialog);
  129.             } break;
  130.             
  131.             case hitDev:
  132.                 HandlePanelHit(CPDialog, theEvent, Item);
  133.             break;
  134.             
  135.             case keyEvtDev:
  136.                 HandlePanelKeyDown(CPDialog, theEvent, Item);
  137.             break;
  138.             
  139.             case nulDev: {
  140.                 HandlePanelIdle(CPDialog, theEvent, Item);
  141.             } break;
  142.             
  143.             case activDev:
  144.             case deactivDev: {
  145.                 HandlePanelActivate(CPDialog, message);
  146.             } break;
  147.         }
  148.     }
  149.  
  150. exitPoint:
  151.     SetA4(oldA4);
  152.     return cdevValue;
  153. } // END main entrypoint
  154.  
  155. // ---------------------------------------------------------------------------
  156.  
  157. void SetupPanelItems(DialogPtr CPDialog) {
  158.     Str31    text;
  159.     short    i;
  160.  
  161.     // Setup dialog items
  162.     if ((**gPrefsResource).snapToMonitor) {
  163.         SetDlogCtlValue(CPDialog, kDragPane_SnapToMonitorCheck, 1);
  164.     }
  165.     if ((**gPrefsResource).snapToWindows) {
  166.         SetDlogCtlValue(CPDialog, kDragPane_SnapToWindowCheck, 1);
  167.     }
  168.     if ((**gPrefsResource).snapToGrid) {
  169.         SetDlogCtlValue(CPDialog, kDragPane_SnapToGridCheck, 1);
  170.     }
  171.     if ((**gPrefsResource).snapWhenGrowingWindow) {
  172.         SetDlogCtlValue(CPDialog, kDragPane_SnapWhenResizingCheck, 1);
  173.     }
  174.     NumToString((**gPrefsResource).snapToDistance, text);
  175.     SetDItemText(CPDialog, kDragPane_SnapDistanceInput, text);
  176.     NumToString((**gPrefsResource).snapGridSize, text);
  177.     SetDItemText(CPDialog, kDragPane_SnapGridSizeInput, text);
  178.     if ((**gPrefsResource).smartDragOn) {
  179.         SelectRadioBtn(CPDialog, kDragPane_SmartDragOnRadio,
  180.             kDragPane_SmartDragOnRadio, kDragPane_SmartDragOffRadio);
  181.         for (i = kDragPane_SnapToMonitorCheck;
  182.             i <= kDragPane_SnapWhenResizingCheck; i++)
  183.             HiliteControl((ControlHandle)GetDItemHdl(CPDialog, i), 0);
  184.     }
  185.     else {
  186.         SelectRadioBtn(CPDialog, kDragPane_SmartDragOffRadio,
  187.             kDragPane_SmartDragOnRadio, kDragPane_SmartDragOffRadio);
  188.         for (i = kDragPane_SnapToMonitorCheck;
  189.             i <= kDragPane_SnapWhenResizingCheck; i++)
  190.             HiliteControl((ControlHandle)GetDItemHdl(CPDialog, i), 255);
  191.     }
  192.     SelectDialogItemText(CPDialog, kDragPane_SnapDistanceInput, 0, 32767);
  193.     
  194.     // No support for resize-snapping (yet)
  195.     HiliteControl((ControlHandle)GetDItemHdl(CPDialog,
  196.         kDragPane_SnapWhenResizingCheck), 255);
  197. } // END SetupPanelItems
  198.  
  199. // ---------------------------------------------------------------------------
  200.  
  201. void CleanupPanelItems(DialogPtr CPDialog) {
  202.     long inputNum;
  203.     Str31 text;
  204.     
  205.     if (GetDlogCtlValue(CPDialog, kDragPane_SmartDragOnRadio)) {
  206.         (**gPrefsResource).smartDragOn = true;
  207.     }
  208.     else {
  209.         (**gPrefsResource).smartDragOn = false;
  210.     }
  211.     if (GetDlogCtlValue(CPDialog, kDragPane_SnapToMonitorCheck)) {
  212.         (**gPrefsResource).snapToMonitor = true;
  213.     }
  214.     else {
  215.         (**gPrefsResource).snapToMonitor = false;
  216.     }
  217.     if (GetDlogCtlValue(CPDialog, kDragPane_SnapToWindowCheck)) {
  218.         (**gPrefsResource).snapToWindows = true;
  219.     }
  220.     else {
  221.         (**gPrefsResource).snapToWindows = false;
  222.     }
  223.     if (GetDlogCtlValue(CPDialog, kDragPane_SnapToGridCheck)) {
  224.         (**gPrefsResource).snapToGrid = true;
  225.     }
  226.     else {
  227.         (**gPrefsResource).snapToGrid = false;
  228.     }
  229.     if (GetDlogCtlValue(CPDialog, kDragPane_SnapWhenResizingCheck)) {
  230.         (**gPrefsResource).snapWhenGrowingWindow = true;
  231.     }
  232.     else {
  233.         (**gPrefsResource).snapWhenGrowingWindow = false;
  234.     }
  235.     
  236.     GetDialogItemText(GetDItemHdl(CPDialog, kDragPane_SnapDistanceInput), text);
  237.     if (text[0] == 0) {
  238.         inputNum = 10;
  239.         NumToString(inputNum, text);
  240.         SetDItemText(CPDialog, kDragPane_SnapDistanceInput, text);
  241.     }
  242.     else
  243.         StringToNum(text, &inputNum);
  244.     (**gPrefsResource).snapToDistance = inputNum;
  245.     GetDialogItemText(GetDItemHdl(CPDialog, kDragPane_SnapGridSizeInput), text);
  246.     if (text[0] == 0) {
  247.         inputNum = 10;
  248.         NumToString(inputNum, text);
  249.         SetDItemText(CPDialog, kDragPane_SnapGridSizeInput, text);
  250.     }
  251.     else
  252.         StringToNum(text, &inputNum);
  253.     (**gPrefsResource).snapGridSize = inputNum;
  254.  
  255.     // Update INIT's globals
  256.     *gINITGlobals = **gPrefsResource;
  257.     ChangedResource((Handle)gPrefsResource);
  258.     WriteResource((Handle)gPrefsResource);
  259. } // END CleanupPanelItems
  260.  
  261. // ---------------------------------------------------------------------------
  262.  
  263. void HandlePanelHit(DialogPtr CPDialog, EventRecord *theEvent, short itemHit) {
  264.     short i;
  265.  
  266.     switch(itemHit) {
  267.         case kDragPane_SmartDragOnRadio:
  268.         case kDragPane_SmartDragOffRadio: {
  269.             short hiliteMode;
  270.             SelectRadioBtn(CPDialog, itemHit,
  271.                 kDragPane_SmartDragOnRadio, kDragPane_SmartDragOffRadio);
  272.             if (GetDlogCtlValue(CPDialog, kDragPane_SmartDragOnRadio)) {
  273.                 hiliteMode = 0;
  274.                 SetDlogCtlValue(CPDialog, kDragPane_SnapToMonitorCheck, 1);
  275.             }
  276.             else
  277.                 hiliteMode = 255;
  278.             // No support for resizing-snapping (yet)
  279.             for (i = kDragPane_SnapToMonitorCheck;
  280.                 i <= kDragPane_SnapToGridCheck; i++)
  281.                 HiliteControl((ControlHandle)GetDItemHdl(CPDialog, i), hiliteMode);
  282.         } break;
  283.         
  284.         case kDragPane_SnapToMonitorCheck:
  285.         case kDragPane_SnapToWindowCheck:
  286.         case kDragPane_SnapToGridCheck:
  287.             FlipCtlValue(CPDialog, itemHit);
  288.             if (!GetDlogCtlValue(CPDialog, kDragPane_SnapToMonitorCheck) &&
  289.                 !GetDlogCtlValue(CPDialog, kDragPane_SnapToWindowCheck) &&
  290.                 !GetDlogCtlValue(CPDialog, kDragPane_SnapToGridCheck)) {
  291.                 SelectRadioBtn(CPDialog, kDragPane_SmartDragOffRadio,
  292.                     kDragPane_SmartDragOnRadio, kDragPane_SmartDragOffRadio);
  293.                 for (i = kDragPane_SnapToMonitorCheck;
  294.                     i <= kDragPane_SnapToGridCheck; i++)
  295.                     HiliteControl((ControlHandle)GetDItemHdl(CPDialog, i), 255);
  296.             }
  297.         break;
  298.  
  299.         case kDragPane_SnapWhenResizingCheck:
  300.             FlipCtlValue(CPDialog, itemHit);
  301.         break;
  302.         
  303.         case kDragPane_WitchBrewBtn: {
  304.             Handle witchSnd;
  305.             witchSnd = Get1Resource('SND!', 1972);
  306.             if (CreateSndChannel(0) == noErr) {
  307.                 PlayAsynch(witchSnd, 0);
  308.                 WaitTillSndDone(0);
  309.                 DisposeSndChannel(0);
  310.             }
  311.             HUnlock(witchSnd);
  312.             ReleaseResource(witchSnd);
  313.         } break;
  314.     }
  315.     
  316.     // Update INIT instantly
  317.     if (itemHit >= kDragPane_SmartDragOnRadio &&
  318.         itemHit <= kDragPane_SnapGridSizeInput)
  319.         CleanupPanelItems(CPDialog);
  320. } // END HandlePanelHit
  321.  
  322. // ---------------------------------------------------------------------------
  323.  
  324. enum {
  325.     kReturn_Key = 13,
  326.  
  327.     kDelete_Key = (char)8,
  328.     kTab_Key,
  329.     
  330.     kEscape_Key = (char)27,
  331.     kLeftArrow_Key,
  332.     kRightArrow_Key,
  333.     kUpArrow_Key,
  334.     kDownArrow_Key
  335.     
  336. };
  337.  
  338. void HandlePanelKeyDown(DialogPtr CPDialog, EventRecord *theEvent, short itemHit) {
  339.     char theKey = theEvent->message & charCodeMask;
  340.  
  341.     if ((theKey >= '0' && theKey <= '9') || theKey == kDelete_Key) {
  342.     }
  343.     else if (theKey == kTab_Key) {
  344.     }
  345.     else if (theKey == kLeftArrow_Key || theKey == kRightArrow_Key) {
  346.     }
  347.     else {
  348.         SysBeep(10);
  349.         theEvent->what = nullEvent;
  350.     }
  351. } // END HandlePanelKeyDown
  352.  
  353. // ---------------------------------------------------------------------------
  354.  
  355. void HandlePanelIdle(DialogPtr CPDialog, EventRecord *theEvent, short itemHit) {
  356.     // Make sure edit text items contain valid input
  357.     Str31 text;
  358.     long inputNum;
  359.  
  360.     GetDialogItemText(GetDItemHdl(CPDialog, kDragPane_SnapDistanceInput), text);
  361.     if (text[0] != 0) {
  362.         StringToNum(text, &inputNum);
  363.         if (inputNum > kMaxSnapValue) {
  364.             inputNum = kMaxSnapValue;
  365.             NumToString(inputNum, text);
  366.             SetDItemText(CPDialog, kDragPane_SnapDistanceInput, text);
  367.         }
  368.         if (inputNum != (**gPrefsResource).snapToDistance) {
  369.             (**gPrefsResource).snapToDistance = inputNum;
  370.             *gINITGlobals = **gPrefsResource;
  371.         }
  372.     }
  373.  
  374.     GetDialogItemText(GetDItemHdl(CPDialog, kDragPane_SnapGridSizeInput), text);
  375.     if (text[0] != 0) {
  376.         StringToNum(text, &inputNum);
  377.         if (inputNum > kMaxSnapValue) {
  378.             inputNum = kMaxSnapValue;
  379.             NumToString(inputNum, text);
  380.             SetDItemText(CPDialog, kDragPane_SnapGridSizeInput, text);
  381.         }
  382.         if (inputNum != (**gPrefsResource).snapGridSize) {
  383.             (**gPrefsResource).snapGridSize = inputNum;
  384.             *gINITGlobals = **gPrefsResource;
  385.         }
  386.     }
  387. } // END HandlePanelIdle
  388.  
  389. // ---------------------------------------------------------------------------
  390.  
  391. void HandlePanelActivate(DialogPtr CPDialog, short message) {
  392.     short i, hiliteMode;
  393.  
  394.     if (message == activDev)
  395.         hiliteMode = 0;
  396.     else
  397.         hiliteMode = 255;
  398.  
  399.     for (i = kDragPane_SmartDragOnRadio;
  400.         i <= kDragPane_SmartDragOffRadio; i++)
  401.         HiliteControl((ControlHandle)GetDItemHdl(CPDialog, i), hiliteMode);
  402.  
  403.     if ((message == activDev && (**gPrefsResource).smartDragOn) ||
  404.         message == deactivDev) {
  405.         for (i = kDragPane_SnapToMonitorCheck;
  406.             i <= kDragPane_SnapToGridCheck; i++)
  407.             HiliteControl((ControlHandle)GetDItemHdl(CPDialog, i), hiliteMode);
  408.     }
  409. } // END HanelPanelActivate