xref: /dports/editors/e93/e93/xgui/events.c

// Low level event handling
// 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"

#define	BLINK_TIMEOUT_START		40			// when restarting the timeout value, this is used
#define	BLINK_TIMEOUT_CONTINUE	30			// when continuing timeouts, this value is used
#define	ABORT_CHECK_INTERVAL	30			// check for abort every 1/2 second

static volatile UINT32
	waitTimer;								// used by the WaitTicks routine, this counts up at the alarm rate, but can be reset
static volatile UINT32
	blinkTimeout;							// when this gets to 0, it is time to flash the cursor
static KeyCode
	abortKeyCode;							// keycode which matches the "abort" key (currently "escape")
static UINT32
	nextAbortCheckTime;						// when timer is >= to this value, it is ok to check for an abort

int XErrorEventHandler(Display *display,XErrorEvent *event)
// Handle protocol errors (generated by strange X implementations, or window managers)
{
//	char
//		errorMessage[256];

//	XGetErrorText(display,event->error_code,errorMessage,256);
//	fprintf(stderr,"X Error: %s\n",errorMessage);

	xFail=true;
	return(0);
}

static Bool UpdateEventsPredicate(Display *display,XEvent *event,char *arg)
// Match all update events
{
	if((event->type==Expose)||(event->type==GraphicsExpose)||(event->type==NoExpose)||(event->type==ConfigureNotify))
	{
		return(True);
	}
	return(False);
}

static Bool AllButUpdateEventsPredicate(Display *display,XEvent *event,char *arg)
// Match all events (used in XCheckIfEvent below)
{
	return(!UpdateEventsPredicate(display,event,arg));
}

static Bool KeyEventsPredicate(Display *display,XEvent *event,char *arg)
// Match all keyboard press events
{
	if(event->type==KeyPress)
	{
		return(True);
	}
	return(False);
}

// **** The following comment is brought to you by: emacs 19.22 ****
// This holds the state XLookupString needs to implement dead keys
// and other tricks known as "compose processing".  _X Window System_
// says that a portable program can't use this, but Stephen Gildea assures
// me (emacs person) that letting the compiler initialize it to zeros will
// work okay.

// If it is good enough for emacs, it is good enough for e93!

static XComposeStatus
	composeStatus;						// keep compose status around, and pass it in to all calls to XLookupString

int ComposeXLookupString(XKeyEvent *event_struct,char *buffer_return,int bytes_buffer,KeySym *keysym_return)
// Call this instead of XLookupString, it does the same thing, but handles the state of
// compose processing properly
// This should allow people to enter umlaut characters more easily
{
	return(XLookupString(event_struct,buffer_return,bytes_buffer,keysym_return,&composeStatus));
}

bool KeyEventToEditorKey(XEvent *event,EDITOR_KEY *keyData)
// Take a keyboard event, and fill in an editor key record
// If event does not yield a editor key, then
// return false
{
	KeySym
		keySym;
	char
		ascCode;
	bool
		virtualKey;
	UINT32
		key;
	int
		numAsc;
	XKeyEvent
		ourEvent;

	key=0;
	ourEvent=*((XKeyEvent *)event);			// copy the event, so we can play with it a bit
	ourEvent.state&=(~Mod1Mask);			// remove this from consideration
	numAsc=ComposeXLookupString(&ourEvent,&ascCode,1,&keySym);
	if(!IsModifierKey(keySym))				// make sure it is not a modifier key (these do not get passed back)
	{
		virtualKey=true;					// assume virtual key
		switch(keySym)
		{
			case XK_Left:
				key=VVK_LEFTARROW;
				break;
			case XK_Right:
				key=VVK_RIGHTARROW;
				break;
			case XK_Up:
				key=VVK_UPARROW;
				break;
			case XK_Down:
				key=VVK_DOWNARROW;
				break;
			case XK_Prior:
				key=VVK_PAGEUP;
				break;
			case XK_Next:
				key=VVK_PAGEDOWN;
				break;
			case XK_Home:
				key=VVK_HOME;
				break;
			case XK_End:
				key=VVK_END;
				break;
			case XK_Insert:
				key=VVK_INSERT;
				break;
			case XK_Delete:
				key=VVK_DELETE;
				break;
			case XK_BackSpace:
				key=VVK_BACKSPACE;
				break;
			case XK_Help:
				key=VVK_HELP;
				break;
			case XK_Undo:
			case XK_F14:
				key=VVK_UNDO;
				break;
			case XK_Redo:
			case XK_F12:
				key=VVK_REDO;
				break;
			case XK_Return:
				key=VVK_RETURN;
				break;
			case XK_KP_Enter:
				key=VVK_RETURN;
				break;
			case XK_Tab:
				key=VVK_TAB;
				break;
			case XK_F20:
				key=VVK_CUT;
				break;
			case XK_F16:
				key=VVK_COPY;
				break;
			case XK_F18:
				key=VVK_PASTE;
				break;
			case XK_F1:
				key=VVK_F1;
				break;
			case XK_F2:
				key=VVK_F2;
				break;
			case XK_F3:
				key=VVK_F3;
				break;
			case XK_F4:
				key=VVK_F4;
				break;
			case XK_F5:
				key=VVK_F5;
				break;
			case XK_F6:
				key=VVK_F6;
				break;
			case XK_F7:
				key=VVK_F7;
				break;
			case XK_F8:
				key=VVK_F8;
				break;
			case XK_F9:
				key=VVK_F9;
				break;
			case XK_F10:
				key=VVK_F10;
				break;
			default:
				virtualKey=false;
				break;
		}
		if((keyData->isVirtual=virtualKey))
		{
			keyData->keyCode=key;
			XStateToEditorModifiers(event->xkey.state,0,&keyData->modifiers);
			return(true);
		}
		else
		{
			if(numAsc)
			{
				keyData->keyCode=ascCode;
				XStateToEditorModifiers(event->xkey.state,0,&keyData->modifiers);
				return(true);
			}
		}
	}
	return(false);
}

bool EditorKeyNameToKeyCode(const char *name,UINT32 *code)
// Given a string which is the name of an unmodified key on the keyboard,
// convert it into a keycode (in the case of X, we use KeySyms)
// if the name is not the name of any key on our keyboard, then return false
{
	KeySym
		keySym;

	if((keySym=XStringToKeysym(name))!=NoSymbol)
	{
		*code=(UINT32)keySym;
		return(true);
	}
	return(false);
}

char *EditorKeyCodeToKeyName(UINT32 code)
// Given a keycode, get its name
// if the code is invalid, return NULL
// NOTE: the returned string is static, and should not be modified or deleted
{
	return(XKeysymToString((KeySym)code));
}

void XStateToEditorModifiers(unsigned int state,UINT32 numClicks,UINT32 *editorModifiers)
// Convert modifiers and numClicks into modifier bits for the editor
{
	(*editorModifiers)=0;

	if(state&LockMask)
	{
		(*editorModifiers)|=EEM_CAPSLOCK;
	}
	if(state&ShiftMask)
	{
		(*editorModifiers)|=EEM_SHIFT;
	}
	if(state&ControlMask)
	{
		(*editorModifiers)|=EEM_CTL;
	}
	if(state&Mod1Mask)						// Alt key
	{
		(*editorModifiers)|=EEM_MOD0;
	}
	if(state&Mod4Mask)						// Meta L key
	{
		(*editorModifiers)|=EEM_MOD1;
	}

	numClicks<<=EES_STATE0;
	numClicks&=EEM_STATE0;
	(*editorModifiers)|=numClicks;
}

bool EditorGetKeyPress(UINT32 *keyCode,UINT32 *editorModifiers,bool wait,bool clearBuffered)
// Used by editor when it wants to get a key press
// If a code is found, it is returned in keyCode/editorModifiers
// If none is ready, return false
// If wait is true, wait here until one is ready (true is always returned)
// If clearBuffered is true, then clear any keypresses that may have been in the
// buffer before proceeding.
{
	XEvent
		event;
	bool
		gotOne;
	KeySym
		keySym;

	gotOne=false;
	if(clearBuffered)
	{
		while(XCheckIfEvent(xDisplay,&event,KeyEventsPredicate,NULL))		// inhale all keypresses
			;
	}
	if(wait)
	{
		do
		{
			XIfEvent(xDisplay,&event,KeyEventsPredicate,NULL);
			ComposeXLookupString((XKeyEvent *)&event,NULL,0,&keySym);		// get KeySym to see if modifiers or real press
		}
		while(IsModifierKey(keySym));
		gotOne=true;
	}
	else
	{
		while(!gotOne&&XCheckIfEvent(xDisplay,&event,KeyEventsPredicate,NULL))
		{
			ComposeXLookupString((XKeyEvent *)&event,NULL,0,&keySym);		// get KeySym to see if modifiers or real press
			if(!IsModifierKey(keySym))
			{
				gotOne=true;
			}
		}
	}
	if(gotOne)
	{
		XStateToEditorModifiers(event.xkey.state,0,editorModifiers);		// make modifiers
		event.xkey.state=0;													// get rid of all modifiers, so we end up with un-modified keysym
		ComposeXLookupString((XKeyEvent *)&event,NULL,0,&keySym);			// get back unmodified keysym
		*keyCode=(UINT32)keySym;
	}
	return(gotOne);
}

// pseudo globals needed to handle multiple clicks

static UINT32
	lastClickTime;
static Window
	lastClickWindow;
static INT32
	lastClickX,
	lastClickY;
static UINT32
	numClicks;

#define	CLICKSLOP		5				// number of pixels of slop in either direction
#define	CLICKTIME		300				// number of milliseconds between clicks considered multiple

void ResetMultipleClicks()
// Clears the double click information, so that next click starts from scratch
{
	lastClickTime=0;					// initialize multiple click variables
	lastClickWindow=(Window)0;
	lastClickX=lastClickY=0;
	numClicks=0;
}

UINT32 HandleMultipleClicks(XEvent *event)
// Updates and returns numClicks which tells how many clicks were in roughly the same area
// of the same window.
// where each click followed the previous by no more than CLICKTIME milliseconds
// This is how double, triple, etc clicks are handled
// NOTE: due to wrap around in the time field, this routine could possibly
// fail to work correctly once every 49.7 days
{
	if((lastClickTime+CLICKTIME)>event->xbutton.time&&
		(lastClickX>=(event->xbutton.x_root-CLICKSLOP))&&(lastClickX<=(event->xbutton.x_root+CLICKSLOP))&&
		(lastClickY>=(event->xbutton.y_root-CLICKSLOP))&&(lastClickY<=(event->xbutton.y_root+CLICKSLOP))&&
		event->xbutton.window==lastClickWindow)
	{
		numClicks++;
	}
	else
	{
		numClicks=0;
	}
	lastClickTime=event->xbutton.time;
	lastClickWindow=event->xbutton.window;
	lastClickX=event->xbutton.x_root;
	lastClickY=event->xbutton.y_root;
	return(numClicks);
}

static Bool ButtonEventPredicate(Display *display,XEvent *event,char *arg)
// Return True if the event is a button press, or a button release
// All button events are looked at while in StillDown
{
	if((event->type==ButtonPress)||(event->type==ButtonRelease))
	{
		return(True);
	}
	return(False);
}

bool StillDown(unsigned int button,UINT32 numTicks)
// Call this after receiving a Button Pressed event for button, and
// it will return true if the button is still held down
// numTicks can be used to give some time back to the system while
// waiting, it can also be used to time scrolls and such so that they
// do not run too fast on fast machines
{
	XEvent
		event;
	bool
		locatedUp;

	locatedUp=false;
	WaitTicks(numTicks);
	while(!locatedUp&&XCheckIfEvent(xDisplay,&event,ButtonEventPredicate,NULL))
	{
		if(event.type==ButtonRelease&&event.xbutton.button==button)
		{
			locatedUp=true;
		}
	}
	return(!locatedUp);
}

static void CollectInvalidations(XEvent *event)
// Given an Expose, or GraphicsExpose event, find the window
// it belongs to, and add the event's invalid area to the window's
// invalid region
{
	WINDOW_LIST_ELEMENT
		*windowElement;
	EDITOR_RECT
		invalidRect;

	if((windowElement=LocateWindowElement(event->xany.window)))
	{
		invalidRect.x=event->xexpose.x;
		invalidRect.y=event->xexpose.y;
		invalidRect.w=event->xexpose.width;
		invalidRect.h=event->xexpose.height;
		InvalidateWindowRect(windowElement->editorWindow,&invalidRect);
	}
}

static void ConfigureWindow(XEvent *event)
// Given a ConfigureNotify event, find the window
// it belongs to, and tell it to adjust to its size
{
	WINDOW_LIST_ELEMENT
		*windowElement;

	if((windowElement=LocateWindowElement(event->xany.window)))
	{
		switch(windowElement->editorWindow->windowType)
		{
			case EWT_DOCUMENT:
				AdjustDocumentWindowForNewSize(windowElement->editorWindow);
				break;
			case EWT_DIALOG:
				AdjustDialogWindowForNewSize(windowElement->editorWindow);
				break;
			case EWT_MENU:
				// these do not configure at the moment, so ignore the events
				break;
			default:
				break;
		}
	}
}

static bool AttemptBoundKeyPress(XEvent *event)
// See if the keypress event can be handled by one of the bound keys
// if so, handle it, and return true
// if the key is not bound, return false
{
	KeySym
		keySym;
	XKeyEvent
		ourEvent;
	UINT32
		editorModifiers;

	XStateToEditorModifiers(event->xkey.state,0,&editorModifiers);	// make modifiers
	ourEvent=*((XKeyEvent *)event);
	ourEvent.state=0;												// get rid of all modifiers, so we end up with un-modified keysym
	ComposeXLookupString(&ourEvent,NULL,0,&keySym);					// get back unmodified keysym
	if(!IsModifierKey(keySym))										// do not pass lone modifiers
	{
		return(HandleBoundKeyEvent((UINT32)keySym,editorModifiers));	// attempt to handle it
	}
	return(false);
}

static void DoEvent(XEvent *event)
// Passed an event, do what is needed to take care of it
{
	WINDOW_LIST_ELEMENT
		*windowElement;
	Window
		xWindow;
	EDITOR_WINDOW
		*window;
	int
		focusRevert;

	switch(event->type)
	{
		case KeyPress:
			if(!AttemptMenuKeyPress(event))								// look for menu key first
			{
				if(!AttemptBoundKeyPress(event))						// then try for bound key
				{
					XGetInputFocus(xDisplay,&xWindow,&focusRevert);		// find out who has the focus
					if((windowElement=LocateWindowElement(xWindow)))	// see if it is one of our windows
					{
						event->xany.window=xWindow;						// fudge top window into event
						switch(windowElement->editorWindow->windowType)
						{
							case EWT_MENU:								// keys in menu window which are not menu keys get passed to top document window
								if((window=GetTopEditorWindowType(EWT_DOCUMENT)))
								{
									event->xany.window=((WINDOW_LIST_ELEMENT *)window->userData)->xWindow;
									DocumentWindowEvent(window,event);
								}
								break;
							case EWT_DOCUMENT:
								DocumentWindowEvent(windowElement->editorWindow,event);
								break;
						}
					}
				}
			}
			break;

		default:
			if((windowElement=LocateWindowElement(event->xany.window)))
			{
				switch(windowElement->editorWindow->windowType)
				{
					case EWT_DOCUMENT:
						DocumentWindowEvent(windowElement->editorWindow,event);
						break;
					case EWT_DIALOG:
						DialogWindowEvent(windowElement->editorWindow,event);
						break;
					case EWT_MENU:
						MenuWindowEvent(windowElement->editorWindow,event);
						break;
					default:
						break;
				}
			}
			break;
	}
}

static void DoDialogEvent(EDITOR_WINDOW *dialog,XEvent *event)
// Passed an event, do what is needed to take care of it
// this is called only when a dialog is up
{
	WINDOW_LIST_ELEMENT
		*windowElement;
	Window
		xWindow;
	int
		focusRevert;

	switch(event->type)
	{
		case KeyPress:
			XGetInputFocus(xDisplay,&xWindow,&focusRevert);			// find out who has the focus
			if((windowElement=LocateWindowElement(xWindow))&&(windowElement->editorWindow==dialog))	// see if it is the active dialog
			{
				event->xany.window=xWindow;							// fudge top window into event
				DialogWindowEvent(windowElement->editorWindow,event);
			}
			else
			{
				EditorBeep();										// ugly kludge caused by X not allowing me to force the dialog to the top of the application
				SetTopEditorWindow(dialog);
			}
			break;

		default:
			if((windowElement=LocateWindowElement(event->xany.window)))
			{
				if((windowElement->editorWindow==dialog)||(event->type!=ButtonPress&&event->type!=ClientMessage))	// dont let the user do things to windows other than the dialog we are handling
				{
					switch(windowElement->editorWindow->windowType)
					{
						case EWT_DOCUMENT:
							DocumentWindowEvent(windowElement->editorWindow,event);
							break;
						case EWT_DIALOG:
							DialogWindowEvent(windowElement->editorWindow,event);
							break;
						case EWT_MENU:
							MenuWindowEvent(windowElement->editorWindow,event);
							break;
						default:
							break;
					}
				}
				else
				{
					SetTopEditorWindow(dialog);
				}
			}
			break;
	}
}

void UpdateEditorWindows()
// Attend to changes brought about in our windows.
// Redraw all editor windows that have been invalidated by previous expose or
// graphics expose events.
{
	XEvent
		event;

	while(XCheckIfEvent(xDisplay,&event,UpdateEventsPredicate,NULL))		// get pending update messages
	{
		switch(event.type)
		{
			case Expose:
			case GraphicsExpose:
				CollectInvalidations(&event);				// collect any rectangles from expose events
				break;
			case ConfigureNotify:
				ConfigureWindow(&event);					// go configure the window
				break;
			default:
				break;
		}
	}
	RedrawInvalidWindows();
}

void ResetCursorBlinkTime()
// Reset the timeout until the next cursor blink arrives
{
	blinkTimeout=BLINK_TIMEOUT_START;			// number of ticks of system timer before flashing the cursor
}

void WaitTicks(UINT32 numTicks)
// Wait for numTicks of the system timer before continuing
// NOTE: the delay is measured from the last time this
// was called, so if it has not been called in a while, the
// first call usually returns immediately, it is useful
// for slowing down scrolls on fast machines
{
	while(waitTimer<numTicks)
	{
		pause();						// give some time back to the machine, while we wait
	}
	waitTimer=0;						// reset the wait timeout
}

void AlarmIntervalProc(int unused)
// When the alarm goes off, this executes (then main wakes up)
{
	if(blinkTimeout)
	{
		blinkTimeout--;
	}
	waitTimer++;
	timer++;
}

void StartAlarmTimer()
// Called at the start of execution, this sets up the time base
// used during the rest of the program
// it also installs the signal handler
{
	struct sigaction
		*vector;								// used to set the alarm vector
	struct itimerval
		timerStruct;

	vector=(struct sigaction *)calloc(sizeof(struct sigaction),1);	// cheap way to clear most fields of sigaction that we do not care about (because fields are named differently on each machine)
#ifdef SOLARIS
	vector->_funcptr._handler=AlarmIntervalProc;	// handle the signal with this routine
#else
	vector->sa_handler=AlarmIntervalProc;		// handle the signal with this routine
#endif
	vector->sa_flags=SA_RESTART;				// do not let system call stop when interrupted
	sigaction(SIGALRM,vector,NULL);				// when the alarm signal goes off, call here
	free(vector);

//	timerStruct.it_interval.tv_sec=0;			// 1/60 of a second intervals (fast enough to avoid sluggish feeling, not so fast as to bog machine)
//	timerStruct.it_interval.tv_usec=16667;
//	timerStruct.it_value.tv_sec=0;
//	timerStruct.it_value.tv_usec=16667;

	timerStruct.it_interval.tv_sec=0;			// 1/100 of a second intervals (machines are faster, and more resolution is better)
	timerStruct.it_interval.tv_usec=10000;
	timerStruct.it_value.tv_sec=0;
	timerStruct.it_value.tv_usec=10000;

	setitimer(ITIMER_REAL,&timerStruct,NULL);
}

static void DoPeriodicProc()
// When it is time to flash the cursor (or whatever), attempt to locate the window with input
// focus, and call it to do its thing
{
	Window
		xWindow;
	int
		focusRevert;
	WINDOW_LIST_ELEMENT
		*element;

	XGetInputFocus(xDisplay,&xWindow,&focusRevert);		// find out who has the focus
	if((element=LocateWindowElement(xWindow)))			// see if it is one of our windows
	{
		switch(element->editorWindow->windowType)
		{
			case EWT_DOCUMENT:
				DocumentPeriodicProc(element->editorWindow);
				break;
			case EWT_DIALOG:
				DialogPeriodicProc(element->editorWindow);
				break;
		}
	}
}

void EditorQuit()
// This is called from the editor when it wants to quit
// it needs to inform the event loop that it should stop looping
{
	timeToQuit=true;								// set the quit request flag
}

void EditorDoBackground()
// do the background tasks of updating windows, tasks and timers
{
	ShellDoBackground();							// call the shell to do anything it wants
	UpdateEditorWindows();							// update anything that is invalid now
	if(!UpdateBufferTasks())						// see if any buffers have tasks that need to be serviced/updated
	{
		// when no tasks needed service, give time back to the machine
		pause();									// wait for alarm signal to wake us up again
	}
	if(blinkTimeout==0)								// time to flash cursor
	{
		blinkTimeout=BLINK_TIMEOUT_CONTINUE;		// reset the timer
		DoPeriodicProc();
	}
}

void EditorEventLoop(int argc,char *argv[])
// Get the next event that the editor needs to know about and return it
// if other events occur, this routine should stay here handling them until
// one specifically related to the editor arrives, it should then pass that
// event up to the editor for processing
// if no events arrive, it is the responsibility of this routine to
// give time back to the OS if necessary.
{
	XEvent
		event;

	HandleShellCommand("initialargs",argc-1,&(argv[1]));	// pass off initial arguments to shell for processing

	while(!timeToQuit)
	{
		if(XCheckIfEvent(xDisplay,&event,AllButUpdateEventsPredicate,NULL))
		{
			DoEvent(&event);
		}
		else
		{
			EditorDoBackground();							// handle background stuff
		}
	}
}

void DialogEventLoop(EDITOR_WINDOW *dialog,bool *dialogComplete)
// When a dialog is up, this handles getting events, it does not send any
// events other than update to document windows, or the menus
// ALL events are either discarded, or given to the current dialog window
// dialogComplete must be cleared when calling this, and it
// must be set for this to return
// NOTE: it is possible for this loop to be called BEFORE EditorEventLoop
// has ever been executed, since dialogs can be brought up during the
// startup script (which executes before the main event loop is called for the
// first time)
{
	XEvent
		event;

	while(!(*dialogComplete))
	{
		if(XCheckIfEvent(xDisplay,&event,AllButUpdateEventsPredicate,NULL))
		{
			DoDialogEvent(dialog,&event);
		}
		else
		{
			EditorDoBackground();						// handle background stuff
		}
	}
}

static Bool AbortEventPredicate(Display *display,XEvent *event,char *arg)
// Check the Event to see if it is an abort event
// if it is, return True
// NOTE: since this is an event predicate, it is not allowed to
// call back into XLib (See XCheckIfEvent man page).
// Because of this, we cannot call XLookupString, and must instead
// compare keycodes directly.
{
	if((event->type==KeyPress))
	{
		if(((XKeyEvent *)event)->keycode==abortKeyCode)
		{
			return(True);
		}
	}
	return(False);
}

void ClearAbort()
// call this to clear any pending abort status
{
	XEvent
		event;

	while(XCheckIfEvent(xDisplay,&event,AbortEventPredicate,NULL))	// get all abort events out of the queue
		;
	nextAbortCheckTime=timer+ABORT_CHECK_INTERVAL;					// set next time it will be ok to check for abort
}

bool CheckAbort()
// This will return true if the user is requesting an abortion of the
// current job
// This should be made to execute as efficiently as possible, since it will
// be called often during certain loops
// To make it more efficient, this version checks the time, and if enough time
// has not passed, returns instantly
{
	XEvent
		event;

	if(timer>=nextAbortCheckTime)
	{
		nextAbortCheckTime=timer+ABORT_CHECK_INTERVAL;				// reset the interval
		if(XCheckIfEvent(xDisplay,&event,AbortEventPredicate,NULL))	// see if there is an abort event floating around in the queue
		{
			return(true);
		}
	}
	return(false);
}

void UnInitEvents()
// Uninitialize event stuff
{
}

bool InitEvents()
// Initialize event stuff
// if there is a problem, SetError, return false
{
	waitTimer=0;										// init the wait timer
	abortKeyCode=XKeysymToKeycode(xDisplay,XK_Escape);	// work out the escape keycode (since we cannot call XLib during an event predicate to work out the keysym from the keycode)
	ResetMultipleClicks();
	return(true);
}