workbench/prefs/serial/prefs.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 /*********************************************************************************************/
  10
  11 #include "global.h"
  12 #include <aros/macros.h>
  13
  14 #define DEBUG 1
  15 #include <aros/debug.h>
  16
  17 #include <stdio.h>
  18 #include <string.h>
  19 #include <stdlib.h>
  20
  21 /*********************************************************************************************/
  22
  23 struct FilePrefHeader
  24 {
  25     UBYTE ph_Version;
  26     UBYTE ph_Type;
  27     UBYTE ph_Flags[4];
  28 };
  29
  30 /*********************************************************************************************/
  31
  32 static struct SerialPrefs   restore_prefs;
  33 static APTR                 mempool;
  34
  35 /*********************************************************************************************/
  36
  37 #define SER_DEFAULT_BAUDRATE       19200
  38 #define SER_DEFAULT_IBUFFER        512
  39 #define SER_DEFAULT_OBUFFER        512
  40
  41 #define SER_DEFAULT_IHANDSHAKE     HSHAKE_NONE
  42 #define SER_DEFAULT_OHANDSHAKE     HSHAKE_NONE
  43
  44 #define SER_DEFAULT_PARITY         PARITY_NONE
  45 #define SER_DEFAULT_BITS_PER_CHAR  8
  46 #define SER_DEFAULT_STOP_BITS      1
  47
  48 /*********************************************************************************************/
  49
  50
  51 void InitPrefs(STRPTR filename, BOOL use, BOOL save)
  52 {
  53     mempool = CreatePool(MEMF_PUBLIC | MEMF_CLEAR, 2048, 2048);
  54     if (!mempool) Cleanup("Out of memory!");
  55
  56     if (!LoadPrefs(filename))
  57     {
  58         if (!DefaultPrefs())
  59         {
  60             Cleanup("Panic! Cannot setup default prefs!");
  61         }
  62     }
  63
  64     restore_prefs = serialprefs;
  65
  66     if (use || save)
  67     {
  68         SavePrefs(CONFIGNAME_ENV);
  69     }
  70
  71     if (save)
  72     {
  73         SavePrefs(CONFIGNAME_ENVARC);
  74     }
  75
  76     if (use || save) Cleanup(NULL);
  77 }
  78
  79 /*********************************************************************************************/
  80
  81 void CleanupPrefs(void)
  82 {
  83     if (mempool) DeletePool(mempool);
  84 }
  85
  86 /*********************************************************************************************/
  87
  88 BOOL LoadPrefs(STRPTR filename)
  89 {
  90     static struct SerialPrefs loadprefs;
  91     struct IFFHandle            *iff;
  92     BOOL                        retval = FALSE;
  93
  94     D(bug("LoadPrefs: Trying to open \"%s\"\n", filename));
  95
  96     if ((iff = AllocIFF()))
  97     {
  98         if ((iff->iff_Stream = (IPTR)Open(filename, MODE_OLDFILE)))
  99         {
 100             D(bug("LoadPrefs: stream opened.\n"));
 101
 102             InitIFFasDOS(iff);
 103
 104             if (!OpenIFF(iff, IFFF_READ))
 105             {
 106                 D(bug("LoadPrefs: OpenIFF okay.\n"));
 107
 108                 if (!StopChunk(iff, ID_PREF, ID_SERL))
 109                 {
 110                     D(bug("LoadPrefs: StopChunk okay.\n"));
 111
 112                     if (!ParseIFF(iff, IFFPARSE_SCAN))
 113                     {
 114                         struct ContextNode *cn;
 115
 116                         D(bug("LoadPrefs: ParseIFF okay.\n"));
 117
 118                         cn = CurrentChunk(iff);
 119
 120                         if (cn->cn_Size == sizeof(struct SerialPrefs))
 121                         {
 122                             D(bug("LoadPrefs: ID_SERL chunk size okay.\n"));
 123
 124                             if (ReadChunkBytes(iff, &loadprefs, sizeof(struct SerialPrefs)) == sizeof(struct SerialPrefs))
 125                             {
 126                                 D(bug("LoadPrefs: Reading chunk successful.\n"));
 127
 128                                 TellGUI(PAGECMD_PREFS_CHANGING);
 129
 130                                 serialprefs = loadprefs;
 131
 132                                 TellGUI(PAGECMD_PREFS_CHANGED);
 133
 134                                 D(bug("LoadPrefs: Everything okay :-)\n"));
 135
 136                                 retval = TRUE;
 137                             }
 138                         }
 139
 140                     } /* if (!ParseIFF(iff, IFFPARSE_SCAN)) */
 141
 142                 } /* if (!StopChunk(iff, ID_PREF, ID_SERL)) */
 143
 144                 CloseIFF(iff);
 145
 146             } /* if (!OpenIFF(iff, IFFF_READ)) */
 147
 148             Close((BPTR)iff->iff_Stream);
 149
 150         } /* if ((iff->iff_Stream = (IPTR)Open(filename, MODE_OLDFILE))) */
 151
 152         FreeIFF(iff);
 153
 154     } /* if ((iff = AllocIFF())) */
 155
 156     return retval;
 157 }
 158
 159 /*********************************************************************************************/
 160
 161 BOOL SavePrefs(STRPTR filename)
 162 {
 163     static struct SerialPrefs   saveprefs;
 164     struct IFFHandle            *iff;
 165     BOOL                        retval = FALSE, delete_if_error = FALSE;
 166
 167     saveprefs = serialprefs;
 168
 169
 170     D(bug("SavePrefs: Trying to open \"%s\"\n", filename));
 171
 172     if ((iff = AllocIFF()))
 173     {
 174         if ((iff->iff_Stream = (IPTR)Open(filename, MODE_NEWFILE)))
 175         {
 176             D(bug("SavePrefs: stream opened.\n"));
 177
 178             delete_if_error = TRUE;
 179
 180             InitIFFasDOS(iff);
 181
 182             if (!OpenIFF(iff, IFFF_WRITE))
 183             {
 184                 D(bug("SavePrefs: OpenIFF okay.\n"));
 185
 186                 if (!PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN))
 187                 {
 188                     D(bug("SavePrefs: PushChunk(FORM) okay.\n"));
 189
 190                     if (!PushChunk(iff, ID_PREF, ID_PRHD, sizeof(struct FilePrefHeader)))
 191                     {
 192                         struct FilePrefHeader head;
 193
 194                         D(bug("SavePrefs: PushChunk(PRHD) okay.\n"));
 195
 196                         head.ph_Version  = 0; // FIXME: should be PHV_CURRENT, but see <prefs/prefhdr.h>
 197                         head.ph_Type     = 0;
 198                         head.ph_Flags[0] =
 199                         head.ph_Flags[1] =
 200                         head.ph_Flags[2] =
 201                         head.ph_Flags[3] = 0;
 202
 203                         if (WriteChunkBytes(iff, &head, sizeof(head)) == sizeof(head))
 204                         {
 205                             D(bug("SavePrefs: WriteChunkBytes(PRHD) okay.\n"));
 206
 207                             PopChunk(iff);
 208
 209                             if (!PushChunk(iff, ID_PREF, ID_SERL, sizeof(struct SerialPrefs)))
 210                             {
 211                                 D(bug("SavePrefs: PushChunk(LCLE) okay.\n"));
 212
 213                                 if (WriteChunkBytes(iff, &saveprefs, sizeof(saveprefs)) == sizeof(saveprefs))
 214                                 {
 215                                     D(bug("SavePrefs: WriteChunkBytes(SERL) okay.\n"));
 216                                     D(bug("SavePrefs: Everything okay :-)\n"));
 217
 218                                     retval = TRUE;
 219                                 }
 220
 221                                 PopChunk(iff);
 222
 223                             } /* if (!PushChunk(iff, ID_PREF, ID_SERL, sizeof(struct LocalePrefs))) */
 224
 225                         } /* if (WriteChunkBytes(iff, &head, sizeof(head)) == sizeof(head)) */
 226                         else
 227                         {
 228                             PopChunk(iff);
 229                         }
 230
 231                     } /* if (!PushChunk(iff, ID_PREF, ID_PRHD, sizeof(struct PrefHeader))) */
 232
 233                     PopChunk(iff);
 234
 235                 } /* if (!PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN)) */
 236
 237                 CloseIFF(iff);
 238
 239             } /* if (!OpenIFF(iff, IFFFWRITE)) */
 240
 241             Close((BPTR)iff->iff_Stream);
 242
 243         } /* if ((iff->iff_Stream = (IPTR)Open(filename, MODE_NEWFILE))) */
 244
 245         FreeIFF(iff);
 246
 247     } /* if ((iff = AllocIFF())) */
 248
 249     if (!retval && delete_if_error)
 250     {
 251         DeleteFile(filename);
 252     }
 253
 254     return retval;
 255 }
 256
 257 /*********************************************************************************************/
 258
 259 BOOL DefaultPrefs(void)
 260 {
 261     TellGUI(PAGECMD_PREFS_CHANGING);
 262
 263     serialprefs.sp_Reserved[0]     = 0;
 264     serialprefs.sp_Reserved[1]     = 0;
 265     serialprefs.sp_Reserved[2]     = 0;
 266     serialprefs.sp_Unit0Map        = 0;
 267     serialprefs.sp_BaudRate        = SER_DEFAULT_BAUDRATE;
 268     serialprefs.sp_InputBuffer     = SER_DEFAULT_IBUFFER;
 269     serialprefs.sp_OutputBuffer    = SER_DEFAULT_OBUFFER;
 270     serialprefs.sp_InputHandshake  = SER_DEFAULT_IHANDSHAKE;
 271     serialprefs.sp_OutputHandshake = SER_DEFAULT_OHANDSHAKE;
 272     serialprefs.sp_Parity          = SER_DEFAULT_PARITY;
 273     serialprefs.sp_BitsPerChar     = SER_DEFAULT_BITS_PER_CHAR;
 274     serialprefs.sp_StopBits        = SER_DEFAULT_STOP_BITS;
 275
 276     TellGUI(PAGECMD_PREFS_CHANGED);
 277
 278     return TRUE;
 279 }
 280
 281 /*********************************************************************************************/
 282
 283 void RestorePrefs(void)
 284 {
 285     TellGUI(PAGECMD_PREFS_CHANGING);
 286     serialprefs = restore_prefs;
 287     TellGUI(PAGECMD_PREFS_CHANGED);
 288 }
 289
 290 /*********************************************************************************************/