workbench/prefs/font/fpeditor.c

   1 /*
   2     Copyright © 2003-2004, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #include <exec/types.h>
   9 #include <utility/tagitem.h>
  10 #include <libraries/asl.h>
  11 #include <libraries/mui.h>
  12 #include <prefs/prefhdr.h>
  13 #include <prefs/font.h>
  14 #include <zune/customclasses.h>
  15 #include <zune/prefseditor.h>
  16
  17 #include <proto/exec.h>
  18 #include <proto/intuition.h>
  19 #include <proto/utility.h>
  20 #include <proto/muimaster.h>
  21 #include <proto/dos.h>
  22 #include <proto/iffparse.h>
  23
  24 #include <string.h>
  25 #include <stdio.h>
  26
  27 #include "misc.h"
  28 #include "locale.h"
  29 #include "fpeditor.h"
  30
  31
  32 /*** Instance Data **********************************************************/
  33 #define FP_COUNT (3)  /* Number of entries in fped_FontPrefs array */
  34
  35 struct FPEditor_DATA
  36 {
  37     struct FontPrefs  fped_FontPrefs[FP_COUNT];
  38     Object           *fped_IconsString,
  39                      *fped_ScreenString,
  40                      *fped_SystemString;
  41 };
  42
  43 /*** Macros *****************************************************************/
  44 #define SETUP_INST_DATA struct FPEditor_DATA *data = INST_DATA(CLASS, self)
  45 #define FP(i) (&(data->fped_FontPrefs[(i)]))
  46
  47 /*** Utility Functions ******************************************************/
  48 #if 0
  49 void FontPrefs_Default(struct FontPrefs *fp[FP_COUNT])
  50 {
  51     UBYTE i;
  52
  53     for (i = 0; i < FP_COUNT; i++)
  54     {
  55         fp[i]->fp_Type     = i;
  56         fp[i]->fp_FrontPen = 0; /* FIXME: Is this (really) default? Look it up! */
  57         fp[i]->fp_BackPen  = 0; /* FIXME: Is this (really) default? Look it up! */
  58         fp[i]->fp_DrawMode = 0; /* FIXME: Is this (really) default? Look it up! */
  59
  60         fp[i]->fp_TextAttr.ta_YSize = 8; /* FIXME: Is this (really) default? Look it up! */
  61         fp[i]->fp_TextAttr.ta_Style = FS_NORMAL;
  62         fp[i]->fp_TextAttr.ta_Flags = FPB_DISKFONT; /* FIXME: Is this (really) default? Look it up! */
  63
  64         fp[i]->fp_Name[0] = '\0';
  65         strlcat(fp[i]->fp_Name, "topaz.font", FONTNAMESIZE); /* FIXME: Is this (really) default? Check it up! */
  66         fp[i]->fp_TextAttr.ta_Name = fp[i]->fp_Name;
  67     }
  68 }
  69 #endif
  70
  71 STATIC VOID convertEndian(struct FontPrefs *fp)
  72 {
  73     BYTE i;
  74
  75     for (i = 0; i <= 2; i++)
  76     {
  77         fp->fp_Reserved[i] = AROS_BE2LONG(fp->fp_Reserved[i]);
  78     }
  79
  80     fp->fp_Reserved2         = AROS_BE2WORD(fp->fp_Reserved2);
  81     fp->fp_Type              = AROS_BE2WORD(fp->fp_Type);
  82     fp->fp_TextAttr.ta_YSize = AROS_BE2WORD(fp->fp_TextAttr.ta_YSize);
  83 }
  84
  85
  86 VOID FontPrefs2FontString
  87 (
  88     STRPTR buffer, ULONG buffersize, struct FontPrefs *fp
  89 )
  90 {
  91     snprintf
  92     (
  93         buffer, buffersize, "%.*s/%d",
  94         strlen(fp->fp_TextAttr.ta_Name) - 5 /* strlen(".font") */,
  95         fp->fp_TextAttr.ta_Name, fp->fp_TextAttr.ta_YSize
  96     );
  97 }
  98
  99 BOOL FontString2FontPrefs(struct FontPrefs *fp, CONST_STRPTR buffer)
 100 {
 101     STRPTR separator    = PathPart((STRPTR) buffer);
 102     ULONG  nameLength   = separator - buffer;
 103     ULONG  suffixLength = 5; /* strlen(".font") */
 104     ULONG  size;
 105
 106     if (nameLength + suffixLength >= FONTNAMESIZE)
 107     {
 108         /* Not enough space for the font name */
 109         return FALSE;
 110     }
 111
 112     snprintf
 113     (
 114         fp->fp_Name, nameLength + suffixLength + 1, "%.*s.font",
 115         (int) nameLength, buffer
 116     );
 117     fp->fp_TextAttr.ta_Name = fp->fp_Name;
 118
 119     StrToLong(FilePart((STRPTR) buffer), &size);
 120     fp->fp_TextAttr.ta_YSize = size;
 121
 122     return TRUE;
 123 }
 124
 125 BOOL Gadgets2FontPrefs
 126 (
 127     struct FPEditor_DATA *data
 128 )
 129 {
 130     STRPTR str = NULL;
 131
 132     // FIXME: error checking
 133     GET(data->fped_IconsString, MUIA_String_Contents, &str);
 134     FontString2FontPrefs(FP(FP_WBFONT), str);
 135
 136     GET(data->fped_SystemString, MUIA_String_Contents, &str);
 137     FontString2FontPrefs(FP(FP_SYSFONT), str);
 138
 139     GET(data->fped_ScreenString, MUIA_String_Contents, &str);
 140     FontString2FontPrefs(FP(FP_SCREENFONT), str);
 141
 142     return TRUE;
 143 }
 144
 145 BOOL FontPrefs2Gadgets
 146 (
 147     struct FPEditor_DATA *data
 148 )
 149 {
 150     TEXT buffer[FONTNAMESIZE + 8];
 151
 152     // FIXME: error checking
 153     FontPrefs2FontString(buffer, FONTNAMESIZE + 8, FP(FP_WBFONT));
 154     NNSET(data->fped_IconsString, MUIA_String_Contents, (IPTR) buffer);
 155
 156     FontPrefs2FontString(buffer, FONTNAMESIZE + 8, FP(FP_SYSFONT));
 157     NNSET(data->fped_SystemString, MUIA_String_Contents, (IPTR) buffer);
 158
 159     FontPrefs2FontString(buffer, FONTNAMESIZE + 8, FP(FP_SCREENFONT));
 160     NNSET(data->fped_ScreenString, MUIA_String_Contents, (IPTR) buffer);
 161
 162     return TRUE;
 163 }
 164
 165 /*** Methods ****************************************************************/
 166 Object *FPEditor__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
 167 {
 168     Object *iconsString, *screenString, *systemString;
 169
 170     self = (Object *) DoSuperNewTags
 171     (
 172         CLASS, self, NULL,
 173
 174         MUIA_PrefsEditor_Name,        __(MSG_NAME),
 175         MUIA_PrefsEditor_Path, (IPTR) "SYS/Font.prefs",
 176
 177         Child, (IPTR) ColGroup(2),
 178             Child, (IPTR) Label2(_(MSG_ICONS)),
 179             Child, (IPTR) PopaslObject,
 180                 MUIA_Popasl_Type,              ASL_FontRequest,
 181                 ASLFO_MaxHeight,               100,
 182                 MUIA_Popstring_String,  (IPTR) (iconsString = StringObject,
 183                     TextFrame,
 184                     MUIA_Background, MUII_TextBack,
 185                 End),
 186                 MUIA_Popstring_Button,  (IPTR) PopButton(MUII_PopUp),
 187             End,
 188             Child, (IPTR) Label2(_(MSG_SCREEN)),
 189             Child, (IPTR) PopaslObject,
 190                 MUIA_Popasl_Type,              ASL_FontRequest,
 191                 ASLFO_MaxHeight,               100,
 192                 MUIA_Popstring_String,  (IPTR) (screenString = StringObject,
 193                     TextFrame,
 194                     MUIA_Background, MUII_TextBack,
 195                 End),
 196                 MUIA_Popstring_Button,  (IPTR) PopButton(MUII_PopUp),
 197             End,
 198             Child, (IPTR) Label2(_(MSG_SYSTEM)),
 199             Child, (IPTR) PopaslObject,
 200                 MUIA_Popasl_Type,              ASL_FontRequest,
 201                 ASLFO_FixedWidthOnly,          TRUE,
 202                 ASLFO_MaxHeight,               100,
 203                 MUIA_Popstring_String,  (IPTR) (systemString = StringObject,
 204                     TextFrame,
 205                     MUIA_Background, MUII_TextBack,
 206                 End),
 207                 MUIA_Popstring_Button,  (IPTR) PopButton(MUII_PopUp),
 208             End,
 209         End,
 210
 211         TAG_DONE
 212     );
 213
 214     if (self != NULL)
 215     {
 216         SETUP_INST_DATA;
 217         data->fped_IconsString  = iconsString;
 218         data->fped_ScreenString = screenString;
 219         data->fped_SystemString = systemString;
 220
 221         /*-- Setup notifications -------------------------------------------*/
 222         DoMethod
 223         (
 224             iconsString, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
 225             (IPTR) self, 3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE
 226         );
 227         DoMethod
 228         (
 229             screenString, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
 230             (IPTR) self, 3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE
 231         );
 232         DoMethod
 233         (
 234             systemString, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
 235             (IPTR) self, 3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE
 236         );
 237     }
 238
 239     return self;
 240 }
 241
 242 IPTR FPEditor__MUIM_PrefsEditor_ImportFH
 243 (
 244     Class *CLASS, Object *self,
 245     struct MUIP_PrefsEditor_ImportFH *message
 246 )
 247 {
 248     SETUP_INST_DATA;
 249     struct ContextNode  *context;
 250     struct IFFHandle    *handle;
 251     BOOL                 success = TRUE;
 252     LONG                 error;
 253
 254     if (!(handle = AllocIFF()))
 255     {
 256         ShowError(_(MSG_CANT_ALLOCATE_IFFPTR));
 257         return(FALSE);
 258     }
 259
 260     handle->iff_Stream = (IPTR) message->fh;
 261     InitIFFasDOS(handle);
 262
 263     if ((error = OpenIFF(handle, IFFF_READ)) == 0)
 264     {
 265         BYTE i;
 266
 267         // FIXME: We want some sanity checking here!
 268         for (i = 0; i < FP_COUNT; i++)
 269         {
 270             if ((error = StopChunk(handle, ID_PREF, ID_FONT)) == 0)
 271             {
 272                 if ((error = ParseIFF(handle, IFFPARSE_SCAN)) == 0)
 273                 {
 274                     context = CurrentChunk(handle);
 275
 276                     error = ReadChunkBytes
 277                     (
 278                         handle, FP(i), sizeof(struct FontPrefs)
 279                     );
 280
 281                     if (error < 0)
 282                     {
 283                         printf("Error: ReadChunkBytes() returned %ld!\n", error);
 284                     }
 285
 286                     FP(i)->fp_TextAttr.ta_Name = FP(i)->fp_Name;
 287
 288                     convertEndian(FP(i));
 289                 }
 290                 else
 291                 {
 292                     printf("ParseIFF() failed, returncode %ld!\n", error);
 293                     success = FALSE;
 294                     break;
 295                 }
 296             }
 297             else
 298             {
 299                 printf("StopChunk() failed, returncode %ld!\n", error);
 300                 success = FALSE;
 301             }
 302         }
 303
 304         CloseIFF(handle);
 305     }
 306     else
 307     {
 308         ShowError(_(MSG_CANT_OPEN_STREAM));
 309     }
 310
 311     FreeIFF(handle);
 312
 313     if (success) FontPrefs2Gadgets(data);
 314
 315     return success;
 316 }
 317
 318 IPTR FPEditor__MUIM_PrefsEditor_ExportFH
 319 (
 320     Class *CLASS, Object *self,
 321     struct MUIP_PrefsEditor_ExportFH *message
 322 )
 323 {
 324     SETUP_INST_DATA;
 325     struct PrefHeader header;
 326     struct IFFHandle *handle;
 327     BOOL              success = TRUE;
 328     LONG              error   = 0;
 329
 330     Gadgets2FontPrefs(data);
 331
 332     memset(&header, 0, sizeof(struct PrefHeader));
 333
 334     if ((handle = AllocIFF()))
 335     {
 336         handle->iff_Stream = (IPTR) message->fh;
 337
 338         InitIFFasDOS(handle);
 339
 340         if (!(error = OpenIFF(handle, IFFF_WRITE))) /* NULL = successful! */
 341         {
 342             BYTE i;
 343
 344             PushChunk(handle, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN); /* FIXME: IFFSIZE_UNKNOWN? */
 345
 346             header.ph_Version = PHV_CURRENT;
 347             header.ph_Type    = 0;
 348
 349             PushChunk(handle, ID_PREF, ID_PRHD, IFFSIZE_UNKNOWN); /* FIXME: IFFSIZE_UNKNOWN? */
 350
 351             WriteChunkBytes(handle, &header, sizeof(struct PrefHeader));
 352
 353             PopChunk(handle);
 354
 355             for (i = 0; i < FP_COUNT; i++)
 356             {
 357                 error = PushChunk(handle, ID_PREF, ID_FONT, sizeof(struct FontPrefs));
 358
 359                 if (error != 0) // TODO: We need some error checking here!
 360                 {
 361                     printf("error: PushChunk() = %ld\n", error);
 362                 }
 363
 364                 convertEndian(FP(i)); // Convert to m68k endian
 365
 366                 error = WriteChunkBytes(handle, FP(i), sizeof(struct FontPrefs));
 367                 error = PopChunk(handle);
 368
 369                 convertEndian(FP(i)); // Revert to initial endian
 370
 371                 if (error != 0) // TODO: We need some error checking here!
 372                 {
 373                     printf("error: PopChunk() = %ld\n", error);
 374                 }
 375             }
 376
 377             // Terminate the FORM
 378             PopChunk(handle);
 379         }
 380         else
 381         {
 382             ShowError(_(MSG_CANT_OPEN_STREAM));
 383             success = FALSE;
 384         }
 385
 386         CloseIFF(handle);
 387         FreeIFF(handle);
 388     }
 389     else // AllocIFF()
 390     {
 391         // Do something more here - if IFF allocation has failed, something isn't right
 392         ShowError(_(MSG_CANT_ALLOCATE_IFFPTR));
 393         success = FALSE;
 394     }
 395
 396     return success;
 397 }
 398
 399 /*** Setup ******************************************************************/
 400 ZUNE_CUSTOMCLASS_3
 401 (
 402     FPEditor, NULL, MUIC_PrefsEditor, NULL,
 403     OM_NEW,                    struct opSet *,
 404     MUIM_PrefsEditor_ImportFH, struct MUIP_PrefsEditor_ImportFH *,
 405     MUIM_PrefsEditor_ExportFH, struct MUIP_PrefsEditor_ExportFH *
 406 );