home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 2: PC / frozenfish_august_1995.bin / bbs / d09xx / d0912.lha / Yak / Source / Source.lha / settings.c < prev    next >
C/C++ Source or Header  |  1993-07-31  |  9KB  |  306 lines
  1.  /*
  2.  * Variables controlling Yak settings.
  3.  * Routines for initialisation at startup.
  4.  */
  5.  
  6. #include <exec/types.h>
  7. #include <dos/dos.h>
  8. #include <dos/dosextens.h>
  9. #include <libraries/commodities.h>
  10. #include <proto/dos.h>
  11. #include <string.h>
  12.  
  13. #include "yak.h"
  14. #include "hotkey_types.h"
  15. #include "popup.h"
  16.  
  17. extern struct DosLibrary *DOSBase;
  18.  
  19.  
  20. /* local prototypes */
  21. static BOOL __regargs FWriteLong(BPTR fh, LONG n);
  22. static BOOL __regargs FReadLong(BPTR fh, LONG *n);
  23. static BOOL __regargs FWriteString(BPTR fh, char *buf);
  24. static BOOL __regargs FReadString(BPTR fh, char *buf, LONG len);
  25. static void LoadHotKeys(void);
  26. static void SaveHotKeys(void);
  27.  
  28. #define DEF_VOLUME      48
  29. LONG    click_volume = DEF_VOLUME;              /* used for keyclick */
  30.  
  31. #define DEF_BLANKSECS   300
  32. LONG    blanksecs = DEF_BLANKSECS;
  33. LONG    blanktimeout;
  34. LONG    blankcount;                             /* countdown to blank-time */
  35.  
  36. #define DEF_MBLANKSECS  5
  37. LONG    mouseblank = MB_SPRITES;
  38. LONG    mblanksecs = DEF_MBLANKSECS;
  39. LONG    mblanktimeout;
  40. LONG    mblankcount;                    /* countdown to mouse-blank-time */
  41.  
  42. TOGGLEDATA toggles[] = {                /* -1 means UNUSED */
  43.         TRUE,   GDX_CTFCheck,
  44.         TRUE,   GDX_CTBCheck,
  45.         TRUE,   GDX_AutoCheck,
  46.         FALSE,  GDX_KeyActCheck,
  47.         TRUE,   GDX_ScrCycleCheck,
  48.         FALSE,  GDX_AutoPopCheck,
  49.         FALSE,  GDX_RMBActCheck,
  50.         FALSE,  -1,
  51.         FALSE,  -1,
  52.         FALSE,  GDX_WildStarCheck,
  53.         TRUE,   GDX_ScrActCheck
  54. };
  55.  
  56. PATTERNDATA patterns[NUM_PATTERNS] = {
  57.         { "#?", NULL },                 /* autoactivation screens */
  58.         { "#?", NULL },                 /* click screens */
  59.         { "~(Workbench)", NULL },       /* autopop windows */
  60.         { "~(Workbench)", NULL }        /* click windows */
  61. };
  62.  
  63. /* 1.5 format
  64.  * Routines to load/save config file for Yak.
  65.  * Should handle config files in upward-compatible manner.
  66.  * File format:
  67.  *
  68.  *      LONG ID
  69.  *      LONG NUM_TOGGLES
  70.  *      BOOL toggles
  71.  *      LONG NUM_HOTKEYS                **REMOVED @ v1.5
  72.  *      STR hotkey1 '\n'                        :
  73.  *              :                               :
  74.  *      STR hotkeyN '\n'                        :
  75.  *      LONG NUM_PATTERNS
  76.  *      STR pattern1 '\n'
  77.  *              :
  78.  *      STR patternN '\n'
  79.  *      STR popcommand '\n'             **REMOVED @ v1.5
  80.  *      STR datefmt '\n'                **REMOVED @ v1.5
  81.  *      LONG click_volume, blanksecs
  82.  *      LONG mblanksecs                 **ADDED @ v1.3b
  83.  *      LONG mouseblank                 **ADDED @ v1.3e
  84.  */
  85.  
  86. #define CONFIG_ID       0x594b3135      /* YK15 */
  87.  
  88. /* write a LONG to a file (in binary format) - returns success*/
  89. static BOOL __regargs
  90. FWriteLong(BPTR fh, LONG n)
  91. {
  92.         return (BOOL)(FWrite(fh, (UBYTE *)&n, sizeof(LONG), 1) == 1);
  93. }
  94.  
  95. /* read a LONG to a file (in binary format) - returns success */
  96. static BOOL __regargs
  97. FReadLong(BPTR fh, LONG *n)
  98. {
  99.         return (BOOL)(FRead(fh, (UBYTE *)n, sizeof(LONG), 1) == 1);
  100. }
  101.  
  102. /* write a string to a file (in binary format) - returns success*/
  103. /* '\n' is appended */
  104. static BOOL __regargs
  105. FWriteString(BPTR fh, char *buf)
  106. {
  107.         FPuts(fh, buf);
  108.         FPutC(fh, '\n');
  109.         return (BOOL)(IoErr() == 0);
  110. }
  111.  
  112. /* read a string to a file (in binary format) - returns success */
  113. /* '\n' is stripped and buf null-terminated; assumes dest large enough */
  114. static BOOL __regargs
  115. FReadString(BPTR fh, char *buf, LONG len)
  116. {
  117.         FGets(fh, buf, len-1);
  118.         buf[strlen(buf)-1] = '\0';      /* '\n' --> '\0' */
  119.         return (BOOL)(IoErr() == 0);
  120. }
  121.  
  122. /* save current settings to config file */
  123. void
  124. SaveSettings()
  125. {
  126.         BPTR    fh;
  127.         UWORD   i;
  128.  
  129.         if (fh = Open(CONFIG_FILE, MODE_NEWFILE))
  130.         {
  131.                 FWriteLong(fh, CONFIG_ID);
  132.  
  133.                 /* toggles */
  134.                 FWriteLong(fh, NUM_TOGGLES);
  135.                 for (i = 0; i < NUM_TOGGLES; i++)
  136.                         FWrite(fh, (UBYTE *)&toggles[i].pos, sizeof(BOOL), 1);
  137.  
  138.                 /* patterns */
  139.                 FWriteLong(fh, NUM_PATTERNS);
  140.                 for (i = 0; i < NUM_PATTERNS; i++)
  141.                         FWriteString(fh, patterns[i].patstr);
  142.  
  143.                 /* miscellaneous */
  144.                 FWriteLong(fh, click_volume);
  145.                 FWriteLong(fh, blanksecs);
  146.                 FWriteLong(fh, mblanksecs);
  147.                 FWriteLong(fh, mouseblank);
  148.  
  149.                 Close(fh);
  150.         }
  151.  
  152.         SaveHotKeys();
  153. }
  154.  
  155.  
  156.  
  157. /* load current settings from file */
  158. void
  159. LoadSettings()
  160. {
  161.         BPTR    fh;
  162.         UWORD   i;
  163.         LONG    n;
  164.  
  165.         if (fh = Open(CONFIG_FILE, MODE_OLDFILE))
  166.         {
  167.                 FReadLong(fh, &n);
  168.                 if (n == CONFIG_ID)
  169.                 {
  170.                         /* toggles */
  171.                         FReadLong(fh, &n);
  172.                         for (i = 0; i < n; i++)
  173.                                 FRead(fh, (UBYTE *)&toggles[i].pos, sizeof(BOOL), 1);
  174.  
  175.                         /* patterns */
  176.                         FReadLong(fh, &n);
  177.                         for (i = 0; i < n; i++)
  178.                                 FReadString(fh, patterns[i].patstr, PATLEN+1);
  179.  
  180.                         /* miscellaneous */
  181.                         FReadLong(fh, &click_volume);
  182.                         FReadLong(fh, &blanksecs);
  183.                         if (!FReadLong(fh, &mblanksecs))        /* none there */
  184.                                 mblanksecs = DEF_MBLANKSECS;
  185.                         if (!FReadLong(fh, &mouseblank))        /* none there */
  186.                                 mouseblank = MB_SPRITES;
  187.                 }
  188.                 else PostError("Invalid config file");
  189.                 Close(fh);
  190.         }
  191.  
  192.         DeleteYakHotKeyList();          /* delete old keys */
  193.         LoadHotKeys();                  /* and load new ones */
  194.  
  195.         /* set-up patterns */
  196.         for (i = 0; i < NUM_PATTERNS; i++)
  197.                 InitPattern(NULL, i);
  198.  
  199.         if (wildstar)
  200.                 WILDSTARON;
  201.         else
  202.                 wildstar = ((struct RootNode *)(DOSBase->dl_Root))->rn_Flags & RNF_WILDSTAR;
  203.         blankcount = blanktimeout = 10*blanksecs;
  204.         mblankcount = mblanktimeout = 10*mblanksecs;
  205. }
  206.  
  207. /*
  208.  *      HOTKEY FILE FORMAT
  209.  *
  210.  *      LONG    ID      'YKK1'
  211.  *      LONG NUM_HOTKEYS
  212.  *      UWORD type1
  213.  *      UWORD opts1
  214.  *      STR hotkey1 '\n'
  215.  *      STR argstr1 '\n'
  216.  *              :
  217.  *      STR hotkeyN '\n'
  218.  */
  219. #define HOTKEY_ID 0x594B4B31    /* 'YKK1' */
  220.  
  221. static void
  222. SaveHotKeys()
  223. {
  224.         YakHotKey *yhk;
  225.         BPTR    fh;
  226.         UWORD   type, i;
  227.  
  228.         if (fh = Open(HOTKEY_FILE, MODE_NEWFILE))
  229.         {
  230.                 FWriteLong(fh, HOTKEY_ID);
  231.  
  232.                 FWriteLong(fh, num_hkeys);
  233.                 for (type = 0; type < NUM_HOTKEY_TYPES; type++)
  234.                         for (yhk = (YakHotKey *)keylist(type)->lh_Head, i = 0;
  235.                              i < numkeys(type);
  236.                              i++, yhk = (YakHotKey *)yhk->yhk_Node.ln_Succ)
  237.                         {
  238.                                 FWrite(fh, (UBYTE *)&yhk->yhk_Type, sizeof(UWORD), 1);
  239.                                 FWrite(fh, (UBYTE *)&yhk->yhk_Options, sizeof(UWORD), 1);
  240.                                 FWriteString(fh, yhk->yhk_KeyDef);
  241.                                 FWriteString(fh, yhk->yhk_ArgStr ? yhk->yhk_ArgStr : "");
  242.                         }
  243.  
  244.                 Close(fh);
  245.         }
  246. }
  247.  
  248. static void
  249. LoadHotKeys()
  250. {
  251.         YakHotKey *yhk;
  252.         char    *buf;
  253.         UWORD   type, opts;
  254.         BPTR    fh;
  255.         LONG    n;
  256.         UWORD   i;
  257.  
  258.         if (!(buf = AllocVec(512, 0L)))
  259.         {
  260.                 PostError("No memory");
  261.                 return;
  262.         }
  263.  
  264.         if (fh = Open(HOTKEY_FILE, MODE_OLDFILE))
  265.         {
  266.                 FReadLong(fh, &n);
  267.  
  268.                 if (n == HOTKEY_ID)
  269.                 {
  270.                         FReadLong(fh, &n);
  271.                         for (i = 0; i < n; i++)
  272.                         {
  273.                           FRead(fh, (UBYTE *)&type, sizeof(UWORD), 1);
  274.                           FRead(fh, (UBYTE *)&opts, sizeof(UWORD), 1);
  275.  
  276.                           if (type >= NUM_HOTKEY_TYPES)
  277.                           {
  278.                             /* ignore key definition */
  279.                             FReadString(fh, buf, 512);
  280.                             FReadString(fh, buf, 512);
  281.                             continue;
  282.                           }
  283.  
  284.                           if (yhk = NewYakHotKey(type))
  285.                           {
  286.                             yhk->yhk_Options = opts;
  287.                             FReadString(fh, buf, 512);
  288.                             if (ModifyYHKKeyDef(yhk, buf))
  289.                             {
  290.                               FReadString(fh, buf, 512);
  291.                               if (!buf[0] || ModifyYHKArgStr(yhk, buf))
  292.                               {
  293.                                 continue;
  294.                               }
  295.                             }
  296.                           }
  297.                           PostError("Error reading hotkey file");
  298.                           DeleteYakHotKeyList();
  299.                           break;
  300.                         }
  301.                 }
  302.                 Close(fh);
  303.         }
  304.         FreeVec(buf);
  305. }
  306.