ich habe kürzlich meinen "Programmierstil" bzgl. der PB Eventschleife geändert.
Dazu gibt es ja an anderer Stelle einen interessanten Thread, in dem jeder seine Art der Eventbehandlung zum Besten gegeben hat (habe den link leider nicht parat).
Nun denn, mir war das auf Dauer zu nervig den Verwaltungscode für die ganzen Events immer wieder neu zu tippen (bzw. immer wieder das Template einzufügen). Außerdem wird es irgendwann auch unübersichtlich, wenn man sehr viele Gadgets benutzt.
Ich habe mir jetzt ein Include geschrieben, das mir diese Verwaltungsarbeit abnimmt und die Funktionalität auslagert, so daß mein Maincode nicht mehr mit den Select/Case/EndSelect/If/EndIf-Wüsten übersäht ist.
Vermutlich bin ich der dreihundertneunundsechzigste, der sich ein Eventmanagment-System für PB geschrieben hat, aber das hält mich nicht davon ab es Euch trotzdem zur Verfügung zu stellen - hehe.
Zum besseren Verständnis hier ein paar Erklärungen:
;*************************************************************************
;* Informationen zur Benutzung
;*************************************************************************
; Mit diesem Eventhandler wird die Auswertung von Window-, Button- und Menüevents erleichtert.
;
; Nachdem die GUI des eigenen Programms erzeugt wurde, können den Gadgets, Fenstern und
; Menüeinträgen mit den folgenden Befehlen eigene Eventprozeduren zugeordnet werden.
;
; evh_SetWindowEvent(iWindowNr, iEventType, *EventProcedure)
; evh_SetMenuEvent (iWindowNr, iMenuitemNr, *EventProcedure)
; evh_SetGadgetEvent(iWindowNr, iGadgetNr, iEventType, *EventProcedure)
;
; iWindowNr, iGadgetNr bzw. iMenuitemNr stellen dabei die Nummern des jeweiligen Fensters, Gadgets oder
; Menüeintrags dar.
;
; iEventType beschreibt die PB Eventkonstante auf die reagiert werden soll (z.B. #PB_EventType_LeftClick)
; Folgende Eventtypen können bei den jeweiligen Befehlen benutzt werden:
;
; evh_SetWindowEvent(): Alle Events, die der Purebasic-Befehl WindowEvent() zurück gibt
; evh_SetMenuEvent() : Hier ist kein Eventtyp anzugeben, es wird nur die Menuitem-Nummer ausgewertet
; evh_SetGadgetEvent(): Alle Events, die der Purebasic-Befehl EventType() zurück gibt
;
; In *EventProcedure gibt man die Adresse der Prozedur an, die bei Auftreten des Events aufgerufen werden soll
; (sie ist anzugeben mittels @Prozedurname()).
;
; Jeder Eventprozedur wird als einziger Parameter ein Zeiger auf die folgende Event-Parameterstruktur übergeben:
;
; \iEvent
; \iEventType
; \iEventWindow
; \iEventGadget
; \iEventMenu
; \iEventTimer
; \iEventwParam ; enthält nur unter Windows sinnvolle Werte
; \iEventlParam ; enthält nur unter Windows sinnvolle Werte
;
; (Der Strukturtyp lautet "evh_EventArgsStruct" und ist im Eventhandler-Include definiert)
;
; Eine Eventprozedur ist somit immer nach folgendem Schema aufzubauen (Beispiel):
;
; Procedure Name(*stEventArgs.evh_EventArgsStruct)
; ...
; EndProcedure
;
; Die Felder der Struktur entsprechen den äquivalenten PB-Befehlen WaitWindowEvent(), EventType(),
; EventWindow(), usw. und enthalten genau das jeweilige Ergebnis dieser PB-Befehle.
; Die Felder iEventwParam und iEventlParam enthalten nur gültige Werte, wenn das Include auf einem Windwos PC
; kompiliert wird. Die zugehörigen PB Befehle EventwParam() und EventlParam() sind undokumentierte Befehle und
; funktionieren nur unter Windows. Auf anderen Betriebssystemen werden diese Felder mit 0 initialisiert.
;
; Die Felder \iEventGadget bzw. \iEventMenu enthalten nur sinnvolle Werte, wenn das Feld \iEvent entweder
; #PB_Event_Gadget oder #PB_Event_Menu enthält.
;
; WICHTIG:
; Bitte nicht vergessen den Parameter (*stEventArgs.evh_EventArgsStruct) immer in die eigenen Eventprozeduren
; einzubauen, da es sonst zwangsläufig zu einem Rücksprungfehler kommt! (=> Das Programm stürzt ab, weil die
; Daten vom Stack nicht abgeholt wurden)
;
; Um einen registrierten Event wieder aufzuheben, ruft man den Befehl evh_RemoveEvent() auf
;
; evh_RemoveEvent(iWindowNr, [iItemNr], [iEventType])
;
; Die beiden Parameter iItemNr und iEventType entsprechen den beiden Parametern des jeweiligen
; evh_SetXYZEvent-Befehls. Also z.B. der GadgetNummer und dem Eventtyp bei evh_SetGadgetEvent()
;
; Werden die beiden o.g. Parameter weggelassen und nur iWindowNr angegeben, dann werden automatisch
; ALLE Events unregistriert, die zu dem angegebenen Fenster iWindowNr gehören.
;
; Dies ist nützlich, wenn man beim Schließen eines Fensters alle zugehörigen, registrierten Events auf einen
; Schlag unregistrieren möchte.
;
; Der eigentliche Eventloop des Programms beschränkt sich dann nur noch auf ein zweizeiliges Konstrukt.
; Beispiel:
;
; While evh_ProcessEvents(25, MainWindow, @OwnEventproc(), 0)
; Wend
;
; Mit dem Befehl evh_ProcessEvents(iTimeOut, iObserveWindow, [*OwnEventHandler], [*stEvents]) nimmt der
; Eventhandler seine Arbeit auf. Der Befehl muß innerhalb eines Loops immer wiederkehrend aufgerufen
; werden, genau so wie der PB Befehl WaitWindowEvent().
;
; Die Parameter im Einzelnen:
;
; iTimeOut: Der Parameter iTimeOut gibt den Timeoutwert in Millisekunden an, die der Eventhandler auf
; eine Nachricht warten soll. Kommt in dieser Zeit keine Nachricht an, dann kehrt das Programm in den
; Loop zurück. Der Eventhandler benutzt den WaitWindowEvent() Befehl, insofern gilt analog das, was in
; der PB Hilfe zu diesem Befehl erklärt wird.
; (Anm.: Wird der Parameter *stEvents benutzt, dann ist der Wert iTimeOut nicht relevant)
;
; iObserveWindow: Mit iObserveWindow gibt man das Handle des Hauptfensters seiner Applikation an.
; Wird in diesem Fenster ein #PB_Event_CloseWindow ausgelöst (= Fenster wird geschlossen), dann gibt der
; Befehl evh_ProcessEvents() ein #False zurück. In allen anderen Fällen ein #True.
; Dadruch wird der obige While/Wend Eventloop ermöglicht, der mittels Rückgabewert #False beendet wird.
;
; *OwnEventHandler (optional): Da man vielleicht nicht alle Events über den Eventhandler bearbeiten lassen
; möchte, kann man als dritten Parameter die Adresse einer eigenen Eventprozedur angeben, die *nach*
; Abarbeitung der registrierten Events zusätzlich aufgerufen wird. Möchte man keine eigene Event Bearbeitungs-
; prozedur benutzen, dann setzt man als dritten Parameter 0 ein.
;
; Diese eigene Event-Bearbeitungsprozedur bekommt als Parameter ebenfalls einen Zeiger auf eine Event-
; Parameterstruktur vom Typ evh_EventArgsStruct übergeben:
;
; \iEvent
; \iEventType
; \iEventWindow
; \iEventGadget
; \iEventMenu
; \iEventTimer
; \iEventwParam ; enthält nur unter Windows sinnvolle Werte
; \iEventlParam ; enthält nur unter Windows sinnvolle Werte
;
; Auch der Inhalt dieser Felder entspricht den äquivalenten PB-Befehlen WaitWindowEvent(), EventType(),
; EventWindow(), usw.
;
; Der Rumpf der eigenen Event-Bearbeitungsprozedur ist somit genau so aufgebaut, wie eine Eventprozedur:
;
; Procedure Name(*stEventArgs.evh_EventArgsStruct)
; ...
; EndProcedure
;
; WICHTIG:
; Bitte nicht vergessen den Parameter (*stEventArgs.evh_EventArgsStruct) immer in die eigenen Event-Bearbeitungs-
; prozedur einzubauen, da es sonst zwangsläufig zu einem Rücksprungfehler kommt! (=> Das Programm stürzt ab,
; weil die Daten vom Stack nicht abgeholt wurden)
;
; *stEvents (optional): *stEvents stellt einen Zeiger auf eine Event-Parameterstruktur dar.
; Ist dieser Zeiger =! 0 (zeigt er also auf eine initialisierte Struktur), dann ermittelt die
; Prozedur evh_ProcessEvents() die PureBasic Fensterevents nicht selbst, sondern bearbeitet die Events,
; die mittels der *stEvents-Struktur übergeben wurden.
;
; Hiermit ist es möglich, seine eigene Eventbearbeitung bzw. sogar eigene Events zu programmieren,
; die dann über den Eventhandler automatisch ausgewertet werden (sofern diese Events zuvor registriert
; wurden.
;
; Die Struktur, auf die *stEvents zeigt ist ebenfalls vom Typ evh_EventArgsStruct und hat folgenden Aufbau:
;
; \iEvent
; \iEventType
; \iEventWindow
; \iEventGadget
; \iEventMenu
; \iEventTimer
; \iEventwParam ; enthält nur unter Windows sinnvolle Werte
; \iEventlParam ; enthält nur unter Windows sinnvolle Werte
;
; Werden die Parameter *stEvents und *OwnEventHandler nicht genutzt, dann können sie weggelassen werden.
Weiter unten gibt es einen downloadlink auf ein Zip-Archiv mit dem Sourcecode des Eventhandlers-Includes sowie zwei Demoprogrammen.
Ich hoffe den Code kann jemand von Euch gebrauchen, auch wenn er sicherlich noch erweiterungsfähig ist.
Erstellt wurde er jedenfalls gewissenhaft. Solltet Ihr dennoch Fehler darin finden, wäre ich über Rückmeldungen hier im thread dankbar.
Viel Spaß damit.
Gruß Kurzer
Edit1:
Include und Demo erweitert.
Änderungen:
- Man kann einem bereits registrierten Gadget/Menüitem nun durch nochmaligen Aufruf von evh_SetGadgetEvent(), evh_SetMenuEvent() bzw. evh_SetWindowEvent() zur Laufzeit eine neue Eventprozedur zuordnen.
Edit2:
Include und Demo erweitert.
Änderungen:
- Anmerkung von ts-soft umgesetzt. Die Prozedur evh_ProcessEvents() hat einen weiteren Parameter bekommen.
iObserveWindow = Handle des Hauptfensters.
Wird in diesem Fenster ein #PB_Event_CloseWindow ausgelöst (Fenster wird geschlossen), dann gibt evh_ProcessEvents() ein #False zurück, in allen anderen Fällen ein #True. Dadruch wird ein While/Wend Eventloop ermöglicht.
Edit3:
Include und Demo erweitert.
Änderungen:
- Ein neuer Befehl ermöglicht nun auch das Registrieren von ganzen Fenstern:
evh_SetWindowEvent(iWindowNr, iEventType, iEventProcedure)
Verhalten analog zu evh_SetGadgetEvent().
- evh_Init() benötigt nun kein Parameter mehr.
Man muß nicht mehr im Vorfeld wissen wieviel Gadgets zu verwalten sind.
- Die zugeordneten Eventprozeduren bekommen nun explizit die folgenden Parameter übergeben:
iEvent.i, iEventType.i, iEventWindow.i, iEventControlNr, iEventwParam.i, iEventlParam.i
Diese Parameter müssen in der Prozedurdefinition vorhanden sein.
Nähere Erklärungen sind oben im Infotext zu finden.
Edit4:
Include und Demo erweitert.
Änderungen:
- Die zugeordneten Eventprozeduren bekommen nun nicht mehr (wie unter Edit 3 beschrieben) einzelne Parameter übergeben, sondern einen Zeiger auf eine Parameterstruktur:
\iEvent
\iEventType
\iEventWindow
\iEventGadget
\iEventMenu
\iEventwParam
\iEventlParam
Die Eventprozeduren haben somit nur noch einen Parameter statt sechs. Gleiches gilt für die Parameter einer eigenen Event-Bearbeitungsprozedur.
Edit5:
Include und Demo erweitert.
Änderungen:
- Vorschlag von PureLust umgesetzt
Die Prozedur evh_ProcessEvents() hat einen weiteren Parameter bekommen: *stEvents
Der Aufruf sieht nun wie folgt aus: evh_ProcessEvents(iTimeOut, iObserveWindow, *OwnEventHandler, *stEvents)
*stEvents ist ein Pointer auf eine Parameterstruktur (Aufbau siehe Edit 6).
Ist dieser Pointer initialisiert, dann wird evh_ProcessEvents() die Events nicht selbst ermitteln, sondern den Event bearbeiten, der über die Struktur übergeben wurde.
Dadurch kann evh_ProcessEvents() in einen eigenen Evenhandler-Loop integriert werden.
(Nähere Details siehe Infotext oben)
Edit6:
Include und Demo erweitert.
Ups, ich hatte den Eventhandler seinerzeit noch zweimal erweitert, aber vergessen diesen Thread hier anzupassen.
Das wird hiermit nachgeholt. Sorry an alle die meinen Code benutzen und somit nicht in den Genuss der neuen Funktionalität gekommen sind.
Änderungen:
Alle evh_SetxyzEvent() Befehle enthalten nun zusätzlich den Parameter WindowNr.
Dieser ist für den neuen Befehl evh_RemoveEvent() nötig.
Den neuen Befehl evh_RemoveEvent(WindowNr, ItemNr, EventType) zugefügt.
Hiermit können während der Programmlaufzeit einzelne Eventzuordnungen wieder entfernt werden oder alle Eventzuordnungen eines Fensters auf einen Schlag entfernt werden.
Der Befehl evh_Init() muss nicht mehr aufgerufen werden. Der Handler initialisiert sich bei der ersten Eventzuordnung selbst.
Die evh_EventArgsstruct wurde um iEventTimer erweitert.
\iEvent
\iEventType
\iEventWindow
\iEventGadget
\iEventMenu
\iEventTimer
\iEventwParam
\iEventlParam
Hiermit wird einer Eventprozedur, die einem WindowTimer-Event zugeordnet wurde, die Nummer des Timers übermittelt. Näheres siehe Beispielquellcode im Downloadpaket.
Edit7:
Include erweitert.
Änderungen:
Die beiden Windows-spezifischen Funktionen EventwParam() und EventlParam() werden nur noch unter Windows mitkompiliert. Dadurch funktioniert das Include auch unter anderen Betriebssystemen (Danke an ts-soft für den Hinweis)
Die zugehörigen Strukturfelder \iEventwParam.i und \iEventlParam.i enthalten unter Nicht-Windows Installationen den Wert 0
Das Zip-Archiv mit Quellcode und zwei Demoprogrammen ist hier herunterzuladen.
