home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / MacGzip 1.1.1 / Mac / Prefs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-04-01  |  6.8 KB  |  273 lines  |  [TEXT/KAHL]
  1. /*
  2.  * Prefs.c
  3.  *
  4.  * SPDsoft, August 14, 1995
  5.  * Based on Greg Robbins' "Sample System 7 Preferences" (Apple DTS)
  6.  */
  7.  
  8. #ifndef _FOLDERS_
  9. #    include <Folders.h>
  10. #endif
  11.  
  12. #include "Prefs.h"
  13.  
  14. /* prefs file constants */
  15.  
  16. #define kPrefsNameStrID        130        /* name of prefs file */
  17. #define kPrefsCreatorType    '\?\?\?\?'
  18. #define kPrefsFileType        'pref'
  19. #define kPrefsResourceType    'Pref'
  20. #define kPrefsResourceID    128
  21.  
  22. #define kFinderMessageStrID    -16397
  23. #define kStrType            'STR '
  24.  
  25. /*
  26.  * Prototypes
  27.  */
  28.  
  29. static OSErr GetPrefsName (StringPtr prefName, short StrID);
  30.  
  31.  
  32.  
  33. /*
  34.  * fill in the prefs structure from the resource file or from scratch
  35.  */
  36. Boolean GetOrGeneratePrefs(PrefsType * thePrefsTypePtr, AliasHandle * fileAliasHandlePtr, long wantedVers )
  37. {
  38.     short                prefsResRefNum;
  39.     Handle                tempHandle;
  40.     
  41.     extern PrefsType    DefaultPrefs;
  42.     
  43.     /*
  44.      * set default prefs
  45.      */
  46.     BlockMove( &DefaultPrefs, thePrefsTypePtr, sizeof(PrefsType));
  47.     *fileAliasHandlePtr = nil;
  48.  
  49.  
  50.     /* open (but don't create) the prefs file */
  51.     
  52.     if ( -1 != (prefsResRefNum = OpenPrefsResFile(fsRdPerm, false, kPrefsNameStrID)))
  53.     {
  54.         /* file opened successfully, get the prefs resource */
  55.         
  56.         tempHandle = Get1Resource(kPrefsResourceType, kPrefsResourceID);
  57.         
  58.         /* 
  59.          * Assertion: left to right evaluation
  60.          */
  61.         
  62.         if (    (tempHandle != nil) &&
  63.                 (GetHandleSize(tempHandle) == sizeof(PrefsType)) &&
  64.                 ((*(PrefsType *)*tempHandle).prefsTypeVers == wantedVers)
  65.             )
  66.         {
  67.             /*
  68.              * copy the prefs struct and close file
  69.              */
  70.              
  71.             *thePrefsTypePtr = *(PrefsType *)*tempHandle;
  72.             
  73.             /* if there's also an alias, get and detach that, too */
  74.             
  75.             if (thePrefsTypePtr->Folder.UseDestFolder)
  76.             {
  77.                 /* don't orphan a previous alias handle */
  78.                 if (*fileAliasHandlePtr != nil)
  79.                     DisposHandle((Handle) *fileAliasHandlePtr);
  80.                             
  81.                 *fileAliasHandlePtr = (AliasHandle)
  82.                     Get1Resource(rAliasType, thePrefsTypePtr->Folder.folderAliasID);
  83.                         
  84.                 if (*fileAliasHandlePtr != nil)
  85.                     DetachResource((Handle) *fileAliasHandlePtr);
  86.             }
  87.             
  88.             CloseResFile(prefsResRefNum);
  89.         }
  90.         else
  91.         {
  92.             /*
  93.              * Current prefs can no longer be used
  94.              * because they are incompatible with current prefs version
  95.              * or otherwise malformed.
  96.              */
  97.             CloseResFile(prefsResRefNum);
  98.             return false;
  99.         }
  100.         return true;
  101.     }
  102.     else
  103.         return false;
  104. }
  105.  
  106. OSErr SavePrefs(PrefsType * thePrefsTypePtr, AliasHandle * fileAliasHandlePtr )
  107. {
  108.     OSErr    retCode;
  109.     short    prefsResRefNum;
  110.     Handle    prefHandle,
  111.             alisHandle,
  112.             finderMessageHandle;
  113.     
  114.     /* open (and, if necessary, create) the prefs file */
  115.     prefsResRefNum = OpenPrefsResFile(fsRdWrPerm, true, kPrefsNameStrID);
  116.     if (prefsResRefNum != -1)
  117.     {
  118.         /* file opened successfully, get the prefs resource */
  119.         prefHandle = Get1Resource(kPrefsResourceType, kPrefsResourceID);
  120.         
  121.         if (prefHandle == nil)
  122.         {
  123.             /* create a new resource */
  124.             prefHandle = NewHandle(sizeof(PrefsType));
  125.             if (prefHandle != nil)
  126.             {
  127.                 /* copy the prefs struct into the handle
  128.                    and make it into a resource */
  129.                 
  130.                 *(PrefsType *)*prefHandle = *thePrefsTypePtr;
  131.                 AddResource(prefHandle, kPrefsResourceType, kPrefsResourceID, "\pPrefsType");
  132.                 retCode = ResError();
  133.                 if (retCode != noErr)
  134.                     DisposHandle(prefHandle);
  135.             } 
  136.             else
  137.                 retCode = MemError(); /* NewHandle failed */
  138.         }
  139.         else
  140.         {  /* prefHandle != nil */
  141.         
  142.             /* update the existing resource */
  143.             SetHandleSize(prefHandle, sizeof(PrefsType));
  144.             retCode = MemError();
  145.             if (retCode == noErr)
  146.             {
  147.                 /* copy the prefs struct into the handle and tell the rsrc manager */
  148.                 *(PrefsType *)*prefHandle = *thePrefsTypePtr;
  149.                 ChangedResource(prefHandle);
  150.             }
  151.         }
  152.         if (retCode == noErr)
  153.         {
  154.             /* now, get rid of the old fileAlias and, if the fileAliasID field
  155.                of the prefs struct indicates that there is a new one, add it to
  156.                the resource file */
  157.                
  158.             /* remove any old file alias */
  159.             alisHandle = Get1Resource(rAliasType, thePrefsTypePtr->Folder.folderAliasID);
  160.             if (alisHandle != nil) {
  161.                 RmveResource(alisHandle);
  162.                 DisposHandle(alisHandle);
  163.             }
  164.             
  165.             /* if appropriate, add the current alias to the resource file */
  166.             
  167.             if ( thePrefsTypePtr->Folder.UseDestFolder && *fileAliasHandlePtr != nil)
  168.             {
  169.                 AddResource((Handle) *fileAliasHandlePtr, rAliasType, 
  170.                     thePrefsTypePtr->Folder.folderAliasID, "\pfolder alias");
  171.                     
  172.                 /* keep the alias available */
  173.                 DetachResource((Handle) *fileAliasHandlePtr);
  174.             }
  175.             
  176.             /* add the message to be displayed if the user tries
  177.                to open the prefs file in the Finder (but don't add it
  178.                if it's already in the preferences file) */
  179.                
  180.             finderMessageHandle = (Handle) GetString(kFinderMessageStrID);
  181.             if (finderMessageHandle != nil &&
  182.                 HomeResFile((Handle) finderMessageHandle) != prefsResRefNum)
  183.             {
  184.                 /* copy the resource into the prefs file */
  185.                 DetachResource(finderMessageHandle);
  186.                 AddResource(finderMessageHandle, kStrType, kFinderMessageStrID,
  187.                     "\pFinder message");
  188.                     
  189.                 /* if AddResource failed, dispose of the handle */
  190.                 retCode = ResError();
  191.                 if (retCode != noErr) DisposHandle(finderMessageHandle);
  192.             }
  193.         }
  194.         
  195.         /* update and close the preference resource file, 
  196.            releasing its resources from memory */
  197.         CloseResFile(prefsResRefNum);
  198.     }
  199.     
  200.     else
  201.     {
  202.         /* couldn't open the res file */
  203.         retCode = ResError();
  204.         if (retCode == noErr) retCode = resFNotFound;
  205.     }
  206.     
  207.     return retCode;
  208. }
  209.  
  210. /******************************************************************************/
  211.  
  212. short OpenPrefsResFile(SignedByte prefsPerm, Boolean createFlag, short StrID)
  213. /* open the preferences file with the given permission; if createFlag is set,
  214.    create a preferences file if necessary */
  215. {
  216.     OSErr    retCode;
  217.     short    prefsVRefNum;
  218.     long    prefsDirID;
  219.     Str255    prefsNameStr;
  220.     FSSpec    prefsFSSpec;
  221.     short    prefsResRefNum;
  222.     
  223.     prefsResRefNum = -1;
  224.  
  225.     if (noErr == (retCode = GetPrefsName(prefsNameStr, StrID)) )
  226.     {
  227.  
  228.         retCode = FindFolder(    kOnSystemDisk,
  229.                                 kPreferencesFolderType,
  230.                                 kCreateFolder,
  231.                                 &prefsVRefNum,
  232.                                 &prefsDirID);
  233.                                 
  234.         if (retCode == noErr) {
  235.         
  236.             /* make a file spec for the prefs file */
  237.             
  238.             retCode = FSMakeFSSpec(prefsVRefNum, prefsDirID, prefsNameStr, &prefsFSSpec);
  239.                 
  240.             if (retCode == fnfErr && createFlag)
  241.             {
  242.                 /* prefs file doesn't already exist, so create it */
  243.                 FSpCreateResFile(&prefsFSSpec, kPrefsCreatorType, kPrefsFileType, smSystemScript);
  244.                 retCode = ResError();
  245.             }
  246.             
  247.             /* open the prefs file */
  248.             if (retCode == noErr)
  249.             {
  250.                 prefsResRefNum = FSpOpenResFile(&prefsFSSpec, prefsPerm);
  251.             }
  252.         }
  253.     }
  254.     return prefsResRefNum;
  255. }
  256.  
  257. static OSErr GetPrefsName (StringPtr prefName, short StrID)
  258. /* get the name of the preferences file from a resource in the application */
  259. {
  260.     StringHandle prefStrHandle;
  261.     OSErr retCode = noErr;
  262.     
  263.     if ( nil != (prefStrHandle = GetString(StrID))) 
  264.         BlockMove(*prefStrHandle, prefName, (Size) (**prefStrHandle) + 1);
  265.     else
  266.         retCode = resNotFound;
  267.     
  268.     return retCode;
  269. }
  270.  
  271.  
  272.  
  273.