Added missing CreateManifest() to initialisation

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

diff --git a/wxPython/src/helpers.cpp b/wxPython/src/helpers.cpp
index 5d13c8f2469b4a22471e4a5e045d0ffa7e49d014..c3c52d2a6e0c76a81e4dfa23c85ea792996faaa1 100644 (file)
--- a/wxPython/src/helpers.cpp
+++ b/wxPython/src/helpers.cpp
@@ -125,40 +125,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.)


@@ -193,12 +196,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;
     }


@@ -238,15 +239,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;
     }


@@ -298,6 +295,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)
 {
 


@@ -333,11 +331,56 @@ PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args)
     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));
 

-

     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 +391,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 +402,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 +427,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 +448,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 +471,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 +480,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 +490,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,7 +522,7 @@ PyObject* wxPyConstructObject(void* ptr,
 
 
 PyObject* wxPyConstructObject(void* ptr,
 
 
 PyObject* wxPyConstructObject(void* ptr,

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

                               int setThisOwn) {
     PyObject* obj;
 
                               int setThisOwn) {
     PyObject* obj;
 


@@ -510,9 +532,9 @@ PyObject* wxPyConstructObject(void* ptr,
     }
 
     char    buff[64];               // should always be big enough...
     }
 
     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) {


@@ -527,6 +549,7 @@ PyObject* wxPyConstructObject(void* ptr,
     return wxPyConstructObject(ptr, className, classobj, setThisOwn);
 }
 
     return wxPyConstructObject(ptr, className, classobj, setThisOwn);
 }
 

+

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


@@ -554,7 +577,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;
 }
 


@@ -625,16 +648,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 +668,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 +683,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");

     }
     }

-    return s;
+    else {
+        // We use only strings for the streams, not unicode
+        obj = PyString_FromStringAndSize(buf, buf.GetDataLen());
+    }
+    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 +746,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 +755,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;

 }
 
 
 }
 
 


@@ -861,13 +858,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 +943,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 +1328,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 +1353,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 +1664,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 +1825,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 +1855,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 +1887,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 +1922,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 +1958,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 +1976,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;
 }