workbench/prefs/input/prefs.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 /*********************************************************************************************/
  10
  11 #define SHOWFLAGS 1  /* Set to 1 to show Flags in the keylist */
  12
  13 #include <libraries/kms.h>
  14
  15 #include <proto/alib.h>
  16 #include <proto/dos.h>
  17 #include <proto/intuition.h>
  18 #include <proto/iffparse.h>
  19 #include <proto/utility.h>
  20
  21 #define DEBUG 0
  22 #include <aros/debug.h>
  23
  24 #include "prefs.h"
  25 #include "misc.h"
  26
  27 /*********************************************************************************************/
  28
  29 #define PREFS_PATH_ENVARC "ENVARC:SYS/input.prefs"
  30 #define PREFS_PATH_ENV    "ENV:SYS/input.prefs"
  31
  32 /*********************************************************************************************/
  33
  34 APTR                mempool;
  35 struct InputPrefs   inputprefs;
  36 struct KMSPrefs     kmsprefs;
  37 struct List         keymap_list;
  38
  39 /*********************************************************************************************/
  40
  41 static const struct nameexp layout_expansion_table[] =
  42 {
  43     {"al"   , "Albanian"            , NULL              },
  44     {"usa"  , "American"            , "United_States"   },
  45     {"usa0" , "American"            , "United_States"   },
  46     {"us"   , "American"            , "United_States"   },
  47     {"usx"  , "American"            , "United_States"   },
  48     {"d"    , "Deutsch"             , "Deutschland"     },
  49     {"b"    , "Belge"               , "Belgique"        },
  50     {"by"   , "Belarussian"         , NULL              },
  51     {"br"   , "Brasileiro"          , "Brasil"          },
  52     {"gb"   , "British"             , "United_Kingdom"  },
  53     {"gbx"  , "British Extended"    , "United_Kingdom"  },
  54     {"bg"   , "Bulgarian"           , "Bulgarija"       },
  55     {"cdn"  , "Canadien Français"   , "Canada_Français" },
  56     {"cz"   , "Czech"               , "Cesko"           },
  57     {"dk"   , "Dansk"               , "Danmark"         },
  58     {"nl"   , "Dutch"               , "Nederland"       },
  59     {"dvx"  , "Dvorak"              , NULL              },
  60     {"usa2" , "Dvorak"              , NULL              },
  61     {"dvl"  , "Dvorak Left-handed"  , NULL              },
  62     {"dvr"  , "Dvorak Right-handed" , NULL              },
  63     {"gr"   , "Ellinikí"            , "Hellas"          }, // Greak
  64     {"irl"  , "English Ireland"     , "Ireland"         },
  65     {"e"    , "Español"             , "España"          },
  66     {"sp"   , "Español no deadkeys" , "España"          },
  67     {"est"  , "Estonian"            , "Eesti"           },
  68     {"fin"  , "Finnish"             , "Suomi"           },
  69     {"f"    , "Français"            , "France"          },
  70     {"hr"   , "Hrvatski"            , "Hrvatska"        }, // Croatia
  71     {"is"   , "Íslenska"            , "Ísland"          },
  72     {"i"    , "Italiana"            , "Italia"          },
  73     {"la"   , "Latin American"      , NULL              },
  74     {"lv"   , "Latvian"             , NULL              }, // Lettland
  75     {"lt"   , "Lithuanian"          , "Lietuva"         }, // Lithuania
  76     {"h"    , "Magyar"              , "Magyarország"    }, // Hungary
  77     {"n"    , "Norsk"               , "Norge"           },
  78     {"pl"   , "Polski"              , "Polska"          },
  79     {"p"    , "Português"           , "Portugal"        },
  80     {"rus"  , "Russian"             , "Rossija"         },
  81     {"ch2"  , "Suisse"              , "Suisse"          },
  82     {"sk"   , "Slovak"              , "Slovakia"        },
  83     {"ch1"  , "Schweizer"           , "Schweiz"         },
  84     {"s"    , "Svenskt"             , "Sverige"         },
  85     {"tr"   , "Türkçe"              , "Türkiye"         },
  86     {"ua"   , "Ukranian"            , "Ukrajina"        },
  87     {NULL   , NULL                  , NULL              }
  88 };
  89
  90 static const struct typeexp type_expansion_table[] = {
  91     {"amiga", "Amiga" },
  92     {"pc104", "PC 104"},
  93     {"pc105", "PC 105"},
  94     {"sun"  , "Sun"   },
  95     {NULL   , NULL    }
  96 };
  97
  98 /*********************************************************************************************/
  99
 100 static BOOL Prefs_Load(STRPTR from)
 101 {
 102     BOOL retval = FALSE;
 103
 104     BPTR fh = Open(from, MODE_OLDFILE);
 105     if (fh)
 106     {
 107         retval = Prefs_ImportFH(fh);
 108         Close(fh);
 109     }
 110
 111     return retval;
 112 }
 113
 114 /*********************************************************************************************/
 115
 116 static void ExpandName(struct ListviewEntry *entry)
 117 {
 118     char *sp;
 119     char *type = NULL;
 120     const struct nameexp *exp;
 121
 122     strcpy(entry->layoutname, entry->realname);
 123
 124     sp = strchr(entry->realname, '_');
 125     if (sp)
 126     {
 127         /*
 128          * We have several variants of US keyboard, so
 129          * we append type name.
 130          */
 131         if ((sp[1] == 'u' && sp[2] == 's'))
 132         {
 133              const struct typeexp *te;
 134
 135              *sp = 0;
 136              for (te = type_expansion_table; te->shortname; te++)
 137              {
 138                 if (!strcmp(entry->realname, te->shortname))
 139                 {
 140                     type = te->longname;
 141                     break;
 142                 }
 143             }
 144             *sp = '_';
 145         }
 146         sp++;
 147     }
 148     else
 149         sp = entry->realname;
 150
 151     for (exp = layout_expansion_table; exp->shortname; exp++)
 152     {
 153         if (stricmp(exp->shortname, sp) == 0)
 154         {
 155             if (type)
 156                 snprintf(entry->layoutname, sizeof(entry->layoutname), "%s (%s)", exp->longname, type);
 157             else
 158                 strcpy(entry->layoutname, exp->longname);
 159
 160             if (exp->flag != NULL)
 161             {
 162 #if SHOWFLAGS == 1
 163                 sprintf(entry->displayflag, "\033I[5:Locale:Flags/Countries/%s]", exp->flag);
 164 #else
 165                 entry->displayflag[0] = '\0';
 166 #endif
 167             }
 168             break;
 169         }
 170     }
 171
 172
 173 }
 174
 175 /*********************************************************************************************/
 176
 177
 178 void SortInNode(struct List *list, struct Node *node)
 179 {
 180     struct Node *sort, *prev = NULL;
 181
 182     ForeachNode(list, sort)
 183     {
 184         if (Stricmp(node->ln_Name, sort->ln_Name) < 0) break;
 185         prev = sort;
 186     }
 187
 188     Insert(list, node, prev);
 189 }
 190
 191 void Prefs_ScanDirectory(STRPTR pattern, struct List *list, LONG entrysize)
 192 {
 193     struct AnchorPath       ap;
 194     struct ListviewEntry    *entry, *entry2;
 195     struct List             templist;
 196     STRPTR                  sp;
 197     LONG                    error;
 198
 199     memset(&ap, 0, sizeof(ap));
 200     NewList(&templist);
 201
 202     /*
 203      * Add default keymap.
 204      * CHECKME: possibly too hacky. May be we should verify its presence in keymap.resource?
 205      * How is it done in classic AmigaOS(tm) ?
 206      */
 207     entry = AllocPooled(mempool, entrysize);
 208     if (entry)
 209     {
 210         strcpy(entry->layoutname, "American (Default)");
 211         strcpy(entry->realname  , DEFAULT_KEYMAP);
 212 #if SHOWFLAGS == 1
 213         strcpy(entry->displayflag, "\033I[5:Locale:Flags/Countries/United_States]");
 214 #else
 215         entry->displayflag[0] = '\0';
 216 #endif
 217
 218         entry->node.ln_Name = entry->layoutname;
 219         AddTail(&templist, &entry->node);
 220     }
 221
 222     error = MatchFirst(pattern, &ap);
 223     while((error == 0))
 224     {
 225         if (ap.ap_Info.fib_DirEntryType < 0)
 226         {
 227             entry = (struct ListviewEntry *)AllocPooled((APTR)mempool, entrysize);
 228             if (entry)
 229             {
 230                 entry->node.ln_Name = entry->layoutname;
 231                 strncpy(entry->realname, ap.ap_Info.fib_FileName, sizeof(entry->realname));
 232
 233                 sp = strchr(entry->realname, '_');
 234                 if (sp)
 235                    sp++;
 236                 else
 237                    sp = entry->realname;
 238                 strcpy(entry->layoutname, sp);
 239
 240                 ExpandName(entry);
 241                 AddTail(&templist, &entry->node);
 242             }
 243         }
 244         error = MatchNext(&ap);
 245     }
 246     MatchEnd(&ap);
 247
 248     /* Sort by Layout Name */
 249
 250     ForeachNodeSafe(&templist, entry, entry2)
 251     {
 252         Remove(&entry->node);
 253         SortInNode(list, &entry->node);
 254     }
 255 }
 256
 257 /*********************************************************************************************/
 258
 259 static LONG stopchunks[] =
 260 {
 261     ID_PREF, ID_INPT,
 262     ID_PREF, ID_KMSW
 263 };
 264
 265 BOOL Prefs_ImportFH(BPTR fh)
 266 {
 267     struct FileInputPrefs   loadprefs;
 268     struct FileKMSPrefs     loadkmsprefs;
 269     struct IFFHandle       *iff;
 270     ULONG                   size;
 271     BOOL                    retval = FALSE;
 272
 273     memset(&loadprefs, 0, sizeof(loadprefs));
 274
 275     if ((iff = AllocIFF()))
 276     {
 277         iff->iff_Stream = (IPTR)fh;
 278         if (fh != BNULL)
 279         {
 280             D(Printf("LoadPrefs: stream opened.\n"));
 281
 282             InitIFFasDOS(iff);
 283
 284             if (!OpenIFF(iff, IFFF_READ))
 285             {
 286                 D(Printf("LoadPrefs: OpenIFF okay.\n"));
 287
 288                 if (!StopChunks(iff, stopchunks, 2))
 289                 {
 290                     D(Printf("LoadPrefs: StopChunk okay.\n"));
 291                     retval = TRUE;
 292
 293                     while (!ParseIFF(iff, IFFPARSE_SCAN))
 294                     {
 295                         struct ContextNode *cn;
 296
 297                         D(Printf("LoadPrefs: ParseIFF okay.\n"));
 298
 299                         cn = CurrentChunk(iff);
 300                         size = cn->cn_Size;
 301
 302                         switch (cn->cn_ID)
 303                         {
 304                         case ID_INPT:
 305                             D(Printf("LoadPrefs: INPT chunk\n"));
 306
 307                             if (size > sizeof(struct FileInputPrefs))
 308                                 size = sizeof(struct FileInputPrefs);
 309
 310                             if (ReadChunkBytes(iff, &loadprefs, size) == size)
 311                             {
 312                                 D(Printf("LoadPrefs: Reading chunk successful.\n"));
 313
 314                                 CopyMem(loadprefs.ip_Keymap, inputprefs.ip_Keymap, sizeof(loadprefs.ip_Keymap));
 315                                 inputprefs.ip_PointerTicks         = ARRAY_TO_WORD(loadprefs.ip_PointerTicks);
 316                                 inputprefs.ip_DoubleClick.tv_secs  = ARRAY_TO_LONG(loadprefs.ip_DoubleClick_secs);
 317                                 inputprefs.ip_DoubleClick.tv_micro = ARRAY_TO_LONG(loadprefs.ip_DoubleClick_micro);
 318                                 inputprefs.ip_KeyRptDelay.tv_secs  = ARRAY_TO_LONG(loadprefs.ip_KeyRptDelay_secs);
 319                                 inputprefs.ip_KeyRptDelay.tv_micro = ARRAY_TO_LONG(loadprefs.ip_KeyRptDelay_micro);
 320                                 inputprefs.ip_KeyRptSpeed.tv_secs  = ARRAY_TO_LONG(loadprefs.ip_KeyRptSpeed_secs);
 321                                 inputprefs.ip_KeyRptSpeed.tv_micro = ARRAY_TO_LONG(loadprefs.ip_KeyRptSpeed_micro);
 322                                 inputprefs.ip_MouseAccel           = ARRAY_TO_WORD(loadprefs.ip_MouseAccel);
 323                                 inputprefs.ip_ClassicKeyboard      = ARRAY_TO_LONG(loadprefs.ip_ClassicKeyboard);
 324                                 CopyMem(loadprefs.ip_KeymapName, inputprefs.ip_KeymapName, sizeof(loadprefs.ip_KeymapName));
 325                                 inputprefs.ip_SwitchMouseButtons   = loadprefs.ip_SwitchMouseButtons[3];
 326
 327                                 D(Printf("LoadPrefs: SwitchMouseButtons: %ld\n", inputprefs.ip_SwitchMouseButtons));
 328                             }
 329                             else
 330                                 retval = FALSE;
 331                             break;
 332
 333                         case ID_KMSW:
 334                             D(Printf("LoadPrefs: KMSW chunk\n"));
 335
 336                             if (size > sizeof(struct FileKMSPrefs))
 337                                 size = sizeof(struct FileKMSPrefs);
 338
 339                             if (ReadChunkBytes(iff, &loadkmsprefs, size) == size)
 340                             {
 341                                 D(Printf("LoadPrefs: Reading chunk successful.\n"));
 342
 343                                 kmsprefs.kms_Enabled    = loadkmsprefs.kms_Enabled;
 344                                 kmsprefs.kms_Reserved   = loadkmsprefs.kms_Reserved;
 345                                 kmsprefs.kms_SwitchQual = ARRAY_TO_WORD(loadkmsprefs.kms_SwitchQual);
 346                                 kmsprefs.kms_SwitchCode = ARRAY_TO_WORD(loadkmsprefs.kms_SwitchCode);
 347                                 CopyMem(loadkmsprefs.kms_AltKeymap, kmsprefs.kms_AltKeymap, sizeof(kmsprefs.kms_AltKeymap));
 348                             }
 349                             else
 350                                 retval = FALSE;
 351                             break;
 352                         }
 353                     } /* if (!ParseIFF(iff, IFFPARSE_SCAN)) */
 354                 } /* if (!StopChunk(iff, ID_PREF, ID_INPT)) */
 355                 CloseIFF(iff);
 356             } /* if (!OpenIFF(iff, IFFF_READ)) */
 357         } /* if (fh != NULL) */
 358         FreeIFF(iff);
 359     } /* if ((iff = AllocIFF())) */
 360
 361     return retval;
 362     }
 363
 364 /*********************************************************************************************/
 365
 366 BOOL Prefs_ExportFH(BPTR fh)
 367 {
 368     struct FileInputPrefs   saveprefs;
 369     struct FileKMSPrefs     savekmsprefs;
 370     struct IFFHandle       *iff;
 371     BOOL                    retval = FALSE;
 372 #if 0 /* unused */
 373     BOOL                    delete_if_error = FALSE;
 374 #endif
 375
 376     D(Printf("SavePrefs: SwitchMouseButtons: %ld\n", inputprefs.ip_SwitchMouseButtons));
 377
 378     CopyMem(inputprefs.ip_Keymap, saveprefs.ip_Keymap, sizeof(saveprefs.ip_Keymap));
 379     WORD_TO_ARRAY(inputprefs.ip_PointerTicks, saveprefs.ip_PointerTicks);
 380     LONG_TO_ARRAY(inputprefs.ip_DoubleClick.tv_secs , saveprefs.ip_DoubleClick_secs);
 381     LONG_TO_ARRAY(inputprefs.ip_DoubleClick.tv_micro, saveprefs.ip_DoubleClick_micro);
 382     LONG_TO_ARRAY(inputprefs.ip_KeyRptDelay.tv_secs , saveprefs.ip_KeyRptDelay_secs);
 383     LONG_TO_ARRAY(inputprefs.ip_KeyRptDelay.tv_micro, saveprefs.ip_KeyRptDelay_micro);
 384     LONG_TO_ARRAY(inputprefs.ip_KeyRptSpeed.tv_secs , saveprefs.ip_KeyRptSpeed_secs);
 385     LONG_TO_ARRAY(inputprefs.ip_KeyRptSpeed.tv_micro, saveprefs.ip_KeyRptSpeed_micro);
 386     WORD_TO_ARRAY(inputprefs.ip_MouseAccel, saveprefs.ip_MouseAccel);
 387     LONG_TO_ARRAY(inputprefs.ip_ClassicKeyboard, saveprefs.ip_ClassicKeyboard);
 388     CopyMem(inputprefs.ip_KeymapName, saveprefs.ip_KeymapName, sizeof(saveprefs.ip_KeymapName));
 389     saveprefs.ip_SwitchMouseButtons[0] = 0;
 390     saveprefs.ip_SwitchMouseButtons[1] = 0;
 391     saveprefs.ip_SwitchMouseButtons[2] = 0;
 392     saveprefs.ip_SwitchMouseButtons[3] = inputprefs.ip_SwitchMouseButtons;
 393
 394     savekmsprefs.kms_Enabled  = kmsprefs.kms_Enabled;
 395     savekmsprefs.kms_Reserved = kmsprefs.kms_Reserved;
 396     WORD_TO_ARRAY(kmsprefs.kms_SwitchQual, savekmsprefs.kms_SwitchQual);
 397     WORD_TO_ARRAY(kmsprefs.kms_SwitchCode, savekmsprefs.kms_SwitchCode);
 398     CopyMem(kmsprefs.kms_AltKeymap, savekmsprefs.kms_AltKeymap, sizeof(savekmsprefs.kms_AltKeymap));
 399
 400     if ((iff = AllocIFF()))
 401     {
 402         iff->iff_Stream = (IPTR)fh;
 403         if (iff->iff_Stream)
 404         {
 405             D(Printf("SavePrefs: stream opened.\n"));
 406
 407 #if 0 /* unused */
 408             delete_if_error = TRUE;
 409 #endif
 410
 411             InitIFFasDOS(iff);
 412
 413             if (!OpenIFF(iff, IFFF_WRITE))
 414             {
 415                 D(Printf("SavePrefs: OpenIFF okay.\n"));
 416
 417                 if (!PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN))
 418                 {
 419                     D(Printf("SavePrefs: PushChunk(FORM) okay.\n"));
 420
 421                     if (!PushChunk(iff, ID_PREF, ID_PRHD, sizeof(struct FilePrefHeader)))
 422                     {
 423                         struct FilePrefHeader head;
 424
 425                         D(Printf("SavePrefs: PushChunk(PRHD) okay.\n"));
 426
 427                         head.ph_Version  = 0; // FIXME: should be PHV_CURRENT, but see <prefs/prefhdr.h>
 428                         head.ph_Type     = 0;
 429                         head.ph_Flags[0] =
 430                         head.ph_Flags[1] =
 431                         head.ph_Flags[2] =
 432                         head.ph_Flags[3] = 0;
 433
 434                         if (WriteChunkBytes(iff, &head, sizeof(head)) == sizeof(head))
 435                         {
 436                             D(Printf("SavePrefs: WriteChunkBytes(PRHD) okay.\n"));
 437
 438                             PopChunk(iff);
 439
 440                             if (!PushChunk(iff, ID_PREF, ID_INPT, sizeof(saveprefs)))
 441                             {
 442                                 D(Printf("SavePrefs: PushChunk(INPT) okay.\n"));
 443
 444                                 if (WriteChunkBytes(iff, &saveprefs, sizeof(saveprefs)) == sizeof(saveprefs))
 445                                 {
 446                                     D(Printf("SavePrefs: WriteChunkBytes(INPT) okay.\n"));
 447
 448                                     retval = TRUE;
 449                                 }
 450
 451                                 PopChunk(iff);
 452
 453                             } /* if (!PushChunk(iff, ID_PREF, ID_INPT, sizeof(saveprefs))) */
 454
 455                             if (!PushChunk(iff, ID_PREF, ID_KMSW, sizeof(savekmsprefs)))
 456                             {
 457                                 if (WriteChunkBytes(iff, &savekmsprefs, sizeof(savekmsprefs)) == sizeof(savekmsprefs))
 458                                     retval = retval && TRUE;
 459
 460                                 PopChunk(iff);
 461
 462                             } /* if (!PushChunk(iff, ID_PREF, ID_INPT, sizeof(saveprefs))) */
 463
 464                         } /* if (WriteChunkBytes(iff, &head, sizeof(head)) == sizeof(head)) */
 465                         else
 466                         {
 467                             PopChunk(iff);
 468                         }
 469
 470                     } /* if (!PushChunk(iff, ID_PREF, ID_PRHD, sizeof(struct PrefHeader))) */
 471
 472                     PopChunk(iff);
 473
 474                 } /* if (!PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN)) */
 475
 476                 CloseIFF(iff);
 477
 478             } /* if (!OpenIFF(iff, IFFFWRITE)) */
 479
 480
 481         } /* if (iff->iff_Stream)) */
 482
 483         FreeIFF(iff);
 484
 485     } /* if ((iff = AllocIFF())) */
 486
 487 #if 0 /* unused */
 488      if (!retval && delete_if_error)
 489      {
 490           DeleteFile(filename);
 491      }
 492 #endif
 493
 494     return retval;
 495 }
 496
 497 /*********************************************************************************************/
 498
 499 BOOL Prefs_HandleArgs(STRPTR from, BOOL use, BOOL save)
 500 {
 501     BPTR fh;
 502
 503     if (from)
 504     {
 505         if (!Prefs_Load(from))
 506         {
 507             ShowMessage("Can't read from input file");
 508             return FALSE;
 509         }
 510     }
 511     else
 512     {
 513         if (!Prefs_Load(PREFS_PATH_ENV))
 514         {
 515             if (!Prefs_Load(PREFS_PATH_ENVARC))
 516             {
 517                 ShowMessage
 518                 (
 519                     "Can't read from file " PREFS_PATH_ENVARC
 520                     ".\nUsing default values."
 521                 );
 522                 Prefs_Default();
 523             }
 524         }
 525     }
 526
 527     if (use || save)
 528     {
 529         fh = Open(PREFS_PATH_ENV, MODE_NEWFILE);
 530         if (fh)
 531         {
 532             Prefs_ExportFH(fh);
 533             Close(fh);
 534         }
 535         else
 536         {
 537             ShowMessage("Can't open " PREFS_PATH_ENV " for writing.");
 538         }
 539     }
 540     if (save)
 541     {
 542         fh = Open(PREFS_PATH_ENVARC, MODE_NEWFILE);
 543         if (fh)
 544         {
 545             Prefs_ExportFH(fh);
 546             Close(fh);
 547         }
 548         else
 549         {
 550             ShowMessage("Can't open " PREFS_PATH_ENVARC " for writing.");
 551         }
 552     }
 553     return TRUE;
 554 }
 555
 556 /*********************************************************************************************/
 557
 558 BOOL Prefs_Default(void)
 559 {
 560     strcpy(inputprefs.ip_Keymap, DEFAULT_KEYMAP);
 561     inputprefs.ip_PointerTicks         = 1;
 562     inputprefs.ip_DoubleClick.tv_secs  = 0;
 563     inputprefs.ip_DoubleClick.tv_micro = 500000;
 564     inputprefs.ip_KeyRptDelay.tv_secs  = 0;
 565     inputprefs.ip_KeyRptDelay.tv_micro = 500000;
 566     inputprefs.ip_KeyRptSpeed.tv_secs  = 0;
 567     inputprefs.ip_KeyRptSpeed.tv_micro = 40000;
 568     inputprefs.ip_MouseAccel           = 1;
 569     inputprefs.ip_ClassicKeyboard      = 0;
 570     strcpy(inputprefs.ip_KeymapName, DEFAULT_KEYMAP);
 571     inputprefs.ip_SwitchMouseButtons   = FALSE;
 572
 573     kmsprefs.kms_Enabled      = FALSE;
 574     kmsprefs.kms_SwitchQual   = KMS_QUAL_DISABLE;
 575     kmsprefs.kms_SwitchCode   = KMS_CODE_NOKEY;
 576     kmsprefs.kms_AltKeymap[0] = 0;
 577
 578     return TRUE;
 579 }