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