wxPython/samples/embedded/embedded.cpp

   1 //----------------------------------------------------------------------
   2 // Name:        embedded.cpp
   3 // Purpose:     To serve as an example of how to use wxPython from
   4 //              within a C++ wxWindows program.
   5 //
   6 // Author:      Robin Dunn
   7 //
   8 // Created:     1-May-2002
   9 // RCS-ID:      $Id$
  10 // Copyright:   (c) 2002 by Total Control Software
  11 // Licence:     wxWindows license
  12 //----------------------------------------------------------------------
  13
  14 #include <Python.h>
  15
  16
  17 // For compilers that support precompilation, includes "wx/wx.h".
  18 #include <wx/wxprec.h>
  19
  20 #ifdef __BORLANDC__
  21     #pragma hdrstop
  22 #endif
  23
  24 #ifndef WX_PRECOMP
  25     #include <wx/wx.h>
  26 #endif
  27
  28 #include <wx/splitter.h>
  29
  30 #if defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXMAC__) || defined(__WXMGL__)
  31     #include "mondrian.xpm"
  32 #endif
  33
  34 // Import Python and wxPython headers
  35 #include <wx/wxPython/wxPython.h>
  36
  37
  38 //----------------------------------------------------------------------
  39 // Class definitions
  40
  41 class MyApp : public wxApp
  42 {
  43 public:
  44     virtual bool OnInit();
  45     virtual ~MyApp();
  46     void Init_wxPython();
  47 private:
  48     PyThreadState* m_mainTState;
  49 };
  50
  51
  52 class MyFrame : public wxFrame
  53 {
  54 public:
  55     MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size);
  56     void RedirectStdio();
  57     wxWindow* DoPythonStuff(wxWindow* parent);
  58     void OnExit(wxCommandEvent& event);
  59     void OnPyFrame(wxCommandEvent& event);
  60
  61 private:
  62     DECLARE_EVENT_TABLE()
  63 };
  64
  65 //----------------------------------------------------------------------
  66 // MyApp methods
  67
  68
  69 bool MyApp::OnInit()
  70 {
  71     Init_wxPython();
  72     MyFrame *frame = new MyFrame(_T("Embedded wxPython Test"),
  73                                  wxPoint(50, 50), wxSize(700, 600));
  74     frame->Show(TRUE);
  75     return TRUE;
  76 }
  77
  78
  79 void MyApp::Init_wxPython()
  80 {
  81     // Initialize Python
  82     Py_Initialize();
  83     PyEval_InitThreads();
  84
  85     // Load the wxPython core API.  Imports the wx._core module and sets a
  86     // local pointer to a function table located there.
  87     wxPyCoreAPI_IMPORT();
  88
  89     // Save the current Python thread state and release the
  90     // Global Interpreter Lock.
  91     m_mainTState = wxPyBeginAllowThreads();
  92 }
  93
  94
  95 MyApp::~MyApp()
  96 {
  97     // Restore the thread state and tell Python to cleanup after itself.
  98     // wxPython will do its own cleanup as part of that process.
  99     wxPyEndAllowThreads(m_mainTState);
 100     Py_Finalize();
 101 }
 102
 103
 104 IMPLEMENT_APP(MyApp)
 105
 106 //----------------------------------------------------------------------
 107
 108 enum
 109 {
 110     ID_EXIT=1001,
 111     ID_PYFRAME
 112 };
 113
 114
 115 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
 116     EVT_MENU(ID_EXIT,      MyFrame::OnExit)
 117     EVT_MENU(ID_PYFRAME,   MyFrame::OnPyFrame)
 118 END_EVENT_TABLE()
 119
 120
 121
 122 MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
 123     : wxFrame(NULL, -1, title, pos, size,
 124               wxDEFAULT_FRAME_STYLE|wxNO_FULL_REPAINT_ON_RESIZE)
 125 {
 126     SetIcon(wxICON(mondrian));
 127
 128     wxMenuBar* mbar = new wxMenuBar;
 129     wxMenu*    menu = new wxMenu;
 130     menu->Append(ID_PYFRAME, _T("Make wx&Python frame"));
 131     menu->AppendSeparator();
 132     menu->Append(ID_EXIT, _T("&Close Frame\tAlt-X"));
 133     mbar->Append(menu, _T("&File"));
 134     SetMenuBar(mbar);
 135
 136     CreateStatusBar();
 137     RedirectStdio();
 138
 139     // Make some child windows from C++
 140     wxSplitterWindow* sp = new wxSplitterWindow(this, -1);
 141     wxPanel* p1 = new wxPanel(sp, -1);
 142     p1->SetFont(wxFont(12, wxSWISS, wxNORMAL, wxBOLD));
 143     new wxStaticText(p1, -1,
 144                  _T("The frame, menu, splitter, this panel and this text were created in C++..."),
 145                  wxPoint(10,10));
 146
 147     // And get a panel from Python
 148     wxWindow* p2 = DoPythonStuff(sp);
 149
 150     sp->SplitHorizontally(p1, p2, GetClientSize().y/4);
 151 }
 152
 153 void MyFrame::OnExit(wxCommandEvent& event)
 154 {
 155     Close();
 156 }
 157
 158
 159 //----------------------------------------------------------------------
 160 // This is where the fun begins...
 161
 162
 163 char* python_code1 = "\
 164 import wx\n\
 165 f = wx.Frame(None, -1, 'Hello from wxPython!', size=(250, 150))\n\
 166 f.Show()\n\
 167 ";
 168
 169 void MyFrame::OnPyFrame(wxCommandEvent& event)
 170 {
 171     // For simple Python code that doesn't have to interact with the
 172     // C++ code in any way, you can execute it with PyRun_SimpleString.
 173
 174
 175     // First, whenever you do anyting with Python objects or code, you
 176     // *MUST* aquire the Global Interpreter Lock and block other
 177     // Python threads from running.
 178     bool blocked = wxPyBeginBlockThreads();
 179
 180     // Execute the code in the __main__ module
 181     PyRun_SimpleString(python_code1);
 182
 183     // Finally, release the GIL and let other Python threads run.
 184     wxPyEndBlockThreads(blocked);
 185 }
 186
 187
 188 void MyFrame::RedirectStdio()
 189 {
 190     // This is a helpful little tidbit to help debugging and such.  It
 191     // redirects Python's stdout and stderr to a window that will popup
 192     // only on demand when something is printed, like a traceback.
 193     char* python_redirect = "\
 194 import sys\n\
 195 import wx\n\
 196 output = wx.PyOnDemandOutputWindow()\n\
 197 sys.stdin = sys.stderr = output\n\
 198 ";
 199     bool blocked = wxPyBeginBlockThreads();
 200     PyRun_SimpleString(python_redirect);
 201     wxPyEndBlockThreads(blocked);
 202 }
 203
 204
 205
 206
 207 char* python_code2 = "\
 208 import embedded_sample\n\
 209 \n\
 210 def makeWindow(parent):\n\
 211     win = embedded_sample.MyPanel(parent)\n\
 212     return win\n\
 213 ";
 214
 215 wxWindow* MyFrame::DoPythonStuff(wxWindow* parent)
 216 {
 217     // More complex embedded situations will require passing C++ objects to
 218     // Python and/or returning objects from Python to be used in C++.  This
 219     // sample shows one way to do it.  NOTE: The above code could just have
 220     // easily come from a file, or the whole thing could be in the Python
 221     // module that is imported and manipulated directly in this C++ code.  See
 222     // the Python API for more details.
 223
 224     wxWindow* window = NULL;
 225     PyObject* result;
 226
 227     // As always, first grab the GIL
 228     bool blocked = wxPyBeginBlockThreads();
 229
 230     // Now make a dictionary to serve as the global namespace when the code is
 231     // executed.  Put a reference to the builtins module in it.  (Yes, the
 232     // names are supposed to be different, I don't know why...)
 233     PyObject* globals = PyDict_New();
 234     PyObject* builtins = PyImport_ImportModule("__builtin__");
 235     PyDict_SetItemString(globals, "__builtins__", builtins);
 236     Py_DECREF(builtins);
 237
 238     // Execute the code to make the makeWindow function
 239     result = PyRun_String(python_code2, Py_file_input, globals, globals);
 240     // Was there an exception?
 241     if (! result) {
 242         PyErr_Print();
 243         wxPyEndBlockThreads(blocked);
 244         return NULL;
 245     }
 246     Py_DECREF(result);
 247
 248     // Now there should be an object named 'makeWindow' in the dictionary that
 249     // we can grab a pointer to:
 250     PyObject* func = PyDict_GetItemString(globals, "makeWindow");
 251     wxASSERT(PyCallable_Check(func));
 252
 253     // Now build an argument tuple and call the Python function.  Notice the
 254     // use of another wxPython API to take a wxWindows object and build a
 255     // wxPython object that wraps it.
 256     PyObject* arg = wxPyMake_wxObject(parent);
 257     wxASSERT(arg != NULL);
 258     PyObject* tuple = PyTuple_New(1);
 259     PyTuple_SET_ITEM(tuple, 0, arg);
 260     result = PyEval_CallObject(func, tuple);
 261
 262     // Was there an exception?
 263     if (! result)
 264         PyErr_Print();
 265     else {
 266         // Otherwise, get the returned window out of Python-land and
 267         // into C++-ville...
 268         bool success = wxPyConvertSwigPtr(result, (void**)&window, _T("wxWindow"));
 269         wxASSERT_MSG(success, _T("Returned object was not a wxWindow!"));
 270         Py_DECREF(result);
 271     }
 272
 273     // Release the python objects we still have
 274     Py_DECREF(globals);
 275     Py_DECREF(tuple);
 276
 277     // Finally, after all Python stuff is done, release the GIL
 278     wxPyEndBlockThreads(blocked);
 279
 280     return window;
 281 }
 282
 283
 284 //----------------------------------------------------------------------
 285
 286
 287
 288
 289
 290