workbench/devs/printer/prefs.c

   1 /*
   2     Copyright © 1995-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 #include <aros/debug.h>
  18
  19 #include <proto/exec.h>
  20 #include <proto/iffparse.h>
  21 #include <proto/dos.h>
  22
  23 #include <prefs/prefhdr.h>
  24
  25 #include "printer_intern.h"
  26
  27 #ifdef BIGENDIAN_PREFS
  28 #define GET_WORD AROS_BE2WORD
  29 #define GET_LONG AROS_BE2LONG
  30 #else
  31 #define GET_WORD(x) x
  32 #define GET_LONG(x) x
  33 #endif
  34
  35 /*********************************************************************************************/
  36
  37 #define PREFS_PATH_ENVARC "ENVARC:SYS/printer"
  38 #define PREFS_PATH_ENV    "ENV:SYS/printer"
  39
  40 /*********************************************************************************************/
  41
  42 struct FilePrefHeader
  43 {
  44     UBYTE ph_Version;
  45     UBYTE ph_Type;
  46     UBYTE ph_Flags[4];
  47 };
  48
  49 /*********************************************************************************************/
  50
  51 #define IMPORT_WORD(x)  do { x = AROS_BE2WORD(x); } while (0)
  52 #define IMPORT_LONG(x)  do { x = AROS_BE2LONG(x); } while (0)
  53
  54 BOOL Printer_LoadPrefs(struct PrinterBase *PrinterBase, LONG unitnum, struct PrinterPrefs *prefs)
  55 {
  56     struct PrinterTxtPrefs txt = prefs->pp_Txt;
  57     struct PrinterUnitPrefs unit = prefs->pp_Unit;
  58     struct PrinterDeviceUnitPrefs devunit = prefs->pp_DeviceUnit;
  59     struct PrinterGfxPrefs gfx = prefs->pp_Gfx;
  60     BPTR fh;
  61     TEXT envpath[64];
  62     TEXT envarcpath[64];
  63
  64     struct IFFHandle   *iff;
  65     LONG chunk_map = 0;
  66     LONG stop_chunks[] = {
  67         ID_PREF, ID_PTXT,
  68         ID_PREF, ID_PUNT,
  69         ID_PREF, ID_PDEV,
  70         ID_PREF, ID_PGFX,
  71     };
  72
  73     AddPart(envpath, PREFS_PATH_ENV, sizeof(envpath));
  74     AddPart(envarcpath, PREFS_PATH_ENVARC, sizeof(envarcpath));
  75     if (unitnum) {
  76         TEXT c[2] = { '0' + unitnum, 0 };
  77         strncat(envpath, c, sizeof(envpath));
  78         strncat(envarcpath, c, sizeof(envarcpath));
  79     }
  80     strncat(envpath, ".prefs", sizeof(envpath));
  81     strncat(envarcpath, ".prefs", sizeof(envarcpath));
  82
  83     D(bug("%s: envpath \"%s\"\n", __func__, envpath));
  84     D(bug("%s: envarcpath \"%s\"\n", __func__, envpath));
  85
  86     if (((fh = Open(envpath, MODE_OLDFILE)) == BNULL) &&
  87         ((fh = Open(envarcpath, MODE_OLDFILE)) == BNULL))
  88         return FALSE;
  89
  90     D(bug("LoadPrefs: Begin\n"));
  91
  92     if ((iff = AllocIFF()))
  93     {
  94         iff->iff_Stream = (IPTR)fh;
  95
  96         InitIFFasDOS(iff);
  97
  98         if (!OpenIFF(iff, IFFF_READ))
  99         {
 100             D(bug("LoadPrefs: OpenIFF okay.\n"));
 101
 102             if (!StopChunks(iff, stop_chunks, 4))
 103             {
 104                 D(bug("LoadPrefs: StopChunks okay.\n"));
 105
 106                 while (ParseIFF(iff, IFFPARSE_SCAN) == 0)
 107                 {
 108                     struct ContextNode *cn;
 109
 110                     cn = CurrentChunk(iff);
 111
 112                     D(bug("LoadPrefs: ParseIFF okay: 0x%04x 0x%04x\n", cn->cn_ID, cn->cn_Type));
 113
 114                     if (cn->cn_ID == ID_PTXT && cn->cn_Size == sizeof(txt))
 115                     {
 116                         D(bug("LoadPrefs: ID_PTXT chunk size okay.\n"));
 117                         if (ReadChunkBytes(iff, &txt, sizeof(txt)) == sizeof(txt))
 118                         {
 119                             D(bug("LoadPrefs: Reading chunk successful.\n"));
 120
 121                             chunk_map |= (1 << 0);
 122                         }
 123                     }
 124                     if (cn->cn_ID == ID_PUNT && cn->cn_Size == sizeof(unit))
 125                     {
 126                         D(bug("LoadPrefs: ID_PUNT chunk size okay.\n"));
 127                         if (ReadChunkBytes(iff, &unit, sizeof(unit)) == sizeof(unit))
 128                         {
 129                             D(bug("LoadPrefs: Reading chunk successful.\n"));
 130
 131                             chunk_map |= (1 << 1);
 132                         }
 133                     }
 134                     if (cn->cn_ID == ID_PDEV && cn->cn_Size == sizeof(devunit))
 135                     {
 136                         D(bug("LoadPrefs: ID_PDEV chunk size okay.\n"));
 137                         if (ReadChunkBytes(iff, &devunit, sizeof(devunit)) == sizeof(devunit))
 138                         {
 139                             D(bug("LoadPrefs: Reading chunk successful.\n"));
 140
 141                             chunk_map |= (1 << 2);
 142                         }
 143                     }
 144                     if (cn->cn_ID == ID_PGFX && cn->cn_Size == sizeof(gfx))
 145                     {
 146                         D(bug("LoadPrefs: ID_PGFX chunk size okay.\n"));
 147                         if (ReadChunkBytes(iff, &gfx, sizeof(gfx)) == sizeof(gfx))
 148                         {
 149                             D(bug("LoadPrefs: Reading chunk successful.\n"));
 150
 151                             chunk_map |= (1 << 3);
 152                         }
 153                     }
 154                 }
 155             }
 156             CloseIFF(iff);
 157         }
 158         FreeIFF(iff);
 159     }
 160     Close(fh);
 161
 162     if (chunk_map & (1 << 0)) {
 163         D(bug("LoadPrefs: PTXT\n"));
 164
 165         IMPORT_WORD(txt.pt_PaperType);
 166         IMPORT_WORD(txt.pt_PaperSize);
 167         IMPORT_WORD(txt.pt_PaperLength);
 168         IMPORT_WORD(txt.pt_Pitch);
 169         IMPORT_WORD(txt.pt_Spacing);
 170         IMPORT_WORD(txt.pt_LeftMargin);
 171         IMPORT_WORD(txt.pt_RightMargin);
 172         IMPORT_WORD(txt.pt_Quality);
 173         prefs->pp_Txt = txt;
 174     }
 175
 176     if (chunk_map & (1 << 1)) {
 177         D(bug("LoadPrefs: PUNT\n"));
 178
 179         IMPORT_LONG(unit.pu_UnitNum);
 180         IMPORT_LONG(unit.pu_OpenDeviceFlags);
 181         prefs->pp_Unit = unit;
 182     }
 183
 184     if (chunk_map & (1 << 2)) {
 185         D(bug("LoadPrefs: PDEV\n"));
 186
 187         IMPORT_LONG(devunit.pd_UnitNum);
 188         prefs->pp_DeviceUnit = devunit;
 189     }
 190
 191     if (chunk_map & (1 << 3)) {
 192         D(bug("LoadPrefs: PGFX\n"));
 193
 194         IMPORT_WORD(gfx.pg_Aspect);
 195         IMPORT_WORD(gfx.pg_Shade);
 196         IMPORT_WORD(gfx.pg_Image);
 197         IMPORT_WORD(gfx.pg_Threshold);
 198         IMPORT_WORD(gfx.pg_GraphicFlags);
 199         IMPORT_WORD(gfx.pg_PrintMaxWidth);
 200         IMPORT_WORD(gfx.pg_PrintMaxHeight);
 201
 202         prefs->pp_Gfx = gfx;
 203     }
 204
 205     D(bug("LoadPrefs: Done\n"));
 206     return (chunk_map & (1 << 0)) ? TRUE : FALSE;
 207 }