workbench/prefs/font/prefs.c

   1 #include <prefs/prefhdr.h>
   2
   3 #include <proto/exec.h>
   4 #include <proto/dos.h>
   5 #include <proto/iffparse.h>
   6
   7 #include <string.h>
   8 #include <stdio.h>
   9
  10 #include "prefs.h"
  11 #include "misc.h"
  12 #include "locale.h"
  13
  14 #define PREFS_PATH_ENVARC "ENVARC:SYS/font.prefs"
  15 #define PREFS_PATH_ENV    "ENV:SYS/font.prefs"
  16
  17 /*** Utility Functions ******************************************************/
  18 static VOID convertEndian(struct FontPrefs *fp)
  19 {
  20     BYTE i;
  21
  22     for (i = 0; i <= 2; i++)
  23     {
  24         fp->fp_Reserved[i] = AROS_BE2LONG(fp->fp_Reserved[i]);
  25     }
  26
  27     fp->fp_Reserved2         = AROS_BE2WORD(fp->fp_Reserved2);
  28     fp->fp_Type              = AROS_BE2WORD(fp->fp_Type);
  29     fp->fp_TextAttr.ta_YSize = AROS_BE2WORD(fp->fp_TextAttr.ta_YSize);
  30 }
  31
  32 static VOID FileFontPrefs2FontPrefs(struct FileFontPrefs *ffp, struct FontPrefs *fp)
  33 {
  34     /* Copy field by field to avoid any alignment problems whatsoever */
  35     CopyMem(&ffp->fp_Reserved, &fp->fp_Reserved, sizeof(fp->fp_Reserved));
  36     CopyMem(&ffp->fp_Reserved2, &fp->fp_Reserved2, sizeof(fp->fp_Reserved2));
  37     CopyMem(&ffp->fp_Type, &fp->fp_Type, sizeof(fp->fp_Type));
  38     fp->fp_FrontPen = ffp->fp_FrontPen;
  39     fp->fp_BackPen = ffp->fp_BackPen;
  40     fp->fp_DrawMode = ffp->fp_Drawmode;
  41     fp->fp_TextAttr.ta_Name = fp->fp_Name;
  42     CopyMem
  43     (
  44         &ffp->fp_TextAttr_ta_YSize,
  45         &fp->fp_TextAttr.ta_YSize,
  46         sizeof(fp->fp_TextAttr.ta_YSize)
  47     );
  48     fp->fp_TextAttr.ta_Style = ffp->fp_TextAttr_ta_Style;
  49     fp->fp_TextAttr.ta_Flags = ffp->fp_TextAttr_ta_Flags;
  50     CopyMem(&ffp->fp_Name, &fp->fp_Name, FONTNAMESIZE);
  51 }
  52
  53 static VOID FontPrefs2FileFontPrefs(struct FontPrefs *fp, struct FileFontPrefs *ffp)
  54 {
  55     /* Copy field by field to avoid any alignment problems whatsoever */
  56     CopyMem(&fp->fp_Reserved, &ffp->fp_Reserved, sizeof(fp->fp_Reserved));
  57     CopyMem(&fp->fp_Reserved2, &ffp->fp_Reserved2, sizeof(fp->fp_Reserved2));
  58     CopyMem(&fp->fp_Type, &ffp->fp_Type, sizeof(fp->fp_Type));
  59     ffp->fp_FrontPen = fp->fp_FrontPen;
  60     ffp->fp_BackPen = fp->fp_BackPen;
  61     ffp->fp_Drawmode = fp->fp_DrawMode;
  62     /* fp->fp_TextAttr.ta_Name is not copied, it may have different sizes on
  63        different architectures and contains only a pointer, so I guess there's
  64        no need to write it on disk. */
  65     CopyMem
  66     (
  67         &fp->fp_TextAttr.ta_YSize,
  68         &ffp->fp_TextAttr_ta_YSize,
  69         sizeof(fp->fp_TextAttr.ta_YSize)
  70     );
  71     ffp->fp_TextAttr_ta_Style = fp->fp_TextAttr.ta_Style;
  72     ffp->fp_TextAttr_ta_Flags = fp->fp_TextAttr.ta_Flags;
  73     CopyMem(&fp->fp_Name, &ffp->fp_Name, FONTNAMESIZE);
  74 }
  75
  76 static BOOL Prefs_Load(STRPTR from, struct FontPrefs fp[])
  77 {
  78     BOOL retval = FALSE;
  79
  80     BPTR fh = Open(from, MODE_OLDFILE);
  81     if (fh)
  82     {
  83         retval = Prefs_ImportFH(fh, fp);
  84         Close(fh);
  85     }
  86     return retval;
  87 }
  88
  89 BOOL Prefs_HandleArgs(STRPTR from, BOOL use, BOOL save)
  90 {
  91     BPTR fh;
  92     struct FontPrefs fp[FP_COUNT];
  93
  94     if (from)
  95     {
  96         if (!Prefs_Load(from, fp))
  97         {
  98             ShowMessage("Can't read from input file");
  99             return FALSE;
 100         }
 101     }
 102     else
 103     {
 104         if (!Prefs_Load(PREFS_PATH_ENV, fp))
 105         {
 106             if (!Prefs_Load(PREFS_PATH_ENVARC, fp))
 107             {
 108                 ShowMessage
 109                 (
 110                     "Can't read from file " PREFS_PATH_ENVARC
 111                     ".\nUsing default values."
 112                 );
 113                 Prefs_Default(fp);
 114             }
 115         }
 116     }
 117
 118     if (use || save)
 119     {
 120         fh = Open(PREFS_PATH_ENV, MODE_NEWFILE);
 121         if (fh)
 122         {
 123             Prefs_ExportFH(fh, fp);
 124             Close(fh);
 125         }
 126         else
 127         {
 128             ShowMessage("Cant' open " PREFS_PATH_ENV " for writing.");
 129         }
 130     }
 131     if (save)
 132     {
 133         fh = Open(PREFS_PATH_ENVARC, MODE_NEWFILE);
 134         if (fh)
 135         {
 136             Prefs_ExportFH(fh, fp);
 137             Close(fh);
 138         }
 139         else
 140         {
 141             ShowMessage("Cant' open " PREFS_PATH_ENVARC " for writing.");
 142         }
 143     }
 144     return TRUE;
 145 }
 146
 147 BOOL Prefs_Default(struct FontPrefs fp[])
 148 {
 149     UBYTE i;
 150
 151     for (i = 0; i < FP_COUNT; i++)
 152     {
 153         fp[i].fp_Type     = i;
 154         fp[i].fp_FrontPen = 0; /* FIXME: Is this (really) default? Look it up! */
 155         fp[i].fp_BackPen  = 0; /* FIXME: Is this (really) default? Look it up! */
 156         fp[i].fp_DrawMode = 0; /* FIXME: Is this (really) default? Look it up! */
 157
 158         fp[i].fp_TextAttr.ta_YSize = 8; /* FIXME: Is this (really) default? Look it up! */
 159         fp[i].fp_TextAttr.ta_Style = FS_NORMAL;
 160         fp[i].fp_TextAttr.ta_Flags = FPB_DISKFONT; /* FIXME: Is this (really) default? Look it up! */
 161
 162         fp[i].fp_Name[0] = '\0';
 163         strlcat(fp[i].fp_Name, "topaz.font", FONTNAMESIZE); /* FIXME: Is this (really) default? Check it up! */
 164         fp[i].fp_TextAttr.ta_Name = fp[i].fp_Name;
 165     }
 166     return TRUE;
 167 }
 168
 169
 170 BOOL Prefs_ImportFH(BPTR fh, struct FontPrefs fp[])
 171 {
 172     struct IFFHandle    *handle;
 173     BOOL                 success = TRUE;
 174     LONG                 error;
 175
 176     if (!(handle = AllocIFF()))
 177     {
 178         ShowMessage(_(MSG_CANT_ALLOCATE_IFFPTR));
 179         return(FALSE);
 180     }
 181
 182     handle->iff_Stream = (IPTR) fh;
 183     InitIFFasDOS(handle);
 184
 185     if ((error = OpenIFF(handle, IFFF_READ)) == 0)
 186     {
 187         BYTE i;
 188
 189         // FIXME: We want some sanity checking here!
 190         for (i = 0; i < FP_COUNT; i++)
 191         {
 192             if ((error = StopChunk(handle, ID_PREF, ID_FONT)) == 0)
 193             {
 194                 if ((error = ParseIFF(handle, IFFPARSE_SCAN)) == 0)
 195                 {
 196                     struct FileFontPrefs ffp;
 197
 198                     error = ReadChunkBytes
 199                     (
 200                         handle, &ffp, sizeof(struct FileFontPrefs)
 201                     );
 202
 203                     if (error < 0)
 204                     {
 205                         printf("Error: ReadChunkBytes() returned %d!\n", (int)error);
 206                     }
 207
 208                     FileFontPrefs2FontPrefs(&ffp, &fp[i]);
 209
 210                     convertEndian(&fp[i]);
 211                 }
 212                 else
 213                 {
 214                     printf("ParseIFF() failed, returncode %d!\n", (int)error);
 215                     success = FALSE;
 216                     break;
 217                 }
 218             }
 219             else
 220             {
 221                 printf("StopChunk() failed, returncode %d!\n", (int)error);
 222                 success = FALSE;
 223             }
 224         }
 225
 226         CloseIFF(handle);
 227     }
 228     else
 229     {
 230         ShowMessage(_(MSG_CANT_OPEN_STREAM));
 231     }
 232
 233     FreeIFF(handle);
 234
 235     return success;
 236 }
 237
 238 BOOL Prefs_ExportFH(BPTR fh, struct FontPrefs fp[])
 239 {
 240     struct PrefHeader header;
 241     struct IFFHandle *handle;
 242     BOOL              success = TRUE;
 243     LONG              error   = 0;
 244
 245     memset(&header, 0, sizeof(struct PrefHeader));
 246
 247     if ((handle = AllocIFF()))
 248     {
 249         handle->iff_Stream = (IPTR)fh;
 250
 251         InitIFFasDOS(handle);
 252
 253         if (!(error = OpenIFF(handle, IFFF_WRITE))) /* NULL = successful! */
 254         {
 255             BYTE i;
 256
 257             PushChunk(handle, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN); /* FIXME: IFFSIZE_UNKNOWN? */
 258
 259             header.ph_Version = PHV_CURRENT;
 260             header.ph_Type    = 0;
 261
 262             PushChunk(handle, ID_PREF, ID_PRHD, IFFSIZE_UNKNOWN); /* FIXME: IFFSIZE_UNKNOWN? */
 263
 264             WriteChunkBytes(handle, &header, sizeof(struct PrefHeader));
 265
 266             PopChunk(handle);
 267
 268             for (i = 0; i < FP_COUNT; i++)
 269             {
 270                 struct FileFontPrefs ffp;
 271                 error = PushChunk(handle, ID_PREF, ID_FONT, sizeof(struct FileFontPrefs));
 272
 273                 if (error != 0) // TODO: We need some error checking here!
 274                 {
 275                     printf("error: PushChunk() = %d\n", (int)error);
 276                 }
 277
 278                 convertEndian(&fp[i]); // Convert to m68k endian
 279                 FontPrefs2FileFontPrefs(&fp[i], &ffp);
 280
 281                 error = WriteChunkBytes(handle, &ffp, sizeof(struct FileFontPrefs));
 282                 error = PopChunk(handle);
 283
 284                 convertEndian(&fp[i]); // Revert to initial endian
 285
 286                 if (error != 0) // TODO: We need some error checking here!
 287                 {
 288                     printf("error: PopChunk() = %d\n", (int)error);
 289                 }
 290             }
 291
 292             // Terminate the FORM
 293             PopChunk(handle);
 294         }
 295         else
 296         {
 297             ShowMessage(_(MSG_CANT_OPEN_STREAM));
 298             success = FALSE;
 299         }
 300
 301         CloseIFF(handle);
 302         FreeIFF(handle);
 303     }
 304     else // AllocIFF()
 305     {
 306         // Do something more here - if IFF allocation has failed, something isn't right
 307         ShowMessage(_(MSG_CANT_ALLOCATE_IFFPTR));
 308         success = FALSE;
 309     }
 310
 311     return success;
 312 }
 313