wxPython/src/helpers.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        helpers.cpp
   3 // Purpose:     Helper functions/classes for the wxPython extension module
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     1-July-1997
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1998 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13
  14 #undef DEBUG
  15 #include <Python.h>
  16 #include "wx/wxPython/wxPython_int.h"
  17 #include "wx/wxPython/pyistream.h"
  18
  19 #ifdef __WXMSW__
  20 #include <wx/msw/private.h>
  21 #include <wx/msw/winundef.h>
  22 #include <wx/msw/msvcrt.h>
  23 #endif
  24
  25 #ifdef __WXGTK__
  26 #include <gtk/gtk.h>
  27 #include <gdk/gdkprivate.h>
  28 #include <wx/gtk/win_gtk.h>
  29 #endif
  30
  31 #include <wx/clipbrd.h>
  32 #include <wx/mimetype.h>
  33 #include <wx/image.h>
  34
  35 //----------------------------------------------------------------------
  36
  37 #if PYTHON_API_VERSION <= 1007 && wxUSE_UNICODE
  38 #error Python must support Unicode to use wxWindows Unicode
  39 #endif
  40
  41 //----------------------------------------------------------------------
  42
  43 wxPyApp* wxPythonApp = NULL;  // Global instance of application object
  44 bool wxPyDoCleanup = False;
  45 bool wxPyDoingCleanup = False;
  46
  47
  48 #ifdef WXP_WITH_THREAD
  49 struct wxPyThreadState {
  50     unsigned long  tid;
  51     PyThreadState* tstate;
  52
  53     wxPyThreadState(unsigned long _tid=0, PyThreadState* _tstate=NULL)
  54         : tid(_tid), tstate(_tstate) {}
  55 };
  56
  57 #include <wx/dynarray.h>
  58 WX_DECLARE_OBJARRAY(wxPyThreadState, wxPyThreadStateArray);
  59 #include <wx/arrimpl.cpp>
  60 WX_DEFINE_OBJARRAY(wxPyThreadStateArray);
  61
  62 wxPyThreadStateArray* wxPyTStates = NULL;
  63 wxMutex*              wxPyTMutex = NULL;
  64 #endif
  65
  66
  67 static PyObject* wxPython_dict = NULL;
  68 static PyObject* wxPyAssertionError = NULL;
  69
  70 PyObject* wxPyPtrTypeMap = NULL;
  71
  72
  73 #ifdef __WXMSW__             // If building for win32...
  74 //----------------------------------------------------------------------
  75 // This gets run when the DLL is loaded.  We just need to save a handle.
  76 //----------------------------------------------------------------------
  77
  78 BOOL WINAPI DllMain(
  79     HINSTANCE   hinstDLL,    // handle to DLL module
  80     DWORD       fdwReason,   // reason for calling function
  81     LPVOID      lpvReserved  // reserved
  82    )
  83 {
  84     // If wxPython is embedded in another wxWindows app then
  85     // the inatance has already been set.
  86     if (! wxGetInstance())
  87         wxSetInstance(hinstDLL);
  88     return True;
  89 }
  90 #endif
  91
  92 //----------------------------------------------------------------------
  93 // Classes for implementing the wxp main application shell.
  94 //----------------------------------------------------------------------
  95
  96 IMPLEMENT_ABSTRACT_CLASS(wxPyApp, wxApp);
  97
  98
  99 wxPyApp::wxPyApp() {
 100     m_assertMode = wxPYAPP_ASSERT_EXCEPTION;
 101     m_startupComplete = False;
 102 }
 103
 104
 105 wxPyApp::~wxPyApp() {
 106 }
 107
 108
 109 // This one isn't acutally called...  We fake it with _BootstrapApp
 110 bool wxPyApp::OnInit() {
 111     return False;
 112 }
 113
 114
 115 int  wxPyApp::MainLoop() {
 116     int retval = 0;
 117
 118     DeletePendingObjects();
 119     bool initialized = wxTopLevelWindows.GetCount() != 0;
 120     if (initialized) {
 121         if ( m_exitOnFrameDelete == Later ) {
 122             m_exitOnFrameDelete = Yes;
 123         }
 124
 125         retval = wxApp::MainLoop();
 126         OnExit();
 127     }
 128     return retval;
 129 }
 130
 131
 132 bool wxPyApp::OnInitGui() {
 133     bool rval=True;
 134     wxApp::OnInitGui();  // in this case always call the base class version
 135     wxPyBeginBlockThreads();
 136     if (wxPyCBH_findCallback(m_myInst, "OnInitGui"))
 137         rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
 138     wxPyEndBlockThreads();
 139     return rval;
 140 }
 141
 142
 143 int wxPyApp::OnExit() {
 144     int rval=0;
 145     wxPyBeginBlockThreads();
 146     if (wxPyCBH_findCallback(m_myInst, "OnExit"))
 147         rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
 148     wxPyEndBlockThreads();
 149     wxApp::OnExit();  // in this case always call the base class version
 150     return rval;
 151 }
 152
 153
 154 #ifdef __WXDEBUG__
 155 void wxPyApp::OnAssert(const wxChar *file,
 156                      int line,
 157                      const wxChar *cond,
 158                      const wxChar *msg) {
 159
 160     // if we're not fully initialized then just log the error
 161     if (! m_startupComplete) {
 162         wxString buf;
 163         buf.Alloc(4096);
 164         buf.Printf(wxT("%s(%d): assert \"%s\" failed"),
 165                    file, line, cond);
 166         if (msg != NULL) {
 167             buf += wxT(": ");
 168             buf += msg;
 169         }
 170         wxLogDebug(buf);
 171         return;
 172     }
 173
 174     // If the OnAssert is overloaded in the Python class then call it...
 175     bool found;
 176     wxPyBeginBlockThreads();
 177     if ((found = wxPyCBH_findCallback(m_myInst, "OnAssert"))) {
 178         PyObject* fso = wx2PyString(file);
 179         PyObject* cso = wx2PyString(file);
 180         PyObject* mso;
 181         if (msg != NULL)
 182             mso = wx2PyString(file);
 183         else {
 184             mso = Py_None; Py_INCREF(Py_None);
 185         }
 186         wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiOO)", fso, line, cso, mso));
 187         Py_DECREF(fso);
 188         Py_DECREF(cso);
 189         Py_DECREF(mso);
 190     }
 191     wxPyEndBlockThreads();
 192
 193     // ...otherwise do our own thing with it
 194     if (! found) {
 195         // ignore it?
 196         if (m_assertMode & wxPYAPP_ASSERT_SUPPRESS)
 197             return;
 198
 199         // turn it into a Python exception?
 200         if (m_assertMode & wxPYAPP_ASSERT_EXCEPTION) {
 201             wxString buf;
 202             buf.Alloc(4096);
 203             buf.Printf(wxT("C++ assertion \"%s\" failed in %s(%d)"), cond, file, line);
 204             if (msg != NULL) {
 205                 buf += wxT(": ");
 206                 buf += msg;
 207             }
 208
 209             // set the exception
 210             wxPyBeginBlockThreads();
 211             PyObject* s = wx2PyString(buf);
 212             PyErr_SetObject(wxPyAssertionError, s);
 213             Py_DECREF(s);
 214             wxPyEndBlockThreads();
 215
 216             // Now when control returns to whatever API wrapper was called from
 217             // Python it should detect that an exception is set and will return
 218             // NULL, signalling the exception to Python.
 219         }
 220
 221         // Send it to the normal log destination, but only if
 222         // not _DIALOG because it will call this too
 223         if ( (m_assertMode & wxPYAPP_ASSERT_LOG) && !(m_assertMode & wxPYAPP_ASSERT_DIALOG)) {
 224             wxString buf;
 225             buf.Alloc(4096);
 226             buf.Printf(wxT("%s(%d): assert \"%s\" failed"),
 227                        file, line, cond);
 228             if (msg != NULL) {
 229                 buf += wxT(": ");
 230                 buf += msg;
 231             }
 232             wxLogDebug(buf);
 233         }
 234
 235         // do the normal wx assert dialog?
 236         if (m_assertMode & wxPYAPP_ASSERT_DIALOG)
 237             wxApp::OnAssert(file, line, cond, msg);
 238     }
 239 }
 240 #endif
 241
 242
 243
 244 /*static*/
 245 bool wxPyApp::GetMacSupportPCMenuShortcuts() {
 246 #ifdef __WXMAC__
 247     return s_macSupportPCMenuShortcuts;
 248 #else
 249     return 0;
 250 #endif
 251 }
 252
 253 /*static*/
 254 long wxPyApp::GetMacAboutMenuItemId() {
 255 #ifdef __WXMAC__
 256     return s_macAboutMenuItemId;
 257 #else
 258     return 0;
 259 #endif
 260 }
 261
 262 /*static*/
 263 long wxPyApp::GetMacPreferencesMenuItemId() {
 264 #ifdef __WXMAC__
 265     return s_macPreferencesMenuItemId;
 266 #else
 267     return 0;
 268 #endif
 269 }
 270
 271 /*static*/
 272 long wxPyApp::GetMacExitMenuItemId() {
 273 #ifdef __WXMAC__
 274     return s_macExitMenuItemId;
 275 #else
 276     return 0;
 277 #endif
 278 }
 279
 280 /*static*/
 281 wxString wxPyApp::GetMacHelpMenuTitleName() {
 282 #ifdef __WXMAC__
 283     return s_macHelpMenuTitleName;
 284 #else
 285     return wxEmptyString;
 286 #endif
 287 }
 288
 289 /*static*/
 290 void wxPyApp::SetMacSupportPCMenuShortcuts(bool val) {
 291 #ifdef __WXMAC__
 292     s_macSupportPCMenuShortcuts = val;
 293 #endif
 294 }
 295
 296 /*static*/
 297 void wxPyApp::SetMacAboutMenuItemId(long val) {
 298 #ifdef __WXMAC__
 299     s_macAboutMenuItemId = val;
 300 #endif
 301 }
 302
 303 /*static*/
 304 void wxPyApp::SetMacPreferencesMenuItemId(long val) {
 305 #ifdef __WXMAC__
 306     s_macPreferencesMenuItemId = val;
 307 #endif
 308 }
 309
 310 /*static*/
 311 void wxPyApp::SetMacExitMenuItemId(long val) {
 312 #ifdef __WXMAC__
 313     s_macExitMenuItemId = val;
 314 #endif
 315 }
 316
 317 /*static*/
 318 void wxPyApp::SetMacHelpMenuTitleName(const wxString& val) {
 319 #ifdef __WXMAC__
 320     s_macHelpMenuTitleName = val;
 321 #endif
 322 }
 323
 324
 325 // This finishes the initialization of wxWindows and then calls the OnInit
 326 // that should be present in the derived (Python) class.
 327 void wxPyApp::_BootstrapApp()
 328 {
 329     bool        result;
 330     PyObject*   retval = NULL;
 331     PyObject*   pyint  = NULL;
 332
 333
 334     // Get any command-line args passed to this program from the sys module
 335     int    argc = 0;
 336     char** argv = NULL;
 337     wxPyBeginBlockThreads();
 338     PyObject* sysargv = PySys_GetObject("argv");
 339     if (sysargv != NULL) {
 340         argc = PyList_Size(sysargv);
 341         argv = new char*[argc+1];
 342         int x;
 343         for(x=0; x<argc; x++) {
 344             PyObject *pyArg = PyList_GetItem(sysargv, x);
 345             argv[x] = PyString_AsString(pyArg);
 346         }
 347         argv[argc] = NULL;
 348     }
 349     wxPyEndBlockThreads();
 350
 351     result = wxEntryStart(argc, argv);
 352     delete [] argv;
 353
 354     wxPyBeginBlockThreads();
 355     if (! result)  {
 356         PyErr_SetString(PyExc_SystemError, "wxEntryStart failed!");
 357         goto error;
 358     }
 359
 360     // The stock objects were all NULL when they were loaded into
 361     // SWIG generated proxies, so re-init those now...
 362     wxPy_ReinitStockObjects(3);
 363
 364     // It's now ok to generate exceptions for assertion errors.
 365     wxPythonApp->SetStartupComplete(True);
 366
 367     // Call the Python wxApp's OnInit function
 368     if (wxPyCBH_findCallback(m_myInst, "OnInit")) {
 369
 370         PyObject* method = m_myInst.GetLastFound();
 371         PyObject* argTuple = PyTuple_New(0);
 372         retval = PyEval_CallObject(method, argTuple);
 373         Py_DECREF(argTuple);
 374         Py_DECREF(method);
 375         if (retval == NULL)
 376             goto error;
 377
 378         pyint = PyNumber_Int(retval);
 379         if (! pyint) {
 380             PyErr_SetString(PyExc_TypeError, "OnInit should return a boolean value");
 381             goto error;
 382         }
 383         result = PyInt_AS_LONG(pyint);
 384     }
 385     else {
 386         // Is it okay if there is no OnInit?  Probably so...
 387         result = True;
 388     }
 389
 390
 391     if (! result) {
 392         PyErr_SetString(PyExc_SystemExit, "OnInit returned False, exiting...");
 393     }
 394
 395  error:
 396     Py_XDECREF(retval);
 397     Py_XDECREF(pyint);
 398
 399     wxPyEndBlockThreads();
 400 };
 401
 402 //---------------------------------------------------------------------
 403 //----------------------------------------------------------------------
 404
 405
 406 #if 0
 407 static char* wxPyCopyCString(const wxChar* src)
 408 {
 409     wxWX2MBbuf buff = (wxWX2MBbuf)wxConvCurrent->cWX2MB(src);
 410     size_t len = strlen(buff);
 411     char*  dest = new char[len+1];
 412     strcpy(dest, buff);
 413     return dest;
 414 }
 415
 416 #if wxUSE_UNICODE
 417 static char* wxPyCopyCString(const char* src)   // we need a char version too
 418 {
 419     size_t len = strlen(src);
 420     char*  dest = new char[len+1];
 421     strcpy(dest, src);
 422     return dest;
 423 }
 424 #endif
 425
 426 static wxChar* wxPyCopyWString(const char *src)
 427 {
 428     //wxMB2WXbuf buff = wxConvCurrent->cMB2WX(src);
 429     wxString str(src, *wxConvCurrent);
 430     return copystring(str);
 431 }
 432
 433 #if wxUSE_UNICODE
 434 static wxChar* wxPyCopyWString(const wxChar *src)
 435 {
 436     return copystring(src);
 437 }
 438 #endif
 439 #endif
 440
 441
 442 inline const char* dropwx(const char* name) {
 443     if (name[0] == 'w' && name[1] == 'x')
 444         return name+2;
 445     else
 446         return name;
 447 }
 448
 449 //----------------------------------------------------------------------
 450
 451 // This function is called when the wxc module is imported to do some initial
 452 // setup.  (Before there is a wxApp object.)  The rest happens in
 453 // wxPyApp::_BootstrapApp
 454 void __wxPyPreStart(PyObject* moduleDict)
 455 {
 456
 457 #ifdef __WXMSW__
 458 //    wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF);
 459 #endif
 460
 461 #ifdef WXP_WITH_THREAD
 462     PyEval_InitThreads();
 463     wxPyTStates = new wxPyThreadStateArray;
 464     wxPyTMutex = new wxMutex;
 465
 466     // Save the current (main) thread state in our array
 467     PyThreadState* tstate = wxPyBeginAllowThreads();
 468     wxPyEndAllowThreads(tstate);
 469 #endif
 470
 471     // Ensure that the build options in the DLL (or whatever) match this build
 472     wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "wxPython");
 473
 474     // Init the stock objects to a non-NULL value so SWIG doesn't create them as None
 475     wxPy_ReinitStockObjects(1);
 476 }
 477
 478
 479
 480 void __wxPyCleanup() {
 481     wxPyDoingCleanup = True;
 482     if (wxPyDoCleanup) {
 483         wxPyDoCleanup = False;
 484         wxEntryCleanup();
 485     }
 486 #ifdef WXP_WITH_THREAD
 487     delete wxPyTMutex;
 488     wxPyTMutex = NULL;
 489     wxPyTStates->Empty();
 490     delete wxPyTStates;
 491     wxPyTStates = NULL;
 492 #endif
 493 }
 494
 495
 496 // Save a reference to the dictionary of the wx.core module, and inject
 497 // a few more things into it.
 498 PyObject* __wxPySetDictionary(PyObject* /* self */, PyObject* args)
 499 {
 500
 501     if (!PyArg_ParseTuple(args, "O", &wxPython_dict))
 502         return NULL;
 503
 504     if (!PyDict_Check(wxPython_dict)) {
 505         PyErr_SetString(PyExc_TypeError, "_wxPySetDictionary must have dictionary object!");
 506         return NULL;
 507     }
 508
 509     if (! wxPyPtrTypeMap)
 510         wxPyPtrTypeMap = PyDict_New();
 511     PyDict_SetItemString(wxPython_dict, "__wxPyPtrTypeMap", wxPyPtrTypeMap);
 512
 513     // Create an exception object to use for wxASSERTions
 514     wxPyAssertionError = PyErr_NewException("wx.core.PyAssertionError",
 515                                             PyExc_AssertionError, NULL);
 516     PyDict_SetItemString(wxPython_dict, "PyAssertionError", wxPyAssertionError);
 517
 518
 519 #ifdef __WXMOTIF__
 520 #define wxPlatform "__WXMOTIF__"
 521 #endif
 522 #ifdef __WXX11__
 523 #define wxPlatform "__WXX11__"
 524 #endif
 525 #ifdef __WXGTK__
 526 #define wxPlatform "__WXGTK__"
 527 #endif
 528 #if defined(__WIN32__) || defined(__WXMSW__)
 529 #define wxPlatform "__WXMSW__"
 530 #endif
 531 #ifdef __WXMAC__
 532 #define wxPlatform "__WXMAC__"
 533 #endif
 534
 535 #ifdef __WXDEBUG__
 536     int wxdebug = 1;
 537 #else
 538     int wxdebug = 0;
 539 #endif
 540
 541     PyDict_SetItemString(wxPython_dict, "Platform", PyString_FromString(wxPlatform));
 542     PyDict_SetItemString(wxPython_dict, "USE_UNICODE", PyInt_FromLong(wxUSE_UNICODE));
 543     PyDict_SetItemString(wxPython_dict, "__WXDEBUG__", PyInt_FromLong(wxdebug));
 544
 545     RETURN_NONE();
 546 }
 547
 548
 549 //---------------------------------------------------------------------------
 550
 551 // Python's PyInstance_Check does not return True for instances of new-style
 552 // classes.  This should get close enough for both new and old classes but I
 553 // should re-evaluate the need for doing instance checks...
 554 bool wxPyInstance_Check(PyObject* obj) {
 555     return PyObject_HasAttrString(obj, "__class__") != 0;
 556 }
 557
 558
 559 // This one checks if the object is an instance of a SWIG proxy class (it has
 560 // a .this attribute)
 561 bool wxPySwigInstance_Check(PyObject* obj) {
 562     return PyObject_HasAttrString(obj, "this") != 0;
 563 }
 564
 565 //---------------------------------------------------------------------------
 566
 567 // The stock objects are no longer created when the wxc module is imported,
 568 // but only after the app object has been created.  The
 569 // wxPy_ReinitStockObjects function will be called 3 times to pass the stock
 570 // objects though various stages of evolution:
 571 //
 572 //   pass 1: Set all the pointers to a non-NULL value so the Python proxy
 573 //           object will be created (otherwise it will just use None.)
 574 //
 575 //   pass 2: After the module has been imported and the python proxys have
 576 //           been created, then set the __class__ to be _wxPyUnbornObject so
 577 //           it will catch any access to the object and will raise an exception.
 578 //
 579 //   pass 3: Finally, from OnInit patch things up so the stock objects can
 580 //           be used.
 581
 582
 583 PyObject* __wxPyFixStockObjects(PyObject* /* self */, PyObject* args)
 584 {
 585     wxPy_ReinitStockObjects(2);
 586     RETURN_NONE();
 587 }
 588
 589
 590 static void rsoPass2(const char* name)
 591 {
 592     static PyObject* unbornObjectClass = NULL;
 593     PyObject* obj;
 594
 595     if (unbornObjectClass == NULL) {
 596         unbornObjectClass = PyDict_GetItemString(wxPython_dict, "_wxPyUnbornObject");
 597         Py_INCREF(unbornObjectClass);
 598     }
 599
 600     // Find the object instance
 601     obj = PyDict_GetItemString(wxPython_dict, (char*)dropwx(name));
 602     wxCHECK_RET(obj != NULL, wxT("Unable to find stock object"));
 603     wxCHECK_RET(wxPySwigInstance_Check(obj), wxT("Not a swig instance"));
 604
 605     // Change its class
 606     PyObject_SetAttrString(obj, "__class__",  unbornObjectClass);
 607
 608 }
 609
 610 static void rsoPass3(const char* name, const char* classname, void* ptr)
 611 {
 612     PyObject* obj;
 613     PyObject* classobj;
 614     PyObject* ptrobj;
 615
 616     // Find the object instance
 617     obj = PyDict_GetItemString(wxPython_dict, (char*)dropwx(name));
 618     wxCHECK_RET(obj != NULL, wxT("Unable to find stock object"));
 619     wxCHECK_RET(wxPySwigInstance_Check(obj), wxT("Not a swig instance"));
 620
 621     // Find the class object and put it back in the instance
 622     classobj = PyDict_GetItemString(wxPython_dict, (char*)dropwx(classname));
 623     wxCHECK_RET(classobj != NULL, wxT("Unable to find stock class object"));
 624     PyObject_SetAttrString(obj, "__class__",  classobj);
 625
 626     // Rebuild the .this swigified pointer with the new value of the C++ pointer
 627     ptrobj = wxPyMakeSwigPtr(ptr, wxString(classname, *wxConvCurrent));
 628     PyObject_SetAttrString(obj, "this", ptrobj);
 629     Py_DECREF(ptrobj);
 630 }
 631
 632
 633
 634 void wxPy_ReinitStockObjects(int pass)
 635 {
 636
 637 #define REINITOBJ(name, classname) \
 638     if (pass == 1) { name = (classname*)0xC0C0C0C0; } \
 639     else if (pass == 2) { rsoPass2(#name); } \
 640     else if (pass == 3) { rsoPass3(#name, #classname, (void*)name); }
 641
 642
 643 #define REINITOBJ2(name, classname) \
 644     if (pass == 1) { } \
 645     else if (pass == 2) { rsoPass2(#name); } \
 646     else if (pass == 3) { rsoPass3(#name, #classname, (void*)&name); }
 647
 648
 649     REINITOBJ(wxNORMAL_FONT, wxFont);
 650     REINITOBJ(wxSMALL_FONT, wxFont);
 651     REINITOBJ(wxITALIC_FONT, wxFont);
 652     REINITOBJ(wxSWISS_FONT, wxFont);
 653
 654     REINITOBJ(wxRED_PEN, wxPen);
 655     REINITOBJ(wxCYAN_PEN, wxPen);
 656     REINITOBJ(wxGREEN_PEN, wxPen);
 657     REINITOBJ(wxBLACK_PEN, wxPen);
 658     REINITOBJ(wxWHITE_PEN, wxPen);
 659     REINITOBJ(wxTRANSPARENT_PEN, wxPen);
 660     REINITOBJ(wxBLACK_DASHED_PEN, wxPen);
 661     REINITOBJ(wxGREY_PEN, wxPen);
 662     REINITOBJ(wxMEDIUM_GREY_PEN, wxPen);
 663     REINITOBJ(wxLIGHT_GREY_PEN, wxPen);
 664
 665     REINITOBJ(wxBLUE_BRUSH, wxBrush);
 666     REINITOBJ(wxGREEN_BRUSH, wxBrush);
 667     REINITOBJ(wxWHITE_BRUSH, wxBrush);
 668     REINITOBJ(wxBLACK_BRUSH, wxBrush);
 669     REINITOBJ(wxTRANSPARENT_BRUSH, wxBrush);
 670     REINITOBJ(wxCYAN_BRUSH, wxBrush);
 671     REINITOBJ(wxRED_BRUSH, wxBrush);
 672     REINITOBJ(wxGREY_BRUSH, wxBrush);
 673     REINITOBJ(wxMEDIUM_GREY_BRUSH, wxBrush);
 674     REINITOBJ(wxLIGHT_GREY_BRUSH, wxBrush);
 675
 676     REINITOBJ(wxBLACK, wxColour);
 677     REINITOBJ(wxWHITE, wxColour);
 678     REINITOBJ(wxRED, wxColour);
 679     REINITOBJ(wxBLUE, wxColour);
 680     REINITOBJ(wxGREEN, wxColour);
 681     REINITOBJ(wxCYAN, wxColour);
 682     REINITOBJ(wxLIGHT_GREY, wxColour);
 683
 684     REINITOBJ(wxSTANDARD_CURSOR, wxCursor);
 685     REINITOBJ(wxHOURGLASS_CURSOR, wxCursor);
 686     REINITOBJ(wxCROSS_CURSOR, wxCursor);
 687
 688     REINITOBJ2(wxNullBitmap, wxBitmap);
 689     REINITOBJ2(wxNullIcon, wxIcon);
 690     REINITOBJ2(wxNullCursor, wxCursor);
 691     REINITOBJ2(wxNullPen, wxPen);
 692     REINITOBJ2(wxNullBrush, wxBrush);
 693     REINITOBJ2(wxNullPalette, wxPalette);
 694     REINITOBJ2(wxNullFont, wxFont);
 695     REINITOBJ2(wxNullColour, wxColour);
 696
 697     REINITOBJ(wxTheFontList, wxFontList);
 698     REINITOBJ(wxThePenList, wxPenList);
 699     REINITOBJ(wxTheBrushList, wxBrushList);
 700     REINITOBJ(wxTheColourDatabase, wxColourDatabase);
 701
 702
 703     REINITOBJ(wxTheClipboard, wxClipboard);
 704     REINITOBJ2(wxDefaultValidator, wxValidator);
 705     REINITOBJ2(wxNullImage, wxImage);
 706     REINITOBJ2(wxNullAcceleratorTable, wxAcceleratorTable);
 707
 708 #undef REINITOBJ
 709 #undef REINITOBJ2
 710 }
 711
 712 //---------------------------------------------------------------------------
 713
 714 void wxPyClientData_dtor(wxPyClientData* self) {
 715     if (! wxPyDoingCleanup) {           // Don't do it during cleanup as Python
 716                                         // may have already garbage collected the object...
 717         wxPyBeginBlockThreads();
 718         Py_DECREF(self->m_obj);
 719         self->m_obj = NULL;
 720         wxPyEndBlockThreads();
 721     }
 722 }
 723
 724 void wxPyUserData_dtor(wxPyUserData* self) {
 725     if (! wxPyDoingCleanup) {
 726         wxPyBeginBlockThreads();
 727         Py_DECREF(self->m_obj);
 728         self->m_obj = NULL;
 729         wxPyEndBlockThreads();
 730     }
 731 }
 732
 733
 734 // This is called when an OOR controled object is being destroyed.  Although
 735 // the C++ object is going away there is no way to force the Python object
 736 // (and all references to it) to die too.  This causes problems (crashes) in
 737 // wxPython when a python shadow object attempts to call a C++ method using
 738 // the now bogus pointer... So to try and prevent this we'll do a little black
 739 // magic and change the class of the python instance to a class that will
 740 // raise an exception for any attempt to call methods with it.  See
 741 // _wxPyDeadObject in _core_ex.py for the implementation of this class.
 742 void wxPyOORClientData_dtor(wxPyOORClientData* self) {
 743
 744     static PyObject* deadObjectClass = NULL;
 745
 746     wxPyBeginBlockThreads();
 747     if (deadObjectClass == NULL) {
 748         deadObjectClass = PyDict_GetItemString(wxPython_dict, "_wxPyDeadObject");
 749         // TODO:  Can not wxASSERT here because inside a wxPyBeginBlock Threads,
 750         // will lead to a deadlock when it tries to aquire the GIL again.
 751         //wxASSERT_MSG(deadObjectClass != NULL, wxT("Can't get _wxPyDeadObject class!"));
 752         Py_INCREF(deadObjectClass);
 753     }
 754
 755
 756     // Only if there is more than one reference to the object
 757     if ( !wxPyDoingCleanup && self->m_obj->ob_refcnt > 1 ) {
 758         // bool isInstance = wxPyInstance_Check(self->m_obj);
 759         // TODO same here
 760         //wxASSERT_MSG(isInstance, wxT("m_obj not an instance!?!?!"));
 761
 762         // Call __del__, if there is one.
 763         PyObject* func = PyObject_GetAttrString(self->m_obj, "__del__");
 764         if (func) {
 765             PyObject* rv = PyObject_CallMethod(self->m_obj, "__del__", NULL);
 766             Py_XDECREF(rv);
 767             Py_DECREF(func);
 768         }
 769         if (PyErr_Occurred())
 770             PyErr_Clear();      // just ignore it for now
 771
 772
 773         PyObject* dict = PyObject_GetAttrString(self->m_obj, "__dict__");
 774         if (dict) {
 775             // Clear the instance's dictionary
 776             PyDict_Clear(dict);
 777
 778             // put the name of the old class into the instance, and then reset the
 779             // class to be the dead class.
 780             PyObject* klass = PyObject_GetAttrString(self->m_obj, "__class__");
 781             PyObject* name =  PyObject_GetAttrString(klass, "__name__");
 782             PyDict_SetItemString(dict, "_name", name);
 783             PyObject_SetAttrString(self->m_obj, "__class__",  deadObjectClass);
 784             //Py_INCREF(deadObjectClass);
 785             Py_DECREF(klass);
 786             Py_DECREF(name);
 787         }
 788     }
 789
 790     // m_obj is DECREF'd in the base class dtor...
 791     wxPyEndBlockThreads();
 792 }
 793
 794
 795 //---------------------------------------------------------------------------
 796 // Stuff used by OOR to find the right wxPython class type to return and to
 797 // build it.
 798
 799
 800 // The pointer type map is used when the "pointer" type name generated by SWIG
 801 // is not the same as the shadow class name, for example wxPyTreeCtrl
 802 // vs. wxTreeCtrl.  It needs to be referenced in Python as well as from C++,
 803 // so we'll just make it a Python dictionary in the wx module's namespace.
 804 // (See __wxSetDictionary)
 805 void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) {
 806     if (! wxPyPtrTypeMap)
 807         wxPyPtrTypeMap = PyDict_New();
 808     PyDict_SetItemString(wxPyPtrTypeMap,
 809                          (char*)commonName,
 810                          PyString_FromString((char*)ptrName));
 811 }
 812
 813
 814
 815
 816 PyObject*  wxPyMake_wxObject(wxObject* source, bool checkEvtHandler) {
 817     PyObject* target = NULL;
 818     bool      isEvtHandler = False;
 819
 820     if (source) {
 821         // If it's derived from wxEvtHandler then there may
 822         // already be a pointer to a Python object that we can use
 823         // in the OOR data.
 824         if (checkEvtHandler && wxIsKindOf(source, wxEvtHandler)) {
 825             isEvtHandler = True;
 826             wxEvtHandler* eh = (wxEvtHandler*)source;
 827             wxPyOORClientData* data = (wxPyOORClientData*)eh->GetClientObject();
 828             if (data) {
 829                 target = data->m_obj;
 830                 if (target)
 831                     Py_INCREF(target);
 832             }
 833         }
 834
 835         if (! target) {
 836             // Otherwise make it the old fashioned way by making a new shadow
 837             // object and putting this pointer in it.  Look up the class
 838             // heirarchy until we find a class name that is located in the
 839             // python module.
 840             const wxClassInfo* info   = source->GetClassInfo();
 841             wxString           name   = info->GetClassName();
 842             bool               exists = wxPyCheckSwigType(name);
 843             while (info && !exists) {
 844                 info = info->GetBaseClass1();
 845                 name = info->GetClassName();
 846                 exists = wxPyCheckSwigType(name);
 847             }
 848             if (info) {
 849                 target = wxPyConstructObject((void*)source, name, False);
 850                 if (target && isEvtHandler)
 851                     ((wxEvtHandler*)source)->SetClientObject(new wxPyOORClientData(target));
 852             } else {
 853                 wxString msg(wxT("wxPython class not found for "));
 854                 msg += source->GetClassInfo()->GetClassName();
 855                 PyErr_SetString(PyExc_NameError, msg.mbc_str());
 856                 target = NULL;
 857             }
 858         }
 859     } else {  // source was NULL so return None.
 860         Py_INCREF(Py_None); target = Py_None;
 861     }
 862     return target;
 863 }
 864
 865
 866 PyObject*  wxPyMake_wxSizer(wxSizer* source) {
 867     PyObject* target = NULL;
 868
 869     if (source && wxIsKindOf(source, wxSizer)) {
 870         // If it's derived from wxSizer then there may already be a pointer to
 871         // a Python object that we can use in the OOR data.
 872         wxSizer* sz = (wxSizer*)source;
 873         wxPyOORClientData* data = (wxPyOORClientData*)sz->GetClientObject();
 874         if (data) {
 875             target = data->m_obj;
 876             if (target)
 877                 Py_INCREF(target);
 878         }
 879     }
 880     if (! target) {
 881         target = wxPyMake_wxObject(source, False);
 882         if (target != Py_None)
 883             ((wxSizer*)source)->SetClientObject(new wxPyOORClientData(target));
 884     }
 885     return target;
 886 }
 887
 888
 889 //---------------------------------------------------------------------------
 890
 891
 892 #ifdef WXP_WITH_THREAD
 893 inline
 894 unsigned long wxPyGetCurrentThreadId() {
 895     return wxThread::GetCurrentId();
 896 }
 897
 898 static PyThreadState* gs_shutdownTState;
 899
 900 static
 901 PyThreadState* wxPyGetThreadState() {
 902     if (wxPyTMutex == NULL) // Python is shutting down...
 903         return gs_shutdownTState;
 904
 905     unsigned long ctid = wxPyGetCurrentThreadId();
 906     PyThreadState* tstate = NULL;
 907
 908     wxPyTMutex->Lock();
 909     for(size_t i=0; i < wxPyTStates->GetCount(); i++) {
 910         wxPyThreadState& info = wxPyTStates->Item(i);
 911         if (info.tid == ctid) {
 912             tstate = info.tstate;
 913             break;
 914         }
 915     }
 916     wxPyTMutex->Unlock();
 917     wxASSERT_MSG(tstate, wxT("PyThreadState should not be NULL!"));
 918     return tstate;
 919 }
 920
 921 static
 922 void wxPySaveThreadState(PyThreadState* tstate) {
 923     if (wxPyTMutex == NULL) { // Python is shutting down, assume a single thread...
 924         gs_shutdownTState = tstate;
 925         return;
 926     }
 927     unsigned long ctid = wxPyGetCurrentThreadId();
 928     wxPyTMutex->Lock();
 929     for(size_t i=0; i < wxPyTStates->GetCount(); i++) {
 930         wxPyThreadState& info = wxPyTStates->Item(i);
 931         if (info.tid == ctid) {
 932 #if 0
 933             if (info.tstate != tstate)
 934                 wxLogMessage("*** tstate mismatch!???");
 935 #endif
 936             // info.tstate = tstate;    *** DO NOT update existing ones???
 937             // Normally it will never change, but apparently COM callbacks
 938             // (i.e. ActiveX controls) will (incorrectly IMHO) use a transient
 939             // tstate which will then be garbage the next time we try to use
 940             // it...
 941             wxPyTMutex->Unlock();
 942             return;
 943         }
 944     }
 945     // not found, so add it...
 946     wxPyTStates->Add(new wxPyThreadState(ctid, tstate));
 947     wxPyTMutex->Unlock();
 948 }
 949
 950 #endif
 951
 952
 953 // Calls from Python to wxWindows code are wrapped in calls to these
 954 // functions:
 955
 956 PyThreadState* wxPyBeginAllowThreads() {
 957 #ifdef WXP_WITH_THREAD
 958     PyThreadState* saved = PyEval_SaveThread();  // Py_BEGIN_ALLOW_THREADS;
 959     wxPySaveThreadState(saved);
 960     return saved;
 961 #else
 962     return NULL;
 963 #endif
 964 }
 965
 966 void wxPyEndAllowThreads(PyThreadState* saved) {
 967 #ifdef WXP_WITH_THREAD
 968     PyEval_RestoreThread(saved);   // Py_END_ALLOW_THREADS;
 969 #endif
 970 }
 971
 972
 973
 974 // Calls from wxWindows back to Python code, or even any PyObject
 975 // manipulations, PyDECREF's and etc. are wrapped in calls to these functions:
 976
 977 void wxPyBeginBlockThreads() {
 978 #ifdef WXP_WITH_THREAD
 979     PyThreadState* tstate = wxPyGetThreadState();
 980     PyEval_RestoreThread(tstate);
 981 #endif
 982 }
 983
 984
 985 void wxPyEndBlockThreads() {
 986 #ifdef WXP_WITH_THREAD
 987     // Is there any need to save it again?
 988     // PyThreadState* tstate =
 989     PyEval_SaveThread();
 990 #endif
 991 }
 992
 993
 994 //---------------------------------------------------------------------------
 995 // wxPyInputStream and wxPyCBInputStream methods
 996
 997
 998 void wxPyInputStream::close() {
 999     /* do nothing for now */
1000 }
1001
1002 void wxPyInputStream::flush() {
1003     /* do nothing for now */
1004 }
1005
1006 bool wxPyInputStream::eof() {
1007     if (m_wxis)
1008         return m_wxis->Eof();
1009     else
1010         return True;
1011 }
1012
1013 wxPyInputStream::~wxPyInputStream() {
1014     /* do nothing */
1015 }
1016
1017
1018
1019
1020 PyObject* wxPyInputStream::read(int size) {
1021     PyObject* obj = NULL;
1022     wxMemoryBuffer buf;
1023     const int BUFSIZE = 1024;
1024
1025     // check if we have a real wxInputStream to work with
1026     if (!m_wxis) {
1027         wxPyBeginBlockThreads();
1028         PyErr_SetString(PyExc_IOError, "no valid C-wxInputStream");
1029         wxPyEndBlockThreads();
1030         return NULL;
1031     }
1032
1033     if (size < 0) {
1034         // read while bytes are available on the stream
1035         while ( m_wxis->CanRead() ) {
1036             m_wxis->Read(buf.GetAppendBuf(BUFSIZE), BUFSIZE);
1037             buf.UngetAppendBuf(m_wxis->LastRead());
1038         }
1039
1040     } else {  // Read only size number of characters
1041         m_wxis->Read(buf.GetWriteBuf(size), size);
1042         buf.UngetWriteBuf(m_wxis->LastRead());
1043     }
1044
1045     // error check
1046     wxPyBeginBlockThreads();
1047     wxStreamError err = m_wxis->GetLastError();
1048     if (err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF) {
1049         PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
1050     }
1051     else {
1052         // We use only strings for the streams, not unicode
1053         obj = PyString_FromStringAndSize(buf, buf.GetDataLen());
1054     }
1055     wxPyEndBlockThreads();
1056     return obj;
1057 }
1058
1059
1060 PyObject* wxPyInputStream::readline(int size) {
1061     PyObject* obj = NULL;
1062     wxMemoryBuffer buf;
1063     int i;
1064     char ch;
1065
1066     // check if we have a real wxInputStream to work with
1067     if (!m_wxis) {
1068         wxPyBeginBlockThreads();
1069         PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream");
1070         wxPyEndBlockThreads();
1071         return NULL;
1072     }
1073
1074     // read until \n or byte limit reached
1075     for (i=ch=0; (ch != '\n') && (m_wxis->CanRead()) && ((size < 0) || (i < size)); i++) {
1076         ch = m_wxis->GetC();
1077         buf.AppendByte(ch);
1078     }
1079
1080     // errorcheck
1081     wxPyBeginBlockThreads();
1082     wxStreamError err = m_wxis->GetLastError();
1083     if (err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF) {
1084         PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
1085     }
1086     else {
1087         // We use only strings for the streams, not unicode
1088         obj = PyString_FromStringAndSize((char*)buf.GetData(), buf.GetDataLen());
1089     }
1090     wxPyEndBlockThreads();
1091     return obj;
1092 }
1093
1094
1095 PyObject* wxPyInputStream::readlines(int sizehint) {
1096     PyObject* pylist;
1097
1098     // check if we have a real wxInputStream to work with
1099     if (!m_wxis) {
1100         wxPyBeginBlockThreads();
1101         PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream");
1102         wxPyEndBlockThreads();
1103         return NULL;
1104     }
1105
1106     // init list
1107     wxPyBeginBlockThreads();
1108     pylist = PyList_New(0);
1109     if (!pylist) {
1110         wxPyBeginBlockThreads();
1111         PyErr_NoMemory();
1112         wxPyEndBlockThreads();
1113         return NULL;
1114     }
1115
1116     // read sizehint bytes or until EOF
1117     int i;
1118     for (i=0; (m_wxis->CanRead()) && ((sizehint < 0) || (i < sizehint));) {
1119         PyObject* s = this->readline();
1120         if (s == NULL) {
1121             wxPyBeginBlockThreads();
1122             Py_DECREF(pylist);
1123             wxPyEndBlockThreads();
1124             return NULL;
1125         }
1126         wxPyBeginBlockThreads();
1127         PyList_Append(pylist, s);
1128         i += PyString_Size(s);
1129         wxPyEndBlockThreads();
1130     }
1131
1132     // error check
1133     wxStreamError err = m_wxis->GetLastError();
1134     if (err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF) {
1135         wxPyBeginBlockThreads();
1136         Py_DECREF(pylist);
1137         PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
1138         wxPyEndBlockThreads();
1139         return NULL;
1140     }
1141
1142     return pylist;
1143 }
1144
1145
1146 void wxPyInputStream::seek(int offset, int whence) {
1147     if (m_wxis)
1148         m_wxis->SeekI(offset, wxSeekMode(whence));
1149 }
1150
1151 int wxPyInputStream::tell(){
1152     if (m_wxis)
1153         return m_wxis->TellI();
1154     else return 0;
1155 }
1156
1157
1158
1159
1160 wxPyCBInputStream::wxPyCBInputStream(PyObject *r, PyObject *s, PyObject *t, bool block)
1161     : wxInputStream(), m_read(r), m_seek(s), m_tell(t), m_block(block)
1162 {}
1163
1164
1165 wxPyCBInputStream::~wxPyCBInputStream() {
1166     if (m_block) wxPyBeginBlockThreads();
1167     Py_XDECREF(m_read);
1168     Py_XDECREF(m_seek);
1169     Py_XDECREF(m_tell);
1170     if (m_block) wxPyEndBlockThreads();
1171 }
1172
1173
1174 wxPyCBInputStream* wxPyCBInputStream::create(PyObject *py, bool block) {
1175     if (block) wxPyBeginBlockThreads();
1176
1177     PyObject* read = getMethod(py, "read");
1178     PyObject* seek = getMethod(py, "seek");
1179     PyObject* tell = getMethod(py, "tell");
1180
1181     if (!read) {
1182         PyErr_SetString(PyExc_TypeError, "Not a file-like object");
1183         Py_XDECREF(read);
1184         Py_XDECREF(seek);
1185         Py_XDECREF(tell);
1186         if (block) wxPyEndBlockThreads();
1187         return NULL;
1188     }
1189
1190     if (block) wxPyEndBlockThreads();
1191     return new wxPyCBInputStream(read, seek, tell, block);
1192 }
1193
1194
1195 wxPyCBInputStream* wxPyCBInputStream_create(PyObject *py, bool block) {
1196     return wxPyCBInputStream::create(py, block);
1197 }
1198
1199 PyObject* wxPyCBInputStream::getMethod(PyObject* py, char* name) {
1200     if (!PyObject_HasAttrString(py, name))
1201         return NULL;
1202     PyObject* o = PyObject_GetAttrString(py, name);
1203     if (!PyMethod_Check(o) && !PyCFunction_Check(o)) {
1204         Py_DECREF(o);
1205         return NULL;
1206     }
1207     return o;
1208 }
1209
1210
1211 size_t wxPyCBInputStream::GetSize() const {
1212     wxPyCBInputStream* self = (wxPyCBInputStream*)this; // cast off const
1213     if (m_seek && m_tell) {
1214         off_t temp = self->OnSysTell();
1215         off_t ret = self->OnSysSeek(0, wxFromEnd);
1216         self->OnSysSeek(temp, wxFromStart);
1217         return ret;
1218     }
1219     else
1220         return 0;
1221 }
1222
1223
1224 size_t wxPyCBInputStream::OnSysRead(void *buffer, size_t bufsize) {
1225     if (bufsize == 0)
1226         return 0;
1227
1228     wxPyBeginBlockThreads();
1229     PyObject* arglist = Py_BuildValue("(i)", bufsize);
1230     PyObject* result = PyEval_CallObject(m_read, arglist);
1231     Py_DECREF(arglist);
1232
1233     size_t o = 0;
1234     if ((result != NULL) && PyString_Check(result)) {
1235         o = PyString_Size(result);
1236         if (o == 0)
1237             m_lasterror = wxSTREAM_EOF;
1238         if (o > bufsize)
1239             o = bufsize;
1240         memcpy((char*)buffer, PyString_AsString(result), o);  // strings only, not unicode...
1241         Py_DECREF(result);
1242
1243     }
1244     else
1245         m_lasterror = wxSTREAM_READ_ERROR;
1246     wxPyEndBlockThreads();
1247     return o;
1248 }
1249
1250 size_t wxPyCBInputStream::OnSysWrite(const void *buffer, size_t bufsize) {
1251     m_lasterror = wxSTREAM_WRITE_ERROR;
1252     return 0;
1253 }
1254
1255 off_t wxPyCBInputStream::OnSysSeek(off_t off, wxSeekMode mode) {
1256     wxPyBeginBlockThreads();
1257 #ifdef _LARGE_FILES
1258     // off_t is a 64-bit value...
1259     PyObject* arglist = Py_BuildValue("(Li)", off, mode);
1260 #else
1261     PyObject* arglist = Py_BuildValue("(ii)", off, mode);
1262 #endif
1263     PyObject* result = PyEval_CallObject(m_seek, arglist);
1264     Py_DECREF(arglist);
1265     Py_XDECREF(result);
1266     wxPyEndBlockThreads();
1267     return OnSysTell();
1268 }
1269
1270
1271 off_t wxPyCBInputStream::OnSysTell() const {
1272     wxPyBeginBlockThreads();
1273     PyObject* arglist = Py_BuildValue("()");
1274     PyObject* result = PyEval_CallObject(m_tell, arglist);
1275     Py_DECREF(arglist);
1276     off_t o = 0;
1277     if (result != NULL) {
1278 #ifdef _LARGE_FILES
1279         if (PyLong_Check(result))
1280             o = PyLong_AsLongLong(result);
1281         else
1282 #else
1283         o = PyInt_AsLong(result);
1284 #endif
1285         Py_DECREF(result);
1286     };
1287     wxPyEndBlockThreads();
1288     return o;
1289 }
1290
1291 //----------------------------------------------------------------------
1292
1293 IMPLEMENT_ABSTRACT_CLASS(wxPyCallback, wxObject);
1294
1295 wxPyCallback::wxPyCallback(PyObject* func) {
1296     m_func = func;
1297     Py_INCREF(m_func);
1298 }
1299
1300 wxPyCallback::wxPyCallback(const wxPyCallback& other) {
1301     m_func = other.m_func;
1302     Py_INCREF(m_func);
1303 }
1304
1305 wxPyCallback::~wxPyCallback() {
1306     wxPyBeginBlockThreads();
1307     Py_DECREF(m_func);
1308     wxPyEndBlockThreads();
1309 }
1310
1311
1312
1313 // This function is used for all events destined for Python event handlers.
1314 void wxPyCallback::EventThunker(wxEvent& event) {
1315     wxPyCallback*   cb = (wxPyCallback*)event.m_callbackUserData;
1316     PyObject*       func = cb->m_func;
1317     PyObject*       result;
1318     PyObject*       arg;
1319     PyObject*       tuple;
1320     bool            checkSkip = False;
1321
1322     wxPyBeginBlockThreads();
1323     wxString className = event.GetClassInfo()->GetClassName();
1324
1325     // If the event is one of these types then pass the original
1326     // event object instead of the one passed to us.
1327     if ( className == wxT("wxPyEvent") ) {
1328         arg =       ((wxPyEvent*)&event)->GetSelf();
1329         checkSkip = ((wxPyEvent*)&event)->GetCloned();
1330     }
1331     else if ( className == wxT("wxPyCommandEvent") ) {
1332         arg =       ((wxPyCommandEvent*)&event)->GetSelf();
1333         checkSkip = ((wxPyCommandEvent*)&event)->GetCloned();
1334     }
1335     else {
1336         arg = wxPyConstructObject((void*)&event, className);
1337     }
1338
1339     // Call the event handler, passing the event object
1340     tuple = PyTuple_New(1);
1341     PyTuple_SET_ITEM(tuple, 0, arg);  // steals ref to arg
1342     result = PyEval_CallObject(func, tuple);
1343     if ( result ) {
1344         Py_DECREF(result);   // result is ignored, but we still need to decref it
1345         PyErr_Clear();       // Just in case...
1346     } else {
1347         PyErr_Print();
1348     }
1349
1350     if ( checkSkip ) {
1351         // if the event object was one of our special types and
1352         // it had been cloned, then we need to extract the Skipped
1353         // value from the original and set it in the clone.
1354         result = PyObject_CallMethod(arg, "GetSkipped", "");
1355         if ( result ) {
1356             event.Skip(PyInt_AsLong(result));
1357             Py_DECREF(result);
1358         } else {
1359             PyErr_Print();
1360         }
1361     }
1362
1363     Py_DECREF(tuple);
1364     wxPyEndBlockThreads();
1365 }
1366
1367
1368 //----------------------------------------------------------------------
1369
1370 wxPyCallbackHelper::wxPyCallbackHelper(const wxPyCallbackHelper& other) {
1371       m_lastFound = NULL;
1372       m_self = other.m_self;
1373       m_class = other.m_class;
1374       if (m_self) {
1375           Py_INCREF(m_self);
1376           Py_INCREF(m_class);
1377       }
1378 }
1379
1380
1381 void wxPyCallbackHelper::setSelf(PyObject* self, PyObject* klass, int incref) {
1382     m_self = self;
1383     m_class = klass;
1384     m_incRef = incref;
1385     if (incref) {
1386         Py_INCREF(m_self);
1387         Py_INCREF(m_class);
1388     }
1389 }
1390
1391
1392 #if PYTHON_API_VERSION >= 1011
1393
1394 // Prior to Python 2.2 PyMethod_GetClass returned the class object
1395 // in which the method was defined.  Starting with 2.2 it returns
1396 // "class that asked for the method" which seems totally bogus to me
1397 // but apprently it fixes some obscure problem waiting to happen in
1398 // Python.  Since the API was not documented Guido and the gang felt
1399 // safe in changing it.  Needless to say that totally screwed up the
1400 // logic below in wxPyCallbackHelper::findCallback, hence this icky
1401 // code to find the class where the method is actually defined...
1402
1403 static
1404 PyObject* PyFindClassWithAttr(PyObject *klass, PyObject *name)
1405 {
1406     int i, n;
1407
1408     if (PyType_Check(klass)) {      // new style classes
1409         // This code is borrowed/adapted from _PyType_Lookup in typeobject.c
1410         PyTypeObject* type = (PyTypeObject*)klass;
1411         PyObject *mro, *res, *base, *dict;
1412         /* Look in tp_dict of types in MRO */
1413         mro = type->tp_mro;
1414         assert(PyTuple_Check(mro));
1415         n = PyTuple_GET_SIZE(mro);
1416         for (i = 0; i < n; i++) {
1417             base = PyTuple_GET_ITEM(mro, i);
1418             if (PyClass_Check(base))
1419                 dict = ((PyClassObject *)base)->cl_dict;
1420             else {
1421                 assert(PyType_Check(base));
1422                 dict = ((PyTypeObject *)base)->tp_dict;
1423             }
1424             assert(dict && PyDict_Check(dict));
1425             res = PyDict_GetItem(dict, name);
1426             if (res != NULL)
1427                 return base;
1428         }
1429         return NULL;
1430     }
1431
1432     else if (PyClass_Check(klass)) { // old style classes
1433         // This code is borrowed/adapted from class_lookup in classobject.c
1434         PyClassObject* cp = (PyClassObject*)klass;
1435         PyObject *value = PyDict_GetItem(cp->cl_dict, name);
1436         if (value != NULL) {
1437             return (PyObject*)cp;
1438         }
1439         n = PyTuple_Size(cp->cl_bases);
1440         for (i = 0; i < n; i++) {
1441             PyObject* base = PyTuple_GetItem(cp->cl_bases, i);
1442             PyObject *v = PyFindClassWithAttr(base, name);
1443             if (v != NULL)
1444                 return v;
1445         }
1446         return NULL;
1447     }
1448     return NULL;
1449 }
1450 #endif
1451
1452
1453 static
1454 PyObject* PyMethod_GetDefiningClass(PyObject* method, const char* name)
1455 {
1456     PyObject* mgc = PyMethod_GET_CLASS(method);
1457
1458 #if PYTHON_API_VERSION <= 1010    // prior to Python 2.2, the easy way
1459     return mgc;
1460 #else                             // 2.2 and after, the hard way...
1461
1462     PyObject* nameo = PyString_FromString(name);
1463     PyObject* klass = PyFindClassWithAttr(mgc, nameo);
1464     Py_DECREF(nameo);
1465     return klass;
1466 #endif
1467 }
1468
1469
1470
1471 bool wxPyCallbackHelper::findCallback(const char* name) const {
1472     wxPyCallbackHelper* self = (wxPyCallbackHelper*)this; // cast away const
1473     self->m_lastFound = NULL;
1474
1475     // If the object (m_self) has an attibute of the given name...
1476     if (m_self && PyObject_HasAttrString(m_self, (char*)name)) {
1477         PyObject *method, *klass;
1478         method = PyObject_GetAttrString(m_self, (char*)name);
1479
1480         // ...and if that attribute is a method, and if that method's class is
1481         // not from a base class...
1482         if (PyMethod_Check(method) &&
1483             (klass = PyMethod_GetDefiningClass(method, (char*)name)) != NULL &&
1484             ((klass == m_class) || PyObject_IsSubclass(klass, m_class))) {
1485
1486             // ...then we'll save a pointer to the method so callCallback can call it.
1487             self->m_lastFound = method;
1488         }
1489         else {
1490             Py_DECREF(method);
1491         }
1492     }
1493     return m_lastFound != NULL;
1494 }
1495
1496
1497 int wxPyCallbackHelper::callCallback(PyObject* argTuple) const {
1498     PyObject*   result;
1499     int         retval = False;
1500
1501     result = callCallbackObj(argTuple);
1502     if (result) {                       // Assumes an integer return type...
1503         retval = PyInt_AsLong(result);
1504         Py_DECREF(result);
1505         PyErr_Clear();                  // forget about it if it's not...
1506     }
1507     return retval;
1508 }
1509
1510 // Invoke the Python callable object, returning the raw PyObject return
1511 // value.  Caller should DECREF the return value and also manage the GIL.
1512 PyObject* wxPyCallbackHelper::callCallbackObj(PyObject* argTuple) const {
1513     PyObject* result;
1514
1515     // Save a copy of the pointer in case the callback generates another
1516     // callback.  In that case m_lastFound will have a different value when
1517     // it gets back here...
1518     PyObject* method = m_lastFound;
1519
1520     result = PyEval_CallObject(method, argTuple);
1521     Py_DECREF(argTuple);
1522     Py_DECREF(method);
1523     if (!result) {
1524         PyErr_Print();
1525     }
1526     return result;
1527 }
1528
1529
1530 void wxPyCBH_setCallbackInfo(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref) {
1531     cbh.setSelf(self, klass, incref);
1532 }
1533
1534 bool wxPyCBH_findCallback(const wxPyCallbackHelper& cbh, const char* name) {
1535     return cbh.findCallback(name);
1536 }
1537
1538 int  wxPyCBH_callCallback(const wxPyCallbackHelper& cbh, PyObject* argTuple) {
1539     return cbh.callCallback(argTuple);
1540 }
1541
1542 PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTuple) {
1543     return cbh.callCallbackObj(argTuple);
1544 }
1545
1546
1547 void wxPyCBH_delete(wxPyCallbackHelper* cbh) {
1548     if (cbh->m_incRef) {
1549         wxPyBeginBlockThreads();
1550         Py_XDECREF(cbh->m_self);
1551         Py_XDECREF(cbh->m_class);
1552         wxPyEndBlockThreads();
1553     }
1554 }
1555
1556 //---------------------------------------------------------------------------
1557 //---------------------------------------------------------------------------
1558 // These event classes can be derived from in Python and passed through the event
1559 // system without losing anything.  They do this by keeping a reference to
1560 // themselves and some special case handling in wxPyCallback::EventThunker.
1561
1562
1563 wxPyEvtSelfRef::wxPyEvtSelfRef() {
1564     //m_self = Py_None;         // **** We don't do normal ref counting to prevent
1565     //Py_INCREF(m_self);        //      circular loops...
1566     m_cloned = False;
1567 }
1568
1569 wxPyEvtSelfRef::~wxPyEvtSelfRef() {
1570     wxPyBeginBlockThreads();
1571     if (m_cloned)
1572         Py_DECREF(m_self);
1573     wxPyEndBlockThreads();
1574 }
1575
1576 void wxPyEvtSelfRef::SetSelf(PyObject* self, bool clone) {
1577     wxPyBeginBlockThreads();
1578     if (m_cloned)
1579         Py_DECREF(m_self);
1580     m_self = self;
1581     if (clone) {
1582         Py_INCREF(m_self);
1583         m_cloned = True;
1584     }
1585     wxPyEndBlockThreads();
1586 }
1587
1588 PyObject* wxPyEvtSelfRef::GetSelf() const {
1589     Py_INCREF(m_self);
1590     return m_self;
1591 }
1592
1593
1594 IMPLEMENT_ABSTRACT_CLASS(wxPyEvent, wxEvent);
1595 IMPLEMENT_ABSTRACT_CLASS(wxPyCommandEvent, wxCommandEvent);
1596
1597
1598 wxPyEvent::wxPyEvent(int winid, wxEventType commandType)
1599     : wxEvent(winid, commandType) {
1600 }
1601
1602
1603 wxPyEvent::wxPyEvent(const wxPyEvent& evt)
1604     : wxEvent(evt)
1605 {
1606     SetSelf(evt.m_self, True);
1607 }
1608
1609
1610 wxPyEvent::~wxPyEvent() {
1611 }
1612
1613
1614 wxPyCommandEvent::wxPyCommandEvent(wxEventType commandType, int id)
1615     : wxCommandEvent(commandType, id) {
1616 }
1617
1618
1619 wxPyCommandEvent::wxPyCommandEvent(const wxPyCommandEvent& evt)
1620     : wxCommandEvent(evt)
1621 {
1622     SetSelf(evt.m_self, True);
1623 }
1624
1625
1626 wxPyCommandEvent::~wxPyCommandEvent() {
1627 }
1628
1629
1630
1631
1632
1633 //---------------------------------------------------------------------------
1634 //---------------------------------------------------------------------------
1635 // Convert a wxList to a Python List, only works for lists of wxObjects
1636
1637 PyObject* wxPy_ConvertList(wxListBase* listbase) {
1638     wxList*     list = (wxList*)listbase;  // this is probably bad...
1639     PyObject*   pyList;
1640     PyObject*   pyObj;
1641     wxObject*   wxObj;
1642     wxNode*     node = list->GetFirst();
1643
1644     wxPyBeginBlockThreads();
1645     pyList = PyList_New(0);
1646     while (node) {
1647         wxObj = node->GetData();
1648         pyObj = wxPyMake_wxObject(wxObj);
1649         PyList_Append(pyList, pyObj);
1650         node = node->GetNext();
1651     }
1652     wxPyEndBlockThreads();
1653     return pyList;
1654 }
1655
1656 //----------------------------------------------------------------------
1657
1658 long wxPyGetWinHandle(wxWindow* win) {
1659 #ifdef __WXMSW__
1660     return (long)win->GetHandle();
1661 #endif
1662
1663     // Find and return the actual X-Window.
1664 #ifdef __WXGTK__
1665     if (win->m_wxwindow) {
1666 #ifdef __WXGTK20__
1667         return (long) GDK_WINDOW_XWINDOW(GTK_PIZZA(win->m_wxwindow)->bin_window);
1668 #else
1669         GdkWindowPrivate* bwin = (GdkWindowPrivate*)GTK_PIZZA(win->m_wxwindow)->bin_window;
1670         if (bwin) {
1671             return (long)bwin->xwindow;
1672         }
1673 #endif
1674     }
1675 #endif
1676     return 0;
1677 }
1678
1679 //----------------------------------------------------------------------
1680 // Some helper functions for typemaps in my_typemaps.i, so they won't be
1681 // included in every file over and over again...
1682
1683 #if PYTHON_API_VERSION >= 1009
1684     static char* wxStringErrorMsg = "String or Unicode type required";
1685 #else
1686     static char* wxStringErrorMsg = "String type required";
1687 #endif
1688
1689
1690 wxString* wxString_in_helper(PyObject* source) {
1691     wxString* target;
1692 #if PYTHON_API_VERSION >= 1009  // Have Python unicode API
1693     if (!PyString_Check(source) && !PyUnicode_Check(source)) {
1694         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1695         return NULL;
1696     }
1697 #if wxUSE_UNICODE
1698     if (PyUnicode_Check(source)) {
1699         target = new wxString();
1700         size_t len = PyUnicode_GET_SIZE(source);
1701         if (len) {
1702             PyUnicode_AsWideChar((PyUnicodeObject*)source, target->GetWriteBuf(len), len);
1703             target->UngetWriteBuf();
1704         }
1705     } else {
1706         // It is a string, get pointers to it and transform to unicode
1707         char* tmpPtr; int tmpSize;
1708         PyString_AsStringAndSize(source, &tmpPtr, &tmpSize);
1709         target = new wxString(tmpPtr, *wxConvCurrent, tmpSize);
1710     }
1711 #else
1712     char* tmpPtr; int tmpSize;
1713     if (PyString_AsStringAndSize(source, &tmpPtr, &tmpSize) == -1) {
1714         PyErr_SetString(PyExc_TypeError, "Unable to convert string");
1715         return NULL;
1716     }
1717     target = new wxString(tmpPtr, tmpSize);
1718 #endif // wxUSE_UNICODE
1719
1720 #else  // No Python unicode API (1.5.2)
1721     if (!PyString_Check(source)) {
1722         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1723         return NULL;
1724     }
1725     target = new wxString(PyString_AS_STRING(source), PyString_GET_SIZE(source));
1726 #endif
1727     return target;
1728 }
1729
1730
1731 // Similar to above except doesn't use "new" and doesn't set an exception
1732 wxString Py2wxString(PyObject* source)
1733 {
1734     wxString target;
1735     bool     doDecRef = False;
1736
1737 #if PYTHON_API_VERSION >= 1009  // Have Python unicode API
1738     if (!PyString_Check(source) && !PyUnicode_Check(source)) {
1739         // Convert to String if not one already...  (TODO: Unicode too?)
1740         source = PyObject_Str(source);
1741         doDecRef = True;
1742     }
1743
1744 #if wxUSE_UNICODE
1745     if (PyUnicode_Check(source)) {
1746         size_t len = PyUnicode_GET_SIZE(source);
1747         if (len) {
1748             PyUnicode_AsWideChar((PyUnicodeObject*)source, target.GetWriteBuf(len), len);
1749             target.UngetWriteBuf();
1750         }
1751     } else {
1752         // It is a string, get pointers to it and transform to unicode
1753         char* tmpPtr; int tmpSize;
1754         PyString_AsStringAndSize(source, &tmpPtr, &tmpSize);
1755         target = wxString(tmpPtr, *wxConvCurrent, tmpSize);
1756     }
1757 #else
1758     char* tmpPtr; int tmpSize;
1759     PyString_AsStringAndSize(source, &tmpPtr, &tmpSize);
1760     target = wxString(tmpPtr, tmpSize);
1761 #endif // wxUSE_UNICODE
1762
1763 #else  // No Python unicode API (1.5.2)
1764     if (!PyString_Check(source)) {
1765         // Convert to String if not one already...
1766         source = PyObject_Str(source);
1767         doDecRef = True;
1768     }
1769     target = wxString(PyString_AS_STRING(source), PyString_GET_SIZE(source));
1770 #endif
1771
1772     if (doDecRef)
1773         Py_DECREF(source);
1774     return target;
1775 }
1776
1777
1778 // Make either a Python String or Unicode object, depending on build mode
1779 PyObject* wx2PyString(const wxString& src)
1780 {
1781     PyObject* str;
1782 #if wxUSE_UNICODE
1783     str = PyUnicode_FromWideChar(src.c_str(), src.Len());
1784 #else
1785     str = PyString_FromStringAndSize(src.c_str(), src.Len());
1786 #endif
1787     return str;
1788 }
1789
1790
1791 //----------------------------------------------------------------------
1792
1793
1794 byte* byte_LIST_helper(PyObject* source) {
1795     if (!PyList_Check(source)) {
1796         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
1797         return NULL;
1798     }
1799     int count = PyList_Size(source);
1800     byte* temp = new byte[count];
1801     if (! temp) {
1802         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
1803         return NULL;
1804     }
1805     for (int x=0; x<count; x++) {
1806         PyObject* o = PyList_GetItem(source, x);
1807         if (! PyInt_Check(o)) {
1808             PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
1809             return NULL;
1810         }
1811         temp[x] = (byte)PyInt_AsLong(o);
1812     }
1813     return temp;
1814 }
1815
1816
1817 int* int_LIST_helper(PyObject* source) {
1818     if (!PyList_Check(source)) {
1819         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
1820         return NULL;
1821     }
1822     int count = PyList_Size(source);
1823     int* temp = new int[count];
1824     if (! temp) {
1825         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
1826         return NULL;
1827     }
1828     for (int x=0; x<count; x++) {
1829         PyObject* o = PyList_GetItem(source, x);
1830         if (! PyInt_Check(o)) {
1831             PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
1832             return NULL;
1833         }
1834         temp[x] = PyInt_AsLong(o);
1835     }
1836     return temp;
1837 }
1838
1839
1840 long* long_LIST_helper(PyObject* source) {
1841     if (!PyList_Check(source)) {
1842         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
1843         return NULL;
1844     }
1845     int count = PyList_Size(source);
1846     long* temp = new long[count];
1847     if (! temp) {
1848         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
1849         return NULL;
1850     }
1851     for (int x=0; x<count; x++) {
1852         PyObject* o = PyList_GetItem(source, x);
1853         if (! PyInt_Check(o)) {
1854             PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
1855             return NULL;
1856         }
1857         temp[x] = PyInt_AsLong(o);
1858     }
1859     return temp;
1860 }
1861
1862
1863 char** string_LIST_helper(PyObject* source) {
1864     if (!PyList_Check(source)) {
1865         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
1866         return NULL;
1867     }
1868     int count = PyList_Size(source);
1869     char** temp = new char*[count];
1870     if (! temp) {
1871         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
1872         return NULL;
1873     }
1874     for (int x=0; x<count; x++) {
1875         PyObject* o = PyList_GetItem(source, x);
1876         if (! PyString_Check(o)) {
1877             PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1878             return NULL;
1879         }
1880         temp[x] = PyString_AsString(o);
1881     }
1882     return temp;
1883 }
1884
1885 //--------------------------------
1886 // Part of patch from Tim Hochberg
1887 static inline bool wxPointFromObjects(PyObject* o1, PyObject* o2, wxPoint* point) {
1888     if (PyInt_Check(o1) && PyInt_Check(o2)) {
1889         point->x = PyInt_AS_LONG(o1);
1890         point->y = PyInt_AS_LONG(o2);
1891         return True;
1892     }
1893     if (PyFloat_Check(o1) && PyFloat_Check(o2)) {
1894         point->x = (int)PyFloat_AS_DOUBLE(o1);
1895         point->y = (int)PyFloat_AS_DOUBLE(o2);
1896         return True;
1897     }
1898     if (wxPySwigInstance_Check(o1) || wxPySwigInstance_Check(o2)) {  // TODO: Why???
1899         // Disallow instances because they can cause havok
1900         return False;
1901     }
1902     if (PyNumber_Check(o1) && PyNumber_Check(o2)) {
1903         // I believe this excludes instances, so this should be safe without INCREFFing o1 and o2
1904         point->x = PyInt_AsLong(o1);
1905         point->y = PyInt_AsLong(o2);
1906         return True;
1907     }
1908     return False;
1909 }
1910
1911
1912 wxPoint* wxPoint_LIST_helper(PyObject* source, int *count) {
1913     // Putting all of the declarations here allows
1914     // us to put the error handling all in one place.
1915     int x;
1916     wxPoint* temp;
1917     PyObject *o, *o1, *o2;
1918     bool isFast = PyList_Check(source) || PyTuple_Check(source);
1919
1920     if (!PySequence_Check(source)) {
1921         goto error0;
1922     }
1923
1924     // The length of the sequence is returned in count.
1925     *count = PySequence_Length(source);
1926     if (*count < 0) {
1927         goto error0;
1928     }
1929
1930     temp = new wxPoint[*count];
1931     if (!temp) {
1932         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
1933         return NULL;
1934     }
1935     for (x=0; x<*count; x++) {
1936         // Get an item: try fast way first.
1937         if (isFast) {
1938             o = PySequence_Fast_GET_ITEM(source, x);
1939         }
1940         else {
1941             o = PySequence_GetItem(source, x);
1942             if (o == NULL) {
1943                 goto error1;
1944             }
1945         }
1946
1947         // Convert o to wxPoint.
1948         if ((PyTuple_Check(o) && PyTuple_GET_SIZE(o) == 2) ||
1949             (PyList_Check(o) && PyList_GET_SIZE(o) == 2)) {
1950             o1 = PySequence_Fast_GET_ITEM(o, 0);
1951             o2 = PySequence_Fast_GET_ITEM(o, 1);
1952             if (!wxPointFromObjects(o1, o2, &temp[x])) {
1953                 goto error2;
1954             }
1955         }
1956         else if (wxPySwigInstance_Check(o)) {
1957             wxPoint* pt;
1958             if (! wxPyConvertSwigPtr(o, (void **)&pt, wxT("wxPoint"))) {
1959                 goto error2;
1960             }
1961             temp[x] = *pt;
1962         }
1963         else if (PySequence_Check(o) && PySequence_Length(o) == 2) {
1964             o1 = PySequence_GetItem(o, 0);
1965             o2 = PySequence_GetItem(o, 1);
1966             if (!wxPointFromObjects(o1, o2, &temp[x])) {
1967                 goto error3;
1968             }
1969             Py_DECREF(o1);
1970             Py_DECREF(o2);
1971         }
1972         else {
1973             goto error2;
1974         }
1975         // Clean up.
1976         if (!isFast)
1977             Py_DECREF(o);
1978     }
1979     return temp;
1980
1981 error3:
1982     Py_DECREF(o1);
1983     Py_DECREF(o2);
1984 error2:
1985     if (!isFast)
1986         Py_DECREF(o);
1987 error1:
1988     delete [] temp;
1989 error0:
1990     PyErr_SetString(PyExc_TypeError, "Expected a sequence of length-2 sequences or wxPoints.");
1991     return NULL;
1992 }
1993 // end of patch
1994 //------------------------------
1995
1996
1997 wxBitmap** wxBitmap_LIST_helper(PyObject* source) {
1998     if (!PyList_Check(source)) {
1999         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
2000         return NULL;
2001     }
2002     int count = PyList_Size(source);
2003     wxBitmap** temp = new wxBitmap*[count];
2004     if (! temp) {
2005         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
2006         return NULL;
2007     }
2008     for (int x=0; x<count; x++) {
2009         PyObject* o = PyList_GetItem(source, x);
2010         if (wxPySwigInstance_Check(o)) {
2011             wxBitmap*    pt;
2012             if (! wxPyConvertSwigPtr(o, (void **) &pt, wxT("wxBitmap"))) {
2013                 PyErr_SetString(PyExc_TypeError,"Expected wxBitmap.");
2014                 return NULL;
2015             }
2016             temp[x] = pt;
2017         }
2018         else {
2019             PyErr_SetString(PyExc_TypeError, "Expected a list of wxBitmaps.");
2020             return NULL;
2021         }
2022     }
2023     return temp;
2024 }
2025
2026
2027
2028 wxString* wxString_LIST_helper(PyObject* source) {
2029     if (!PyList_Check(source)) {
2030         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
2031         return NULL;
2032     }
2033     int count = PyList_Size(source);
2034     wxString* temp = new wxString[count];
2035     if (! temp) {
2036         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
2037         return NULL;
2038     }
2039     for (int x=0; x<count; x++) {
2040         PyObject* o = PyList_GetItem(source, x);
2041 #if PYTHON_API_VERSION >= 1009
2042         if (! PyString_Check(o) && ! PyUnicode_Check(o)) {
2043             PyErr_SetString(PyExc_TypeError, "Expected a list of string or unicode objects.");
2044             return NULL;
2045         }
2046 #else
2047         if (! PyString_Check(o)) {
2048             PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
2049             return NULL;
2050         }
2051 #endif
2052
2053         wxString* pStr = wxString_in_helper(o);
2054         temp[x] = *pStr;
2055         delete pStr;
2056     }
2057     return temp;
2058 }
2059
2060
2061 wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) {
2062     if (!PyList_Check(source)) {
2063         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
2064         return NULL;
2065     }
2066     int count                = PyList_Size(source);
2067     wxAcceleratorEntry* temp = new wxAcceleratorEntry[count];
2068     if (! temp) {
2069         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
2070         return NULL;
2071     }
2072     for (int x=0; x<count; x++) {
2073         PyObject* o = PyList_GetItem(source, x);
2074         if (wxPySwigInstance_Check(o)) {
2075             wxAcceleratorEntry* ae;
2076             if (! wxPyConvertSwigPtr(o, (void **) &ae, wxT("wxAcceleratorEntry"))) {
2077                 PyErr_SetString(PyExc_TypeError,"Expected wxAcceleratorEntry.");
2078                 return NULL;
2079             }
2080             temp[x] = *ae;
2081         }
2082         else if (PyTuple_Check(o)) {
2083             PyObject* o1 = PyTuple_GetItem(o, 0);
2084             PyObject* o2 = PyTuple_GetItem(o, 1);
2085             PyObject* o3 = PyTuple_GetItem(o, 2);
2086             temp[x].Set(PyInt_AsLong(o1), PyInt_AsLong(o2), PyInt_AsLong(o3));
2087         }
2088         else {
2089             PyErr_SetString(PyExc_TypeError, "Expected a list of 3-tuples or wxAcceleratorEntry objects.");
2090             return NULL;
2091         }
2092     }
2093     return temp;
2094 }
2095
2096
2097 wxPen** wxPen_LIST_helper(PyObject* source) {
2098     if (!PyList_Check(source)) {
2099         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
2100         return NULL;
2101     }
2102     int count = PyList_Size(source);
2103     wxPen** temp = new wxPen*[count];
2104     if (!temp) {
2105         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
2106         return NULL;
2107     }
2108     for (int x=0; x<count; x++) {
2109         PyObject* o = PyList_GetItem(source, x);
2110         if (wxPySwigInstance_Check(o)) {
2111             wxPen*  pt;
2112             if (! wxPyConvertSwigPtr(o, (void **)&pt, wxT("wxPen"))) {
2113                 delete temp;
2114                 PyErr_SetString(PyExc_TypeError,"Expected wxPen.");
2115                 return NULL;
2116             }
2117             temp[x] = pt;
2118         }
2119         else {
2120             delete temp;
2121             PyErr_SetString(PyExc_TypeError, "Expected a list of wxPens.");
2122             return NULL;
2123         }
2124     }
2125     return temp;
2126 }
2127
2128
2129 bool wxPy2int_seq_helper(PyObject* source, int* i1, int* i2) {
2130     bool isFast = PyList_Check(source) || PyTuple_Check(source);
2131     PyObject *o1, *o2;
2132
2133     if (!PySequence_Check(source) || PySequence_Length(source) != 2)
2134         return False;
2135
2136     if (isFast) {
2137         o1 = PySequence_Fast_GET_ITEM(source, 0);
2138         o2 = PySequence_Fast_GET_ITEM(source, 1);
2139     }
2140     else {
2141         o1 = PySequence_GetItem(source, 0);
2142         o2 = PySequence_GetItem(source, 1);
2143     }
2144
2145     *i1 = PyInt_AsLong(o1);
2146     *i2 = PyInt_AsLong(o2);
2147
2148     if (! isFast) {
2149         Py_DECREF(o1);
2150         Py_DECREF(o2);
2151     }
2152     return True;
2153 }
2154
2155
2156 bool wxPy4int_seq_helper(PyObject* source, int* i1, int* i2, int* i3, int* i4) {
2157     bool isFast = PyList_Check(source) || PyTuple_Check(source);
2158     PyObject *o1, *o2, *o3, *o4;
2159
2160     if (!PySequence_Check(source) || PySequence_Length(source) != 4)
2161         return False;
2162
2163     if (isFast) {
2164         o1 = PySequence_Fast_GET_ITEM(source, 0);
2165         o2 = PySequence_Fast_GET_ITEM(source, 1);
2166         o3 = PySequence_Fast_GET_ITEM(source, 2);
2167         o4 = PySequence_Fast_GET_ITEM(source, 3);
2168     }
2169     else {
2170         o1 = PySequence_GetItem(source, 0);
2171         o2 = PySequence_GetItem(source, 1);
2172         o3 = PySequence_GetItem(source, 2);
2173         o4 = PySequence_GetItem(source, 3);
2174     }
2175
2176     *i1 = PyInt_AsLong(o1);
2177     *i2 = PyInt_AsLong(o2);
2178     *i3 = PyInt_AsLong(o3);
2179     *i4 = PyInt_AsLong(o4);
2180
2181     if (! isFast) {
2182         Py_DECREF(o1);
2183         Py_DECREF(o2);
2184         Py_DECREF(o3);
2185         Py_DECREF(o4);
2186     }
2187     return True;
2188 }
2189
2190
2191 //----------------------------------------------------------------------
2192
2193 bool wxPySimple_typecheck(PyObject* source, const wxChar* classname, int seqLen)
2194 {
2195     void* ptr;
2196
2197     if (wxPySwigInstance_Check(source) &&
2198         wxPyConvertSwigPtr(source, (void **)&ptr, classname))
2199         return True;
2200
2201     PyErr_Clear();
2202     if (PySequence_Check(source) && PySequence_Length(source) == seqLen)
2203         return True;
2204
2205     return False;
2206 }
2207
2208 bool wxSize_helper(PyObject* source, wxSize** obj)
2209 {
2210     return wxPyTwoIntItem_helper(source, obj, wxT("wxSize"));
2211 }
2212
2213
2214 bool wxPoint_helper(PyObject* source, wxPoint** obj)
2215 {
2216     return wxPyTwoIntItem_helper(source, obj, wxT("wxPoint"));
2217 }
2218
2219
2220
2221 bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj) {
2222
2223     // If source is an object instance then it may already be the right type
2224     if (wxPySwigInstance_Check(source)) {
2225         wxRealPoint* ptr;
2226         if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxRealPoint")))
2227             goto error;
2228         *obj = ptr;
2229         return True;
2230     }
2231     // otherwise a 2-tuple of floats is expected
2232     else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
2233         PyObject* o1 = PySequence_GetItem(source, 0);
2234         PyObject* o2 = PySequence_GetItem(source, 1);
2235         if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
2236             Py_DECREF(o1);
2237             Py_DECREF(o2);
2238             goto error;
2239         }
2240         **obj = wxRealPoint(PyFloat_AsDouble(o1), PyFloat_AsDouble(o2));
2241         Py_DECREF(o1);
2242         Py_DECREF(o2);
2243         return True;
2244     }
2245
2246  error:
2247     PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of floats or a wxRealPoint object.");
2248     return False;
2249 }
2250
2251
2252
2253 bool wxRect_helper(PyObject* source, wxRect** obj) {
2254
2255     // If source is an object instance then it may already be the right type
2256     if (wxPySwigInstance_Check(source)) {
2257         wxRect* ptr;
2258         if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxRect")))
2259             goto error;
2260         *obj = ptr;
2261         return True;
2262     }
2263     // otherwise a 4-tuple of integers is expected
2264     else if (PySequence_Check(source) && PyObject_Length(source) == 4) {
2265         PyObject* o1 = PySequence_GetItem(source, 0);
2266         PyObject* o2 = PySequence_GetItem(source, 1);
2267         PyObject* o3 = PySequence_GetItem(source, 2);
2268         PyObject* o4 = PySequence_GetItem(source, 3);
2269         if (!PyNumber_Check(o1) || !PyNumber_Check(o2) ||
2270             !PyNumber_Check(o3) || !PyNumber_Check(o4)) {
2271             Py_DECREF(o1);
2272             Py_DECREF(o2);
2273             Py_DECREF(o3);
2274             Py_DECREF(o4);
2275             goto error;
2276         }
2277         **obj = wxRect(PyInt_AsLong(o1), PyInt_AsLong(o2),
2278                        PyInt_AsLong(o3), PyInt_AsLong(o4));
2279         Py_DECREF(o1);
2280         Py_DECREF(o2);
2281         Py_DECREF(o3);
2282         Py_DECREF(o4);
2283         return True;
2284     }
2285
2286  error:
2287     PyErr_SetString(PyExc_TypeError, "Expected a 4-tuple of integers or a wxRect object.");
2288     return False;
2289 }
2290
2291
2292
2293 bool wxColour_helper(PyObject* source, wxColour** obj) {
2294
2295     // If source is an object instance then it may already be the right type
2296     if (wxPySwigInstance_Check(source)) {
2297         wxColour* ptr;
2298         if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxColour")))
2299             goto error;
2300         *obj = ptr;
2301         return True;
2302     }
2303     // otherwise check for a string
2304     else if (PyString_Check(source) || PyUnicode_Check(source)) {
2305         wxString spec = Py2wxString(source);
2306         if (spec.GetChar(0) == '#' && spec.Length() == 7) {  // It's  #RRGGBB
2307             long red, green, blue;
2308             red = green = blue = 0;
2309             spec.Mid(1,2).ToLong(&red,   16);
2310             spec.Mid(3,2).ToLong(&green, 16);
2311             spec.Mid(5,2).ToLong(&blue,  16);
2312
2313             **obj = wxColour(red, green, blue);
2314             return True;
2315         }
2316         else {                                       // it's a colour name
2317             **obj = wxColour(spec);
2318             return True;
2319         }
2320     }
2321     // last chance: 3-tuple of integers is expected
2322     else if (PySequence_Check(source) && PyObject_Length(source) == 3) {
2323         PyObject* o1 = PySequence_GetItem(source, 0);
2324         PyObject* o2 = PySequence_GetItem(source, 1);
2325         PyObject* o3 = PySequence_GetItem(source, 2);
2326         if (!PyNumber_Check(o1) || !PyNumber_Check(o2) || !PyNumber_Check(o3)) {
2327             Py_DECREF(o1);
2328             Py_DECREF(o2);
2329             Py_DECREF(o3);
2330             goto error;
2331         }
2332         **obj = wxColour(PyInt_AsLong(o1), PyInt_AsLong(o2), PyInt_AsLong(o3));
2333         Py_DECREF(o1);
2334         Py_DECREF(o2);
2335         Py_DECREF(o3);
2336         return True;
2337     }
2338
2339  error:
2340     PyErr_SetString(PyExc_TypeError,
2341                     "Expected a wxColour object or a string containing a colour name or '#RRGGBB'.");
2342     return False;
2343 }
2344
2345
2346 bool wxColour_typecheck(PyObject* source) {
2347
2348     if (wxPySimple_typecheck(source, wxT("wxColour"), 3))
2349         return True;
2350
2351     if (PyString_Check(source) || PyUnicode_Check(source))
2352         return True;
2353
2354     return False;
2355 }
2356
2357
2358
2359 bool wxPoint2D_helper(PyObject* source, wxPoint2D** obj) {
2360     // If source is an object instance then it may already be the right type
2361     if (wxPySwigInstance_Check(source)) {
2362         wxPoint2D* ptr;
2363         if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxPoint2D")))
2364             goto error;
2365         *obj = ptr;
2366         return True;
2367     }
2368     // otherwise a length-2 sequence of floats is expected
2369     if (PySequence_Check(source) && PySequence_Length(source) == 2) {
2370         PyObject* o1 = PySequence_GetItem(source, 0);
2371         PyObject* o2 = PySequence_GetItem(source, 1);
2372         // This should really check for floats, not numbers -- but that would break code.
2373         if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
2374             Py_DECREF(o1);
2375             Py_DECREF(o2);
2376             goto error;
2377         }
2378         **obj = wxPoint2D(PyFloat_AsDouble(o1), PyFloat_AsDouble(o2));
2379         Py_DECREF(o1);
2380         Py_DECREF(o2);
2381         return True;
2382     }
2383  error:
2384     PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of floats or a wxPoint2D object.");
2385     return False;
2386 }
2387
2388
2389 //----------------------------------------------------------------------
2390
2391 PyObject* wxArrayString2PyList_helper(const wxArrayString& arr) {
2392
2393     PyObject* list = PyList_New(0);
2394     for (size_t i=0; i < arr.GetCount(); i++) {
2395 #if wxUSE_UNICODE
2396         PyObject* str = PyUnicode_FromWideChar(arr[i].c_str(), arr[i].Len());
2397 #else
2398         PyObject* str = PyString_FromStringAndSize(arr[i].c_str(), arr[i].Len());
2399 #endif
2400         PyList_Append(list, str);
2401         Py_DECREF(str);
2402     }
2403     return list;
2404 }
2405
2406
2407 PyObject* wxArrayInt2PyList_helper(const wxArrayInt& arr) {
2408
2409     PyObject* list = PyList_New(0);
2410     for (size_t i=0; i < arr.GetCount(); i++) {
2411         PyObject* number = PyInt_FromLong(arr[i]);
2412         PyList_Append(list, number);
2413         Py_DECREF(number);
2414     }
2415     return list;
2416 }
2417
2418
2419 //----------------------------------------------------------------------
2420 //----------------------------------------------------------------------
2421
2422
2423
2424