home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 100-199 / ff193.lzh / KeyMapEd / Source / KME_ProcKeyReq.c < prev    next >
C/C++ Source or Header  |  1989-03-13  |  75KB  |  2,156 lines
  1. /*
  2.  * Key Map Editor ver 1.0
  3.  * Process Key Requester
  4.  *
  5.  * parameter:     KeyCode - Key Code of key to edit
  6.  * returns:     Success - TRUE if key was changed, FALSE if not
  7.  *
  8.  * by: Tim Friest
  9.  * on: January 8, 1989
  10.  */
  11.  
  12. #include "KME_Includes.h"
  13. #include <ctype.h>
  14. #include "KME_Protos.h"
  15. #include "KME_Defs.h"
  16. #include "KME_KeyReq.h"
  17. #include "KME_Globals.h"
  18.  
  19. struct    KeyNode {
  20.     UBYTE    Type;
  21.     int    Capsable, Repeatable;
  22.     UBYTE    AloneOpt;
  23.     UBYTE    AloneLen;
  24.     char    Alone[33];
  25.     UBYTE    ShiftOpt;
  26.     UBYTE    ShiftLen;
  27.     char    Shift[33];
  28.     UBYTE    AltOpt;
  29.     UBYTE    AltLen;
  30.     char    Alt[33];
  31.     UBYTE    ShiftAltOpt;
  32.     UBYTE    ShiftAltLen;
  33.     char    ShiftAlt[33];
  34.     UBYTE    CtrlOpt;
  35.     UBYTE    CtrlLen;
  36.     char    Ctrl[33];
  37.     UBYTE    CtrlShiftOpt;
  38.     UBYTE    CtrlShiftLen;
  39.     char    CtrlShift[33];
  40.     UBYTE    CtrlAltOpt;
  41.     UBYTE    CtrlAltLen;
  42.     char    CtrlAlt[33];
  43.     UBYTE    VanillaOpt;
  44.     UBYTE    VanillaLen;
  45.     char    Vanilla[33];
  46. };
  47.  
  48. extern    void    InitKeyReq(struct KeyNode *);
  49. extern    struct    KeyNode *MakeKeyNode(USHORT);
  50. extern    int    ChangeKeyReq(struct KeyNode *, UBYTE);
  51. extern    void    ExcludeAccGads(struct Gadget *, struct Gadget *);
  52. extern    void    UpdateKey(struct KeyNode *);
  53. extern    void    UpdateKeyMap(struct KeyNode *, USHORT);
  54. extern    int    ExpandCtrl(unsigned char *, unsigned char *, int);
  55. extern    int    CollapseCtrl(char *, char *, int);
  56.  
  57. int ProcKeyReq(KeyCode)
  58. USHORT KeyCode;
  59. {
  60.     struct    KeyNode *Key;
  61.     ULONG    KeyWind_sf = 0;
  62.     static SHORT KeyReqWindx = KRWLEFTEDGE;
  63.     static SHORT KeyReqWindy = KRWTOPEDGE;
  64.     struct IntuiMessage *Message;
  65.     ULONG    Class;
  66.     USHORT    Code;
  67.     struct Gadget *Gad;
  68.     int    Done = FALSE;
  69.     int    Use = FALSE;
  70.  
  71.     if ((Key = MakeKeyNode(KeyCode)) == NULL) {
  72.         CloseWindow(KeyReqWindow);
  73.         return(FALSE);
  74.     }
  75.     InitKeyReq(Key);
  76.     NewKeyReqWindow.LeftEdge = KeyReqWindx;
  77.     NewKeyReqWindow.TopEdge = KeyReqWindy;
  78.     if ((KeyReqWindow = OpenWindow(&NewKeyReqWindow)) == NULL)
  79.         return(FALSE);
  80.     KeyWind_sf = (1<<KeyReqWindow->UserPort->mp_SigBit);
  81.     if (CheckResource(RF_Font))
  82.         SetFont(KeyReqWindow->RPort, TopazFont);
  83.     Done = !Request(&KRRequester, KeyReqWindow);
  84.     while (!Done) {
  85.         while (Wait(KeyWind_sf|Wind_sf) == Wind_sf) {
  86.             while ((Message = (struct IntuiMessage *)GetMsg(KeyMapEdWindow->UserPort)) != NULL)
  87.                 ReplyMsg((struct Message *)Message);
  88.             DisplayBeep(KeyReqWindow->WScreen);
  89.         } /* while */
  90.         while ((!Done) && ((Message = (struct IntuiMessage *)GetMsg(KeyReqWindow->UserPort)) != NULL)) {
  91.             Class = Message->Class;
  92.             Code = Message->Code;
  93.             Gad = (struct Gadget *)Message->IAddress;
  94.             ReplyMsg((struct Message *)Message);
  95.             switch (Class) {
  96.                 case REQSET:
  97.                     break;
  98.                 case GADGETUP:
  99.                     switch (Gad->GadgetID) {
  100.                         case 0xFF: /* Use changes */
  101.                             EndRequest(&KRRequester, KeyReqWindow);
  102.                             Done = TRUE;
  103.                             Use = TRUE;
  104.                             break;
  105.                         case 0xFE: /* Cancel any changes */
  106.                             EndRequest(&KRRequester, KeyReqWindow);
  107.                             Done = TRUE;
  108.                             break;
  109.                         case 0x00: /* switch type to NOP */
  110.                             if (Gad->Flags & SELECTED)
  111.                                 Done = !ChangeKeyReq(Key, KCF_NOP);
  112.                             else {
  113.                                 Gad->Flags |= SELECTED;
  114.                                 RefreshGList(Gad, KeyReqWindow, &KRRequester, 1);
  115.                             }
  116.                             break;
  117.                         case 0x01: /* switch type to NoQual */
  118.                             if (Gad->Flags & SELECTED)
  119.                                 Done = !ChangeKeyReq(Key, KC_NOQUAL);
  120.                             else {
  121.                                 Gad->Flags |= SELECTED;
  122.                                 RefreshGList(Gad, KeyReqWindow, &KRRequester, 1);
  123.                             }
  124.                             break;
  125.                         case 0x02: /* switch type to String */
  126.                             if (Gad->Flags & SELECTED)
  127.                                 Done = !ChangeKeyReq(Key, KCF_STRING);
  128.                             else {
  129.                                 Gad->Flags |= SELECTED;
  130.                                 RefreshGList(Gad, KeyReqWindow, &KRRequester, 1);
  131.                             }
  132.                             break;
  133.                         case 0x03: /* switch type to Dead */
  134.                             if (Gad->Flags & SELECTED)
  135.                                 Done = !ChangeKeyReq(Key, KCF_DEAD);
  136.                             else {
  137.                                 Gad->Flags |= SELECTED;
  138.                                 RefreshGList(Gad, KeyReqWindow, &KRRequester, 1);
  139.                             }
  140.                             break;
  141.                         case 0x10: /* toggle Shift type */
  142.                             UpdateKey(Key);
  143.                             if (Gad->Flags & SELECTED)
  144.                                 Key->Type |= KCF_SHIFT;
  145.                             else
  146.                                 Key->Type &= ~KCF_SHIFT;
  147.                             InitKeyReq(Key);
  148.                             Done = !Request(&KRRequester, KeyReqWindow);
  149.                             break;
  150.                         case 0x11: /* toggle Alt type */
  151.                             UpdateKey(Key);
  152.                             if (Gad->Flags & SELECTED)
  153.                                 Key->Type |= KCF_ALT;
  154.                             else
  155.                                 Key->Type &= ~KCF_ALT;
  156.                             InitKeyReq(Key);
  157.                             Done = !Request(&KRRequester, KeyReqWindow);
  158.                             break;
  159.                         case 0x12: /* toggle Ctrl type */
  160.                             UpdateKey(Key);
  161.                             if (Gad->Flags & SELECTED)
  162.                                 Key->Type |= KCF_CONTROL;
  163.                             else
  164.                                 Key->Type &= ~KCF_CONTROL;
  165.                             InitKeyReq(Key);
  166.                             Done = !Request(&KRRequester, KeyReqWindow);
  167.                             break;
  168.                         case 0x13: /* toggle Capsable */
  169.                             if (Gad->Flags & SELECTED)
  170.                                 Key->Capsable = TRUE;
  171.                             else
  172.                                 Key->Capsable = FALSE;
  173.                             break;
  174.                         case 0x14: /* toggle Repeatable */
  175.                             if (Gad->Flags & SELECTED)
  176.                                 Key->Repeatable = TRUE;
  177.                             else
  178.                                 Key->Repeatable = FALSE;
  179.                             break;
  180.                         case 0x40: /* Alone Mod gadget */
  181.                             UpdateKey(Key);
  182.                             if (Gad->Flags & SELECTED)
  183.                                 Key->AloneOpt = DPF_MOD;
  184.                             else
  185.                                 Key->AloneOpt = KC_NOQUAL;
  186.                             InitKeyReq(Key);
  187.                             Done = !Request(&KRRequester, KeyReqWindow);
  188.                             break;
  189.                         case 0x41: /* Alone Dead gadget */
  190.                             UpdateKey(Key);
  191.                             if (Gad->Flags & SELECTED)
  192.                                 Key->AloneOpt = DPF_DEAD;
  193.                             else
  194.                                 Key->AloneOpt = KC_NOQUAL;
  195.                             InitKeyReq(Key);
  196.                             Done = !Request(&KRRequester, KeyReqWindow);
  197.                             break;
  198.                         case 0x49: /* Alone Acc1 Gadget */
  199.                         case 0x4A: /* Alone Acc2 Gadget */
  200.                         case 0x4B: /* Alone Acc3 Gadget */
  201.                         case 0x4C: /* Alone Acc4 Gadget */
  202.                         case 0x4D: /* Alone Acc5 Gadget */
  203.                             ExcludeAccGads(&KRDAloneAcc1Gadget, Gad);
  204.                             break;
  205.                         case 0x50: /* Shift Mod gadget */
  206.                             UpdateKey(Key);
  207.                             if (Gad->Flags & SELECTED)
  208.                                 Key->ShiftOpt = DPF_MOD;
  209.                             else
  210.                                 Key->ShiftOpt = KC_NOQUAL;
  211.                             InitKeyReq(Key);
  212.                             Done = !Request(&KRRequester, KeyReqWindow);
  213.                             break;
  214.                         case 0x51: /* Shift Dead gadget */
  215.                             UpdateKey(Key);
  216.                             if (Gad->Flags & SELECTED)
  217.                                 Key->ShiftOpt = DPF_DEAD;
  218.                             else
  219.                                 Key->ShiftOpt = KC_NOQUAL;
  220.                             InitKeyReq(Key);
  221.                             Done = !Request(&KRRequester, KeyReqWindow);
  222.                             break;
  223.                         case 0x59: /* Shift Acc1 Gadget */
  224.                         case 0x5A: /* Shift Acc2 Gadget */
  225.                         case 0x5B: /* Shift Acc3 Gadget */
  226.                         case 0x5C: /* Shift Acc4 Gadget */
  227.                         case 0x5D: /* Shift Acc5 Gadget */
  228.                             ExcludeAccGads(&KRDShiftAcc1Gadget, Gad);
  229.                             break;
  230.                         case 0x60: /* Alt Mod gadget */
  231.                             UpdateKey(Key);
  232.                             if (Gad->Flags & SELECTED)
  233.                                 Key->AltOpt = DPF_MOD;
  234.                             else
  235.                                 Key->AltOpt = KC_NOQUAL;
  236.                             InitKeyReq(Key);
  237.                             Done = !Request(&KRRequester, KeyReqWindow);
  238.                             break;
  239.                         case 0x61: /* Alt Dead gadget */
  240.                             UpdateKey(Key);
  241.                             if (Gad->Flags & SELECTED)
  242.                                 Key->AltOpt = DPF_DEAD;
  243.                             else
  244.                                 Key->AltOpt = KC_NOQUAL;
  245.                             InitKeyReq(Key);
  246.                             Done = !Request(&KRRequester, KeyReqWindow);
  247.                             break;
  248.                         case 0x69: /* Alt Acc1 Gadget */
  249.                         case 0x6A: /* Alt Acc2 Gadget */
  250.                         case 0x6B: /* Alt Acc3 Gadget */
  251.                         case 0x6C: /* Alt Acc4 Gadget */
  252.                         case 0x6D: /* Alt Acc5 Gadget */
  253.                             ExcludeAccGads(&KRDAltAcc1Gadget, Gad);
  254.                             break;
  255.                         case 0x70: /* ShiftAlt Mod gadget */
  256.                             UpdateKey(Key);
  257.                             if (Gad->Flags & SELECTED)
  258.                                 Key->ShiftAltOpt = DPF_MOD;
  259.                             else
  260.                                 Key->ShiftAltOpt = KC_NOQUAL;
  261.                             InitKeyReq(Key);
  262.                             Done = !Request(&KRRequester, KeyReqWindow);
  263.                             break;
  264.                         case 0x71: /* ShiftAlt Dead gadget */
  265.                             UpdateKey(Key);
  266.                             if (Gad->Flags & SELECTED)
  267.                                 Key->ShiftAltOpt = DPF_DEAD;
  268.                             else
  269.                                 Key->ShiftAltOpt = KC_NOQUAL;
  270.                             InitKeyReq(Key);
  271.                             Done = !Request(&KRRequester, KeyReqWindow);
  272.                             break;
  273.                         case 0x79: /* ShiftAlt Acc1 Gadget */
  274.                         case 0x7A: /* ShiftAlt Acc2 Gadget */
  275.                         case 0x7B: /* ShiftAlt Acc3 Gadget */
  276.                         case 0x7C: /* ShiftAlt Acc4 Gadget */
  277.                         case 0x7D: /* ShiftAlt Acc5 Gadget */
  278.                             ExcludeAccGads(&KRDShiftAltAcc1Gadget, Gad);
  279.                             break;
  280.                         case 0x80: /* Ctrl Mod gadget */
  281.                             UpdateKey(Key);
  282.                             if (Gad->Flags & SELECTED)
  283.                                 Key->CtrlOpt = DPF_MOD;
  284.                             else
  285.                                 Key->CtrlOpt = KC_NOQUAL;
  286.                             InitKeyReq(Key);
  287.                             Done = !Request(&KRRequester, KeyReqWindow);
  288.                             break;
  289.                         case 0x81: /* Ctrl Dead gadget */
  290.                             UpdateKey(Key);
  291.                             if (Gad->Flags & SELECTED)
  292.                                 Key->CtrlOpt = DPF_DEAD;
  293.                             else
  294.                                 Key->CtrlOpt = KC_NOQUAL;
  295.                             InitKeyReq(Key);
  296.                             Done = !Request(&KRRequester, KeyReqWindow);
  297.                             break;
  298.                         case 0x89: /* Ctrl Acc1 Gadget */
  299.                         case 0x8A: /* Ctrl Acc2 Gadget */
  300.                         case 0x8B: /* Ctrl Acc3 Gadget */
  301.                         case 0x8C: /* Ctrl Acc4 Gadget */
  302.                         case 0x8D: /* Ctrl Acc5 Gadget */
  303.                             ExcludeAccGads(&KRDCtrlAcc1Gadget, Gad);
  304.                             break;
  305.                         case 0x90: /* CtrlShift Mod gadget */
  306.                             UpdateKey(Key);
  307.                             if (Gad->Flags & SELECTED)
  308.                                 Key->CtrlShiftOpt = DPF_MOD;
  309.                             else
  310.                                 Key->CtrlShiftOpt = KC_NOQUAL;
  311.                             InitKeyReq(Key);
  312.                             Done = !Request(&KRRequester, KeyReqWindow);
  313.                             break;
  314.                         case 0x91: /* CtrlShift Dead gadget */
  315.                             UpdateKey(Key);
  316.                             if (Gad->Flags & SELECTED)
  317.                                 Key->CtrlShiftOpt = DPF_DEAD;
  318.                             else
  319.                                 Key->CtrlShiftOpt = KC_NOQUAL;
  320.                             InitKeyReq(Key);
  321.                             Done = !Request(&KRRequester, KeyReqWindow);
  322.                             break;
  323.                         case 0x99: /* CtrlShift Acc1 Gadget */
  324.                         case 0x9A: /* CtrlShift Acc2 Gadget */
  325.                         case 0x9B: /* CtrlShift Acc3 Gadget */
  326.                         case 0x9C: /* CtrlShift Acc4 Gadget */
  327.                         case 0x9D: /* CtrlShift Acc5 Gadget */
  328.                             ExcludeAccGads(&KRDCtrlShiftAcc1Gadget, Gad);
  329.                             break;
  330.                         case 0xA0: /* CtrlAlt Mod gadget */
  331.                             UpdateKey(Key);
  332.                             if (Gad->Flags & SELECTED)
  333.                                 Key->CtrlAltOpt = DPF_MOD;
  334.                             else
  335.                                 Key->CtrlAltOpt = KC_NOQUAL;
  336.                             InitKeyReq(Key);
  337.                             Done = !Request(&KRRequester, KeyReqWindow);
  338.                             break;
  339.                         case 0xA1: /* CtrlAlt Dead gadget */
  340.                             UpdateKey(Key);
  341.                             if (Gad->Flags & SELECTED)
  342.                                 Key->CtrlAltOpt = DPF_DEAD;
  343.                             else
  344.                                 Key->CtrlAltOpt = KC_NOQUAL;
  345.                             InitKeyReq(Key);
  346.                             Done = !Request(&KRRequester, KeyReqWindow);
  347.                             break;
  348.                         case 0xA9: /* CtrlAlt Acc1 Gadget */
  349.                         case 0xAA: /* CtrlAlt Acc2 Gadget */
  350.                         case 0xAB: /* CtrlAlt Acc3 Gadget */
  351.                         case 0xAC: /* CtrlAlt Acc4 Gadget */
  352.                         case 0xAD: /* CtrlAlt Acc5 Gadget */
  353.                             ExcludeAccGads(&KRDCtrlAltAcc1Gadget, Gad);
  354.                             break;
  355.                         case 0xB0: /* Vanilla Mod gadget */
  356.                             UpdateKey(Key);
  357.                             if (Gad->Flags & SELECTED)
  358.                                 Key->VanillaOpt = DPF_MOD;
  359.                             else
  360.                                 Key->VanillaOpt = KC_NOQUAL;
  361.                             InitKeyReq(Key);
  362.                             Done = !Request(&KRRequester, KeyReqWindow);
  363.                             break;
  364.                         case 0xB1: /* Vanilla Dead gadget */
  365.                             UpdateKey(Key);
  366.                             if (Gad->Flags & SELECTED)
  367.                                 Key->VanillaOpt = DPF_DEAD;
  368.                             else
  369.                                 Key->VanillaOpt = KC_NOQUAL;
  370.                             InitKeyReq(Key);
  371.                             Done = !Request(&KRRequester, KeyReqWindow);
  372.                             break;
  373.                         case 0xB9: /* Vanilla Acc1 Gadget */
  374.                         case 0xBA: /* Vanilla Acc2 Gadget */
  375.                         case 0xBB: /* Vanilla Acc3 Gadget */
  376.                         case 0xBC: /* Vanilla Acc4 Gadget */
  377.                         case 0xBD: /* Vanilla Acc5 Gadget */
  378.                             ExcludeAccGads(&KRDVanillaAcc1Gadget, Gad);
  379.                             break;
  380.                     } /* switch */
  381.             } /* switch */
  382.         } /* while */
  383.     } /* while */
  384.     KeyReqWindx = KeyReqWindow->LeftEdge;
  385.     KeyReqWindy = KeyReqWindow->TopEdge;
  386.     CloseWindow(KeyReqWindow);
  387.     if (Use) {
  388.         UpdateKey(Key);
  389.         UpdateKeyMap(Key, KeyCode);
  390.         SetFlag(SF_Modified);
  391.     }
  392.     FreeMem(Key, sizeof(struct KeyNode));
  393.     return(Use);
  394. }
  395.  
  396. /*
  397.  * Change Key Requester
  398.  */
  399. int ChangeKeyReq(Key, Type)
  400. struct KeyNode *Key;
  401. UBYTE Type;
  402. {
  403.     EndRequest(&KRRequester, KeyReqWindow);
  404.     UpdateKey(Key);
  405.     Key->Type &= ~(KCF_STRING|KCF_DEAD|KCF_NOP);
  406.     Key->Type |= Type;
  407.     InitKeyReq(Key);
  408.     return(Request(&KRRequester, KeyReqWindow));
  409. }
  410.  
  411. /*
  412.  * Exclude Accent Gadgets
  413.  */
  414. void ExcludeAccGads(AccentList, AccGad)
  415. struct Gadget *AccentList;
  416. struct Gadget *AccGad;
  417. {
  418.     int pos, count;
  419.     struct Gadget *tempgad;
  420.  
  421.     pos = RemoveGList(KeyReqWindow, AccentList, 5);
  422.     if (AccGad->Flags & SELECTED)
  423.         for (tempgad = AccentList, count = 0; (count < 5) && (tempgad != NULL); tempgad = tempgad->NextGadget, count++)
  424.             tempgad->Flags &= ~SELECTED;
  425.     AccGad->Flags |= SELECTED;
  426.     AddGList(KeyReqWindow, AccentList, pos, 5, &KRRequester);
  427.     RefreshGList(AccentList, KeyReqWindow, &KRRequester, 5);
  428. }
  429.  
  430. /*
  431.  * Make the Key Node
  432.  */
  433. struct KeyNode *MakeKeyNode(KeyCode)
  434. USHORT KeyCode;
  435. {
  436.     struct KeyNode *Key;
  437.     struct HalfKeyMap *HalfKeyMap;
  438.     UBYTE    *KeyMapVal;
  439.     UBYTE    *KeyMapPtr;
  440.     
  441.     if ((Key = (struct KeyNode *)AllocMem(sizeof(struct KeyNode), MEMF_CLEAR)) == NULL)
  442.         return(Key);
  443.     if (KeyCode < 0x40)
  444.         HalfKeyMap = (struct HalfKeyMap *)&KeyMapNode->kn_KeyMap;
  445.     else {
  446.         HalfKeyMap = (struct HalfKeyMap *)&KeyMapNode->kn_KeyMap.km_HiKeyMapTypes;
  447.         KeyCode -= 0x40;
  448.     }
  449.     Key->Type = HalfKeyMap->KeyMapTypes[KeyCode];
  450.     Key->Capsable = (HalfKeyMap->Capsable[KeyCode/8] & (1<<(KeyCode % 8)));
  451.     Key->Repeatable = (HalfKeyMap->Repeatable[KeyCode/8] & (1<<(KeyCode % 8)));
  452.     KeyMapVal = (UBYTE *)&HalfKeyMap->KeyMap[KeyCode];
  453.     KeyMapPtr = (UBYTE *)HalfKeyMap->KeyMap[KeyCode];
  454.     switch (Key->Type & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
  455.         case KC_NOQUAL:
  456.             switch (Key->Type & KC_VANILLA) {
  457.                 case KC_NOQUAL:
  458.                     Key->AloneLen = 1;
  459.                     Key->Alone[0] = KeyMapVal[3];
  460.                     break;
  461.                 case KCF_SHIFT:
  462.                     Key->AloneLen = 1;
  463.                     Key->Alone[0] = KeyMapVal[3];
  464.                     Key->ShiftLen = 1;
  465.                     Key->Shift[0] = KeyMapVal[2];
  466.                     break;
  467.                 case KCF_ALT:
  468.                     Key->AloneLen = 1;
  469.                     Key->Alone[0] = KeyMapVal[3];
  470.                     Key->AltLen = 1;
  471.                     Key->Alt[0] = KeyMapVal[2];
  472.                     break;
  473.                 case KCF_SHIFT|KCF_ALT:
  474.                     Key->AloneLen = 1;
  475.                     Key->Alone[0] = KeyMapVal[3];
  476.                     Key->ShiftLen = 1;
  477.                     Key->Shift[0] = KeyMapVal[2];
  478.                     Key->AltLen = 1;
  479.                     Key->Alt[0] = KeyMapVal[1];
  480.                     Key->ShiftAltLen = 1;
  481.                     Key->ShiftAlt[0] = KeyMapVal[0];;
  482.                     break;
  483.                 case KCF_CONTROL:
  484.                     Key->AloneLen = 1;
  485.                     Key->Alone[0] = KeyMapVal[3];
  486.                     Key->CtrlLen = 1;
  487.                     Key->Ctrl[0] = KeyMapVal[2];
  488.                     break;
  489.                 case KCF_CONTROL|KCF_SHIFT:
  490.                     Key->AloneLen = 1;
  491.                     Key->Alone[0] = KeyMapVal[3];
  492.                     Key->ShiftLen = 1;
  493.                     Key->Shift[0] = KeyMapVal[2];
  494.                     Key->CtrlLen = 1;
  495.                     Key->Ctrl[0] = KeyMapVal[1];
  496.                     Key->CtrlShiftLen = 1;
  497.                     Key->CtrlShift[0] = KeyMapVal[0];
  498.                     break;
  499.                 case KCF_CONTROL|KCF_ALT:
  500.                     Key->AloneLen = 1;
  501.                     Key->Alone[0] = KeyMapVal[3];
  502.                     Key->AltLen = 1;
  503.                     Key->Alt[0] = KeyMapVal[2];
  504.                     Key->CtrlLen = 1;
  505.                     Key->Ctrl[0] = KeyMapVal[1];
  506.                     Key->CtrlAltLen = 1;
  507.                     Key->CtrlAlt[0] = KeyMapVal[0];
  508.                     break;
  509.                 case KC_VANILLA:
  510.                     Key->AloneLen = 1;
  511.                     Key->Alone[0] = KeyMapVal[3];
  512.                     Key->ShiftLen = 1;
  513.                     Key->Shift[0] = KeyMapVal[2];
  514.                     Key->AltLen = 1;
  515.                     Key->Alt[0] = KeyMapVal[1];
  516.                     Key->ShiftAltLen = 1;
  517.                     Key->ShiftAlt[0] = KeyMapVal[0];
  518.             } /* switch */
  519.             break;
  520.         case KCF_STRING:
  521.             switch (Key->Type & KC_VANILLA) {
  522.                 case KC_NOQUAL:
  523.                     Key->AloneLen = KeyMapPtr[0];
  524.                     memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
  525.                     break;
  526.                 case KCF_SHIFT:
  527.                     Key->AloneLen = KeyMapPtr[0];
  528.                     memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
  529.                     Key->ShiftLen = KeyMapPtr[2];
  530.                     memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), Key->ShiftLen);
  531.                     break;
  532.                 case KCF_ALT:
  533.                     Key->AloneLen = KeyMapPtr[0];
  534.                     memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
  535.                     Key->AltLen = KeyMapPtr[2];
  536.                     memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[3]), Key->AltLen);
  537.                     break;
  538.                 case KCF_SHIFT|KCF_ALT:
  539.                     Key->AloneLen = KeyMapPtr[0];
  540.                     memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
  541.                     Key->ShiftLen = KeyMapPtr[2];
  542.                     memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), Key->ShiftLen);
  543.                     Key->AltLen = KeyMapPtr[4];
  544.                     memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[5]), Key->AltLen);
  545.                     Key->ShiftAltLen = KeyMapPtr[6];
  546.                     memcpy(Key->ShiftAlt, (KeyMapPtr+KeyMapPtr[7]), Key->ShiftAltLen);
  547.                     break;
  548.                 case KCF_CONTROL:
  549.                     Key->AloneLen = KeyMapPtr[0];
  550.                     memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
  551.                     Key->CtrlLen = KeyMapPtr[2];
  552.                     memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[3]), Key->CtrlLen);
  553.                     break;
  554.                 case KCF_CONTROL|KCF_SHIFT:
  555.                     Key->AloneLen = KeyMapPtr[0];
  556.                     memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
  557.                     Key->ShiftLen = KeyMapPtr[2];
  558.                     memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), Key->ShiftLen);
  559.                     Key->CtrlLen = KeyMapPtr[4];
  560.                     memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[5]), Key->CtrlLen);
  561.                     Key->CtrlShiftLen = KeyMapPtr[6];
  562.                     memcpy(Key->CtrlShift, (KeyMapPtr+KeyMapPtr[7]), Key->CtrlShiftLen);
  563.                     break;
  564.                 case KCF_CONTROL|KCF_ALT:
  565.                     Key->AloneLen = KeyMapPtr[0];
  566.                     memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
  567.                     Key->AltLen = KeyMapPtr[2];
  568.                     memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[3]), Key->AltLen);
  569.                     Key->CtrlLen = KeyMapPtr[4];
  570.                     memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[5]), Key->CtrlLen);
  571.                     Key->CtrlAltLen = KeyMapPtr[6];
  572.                     memcpy(Key->CtrlAlt, (KeyMapPtr+KeyMapPtr[7]), Key->CtrlAltLen);
  573.                     break;
  574.                 case KC_VANILLA:
  575.                     Key->AloneLen = KeyMapPtr[0];
  576.                     memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
  577.                     Key->ShiftLen = KeyMapPtr[2];
  578.                     memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), Key->ShiftLen);
  579.                     Key->AltLen = KeyMapPtr[4];
  580.                     memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[5]), Key->AltLen);
  581.                     Key->ShiftAltLen = KeyMapPtr[6];
  582.                     memcpy(Key->ShiftAlt, (KeyMapPtr+KeyMapPtr[7]), Key->ShiftAltLen);
  583.                     Key->CtrlLen = KeyMapPtr[8];
  584.                     memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[9]), Key->CtrlLen);
  585.                     Key->CtrlShiftLen = KeyMapPtr[10];
  586.                     memcpy(Key->CtrlShift, (KeyMapPtr+KeyMapPtr[11]), Key->CtrlShiftLen);
  587.                     Key->CtrlAltLen = KeyMapPtr[12];
  588.                     memcpy(Key->CtrlAlt, (KeyMapPtr+KeyMapPtr[13]), Key->CtrlAltLen);
  589.                     Key->VanillaLen = KeyMapPtr[14];
  590.                     memcpy(Key->Vanilla, (KeyMapPtr+KeyMapPtr[15]), Key->VanillaLen);
  591.             } /* switch */
  592.             break;
  593.         case KCF_DEAD:
  594.             switch (Key->Type & KC_VANILLA) {
  595.                 case KC_NOQUAL:
  596.                     Key->AloneOpt = KeyMapPtr[0];
  597.                     switch (Key->AloneOpt) {
  598.                         case KC_NOQUAL:
  599.                         case DPF_DEAD:
  600.                             Key->AloneLen = 1;
  601.                             Key->Alone[0] = KeyMapPtr[1];
  602.                             break;
  603.                         case DPF_MOD:
  604.                             Key->AloneLen = 6;
  605.                             memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
  606.                     } /* switch */
  607.                     break;
  608.                 case KCF_SHIFT:
  609.                     Key->AloneOpt = KeyMapPtr[0];
  610.                     switch (Key->AloneOpt) {
  611.                         case KC_NOQUAL:
  612.                         case DPF_DEAD:
  613.                             Key->AloneLen = 1;
  614.                             Key->Alone[0] = KeyMapPtr[1];
  615.                             break;
  616.                         case DPF_MOD:
  617.                             Key->AloneLen = 6;
  618.                             memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
  619.                     } /* switch */
  620.                     Key->ShiftOpt = KeyMapPtr[2];
  621.                     switch (Key->ShiftOpt) {
  622.                         case KC_NOQUAL:
  623.                         case DPF_DEAD:
  624.                             Key->ShiftLen = 1;
  625.                             Key->Shift[0] = KeyMapPtr[3];
  626.                             break;
  627.                         case DPF_MOD:
  628.                             Key->ShiftLen = 6;
  629.                             memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), 6);
  630.                     } /* switch */
  631.                     break;
  632.                 case KCF_ALT:
  633.                     Key->AloneOpt = KeyMapPtr[0];
  634.                     switch (Key->AloneOpt) {
  635.                         case KC_NOQUAL:
  636.                         case DPF_DEAD:
  637.                             Key->AloneLen = 1;
  638.                             Key->Alone[0] = KeyMapPtr[1];
  639.                             break;
  640.                         case DPF_MOD:
  641.                             Key->AloneLen = 6;
  642.                             memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
  643.                     } /* switch */
  644.                     Key->AltOpt = KeyMapPtr[2];
  645.                     switch (Key->AltOpt) {
  646.                         case KC_NOQUAL:
  647.                         case DPF_DEAD:
  648.                             Key->AltLen = 1;
  649.                             Key->Alt[0] = KeyMapPtr[3];
  650.                             break;
  651.                         case DPF_MOD:
  652.                             Key->AltLen = 6;
  653.                             memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[3]), 6);
  654.                     } /* switch */
  655.                     break;
  656.                 case KCF_SHIFT|KCF_ALT:
  657.                     Key->AloneOpt = KeyMapPtr[0];
  658.                     switch (Key->AloneOpt) {
  659.                         case KC_NOQUAL:
  660.                         case DPF_DEAD:
  661.                             Key->AloneLen = 1;
  662.                             Key->Alone[0] = KeyMapPtr[1];
  663.                             break;
  664.                         case DPF_MOD:
  665.                             Key->AloneLen = 6;
  666.                             memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
  667.                     } /* switch */
  668.                     Key->ShiftOpt = KeyMapPtr[2];
  669.                     switch (Key->ShiftOpt) {
  670.                         case KC_NOQUAL:
  671.                         case DPF_DEAD:
  672.                             Key->ShiftLen = 1;
  673.                             Key->Shift[0] = KeyMapPtr[3];
  674.                             break;
  675.                         case DPF_MOD:
  676.                             Key->ShiftLen = 6;
  677.                             memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), 6);
  678.                     } /* switch */
  679.                     Key->AltOpt = KeyMapPtr[4];
  680.                     switch (Key->AltOpt) {
  681.                         case KC_NOQUAL:
  682.                         case DPF_DEAD:
  683.                             Key->AltLen = 1;
  684.                             Key->Alt[0] = KeyMapPtr[5];
  685.                             break;
  686.                         case DPF_MOD:
  687.                             Key->AltLen = 6;
  688.                             memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[5]), 6);
  689.                     } /* switch */
  690.                     Key->ShiftAltOpt = KeyMapPtr[6];
  691.                     switch (Key->ShiftAltOpt) {
  692.                         case KC_NOQUAL:
  693.                         case DPF_DEAD:
  694.                             Key->ShiftAltLen = 1;
  695.                             Key->ShiftAlt[0] = KeyMapPtr[7];
  696.                             break;
  697.                         case DPF_MOD:
  698.                             Key->ShiftAltLen = 6;
  699.                             memcpy(Key->ShiftAlt, (KeyMapPtr+KeyMapPtr[7]), 6);
  700.                     } /* switch */
  701.                     break;
  702.                 case KCF_CONTROL:
  703.                     Key->AloneOpt = KeyMapPtr[0];
  704.                     switch (Key->AloneOpt) {
  705.                         case KC_NOQUAL:
  706.                         case DPF_DEAD:
  707.                             Key->AloneLen = 1;
  708.                             Key->Alone[0] = KeyMapPtr[1];
  709.                             break;
  710.                         case DPF_MOD:
  711.                             Key->AloneLen = 6;
  712.                             memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
  713.                     } /* switch */
  714.                     Key->CtrlOpt = KeyMapPtr[2];
  715.                     switch (Key->CtrlOpt) {
  716.                         case KC_NOQUAL:
  717.                         case DPF_DEAD:
  718.                             Key->CtrlLen = 1;
  719.                             Key->Ctrl[0] = KeyMapPtr[3];
  720.                             break;
  721.                         case DPF_MOD:
  722.                             Key->CtrlLen = 6;
  723.                             memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[3]), 6);
  724.                     } /* switch */
  725.                     break;
  726.                 case KCF_CONTROL|KCF_SHIFT:
  727.                     Key->AloneOpt = KeyMapPtr[0];
  728.                     switch (Key->AloneOpt) {
  729.                         case KC_NOQUAL:
  730.                         case DPF_DEAD:
  731.                             Key->AloneLen = 1;
  732.                             Key->Alone[0] = KeyMapPtr[1];
  733.                             break;
  734.                         case DPF_MOD:
  735.                             Key->AloneLen = 6;
  736.                             memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
  737.                     } /* switch */
  738.                     Key->ShiftOpt = KeyMapPtr[2];
  739.                     switch (Key->ShiftOpt) {
  740.                         case KC_NOQUAL:
  741.                         case DPF_DEAD:
  742.                             Key->ShiftLen = 1;
  743.                             Key->Shift[0] = KeyMapPtr[3];
  744.                             break;
  745.                         case DPF_MOD:
  746.                             Key->ShiftLen = 6;
  747.                             memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), 6);
  748.                     } /* switch */
  749.                     Key->CtrlOpt = KeyMapPtr[4];
  750.                     switch (Key->CtrlOpt) {
  751.                         case KC_NOQUAL:
  752.                         case DPF_DEAD:
  753.                             Key->CtrlLen = 1;
  754.                             Key->Ctrl[0] = KeyMapPtr[5];
  755.                             break;
  756.                         case DPF_MOD:
  757.                             Key->CtrlLen = 6;
  758.                             memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[5]), 6);
  759.                     } /* switch */
  760.                     Key->CtrlShiftOpt = KeyMapPtr[6];
  761.                     switch (Key->CtrlShiftOpt) {
  762.                         case KC_NOQUAL:
  763.                         case DPF_DEAD:
  764.                             Key->CtrlShiftLen = 1;
  765.                             Key->CtrlShift[0] = KeyMapPtr[7];
  766.                             break;
  767.                         case DPF_MOD:
  768.                             Key->CtrlShiftLen = 6;
  769.                             memcpy(Key->CtrlShift, (KeyMapPtr+KeyMapPtr[7]), 6);
  770.                     } /* switch */
  771.                     break;
  772.                 case KCF_CONTROL|KCF_ALT:
  773.                     Key->AloneOpt = KeyMapPtr[0];
  774.                     switch (Key->AloneOpt) {
  775.                         case KC_NOQUAL:
  776.                         case DPF_DEAD:
  777.                             Key->AloneLen = 1;
  778.                             Key->Alone[0] = KeyMapPtr[1];
  779.                             break;
  780.                         case DPF_MOD:
  781.                             Key->AloneLen = 6;
  782.                             memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
  783.                     } /* switch */
  784.                     Key->AltOpt = KeyMapPtr[2];
  785.                     switch (Key->AltOpt) {
  786.                         case KC_NOQUAL:
  787.                         case DPF_DEAD:
  788.                             Key->AltLen = 1;
  789.                             Key->Alt[0] = KeyMapPtr[3];
  790.                             break;
  791.                         case DPF_MOD:
  792.                             Key->AltLen = 6;
  793.                             memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[3]), 6);
  794.                     } /* switch */
  795.                     Key->CtrlOpt = KeyMapPtr[4];
  796.                     switch (Key->CtrlOpt) {
  797.                         case KC_NOQUAL:
  798.                         case DPF_DEAD:
  799.                             Key->CtrlLen = 1;
  800.                             Key->Ctrl[0] = KeyMapPtr[5];
  801.                             break;
  802.                         case DPF_MOD:
  803.                             Key->CtrlLen = 6;
  804.                             memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[5]), 6);
  805.                     } /* switch */
  806.                     Key->CtrlAltOpt = KeyMapPtr[6];
  807.                     switch (Key->CtrlAltOpt) {
  808.                         case KC_NOQUAL:
  809.                         case DPF_DEAD:
  810.                             Key->CtrlAltLen = 1;
  811.                             Key->CtrlAlt[0] = KeyMapPtr[7];
  812.                             break;
  813.                         case DPF_MOD:
  814.                             Key->CtrlAltLen = 6;
  815.                             memcpy(Key->CtrlAlt, (KeyMapPtr+KeyMapPtr[7]), 6);
  816.                     } /* switch */
  817.                     break;
  818.                 case KC_VANILLA:
  819.                     Key->AloneOpt = KeyMapPtr[0];
  820.                     switch (Key->AloneOpt) {
  821.                         case KC_NOQUAL:
  822.                         case DPF_DEAD:
  823.                             Key->AloneLen = 1;
  824.                             Key->Alone[0] = KeyMapPtr[1];
  825.                             break;
  826.                         case DPF_MOD:
  827.                             Key->AloneLen = 6;
  828.                             memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
  829.                     } /* switch */
  830.                     Key->ShiftOpt = KeyMapPtr[2];
  831.                     switch (Key->ShiftOpt) {
  832.                         case KC_NOQUAL:
  833.                         case DPF_DEAD:
  834.                             Key->ShiftLen = 1;
  835.                             Key->Shift[0] = KeyMapPtr[3];
  836.                             break;
  837.                         case DPF_MOD:
  838.                             Key->ShiftLen = 6;
  839.                             memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), 6);
  840.                     } /* switch */
  841.                     Key->AltOpt = KeyMapPtr[4];
  842.                     switch (Key->AltOpt) {
  843.                         case KC_NOQUAL:
  844.                         case DPF_DEAD:
  845.                             Key->AltLen = 1;
  846.                             Key->Alt[0] = KeyMapPtr[5];
  847.                             break;
  848.                         case DPF_MOD:
  849.                             Key->AltLen = 6;
  850.                             memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[5]), 6);
  851.                     } /* switch */
  852.                     Key->ShiftAltOpt = KeyMapPtr[6];
  853.                     switch (Key->ShiftAltOpt) {
  854.                         case KC_NOQUAL:
  855.                         case DPF_DEAD:
  856.                             Key->ShiftAltLen = 1;
  857.                             Key->ShiftAlt[0] = KeyMapPtr[7];
  858.                             break;
  859.                         case DPF_MOD:
  860.                             Key->ShiftAltLen = 6;
  861.                             memcpy(Key->ShiftAlt, (KeyMapPtr+KeyMapPtr[7]), 6);
  862.                     } /* switch */
  863.                     Key->CtrlOpt = KeyMapPtr[8];
  864.                     switch (Key->CtrlOpt) {
  865.                         case KC_NOQUAL:
  866.                         case DPF_DEAD:
  867.                             Key->CtrlLen = 1;
  868.                             Key->Ctrl[0] = KeyMapPtr[9];
  869.                             break;
  870.                         case DPF_MOD:
  871.                             Key->CtrlLen = 6;
  872.                             memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[9]), 6);
  873.                     } /* switch */
  874.                     Key->CtrlShiftOpt = KeyMapPtr[10];
  875.                     switch (Key->CtrlShiftOpt) {
  876.                         case KC_NOQUAL:
  877.                         case DPF_DEAD:
  878.                             Key->CtrlShiftLen = 1;
  879.                             Key->CtrlShift[0] = KeyMapPtr[11];
  880.                             break;
  881.                         case DPF_MOD:
  882.                             Key->CtrlShiftLen = 6;
  883.                             memcpy(Key->CtrlShift, (KeyMapPtr+KeyMapPtr[11]), 6);
  884.                     } /* switch */
  885.                     Key->CtrlAltOpt = KeyMapPtr[12];
  886.                     switch (Key->CtrlAltOpt) {
  887.                         case KC_NOQUAL:
  888.                         case DPF_DEAD:
  889.                             Key->CtrlAltLen = 1;
  890.                             Key->CtrlAlt[0] = KeyMapPtr[13];
  891.                             break;
  892.                         case DPF_MOD:
  893.                             Key->CtrlAltLen = 6;
  894.                             memcpy(Key->CtrlAlt, (KeyMapPtr+KeyMapPtr[13]), 6);
  895.                     } /* switch */
  896.                     Key->VanillaOpt = KeyMapPtr[14];
  897.                     switch (Key->VanillaOpt) {
  898.                         case KC_NOQUAL:
  899.                         case DPF_DEAD:
  900.                             Key->VanillaLen = 1;
  901.                             Key->Vanilla[0] = KeyMapPtr[15];
  902.                             break;
  903.                         case DPF_MOD:
  904.                             Key->VanillaLen = 6;
  905.                             memcpy(Key->Vanilla, (KeyMapPtr+KeyMapPtr[15]), 6);
  906.                     } /* switch */
  907.             } /* switch */
  908.             break;
  909.         case KCF_NOP:
  910.             break;
  911.     } /* switch */
  912.     return(Key);
  913. }
  914.  
  915. /*
  916.  * Initialize requester for type of key
  917.  */
  918. void InitKeyReq(Key)
  919. struct KeyNode *Key;
  920. {
  921.     switch(Key->Type & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
  922.         case KC_NOQUAL:
  923.             KRNOPGadget.Flags &= ~SELECTED;
  924.             KRNoQualGadget.Flags |= SELECTED;
  925.             KRStringGadget.Flags &= ~SELECTED;
  926.             KRDeadGadget.Flags &= ~SELECTED;
  927.             KRRepeatableGadget.NextGadget = KRNormalGadgetList;
  928.             KRRequester.ReqText = KRNormalITextList;
  929.  
  930.             KRNAloneStrGadSInfo.BufferPos = ExpandCtrl(KRNAloneStrGadSIBuff, Key->Alone, 1);
  931.             if (Key->Type & KCF_SHIFT) {
  932.                 KRNormalIText1.IText = KRShiftString;
  933.                 KRNOpt1StrGadget.Flags &= ~GADGDISABLED;
  934.                 KRNOpt1StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt1StrGadSIBuff, Key->Shift, 1);
  935.             }
  936.             else if (Key->Type & KCF_ALT) {
  937.                 KRNormalIText1.IText = KRAltString;
  938.                 KRNOpt1StrGadget.Flags &= ~GADGDISABLED;
  939.                 KRNOpt1StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt1StrGadSIBuff, Key->Alt, 1);
  940.             }
  941.             else if (Key->Type & KCF_CONTROL) {
  942.                 KRNormalIText1.IText = KRCtrlString;
  943.                 KRNOpt1StrGadget.Flags &= ~GADGDISABLED;
  944.                 KRNOpt1StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt1StrGadSIBuff, Key->Ctrl, 1);
  945.             }
  946.             else {
  947.                 KRNormalIText1.IText = NULL;
  948.                 KRNOpt1StrGadget.Flags |= GADGDISABLED;
  949.                 KRNOpt1StrGadSIBuff[0] = '\x00';
  950.                 KRNOpt1StrGadSInfo.BufferPos = 0;
  951.             }
  952.             if ((Key->Type & KCF_ALT) && (Key->Type & KCF_SHIFT)) {
  953.                 KRNormalIText2.IText = KRAltString;
  954.                 KRNOpt2StrGadget.Flags &= ~GADGDISABLED;
  955.                 KRNOpt2StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt2StrGadSIBuff, Key->Alt, 1);
  956.             }
  957.             else if ((Key->Type & KCF_CONTROL) && (Key->Type & (KCF_SHIFT|KCF_ALT))) {
  958.                 KRNormalIText2.IText = KRCtrlString;
  959.                 KRNOpt2StrGadget.Flags &= ~GADGDISABLED;
  960.                 KRNOpt2StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt2StrGadSIBuff, Key->Ctrl, 1);
  961.             }
  962.             else {
  963.                 KRNormalIText2.IText = NULL;
  964.                 KRNOpt2StrGadget.Flags |= GADGDISABLED;
  965.                 KRNOpt2StrGadSIBuff[0] = '\x00';
  966.                 KRNOpt2StrGadSInfo.BufferPos = 0;
  967.             }
  968.             if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT)) {
  969.                 KRNormalIText3.IText = KRShiftAltString;
  970.                 KRNOpt3StrGadget.Flags &= ~GADGDISABLED;
  971.                 KRNOpt3StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt3StrGadSIBuff, Key->ShiftAlt, 1);
  972.             }
  973.             else if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT)) {
  974.                 KRNormalIText3.IText = KRCtrlShiftString;
  975.                 KRNOpt3StrGadget.Flags &= ~GADGDISABLED;
  976.                 KRNOpt3StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt3StrGadSIBuff, Key->CtrlShift, 1);
  977.             }
  978.             else if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT)) {
  979.                 KRNormalIText3.IText = KRCtrlAltString;
  980.                 KRNOpt3StrGadget.Flags &= ~GADGDISABLED;
  981.                 KRNOpt3StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt3StrGadSIBuff, Key->CtrlAlt, 1);
  982.             }
  983.             else {
  984.                 KRNormalIText3.IText = NULL;
  985.                 KRNOpt3StrGadget.Flags |= GADGDISABLED;
  986.                 KRNOpt3StrGadSIBuff[0] = '\x00';
  987.                 KRNOpt3StrGadSInfo.BufferPos = 0;
  988.             }
  989.             break;
  990.         case KCF_STRING:
  991.             KRNOPGadget.Flags &= ~SELECTED;
  992.             KRNoQualGadget.Flags &= ~SELECTED;
  993.             KRStringGadget.Flags |= SELECTED;
  994.             KRDeadGadget.Flags &= ~SELECTED;
  995.             KRRepeatableGadget.NextGadget = KRStringGadgetList;
  996.             KRRequester.ReqText = KRStringITextList;
  997.  
  998.             KRSAloneStrGadSInfo.BufferPos = ExpandCtrl(KRSAloneStrGadSIBuff, Key->Alone, Key->AloneLen);
  999.             if (Key->Type & KCF_SHIFT) {
  1000.                 KRSShiftStrGadget.Flags &= ~GADGDISABLED;
  1001.                 KRSShiftStrGadSInfo.BufferPos = ExpandCtrl(KRSShiftStrGadSIBuff, Key->Shift, Key->ShiftLen);
  1002.             }
  1003.             else {
  1004.                 KRSShiftStrGadget.Flags |= GADGDISABLED;
  1005.                 KRSShiftStrGadSIBuff[0] = '\x00';
  1006.                 KRSShiftStrGadSInfo.BufferPos = 0;
  1007.             }
  1008.             if (Key->Type & KCF_ALT) {
  1009.                 KRSAltStrGadget.Flags &= ~GADGDISABLED;
  1010.                 KRSAltStrGadSInfo.BufferPos = ExpandCtrl(KRSAltStrGadSIBuff, Key->Alt, Key->AltLen);
  1011.             }
  1012.             else {
  1013.                 KRSAltStrGadget.Flags |= GADGDISABLED;
  1014.                 KRSAltStrGadSIBuff[0] = '\x00';
  1015.                 KRSAltStrGadSInfo.BufferPos = 0;
  1016.             }
  1017.             if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT)) {
  1018.                 KRSShiftAltStrGadget.Flags &= ~GADGDISABLED;
  1019.                 KRSShiftAltStrGadSInfo.BufferPos = ExpandCtrl(KRSShiftAltStrGadSIBuff, Key->ShiftAlt, Key->ShiftAltLen);
  1020.             }
  1021.             else {
  1022.                 KRSShiftAltStrGadget.Flags |= GADGDISABLED;
  1023.                 KRSShiftAltStrGadSIBuff[0] = '\x00';
  1024.                 KRSShiftAltStrGadSInfo.BufferPos = 0;
  1025.             }
  1026.             if (Key->Type & KCF_CONTROL) {
  1027.                 KRSCtrlStrGadget.Flags &= ~GADGDISABLED;
  1028.                 KRSCtrlStrGadSInfo.BufferPos = ExpandCtrl(KRSCtrlStrGadSIBuff, Key->Ctrl, Key->CtrlLen);
  1029.             }
  1030.             else {
  1031.                 KRSCtrlStrGadget.Flags |= GADGDISABLED;
  1032.                 KRSCtrlStrGadSIBuff[0] = '\x00';
  1033.                 KRSCtrlStrGadSInfo.BufferPos = 0;
  1034.             }
  1035.             if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT)) {
  1036.                 KRSCtrlShiftStrGadget.Flags &= ~GADGDISABLED;
  1037.                 KRSCtrlShiftStrGadSInfo.BufferPos = ExpandCtrl(KRSCtrlShiftStrGadSIBuff, Key->CtrlShift, Key->CtrlShiftLen);
  1038.             }
  1039.             else {
  1040.                 KRSCtrlShiftStrGadget.Flags |= GADGDISABLED;
  1041.                 KRSCtrlShiftStrGadSIBuff[0] = '\x00';
  1042.                 KRSCtrlShiftStrGadSInfo.BufferPos = 0;
  1043.             }
  1044.             if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT)) {
  1045.                 KRSCtrlAltStrGadget.Flags &= ~GADGDISABLED;
  1046.                 KRSCtrlAltStrGadSInfo.BufferPos = ExpandCtrl(KRSCtrlAltStrGadSIBuff, Key->CtrlAlt, Key->CtrlAltLen);
  1047.             }
  1048.             else {
  1049.                 KRSCtrlAltStrGadget.Flags |= GADGDISABLED;
  1050.                 KRSCtrlAltStrGadSIBuff[0] = '\x00';
  1051.                 KRSCtrlAltStrGadSInfo.BufferPos = 0;
  1052.             }
  1053.             if ((Key->Type & KC_VANILLA) == KC_VANILLA) {
  1054.                 KRSVanillaStrGadget.Flags &= ~GADGDISABLED;
  1055.                 KRSVanillaStrGadSInfo.BufferPos = ExpandCtrl(KRSVanillaStrGadSIBuff, Key->Vanilla, Key->VanillaLen);
  1056.             }
  1057.             else {
  1058.                 KRSVanillaStrGadget.Flags |= GADGDISABLED;
  1059.                 KRSVanillaStrGadSIBuff[0] = '\x00';
  1060.                 KRSVanillaStrGadSInfo.BufferPos = 0;
  1061.             }
  1062.             break;
  1063.         case KCF_DEAD:
  1064.             KRNOPGadget.Flags &= ~SELECTED;
  1065.             KRNoQualGadget.Flags &= ~SELECTED;
  1066.             KRStringGadget.Flags &= ~SELECTED;
  1067.             KRDeadGadget.Flags |= SELECTED;
  1068.             KRRepeatableGadget.NextGadget = KRDeadGadgetList;
  1069.             KRRequester.ReqText = KRDeadITextList;
  1070.  
  1071.             KRDAloneModGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1072.             KRDAloneDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1073.             switch (Key->AloneOpt) {
  1074.                 case KC_NOQUAL:
  1075.                     KRDAloneDeadGadget.NextGadget = &KRDAloneNormalStrGadget;
  1076.                     KRDAloneNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDAloneNormalStrGadSIBuff, Key->Alone, 1);
  1077.                     break;
  1078.                 case DPF_MOD:
  1079.                     KRDAloneModGadget.Flags |= SELECTED;
  1080.                     KRDAloneDeadGadget.NextGadget = &KRDAloneMod0StrGadget;
  1081.                     KRDAloneMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDAloneMod0StrGadSIBuff, &Key->Alone[0], 1);
  1082.                     KRDAloneMod0StrGadSInfo.DispPos = KRDAloneMod0StrGadSInfo.BufferPos - 1;
  1083.                     KRDAloneMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDAloneMod1StrGadSIBuff, &Key->Alone[1], 1);
  1084.                     KRDAloneMod1StrGadSInfo.DispPos = KRDAloneMod1StrGadSInfo.BufferPos - 1;
  1085.                     KRDAloneMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDAloneMod2StrGadSIBuff, &Key->Alone[2], 1);
  1086.                     KRDAloneMod2StrGadSInfo.DispPos = KRDAloneMod2StrGadSInfo.BufferPos - 1;
  1087.                     KRDAloneMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDAloneMod3StrGadSIBuff, &Key->Alone[3], 1);
  1088.                     KRDAloneMod3StrGadSInfo.DispPos = KRDAloneMod3StrGadSInfo.BufferPos - 1;
  1089.                     KRDAloneMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDAloneMod4StrGadSIBuff, &Key->Alone[4], 1);
  1090.                     KRDAloneMod4StrGadSInfo.DispPos = KRDAloneMod4StrGadSInfo.BufferPos - 1;
  1091.                     KRDAloneMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDAloneMod5StrGadSIBuff, &Key->Alone[5], 1);
  1092.                     KRDAloneMod5StrGadSInfo.DispPos = KRDAloneMod5StrGadSInfo.BufferPos - 1;
  1093.                     break;
  1094.                 case DPF_DEAD:
  1095.                     KRDAloneDeadGadget.Flags |= SELECTED;
  1096.                     KRDAloneDeadGadget.NextGadget = &KRDAloneAcc1Gadget;
  1097.                     KRDAloneAcc1Gadget.Flags &= ~SELECTED;
  1098.                     KRDAloneAcc2Gadget.Flags &= ~SELECTED;
  1099.                     KRDAloneAcc3Gadget.Flags &= ~SELECTED;
  1100.                     KRDAloneAcc4Gadget.Flags &= ~SELECTED;
  1101.                     KRDAloneAcc5Gadget.Flags &= ~SELECTED;
  1102.                     switch (Key->Alone[0]) {
  1103.                         case 01:
  1104.                             KRDAloneAcc1Gadget.Flags |= SELECTED;
  1105.                             break;
  1106.                         case 02:
  1107.                             KRDAloneAcc2Gadget.Flags |= SELECTED;
  1108.                             break;
  1109.                         case 03:
  1110.                             KRDAloneAcc3Gadget.Flags |= SELECTED;
  1111.                             break;
  1112.                         case 04:
  1113.                             KRDAloneAcc4Gadget.Flags |= SELECTED;
  1114.                             break;
  1115.                         case 05:
  1116.                             KRDAloneAcc5Gadget.Flags |= SELECTED;
  1117.                     } /* switch */
  1118.             } /* switch */
  1119.             KRDShiftModGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1120.             KRDShiftDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1121.             if (Key->Type & KCF_SHIFT)
  1122.                 switch (Key->ShiftOpt) {
  1123.                     case KC_NOQUAL:
  1124.                         KRDShiftDeadGadget.NextGadget = &KRDShiftNormalStrGadget;
  1125.                         KRDShiftNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDShiftNormalStrGadSIBuff, Key->Shift, 1);
  1126.                         break;
  1127.                     case DPF_MOD:
  1128.                         KRDShiftModGadget.Flags |= SELECTED;
  1129.                         KRDShiftDeadGadget.NextGadget = &KRDShiftMod0StrGadget;
  1130.                         KRDShiftMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftMod0StrGadSIBuff, &Key->Shift[0], 1);
  1131.                         KRDShiftMod0StrGadSInfo.DispPos = KRDShiftMod0StrGadSInfo.BufferPos - 1;
  1132.                         KRDShiftMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftMod1StrGadSIBuff, &Key->Shift[1], 1);
  1133.                         KRDShiftMod1StrGadSInfo.DispPos = KRDShiftMod1StrGadSInfo.BufferPos - 1;
  1134.                         KRDShiftMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftMod2StrGadSIBuff, &Key->Shift[2], 1);
  1135.                         KRDShiftMod2StrGadSInfo.DispPos = KRDShiftMod2StrGadSInfo.BufferPos - 1;
  1136.                         KRDShiftMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftMod3StrGadSIBuff, &Key->Shift[3], 1);
  1137.                         KRDShiftMod3StrGadSInfo.DispPos = KRDShiftMod3StrGadSInfo.BufferPos - 1;
  1138.                         KRDShiftMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftMod4StrGadSIBuff, &Key->Shift[4], 1);
  1139.                         KRDShiftMod4StrGadSInfo.DispPos = KRDShiftMod4StrGadSInfo.BufferPos - 1;
  1140.                         KRDShiftMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftMod5StrGadSIBuff, &Key->Shift[5], 1);
  1141.                         KRDShiftMod5StrGadSInfo.DispPos = KRDShiftMod5StrGadSInfo.BufferPos - 1;
  1142.                         break;
  1143.                     case DPF_DEAD:
  1144.                         KRDShiftDeadGadget.Flags |= SELECTED;
  1145.                         KRDShiftDeadGadget.NextGadget = &KRDShiftAcc1Gadget;
  1146.                         KRDShiftAcc1Gadget.Flags &= ~SELECTED;
  1147.                         KRDShiftAcc2Gadget.Flags &= ~SELECTED;
  1148.                         KRDShiftAcc3Gadget.Flags &= ~SELECTED;
  1149.                         KRDShiftAcc4Gadget.Flags &= ~SELECTED;
  1150.                         KRDShiftAcc5Gadget.Flags &= ~SELECTED;
  1151.                         switch (Key->Shift[0]) {
  1152.                             case 01:
  1153.                                 KRDShiftAcc1Gadget.Flags |= SELECTED;
  1154.                                 break;
  1155.                             case 02:
  1156.                                 KRDShiftAcc2Gadget.Flags |= SELECTED;
  1157.                                 break;
  1158.                             case 03:
  1159.                                 KRDShiftAcc3Gadget.Flags |= SELECTED;
  1160.                                 break;
  1161.                             case 04:
  1162.                                 KRDShiftAcc4Gadget.Flags |= SELECTED;
  1163.                                 break;
  1164.                             case 05:
  1165.                                 KRDShiftAcc5Gadget.Flags |= SELECTED;
  1166.                         } /* switch */
  1167.                 } /* switch */
  1168.             else {
  1169.                 KRDShiftModGadget.Flags |= GADGDISABLED;
  1170.                 KRDShiftDeadGadget.Flags |= GADGDISABLED;
  1171.                 KRDShiftDeadGadget.NextGadget = &KRDAltModGadget;
  1172.             }
  1173.             KRDAltModGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1174.             KRDAltDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1175.             if (Key->Type & KCF_ALT)
  1176.                 switch (Key->AltOpt) {
  1177.                     case KC_NOQUAL:
  1178.                         KRDAltDeadGadget.NextGadget = &KRDAltNormalStrGadget;
  1179.                         KRDAltNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDAltNormalStrGadSIBuff, Key->Alt, 1);
  1180.                         break;
  1181.                     case DPF_MOD:
  1182.                         KRDAltModGadget.Flags |= SELECTED;
  1183.                         KRDAltDeadGadget.NextGadget = &KRDAltMod0StrGadget;
  1184.                         KRDAltMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDAltMod0StrGadSIBuff, &Key->Alt[0], 1);
  1185.                         KRDAltMod0StrGadSInfo.DispPos = KRDAltMod0StrGadSInfo.BufferPos - 1;
  1186.                         KRDAltMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDAltMod1StrGadSIBuff, &Key->Alt[1], 1);
  1187.                         KRDAltMod1StrGadSInfo.DispPos = KRDAltMod1StrGadSInfo.BufferPos - 1;
  1188.                         KRDAltMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDAltMod2StrGadSIBuff, &Key->Alt[2], 1);
  1189.                         KRDAltMod2StrGadSInfo.DispPos = KRDAltMod2StrGadSInfo.BufferPos - 1;
  1190.                         KRDAltMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDAltMod3StrGadSIBuff, &Key->Alt[3], 1);
  1191.                         KRDAltMod3StrGadSInfo.DispPos = KRDAltMod3StrGadSInfo.BufferPos - 1;
  1192.                         KRDAltMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDAltMod4StrGadSIBuff, &Key->Alt[4], 1);
  1193.                         KRDAltMod4StrGadSInfo.DispPos = KRDAltMod4StrGadSInfo.BufferPos - 1;
  1194.                         KRDAltMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDAltMod5StrGadSIBuff, &Key->Alt[5], 1);
  1195.                         KRDAltMod5StrGadSInfo.DispPos = KRDAltMod5StrGadSInfo.BufferPos - 1;
  1196.                         break;
  1197.                     case DPF_DEAD:
  1198.                         KRDAltDeadGadget.Flags |= SELECTED;
  1199.                         KRDAltDeadGadget.NextGadget = &KRDAltAcc1Gadget;
  1200.                         KRDAltAcc1Gadget.Flags &= ~SELECTED;
  1201.                         KRDAltAcc2Gadget.Flags &= ~SELECTED;
  1202.                         KRDAltAcc3Gadget.Flags &= ~SELECTED;
  1203.                         KRDAltAcc4Gadget.Flags &= ~SELECTED;
  1204.                         KRDAltAcc5Gadget.Flags &= ~SELECTED;
  1205.                         switch (Key->Alt[0]) {
  1206.                             case 01:
  1207.                                 KRDAltAcc1Gadget.Flags |= SELECTED;
  1208.                                 break;
  1209.                             case 02:
  1210.                                 KRDAltAcc2Gadget.Flags |= SELECTED;
  1211.                                 break;
  1212.                             case 03:
  1213.                                 KRDAltAcc3Gadget.Flags |= SELECTED;
  1214.                                 break;
  1215.                             case 04:
  1216.                                 KRDAltAcc4Gadget.Flags |= SELECTED;
  1217.                                 break;
  1218.                             case 05:
  1219.                                 KRDAltAcc5Gadget.Flags |= SELECTED;
  1220.                         } /* switch */
  1221.                 } /* switch */
  1222.             else {
  1223.                 KRDAltModGadget.Flags |= GADGDISABLED;
  1224.                 KRDAltDeadGadget.Flags |= GADGDISABLED;
  1225.                 KRDAltDeadGadget.NextGadget = &KRDShiftAltModGadget;
  1226.             }
  1227.             KRDShiftAltModGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1228.             KRDShiftAltDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1229.             if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
  1230.                 switch (Key->ShiftAltOpt) {
  1231.                     case KC_NOQUAL:
  1232.                         KRDShiftAltDeadGadget.NextGadget = &KRDShiftAltNormalStrGadget;
  1233.                         KRDShiftAltNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDShiftAltNormalStrGadSIBuff, Key->ShiftAlt, 1);
  1234.                         break;
  1235.                     case DPF_MOD:
  1236.                         KRDShiftAltModGadget.Flags |= SELECTED;
  1237.                         KRDShiftAltDeadGadget.NextGadget = &KRDShiftAltMod0StrGadget;
  1238.                         KRDShiftAltMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftAltMod0StrGadSIBuff, &Key->ShiftAlt[0], 1);
  1239.                         KRDShiftAltMod0StrGadSInfo.DispPos = KRDShiftAltMod0StrGadSInfo.BufferPos - 1;
  1240.                         KRDShiftAltMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftAltMod1StrGadSIBuff, &Key->ShiftAlt[1], 1);
  1241.                         KRDShiftAltMod1StrGadSInfo.DispPos = KRDShiftAltMod1StrGadSInfo.BufferPos - 1;
  1242.                         KRDShiftAltMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftAltMod2StrGadSIBuff, &Key->ShiftAlt[2], 1);
  1243.                         KRDShiftAltMod2StrGadSInfo.DispPos = KRDShiftAltMod2StrGadSInfo.BufferPos - 1;
  1244.                         KRDShiftAltMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftAltMod3StrGadSIBuff, &Key->ShiftAlt[3], 1);
  1245.                         KRDShiftAltMod3StrGadSInfo.DispPos = KRDShiftAltMod3StrGadSInfo.BufferPos - 1;
  1246.                         KRDShiftAltMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftAltMod4StrGadSIBuff, &Key->ShiftAlt[4], 1);
  1247.                         KRDShiftAltMod4StrGadSInfo.DispPos = KRDShiftAltMod4StrGadSInfo.BufferPos - 1;
  1248.                         KRDShiftAltMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftAltMod5StrGadSIBuff, &Key->ShiftAlt[5], 1);
  1249.                         KRDShiftAltMod5StrGadSInfo.DispPos = KRDShiftAltMod5StrGadSInfo.BufferPos - 1;
  1250.                     case DPF_DEAD:
  1251.                         KRDShiftAltDeadGadget.Flags |= SELECTED;
  1252.                         KRDShiftAltDeadGadget.NextGadget = &KRDShiftAltAcc1Gadget;
  1253.                         KRDShiftAltAcc1Gadget.Flags &= ~SELECTED;
  1254.                         KRDShiftAltAcc2Gadget.Flags &= ~SELECTED;
  1255.                         KRDShiftAltAcc3Gadget.Flags &= ~SELECTED;
  1256.                         KRDShiftAltAcc4Gadget.Flags &= ~SELECTED;
  1257.                         KRDShiftAltAcc5Gadget.Flags &= ~SELECTED;
  1258.                         switch (Key->ShiftAlt[0]) {
  1259.                             case 01:
  1260.                                 KRDShiftAltAcc1Gadget.Flags |= SELECTED;
  1261.                                 break;
  1262.                             case 02:
  1263.                                 KRDShiftAltAcc2Gadget.Flags |= SELECTED;
  1264.                                 break;
  1265.                             case 03:
  1266.                                 KRDShiftAltAcc3Gadget.Flags |= SELECTED;
  1267.                                 break;
  1268.                             case 04:
  1269.                                 KRDShiftAltAcc4Gadget.Flags |= SELECTED;
  1270.                                 break;
  1271.                             case 05:
  1272.                                 KRDShiftAltAcc5Gadget.Flags |= SELECTED;
  1273.                         } /* switch */
  1274.                 } /* switch */
  1275.             else {
  1276.                 KRDShiftAltModGadget.Flags |= GADGDISABLED;
  1277.                 KRDShiftAltDeadGadget.Flags |= GADGDISABLED;
  1278.                 KRDShiftAltDeadGadget.NextGadget = &KRDCtrlModGadget;
  1279.             }
  1280.             KRDCtrlModGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1281.             KRDCtrlDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1282.             if (Key->Type & KCF_CONTROL)
  1283.                 switch (Key->CtrlOpt) {
  1284.                     case KC_NOQUAL:
  1285.                         KRDCtrlDeadGadget.NextGadget = &KRDCtrlNormalStrGadget;
  1286.                         KRDCtrlNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlNormalStrGadSIBuff, Key->Ctrl, 1);
  1287.                         break;
  1288.                     case DPF_MOD:
  1289.                         KRDCtrlModGadget.Flags |= SELECTED;
  1290.                         KRDCtrlDeadGadget.NextGadget = &KRDCtrlMod0StrGadget;
  1291.                         KRDCtrlMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlMod0StrGadSIBuff, &Key->Ctrl[0], 1);
  1292.                         KRDCtrlMod0StrGadSInfo.DispPos = KRDCtrlMod0StrGadSInfo.BufferPos - 1;
  1293.                         KRDCtrlMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlMod1StrGadSIBuff, &Key->Ctrl[1], 1);
  1294.                         KRDCtrlMod1StrGadSInfo.DispPos = KRDCtrlMod1StrGadSInfo.BufferPos - 1;
  1295.                         KRDCtrlMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlMod2StrGadSIBuff, &Key->Ctrl[2], 1);
  1296.                         KRDCtrlMod2StrGadSInfo.DispPos = KRDCtrlMod2StrGadSInfo.BufferPos - 1;
  1297.                         KRDCtrlMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlMod3StrGadSIBuff, &Key->Ctrl[3], 1);
  1298.                         KRDCtrlMod3StrGadSInfo.DispPos = KRDCtrlMod3StrGadSInfo.BufferPos - 1;
  1299.                         KRDCtrlMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlMod4StrGadSIBuff, &Key->Ctrl[4], 1);
  1300.                         KRDCtrlMod4StrGadSInfo.DispPos = KRDCtrlMod4StrGadSInfo.BufferPos - 1;
  1301.                         KRDCtrlMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlMod5StrGadSIBuff, &Key->Ctrl[5], 1);
  1302.                         KRDCtrlMod5StrGadSInfo.DispPos = KRDCtrlMod5StrGadSInfo.BufferPos - 1;
  1303.                         break;
  1304.                     case DPF_DEAD:
  1305.                         KRDCtrlDeadGadget.Flags |= SELECTED;
  1306.                         KRDCtrlDeadGadget.NextGadget = &KRDCtrlAcc1Gadget;
  1307.                         KRDCtrlAcc1Gadget.Flags &= ~SELECTED;
  1308.                         KRDCtrlAcc2Gadget.Flags &= ~SELECTED;
  1309.                         KRDCtrlAcc3Gadget.Flags &= ~SELECTED;
  1310.                         KRDCtrlAcc4Gadget.Flags &= ~SELECTED;
  1311.                         KRDCtrlAcc5Gadget.Flags &= ~SELECTED;
  1312.                         switch (Key->Ctrl[0]) {
  1313.                             case 01:
  1314.                                 KRDCtrlAcc1Gadget.Flags |= SELECTED;
  1315.                                 break;
  1316.                             case 02:
  1317.                                 KRDCtrlAcc2Gadget.Flags |= SELECTED;
  1318.                                 break;
  1319.                             case 03:
  1320.                                 KRDCtrlAcc3Gadget.Flags |= SELECTED;
  1321.                                 break;
  1322.                             case 04:
  1323.                                 KRDCtrlAcc4Gadget.Flags |= SELECTED;
  1324.                                 break;
  1325.                             case 05:
  1326.                                 KRDCtrlAcc5Gadget.Flags |= SELECTED;
  1327.                         } /* switch */
  1328.                 } /* switch */
  1329.             else {
  1330.                 KRDCtrlModGadget.Flags |= GADGDISABLED;
  1331.                 KRDCtrlDeadGadget.Flags |= GADGDISABLED;
  1332.                 KRDCtrlDeadGadget.NextGadget = &KRDCtrlShiftModGadget;
  1333.             }
  1334.             KRDCtrlShiftModGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1335.             KRDCtrlShiftDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1336.             if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
  1337.                 switch (Key->CtrlShiftOpt) {
  1338.                     case KC_NOQUAL:
  1339.                         KRDCtrlShiftDeadGadget.NextGadget = &KRDCtrlShiftNormalStrGadget;
  1340.                         KRDCtrlShiftNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlShiftNormalStrGadSIBuff, Key->CtrlShift, 1);
  1341.                         break;
  1342.                     case DPF_MOD:
  1343.                         KRDCtrlShiftModGadget.Flags |= SELECTED;
  1344.                         KRDCtrlShiftDeadGadget.NextGadget = &KRDCtrlShiftMod0StrGadget;
  1345.                         KRDCtrlShiftMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlShiftMod0StrGadSIBuff, &Key->CtrlShift[0], 1);
  1346.                         KRDCtrlShiftMod0StrGadSInfo.DispPos = KRDCtrlShiftMod0StrGadSInfo.BufferPos - 1;
  1347.                         KRDCtrlShiftMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlShiftMod1StrGadSIBuff, &Key->CtrlShift[1], 1);
  1348.                         KRDCtrlShiftMod1StrGadSInfo.DispPos = KRDCtrlShiftMod1StrGadSInfo.BufferPos - 1;
  1349.                         KRDCtrlShiftMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlShiftMod2StrGadSIBuff, &Key->CtrlShift[2], 1);
  1350.                         KRDCtrlShiftMod2StrGadSInfo.DispPos = KRDCtrlShiftMod2StrGadSInfo.BufferPos - 1;
  1351.                         KRDCtrlShiftMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlShiftMod3StrGadSIBuff, &Key->CtrlShift[3], 1);
  1352.                         KRDCtrlShiftMod3StrGadSInfo.DispPos = KRDCtrlShiftMod3StrGadSInfo.BufferPos - 1;
  1353.                         KRDCtrlShiftMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlShiftMod4StrGadSIBuff, &Key->CtrlShift[4], 1);
  1354.                         KRDCtrlShiftMod4StrGadSInfo.DispPos = KRDCtrlShiftMod4StrGadSInfo.BufferPos - 1;
  1355.                         KRDCtrlShiftMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlShiftMod5StrGadSIBuff, &Key->CtrlShift[5], 1);
  1356.                         KRDCtrlShiftMod5StrGadSInfo.DispPos = KRDCtrlShiftMod5StrGadSInfo.BufferPos - 1;
  1357.                         break;
  1358.                     case DPF_DEAD:
  1359.                         KRDCtrlShiftDeadGadget.Flags |= SELECTED;
  1360.                         KRDCtrlShiftDeadGadget.NextGadget = &KRDCtrlShiftAcc1Gadget;
  1361.                         KRDCtrlShiftAcc1Gadget.Flags &= ~SELECTED;
  1362.                         KRDCtrlShiftAcc2Gadget.Flags &= ~SELECTED;
  1363.                         KRDCtrlShiftAcc3Gadget.Flags &= ~SELECTED;
  1364.                         KRDCtrlShiftAcc4Gadget.Flags &= ~SELECTED;
  1365.                         KRDCtrlShiftAcc5Gadget.Flags &= ~SELECTED;
  1366.                         switch (Key->CtrlShift[0]) {
  1367.                             case 01:
  1368.                                 KRDCtrlShiftAcc1Gadget.Flags |= SELECTED;
  1369.                                 break;
  1370.                             case 02:
  1371.                                 KRDCtrlShiftAcc2Gadget.Flags |= SELECTED;
  1372.                                 break;
  1373.                             case 03:
  1374.                                 KRDCtrlShiftAcc3Gadget.Flags |= SELECTED;
  1375.                                 break;
  1376.                             case 04:
  1377.                                 KRDCtrlShiftAcc4Gadget.Flags |= SELECTED;
  1378.                                 break;
  1379.                             case 05:
  1380.                                 KRDCtrlShiftAcc5Gadget.Flags |= SELECTED;
  1381.                         } /* switch */
  1382.                 } /* switch */
  1383.             else {
  1384.                 KRDCtrlShiftModGadget.Flags |= GADGDISABLED;
  1385.                 KRDCtrlShiftDeadGadget.Flags |= GADGDISABLED;
  1386.                 KRDCtrlShiftDeadGadget.NextGadget = &KRDCtrlAltModGadget;
  1387.             }
  1388.             KRDCtrlAltModGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1389.             KRDCtrlAltDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1390.             if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
  1391.                 switch (Key->CtrlAltOpt) {
  1392.                     case KC_NOQUAL:
  1393.                         KRDCtrlAltDeadGadget.NextGadget = &KRDCtrlAltNormalStrGadget;
  1394.                         KRDCtrlAltNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlAltNormalStrGadSIBuff, Key->CtrlAlt, 1);
  1395.                         break;
  1396.                     case DPF_MOD:
  1397.                         KRDCtrlAltModGadget.Flags |= SELECTED;
  1398.                         KRDCtrlAltDeadGadget.NextGadget = &KRDCtrlAltMod0StrGadget;
  1399.                         KRDCtrlAltMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlAltMod0StrGadSIBuff, &Key->CtrlAlt[0], 1);
  1400.                         KRDCtrlAltMod0StrGadSInfo.DispPos = KRDCtrlAltMod0StrGadSInfo.BufferPos - 1;
  1401.                         KRDCtrlAltMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlAltMod1StrGadSIBuff, &Key->CtrlAlt[1], 1);
  1402.                         KRDCtrlAltMod1StrGadSInfo.DispPos = KRDCtrlAltMod1StrGadSInfo.BufferPos - 1;
  1403.                         KRDCtrlAltMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlAltMod2StrGadSIBuff, &Key->CtrlAlt[2], 1);
  1404.                         KRDCtrlAltMod2StrGadSInfo.DispPos = KRDCtrlAltMod2StrGadSInfo.BufferPos - 1;
  1405.                         KRDCtrlAltMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlAltMod3StrGadSIBuff, &Key->CtrlAlt[3], 1);
  1406.                         KRDCtrlAltMod3StrGadSInfo.DispPos = KRDCtrlAltMod3StrGadSInfo.BufferPos - 1;
  1407.                         KRDCtrlAltMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlAltMod4StrGadSIBuff, &Key->CtrlAlt[4], 1);
  1408.                         KRDCtrlAltMod4StrGadSInfo.DispPos = KRDCtrlAltMod4StrGadSInfo.BufferPos - 1;
  1409.                         KRDCtrlAltMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlAltMod5StrGadSIBuff, &Key->CtrlAlt[5], 1);
  1410.                         KRDCtrlAltMod5StrGadSInfo.DispPos = KRDCtrlAltMod5StrGadSInfo.BufferPos - 1;
  1411.                         break;
  1412.                     case DPF_DEAD:
  1413.                         KRDCtrlAltDeadGadget.Flags |= SELECTED;
  1414.                         KRDCtrlAltDeadGadget.NextGadget = &KRDCtrlAltAcc1Gadget;
  1415.                         KRDCtrlAltAcc1Gadget.Flags &= ~SELECTED;
  1416.                         KRDCtrlAltAcc2Gadget.Flags &= ~SELECTED;
  1417.                         KRDCtrlAltAcc3Gadget.Flags &= ~SELECTED;
  1418.                         KRDCtrlAltAcc4Gadget.Flags &= ~SELECTED;
  1419.                         KRDCtrlAltAcc5Gadget.Flags &= ~SELECTED;
  1420.                         switch (Key->CtrlAlt[0]) {
  1421.                             case 01:
  1422.                                 KRDCtrlAltAcc1Gadget.Flags |= SELECTED;
  1423.                                 break;
  1424.                             case 02:
  1425.                                 KRDCtrlAltAcc2Gadget.Flags |= SELECTED;
  1426.                                 break;
  1427.                             case 03:
  1428.                                 KRDCtrlAltAcc3Gadget.Flags |= SELECTED;
  1429.                                 break;
  1430.                             case 04:
  1431.                                 KRDCtrlAltAcc4Gadget.Flags |= SELECTED;
  1432.                                 break;
  1433.                             case 05:
  1434.                                 KRDCtrlAltAcc5Gadget.Flags |= SELECTED;
  1435.                         } /* switch */
  1436.                 } /* switch */
  1437.             else {
  1438.                 KRDCtrlAltModGadget.Flags |= GADGDISABLED;
  1439.                 KRDCtrlAltDeadGadget.Flags |= GADGDISABLED;
  1440.                 KRDCtrlAltDeadGadget.NextGadget = &KRDVanillaModGadget;
  1441.             }
  1442.             KRDVanillaModGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1443.             KRDVanillaDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1444.             if ((Key->Type & KC_VANILLA) == KC_VANILLA)
  1445.                 switch (Key->VanillaOpt) {
  1446.                     case KC_NOQUAL:
  1447.                         KRDVanillaDeadGadget.NextGadget = &KRDVanillaNormalStrGadget;
  1448.                         KRDVanillaNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDVanillaNormalStrGadSIBuff, Key->Vanilla, 1);
  1449.                         break;
  1450.                     case DPF_MOD:
  1451.                         KRDVanillaModGadget.Flags |= SELECTED;
  1452.                         KRDVanillaDeadGadget.NextGadget = &KRDVanillaMod0StrGadget;
  1453.                         KRDVanillaMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDVanillaMod0StrGadSIBuff, &Key->Vanilla[0], 1);
  1454.                         KRDVanillaMod0StrGadSInfo.DispPos = KRDVanillaMod0StrGadSInfo.BufferPos - 1;
  1455.                         KRDVanillaMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDVanillaMod1StrGadSIBuff, &Key->Vanilla[1], 1);
  1456.                         KRDVanillaMod1StrGadSInfo.DispPos = KRDVanillaMod1StrGadSInfo.BufferPos - 1;
  1457.                         KRDVanillaMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDVanillaMod2StrGadSIBuff, &Key->Vanilla[2], 1);
  1458.                         KRDVanillaMod2StrGadSInfo.DispPos = KRDVanillaMod2StrGadSInfo.BufferPos - 1;
  1459.                         KRDVanillaMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDVanillaMod3StrGadSIBuff, &Key->Vanilla[3], 1);
  1460.                         KRDVanillaMod3StrGadSInfo.DispPos = KRDVanillaMod3StrGadSInfo.BufferPos - 1;
  1461.                         KRDVanillaMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDVanillaMod4StrGadSIBuff, &Key->Vanilla[4], 1);
  1462.                         KRDVanillaMod4StrGadSInfo.DispPos = KRDVanillaMod4StrGadSInfo.BufferPos - 1;
  1463.                         KRDVanillaMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDVanillaMod5StrGadSIBuff, &Key->Vanilla[5], 1);
  1464.                         KRDVanillaMod5StrGadSInfo.DispPos = KRDVanillaMod5StrGadSInfo.BufferPos - 1;
  1465.                         break;
  1466.                     case DPF_DEAD:
  1467.                         KRDVanillaDeadGadget.Flags |= SELECTED;
  1468.                         KRDVanillaDeadGadget.NextGadget = &KRDVanillaAcc1Gadget;
  1469.                         KRDVanillaAcc1Gadget.Flags &= ~SELECTED;
  1470.                         KRDVanillaAcc2Gadget.Flags &= ~SELECTED;
  1471.                         KRDVanillaAcc3Gadget.Flags &= ~SELECTED;
  1472.                         KRDVanillaAcc4Gadget.Flags &= ~SELECTED;
  1473.                         KRDVanillaAcc5Gadget.Flags &= ~SELECTED;
  1474.                         switch (Key->Vanilla[0]) {
  1475.                             case 01:
  1476.                                 KRDVanillaAcc1Gadget.Flags |= SELECTED;
  1477.                                 break;
  1478.                             case 02:
  1479.                                 KRDVanillaAcc2Gadget.Flags |= SELECTED;
  1480.                                 break;
  1481.                             case 03:
  1482.                                 KRDVanillaAcc3Gadget.Flags |= SELECTED;
  1483.                                 break;
  1484.                             case 04:
  1485.                                 KRDVanillaAcc4Gadget.Flags |= SELECTED;
  1486.                                 break;
  1487.                             case 05:
  1488.                                 KRDVanillaAcc5Gadget.Flags |= SELECTED;
  1489.                         } /* switch */
  1490.                 } /* switch */
  1491.             else {
  1492.                 KRDVanillaModGadget.Flags |= GADGDISABLED;
  1493.                 KRDVanillaDeadGadget.Flags |= GADGDISABLED;
  1494.                 KRDVanillaDeadGadget.NextGadget = &KRUseGadget;
  1495.             }
  1496.             break;
  1497.         case KCF_NOP:
  1498.             KRNOPGadget.Flags |= SELECTED;
  1499.             KRNoQualGadget.Flags &= ~SELECTED;
  1500.             KRStringGadget.Flags &= ~SELECTED;
  1501.             KRDeadGadget.Flags &= ~SELECTED;
  1502.             KRRepeatableGadget.NextGadget = KRNOPGadgetList;
  1503.             KRRequester.ReqText = NULL;
  1504.             break;
  1505.     } /* switch */
  1506.     KRShiftGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1507.     KRAltGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1508.     KRCtrlGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1509.     KRCapsableGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1510.     KRRepeatableGadget.Flags &= ~(SELECTED|GADGDISABLED);
  1511.     if (!(Key->Type & KCF_NOP)) {
  1512.         if (Key->Type & KCF_SHIFT)
  1513.             KRShiftGadget.Flags |= SELECTED;
  1514.         if (Key->Type & KCF_ALT)
  1515.             KRAltGadget.Flags |= SELECTED;
  1516.         if (Key->Type & KCF_CONTROL)
  1517.             KRCtrlGadget.Flags |= SELECTED;
  1518.         if (Key->Capsable)
  1519.             KRCapsableGadget.Flags |= SELECTED;
  1520.         if (Key->Repeatable)
  1521.             KRRepeatableGadget.Flags |= SELECTED;
  1522.     }
  1523.     else {
  1524.         KRShiftGadget.Flags |= GADGDISABLED;
  1525.         KRAltGadget.Flags |= GADGDISABLED;
  1526.         KRCtrlGadget.Flags |= GADGDISABLED;
  1527.         KRCapsableGadget.Flags |= GADGDISABLED;
  1528.         KRRepeatableGadget.Flags |= GADGDISABLED;
  1529.     }
  1530. }
  1531.  
  1532. /*
  1533.  * Update Key
  1534.  */
  1535. void UpdateKey(Key)
  1536. struct KeyNode *Key;
  1537. {
  1538.     switch(Key->Type & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
  1539.         case KC_NOQUAL:
  1540.             Key->AloneLen = CollapseCtrl(Key->Alone, KRNAloneStrGadSIBuff, 1);
  1541.             if (Key->Type & KCF_SHIFT)
  1542.                 Key->ShiftLen = CollapseCtrl(Key->Shift, KRNOpt1StrGadSIBuff, 1);
  1543.             else if (Key->Type & KCF_ALT)
  1544.                 Key->AltLen = CollapseCtrl(Key->Alt, KRNOpt1StrGadSIBuff, 1);
  1545.             else if (Key->Type & KCF_CONTROL)
  1546.                 Key->CtrlLen = CollapseCtrl(Key->Ctrl, KRNOpt1StrGadSIBuff, 1);
  1547.             if ((Key->Type & KCF_ALT) && (Key->Type & KCF_SHIFT))
  1548.                 Key->AltLen = CollapseCtrl(Key->Alt, KRNOpt2StrGadSIBuff, 1);
  1549.             else if ((Key->Type & KCF_CONTROL) && (Key->Type & (KCF_SHIFT|KCF_ALT)))
  1550.                 Key->CtrlLen = CollapseCtrl(Key->Ctrl, KRNOpt2StrGadSIBuff, 1);
  1551.             if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
  1552.                 Key->ShiftAltLen = CollapseCtrl(Key->ShiftAlt, KRNOpt3StrGadSIBuff, 1);
  1553.             else if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
  1554.                 Key->CtrlShiftLen = CollapseCtrl(Key->CtrlShift, KRNOpt3StrGadSIBuff, 1);
  1555.             else if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
  1556.                 Key->CtrlAltLen = CollapseCtrl(Key->CtrlAlt, KRNOpt3StrGadSIBuff, 1);
  1557.             break;
  1558.         case KCF_STRING:
  1559.             Key->AloneLen = CollapseCtrl(Key->Alone, KRSAloneStrGadSIBuff, 32);
  1560.             Key->ShiftLen = CollapseCtrl(Key->Shift, KRSShiftStrGadSIBuff, 32);
  1561.             Key->AltLen = CollapseCtrl(Key->Alt, KRSAltStrGadSIBuff, 32);
  1562.             Key->ShiftAltLen = CollapseCtrl(Key->ShiftAlt, KRSShiftAltStrGadSIBuff, 32);
  1563.             Key->CtrlLen = CollapseCtrl(Key->Ctrl, KRSCtrlStrGadSIBuff, 32);
  1564.             Key->CtrlShiftLen = CollapseCtrl(Key->CtrlShift, KRSCtrlShiftStrGadSIBuff, 32);
  1565.             Key->CtrlAltLen = CollapseCtrl(Key->CtrlAlt, KRSCtrlAltStrGadSIBuff, 32);
  1566.             Key->VanillaLen = CollapseCtrl(Key->Vanilla, KRSVanillaStrGadSIBuff, 32);
  1567.             break;
  1568.         case KCF_DEAD:
  1569.             switch (Key->AloneOpt) {
  1570.                 case KC_NOQUAL:
  1571.                     Key->AloneLen = CollapseCtrl(Key->Alone, KRDAloneNormalStrGadSIBuff, 1);
  1572.                     break;
  1573.                 case DPF_MOD:
  1574.                     Key->AloneLen = 6;
  1575.                     CollapseCtrl(&Key->Alone[0], KRDAloneMod0StrGadSIBuff, 1);
  1576.                     CollapseCtrl(&Key->Alone[1], KRDAloneMod1StrGadSIBuff, 1);
  1577.                     CollapseCtrl(&Key->Alone[2], KRDAloneMod2StrGadSIBuff, 1);
  1578.                     CollapseCtrl(&Key->Alone[3], KRDAloneMod3StrGadSIBuff, 1);
  1579.                     CollapseCtrl(&Key->Alone[4], KRDAloneMod4StrGadSIBuff, 1);
  1580.                     CollapseCtrl(&Key->Alone[5], KRDAloneMod5StrGadSIBuff, 1);
  1581.                     break;
  1582.                 case DPF_DEAD:
  1583.                     Key->AloneLen = 1;
  1584.                     if (KRDAloneAcc1Gadget.Flags & SELECTED)
  1585.                         Key->Alone[0] = 1;
  1586.                     else if (KRDAloneAcc2Gadget.Flags & SELECTED)
  1587.                         Key->Alone[0] = 2;
  1588.                     else if (KRDAloneAcc3Gadget.Flags & SELECTED)
  1589.                         Key->Alone[0] = 3;
  1590.                     else if (KRDAloneAcc4Gadget.Flags & SELECTED)
  1591.                         Key->Alone[0] = 4;
  1592.                     else
  1593.                         Key->Alone[0] = 5;
  1594.                     Key->Alone[1] = '\x00';
  1595.             } /* switch */
  1596.             switch (Key->ShiftOpt) {
  1597.                 case KC_NOQUAL:
  1598.                     Key->ShiftLen = CollapseCtrl(Key->Shift, KRDShiftNormalStrGadSIBuff, 1);
  1599.                     break;
  1600.                 case DPF_MOD:
  1601.                     Key->ShiftLen = 6;
  1602.                     CollapseCtrl(&Key->Shift[0], KRDShiftMod0StrGadSIBuff, 1);
  1603.                     CollapseCtrl(&Key->Shift[1], KRDShiftMod1StrGadSIBuff, 1);
  1604.                     CollapseCtrl(&Key->Shift[2], KRDShiftMod2StrGadSIBuff, 1);
  1605.                     CollapseCtrl(&Key->Shift[3], KRDShiftMod3StrGadSIBuff, 1);
  1606.                     CollapseCtrl(&Key->Shift[4], KRDShiftMod4StrGadSIBuff, 1);
  1607.                     CollapseCtrl(&Key->Shift[5], KRDShiftMod5StrGadSIBuff, 1);
  1608.                     break;
  1609.                 case DPF_DEAD:
  1610.                     Key->ShiftLen = 1;
  1611.                     if (KRDShiftAcc1Gadget.Flags & SELECTED)
  1612.                         Key->Shift[0] = 1;
  1613.                     else if (KRDShiftAcc2Gadget.Flags & SELECTED)
  1614.                         Key->Shift[0] = 2;
  1615.                     else if (KRDShiftAcc3Gadget.Flags & SELECTED)
  1616.                         Key->Shift[0] = 3;
  1617.                     else if (KRDShiftAcc4Gadget.Flags & SELECTED)
  1618.                         Key->Shift[0] = 4;
  1619.                     else
  1620.                         Key->Shift[0] = 5;
  1621.                     Key->Shift[1] = '\x00';
  1622.             } /* switch */
  1623.             switch (Key->AltOpt) {
  1624.                 case KC_NOQUAL:
  1625.                     Key->AltLen = CollapseCtrl(Key->Alt, KRDAltNormalStrGadSIBuff, 1);
  1626.                     break;
  1627.                 case DPF_MOD:
  1628.                     Key->AltLen = 6;
  1629.                     CollapseCtrl(&Key->Alt[0], KRDAltMod0StrGadSIBuff, 1);
  1630.                     CollapseCtrl(&Key->Alt[1], KRDAltMod1StrGadSIBuff, 1);
  1631.                     CollapseCtrl(&Key->Alt[2], KRDAltMod2StrGadSIBuff, 1);
  1632.                     CollapseCtrl(&Key->Alt[3], KRDAltMod3StrGadSIBuff, 1);
  1633.                     CollapseCtrl(&Key->Alt[4], KRDAltMod4StrGadSIBuff, 1);
  1634.                     CollapseCtrl(&Key->Alt[5], KRDAltMod5StrGadSIBuff, 1);
  1635.                     break;
  1636.                 case DPF_DEAD:
  1637.                     Key->AltLen = 1;
  1638.                     if (KRDAltAcc1Gadget.Flags & SELECTED)
  1639.                         Key->Alt[0] = 1;
  1640.                     else if (KRDAltAcc2Gadget.Flags & SELECTED)
  1641.                         Key->Alt[0] = 2;
  1642.                     else if (KRDAltAcc3Gadget.Flags & SELECTED)
  1643.                         Key->Alt[0] = 3;
  1644.                     else if (KRDAltAcc4Gadget.Flags & SELECTED)
  1645.                         Key->Alt[0] = 4;
  1646.                     else
  1647.                         Key->Alt[0] = 5;
  1648.                     Key->Alt[1] = '\x00';
  1649.             } /* switch */
  1650.             switch (Key->ShiftAltOpt) {
  1651.                 case KC_NOQUAL:
  1652.                     Key->ShiftAltLen = CollapseCtrl(Key->ShiftAlt, KRDShiftAltNormalStrGadSIBuff, 1);
  1653.                     break;
  1654.                 case DPF_MOD:
  1655.                     Key->ShiftAltLen = 6;
  1656.                     CollapseCtrl(&Key->ShiftAlt[0], KRDShiftAltMod0StrGadSIBuff, 1);
  1657.                     CollapseCtrl(&Key->ShiftAlt[1], KRDShiftAltMod1StrGadSIBuff, 1);
  1658.                     CollapseCtrl(&Key->ShiftAlt[2], KRDShiftAltMod2StrGadSIBuff, 1);
  1659.                     CollapseCtrl(&Key->ShiftAlt[3], KRDShiftAltMod3StrGadSIBuff, 1);
  1660.                     CollapseCtrl(&Key->ShiftAlt[4], KRDShiftAltMod4StrGadSIBuff, 1);
  1661.                     CollapseCtrl(&Key->ShiftAlt[5], KRDShiftAltMod5StrGadSIBuff, 1);
  1662.                     break;
  1663.                 case DPF_DEAD:
  1664.                     Key->ShiftAltLen = 1;
  1665.                     if (KRDShiftAltAcc1Gadget.Flags & SELECTED)
  1666.                         Key->ShiftAlt[0] = 1;
  1667.                     else if (KRDShiftAltAcc2Gadget.Flags & SELECTED)
  1668.                         Key->ShiftAlt[0] = 2;
  1669.                     else if (KRDShiftAltAcc3Gadget.Flags & SELECTED)
  1670.                         Key->ShiftAlt[0] = 3;
  1671.                     else if (KRDShiftAltAcc4Gadget.Flags & SELECTED)
  1672.                         Key->ShiftAlt[0] = 4;
  1673.                     else
  1674.                         Key->ShiftAlt[0] = 5;
  1675.                     Key->ShiftAlt[1] = '\x00';
  1676.             } /* switch */
  1677.             switch (Key->CtrlOpt) {
  1678.                 case KC_NOQUAL:
  1679.                     Key->CtrlLen = CollapseCtrl(Key->Ctrl, KRDCtrlNormalStrGadSIBuff, 1);
  1680.                     break;
  1681.                 case DPF_MOD:
  1682.                     Key->CtrlLen = 6;
  1683.                     CollapseCtrl(&Key->Ctrl[0], KRDCtrlMod0StrGadSIBuff, 1);
  1684.                     CollapseCtrl(&Key->Ctrl[1], KRDCtrlMod1StrGadSIBuff, 1);
  1685.                     CollapseCtrl(&Key->Ctrl[2], KRDCtrlMod2StrGadSIBuff, 1);
  1686.                     CollapseCtrl(&Key->Ctrl[3], KRDCtrlMod3StrGadSIBuff, 1);
  1687.                     CollapseCtrl(&Key->Ctrl[4], KRDCtrlMod4StrGadSIBuff, 1);
  1688.                     CollapseCtrl(&Key->Ctrl[5], KRDCtrlMod5StrGadSIBuff, 1);
  1689.                     break;
  1690.                 case DPF_DEAD:
  1691.                     Key->CtrlLen = 1;
  1692.                     if (KRDCtrlAcc1Gadget.Flags & SELECTED)
  1693.                         Key->Ctrl[0] = 1;
  1694.                     else if (KRDCtrlAcc2Gadget.Flags & SELECTED)
  1695.                         Key->Ctrl[0] = 2;
  1696.                     else if (KRDCtrlAcc3Gadget.Flags & SELECTED)
  1697.                         Key->Ctrl[0] = 3;
  1698.                     else if (KRDCtrlAcc4Gadget.Flags & SELECTED)
  1699.                         Key->Ctrl[0] = 4;
  1700.                     else
  1701.                         Key->Ctrl[0] = 5;
  1702.                     Key->Ctrl[1] = '\x00';
  1703.             } /* switch */
  1704.             switch (Key->CtrlShiftOpt) {
  1705.                 case KC_NOQUAL:
  1706.                     Key->CtrlShiftLen = CollapseCtrl(Key->CtrlShift, KRDCtrlShiftNormalStrGadSIBuff, 1);
  1707.                     break;
  1708.                 case DPF_MOD:
  1709.                     Key->CtrlShiftLen = 6;
  1710.                     CollapseCtrl(&Key->CtrlShift[0], KRDCtrlShiftMod0StrGadSIBuff, 1);
  1711.                     CollapseCtrl(&Key->CtrlShift[1], KRDCtrlShiftMod1StrGadSIBuff, 1);
  1712.                     CollapseCtrl(&Key->CtrlShift[2], KRDCtrlShiftMod2StrGadSIBuff, 1);
  1713.                     CollapseCtrl(&Key->CtrlShift[3], KRDCtrlShiftMod3StrGadSIBuff, 1);
  1714.                     CollapseCtrl(&Key->CtrlShift[4], KRDCtrlShiftMod4StrGadSIBuff, 1);
  1715.                     CollapseCtrl(&Key->CtrlShift[5], KRDCtrlShiftMod5StrGadSIBuff, 1);
  1716.                     break;
  1717.                 case DPF_DEAD:
  1718.                     Key->CtrlShiftLen = 1;
  1719.                     if (KRDCtrlShiftAcc1Gadget.Flags & SELECTED)
  1720.                         Key->CtrlShift[0] = 1;
  1721.                     else if (KRDCtrlShiftAcc2Gadget.Flags & SELECTED)
  1722.                         Key->CtrlShift[0] = 2;
  1723.                     else if (KRDCtrlShiftAcc3Gadget.Flags & SELECTED)
  1724.                         Key->CtrlShift[0] = 3;
  1725.                     else if (KRDCtrlShiftAcc4Gadget.Flags & SELECTED)
  1726.                         Key->CtrlShift[0] = 4;
  1727.                     else
  1728.                         Key->CtrlShift[0] = 5;
  1729.                     Key->CtrlShift[1] = '\x00';
  1730.             } /* switch */
  1731.             switch (Key->CtrlAltOpt) {
  1732.                 case KC_NOQUAL:
  1733.                     Key->CtrlAltLen = CollapseCtrl(Key->CtrlAlt, KRDCtrlAltNormalStrGadSIBuff, 1);
  1734.                     break;
  1735.                 case DPF_MOD:
  1736.                     Key->CtrlAltLen = 6;
  1737.                     CollapseCtrl(&Key->CtrlAlt[0], KRDCtrlAltMod0StrGadSIBuff, 1);
  1738.                     CollapseCtrl(&Key->CtrlAlt[1], KRDCtrlAltMod1StrGadSIBuff, 1);
  1739.                     CollapseCtrl(&Key->CtrlAlt[2], KRDCtrlAltMod2StrGadSIBuff, 1);
  1740.                     CollapseCtrl(&Key->CtrlAlt[3], KRDCtrlAltMod3StrGadSIBuff, 1);
  1741.                     CollapseCtrl(&Key->CtrlAlt[4], KRDCtrlAltMod4StrGadSIBuff, 1);
  1742.                     CollapseCtrl(&Key->CtrlAlt[5], KRDCtrlAltMod5StrGadSIBuff, 1);
  1743.                     break;
  1744.                 case DPF_DEAD:
  1745.                     Key->CtrlAltLen = 1;
  1746.                     if (KRDCtrlAltAcc1Gadget.Flags & SELECTED)
  1747.                         Key->CtrlAlt[0] = 1;
  1748.                     else if (KRDCtrlAltAcc2Gadget.Flags & SELECTED)
  1749.                         Key->CtrlAlt[0] = 2;
  1750.                     else if (KRDCtrlAltAcc3Gadget.Flags & SELECTED)
  1751.                         Key->CtrlAlt[0] = 3;
  1752.                     else if (KRDCtrlAltAcc4Gadget.Flags & SELECTED)
  1753.                         Key->CtrlAlt[0] = 4;
  1754.                     else
  1755.                         Key->CtrlAlt[0] = 5;
  1756.                     Key->CtrlAlt[1] = '\x00';
  1757.             } /* switch */
  1758.             switch (Key->VanillaOpt) {
  1759.                 case KC_NOQUAL:
  1760.                     Key->VanillaLen = CollapseCtrl(Key->Vanilla, KRDVanillaNormalStrGadSIBuff, 1);
  1761.                     break;
  1762.                 case DPF_MOD:
  1763.                     Key->VanillaLen = 6;
  1764.                     CollapseCtrl(&Key->Vanilla[0], KRDVanillaMod0StrGadSIBuff, 1);
  1765.                     CollapseCtrl(&Key->Vanilla[1], KRDVanillaMod1StrGadSIBuff, 1);
  1766.                     CollapseCtrl(&Key->Vanilla[2], KRDVanillaMod2StrGadSIBuff, 1);
  1767.                     CollapseCtrl(&Key->Vanilla[3], KRDVanillaMod3StrGadSIBuff, 1);
  1768.                     CollapseCtrl(&Key->Vanilla[4], KRDVanillaMod4StrGadSIBuff, 1);
  1769.                     CollapseCtrl(&Key->Vanilla[5], KRDVanillaMod5StrGadSIBuff, 1);
  1770.                     break;
  1771.                 case DPF_DEAD:
  1772.                     Key->VanillaLen = 1;
  1773.                     if (KRDVanillaAcc1Gadget.Flags & SELECTED)
  1774.                         Key->Vanilla[0] = 1;
  1775.                     else if (KRDVanillaAcc2Gadget.Flags & SELECTED)
  1776.                         Key->Vanilla[0] = 2;
  1777.                     else if (KRDVanillaAcc3Gadget.Flags & SELECTED)
  1778.                         Key->Vanilla[0] = 3;
  1779.                     else if (KRDVanillaAcc4Gadget.Flags & SELECTED)
  1780.                         Key->Vanilla[0] = 4;
  1781.                     else
  1782.                         Key->Vanilla[0] = 5;
  1783.                     Key->Vanilla[1] = '\x00';
  1784.             } /* switch */
  1785.             break;
  1786.         case KCF_NOP:
  1787.             break;
  1788.     } /* switch */
  1789. }
  1790.  
  1791. /*
  1792.  * Update Key Map
  1793.  */
  1794. void UpdateKeyMap(Key, KeyCode)
  1795. struct KeyNode *Key;
  1796. USHORT KeyCode;
  1797. {
  1798.     struct HalfKeyMap *HalfKeyMap;
  1799.     ULONG    KeyMapVal;
  1800.     UBYTE    *KeyMapPtr;
  1801.     UBYTE    buff[256];
  1802.     UBYTE    len, offsets;
  1803.  
  1804.     if (KeyCode < 0x40)
  1805.         HalfKeyMap = (struct HalfKeyMap *)&KeyMapNode->kn_KeyMap;
  1806.     else {
  1807.         HalfKeyMap = (struct HalfKeyMap *)&KeyMapNode->kn_KeyMap.km_HiKeyMapTypes;
  1808.         KeyCode -= 0x40;
  1809.     }
  1810.     switch (HalfKeyMap->KeyMapTypes[KeyCode] & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
  1811.         case KC_NOQUAL:
  1812.             HalfKeyMap->KeyMapTypes[KeyCode] = KCF_NOP;
  1813.             HalfKeyMap->KeyMap[KeyCode] = NULL;
  1814.             break;
  1815.         case KCF_STRING:
  1816.             len = StringKeyLength(HalfKeyMap, KeyCode, &offsets);
  1817.             FreeMem((char *)HalfKeyMap->KeyMap[KeyCode], len);
  1818.             HalfKeyMap->KeyMapTypes[KeyCode] = KCF_NOP;
  1819.             HalfKeyMap->KeyMap[KeyCode] = NULL;
  1820.             break;
  1821.         case KCF_DEAD:
  1822.             len = DeadKeyLength(HalfKeyMap, KeyCode, &offsets);
  1823.             FreeMem((char *)HalfKeyMap->KeyMap[KeyCode], len);
  1824.             HalfKeyMap->KeyMapTypes[KeyCode] = KCF_NOP;
  1825.             HalfKeyMap->KeyMap[KeyCode] = NULL;
  1826.             break;
  1827.     } /* switch */
  1828.     switch (Key->Type & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
  1829.         case KC_NOQUAL:
  1830.             KeyMapVal = Key->Alone[0];
  1831.             if (Key->Type & KCF_SHIFT)
  1832.                 KeyMapVal |= Key->Shift[0]<<8;
  1833.             else if (Key->Type & KCF_ALT)
  1834.                 KeyMapVal |= Key->Alt[0]<<8;
  1835.             else if (Key->Type & KCF_CONTROL)
  1836.                 KeyMapVal |= Key->Ctrl[0]<<8;
  1837.             if ((Key->Type & KCF_ALT) && (Key->Type & KCF_SHIFT))
  1838.                 KeyMapVal |= Key->Alt[0]<<16;
  1839.             else if ((Key->Type & KCF_CONTROL) && (Key->Type & (KCF_SHIFT|KCF_ALT)))
  1840.                 KeyMapVal |= Key->Ctrl[0]<<16;
  1841.             if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
  1842.                 KeyMapVal |= Key->ShiftAlt[0]<<24;
  1843.             else if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
  1844.                 KeyMapVal |= Key->CtrlShift[0]<<24;
  1845.             else if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
  1846.                 KeyMapVal |= Key->CtrlAlt[0]<<24;
  1847.             break;
  1848.         case KCF_STRING:
  1849.             buff[len = 0] = Key->AloneLen;
  1850.             if (Key->Type & KCF_SHIFT)
  1851.                 buff[len += 2] = Key->ShiftLen;
  1852.             if (Key->Type & KCF_ALT)
  1853.                 buff[len += 2] = Key->AltLen;
  1854.             if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
  1855.                 buff[len += 2] = Key->ShiftAltLen;
  1856.             if (Key->Type & KCF_CONTROL)
  1857.                 buff[len += 2] = Key->CtrlLen;
  1858.             if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
  1859.                 buff[len += 2] = Key->CtrlShiftLen;
  1860.             if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
  1861.                 buff[len += 2] = Key->CtrlAltLen;
  1862.             if ((Key->Type & KC_VANILLA) == KC_VANILLA)
  1863.                 buff[len += 2] = Key->VanillaLen;
  1864.             memcpy(&buff[len += 2], Key->Alone, Key->AloneLen);
  1865.             buff[offsets = 1] = len;
  1866.             len += Key->AloneLen;
  1867.             if (Key->Type & KCF_SHIFT) {
  1868.                 memcpy(&buff[len], Key->Shift, Key->ShiftLen);
  1869.                 buff[offsets += 2] = len;
  1870.                 len += Key->ShiftLen;
  1871.             }
  1872.             if (Key->Type & KCF_ALT) {
  1873.                 memcpy(&buff[len], Key->Alt, Key->AltLen);
  1874.                 buff[offsets += 2] = len;
  1875.                 len += Key->AltLen;
  1876.             }
  1877.             if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT)) {
  1878.                 memcpy(&buff[len], Key->ShiftAlt, Key->ShiftAltLen);
  1879.                 buff[offsets += 2] = len;
  1880.                 len += Key->ShiftAltLen;
  1881.             }
  1882.             if (Key->Type & KCF_CONTROL) {
  1883.                 memcpy(&buff[len], Key->Ctrl, Key->CtrlLen);
  1884.                 buff[offsets += 2] = len;
  1885.                 len += Key->CtrlLen;
  1886.             }
  1887.             if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT)) {
  1888.                 memcpy(&buff[len], Key->CtrlShift, Key->CtrlShiftLen);
  1889.                 buff[offsets += 2] = len;
  1890.                 len += Key->CtrlShiftLen;
  1891.             }
  1892.             if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT)) {
  1893.                 memcpy(&buff[len], Key->CtrlAlt, Key->CtrlAltLen);
  1894.                 buff[offsets += 2] = len;
  1895.                 len += Key->CtrlAltLen;
  1896.             }
  1897.             if ((Key->Type & KC_VANILLA) == KC_VANILLA) {
  1898.                 memcpy(&buff[len], Key->Vanilla, Key->VanillaLen);
  1899.                 buff[offsets += 2] = len;
  1900.                 len += Key->VanillaLen;
  1901.             }
  1902.             break;
  1903.         case KCF_DEAD:
  1904.             buff[len = 0] = Key->AloneOpt;
  1905.             if (Key->Type & KCF_SHIFT)
  1906.                 buff[len += 2] = Key->ShiftOpt;
  1907.             if (Key->Type & KCF_ALT)
  1908.                 buff[len += 2] = Key->AltOpt;
  1909.             if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
  1910.                 buff[len += 2] = Key->ShiftAltOpt;
  1911.             if (Key->Type & KCF_CONTROL)
  1912.                 buff[len += 2] = Key->CtrlOpt;
  1913.             if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
  1914.                 buff[len += 2] = Key->CtrlShiftOpt;
  1915.             if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
  1916.                 buff[len += 2] = Key->CtrlAltOpt;
  1917.             if ((Key->Type & KC_VANILLA) == KC_VANILLA)
  1918.                 buff[len += 2] = Key->VanillaOpt;
  1919.             len += 2;
  1920.             switch (Key->AloneOpt) {
  1921.                 case KC_NOQUAL:
  1922.                 case DPF_DEAD:
  1923.                     buff[offsets = 1] = Key->Alone[0];
  1924.                     break;
  1925.                 case DPF_MOD:
  1926.                     memcpy(&buff[len], Key->Alone, 6);
  1927.                     buff[offsets = 1] = len;
  1928.                     len += 6;
  1929.             } /* switch */
  1930.             if (Key->Type & KCF_SHIFT)
  1931.                 switch (Key->ShiftOpt) {
  1932.                     case KC_NOQUAL:
  1933.                     case DPF_DEAD:
  1934.                         buff[offsets += 2] = Key->Shift[0];
  1935.                         break;
  1936.                     case DPF_MOD:
  1937.                         memcpy(&buff[len], Key->Shift, 6);
  1938.                         buff[offsets += 2] = len;
  1939.                         len += 6;
  1940.                 } /* switch */
  1941.             if (Key->Type & KCF_ALT)
  1942.                 switch (Key->AltOpt) {
  1943.                     case KC_NOQUAL:
  1944.                     case DPF_DEAD:
  1945.                         buff[offsets += 2] = Key->Alt[0];
  1946.                         break;
  1947.                     case DPF_MOD:
  1948.                         memcpy(&buff[len], Key->Alt, 6);
  1949.                         buff[offsets += 2] = len;
  1950.                         len += 6;
  1951.                 } /* switch */
  1952.             if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
  1953.                 switch (Key->ShiftAltOpt) {
  1954.                     case KC_NOQUAL:
  1955.                     case DPF_DEAD:
  1956.                         buff[offsets += 2] = Key->ShiftAlt[0];
  1957.                         break;
  1958.                     case DPF_MOD:
  1959.                         memcpy(&buff[len], Key->ShiftAlt, 6);
  1960.                         buff[offsets += 2] = len;
  1961.                         len += 6;
  1962.                 } /* switch */
  1963.             if (Key->Type & KCF_CONTROL)
  1964.                 switch (Key->CtrlOpt) {
  1965.                     case KC_NOQUAL:
  1966.                     case DPF_DEAD:
  1967.                         buff[offsets += 2] = Key->Ctrl[0];
  1968.                         break;
  1969.                     case DPF_MOD:
  1970.                         memcpy(&buff[len], Key->Ctrl, 6);
  1971.                         buff[offsets += 2] = len;
  1972.                         len += 6;
  1973.                 } /* switch */
  1974.             if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
  1975.                 switch (Key->CtrlShiftOpt) {
  1976.                     case KC_NOQUAL:
  1977.                     case DPF_DEAD:
  1978.                         buff[offsets += 2] = Key->CtrlShift[0];
  1979.                         break;
  1980.                     case DPF_MOD:
  1981.                         memcpy(&buff[len], Key->CtrlShift, 6);
  1982.                         buff[offsets += 2] = len;
  1983.                         len += 6;
  1984.                 } /* switch */
  1985.             if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
  1986.                 switch (Key->CtrlAltOpt) {
  1987.                     case KC_NOQUAL:
  1988.                     case DPF_DEAD:
  1989.                         buff[offsets += 2] = Key->CtrlAlt[0];
  1990.                         break;
  1991.                     case DPF_MOD:
  1992.                         memcpy(&buff[len], Key->CtrlAlt, 6);
  1993.                         buff[offsets += 2] = len;
  1994.                         len += 6;
  1995.                 } /* switch */
  1996.             if ((Key->Type & KC_VANILLA) == KC_VANILLA)
  1997.                 switch (Key->VanillaOpt) {
  1998.                     case KC_NOQUAL:
  1999.                     case DPF_DEAD:
  2000.                         buff[offsets += 2] = Key->Vanilla[0];
  2001.                         break;
  2002.                     case DPF_MOD:
  2003.                         memcpy(&buff[len], Key->Vanilla, 6);
  2004.                         buff[offsets += 2] = len;
  2005.                         len += 6;
  2006.                 } /* switch */
  2007.             break;
  2008.         case KCF_NOP:
  2009.             KeyMapVal = NULL;
  2010.     } /* switch */
  2011.     if (Key->Type & (KCF_STRING|KCF_DEAD)) {
  2012.         if ((KeyMapPtr = (char *)AllocMem(len, MEMF_CLEAR)) != NULL)
  2013.             memcpy(KeyMapPtr, buff, len);
  2014.         else {
  2015.             Write(Output(), "Memory Allocation Failed, UpdateKeyMap\n", 39);
  2016.             Key->Type = KCF_NOP;
  2017.             HalfKeyMap->KeyMap[KeyCode] = NULL;
  2018.         }
  2019.         HalfKeyMap->KeyMap[KeyCode] = (ULONG)KeyMapPtr;
  2020.     }
  2021.     else
  2022.         HalfKeyMap->KeyMap[KeyCode] = KeyMapVal;
  2023.     HalfKeyMap->KeyMapTypes[KeyCode] = Key->Type;
  2024.     if (Key->Capsable)
  2025.         HalfKeyMap->Capsable[KeyCode/8] |= (1<<(KeyCode % 8));
  2026.     else
  2027.         HalfKeyMap->Capsable[KeyCode/8] &= ~(1<<(KeyCode % 8));
  2028.     if (Key->Repeatable)
  2029.         HalfKeyMap->Repeatable[KeyCode/8] |= (1<<(KeyCode % 8));
  2030.     else
  2031.         HalfKeyMap->Repeatable[KeyCode/8] &= ~(1<<(KeyCode % 8));
  2032. }
  2033.  
  2034. /*
  2035.  * Expand Control Characters
  2036.  */
  2037. int ExpandCtrl(to, from, len)
  2038. unsigned char *to;
  2039. unsigned char *from;
  2040. int len;
  2041. {
  2042.     int    reslen = 0;
  2043.     int    count;
  2044.  
  2045.     for (count = 0; count < len; count++)
  2046.         if ((from[count] > '\x20') && (from[count] < '\x7F') && (from[count] != '\\'))
  2047.             to[reslen++] = from[count];
  2048.         else
  2049.             switch (from[count]) {
  2050.                 case '\n':
  2051.                     to[reslen++] = '\\';
  2052.                     to[reslen++] = 'n';
  2053.                     break;
  2054.                 case '\t':
  2055.                     to[reslen++] = '\\';
  2056.                     to[reslen++] = 't';
  2057.                     break;
  2058.                 case '\v':
  2059.                     to[reslen++] = '\\';
  2060.                     to[reslen++] = 'v';
  2061.                     break;
  2062.                 case '\b':
  2063.                     to[reslen++] = '\\';
  2064.                     to[reslen++] = 'b';
  2065.                     break;
  2066.                 case '\r':
  2067.                     to[reslen++] = '\\';
  2068.                     to[reslen++] = 'r';
  2069.                     break;
  2070.                 case '\f':
  2071.                     to[reslen++] = '\\';
  2072.                     to[reslen++] = 'f';
  2073.                     break;
  2074.                 case '\\':
  2075.                     to[reslen++] = '\\';
  2076.                     to[reslen++] = '\\';
  2077.                     break;
  2078.                 default:
  2079.                     to[reslen++] = '\\';
  2080.                     to[reslen++] = 'x';
  2081.                     if (from[count] < 0x10)
  2082.                         to[reslen++] = '0';
  2083.                     reslen += stci_h(&to[reslen], from[count]);
  2084.             } /* switch */
  2085.     to[reslen] = '\x00';
  2086.     return(reslen-1);
  2087. }
  2088.  
  2089. /*
  2090.  * Collapse Ctrl
  2091.  */
  2092. int CollapseCtrl(to, from, maxlen)
  2093. char *to;
  2094. char *from;
  2095. int maxlen;
  2096. {
  2097.     int    reslen = 0;
  2098.     int    count, offset, num;
  2099.     char    digit;
  2100.  
  2101.     for (count = 0; from[count] && (reslen < maxlen);)
  2102.         if (from[count] != '\\')
  2103.             to[reslen++] = from[count++];
  2104.         else {
  2105.             offset = 1;
  2106.             switch (from[count+1]) {
  2107.                 case 'N':
  2108.                 case 'n':
  2109.                     to[reslen++] = '\n';
  2110.                     break;
  2111.                 case 'T':
  2112.                 case 't':
  2113.                     to[reslen++] = '\t';
  2114.                     break;
  2115.                 case 'V':
  2116.                 case 'v':
  2117.                     to[reslen++] = '\v';
  2118.                     break;
  2119.                 case 'B':
  2120.                 case 'b':
  2121.                     to[reslen++] = '\b';
  2122.                     break;
  2123.                 case 'R':
  2124.                 case 'r':
  2125.                     to[reslen++] = '\r';
  2126.                     break;
  2127.                 case 'F':
  2128.                 case 'f':
  2129.                     to[reslen++] = '\f';
  2130.                     break;
  2131.                 case '\\':
  2132.                     to[reslen++] = '\\';
  2133.                     break;
  2134.                 case 'X':
  2135.                 case 'x':
  2136.                     num = 0;
  2137.                     for (offset++; ((offset < 4) && (digit = tolower(from[count+offset])) && (isxdigit(digit))); offset++)
  2138.                         if (isdigit(digit))
  2139.                             num = (num<<4) | (digit-0x30);
  2140.                         else
  2141.                             num = (num<<4) | (tolower(digit)-0x57);
  2142.                     to[reslen++] = num;
  2143.                     break;
  2144.                 default:
  2145.                     num = 0;
  2146.                     for (;((offset < 4) && (digit = from[count+offset]) && ((digit >= '0') && (digit <= '7'))); offset++)
  2147.                         num = (num<<3) | (digit - 0x30);
  2148.                     to[reslen++] = num;
  2149.             } /* switch */
  2150.             if (offset > 3)
  2151.                 offset -= 1;
  2152.             count += (1 + offset);
  2153.         }
  2154.     return(reslen);        
  2155. }
  2156.