Docstring update

[wxWidgets.git] / wxPython / src / helpers.cpp

diff --git a/wxPython/src/helpers.cpp b/wxPython/src/helpers.cpp
index b5ad3f8f6b8a241c84b5ba0a24e78f4923fd6e20..963d0c58dfe6430e15216161c15fb82b731f47b9 100644 (file)
--- a/wxPython/src/helpers.cpp
+++ b/wxPython/src/helpers.cpp
@@ -15,6 +15,7 @@
 #include <Python.h>
 #include "wx/wxPython/wxPython_int.h"
 #include "wx/wxPython/pyistream.h"
 #include <Python.h>
 #include "wx/wxPython/wxPython_int.h"
 #include "wx/wxPython/pyistream.h"

+#include "wx/wxPython/swigver.h"

 
 #ifdef __WXMSW__
 #include <wx/msw/private.h>
 
 #ifdef __WXMSW__
 #include <wx/msw/private.h>


@@ -29,8 +30,8 @@
 #include <gdk/gdkprivate.h>
 #include <wx/gtk/win_gtk.h>
 #define GetXWindow(wxwin) (wxwin)->m_wxwindow ? \
 #include <gdk/gdkprivate.h>
 #include <wx/gtk/win_gtk.h>
 #define GetXWindow(wxwin) (wxwin)->m_wxwindow ? \

-                              GDK_WINDOW_XWINDOW(GTK_PIZZA((wxwin)->m_wxwindow)->bin_window) : \
-                              GDK_WINDOW_XWINDOW((wxwin)->m_widget->window)
+                          GDK_WINDOW_XWINDOW(GTK_PIZZA((wxwin)->m_wxwindow)->bin_window) : \
+                          GDK_WINDOW_XWINDOW((wxwin)->m_widget->window)

 #include <locale.h>
 #endif
 
 #include <locale.h>
 #endif
 


@@ -97,6 +98,7 @@ PyObject* wxPyPtrTypeMap = NULL;
 // This gets run when the DLL is loaded.  We just need to save a handle.
 //----------------------------------------------------------------------
 
 // This gets run when the DLL is loaded.  We just need to save a handle.
 //----------------------------------------------------------------------
 

+extern "C"

 BOOL WINAPI DllMain(
     HINSTANCE   hinstDLL,    // handle to DLL module
     DWORD       fdwReason,   // reason for calling function
 BOOL WINAPI DllMain(
     HINSTANCE   hinstDLL,    // handle to DLL module
     DWORD       fdwReason,   // reason for calling function


@@ -125,6 +127,8 @@ wxPyApp::wxPyApp() {
 
 
 wxPyApp::~wxPyApp() {
 
 
 wxPyApp::~wxPyApp() {

+    wxPythonApp = NULL;
+    wxApp::SetInstance(NULL);

 }
 
 
 }
 
 


@@ -173,6 +177,18 @@ int wxPyApp::OnExit() {
 }
 
 
 }
 
 

+
+void wxPyApp::ExitMainLoop() {
+    bool found;
+    wxPyBlock_t blocked = wxPyBeginBlockThreads();
+    if ((found = wxPyCBH_findCallback(m_myInst, "ExitMainLoop")))
+        wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
+    wxPyEndBlockThreads(blocked);
+    if (! found)
+        wxApp::ExitMainLoop();
+}  
+
+

 #ifdef __WXDEBUG__
 void wxPyApp::OnAssert(const wxChar *file,
                      int line,
 #ifdef __WXDEBUG__
 void wxPyApp::OnAssert(const wxChar *file,
                      int line,


@@ -407,11 +423,11 @@ void wxPyApp::_BootstrapApp()
         if (sysargv != NULL && executable != NULL) {
             argc = PyList_Size(sysargv) + 1;
             argv = new char*[argc+1];
         if (sysargv != NULL && executable != NULL) {
             argc = PyList_Size(sysargv) + 1;
             argv = new char*[argc+1];

-            argv[0] = PyString_AsString(executable);
+            argv[0] = strdup(PyString_AsString(executable));

             int x;
             for(x=1; x<argc; x++) {
                 PyObject *pyArg = PyList_GetItem(sysargv, x-1);
             int x;
             for(x=1; x<argc; x++) {
                 PyObject *pyArg = PyList_GetItem(sysargv, x-1);

-                argv[x] = PyString_AsString(pyArg);
+                argv[x] = strdup(PyString_AsString(pyArg));

             }
             argv[argc] = NULL;
         }
             }
             argv[argc] = NULL;
         }


@@ -419,7 +435,7 @@ void wxPyApp::_BootstrapApp()
 
         // Initialize wxWidgets
         result = wxEntryStart(argc, argv);
 
         // Initialize wxWidgets
         result = wxEntryStart(argc, argv);

-        delete [] argv;
+        // wxApp takes ownership of the argv array, don't delete it here

 
         blocked = wxPyBeginBlockThreads();
         if (! result)  {
 
         blocked = wxPyBeginBlockThreads();
         if (! result)  {


@@ -439,6 +455,8 @@ void wxPyApp::_BootstrapApp()
         setlocale(LC_NUMERIC, "C");
 #endif
 
         setlocale(LC_NUMERIC, "C");
 #endif
 

+//        wxSystemOptions::SetOption(wxT("mac.textcontrol-use-mlte"), 1);
+        

         // The stock objects were all NULL when they were loaded into
         // SWIG generated proxies, so re-init those now...
         wxPy_ReinitStockObjects(3);
         // The stock objects were all NULL when they were loaded into
         // SWIG generated proxies, so re-init those now...
         wxPy_ReinitStockObjects(3);


@@ -446,6 +464,11 @@ void wxPyApp::_BootstrapApp()
         wxPyEndBlockThreads(blocked);
         haveInitialized = true;
     }
         wxPyEndBlockThreads(blocked);
         haveInitialized = true;
     }

+    else {
+        this->argc = 0;
+        this->argv = NULL;
+    }
+    

 
     // It's now ok to generate exceptions for assertion errors.
     wxPythonApp->SetStartupComplete(true);
 
     // It's now ok to generate exceptions for assertion errors.
     wxPythonApp->SetStartupComplete(true);


@@ -457,6 +480,7 @@ void wxPyApp::_BootstrapApp()
         PyObject* method = m_myInst.GetLastFound();
         PyObject* argTuple = PyTuple_New(0);
         retval = PyEval_CallObject(method, argTuple);
         PyObject* method = m_myInst.GetLastFound();
         PyObject* argTuple = PyTuple_New(0);
         retval = PyEval_CallObject(method, argTuple);

+        m_myInst.clearRecursionGuard(method);

         Py_DECREF(argTuple);
         Py_DECREF(method);
         if (retval == NULL)
         Py_DECREF(argTuple);
         Py_DECREF(method);
         if (retval == NULL)


@@ -680,7 +704,8 @@ PyObject* __wxPySetDictionary(PyObject* /* self */, PyObject* args)
 #else
     _AddInfoString("wx-assertions-off");
 #endif
 #else
     _AddInfoString("wx-assertions-off");
 #endif

-
+    _AddInfoString(wxPy_SWIG_VERSION);    
+    

 #undef _AddInfoString
 
     PyObject* PlatInfoTuple = PyList_AsTuple(PlatInfo);
 #undef _AddInfoString
 
     PyObject* PlatInfoTuple = PyList_AsTuple(PlatInfo);


@@ -691,21 +716,6 @@ PyObject* __wxPySetDictionary(PyObject* /* self */, PyObject* args)
 }
 
 
 }
 
 

-//---------------------------------------------------------------------------
-
-// Python's PyInstance_Check does not return True for instances of new-style
-// classes.  This should get close enough for both new and old classes but I
-// should re-evaluate the need for doing instance checks...
-bool wxPyInstance_Check(PyObject* obj) {
-    return PyObject_HasAttrString(obj, "__class__") != 0;
-}
-
-
-// This one checks if the object is an instance of a SWIG proxy class (it has
-// a .this attribute)
-bool wxPySwigInstance_Check(PyObject* obj) {
-    return PyObject_HasAttrString(obj, "this") != 0;
-}

 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 


@@ -991,6 +1001,7 @@ void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) {
 PyObject*  wxPyMake_wxObject(wxObject* source, bool setThisOwn, bool checkEvtHandler) {
     PyObject* target = NULL;
     bool      isEvtHandler = false;
 PyObject*  wxPyMake_wxObject(wxObject* source, bool setThisOwn, bool checkEvtHandler) {
     PyObject* target = NULL;
     bool      isEvtHandler = false;

+    bool      isSizer = false;

 
     if (source) {
         // If it's derived from wxEvtHandler then there may
 
     if (source) {
         // If it's derived from wxEvtHandler then there may


@@ -1007,6 +1018,18 @@ PyObject*  wxPyMake_wxObject(wxObject* source, bool setThisOwn, bool checkEvtHan
             }
         }
 
             }
         }
 

+        // Also check for wxSizer
+        if (!target && wxIsKindOf(source, wxSizer)) {
+            isSizer = true;
+            wxSizer* sz = (wxSizer*)source;
+            wxPyOORClientData* data = (wxPyOORClientData*)sz->GetClientObject();
+            if (data) {
+                target = data->m_obj;
+                if (target)
+                    Py_INCREF(target);
+            }
+        }
+        

         if (! target) {
             // Otherwise make it the old fashioned way by making a new shadow
             // object and putting this pointer in it.  Look up the class
         if (! target) {
             // Otherwise make it the old fashioned way by making a new shadow
             // object and putting this pointer in it.  Look up the class


@@ -1024,6 +1047,8 @@ PyObject*  wxPyMake_wxObject(wxObject* source, bool setThisOwn, bool checkEvtHan
                 target = wxPyConstructObject((void*)source, name, setThisOwn);
                 if (target && isEvtHandler)
                     ((wxEvtHandler*)source)->SetClientObject(new wxPyOORClientData(target));
                 target = wxPyConstructObject((void*)source, name, setThisOwn);
                 if (target && isEvtHandler)
                     ((wxEvtHandler*)source)->SetClientObject(new wxPyOORClientData(target));

+                if (target && isSizer)
+                    ((wxSizer*)source)->SetClientObject(new wxPyOORClientData(target));

             } else {
                 wxString msg(wxT("wxPython class not found for "));
                 msg += source->GetClassInfo()->GetClassName();
             } else {
                 wxString msg(wxT("wxPython class not found for "));
                 msg += source->GetClassInfo()->GetClassName();


@@ -1039,25 +1064,8 @@ PyObject*  wxPyMake_wxObject(wxObject* source, bool setThisOwn, bool checkEvtHan
 
 
 PyObject*  wxPyMake_wxSizer(wxSizer* source, bool setThisOwn) {
 
 
 PyObject*  wxPyMake_wxSizer(wxSizer* source, bool setThisOwn) {

-    PyObject* target = NULL;

 
 

-    if (source && wxIsKindOf(source, wxSizer)) {
-        // If it's derived from wxSizer then there may already be a pointer to
-        // a Python object that we can use in the OOR data.
-        wxSizer* sz = (wxSizer*)source;
-        wxPyOORClientData* data = (wxPyOORClientData*)sz->GetClientObject();
-        if (data) {
-            target = data->m_obj;
-            if (target)
-                Py_INCREF(target);
-        }
-    }
-    if (! target) {
-        target = wxPyMake_wxObject(source, setThisOwn, false);
-        if (target != Py_None)
-            ((wxSizer*)source)->SetClientObject(new wxPyOORClientData(target));
-    }
-    return target;
+    return wxPyMake_wxObject(source, setThisOwn);

 }
 
 
 }
 
 


@@ -1159,6 +1167,9 @@ void wxPyEndAllowThreads(PyThreadState* saved) {
 
 wxPyBlock_t wxPyBeginBlockThreads() {
 #ifdef WXP_WITH_THREAD
 
 wxPyBlock_t wxPyBeginBlockThreads() {
 #ifdef WXP_WITH_THREAD

+    if (! Py_IsInitialized()) {
+        return (wxPyBlock_t)0;
+    }

 #if wxPyUSE_GIL_STATE
     PyGILState_STATE state = PyGILState_Ensure();
     return state;
 #if wxPyUSE_GIL_STATE
     PyGILState_STATE state = PyGILState_Ensure();
     return state;


@@ -1177,13 +1188,16 @@ wxPyBlock_t wxPyBeginBlockThreads() {
     return blocked;
 #endif
 #else
     return blocked;
 #endif
 #else

-    return false;
+    return (wxPyBlock_t)0;

 #endif
 }
 
 
 void wxPyEndBlockThreads(wxPyBlock_t blocked) {
 #ifdef WXP_WITH_THREAD
 #endif
 }
 
 
 void wxPyEndBlockThreads(wxPyBlock_t blocked) {
 #ifdef WXP_WITH_THREAD

+    if (! Py_IsInitialized()) {
+        return;
+    }            

 #if wxPyUSE_GIL_STATE
     PyGILState_Release(blocked);
 #else
 #if wxPyUSE_GIL_STATE
     PyGILState_Release(blocked);
 #else


@@ -1716,45 +1730,80 @@ PyObject* PyFindClassWithAttr(PyObject *klass, PyObject *name)
 
 
 static
 
 
 static

-PyObject* PyMethod_GetDefiningClass(PyObject* method, const char* name)
+PyObject* PyMethod_GetDefiningClass(PyObject* method, PyObject* nameo)

 {
     PyObject* mgc = PyMethod_GET_CLASS(method);
 
 #if PYTHON_API_VERSION <= 1010    // prior to Python 2.2, the easy way
     return mgc;
 #else                             // 2.2 and after, the hard way...
 {
     PyObject* mgc = PyMethod_GET_CLASS(method);
 
 #if PYTHON_API_VERSION <= 1010    // prior to Python 2.2, the easy way
     return mgc;
 #else                             // 2.2 and after, the hard way...

-
-    PyObject* nameo = PyString_FromString(name);
-    PyObject* klass = PyFindClassWithAttr(mgc, nameo);
-    Py_DECREF(nameo);
-    return klass;
+    return PyFindClassWithAttr(mgc, nameo);

 #endif
 }
 
 
 
 #endif
 }
 
 
 

+// To avoid recursion when an overridden virtual method wants to call the base
+// class version, temporarily set an attribute in the instance with the same
+// name as the method.  Then the PyObject_GetAttr in the next findCallback
+// will return this attribute and the PyMethod_Check will fail.
+
+void wxPyCallbackHelper::setRecursionGuard(PyObject* method) const
+{
+    PyFunctionObject* func = (PyFunctionObject*)PyMethod_Function(method);
+    PyObject_SetAttr(m_self, func->func_name, Py_None);
+}
+
+void wxPyCallbackHelper::clearRecursionGuard(PyObject* method) const
+{
+    PyFunctionObject* func = (PyFunctionObject*)PyMethod_Function(method);
+    if (PyObject_HasAttr(m_self, func->func_name)) {
+        PyObject_DelAttr(m_self, func->func_name);
+    }
+}
+
+// bool wxPyCallbackHelper::hasRecursionGuard(PyObject* method) const
+// {
+//     PyFunctionObject* func = (PyFunctionObject*)PyMethod_Function(method);
+//     if (PyObject_HasAttr(m_self, func->func_name)) {
+//         PyObject* attr = PyObject_GetAttr(m_self, func->func_name);
+//         bool retval = (attr == Py_None);
+//         Py_DECREF(attr);
+//         return retval;
+//     }
+//     return false;
+// }
+
+

 bool wxPyCallbackHelper::findCallback(const char* name) const {
     wxPyCallbackHelper* self = (wxPyCallbackHelper*)this; // cast away const
 bool wxPyCallbackHelper::findCallback(const char* name) const {
     wxPyCallbackHelper* self = (wxPyCallbackHelper*)this; // cast away const

+    PyObject *method, *klass;
+    PyObject* nameo = PyString_FromString(name);

     self->m_lastFound = NULL;
 
     // If the object (m_self) has an attibute of the given name...
     self->m_lastFound = NULL;
 
     // If the object (m_self) has an attibute of the given name...

-    if (m_self && PyObject_HasAttrString(m_self, (char*)name)) {
-        PyObject *method, *klass;
-        method = PyObject_GetAttrString(m_self, (char*)name);
+    if (m_self && PyObject_HasAttr(m_self, nameo)) {
+        method = PyObject_GetAttr(m_self, nameo);

 
         // ...and if that attribute is a method, and if that method's class is
 
         // ...and if that attribute is a method, and if that method's class is

-        // not from a base class...
+        // not from the registered class or a base class...

         if (PyMethod_Check(method) &&
         if (PyMethod_Check(method) &&

-            (klass = PyMethod_GetDefiningClass(method, (char*)name)) != NULL &&
-            ((klass == m_class) || PyObject_IsSubclass(klass, m_class))) {
-
-            // ...then we'll save a pointer to the method so callCallback can call it.
+            (klass = PyMethod_GetDefiningClass(method, nameo)) != NULL &&
+            (klass != m_class) &&
+            PyObject_IsSubclass(klass, m_class)) {
+
+            // ...then we'll save a pointer to the method so callCallback can
+            // call it.  But first, set a recursion guard in case the
+            // overridden method wants to call the base class version.
+            setRecursionGuard(method);

             self->m_lastFound = method;
         }
         else {
             Py_DECREF(method);
         }
     }
             self->m_lastFound = method;
         }
         else {
             Py_DECREF(method);
         }
     }

+    
+    Py_DECREF(nameo);

     return m_lastFound != NULL;
 }
 
     return m_lastFound != NULL;
 }
 


@@ -1783,6 +1832,8 @@ PyObject* wxPyCallbackHelper::callCallbackObj(PyObject* argTuple) const {
     PyObject* method = m_lastFound;
 
     result = PyEval_CallObject(method, argTuple);
     PyObject* method = m_lastFound;
 
     result = PyEval_CallObject(method, argTuple);

+    clearRecursionGuard(method);
+    

     Py_DECREF(argTuple);
     Py_DECREF(method);
     if (!result) {
     Py_DECREF(argTuple);
     Py_DECREF(method);
     if (!result) {


@@ -2711,6 +2762,145 @@ PyObject* wxArrayInt2PyList_helper(const wxArrayInt& arr) {
 }
 
 
 }
 
 

+//----------------------------------------------------------------------
+// wxPyImageHandler methods
+//
+// TODO: Switch these to use wxPython's standard macros and helper classes
+//       for calling callbacks.
+
+PyObject* wxPyImageHandler::m_DoCanRead_Name = NULL;
+PyObject* wxPyImageHandler::m_GetImageCount_Name = NULL;
+PyObject* wxPyImageHandler::m_LoadFile_Name = NULL;
+PyObject* wxPyImageHandler::m_SaveFile_Name = NULL;
+
+PyObject* wxPyImageHandler::py_InputStream(wxInputStream* stream) {
+    return wxPyConstructObject(new wxPyInputStream(stream),
+                               wxT("wxPyInputStream"), 0);
+}
+
+PyObject* wxPyImageHandler::py_Image(wxImage* image) {
+    return wxPyConstructObject(image, wxT("wxImage"), 0);
+}
+
+PyObject* wxPyImageHandler::py_OutputStream(wxOutputStream* stream) {
+    return wxPyConstructObject(stream, wxT("wxOutputStream"), 0);
+}
+
+wxPyImageHandler::wxPyImageHandler():
+    m_self(NULL)
+{
+    if (!m_DoCanRead_Name) {
+        m_DoCanRead_Name = PyString_FromString("DoCanRead");
+        m_GetImageCount_Name = PyString_FromString("GetImageCount");
+        m_LoadFile_Name = PyString_FromString("LoadFile");
+        m_SaveFile_Name = PyString_FromString("SaveFile");
+    }
+}
+
+wxPyImageHandler::~wxPyImageHandler() {
+    if (m_self) {
+        Py_DECREF(m_self);
+        m_self = NULL;
+    }
+}
+
+void wxPyImageHandler::_SetSelf(PyObject *self) {
+    // should check here for isinstance(PyImageHandler) ??
+    m_self = self;
+    Py_INCREF(m_self);
+}
+
+bool wxPyImageHandler::DoCanRead(wxInputStream& stream) {
+    // check if our object has this method
+    wxPyBlock_t blocked = wxPyBeginBlockThreads();
+    if (!m_self || !PyObject_HasAttr(m_self, m_DoCanRead_Name)) {
+        wxPyEndBlockThreads(blocked);
+        return false;
+    }
+
+    PyObject* res = PyObject_CallMethodObjArgs(m_self, m_DoCanRead_Name,
+                                               py_InputStream(&stream), NULL);
+    bool retval = false;
+    if (res) {
+        retval = PyInt_AsLong(res);
+        Py_DECREF(res);
+        PyErr_Clear();
+    }
+    else
+        PyErr_Print();
+    wxPyEndBlockThreads(blocked);
+    return retval;
+}
+
+bool wxPyImageHandler::LoadFile( wxImage* image, wxInputStream& stream,
+                                 bool verbose, int index ) {
+    // check if our object has this method
+    wxPyBlock_t blocked = wxPyBeginBlockThreads();
+    if (!m_self || !PyObject_HasAttr(m_self, m_LoadFile_Name)) {
+        wxPyEndBlockThreads(blocked);
+        return false;
+    }
+    PyObject* res = PyObject_CallMethodObjArgs(m_self, m_LoadFile_Name,
+                                               py_Image(image),
+                                               py_InputStream(&stream),
+                                               PyInt_FromLong(verbose),
+                                               PyInt_FromLong(index),
+                                               NULL);
+    bool retval = false;
+    if (res) {
+        retval = PyInt_AsLong(res);
+        Py_DECREF(res);
+        PyErr_Clear();
+    } else
+        PyErr_Print();
+    wxPyEndBlockThreads(blocked);
+    return retval;
+}
+
+bool wxPyImageHandler::SaveFile( wxImage* image, wxOutputStream& stream,
+                                 bool verbose ) {
+    wxPyBlock_t blocked = wxPyBeginBlockThreads();
+    if (!m_self || !PyObject_HasAttr(m_self, m_SaveFile_Name)) {
+        wxPyEndBlockThreads(blocked);
+        return false;
+    }
+    PyObject* res = PyObject_CallMethodObjArgs(m_self, m_SaveFile_Name,
+                                               py_Image(image),
+                                               py_OutputStream(&stream),
+                                               PyInt_FromLong(verbose),
+                                               NULL);
+    bool retval = false;
+    if(res) {
+        retval=PyInt_AsLong(res);
+        Py_DECREF(res);
+        PyErr_Clear();
+    } else
+        PyErr_Print();
+    wxPyEndBlockThreads(blocked);
+    return retval;
+}
+
+int wxPyImageHandler::GetImageCount( wxInputStream& stream ) {
+    wxPyBlock_t blocked = wxPyBeginBlockThreads();
+    if (!m_self || !PyObject_HasAttr(m_self, m_GetImageCount_Name)) {
+        wxPyEndBlockThreads(blocked);
+        return 1;
+    }
+    PyObject *res=PyObject_CallMethodObjArgs(m_self, m_GetImageCount_Name,
+                                             py_InputStream(&stream),
+                                             NULL);
+    int retval = 1;
+    if(res) {
+        retval=PyInt_AsLong(res);
+        Py_DECREF(res);
+        PyErr_Clear();
+    } else
+        PyErr_Print();
+    wxPyEndBlockThreads(blocked);
+    return retval;
+}
+
+

 //----------------------------------------------------------------------
 //----------------------------------------------------------------------
 
 //----------------------------------------------------------------------
 //----------------------------------------------------------------------