home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / MacGzip 1.1.1 / Mac / PrefsDlg.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-04-01  |  22.5 KB  |  897 lines  |  [TEXT/KAHL]
  1. /*
  2.  * PrefsDlg.c
  3.  * (C) SPDsoft, August 13, 1995
  4.  *
  5.  * Prefs Dialog
  6.  */
  7.  
  8. /*
  9.  * THINK_C 8.0 extra includes (Not in MacHeaders)
  10.  */
  11.  
  12. #include <Balloons.h>
  13. #include <Aliases.h>
  14.  
  15.  
  16. #include "GzErrors.h"
  17. #include "ErrorStrings.h"
  18. #include "GzPStrings.h"
  19.  
  20. #include "PrefsDlg.h"
  21. #include "Prefs.h"
  22.  
  23. #include "tailor.h" /* for MAX_SUFFIX */
  24.  
  25. /*
  26.  * Globals
  27.  */
  28.  
  29. AliasHandle gOriginalAliasHdl;
  30.  
  31. /*
  32.  * Prototypes
  33.  */
  34.  
  35. Boolean DoPrefsDialog(PrefsTypePtr thePrefs, AliasHandle * theFldrAlias);
  36.  
  37. static void DoItem(    DialogPtr DlgPtr, short item,
  38.                     DlgInfoPtr myDlgInfo, PrefsTypePtr thePrefs, AliasHandle *FldrAlias );
  39. static void SetItems(    DialogPtr DlgPtr,
  40.                     DlgInfoPtr myDlgInfo, PrefsTypePtr thePrefs, AliasHandle *FldrAlias );
  41.                     
  42. static Boolean GetItems(    DialogPtr DlgPtr,
  43.                     DlgInfoPtr myDlgInfo, PrefsTypePtr thePrefs );
  44.  
  45. static void SetUpDitl(    DialogPtr DlgPtr, DlgInfoPtr myDlgInfo, PrefsTypePtr thePrefs );
  46. static void CleanDitl(    DialogPtr DlgPtr, DlgInfoPtr myDlgInfo );
  47.  
  48. static Boolean GetItemValue( DialogPtr DlgPtr, short item, short *value);
  49. static void SetItemValue( DialogPtr DlgPtr, short item, short value);
  50. static void SetItemText( DialogPtr DlgPtr, short item, Str255 pstr, Boolean quote);
  51. static void DisableDItem( DialogPtr DlgPtr, short item);
  52. static void EnableDItem( DialogPtr DlgPtr, short item);
  53.  
  54. /*
  55.  * main function
  56.  */
  57.  
  58. Boolean DoPrefsDialog(PrefsTypePtr thePrefs, AliasHandle * theFldrAlias)
  59. {
  60.     GrafPtr                savePort;
  61.     DialogPtr            DlgPtr;
  62.     short                itemHit;
  63.     Boolean                DlgDone;
  64.     Boolean                SaveBalloons;
  65.     ModalFilterUPP        ModalUPP;
  66.  
  67.     Boolean                result = false;
  68.     PrefsType            tmpPrefs;        /* work on these */
  69.     AliasHandle            FldrAlias;        /* instead of originals */
  70.     extern PrefsType    DefaultPrefs;
  71.     
  72.     static DlgInfo myDlgInfo =
  73.         {
  74.             {
  75.                 kPrefgzipDITL_ID,
  76.                 kPrefCompDITL_ID,
  77.                 kPrefDecoDITL_ID,
  78.                 kPrefFoldDITL_ID,
  79.                 kPrefMiscDITL_ID
  80.             },
  81.             0,                            /* Number of items in layout DITL */
  82.             pmPrefgzip
  83.         };
  84.     
  85.     if ( nil == (DlgPtr = GetNewDialog(kPrefGenPDLOG_ID, nil, (WindowPtr) -1)))
  86.     {
  87.         if ( noErr == (err = ResError())) err = resFNotFound;
  88.         DoError(SYS_ERR,QUIT_ERR,GetErrFmt(RES_MANAGER, RES_NOTFOUND));
  89.     }
  90.     
  91.     BlockMove(thePrefs, &tmpPrefs, sizeof(tmpPrefs));
  92.     gOriginalAliasHdl = *theFldrAlias;
  93.     FldrAlias = *theFldrAlias;
  94.     
  95.     GetPort(&savePort);
  96.     SetPort(DlgPtr);
  97.     
  98.     SetDialogDefaultItem( DlgPtr, kPrefComm_OK_ID);
  99.     SetDialogCancelItem( DlgPtr, kPrefComm_Cancel_ID);
  100.     
  101.     if (noErr != (err = GetStdFilterProc(&ModalUPP)) )
  102.     {
  103.         DoError(SYS_ERR,QUIT_ERR,GetErrFmt(GENERIC, NOT_UPP), 1);
  104.     }
  105.     
  106.     myDlgInfo.BaseDITL = CountDITL( DlgPtr );
  107.     SetItemValue( DlgPtr, kPrefComm_Menu_ID, myDlgInfo.Selection );
  108.     SetUpDitl( DlgPtr, &myDlgInfo, &tmpPrefs);
  109.     SetItems( DlgPtr, &myDlgInfo, &tmpPrefs,  &FldrAlias);
  110.     
  111.     /*
  112.      * Initial Dlg values
  113.      */
  114.      
  115.     SaveBalloons = HMGetBalloons();
  116.     SetItemValue( DlgPtr, kPrefComm_Help_ID, (short) SaveBalloons );
  117.  
  118.     for( DlgDone = FALSE; !DlgDone ; )
  119.     {
  120.         ModalDialog(ModalUPP, &itemHit);
  121.         
  122.         switch ( itemHit )
  123.         {
  124.             case kPrefComm_OK_ID:
  125.                 
  126.                 /*
  127.                  * Save Dlg Prefs
  128.                  */
  129.                 if (GetItems( DlgPtr, &myDlgInfo, &tmpPrefs ))
  130.                 {
  131.                     BlockMove(&tmpPrefs, thePrefs, sizeof(tmpPrefs));
  132.                     
  133.                     if (*theFldrAlias != FldrAlias)
  134.                     {
  135.                         if (*theFldrAlias != nil)
  136.                             DisposHandle((Handle)  *theFldrAlias);
  137.                             
  138.                         *theFldrAlias = FldrAlias;
  139.                     }
  140.                     DlgDone = TRUE;
  141.                     result = TRUE;
  142.                 }
  143.                 break;
  144.                 
  145.             case kPrefComm_Cancel_ID:
  146.                 
  147.                 /*
  148.                  * Discard Dlg Prefs
  149.                  */
  150.                  
  151.                 DlgDone = TRUE;
  152.                 break;
  153.                 
  154.             case kPrefComm_Dflt_ID:
  155.                 
  156.                 /*
  157.                  * Set Defaults
  158.                  */
  159.                 switch( myDlgInfo.Selection )
  160.                 {
  161.                     case pmPrefgzip:
  162.                             BlockMove(& DefaultPrefs.gzip, & tmpPrefs.gzip, sizeof(gzip_prefs));
  163.                         break;
  164.                         
  165.                     case pmPrefcomp:
  166.                             BlockMove(& DefaultPrefs.Compress, & tmpPrefs.Compress, sizeof(Compress_prefs));
  167.                         break;
  168.                         
  169.                     case pmPrefdeco:
  170.                             BlockMove(& DefaultPrefs.Decompress, & tmpPrefs.Decompress, sizeof(Decompress_prefs));
  171.                         break;
  172.                         
  173.                     case pmPreffold:
  174.                             BlockMove(& DefaultPrefs.Folder, & tmpPrefs.Folder, sizeof(Folder_prefs));
  175.                         break;
  176.                         
  177.                     case pmPrefmisc:
  178.                             BlockMove(& DefaultPrefs.Misc, & tmpPrefs.Misc, sizeof(Misc_prefs));
  179.                         break;
  180.                         
  181.                     default:
  182.                         break;
  183.                 }        
  184.                  SetItems( DlgPtr, &myDlgInfo, &tmpPrefs, &FldrAlias );
  185.                  
  186.                 break;
  187.                 
  188.             case kPrefComm_Help_ID:
  189.                 
  190.                 /*
  191.                  * Balloon Help on/off
  192.                  */
  193.                 HMSetBalloons(!HMGetBalloons());
  194.                 SetItemValue( DlgPtr, kPrefComm_Help_ID, (short) HMGetBalloons() );
  195.  
  196.                 break;
  197.                 
  198.             case kPrefComm_Menu_ID:
  199.                 
  200.                 /*
  201.                  * Change DITL
  202.                  */
  203.                 if (GetItems( DlgPtr, &myDlgInfo, &tmpPrefs ))
  204.                 { 
  205.                     if ( GetItemValue( DlgPtr, kPrefComm_Menu_ID, &(myDlgInfo.Selection)))
  206.                     {
  207.                         CleanDitl(DlgPtr, &myDlgInfo);
  208.                         SetUpDitl(DlgPtr, &myDlgInfo, &tmpPrefs);
  209.                         SetItems( DlgPtr, &myDlgInfo, &tmpPrefs, &FldrAlias );
  210.                     }
  211.                 }
  212.                 else
  213.                     SetItemValue( DlgPtr, kPrefComm_Menu_ID, myDlgInfo.Selection);
  214.                     
  215.                 break;
  216.             
  217.             default:
  218.                 
  219.                 DoItem(    DlgPtr, itemHit, &myDlgInfo, &tmpPrefs, &FldrAlias );
  220.                 break;
  221.         }
  222.                 
  223.     }
  224.     
  225.     HMSetBalloons(SaveBalloons);
  226.     
  227.     SetPort(savePort);
  228.     DisposeRoutineDescriptor (ModalUPP);
  229.     DisposDialog(DlgPtr);
  230.     return result;
  231. }
  232.  
  233.  
  234. /*
  235.  * Manage extra DITL's
  236.  */
  237.  
  238. static void SetUpDitl(    DialogPtr DlgPtr, DlgInfoPtr myDlgInfo, PrefsTypePtr thePrefs )
  239. {
  240.     Handle        addDitl;
  241.  
  242.     if (nil == (addDitl =
  243.         GetResource( 'DITL', myDlgInfo->ExtraDITL[myDlgInfo->Selection - 1]   )))
  244.     {
  245.         if ( noErr == (err = ResError())) err = resFNotFound;
  246.         DoError(SYS_ERR,QUIT_ERR,GetErrFmt(RES_MANAGER, RES_NOTFOUND));
  247.     }
  248.     
  249.     HLock( addDitl );
  250.     AppendDITL( DlgPtr, addDitl, myDlgInfo->BaseDITL );
  251.     HUnlock( addDitl );
  252.     ReleaseResource( addDitl );
  253.  
  254. }
  255.  
  256. static void CleanDitl(    DialogPtr DlgPtr, DlgInfoPtr myDlgInfo )
  257. {
  258.     ShortenDITL( DlgPtr, CountDITL( DlgPtr ) - myDlgInfo->BaseDITL );
  259. }
  260.  
  261. /*
  262.  * Set/get values for controls (access by Item ID)
  263.  */
  264.  
  265. static Boolean GetItemValue( DialogPtr DlgPtr, short item, short *value)
  266. {
  267.     short        itemType;
  268.     Handle        itemHandle;
  269.     Rect        itemRect;
  270.     short        newValue;
  271.  
  272.     GetDialogItem( DlgPtr, item, &itemType, &itemHandle, &itemRect);
  273.     newValue = GetControlValue( (ControlHandle)itemHandle);
  274.     
  275.     if ( *value == newValue )
  276.         return FALSE;
  277.     else
  278.     {
  279.         *value = newValue;
  280.         return TRUE;
  281.     }
  282. }
  283.  
  284. static void SetItemValue( DialogPtr DlgPtr, short item, short value)
  285. {
  286.     short        itemType;
  287.     Handle        itemHandle;
  288.     Rect        itemRect;
  289.  
  290.     GetDialogItem( DlgPtr, item, &itemType, &itemHandle, &itemRect);
  291.     SetControlValue( (ControlHandle) itemHandle, value );
  292. }
  293.  
  294. static void SetItemText( DialogPtr DlgPtr, short item, Str255 pstr, Boolean quote)
  295. {
  296.     short        itemType;
  297.     Handle        itemHandle;
  298.     Rect        itemRect;
  299.     Str255        sTemp;
  300.  
  301.     if (quote)
  302.     {
  303.         sTemp[0] = 0x00;
  304.         PStrCat( sTemp, "\p “");
  305.         PStrCat( sTemp, pstr);
  306.         PStrCat( sTemp, "\p”");
  307.     }
  308.     else
  309.     {
  310.         PStrCpy( sTemp, pstr );
  311.     }
  312.     
  313.     GetDialogItem( DlgPtr, item, &itemType, &itemHandle, &itemRect);
  314.     /*
  315.      * OJO: should adjust strlen to item rect...
  316.      */
  317.     SetIText( itemHandle, sTemp );
  318. }
  319.  
  320. static void DisableDItem( DialogPtr DlgPtr, short item)
  321. {
  322.     short        itemType;
  323.     Handle        itemHandle;
  324.     Rect        itemRect;
  325.  
  326.     GetDialogItem( DlgPtr, item, &itemType, &itemHandle, &itemRect);
  327.     HiliteControl( (ControlHandle) itemHandle, 255 );
  328. }
  329.  
  330. static void EnableDItem( DialogPtr DlgPtr, short item)
  331. {
  332.     short        itemType;
  333.     Handle        itemHandle;
  334.     Rect        itemRect;
  335.  
  336.     GetDialogItem( DlgPtr, item, &itemType, &itemHandle, &itemRect);
  337.     HiliteControl( (ControlHandle) itemHandle, 0 );
  338. }
  339. /******************************************************************************/
  340.  
  341. static void DoItem(    DialogPtr DlgPtr, short item,
  342.                     DlgInfoPtr myDlgInfo, PrefsTypePtr thePrefs, AliasHandle *FldrAlias )
  343.  
  344. {
  345.     short        itemType;
  346.     Handle        itemHandle;
  347.     Rect        itemRect;
  348.     short        value=-1;
  349.     Str255        sTemp;
  350.     
  351.     extern Boolean SFGetFolder(FSSpec *fSpec);
  352.     FSSpec        fSpec;
  353.     
  354.     
  355.     
  356.     GetDialogItem( DlgPtr, item, &itemType, &itemHandle, &itemRect);
  357.     
  358.     switch( myDlgInfo->Selection )
  359.     {
  360.         case pmPrefgzip:
  361.                 
  362.         switch( item - myDlgInfo->BaseDITL )
  363.         {
  364.             case kPrefgzip_Force:
  365.                 
  366.                 value = thePrefs->gzip.Force = !thePrefs->gzip.Force;
  367.                 break;
  368.                 
  369.             case kPrefgzip_NoName:
  370.             
  371.                 value = thePrefs->gzip.NoName = !thePrefs->gzip.NoName;
  372.                 
  373.                 if ( value && thePrefs->gzip.Name )
  374.                 {
  375.                     SetItemValue( DlgPtr, kPrefgzip_Name + myDlgInfo->BaseDITL, FALSE);
  376.                     thePrefs->gzip.Name = FALSE;
  377.                 }
  378.                     
  379.                 break;
  380.                 
  381.             case kPrefgzip_Name:
  382.     
  383.                 value = thePrefs->gzip.Name = !thePrefs->gzip.Name;
  384.     
  385.                 if ( value && thePrefs->gzip.NoName )
  386.                 {
  387.                     SetItemValue( DlgPtr, kPrefgzip_NoName + myDlgInfo->BaseDITL, FALSE);
  388.                     thePrefs->gzip.NoName = FALSE;
  389.                 }
  390.     
  391.                 break;
  392.     
  393.             case kPrefgzip_Custom:
  394.             
  395.                 value = thePrefs->gzip.UseCustomSuffix = !thePrefs->gzip.UseCustomSuffix;
  396.                 
  397.                 if ( value )
  398.                 {
  399.                     ShowDialogItem( DlgPtr, kPrefgzip_Suffix + myDlgInfo->BaseDITL);
  400.                     EnableDItem( DlgPtr, kPrefgzip_GunSuff + myDlgInfo->BaseDITL);
  401.                 }
  402.                 else
  403.                 {
  404.                     HideDialogItem( DlgPtr, kPrefgzip_Suffix + myDlgInfo->BaseDITL);
  405.                     DisableDItem( DlgPtr, kPrefgzip_GunSuff + myDlgInfo->BaseDITL);
  406.                 }
  407.                 
  408.                 break;
  409.                 
  410.             case kPrefgzip_GunSuff:
  411.             
  412.                 value = thePrefs->gzip.GunzipSuffix = !thePrefs->gzip.GunzipSuffix;
  413.                 break;
  414.                 
  415.             case kPrefgzip_Up:
  416.             
  417.                 if ( thePrefs->gzip.Level < 9 )
  418.                 {
  419.                     thePrefs->gzip.Level ++;
  420.                     InvertRect(&itemRect);
  421.                     while (StillDown())
  422.                         ;
  423.                     InvertRect(&itemRect);
  424.                     GetDialogItem( DlgPtr, kPrefgzip_Level + myDlgInfo->BaseDITL, &itemType, &itemHandle, &itemRect);
  425.                     NumToString( (long)thePrefs->gzip.Level, sTemp );
  426.                     SetIText(itemHandle,sTemp);
  427.                 }
  428.                 break;
  429.                 
  430.             case kPrefgzip_Down:
  431.             
  432.                 if ( thePrefs->gzip.Level > 1 )
  433.                 {
  434.                     thePrefs->gzip.Level --;
  435.                     InvertRect(&itemRect);
  436.                     while (StillDown())
  437.                         ;
  438.                     InvertRect(&itemRect);
  439.                     GetDialogItem( DlgPtr, kPrefgzip_Level + myDlgInfo->BaseDITL, &itemType, &itemHandle, &itemRect);
  440.                     NumToString( (long)thePrefs->gzip.Level, sTemp );
  441.                     SetIText(itemHandle,sTemp);
  442.                 }
  443.                 break;
  444.         }
  445.         break;
  446.         
  447.         case pmPrefcomp:
  448.         switch( item - myDlgInfo->BaseDITL )
  449.         {
  450.             case kPrefComp_Keys:
  451.                 value = thePrefs->Compress.Keys = !thePrefs->Compress.Keys;
  452.                 break;
  453.             case kPrefComp_IC:
  454.                 value = thePrefs->Compress.IC = !thePrefs->Compress.IC;
  455.                 if ( thePrefs->Compress.IC )
  456.                 {
  457.                     EnableDItem( DlgPtr, kPrefComp_ASCII + myDlgInfo->BaseDITL );
  458.                     EnableDItem( DlgPtr, kPrefComp_NotMB + myDlgInfo->BaseDITL );
  459.                 }
  460.                 else
  461.                 {
  462.                     DisableDItem( DlgPtr, kPrefComp_ASCII + myDlgInfo->BaseDITL );
  463.                     DisableDItem( DlgPtr, kPrefComp_NotMB + myDlgInfo->BaseDITL );
  464.                 }    
  465.     
  466.                 break;
  467.             case kPrefComp_ASCII:
  468.                 value = thePrefs->Compress.IC_ASCII = !thePrefs->Compress.IC_ASCII;
  469.                 break;
  470.             case kPrefComp_NotMB:
  471.                 value = thePrefs->Compress.IC_NotMB = !thePrefs->Compress.IC_NotMB;
  472.                 break;
  473.             case kPrefComp_RFPopup:
  474.                 GetItemValue( DlgPtr, item, &(thePrefs->Compress.ResFork));
  475.                 break;
  476.             case kPrefComp_ModePopup:
  477.                 if ( GetItemValue( DlgPtr, item, &(thePrefs->Compress.Mode)))
  478.                 {
  479.                     if ( thePrefs->Compress.Mode == pmPrefComp_MBin )
  480.                         ShowDialogItem( DlgPtr, kPrefComp_ModeA + myDlgInfo->BaseDITL);
  481.                     else
  482.                         HideDialogItem( DlgPtr, kPrefComp_ModeA + myDlgInfo->BaseDITL);
  483.                 }
  484.                 break;
  485.             case kPrefComp_ModeA:
  486.                 value = thePrefs->Compress.Mode_a = !thePrefs->Compress.Mode_a;
  487.                 break;
  488.         }
  489.         break;
  490.                             
  491.         
  492.         case pmPrefdeco:
  493.         switch( item - myDlgInfo->BaseDITL )
  494.         {
  495.             case kPrefDeco_Keys:
  496.                 value = thePrefs->Decompress.Keys = !thePrefs->Decompress.Keys;
  497.                 break;
  498.             case kPrefDeco_IC:
  499.                 value = thePrefs->Decompress.IC = !thePrefs->Decompress.IC;
  500.                 
  501.                 if ( value && thePrefs->Decompress.Fetch )
  502.                 {
  503.                     SetItemValue( DlgPtr, kPrefDeco_Fetch + myDlgInfo->BaseDITL, FALSE);
  504.                     thePrefs->Decompress.Fetch = FALSE;
  505.                 }
  506.                 break;
  507.                 
  508.             case kPrefDeco_Fetch:
  509.                 value = thePrefs->Decompress.Fetch = !thePrefs->Decompress.Fetch;
  510.     
  511.                 if ( value && thePrefs->Decompress.IC )
  512.                 {
  513.                     SetItemValue( DlgPtr, kPrefDeco_IC + myDlgInfo->BaseDITL, FALSE);
  514.                     thePrefs->Decompress.IC = FALSE;
  515.                 }
  516.     
  517.                 break;
  518.             case kPrefDeco_MB:
  519.                 value = thePrefs->Decompress.TryMB = !thePrefs->Decompress.TryMB;
  520.                 break;
  521.             case kPrefDeco_MPopup:
  522.                 GetItemValue( DlgPtr, item, &(thePrefs->Decompress.Mode));
  523.                 break;
  524.             default:
  525.                 break;
  526.         }
  527.         break;
  528.     
  529.         case pmPreffold:
  530.         switch( item - myDlgInfo->BaseDITL )
  531.         {
  532.             case kPrefFold_FNot:
  533.             case kPrefFold_FFold:
  534.             case kPrefFold_FAll:
  535.             
  536.                 SetItemValue( DlgPtr, thePrefs->Folder.RecurseMode + myDlgInfo->BaseDITL, 0 );
  537.                 thePrefs->Folder.RecurseMode = item - myDlgInfo->BaseDITL;
  538.                 value = 1;
  539.                 break;
  540.                 
  541.             case kPrefFold_UseDest:
  542.             
  543.                 /*
  544.                  * SFGetFolder
  545.                  */
  546.                  
  547.                 SetItemText( DlgPtr, kPrefFold_Dest + myDlgInfo->BaseDITL, "\p", FALSE);
  548.                 
  549.                 if (!thePrefs->Folder.UseDestFolder)
  550.                 {
  551.                     if ( SFGetFolder(&fSpec) )
  552.                     {
  553.                         if ((*FldrAlias != gOriginalAliasHdl) && ( *FldrAlias != nil ))
  554.                             DisposHandle((Handle) *FldrAlias);
  555.                             
  556.                         if ( noErr != (err=NewAlias(nil, &fSpec, FldrAlias)) )
  557.                         {
  558.                             *FldrAlias = nil;
  559.                             
  560.                             DoError(SYS_ERR,INFO_ERR,GetErrFmt(GENERIC, NOT_ALIAS));                            
  561.                             
  562.                         }
  563.                         else
  564.                         {
  565.                             value = thePrefs->Folder.UseDestFolder = TRUE;
  566.                             SetItemText( DlgPtr, kPrefFold_Dest + myDlgInfo->BaseDITL,
  567.                                     fSpec.name, TRUE);
  568.                         }
  569.                     }
  570.                 }
  571.                 else
  572.                     value = thePrefs->Folder.UseDestFolder = FALSE;
  573.  
  574.                     
  575.                     
  576.                 break;
  577.         }
  578.         break;
  579.         
  580.         case pmPrefmisc:
  581.         switch( item - myDlgInfo->BaseDITL )
  582.         {
  583.             case kPrefMisc_KeepOrig:
  584.                 value = thePrefs->Misc.KeepOriginal = !thePrefs->Misc.KeepOriginal;
  585.                 break;
  586.             case kPrefMisc_Beep:
  587.                 value = thePrefs->Misc.BeepWhenDone = !thePrefs->Misc.BeepWhenDone;
  588.                 break;
  589.             case kPrefMisc_Quit:
  590.                 value = thePrefs->Misc.QuitWhenDone = !thePrefs->Misc.QuitWhenDone;
  591.                 break;
  592.             case kPrefMisc_Keys:
  593.                 value = thePrefs->Misc.Keys = !thePrefs->Misc.Keys;
  594.                 break;
  595.             case kPrefMisc_SelPopup:
  596.                 GetItemValue( DlgPtr, item, &(thePrefs->Misc.DefaultOp));
  597.                 break;
  598.             case kPrefMisc_Reset:
  599.                 thePrefs->SavedPos = TRUE;
  600.                 thePrefs->SavedPoint.v = 80;
  601.                 thePrefs->SavedPoint.h = 80;
  602.                 break;
  603.         }
  604.         
  605.         default:
  606.             break;
  607.     }
  608.     if (( itemType & ctrlItem ) && ( value != -1 ))
  609.         SetControlValue( (ControlHandle) itemHandle, value );
  610. }
  611.  
  612. static void SetItems(    DialogPtr DlgPtr,
  613.                     DlgInfoPtr myDlgInfo, PrefsTypePtr thePrefs, AliasHandle *FldrAlias )
  614. {
  615.     short        itemType;
  616.     Handle        itemHandle;
  617.     Rect        itemRect;
  618.     Str255        sTemp;
  619.  
  620.     switch( myDlgInfo->Selection )
  621.     {
  622.         case pmPrefgzip:
  623.             
  624.             SetItemValue( DlgPtr, kPrefgzip_Force + myDlgInfo->BaseDITL, thePrefs->gzip.Force);
  625.             SetItemValue( DlgPtr, kPrefgzip_NoName + myDlgInfo->BaseDITL, thePrefs->gzip.NoName);
  626.             SetItemValue( DlgPtr, kPrefgzip_Name + myDlgInfo->BaseDITL, thePrefs->gzip.Name);
  627.             SetItemValue( DlgPtr, kPrefgzip_Custom + myDlgInfo->BaseDITL, thePrefs->gzip.UseCustomSuffix);
  628.             if ( thePrefs->gzip.UseCustomSuffix )
  629.             {
  630.                 ShowDialogItem( DlgPtr, kPrefgzip_Suffix + myDlgInfo->BaseDITL);
  631.                 EnableDItem( DlgPtr, kPrefgzip_GunSuff + myDlgInfo->BaseDITL);
  632.             }
  633.             else
  634.             {
  635.                 HideDialogItem( DlgPtr, kPrefgzip_Suffix + myDlgInfo->BaseDITL);
  636.                 DisableDItem( DlgPtr, kPrefgzip_GunSuff + myDlgInfo->BaseDITL);
  637.             }
  638.             SetItemValue( DlgPtr, kPrefgzip_GunSuff + myDlgInfo->BaseDITL, thePrefs->gzip.GunzipSuffix);
  639.             GetDialogItem( DlgPtr, kPrefgzip_Level + myDlgInfo->BaseDITL, &itemType, &itemHandle, &itemRect);
  640.             NumToString( (long)thePrefs->gzip.Level, sTemp );
  641.             SetIText(itemHandle,sTemp);
  642.             GetDialogItem(DlgPtr, kPrefgzip_Suffix + myDlgInfo->BaseDITL, &itemType, &itemHandle, &itemRect);
  643.             SetIText(itemHandle, thePrefs->gzip.Suffix);
  644.             if(thePrefs->gzip.Suffix[0]!=0x00)
  645.             SelIText(DlgPtr, kPrefgzip_Suffix + myDlgInfo->BaseDITL, 0, 32767);
  646.             break;
  647.             
  648.         case pmPrefcomp:
  649.  
  650.             SetItemValue( DlgPtr, kPrefComp_Keys + myDlgInfo->BaseDITL, thePrefs->Compress.Keys);
  651.             SetItemValue( DlgPtr, kPrefComp_IC + myDlgInfo->BaseDITL, thePrefs->Compress.IC);
  652.             SetItemValue( DlgPtr, kPrefComp_ASCII + myDlgInfo->BaseDITL, thePrefs->Compress.IC_ASCII);
  653.             SetItemValue( DlgPtr, kPrefComp_NotMB + myDlgInfo->BaseDITL, thePrefs->Compress.IC_NotMB);
  654.             SetItemValue( DlgPtr, kPrefComp_RFPopup + myDlgInfo->BaseDITL, thePrefs->Compress.ResFork);
  655.             SetItemValue( DlgPtr, kPrefComp_ModePopup + myDlgInfo->BaseDITL, thePrefs->Compress.Mode);
  656.             SetItemValue( DlgPtr, kPrefComp_ModeA + myDlgInfo->BaseDITL, thePrefs->Compress.Mode_a);
  657.             
  658.             if ( thePrefs->Compress.IC )
  659.             {
  660.                 EnableDItem( DlgPtr, kPrefComp_ASCII + myDlgInfo->BaseDITL );
  661.                 EnableDItem( DlgPtr, kPrefComp_NotMB + myDlgInfo->BaseDITL );
  662.             }
  663.             else
  664.             {
  665.                 DisableDItem( DlgPtr, kPrefComp_ASCII + myDlgInfo->BaseDITL );
  666.                 DisableDItem( DlgPtr, kPrefComp_NotMB + myDlgInfo->BaseDITL );
  667.             }    
  668.             
  669.             if ( thePrefs->Compress.Mode == pmPrefComp_MBin )
  670.                 ShowDialogItem( DlgPtr, kPrefComp_ModeA + myDlgInfo->BaseDITL);
  671.             else
  672.                 HideDialogItem( DlgPtr, kPrefComp_ModeA + myDlgInfo->BaseDITL);
  673.             
  674.             break;
  675.  
  676.         case pmPrefdeco:
  677.         
  678.             SetItemValue( DlgPtr, kPrefDeco_Keys + myDlgInfo->BaseDITL, thePrefs->Decompress.Keys);
  679.             SetItemValue( DlgPtr, kPrefDeco_IC + myDlgInfo->BaseDITL, thePrefs->Decompress.IC);
  680.             SetItemValue( DlgPtr, kPrefDeco_Fetch + myDlgInfo->BaseDITL, thePrefs->Decompress.Fetch);
  681.             SetItemValue( DlgPtr, kPrefDeco_MB + myDlgInfo->BaseDITL, thePrefs->Decompress.TryMB);
  682.             
  683.             OSTypeToStr255( sTemp, &thePrefs->Decompress.TextCreator );
  684.             GetDialogItem(DlgPtr, kPrefDeco_CText + myDlgInfo->BaseDITL, &itemType, &itemHandle, &itemRect);
  685.             SetIText(itemHandle, sTemp);
  686.             SelIText(DlgPtr, kPrefDeco_CText + myDlgInfo->BaseDITL, 0, 32767);
  687.  
  688.             OSTypeToStr255( sTemp, &thePrefs->Decompress.BinType );
  689.             GetDialogItem(DlgPtr, kPrefDeco_TBin + myDlgInfo->BaseDITL, &itemType, &itemHandle, &itemRect);
  690.             SetIText(itemHandle, sTemp);
  691.             
  692.             OSTypeToStr255( sTemp, &thePrefs->Decompress.BinCreator );
  693.             GetDialogItem(DlgPtr, kPrefDeco_CBin + myDlgInfo->BaseDITL, &itemType, &itemHandle, &itemRect);
  694.             SetIText(itemHandle, sTemp);
  695.  
  696.             SetItemValue( DlgPtr, kPrefDeco_MPopup + myDlgInfo->BaseDITL, thePrefs->Decompress.Mode);
  697.         
  698.             break;
  699.             
  700.         case pmPreffold:
  701.         
  702.             SetItemValue( DlgPtr, kPrefFold_FNot + myDlgInfo->BaseDITL, 0 );
  703.             SetItemValue( DlgPtr, kPrefFold_FFold + myDlgInfo->BaseDITL, 0 );
  704.             SetItemValue( DlgPtr, kPrefFold_FAll + myDlgInfo->BaseDITL, 0 );
  705.             SetItemValue( DlgPtr, thePrefs->Folder.RecurseMode + myDlgInfo->BaseDITL, 1 );
  706.  
  707.             SetItemText( DlgPtr, kPrefFold_Dest + myDlgInfo->BaseDITL, "\p", FALSE);
  708.             
  709.             if (( thePrefs->Folder.UseDestFolder ) && (*FldrAlias!=nil))
  710.             {
  711.                 FSSpec    fSpec;
  712.                 Boolean    changedFlag;
  713.                 
  714.                 if( noErr == ResolveAlias(nil, *FldrAlias, &fSpec, &changedFlag))
  715.                     SetItemText( DlgPtr, kPrefFold_Dest + myDlgInfo->BaseDITL, fSpec.name, TRUE);
  716.                 else
  717.                 {
  718.                     thePrefs->Folder.UseDestFolder = FALSE;
  719.                 }
  720.             }
  721.             else
  722.             {
  723.                 thePrefs->Folder.UseDestFolder = FALSE;
  724.             }
  725.             
  726.             SetItemValue( DlgPtr, kPrefFold_UseDest + myDlgInfo->BaseDITL, thePrefs->Folder.UseDestFolder );
  727.  
  728.  
  729.             break;
  730.             
  731.         case pmPrefmisc:
  732.         
  733.             SetItemValue( DlgPtr, kPrefMisc_KeepOrig + myDlgInfo->BaseDITL, thePrefs->Misc.KeepOriginal);
  734.             SetItemValue( DlgPtr, kPrefMisc_Beep + myDlgInfo->BaseDITL, thePrefs->Misc.BeepWhenDone);
  735.             SetItemValue( DlgPtr, kPrefMisc_Quit + myDlgInfo->BaseDITL, thePrefs->Misc.QuitWhenDone);
  736.             SetItemValue( DlgPtr, kPrefMisc_Keys + myDlgInfo->BaseDITL, thePrefs->Misc.Keys);
  737.             SetItemValue( DlgPtr, kPrefMisc_SelPopup + myDlgInfo->BaseDITL, thePrefs->Misc.DefaultOp);
  738.             break;
  739.         
  740.         default:
  741.             break;
  742.     }
  743. }
  744.  
  745. /* Get editText fields */
  746.  
  747. static Boolean GetItems(    DialogPtr DlgPtr,
  748.                     DlgInfoPtr myDlgInfo, PrefsTypePtr thePrefs )
  749. {
  750.     short        itemType;
  751.     Handle        itemHandle;
  752.     Rect        itemRect;
  753.     Str255        sTemp;
  754.     Boolean        result;
  755.     
  756.     result = TRUE;
  757.  
  758.     switch( myDlgInfo->Selection )
  759.     {
  760.         case pmPrefgzip:
  761.             GetDialogItem(DlgPtr, kPrefgzip_Suffix + myDlgInfo->BaseDITL, &itemType, &itemHandle, &itemRect);
  762.             
  763.             if (thePrefs->gzip.UseCustomSuffix)
  764.             {
  765.                 GetIText(itemHandle, thePrefs->gzip.Suffix);
  766.                 
  767.                 if ((thePrefs->gzip.Suffix[0] == 0) || (thePrefs->gzip.Suffix[0] > MAX_SUFFIX ))
  768.                 {
  769.                     DoError(INPUT_ERR,INFO_ERR,GetErrFmt(USER_ERROR,BAD_SUFFIX), 1, MAX_SUFFIX);
  770.                     if (thePrefs->gzip.Suffix[0] != 0)
  771.                         SelIText(DlgPtr, kPrefgzip_Suffix + myDlgInfo->BaseDITL,0,32767);
  772.                     result = FALSE;
  773.                 }
  774.             }
  775.             break;
  776.             
  777.         case pmPrefcomp:
  778.             break;
  779.             
  780.         case pmPrefdeco:
  781.         
  782.             GetDialogItem(DlgPtr, kPrefDeco_CText + myDlgInfo->BaseDITL, &itemType, &itemHandle, &itemRect);
  783.             GetIText(itemHandle, sTemp);
  784.             
  785.             if (sTemp[0] != 4)
  786.             {
  787.                 DoError(INPUT_ERR,INFO_ERR,GetErrFmt(USER_ERROR,BAD_CTEXT));
  788.                 if (sTemp[0] != 0)
  789.                         SelIText(DlgPtr, kPrefDeco_CText + myDlgInfo->BaseDITL,0,32767);
  790.                 result = FALSE;
  791.                 break;
  792.             }
  793.             
  794.             thePrefs->Decompress.TextCreator = Str255ToOSType( sTemp );
  795.             
  796.             GetDialogItem(DlgPtr, kPrefDeco_TBin + myDlgInfo->BaseDITL, &itemType, &itemHandle, &itemRect);
  797.             GetIText(itemHandle, sTemp);
  798.             
  799.             if (sTemp[0] != 4)
  800.             {
  801.                 DoError(INPUT_ERR,INFO_ERR,GetErrFmt(USER_ERROR,BAD_TBIN));
  802.                 if (sTemp[0] != 0)
  803.                         SelIText(DlgPtr, kPrefDeco_TBin + myDlgInfo->BaseDITL,0,32767);
  804.                 result = FALSE;
  805.                 break;
  806.             }
  807.             
  808.             thePrefs->Decompress.BinType = Str255ToOSType( sTemp );
  809.             
  810.             GetDialogItem(DlgPtr, kPrefDeco_CBin + myDlgInfo->BaseDITL, &itemType, &itemHandle, &itemRect);
  811.             GetIText(itemHandle, sTemp);
  812.             
  813.             if (sTemp[0] != 4)
  814.             {
  815.                 DoError(INPUT_ERR,INFO_ERR,GetErrFmt(USER_ERROR,BAD_CBIN));
  816.                 if (sTemp[0] != 0)
  817.                         SelIText(DlgPtr, kPrefDeco_CBin + myDlgInfo->BaseDITL,0,32767);
  818.                 result = FALSE;
  819.                 break;
  820.             }
  821.  
  822.             thePrefs->Decompress.BinCreator = Str255ToOSType( sTemp );
  823.  
  824.             break;
  825.             
  826.         case pmPreffold:
  827.             break;
  828.             
  829.         case pmPrefmisc:
  830.             break;
  831.             
  832.         default:
  833.             break;
  834.     }        
  835.     return result;
  836. }
  837.  
  838.  
  839. /******************************************************************************/
  840.  
  841. PrefsType DefaultPrefs =
  842. {
  843.     kCurrentPrefsTypeVers,
  844.     TRUE,                /* SavedPos */
  845.     0x00,
  846.     {
  847.         80,                /* v */
  848.         80                /* h */
  849.     },
  850.     {
  851.         FALSE,            /* Force */
  852.         FALSE,            /* NoName */
  853.         TRUE,            /* Name */
  854.         FALSE,            /* UseCustomSuffix */
  855.         FALSE,            /* GunzipSuffix */
  856.         0x00,
  857.         6,                /* Level */
  858.         "\p"            /* Suffix */
  859.     },
  860.     {
  861.         TRUE,            /* Keys */
  862.         TRUE,            /* IC */
  863.         FALSE,            /* IC_ASCII */
  864.         FALSE,            /* IC_NotMB */
  865.         kComp_RFAsk,    /* ResFork */
  866.         kComp_MBin,        /* Mode */
  867.         TRUE,            /* Modea */
  868.     },
  869.     {
  870.         TRUE,            /* Keys */
  871.         TRUE,            /* IC */
  872.         FALSE,            /* Fetch */
  873.         TRUE,            /* TryMB */
  874.         'ttxt',            /* TextCreator */
  875.         '\?\?\?\?',        /* BinType */
  876.         '\?\?\?\?',        /* BinCreator */
  877.         kDeco_MBin        /* Default Mode */
  878.     },
  879.     {
  880.         kFold_FAll,        /* RecurseMode */
  881.         FALSE,            /* UseDestFolder */
  882.         0x00,
  883.         kFldrAliasResID    /* folderAliasID */
  884.     },
  885.     {
  886.         FALSE,            /* KeepOriginal */
  887.         TRUE,            /* BeepWhenDone */
  888.         TRUE,            /* QuitWhenDone */
  889.         TRUE,            /* Keys */
  890.         kMisc_auto        /* DefaultCompress */
  891.     }
  892. };
  893.  
  894.  
  895.  
  896.  
  897.