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