vdk 2.4.0
evhandle.h
1/*
2 * ===========================
3 * VDK Visual Develeopment Kit
4 * Version 0.4
5 * October 1998
6 * ===========================
7 *
8 * Copyright (C) 1998, Mario Motta
9 * Developed by Mario Motta <mmotta@guest.net>
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Library General Public
13 * License as published by the Free Software Foundation; either
14 * version 2 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Library General Public License for more details.
20 *
21 * You should have received a copy of the GNU Library General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
24 * 02111-1307, USA.
25 */
26#ifndef EVHANDLE_H
27#define EVHANDLE_H
28#include <vdk/vdkobj.h>
29#include <gdk/gdktypes.h>
30#include <cstring>
31/*
32==============================================
33 SIGNAL DISPATCHER ROUTINES
34==============================================
35*/
36/*
37_VDKSignalTable_:
38Obj/Signal/Response method Table
39*/
40template <class T>
41class _VDKSignalTable_ {
42 public:
43 typedef bool (T::*PMF)(VDKObject* sender);
44 VDKObject* T::*Pm; /* <class T> member offset */
45 int signal; /* signal type (see enum VDKSignal in vdkobj.h) */
46 PMF Pmf; /* <class T> member function offset */
47 bool connected; /* connected flag, if false denies signal */
48};
49
50/*
51Signal response function map declaration:
52declare a static signal table for each form
53*/
54
55#define DECLARE_SIGNAL_MAP(_Parent_Class_) \
56private:\
57static _VDKSignalTable_< _Parent_Class_ > _STEntries_[];\
58typedef _VDKSignalTable_< _Parent_Class_ >::PMF _Member_;\
59typedef _Parent_Class_ _Parent_MyClass_;\
60protected:\
61 virtual int VDKSignalResponseTableSize();\
62public:\
63 virtual int VDKSignalResponse(GtkWidget* , int signal, void*, void*,bool);\
64 virtual int SignalDetach(VDKObject* Pm, int signal);\
65 virtual bool SignalAttach(int slot);
66
67/*
68define form signal response function that in turn call
69object signal response function
70algorithm:
711. scan table until find table end
72 2. if matches object and signal then slot is found
73 3. if slot is connected
74 4. bind object address with member function class offset
75 5. call callback
76 6. if callback return true consider signal "treated"
777. if signal is treated finish
78 otherwise recursively call himself to ancestor class
79*/
80
81#define DEFINE_SIGNAL_MAP(_Parent_Class_,base)\
82\
83int _Parent_Class_::VDKSignalResponse(GtkWidget* mobj, \
84int signal, void* obj, void* real_sender, bool treated) \
85{\
86int t=0;\
87 /*bool treated = false;*/\
88VDKObject* vdkobj = reinterpret_cast<VDKObject*>(obj);\
89VDKObject* real = reinterpret_cast<VDKObject*>(real_sender);\
90for(;_STEntries_[t].Pm != NULL ;t++)\
91{\
92VDKObject* _Parent_Class_::*memberOffset = _STEntries_[t].Pm;\
93if ( ((*this).*memberOffset == vdkobj) &&\
94 (_STEntries_[t].signal == signal) )\
95 {\
96 if (_STEntries_[t].connected)\
97 {\
98 bool(_Parent_Class_::*response)(VDKObject* sender)= \
99 _STEntries_[t].Pmf;\
100 if(((*this).*response)(real) == true)\
101 treated = true;\
102 }\
103 /*break;*/\
104 }\
105 }\
106if(treated) return 1;\
107else return base::VDKSignalResponse(mobj,signal,obj,real_sender, treated);\
108}\
109\
110\
111int _Parent_Class_::VDKSignalResponseTableSize()\
112{\
113int t = 0;\
114for(;_STEntries_[t].Pm != NULL;t++)\
115 ;\
116return t;\
117}\
118\
119\
120\
121int _Parent_Class_::SignalDetach(VDKObject* Pm, int signal)\
122{\
123int t=0;\
124for(;_STEntries_[t].Pm != NULL ;t++)\
125 {\
126 VDKObject* _Parent_Class_::*memberOffset = _STEntries_[t].Pm;\
127 if ( ((*this).*memberOffset == Pm) &&\
128 (_STEntries_[t].signal == signal) &&\
129 _STEntries_[t].connected != false)\
130 {\
131 _STEntries_[t].connected = false;\
132 return t;\
133 }\
134 }\
135return -1;\
136}\
137\
138\
139\
140bool _Parent_Class_::SignalAttach(int slot)\
141{\
142if( (slot >= 0) && (slot <= VDKSignalResponseTableSize()) )\
143 {\
144 _STEntries_[slot].connected = true;\
145 return true;\
146 }\
147else\
148 return false;\
149}\
150\
151\
152_VDKSignalTable_< _Parent_Class_ > _Parent_Class_::_STEntries_[] = {
153/*
154fill static signal table
155*/
156#define ON_SIGNAL(_obj_,_SIGNAL_,_member_) \
157 { reinterpret_cast<VDKObject* _Parent_MyClass_::*>(&_Parent_MyClass_::_obj_),\
158 _SIGNAL_,&_Parent_MyClass_::_member_,true}
159/*
160*/
161#define END_SIGNAL_MAP ,{ NULL, 0, NULL, false} };
162/*
163*/
164
165/*
166==============================================
167 EVENT DISPATCHER ROUTINES
168==============================================
169*/
170/*
171EVENTTableEntry:
172Event-ObjectCallback Table Entry
173*/
174template <class T>
175class EVENTTableEntry {
176 public:
177 // typedef void (T::*PMF)(VDKObject* sender, GdkEvent* event);
178 typedef bool (T::*PMF)(VDKObject* sender, GdkEvent* event);
179 VDKObject* T::*Pm; /* pointer to <class T> member offset */
180 GdkEventType event; /* event type (see enum VDKevent in vdkobj.h) */
181 PMF Pmf; /* pointer to <class T> member function */
182 bool connected;
183};
184/*
185Events response function map declaration:
186declare a static events table for each form
187*/
188#define DECLARE_EVENT_MAP(_EVENTclass_) \
189private:\
190static EVENTTableEntry< _EVENTclass_ > __OCBEventEntries[];\
191typedef EVENTTableEntry< _EVENTclass_ >::PMF _EvMember_;\
192typedef _EVENTclass_ _EVENTmyclass_;\
193protected:\
194 virtual int VDKEventResponseTableSize();\
195public:\
196 virtual int VDKEventResponse(GtkWidget* , GdkEvent* , void*, void*,bool);\
197 virtual int EventDetach(VDKObject* , VDKEvent event);\
198 virtual bool EventAttach(int slot);
199/*
200define form EVENT response function that in turn call
201object EVENT response function
202*/
203#define DEFINE_EVENT_MAP(_EVENTclass_,base) \
204int _EVENTclass_::VDKEventResponse(GtkWidget* wid, GdkEvent* event, void* obj, void* real_sender, bool treated) \
205\
206{\
207int t=0;\
208 /*bool treated = false;*/\
209VDKObject* vdkobj = reinterpret_cast<VDKObject*>(obj);\
210VDKObject* real = reinterpret_cast<VDKObject*>(real_sender);\
211for(;__OCBEventEntries[t].Pm != NULL ;t++)\
212 {\
213 VDKObject* _EVENTclass_::*memberOffset = __OCBEventEntries[t].Pm;\
214 if( ((*this).*memberOffset == vdkobj) &&\
215 (__OCBEventEntries[t].event == ((GdkEventAny*)event)->type) )\
216 {\
217 if (__OCBEventEntries[t].connected)\
218 {\
219 bool (_EVENTclass_::*response)\
220 (VDKObject* , GdkEvent* ) = \
221 __OCBEventEntries[t].Pmf;\
222 if(((*this).*response)(real,event))\
223 treated = true;\
224 }\
225 /*break;*/\
226 }\
227 }\
228if(treated) return 1;\
229else return base::VDKEventResponse(wid,event,obj,real_sender, treated); \
230}\
231\
232\
233\
234int _EVENTclass_::VDKEventResponseTableSize()\
235{\
236int t = 0;\
237for(;__OCBEventEntries[t].Pm != NULL;t++)\
238 ;\
239return t;\
240}\
241\
242\
243\
244int _EVENTclass_::EventDetach(VDKObject* Pm, VDKEvent event)\
245{\
246int t=0;\
247for(;__OCBEventEntries[t].Pm != NULL ;t++)\
248 {\
249VDKObject* _EVENTclass_::*memberOffset = __OCBEventEntries[t].Pm;\
250 if ( ((*this).*memberOffset == Pm) &&\
251 (__OCBEventEntries[t].event == (GdkEventType) event)&&\
252 __OCBEventEntries[t].connected != false)\
253 {\
254 __OCBEventEntries[t].connected = false;\
255 return t;\
256 }\
257 }\
258return -1;\
259}\
260\
261\
262\
263bool _EVENTclass_::EventAttach(int slot)\
264{\
265if( (slot >= 0) && (slot <= VDKEventResponseTableSize()) )\
266 {\
267 __OCBEventEntries[slot].connected = true;\
268 return true;\
269 }\
270else\
271 return false;\
272}\
273\
274\
275EVENTTableEntry< _EVENTclass_ > _EVENTclass_::__OCBEventEntries[] = {
276/*
277fill static EVENT table
278*/
279#define ON_EVENT(_obj_,_EVENT_,_member_) \
280/* {reinterpret_cast<VDKObject* _EVENTmyclass_::*>(&_EVENTmyclass_::_obj_), (GdkEventType) _EVENT_,&(_EVENTmyclass_::_member_),true} */ \
281{reinterpret_cast<VDKObject* _EVENTmyclass_::*>(&_EVENTmyclass_::_obj_), (GdkEventType) _EVENT_,&_EVENTmyclass_::_member_,true}
282
283/*
284*/
285#define END_EVENT_MAP ,{ NULL , (GdkEventType) 0, NULL,false} };
286
287#endif
288
289
290
291
292
293
294
Definition: vdkobj.h:141