workbench/prefs/locale/prefs.c

   1 /*
   2    Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3    $Id$
   4 */
   5
   6 /*********************************************************************************************/
   7
   8 #include <aros/debug.h>
   9
  10 #include <proto/exec.h>
  11 #include <proto/dos.h>
  12 #include <proto/locale.h>
  13 #include <proto/utility.h>
  14 #include <proto/alib.h>
  15 #include <proto/iffparse.h>
  16
  17 #include <aros/macros.h>
  18
  19 #include <prefs/prefhdr.h>
  20
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <stdlib.h>
  24
  25 #include "prefs.h"
  26 #include "misc.h"
  27
  28 /*********************************************************************************************/
  29
  30 #define PREFS_PATH_ENVARC "ENVARC:SYS/locale.prefs"
  31 #define PREFS_PATH_ENV    "ENV:SYS/locale.prefs"
  32
  33 /*********************************************************************************************/
  34
  35 struct FilePrefHeader
  36 {
  37     UBYTE ph_Version;
  38     UBYTE ph_Type;
  39     UBYTE ph_Flags[4];
  40 };
  41
  42 /*********************************************************************************************/
  43
  44 struct LocalePrefs  localeprefs;
  45 char                character_set[CHARACTER_SET_LEN];
  46 char                restore_charset[CHARACTER_SET_LEN];
  47 struct List         region_list;
  48 struct List         language_list;
  49 struct List         pref_language_list;
  50
  51 /*********************************************************************************************/
  52
  53 static APTR         mempool;
  54
  55 const char          *flagpathstr = "\033I[5:Locale:Flags/";
  56
  57 /*********************************************************************************************/
  58
  59 STATIC VOID SortInNode(struct List *list, struct Node *node)
  60 {
  61     struct Node *sort, *prev = NULL;
  62     struct Locale *loc;
  63
  64     loc = OpenLocale(NULL);
  65
  66     ForeachNode(list, sort)
  67     {
  68         if (StrnCmp(loc,
  69                     node->ln_Name, sort->ln_Name,
  70                     strlen(node->ln_Name), SC_COLLATE2)
  71                 < 0)
  72         {
  73             break;
  74         }
  75         prev = sort;
  76     }
  77
  78     Insert(list, node, prev);
  79     CloseLocale(loc);
  80 }
  81
  82 /*********************************************************************************************/
  83
  84 char *GetAROSRegionAttribs(struct AnchorPath *ap, char **regionNamePtr)
  85 {
  86     char                *lockFlag = NULL;
  87     struct IFFHandle    *iff;
  88     struct ContextNode  *cn;
  89     LONG                parse_mode = IFFPARSE_SCAN, error;
  90
  91     if ((iff = AllocIFF()))
  92     {
  93         if ((iff->iff_Stream = (IPTR)Open(ap->ap_Info.fib_FileName, MODE_OLDFILE)))
  94         {
  95             InitIFFasDOS(iff);
  96
  97             if (!OpenIFF(iff, IFFF_READ))
  98             {
  99                 if (!StopChunk(iff, ID_PREF, ID_PRHD))
 100                 {
 101                     do
 102                     {
 103                         if ((error = ParseIFF(iff, parse_mode)) == 0)
 104                         {
 105                             parse_mode = IFFPARSE_STEP;
 106
 107                             cn = CurrentChunk(iff);
 108                             D(bug("[LocalePrefs] GetAROSRegionAttribs: Chunk ID %08x. %d bytes\n", cn->cn_ID, cn->cn_Size));
 109
 110                             if (cn->cn_ID == MAKE_ID('N','N','A','M'))
 111                             {
 112                                 FreeVecPooled(mempool, *regionNamePtr);
 113                                 *regionNamePtr = AllocVecPooled(mempool, cn->cn_Size);
 114                                 ReadChunkBytes(iff, *regionNamePtr, cn->cn_Size);
 115                                 D(bug("[LocalePrefs] GetAROSRegionAttribs: NativeNames '%s'\n", *regionNamePtr));
 116                             }
 117
 118                             if (cn->cn_ID == MAKE_ID('F','L','A','G'))
 119                             {
 120                                 lockFlag = AllocVecPooled(mempool, cn->cn_Size + 18 + 1);
 121                                 sprintf(lockFlag, flagpathstr);
 122                                 ReadChunkBytes(iff, lockFlag + 18, cn->cn_Size);
 123                                 lockFlag[cn->cn_Size + 17] = ']';
 124                                 D(bug("[LocalePrefs] GetAROSRegionAttribs: Flag '%s'\n", lockFlag));
 125                             }
 126                         }
 127                     } while ((error != IFFERR_EOF) && (error != IFFERR_NOTIFF));
 128                 }
 129                 CloseIFF(iff);
 130             }
 131             Close((BPTR)iff->iff_Stream);
 132         }
 133         FreeIFF(iff);
 134     }
 135
 136     return lockFlag;
 137 }
 138
 139 char *GetAROSLanguageAttribs(struct AnchorPath *ap, char **languageNamePtr)
 140 {
 141     BPTR fileHandle;
 142     char tmpbuff[32];
 143     int read, len = 0, pos, i;
 144     BOOL match = FALSE;
 145
 146     if ((fileHandle = Open(ap->ap_Info.fib_FileName, MODE_OLDFILE)) != BNULL)
 147     {
 148         while ((read = Read(fileHandle, &tmpbuff[len], sizeof(tmpbuff) - len)) > 0)
 149         {
 150             len = len + read;
 151
 152             if (match)
 153             {
 154                 for (i = 0; i < len; i++)
 155                 {
 156                     if (tmpbuff[i] == '\0')
 157                     {
 158                         FreeVecPooled(mempool, *languageNamePtr);
 159                         *languageNamePtr = AllocVecPooled(mempool, i + 2);
 160                         CopyMem(tmpbuff, *languageNamePtr, i + 1);
 161                         Close(fileHandle);
 162                         D(bug("[LocalePrefs] GetAROSLanguageAttribs: NativeName (A) '%s'\n", *languageNamePtr));
 163                         return *languageNamePtr;
 164                     }
 165                     /* we shouldnt really ever reach here .. */
 166                 }
 167             }
 168             else
 169             {
 170                 pos = 0;
 171
 172                 while ((len - pos) >= 7)
 173                 {
 174                     if (strncmp(&tmpbuff[pos], "$NLANG:", 7) == 0)
 175                     {
 176                         match = TRUE;
 177                         pos += 7;
 178
 179                         if ((len - pos) > 0)
 180                         {
 181                             CopyMem(&tmpbuff[pos], tmpbuff, (len - pos));
 182                             len = len - pos;
 183                             for (i = 0; i < len; i++)
 184                             {
 185                                 if (tmpbuff[i] == '\0')
 186                                 {
 187                                     FreeVecPooled(mempool, *languageNamePtr);
 188                                     *languageNamePtr = AllocVecPooled(mempool, i + 2);
 189                                     CopyMem(tmpbuff, *languageNamePtr, i + 1);
 190                                     Close(fileHandle);
 191                                     D(bug("[LocalePrefs] GetAROSLanguageAttribs: NativeName (B) '%s'\n", *languageNamePtr));
 192                                     return *languageNamePtr;
 193                                 }
 194                             }
 195                         }
 196                         else
 197                             len = 0;
 198                     }
 199                     else
 200                         pos++;
 201                 }
 202                 if (!match && (pos < len))
 203                 {
 204                     CopyMem(&tmpbuff[pos], tmpbuff, (len - pos));
 205                     len = len - pos;
 206                 }
 207             }
 208         }
 209         Close(fileHandle);
 210     }
 211     return NULL;
 212 }
 213
 214 /*********************************************************************************************/
 215
 216 STATIC VOID ScanDirectory(char *pattern, struct List *list, LONG entrysize)
 217 {
 218     struct AnchorPath           ap;
 219     struct ListviewEntry        *entry;
 220     BPTR                        curdir = BNULL;
 221     char                        *sp;
 222     LONG                        error;
 223
 224     memset(&ap, 0, sizeof(ap));
 225
 226     if ((error = MatchFirst(pattern, &ap)) == 0)
 227         curdir = CurrentDir(ap.ap_Current->an_Lock);
 228
 229     while((error == 0))
 230     {
 231         if (ap.ap_Info.fib_DirEntryType < 0)
 232         {
 233             entry = (struct ListviewEntry *)AllocPooled(mempool, entrysize);
 234             if (entry)
 235             {
 236                 entry->node.ln_Name = AllocVecPooled(mempool, strlen(ap.ap_Info.fib_FileName) + 1);
 237                 strcpy(entry->node.ln_Name, ap.ap_Info.fib_FileName);
 238
 239                 if ((sp = strchr(entry->node.ln_Name, '.')) != NULL)
 240                     sp[0] = '\0';
 241
 242                 strcpy(entry->realname, entry->node.ln_Name);
 243                 entry->node.ln_Name[0] = ToUpper(entry->node.ln_Name[0]);
 244
 245                 if (entrysize == sizeof(struct RegionEntry))
 246                 {
 247                     D(bug("[LocalePrefs] ScanDir: Checking for FLAG chunk\n"));
 248                     if (!(entry->displayflag = GetAROSRegionAttribs(&ap, &entry->node.ln_Name)))
 249                     {
 250                         entry->displayflag = AllocVecPooled(mempool, strlen(entry->realname) + strlen(flagpathstr) + 12);
 251                         sprintf(entry->displayflag, "%sCountries/%s]", flagpathstr, entry->realname);
 252                     }
 253                 }
 254                 else if (entrysize == sizeof(struct LanguageEntry))
 255                 {
 256                     D(bug("[LocalePrefs] ScanDir: Checking for native Language name\n"));
 257                     GetAROSLanguageAttribs(&ap, &entry->node.ln_Name);
 258                     entry->node.ln_Name[0] = ToUpper(entry->node.ln_Name[0]);
 259                 }
 260
 261                 sp = entry->node.ln_Name;
 262                 while((sp = strchr(sp, '_')))
 263                 {
 264                     sp[0] = ' ';
 265                     if (sp[1])
 266                     {
 267                         /* Make char after underscore uppercase only if no
 268                            more underscores follow */
 269                         if (strchr(sp, '_') == 0)
 270                         {
 271                             sp[1] = ToUpper(sp[1]);
 272                         }
 273                     }
 274                 }
 275                 SortInNode(list, &entry->node);
 276             }
 277         }
 278         error = MatchNext(&ap);
 279     }
 280     if (curdir != BNULL)
 281         CurrentDir(curdir);
 282     MatchEnd(&ap);
 283 }
 284
 285 /*********************************************************************************************/
 286
 287 #if !AROS_BIG_ENDIAN
 288 STATIC VOID FixCountryEndianess(struct CountryPrefs *region)
 289 {
 290     region->cp_Reserved[0] = AROS_BE2LONG(region->cp_Reserved[0]);
 291     region->cp_Reserved[1] = AROS_BE2LONG(region->cp_Reserved[1]);
 292     region->cp_Reserved[2] = AROS_BE2LONG(region->cp_Reserved[2]);
 293     region->cp_Reserved[3] = AROS_BE2LONG(region->cp_Reserved[3]);
 294     region->cp_CountryCode = AROS_BE2LONG(region->cp_CountryCode);
 295 }
 296 #endif
 297
 298 /*********************************************************************************************/
 299
 300 #if !AROS_BIG_ENDIAN
 301 STATIC VOID FixLocaleEndianess(struct LocalePrefs *localeprefs)
 302 {
 303     localeprefs->lp_Reserved[0] = AROS_BE2LONG(localeprefs->lp_Reserved[0]);
 304     localeprefs->lp_Reserved[1] = AROS_BE2LONG(localeprefs->lp_Reserved[1]);
 305     localeprefs->lp_Reserved[2] = AROS_BE2LONG(localeprefs->lp_Reserved[2]);
 306     localeprefs->lp_Reserved[3] = AROS_BE2LONG(localeprefs->lp_Reserved[3]);
 307     localeprefs->lp_GMTOffset   = AROS_BE2LONG(localeprefs->lp_GMTOffset);
 308     localeprefs->lp_Flags       = AROS_BE2LONG(localeprefs->lp_Flags);
 309 }
 310 #endif
 311
 312 /*********************************************************************************************/
 313
 314 BOOL Prefs_LoadRegion(STRPTR name, struct CountryPrefs *region)
 315 {
 316     static struct CountryPrefs  loadregion;
 317     struct IFFHandle            *iff;
 318     struct ContextNode          *cn;
 319     LONG                        parse_mode = IFFPARSE_SCAN, error;
 320     char                        fullname[100];
 321     BOOL                        retval = FALSE;
 322
 323     strcpy(fullname, "LOCALE:Countries");
 324     AddPart(fullname, name, 100);
 325     strcat(fullname, ".country");
 326
 327     D(bug("[LocalePrefs] LoadRegion: Trying to open \"%s\"\n", fullname));
 328
 329     if ((iff = AllocIFF()))
 330     {
 331         if ((iff->iff_Stream = (IPTR)Open(fullname, MODE_OLDFILE)))
 332         {
 333             D(bug("[LocalePrefs] LoadRegion: stream opened.\n"));
 334
 335             InitIFFasDOS(iff);
 336
 337             if (!OpenIFF(iff, IFFF_READ))
 338             {
 339                 D(bug("[LocalePrefs] LoadRegion: OpenIFF okay.\n"));
 340
 341                 if (!StopChunk(iff, ID_PREF, ID_PRHD))
 342                 {
 343                     D(bug("[LocalePrefs] LoadRegion: StopChunk okay.\n"));
 344
 345                     do
 346                     {
 347                         if ((error = ParseIFF(iff, parse_mode)) == 0)
 348                         {
 349                             parse_mode = IFFPARSE_STEP;
 350
 351                             D(bug("[LocalePrefs] LoadRegion: ParseIFF okay.\n"));
 352
 353                             cn = CurrentChunk(iff);
 354
 355                             D(bug("[LocalePrefs] LoadRegion: Chunk ID %08x.\n", cn->cn_ID));
 356
 357                             if ((cn->cn_ID == ID_CTRY) && (cn->cn_Size == sizeof(struct CountryPrefs)))
 358                             {
 359                                 D(bug("[LocalePrefs] LoadRegion: Chunk ID_CTRY (size okay).\n"));
 360
 361                                 if (ReadChunkBytes(iff, &loadregion, sizeof(struct CountryPrefs)) == sizeof(struct CountryPrefs))
 362                                 {
 363                                     D(bug("[LocalePrefs] LoadRegion: Reading chunk successful.\n"));
 364
 365                                     *region = loadregion;
 366
 367 #if !AROS_BIG_ENDIAN
 368                                     FixCountryEndianess(region);
 369 #endif
 370
 371                                     D(bug("[LocalePrefs] LoadRegion: Everything okay :-)\n"));
 372
 373                                     retval = TRUE;
 374                                     error = IFFERR_EOF;
 375                                 }
 376                             }
 377                         } /* if (!ParseIFF(iff, IFFPARSE_SCAN)) */
 378                     } while ((error != IFFERR_EOF) && (error != IFFERR_NOTIFF));
 379                 } /* if (!StopChunk(iff, ID_PREF, ID_CTRY)) */
 380                 CloseIFF(iff);
 381             } /* if (!OpenIFF(iff, IFFF_READ)) */
 382             Close((BPTR)iff->iff_Stream);
 383         } /* if ((iff->iff_Stream = (IPTR)Open(fullname, MODE_OLDFILE))) */
 384         FreeIFF(iff);
 385     } /* if ((iff = AllocIFF())) */
 386
 387     return retval;
 388 }
 389
 390 /*********************************************************************************************/
 391
 392 BOOL Prefs_ImportFH(BPTR fh)
 393 {
 394     static struct LocalePrefs   loadprefs;
 395     struct IFFHandle           *iff;
 396     BOOL                        retval = FALSE;
 397
 398     D(bug("[LocalePrefs] LoadPrefsFH\n"));
 399
 400     if ((iff = AllocIFF()))
 401     {
 402         if ((iff->iff_Stream = (IPTR) fh))
 403         {
 404             D(bug("[LocalePrefs] LoadPrefsFH: stream is ok.\n"));
 405
 406             InitIFFasDOS(iff);
 407
 408             if (!OpenIFF(iff, IFFF_READ))
 409             {
 410                 D(bug("[LocalePrefs] LoadPrefsFH: OpenIFF okay.\n"));
 411
 412                 if (!StopChunk(iff, ID_PREF, ID_LCLE))
 413                 {
 414                     D(bug("[LocalePrefs] LoadPrefsFH: StopChunk okay.\n"));
 415
 416                     if (!ParseIFF(iff, IFFPARSE_SCAN))
 417                     {
 418                         struct ContextNode *cn;
 419
 420                         D(bug("[LocalePrefs] LoadPrefsFH: ParseIFF okay.\n"));
 421
 422                         cn = CurrentChunk(iff);
 423
 424                         if (cn->cn_Size == sizeof(struct LocalePrefs))
 425                         {
 426                             D(bug("[LocalePrefs] LoadPrefsFH: ID_LCLE chunk size okay.\n"));
 427
 428                             if (ReadChunkBytes(iff, &loadprefs, sizeof(struct LocalePrefs)) == sizeof(struct LocalePrefs))
 429                             {
 430                                 D(bug("[LocalePrefs] LoadPrefsFH: Reading chunk successful.\n"));
 431
 432                                 localeprefs = loadprefs;
 433
 434 #if !AROS_BIG_ENDIAN
 435                                 FixLocaleEndianess(&localeprefs);
 436                                 FixCountryEndianess(&localeprefs.lp_CountryData);
 437 #endif
 438
 439                                 D(bug("[LocalePrefs] LoadPrefsFH: Everything okay :-)\n"));
 440
 441                                 retval = TRUE;
 442                             }
 443                         }
 444                     } /* if (!ParseIFF(iff, IFFPARSE_SCAN)) */
 445                 } /* if (!StopChunk(iff, ID_PREF, ID_CTRY)) */
 446                 CloseIFF(iff);
 447             } /* if (!OpenIFF(iff, IFFF_READ)) */
 448         } /* if ((iff->iff_Stream = (IPTR)Open(filename, MODE_OLDFILE))) */
 449         FreeIFF(iff);
 450     } /* if ((iff = AllocIFF())) */
 451
 452     D(bug("[LocalePrefs] LoadPrefsFH: CountryName = '%s'\n", localeprefs.lp_CountryName));
 453
 454     D(
 455         int i;
 456         for(i = 0; i < 10 && localeprefs.lp_PreferredLanguages[i]; i++)
 457         {
 458             bug("[LocalePrefs] LoadPrefsFH: preferred %02d = '%s'\n", i, localeprefs.lp_PreferredLanguages[i]);
 459         }
 460     )
 461     D(bug("[LocalePrefs] LoadPrefsFH: lp_GMTOffset = %ld\n", localeprefs.lp_GMTOffset));
 462     return retval;
 463 }
 464
 465
 466 /*********************************************************************************************/
 467
 468 BOOL Prefs_ExportFH(BPTR fh)
 469 {
 470     struct LocalePrefs  saveprefs;
 471     struct IFFHandle   *iff;
 472     BOOL                retval = FALSE;
 473 #if 0 /* unused */
 474     BOOL                delete_if_error = FALSE;
 475 #endif
 476
 477     D(bug("[LocalePrefs] SavePrefsFH: fh: %lx\n", fh));
 478
 479     CopyMem(&localeprefs, &saveprefs, sizeof(struct LocalePrefs));
 480
 481 #if !AROS_BIG_ENDIAN
 482     FixLocaleEndianess(&saveprefs);
 483     FixCountryEndianess(&saveprefs.lp_CountryData);
 484 #endif
 485
 486     if ((iff = AllocIFF()))
 487     {
 488         iff->iff_Stream = (IPTR) fh;
 489         D(bug("[LocalePrefs] SavePrefsFH: stream opened.\n"));
 490
 491 #if 0 /* unused */
 492         delete_if_error = TRUE;
 493 #endif
 494
 495         InitIFFasDOS(iff);
 496
 497         if (!OpenIFF(iff, IFFF_WRITE))
 498         {
 499             D(bug("[LocalePrefs] SavePrefsFH: OpenIFF okay.\n"));
 500
 501             if (!PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN))
 502             {
 503                 D(bug("[LocalePrefs] SavePrefsFH: PushChunk(FORM) okay.\n"));
 504
 505                 if (!PushChunk(iff, ID_PREF, ID_PRHD, sizeof(struct FilePrefHeader)))
 506                 {
 507                     struct FilePrefHeader head;
 508
 509                     D(bug("[LocalePrefs] SavePrefsFH: PushChunk(PRHD) okay.\n"));
 510
 511                     head.ph_Version  = PHV_CURRENT;
 512                     head.ph_Type     = 0;
 513                     head.ph_Flags[0] =
 514                         head.ph_Flags[1] =
 515                         head.ph_Flags[2] =
 516                         head.ph_Flags[3] = 0;
 517
 518                     if (WriteChunkBytes(iff, &head, sizeof(head)) == sizeof(head))
 519                     {
 520                         D(bug("[LocalePrefs] SavePrefsFH: WriteChunkBytes(PRHD) okay.\n"));
 521
 522                         PopChunk(iff);
 523
 524                         if (!PushChunk(iff, ID_PREF, ID_LCLE, sizeof(struct LocalePrefs)))
 525                         {
 526                             D(bug("[LocalePrefs] SavePrefsFH: PushChunk(LCLE) okay.\n"));
 527
 528                             if (WriteChunkBytes(iff, &saveprefs, sizeof(saveprefs)) == sizeof(saveprefs))
 529                             {
 530                                 D(bug("[LocalePrefs] SavePrefsFH: WriteChunkBytes(SERL) okay.\n"));
 531                                 D(bug("[LocalePrefs] SavePrefsFH: Everything okay :-)\n"));
 532
 533                                 retval = TRUE;
 534                             }
 535                             PopChunk(iff);
 536                         } /* if (!PushChunk(iff, ID_PREF, ID_SERL, sizeof(struct LocalePrefs))) */
 537
 538                     } /* if (WriteChunkBytes(iff, &head, sizeof(head)) == sizeof(head)) */
 539                     else
 540                     {
 541                         PopChunk(iff);
 542                     }
 543                 } /* if (!PushChunk(iff, ID_PREF, ID_PRHD, sizeof(struct PrefHeader))) */
 544                 PopChunk(iff);
 545             } /* if (!PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN)) */
 546             CloseIFF(iff);
 547         } /* if (!OpenIFF(iff, IFFFWRITE)) */
 548         FreeIFF(iff);
 549     } /* if ((iff = AllocIFF())) */
 550
 551 #if 0 /* unused */
 552     if (!retval && delete_if_error)
 553     {
 554         DeleteFile(filename);
 555     }
 556 #endif
 557
 558     return retval;
 559 }
 560
 561 /*********************************************************************************************/
 562
 563 BOOL Prefs_SaveCharset(BOOL envarc)
 564 {
 565     LONG flags = GVF_GLOBAL_ONLY;
 566
 567     D(bug("[LocalePrefs] SaveCharset(%ld)\n", envarc));
 568
 569     if (envarc)
 570         flags |= GVF_SAVE_VAR;
 571     /* We don't check results of the following actions because they may fail if ENVARC: is read-only (CD-ROM) */
 572     if (character_set[0])
 573         SetVar("CHARSET", character_set, -1, flags);
 574     else
 575         DeleteVar("CHARSET", flags);
 576
 577     return TRUE;
 578 }
 579
 580 /*********************************************************************************************/
 581
 582 static BOOL Prefs_Load(STRPTR from)
 583 {
 584     BOOL retval = FALSE;
 585
 586     BPTR fh = Open(from, MODE_OLDFILE);
 587     if (fh)
 588     {
 589         retval = Prefs_ImportFH(fh);
 590         Close(fh);
 591     }
 592
 593     return retval;
 594 }
 595
 596 /*********************************************************************************************/
 597
 598 BOOL Prefs_HandleArgs(STRPTR from, BOOL use, BOOL save)
 599 {
 600     BPTR fh;
 601
 602     if (from)
 603     {
 604         if (!Prefs_Load(from))
 605         {
 606             ShowMessage("Can't read from input file");
 607             return FALSE;
 608         }
 609     }
 610     else
 611     {
 612         if (!Prefs_Load(PREFS_PATH_ENV))
 613         {
 614             if (!Prefs_Load(PREFS_PATH_ENVARC))
 615             {
 616                 ShowMessage
 617                 (
 618                     "Can't read from file " PREFS_PATH_ENVARC
 619                     ".\nUsing default values."
 620                 );
 621                 Prefs_Default();
 622             }
 623         }
 624     }
 625
 626     if (use || save)
 627     {
 628         Prefs_LoadRegion(localeprefs.lp_CountryName, &localeprefs.lp_CountryData);
 629         fh = Open(PREFS_PATH_ENV, MODE_NEWFILE);
 630         if (fh)
 631         {
 632             Prefs_ExportFH(fh);
 633             Close(fh);
 634         }
 635         else
 636         {
 637             ShowMessage("Cant' open " PREFS_PATH_ENV " for writing.");
 638         }
 639     }
 640     if (save)
 641     {
 642         fh = Open(PREFS_PATH_ENVARC, MODE_NEWFILE);
 643         if (fh)
 644         {
 645             Prefs_ExportFH(fh);
 646             Close(fh);
 647         }
 648         else
 649         {
 650             ShowMessage("Cant' open " PREFS_PATH_ENVARC " for writing.");
 651         }
 652     }
 653
 654     return TRUE;
 655 }
 656
 657 /*********************************************************************************************/
 658
 659 BOOL Prefs_Initialize(VOID)
 660 {
 661     D(bug("[LocalePrefs] InitPrefs\n"));
 662
 663     struct LanguageEntry *entry;
 664
 665     mempool = CreatePool(MEMF_PUBLIC | MEMF_CLEAR, 2048, 2048);
 666     if (!mempool)
 667     {
 668         ShowMessage("Out of memory!");
 669         return FALSE;
 670     }
 671
 672     NewList(&region_list);
 673     NewList(&language_list);
 674     NewList(&pref_language_list);
 675
 676     ScanDirectory("LOCALE:Countries/~(#?.info)", &region_list, sizeof(struct RegionEntry));
 677     ScanDirectory("LOCALE:Languages/#?.language", &language_list, sizeof(struct LanguageEntry));
 678
 679     /* English language is always available */
 680
 681     if ((entry = AllocPooled(mempool, sizeof(struct LanguageEntry))))
 682     {
 683         entry->lve.node.ln_Name = AllocVecPooled(mempool, 8);
 684         strcpy( entry->lve.node.ln_Name, "English");
 685         strcpy( entry->lve.realname, "english");
 686
 687         SortInNode(&language_list, &entry->lve.node);
 688     }
 689
 690     character_set[0] = 0;
 691     GetVar("CHARSET", character_set, sizeof(character_set), 0);
 692     D(bug("[LocalePrefs] System character set: %s\n", character_set));
 693
 694     return TRUE;
 695 }
 696
 697 /*********************************************************************************************/
 698
 699 VOID Prefs_Deinitialize(VOID)
 700 {
 701     D(bug("[LocalePrefs] CleanupPrefs\n"));
 702     if (mempool)
 703     {
 704         DeletePool(mempool);
 705         mempool = NULL;
 706     }
 707 }
 708
 709 /*********************************************************************************************/
 710
 711 BOOL Prefs_Default(VOID)
 712 {
 713     BOOL retval = FALSE;
 714     WORD i;
 715
 716     localeprefs.lp_Reserved[0] = 0;
 717     localeprefs.lp_Reserved[1] = 0;
 718     localeprefs.lp_Reserved[2] = 0;
 719     localeprefs.lp_Reserved[3] = 0;
 720
 721     strcpy(localeprefs.lp_CountryName, "united_states");
 722
 723     for(i = 0; i < 10; i++)
 724     {
 725         memset(localeprefs.lp_PreferredLanguages[i], 0, sizeof(localeprefs.lp_PreferredLanguages[i]));
 726     }
 727     localeprefs.lp_GMTOffset = 5 * 60;
 728     localeprefs.lp_Flags = 0;
 729
 730     if (Prefs_LoadRegion((STRPTR) "united_states", &localeprefs.lp_CountryData))
 731     {
 732         retval = TRUE;
 733     }
 734
 735     character_set[0] = 0;
 736
 737     return retval;
 738 }