workbench/prefs/input/prefs.c

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