workbench/prefs/screenmode/prefs.c

   1 /*
   2     Copyright © 2010-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 0
   7 #include <aros/debug.h>
   8
   9 #include <intuition/preferences.h>
  10 #include <prefs/screenmode.h>
  11 #include <prefs/prefhdr.h>
  12 #include <graphics/modeid.h>
  13
  14 #include <proto/dos.h>
  15 #include <proto/exec.h>
  16 #include <proto/iffparse.h>
  17 #include <proto/intuition.h>
  18
  19 #include <stdio.h>
  20 #include <string.h>
  21
  22 #include "prefs.h"
  23 #include "misc.h"
  24
  25 #ifdef BIGENDIAN_PREFS
  26 #define GET_WORD AROS_BE2WORD
  27 #define GET_LONG AROS_BE2LONG
  28 #else
  29 #define GET_WORD(x) x
  30 #define GET_LONG(x) x
  31 #endif
  32
  33 /*********************************************************************************************/
  34
  35 #define PREFS_PATH_ENVARC "ENVARC:SYS/screenmode.prefs"
  36 #define PREFS_PATH_ENV    "ENV:SYS/screenmode.prefs"
  37
  38 /*********************************************************************************************/
  39
  40 struct ScreenModePrefs screenmodeprefs;
  41
  42 /*********************************************************************************************/
  43
  44 static BOOL Prefs_Load(STRPTR from)
  45 {
  46     BOOL retval = FALSE;
  47
  48     BPTR fh = Open(from, MODE_OLDFILE);
  49     if (fh)
  50     {
  51         retval = Prefs_ImportFH(fh);
  52         Close(fh);
  53     }
  54
  55     return retval;
  56 }
  57
  58 /*********************************************************************************************/
  59
  60 BOOL Prefs_ImportFH(BPTR fh)
  61 {
  62     struct IFFHandle       *handle;
  63     struct ScreenModePrefs  loadprefs = {{0},0};
  64     BOOL                    success = TRUE;
  65     LONG                    error;
  66
  67     if (!(handle = AllocIFF()))
  68         return FALSE;
  69
  70     handle->iff_Stream = (IPTR)fh;
  71     InitIFFasDOS(handle);
  72
  73     if ((error = OpenIFF(handle, IFFF_READ)) == 0)
  74     {
  75         // FIXME: We want some sanity checking here!
  76         if ((error = StopChunk(handle, ID_PREF, ID_SCRM)) == 0)
  77         {
  78             if ((error = ParseIFF(handle, IFFPARSE_SCAN)) == 0)
  79             {
  80                 error = ReadChunkBytes
  81                 (
  82                     handle, &loadprefs, sizeof(struct ScreenModePrefs)
  83                 );
  84
  85                 if (error < 0)
  86                 {
  87                     printf("Error: ReadChunkBytes() returned %d!\n", (int)error);
  88                 }
  89                 else
  90                 {
  91                     CopyMem(loadprefs.smp_Reserved, screenmodeprefs.smp_Reserved, sizeof(screenmodeprefs.smp_Reserved));
  92                     screenmodeprefs.smp_DisplayID = GET_LONG(loadprefs.smp_DisplayID);
  93                     screenmodeprefs.smp_Width     = GET_WORD(loadprefs.smp_Width);
  94                     screenmodeprefs.smp_Height    = GET_WORD(loadprefs.smp_Height);
  95                     screenmodeprefs.smp_Depth     = GET_WORD(loadprefs.smp_Depth);
  96                     screenmodeprefs.smp_Control   = AROS_BE2WORD(loadprefs.smp_Control);
  97                 }
  98             }
  99             else
 100             {
 101                 printf("ParseIFF() failed, returncode %d!\n", (int)error);
 102                 success = FALSE;
 103             }
 104         }
 105         else
 106         {
 107             printf("StopChunk() failed, returncode %d!\n", (int)error);
 108             success = FALSE;
 109         }
 110
 111         CloseIFF(handle);
 112     }
 113     else
 114     {
 115         //ShowError(_(MSG_CANT_OPEN_STREAM));
 116     }
 117
 118     FreeIFF(handle);
 119
 120     return success;
 121 }
 122
 123 /*********************************************************************************************/
 124
 125 BOOL Prefs_ExportFH(BPTR fh)
 126 {
 127     struct PrefHeader       header = { 0 };
 128     struct IFFHandle       *handle;
 129     struct ScreenModePrefs  saveprefs;
 130     BOOL                    success = TRUE;
 131     LONG                    error   = 0;
 132
 133     CopyMem(screenmodeprefs.smp_Reserved, saveprefs.smp_Reserved, sizeof(screenmodeprefs.smp_Reserved));
 134     saveprefs.smp_DisplayID = GET_LONG(screenmodeprefs.smp_DisplayID);
 135     saveprefs.smp_Width     = GET_WORD(screenmodeprefs.smp_Width);
 136     saveprefs.smp_Height    = GET_WORD(screenmodeprefs.smp_Height);
 137     saveprefs.smp_Depth     = GET_WORD(screenmodeprefs.smp_Depth);
 138     saveprefs.smp_Control   = AROS_WORD2BE(screenmodeprefs.smp_Control);
 139
 140     if ((handle = AllocIFF()))
 141     {
 142         handle->iff_Stream = (IPTR)fh;
 143
 144         InitIFFasDOS(handle);
 145
 146         if (!(error = OpenIFF(handle, IFFF_WRITE))) /* NULL = successful! */
 147         {
 148             error = PushChunk(handle, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN); /* FIXME: IFFSIZE_UNKNOWN? */
 149
 150             if (!error)
 151             {
 152                 header.ph_Version = PHV_CURRENT;
 153                 header.ph_Type    = 0;
 154
 155                 error = PushChunk(handle, ID_PREF, ID_PRHD, IFFSIZE_UNKNOWN); /* FIXME: IFFSIZE_UNKNOWN? */
 156
 157                 if (!error)
 158                 {
 159                     WriteChunkBytes(handle, &header, sizeof(struct PrefHeader));
 160                     PopChunk(handle);
 161                 }
 162
 163                 if (!error)
 164                 {
 165                     error = PushChunk(handle, ID_PREF, ID_SCRM, sizeof(struct ScreenModePrefs));
 166                     if (!error)
 167                     {
 168                         WriteChunkBytes(handle, &saveprefs, sizeof(struct ScreenModePrefs));
 169                         PopChunk(handle);
 170                     }
 171                 }
 172
 173                 // Terminate the FORM
 174                 PopChunk(handle);
 175             }
 176
 177             if (error != 0) // TODO: We need some error checking here!
 178             {
 179                 char buf[256];
 180
 181                 NameFromFH(fh, buf, sizeof(buf));
 182                 printf("Error saving prefs file %s!\n", buf);
 183             }
 184         }
 185         else
 186         {
 187             //ShowError(_(MSG_CANT_OPEN_STREAM));
 188             success = FALSE;
 189         }
 190
 191         CloseIFF(handle);
 192         FreeIFF(handle);
 193     }
 194     else // AllocIFF()
 195     {
 196         // Do something more here - if IFF allocation has failed, something isn't right
 197         //ShowError(_(MSG_CANT_ALLOCATE_IFFPTR));
 198         success = FALSE;
 199     }
 200
 201     return success;
 202 }
 203
 204 /*********************************************************************************************/
 205
 206 BOOL Prefs_HandleArgs(STRPTR from, BOOL use, BOOL save)
 207 {
 208     BPTR fh;
 209
 210     if (from)
 211     {
 212         if (!Prefs_Load(from))
 213         {
 214             ShowMessage("Can't read from input file");
 215             return FALSE;
 216         }
 217     }
 218     else
 219     {
 220         if (!Prefs_Load(PREFS_PATH_ENV))
 221         {
 222             if (!Prefs_Load(PREFS_PATH_ENVARC))
 223             {
 224                 ShowMessage
 225                 (
 226                     "Can't read from file " PREFS_PATH_ENVARC
 227                     ".\nUsing default values."
 228                 );
 229                 Prefs_Default();
 230             }
 231         }
 232     }
 233
 234     if (use || save)
 235     {
 236         fh = Open(PREFS_PATH_ENV, MODE_NEWFILE);
 237         if (fh)
 238         {
 239             Prefs_ExportFH(fh);
 240             Close(fh);
 241         }
 242         else
 243         {
 244             ShowMessage("Can't open " PREFS_PATH_ENV " for writing.");
 245         }
 246     }
 247     if (save)
 248     {
 249         fh = Open(PREFS_PATH_ENVARC, MODE_NEWFILE);
 250         if (fh)
 251         {
 252             Prefs_ExportFH(fh);
 253             Close(fh);
 254         }
 255         else
 256         {
 257             ShowMessage("Can't open " PREFS_PATH_ENVARC " for writing.");
 258         }
 259     }
 260     return TRUE;
 261 }
 262
 263 /*********************************************************************************************/
 264
 265 BOOL Prefs_Default(VOID)
 266 {
 267     static struct Preferences def;
 268
 269     GetDefPrefs(&def, sizeof(def));
 270     screenmodeprefs.smp_Reserved[0] = 0;
 271     screenmodeprefs.smp_Reserved[1] = 0;
 272     screenmodeprefs.smp_Reserved[2] = 0;
 273     screenmodeprefs.smp_Reserved[3] = 0;
 274     screenmodeprefs.smp_DisplayID   = INVALID_ID;
 275     screenmodeprefs.smp_Width       = def.wb_Width;
 276     screenmodeprefs.smp_Height      = def.wb_Height;
 277     screenmodeprefs.smp_Depth       = def.wb_Depth;
 278     screenmodeprefs.smp_Control     = 0;
 279
 280     D(Printf("[Prefs_Default] Default Workbench screen: %ldx%ldx%ld\n",
 281              screenmodeprefs.smp_Width, screenmodeprefs.smp_Height, screenmodeprefs.smp_Depth));
 282
 283     return TRUE;
 284 }