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_UpdateDisplay.c < prev    next >
C/C++ Source or Header  |  1989-03-13  |  20KB  |  811 lines
  1. /*
  2.  * Key Map Editor ver 1.0
  3.  * Update Display
  4.  *
  5.  * parameters:    GadgetList - pointer to linked list of Gadgets to update
  6.  *        KeyMapNode - KeyMapNode pointer
  7.  *        Option     - Update Options (TRUE = all keys, FALSE = 1 key)
  8.  *
  9.  * by: Tim Friest
  10.  * on: January 2, 1989
  11.  */
  12.  
  13. #include "KME_Includes.h"
  14. #include "KME_Protos.h"
  15. #include "KME_Defs.h"
  16. #include "KME_Globals.h"
  17.  
  18. extern char GetKeyVal(UBYTE, ULONG, int);
  19. extern int GetKeyStr(char *, UBYTE, UBYTE *, int);
  20. extern char GetKeyDead(UBYTE, UBYTE *, int, UBYTE *);
  21.  
  22. extern struct Gadget    CloseBracketGadget;
  23.  
  24. void UpdateDisplay(Gadget, KeyMapNode, UpdateAll)
  25. struct Gadget *Gadget;
  26. struct KeyMapNode *KeyMapNode;
  27. int UpdateAll;
  28. {
  29.     struct    Gadget *Gad;
  30.     USHORT    KeyCode;
  31.     struct    KeyMap    *KeyMap;
  32.     struct    HalfKeyMap *HalfKeyMap;
  33.     int    Capsable;
  34.     static char    buff[256];
  35.     static struct    IntuiText    buffIText = {
  36.         1, 0, JAM1, 0, 0, NULL, buff, NULL
  37.     };
  38.     int    len;
  39.     UBYTE    color;
  40.     struct    IntuiText    *IntuiText;
  41.     int    GadWidth;
  42.  
  43.     KeyMap = &KeyMapNode->kn_KeyMap;
  44.     Gad = Gadget;
  45.     KeyCode = Gad->GadgetID;
  46.     do {
  47.         if (KeyCode < 0x40)
  48.             HalfKeyMap = (struct HalfKeyMap *)KeyMap;
  49.         else {
  50.             HalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
  51.             KeyCode -= 0x40;
  52.         }
  53.         len = 0;
  54.         color = 1;
  55.         Capsable = HalfKeyMap->Capsable[(KeyCode/8)] & (1<<(KeyCode % 8));
  56.         switch (HalfKeyMap->KeyMapTypes[KeyCode] & (KCF_DEAD|KCF_STRING|KCF_NOP)) {
  57.             case KC_NOQUAL:
  58.                 buff[0] = GetKeyVal(
  59.                     HalfKeyMap->KeyMapTypes[KeyCode], 
  60.                     HalfKeyMap->KeyMap[KeyCode],
  61.                     Capsable);
  62.                 buff[1] = '\x00';
  63.                 len = 2;
  64.                 break;
  65.             case KCF_STRING:
  66.                 len = GetKeyStr(buff,
  67.                     HalfKeyMap->KeyMapTypes[KeyCode], 
  68.                     (UBYTE *)HalfKeyMap->KeyMap[KeyCode],
  69.                     Capsable);
  70.                 break;
  71.             case KCF_DEAD:
  72.                 buff[0] = GetKeyDead(
  73.                     HalfKeyMap->KeyMapTypes[KeyCode],
  74.                     (UBYTE *)HalfKeyMap->KeyMap[KeyCode],
  75.                     Capsable, &color);
  76.                 buff[1] = '\x00';
  77.                 len = 2;
  78.                 break;
  79.             case KCF_NOP:
  80.             default:
  81.                 len = 0;
  82.         } /* switch */
  83.         if (len > 0) {
  84.             GadWidth = Gad->Width;
  85.             if (Gad->Activation & BOOLEXTEND)
  86.                 GadWidth -= 22;
  87.             while ((len > 0) && (IntuiTextLength(&buffIText) > GadWidth))
  88.                 buff[--len] = '\x00';
  89.             if (Gad->GadgetText == NULL) {
  90.                 IntuiText = (struct IntuiText *)AllocMem(sizeof(struct IntuiText), MEMF_CLEAR);
  91.                 if (IntuiText != NULL) {
  92.                     IntuiText->IText = (UBYTE *)AllocMem(len, 0);
  93.                     IntuiText->FrontPen = 1;
  94.                     IntuiText->BackPen = 0;
  95.                     IntuiText->DrawMode = JAM2;
  96.                 }
  97.             }
  98.             else {
  99.                 IntuiText = Gad->GadgetText;
  100.                 if (IntuiText->IText == NULL)
  101.                     IntuiText->IText = (UBYTE *)AllocMem(len, 0);
  102.                 else
  103.                     if (strlen(IntuiText->IText) != len) {
  104.                         FreeMem(IntuiText->IText, strlen(IntuiText->IText)+1);
  105.                         IntuiText->IText = (UBYTE *)AllocMem(len, 0);
  106.                     }
  107.             }
  108.             if (IntuiText != NULL) {
  109.                 if (IntuiText->IText != NULL) {
  110.                     if (buff[0] != '\x00') {
  111.                         strcpy(IntuiText->IText, buff);
  112.                         IntuiText->FrontPen = color;
  113.                         IntuiText->BackPen = 0;
  114.                     }
  115.                     else {
  116.                         IntuiText->IText[0] = '@';
  117.                         IntuiText->IText[1] = '\x00';
  118.                         IntuiText->FrontPen = 0;
  119.                         IntuiText->BackPen = 1;
  120.                     }
  121.                     if (buff[0] == ' ')
  122.                         IntuiText->BackPen = 1;
  123.                     IntuiText->LeftEdge = (GadWidth - IntuiTextLength(IntuiText))/2;
  124.                     if (Gad->Activation & BOOLEXTEND)
  125.                         IntuiText->LeftEdge += 22;
  126.                     Gad->GadgetText = IntuiText;
  127.                     FlagResource(RF_GadgetText);
  128.                 }
  129.                 else {
  130.                     FreeMem(IntuiText, sizeof(struct IntuiText));
  131.                     Gad->GadgetText = NULL;
  132.                 }
  133.             }
  134.         }
  135.         else
  136.             if (Gad->GadgetText != NULL)
  137.                 if (Gad->GadgetText->IText != NULL) {
  138.                     FreeMem(Gad->GadgetText->IText, strlen(Gad->GadgetText->IText)+1);
  139.                     Gad->GadgetText->IText = NULL;
  140.                 }
  141.     } while ((Gad = Gad->NextGadget) && ((KeyCode = Gad->GadgetID) < 0x60) && UpdateAll);
  142.     if (CheckResource(RF_Window))
  143.         if (UpdateAll)
  144.             RefreshGList(GadgetList, KeyMapEdWindow, NULL, DefinableKeys);
  145.         else {
  146.             RefreshGList(Gadget, KeyMapEdWindow, NULL, 1);
  147.             if (Gadget->GadgetType == BOOLGADGET) /* kludge to fix return key overwriting this gadget */
  148.                 RefreshGList(&CloseBracketGadget, KeyMapEdWindow, NULL, 1);
  149.         }
  150. }
  151.  
  152. /*
  153.  * Get Key Value
  154.  *
  155.  * parameters:     KeyType - Key Type Flags
  156.  *        KeyMap  - Longword Key Map Value
  157.  *        KeyCapsable - Is key Caps Lockable
  158.  * returns:    Key Value
  159.  */
  160. char GetKeyVal(KeyType, KeyMap, KeyCapsable)
  161. UBYTE    KeyType;
  162. ULONG    KeyMap;
  163. int    KeyCapsable;
  164. {
  165.     char KeyVal = '\x00';
  166.     ULONG    CurrentStatus;
  167.  
  168.     CurrentStatus = StatusFlags;
  169.     if (CheckFlag(SF_CapsLock))
  170.         if (KeyCapsable)
  171.             CurrentStatus |= SF_Shift;
  172.     
  173.     switch(KeyType & KC_VANILLA) {
  174.         case KC_NOQUAL:
  175.             KeyVal = KeyMap & 0x000000FF;
  176.             break;
  177.         case KCF_SHIFT:
  178.             if (!(CurrentStatus & SF_Shift))
  179.                 KeyVal = KeyMap & 0x000000FF;
  180.             else
  181.                 KeyVal = ((KeyMap & 0x0000FF00)>>8);
  182.             break;
  183.         case KCF_ALT:
  184.             if (!(CurrentStatus & SF_Alt))
  185.                 KeyVal = KeyMap & 0x000000FF;
  186.             else
  187.                 KeyVal = ((KeyMap & 0x0000FF00)>>8);
  188.             break;
  189.         case KCF_CONTROL:
  190.             if (!(CurrentStatus & SF_Control))
  191.                 KeyVal = KeyMap & 0x000000FF;
  192.             else
  193.                 KeyVal = ((KeyMap & 0x0000FF00)>>8);
  194.             break;
  195.         case KCF_ALT|KCF_SHIFT:
  196.             switch (CurrentStatus & (SF_Shift|SF_Alt)) {
  197.                 case 0:    /* Shift and Alt are not pressed */
  198.                     KeyVal = KeyMap & 0x000000FF;
  199.                     break;
  200.                 case SF_Shift:
  201.                     KeyVal = ((KeyMap & 0x0000FF00)>>8);
  202.                     break;
  203.                 case SF_Alt:
  204.                     KeyVal = ((KeyMap & 0x00FF0000)>>16);
  205.                     break;
  206.                 case SF_Shift|SF_Alt:
  207.                     KeyVal = ((KeyMap & 0xFF000000)>>24);
  208.             } /* switch */
  209.             break;
  210.         case KCF_CONTROL|KCF_SHIFT:
  211.             switch (CurrentStatus & (SF_Shift|SF_Control)) {
  212.                 case 0:    /* Shift and Control are not pressed */
  213.                     KeyVal = KeyMap & 0x000000FF;
  214.                     break;
  215.                 case SF_Shift:
  216.                     KeyVal = ((KeyMap & 0x0000FF00)>>8);
  217.                     break;
  218.                 case SF_Control:
  219.                     KeyVal = ((KeyMap & 0x00FF0000)>>16);
  220.                     break;
  221.                 case SF_Shift|SF_Control:
  222.                     KeyVal = ((KeyMap & 0xFF000000)>>24);
  223.             } /* switch */
  224.             break;
  225.         case KCF_CONTROL|KCF_ALT:
  226.             switch (CurrentStatus & (SF_Control|SF_Alt)) {
  227.                 case 0:    /* Control and Alt are not pressed */
  228.                     KeyVal = KeyMap & 0x000000FF;
  229.                     break;
  230.                 case SF_Alt:
  231.                     KeyVal = ((KeyMap & 0x0000FF00)>>8);
  232.                     break;
  233.                 case SF_Control:
  234.                     KeyVal = ((KeyMap & 0x00FF0000)>>16);
  235.                     break;
  236.                 case SF_Alt|SF_Control:
  237.                     KeyVal = ((KeyMap & 0xFF000000)>>24);
  238.             } /* switch */
  239.             break;
  240.         case KC_VANILLA:
  241.             switch (CurrentStatus & (SF_Shift|SF_Alt)) {
  242.                 case 0:    /* Shift and Alt are not pressed */
  243.                     KeyVal = KeyMap & 0x000000FF;
  244.                     break;
  245.                 case SF_Shift:
  246.                     KeyVal = ((KeyMap & 0x0000FF00)>>8);
  247.                     break;
  248.                 case SF_Alt:
  249.                     KeyVal = ((KeyMap & 0x00FF0000)>>16);
  250.                     break;
  251.                 case SF_Shift|SF_Alt:
  252.                     KeyVal = ((KeyMap & 0xFF000000)>>24);
  253.             } /* switch */
  254.             if (CurrentStatus & SF_Control)
  255.                 if ((KeyMap & 0x00000040) && (!((CurrentStatus & SF_Shift) && (KeyMap & 0x00000040))))
  256.                     KeyVal = KeyMap & 0x0000009F;
  257.                 else
  258.                     if (KeyMap & 0x00004000)
  259.                         KeyVal = ((KeyMap & 0x00009F00)>>8);
  260.     } /* switch */
  261.     return(KeyVal);
  262. }
  263.  
  264. /*
  265.  * Get Key String
  266.  *
  267.  * parameters:     KeyStr - String to receive key's string
  268.  *        KeyType - Key Type Flags
  269.  *        KeyMap  - Longword Key Map Value
  270.  *        KeyCapsable - Is key Caps Lockable
  271.  * returns:    String length
  272.  */
  273. int GetKeyStr(KeyStr, KeyType, KeyMap, KeyCapsable)
  274. char    *KeyStr;
  275. UBYTE    KeyType;
  276. UBYTE    *KeyMap;
  277. int    KeyCapsable;
  278. {
  279.     ULONG    CurrentStatus;
  280.     int len = 0;
  281.  
  282.     CurrentStatus = StatusFlags;
  283.     if (CheckFlag(SF_CapsLock))
  284.         if (KeyCapsable)
  285.             CurrentStatus |= SF_Shift;
  286.     
  287.     switch(KeyType & KC_VANILLA) {
  288.         case KC_NOQUAL:
  289.             len = *KeyMap;
  290.             memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
  291.             break;
  292.         case KCF_SHIFT:
  293.             if (!(CurrentStatus & SF_Shift)) {
  294.                 len = *KeyMap;
  295.                 memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
  296.             }
  297.             else {
  298.                 len = *(KeyMap+2);
  299.                 memcpy(KeyStr, (KeyMap + *(KeyMap+3)), len);
  300.             }
  301.             break;
  302.         case KCF_ALT:
  303.             if (!(CurrentStatus & SF_Alt)) {
  304.                 len = *KeyMap;
  305.                 memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
  306.             }
  307.             else {
  308.                 len = *(KeyMap+2);
  309.                 memcpy(KeyStr, (KeyMap + *(KeyMap+3)), len);
  310.             }
  311.             break;
  312.         case KCF_CONTROL:
  313.             if (!(CurrentStatus & SF_Control)) {
  314.                 len = *KeyMap;
  315.                 memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
  316.             }
  317.             else {
  318.                 len = *(KeyMap+2);
  319.                 memcpy(KeyStr, (KeyMap + *(KeyMap+3)), len);
  320.             }
  321.             break;
  322.         case KCF_ALT|KCF_SHIFT:
  323.             switch (CurrentStatus & (SF_Shift|SF_Alt)) {
  324.                 case 0:    /* Shift and Alt are not pressed */
  325.                     len = *KeyMap;
  326.                     memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
  327.                     break;
  328.                 case SF_Shift:
  329.                     len = *(KeyMap+2);
  330.                     memcpy(KeyStr, (KeyMap + *(KeyMap+3)), len);
  331.                     break;
  332.                 case SF_Alt:
  333.                     len = *(KeyMap+4);
  334.                     memcpy(KeyStr, (KeyMap + *(KeyMap+5)), len);
  335.                     break;
  336.                 case SF_Shift|SF_Alt:
  337.                     len = *(KeyMap+6);
  338.                     memcpy(KeyStr, (KeyMap + *(KeyMap+7)), len);
  339.             } /* switch */
  340.             break;
  341.         case KCF_CONTROL|KCF_SHIFT:
  342.             switch (CurrentStatus & (SF_Shift|SF_Control)) {
  343.                 case 0:    /* Shift and Control are not pressed */
  344.                     len = *KeyMap;
  345.                     memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
  346.                     break;
  347.                 case SF_Shift:
  348.                     len = *(KeyMap+2);
  349.                     memcpy(KeyStr, (KeyMap + *(KeyMap+3)), len);
  350.                     break;
  351.                 case SF_Control:
  352.                     len = *(KeyMap+4);
  353.                     memcpy(KeyStr, (KeyMap + *(KeyMap+5)), len);
  354.                     break;
  355.                 case SF_Shift|SF_Control:
  356.                     len = *(KeyMap+6);
  357.                     memcpy(KeyStr, (KeyMap + *(KeyMap+7)), len);
  358.             } /* switch */
  359.             break;
  360.         case KCF_CONTROL|KCF_ALT:
  361.             switch (CurrentStatus & (SF_Control|SF_Alt)) {
  362.                 case 0:    /* Alt and Control are not pressed */
  363.                     len = *KeyMap;
  364.                     memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
  365.                     break;
  366.                 case SF_Alt:
  367.                     len = *(KeyMap+2);
  368.                     memcpy(KeyStr, (KeyMap + *(KeyMap+3)), len);
  369.                     break;
  370.                 case SF_Control:
  371.                     len = *(KeyMap+4);
  372.                     memcpy(KeyStr, (KeyMap + *(KeyMap+5)), len);
  373.                     break;
  374.                 case SF_Alt|SF_Control:
  375.                     len = *(KeyMap+6);
  376.                     memcpy(KeyStr, (KeyMap + *(KeyMap+7)), len);
  377.             } /* switch */
  378.             break;
  379.         case KC_VANILLA:
  380.             switch (CurrentStatus & (SF_Shift|SF_Control|SF_Alt)) {
  381.                 case 0:    /* Shift, Alt and Control are not pressed */
  382.                     len = *KeyMap;
  383.                     memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
  384.                     break;
  385.                 case SF_Shift:
  386.                     len = *(KeyMap+2);
  387.                     memcpy(KeyStr, (KeyMap + *(KeyMap+3)), len);
  388.                     break;
  389.                 case SF_Alt:
  390.                     len = *(KeyMap+4);
  391.                     memcpy(KeyStr, (KeyMap + *(KeyMap+5)), len);
  392.                     break;
  393.                 case SF_Shift|SF_Alt:
  394.                     len = *(KeyMap+6);
  395.                     memcpy(KeyStr, (KeyMap + *(KeyMap+7)), len);
  396.                     break;
  397.                 case SF_Control:
  398.                     len = *(KeyMap+8);
  399.                     memcpy(KeyStr, (KeyMap + *(KeyMap+9)), len);
  400.                     break;
  401.                 case SF_Shift|SF_Control:
  402.                     len = *(KeyMap+10);
  403.                     memcpy(KeyStr, (KeyMap + *(KeyMap+11)), len);
  404.                     break;
  405.                 case SF_Control|SF_Alt:
  406.                     len = *(KeyMap+12);
  407.                     memcpy(KeyStr, (KeyMap + *(KeyMap+13)), len);
  408.                     break;
  409.                 case SF_Shift|SF_Control|SF_Alt:
  410.                     len = *(KeyMap+14);
  411.                     memcpy(KeyStr, (KeyMap + *(KeyMap+15)), len);
  412.             } /* switch */
  413.     } /* switch */
  414.     if (len > 0)
  415.         KeyStr[len++] = '\x00';
  416.     return(len);
  417. }
  418.  
  419. /*
  420.  * Get Key Dead
  421.  *
  422.  * parameters:    KeyType - Key Type Flags
  423.  *        KeyMap  - Longword Key Map Value
  424.  *        KeyCapsable - Is key Caps Lockable
  425.  * returns:    Key Value
  426.  */
  427. char GetKeyDead(KeyType, KeyMap, KeyCapsable, color)
  428. UBYTE    KeyType;
  429. UBYTE    *KeyMap;
  430. int    KeyCapsable;
  431. UBYTE    *color;
  432. {
  433.     static char    Accents[] = {
  434.         '\xB4', '`', '^', '~', '\xA8'
  435.     };
  436.     ULONG    CurrentStatus;
  437.     char    KeyVal = '\x00';
  438.  
  439.     CurrentStatus = StatusFlags;
  440.     if (CheckFlag(SF_CapsLock))
  441.         if (KeyCapsable)
  442.             CurrentStatus |= SF_Shift;
  443.  
  444.     *color = 1;
  445.     switch (KeyType & KC_VANILLA) {
  446.         case KC_NOQUAL:
  447.             switch (*KeyMap) {
  448.                 case KC_NOQUAL:
  449.                     KeyVal = *(KeyMap+1);
  450.                     break;
  451.                 case DPF_MOD:
  452.                     KeyVal = *(KeyMap + *(KeyMap+1));
  453.                     break;
  454.                 case DPF_DEAD:
  455.                     KeyVal = Accents[*(KeyMap+1)-1];
  456.                     *color = 3;
  457.             } /* switch */
  458.             break;
  459.         case KCF_SHIFT:
  460.             if (!(CurrentStatus & SF_Shift))
  461.                 switch (*KeyMap) {
  462.                     case KC_NOQUAL:
  463.                         KeyVal = *(KeyMap+1);
  464.                         break;
  465.                     case DPF_MOD:
  466.                         KeyVal = *(KeyMap + *(KeyMap+1));
  467.                         break;
  468.                     case DPF_DEAD:
  469.                         KeyVal = Accents[*(KeyMap+1)-1];
  470.                         *color = 3;
  471.                 } /* switch */
  472.             else
  473.                 switch (*(KeyMap+2)) {
  474.                     case KC_NOQUAL:
  475.                         KeyVal = *(KeyMap+3);
  476.                         break;
  477.                     case DPF_MOD:
  478.                         KeyVal = *(KeyMap + *(KeyMap+3));
  479.                         break;
  480.                     case DPF_DEAD:
  481.                         KeyVal = Accents[*(KeyMap+3)-1];
  482.                         *color = 3;
  483.                 } /* switch */
  484.             break;
  485.         case KCF_ALT:
  486.             if (!(CurrentStatus & SF_Alt))
  487.                 switch (*KeyMap) {
  488.                     case KC_NOQUAL:
  489.                         KeyVal = *(KeyMap+1);
  490.                         break;
  491.                     case DPF_MOD:
  492.                         KeyVal = *(KeyMap + *(KeyMap+1));
  493.                         break;
  494.                     case DPF_DEAD:
  495.                         KeyVal = Accents[*(KeyMap+1)-1];
  496.                         *color = 3;
  497.                 } /* switch */
  498.             else
  499.                 switch (*(KeyMap+2)) {
  500.                     case KC_NOQUAL:
  501.                         KeyVal = *(KeyMap+3);
  502.                         break;
  503.                     case DPF_MOD:
  504.                         KeyVal = *(KeyMap + *(KeyMap+3));
  505.                         break;
  506.                     case DPF_DEAD:
  507.                         KeyVal = Accents[*(KeyMap+3)-1];
  508.                         *color = 3;
  509.                 } /* switch */
  510.             break;
  511.         case KCF_CONTROL:
  512.             if (!(CurrentStatus & SF_Control))
  513.                 switch (*KeyMap) {
  514.                     case KC_NOQUAL:
  515.                         KeyVal = *(KeyMap+1);
  516.                         break;
  517.                     case DPF_MOD:
  518.                         KeyVal = *(KeyMap + *(KeyMap+1));
  519.                         break;
  520.                     case DPF_DEAD:
  521.                         KeyVal = Accents[*(KeyMap+1)-1];
  522.                         *color = 3;
  523.                 } /* switch */
  524.             else
  525.                 switch (*(KeyMap+2)) {
  526.                     case KC_NOQUAL:
  527.                         KeyVal = *(KeyMap+3);
  528.                         break;
  529.                     case DPF_MOD:
  530.                         KeyVal = *(KeyMap + *(KeyMap+3));
  531.                         break;
  532.                     case DPF_DEAD:
  533.                         KeyVal = Accents[*(KeyMap+3)-1];
  534.                         *color = 3;
  535.                 } /* switch */
  536.             break;
  537.         case KCF_SHIFT|KCF_ALT:
  538.             switch (CurrentStatus & (SF_Shift|SF_Alt)) {
  539.                 case 0: /* Shift and Alt not selected */
  540.                     switch (*KeyMap) {
  541.                         case KC_NOQUAL:
  542.                             KeyVal = *(KeyMap+1);
  543.                             break;
  544.                         case DPF_MOD:
  545.                             KeyVal = *(KeyMap + *(KeyMap+1));
  546.                             break;
  547.                         case DPF_DEAD:
  548.                             KeyVal = Accents[*(KeyMap+1)-1];
  549.                             *color = 3;
  550.                     } /* switch */
  551.                     break;
  552.                 case SF_Shift:
  553.                     switch (*(KeyMap+2)) {
  554.                         case KC_NOQUAL:
  555.                             KeyVal = *(KeyMap+3);
  556.                             break;
  557.                         case DPF_MOD:
  558.                             KeyVal = *(KeyMap + *(KeyMap+3));
  559.                             break;
  560.                         case DPF_DEAD:
  561.                             KeyVal = Accents[*(KeyMap+3)-1];
  562.                             *color = 3;
  563.                     } /* switch */
  564.                     break;
  565.                 case SF_Alt:
  566.                     switch (*(KeyMap+4)) {
  567.                         case KC_NOQUAL:
  568.                             KeyVal = *(KeyMap+5);
  569.                             break;
  570.                         case DPF_MOD:
  571.                             KeyVal = *(KeyMap + *(KeyMap+5));
  572.                             break;
  573.                         case DPF_DEAD:
  574.                             KeyVal = Accents[*(KeyMap+5)-1];
  575.                             *color = 3;
  576.                     } /* switch */
  577.                     break;
  578.                 case SF_Shift|SF_Alt:
  579.                     switch (*(KeyMap+6)) {
  580.                         case KC_NOQUAL:
  581.                             KeyVal = *(KeyMap+7);
  582.                             break;
  583.                         case DPF_MOD:
  584.                             KeyVal = *(KeyMap + *(KeyMap+7));
  585.                             break;
  586.                         case DPF_DEAD:
  587.                             KeyVal = Accents[*(KeyMap+7)-1];
  588.                             *color = 3;
  589.                     } /* switch */
  590.             } /* switch */
  591.             break;
  592.         case KCF_SHIFT|KCF_CONTROL:
  593.             switch (CurrentStatus & (SF_Shift|SF_Control)) {
  594.                 case 0: /* Shift and Control not selected */
  595.                     switch (*KeyMap) {
  596.                         case KC_NOQUAL:
  597.                             KeyVal = *(KeyMap+1);
  598.                             break;
  599.                         case DPF_MOD:
  600.                             KeyVal = *(KeyMap + *(KeyMap+1));
  601.                             break;
  602.                         case DPF_DEAD:
  603.                             KeyVal = Accents[*(KeyMap+1)-1];
  604.                             *color = 3;
  605.                     } /* switch */
  606.                     break;
  607.                 case SF_Shift:
  608.                     switch (*(KeyMap+2)) {
  609.                         case KC_NOQUAL:
  610.                             KeyVal = *(KeyMap+3);
  611.                             break;
  612.                         case DPF_MOD:
  613.                             KeyVal = *(KeyMap + *(KeyMap+3));
  614.                             break;
  615.                         case DPF_DEAD:
  616.                             KeyVal = Accents[*(KeyMap+3)-1];
  617.                             *color = 3;
  618.                     } /* switch */
  619.                     break;
  620.                 case SF_Control:
  621.                     switch (*(KeyMap+4)) {
  622.                         case KC_NOQUAL:
  623.                             KeyVal = *(KeyMap+5);
  624.                             break;
  625.                         case DPF_MOD:
  626.                             KeyVal = *(KeyMap + *(KeyMap+5));
  627.                             break;
  628.                         case DPF_DEAD:
  629.                             KeyVal = Accents[*(KeyMap+5)-1];
  630.                             *color = 3;
  631.                     } /* switch */
  632.                     break;
  633.                 case SF_Shift|SF_Control:
  634.                     switch (*(KeyMap+6)) {
  635.                         case KC_NOQUAL:
  636.                             KeyVal = *(KeyMap+7);
  637.                             break;
  638.                         case DPF_MOD:
  639.                             KeyVal = *(KeyMap + *(KeyMap+7));
  640.                             break;
  641.                         case DPF_DEAD:
  642.                             KeyVal = Accents[*(KeyMap+7)-1];
  643.                             *color = 3;
  644.                     } /* switch */
  645.             } /* switch */
  646.             break;
  647.         case KCF_ALT|KCF_CONTROL:
  648.             switch (CurrentStatus & (SF_Alt|SF_Control)) {
  649.                 case 0: /* Alt and Control not selected */
  650.                     switch (*KeyMap) {
  651.                         case KC_NOQUAL:
  652.                             KeyVal = *(KeyMap+1);
  653.                             break;
  654.                         case DPF_MOD:
  655.                             KeyVal = *(KeyMap + *(KeyMap+1));
  656.                             break;
  657.                         case DPF_DEAD:
  658.                             KeyVal = Accents[*(KeyMap+1)-1];
  659.                             *color = 3;
  660.                     } /* switch */
  661.                     break;
  662.                 case SF_Alt:
  663.                     switch (*(KeyMap+2)) {
  664.                         case KC_NOQUAL:
  665.                             KeyVal = *(KeyMap+3);
  666.                             break;
  667.                         case DPF_MOD:
  668.                             KeyVal = *(KeyMap + *(KeyMap+3));
  669.                             break;
  670.                         case DPF_DEAD:
  671.                             KeyVal = Accents[*(KeyMap+3)-1];
  672.                             *color = 3;
  673.                     } /* switch */
  674.                     break;
  675.                 case SF_Control:
  676.                     switch (*(KeyMap+4)) {
  677.                         case KC_NOQUAL:
  678.                             KeyVal = *(KeyMap+5);
  679.                             break;
  680.                         case DPF_MOD:
  681.                             KeyVal = *(KeyMap + *(KeyMap+5));
  682.                             break;
  683.                         case DPF_DEAD:
  684.                             KeyVal = Accents[*(KeyMap+5)-1];
  685.                             *color = 3;
  686.                     } /* switch */
  687.                     break;
  688.                 case SF_Alt|SF_Control:
  689.                     switch (*(KeyMap+6)) {
  690.                         case KC_NOQUAL:
  691.                             KeyVal = *(KeyMap+7);
  692.                             break;
  693.                         case DPF_MOD:
  694.                             KeyVal = *(KeyMap + *(KeyMap+7));
  695.                             break;
  696.                         case DPF_DEAD:
  697.                             KeyVal = Accents[*(KeyMap+7)-1];
  698.                             *color = 3;
  699.                     } /* switch */
  700.             } /* switch */
  701.             break;
  702.         case KC_VANILLA:
  703.             switch (CurrentStatus & (SF_Shift|SF_Alt|SF_Control)) {
  704.                 case 0: /* Shift, Alt and Control not selected */
  705.                     switch (*KeyMap) {
  706.                         case KC_NOQUAL:
  707.                             KeyVal = *(KeyMap+1);
  708.                             break;
  709.                         case DPF_MOD:
  710.                             KeyVal = *(KeyMap + *(KeyMap+1));
  711.                             break;
  712.                         case DPF_DEAD:
  713.                             KeyVal = Accents[*(KeyMap+1)-1];
  714.                             *color = 3;
  715.                     } /* switch */
  716.                     break;
  717.                 case SF_Shift:
  718.                     switch (*(KeyMap+2)) {
  719.                         case KC_NOQUAL:
  720.                             KeyVal = *(KeyMap+3);
  721.                             break;
  722.                         case DPF_MOD:
  723.                             KeyVal = *(KeyMap + *(KeyMap+3));
  724.                             break;
  725.                         case DPF_DEAD:
  726.                             KeyVal = Accents[*(KeyMap+3)-1];
  727.                             *color = 3;
  728.                     } /* switch */
  729.                     break;
  730.                 case SF_Alt:
  731.                     switch (*(KeyMap+4)) {
  732.                         case KC_NOQUAL:
  733.                             KeyVal = *(KeyMap+5);
  734.                             break;
  735.                         case DPF_MOD:
  736.                             KeyVal = *(KeyMap + *(KeyMap+5));
  737.                             break;
  738.                         case DPF_DEAD:
  739.                             KeyVal = Accents[*(KeyMap+5)-1];
  740.                             *color = 3;
  741.                     } /* switch */
  742.                     break;
  743.                 case SF_Shift|SF_Alt:
  744.                     switch (*(KeyMap+6)) {
  745.                         case KC_NOQUAL:
  746.                             KeyVal = *(KeyMap+7);
  747.                             break;
  748.                         case DPF_MOD:
  749.                             KeyVal = *(KeyMap + *(KeyMap+7));
  750.                             break;
  751.                         case DPF_DEAD:
  752.                             KeyVal = Accents[*(KeyMap+7)-1];
  753.                             *color = 3;
  754.                     } /* switch */
  755.                     break;
  756.                 case SF_Control:
  757.                     switch (*(KeyMap+8)) {
  758.                         case KC_NOQUAL:
  759.                             KeyVal = *(KeyMap+9);
  760.                             break;
  761.                         case DPF_MOD:
  762.                             KeyVal = *(KeyMap + *(KeyMap+9));
  763.                             break;
  764.                         case DPF_DEAD:
  765.                             KeyVal = Accents[*(KeyMap+9)-1];
  766.                             *color = 3;
  767.                     } /* switch */
  768.                     break;
  769.                 case SF_Shift|SF_Control:
  770.                     switch (*(KeyMap+10)) {
  771.                         case KC_NOQUAL:
  772.                             KeyVal = *(KeyMap+11);
  773.                             break;
  774.                         case DPF_MOD:
  775.                             KeyVal = *(KeyMap + *(KeyMap+11));
  776.                             break;
  777.                         case DPF_DEAD:
  778.                             KeyVal = Accents[*(KeyMap+11)-1];
  779.                             *color = 3;
  780.                     } /* switch */
  781.                     break;
  782.                 case SF_Alt|SF_Control:
  783.                     switch (*(KeyMap+12)) {
  784.                         case KC_NOQUAL:
  785.                             KeyVal = *(KeyMap+13);
  786.                             break;
  787.                         case DPF_MOD:
  788.                             KeyVal = *(KeyMap + *(KeyMap+13));
  789.                             break;
  790.                         case DPF_DEAD:
  791.                             KeyVal = Accents[*(KeyMap+13)-1];
  792.                             *color = 3;
  793.                     } /* switch */
  794.                     break;
  795.                 case SF_Shift|SF_Alt|SF_Control:
  796.                     switch (*(KeyMap+14)) {
  797.                         case KC_NOQUAL:
  798.                             KeyVal = *(KeyMap+15);
  799.                             break;
  800.                         case DPF_MOD:
  801.                             KeyVal = *(KeyMap + *(KeyMap+15));
  802.                             break;
  803.                         case DPF_DEAD:
  804.                             KeyVal = Accents[*(KeyMap+15)-1];
  805.                             *color = 3;
  806.                     } /* switch */
  807.             } /* switch */
  808.     } /* switch */
  809.     return(KeyVal);
  810. }
  811.