// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
-
-#ifdef __WXGTK__
-#include <gtk/gtk.h>
-#endif
+#include <stdio.h> // get the correct definition of NULL
#undef DEBUG
#include <Python.h>
#include "helpers.h"
+
#ifdef __WXMSW__
#include <wx/msw/private.h>
#undef FindWindow
#undef GetClassInfo
#undef GetClassName
#endif
-#include <wx/module.h>
+
+#ifdef __WXGTK__
+#include <gtk/gtk.h>
+#include <gdk/gdkprivate.h>
+#include <wx/gtk/win_gtk.h>
+//#include <gdk/gdk.h>
+//#include <gdk/gdkx.h>
+//#include <gtk/gtkwindow.h>
+
+extern GtkWidget *wxRootWindow;
+
+#endif
//---------------------------------------------------------------------------
// This one isn't acutally called... See __wxStart()
bool wxPyApp::OnInit(void) {
- return false;
+ return FALSE;
}
int wxPyApp::MainLoop(void) {
- int retval = wxApp::MainLoop();
-//# AfterMainLoop();
- wxPythonApp->OnExit(); //#
- return retval;
-}
-
-
-//# void wxPyApp::AfterMainLoop(void) {
-// // more stuff from wxEntry...
-
-// if (wxPythonApp->GetTopWindow()) {
-// // Forcibly delete the window.
-// if (wxPythonApp->GetTopWindow()->IsKindOf(CLASSINFO(wxFrame)) ||
-// wxPythonApp->GetTopWindow()->IsKindOf(CLASSINFO(wxDialog))) {
+ int retval = 0;
-// wxPythonApp->GetTopWindow()->Close(TRUE);
-// wxPythonApp->DeletePendingObjects();
-// }
-// else {
-// delete wxPythonApp->GetTopWindow();
-// wxPythonApp->SetTopWindow(NULL);
-// }
-// }
-// #ifdef __WXGTK__
-// wxPythonApp->DeletePendingObjects();
-// #endif
+ DeletePendingObjects();
+#ifdef __WXGTK__
+ m_initialized = wxTopLevelWindows.GetCount() != 0;
+#endif
-// wxPythonApp->OnExit();
-// wxApp::CleanUp();
-// // delete wxPythonApp;
-// }
+ if (Initialized()) {
+ retval = wxApp::MainLoop();
+ wxPythonApp->OnExit();
+ }
+ return retval;
+}
//---------------------------------------------------------------------
-// a few native methods to add to the module
//----------------------------------------------------------------------
+int WXDLLEXPORT wxEntryStart( int argc, char** argv );
+int WXDLLEXPORT wxEntryInitGui();
+void WXDLLEXPORT wxEntryCleanup();
+
// This is where we pick up the first part of the wxEntry functionality...
// The rest is in __wxStart and AfterMainLoop. This function is called when
if (wxTopLevelWindows.Number() > 0)
return;
-#ifdef __WXMSW__
- wxApp::Initialize();
-#endif
-#ifdef __WXGTK__
PyObject* sysargv = PySys_GetObject("argv");
int argc = PyList_Size(sysargv);
char** argv = new char*[argc+1];
argv[x] = PyString_AsString(PyList_GetItem(sysargv, x));
argv[argc] = NULL;
- gtk_set_locale();
-#if wxUSE_WCHAR_T
- if (!wxOKlibc()) wxConvCurrent = &wxConvLocal;
-#else
- if (!wxOKlibc()) wxConvCurrent = (wxMBConv*) NULL;
-#endif
- gtk_init( &argc, &argv );
- wxSetDetectableAutoRepeat( TRUE );
- delete [] argv;
-
- wxApp::Initialize(); // may return FALSE. Should we check?
-#endif
-
+ wxEntryStart(argc, argv);
}
+
#ifdef WXP_WITH_THREAD
PyThreadState* wxPyEventThreadState = NULL;
#endif
// This is the next part of the wxEntry functionality...
wxPythonApp->argc = 0;
wxPythonApp->argv = NULL;
- wxPythonApp->OnInitGui();
+ wxEntryInitGui();
// Call the Python App's OnInit function
arglist = PyTuple_New(0);
}
bResult = PyInt_AS_LONG(result);
if (! bResult) {
- PyErr_SetString(PyExc_SystemExit, "OnInit returned false, exiting...");
+ PyErr_SetString(PyExc_SystemExit, "OnInit returned FALSE, exiting...");
return NULL;
}
#ifdef __WXGTK__
- wxTheApp->m_initialized = (wxTopLevelWindows.Number() > 0);
+ wxTheApp->m_initialized = (wxTopLevelWindows.GetCount() > 0);
#endif
Py_INCREF(Py_None);
return Py_None;
}
-
+void __wxCleanup() {
+ wxEntryCleanup();
+}
//---------------------------------------------------------------------------
-PyObject* wxPyConstructObject(void* ptr, char* className) {
+PyObject* wxPyConstructObject(void* ptr, const char* className) {
char buff[64]; // should always be big enough...
char swigptr[64];
bool doSave = wxPyRestoreThread();
- arg = wxPyConstructObject((void*)&event, event.GetClassInfo()->GetClassName());
+ wxString className = event.GetClassInfo()->GetClassName();
+
+ if (className == "wxPyEvent")
+ arg = ((wxPyEvent*)&event)->GetSelf();
+ else if (className == "wxPyCommandEvent")
+ arg = ((wxPyCommandEvent*)&event)->GetSelf();
+ else
+ arg = wxPyConstructObject((void*)&event, className);
tuple = PyTuple_New(1);
PyTuple_SET_ITEM(tuple, 0, arg);
wxPyCallbackHelper::wxPyCallbackHelper() {
m_self = NULL;
m_lastFound = NULL;
+ m_incRef = FALSE;
}
wxPyCallbackHelper::~wxPyCallbackHelper() {
bool doSave = wxPyRestoreThread();
- Py_XDECREF(m_self);
+ if (m_incRef)
+ Py_XDECREF(m_self);
wxPySaveThread(doSave);
}
void wxPyCallbackHelper::setSelf(PyObject* self, int incref) {
m_self = self;
+ m_incRef = incref;
if (incref)
Py_INCREF(m_self);
}
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+// These classes can be derived from in Python and passed through the event
+// system without loosing anything. They do this by keeping a reference to
+// themselves and some special case handling in wxPyCallback::EventThunker.
+
+
+wxPyEvtSelfRef::wxPyEvtSelfRef() {
+ //m_self = Py_None; // **** We don't do normal ref counting to prevent
+ //Py_INCREF(m_self); // circular loops...
+ m_cloned = FALSE;
+}
+
+wxPyEvtSelfRef::~wxPyEvtSelfRef() {
+ bool doSave = wxPyRestoreThread();
+ if (m_cloned)
+ Py_DECREF(m_self);
+ wxPySaveThread(doSave);
+}
+
+void wxPyEvtSelfRef::SetSelf(PyObject* self, bool clone) {
+ bool doSave = wxPyRestoreThread();
+ if (m_cloned)
+ Py_DECREF(m_self);
+ m_self = self;
+ if (clone) {
+ Py_INCREF(m_self);
+ m_cloned = TRUE;
+ }
+ wxPySaveThread(doSave);
+}
+
+PyObject* wxPyEvtSelfRef::GetSelf() const {
+ Py_INCREF(m_self);
+ return m_self;
+}
+
+
+wxPyEvent::wxPyEvent(int id)
+ : wxEvent(id) {
+}
+
+wxPyEvent::~wxPyEvent() {
+}
+
+// This one is so the event object can be Cloned...
+void wxPyEvent::CopyObject(wxObject& dest) const {
+ wxEvent::CopyObject(dest);
+ ((wxPyEvent*)&dest)->SetSelf(m_self, TRUE);
+}
+
+
+IMPLEMENT_DYNAMIC_CLASS(wxPyEvent, wxEvent);
+
+
+wxPyCommandEvent::wxPyCommandEvent(wxEventType commandType, int id)
+ : wxCommandEvent(commandType, id) {
+}
+
+wxPyCommandEvent::~wxPyCommandEvent() {
+}
+
+void wxPyCommandEvent::CopyObject(wxObject& dest) const {
+ wxCommandEvent::CopyObject(dest);
+ ((wxPyCommandEvent*)&dest)->SetSelf(m_self, TRUE);
+}
+
+
+IMPLEMENT_DYNAMIC_CLASS(wxPyCommandEvent, wxCommandEvent);
+
+
+
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Convert a wxList to a Python List
-PyObject* wxPy_ConvertList(wxListBase* list, char* className) {
+PyObject* wxPy_ConvertList(wxListBase* list, const char* className) {
PyObject* pyList;
PyObject* pyObj;
wxObject* wxObj;
return pyList;
}
+//----------------------------------------------------------------------
+
+long wxPyGetWinHandle(wxWindow* win) {
+#ifdef __WXMSW__
+ return (long)win->GetHandle();
+#endif
+
+ // Find and return the actual X-Window.
+#ifdef __WXGTK__
+ if (win->m_wxwindow) {
+ GdkWindowPrivate* bwin = (GdkWindowPrivate*)GTK_PIZZA(win->m_wxwindow)->bin_window;
+ if (bwin) {
+ return (long)bwin->xwindow;
+ }
+ }
+#endif
+ return 0;
+}
+
//----------------------------------------------------------------------
// Some helper functions for typemaps in my_typemaps.i, so they won't be
// included in every file...
projects / wxWidgets.git / blobdiff