workbench/prefs/locale/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 0
  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 LocalePrefs   restore_prefs;
  33 static APTR                 mempool;
  34
  35 /*********************************************************************************************/
  36
  37 static void ScanDirectory(STRPTR pattern, struct List *list, LONG entrysize)
  38 {
  39     struct AnchorPath       ap;
  40     struct ListviewEntry    *entry;
  41     STRPTR                  sp;
  42     LONG                    error;
  43
  44     memset(&ap, 0, sizeof(ap));
  45
  46     error = MatchFirst(pattern, &ap);
  47     while((error == 0))
  48     {
  49         if (ap.ap_Info.fib_DirEntryType < 0)
  50         {
  51             entry = (struct ListviewEntry *)AllocPooled(mempool, entrysize);
  52             if (entry)
  53             {
  54                 entry->node.ln_Name = entry->name;
  55                 strncpy(entry->name, ap.ap_Info.fib_FileName, sizeof(entry->name));
  56
  57                 entry->name[0] = ToUpper(entry->name[0]);
  58                 sp = strchr(entry->name, '.');
  59                 if (sp) sp[0] = '\0';
  60
  61                 strcpy(entry->realname, entry->name);
  62
  63                 sp = entry->name;
  64                 while((sp = strchr(sp, '_')))
  65                 {
  66                     sp[0] = ' ';
  67                     if (sp[1])
  68                     {
  69                         /* Make char after underscore uppercase only if no
  70                            more underscores follow */
  71                         if (strchr(sp, '_') == 0)
  72                         {
  73                             sp[1] = ToUpper(sp[1]);
  74                         }
  75                     }
  76                 }
  77                 SortInNode(list, &entry->node);
  78             }
  79         }
  80         error = MatchNext(&ap);
  81     }
  82     MatchEnd(&ap);
  83 }
  84
  85 /*********************************************************************************************/
  86
  87 static BOOL GetCountryFromDefLocale(struct CountryPrefs *country)
  88 {
  89     BOOL retval = FALSE;
  90
  91     if (LocaleBase)
  92     {
  93         struct Locale *loc = OpenLocale(NULL);
  94
  95         CloseLocale(loc);
  96     }
  97
  98     return retval;
  99 }
 100
 101 /*********************************************************************************************/
 102
 103 void InitPrefs(STRPTR filename, BOOL use, BOOL save)
 104 {
 105     struct LanguageEntry *entry;
 106
 107     NewList(&country_list);
 108     NewList(&language_list);
 109     NewList(&pref_language_list);
 110
 111     mempool = CreatePool(MEMF_PUBLIC | MEMF_CLEAR, 2048, 2048);
 112     if (!mempool) Cleanup("Out of memory!");
 113
 114     ScanDirectory("LOCALE:Countries/~(#?.info)", &country_list, sizeof(struct CountryEntry));
 115     ScanDirectory("LOCALE:Languages/#?.language", &language_list, sizeof(struct LanguageEntry));
 116
 117     /* English language is always available */
 118
 119     if ((entry = AllocPooled(mempool, sizeof(struct LanguageEntry))))
 120     {
 121         strcpy(entry->lve.name, "English");
 122         strcpy(entry->lve.realname, "English");
 123         entry->lve.node.ln_Name = entry->lve.name;
 124
 125         SortInNode(&language_list, &entry->lve.node);
 126     }
 127
 128     if (!LoadPrefs(filename))
 129     {
 130         if (!DefaultPrefs())
 131         {
 132             if (!GetCountryFromDefLocale(&localeprefs.lp_CountryData))
 133             {
 134                 Cleanup("Panic! Cannot setup default prefs!");
 135             }
 136         }
 137     }
 138
 139     restore_prefs = localeprefs;
 140
 141     if (use || save)
 142     {
 143         SavePrefs(CONFIGNAME_ENV);
 144     }
 145
 146     if (save)
 147     {
 148         SavePrefs(CONFIGNAME_ENVARC);
 149     }
 150
 151     if (use || save) Cleanup(NULL);
 152 }
 153
 154 /*********************************************************************************************/
 155
 156 void CleanupPrefs(void)
 157 {
 158     if (mempool) DeletePool(mempool);
 159 }
 160
 161 /*********************************************************************************************/
 162
 163 #if !AROS_BIG_ENDIAN
 164 static void FixCountryEndianess(struct CountryPrefs *country)
 165 {
 166     country->cp_Reserved[0] = AROS_BE2LONG(country->cp_Reserved[0]);
 167     country->cp_Reserved[1] = AROS_BE2LONG(country->cp_Reserved[1]);
 168     country->cp_Reserved[2] = AROS_BE2LONG(country->cp_Reserved[2]);
 169     country->cp_Reserved[3] = AROS_BE2LONG(country->cp_Reserved[3]);
 170     country->cp_CountryCode = AROS_BE2LONG(country->cp_CountryCode);
 171 }
 172 #endif
 173
 174 /*********************************************************************************************/
 175
 176 #if !AROS_BIG_ENDIAN
 177 static void FixLocaleEndianess(struct LocalePrefs *localeprefs)
 178 {
 179     localeprefs->lp_Reserved[0] = AROS_BE2LONG(localeprefs->lp_Reserved[0]);
 180     localeprefs->lp_Reserved[1] = AROS_BE2LONG(localeprefs->lp_Reserved[1]);
 181     localeprefs->lp_Reserved[2] = AROS_BE2LONG(localeprefs->lp_Reserved[2]);
 182     localeprefs->lp_Reserved[3] = AROS_BE2LONG(localeprefs->lp_Reserved[3]);
 183     localeprefs->lp_GMTOffset   = AROS_BE2LONG(localeprefs->lp_GMTOffset);
 184     localeprefs->lp_Flags       = AROS_BE2LONG(localeprefs->lp_Flags);
 185 }
 186 #endif
 187
 188 /*********************************************************************************************/
 189
 190 BOOL LoadCountry(STRPTR name, struct CountryPrefs *country)
 191 {
 192     static struct CountryPrefs  loadcountry;
 193     struct IFFHandle            *iff;
 194     UBYTE                       fullname[100];
 195     BOOL                        retval = FALSE;
 196
 197     strcpy(fullname, "LOCALE:Countries");
 198     AddPart(fullname, name, 100);
 199     strcat(fullname, ".country");
 200
 201     D(bug("LoadCountry: Trying to open \"%s\"\n", fullname));
 202
 203     if ((iff = AllocIFF()))
 204     {
 205         if ((iff->iff_Stream = (IPTR)Open(fullname, MODE_OLDFILE)))
 206         {
 207             D(bug("LoadCountry: stream opened.\n"));
 208
 209             InitIFFasDOS(iff);
 210
 211             if (!OpenIFF(iff, IFFF_READ))
 212             {
 213                 D(bug("LoadCountry: OpenIFF okay.\n"));
 214
 215                 if (!StopChunk(iff, ID_PREF, ID_CTRY))
 216                 {
 217                     D(bug("LoadCountry: StopChunk okay.\n"));
 218
 219                     if (!ParseIFF(iff, IFFPARSE_SCAN))
 220                     {
 221                         struct ContextNode *cn;
 222
 223                         D(bug("LoadCountry: ParseIFF okay.\n"));
 224
 225                         cn = CurrentChunk(iff);
 226
 227                         if (cn->cn_Size == sizeof(struct CountryPrefs))
 228                         {
 229                             D(bug("LoadCountry: ID_CTRY chunk size okay.\n"));
 230
 231                             if (ReadChunkBytes(iff, &loadcountry, sizeof(struct CountryPrefs)) == sizeof(struct CountryPrefs))
 232                             {
 233                                 D(bug("LoadCountry: Reading chunk successful.\n"));
 234
 235                                 *country = loadcountry;
 236
 237                             #if !AROS_BIG_ENDIAN
 238                                 FixCountryEndianess(country);
 239                             #endif
 240
 241                                 D(bug("LoadCountry: Everything okay :-)\n"));
 242
 243                                 retval = TRUE;
 244                             }
 245                         }
 246
 247                     } /* if (!ParseIFF(iff, IFFPARSE_SCAN)) */
 248
 249                 } /* if (!StopChunk(iff, ID_PREF, ID_CTRY)) */
 250
 251                 CloseIFF(iff);
 252
 253             } /* if (!OpenIFF(iff, IFFF_READ)) */
 254
 255             Close((BPTR)iff->iff_Stream);
 256
 257         } /* if ((iff->iff_Stream = (IPTR)Open(fullname, MODE_OLDFILE))) */
 258
 259         FreeIFF(iff);
 260
 261     } /* if ((iff = AllocIFF())) */
 262
 263     return retval;
 264 }
 265
 266 /*********************************************************************************************/
 267
 268 BOOL LoadPrefs(STRPTR filename)
 269 {
 270     static struct LocalePrefs loadprefs;
 271     struct IFFHandle            *iff;
 272     BOOL                        retval = FALSE;
 273
 274     D(bug("LoadPrefs: Trying to open \"%s\"\n", filename));
 275
 276     if ((iff = AllocIFF()))
 277     {
 278         if ((iff->iff_Stream = (IPTR)Open(filename, MODE_OLDFILE)))
 279         {
 280             D(bug("LoadPrefs: stream opened.\n"));
 281
 282             InitIFFasDOS(iff);
 283
 284             if (!OpenIFF(iff, IFFF_READ))
 285             {
 286                 D(bug("LoadPrefs: OpenIFF okay.\n"));
 287
 288                 if (!StopChunk(iff, ID_PREF, ID_LCLE))
 289                 {
 290                     D(bug("LoadPrefs: StopChunk okay.\n"));
 291
 292                     if (!ParseIFF(iff, IFFPARSE_SCAN))
 293                     {
 294                         struct ContextNode *cn;
 295
 296                         D(bug("LoadPrefs: ParseIFF okay.\n"));
 297
 298                         cn = CurrentChunk(iff);
 299
 300                         if (cn->cn_Size == sizeof(struct LocalePrefs))
 301                         {
 302                             D(bug("LoadPrefs: ID_LCLE chunk size okay.\n"));
 303
 304                             if (ReadChunkBytes(iff, &loadprefs, sizeof(struct LocalePrefs)) == sizeof(struct LocalePrefs))
 305                             {
 306                                 D(bug("LoadPrefs: Reading chunk successful.\n"));
 307
 308                                 TellGUI(PAGECMD_PREFS_CHANGING);
 309
 310                                 localeprefs = loadprefs;
 311
 312                             #if !AROS_BIG_ENDIAN
 313                                 FixLocaleEndianess(&localeprefs);
 314                                 FixCountryEndianess(&localeprefs.lp_CountryData);
 315                             #endif
 316                                 TellGUI(PAGECMD_PREFS_CHANGED);
 317
 318                                 D(bug("LoadPrefs: Everything okay :-)\n"));
 319
 320                                 retval = TRUE;
 321                             }
 322                         }
 323
 324                     } /* if (!ParseIFF(iff, IFFPARSE_SCAN)) */
 325
 326                 } /* if (!StopChunk(iff, ID_PREF, ID_CTRY)) */
 327
 328                 CloseIFF(iff);
 329
 330             } /* if (!OpenIFF(iff, IFFF_READ)) */
 331
 332             Close((BPTR)iff->iff_Stream);
 333
 334         } /* if ((iff->iff_Stream = (IPTR)Open(filename, MODE_OLDFILE))) */
 335
 336         FreeIFF(iff);
 337
 338     } /* if ((iff = AllocIFF())) */
 339
 340     return retval;
 341 }
 342
 343 /*********************************************************************************************/
 344
 345 BOOL SavePrefs(STRPTR filename)
 346 {
 347     static struct LocalePrefs   saveprefs;
 348     struct IFFHandle            *iff;
 349     WORD                        i;
 350     BOOL                        retval = FALSE, delete_if_error = FALSE;
 351
 352     saveprefs = localeprefs;
 353 #if !AROS_BIG_ENDIAN
 354     FixLocaleEndianess(&saveprefs);
 355     FixCountryEndianess(&saveprefs.lp_CountryData);
 356 #endif
 357
 358     for(i = 0; i < 10; i++)
 359     {
 360         saveprefs.lp_PreferredLanguages[i][0] = ToLower(saveprefs.lp_PreferredLanguages[i][0]);
 361     }
 362
 363     D(bug("SavePrefs: Trying to open \"%s\"\n", filename));
 364
 365     if ((iff = AllocIFF()))
 366     {
 367         if ((iff->iff_Stream = (IPTR)Open(filename, MODE_NEWFILE)))
 368         {
 369             D(bug("SavePrefs: stream opened.\n"));
 370
 371             delete_if_error = TRUE;
 372
 373             InitIFFasDOS(iff);
 374
 375             if (!OpenIFF(iff, IFFF_WRITE))
 376             {
 377                 D(bug("SavePrefs: OpenIFF okay.\n"));
 378
 379                 if (!PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN))
 380                 {
 381                     D(bug("SavePrefs: PushChunk(FORM) okay.\n"));
 382
 383                     if (!PushChunk(iff, ID_PREF, ID_PRHD, sizeof(struct FilePrefHeader)))
 384                     {
 385                         struct FilePrefHeader head;
 386
 387                         D(bug("SavePrefs: PushChunk(PRHD) okay.\n"));
 388
 389                         head.ph_Version  = 0; // FIXME: shouold be PHV_CURRENT, but see <prefs/prefhdr.h>
 390                         head.ph_Type     = 0;
 391                         head.ph_Flags[0] =
 392                         head.ph_Flags[1] =
 393                         head.ph_Flags[2] =
 394                         head.ph_Flags[3] = 0;
 395
 396                         if (WriteChunkBytes(iff, &head, sizeof(head)) == sizeof(head))
 397                         {
 398                             D(bug("SavePrefs: WriteChunkBytes(PRHD) okay.\n"));
 399
 400                             PopChunk(iff);
 401
 402                             if (!PushChunk(iff, ID_PREF, ID_LCLE, sizeof(struct LocalePrefs)))
 403                             {
 404                                 D(bug("SavePrefs: PushChunk(LCLE) okay.\n"));
 405
 406                                 if (WriteChunkBytes(iff, &saveprefs, sizeof(saveprefs)) == sizeof(saveprefs))
 407                                 {
 408                                     D(bug("SavePrefs: WriteChunkBytes(LCLE) okay.\n"));
 409                                     D(bug("SavePrefs: Everything okay :-)\n"));
 410
 411                                     retval = TRUE;
 412                                 }
 413
 414                                 PopChunk(iff);
 415
 416                             } /* if (!PushChunk(iff, ID_PREF, ID_LCLE, sizeof(struct LocalePrefs))) */
 417
 418                         } /* if (WriteChunkBytes(iff, &head, sizeof(head)) == sizeof(head)) */
 419                         else
 420                         {
 421                             PopChunk(iff);
 422                         }
 423
 424                     } /* if (!PushChunk(iff, ID_PREF, ID_PRHD, sizeof(struct PrefHeader))) */
 425
 426                     PopChunk(iff);
 427
 428                 } /* if (!PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN)) */
 429
 430                 CloseIFF(iff);
 431
 432             } /* if (!OpenIFF(iff, IFFFWRITE)) */
 433
 434             Close((BPTR)iff->iff_Stream);
 435
 436         } /* if ((iff->iff_Stream = (IPTR)Open(filename, MODE_NEWFILE))) */
 437
 438         FreeIFF(iff);
 439
 440     } /* if ((iff = AllocIFF())) */
 441
 442     if (!retval && delete_if_error)
 443     {
 444         DeleteFile(filename);
 445     }
 446
 447     return retval;
 448 }
 449
 450 /*********************************************************************************************/
 451
 452 BOOL DefaultPrefs(void)
 453 {
 454     BOOL retval = FALSE;
 455     WORD i;
 456
 457     TellGUI(PAGECMD_PREFS_CHANGING);
 458
 459     localeprefs.lp_Reserved[0] = 0;
 460     localeprefs.lp_Reserved[1] = 0;
 461     localeprefs.lp_Reserved[2] = 0;
 462     localeprefs.lp_Reserved[3] = 0;
 463
 464     strcpy(localeprefs.lp_CountryName, "united_states");
 465
 466     for(i = 0; i < 10; i++)
 467     {
 468         memset(localeprefs.lp_PreferredLanguages[i], 0, sizeof(localeprefs.lp_PreferredLanguages[i]));
 469     }
 470     localeprefs.lp_GMTOffset = 5 * 60;
 471     localeprefs.lp_Flags = 0;
 472
 473     if (LoadCountry("united_states", &localeprefs.lp_CountryData))
 474     {
 475         retval = TRUE;
 476     }
 477
 478     TellGUI(PAGECMD_PREFS_CHANGED);
 479
 480     return retval;
 481 }
 482
 483 /*********************************************************************************************/
 484
 485 void RestorePrefs(void)
 486 {
 487     TellGUI(PAGECMD_PREFS_CHANGING);
 488     localeprefs = restore_prefs;
 489     TellGUI(PAGECMD_PREFS_CHANGED);
 490 }
 491
 492 /*********************************************************************************************/