workbench/prefs/palette/prefs.c

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