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