utils/wxPython/src/helpers.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        helpers.h
   3 // Purpose:     Helper functions/classes for the wxPython extenaion module
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     7/1/97
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1998 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 #ifndef __wxp_helpers__
  14 #define __wxp_helpers__
  15
  16 #include <wx/wx.h>
  17
  18
  19 //----------------------------------------------------------------------
  20
  21 // if we want to handle threads and Python threads are available...
  22 #if defined(WXP_USE_THREAD) && defined(WITH_THREAD)
  23
  24 #define WXP_WITH_THREAD
  25 #define wxPy_BEGIN_ALLOW_THREADS  Py_BEGIN_ALLOW_THREADS
  26 #define wxPy_END_ALLOW_THREADS    Py_END_ALLOW_THREADS
  27
  28 #else  // no Python threads...
  29 #undef WXP_WITH_THREAD
  30 #define wxPy_BEGIN_ALLOW_THREADS
  31 #define wxPy_END_ALLOW_THREADS
  32 #endif
  33
  34 #ifdef WXP_WITH_THREAD
  35 extern PyThreadState*   wxPyEventThreadState;
  36 extern bool             wxPyInEvent;
  37 #endif
  38
  39 //----------------------------------------------------------------------
  40
  41 class wxPyApp: public wxApp
  42 {
  43 public:
  44     wxPyApp();
  45     ~wxPyApp();
  46     int  MainLoop(void);
  47     bool OnInit(void);
  48     void AfterMainLoop(void);
  49 };
  50
  51 extern wxPyApp *wxPythonApp;
  52
  53 //----------------------------------------------------------------------
  54
  55 void      __wxPreStart();
  56 PyObject* __wxStart(PyObject*, PyObject* args);
  57
  58 extern PyObject* wxPython_dict;
  59 PyObject* __wxSetDictionary(PyObject*, PyObject* args);
  60
  61 extern wxHashTable*  wxPyWindows;  // keep track of all windows so we
  62                                    // don't accidentally delete them twice.
  63
  64 void wxPyEventThunker(wxObject*, wxEvent& event);
  65
  66 //----------------------------------------------------------------------
  67
  68
  69 #ifndef SWIGCODE
  70 extern "C" void SWIG_MakePtr(char *, void *, char *);
  71 extern "C" char *SWIG_GetPtr(char *, void **, char *);
  72 #endif
  73
  74
  75 #ifdef _MSC_VER
  76 # pragma warning(disable:4800)
  77 #endif
  78
  79 typedef unsigned char byte;
  80
  81
  82 // Non-const versions to keep SWIG happy.
  83 extern wxPoint  wxPyDefaultPosition;
  84 extern wxSize   wxPyDefaultSize;
  85 extern wxString wxPyEmptyStr;
  86
  87 //----------------------------------------------------------------------
  88
  89 class wxPyCallback : public wxObject {
  90 public:
  91     wxPyCallback(PyObject* func);
  92     ~wxPyCallback();
  93
  94     void EventThunker(wxEvent& event);
  95
  96     PyObject*   m_func;
  97 };
  98
  99 //---------------------------------------------------------------------------
 100
 101 class wxPyMenu : public wxMenu {
 102 public:
 103     wxPyMenu(const wxString& title = "", PyObject* func=NULL);
 104     ~wxPyMenu();
 105
 106 private:
 107     static void MenuCallback(wxMenu& menu, wxCommandEvent& evt);
 108     PyObject*   func;
 109 };
 110
 111
 112 //---------------------------------------------------------------------------
 113
 114 class wxPyTimer : public wxTimer {
 115 public:
 116     wxPyTimer(PyObject* callback);
 117     ~wxPyTimer();
 118
 119     void        Notify();
 120
 121 private:
 122     PyObject*   func;
 123 };
 124
 125 //---------------------------------------------------------------------------
 126
 127 class wxPyEvent : public wxCommandEvent {
 128     DECLARE_DYNAMIC_CLASS(wxPyEvent)
 129 public:
 130     wxPyEvent(wxEventType commandType = wxEVT_NULL, PyObject* userData = Py_None);
 131     ~wxPyEvent();
 132
 133     void SetUserData(PyObject* userData);
 134     PyObject* GetUserData();
 135
 136 private:
 137     PyObject* m_userData;
 138 };
 139
 140
 141
 142
 143
 144 //---------------------------------------------------------------------------
 145 // This class holds an instance of a Python Shadow Class object and assists
 146 // with looking up and invoking Python callback methods from C++ virtual
 147 // method redirections.  For all classes which have virtuals which should be
 148 // overridable in wxPython, a new subclass is created that contains a
 149 // wxPyCallbackList.  This list is used to hold references to the Python
 150 // methods.
 151 //---------------------------------------------------------------------------
 152
 153 class wxPyCallbackHelper {
 154 public:
 155     wxPyCallbackHelper();
 156     ~wxPyCallbackHelper();
 157
 158     void        setSelf(PyObject* self);
 159
 160     bool        findCallback(const wxString& name);
 161     int         callCallback(PyObject* argTuple);
 162     PyObject*   callCallbackObj(PyObject* argTuple);
 163
 164 private:
 165     PyObject*   m_self;
 166     PyObject*   m_lastFound;
 167 };
 168
 169
 170
 171 //---------------------------------------------------------------------------
 172 // These macros are used to implement the virtual methods that should
 173 // redirect to a Python method if one exists.  The names designate the
 174 // return type, if any as well as any parameter types.
 175 //---------------------------------------------------------------------------
 176
 177 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME)                          \
 178     bool CBNAME(int a, int b) {                                         \
 179         if (m_myInst.findCallback(#CBNAME))                             \
 180             return m_myInst.callCallback(Py_BuildValue("(ii)",a,b));    \
 181         else                                                            \
 182             return PCLASS::CBNAME(a,b);                                 \
 183     }                                                                   \
 184     bool base_##CBNAME(int a, int b) {                                  \
 185         return PCLASS::CBNAME(a,b);                                     \
 186     }
 187
 188 //---------------------------------------------------------------------------
 189
 190 #define PYCALLBACK_BOOL_INT(PCLASS, CBNAME)                             \
 191     bool CBNAME(int a) {                                                \
 192         if (m_myInst.findCallback(#CBNAME))                             \
 193             return m_myInst.callCallback(Py_BuildValue("(i)",a));       \
 194         else                                                            \
 195             return PCLASS::CBNAME(a);                                   \
 196     }                                                                   \
 197     bool base_##CBNAME(int a) {                                         \
 198         return PCLASS::CBNAME(a);                                       \
 199     }
 200
 201 #define PYCALLBACK_BOOL_INT_pure(PCLASS, CBNAME)                        \
 202     bool CBNAME(int a) {                                                \
 203         if (m_myInst.findCallback(#CBNAME))                             \
 204             return m_myInst.callCallback(Py_BuildValue("(i)",a));       \
 205         else return false;                                              \
 206     }
 207
 208
 209 //---------------------------------------------------------------------------
 210
 211 #define PYCALLBACK__(PCLASS, CBNAME)                                    \
 212     void CBNAME() {                                                     \
 213         if (m_myInst.findCallback(#CBNAME))                             \
 214             m_myInst.callCallback(Py_BuildValue("()"));                 \
 215         else                                                            \
 216             PCLASS::CBNAME();                                           \
 217     }                                                                   \
 218     void base_##CBNAME() {                                              \
 219         PCLASS::CBNAME();                                               \
 220     }
 221
 222 //---------------------------------------------------------------------------
 223
 224 #define PYPRIVATE                               \
 225     void _setSelf(PyObject* self) {             \
 226         m_myInst.setSelf(self);                 \
 227     }                                           \
 228     private: wxPyCallbackHelper m_myInst;
 229
 230 //---------------------------------------------------------------------------
 231
 232 #endif
 233