workbench/prefs/input/prefs.c

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