Reorganized listctrl demo a bit so I can test a bug report

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

diff --git a/wxPython/src/helpers.cpp b/wxPython/src/helpers.cpp
index 5d13c8f2469b4a22471e4a5e045d0ffa7e49d014..992ff622a6bd704f12e2fb2494959282f59bd018 100644 (file)
--- a/wxPython/src/helpers.cpp
+++ b/wxPython/src/helpers.cpp
@@ -10,7 +10,6 @@
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 

-#include <stdio.h>  // get the correct definition of NULL

 
 #undef DEBUG
 #include <Python.h>
 
 #undef DEBUG
 #include <Python.h>


@@ -29,7 +28,6 @@
 #include <wx/gtk/win_gtk.h>
 #endif
 
 #include <wx/gtk/win_gtk.h>
 #endif
 

-

 //----------------------------------------------------------------------
 
 #if PYTHON_API_VERSION <= 1007 && wxUSE_UNICODE
 //----------------------------------------------------------------------
 
 #if PYTHON_API_VERSION <= 1007 && wxUSE_UNICODE


@@ -47,6 +45,7 @@ int  WXDLLEXPORT wxEntryInitGui();
 void WXDLLEXPORT wxEntryCleanup();
 
 wxPyApp* wxPythonApp = NULL;  // Global instance of application object
 void WXDLLEXPORT wxEntryCleanup();
 
 wxPyApp* wxPythonApp = NULL;  // Global instance of application object

+bool wxPyDoCleanup = FALSE;

 
 
 #ifdef WXP_WITH_THREAD
 
 
 #ifdef WXP_WITH_THREAD


@@ -79,8 +78,11 @@ BOOL WINAPI DllMain(
     LPVOID      lpvReserved  // reserved
    )
 {
     LPVOID      lpvReserved  // reserved
    )
 {

-    wxSetInstance(hinstDLL);
-    return 1;
+    // If wxPython is embedded in another wxWindows app then
+    // the inatance has already been set.
+    if (! wxGetInstance())
+        wxSetInstance(hinstDLL);
+    return TRUE;

 }
 #endif
 
 }
 #endif
 


@@ -90,11 +92,10 @@ BOOL WINAPI DllMain(
 
 
 wxPyApp::wxPyApp() {
 
 
 wxPyApp::wxPyApp() {

-//    printf("**** ctor\n");
+    SetUseBestVisual(TRUE);

 }
 
 wxPyApp::~wxPyApp() {
 }
 
 wxPyApp::~wxPyApp() {

-//    printf("**** dtor\n");

 }
 
 
 }
 
 


@@ -114,6 +115,10 @@ int  wxPyApp::MainLoop() {
 #endif
 
     if (initialized) {
 #endif
 
     if (initialized) {

+        if ( m_exitOnFrameDelete == Later ) {
+            m_exitOnFrameDelete = Yes;
+        }
+

         retval = wxApp::MainLoop();
         OnExit();
     }
         retval = wxApp::MainLoop();
         OnExit();
     }


@@ -125,40 +130,43 @@ int  wxPyApp::MainLoop() {
 //---------------------------------------------------------------------
 //----------------------------------------------------------------------
 
 //---------------------------------------------------------------------
 //----------------------------------------------------------------------
 

+
+static char* wxPyCopyCString(const wxChar* src)
+{
+    wxWX2MBbuf buff = (wxWX2MBbuf)wxConvCurrent->cWX2MB(src);
+    size_t len = strlen(buff);
+    char*  dest = new char[len+1];
+    strcpy(dest, buff);
+    return dest;
+}
+

 #if wxUSE_UNICODE
 #if wxUSE_UNICODE

-// TODO:  Is this really the right way to do these????
-static char* copyUniString(const wxChar *s)
+static char* wxPyCopyCString(const char* src)   // we need a char version too

 {
 {

-    if (s == NULL) s = wxT("");
-    wxString tmpStr = wxString(s);
-    char *news = new char[tmpStr.Len()+1];
-    for (unsigned int i=0; i<tmpStr.Len(); i++)
-      news[i] = tmpStr[i];
-    news[i] = '\0';
-    return news;
+    size_t len = strlen(src);
+    char*  dest = new char[len+1];
+    strcpy(dest, src);
+    return dest;

 }
 }

+#endif

 
 

-static char* copyCString(const char *s)
+static wxChar* wxPyCopyWString(const char *src)

 {
 {

-    if (s == NULL) s = "";
-    int len = strlen(s);
-    char *news = new char[len+1];
-    memcpy(news, s, len+1);
-    return news;
+    //wxMB2WXbuf buff = wxConvCurrent->cMB2WX(src);
+    wxString str(src, *wxConvCurrent);
+    return copystring(str);

 }
 
 }
 

-static wxChar* wCharFromCStr(const char *s)
+#if wxUSE_UNICODE
+static wxChar* wxPyCopyWString(const wxChar *src)

 {
 {

-  if (s == NULL) s = "";
-  size_t len = strlen(s) + 1;
-  wxChar *news = new wxChar[len];
-  for (size_t i=0; i<len; i++) {
-    news[i] = (wxChar)s[i];
-  }
-  return news;
+    return copystring(src);

 }
 #endif
 
 }
 #endif
 

+
+//----------------------------------------------------------------------
+

 // This is where we pick up the first part of the wxEntry functionality...
 // The rest is in __wxStart and  __wxCleanup.  This function is called when
 // wxcmodule is imported.  (Before there is a wxApp object.)
 // This is where we pick up the first part of the wxEntry functionality...
 // The rest is in __wxStart and  __wxCleanup.  This function is called when
 // wxcmodule is imported.  (Before there is a wxApp object.)


@@ -175,12 +183,15 @@ void __wxPreStart()
     wxPyTMutex = new wxMutex;
 #endif
 
     wxPyTMutex = new wxMutex;
 #endif
 

-    // Bail out if there is already windows created.  This means that the
+    wxApp::CheckBuildOptions(wxBuildOptions());
+
+    // Bail out if there is already a wxApp created.  This means that the

     // toolkit has already been initialized, as in embedding wxPython in
     // toolkit has already been initialized, as in embedding wxPython in

-    // a C++ wxWindows app.
-    if (wxTopLevelWindows.Number() > 0)
+    // a C++ wxWindows app, so we don't need to call wxEntryStart.
+    if (wxTheApp != NULL) {

         return;
         return;

-
+    }
+    wxPyDoCleanup = TRUE;

 
     int argc = 0;
     char** argv = NULL;
 
     int argc = 0;
     char** argv = NULL;


@@ -193,12 +204,10 @@ void __wxPreStart()
            PyObject *item = PyList_GetItem(sysargv, x);
 #if wxUSE_UNICODE
            if (PyUnicode_Check(item))
            PyObject *item = PyList_GetItem(sysargv, x);
 #if wxUSE_UNICODE
            if (PyUnicode_Check(item))

-               argv[x] = copyUniString(PyUnicode_AS_UNICODE(item));
-           else
-               argv[x] = copyCString(PyString_AsString(item));
-#else
-           argv[x] = copystring(PyString_AsString(item));
+               argv[x] = wxPyCopyCString(PyUnicode_AS_UNICODE(item));
+            else

 #endif
 #endif

+                argv[x] = wxPyCopyCString(PyString_AsString(item));

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


@@ -220,13 +229,6 @@ PyObject* __wxStart(PyObject* /* self */, PyObject* args)
     if (!PyArg_ParseTuple(args, "O", &onInitFunc))
         return NULL;
 
     if (!PyArg_ParseTuple(args, "O", &onInitFunc))
         return NULL;
 

-#if 0  // Try it out without this check, see how it does...
-    if (wxTopLevelWindows.Number() > 0) {
-        PyErr_SetString(PyExc_TypeError, "Only 1 wxApp per process!");
-        return NULL;
-    }
-#endif
-

     // This is the next part of the wxEntry functionality...
     int argc = 0;
     wxChar** argv = NULL;
     // This is the next part of the wxEntry functionality...
     int argc = 0;
     wxChar** argv = NULL;


@@ -238,15 +240,11 @@ PyObject* __wxStart(PyObject* /* self */, PyObject* args)
         for(x=0; x<argc; x++) {
             PyObject *pyArg = PyList_GetItem(sysargv, x);
 #if wxUSE_UNICODE
         for(x=0; x<argc; x++) {
             PyObject *pyArg = PyList_GetItem(sysargv, x);
 #if wxUSE_UNICODE

-            if (PyUnicode_Check(pyArg)) {
-                argv[x] = copystring(PyUnicode_AS_UNICODE(pyArg));
-            } else {
-                assert(PyString_Check(pyArg));
-                argv[x] = wCharFromCStr(PyString_AsString(pyArg));
-            }
-#else
-            argv[x] = copystring(PyString_AsString(pyArg));
+            if (PyUnicode_Check(pyArg))
+                argv[x] = wxPyCopyWString(PyUnicode_AS_UNICODE(pyArg));
+            else

 #endif
 #endif

+                argv[x] = wxPyCopyWString(PyString_AsString(pyArg));

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


@@ -283,7 +281,8 @@ PyObject* __wxStart(PyObject* /* self */, PyObject* args)
 
 
 void __wxCleanup() {
 
 
 void __wxCleanup() {

-    wxEntryCleanup();
+    if (wxPyDoCleanup)
+        wxEntryCleanup();

 #ifdef WXP_WITH_THREAD
     delete wxPyTMutex;
     wxPyTMutex = NULL;
 #ifdef WXP_WITH_THREAD
     delete wxPyTMutex;
     wxPyTMutex = NULL;


@@ -298,6 +297,7 @@ void __wxCleanup() {
 static PyObject* wxPython_dict = NULL;
 static PyObject* wxPyPtrTypeMap = NULL;
 
 static PyObject* wxPython_dict = NULL;
 static PyObject* wxPyPtrTypeMap = NULL;
 

+

 PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args)
 {
 
 PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args)
 {
 


@@ -330,14 +330,66 @@ PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args)
 #define wxPlatform "__WXMAC__"
 #endif
 
 #define wxPlatform "__WXMAC__"
 #endif
 

+#ifdef __WXDEBUG__
+    int wxdebug = 1;
+#else
+    int wxdebug = 0;
+#endif
+

     PyDict_SetItemString(wxPython_dict, "wxPlatform", PyString_FromString(wxPlatform));
     PyDict_SetItemString(wxPython_dict, "wxUSE_UNICODE", PyInt_FromLong(wxUSE_UNICODE));
     PyDict_SetItemString(wxPython_dict, "wxPlatform", PyString_FromString(wxPlatform));
     PyDict_SetItemString(wxPython_dict, "wxUSE_UNICODE", PyInt_FromLong(wxUSE_UNICODE));

-
+    PyDict_SetItemString(wxPython_dict, "__WXDEBUG__", PyInt_FromLong(wxdebug));

 
     Py_INCREF(Py_None);
     return Py_None;
 }
 
 
     Py_INCREF(Py_None);
     return Py_None;
 }
 

+//---------------------------------------------------------------------------
+
+void wxPyClientData_dtor(wxPyClientData* self) {
+    wxPyBeginBlockThreads();
+    Py_DECREF(self->m_obj);
+    wxPyEndBlockThreads();
+}
+
+void wxPyUserData_dtor(wxPyUserData* self) {
+    wxPyBeginBlockThreads();
+    Py_DECREF(self->m_obj);
+    wxPyEndBlockThreads();
+}
+
+
+// This is called when an OOR controled object is being destroyed.  Although
+// the C++ object is going away there is no way to force the Python object
+// (and all references to it) to die too.  This causes problems (crashes) in
+// wxPython when a python shadow object attempts to call a C++ method using
+// the now bogus pointer... So to try and prevent this we'll do a little black
+// magic and change the class of the python instance to a class that will
+// raise an exception for any attempt to call methods with it.  See
+// _wxPyDeadObject in _extras.py for the implementation of this class.
+void wxPyOORClientData_dtor(wxPyOORClientData* self) {
+
+    static PyObject* deadObjectClass = NULL;
+
+    wxPyBeginBlockThreads();
+    if (deadObjectClass == NULL) {
+        deadObjectClass = PyDict_GetItemString(wxPython_dict, "_wxPyDeadObject");
+        wxASSERT_MSG(deadObjectClass != NULL, wxT("Can't get _wxPyDeadObject class!"));
+        Py_INCREF(deadObjectClass);
+    }
+
+    // Clear the instance's dictionary, put the name of the old class into the
+    // instance, and then reset the class to be the dead class.
+    if (self->m_obj->ob_refcnt > 1) {  // but only if there is more than one reference
+        wxASSERT_MSG(PyInstance_Check(self->m_obj), wxT("m_obj not an instance!?!?!"));
+        PyInstanceObject* inst = (PyInstanceObject*)self->m_obj;
+        PyDict_Clear(inst->in_dict);
+        PyDict_SetItemString(inst->in_dict, "_name", inst->in_class->cl_name);
+        inst->in_class = (PyClassObject*)deadObjectClass;
+        Py_INCREF(deadObjectClass);
+    }
+    wxPyEndBlockThreads();
+}

 
 //---------------------------------------------------------------------------
 // Stuff used by OOR to find the right wxPython class type to return and to
 
 //---------------------------------------------------------------------------
 // Stuff used by OOR to find the right wxPython class type to return and to


@@ -348,6 +400,7 @@ PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args)
 // 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.
 // 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.

+// (See __wxSetDictionary)

 void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) {
     if (! wxPyPtrTypeMap)
         wxPyPtrTypeMap = PyDict_New();
 void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) {
     if (! wxPyPtrTypeMap)
         wxPyPtrTypeMap = PyDict_New();


@@ -358,42 +411,20 @@ void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) {
 
 
 
 
 
 

-PyObject* wxPyClassExists(const char* className) {
+PyObject* wxPyClassExists(const wxString& className) {

 
     if (!className)
         return NULL;
 
     char    buff[64];               // should always be big enough...
 
 
     if (!className)
         return NULL;
 
     char    buff[64];               // should always be big enough...
 

-    sprintf(buff, "%sPtr", className);
+    sprintf(buff, "%sPtr", className.mbc_str());

     PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
 
     return classobj;  // returns NULL if not found
 }
 
 
     PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
 
     return classobj;  // returns NULL if not found
 }
 
 

-#if wxUSE_UNICODE
-void unicodeToChar(const wxString *src, char *dest)
-{
-    for (unsigned int i=0; i<src->Len(); i++) {
-      dest[i] = (char)(*src)[i];
-    }
-    dest[i] = '\0';
-}
-PyObject* wxPyClassExistsUnicode(const wxString *className) {
-    if (!className->Len())
-        return NULL;
-    char    buff[64];               // should always be big enough...
-    char *nameBuf = new char[className->Len()+1];
-    unicodeToChar(className, nameBuf);
-    sprintf(buff, "%sPtr", nameBuf);
-    PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
-    delete [] nameBuf;
-    return classobj;  // returns NULL if not found
-}
-#endif
-
-

 PyObject*  wxPyMake_wxObject(wxObject* source, bool checkEvtHandler) {
     PyObject* target = NULL;
     bool      isEvtHandler = FALSE;
 PyObject*  wxPyMake_wxObject(wxObject* source, bool checkEvtHandler) {
     PyObject* target = NULL;
     bool      isEvtHandler = FALSE;


@@ -405,14 +436,13 @@ PyObject*  wxPyMake_wxObject(wxObject* source, bool checkEvtHandler) {
         if (checkEvtHandler && wxIsKindOf(source, wxEvtHandler)) {
             isEvtHandler = TRUE;
             wxEvtHandler* eh = (wxEvtHandler*)source;
         if (checkEvtHandler && wxIsKindOf(source, wxEvtHandler)) {
             isEvtHandler = TRUE;
             wxEvtHandler* eh = (wxEvtHandler*)source;

-            wxPyClientData* data = (wxPyClientData*)eh->GetClientObject();
+            wxPyOORClientData* data = (wxPyOORClientData*)eh->GetClientObject();

             if (data) {
                 target = data->m_obj;
                 Py_INCREF(target);
             }
         }
 
             if (data) {
                 target = data->m_obj;
                 Py_INCREF(target);
             }
         }
 

-        // TODO: unicode fix

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


@@ -427,11 +457,11 @@ PyObject*  wxPyMake_wxObject(wxObject* source, bool checkEvtHandler) {
             if (info) {
                 target = wxPyConstructObject(source, name, klass, FALSE);
                 if (target && isEvtHandler)
             if (info) {
                 target = wxPyConstructObject(source, name, klass, FALSE);
                 if (target && isEvtHandler)

-                    ((wxEvtHandler*)source)->SetClientObject(new wxPyClientData(target));
+                    ((wxEvtHandler*)source)->SetClientObject(new wxPyOORClientData(target));

             } else {
             } else {

-                wxString msg("wxPython class not found for ");
+                wxString msg(wxT("wxPython class not found for "));

                 msg += source->GetClassInfo()->GetClassName();
                 msg += source->GetClassInfo()->GetClassName();

-                PyErr_SetString(PyExc_NameError, msg.c_str());
+                PyErr_SetString(PyExc_NameError, msg.mbc_str());

                 target = NULL;
             }
         }
                 target = NULL;
             }
         }


@@ -450,7 +480,7 @@ PyObject*  wxPyMake_wxSizer(wxSizer* source) {
         // already be a pointer to a Python object that we can use
         // in the OOR data.
         wxSizer* sz = (wxSizer*)source;
         // already be a pointer to a Python object that we can use
         // in the OOR data.
         wxSizer* sz = (wxSizer*)source;

-        wxPyClientData* data = (wxPyClientData*)sz->GetClientObject();
+        wxPyOORClientData* data = (wxPyOORClientData*)sz->GetClientObject();

         if (data) {
             target = data->m_obj;
             Py_INCREF(target);
         if (data) {
             target = data->m_obj;
             Py_INCREF(target);


@@ -459,7 +489,7 @@ PyObject*  wxPyMake_wxSizer(wxSizer* source) {
     if (! target) {
         target = wxPyMake_wxObject(source, FALSE);
         if (target != Py_None)
     if (! target) {
         target = wxPyMake_wxObject(source, FALSE);
         if (target != Py_None)

-            ((wxSizer*)source)->SetClientObject(new wxPyClientData(target));
+            ((wxSizer*)source)->SetClientObject(new wxPyOORClientData(target));

     }
     return target;
 }
     }
     return target;
 }


@@ -469,20 +499,21 @@ PyObject*  wxPyMake_wxSizer(wxSizer* source) {
 //---------------------------------------------------------------------------
 
 PyObject* wxPyConstructObject(void* ptr,
 //---------------------------------------------------------------------------
 
 PyObject* wxPyConstructObject(void* ptr,

-                              const char* className,
+                              const wxString& className,

                               PyObject* klass,
                               int setThisOwn) {
 
     PyObject* obj;
     PyObject* arg;
     PyObject* item;
                               PyObject* klass,
                               int setThisOwn) {
 
     PyObject* obj;
     PyObject* arg;
     PyObject* item;

+    wxString  name(className);

     char      swigptr[64];      // should always be big enough...
     char      buff[64];
 
     char      swigptr[64];      // should always be big enough...
     char      buff[64];
 

-    if ((item = PyDict_GetItemString(wxPyPtrTypeMap, (char*)className)) != NULL) {
-        className = PyString_AsString(item);
+    if ((item = PyDict_GetItemString(wxPyPtrTypeMap, (char*)(const char*)name.mbc_str())) != NULL) {
+        name = wxString(PyString_AsString(item), *wxConvCurrent);

     }
     }

-    sprintf(buff, "_%s_p", className);
+    sprintf(buff, "_%s_p", (const char*)name.mbc_str());

     SWIG_MakePtr(swigptr, ptr, buff);
 
     arg = Py_BuildValue("(s)", swigptr);
     SWIG_MakePtr(swigptr, ptr, buff);
 
     arg = Py_BuildValue("(s)", swigptr);


@@ -500,33 +531,30 @@ PyObject* wxPyConstructObject(void* ptr,
 
 
 PyObject* wxPyConstructObject(void* ptr,
 
 
 PyObject* wxPyConstructObject(void* ptr,

-                              const char* className,
+                              const wxString& className,

                               int setThisOwn) {
                               int setThisOwn) {

-    PyObject* obj;
-

     if (!ptr) {
         Py_INCREF(Py_None);
         return Py_None;
     }
 
     char    buff[64];               // should always be big enough...
     if (!ptr) {
         Py_INCREF(Py_None);
         return Py_None;
     }
 
     char    buff[64];               // should always be big enough...

-    sprintf(buff, "%sPtr", className);
+    sprintf(buff, "%sPtr", (const char*)className.mbc_str());

 
 

-    wxASSERT_MSG(wxPython_dict, "wxPython_dict is not set yet!!");
+    wxASSERT_MSG(wxPython_dict, wxT("wxPython_dict is not set yet!!"));

 
     PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
     if (! classobj) {
 
     PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
     if (! classobj) {

-        char temp[128];
-        sprintf(temp,
-                "*** Unknown class name %s, tell Robin about it please ***",
-                buff);
-        obj = PyString_FromString(temp);
-        return obj;
+        wxString msg(wxT("wxPython class not found for "));
+        msg += className;
+        PyErr_SetString(PyExc_NameError, msg.mbc_str());
+        return NULL;

     }
 
     return wxPyConstructObject(ptr, className, classobj, setThisOwn);
 }
 
     }
 
     return wxPyConstructObject(ptr, className, classobj, setThisOwn);
 }
 

+

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


@@ -554,7 +582,7 @@ PyThreadState* wxPyGetThreadState() {
         }
     }
     wxPyTMutex->Unlock();
         }
     }
     wxPyTMutex->Unlock();

-    wxASSERT_MSG(tstate, "PyThreadState should not be NULL!");
+    wxASSERT_MSG(tstate, wxT("PyThreadState should not be NULL!"));

     return tstate;
 }
 
     return tstate;
 }
 


@@ -569,7 +597,15 @@ void wxPySaveThreadState(PyThreadState* tstate) {
     for(size_t i=0; i < wxPyTStates->GetCount(); i++) {
         wxPyThreadState& info = wxPyTStates->Item(i);
         if (info.tid == ctid) {
     for(size_t i=0; i < wxPyTStates->GetCount(); i++) {
         wxPyThreadState& info = wxPyTStates->Item(i);
         if (info.tid == ctid) {

-            info.tstate = tstate;
+#if 0
+            if (info.tstate != tstate)
+                wxLogMessage("*** tstate mismatch!???");
+#endif
+            // info.tstate = tstate;    *** DO NOT update existing ones???
+            // Normally it will never change, but apparently COM callbacks
+            // (i.e. ActiveX controls) will (incorrectly IMHO) use a transient
+            // tstate which will then be garbage the next time we try to use
+            // it...

             wxPyTMutex->Unlock();
             return;
         }
             wxPyTMutex->Unlock();
             return;
         }


@@ -616,8 +652,9 @@ void wxPyBeginBlockThreads() {
 
 void wxPyEndBlockThreads() {
 #ifdef WXP_WITH_THREAD
 
 void wxPyEndBlockThreads() {
 #ifdef WXP_WITH_THREAD

-    PyThreadState* tstate = PyEval_SaveThread();

     // Is there any need to save it again?
     // Is there any need to save it again?

+    // PyThreadState* tstate =
+    PyEval_SaveThread();

 #endif
 }
 
 #endif
 }
 


@@ -625,16 +662,13 @@ void wxPyEndBlockThreads() {
 //---------------------------------------------------------------------------
 // wxPyInputStream and wxPyCBInputStream methods
 
 //---------------------------------------------------------------------------
 // wxPyInputStream and wxPyCBInputStream methods
 

-#include <wx/listimpl.cpp>
-WX_DEFINE_LIST(wxStringPtrList);
-

 
 void wxPyInputStream::close() {
 
 void wxPyInputStream::close() {

-    /* do nothing */
+    /* do nothing for now */

 }
 
 void wxPyInputStream::flush() {
 }
 
 void wxPyInputStream::flush() {

-    /* do nothing */
+    /* do nothing for now */

 }
 
 bool wxPyInputStream::eof() {
 }
 
 bool wxPyInputStream::eof() {


@@ -648,8 +682,12 @@ wxPyInputStream::~wxPyInputStream() {
     /* do nothing */
 }
 
     /* do nothing */
 }
 

-wxString* wxPyInputStream::read(int size) {
-    wxString* s = NULL;
+
+
+
+PyObject* wxPyInputStream::read(int size) {
+    PyObject* obj = NULL;
+    wxMemoryBuffer buf;

     const int BUFSIZE = 1024;
 
     // check if we have a real wxInputStream to work with
     const int BUFSIZE = 1024;
 
     // check if we have a real wxInputStream to work with


@@ -659,88 +697,62 @@ wxString* wxPyInputStream::read(int size) {
     }
 
     if (size < 0) {
     }
 
     if (size < 0) {

-        // init buffers
-        char * buf = new char[BUFSIZE];
-        if (!buf) {
-            PyErr_NoMemory();
-            return NULL;
-        }
-
-        s = new wxString();
-        if (!s) {
-            delete buf;
-            PyErr_NoMemory();
-            return NULL;
-        }
-

         // read until EOF
         while (! m_wxis->Eof()) {
         // read until EOF
         while (! m_wxis->Eof()) {

-            m_wxis->Read(buf, BUFSIZE);
-            s->Append(buf, m_wxis->LastRead());
-        }
-        delete buf;
-
-        // error check
-        if (m_wxis->LastError() == wxSTREAM_READ_ERROR) {
-            delete s;
-            PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
-            return NULL;
+            m_wxis->Read(buf.GetAppendBuf(BUFSIZE), BUFSIZE);
+            buf.UngetAppendBuf(m_wxis->LastRead());

         }
 
     } else {  // Read only size number of characters
         }
 
     } else {  // Read only size number of characters

-        s = new wxString;
-        if (!s) {
-            PyErr_NoMemory();
-            return NULL;
-        }
-
-        // read size bytes
-        m_wxis->Read(s->GetWriteBuf(size+1), size);
-        s->UngetWriteBuf(m_wxis->LastRead());
+        m_wxis->Read(buf.GetWriteBuf(size), size);
+        buf.UngetWriteBuf(m_wxis->LastRead());
+    }

 
 

-        // error check
-        if (m_wxis->LastError() == wxSTREAM_READ_ERROR) {
-            delete s;
-            PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
-            return NULL;
-        }
+    // error check
+    if (m_wxis->LastError() == wxSTREAM_READ_ERROR) {
+        PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
+    }
+    else {
+        // We use only strings for the streams, not unicode
+        obj = PyString_FromStringAndSize(buf, buf.GetDataLen());

     }
     }

-    return s;
+    return obj;

 }
 
 
 }
 
 

-wxString* wxPyInputStream::readline (int size) {
+PyObject* wxPyInputStream::readline(int size) {
+    PyObject* obj = NULL;
+    wxMemoryBuffer buf;
+    int i;
+    char ch;
+

     // check if we have a real wxInputStream to work with
     if (!m_wxis) {
         PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream");
         return NULL;
     }
 
     // check if we have a real wxInputStream to work with
     if (!m_wxis) {
         PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream");
         return NULL;
     }
 

-    // init buffer
-    int i;
-    char ch;
-    wxString* s = new wxString;
-    if (!s) {
-        PyErr_NoMemory();
-        return NULL;
-    }
-

     // read until \n or byte limit reached
     for (i=ch=0; (ch != '\n') && (!m_wxis->Eof()) && ((size < 0) || (i < size)); i++) {
     // read until \n or byte limit reached
     for (i=ch=0; (ch != '\n') && (!m_wxis->Eof()) && ((size < 0) || (i < size)); i++) {

-        *s += ch = m_wxis->GetC();
+        ch = m_wxis->GetC();
+        buf.AppendByte(ch);

     }
 
     // errorcheck
     if (m_wxis->LastError() == wxSTREAM_READ_ERROR) {
     }
 
     // errorcheck
     if (m_wxis->LastError() == wxSTREAM_READ_ERROR) {

-        delete s;

         PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
         PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");

-        return NULL;

     }
     }

-    return s;
+    else {
+        // We use only strings for the streams, not unicode
+        obj = PyString_FromStringAndSize((char*)buf.GetData(), buf.GetDataLen());
+    }
+    return obj;

 }
 
 
 }
 
 

-wxStringPtrList* wxPyInputStream::readlines (int sizehint) {
+PyObject* wxPyInputStream::readlines(int sizehint) {
+    PyObject* pylist;
+

     // check if we have a real wxInputStream to work with
     if (!m_wxis) {
         PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream below");
     // check if we have a real wxInputStream to work with
     if (!m_wxis) {
         PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream below");


@@ -748,8 +760,8 @@ wxStringPtrList* wxPyInputStream::readlines (int sizehint) {
     }
 
     // init list
     }
 
     // init list

-    wxStringPtrList* l = new wxStringPtrList();
-    if (!l) {
+    pylist = PyList_New(0);
+    if (!pylist) {

         PyErr_NoMemory();
         return NULL;
     }
         PyErr_NoMemory();
         return NULL;
     }


@@ -757,24 +769,23 @@ wxStringPtrList* wxPyInputStream::readlines (int sizehint) {
     // read sizehint bytes or until EOF
     int i;
     for (i=0; (!m_wxis->Eof()) && ((sizehint < 0) || (i < sizehint));) {
     // read sizehint bytes or until EOF
     int i;
     for (i=0; (!m_wxis->Eof()) && ((sizehint < 0) || (i < sizehint));) {

-        wxString* s = readline();
+        PyObject* s = this->readline();

         if (s == NULL) {
         if (s == NULL) {

-            l->DeleteContents(TRUE);
-            l->Clear();
+            Py_DECREF(pylist);

             return NULL;
         }
             return NULL;
         }

-        l->Append(s);
-        i = i + s->Length();
+        PyList_Append(pylist, s);
+        i += PyString_Size(s);

     }
 
     // error check
     if (m_wxis->LastError() == wxSTREAM_READ_ERROR) {
     }
 
     // error check
     if (m_wxis->LastError() == wxSTREAM_READ_ERROR) {

-        l->DeleteContents(TRUE);
-        l->Clear();
+        Py_DECREF(pylist);

         PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
         return NULL;
     }
         PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
         return NULL;
     }

-    return l;
+
+    return pylist;

 }
 
 
 }
 
 


@@ -826,6 +837,11 @@ wxPyCBInputStream* wxPyCBInputStream::create(PyObject *py, bool block) {
     return new wxPyCBInputStream(read, seek, tell, block);
 }
 
     return new wxPyCBInputStream(read, seek, tell, block);
 }
 

+
+wxPyCBInputStream* wxPyCBInputStream_create(PyObject *py, bool block) {
+    return wxPyCBInputStream::create(py, block);
+}
+

 PyObject* wxPyCBInputStream::getMethod(PyObject* py, char* name) {
     if (!PyObject_HasAttrString(py, name))
         return NULL;
 PyObject* wxPyCBInputStream::getMethod(PyObject* py, char* name) {
     if (!PyObject_HasAttrString(py, name))
         return NULL;


@@ -861,13 +877,13 @@ size_t wxPyCBInputStream::OnSysRead(void *buffer, size_t bufsize) {
     Py_DECREF(arglist);
 
     size_t o = 0;
     Py_DECREF(arglist);
 
     size_t o = 0;

-    if ((result != NULL) && PyString_Check(result)) {  // TODO: unicode?
+    if ((result != NULL) && PyString_Check(result)) {

         o = PyString_Size(result);
         if (o == 0)
             m_lasterror = wxSTREAM_EOF;
         if (o > bufsize)
             o = bufsize;
         o = PyString_Size(result);
         if (o == 0)
             m_lasterror = wxSTREAM_EOF;
         if (o > bufsize)
             o = bufsize;

-        memcpy((char*)buffer, PyString_AsString(result), o);
+        memcpy((char*)buffer, PyString_AsString(result), o);  // strings only, not unicode...

         Py_DECREF(result);
 
     }
         Py_DECREF(result);
 
     }


@@ -946,16 +962,7 @@ void wxPyCallback::EventThunker(wxEvent& event) {
     else if (className == "wxPyCommandEvent")
         arg = ((wxPyCommandEvent*)&event)->GetSelf();
     else {
     else if (className == "wxPyCommandEvent")
         arg = ((wxPyCommandEvent*)&event)->GetSelf();
     else {

-
-// TODO:  get rid of this ifdef by changing wxPyConstructObject to take a wxString
-#if wxUSE_UNICODE
-        char *classNameAsChrStr = new char[className.Len()+1];
-       unicodeToChar(&className, classNameAsChrStr);
-       arg = wxPyConstructObject((void*)&event, classNameAsChrStr);
-       delete [] classNameAsChrStr;
-#else
-       arg = wxPyConstructObject((void*)&event, className);
-#endif
+        arg = wxPyConstructObject((void*)&event, className);

     }
 
     tuple = PyTuple_New(1);
     }
 
     tuple = PyTuple_New(1);


@@ -1340,10 +1347,10 @@ wxString* wxString_in_helper(PyObject* source) {
     if (PyUnicode_Check(source)) {
         target = new wxString(PyUnicode_AS_UNICODE(source));
     } else {
     if (PyUnicode_Check(source)) {
         target = new wxString(PyUnicode_AS_UNICODE(source));
     } else {

-        // It is a string, transform to unicode
-        PyObject *tempUniStr = PyObject_Unicode(source);
-        target = new wxString(PyUnicode_AS_UNICODE(tempUniStr));
-        Py_DECREF(tempUniStr);
+        // It is a string, get pointers to it and transform to unicode
+        char* tmpPtr; int tmpSize;
+        PyString_AsStringAndSize(source, &tmpPtr, &tmpSize);
+        target = new wxString(tmpPtr, *wxConvCurrent, tmpSize);

     }
 #else
     char* tmpPtr; int tmpSize;
     }
 #else
     char* tmpPtr; int tmpSize;


@@ -1365,6 +1372,64 @@ wxString* wxString_in_helper(PyObject* source) {
 }
 
 
 }
 
 

+// Similar to above except doesn't use "new" and doesn't set an exception
+wxString Py2wxString(PyObject* source)
+{
+    wxString target;
+    bool     doDecRef = FALSE;
+
+#if PYTHON_API_VERSION >= 1009  // Have Python unicode API
+    if (!PyString_Check(source) && !PyUnicode_Check(source)) {
+        // Convert to String if not one already...  (TODO: Unicode too?)
+        source = PyObject_Str(source);
+        doDecRef = TRUE;
+    }
+
+#if wxUSE_UNICODE
+    if (PyUnicode_Check(source)) {
+        target = PyUnicode_AS_UNICODE(source);
+    } else {
+        // It is a string, get pointers to it and transform to unicode
+        char* tmpPtr; int tmpSize;
+        PyString_AsStringAndSize(source, &tmpPtr, &tmpSize);
+        target = wxString(tmpPtr, *wxConvCurrent, tmpSize);
+    }
+#else
+    char* tmpPtr; int tmpSize;
+    PyString_AsStringAndSize(source, &tmpPtr, &tmpSize);
+    target = wxString(tmpPtr, tmpSize);
+#endif // wxUSE_UNICODE
+
+#else  // No Python unicode API (1.5.2)
+    if (!PyString_Check(source)) {
+        // Convert to String if not one already...
+        source = PyObject_Str(source);
+        doDecRef = TRUE;
+    }
+    target = wxString(PyString_AS_STRING(source), PyString_GET_SIZE(source));
+#endif
+
+    if (doDecRef)
+        Py_DECREF(source);
+    return target;
+}
+
+
+// Make either a Python String or Unicode object, depending on build mode
+PyObject* wx2PyString(const wxString& src)
+{
+    PyObject* str;
+#if wxUSE_UNICODE
+    str = PyUnicode_FromUnicode(src.c_str(), src.Len());
+#else
+    str = PyString_FromStringAndSize(src.c_str(), src.Len());
+#endif
+    return str;
+}
+
+
+//----------------------------------------------------------------------
+

 
 byte* byte_LIST_helper(PyObject* source) {
     if (!PyList_Check(source)) {
 
 byte* byte_LIST_helper(PyObject* source) {
     if (!PyList_Check(source)) {


@@ -1618,25 +1683,16 @@ wxString* wxString_LIST_helper(PyObject* source) {
             PyErr_SetString(PyExc_TypeError, "Expected a list of string or unicode objects.");
             return NULL;
         }
             PyErr_SetString(PyExc_TypeError, "Expected a list of string or unicode objects.");
             return NULL;
         }

-
-        char* buff;
-        int   length;
-        if (PyString_AsStringAndSize(o, &buff, &length) == -1)
-            return NULL;
-#if wxUSE_UNICODE  // TODO:  unicode fix.  this is wrong!
-       wxChar *uniBuff = wCharFromCStr(buff);
-        temp[x] = wxString(uniBuff, length);
-       delete [] uniBuff;
-#else
-        temp[x] = wxString(buff, length);
-#endif //wxUSE_UNICODE

 #else
         if (! PyString_Check(o)) {
             PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
             return NULL;
         }
 #else
         if (! PyString_Check(o)) {
             PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
             return NULL;
         }

-        temp[x] = PyString_AsString(o);

 #endif
 #endif

+
+        wxString* pStr = wxString_in_helper(o);
+        temp[x] = *pStr;
+        delete pStr;

     }
     return temp;
 }
     }
     return temp;
 }


@@ -1788,7 +1844,14 @@ bool wxSize_helper(PyObject* source, wxSize** obj) {
     else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
         PyObject* o1 = PySequence_GetItem(source, 0);
         PyObject* o2 = PySequence_GetItem(source, 1);
     else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
         PyObject* o1 = PySequence_GetItem(source, 0);
         PyObject* o2 = PySequence_GetItem(source, 1);

+        if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
+            Py_DECREF(o1);
+            Py_DECREF(o2);
+            goto error;
+        }

         **obj = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
         **obj = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));

+        Py_DECREF(o1);
+        Py_DECREF(o2);

         return TRUE;
     }
 
         return TRUE;
     }
 


@@ -1811,15 +1874,15 @@ bool wxPoint_helper(PyObject* source, wxPoint** obj) {
     if (PySequence_Check(source) && PySequence_Length(source) == 2) {
         PyObject* o1 = PySequence_GetItem(source, 0);
         PyObject* o2 = PySequence_GetItem(source, 1);
     if (PySequence_Check(source) && PySequence_Length(source) == 2) {
         PyObject* o1 = PySequence_GetItem(source, 0);
         PyObject* o2 = PySequence_GetItem(source, 1);

-                // This should really check for integers, not numbers -- but that would break code.
-                if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
-                        Py_DECREF(o1);
-                    Py_DECREF(o2);
-                        goto error;
-                }
-                **obj = wxPoint(PyInt_AsLong(o1), PyInt_AsLong(o2));
-                Py_DECREF(o1);
-                Py_DECREF(o2);
+        // This should really check for integers, not numbers -- but that would break code.
+        if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
+            Py_DECREF(o1);
+            Py_DECREF(o2);
+            goto error;
+        }
+        **obj = wxPoint(PyInt_AsLong(o1), PyInt_AsLong(o2));
+        Py_DECREF(o1);
+        Py_DECREF(o2);

         return TRUE;
     }
  error:
         return TRUE;
     }
  error:


@@ -1843,7 +1906,14 @@ bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj) {
     else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
         PyObject* o1 = PySequence_GetItem(source, 0);
         PyObject* o2 = PySequence_GetItem(source, 1);
     else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
         PyObject* o1 = PySequence_GetItem(source, 0);
         PyObject* o2 = PySequence_GetItem(source, 1);

+        if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
+            Py_DECREF(o1);
+            Py_DECREF(o2);
+            goto error;
+        }

         **obj = wxRealPoint(PyFloat_AsDouble(o1), PyFloat_AsDouble(o2));
         **obj = wxRealPoint(PyFloat_AsDouble(o1), PyFloat_AsDouble(o2));

+        Py_DECREF(o1);
+        Py_DECREF(o2);

         return TRUE;
     }
 
         return TRUE;
     }
 


@@ -1871,8 +1941,20 @@ bool wxRect_helper(PyObject* source, wxRect** obj) {
         PyObject* o2 = PySequence_GetItem(source, 1);
         PyObject* o3 = PySequence_GetItem(source, 2);
         PyObject* o4 = PySequence_GetItem(source, 3);
         PyObject* o2 = PySequence_GetItem(source, 1);
         PyObject* o3 = PySequence_GetItem(source, 2);
         PyObject* o4 = PySequence_GetItem(source, 3);

+        if (!PyNumber_Check(o1) || !PyNumber_Check(o2) ||
+            !PyNumber_Check(o3) || !PyNumber_Check(o4)) {
+            Py_DECREF(o1);
+            Py_DECREF(o2);
+            Py_DECREF(o3);
+            Py_DECREF(o4);
+            goto error;
+        }

         **obj = wxRect(PyInt_AsLong(o1), PyInt_AsLong(o2),
         **obj = wxRect(PyInt_AsLong(o1), PyInt_AsLong(o2),

-                     PyInt_AsLong(o3), PyInt_AsLong(o4));
+                       PyInt_AsLong(o3), PyInt_AsLong(o4));
+        Py_DECREF(o1);
+        Py_DECREF(o2);
+        Py_DECREF(o3);
+        Py_DECREF(o4);

         return TRUE;
     }
 
         return TRUE;
     }
 


@@ -1895,25 +1977,14 @@ bool wxColour_helper(PyObject* source, wxColour** obj) {
     }
     // otherwise a string is expected
     else if (PyString_Check(source)) {
     }
     // otherwise a string is expected
     else if (PyString_Check(source)) {

-        wxString spec = PyString_AS_STRING(source);
-        if (spec[0U] == '#' && spec.Length() == 7) {  // It's  #RRGGBB
-            char* junk;
-#if wxUSE_UNICODE  // TODO: unicode fix.
-            // This ifdef can be removed by using wxString methods to
-            // convert to long instead of strtol
-           char *tmpAsChar = new char[spec.Len()+1];
-           unicodeToChar(&spec.Mid(1,2), tmpAsChar);
-            int red   = strtol(tmpAsChar, &junk, 16);
-           unicodeToChar(&spec.Mid(3,2), tmpAsChar);
-            int green = strtol(tmpAsChar, &junk, 16);
-           unicodeToChar(&spec.Mid(5,2), tmpAsChar);
-            int blue  = strtol(tmpAsChar, &junk, 16);
-           delete [] tmpAsChar;
-#else
-            int red   = strtol(spec.Mid(1,2), &junk, 16);
-            int green = strtol(spec.Mid(3,2), &junk, 16);
-            int blue  = strtol(spec.Mid(5,2), &junk, 16);
-#endif
+        wxString spec(PyString_AS_STRING(source), *wxConvCurrent);
+        if (spec.GetChar(0) == '#' && spec.Length() == 7) {  // It's  #RRGGBB
+            long red, green, blue;
+            red = green = blue = 0;
+            spec.Mid(1,2).ToLong(&red,   16);
+            spec.Mid(3,2).ToLong(&green, 16);
+            spec.Mid(5,2).ToLong(&blue,  16);
+

             **obj = wxColour(red, green, blue);
             return TRUE;
         }
             **obj = wxColour(red, green, blue);
             return TRUE;
         }


@@ -1924,7 +1995,9 @@ bool wxColour_helper(PyObject* source, wxColour** obj) {
     }
 
  error:
     }
 
  error:

-    PyErr_SetString(PyExc_TypeError, "Expected a wxColour object or a string containing a colour name or '#RRGGBB'.");
+    PyErr_SetString(PyExc_TypeError,
+                    "Expected a wxColour object or a string containing a colour "
+                    "name or '#RRGGBB'.");

     return FALSE;
 }
 
     return FALSE;
 }