workbench/prefs/pointer/prefs.c

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