e93/e93/keybind.c

// Key binding interface
// Copyright (C) 2000 Core Technologies.

// This file is part of e93.
//
// e93 is free software; you can redistribute it and/or modify
// it under the terms of the e93 LICENSE AGREEMENT.
//
// e93 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// e93 LICENSE AGREEMENT for more details.
//
// You should have received a copy of the e93 LICENSE AGREEMENT
// along with e93; see the file "LICENSE.TXT".

#include	"includes.h"

typedef struct keyBinding
{
	UINT32
		keyCode,
		modifierMask,
		modifierValue;
	struct keyBinding
		*previousBinding,					// pointer to previous binding in the global binding list
		*nextBinding,						// pointer to next binding in the global binding list (in user defined order)
		*nextHashBinding;					// pointer to next binding in local hash list
	char
		dataText[1];						// variable length array of characters of data (would like to declare as dataText[0] but some compilers complain)
} EDITOR_KEY_BINDING;

static EDITOR_KEY_BINDING **GetBindingHashListHead(UINT32 keyCode)
// perform hashing function on keyCode, return pointer to list head
// for bindings
{
	return(&(keyBindingTable[keyCode&0xFF]));
}

char *GetKeyBindingText(EDITOR_KEY_BINDING *binding)
// return a pointer to the key binding text for binding
{
	return(binding->dataText);
}

void GetKeyBindingCodeAndModifiers(EDITOR_KEY_BINDING *binding,UINT32 *keyCode,UINT32 *modifierMask,UINT32 *modifierValue)
// return the key binding information
{
	*keyCode=binding->keyCode;
	*modifierMask=binding->modifierMask;
	*modifierValue=binding->modifierValue;
}

static bool LocateKeyBinding(UINT32 keyCode,UINT32 modifierMask,UINT32 modifierValue,EDITOR_KEY_BINDING ***hashListHead,EDITOR_KEY_BINDING **previousHashEntry,EDITOR_KEY_BINDING **entry)
// locate a key binding in the binding table, return pointers to important entries
{
	bool
		found;
	EDITOR_KEY_BINDING
		*currentEntry;

	*entry=NULL;													// keep gcc quiet
	currentEntry=*(*hashListHead=GetBindingHashListHead(keyCode));	// point to the head of the linked list at this hash entry
	*previousHashEntry=NULL;
	found=false;
	while(currentEntry&&!found)
	{
		if((currentEntry->keyCode==keyCode)&&(currentEntry->modifierMask==modifierMask)&&(currentEntry->modifierValue==modifierValue))
		{
			found=true;
			*entry=currentEntry;
		}
		else
		{
			*previousHashEntry=currentEntry;
			currentEntry=currentEntry->nextHashBinding;
		}
	}
	return(found);
}

EDITOR_KEY_BINDING *LocateNextKeyBinding(EDITOR_KEY_BINDING *currentBinding)
// return the next key binding from the current one
// if there is none, return NULL
{
	return(currentBinding->nextBinding);
}

EDITOR_KEY_BINDING *LocateKeyBindingMatch(UINT32 keyCode,UINT32 modifierValue)
// find a key binding that matches the keyCode, and modifierValue, and return it
// if there is none, return NULL
{
	bool
		found;
	EDITOR_KEY_BINDING
		*currentEntry;

	currentEntry=*GetBindingHashListHead(keyCode);	// point to the head of the linked list at this hash entry
	found=false;
	while(currentEntry&&!found)
	{
		if((currentEntry->keyCode==keyCode)&&((currentEntry->modifierMask&modifierValue)==currentEntry->modifierValue))
		{
			found=true;
		}
		else
		{
			currentEntry=currentEntry->nextHashBinding;
		}
	}
	return(currentEntry);
}

bool DeleteEditorKeyBinding(UINT32 keyCode,UINT32 modifierMask,UINT32 modifierValue)
// attempt to locate the given binding in the key bindings table, and
// remove it if it is found
// if it is not located, return false
{
	EDITOR_KEY_BINDING
		**hashListHead,
		*previousHashEntry,
		*entry;

	if(LocateKeyBinding(keyCode,modifierMask,modifierValue,&hashListHead,&previousHashEntry,&entry))
	{
		if(previousHashEntry)
		{
			previousHashEntry->nextHashBinding=entry->nextHashBinding;		// unlink the located entry
		}
		else
		{
			*hashListHead=entry->nextHashBinding;
		}
		if(entry->previousBinding)
		{
			if((entry->previousBinding->nextBinding=entry->nextBinding))
			{
				entry->nextBinding->previousBinding=entry->previousBinding;
			}
		}
		else
		{
			if((keyBindingListHead=entry->nextBinding))
			{
				keyBindingListHead->previousBinding=NULL;
			}
		}
		MDisposePtr(entry);
		return(true);
	}
	return(false);
}

bool CreateEditorKeyBinding(UINT32 keyCode,UINT32 modifierMask,UINT32 modifierValue,char *dataText)
// search the key binding table for an entry that matches the one given, and delete it if
// it exists. Then add this entry to the table
// if there is a problem, SetError, and return false
{
	EDITOR_KEY_BINDING
		**hashListHead,
		*newEntry;

	DeleteEditorKeyBinding(keyCode,modifierMask,modifierValue);	// try to delete one if it exists
	hashListHead=GetBindingHashListHead(keyCode);						// point to head of list in hash table where this binding will go
	if((newEntry=(EDITOR_KEY_BINDING *)MNewPtr(sizeof(EDITOR_KEY_BINDING)+strlen(dataText)+1)))
	{
		newEntry->keyCode=keyCode;
		newEntry->modifierMask=modifierMask;
		newEntry->modifierValue=modifierValue;
		newEntry->nextHashBinding=*hashListHead;
		strcpy(&(newEntry->dataText[0]),dataText);				// copy in the data
		*hashListHead=newEntry;									// link to head of hash list
		newEntry->previousBinding=NULL;
		if((newEntry->nextBinding=keyBindingListHead))			// point to the next entry
		{
			keyBindingListHead->previousBinding=newEntry;
		}
		keyBindingListHead=newEntry;
		return(true);
	}
	return(false);
}

bool InitKeyBindingTable()
// clear the key binding table so that there are no bindings present
// if there is a problem, SetError, and return false
{
	int
		i;

	for(i=0;i<256;i++)
	{
		keyBindingTable[i]=NULL;
	}
	keyBindingListHead=NULL;
	return(true);
}

void UnInitKeyBindingTable()
// remove all key bindings from the bindings table
{
	int
		i;
	EDITOR_KEY_BINDING
		*currentEntry,
		*nextEntry;

	for(i=0;i<256;i++)
	{
		currentEntry=keyBindingTable[i];
		while(currentEntry)
		{
			nextEntry=currentEntry->nextHashBinding;
			MDisposePtr(currentEntry);
			currentEntry=nextEntry;
		}
		keyBindingTable[i]=NULL;
	}
	keyBindingListHead=NULL;
}