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