/*
 * Key Map Editor ver 1.0
 * Process Key Requester
 *
 * parameter: 	KeyCode - Key Code of key to edit
 * returns: 	Success - TRUE if key was changed, FALSE if not
 *
 * by: Tim Friest
 * on: January 8, 1989
 */

#include "KME_Includes.h"
#include <ctype.h>
#include "KME_Protos.h"
#include "KME_Defs.h"
#include "KME_KeyReq.h"
#include "KME_Globals.h"

struct	KeyNode {
	UBYTE	Type;
	int	Capsable, Repeatable;
	UBYTE	AloneOpt;
	UBYTE	AloneLen;
	char	Alone[33];
	UBYTE	ShiftOpt;
	UBYTE	ShiftLen;
	char	Shift[33];
	UBYTE	AltOpt;
	UBYTE	AltLen;
	char	Alt[33];
	UBYTE	ShiftAltOpt;
	UBYTE	ShiftAltLen;
	char	ShiftAlt[33];
	UBYTE	CtrlOpt;
	UBYTE	CtrlLen;
	char	Ctrl[33];
	UBYTE	CtrlShiftOpt;
	UBYTE	CtrlShiftLen;
	char	CtrlShift[33];
	UBYTE	CtrlAltOpt;
	UBYTE	CtrlAltLen;
	char	CtrlAlt[33];
	UBYTE	VanillaOpt;
	UBYTE	VanillaLen;
	char	Vanilla[33];
};

extern	void	InitKeyReq(struct KeyNode *);
extern	struct	KeyNode *MakeKeyNode(USHORT);
extern	int	ChangeKeyReq(struct KeyNode *, UBYTE);
extern	void	ExcludeAccGads(struct Gadget *, struct Gadget *);
extern	void	UpdateKey(struct KeyNode *);
extern	void	UpdateKeyMap(struct KeyNode *, USHORT);
extern	int	ExpandCtrl(unsigned char *, unsigned char *, int);
extern	int	CollapseCtrl(char *, char *, int);

int ProcKeyReq(KeyCode)
USHORT KeyCode;
{
	struct	KeyNode *Key;
	ULONG	KeyWind_sf = 0;
	static SHORT KeyReqWindx = KRWLEFTEDGE;
	static SHORT KeyReqWindy = KRWTOPEDGE;
	struct IntuiMessage *Message;
	ULONG	Class;
	USHORT	Code;
	struct Gadget *Gad;
	int	Done = FALSE;
	int	Use = FALSE;

	if ((Key = MakeKeyNode(KeyCode)) == NULL) {
		CloseWindow(KeyReqWindow);
		return(FALSE);
	}
	InitKeyReq(Key);
	NewKeyReqWindow.LeftEdge = KeyReqWindx;
	NewKeyReqWindow.TopEdge = KeyReqWindy;
	if ((KeyReqWindow = OpenWindow(&NewKeyReqWindow)) == NULL)
		return(FALSE);
	KeyWind_sf = (1<<KeyReqWindow->UserPort->mp_SigBit);
	if (CheckResource(RF_Font))
		SetFont(KeyReqWindow->RPort, TopazFont);
	Done = !Request(&KRRequester, KeyReqWindow);
	while (!Done) {
		while (Wait(KeyWind_sf|Wind_sf) == Wind_sf) {
			while ((Message = (struct IntuiMessage *)GetMsg(KeyMapEdWindow->UserPort)) != NULL)
				ReplyMsg((struct Message *)Message);
			DisplayBeep(KeyReqWindow->WScreen);
		} /* while */
		while ((!Done) && ((Message = (struct IntuiMessage *)GetMsg(KeyReqWindow->UserPort)) != NULL)) {
			Class = Message->Class;
			Code = Message->Code;
			Gad = (struct Gadget *)Message->IAddress;
			ReplyMsg((struct Message *)Message);
			switch (Class) {
				case REQSET:
					break;
				case GADGETUP:
					switch (Gad->GadgetID) {
						case 0xFF: /* Use changes */
							EndRequest(&KRRequester, KeyReqWindow);
							Done = TRUE;
							Use = TRUE;
							break;
						case 0xFE: /* Cancel any changes */
							EndRequest(&KRRequester, KeyReqWindow);
							Done = TRUE;
							break;
						case 0x00: /* switch type to NOP */
							if (Gad->Flags & SELECTED)
								Done = !ChangeKeyReq(Key, KCF_NOP);
							else {
								Gad->Flags |= SELECTED;
								RefreshGList(Gad, KeyReqWindow, &KRRequester, 1);
							}
							break;
						case 0x01: /* switch type to NoQual */
							if (Gad->Flags & SELECTED)
								Done = !ChangeKeyReq(Key, KC_NOQUAL);
							else {
								Gad->Flags |= SELECTED;
								RefreshGList(Gad, KeyReqWindow, &KRRequester, 1);
							}
							break;
						case 0x02: /* switch type to String */
							if (Gad->Flags & SELECTED)
								Done = !ChangeKeyReq(Key, KCF_STRING);
							else {
								Gad->Flags |= SELECTED;
								RefreshGList(Gad, KeyReqWindow, &KRRequester, 1);
							}
							break;
						case 0x03: /* switch type to Dead */
							if (Gad->Flags & SELECTED)
								Done = !ChangeKeyReq(Key, KCF_DEAD);
							else {
								Gad->Flags |= SELECTED;
								RefreshGList(Gad, KeyReqWindow, &KRRequester, 1);
							}
							break;
						case 0x10: /* toggle Shift type */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->Type |= KCF_SHIFT;
							else
								Key->Type &= ~KCF_SHIFT;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x11: /* toggle Alt type */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->Type |= KCF_ALT;
							else
								Key->Type &= ~KCF_ALT;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x12: /* toggle Ctrl type */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->Type |= KCF_CONTROL;
							else
								Key->Type &= ~KCF_CONTROL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x13: /* toggle Capsable */
							if (Gad->Flags & SELECTED)
								Key->Capsable = TRUE;
							else
								Key->Capsable = FALSE;
							break;
						case 0x14: /* toggle Repeatable */
							if (Gad->Flags & SELECTED)
								Key->Repeatable = TRUE;
							else
								Key->Repeatable = FALSE;
							break;
						case 0x40: /* Alone Mod gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->AloneOpt = DPF_MOD;
							else
								Key->AloneOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x41: /* Alone Dead gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->AloneOpt = DPF_DEAD;
							else
								Key->AloneOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x49: /* Alone Acc1 Gadget */
						case 0x4A: /* Alone Acc2 Gadget */
						case 0x4B: /* Alone Acc3 Gadget */
						case 0x4C: /* Alone Acc4 Gadget */
						case 0x4D: /* Alone Acc5 Gadget */
							ExcludeAccGads(&KRDAloneAcc1Gadget, Gad);
							break;
						case 0x50: /* Shift Mod gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->ShiftOpt = DPF_MOD;
							else
								Key->ShiftOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x51: /* Shift Dead gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->ShiftOpt = DPF_DEAD;
							else
								Key->ShiftOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x59: /* Shift Acc1 Gadget */
						case 0x5A: /* Shift Acc2 Gadget */
						case 0x5B: /* Shift Acc3 Gadget */
						case 0x5C: /* Shift Acc4 Gadget */
						case 0x5D: /* Shift Acc5 Gadget */
							ExcludeAccGads(&KRDShiftAcc1Gadget, Gad);
							break;
						case 0x60: /* Alt Mod gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->AltOpt = DPF_MOD;
							else
								Key->AltOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x61: /* Alt Dead gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->AltOpt = DPF_DEAD;
							else
								Key->AltOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x69: /* Alt Acc1 Gadget */
						case 0x6A: /* Alt Acc2 Gadget */
						case 0x6B: /* Alt Acc3 Gadget */
						case 0x6C: /* Alt Acc4 Gadget */
						case 0x6D: /* Alt Acc5 Gadget */
							ExcludeAccGads(&KRDAltAcc1Gadget, Gad);
							break;
						case 0x70: /* ShiftAlt Mod gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->ShiftAltOpt = DPF_MOD;
							else
								Key->ShiftAltOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x71: /* ShiftAlt Dead gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->ShiftAltOpt = DPF_DEAD;
							else
								Key->ShiftAltOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x79: /* ShiftAlt Acc1 Gadget */
						case 0x7A: /* ShiftAlt Acc2 Gadget */
						case 0x7B: /* ShiftAlt Acc3 Gadget */
						case 0x7C: /* ShiftAlt Acc4 Gadget */
						case 0x7D: /* ShiftAlt Acc5 Gadget */
							ExcludeAccGads(&KRDShiftAltAcc1Gadget, Gad);
							break;
						case 0x80: /* Ctrl Mod gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->CtrlOpt = DPF_MOD;
							else
								Key->CtrlOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x81: /* Ctrl Dead gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->CtrlOpt = DPF_DEAD;
							else
								Key->CtrlOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x89: /* Ctrl Acc1 Gadget */
						case 0x8A: /* Ctrl Acc2 Gadget */
						case 0x8B: /* Ctrl Acc3 Gadget */
						case 0x8C: /* Ctrl Acc4 Gadget */
						case 0x8D: /* Ctrl Acc5 Gadget */
							ExcludeAccGads(&KRDCtrlAcc1Gadget, Gad);
							break;
						case 0x90: /* CtrlShift Mod gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->CtrlShiftOpt = DPF_MOD;
							else
								Key->CtrlShiftOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x91: /* CtrlShift Dead gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->CtrlShiftOpt = DPF_DEAD;
							else
								Key->CtrlShiftOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0x99: /* CtrlShift Acc1 Gadget */
						case 0x9A: /* CtrlShift Acc2 Gadget */
						case 0x9B: /* CtrlShift Acc3 Gadget */
						case 0x9C: /* CtrlShift Acc4 Gadget */
						case 0x9D: /* CtrlShift Acc5 Gadget */
							ExcludeAccGads(&KRDCtrlShiftAcc1Gadget, Gad);
							break;
						case 0xA0: /* CtrlAlt Mod gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->CtrlAltOpt = DPF_MOD;
							else
								Key->CtrlAltOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0xA1: /* CtrlAlt Dead gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->CtrlAltOpt = DPF_DEAD;
							else
								Key->CtrlAltOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0xA9: /* CtrlAlt Acc1 Gadget */
						case 0xAA: /* CtrlAlt Acc2 Gadget */
						case 0xAB: /* CtrlAlt Acc3 Gadget */
						case 0xAC: /* CtrlAlt Acc4 Gadget */
						case 0xAD: /* CtrlAlt Acc5 Gadget */
							ExcludeAccGads(&KRDCtrlAltAcc1Gadget, Gad);
							break;
						case 0xB0: /* Vanilla Mod gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->VanillaOpt = DPF_MOD;
							else
								Key->VanillaOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0xB1: /* Vanilla Dead gadget */
							UpdateKey(Key);
							if (Gad->Flags & SELECTED)
								Key->VanillaOpt = DPF_DEAD;
							else
								Key->VanillaOpt = KC_NOQUAL;
							InitKeyReq(Key);
							Done = !Request(&KRRequester, KeyReqWindow);
							break;
						case 0xB9: /* Vanilla Acc1 Gadget */
						case 0xBA: /* Vanilla Acc2 Gadget */
						case 0xBB: /* Vanilla Acc3 Gadget */
						case 0xBC: /* Vanilla Acc4 Gadget */
						case 0xBD: /* Vanilla Acc5 Gadget */
							ExcludeAccGads(&KRDVanillaAcc1Gadget, Gad);
							break;
					} /* switch */
			} /* switch */
		} /* while */
	} /* while */
	KeyReqWindx = KeyReqWindow->LeftEdge;
	KeyReqWindy = KeyReqWindow->TopEdge;
	CloseWindow(KeyReqWindow);
	if (Use) {
		UpdateKey(Key);
		UpdateKeyMap(Key, KeyCode);
		SetFlag(SF_Modified);
	}
	FreeMem(Key, sizeof(struct KeyNode));
	return(Use);
}

/*
 * Change Key Requester
 */
int ChangeKeyReq(Key, Type)
struct KeyNode *Key;
UBYTE Type;
{
	EndRequest(&KRRequester, KeyReqWindow);
	UpdateKey(Key);
	Key->Type &= ~(KCF_STRING|KCF_DEAD|KCF_NOP);
	Key->Type |= Type;
	InitKeyReq(Key);
	return(Request(&KRRequester, KeyReqWindow));
}

/*
 * Exclude Accent Gadgets
 */
void ExcludeAccGads(AccentList, AccGad)
struct Gadget *AccentList;
struct Gadget *AccGad;
{
	int pos, count;
	struct Gadget *tempgad;

	pos = RemoveGList(KeyReqWindow, AccentList, 5);
	if (AccGad->Flags & SELECTED)
		for (tempgad = AccentList, count = 0; (count < 5) && (tempgad != NULL); tempgad = tempgad->NextGadget, count++)
			tempgad->Flags &= ~SELECTED;
	AccGad->Flags |= SELECTED;
	AddGList(KeyReqWindow, AccentList, pos, 5, &KRRequester);
	RefreshGList(AccentList, KeyReqWindow, &KRRequester, 5);
}

/*
 * Make the Key Node
 */
struct KeyNode *MakeKeyNode(KeyCode)
USHORT KeyCode;
{
	struct KeyNode *Key;
	struct HalfKeyMap *HalfKeyMap;
	UBYTE	*KeyMapVal;
	UBYTE	*KeyMapPtr;
	
	if ((Key = (struct KeyNode *)AllocMem(sizeof(struct KeyNode), MEMF_CLEAR)) == NULL)
		return(Key);
	if (KeyCode < 0x40)
		HalfKeyMap = (struct HalfKeyMap *)&KeyMapNode->kn_KeyMap;
	else {
		HalfKeyMap = (struct HalfKeyMap *)&KeyMapNode->kn_KeyMap.km_HiKeyMapTypes;
		KeyCode -= 0x40;
	}
	Key->Type = HalfKeyMap->KeyMapTypes[KeyCode];
	Key->Capsable = (HalfKeyMap->Capsable[KeyCode/8] & (1<<(KeyCode % 8)));
	Key->Repeatable = (HalfKeyMap->Repeatable[KeyCode/8] & (1<<(KeyCode % 8)));
	KeyMapVal = (UBYTE *)&HalfKeyMap->KeyMap[KeyCode];
	KeyMapPtr = (UBYTE *)HalfKeyMap->KeyMap[KeyCode];
	switch (Key->Type & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
		case KC_NOQUAL:
			switch (Key->Type & KC_VANILLA) {
				case KC_NOQUAL:
					Key->AloneLen = 1;
					Key->Alone[0] = KeyMapVal[3];
					break;
				case KCF_SHIFT:
					Key->AloneLen = 1;
					Key->Alone[0] = KeyMapVal[3];
					Key->ShiftLen = 1;
					Key->Shift[0] = KeyMapVal[2];
					break;
				case KCF_ALT:
					Key->AloneLen = 1;
					Key->Alone[0] = KeyMapVal[3];
					Key->AltLen = 1;
					Key->Alt[0] = KeyMapVal[2];
					break;
				case KCF_SHIFT|KCF_ALT:
					Key->AloneLen = 1;
					Key->Alone[0] = KeyMapVal[3];
					Key->ShiftLen = 1;
					Key->Shift[0] = KeyMapVal[2];
					Key->AltLen = 1;
					Key->Alt[0] = KeyMapVal[1];
					Key->ShiftAltLen = 1;
					Key->ShiftAlt[0] = KeyMapVal[0];;
					break;
				case KCF_CONTROL:
					Key->AloneLen = 1;
					Key->Alone[0] = KeyMapVal[3];
					Key->CtrlLen = 1;
					Key->Ctrl[0] = KeyMapVal[2];
					break;
				case KCF_CONTROL|KCF_SHIFT:
					Key->AloneLen = 1;
					Key->Alone[0] = KeyMapVal[3];
					Key->ShiftLen = 1;
					Key->Shift[0] = KeyMapVal[2];
					Key->CtrlLen = 1;
					Key->Ctrl[0] = KeyMapVal[1];
					Key->CtrlShiftLen = 1;
					Key->CtrlShift[0] = KeyMapVal[0];
					break;
				case KCF_CONTROL|KCF_ALT:
					Key->AloneLen = 1;
					Key->Alone[0] = KeyMapVal[3];
					Key->AltLen = 1;
					Key->Alt[0] = KeyMapVal[2];
					Key->CtrlLen = 1;
					Key->Ctrl[0] = KeyMapVal[1];
					Key->CtrlAltLen = 1;
					Key->CtrlAlt[0] = KeyMapVal[0];
					break;
				case KC_VANILLA:
					Key->AloneLen = 1;
					Key->Alone[0] = KeyMapVal[3];
					Key->ShiftLen = 1;
					Key->Shift[0] = KeyMapVal[2];
					Key->AltLen = 1;
					Key->Alt[0] = KeyMapVal[1];
					Key->ShiftAltLen = 1;
					Key->ShiftAlt[0] = KeyMapVal[0];
			} /* switch */
			break;
		case KCF_STRING:
			switch (Key->Type & KC_VANILLA) {
				case KC_NOQUAL:
					Key->AloneLen = KeyMapPtr[0];
					memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
					break;
				case KCF_SHIFT:
					Key->AloneLen = KeyMapPtr[0];
					memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
					Key->ShiftLen = KeyMapPtr[2];
					memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), Key->ShiftLen);
					break;
				case KCF_ALT:
					Key->AloneLen = KeyMapPtr[0];
					memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
					Key->AltLen = KeyMapPtr[2];
					memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[3]), Key->AltLen);
					break;
				case KCF_SHIFT|KCF_ALT:
					Key->AloneLen = KeyMapPtr[0];
					memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
					Key->ShiftLen = KeyMapPtr[2];
					memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), Key->ShiftLen);
					Key->AltLen = KeyMapPtr[4];
					memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[5]), Key->AltLen);
					Key->ShiftAltLen = KeyMapPtr[6];
					memcpy(Key->ShiftAlt, (KeyMapPtr+KeyMapPtr[7]), Key->ShiftAltLen);
					break;
				case KCF_CONTROL:
					Key->AloneLen = KeyMapPtr[0];
					memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
					Key->CtrlLen = KeyMapPtr[2];
					memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[3]), Key->CtrlLen);
					break;
				case KCF_CONTROL|KCF_SHIFT:
					Key->AloneLen = KeyMapPtr[0];
					memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
					Key->ShiftLen = KeyMapPtr[2];
					memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), Key->ShiftLen);
					Key->CtrlLen = KeyMapPtr[4];
					memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[5]), Key->CtrlLen);
					Key->CtrlShiftLen = KeyMapPtr[6];
					memcpy(Key->CtrlShift, (KeyMapPtr+KeyMapPtr[7]), Key->CtrlShiftLen);
					break;
				case KCF_CONTROL|KCF_ALT:
					Key->AloneLen = KeyMapPtr[0];
					memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
					Key->AltLen = KeyMapPtr[2];
					memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[3]), Key->AltLen);
					Key->CtrlLen = KeyMapPtr[4];
					memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[5]), Key->CtrlLen);
					Key->CtrlAltLen = KeyMapPtr[6];
					memcpy(Key->CtrlAlt, (KeyMapPtr+KeyMapPtr[7]), Key->CtrlAltLen);
					break;
				case KC_VANILLA:
					Key->AloneLen = KeyMapPtr[0];
					memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), Key->AloneLen);
					Key->ShiftLen = KeyMapPtr[2];
					memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), Key->ShiftLen);
					Key->AltLen = KeyMapPtr[4];
					memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[5]), Key->AltLen);
					Key->ShiftAltLen = KeyMapPtr[6];
					memcpy(Key->ShiftAlt, (KeyMapPtr+KeyMapPtr[7]), Key->ShiftAltLen);
					Key->CtrlLen = KeyMapPtr[8];
					memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[9]), Key->CtrlLen);
					Key->CtrlShiftLen = KeyMapPtr[10];
					memcpy(Key->CtrlShift, (KeyMapPtr+KeyMapPtr[11]), Key->CtrlShiftLen);
					Key->CtrlAltLen = KeyMapPtr[12];
					memcpy(Key->CtrlAlt, (KeyMapPtr+KeyMapPtr[13]), Key->CtrlAltLen);
					Key->VanillaLen = KeyMapPtr[14];
					memcpy(Key->Vanilla, (KeyMapPtr+KeyMapPtr[15]), Key->VanillaLen);
			} /* switch */
			break;
		case KCF_DEAD:
			switch (Key->Type & KC_VANILLA) {
				case KC_NOQUAL:
					Key->AloneOpt = KeyMapPtr[0];
					switch (Key->AloneOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->AloneLen = 1;
							Key->Alone[0] = KeyMapPtr[1];
							break;
						case DPF_MOD:
							Key->AloneLen = 6;
							memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
					} /* switch */
					break;
				case KCF_SHIFT:
					Key->AloneOpt = KeyMapPtr[0];
					switch (Key->AloneOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->AloneLen = 1;
							Key->Alone[0] = KeyMapPtr[1];
							break;
						case DPF_MOD:
							Key->AloneLen = 6;
							memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
					} /* switch */
					Key->ShiftOpt = KeyMapPtr[2];
					switch (Key->ShiftOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->ShiftLen = 1;
							Key->Shift[0] = KeyMapPtr[3];
							break;
						case DPF_MOD:
							Key->ShiftLen = 6;
							memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), 6);
					} /* switch */
					break;
				case KCF_ALT:
					Key->AloneOpt = KeyMapPtr[0];
					switch (Key->AloneOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->AloneLen = 1;
							Key->Alone[0] = KeyMapPtr[1];
							break;
						case DPF_MOD:
							Key->AloneLen = 6;
							memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
					} /* switch */
					Key->AltOpt = KeyMapPtr[2];
					switch (Key->AltOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->AltLen = 1;
							Key->Alt[0] = KeyMapPtr[3];
							break;
						case DPF_MOD:
							Key->AltLen = 6;
							memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[3]), 6);
					} /* switch */
					break;
				case KCF_SHIFT|KCF_ALT:
					Key->AloneOpt = KeyMapPtr[0];
					switch (Key->AloneOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->AloneLen = 1;
							Key->Alone[0] = KeyMapPtr[1];
							break;
						case DPF_MOD:
							Key->AloneLen = 6;
							memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
					} /* switch */
					Key->ShiftOpt = KeyMapPtr[2];
					switch (Key->ShiftOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->ShiftLen = 1;
							Key->Shift[0] = KeyMapPtr[3];
							break;
						case DPF_MOD:
							Key->ShiftLen = 6;
							memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), 6);
					} /* switch */
					Key->AltOpt = KeyMapPtr[4];
					switch (Key->AltOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->AltLen = 1;
							Key->Alt[0] = KeyMapPtr[5];
							break;
						case DPF_MOD:
							Key->AltLen = 6;
							memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[5]), 6);
					} /* switch */
					Key->ShiftAltOpt = KeyMapPtr[6];
					switch (Key->ShiftAltOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->ShiftAltLen = 1;
							Key->ShiftAlt[0] = KeyMapPtr[7];
							break;
						case DPF_MOD:
							Key->ShiftAltLen = 6;
							memcpy(Key->ShiftAlt, (KeyMapPtr+KeyMapPtr[7]), 6);
					} /* switch */
					break;
				case KCF_CONTROL:
					Key->AloneOpt = KeyMapPtr[0];
					switch (Key->AloneOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->AloneLen = 1;
							Key->Alone[0] = KeyMapPtr[1];
							break;
						case DPF_MOD:
							Key->AloneLen = 6;
							memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
					} /* switch */
					Key->CtrlOpt = KeyMapPtr[2];
					switch (Key->CtrlOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->CtrlLen = 1;
							Key->Ctrl[0] = KeyMapPtr[3];
							break;
						case DPF_MOD:
							Key->CtrlLen = 6;
							memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[3]), 6);
					} /* switch */
					break;
				case KCF_CONTROL|KCF_SHIFT:
					Key->AloneOpt = KeyMapPtr[0];
					switch (Key->AloneOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->AloneLen = 1;
							Key->Alone[0] = KeyMapPtr[1];
							break;
						case DPF_MOD:
							Key->AloneLen = 6;
							memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
					} /* switch */
					Key->ShiftOpt = KeyMapPtr[2];
					switch (Key->ShiftOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->ShiftLen = 1;
							Key->Shift[0] = KeyMapPtr[3];
							break;
						case DPF_MOD:
							Key->ShiftLen = 6;
							memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), 6);
					} /* switch */
					Key->CtrlOpt = KeyMapPtr[4];
					switch (Key->CtrlOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->CtrlLen = 1;
							Key->Ctrl[0] = KeyMapPtr[5];
							break;
						case DPF_MOD:
							Key->CtrlLen = 6;
							memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[5]), 6);
					} /* switch */
					Key->CtrlShiftOpt = KeyMapPtr[6];
					switch (Key->CtrlShiftOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->CtrlShiftLen = 1;
							Key->CtrlShift[0] = KeyMapPtr[7];
							break;
						case DPF_MOD:
							Key->CtrlShiftLen = 6;
							memcpy(Key->CtrlShift, (KeyMapPtr+KeyMapPtr[7]), 6);
					} /* switch */
					break;
				case KCF_CONTROL|KCF_ALT:
					Key->AloneOpt = KeyMapPtr[0];
					switch (Key->AloneOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->AloneLen = 1;
							Key->Alone[0] = KeyMapPtr[1];
							break;
						case DPF_MOD:
							Key->AloneLen = 6;
							memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
					} /* switch */
					Key->AltOpt = KeyMapPtr[2];
					switch (Key->AltOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->AltLen = 1;
							Key->Alt[0] = KeyMapPtr[3];
							break;
						case DPF_MOD:
							Key->AltLen = 6;
							memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[3]), 6);
					} /* switch */
					Key->CtrlOpt = KeyMapPtr[4];
					switch (Key->CtrlOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->CtrlLen = 1;
							Key->Ctrl[0] = KeyMapPtr[5];
							break;
						case DPF_MOD:
							Key->CtrlLen = 6;
							memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[5]), 6);
					} /* switch */
					Key->CtrlAltOpt = KeyMapPtr[6];
					switch (Key->CtrlAltOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->CtrlAltLen = 1;
							Key->CtrlAlt[0] = KeyMapPtr[7];
							break;
						case DPF_MOD:
							Key->CtrlAltLen = 6;
							memcpy(Key->CtrlAlt, (KeyMapPtr+KeyMapPtr[7]), 6);
					} /* switch */
					break;
				case KC_VANILLA:
					Key->AloneOpt = KeyMapPtr[0];
					switch (Key->AloneOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->AloneLen = 1;
							Key->Alone[0] = KeyMapPtr[1];
							break;
						case DPF_MOD:
							Key->AloneLen = 6;
							memcpy(Key->Alone, (KeyMapPtr+KeyMapPtr[1]), 6);
					} /* switch */
					Key->ShiftOpt = KeyMapPtr[2];
					switch (Key->ShiftOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->ShiftLen = 1;
							Key->Shift[0] = KeyMapPtr[3];
							break;
						case DPF_MOD:
							Key->ShiftLen = 6;
							memcpy(Key->Shift, (KeyMapPtr+KeyMapPtr[3]), 6);
					} /* switch */
					Key->AltOpt = KeyMapPtr[4];
					switch (Key->AltOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->AltLen = 1;
							Key->Alt[0] = KeyMapPtr[5];
							break;
						case DPF_MOD:
							Key->AltLen = 6;
							memcpy(Key->Alt, (KeyMapPtr+KeyMapPtr[5]), 6);
					} /* switch */
					Key->ShiftAltOpt = KeyMapPtr[6];
					switch (Key->ShiftAltOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->ShiftAltLen = 1;
							Key->ShiftAlt[0] = KeyMapPtr[7];
							break;
						case DPF_MOD:
							Key->ShiftAltLen = 6;
							memcpy(Key->ShiftAlt, (KeyMapPtr+KeyMapPtr[7]), 6);
					} /* switch */
					Key->CtrlOpt = KeyMapPtr[8];
					switch (Key->CtrlOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->CtrlLen = 1;
							Key->Ctrl[0] = KeyMapPtr[9];
							break;
						case DPF_MOD:
							Key->CtrlLen = 6;
							memcpy(Key->Ctrl, (KeyMapPtr+KeyMapPtr[9]), 6);
					} /* switch */
					Key->CtrlShiftOpt = KeyMapPtr[10];
					switch (Key->CtrlShiftOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->CtrlShiftLen = 1;
							Key->CtrlShift[0] = KeyMapPtr[11];
							break;
						case DPF_MOD:
							Key->CtrlShiftLen = 6;
							memcpy(Key->CtrlShift, (KeyMapPtr+KeyMapPtr[11]), 6);
					} /* switch */
					Key->CtrlAltOpt = KeyMapPtr[12];
					switch (Key->CtrlAltOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->CtrlAltLen = 1;
							Key->CtrlAlt[0] = KeyMapPtr[13];
							break;
						case DPF_MOD:
							Key->CtrlAltLen = 6;
							memcpy(Key->CtrlAlt, (KeyMapPtr+KeyMapPtr[13]), 6);
					} /* switch */
					Key->VanillaOpt = KeyMapPtr[14];
					switch (Key->VanillaOpt) {
						case KC_NOQUAL:
						case DPF_DEAD:
							Key->VanillaLen = 1;
							Key->Vanilla[0] = KeyMapPtr[15];
							break;
						case DPF_MOD:
							Key->VanillaLen = 6;
							memcpy(Key->Vanilla, (KeyMapPtr+KeyMapPtr[15]), 6);
					} /* switch */
			} /* switch */
			break;
		case KCF_NOP:
			break;
	} /* switch */
	return(Key);
}

/*
 * Initialize requester for type of key
 */
void InitKeyReq(Key)
struct KeyNode *Key;
{
	switch(Key->Type & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
		case KC_NOQUAL:
			KRNOPGadget.Flags &= ~SELECTED;
			KRNoQualGadget.Flags |= SELECTED;
			KRStringGadget.Flags &= ~SELECTED;
			KRDeadGadget.Flags &= ~SELECTED;
			KRRepeatableGadget.NextGadget = KRNormalGadgetList;
			KRRequester.ReqText = KRNormalITextList;

			KRNAloneStrGadSInfo.BufferPos = ExpandCtrl(KRNAloneStrGadSIBuff, Key->Alone, 1);
			if (Key->Type & KCF_SHIFT) {
				KRNormalIText1.IText = KRShiftString;
				KRNOpt1StrGadget.Flags &= ~GADGDISABLED;
				KRNOpt1StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt1StrGadSIBuff, Key->Shift, 1);
			}
			else if (Key->Type & KCF_ALT) {
				KRNormalIText1.IText = KRAltString;
				KRNOpt1StrGadget.Flags &= ~GADGDISABLED;
				KRNOpt1StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt1StrGadSIBuff, Key->Alt, 1);
			}
			else if (Key->Type & KCF_CONTROL) {
				KRNormalIText1.IText = KRCtrlString;
				KRNOpt1StrGadget.Flags &= ~GADGDISABLED;
				KRNOpt1StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt1StrGadSIBuff, Key->Ctrl, 1);
			}
			else {
				KRNormalIText1.IText = NULL;
				KRNOpt1StrGadget.Flags |= GADGDISABLED;
				KRNOpt1StrGadSIBuff[0] = '\x00';
				KRNOpt1StrGadSInfo.BufferPos = 0;
			}
			if ((Key->Type & KCF_ALT) && (Key->Type & KCF_SHIFT)) {
				KRNormalIText2.IText = KRAltString;
				KRNOpt2StrGadget.Flags &= ~GADGDISABLED;
				KRNOpt2StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt2StrGadSIBuff, Key->Alt, 1);
			}
			else if ((Key->Type & KCF_CONTROL) && (Key->Type & (KCF_SHIFT|KCF_ALT))) {
				KRNormalIText2.IText = KRCtrlString;
				KRNOpt2StrGadget.Flags &= ~GADGDISABLED;
				KRNOpt2StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt2StrGadSIBuff, Key->Ctrl, 1);
			}
			else {
				KRNormalIText2.IText = NULL;
				KRNOpt2StrGadget.Flags |= GADGDISABLED;
				KRNOpt2StrGadSIBuff[0] = '\x00';
				KRNOpt2StrGadSInfo.BufferPos = 0;
			}
			if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT)) {
				KRNormalIText3.IText = KRShiftAltString;
				KRNOpt3StrGadget.Flags &= ~GADGDISABLED;
				KRNOpt3StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt3StrGadSIBuff, Key->ShiftAlt, 1);
			}
			else if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT)) {
				KRNormalIText3.IText = KRCtrlShiftString;
				KRNOpt3StrGadget.Flags &= ~GADGDISABLED;
				KRNOpt3StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt3StrGadSIBuff, Key->CtrlShift, 1);
			}
			else if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT)) {
				KRNormalIText3.IText = KRCtrlAltString;
				KRNOpt3StrGadget.Flags &= ~GADGDISABLED;
				KRNOpt3StrGadSInfo.BufferPos = ExpandCtrl(KRNOpt3StrGadSIBuff, Key->CtrlAlt, 1);
			}
			else {
				KRNormalIText3.IText = NULL;
				KRNOpt3StrGadget.Flags |= GADGDISABLED;
				KRNOpt3StrGadSIBuff[0] = '\x00';
				KRNOpt3StrGadSInfo.BufferPos = 0;
			}
			break;
		case KCF_STRING:
			KRNOPGadget.Flags &= ~SELECTED;
			KRNoQualGadget.Flags &= ~SELECTED;
			KRStringGadget.Flags |= SELECTED;
			KRDeadGadget.Flags &= ~SELECTED;
			KRRepeatableGadget.NextGadget = KRStringGadgetList;
			KRRequester.ReqText = KRStringITextList;

			KRSAloneStrGadSInfo.BufferPos = ExpandCtrl(KRSAloneStrGadSIBuff, Key->Alone, Key->AloneLen);
			if (Key->Type & KCF_SHIFT) {
				KRSShiftStrGadget.Flags &= ~GADGDISABLED;
				KRSShiftStrGadSInfo.BufferPos = ExpandCtrl(KRSShiftStrGadSIBuff, Key->Shift, Key->ShiftLen);
			}
			else {
				KRSShiftStrGadget.Flags |= GADGDISABLED;
				KRSShiftStrGadSIBuff[0] = '\x00';
				KRSShiftStrGadSInfo.BufferPos = 0;
			}
			if (Key->Type & KCF_ALT) {
				KRSAltStrGadget.Flags &= ~GADGDISABLED;
				KRSAltStrGadSInfo.BufferPos = ExpandCtrl(KRSAltStrGadSIBuff, Key->Alt, Key->AltLen);
			}
			else {
				KRSAltStrGadget.Flags |= GADGDISABLED;
				KRSAltStrGadSIBuff[0] = '\x00';
				KRSAltStrGadSInfo.BufferPos = 0;
			}
			if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT)) {
				KRSShiftAltStrGadget.Flags &= ~GADGDISABLED;
				KRSShiftAltStrGadSInfo.BufferPos = ExpandCtrl(KRSShiftAltStrGadSIBuff, Key->ShiftAlt, Key->ShiftAltLen);
			}
			else {
				KRSShiftAltStrGadget.Flags |= GADGDISABLED;
				KRSShiftAltStrGadSIBuff[0] = '\x00';
				KRSShiftAltStrGadSInfo.BufferPos = 0;
			}
			if (Key->Type & KCF_CONTROL) {
				KRSCtrlStrGadget.Flags &= ~GADGDISABLED;
				KRSCtrlStrGadSInfo.BufferPos = ExpandCtrl(KRSCtrlStrGadSIBuff, Key->Ctrl, Key->CtrlLen);
			}
			else {
				KRSCtrlStrGadget.Flags |= GADGDISABLED;
				KRSCtrlStrGadSIBuff[0] = '\x00';
				KRSCtrlStrGadSInfo.BufferPos = 0;
			}
			if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT)) {
				KRSCtrlShiftStrGadget.Flags &= ~GADGDISABLED;
				KRSCtrlShiftStrGadSInfo.BufferPos = ExpandCtrl(KRSCtrlShiftStrGadSIBuff, Key->CtrlShift, Key->CtrlShiftLen);
			}
			else {
				KRSCtrlShiftStrGadget.Flags |= GADGDISABLED;
				KRSCtrlShiftStrGadSIBuff[0] = '\x00';
				KRSCtrlShiftStrGadSInfo.BufferPos = 0;
			}
			if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT)) {
				KRSCtrlAltStrGadget.Flags &= ~GADGDISABLED;
				KRSCtrlAltStrGadSInfo.BufferPos = ExpandCtrl(KRSCtrlAltStrGadSIBuff, Key->CtrlAlt, Key->CtrlAltLen);
			}
			else {
				KRSCtrlAltStrGadget.Flags |= GADGDISABLED;
				KRSCtrlAltStrGadSIBuff[0] = '\x00';
				KRSCtrlAltStrGadSInfo.BufferPos = 0;
			}
			if ((Key->Type & KC_VANILLA) == KC_VANILLA) {
				KRSVanillaStrGadget.Flags &= ~GADGDISABLED;
				KRSVanillaStrGadSInfo.BufferPos = ExpandCtrl(KRSVanillaStrGadSIBuff, Key->Vanilla, Key->VanillaLen);
			}
			else {
				KRSVanillaStrGadget.Flags |= GADGDISABLED;
				KRSVanillaStrGadSIBuff[0] = '\x00';
				KRSVanillaStrGadSInfo.BufferPos = 0;
			}
			break;
		case KCF_DEAD:
			KRNOPGadget.Flags &= ~SELECTED;
			KRNoQualGadget.Flags &= ~SELECTED;
			KRStringGadget.Flags &= ~SELECTED;
			KRDeadGadget.Flags |= SELECTED;
			KRRepeatableGadget.NextGadget = KRDeadGadgetList;
			KRRequester.ReqText = KRDeadITextList;

			KRDAloneModGadget.Flags &= ~(SELECTED|GADGDISABLED);
			KRDAloneDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
			switch (Key->AloneOpt) {
				case KC_NOQUAL:
					KRDAloneDeadGadget.NextGadget = &KRDAloneNormalStrGadget;
					KRDAloneNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDAloneNormalStrGadSIBuff, Key->Alone, 1);
					break;
				case DPF_MOD:
					KRDAloneModGadget.Flags |= SELECTED;
					KRDAloneDeadGadget.NextGadget = &KRDAloneMod0StrGadget;
					KRDAloneMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDAloneMod0StrGadSIBuff, &Key->Alone[0], 1);
					KRDAloneMod0StrGadSInfo.DispPos = KRDAloneMod0StrGadSInfo.BufferPos - 1;
					KRDAloneMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDAloneMod1StrGadSIBuff, &Key->Alone[1], 1);
					KRDAloneMod1StrGadSInfo.DispPos = KRDAloneMod1StrGadSInfo.BufferPos - 1;
					KRDAloneMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDAloneMod2StrGadSIBuff, &Key->Alone[2], 1);
					KRDAloneMod2StrGadSInfo.DispPos = KRDAloneMod2StrGadSInfo.BufferPos - 1;
					KRDAloneMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDAloneMod3StrGadSIBuff, &Key->Alone[3], 1);
					KRDAloneMod3StrGadSInfo.DispPos = KRDAloneMod3StrGadSInfo.BufferPos - 1;
					KRDAloneMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDAloneMod4StrGadSIBuff, &Key->Alone[4], 1);
					KRDAloneMod4StrGadSInfo.DispPos = KRDAloneMod4StrGadSInfo.BufferPos - 1;
					KRDAloneMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDAloneMod5StrGadSIBuff, &Key->Alone[5], 1);
					KRDAloneMod5StrGadSInfo.DispPos = KRDAloneMod5StrGadSInfo.BufferPos - 1;
					break;
				case DPF_DEAD:
					KRDAloneDeadGadget.Flags |= SELECTED;
					KRDAloneDeadGadget.NextGadget = &KRDAloneAcc1Gadget;
					KRDAloneAcc1Gadget.Flags &= ~SELECTED;
					KRDAloneAcc2Gadget.Flags &= ~SELECTED;
					KRDAloneAcc3Gadget.Flags &= ~SELECTED;
					KRDAloneAcc4Gadget.Flags &= ~SELECTED;
					KRDAloneAcc5Gadget.Flags &= ~SELECTED;
					switch (Key->Alone[0]) {
						case 01:
							KRDAloneAcc1Gadget.Flags |= SELECTED;
							break;
						case 02:
							KRDAloneAcc2Gadget.Flags |= SELECTED;
							break;
						case 03:
							KRDAloneAcc3Gadget.Flags |= SELECTED;
							break;
						case 04:
							KRDAloneAcc4Gadget.Flags |= SELECTED;
							break;
						case 05:
							KRDAloneAcc5Gadget.Flags |= SELECTED;
					} /* switch */
			} /* switch */
			KRDShiftModGadget.Flags &= ~(SELECTED|GADGDISABLED);
			KRDShiftDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
			if (Key->Type & KCF_SHIFT)
				switch (Key->ShiftOpt) {
					case KC_NOQUAL:
						KRDShiftDeadGadget.NextGadget = &KRDShiftNormalStrGadget;
						KRDShiftNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDShiftNormalStrGadSIBuff, Key->Shift, 1);
						break;
					case DPF_MOD:
						KRDShiftModGadget.Flags |= SELECTED;
						KRDShiftDeadGadget.NextGadget = &KRDShiftMod0StrGadget;
						KRDShiftMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftMod0StrGadSIBuff, &Key->Shift[0], 1);
						KRDShiftMod0StrGadSInfo.DispPos = KRDShiftMod0StrGadSInfo.BufferPos - 1;
						KRDShiftMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftMod1StrGadSIBuff, &Key->Shift[1], 1);
						KRDShiftMod1StrGadSInfo.DispPos = KRDShiftMod1StrGadSInfo.BufferPos - 1;
						KRDShiftMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftMod2StrGadSIBuff, &Key->Shift[2], 1);
						KRDShiftMod2StrGadSInfo.DispPos = KRDShiftMod2StrGadSInfo.BufferPos - 1;
						KRDShiftMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftMod3StrGadSIBuff, &Key->Shift[3], 1);
						KRDShiftMod3StrGadSInfo.DispPos = KRDShiftMod3StrGadSInfo.BufferPos - 1;
						KRDShiftMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftMod4StrGadSIBuff, &Key->Shift[4], 1);
						KRDShiftMod4StrGadSInfo.DispPos = KRDShiftMod4StrGadSInfo.BufferPos - 1;
						KRDShiftMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftMod5StrGadSIBuff, &Key->Shift[5], 1);
						KRDShiftMod5StrGadSInfo.DispPos = KRDShiftMod5StrGadSInfo.BufferPos - 1;
						break;
					case DPF_DEAD:
						KRDShiftDeadGadget.Flags |= SELECTED;
						KRDShiftDeadGadget.NextGadget = &KRDShiftAcc1Gadget;
						KRDShiftAcc1Gadget.Flags &= ~SELECTED;
						KRDShiftAcc2Gadget.Flags &= ~SELECTED;
						KRDShiftAcc3Gadget.Flags &= ~SELECTED;
						KRDShiftAcc4Gadget.Flags &= ~SELECTED;
						KRDShiftAcc5Gadget.Flags &= ~SELECTED;
						switch (Key->Shift[0]) {
							case 01:
								KRDShiftAcc1Gadget.Flags |= SELECTED;
								break;
							case 02:
								KRDShiftAcc2Gadget.Flags |= SELECTED;
								break;
							case 03:
								KRDShiftAcc3Gadget.Flags |= SELECTED;
								break;
							case 04:
								KRDShiftAcc4Gadget.Flags |= SELECTED;
								break;
							case 05:
								KRDShiftAcc5Gadget.Flags |= SELECTED;
						} /* switch */
				} /* switch */
			else {
				KRDShiftModGadget.Flags |= GADGDISABLED;
				KRDShiftDeadGadget.Flags |= GADGDISABLED;
				KRDShiftDeadGadget.NextGadget = &KRDAltModGadget;
			}
			KRDAltModGadget.Flags &= ~(SELECTED|GADGDISABLED);
			KRDAltDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
			if (Key->Type & KCF_ALT)
				switch (Key->AltOpt) {
					case KC_NOQUAL:
						KRDAltDeadGadget.NextGadget = &KRDAltNormalStrGadget;
						KRDAltNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDAltNormalStrGadSIBuff, Key->Alt, 1);
						break;
					case DPF_MOD:
						KRDAltModGadget.Flags |= SELECTED;
						KRDAltDeadGadget.NextGadget = &KRDAltMod0StrGadget;
						KRDAltMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDAltMod0StrGadSIBuff, &Key->Alt[0], 1);
						KRDAltMod0StrGadSInfo.DispPos = KRDAltMod0StrGadSInfo.BufferPos - 1;
						KRDAltMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDAltMod1StrGadSIBuff, &Key->Alt[1], 1);
						KRDAltMod1StrGadSInfo.DispPos = KRDAltMod1StrGadSInfo.BufferPos - 1;
						KRDAltMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDAltMod2StrGadSIBuff, &Key->Alt[2], 1);
						KRDAltMod2StrGadSInfo.DispPos = KRDAltMod2StrGadSInfo.BufferPos - 1;
						KRDAltMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDAltMod3StrGadSIBuff, &Key->Alt[3], 1);
						KRDAltMod3StrGadSInfo.DispPos = KRDAltMod3StrGadSInfo.BufferPos - 1;
						KRDAltMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDAltMod4StrGadSIBuff, &Key->Alt[4], 1);
						KRDAltMod4StrGadSInfo.DispPos = KRDAltMod4StrGadSInfo.BufferPos - 1;
						KRDAltMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDAltMod5StrGadSIBuff, &Key->Alt[5], 1);
						KRDAltMod5StrGadSInfo.DispPos = KRDAltMod5StrGadSInfo.BufferPos - 1;
						break;
					case DPF_DEAD:
						KRDAltDeadGadget.Flags |= SELECTED;
						KRDAltDeadGadget.NextGadget = &KRDAltAcc1Gadget;
						KRDAltAcc1Gadget.Flags &= ~SELECTED;
						KRDAltAcc2Gadget.Flags &= ~SELECTED;
						KRDAltAcc3Gadget.Flags &= ~SELECTED;
						KRDAltAcc4Gadget.Flags &= ~SELECTED;
						KRDAltAcc5Gadget.Flags &= ~SELECTED;
						switch (Key->Alt[0]) {
							case 01:
								KRDAltAcc1Gadget.Flags |= SELECTED;
								break;
							case 02:
								KRDAltAcc2Gadget.Flags |= SELECTED;
								break;
							case 03:
								KRDAltAcc3Gadget.Flags |= SELECTED;
								break;
							case 04:
								KRDAltAcc4Gadget.Flags |= SELECTED;
								break;
							case 05:
								KRDAltAcc5Gadget.Flags |= SELECTED;
						} /* switch */
				} /* switch */
			else {
				KRDAltModGadget.Flags |= GADGDISABLED;
				KRDAltDeadGadget.Flags |= GADGDISABLED;
				KRDAltDeadGadget.NextGadget = &KRDShiftAltModGadget;
			}
			KRDShiftAltModGadget.Flags &= ~(SELECTED|GADGDISABLED);
			KRDShiftAltDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
			if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
				switch (Key->ShiftAltOpt) {
					case KC_NOQUAL:
						KRDShiftAltDeadGadget.NextGadget = &KRDShiftAltNormalStrGadget;
						KRDShiftAltNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDShiftAltNormalStrGadSIBuff, Key->ShiftAlt, 1);
						break;
					case DPF_MOD:
						KRDShiftAltModGadget.Flags |= SELECTED;
						KRDShiftAltDeadGadget.NextGadget = &KRDShiftAltMod0StrGadget;
						KRDShiftAltMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftAltMod0StrGadSIBuff, &Key->ShiftAlt[0], 1);
						KRDShiftAltMod0StrGadSInfo.DispPos = KRDShiftAltMod0StrGadSInfo.BufferPos - 1;
						KRDShiftAltMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftAltMod1StrGadSIBuff, &Key->ShiftAlt[1], 1);
						KRDShiftAltMod1StrGadSInfo.DispPos = KRDShiftAltMod1StrGadSInfo.BufferPos - 1;
						KRDShiftAltMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftAltMod2StrGadSIBuff, &Key->ShiftAlt[2], 1);
						KRDShiftAltMod2StrGadSInfo.DispPos = KRDShiftAltMod2StrGadSInfo.BufferPos - 1;
						KRDShiftAltMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftAltMod3StrGadSIBuff, &Key->ShiftAlt[3], 1);
						KRDShiftAltMod3StrGadSInfo.DispPos = KRDShiftAltMod3StrGadSInfo.BufferPos - 1;
						KRDShiftAltMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftAltMod4StrGadSIBuff, &Key->ShiftAlt[4], 1);
						KRDShiftAltMod4StrGadSInfo.DispPos = KRDShiftAltMod4StrGadSInfo.BufferPos - 1;
						KRDShiftAltMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDShiftAltMod5StrGadSIBuff, &Key->ShiftAlt[5], 1);
						KRDShiftAltMod5StrGadSInfo.DispPos = KRDShiftAltMod5StrGadSInfo.BufferPos - 1;
					case DPF_DEAD:
						KRDShiftAltDeadGadget.Flags |= SELECTED;
						KRDShiftAltDeadGadget.NextGadget = &KRDShiftAltAcc1Gadget;
						KRDShiftAltAcc1Gadget.Flags &= ~SELECTED;
						KRDShiftAltAcc2Gadget.Flags &= ~SELECTED;
						KRDShiftAltAcc3Gadget.Flags &= ~SELECTED;
						KRDShiftAltAcc4Gadget.Flags &= ~SELECTED;
						KRDShiftAltAcc5Gadget.Flags &= ~SELECTED;
						switch (Key->ShiftAlt[0]) {
							case 01:
								KRDShiftAltAcc1Gadget.Flags |= SELECTED;
								break;
							case 02:
								KRDShiftAltAcc2Gadget.Flags |= SELECTED;
								break;
							case 03:
								KRDShiftAltAcc3Gadget.Flags |= SELECTED;
								break;
							case 04:
								KRDShiftAltAcc4Gadget.Flags |= SELECTED;
								break;
							case 05:
								KRDShiftAltAcc5Gadget.Flags |= SELECTED;
						} /* switch */
				} /* switch */
			else {
				KRDShiftAltModGadget.Flags |= GADGDISABLED;
				KRDShiftAltDeadGadget.Flags |= GADGDISABLED;
				KRDShiftAltDeadGadget.NextGadget = &KRDCtrlModGadget;
			}
			KRDCtrlModGadget.Flags &= ~(SELECTED|GADGDISABLED);
			KRDCtrlDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
			if (Key->Type & KCF_CONTROL)
				switch (Key->CtrlOpt) {
					case KC_NOQUAL:
						KRDCtrlDeadGadget.NextGadget = &KRDCtrlNormalStrGadget;
						KRDCtrlNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlNormalStrGadSIBuff, Key->Ctrl, 1);
						break;
					case DPF_MOD:
						KRDCtrlModGadget.Flags |= SELECTED;
						KRDCtrlDeadGadget.NextGadget = &KRDCtrlMod0StrGadget;
						KRDCtrlMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlMod0StrGadSIBuff, &Key->Ctrl[0], 1);
						KRDCtrlMod0StrGadSInfo.DispPos = KRDCtrlMod0StrGadSInfo.BufferPos - 1;
						KRDCtrlMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlMod1StrGadSIBuff, &Key->Ctrl[1], 1);
						KRDCtrlMod1StrGadSInfo.DispPos = KRDCtrlMod1StrGadSInfo.BufferPos - 1;
						KRDCtrlMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlMod2StrGadSIBuff, &Key->Ctrl[2], 1);
						KRDCtrlMod2StrGadSInfo.DispPos = KRDCtrlMod2StrGadSInfo.BufferPos - 1;
						KRDCtrlMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlMod3StrGadSIBuff, &Key->Ctrl[3], 1);
						KRDCtrlMod3StrGadSInfo.DispPos = KRDCtrlMod3StrGadSInfo.BufferPos - 1;
						KRDCtrlMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlMod4StrGadSIBuff, &Key->Ctrl[4], 1);
						KRDCtrlMod4StrGadSInfo.DispPos = KRDCtrlMod4StrGadSInfo.BufferPos - 1;
						KRDCtrlMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlMod5StrGadSIBuff, &Key->Ctrl[5], 1);
						KRDCtrlMod5StrGadSInfo.DispPos = KRDCtrlMod5StrGadSInfo.BufferPos - 1;
						break;
					case DPF_DEAD:
						KRDCtrlDeadGadget.Flags |= SELECTED;
						KRDCtrlDeadGadget.NextGadget = &KRDCtrlAcc1Gadget;
						KRDCtrlAcc1Gadget.Flags &= ~SELECTED;
						KRDCtrlAcc2Gadget.Flags &= ~SELECTED;
						KRDCtrlAcc3Gadget.Flags &= ~SELECTED;
						KRDCtrlAcc4Gadget.Flags &= ~SELECTED;
						KRDCtrlAcc5Gadget.Flags &= ~SELECTED;
						switch (Key->Ctrl[0]) {
							case 01:
								KRDCtrlAcc1Gadget.Flags |= SELECTED;
								break;
							case 02:
								KRDCtrlAcc2Gadget.Flags |= SELECTED;
								break;
							case 03:
								KRDCtrlAcc3Gadget.Flags |= SELECTED;
								break;
							case 04:
								KRDCtrlAcc4Gadget.Flags |= SELECTED;
								break;
							case 05:
								KRDCtrlAcc5Gadget.Flags |= SELECTED;
						} /* switch */
				} /* switch */
			else {
				KRDCtrlModGadget.Flags |= GADGDISABLED;
				KRDCtrlDeadGadget.Flags |= GADGDISABLED;
				KRDCtrlDeadGadget.NextGadget = &KRDCtrlShiftModGadget;
			}
			KRDCtrlShiftModGadget.Flags &= ~(SELECTED|GADGDISABLED);
			KRDCtrlShiftDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
			if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
				switch (Key->CtrlShiftOpt) {
					case KC_NOQUAL:
						KRDCtrlShiftDeadGadget.NextGadget = &KRDCtrlShiftNormalStrGadget;
						KRDCtrlShiftNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlShiftNormalStrGadSIBuff, Key->CtrlShift, 1);
						break;
					case DPF_MOD:
						KRDCtrlShiftModGadget.Flags |= SELECTED;
						KRDCtrlShiftDeadGadget.NextGadget = &KRDCtrlShiftMod0StrGadget;
						KRDCtrlShiftMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlShiftMod0StrGadSIBuff, &Key->CtrlShift[0], 1);
						KRDCtrlShiftMod0StrGadSInfo.DispPos = KRDCtrlShiftMod0StrGadSInfo.BufferPos - 1;
						KRDCtrlShiftMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlShiftMod1StrGadSIBuff, &Key->CtrlShift[1], 1);
						KRDCtrlShiftMod1StrGadSInfo.DispPos = KRDCtrlShiftMod1StrGadSInfo.BufferPos - 1;
						KRDCtrlShiftMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlShiftMod2StrGadSIBuff, &Key->CtrlShift[2], 1);
						KRDCtrlShiftMod2StrGadSInfo.DispPos = KRDCtrlShiftMod2StrGadSInfo.BufferPos - 1;
						KRDCtrlShiftMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlShiftMod3StrGadSIBuff, &Key->CtrlShift[3], 1);
						KRDCtrlShiftMod3StrGadSInfo.DispPos = KRDCtrlShiftMod3StrGadSInfo.BufferPos - 1;
						KRDCtrlShiftMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlShiftMod4StrGadSIBuff, &Key->CtrlShift[4], 1);
						KRDCtrlShiftMod4StrGadSInfo.DispPos = KRDCtrlShiftMod4StrGadSInfo.BufferPos - 1;
						KRDCtrlShiftMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlShiftMod5StrGadSIBuff, &Key->CtrlShift[5], 1);
						KRDCtrlShiftMod5StrGadSInfo.DispPos = KRDCtrlShiftMod5StrGadSInfo.BufferPos - 1;
						break;
					case DPF_DEAD:
						KRDCtrlShiftDeadGadget.Flags |= SELECTED;
						KRDCtrlShiftDeadGadget.NextGadget = &KRDCtrlShiftAcc1Gadget;
						KRDCtrlShiftAcc1Gadget.Flags &= ~SELECTED;
						KRDCtrlShiftAcc2Gadget.Flags &= ~SELECTED;
						KRDCtrlShiftAcc3Gadget.Flags &= ~SELECTED;
						KRDCtrlShiftAcc4Gadget.Flags &= ~SELECTED;
						KRDCtrlShiftAcc5Gadget.Flags &= ~SELECTED;
						switch (Key->CtrlShift[0]) {
							case 01:
								KRDCtrlShiftAcc1Gadget.Flags |= SELECTED;
								break;
							case 02:
								KRDCtrlShiftAcc2Gadget.Flags |= SELECTED;
								break;
							case 03:
								KRDCtrlShiftAcc3Gadget.Flags |= SELECTED;
								break;
							case 04:
								KRDCtrlShiftAcc4Gadget.Flags |= SELECTED;
								break;
							case 05:
								KRDCtrlShiftAcc5Gadget.Flags |= SELECTED;
						} /* switch */
				} /* switch */
			else {
				KRDCtrlShiftModGadget.Flags |= GADGDISABLED;
				KRDCtrlShiftDeadGadget.Flags |= GADGDISABLED;
				KRDCtrlShiftDeadGadget.NextGadget = &KRDCtrlAltModGadget;
			}
			KRDCtrlAltModGadget.Flags &= ~(SELECTED|GADGDISABLED);
			KRDCtrlAltDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
			if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
				switch (Key->CtrlAltOpt) {
					case KC_NOQUAL:
						KRDCtrlAltDeadGadget.NextGadget = &KRDCtrlAltNormalStrGadget;
						KRDCtrlAltNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlAltNormalStrGadSIBuff, Key->CtrlAlt, 1);
						break;
					case DPF_MOD:
						KRDCtrlAltModGadget.Flags |= SELECTED;
						KRDCtrlAltDeadGadget.NextGadget = &KRDCtrlAltMod0StrGadget;
						KRDCtrlAltMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlAltMod0StrGadSIBuff, &Key->CtrlAlt[0], 1);
						KRDCtrlAltMod0StrGadSInfo.DispPos = KRDCtrlAltMod0StrGadSInfo.BufferPos - 1;
						KRDCtrlAltMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlAltMod1StrGadSIBuff, &Key->CtrlAlt[1], 1);
						KRDCtrlAltMod1StrGadSInfo.DispPos = KRDCtrlAltMod1StrGadSInfo.BufferPos - 1;
						KRDCtrlAltMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlAltMod2StrGadSIBuff, &Key->CtrlAlt[2], 1);
						KRDCtrlAltMod2StrGadSInfo.DispPos = KRDCtrlAltMod2StrGadSInfo.BufferPos - 1;
						KRDCtrlAltMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlAltMod3StrGadSIBuff, &Key->CtrlAlt[3], 1);
						KRDCtrlAltMod3StrGadSInfo.DispPos = KRDCtrlAltMod3StrGadSInfo.BufferPos - 1;
						KRDCtrlAltMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlAltMod4StrGadSIBuff, &Key->CtrlAlt[4], 1);
						KRDCtrlAltMod4StrGadSInfo.DispPos = KRDCtrlAltMod4StrGadSInfo.BufferPos - 1;
						KRDCtrlAltMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDCtrlAltMod5StrGadSIBuff, &Key->CtrlAlt[5], 1);
						KRDCtrlAltMod5StrGadSInfo.DispPos = KRDCtrlAltMod5StrGadSInfo.BufferPos - 1;
						break;
					case DPF_DEAD:
						KRDCtrlAltDeadGadget.Flags |= SELECTED;
						KRDCtrlAltDeadGadget.NextGadget = &KRDCtrlAltAcc1Gadget;
						KRDCtrlAltAcc1Gadget.Flags &= ~SELECTED;
						KRDCtrlAltAcc2Gadget.Flags &= ~SELECTED;
						KRDCtrlAltAcc3Gadget.Flags &= ~SELECTED;
						KRDCtrlAltAcc4Gadget.Flags &= ~SELECTED;
						KRDCtrlAltAcc5Gadget.Flags &= ~SELECTED;
						switch (Key->CtrlAlt[0]) {
							case 01:
								KRDCtrlAltAcc1Gadget.Flags |= SELECTED;
								break;
							case 02:
								KRDCtrlAltAcc2Gadget.Flags |= SELECTED;
								break;
							case 03:
								KRDCtrlAltAcc3Gadget.Flags |= SELECTED;
								break;
							case 04:
								KRDCtrlAltAcc4Gadget.Flags |= SELECTED;
								break;
							case 05:
								KRDCtrlAltAcc5Gadget.Flags |= SELECTED;
						} /* switch */
				} /* switch */
			else {
				KRDCtrlAltModGadget.Flags |= GADGDISABLED;
				KRDCtrlAltDeadGadget.Flags |= GADGDISABLED;
				KRDCtrlAltDeadGadget.NextGadget = &KRDVanillaModGadget;
			}
			KRDVanillaModGadget.Flags &= ~(SELECTED|GADGDISABLED);
			KRDVanillaDeadGadget.Flags &= ~(SELECTED|GADGDISABLED);
			if ((Key->Type & KC_VANILLA) == KC_VANILLA)
				switch (Key->VanillaOpt) {
					case KC_NOQUAL:
						KRDVanillaDeadGadget.NextGadget = &KRDVanillaNormalStrGadget;
						KRDVanillaNormalStrGadSInfo.BufferPos = ExpandCtrl(KRDVanillaNormalStrGadSIBuff, Key->Vanilla, 1);
						break;
					case DPF_MOD:
						KRDVanillaModGadget.Flags |= SELECTED;
						KRDVanillaDeadGadget.NextGadget = &KRDVanillaMod0StrGadget;
						KRDVanillaMod0StrGadSInfo.BufferPos = ExpandCtrl(KRDVanillaMod0StrGadSIBuff, &Key->Vanilla[0], 1);
						KRDVanillaMod0StrGadSInfo.DispPos = KRDVanillaMod0StrGadSInfo.BufferPos - 1;
						KRDVanillaMod1StrGadSInfo.BufferPos = ExpandCtrl(KRDVanillaMod1StrGadSIBuff, &Key->Vanilla[1], 1);
						KRDVanillaMod1StrGadSInfo.DispPos = KRDVanillaMod1StrGadSInfo.BufferPos - 1;
						KRDVanillaMod2StrGadSInfo.BufferPos = ExpandCtrl(KRDVanillaMod2StrGadSIBuff, &Key->Vanilla[2], 1);
						KRDVanillaMod2StrGadSInfo.DispPos = KRDVanillaMod2StrGadSInfo.BufferPos - 1;
						KRDVanillaMod3StrGadSInfo.BufferPos = ExpandCtrl(KRDVanillaMod3StrGadSIBuff, &Key->Vanilla[3], 1);
						KRDVanillaMod3StrGadSInfo.DispPos = KRDVanillaMod3StrGadSInfo.BufferPos - 1;
						KRDVanillaMod4StrGadSInfo.BufferPos = ExpandCtrl(KRDVanillaMod4StrGadSIBuff, &Key->Vanilla[4], 1);
						KRDVanillaMod4StrGadSInfo.DispPos = KRDVanillaMod4StrGadSInfo.BufferPos - 1;
						KRDVanillaMod5StrGadSInfo.BufferPos = ExpandCtrl(KRDVanillaMod5StrGadSIBuff, &Key->Vanilla[5], 1);
						KRDVanillaMod5StrGadSInfo.DispPos = KRDVanillaMod5StrGadSInfo.BufferPos - 1;
						break;
					case DPF_DEAD:
						KRDVanillaDeadGadget.Flags |= SELECTED;
						KRDVanillaDeadGadget.NextGadget = &KRDVanillaAcc1Gadget;
						KRDVanillaAcc1Gadget.Flags &= ~SELECTED;
						KRDVanillaAcc2Gadget.Flags &= ~SELECTED;
						KRDVanillaAcc3Gadget.Flags &= ~SELECTED;
						KRDVanillaAcc4Gadget.Flags &= ~SELECTED;
						KRDVanillaAcc5Gadget.Flags &= ~SELECTED;
						switch (Key->Vanilla[0]) {
							case 01:
								KRDVanillaAcc1Gadget.Flags |= SELECTED;
								break;
							case 02:
								KRDVanillaAcc2Gadget.Flags |= SELECTED;
								break;
							case 03:
								KRDVanillaAcc3Gadget.Flags |= SELECTED;
								break;
							case 04:
								KRDVanillaAcc4Gadget.Flags |= SELECTED;
								break;
							case 05:
								KRDVanillaAcc5Gadget.Flags |= SELECTED;
						} /* switch */
				} /* switch */
			else {
				KRDVanillaModGadget.Flags |= GADGDISABLED;
				KRDVanillaDeadGadget.Flags |= GADGDISABLED;
				KRDVanillaDeadGadget.NextGadget = &KRUseGadget;
			}
			break;
		case KCF_NOP:
			KRNOPGadget.Flags |= SELECTED;
			KRNoQualGadget.Flags &= ~SELECTED;
			KRStringGadget.Flags &= ~SELECTED;
			KRDeadGadget.Flags &= ~SELECTED;
			KRRepeatableGadget.NextGadget = KRNOPGadgetList;
			KRRequester.ReqText = NULL;
			break;
	} /* switch */
	KRShiftGadget.Flags &= ~(SELECTED|GADGDISABLED);
	KRAltGadget.Flags &= ~(SELECTED|GADGDISABLED);
	KRCtrlGadget.Flags &= ~(SELECTED|GADGDISABLED);
	KRCapsableGadget.Flags &= ~(SELECTED|GADGDISABLED);
	KRRepeatableGadget.Flags &= ~(SELECTED|GADGDISABLED);
	if (!(Key->Type & KCF_NOP)) {
		if (Key->Type & KCF_SHIFT)
			KRShiftGadget.Flags |= SELECTED;
		if (Key->Type & KCF_ALT)
			KRAltGadget.Flags |= SELECTED;
		if (Key->Type & KCF_CONTROL)
			KRCtrlGadget.Flags |= SELECTED;
		if (Key->Capsable)
			KRCapsableGadget.Flags |= SELECTED;
		if (Key->Repeatable)
			KRRepeatableGadget.Flags |= SELECTED;
	}
	else {
		KRShiftGadget.Flags |= GADGDISABLED;
		KRAltGadget.Flags |= GADGDISABLED;
		KRCtrlGadget.Flags |= GADGDISABLED;
		KRCapsableGadget.Flags |= GADGDISABLED;
		KRRepeatableGadget.Flags |= GADGDISABLED;
	}
}

/*
 * Update Key
 */
void UpdateKey(Key)
struct KeyNode *Key;
{
	switch(Key->Type & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
		case KC_NOQUAL:
			Key->AloneLen = CollapseCtrl(Key->Alone, KRNAloneStrGadSIBuff, 1);
			if (Key->Type & KCF_SHIFT)
				Key->ShiftLen = CollapseCtrl(Key->Shift, KRNOpt1StrGadSIBuff, 1);
			else if (Key->Type & KCF_ALT)
				Key->AltLen = CollapseCtrl(Key->Alt, KRNOpt1StrGadSIBuff, 1);
			else if (Key->Type & KCF_CONTROL)
				Key->CtrlLen = CollapseCtrl(Key->Ctrl, KRNOpt1StrGadSIBuff, 1);
			if ((Key->Type & KCF_ALT) && (Key->Type & KCF_SHIFT))
				Key->AltLen = CollapseCtrl(Key->Alt, KRNOpt2StrGadSIBuff, 1);
			else if ((Key->Type & KCF_CONTROL) && (Key->Type & (KCF_SHIFT|KCF_ALT)))
				Key->CtrlLen = CollapseCtrl(Key->Ctrl, KRNOpt2StrGadSIBuff, 1);
			if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
				Key->ShiftAltLen = CollapseCtrl(Key->ShiftAlt, KRNOpt3StrGadSIBuff, 1);
			else if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
				Key->CtrlShiftLen = CollapseCtrl(Key->CtrlShift, KRNOpt3StrGadSIBuff, 1);
			else if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
				Key->CtrlAltLen = CollapseCtrl(Key->CtrlAlt, KRNOpt3StrGadSIBuff, 1);
			break;
		case KCF_STRING:
			Key->AloneLen = CollapseCtrl(Key->Alone, KRSAloneStrGadSIBuff, 32);
			Key->ShiftLen = CollapseCtrl(Key->Shift, KRSShiftStrGadSIBuff, 32);
			Key->AltLen = CollapseCtrl(Key->Alt, KRSAltStrGadSIBuff, 32);
			Key->ShiftAltLen = CollapseCtrl(Key->ShiftAlt, KRSShiftAltStrGadSIBuff, 32);
			Key->CtrlLen = CollapseCtrl(Key->Ctrl, KRSCtrlStrGadSIBuff, 32);
			Key->CtrlShiftLen = CollapseCtrl(Key->CtrlShift, KRSCtrlShiftStrGadSIBuff, 32);
			Key->CtrlAltLen = CollapseCtrl(Key->CtrlAlt, KRSCtrlAltStrGadSIBuff, 32);
			Key->VanillaLen = CollapseCtrl(Key->Vanilla, KRSVanillaStrGadSIBuff, 32);
			break;
		case KCF_DEAD:
			switch (Key->AloneOpt) {
				case KC_NOQUAL:
					Key->AloneLen = CollapseCtrl(Key->Alone, KRDAloneNormalStrGadSIBuff, 1);
					break;
				case DPF_MOD:
					Key->AloneLen = 6;
					CollapseCtrl(&Key->Alone[0], KRDAloneMod0StrGadSIBuff, 1);
					CollapseCtrl(&Key->Alone[1], KRDAloneMod1StrGadSIBuff, 1);
					CollapseCtrl(&Key->Alone[2], KRDAloneMod2StrGadSIBuff, 1);
					CollapseCtrl(&Key->Alone[3], KRDAloneMod3StrGadSIBuff, 1);
					CollapseCtrl(&Key->Alone[4], KRDAloneMod4StrGadSIBuff, 1);
					CollapseCtrl(&Key->Alone[5], KRDAloneMod5StrGadSIBuff, 1);
					break;
				case DPF_DEAD:
					Key->AloneLen = 1;
					if (KRDAloneAcc1Gadget.Flags & SELECTED)
						Key->Alone[0] = 1;
					else if (KRDAloneAcc2Gadget.Flags & SELECTED)
						Key->Alone[0] = 2;
					else if (KRDAloneAcc3Gadget.Flags & SELECTED)
						Key->Alone[0] = 3;
					else if (KRDAloneAcc4Gadget.Flags & SELECTED)
						Key->Alone[0] = 4;
					else
						Key->Alone[0] = 5;
					Key->Alone[1] = '\x00';
			} /* switch */
			switch (Key->ShiftOpt) {
				case KC_NOQUAL:
					Key->ShiftLen = CollapseCtrl(Key->Shift, KRDShiftNormalStrGadSIBuff, 1);
					break;
				case DPF_MOD:
					Key->ShiftLen = 6;
					CollapseCtrl(&Key->Shift[0], KRDShiftMod0StrGadSIBuff, 1);
					CollapseCtrl(&Key->Shift[1], KRDShiftMod1StrGadSIBuff, 1);
					CollapseCtrl(&Key->Shift[2], KRDShiftMod2StrGadSIBuff, 1);
					CollapseCtrl(&Key->Shift[3], KRDShiftMod3StrGadSIBuff, 1);
					CollapseCtrl(&Key->Shift[4], KRDShiftMod4StrGadSIBuff, 1);
					CollapseCtrl(&Key->Shift[5], KRDShiftMod5StrGadSIBuff, 1);
					break;
				case DPF_DEAD:
					Key->ShiftLen = 1;
					if (KRDShiftAcc1Gadget.Flags & SELECTED)
						Key->Shift[0] = 1;
					else if (KRDShiftAcc2Gadget.Flags & SELECTED)
						Key->Shift[0] = 2;
					else if (KRDShiftAcc3Gadget.Flags & SELECTED)
						Key->Shift[0] = 3;
					else if (KRDShiftAcc4Gadget.Flags & SELECTED)
						Key->Shift[0] = 4;
					else
						Key->Shift[0] = 5;
					Key->Shift[1] = '\x00';
			} /* switch */
			switch (Key->AltOpt) {
				case KC_NOQUAL:
					Key->AltLen = CollapseCtrl(Key->Alt, KRDAltNormalStrGadSIBuff, 1);
					break;
				case DPF_MOD:
					Key->AltLen = 6;
					CollapseCtrl(&Key->Alt[0], KRDAltMod0StrGadSIBuff, 1);
					CollapseCtrl(&Key->Alt[1], KRDAltMod1StrGadSIBuff, 1);
					CollapseCtrl(&Key->Alt[2], KRDAltMod2StrGadSIBuff, 1);
					CollapseCtrl(&Key->Alt[3], KRDAltMod3StrGadSIBuff, 1);
					CollapseCtrl(&Key->Alt[4], KRDAltMod4StrGadSIBuff, 1);
					CollapseCtrl(&Key->Alt[5], KRDAltMod5StrGadSIBuff, 1);
					break;
				case DPF_DEAD:
					Key->AltLen = 1;
					if (KRDAltAcc1Gadget.Flags & SELECTED)
						Key->Alt[0] = 1;
					else if (KRDAltAcc2Gadget.Flags & SELECTED)
						Key->Alt[0] = 2;
					else if (KRDAltAcc3Gadget.Flags & SELECTED)
						Key->Alt[0] = 3;
					else if (KRDAltAcc4Gadget.Flags & SELECTED)
						Key->Alt[0] = 4;
					else
						Key->Alt[0] = 5;
					Key->Alt[1] = '\x00';
			} /* switch */
			switch (Key->ShiftAltOpt) {
				case KC_NOQUAL:
					Key->ShiftAltLen = CollapseCtrl(Key->ShiftAlt, KRDShiftAltNormalStrGadSIBuff, 1);
					break;
				case DPF_MOD:
					Key->ShiftAltLen = 6;
					CollapseCtrl(&Key->ShiftAlt[0], KRDShiftAltMod0StrGadSIBuff, 1);
					CollapseCtrl(&Key->ShiftAlt[1], KRDShiftAltMod1StrGadSIBuff, 1);
					CollapseCtrl(&Key->ShiftAlt[2], KRDShiftAltMod2StrGadSIBuff, 1);
					CollapseCtrl(&Key->ShiftAlt[3], KRDShiftAltMod3StrGadSIBuff, 1);
					CollapseCtrl(&Key->ShiftAlt[4], KRDShiftAltMod4StrGadSIBuff, 1);
					CollapseCtrl(&Key->ShiftAlt[5], KRDShiftAltMod5StrGadSIBuff, 1);
					break;
				case DPF_DEAD:
					Key->ShiftAltLen = 1;
					if (KRDShiftAltAcc1Gadget.Flags & SELECTED)
						Key->ShiftAlt[0] = 1;
					else if (KRDShiftAltAcc2Gadget.Flags & SELECTED)
						Key->ShiftAlt[0] = 2;
					else if (KRDShiftAltAcc3Gadget.Flags & SELECTED)
						Key->ShiftAlt[0] = 3;
					else if (KRDShiftAltAcc4Gadget.Flags & SELECTED)
						Key->ShiftAlt[0] = 4;
					else
						Key->ShiftAlt[0] = 5;
					Key->ShiftAlt[1] = '\x00';
			} /* switch */
			switch (Key->CtrlOpt) {
				case KC_NOQUAL:
					Key->CtrlLen = CollapseCtrl(Key->Ctrl, KRDCtrlNormalStrGadSIBuff, 1);
					break;
				case DPF_MOD:
					Key->CtrlLen = 6;
					CollapseCtrl(&Key->Ctrl[0], KRDCtrlMod0StrGadSIBuff, 1);
					CollapseCtrl(&Key->Ctrl[1], KRDCtrlMod1StrGadSIBuff, 1);
					CollapseCtrl(&Key->Ctrl[2], KRDCtrlMod2StrGadSIBuff, 1);
					CollapseCtrl(&Key->Ctrl[3], KRDCtrlMod3StrGadSIBuff, 1);
					CollapseCtrl(&Key->Ctrl[4], KRDCtrlMod4StrGadSIBuff, 1);
					CollapseCtrl(&Key->Ctrl[5], KRDCtrlMod5StrGadSIBuff, 1);
					break;
				case DPF_DEAD:
					Key->CtrlLen = 1;
					if (KRDCtrlAcc1Gadget.Flags & SELECTED)
						Key->Ctrl[0] = 1;
					else if (KRDCtrlAcc2Gadget.Flags & SELECTED)
						Key->Ctrl[0] = 2;
					else if (KRDCtrlAcc3Gadget.Flags & SELECTED)
						Key->Ctrl[0] = 3;
					else if (KRDCtrlAcc4Gadget.Flags & SELECTED)
						Key->Ctrl[0] = 4;
					else
						Key->Ctrl[0] = 5;
					Key->Ctrl[1] = '\x00';
			} /* switch */
			switch (Key->CtrlShiftOpt) {
				case KC_NOQUAL:
					Key->CtrlShiftLen = CollapseCtrl(Key->CtrlShift, KRDCtrlShiftNormalStrGadSIBuff, 1);
					break;
				case DPF_MOD:
					Key->CtrlShiftLen = 6;
					CollapseCtrl(&Key->CtrlShift[0], KRDCtrlShiftMod0StrGadSIBuff, 1);
					CollapseCtrl(&Key->CtrlShift[1], KRDCtrlShiftMod1StrGadSIBuff, 1);
					CollapseCtrl(&Key->CtrlShift[2], KRDCtrlShiftMod2StrGadSIBuff, 1);
					CollapseCtrl(&Key->CtrlShift[3], KRDCtrlShiftMod3StrGadSIBuff, 1);
					CollapseCtrl(&Key->CtrlShift[4], KRDCtrlShiftMod4StrGadSIBuff, 1);
					CollapseCtrl(&Key->CtrlShift[5], KRDCtrlShiftMod5StrGadSIBuff, 1);
					break;
				case DPF_DEAD:
					Key->CtrlShiftLen = 1;
					if (KRDCtrlShiftAcc1Gadget.Flags & SELECTED)
						Key->CtrlShift[0] = 1;
					else if (KRDCtrlShiftAcc2Gadget.Flags & SELECTED)
						Key->CtrlShift[0] = 2;
					else if (KRDCtrlShiftAcc3Gadget.Flags & SELECTED)
						Key->CtrlShift[0] = 3;
					else if (KRDCtrlShiftAcc4Gadget.Flags & SELECTED)
						Key->CtrlShift[0] = 4;
					else
						Key->CtrlShift[0] = 5;
					Key->CtrlShift[1] = '\x00';
			} /* switch */
			switch (Key->CtrlAltOpt) {
				case KC_NOQUAL:
					Key->CtrlAltLen = CollapseCtrl(Key->CtrlAlt, KRDCtrlAltNormalStrGadSIBuff, 1);
					break;
				case DPF_MOD:
					Key->CtrlAltLen = 6;
					CollapseCtrl(&Key->CtrlAlt[0], KRDCtrlAltMod0StrGadSIBuff, 1);
					CollapseCtrl(&Key->CtrlAlt[1], KRDCtrlAltMod1StrGadSIBuff, 1);
					CollapseCtrl(&Key->CtrlAlt[2], KRDCtrlAltMod2StrGadSIBuff, 1);
					CollapseCtrl(&Key->CtrlAlt[3], KRDCtrlAltMod3StrGadSIBuff, 1);
					CollapseCtrl(&Key->CtrlAlt[4], KRDCtrlAltMod4StrGadSIBuff, 1);
					CollapseCtrl(&Key->CtrlAlt[5], KRDCtrlAltMod5StrGadSIBuff, 1);
					break;
				case DPF_DEAD:
					Key->CtrlAltLen = 1;
					if (KRDCtrlAltAcc1Gadget.Flags & SELECTED)
						Key->CtrlAlt[0] = 1;
					else if (KRDCtrlAltAcc2Gadget.Flags & SELECTED)
						Key->CtrlAlt[0] = 2;
					else if (KRDCtrlAltAcc3Gadget.Flags & SELECTED)
						Key->CtrlAlt[0] = 3;
					else if (KRDCtrlAltAcc4Gadget.Flags & SELECTED)
						Key->CtrlAlt[0] = 4;
					else
						Key->CtrlAlt[0] = 5;
					Key->CtrlAlt[1] = '\x00';
			} /* switch */
			switch (Key->VanillaOpt) {
				case KC_NOQUAL:
					Key->VanillaLen = CollapseCtrl(Key->Vanilla, KRDVanillaNormalStrGadSIBuff, 1);
					break;
				case DPF_MOD:
					Key->VanillaLen = 6;
					CollapseCtrl(&Key->Vanilla[0], KRDVanillaMod0StrGadSIBuff, 1);
					CollapseCtrl(&Key->Vanilla[1], KRDVanillaMod1StrGadSIBuff, 1);
					CollapseCtrl(&Key->Vanilla[2], KRDVanillaMod2StrGadSIBuff, 1);
					CollapseCtrl(&Key->Vanilla[3], KRDVanillaMod3StrGadSIBuff, 1);
					CollapseCtrl(&Key->Vanilla[4], KRDVanillaMod4StrGadSIBuff, 1);
					CollapseCtrl(&Key->Vanilla[5], KRDVanillaMod5StrGadSIBuff, 1);
					break;
				case DPF_DEAD:
					Key->VanillaLen = 1;
					if (KRDVanillaAcc1Gadget.Flags & SELECTED)
						Key->Vanilla[0] = 1;
					else if (KRDVanillaAcc2Gadget.Flags & SELECTED)
						Key->Vanilla[0] = 2;
					else if (KRDVanillaAcc3Gadget.Flags & SELECTED)
						Key->Vanilla[0] = 3;
					else if (KRDVanillaAcc4Gadget.Flags & SELECTED)
						Key->Vanilla[0] = 4;
					else
						Key->Vanilla[0] = 5;
					Key->Vanilla[1] = '\x00';
			} /* switch */
			break;
		case KCF_NOP:
			break;
	} /* switch */
}

/*
 * Update Key Map
 */
void UpdateKeyMap(Key, KeyCode)
struct KeyNode *Key;
USHORT KeyCode;
{
	struct HalfKeyMap *HalfKeyMap;
	ULONG	KeyMapVal;
	UBYTE	*KeyMapPtr;
	UBYTE	buff[256];
	UBYTE	len, offsets;

	if (KeyCode < 0x40)
		HalfKeyMap = (struct HalfKeyMap *)&KeyMapNode->kn_KeyMap;
	else {
		HalfKeyMap = (struct HalfKeyMap *)&KeyMapNode->kn_KeyMap.km_HiKeyMapTypes;
		KeyCode -= 0x40;
	}
	switch (HalfKeyMap->KeyMapTypes[KeyCode] & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
		case KC_NOQUAL:
			HalfKeyMap->KeyMapTypes[KeyCode] = KCF_NOP;
			HalfKeyMap->KeyMap[KeyCode] = NULL;
			break;
		case KCF_STRING:
			len = StringKeyLength(HalfKeyMap, KeyCode, &offsets);
			FreeMem((char *)HalfKeyMap->KeyMap[KeyCode], len);
			HalfKeyMap->KeyMapTypes[KeyCode] = KCF_NOP;
			HalfKeyMap->KeyMap[KeyCode] = NULL;
			break;
		case KCF_DEAD:
			len = DeadKeyLength(HalfKeyMap, KeyCode, &offsets);
			FreeMem((char *)HalfKeyMap->KeyMap[KeyCode], len);
			HalfKeyMap->KeyMapTypes[KeyCode] = KCF_NOP;
			HalfKeyMap->KeyMap[KeyCode] = NULL;
			break;
	} /* switch */
	switch (Key->Type & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
		case KC_NOQUAL:
			KeyMapVal = Key->Alone[0];
			if (Key->Type & KCF_SHIFT)
				KeyMapVal |= Key->Shift[0]<<8;
			else if (Key->Type & KCF_ALT)
				KeyMapVal |= Key->Alt[0]<<8;
			else if (Key->Type & KCF_CONTROL)
				KeyMapVal |= Key->Ctrl[0]<<8;
			if ((Key->Type & KCF_ALT) && (Key->Type & KCF_SHIFT))
				KeyMapVal |= Key->Alt[0]<<16;
			else if ((Key->Type & KCF_CONTROL) && (Key->Type & (KCF_SHIFT|KCF_ALT)))
				KeyMapVal |= Key->Ctrl[0]<<16;
			if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
				KeyMapVal |= Key->ShiftAlt[0]<<24;
			else if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
				KeyMapVal |= Key->CtrlShift[0]<<24;
			else if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
				KeyMapVal |= Key->CtrlAlt[0]<<24;
			break;
		case KCF_STRING:
			buff[len = 0] = Key->AloneLen;
			if (Key->Type & KCF_SHIFT)
				buff[len += 2] = Key->ShiftLen;
			if (Key->Type & KCF_ALT)
				buff[len += 2] = Key->AltLen;
			if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
				buff[len += 2] = Key->ShiftAltLen;
			if (Key->Type & KCF_CONTROL)
				buff[len += 2] = Key->CtrlLen;
			if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
				buff[len += 2] = Key->CtrlShiftLen;
			if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
				buff[len += 2] = Key->CtrlAltLen;
			if ((Key->Type & KC_VANILLA) == KC_VANILLA)
				buff[len += 2] = Key->VanillaLen;
			memcpy(&buff[len += 2], Key->Alone, Key->AloneLen);
			buff[offsets = 1] = len;
			len += Key->AloneLen;
			if (Key->Type & KCF_SHIFT) {
				memcpy(&buff[len], Key->Shift, Key->ShiftLen);
				buff[offsets += 2] = len;
				len += Key->ShiftLen;
			}
			if (Key->Type & KCF_ALT) {
				memcpy(&buff[len], Key->Alt, Key->AltLen);
				buff[offsets += 2] = len;
				len += Key->AltLen;
			}
			if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT)) {
				memcpy(&buff[len], Key->ShiftAlt, Key->ShiftAltLen);
				buff[offsets += 2] = len;
				len += Key->ShiftAltLen;
			}
			if (Key->Type & KCF_CONTROL) {
				memcpy(&buff[len], Key->Ctrl, Key->CtrlLen);
				buff[offsets += 2] = len;
				len += Key->CtrlLen;
			}
			if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT)) {
				memcpy(&buff[len], Key->CtrlShift, Key->CtrlShiftLen);
				buff[offsets += 2] = len;
				len += Key->CtrlShiftLen;
			}
			if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT)) {
				memcpy(&buff[len], Key->CtrlAlt, Key->CtrlAltLen);
				buff[offsets += 2] = len;
				len += Key->CtrlAltLen;
			}
			if ((Key->Type & KC_VANILLA) == KC_VANILLA) {
				memcpy(&buff[len], Key->Vanilla, Key->VanillaLen);
				buff[offsets += 2] = len;
				len += Key->VanillaLen;
			}
			break;
		case KCF_DEAD:
			buff[len = 0] = Key->AloneOpt;
			if (Key->Type & KCF_SHIFT)
				buff[len += 2] = Key->ShiftOpt;
			if (Key->Type & KCF_ALT)
				buff[len += 2] = Key->AltOpt;
			if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
				buff[len += 2] = Key->ShiftAltOpt;
			if (Key->Type & KCF_CONTROL)
				buff[len += 2] = Key->CtrlOpt;
			if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
				buff[len += 2] = Key->CtrlShiftOpt;
			if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
				buff[len += 2] = Key->CtrlAltOpt;
			if ((Key->Type & KC_VANILLA) == KC_VANILLA)
				buff[len += 2] = Key->VanillaOpt;
			len += 2;
			switch (Key->AloneOpt) {
				case KC_NOQUAL:
				case DPF_DEAD:
					buff[offsets = 1] = Key->Alone[0];
					break;
				case DPF_MOD:
					memcpy(&buff[len], Key->Alone, 6);
					buff[offsets = 1] = len;
					len += 6;
			} /* switch */
			if (Key->Type & KCF_SHIFT)
				switch (Key->ShiftOpt) {
					case KC_NOQUAL:
					case DPF_DEAD:
						buff[offsets += 2] = Key->Shift[0];
						break;
					case DPF_MOD:
						memcpy(&buff[len], Key->Shift, 6);
						buff[offsets += 2] = len;
						len += 6;
				} /* switch */
			if (Key->Type & KCF_ALT)
				switch (Key->AltOpt) {
					case KC_NOQUAL:
					case DPF_DEAD:
						buff[offsets += 2] = Key->Alt[0];
						break;
					case DPF_MOD:
						memcpy(&buff[len], Key->Alt, 6);
						buff[offsets += 2] = len;
						len += 6;
				} /* switch */
			if ((Key->Type & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
				switch (Key->ShiftAltOpt) {
					case KC_NOQUAL:
					case DPF_DEAD:
						buff[offsets += 2] = Key->ShiftAlt[0];
						break;
					case DPF_MOD:
						memcpy(&buff[len], Key->ShiftAlt, 6);
						buff[offsets += 2] = len;
						len += 6;
				} /* switch */
			if (Key->Type & KCF_CONTROL)
				switch (Key->CtrlOpt) {
					case KC_NOQUAL:
					case DPF_DEAD:
						buff[offsets += 2] = Key->Ctrl[0];
						break;
					case DPF_MOD:
						memcpy(&buff[len], Key->Ctrl, 6);
						buff[offsets += 2] = len;
						len += 6;
				} /* switch */
			if ((Key->Type & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
				switch (Key->CtrlShiftOpt) {
					case KC_NOQUAL:
					case DPF_DEAD:
						buff[offsets += 2] = Key->CtrlShift[0];
						break;
					case DPF_MOD:
						memcpy(&buff[len], Key->CtrlShift, 6);
						buff[offsets += 2] = len;
						len += 6;
				} /* switch */
			if ((Key->Type & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
				switch (Key->CtrlAltOpt) {
					case KC_NOQUAL:
					case DPF_DEAD:
						buff[offsets += 2] = Key->CtrlAlt[0];
						break;
					case DPF_MOD:
						memcpy(&buff[len], Key->CtrlAlt, 6);
						buff[offsets += 2] = len;
						len += 6;
				} /* switch */
			if ((Key->Type & KC_VANILLA) == KC_VANILLA)
				switch (Key->VanillaOpt) {
					case KC_NOQUAL:
					case DPF_DEAD:
						buff[offsets += 2] = Key->Vanilla[0];
						break;
					case DPF_MOD:
						memcpy(&buff[len], Key->Vanilla, 6);
						buff[offsets += 2] = len;
						len += 6;
				} /* switch */
			break;
		case KCF_NOP:
			KeyMapVal = NULL;
	} /* switch */
	if (Key->Type & (KCF_STRING|KCF_DEAD)) {
		if ((KeyMapPtr = (char *)AllocMem(len, MEMF_CLEAR)) != NULL)
			memcpy(KeyMapPtr, buff, len);
		else {
			Write(Output(), "Memory Allocation Failed, UpdateKeyMap\n", 39);
			Key->Type = KCF_NOP;
			HalfKeyMap->KeyMap[KeyCode] = NULL;
		}
		HalfKeyMap->KeyMap[KeyCode] = (ULONG)KeyMapPtr;
	}
	else
		HalfKeyMap->KeyMap[KeyCode] = KeyMapVal;
	HalfKeyMap->KeyMapTypes[KeyCode] = Key->Type;
	if (Key->Capsable)
		HalfKeyMap->Capsable[KeyCode/8] |= (1<<(KeyCode % 8));
	else
		HalfKeyMap->Capsable[KeyCode/8] &= ~(1<<(KeyCode % 8));
	if (Key->Repeatable)
		HalfKeyMap->Repeatable[KeyCode/8] |= (1<<(KeyCode % 8));
	else
		HalfKeyMap->Repeatable[KeyCode/8] &= ~(1<<(KeyCode % 8));
}

/*
 * Expand Control Characters
 */
int ExpandCtrl(to, from, len)
unsigned char *to;
unsigned char *from;
int len;
{
	int	reslen = 0;
	int	count;

	for (count = 0; count < len; count++)
		if ((from[count] > '\x20') && (from[count] < '\x7F') && (from[count] != '\\'))
			to[reslen++] = from[count];
		else
			switch (from[count]) {
				case '\n':
					to[reslen++] = '\\';
					to[reslen++] = 'n';
					break;
				case '\t':
					to[reslen++] = '\\';
					to[reslen++] = 't';
					break;
				case '\v':
					to[reslen++] = '\\';
					to[reslen++] = 'v';
					break;
				case '\b':
					to[reslen++] = '\\';
					to[reslen++] = 'b';
					break;
				case '\r':
					to[reslen++] = '\\';
					to[reslen++] = 'r';
					break;
				case '\f':
					to[reslen++] = '\\';
					to[reslen++] = 'f';
					break;
				case '\\':
					to[reslen++] = '\\';
					to[reslen++] = '\\';
					break;
				default:
					to[reslen++] = '\\';
					to[reslen++] = 'x';
					if (from[count] < 0x10)
						to[reslen++] = '0';
					reslen += stci_h(&to[reslen], from[count]);
			} /* switch */
	to[reslen] = '\x00';
	return(reslen-1);
}

/*
 * Collapse Ctrl
 */
int CollapseCtrl(to, from, maxlen)
char *to;
char *from;
int maxlen;
{
	int	reslen = 0;
	int	count, offset, num;
	char	digit;

	for (count = 0; from[count] && (reslen < maxlen);)
		if (from[count] != '\\')
			to[reslen++] = from[count++];
		else {
			offset = 1;
			switch (from[count+1]) {
				case 'N':
				case 'n':
					to[reslen++] = '\n';
					break;
				case 'T':
				case 't':
					to[reslen++] = '\t';
					break;
				case 'V':
				case 'v':
					to[reslen++] = '\v';
					break;
				case 'B':
				case 'b':
					to[reslen++] = '\b';
					break;
				case 'R':
				case 'r':
					to[reslen++] = '\r';
					break;
				case 'F':
				case 'f':
					to[reslen++] = '\f';
					break;
				case '\\':
					to[reslen++] = '\\';
					break;
				case 'X':
				case 'x':
					num = 0;
					for (offset++; ((offset < 4) && (digit = tolower(from[count+offset])) && (isxdigit(digit))); offset++)
						if (isdigit(digit))
							num = (num<<4) | (digit-0x30);
						else
							num = (num<<4) | (tolower(digit)-0x57);
					to[reslen++] = num;
					break;
				default:
					num = 0;
					for (;((offset < 4) && (digit = from[count+offset]) && ((digit >= '0') && (digit <= '7'))); offset++)
						num = (num<<3) | (digit - 0x30);
					to[reslen++] = num;
			} /* switch */
			if (offset > 3)
				offset -= 1;
			count += (1 + offset);
		}
	return(reslen);		
}