Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed the bugs preventing wxPython from being embedded in a wxWindows

Browse Source 
app, and added a sample showing how to do it.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@15329 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn
2002-05-02 04:45:47 +00:00
parent f44602beb7
commit a24268437f
14 changed files with 553 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

378
wxPython/samples/embedded/embedded.cpp Normal file
View File

@@ -0,0 +1,378 @@
//----------------------------------------------------------------------
// Name: embedded.cpp
// Purpose: To server as an example of how to use wxPython from
// within a C++ wxWindows program.
//
// Author: Robin Dunn
//
// Created: 1-May-2002
// RCS-ID: $Id$
// Copyright: (c) 2002 by Total Control Software
// Licence: wxWindows license
//----------------------------------------------------------------------
// For compilers that support precompilation, includes "wx/wx.h".
#include <wx/wxprec.h>
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif
#include <wx/splitter.h>
#if defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXMAC__) || defined(__WXMGL__)
#include "mondrian.xpm"
#endif
// Import Python and wxPython headers
#include <Python.h>
#include <wxPython.h>
//----------------------------------------------------------------------
// Class definitions
class MyApp : public wxApp
{
public:
virtual bool OnInit();
virtual ~MyApp();
void Init_wxPython();
private:
PyThreadState* main_tstate;
};
class MyFrame : public wxFrame
{
public:
MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size);
void RedirectStdio();
wxWindow* DoPythonStuff(wxWindow* parent);
void OnExit(wxCommandEvent& event);
void OnPyFrame(wxCommandEvent& event);
private:
DECLARE_EVENT_TABLE()
};
//----------------------------------------------------------------------
// MyApp methods
bool MyApp::OnInit()
{
Init_wxPython();
MyFrame *frame = new MyFrame(_T("Embedded wxPython Test"),
wxPoint(50, 50), wxSize(700, 600));
frame->Show(TRUE);
return TRUE;
}
void MyApp::Init_wxPython()
{
// Initialize Python
Py_Initialize();
PyEval_InitThreads();
// Load the wxPython core API. Imports the wxPython.wxc
// module and sets a pointer to a function table located there.
wxPyCoreAPI_IMPORT();
// Save the current Python thread state and release the
// Global Interpreter Lock.
main_tstate = wxPyBeginAllowThreads();
}
MyApp::~MyApp()
{
// Restore the thread state and tell Python to cleanup after itself.
wxPyEndAllowThreads(main_tstate);
Py_Finalize();
}
IMPLEMENT_APP(MyApp)
//----------------------------------------------------------------------
enum
{
ID_EXIT=1001,
ID_PYFRAME
};
BEGIN_EVENT_TABLE(MyFrame, wxFrame)
EVT_MENU(ID_EXIT, OnExit)
EVT_MENU(ID_PYFRAME, OnPyFrame)
END_EVENT_TABLE()
MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
: wxFrame(NULL, -1, title, pos, size,
wxDEFAULT_FRAME_STYLE|wxNO_FULL_REPAINT_ON_RESIZE)
{
SetIcon(wxICON(mondrian));
wxMenuBar* mbar = new wxMenuBar;
wxMenu* menu = new wxMenu;
menu->Append(ID_PYFRAME, "Make wx&Python frame");
menu->AppendSeparator();
menu->Append(ID_EXIT, "&Close Frame\tAlt-X");
mbar->Append(menu, "&File");
SetMenuBar(mbar);
CreateStatusBar();
RedirectStdio();
// Make some child windows from C++
wxSplitterWindow* sp = new wxSplitterWindow(this, -1);
wxPanel* p1 = new wxPanel(sp, -1);
p1->SetFont(wxFont(12, wxSWISS, wxNORMAL, wxBOLD));
new wxStaticText(p1, -1,
wxT("The frame, menu, splitter, this panel and this text were created in C++..."),
wxPoint(10,10));
// And get a panel from Python
wxWindow* p2 = DoPythonStuff(sp);
sp->SplitHorizontally(p1, p2, GetClientSize().y/4);
}
void MyFrame::OnExit(wxCommandEvent& event)
{
Close();
}
//----------------------------------------------------------------------
// This is were the fun begins...
char* python_code1 = "\
from wxPython.wx import wxFrame\n\
f = wxFrame(None, -1, 'Hello from wxPython!', size=(250, 150))\n\
f.Show()\n\
";
void MyFrame::OnPyFrame(wxCommandEvent& event)
{
// For simple Python code that doesn't have to interact with the
// C++ code in any way, you can execute it with PyRun_SimpleString.
// First, whenever you do anyting with Python objects or code, you
// *MUST* aquire the Global Interpreter Lock and block other
// Python threads from running.
wxPyBeginBlockThreads();
// Execute the code in the __main__ module
PyRun_SimpleString(python_code1);
// Finally, release the GIL and let other Python threads run.
wxPyEndBlockThreads();
}
void MyFrame::RedirectStdio()
{
// This is a helpful little tidbit to help debugging and such. It
// redirects Python's stdout and stderr to a window that will popup
// only on demand when something is printed, like a traceback.
char* python_redirect = "\
import sys\n\
from wxPython.wx import wxPyOnDemandOutputWindow\n\
output = wxPyOnDemandOutputWindow()\n\
sys.stdin = sys.stderr = output\n\
";
wxPyBeginBlockThreads();
PyRun_SimpleString(python_redirect);
wxPyEndBlockThreads();
}
char* python_code2 = "\
import embedded_sample\n\
\n\
def makeWindow(parent):\n\
win = embedded_sample.MyPanel(parent)\n\
return win\n\
";
wxWindow* MyFrame::DoPythonStuff(wxWindow* parent)
{
// More complex embedded situations will require passing C++ objects to
// Python and/or returning objects from Python to be used in C++. This
// sample shows one way to do it. NOTE: The above code could just have
// easily come from a file, or the whole thing coupld be in the Python
// module that is imported and manipulated directly in this C++ code. See
// the Python API for more details.
wxWindow* window = NULL;
PyObject* result;
// As always, first grab the GIL
wxPyBeginBlockThreads();
// Now make a dictionary to serve as the global namespace when the code is
// executed. Put a reference to the builtins module in it. (Yes, the
// names are supposed to be different, I don't know why...)
PyObject* globals = PyDict_New();
PyObject* builtins = PyImport_ImportModule("__builtin__");
PyDict_SetItemString(globals, "__builtins__", builtins);
Py_DECREF(builtins);
// Execute the code to make the makeWindow function
result = PyRun_String(python_code2, Py_file_input, globals, globals);
// Was there an exception?
if (! result) {
PyErr_Print();
wxPyEndBlockThreads();
return NULL;
}
Py_DECREF(result);
// Now there should be an object named 'makeWindow' in the dictionary that
// we can grab a pointer to:
PyObject* func = PyDict_GetItemString(globals, "makeWindow");
wxASSERT(PyCallable_Check(func));
// Now build an argument tuple and call the Python function. Notice the
// use of another wxPython API to take a wxWindows object and build a
// wxPython object that wraps it.
PyObject* arg = wxPyMake_wxObject(parent);
wxASSERT(arg != NULL);
PyObject* tuple = PyTuple_New(1);
PyTuple_SET_ITEM(tuple, 0, arg);
result = PyEval_CallObject(func, tuple);
// Was there an exception?
if (! result)
PyErr_Print();
else {
// Otherwise, get the returned window out of Python-land and
// into C++-ville...
bool error = SWIG_GetPtrObj(result, (void**)&window, "_wxWindow_p");
wxASSERT_MSG(!error, wxT("Returned object was not a wxWindow!"));
Py_DECREF(result);
}
// Release the python objects we still have
Py_DECREF(globals);
Py_DECREF(tuple);
// Finally, after all Python stuff is done, release the GIL
wxPyEndBlockThreads();
return window;
}
//----------------------------------------------------------------------
// void MyFrame::OnButton(wxCommandEvent& WXUNUSED(event))
// {
// //Py_Initialize();
// //PySys_SetArgv(argc, argv)
// // // initialize thread support
// // PyEval_InitThreads();
// wxPyBeginBlockThreads();
// PyRun_SimpleString(
// "from wxPython.wx import *\n"
// "f = wxFrame(None, -1, 'Hello from wxPython', size=(250,150))\n"
// "f.Show()"
// );
// wxPyEndBlockThreads();
// }
// ////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////
// /// this, RedirectIOToConsole(), help came from
// /// http://www.halcyon.com/ast/dload/guicon.htm
// // #include <windows.h>
// // #include <stdio.h>
// #include <fcntl.h>
// #include <io.h>
// // #include <iostream>
// // #include <fstream>
// // //#ifndef _USE_OLD_IOSTREAMS
// // using namespace std;
// // //#endif
// // maximum mumber of lines the output console should have
// static const WORD MAX_CONSOLE_LINES = 500;
// void RedirectIOToConsole()
// {
// int hConHandle;
// long lStdHandle;
// CONSOLE_SCREEN_BUFFER_INFO coninfo;
// FILE *fp;
// // allocate a console for this app
// AllocConsole();
// // set the screen buffer to be big enough to let us scroll text
// GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &coninfo);
// coninfo.dwSize.Y = MAX_CONSOLE_LINES;
// SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), coninfo.dwSize);
// // redirect unbuffered STDOUT to the console
// lStdHandle = (long)GetStdHandle(STD_OUTPUT_HANDLE);
// hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
// fp = _fdopen( hConHandle, "w" );
// *stdout = *fp;
// setvbuf( stdout, NULL, _IONBF, 0 );
// // redirect unbuffered STDIN to the console
// lStdHandle = (long)GetStdHandle(STD_INPUT_HANDLE);
// hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
// fp = _fdopen( hConHandle, "r" );
// *stdin = *fp;
// setvbuf( stdin, NULL, _IONBF, 0 );
// // redirect unbuffered STDERR to the console
// lStdHandle = (long)GetStdHandle(STD_ERROR_HANDLE);
// hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
// fp = _fdopen( hConHandle, "w" );
// *stderr = *fp;
// setvbuf( stderr, NULL, _IONBF, 0 );
// // make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog
// // point to console as well
// //std::ios::sync_with_stdio();
// }
// ////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////