/*
 * Key Map Editor ver 1.0
 * Update Display
 *
 * parameters:	GadgetList - pointer to linked list of Gadgets to update
 *		KeyMapNode - KeyMapNode pointer
 *		Option     - Update Options (TRUE = all keys, FALSE = 1 key)
 *
 * by: Tim Friest
 * on: January 2, 1989
 */

#include "KME_Includes.h"
#include "KME_Protos.h"
#include "KME_Defs.h"
#include "KME_Globals.h"

extern char GetKeyVal(UBYTE, ULONG, int);
extern int GetKeyStr(char *, UBYTE, UBYTE *, int);
extern char GetKeyDead(UBYTE, UBYTE *, int, UBYTE *);

extern struct Gadget	CloseBracketGadget;

void UpdateDisplay(Gadget, KeyMapNode, UpdateAll)
struct Gadget *Gadget;
struct KeyMapNode *KeyMapNode;
int UpdateAll;
{
	struct	Gadget *Gad;
	USHORT	KeyCode;
	struct	KeyMap	*KeyMap;
	struct	HalfKeyMap *HalfKeyMap;
	int	Capsable;
	static char	buff[256];
	static struct	IntuiText	buffIText = {
		1, 0, JAM1, 0, 0, NULL, buff, NULL
	};
	int	len;
	UBYTE	color;
	struct	IntuiText	*IntuiText;
	int	GadWidth;

	KeyMap = &KeyMapNode->kn_KeyMap;
	Gad = Gadget;
	KeyCode = Gad->GadgetID;
	do {
		if (KeyCode < 0x40)
			HalfKeyMap = (struct HalfKeyMap *)KeyMap;
		else {
			HalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
			KeyCode -= 0x40;
		}
		len = 0;
		color = 1;
		Capsable = HalfKeyMap->Capsable[(KeyCode/8)] & (1<<(KeyCode % 8));
		switch (HalfKeyMap->KeyMapTypes[KeyCode] & (KCF_DEAD|KCF_STRING|KCF_NOP)) {
			case KC_NOQUAL:
				buff[0] = GetKeyVal(
					HalfKeyMap->KeyMapTypes[KeyCode], 
					HalfKeyMap->KeyMap[KeyCode],
					Capsable);
				buff[1] = '\x00';
				len = 2;
				break;
			case KCF_STRING:
				len = GetKeyStr(buff,
					HalfKeyMap->KeyMapTypes[KeyCode], 
					(UBYTE *)HalfKeyMap->KeyMap[KeyCode],
					Capsable);
				break;
			case KCF_DEAD:
				buff[0] = GetKeyDead(
					HalfKeyMap->KeyMapTypes[KeyCode],
					(UBYTE *)HalfKeyMap->KeyMap[KeyCode],
					Capsable, &color);
				buff[1] = '\x00';
				len = 2;
				break;
			case KCF_NOP:
			default:
				len = 0;
		} /* switch */
		if (len > 0) {
			GadWidth = Gad->Width;
			if (Gad->Activation & BOOLEXTEND)
				GadWidth -= 22;
			while ((len > 0) && (IntuiTextLength(&buffIText) > GadWidth))
				buff[--len] = '\x00';
			if (Gad->GadgetText == NULL) {
				IntuiText = (struct IntuiText *)AllocMem(sizeof(struct IntuiText), MEMF_CLEAR);
				if (IntuiText != NULL) {
					IntuiText->IText = (UBYTE *)AllocMem(len, 0);
					IntuiText->FrontPen = 1;
					IntuiText->BackPen = 0;
					IntuiText->DrawMode = JAM2;
				}
			}
			else {
				IntuiText = Gad->GadgetText;
				if (IntuiText->IText == NULL)
					IntuiText->IText = (UBYTE *)AllocMem(len, 0);
				else
					if (strlen(IntuiText->IText) != len) {
						FreeMem(IntuiText->IText, strlen(IntuiText->IText)+1);
						IntuiText->IText = (UBYTE *)AllocMem(len, 0);
					}
			}
			if (IntuiText != NULL) {
				if (IntuiText->IText != NULL) {
					if (buff[0] != '\x00') {
						strcpy(IntuiText->IText, buff);
						IntuiText->FrontPen = color;
						IntuiText->BackPen = 0;
					}
					else {
						IntuiText->IText[0] = '@';
						IntuiText->IText[1] = '\x00';
						IntuiText->FrontPen = 0;
						IntuiText->BackPen = 1;
					}
					if (buff[0] == ' ')
						IntuiText->BackPen = 1;
					IntuiText->LeftEdge = (GadWidth - IntuiTextLength(IntuiText))/2;
					if (Gad->Activation & BOOLEXTEND)
						IntuiText->LeftEdge += 22;
					Gad->GadgetText = IntuiText;
					FlagResource(RF_GadgetText);
				}
				else {
					FreeMem(IntuiText, sizeof(struct IntuiText));
					Gad->GadgetText = NULL;
				}
			}
		}
		else
			if (Gad->GadgetText != NULL)
				if (Gad->GadgetText->IText != NULL) {
					FreeMem(Gad->GadgetText->IText, strlen(Gad->GadgetText->IText)+1);
					Gad->GadgetText->IText = NULL;
				}
	} while ((Gad = Gad->NextGadget) && ((KeyCode = Gad->GadgetID) < 0x60) && UpdateAll);
	if (CheckResource(RF_Window))
		if (UpdateAll)
			RefreshGList(GadgetList, KeyMapEdWindow, NULL, DefinableKeys);
		else {
			RefreshGList(Gadget, KeyMapEdWindow, NULL, 1);
			if (Gadget->GadgetType == BOOLGADGET) /* kludge to fix return key overwriting this gadget */
				RefreshGList(&CloseBracketGadget, KeyMapEdWindow, NULL, 1);
		}
}

/*
 * Get Key Value
 *
 * parameters: 	KeyType - Key Type Flags
 *		KeyMap  - Longword Key Map Value
 *		KeyCapsable - Is key Caps Lockable
 * returns:	Key Value
 */
char GetKeyVal(KeyType, KeyMap, KeyCapsable)
UBYTE	KeyType;
ULONG	KeyMap;
int	KeyCapsable;
{
	char KeyVal = '\x00';
	ULONG	CurrentStatus;

	CurrentStatus = StatusFlags;
	if (CheckFlag(SF_CapsLock))
		if (KeyCapsable)
			CurrentStatus |= SF_Shift;
	
	switch(KeyType & KC_VANILLA) {
		case KC_NOQUAL:
			KeyVal = KeyMap & 0x000000FF;
			break;
		case KCF_SHIFT:
			if (!(CurrentStatus & SF_Shift))
				KeyVal = KeyMap & 0x000000FF;
			else
				KeyVal = ((KeyMap & 0x0000FF00)>>8);
			break;
		case KCF_ALT:
			if (!(CurrentStatus & SF_Alt))
				KeyVal = KeyMap & 0x000000FF;
			else
				KeyVal = ((KeyMap & 0x0000FF00)>>8);
			break;
		case KCF_CONTROL:
			if (!(CurrentStatus & SF_Control))
				KeyVal = KeyMap & 0x000000FF;
			else
				KeyVal = ((KeyMap & 0x0000FF00)>>8);
			break;
		case KCF_ALT|KCF_SHIFT:
			switch (CurrentStatus & (SF_Shift|SF_Alt)) {
				case 0:	/* Shift and Alt are not pressed */
					KeyVal = KeyMap & 0x000000FF;
					break;
				case SF_Shift:
					KeyVal = ((KeyMap & 0x0000FF00)>>8);
					break;
				case SF_Alt:
					KeyVal = ((KeyMap & 0x00FF0000)>>16);
					break;
				case SF_Shift|SF_Alt:
					KeyVal = ((KeyMap & 0xFF000000)>>24);
			} /* switch */
			break;
		case KCF_CONTROL|KCF_SHIFT:
			switch (CurrentStatus & (SF_Shift|SF_Control)) {
				case 0:	/* Shift and Control are not pressed */
					KeyVal = KeyMap & 0x000000FF;
					break;
				case SF_Shift:
					KeyVal = ((KeyMap & 0x0000FF00)>>8);
					break;
				case SF_Control:
					KeyVal = ((KeyMap & 0x00FF0000)>>16);
					break;
				case SF_Shift|SF_Control:
					KeyVal = ((KeyMap & 0xFF000000)>>24);
			} /* switch */
			break;
		case KCF_CONTROL|KCF_ALT:
			switch (CurrentStatus & (SF_Control|SF_Alt)) {
				case 0:	/* Control and Alt are not pressed */
					KeyVal = KeyMap & 0x000000FF;
					break;
				case SF_Alt:
					KeyVal = ((KeyMap & 0x0000FF00)>>8);
					break;
				case SF_Control:
					KeyVal = ((KeyMap & 0x00FF0000)>>16);
					break;
				case SF_Alt|SF_Control:
					KeyVal = ((KeyMap & 0xFF000000)>>24);
			} /* switch */
			break;
		case KC_VANILLA:
			switch (CurrentStatus & (SF_Shift|SF_Alt)) {
				case 0:	/* Shift and Alt are not pressed */
					KeyVal = KeyMap & 0x000000FF;
					break;
				case SF_Shift:
					KeyVal = ((KeyMap & 0x0000FF00)>>8);
					break;
				case SF_Alt:
					KeyVal = ((KeyMap & 0x00FF0000)>>16);
					break;
				case SF_Shift|SF_Alt:
					KeyVal = ((KeyMap & 0xFF000000)>>24);
			} /* switch */
			if (CurrentStatus & SF_Control)
				if ((KeyMap & 0x00000040) && (!((CurrentStatus & SF_Shift) && (KeyMap & 0x00000040))))
					KeyVal = KeyMap & 0x0000009F;
				else
					if (KeyMap & 0x00004000)
						KeyVal = ((KeyMap & 0x00009F00)>>8);
	} /* switch */
	return(KeyVal);
}

/*
 * Get Key String
 *
 * parameters: 	KeyStr - String to receive key's string
 *		KeyType - Key Type Flags
 *		KeyMap  - Longword Key Map Value
 *		KeyCapsable - Is key Caps Lockable
 * returns:	String length
 */
int GetKeyStr(KeyStr, KeyType, KeyMap, KeyCapsable)
char	*KeyStr;
UBYTE	KeyType;
UBYTE	*KeyMap;
int	KeyCapsable;
{
	ULONG	CurrentStatus;
	int len = 0;

	CurrentStatus = StatusFlags;
	if (CheckFlag(SF_CapsLock))
		if (KeyCapsable)
			CurrentStatus |= SF_Shift;
	
	switch(KeyType & KC_VANILLA) {
		case KC_NOQUAL:
			len = *KeyMap;
			memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
			break;
		case KCF_SHIFT:
			if (!(CurrentStatus & SF_Shift)) {
				len = *KeyMap;
				memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
			}
			else {
				len = *(KeyMap+2);
				memcpy(KeyStr, (KeyMap + *(KeyMap+3)), len);
			}
			break;
		case KCF_ALT:
			if (!(CurrentStatus & SF_Alt)) {
				len = *KeyMap;
				memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
			}
			else {
				len = *(KeyMap+2);
				memcpy(KeyStr, (KeyMap + *(KeyMap+3)), len);
			}
			break;
		case KCF_CONTROL:
			if (!(CurrentStatus & SF_Control)) {
				len = *KeyMap;
				memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
			}
			else {
				len = *(KeyMap+2);
				memcpy(KeyStr, (KeyMap + *(KeyMap+3)), len);
			}
			break;
		case KCF_ALT|KCF_SHIFT:
			switch (CurrentStatus & (SF_Shift|SF_Alt)) {
				case 0:	/* Shift and Alt are not pressed */
					len = *KeyMap;
					memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
					break;
				case SF_Shift:
					len = *(KeyMap+2);
					memcpy(KeyStr, (KeyMap + *(KeyMap+3)), len);
					break;
				case SF_Alt:
					len = *(KeyMap+4);
					memcpy(KeyStr, (KeyMap + *(KeyMap+5)), len);
					break;
				case SF_Shift|SF_Alt:
					len = *(KeyMap+6);
					memcpy(KeyStr, (KeyMap + *(KeyMap+7)), len);
			} /* switch */
			break;
		case KCF_CONTROL|KCF_SHIFT:
			switch (CurrentStatus & (SF_Shift|SF_Control)) {
				case 0:	/* Shift and Control are not pressed */
					len = *KeyMap;
					memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
					break;
				case SF_Shift:
					len = *(KeyMap+2);
					memcpy(KeyStr, (KeyMap + *(KeyMap+3)), len);
					break;
				case SF_Control:
					len = *(KeyMap+4);
					memcpy(KeyStr, (KeyMap + *(KeyMap+5)), len);
					break;
				case SF_Shift|SF_Control:
					len = *(KeyMap+6);
					memcpy(KeyStr, (KeyMap + *(KeyMap+7)), len);
			} /* switch */
			break;
		case KCF_CONTROL|KCF_ALT:
			switch (CurrentStatus & (SF_Control|SF_Alt)) {
				case 0:	/* Alt and Control are not pressed */
					len = *KeyMap;
					memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
					break;
				case SF_Alt:
					len = *(KeyMap+2);
					memcpy(KeyStr, (KeyMap + *(KeyMap+3)), len);
					break;
				case SF_Control:
					len = *(KeyMap+4);
					memcpy(KeyStr, (KeyMap + *(KeyMap+5)), len);
					break;
				case SF_Alt|SF_Control:
					len = *(KeyMap+6);
					memcpy(KeyStr, (KeyMap + *(KeyMap+7)), len);
			} /* switch */
			break;
		case KC_VANILLA:
			switch (CurrentStatus & (SF_Shift|SF_Control|SF_Alt)) {
				case 0:	/* Shift, Alt and Control are not pressed */
					len = *KeyMap;
					memcpy(KeyStr, (KeyMap + *(KeyMap+1)), len);
					break;
				case SF_Shift:
					len = *(KeyMap+2);
					memcpy(KeyStr, (KeyMap + *(KeyMap+3)), len);
					break;
				case SF_Alt:
					len = *(KeyMap+4);
					memcpy(KeyStr, (KeyMap + *(KeyMap+5)), len);
					break;
				case SF_Shift|SF_Alt:
					len = *(KeyMap+6);
					memcpy(KeyStr, (KeyMap + *(KeyMap+7)), len);
					break;
				case SF_Control:
					len = *(KeyMap+8);
					memcpy(KeyStr, (KeyMap + *(KeyMap+9)), len);
					break;
				case SF_Shift|SF_Control:
					len = *(KeyMap+10);
					memcpy(KeyStr, (KeyMap + *(KeyMap+11)), len);
					break;
				case SF_Control|SF_Alt:
					len = *(KeyMap+12);
					memcpy(KeyStr, (KeyMap + *(KeyMap+13)), len);
					break;
				case SF_Shift|SF_Control|SF_Alt:
					len = *(KeyMap+14);
					memcpy(KeyStr, (KeyMap + *(KeyMap+15)), len);
			} /* switch */
	} /* switch */
	if (len > 0)
		KeyStr[len++] = '\x00';
	return(len);
}

/*
 * Get Key Dead
 *
 * parameters:	KeyType - Key Type Flags
 *		KeyMap  - Longword Key Map Value
 *		KeyCapsable - Is key Caps Lockable
 * returns:	Key Value
 */
char GetKeyDead(KeyType, KeyMap, KeyCapsable, color)
UBYTE	KeyType;
UBYTE	*KeyMap;
int	KeyCapsable;
UBYTE	*color;
{
	static char	Accents[] = {
		'\xB4', '`', '^', '~', '\xA8'
	};
	ULONG	CurrentStatus;
	char	KeyVal = '\x00';

	CurrentStatus = StatusFlags;
	if (CheckFlag(SF_CapsLock))
		if (KeyCapsable)
			CurrentStatus |= SF_Shift;

	*color = 1;
	switch (KeyType & KC_VANILLA) {
		case KC_NOQUAL:
			switch (*KeyMap) {
				case KC_NOQUAL:
					KeyVal = *(KeyMap+1);
					break;
				case DPF_MOD:
					KeyVal = *(KeyMap + *(KeyMap+1));
					break;
				case DPF_DEAD:
					KeyVal = Accents[*(KeyMap+1)-1];
					*color = 3;
			} /* switch */
			break;
		case KCF_SHIFT:
			if (!(CurrentStatus & SF_Shift))
				switch (*KeyMap) {
					case KC_NOQUAL:
						KeyVal = *(KeyMap+1);
						break;
					case DPF_MOD:
						KeyVal = *(KeyMap + *(KeyMap+1));
						break;
					case DPF_DEAD:
						KeyVal = Accents[*(KeyMap+1)-1];
						*color = 3;
				} /* switch */
			else
				switch (*(KeyMap+2)) {
					case KC_NOQUAL:
						KeyVal = *(KeyMap+3);
						break;
					case DPF_MOD:
						KeyVal = *(KeyMap + *(KeyMap+3));
						break;
					case DPF_DEAD:
						KeyVal = Accents[*(KeyMap+3)-1];
						*color = 3;
				} /* switch */
			break;
		case KCF_ALT:
			if (!(CurrentStatus & SF_Alt))
				switch (*KeyMap) {
					case KC_NOQUAL:
						KeyVal = *(KeyMap+1);
						break;
					case DPF_MOD:
						KeyVal = *(KeyMap + *(KeyMap+1));
						break;
					case DPF_DEAD:
						KeyVal = Accents[*(KeyMap+1)-1];
						*color = 3;
				} /* switch */
			else
				switch (*(KeyMap+2)) {
					case KC_NOQUAL:
						KeyVal = *(KeyMap+3);
						break;
					case DPF_MOD:
						KeyVal = *(KeyMap + *(KeyMap+3));
						break;
					case DPF_DEAD:
						KeyVal = Accents[*(KeyMap+3)-1];
						*color = 3;
				} /* switch */
			break;
		case KCF_CONTROL:
			if (!(CurrentStatus & SF_Control))
				switch (*KeyMap) {
					case KC_NOQUAL:
						KeyVal = *(KeyMap+1);
						break;
					case DPF_MOD:
						KeyVal = *(KeyMap + *(KeyMap+1));
						break;
					case DPF_DEAD:
						KeyVal = Accents[*(KeyMap+1)-1];
						*color = 3;
				} /* switch */
			else
				switch (*(KeyMap+2)) {
					case KC_NOQUAL:
						KeyVal = *(KeyMap+3);
						break;
					case DPF_MOD:
						KeyVal = *(KeyMap + *(KeyMap+3));
						break;
					case DPF_DEAD:
						KeyVal = Accents[*(KeyMap+3)-1];
						*color = 3;
				} /* switch */
			break;
		case KCF_SHIFT|KCF_ALT:
			switch (CurrentStatus & (SF_Shift|SF_Alt)) {
				case 0: /* Shift and Alt not selected */
					switch (*KeyMap) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+1);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+1));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+1)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Shift:
					switch (*(KeyMap+2)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+3);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+3));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+3)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Alt:
					switch (*(KeyMap+4)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+5);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+5));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+5)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Shift|SF_Alt:
					switch (*(KeyMap+6)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+7);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+7));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+7)-1];
							*color = 3;
					} /* switch */
			} /* switch */
			break;
		case KCF_SHIFT|KCF_CONTROL:
			switch (CurrentStatus & (SF_Shift|SF_Control)) {
				case 0: /* Shift and Control not selected */
					switch (*KeyMap) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+1);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+1));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+1)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Shift:
					switch (*(KeyMap+2)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+3);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+3));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+3)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Control:
					switch (*(KeyMap+4)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+5);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+5));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+5)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Shift|SF_Control:
					switch (*(KeyMap+6)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+7);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+7));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+7)-1];
							*color = 3;
					} /* switch */
			} /* switch */
			break;
		case KCF_ALT|KCF_CONTROL:
			switch (CurrentStatus & (SF_Alt|SF_Control)) {
				case 0: /* Alt and Control not selected */
					switch (*KeyMap) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+1);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+1));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+1)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Alt:
					switch (*(KeyMap+2)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+3);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+3));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+3)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Control:
					switch (*(KeyMap+4)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+5);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+5));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+5)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Alt|SF_Control:
					switch (*(KeyMap+6)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+7);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+7));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+7)-1];
							*color = 3;
					} /* switch */
			} /* switch */
			break;
		case KC_VANILLA:
			switch (CurrentStatus & (SF_Shift|SF_Alt|SF_Control)) {
				case 0: /* Shift, Alt and Control not selected */
					switch (*KeyMap) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+1);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+1));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+1)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Shift:
					switch (*(KeyMap+2)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+3);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+3));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+3)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Alt:
					switch (*(KeyMap+4)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+5);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+5));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+5)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Shift|SF_Alt:
					switch (*(KeyMap+6)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+7);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+7));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+7)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Control:
					switch (*(KeyMap+8)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+9);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+9));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+9)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Shift|SF_Control:
					switch (*(KeyMap+10)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+11);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+11));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+11)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Alt|SF_Control:
					switch (*(KeyMap+12)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+13);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+13));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+13)-1];
							*color = 3;
					} /* switch */
					break;
				case SF_Shift|SF_Alt|SF_Control:
					switch (*(KeyMap+14)) {
						case KC_NOQUAL:
							KeyVal = *(KeyMap+15);
							break;
						case DPF_MOD:
							KeyVal = *(KeyMap + *(KeyMap+15));
							break;
						case DPF_DEAD:
							KeyVal = Accents[*(KeyMap+15)-1];
							*color = 3;
					} /* switch */
			} /* switch */
	} /* switch */
	return(KeyVal);
}