/*
 * Key Map Editor ver 1.0
 * Process Gadget
 *
 * parameter: 	Gadget - Address of Gadget selected
 *
 * by: Tim Friest
 * on: January 1, 1989
 */

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

extern	int	CopyKey(struct KeyMap *, USHORT, USHORT);
extern	void	MoveKey(struct KeyMap *, USHORT, USHORT);
extern	void	SwapKeys(struct KeyMap *, USHORT, USHORT);
extern	void	ClearKey(struct KeyMap *, USHORT);

void	ProcGadget(Gad)
struct Gadget *Gad;
{
	int OldStatus;

	switch (Gad->GadgetID) {
		case 0x60:	/* Shift Key Toggled */
		case 0x61:
			OldStatus = CheckFlag(SF_Shift);
			if ((LeftShiftGadget.Flags & SELECTED) || (RightShiftGadget.Flags & SELECTED))
				SetFlag(SF_Shift);
			else
				ClearFlag(SF_Shift);
			if (OldStatus != (CheckFlag(SF_Shift)))
				UpdateDisplay(GadgetList, KeyMapNode, TRUE);
			break;
		case 0x62:	/* Caps Lock Key Toggled */
			OldStatus = CheckFlag(SF_CapsLock);
			if (Gad->Flags & SELECTED)
				SetFlag(SF_CapsLock);
			else
				ClearFlag(SF_CapsLock);
			if (!(CheckFlag(SF_Shift)) && (OldStatus != (CheckFlag(SF_CapsLock))))
				UpdateDisplay(GadgetList, KeyMapNode, TRUE);
			break;
		case 0x63:	/* Control Key Toggled */
			OldStatus = CheckFlag(SF_Control);
			if (Gad->Flags & SELECTED)
				SetFlag(SF_Control);
			else
				ClearFlag(SF_Control);
			if (OldStatus != (CheckFlag(SF_Control)))
				UpdateDisplay(GadgetList, KeyMapNode, TRUE);
			break;
		case 0x64:	/* Alt Key Toggled */
		case 0x65:
			OldStatus = CheckFlag(SF_Alt);
			if ((LeftAltGadget.Flags & SELECTED) || (RightAltGadget.Flags & SELECTED))
				SetFlag(SF_Alt);
			else
				ClearFlag(SF_Alt);
			if (OldStatus != (CheckFlag(SF_Alt)))
				UpdateDisplay(GadgetList, KeyMapNode, TRUE);
			break;
		default:
			switch (StatusFlags & (SF_Define|SF_Copy|SF_Move|SF_Swap|SF_Clear)) {
				case SF_Define:
					if (ProcKeyReq(Gad->GadgetID))
						UpdateDisplay(Gad, KeyMapNode, FALSE);
					break;
				case SF_Copy:
					if (FromKeyGad == NULL) {
						FromKeyGad = Gad;
						ChangePointer(-1);
					}
					else {
						if (FromKeyGad != Gad) {
							CopyKey(&KeyMapNode->kn_KeyMap, FromKeyGad->GadgetID, Gad->GadgetID);
							UpdateDisplay(Gad, KeyMapNode, FALSE);
						}
						ChangePointer(SF_Copy);
						FromKeyGad = NULL;
					}
					break;
				case SF_Move:
					if (FromKeyGad == NULL) {
						FromKeyGad = Gad;
						ChangePointer(-1);
					}
					else {
						if (FromKeyGad != Gad) {
							MoveKey(&KeyMapNode->kn_KeyMap, FromKeyGad->GadgetID, Gad->GadgetID);
							UpdateDisplay(FromKeyGad, KeyMapNode, FALSE);
							UpdateDisplay(Gad, KeyMapNode, FALSE);
						}
						ChangePointer(SF_Move);
						FromKeyGad = NULL;
					}
					break;
				case SF_Swap:
					if (FromKeyGad == NULL) {
						FromKeyGad = Gad;
						ChangePointer(-1);
					}
					else {
						if (FromKeyGad != Gad) {
							SwapKeys(&KeyMapNode->kn_KeyMap, FromKeyGad->GadgetID, Gad->GadgetID);
							UpdateDisplay(FromKeyGad, KeyMapNode, FALSE);
							UpdateDisplay(Gad, KeyMapNode, FALSE);
						}
						ChangePointer(SF_Swap);
						FromKeyGad = NULL;
					}
					break;
				case SF_Clear:
					ClearKey(&KeyMapNode->kn_KeyMap, Gad->GadgetID);
					UpdateDisplay(Gad, KeyMapNode, FALSE);
			} /* switch */
	} /* switch */
}

/*
 * Copy Key
 *
 * Parameters:	KeyMap - KeyMap to work with
 *		FromKeyCode - Key Code to copy from
 *		ToKeyCode - Key Code to copy to
 */
int CopyKey(KeyMap, FromKey, ToKey)
struct KeyMap *KeyMap;
unsigned short FromKey;
unsigned short ToKey;
{
	struct HalfKeyMap *FromHalfKeyMap, *ToHalfKeyMap;
	int len;
	UBYTE headerlen;

	if (FromKey < 0x40)
		FromHalfKeyMap = (struct HalfKeyMap *)KeyMap;
	else {
		FromHalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
		FromKey -= 0x40;
	}
	if (ToKey < 0x40)
		ToHalfKeyMap = (struct HalfKeyMap *)KeyMap;
	else {
		ToHalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
		ToKey -= 0x40;
	}

	switch (FromHalfKeyMap->KeyMapTypes[FromKey] & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
		case KC_NOQUAL:
		case KCF_NOP:
			ToHalfKeyMap->KeyMap[ToKey] = FromHalfKeyMap->KeyMap[FromKey];
			break;
		case KCF_STRING:
			len = StringKeyLength(FromHalfKeyMap, FromKey, &headerlen);
			if ((ToHalfKeyMap->KeyMap[ToKey] = (ULONG)AllocMem(len, MEMF_CLEAR)) == NULL) {
				Write(Output(), "Memory Allocation Failed, CopyKey:String\n", 41);
				return(FALSE);
			}
			CopyStringKey(FromHalfKeyMap, FromKey, (UBYTE *)ToHalfKeyMap->KeyMap[ToKey], headerlen);
			break;
		case KCF_DEAD:
			len = DeadKeyLength(FromHalfKeyMap, FromKey, &headerlen);
			if ((ToHalfKeyMap->KeyMap[ToKey] = (ULONG)AllocMem(len, MEMF_CLEAR)) == NULL) {
				Write(Output(), "Memory Allocation Failed, CopyKey:Dead\n", 39);
				return(FALSE);
			}
			CopyDeadKey(FromHalfKeyMap, FromKey, (UBYTE *)ToHalfKeyMap->KeyMap[ToKey], headerlen);
	} /* switch */
	ToHalfKeyMap->KeyMapTypes[ToKey] = FromHalfKeyMap->KeyMapTypes[FromKey];
	ToHalfKeyMap->Capsable[ToKey/8] &= ~(ToKey % 8);
	ToHalfKeyMap->Capsable[ToKey/8] |= (FromHalfKeyMap->Capsable[FromKey/8] & (FromKey % 8));
	ToHalfKeyMap->Repeatable[ToKey/8] &= ~(ToKey % 8);
	ToHalfKeyMap->Repeatable[ToKey/8] |= (FromHalfKeyMap->Repeatable[FromKey/8] & (FromKey % 8));
	SetFlag(SF_Modified);
	return(TRUE);
}

/*
 * Move Key
 *
 * Parameters:	KeyMap - KeyMap to work with
 *		FromKeyCode - Key Code to move from
 *		ToKeyCode - Key Code to move to
 */
void MoveKey(KeyMap, FromKey, ToKey)
struct KeyMap *KeyMap;
unsigned short FromKey;
unsigned short ToKey;
{
	struct HalfKeyMap *FromHalfKeyMap, *ToHalfKeyMap;

	if (FromKey < 0x40)
		FromHalfKeyMap = (struct HalfKeyMap *)KeyMap;
	else {
		FromHalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
		FromKey -= 0x40;
	}
	if (ToKey < 0x40)
		ToHalfKeyMap = (struct HalfKeyMap *)KeyMap;
	else {
		ToHalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
		ToKey -= 0x40;
	}

	ToHalfKeyMap->KeyMapTypes[ToKey] = FromHalfKeyMap->KeyMapTypes[FromKey];
	ToHalfKeyMap->KeyMap[ToKey] = FromHalfKeyMap->KeyMap[FromKey];
	ToHalfKeyMap->Capsable[ToKey/8] &= ~(ToKey % 8);
	ToHalfKeyMap->Capsable[ToKey/8] |= (FromHalfKeyMap->Capsable[FromKey/8] & (FromKey % 8));
	ToHalfKeyMap->Repeatable[ToKey/8] &= ~(ToKey % 8);
	ToHalfKeyMap->Repeatable[ToKey/8] |= (FromHalfKeyMap->Repeatable[FromKey/8] & (FromKey % 8));

	FromHalfKeyMap->KeyMapTypes[FromKey] = KCF_NOP;
	FromHalfKeyMap->KeyMap[FromKey] = NULL;
	FromHalfKeyMap->Capsable[FromKey/8] &= ~(FromKey % 8);
	FromHalfKeyMap->Repeatable[FromKey/8] &= ~(FromKey % 8);
	SetFlag(SF_Modified);
}

/*
 * Swap Key
 *
 * Parameters:	KeyMap - KeyMap to work with
 *		FromKeyCode - Key Code to swap from
 *		ToKeyCode - Key Code to swap to
 */
void SwapKeys(KeyMap, FromKey, ToKey)
struct KeyMap *KeyMap;
unsigned short FromKey;
unsigned short ToKey;
{
	struct HalfKeyMap *FromHalfKeyMap, *ToHalfKeyMap;
	UBYTE temptype, tempcaps, temprepeat;
	ULONG tempmap;

	if (FromKey < 0x40)
		FromHalfKeyMap = (struct HalfKeyMap *)KeyMap;
	else {
		FromHalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
		FromKey -= 0x40;
	}
	if (ToKey < 0x40)
		ToHalfKeyMap = (struct HalfKeyMap *)KeyMap;
	else {
		ToHalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
		ToKey -= 0x40;
	}

	temptype = ToHalfKeyMap->KeyMapTypes[ToKey];
	tempmap = ToHalfKeyMap->KeyMap[ToKey];
	tempcaps = ToHalfKeyMap->Capsable[ToKey/8] & (ToKey % 8);
	temprepeat = ToHalfKeyMap->Repeatable[ToKey/8] & (ToKey % 8);

	ToHalfKeyMap->KeyMapTypes[ToKey] = FromHalfKeyMap->KeyMapTypes[FromKey];
	ToHalfKeyMap->KeyMap[ToKey] = FromHalfKeyMap->KeyMap[FromKey];
	ToHalfKeyMap->Capsable[ToKey/8] &= ~(ToKey % 8);
	ToHalfKeyMap->Capsable[ToKey/8] |= (FromHalfKeyMap->Capsable[FromKey/8] & (FromKey % 8));
	ToHalfKeyMap->Repeatable[ToKey/8] &= ~(ToKey % 8);
	ToHalfKeyMap->Repeatable[ToKey/8] |= (FromHalfKeyMap->Repeatable[FromKey/8] & (FromKey % 8));

	FromHalfKeyMap->KeyMapTypes[FromKey] = temptype;
	FromHalfKeyMap->KeyMap[FromKey] = tempmap;
	FromHalfKeyMap->Capsable[FromKey/8] &= ~(FromKey % 8);
	FromHalfKeyMap->Capsable[FromKey/8] |= tempcaps;
	FromHalfKeyMap->Repeatable[FromKey/8] &= ~(FromKey % 8);
	FromHalfKeyMap->Repeatable[FromKey/8] |= temprepeat;
	SetFlag(SF_Modified);
}

/*
 * Clear Key
 *
 * parameters:	KeyMap - Key Map to work with
 *		KeyCode - KeyCode to erase
 */
void ClearKey(KeyMap, KeyCode)
struct KeyMap *KeyMap;
unsigned short KeyCode;
{
	struct HalfKeyMap *HalfKeyMap;
	int len;
	UBYTE headerlen;

	if (KeyCode < 0x40)
		HalfKeyMap = (struct HalfKeyMap *)KeyMap;
	else {
		HalfKeyMap = (struct HalfKeyMap *)&KeyMap->km_HiKeyMapTypes;
		KeyCode -= 0x40;
	}

	switch (HalfKeyMap->KeyMapTypes[KeyCode] & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
		case KCF_STRING:
			len = StringKeyLength(HalfKeyMap, KeyCode, &headerlen);
			FreeMem((UBYTE *)HalfKeyMap->KeyMap[KeyCode], len);
			break;
		case KCF_DEAD:
			len = DeadKeyLength(HalfKeyMap, KeyCode, &headerlen);
			FreeMem((UBYTE *)HalfKeyMap->KeyMap[KeyCode], len);
	} /* switch */
	HalfKeyMap->KeyMap[KeyCode] = NULL;
	HalfKeyMap->KeyMapTypes[KeyCode] = KCF_NOP;
	HalfKeyMap->Capsable[KeyCode/8] &= ~(KeyCode % 8);
	HalfKeyMap->Repeatable[KeyCode/8] &= ~(KeyCode % 8);
	SetFlag(SF_Modified);
}

/*
 * String Key Length
 *
 * parameters:	HalfKeyMap - half of a key map structure
 *		KeyCode - Key Code
 *		HeaderLen - Location to place header length
 *
 * returns:	Length - length of key buffer
 */
UBYTE StringKeyLength(HalfKeyMap, KeyCode, HeaderLength)
struct HalfKeyMap *HalfKeyMap;
USHORT KeyCode;
UBYTE *HeaderLength;
{
	UBYTE KeyType;
	UBYTE *KeyMapPtr;
	UBYTE len, index;

	KeyType = HalfKeyMap->KeyMapTypes[KeyCode];
	KeyMapPtr = (UBYTE *)HalfKeyMap->KeyMap[KeyCode];

	len = 2 + KeyMapPtr[index = 0];
	if (KeyType & KCF_SHIFT)
		len += 2 + KeyMapPtr[index += 2];
	if (KeyType & KCF_ALT)
		len += 2 + KeyMapPtr[index += 2];
	if ((KeyType & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
		len += 2 + KeyMapPtr[index += 2];
	if (KeyType & KCF_CONTROL)
		len += 2 + KeyMapPtr[index += 2];
	if ((KeyType & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
		len += 2 + KeyMapPtr[index += 2];
	if ((KeyType & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
		len += 2 + KeyMapPtr[index += 2];
	if ((KeyType & KC_VANILLA) == KC_VANILLA)
		len += 2 + KeyMapPtr[index += 2];
	*HeaderLength = index + 2;
	return(len);
}

/*
 * Copy String Key
 *
 * parameters:	HalfKeyMap - Half of a key map
 *		KeyCode - Key Code
 *		KeyBuff - location to place key data
 *		Header - length of key data header
 *
 * returns:	Length - length copied
 */
UBYTE CopyStringKey(HalfKeyMap, KeyCode, KeyBuff, HeaderLength)
struct HalfKeyMap *HalfKeyMap;
USHORT KeyCode;
UBYTE *KeyBuff;
UBYTE HeaderLength;
{
	UBYTE KeyType;
	UBYTE *KeyMapPtr;
	UBYTE len, index;

	KeyType = HalfKeyMap->KeyMapTypes[KeyCode];
	KeyMapPtr = (UBYTE *)HalfKeyMap->KeyMap[KeyCode];

	len = HeaderLength;
	KeyBuff[index = 0] = KeyMapPtr[index];
	KeyBuff[index+1] = len;
	memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
	len += KeyBuff[index];
	if (KeyType & KCF_SHIFT) {
		KeyBuff[index += 2] = KeyMapPtr[index];
		KeyBuff[index+1] = len;
		memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
		len += KeyBuff[index];
	}
	if (KeyType & KCF_ALT) {
		KeyBuff[index += 2] = KeyMapPtr[index];
		KeyBuff[index+1] = len;
		memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
		len += KeyBuff[index];
	}
	if ((KeyType & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT)) {
		KeyBuff[index += 2] = KeyMapPtr[index];
		KeyBuff[index+1] = len;
		memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
		len += KeyBuff[index];
	}
	if (KeyType & KCF_CONTROL) {
		KeyBuff[index += 2] = KeyMapPtr[index];
		KeyBuff[index+1] = len;
		memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
		len += KeyBuff[index];
	}
	if ((KeyType & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT)) {
		KeyBuff[index += 2] = KeyMapPtr[index];
		KeyBuff[index+1] = len;
		memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
		len += KeyBuff[index];
	}
	if ((KeyType & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT)) {
		KeyBuff[index += 2] = KeyMapPtr[index];
		KeyBuff[index+1] = len;
		memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
		len += KeyBuff[index];
	}
	if ((KeyType & KC_VANILLA) == KC_VANILLA) {
		KeyBuff[index += 2] = KeyMapPtr[index];
		KeyBuff[index+1] = len;
		memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), KeyMapPtr[index]);
		len += KeyBuff[index];
	}
	return(len);
}

/*
 * Dead Key Length
 *
 * parameters:	HalfKeyMap - half of a key map structure
 *		KeyCode - Key Code
 *		HeaderLength - Location to place header length
 *
 * returns:	Length - length of key buffer
 */
UBYTE DeadKeyLength(HalfKeyMap, KeyCode, HeaderLength)
struct HalfKeyMap *HalfKeyMap;
USHORT KeyCode;
UBYTE *HeaderLength;
{
	UBYTE KeyType;
	UBYTE *KeyMapPtr;
	UBYTE len, index;

	KeyType = HalfKeyMap->KeyMapTypes[KeyCode];
	KeyMapPtr = (UBYTE *)HalfKeyMap->KeyMap[KeyCode];
	
	switch (KeyMapPtr[index = 0]) {
		case KC_NOQUAL:
		case DPF_DEAD:
			len = 2;
			break;
		case DPF_MOD:
			len = 2 + 6;
	} /* switch */
	if (KeyType & KCF_SHIFT)
		switch (KeyMapPtr[index += 2]) {
			case KC_NOQUAL:
			case DPF_DEAD:
				len += 2;
				break;
			case DPF_MOD:
				len += 2 + 6;
		} /* switch */
	if (KeyType & KCF_ALT)
		switch (KeyMapPtr[index += 2]) {
			case KC_NOQUAL:
			case DPF_DEAD:
				len += 2;
				break;
			case DPF_MOD:
				len += 2 + 6;
		} /* switch */
	if ((KeyType & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
		switch (KeyMapPtr[index += 2]) {
			case KC_NOQUAL:
			case DPF_DEAD:
				len += 2;
				break;
			case DPF_MOD:
				len += 2 + 6;
		} /* switch */
	if (KeyType & KCF_CONTROL)
		switch (KeyMapPtr[index += 2]) {
			case KC_NOQUAL:
			case DPF_DEAD:
				len += 2;
				break;
			case DPF_MOD:
				len += 2 + 6;
		} /* switch */
	if ((KeyType & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
		switch (KeyMapPtr[index += 2]) {
			case KC_NOQUAL:
			case DPF_DEAD:
				len += 2;
				break;
			case DPF_MOD:
				len += 2 + 6;
		} /* switch */
	if ((KeyType & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
		switch (KeyMapPtr[index += 2]) {
			case KC_NOQUAL:
			case DPF_DEAD:
				len += 2;
				break;
			case DPF_MOD:
				len += 2 + 6;
		} /* switch */
	if ((KeyType & KC_VANILLA) == KC_VANILLA)
		switch (KeyMapPtr[index += 2]) {
			case KC_NOQUAL:
			case DPF_DEAD:
				len += 2;
				break;
			case DPF_MOD:
				len += 2 + 6;
		} /* switch */
	*HeaderLength = index + 2;
	return(len);
}

/*
 * Copy Dead Key
 *
 * parameters:	HalfKeyMap - Half of a key map
 *		KeyCode - Key Code
 *		KeyBuff - location to place key data
 *		HeaderLength - length of key data header
 *
 * returns:	Length - length copied
 */
UBYTE CopyDeadKey(HalfKeyMap, KeyCode, KeyBuff, HeaderLength)
struct HalfKeyMap *HalfKeyMap;
USHORT KeyCode;
UBYTE *KeyBuff;
UBYTE HeaderLength;
{
	UBYTE KeyType;
	UBYTE *KeyMapPtr;
	UBYTE len, index;

	KeyType = HalfKeyMap->KeyMapTypes[KeyCode];
	KeyMapPtr = (UBYTE *)HalfKeyMap->KeyMap[KeyCode];

	len = HeaderLength;	
	switch (KeyBuff[index = 0] = KeyMapPtr[index]) {
		case KC_NOQUAL:
		case DPF_DEAD:
			KeyBuff[index+1] = KeyMapPtr[index+1];
			break;
		case DPF_MOD:
			KeyBuff[index+1] = len;
			memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
			len += 6;
	} /* switch */
	if (KeyType & KCF_SHIFT)
		switch (KeyBuff[index += 2] = KeyMapPtr[index]) {
			case KC_NOQUAL:
			case DPF_DEAD:
				KeyBuff[index+1] = KeyMapPtr[index+1];
				break;
			case DPF_MOD:
				KeyBuff[index+1] = len;
				memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
				len += 6;
		} /* switch */
	if (KeyType & KCF_ALT)
		switch (KeyBuff[index += 2] = KeyMapPtr[index]) {
			case KC_NOQUAL:
			case DPF_DEAD:
				KeyBuff[index+1] = KeyMapPtr[index+1];
				break;
			case DPF_MOD:
				KeyBuff[index+1] = len;
				memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
				len += 6;
		} /* switch */
	if ((KeyType & (KCF_SHIFT|KCF_ALT)) == (KCF_SHIFT|KCF_ALT))
		switch (KeyBuff[index += 2] = KeyMapPtr[index]) {
			case KC_NOQUAL:
			case DPF_DEAD:
				KeyBuff[index+1] = KeyMapPtr[index+1];
				break;
			case DPF_MOD:
				KeyBuff[index+1] = len;
				memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
				len += 6;
		} /* switch */
	if (KeyType & KCF_CONTROL)
		switch (KeyBuff[index += 2] = KeyMapPtr[index]) {
			case KC_NOQUAL:
			case DPF_DEAD:
				KeyBuff[index+1] = KeyMapPtr[index+1];
				break;
			case DPF_MOD:
				KeyBuff[index+1] = len;
				memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
				len += 6;
		} /* switch */
	if ((KeyType & (KCF_CONTROL|KCF_SHIFT)) == (KCF_CONTROL|KCF_SHIFT))
		switch (KeyBuff[index += 2] = KeyMapPtr[index]) {
			case KC_NOQUAL:
			case DPF_DEAD:
				KeyBuff[index+1] = KeyMapPtr[index+1];
				break;
			case DPF_MOD:
				KeyBuff[index+1] = len;
				memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
				len += 6;
		} /* switch */
	if ((KeyType & (KCF_CONTROL|KCF_ALT)) == (KCF_CONTROL|KCF_ALT))
		switch (KeyBuff[index += 2] = KeyMapPtr[index]) {
			case KC_NOQUAL:
			case DPF_DEAD:
				KeyBuff[index+1] = KeyMapPtr[index+1];
				break;
			case DPF_MOD:
				KeyBuff[index+1] = len;
				memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
				len += 6;
		} /* switch */
	if ((KeyType & KC_VANILLA) == KC_VANILLA)
		switch (KeyBuff[index += 2] = KeyMapPtr[index]) {
			case KC_NOQUAL:
			case DPF_DEAD:
				KeyBuff[index+1] = KeyMapPtr[index+1];
				break;
			case DPF_MOD:
				KeyBuff[index+1] = len;
				memcpy(&KeyBuff[len], (KeyMapPtr+KeyMapPtr[index+1]), 6);
				len += 6;
		} /* switch */
	return(len);
}