home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1994 November / macformat-018.iso / Utility Spectacular / Developer / macgzip_022-src / macos / think / ThePrefs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-26  |  19.3 KB  |  661 lines  |  [TEXT/KAHL]
  1. /*            SpinCursors by
  2.  *            America Online: LISPer
  3.  *             Internet: tree@uvm.edu
  4. */
  5. #ifndef _FOLDERS_
  6. #include <Folders.h>
  7. #endif
  8. #include <Script.h>
  9. #include <Balloons.h>
  10.  
  11. #include "ThePrefs.h"
  12. #include "MacErrors.h"
  13. #include "PopUp.h"
  14.  
  15.  
  16. /************************************************************************************/
  17.  
  18. #define kPrefsDialogID        130
  19. #define kSaveButtonItem        1
  20. #define kCancelButtonItem    2
  21.  
  22. #define    kKeepOrig            16
  23. #define kBeepWD                14
  24. #define kQuitWD                5
  25.  
  26. #define kForce                7
  27. #define    kBHelp                8
  28. #define kHelp                15
  29.  
  30. #define kCStKeys            26
  31. #define kUStKeys            27
  32. #define    kAltStKeys            30
  33.  
  34. #define kTEXTsuffix            3
  35. #define kTEXTcreator        4
  36. #define kTEXTbcreator        23
  37. #define kTEXTbtype            28
  38.  
  39. #define kTEXTlevel            10
  40.  
  41. #define kUpArrow            11
  42. #define kDownArrow            12
  43.  
  44. #define    kAsciiGzip            17
  45. #define    kAsciiGunzip        18
  46. #define    kGzip                19
  47.  
  48.  
  49. #define    kAsciiGzipMenu        128
  50. #define    kAsciiGunzipMenu    129
  51. #define    kGzipMenu            130
  52.  
  53. /* prefs file constants */
  54. #define kPrefsNameStrID            128
  55. #define kPrefsCreatorType        '\?\?\?\?'
  56. #define kPrefsFileType            'pref'
  57. #define kPrefsResourceType        'Pref'
  58. #define kPrefsResourceID        128
  59.  
  60. #define kFetchPrefsNameStrID    129
  61. #define kFetchPrefsResourceType    'SUFX'
  62. #define kFetchPrefsResourceID    1
  63.  
  64. #define kFinderMessageStrID    -16397 /* ID of STR for default finder message */
  65.                                    /* see Inside Mac VI, page 9-22         */
  66. #define kStrType            'STR '
  67.  
  68. #define CmdKeyMask            0x0100
  69.  
  70. /*
  71.  * From DialogBits,C.K. Haun
  72.  * Apple Developer Tech Support
  73.  */
  74.  
  75.  /* key equates */
  76. enum  {
  77.     kEnterKey        = 0x03, 
  78.     kTabKey            = 9, 
  79.     kReturnKey        = 0x0D, 
  80.     kBackSpace        = 8, 
  81.     kEscKey            = 0x1B, 
  82.     kLeftArrowKey    = 0x1C, 
  83.     kRightArrowKey, 
  84.     kUpArrowKey,
  85.     kDownArrowKey, 
  86.     kDeleteKey        = 0x7F
  87. };
  88.  
  89. pascal Boolean filterIt(DialogPtr inputDialog, EventRecord *myDialogEvent, short *theDialogItem);
  90.  
  91. pascal OSErr GetStdFilterProc(ModalFilterProcPtr *theProc) = 
  92. {
  93.     0x303C, 0x0203, 0xAA68
  94. };
  95.  
  96. /* Indicates to the dialog manager which item is default.  Will then alias the return key */
  97. /* to this item, and also bold border it for you (yaaaaa!) */
  98. pascal OSErr SetDialogDefaultItem(DialogPtr theDialog, short newItem)
  99. = 
  100. {
  101.     0x303C, 0x0304, 0xAA68
  102. };
  103.  
  104. /* Indicates which item should be aliased to escape or Command - . */
  105. pascal OSErr SetDialogCancelItem(DialogPtr theDialog, short newItem)
  106. = 
  107. {
  108.     0x303C, 0x0305, 0xAA68
  109. };
  110. /* End From DialogBits */
  111.  
  112. /* these constants may be stored in the fields of the prefs struct */
  113.  
  114. OSErr GetPrefsName (StringPtr prefName, short StrID);
  115.  
  116. PrefsType    currPrefs;
  117. Boolean        prefsChangedFlag;
  118.  
  119. Handle        FPrefs;
  120. Size        FPrefsSize=0;
  121.  
  122.  
  123.  
  124. short OpenPrefsResFile(SignedByte prefsPerm, Boolean createFlag, short StrID)
  125. /* open the preferences file with the given permission; if createFlag is set,
  126.    create a preferences file if necessary */
  127. {
  128.     OSErr retCode;
  129.     short prefsVRefNum;
  130.     long prefsDirID;
  131.     Str255 prefsNameStr;
  132.     FSSpec prefsFSSpec;
  133.     short prefsResRefNum;
  134.     
  135.     prefsResRefNum = -1;
  136.     /* get the name of the prefs file */
  137.     retCode = GetPrefsName(prefsNameStr, StrID);
  138.     if (retCode == noErr) {
  139.     
  140.         /* Use FindFolder to locate the Preferences folder.
  141.         
  142.            MPW 3.2 and some other compilers provide the
  143.            glue necessary to use FindFolder (and Gestalt) safely
  144.            under System 6 and earlier.  Under System 6, the dirID
  145.            returned for the Preferences folder request will be
  146.            the System folder's dirID */
  147.  
  148.         retCode = FindFolder(kOnSystemDisk, kPreferencesFolderType, kCreateFolder,
  149.             &prefsVRefNum, &prefsDirID);
  150.         if (retCode == noErr) {
  151.         
  152.             /* make a file spec for the prefs file */
  153.             
  154.             retCode = FSMakeFSSpec(prefsVRefNum, prefsDirID, prefsNameStr,
  155.                 &prefsFSSpec);
  156.                 
  157.             if (retCode == fnfErr && createFlag) {
  158.                 /* prefs file doesn't already exist, so create it */
  159.                 FSpCreateResFile(&prefsFSSpec, kPrefsCreatorType, kPrefsFileType,
  160.                     smSystemScript);
  161.                 retCode = ResError();
  162.             }
  163.             
  164.             /* open the prefs file */
  165.             if (retCode == noErr) {
  166.                 prefsResRefNum = FSpOpenResFile(&prefsFSSpec, prefsPerm);
  167.             }
  168.         }
  169.     }
  170.     return prefsResRefNum;
  171. }
  172.  
  173. OSErr GetPrefsName (StringPtr prefName, short StrID)
  174. /* get the name of the preferences file from a resource in the application */
  175. {
  176.     StringHandle prefStrHandle;
  177.     OSErr retCode = noErr;
  178.     
  179.     prefStrHandle = GetString(StrID);
  180.     if (prefStrHandle != nil) 
  181.         BlockMove(*prefStrHandle, prefName, (Size) (**prefStrHandle) + 1);
  182.     else retCode = resNotFound;
  183.     
  184.     return retCode;
  185. }
  186.  
  187. Boolean GetOrGeneratePrefs( PrefsType * thePrefsTypePtr, long wantedVers )
  188. /* fill in the prefs structure from the resource file or from scratch */
  189. {
  190.     short                prefsResRefNum;
  191.     Handle                tempHandle;
  192.     extern    Boolean        gSavedPos;
  193.     extern    Point        gSavedPoint;
  194.     
  195.     /* initialize prefs structure in case we can't get a valid set */
  196.     thePrefsTypePtr->prefsTypeVers =        wantedVers;
  197.     thePrefsTypePtr->compress =                false;
  198.     thePrefsTypePtr->ascii =                false;
  199.     thePrefsTypePtr->force =                false;
  200.     thePrefsTypePtr->level =                6;
  201.     thePrefsTypePtr->suffix[0] =            0x00;
  202.     BlockMove("\pttxt", thePrefsTypePtr->textcreator, 5);
  203.     BlockMove("\p\?\?\?\?", thePrefsTypePtr->bincreator, 5);
  204.     BlockMove("\p\?\?\?\?", thePrefsTypePtr->bintype, 5);
  205.     thePrefsTypePtr->KeepOriginals =        false;
  206.     thePrefsTypePtr->QuitWhenDone =            true;
  207.     thePrefsTypePtr->BeepWhenDone =            false;
  208.  
  209.     thePrefsTypePtr->AsciiCompress =        OnlyText;
  210.     thePrefsTypePtr->AsciiUnCompress =        UseMenu;
  211.     thePrefsTypePtr->ResourceCompress =        Ask;
  212.     thePrefsTypePtr->WhenCompress =            NonMacGzip;
  213.  
  214.     thePrefsTypePtr->DecodeHQX =    false;
  215.     thePrefsTypePtr->StKeysComp =    true;
  216.     thePrefsTypePtr->StKeysUnComp =    true;
  217.     thePrefsTypePtr->StKeysAlt =     true;
  218.  
  219.     thePrefsTypePtr->SavedPos = false;
  220.     thePrefsTypePtr->SavedPoint.h = 0;
  221.     thePrefsTypePtr->SavedPoint.v = 0;
  222.     
  223.     
  224.     /* open (but don't create) the prefs file */
  225.     prefsResRefNum = OpenPrefsResFile(fsRdPerm, false, kPrefsNameStrID);
  226.     if (prefsResRefNum != -1) {
  227.     
  228.         /* file opened successfully, get the prefs resource */
  229.         tempHandle = Get1Resource(kPrefsResourceType, kPrefsResourceID);
  230.         
  231.         /* if the resource is there and it's the right size and version, copy it */
  232.         /* (in C these can be combined with &&, but don't use AND in Pascal)     */
  233.         
  234.         if (tempHandle != nil)
  235.             if (GetHandleSize(tempHandle) == sizeof(PrefsType)) 
  236.                 if ((*(PrefsType *)*tempHandle).prefsTypeVers == wantedVers) {
  237.                 
  238.                     /* copy the prefs struct */
  239.                     *thePrefsTypePtr = *(PrefsType *)*tempHandle;
  240.                     
  241.                 }
  242.         /* release the pref resource and close the file */
  243.         CloseResFile(prefsResRefNum);
  244.         
  245.     /* Get Fetch Prefs */
  246.     if( thePrefsTypePtr->AsciiUnCompress == Fetch )
  247.     {
  248.     if((prefsResRefNum = OpenPrefsResFile(fsRdPerm, false, kFetchPrefsNameStrID))!=-1)
  249.         {
  250.             tempHandle = GetResource('SUFX',1);
  251.             FPrefs = tempHandle;
  252.             HandToHand( &FPrefs );
  253.             FPrefsSize = GetHandleSize(FPrefs);
  254.             ReleaseResource( tempHandle );
  255.             CloseResFile(prefsResRefNum);
  256.         }
  257.         else
  258.         {
  259.             /* Fetch Prefs not found; set to menu */
  260.             Calert("Warning: 'Fetch Prefs' not found. Check your Prefs. folder");
  261.             thePrefsTypePtr->AsciiUnCompress = UseMenu;
  262.         }
  263.     }
  264.     
  265.         gSavedPos = thePrefsTypePtr->SavedPos;
  266.         gSavedPoint.h = thePrefsTypePtr->SavedPoint.h;
  267.         gSavedPoint.v = thePrefsTypePtr->SavedPoint.v;
  268.  
  269.     return true;
  270.     
  271.     }
  272.     else
  273.         return false;
  274. }
  275. OSErr SavePrefs(PrefsType * thePrefsTypePtr )
  276. /* save the prefs structure in the prefs resource file */
  277. {
  278.     OSErr retCode;
  279.     short prefsResRefNum;
  280.     Handle prefHandle, finderMessageHandle;
  281.     
  282.     /* open (and, if necessary, create) the prefs file */
  283.     prefsResRefNum = OpenPrefsResFile(fsRdWrPerm, true, kPrefsNameStrID);
  284.     if (prefsResRefNum != -1) {
  285.     
  286.         /* file opened successfully, get the prefs resource */
  287.         prefHandle = Get1Resource(kPrefsResourceType, kPrefsResourceID);
  288.         
  289.         if (prefHandle == nil) {
  290.         
  291.             /* create a new resource */
  292.             prefHandle = NewHandle(sizeof(PrefsType));
  293.             if (prefHandle != nil) {
  294.             
  295.                 /* copy the prefs struct into the handle
  296.                    and make it into a resource */
  297.                 
  298.                 *(PrefsType *)*prefHandle = *thePrefsTypePtr;
  299.                 AddResource(prefHandle, kPrefsResourceType, kPrefsResourceID, 
  300.                     "\pPrefsType");
  301.                 retCode = ResError();
  302.                 if (retCode != noErr) DisposHandle(prefHandle);
  303.             } 
  304.             
  305.             else retCode = MemError(); /* NewHandle failed */
  306.         }
  307.         
  308.         else {  /* prefHandle != nil */
  309.         
  310.             /* update the existing resource */
  311.             SetHandleSize(prefHandle, sizeof(PrefsType));
  312.             retCode = MemError();
  313.             if (retCode == noErr) {
  314.  
  315.                 /* copy the prefs struct into the handle and tell the rsrc manager */
  316.                 *(PrefsType *)*prefHandle = *thePrefsTypePtr;
  317.                 ChangedResource(prefHandle);
  318.             }
  319.         }
  320.         if (retCode == noErr) {
  321.         
  322.             /* add the message to be displayed if the user tries
  323.                to open the prefs file in the Finder (but don't add it
  324.                if it's already in the preferences file) */
  325.                
  326.             finderMessageHandle = (Handle) GetString(kFinderMessageStrID);
  327.             if (finderMessageHandle != nil &&
  328.                 HomeResFile((Handle) finderMessageHandle) != prefsResRefNum) {
  329.             
  330.                 /* copy the resource into the prefs file */
  331.                 DetachResource(finderMessageHandle);
  332.                 AddResource(finderMessageHandle, kStrType, kFinderMessageStrID,
  333.                     "\pFinder message");
  334.                     
  335.                 /* if AddResource failed, dispose of the handle */
  336.                 retCode = ResError();
  337.                 if (retCode != noErr) DisposHandle(finderMessageHandle);
  338.             }
  339.         }
  340.         
  341.         /* update and close the preference resource file, 
  342.            releasing its resources from memory */
  343.         CloseResFile(prefsResRefNum);
  344.     }
  345.     
  346.     else {
  347.         /* couldn't open the res file */
  348.         retCode = ResError();
  349.         if (retCode == noErr) retCode = resFNotFound;
  350.     }
  351.     
  352.     return retCode;
  353. }
  354. /***********************Dialog*************/
  355. Boolean DoPrefsDialog(PrefsType * thePrefsTypePtr)
  356. /* display the prefs dialog; returns true if change made to prefs record */
  357. {
  358.     GrafPtr savePort;
  359.     DialogPtr prefDialogPtr;
  360.     short item;
  361.     Boolean doneFlag = false;
  362.     Boolean    SaveBalloons;
  363.     OSErr retCode;
  364.  
  365.     /* keep the new preference settings only in local variables
  366.        in case the user cancels */
  367.        
  368.     PrefsType newPrefsType;
  369.  
  370.     short        itemType;
  371.     Handle        itemHandle;
  372.     Rect        itemRect;
  373.     Str255        sTemp;
  374.     
  375.     Boolean changedFlag;
  376.  
  377.  
  378.     /* the old settings are our starting point, so copy them */
  379.     newPrefsType = *thePrefsTypePtr;
  380.     
  381.     /* throw up the dialog */
  382.     prefDialogPtr = GetNewDialog(kPrefsDialogID, nil, (WindowPtr) -1);
  383.     if (prefDialogPtr == nil) ExitToShell();  /* hurtin’ bad */
  384.     
  385.     SetDialogDefaultItem( prefDialogPtr, kSaveButtonItem);
  386.     SetDialogCancelItem( prefDialogPtr, kCancelButtonItem);
  387.  
  388.     /* set up the dialog to the initial values */
  389.     SaveBalloons = HMGetBalloons();
  390.  
  391.     GetDItem(prefDialogPtr, kForce, &itemType, &itemHandle, &itemRect);
  392.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.force ? 1 : 0));
  393.  
  394.     GetDItem(prefDialogPtr,kTEXTlevel, &itemType, &itemHandle, &itemRect);
  395.     NumToString( (long)thePrefsTypePtr->level, sTemp );
  396.     SetIText(itemHandle,sTemp);
  397.  
  398.  
  399.  
  400.     GetDItem(prefDialogPtr, kTEXTsuffix, &itemType, &itemHandle, &itemRect);
  401.     SetIText(itemHandle,thePrefsTypePtr->suffix);
  402.  
  403.     
  404.     
  405.     GetDItem(prefDialogPtr, kTEXTcreator, &itemType, &itemHandle, &itemRect);
  406.     SetIText(itemHandle,thePrefsTypePtr->textcreator);
  407.     
  408.     GetDItem(prefDialogPtr, kTEXTbcreator, &itemType, &itemHandle, &itemRect);
  409.     SetIText(itemHandle,thePrefsTypePtr->bincreator);
  410.  
  411.     GetDItem(prefDialogPtr, kTEXTbtype, &itemType, &itemHandle, &itemRect);
  412.     SetIText(itemHandle,thePrefsTypePtr->bintype);
  413.  
  414.     SelIText(prefDialogPtr, kTEXTbcreator, 0, 32767);
  415.  
  416.     GetDItem(prefDialogPtr, kKeepOrig, &itemType, &itemHandle, &itemRect);
  417.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.KeepOriginals ? 1 : 0));
  418.  
  419.     GetDItem(prefDialogPtr, kBeepWD, &itemType, &itemHandle, &itemRect);
  420.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.BeepWhenDone ? 1 : 0));
  421.  
  422.     GetDItem(prefDialogPtr, kQuitWD, &itemType, &itemHandle, &itemRect);
  423.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.QuitWhenDone ? 1 : 0));
  424.  
  425.  
  426.     GetDItem(prefDialogPtr, kAsciiGzip, &itemType, &itemHandle, &itemRect);
  427.     PopUp[kAsciiGzip-PopUpBaseItem].MenuRect = itemRect;
  428.     PopUp[kAsciiGzip-PopUpBaseItem].MenuID = kAsciiGzipMenu;
  429.     PopUp[kAsciiGzip-PopUpBaseItem].Menu = GetMenu(kAsciiGzipMenu);
  430.     PopUp[kAsciiGzip-PopUpBaseItem].Selection = newPrefsType.AsciiCompress;
  431.     SetItemMark(PopUp[kAsciiGzip-PopUpBaseItem].Menu,PopUp[kAsciiGzip-PopUpBaseItem].Selection,checkMark);
  432.     SetDItem(prefDialogPtr, kAsciiGzip, itemType, &DrawPopUp, &itemRect);
  433.  
  434.     GetDItem(prefDialogPtr, kAsciiGunzip, &itemType, &itemHandle, &itemRect);
  435.     PopUp[kAsciiGunzip-PopUpBaseItem].MenuRect = itemRect;
  436.     PopUp[kAsciiGunzip-PopUpBaseItem].MenuID = kAsciiGunzipMenu;
  437.     PopUp[kAsciiGunzip-PopUpBaseItem].Menu = GetMenu(kAsciiGunzipMenu);
  438.     PopUp[kAsciiGunzip-PopUpBaseItem].Selection = newPrefsType.AsciiUnCompress;
  439.     SetItemMark(PopUp[kAsciiGunzip-PopUpBaseItem].Menu,PopUp[kAsciiGunzip-PopUpBaseItem].Selection,checkMark);
  440.     SetDItem(prefDialogPtr, kAsciiGunzip, itemType, &DrawPopUp, &itemRect);
  441.  
  442.     GetDItem(prefDialogPtr, kGzip, &itemType, &itemHandle, &itemRect);
  443.     PopUp[kGzip-PopUpBaseItem].MenuRect = itemRect;
  444.     PopUp[kGzip-PopUpBaseItem].MenuID = kGzipMenu;
  445.     PopUp[kGzip-PopUpBaseItem].Menu = GetMenu(kGzipMenu);
  446.     PopUp[kGzip-PopUpBaseItem].Selection = newPrefsType.WhenCompress;
  447.     SetItemMark(PopUp[kGzip-PopUpBaseItem].Menu,PopUp[kGzip-PopUpBaseItem].Selection,checkMark);
  448.     SetDItem(prefDialogPtr, kGzip, itemType, &DrawPopUp, &itemRect);
  449.  
  450.     GetDItem(prefDialogPtr, kCStKeys, &itemType, &itemHandle, &itemRect);
  451.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.StKeysComp ? 1 : 0));
  452.     
  453.     GetDItem(prefDialogPtr, kUStKeys, &itemType, &itemHandle, &itemRect);
  454.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.StKeysUnComp ? 1 : 0));
  455.     
  456.     GetDItem(prefDialogPtr, kAltStKeys, &itemType, &itemHandle, &itemRect);
  457.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.StKeysAlt ? 1 : 0));
  458.  
  459.     GetDItem(prefDialogPtr, kHelp, &itemType, &itemHandle, &itemRect);
  460.     SetCtlValue((ControlHandle) itemHandle, SaveBalloons);
  461.  
  462.     do {
  463.         GetPort(&savePort);
  464.         SetPort(prefDialogPtr);
  465.  
  466.         ModalDialog((ModalFilterProcPtr)filterIt, &item);
  467.         switch(item) {
  468.         
  469.             
  470.             case kSaveButtonItem:
  471.                 /* user wants to save the current or new settings */
  472.                 
  473.                 /* copy the editText string into the new prefs record */
  474.                 GetDItem(prefDialogPtr, kTEXTcreator, &itemType, &itemHandle, &itemRect);
  475.                 GetIText(itemHandle, newPrefsType.textcreator);
  476.                 
  477.                 GetDItem(prefDialogPtr, kTEXTbcreator, &itemType, &itemHandle, &itemRect);
  478.                 GetIText(itemHandle, newPrefsType.bincreator);
  479.                 
  480.                 GetDItem(prefDialogPtr, kTEXTbtype, &itemType, &itemHandle, &itemRect);
  481.                 GetIText(itemHandle, newPrefsType.bintype);
  482.  
  483.                 GetDItem(prefDialogPtr, kTEXTsuffix, &itemType, &itemHandle, &itemRect);
  484.                 GetIText(itemHandle, newPrefsType.suffix);
  485.                 
  486.                 if(newPrefsType.textcreator[0]!=0x04)
  487.                 {
  488.                     Calert( "Text creator not valid (Only 4 chars!)" );
  489.                     SelIText(prefDialogPtr, kTEXTcreator, 0, 32767);
  490.                 }
  491.                 else if (newPrefsType.bincreator[0]!=0x04)
  492.                 {
  493.                     Calert( "Binary creator not valid (Only 4 chars!)" );
  494.                     SelIText(prefDialogPtr, kTEXTbcreator, 0, 32767);
  495.                 }
  496.                 else if (newPrefsType.bintype[0]!=0x04)
  497.                 {
  498.                     Calert( "Binary type not valid (Only 4 chars!)" );
  499.                     SelIText(prefDialogPtr, kTEXTbtype, 0, 32767);
  500.                 }
  501.                 else
  502.                 {
  503.                         /* replace the old record with the new record */
  504.                         
  505.                         newPrefsType.AsciiCompress = PopUp[kAsciiGzip-PopUpBaseItem].Selection;
  506.                         newPrefsType.AsciiUnCompress = PopUp[kAsciiGunzip-PopUpBaseItem].Selection;
  507.                         newPrefsType.WhenCompress = PopUp[kGzip-PopUpBaseItem].Selection;
  508.                         
  509.                         *thePrefsTypePtr = newPrefsType;
  510.                         doneFlag = true;
  511.                 }
  512.                 
  513.                 if (( FPrefsSize==0) && (newPrefsType.AsciiUnCompress==Fetch))
  514.                 {
  515.                     Calert("You must restart MacGzip for your changes to take effect");
  516.                 }
  517.                 break;
  518.                 
  519.             case kCancelButtonItem:
  520.                 /* abandon the new preferences structure */
  521.                 doneFlag = true;
  522.                 break;
  523.                 
  524.             case kForce:
  525.             
  526.                 newPrefsType.force = !newPrefsType.force;
  527.                 GetDItem(prefDialogPtr, kForce, &itemType, &itemHandle, &itemRect);
  528.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.force ? 1 : 0));
  529.                 break;
  530.                 
  531.             case kUpArrow:
  532.             
  533.                 if ( newPrefsType.level < 9 )
  534.                 {
  535.                     newPrefsType.level++;
  536.                     GetDItem(prefDialogPtr,kUpArrow, &itemType, &itemHandle, &itemRect);
  537.                     InvertRect(&itemRect);
  538.                     while (StillDown())
  539.                     ;
  540.                     InvertRect(&itemRect);
  541.                     GetDItem(prefDialogPtr,kTEXTlevel, &itemType, &itemHandle, &itemRect);
  542.                     NumToString( (long)newPrefsType.level, sTemp );
  543.                     SetIText(itemHandle,sTemp);
  544.                 }
  545.                 break;
  546.                 
  547.             case kDownArrow:
  548.             
  549.                 if ( newPrefsType.level > 1 )
  550.                 {
  551.                     newPrefsType.level--;
  552.                     GetDItem(prefDialogPtr,kDownArrow, &itemType, &itemHandle, &itemRect);
  553.                     InvertRect(&itemRect);
  554.                     while (StillDown())
  555.                     ;
  556.                     InvertRect(&itemRect);
  557.                     GetDItem(prefDialogPtr,kTEXTlevel, &itemType, &itemHandle, &itemRect);
  558.                     NumToString( (long)newPrefsType.level, sTemp );
  559.                     SetIText(itemHandle,sTemp);
  560.                 }
  561.                 break;
  562.                 
  563.             case kKeepOrig:
  564.             
  565.                 newPrefsType.KeepOriginals = !newPrefsType.KeepOriginals;
  566.                 GetDItem(prefDialogPtr, kKeepOrig, &itemType, &itemHandle, &itemRect);
  567.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.KeepOriginals ? 1 : 0));
  568.                 break;
  569.  
  570.             case kQuitWD:
  571.             
  572.                 newPrefsType.QuitWhenDone = !newPrefsType.QuitWhenDone;
  573.                 GetDItem(prefDialogPtr, kQuitWD, &itemType, &itemHandle, &itemRect);
  574.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.QuitWhenDone ? 1 : 0));
  575.                 break;
  576.                 
  577.             case kBeepWD:
  578.             
  579.                 newPrefsType.BeepWhenDone = !newPrefsType.BeepWhenDone;
  580.                 GetDItem(prefDialogPtr, kBeepWD, &itemType, &itemHandle, &itemRect);
  581.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.BeepWhenDone ? 1 : 0));
  582.                 break;
  583.                 
  584.             case kAsciiGzip:
  585.             case kAsciiGunzip:
  586.             case kGzip:
  587.             
  588.                 DoPopUp(prefDialogPtr, item);
  589.                 break;
  590.             
  591.             case kCStKeys:
  592.             
  593.                 newPrefsType.StKeysComp = !newPrefsType.StKeysComp;
  594.                 GetDItem(prefDialogPtr, kCStKeys, &itemType, &itemHandle, &itemRect);
  595.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.StKeysComp ? 1 : 0));
  596.                 break;
  597.                 
  598.             case kUStKeys:
  599.             
  600.                 newPrefsType.StKeysUnComp = !newPrefsType.StKeysUnComp;
  601.                 GetDItem(prefDialogPtr, kUStKeys, &itemType, &itemHandle, &itemRect);
  602.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.StKeysUnComp ? 1 : 0));
  603.                 break;
  604.  
  605.             case kAltStKeys:
  606.             
  607.                 newPrefsType.StKeysAlt = !newPrefsType.StKeysAlt;
  608.                 GetDItem(prefDialogPtr, kAltStKeys, &itemType, &itemHandle, &itemRect);
  609.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.StKeysAlt ? 1 : 0));
  610.                 break;
  611.  
  612.             case kHelp:
  613.             case kBHelp:
  614.             
  615.                 HMSetBalloons(!HMGetBalloons());
  616.                 GetDItem(prefDialogPtr, kHelp, &itemType, &itemHandle, &itemRect);
  617.                 SetCtlValue((ControlHandle) itemHandle, HMGetBalloons());
  618.                 break;
  619.  
  620.                 
  621.         }
  622.     } while (!doneFlag);
  623.     
  624.     HMSetBalloons(SaveBalloons);
  625.     DisposDialog(prefDialogPtr);
  626.     
  627.     SetPort(savePort);
  628.  
  629.     /* if the user clicked Save, return true */
  630.     return (item == kSaveButtonItem);
  631. }
  632.  
  633. pascal Boolean filterIt(DialogPtr inputDialog, EventRecord *myDialogEvent, short *theDialogItem)
  634. {
  635.     ModalFilterProcPtr theModalProc;
  636.     Boolean returnVal = false;
  637.     char theKey;
  638.     
  639.     if (((myDialogEvent->what == keyDown) || (myDialogEvent->what == autoKey)) &&
  640.         (myDialogEvent->modifiers & CmdKeyMask))
  641.     {
  642.         theKey = myDialogEvent->message & charCodeMask;
  643.         switch (theKey)
  644.         {
  645.             case kUpArrowKey:
  646.                             *theDialogItem = kUpArrow;
  647.                             returnVal = true;
  648.                             break;
  649.             case kDownArrowKey:
  650.                             *theDialogItem = kDownArrow;
  651.                             returnVal = true;
  652.                             break;
  653.         }
  654.     }
  655.     
  656.     if (!returnVal)
  657.         if (GetStdFilterProc(&theModalProc) == noErr)
  658.             returnVal=theModalProc(inputDialog, myDialogEvent, theDialogItem);
  659.  
  660.     return(returnVal);
  661. }