]> git.saurik.com Git - wxWidgets.git/blobdiff - wxPython/src/helpers.cpp
Added classinfo macros for wxTreeEvent
[wxWidgets.git] / wxPython / src / helpers.cpp
index 9d12d8962ae08ced014f12a88bf438c93295feee..131ed8b56d4799b874362caafe1da28bf4cc225f 100644 (file)
 #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
 
 
@@ -122,13 +116,8 @@ void __wxPreStart()
 #endif
 
 #ifdef WXP_WITH_THREAD
-#if 0   // OLD THREAD STUFF
-    PyEval_InitThreads();
-    wxPyEventThreadState = PyThreadState_Get();
-#else
     PyEval_InitThreads();
-    wxPyEventThreadState = PyThreadState_New(PyThreadState_Get()->interp);
-#endif
+    wxPyEventThreadState = PyThreadState_Get(); // PyThreadState_New(PyThreadState_Get()->interp);
 #endif
 
     // Bail out if there is already windows created.  This means that the
@@ -138,13 +127,17 @@ void __wxPreStart()
         return;
 
 
+    int argc = 0;
+    char** argv = NULL;
     PyObject* sysargv = PySys_GetObject("argv");
-    int argc = PyList_Size(sysargv);
-    char** argv = new char*[argc+1];
-    int x;
-    for(x=0; x<argc; x++)
-        argv[x] = PyString_AsString(PyList_GetItem(sysargv, x));
-    argv[argc] = NULL;
+    if (sysargv != NULL) {
+        argc = PyList_Size(sysargv);
+        argv = new char*[argc+1];
+        int x;
+        for(x=0; x<argc; x++)
+            argv[x] = copystring(PyString_AsString(PyList_GetItem(sysargv, x)));
+        argv[argc] = NULL;
+    }
 
     wxEntryStart(argc, argv);
     delete [] argv;
@@ -171,14 +164,17 @@ PyObject* __wxStart(PyObject* /* self */, PyObject* args)
 #endif
 
     // This is the next part of the wxEntry functionality...
+    int argc = 0;
+    char** argv = NULL;
     PyObject* sysargv = PySys_GetObject("argv");
-    int argc = PyList_Size(sysargv);
-    char** argv = new char*[argc+1];
-    int x;
-    for(x=0; x<argc; x++)
-        argv[x] = copystring(PyString_AsString(PyList_GetItem(sysargv, x)));
-    argv[argc] = NULL;
-
+    if (sysargv != NULL) {
+        argc = PyList_Size(sysargv);
+        argv = new char*[argc+1];
+        int x;
+        for(x=0; x<argc; x++)
+            argv[x] = copystring(PyString_AsString(PyList_GetItem(sysargv, x)));
+        argv[argc] = NULL;
+    }
     wxPythonApp->argc = argc;
     wxPythonApp->argv = argv;
 
@@ -215,7 +211,9 @@ void __wxCleanup() {
 
 
 
-PyObject* wxPython_dict;
+static PyObject* wxPython_dict = NULL;
+static PyObject* wxPyPtrTypeMap = NULL;
+
 PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args)
 {
 
@@ -226,6 +224,12 @@ PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args)
         PyErr_SetString(PyExc_TypeError, "_wxSetDictionary must have dictionary object!");
         return NULL;
     }
+
+    if (! wxPyPtrTypeMap)
+        wxPyPtrTypeMap = PyDict_New();
+    PyDict_SetItemString(wxPython_dict, "__wxPyPtrTypeMap", wxPyPtrTypeMap);
+
+
 #ifdef __WXMOTIF__
 #define wxPlatform "__WXMOTIF__"
 #endif
@@ -249,13 +253,103 @@ PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args)
 }
 
 
+//---------------------------------------------------------------------------
+// Stuff used by OOR to find the right wxPython class type to return and to
+// build it.
+
+
+// The pointer type map is used when the "pointer" type name generated by SWIG
+// is not the same as the shadow class name, for example wxPyTreeCtrl
+// vs. wxTreeCtrl.  It needs to be referenced in Python as well as from C++,
+// so we'll just make it a Python dictionary in the wx module's namespace.
+void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) {
+    if (! wxPyPtrTypeMap)
+        wxPyPtrTypeMap = PyDict_New();
+
+    PyDict_SetItemString(wxPyPtrTypeMap,
+                         (char*)commonName,
+                         PyString_FromString((char*)ptrName));
+}
+
+
+
+PyObject* wxPyClassExists(const char* className) {
+
+    if (!className)
+        return NULL;
+
+    char    buff[64];               // should always be big enough...
+
+    sprintf(buff, "%sPtr", className);
+    PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
+
+    return classobj;  // returns NULL if not found
+}
+
+
+PyObject*  wxPyMake_wxObject(wxObject* source) {
+    PyObject* target;
+
+    if (source) {
+        wxClassInfo* info = source->GetClassInfo();
+        wxChar*      name = (wxChar*)info->GetClassName();
+        PyObject*    klass = wxPyClassExists(name);
+        while (info && !klass) {
+            name = (wxChar*)info->GetBaseClassName1();
+            info = wxClassInfo::FindClass(name);
+            klass = wxPyClassExists(name);
+        }
+        if (info) {
+            target = wxPyConstructObject(source, name, klass, FALSE);
+        } else {
+            wxString msg("wxPython class not found for ");
+            msg += source->GetClassInfo()->GetClassName();
+            PyErr_SetString(PyExc_NameError, msg.c_str());
+            target = NULL;
+        }
+    } else {  // source was NULL so return None.
+        Py_INCREF(Py_None); target = Py_None;
+    }
+    return target;
+}
+
 //---------------------------------------------------------------------------
 
 PyObject* wxPyConstructObject(void* ptr,
                               const char* className,
+                              PyObject* klass,
                               int setThisOwn) {
+
     PyObject* obj;
     PyObject* arg;
+    PyObject* item;
+    char      swigptr[64];      // should always be big enough...
+    char      buff[64];
+
+    if ((item = PyDict_GetItemString(wxPyPtrTypeMap, (char*)className)) != NULL) {
+        className = PyString_AsString(item);
+    }
+    sprintf(buff, "_%s_p", className);
+    SWIG_MakePtr(swigptr, ptr, buff);
+
+    arg = Py_BuildValue("(s)", swigptr);
+    obj = PyInstance_New(klass, arg, NULL);
+    Py_DECREF(arg);
+
+    if (setThisOwn) {
+        PyObject* one = PyInt_FromLong(1);
+        PyObject_SetAttrString(obj, "thisown", one);
+        Py_DECREF(one);
+    }
+
+    return obj;
+}
+
+
+PyObject* wxPyConstructObject(void* ptr,
+                              const char* className,
+                              int setThisOwn) {
+    PyObject* obj;
 
     if (!ptr) {
         Py_INCREF(Py_None);
@@ -263,16 +357,10 @@ PyObject* wxPyConstructObject(void* ptr,
     }
 
     char    buff[64];               // should always be big enough...
-    char    swigptr[64];
-
-    sprintf(buff, "_%s_p", className);
-    SWIG_MakePtr(swigptr, ptr, buff);
 
     sprintf(buff, "%sPtr", className);
     PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
     if (! classobj) {
-        //Py_INCREF(Py_None);
-        //return Py_None;
         char temp[128];
         sprintf(temp,
                 "*** Unknown class name %s, tell Robin about it please ***",
@@ -281,17 +369,7 @@ PyObject* wxPyConstructObject(void* ptr,
         return obj;
     }
 
-    arg = Py_BuildValue("(s)", swigptr);
-    obj = PyInstance_New(classobj, arg, NULL);
-    Py_DECREF(arg);
-
-    if (setThisOwn) {
-        PyObject* one = PyInt_FromLong(1);
-        PyObject_SetAttrString(obj, "thisown", one);
-        Py_DECREF(one);
-    }
-
-    return obj;
+    return wxPyConstructObject(ptr, className, classobj, setThisOwn);
 }
 
 //---------------------------------------------------------------------------
@@ -313,19 +391,11 @@ bool wxPyRestoreThread() {
     // already have the lock.  (I hope!)
     //
 #ifdef WXP_WITH_THREAD
-#if 0   // OLD THREAD STUFF
-    if (wxPyEventThreadState != myPyThreadState_Get()) {
-        PyEval_RestoreThread(wxPyEventThreadState);
-        return TRUE;
-    }
-    else
-#else
     if (wxPyEventThreadState != myPyThreadState_Get()) {
         PyEval_AcquireThread(wxPyEventThreadState);
         return TRUE;
     }
     else
-#endif
 #endif
         return FALSE;
 }
@@ -333,21 +403,14 @@ bool wxPyRestoreThread() {
 
 void wxPySaveThread(bool doSave) {
 #ifdef WXP_WITH_THREAD
-#if 0   // OLD THREAD STUFF
-    if (doSave) {
-        wxPyEventThreadState = PyEval_SaveThread();
-    }
-#else
     if (doSave) {
         PyEval_ReleaseThread(wxPyEventThreadState);
     }
 #endif
-#endif
 }
 
 //---------------------------------------------------------------------------
 
-
 IMPLEMENT_ABSTRACT_CLASS(wxPyCallback, wxObject);
 
 wxPyCallback::wxPyCallback(PyObject* func) {
@@ -393,7 +456,7 @@ void wxPyCallback::EventThunker(wxEvent& event) {
     Py_DECREF(tuple);
     if (result) {
         Py_DECREF(result);
-        PyErr_Clear();
+        PyErr_Clear();       // Just in case...
     } else {
         PyErr_Print();
     }
@@ -634,7 +697,7 @@ PyObject* wxPy_ConvertList(wxListBase* list, const char* className) {
     pyList = PyList_New(0);
     while (node) {
         wxObj = node->Data();
-        pyObj = wxPyConstructObject(wxObj, className);
+        pyObj = wxPyMake_wxObject(wxObj); //wxPyConstructObject(wxObj, className);
         PyList_Append(pyList, pyObj);
         node = node->Next();
     }
@@ -952,10 +1015,7 @@ wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) {
             PyObject* o1 = PyTuple_GetItem(o, 0);
             PyObject* o2 = PyTuple_GetItem(o, 1);
             PyObject* o3 = PyTuple_GetItem(o, 2);
-
-            temp[x].m_flags   = PyInt_AsLong(o1);
-            temp[x].m_keyCode = PyInt_AsLong(o2);
-            temp[x].m_command = PyInt_AsLong(o3);
+            temp[x].Set(PyInt_AsLong(o1), PyInt_AsLong(o2), PyInt_AsLong(o3));
         }
         else {
             PyErr_SetString(PyExc_TypeError, "Expected a list of 3-tuples or wxAcceleratorEntry objects.");