workbench/prefs/icontrol/prefs.c

   1 /*
   2    Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3    $Id$
   4
   5    Desc:
   6    Lang: English
   7 */
   8
   9 /*********************************************************************************************/
  10
  11 #include <aros/macros.h>
  12
  13 #define DEBUG 0
  14 #include <aros/debug.h>
  15
  16 #include <proto/exec.h>
  17 #include <proto/dos.h>
  18 #include <proto/iffparse.h>
  19
  20 #include <prefs/prefhdr.h>
  21 #include <devices/inputevent.h>
  22
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26
  27 #include "prefs.h"
  28 #include "misc.h"
  29
  30 /*********************************************************************************************/
  31
  32 #define PREFS_PATH_ENVARC "ENVARC:SYS/icontrol.prefs"
  33 #define PREFS_PATH_ENV    "ENV:SYS/icontrol.prefs"
  34
  35 /*********************************************************************************************/
  36
  37 struct FilePrefHeader
  38 {
  39     UBYTE ph_Version;
  40     UBYTE ph_Type;
  41     UBYTE ph_Flags[4];
  42 };
  43
  44 /*********************************************************************************************/
  45
  46 struct IControlPrefs icontrolprefs;
  47
  48 /*********************************************************************************************/
  49
  50 static BOOL Prefs_Load(STRPTR from)
  51 {
  52     BOOL retval = FALSE;
  53
  54     BPTR fh = Open(from, MODE_OLDFILE);
  55     if (fh)
  56     {
  57         retval = Prefs_ImportFH(fh);
  58         Close(fh);
  59     }
  60
  61     return retval;
  62 }
  63
  64 /*********************************************************************************************/
  65
  66 BOOL Prefs_ImportFH(BPTR fh)
  67 {
  68     struct IControlPrefs    loadprefs;
  69     struct IFFHandle       *iff;
  70     BOOL                    retval = FALSE;
  71
  72     if ((iff = AllocIFF()))
  73     {
  74         iff->iff_Stream = (IPTR)fh;
  75
  76         InitIFFasDOS(iff);
  77
  78         if (!OpenIFF(iff, IFFF_READ))
  79         {
  80             D(bug("LoadPrefs: OpenIFF okay.\n"));
  81
  82             if (!StopChunk(iff, ID_PREF, ID_ICTL))
  83             {
  84                 D(bug("LoadPrefs: StopChunk okay.\n"));
  85
  86                 if (!ParseIFF(iff, IFFPARSE_SCAN))
  87                 {
  88                     struct ContextNode *cn;
  89
  90                     D(bug("LoadPrefs: ParseIFF okay.\n"));
  91
  92                     cn = CurrentChunk(iff);
  93
  94                     if (cn->cn_Size == sizeof(struct IControlPrefs))
  95                     {
  96                         D(bug("LoadPrefs: ID_ICTL chunk size okay.\n"));
  97
  98                         if (ReadChunkBytes(iff, &loadprefs, sizeof(struct IControlPrefs)) == sizeof(struct IControlPrefs))
  99                         {
 100                             D(bug("LoadPrefs: Reading chunk successful.\n"));
 101
 102                             CopyMem(loadprefs.ic_Reserved, icontrolprefs.ic_Reserved, sizeof(icontrolprefs.ic_Reserved));
 103
 104                             icontrolprefs.ic_TimeOut        = AROS_BE2WORD(loadprefs.ic_TimeOut);
 105                             icontrolprefs.ic_MetaDrag       = AROS_BE2WORD(loadprefs.ic_MetaDrag);
 106                             icontrolprefs.ic_Flags          = AROS_BE2LONG(loadprefs.ic_Flags);
 107                             icontrolprefs.ic_WBtoFront      = loadprefs.ic_WBtoFront;
 108                             icontrolprefs.ic_FrontToBack    = loadprefs.ic_FrontToBack;
 109                             icontrolprefs.ic_ReqTrue        = loadprefs.ic_ReqTrue;
 110                             icontrolprefs.ic_ReqFalse       = loadprefs.ic_ReqFalse;
 111                             icontrolprefs.ic_Reserved2      = AROS_BE2WORD(loadprefs.ic_Reserved2);
 112                             icontrolprefs.ic_VDragModes[0]  = AROS_BE2WORD(loadprefs.ic_VDragModes[0]);
 113                             icontrolprefs.ic_VDragModes[1]  = AROS_BE2WORD(loadprefs.ic_VDragModes[1]);
 114
 115                             D(bug("LoadPrefs: Everything okay :-)\n"));
 116
 117                             retval = TRUE;
 118                         }
 119                     }
 120                 } /* if (!ParseIFF(iff, IFFPARSE_SCAN)) */
 121             } /* if (!StopChunk(iff, ID_PREF, ID_ICTL)) */
 122             CloseIFF(iff);
 123         } /* if (!OpenIFF(iff, IFFF_READ)) */
 124         FreeIFF(iff);
 125     } /* if ((iff = AllocIFF())) */
 126     return retval;
 127 }
 128
 129 /*********************************************************************************************/
 130
 131 BOOL Prefs_ExportFH(BPTR fh)
 132 {
 133     struct IControlPrefs    saveprefs;
 134     struct IFFHandle       *iff;
 135     BOOL                    retval = FALSE;
 136 #if 0 /* unused */
 137     BOOL                    delete_if_error = FALSE;
 138 #endif
 139
 140     CopyMem(icontrolprefs.ic_Reserved, saveprefs.ic_Reserved, sizeof(icontrolprefs.ic_Reserved));
 141
 142     saveprefs.ic_TimeOut        = AROS_WORD2BE(icontrolprefs.ic_TimeOut);
 143     saveprefs.ic_MetaDrag       = AROS_WORD2BE(icontrolprefs.ic_MetaDrag);
 144     saveprefs.ic_Flags          = AROS_LONG2BE(icontrolprefs.ic_Flags);
 145     saveprefs.ic_WBtoFront      = icontrolprefs.ic_WBtoFront;
 146     saveprefs.ic_FrontToBack    = icontrolprefs.ic_FrontToBack;
 147     saveprefs.ic_ReqTrue        = icontrolprefs.ic_ReqTrue;
 148     saveprefs.ic_ReqFalse       = icontrolprefs.ic_ReqFalse;
 149     saveprefs.ic_Reserved2      = AROS_WORD2BE(icontrolprefs.ic_Reserved2);
 150     saveprefs.ic_VDragModes[0]  = AROS_WORD2BE(icontrolprefs.ic_VDragModes[0]);
 151     saveprefs.ic_VDragModes[1]  = AROS_WORD2BE(icontrolprefs.ic_VDragModes[1]);
 152
 153     D(bug("SavePrefsFH: fh: %lx\n", fh));
 154
 155     if ((iff = AllocIFF()))
 156     {
 157         iff->iff_Stream = (IPTR) fh;
 158         D(bug("SavePrefsFH: stream opened.\n"));
 159
 160 #if 0 /* unused */
 161         delete_if_error = TRUE;
 162 #endif
 163
 164         InitIFFasDOS(iff);
 165
 166         if (!OpenIFF(iff, IFFF_WRITE))
 167         {
 168             D(bug("SavePrefsFH: OpenIFF okay.\n"));
 169
 170             if (!PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN))
 171             {
 172                 D(bug("SavePrefsFH: PushChunk(FORM) okay.\n"));
 173
 174                 if (!PushChunk(iff, ID_PREF, ID_PRHD, sizeof(struct FilePrefHeader)))
 175                 {
 176                     struct FilePrefHeader head;
 177
 178                     D(bug("SavePrefsFH: PushChunk(PRHD) okay.\n"));
 179
 180                     head.ph_Version  = PHV_CURRENT;
 181                     head.ph_Type     = 0;
 182                     head.ph_Flags[0] =
 183                     head.ph_Flags[1] =
 184                     head.ph_Flags[2] =
 185                     head.ph_Flags[3] = 0;
 186
 187                     if (WriteChunkBytes(iff, &head, sizeof(head)) == sizeof(head))
 188                     {
 189                         D(bug("SavePrefsFH: WriteChunkBytes(PRHD) okay.\n"));
 190
 191                         PopChunk(iff);
 192
 193                         if (!PushChunk(iff, ID_PREF, ID_ICTL, sizeof(struct IControlPrefs)))
 194                         {
 195                             D(bug("SavePrefsFH: PushChunk(LCLE) okay.\n"));
 196
 197                             if (WriteChunkBytes(iff, &saveprefs, sizeof(saveprefs)) == sizeof(saveprefs))
 198                             {
 199                                 D(bug("SavePrefsFH: WriteChunkBytes(ICTL) okay.\n"));
 200                                 D(bug("SavePrefsFH: Everything okay :-)\n"));
 201
 202                                 retval = TRUE;
 203                             }
 204                             PopChunk(iff);
 205                         } /* if (!PushChunk(iff, ID_PREF, ID_ICTL, sizeof(struct IControlPrefs))) */
 206                     } /* if (WriteChunkBytes(iff, &head, sizeof(head)) == sizeof(head)) */
 207                     else
 208                     {
 209                         PopChunk(iff);
 210                     }
 211                 } /* if (!PushChunk(iff, ID_PREF, ID_PRHD, sizeof(struct PrefHeader))) */
 212                 PopChunk(iff);
 213             } /* if (!PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN)) */
 214             CloseIFF(iff);
 215         } /* if (!OpenIFF(iff, IFFFWRITE)) */
 216         FreeIFF(iff);
 217
 218     } /* if ((iff = AllocIFF())) */
 219
 220 #if 0 /* unused */
 221     if (!retval && delete_if_error)
 222     {
 223         DeleteFile(filename);
 224     }
 225 #endif
 226
 227     return retval;
 228 }
 229
 230 /*********************************************************************************************/
 231
 232 BOOL Prefs_HandleArgs(STRPTR from, BOOL use, BOOL save)
 233 {
 234     BPTR fh;
 235
 236     if (from)
 237     {
 238         if (!Prefs_Load(from))
 239         {
 240             ShowMessage("Can't read from input file");
 241             return FALSE;
 242         }
 243     }
 244     else
 245     {
 246         if (!Prefs_Load(PREFS_PATH_ENV))
 247         {
 248             if (!Prefs_Load(PREFS_PATH_ENVARC))
 249             {
 250                 ShowMessage
 251                 (
 252                     "Can't read from file " PREFS_PATH_ENVARC
 253                     ".\nUsing default values."
 254                 );
 255                 Prefs_Default();
 256             }
 257         }
 258     }
 259
 260     if (use || save)
 261     {
 262         fh = Open(PREFS_PATH_ENV, MODE_NEWFILE);
 263         if (fh)
 264         {
 265             Prefs_ExportFH(fh);
 266             Close(fh);
 267         }
 268         else
 269         {
 270             ShowMessage("Cant' open " PREFS_PATH_ENV " for writing.");
 271         }
 272     }
 273     if (save)
 274     {
 275         fh = Open(PREFS_PATH_ENVARC, MODE_NEWFILE);
 276         if (fh)
 277         {
 278             Prefs_ExportFH(fh);
 279             Close(fh);
 280         }
 281         else
 282         {
 283             ShowMessage("Cant' open " PREFS_PATH_ENVARC " for writing.");
 284         }
 285     }
 286     return TRUE;
 287 }
 288
 289 /*********************************************************************************************/
 290
 291 BOOL Prefs_Default(VOID)
 292 {
 293     icontrolprefs.ic_Reserved[0] = 0;
 294     icontrolprefs.ic_Reserved[1] = 0;
 295     icontrolprefs.ic_Reserved[2] = 0;
 296     icontrolprefs.ic_Reserved[3] = 0;
 297     icontrolprefs.ic_TimeOut = 50;
 298     icontrolprefs.ic_MetaDrag = IEQUALIFIER_LCOMMAND;
 299     icontrolprefs.ic_Flags = ICF_3DMENUS |
 300         ICF_MODEPROMOTE |
 301         ICF_MENUSNAP |
 302         ICF_STRGAD_FILTER |
 303         ICF_COERCE_LACE |
 304         ICF_OFFSCREENLAYERS;
 305         /* FIXME: check whether ICF_DEFPUBSCREEN is set as default */
 306     icontrolprefs.ic_WBtoFront = 'N';
 307     icontrolprefs.ic_FrontToBack = 'M';
 308     icontrolprefs.ic_ReqTrue = 'V';
 309     icontrolprefs.ic_ReqFalse = 'B';
 310     icontrolprefs.ic_VDragModes[0] = 0;
 311     icontrolprefs.ic_VDragModes[1] = 0;
 312
 313     return TRUE;
 314 }