/usr/include/wx-3.0/wx/wxPython/i_files/_evthandler.i is in python-wxgtk3.0-dev 3.0.2.0+dfsg-4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 | /////////////////////////////////////////////////////////////////////////////
// Name: _evthandler.i
// Purpose: SWIG interface for wxEventHandler
//
// Author: Robin Dunn
//
// Created: 9-Aug-2003
// RCS-ID: $Id$
// Copyright: (c) 2003 by Total Control Software
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// Not a %module
//---------------------------------------------------------------------------
%newgroup
// wxEvtHandler: the base class for all objects handling wxWindows events
class wxEvtHandler : public wxObject {
public:
// turn off this typemap
%typemap(out) wxEvtHandler*;
%pythonAppend wxEvtHandler "self._setOORInfo(self)"
wxEvtHandler();
// Turn it back on again
%typemap(out) wxEvtHandler* { $result = wxPyMake_wxObject($1, $owner); }
wxEvtHandler* GetNextHandler();
wxEvtHandler* GetPreviousHandler();
void SetNextHandler(wxEvtHandler* handler);
void SetPreviousHandler(wxEvtHandler* handler);
bool GetEvtHandlerEnabled();
void SetEvtHandlerEnabled(bool enabled);
void Unlink();
bool IsUnlinked() const;
// process an event right now
bool ProcessEvent(wxEvent& event);
// Process an event by calling ProcessEvent and handling any exceptions
// thrown by event handlers. It's mostly useful when processing wx events
// when called from C code (e.g. in GTK+ callback) when the exception
// wouldn't correctly propagate to wxEventLoop.
bool SafelyProcessEvent(wxEvent& event);
// This method tries to process the event in this event handler, including
// any preprocessing done by TryBefore() and all the handlers chained to
// it, but excluding the post-processing done in TryAfter().
//
// It is meant to be called from ProcessEvent() only and is not virtual,
// additional event handlers can be hooked into the normal event processing
// logic using TryBefore() and TryAfter() hooks.
//
// You can also call it yourself to forward an event to another handler but
// without propagating it upwards if it's unhandled (this is usually
// unwanted when forwarding as the original handler would already do it if
// needed normally).
bool ProcessEventLocally(wxEvent& event);
void QueueEvent(wxEvent *event);
// add an event to be processed later
void AddPendingEvent(const wxEvent& event);
// process all pending events
void ProcessPendingEvents();
void DeletePendingEvents();
%extend {
// Dynamic association of a member function handler with the event handler
void Connect( int id, int lastId, wxEventType eventType, PyObject* func) {
bool is_callable = false;
{
wxPyThreadBlocker blocker;
is_callable = PyCallable_Check(func) != 0;
}
if (is_callable) {
self->Connect(id, lastId, eventType,
(wxObjectEventFunction)(wxEventFunction)
&wxPyCallback::EventThunker,
new wxPyCallback(func));
}
else if (func == Py_None) {
self->Disconnect(id, lastId, eventType,
(wxObjectEventFunction)(wxEventFunction)
&wxPyCallback::EventThunker);
}
else {
wxPyBLOCK_THREADS(
PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
}
}
bool Disconnect(int id, int lastId = -1,
wxEventType eventType = wxEVT_NULL,
PyObject* func = NULL ) {
if (func && func != Py_None) {
// Find the current matching binder that has this function
// pointer and dissconnect that one. Unfortuneatly since we
// wrapped the PyObject function pointer in another object we
// have to do the searching ourselves...
wxList::compatibility_iterator node = self->GetDynamicEventTable()->GetFirst();
while (node)
{
wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
if ((entry->m_id == id) &&
((entry->m_lastId == lastId) || (lastId == wxID_ANY)) &&
((entry->m_eventType == eventType) || (eventType == wxEVT_NULL)) &&
// FIXME?
//((entry->m_fn->IsMatching((wxObjectEventFunction)(wxEventFunction)&wxPyCallback::EventThunker))) &&
(entry->m_callbackUserData != NULL))
{
wxPyCallback *cb = (wxPyCallback*)entry->m_callbackUserData;
wxPyBlock_t blocked = wxPyBeginBlockThreads();
int result = PyObject_Compare(cb->m_func, func);
wxPyEndBlockThreads(blocked);
if (result == 0) {
delete cb;
self->GetDynamicEventTable()->Erase(node);
delete entry;
return true;
}
}
node = node->GetNext();
}
return false;
}
else {
return self->Disconnect(id, lastId, eventType,
(wxObjectEventFunction)
&wxPyCallback::EventThunker);
}
}
}
%pythonAppend _setOORInfo "args[0].this.own(False)";
%extend {
void _setOORInfo(PyObject* _self, bool incref=true) {
if (_self && _self != Py_None) {
self->SetClientObject(new wxPyOORClientData(_self, incref));
}
else {
wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
if (data) {
self->SetClientObject(NULL); // This will delete it too
}
}
}
}
%pythoncode {
def Bind(self, event, handler, source=None, id=wx.ID_ANY, id2=wx.ID_ANY):
"""
Bind an event to an event handler.
:param event: One of the EVT_* objects that specifies the
type of event to bind,
:param handler: A callable object to be invoked when the
event is delivered to self. Pass None to
disconnect an event handler.
:param source: Sometimes the event originates from a
different window than self, but you still
want to catch it in self. (For example, a
button event delivered to a frame.) By
passing the source of the event, the event
handling system is able to differentiate
between the same event type from different
controls.
:param id: Used to spcify the event source by ID instead
of instance.
:param id2: Used when it is desirable to bind a handler
to a range of IDs, such as with EVT_MENU_RANGE.
"""
assert isinstance(event, wx.PyEventBinder)
assert handler is None or callable(handler)
assert source is None or hasattr(source, 'GetId')
if source is not None:
id = source.GetId()
event.Bind(self, id, id2, handler)
def Unbind(self, event, source=None, id=wx.ID_ANY, id2=wx.ID_ANY, handler=None):
"""
Disconnects the event handler binding for event from self.
Returns True if successful.
"""
if source is not None:
id = source.GetId()
return event.Unbind(self, id, id2, handler)
}
%property(EvtHandlerEnabled, GetEvtHandlerEnabled, SetEvtHandlerEnabled, doc="See `GetEvtHandlerEnabled` and `SetEvtHandlerEnabled`");
%property(NextHandler, GetNextHandler, SetNextHandler, doc="See `GetNextHandler` and `SetNextHandler`");
%property(PreviousHandler, GetPreviousHandler, SetPreviousHandler, doc="See `GetPreviousHandler` and `SetPreviousHandler`");
};
//---------------------------------------------------------------------------
// A class derived from wxEvtHandler that allows the ProcessEvent method to be
// overridden in Python.
%{ // The Python-aware C++ class
class wxPyEvtHandler : public wxEvtHandler
{
DECLARE_DYNAMIC_CLASS(wxPyEvtHandler)
public:
wxPyEvtHandler() : wxEvtHandler() {}
virtual bool ProcessEvent(wxEvent& event)
{
bool found;
bool rval;
wxString className = event.GetClassInfo()->GetClassName();
wxPyBlock_t blocked = wxPyBeginBlockThreads();
if ((found = wxPyCBH_findCallback(m_myInst, "ProcessEvent"))) {
PyObject* arg = wxPyConstructObject((void*)&event, className);
rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)",arg));
Py_DECREF(arg);
}
wxPyEndBlockThreads(blocked);
if (! found)
rval = wxEvtHandler::ProcessEvent(event);
return rval;
}
PYPRIVATE;
};
IMPLEMENT_DYNAMIC_CLASS(wxPyEvtHandler, wxEvtHandler)
%}
// Let SWIG see this class too
DocStr(wxPyEvtHandler,
"The wx.PyEvtHandler class can be used to intercept calls to the
`ProcessEvent` method. Simply derive a new class from this one,
override ProcessEvent, and then push an instance of the class onto the
event handler chain for a window using `wx.Window.PushEventHandler`.", "");
class wxPyEvtHandler : public wxEvtHandler
{
public:
%pythonAppend wxPyEvtHandler "self._setOORInfo(self);" setCallbackInfo(PyEvtHandler)
wxPyEvtHandler();
void _setCallbackInfo(PyObject* self, PyObject* _class);
DocDeclStr(
virtual bool , ProcessEvent(wxEvent& event),
"Override this method to intercept the events being sent to the window.
The default implementation searches the event tables and calls event
handler functions if matching event bindings are found.", "");
};
//---------------------------------------------------------------------------
|