Das scot event subsystem versucht ein Abstraction layer auf beliebige
event systeme (auch selbst definierte) zu sein.

Ich trenn Objeke (Strukture oder was auch immer) von der Event verarbeitung.
Das soll heißen, wenn ich ein Modul (struktur & funktionen) habe das
Xwindows erzeugt, anzeigt und maniputliert, so kann dieses Modul aber noch
nicht arbeiten, das es von sich aus nicht auf Events reagiert. Um es zum
arbeiten zu bringen muß man von einem Konkreten Xwindow (struktur gefüllt,etc)
eine X11_event_sink erzeugen. Diese kümmert sich um die Verarbeitung
von events (masken erzeugen, events eintragen, callbacks aufrufen, etc.).
Die event_sink muß noch in einen dispatcher eingetragen werden, der dann die
event_sink event Verarbeitungen auf eine bestimmte art und weise aufruft.
Dieser wird dann noch in einen dispatcher_manager eingetragen, der die
dispatcher ein oder ausschalten kann...evtl. brauch man dafür keinen
Manager sondern bietet zu dispatchern eben eine dispatcher_on, dispatcher_off
methode an.
Ein Objekt muß selbst die Methoden bieten, die eine passende event_sink
zu diesem objekt erzeugen. Dadurch kann ich z.B. ein erweiterte XWindow
Modul anlegen, dessen Struktur zum einen eine Kopie der Xwindow Struktur aber
auch noch weitere Informationen incl. Informationen für andere event typen
enthält. Diese Struktur kann dann mit den XWindow Methoden einen
X11_event_sink anlegen, aber auch einen neue Methode bauen die eine
andere event_sink erzeugt. Dadurch kann das neue Objekt dann auf beide
Arten Events reagieren.


scot_event_typ.c:
-----------------
Stellt die Struktur scot_event_typ bereit, welche voraussichtlich so aussieht:

typedef struct scot_event_typ_st
{
	int    id;		/* diese wird von scot_event_typ_register gefüllt. */
	char * name;   /* this is a unique name for the event_typ */

	/* eine Struktur die für jeden event_typ anders aussieht, z.B. muß
		für X events mindestens das Display bekannt sein. */
	void * event_typ_info;

	/* 
	 * folgende Funktionen sind allen event Typen gemein, sie müssen nur
	 * für jeden event_typ unterschiedlich implementiert werden.
	 * Diese Implementierungen stehen dann in scot_event_type_*.[ch]
	 */
	void (process_events*) (scot_dispatcher_st * dispatcher);
	void (trigger_event*)  (int event,
	                        const void* event_sink,
									const void* event_data);
};

außerdem wird eine globale statische Liste von registrierten event Typen 
angelegt. (evtl. aber auch nicht, nämlich dann wenn ich einen Manger für
die event_types baue...dann enthält natürlich der manager die Liste.)

GEN_LIST (scot_event_typ_st);
list_scot_event_typ_st_node_t * scot_registered_event_types;

und folgende Funktionen:
void scot_event_typ_register (const scot_event_typ_st *event_typ);
void scot_event_typ_unregister (const scot_event_typ_st *event_typ);
scot_event_typ_st * scot_get_event_typ_by_name (const char * name);


scot_event_sink.c: 
------------------
Stellt die Struktur scot_event_sink bereit. Diese sieht voraussichtlich
irgendwie so aus:

struct scot_event_sink
{
	struct scot_event_typ * event_typ;
	/*
	void (process_events*) (void);
	void (trigger_event*)  (int event,
	                        const void* event_sink,
	                        const void* data);
   */
	void * objekt;
};