utils/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:     7/1/97
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1998 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13
  14 #ifdef __WXGTK__
  15 #include <gtk/gtk.h>
  16 #endif
  17
  18 #undef DEBUG
  19 #include <Python.h>
  20 #include "helpers.h"
  21 #ifdef __WXMSW__
  22 #include <wx/msw/private.h>
  23 #undef FindWindow
  24 #undef GetCharWidth
  25 #undef LoadAccelerators
  26 #undef GetClassInfo
  27 #undef GetClassName
  28 #endif
  29 #include <wx/module.h>
  30
  31
  32 //---------------------------------------------------------------------------
  33
  34 //wxHashTable*  wxPyWindows = NULL;
  35
  36
  37 wxPoint     wxPyDefaultPosition;        //wxDefaultPosition);
  38 wxSize      wxPyDefaultSize;            //wxDefaultSize);
  39 wxString    wxPyEmptyStr("");
  40
  41
  42
  43 #ifdef __WXMSW__             // If building for win32...
  44 //----------------------------------------------------------------------
  45 // This gets run when the DLL is loaded.  We just need to save a handle.
  46 //----------------------------------------------------------------------
  47
  48 BOOL WINAPI DllMain(
  49     HINSTANCE   hinstDLL,    // handle to DLL module
  50     DWORD       fdwReason,   // reason for calling function
  51     LPVOID      lpvReserved  // reserved
  52    )
  53 {
  54     wxSetInstance(hinstDLL);
  55     return 1;
  56 }
  57 #endif
  58
  59 //----------------------------------------------------------------------
  60 // Class for implementing the wxp main application shell.
  61 //----------------------------------------------------------------------
  62
  63 wxPyApp *wxPythonApp = NULL;            // Global instance of application object
  64
  65
  66 wxPyApp::wxPyApp() {
  67 //    printf("**** ctor\n");
  68 }
  69
  70 wxPyApp::~wxPyApp() {
  71 //    printf("**** dtor\n");
  72 }
  73
  74
  75 // This one isn't acutally called...  See __wxStart()
  76 bool wxPyApp::OnInit(void) {
  77     return false;
  78 }
  79
  80 int  wxPyApp::MainLoop(void) {
  81     int retval = wxApp::MainLoop();
  82 //#    AfterMainLoop();
  83     wxPythonApp->OnExit();  //#
  84     return retval;
  85 }
  86
  87
  88 //#  void wxPyApp::AfterMainLoop(void) {
  89 //      // more stuff from wxEntry...
  90
  91 //      if (wxPythonApp->GetTopWindow()) {
  92 //          // Forcibly delete the window.
  93 //          if (wxPythonApp->GetTopWindow()->IsKindOf(CLASSINFO(wxFrame)) ||
  94 //              wxPythonApp->GetTopWindow()->IsKindOf(CLASSINFO(wxDialog))) {
  95
  96 //              wxPythonApp->GetTopWindow()->Close(TRUE);
  97 //              wxPythonApp->DeletePendingObjects();
  98 //          }
  99 //          else {
 100 //              delete wxPythonApp->GetTopWindow();
 101 //              wxPythonApp->SetTopWindow(NULL);
 102 //          }
 103 //      }
 104 //  #ifdef __WXGTK__
 105 //        wxPythonApp->DeletePendingObjects();
 106 //  #endif
 107
 108 //      wxPythonApp->OnExit();
 109 //      wxApp::CleanUp();
 110 //  //    delete wxPythonApp;
 111 //  }
 112
 113
 114 //---------------------------------------------------------------------
 115 // a few native methods to add to the module
 116 //----------------------------------------------------------------------
 117
 118
 119 // This is where we pick up the first part of the wxEntry functionality...
 120 // The rest is in __wxStart and  AfterMainLoop.  This function is called when
 121 // wxcmodule is imported.  (Before there is a wxApp object.)
 122 void __wxPreStart()
 123 {
 124 #ifdef WXP_WITH_THREAD
 125     PyEval_InitThreads();
 126 #endif
 127
 128     // Bail out if there is already windows created.  This means that the
 129     // toolkit has already been initialized, as in embedding wxPython in
 130     // a C++ wxWindows app.
 131     if (wxTopLevelWindows.Number() > 0)
 132         return;
 133
 134 #ifdef __WXMSW__
 135     wxApp::Initialize();
 136 #endif
 137
 138 #ifdef __WXGTK__
 139     PyObject* sysargv = PySys_GetObject("argv");
 140     int argc = PyList_Size(sysargv);
 141     char** argv = new char*[argc+1];
 142     int x;
 143     for(x=0; x<argc; x++)
 144         argv[x] = PyString_AsString(PyList_GetItem(sysargv, x));
 145     argv[argc] = NULL;
 146
 147     gtk_set_locale();
 148 #if wxUSE_WCHAR_T
 149     if (!wxOKlibc()) wxConvCurrent = &wxConvLocal;
 150 #else
 151     if (!wxOKlibc()) wxConvCurrent = (wxMBConv*) NULL;
 152 #endif
 153     gtk_init( &argc, &argv );
 154     wxSetDetectableAutoRepeat( TRUE );
 155     delete [] argv;
 156
 157     wxApp::Initialize();     // may return FALSE. Should we check?
 158 #endif
 159
 160 }
 161
 162
 163 #ifdef WXP_WITH_THREAD
 164 PyThreadState*  wxPyEventThreadState = NULL;
 165 #endif
 166 static char* __nullArgv[1] = { 0 };
 167
 168
 169
 170 // Start the user application, user App's OnInit method is a parameter here
 171 PyObject* __wxStart(PyObject* /* self */, PyObject* args)
 172 {
 173     PyObject*   onInitFunc = NULL;
 174     PyObject*   arglist;
 175     PyObject*   result;
 176     long        bResult;
 177
 178 #ifdef WXP_WITH_THREAD
 179     wxPyEventThreadState = PyThreadState_Get();
 180 #endif
 181
 182     if (!PyArg_ParseTuple(args, "O", &onInitFunc))
 183         return NULL;
 184
 185     if (wxTopLevelWindows.Number() > 0) {
 186         PyErr_SetString(PyExc_TypeError, "Only 1 wxApp per process!");
 187         return NULL;
 188     }
 189
 190
 191     // This is the next part of the wxEntry functionality...
 192     wxPythonApp->argc = 0;
 193     wxPythonApp->argv = NULL;
 194     wxPythonApp->OnInitGui();
 195
 196
 197     // Call the Python App's OnInit function
 198     arglist = PyTuple_New(0);
 199     result = PyEval_CallObject(onInitFunc, arglist);
 200     if (!result) {      // an exception was raised.
 201         return NULL;
 202     }
 203
 204     if (! PyInt_Check(result)) {
 205         PyErr_SetString(PyExc_TypeError, "OnInit should return a boolean value");
 206         return NULL;
 207     }
 208     bResult = PyInt_AS_LONG(result);
 209     if (! bResult) {
 210         PyErr_SetString(PyExc_SystemExit, "OnInit returned false, exiting...");
 211         return NULL;
 212     }
 213
 214 #ifdef __WXGTK__
 215     wxTheApp->m_initialized = (wxTopLevelWindows.Number() > 0);
 216 #endif
 217
 218     Py_INCREF(Py_None);
 219     return Py_None;
 220 }
 221
 222
 223
 224
 225
 226 PyObject* wxPython_dict;
 227 PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args)
 228 {
 229
 230     if (!PyArg_ParseTuple(args, "O", &wxPython_dict))
 231         return NULL;
 232
 233     if (!PyDict_Check(wxPython_dict)) {
 234         PyErr_SetString(PyExc_TypeError, "_wxSetDictionary must have dictionary object!");
 235         return NULL;
 236     }
 237 #ifdef __WXMOTIF__
 238 #define wxPlatform "__WXMOTIF__"
 239 #endif
 240 #ifdef __WXQT__
 241 #define wxPlatform "__WXQT__"
 242 #endif
 243 #ifdef __WXGTK__
 244 #define wxPlatform "__WXGTK__"
 245 #endif
 246 #if defined(__WIN32__) || defined(__WXMSW__)
 247 #define wxPlatform "__WXMSW__"
 248 #endif
 249 #ifdef __WXMAC__
 250 #define wxPlatform "__WXMAC__"
 251 #endif
 252
 253     PyDict_SetItemString(wxPython_dict, "wxPlatform", PyString_FromString(wxPlatform));
 254
 255     Py_INCREF(Py_None);
 256     return Py_None;
 257 }
 258
 259
 260 //---------------------------------------------------------------------------
 261
 262 PyObject* wxPyConstructObject(void* ptr, const char* className) {
 263     char    buff[64];               // should always be big enough...
 264     char    swigptr[64];
 265
 266     sprintf(buff, "_%s_p", className);
 267     SWIG_MakePtr(swigptr, ptr, buff);
 268
 269     sprintf(buff, "%sPtr", className);
 270     PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
 271     if (! classobj) {
 272         Py_INCREF(Py_None);
 273         return Py_None;
 274     }
 275
 276     PyObject* arg = Py_BuildValue("(s)", swigptr);
 277     PyObject* obj = PyInstance_New(classobj, arg, NULL);
 278     Py_DECREF(arg);
 279
 280     return obj;
 281 }
 282
 283 //---------------------------------------------------------------------------
 284
 285 static unsigned int _wxPyNestCount = 0;
 286
 287 static PyThreadState* myPyThreadState_Get() {
 288     PyThreadState* current;
 289     current = PyThreadState_Swap(NULL);
 290     PyThreadState_Swap(current);
 291     return current;
 292 }
 293
 294
 295 HELPEREXPORT bool wxPyRestoreThread() {
 296     // NOTE: The Python API docs state that if a thread already has the
 297     // interpreter lock and calls PyEval_RestoreThread again a deadlock
 298     // occurs, so I put in this code as a guard condition since there are
 299     // many possibilites for nested events and callbacks in wxPython.  If
 300     // The current thread is our thread, then we can assume that we
 301     // already have the lock.  (I hope!)
 302     //
 303 #ifdef WXP_WITH_THREAD
 304     _wxPyNestCount += 1;
 305     if (wxPyEventThreadState != myPyThreadState_Get()) {
 306         PyEval_RestoreThread(wxPyEventThreadState);
 307         return TRUE;
 308     }
 309     else
 310 #endif
 311         return FALSE;
 312 }
 313
 314
 315 HELPEREXPORT void wxPySaveThread(bool doSave) {
 316 #ifdef WXP_WITH_THREAD
 317     if (doSave) {
 318         wxPyEventThreadState = PyEval_SaveThread();
 319     }
 320     _wxPyNestCount -= 1;
 321 #endif
 322 }
 323
 324 //---------------------------------------------------------------------------
 325
 326
 327 IMPLEMENT_ABSTRACT_CLASS(wxPyCallback, wxObject);
 328
 329 wxPyCallback::wxPyCallback(PyObject* func) {
 330     m_func = func;
 331     Py_INCREF(m_func);
 332 }
 333
 334 wxPyCallback::wxPyCallback(const wxPyCallback& other) {
 335     m_func = other.m_func;
 336     Py_INCREF(m_func);
 337 }
 338
 339 wxPyCallback::~wxPyCallback() {
 340     bool doSave = wxPyRestoreThread();
 341     Py_DECREF(m_func);
 342     wxPySaveThread(doSave);
 343 }
 344
 345
 346
 347 // This function is used for all events destined for Python event handlers.
 348 void wxPyCallback::EventThunker(wxEvent& event) {
 349     wxPyCallback*   cb = (wxPyCallback*)event.m_callbackUserData;
 350     PyObject*       func = cb->m_func;
 351     PyObject*       result;
 352     PyObject*       arg;
 353     PyObject*       tuple;
 354
 355
 356     bool doSave = wxPyRestoreThread();
 357     wxString className = event.GetClassInfo()->GetClassName();
 358
 359     if (className == "wxPyEvent")
 360         arg = ((wxPyEvent*)&event)->GetSelf();
 361     else if (className == "wxPyCommandEvent")
 362         arg = ((wxPyCommandEvent*)&event)->GetSelf();
 363     else
 364         arg = wxPyConstructObject((void*)&event, className);
 365
 366     tuple = PyTuple_New(1);
 367     PyTuple_SET_ITEM(tuple, 0, arg);
 368     result = PyEval_CallObject(func, tuple);
 369     Py_DECREF(tuple);
 370     if (result) {
 371         Py_DECREF(result);
 372         PyErr_Clear();
 373     } else {
 374         PyErr_Print();
 375     }
 376     wxPySaveThread(doSave);
 377 }
 378
 379
 380 //----------------------------------------------------------------------
 381
 382 wxPyCallbackHelper::wxPyCallbackHelper() {
 383     m_self = NULL;
 384     m_lastFound = NULL;
 385 }
 386
 387
 388 wxPyCallbackHelper::~wxPyCallbackHelper() {
 389     bool doSave = wxPyRestoreThread();
 390     Py_XDECREF(m_self);
 391     wxPySaveThread(doSave);
 392 }
 393
 394 wxPyCallbackHelper::wxPyCallbackHelper(const wxPyCallbackHelper& other) {
 395       m_lastFound = NULL;
 396       m_self = other.m_self;
 397       if (m_self)
 398           Py_INCREF(m_self);
 399 }
 400
 401
 402 void wxPyCallbackHelper::setSelf(PyObject* self, int incref) {
 403     m_self = self;
 404     if (incref)
 405         Py_INCREF(m_self);
 406 }
 407
 408
 409 bool wxPyCallbackHelper::findCallback(const wxString& name) {
 410     m_lastFound = NULL;
 411     if (m_self && PyObject_HasAttrString(m_self, (char*)name.c_str()))
 412         m_lastFound = PyObject_GetAttrString(m_self, (char*)name.c_str());
 413
 414     return m_lastFound != NULL;
 415 }
 416
 417
 418 int wxPyCallbackHelper::callCallback(PyObject* argTuple) {
 419     PyObject*   result;
 420     int         retval = FALSE;
 421
 422     result = callCallbackObj(argTuple);
 423     if (result) {                       // Assumes an integer return type...
 424         retval = PyInt_AsLong(result);
 425         Py_DECREF(result);
 426         PyErr_Clear();                  // forget about it if it's not...
 427     }
 428     return retval;
 429 }
 430
 431 // Invoke the Python callable object, returning the raw PyObject return
 432 // value.  Caller should DECREF the return value and also call PyEval_SaveThread.
 433 PyObject* wxPyCallbackHelper::callCallbackObj(PyObject* argTuple) {
 434     PyObject*   result;
 435
 436     result = PyEval_CallObject(m_lastFound, argTuple);
 437     Py_DECREF(argTuple);
 438     if (!result) {
 439         PyErr_Print();
 440     }
 441     return result;
 442 }
 443
 444
 445
 446 //---------------------------------------------------------------------------
 447 //---------------------------------------------------------------------------
 448 // These classes can be derived from in Python and passed through the event
 449 // system without loosing anything.  They do this by keeping a reference to
 450 // themselves and some special case handling in wxPyCallback::EventThunker.
 451
 452
 453 wxPySelfRef::wxPySelfRef() {
 454     //m_self = Py_None;         // **** We don't do normal ref counting to prevent
 455     //Py_INCREF(m_self);        //      circular loops...
 456     m_cloned = false;
 457 }
 458
 459 wxPySelfRef::~wxPySelfRef() {
 460     bool doSave = wxPyRestoreThread();
 461     if (m_cloned)
 462         Py_DECREF(m_self);
 463     wxPySaveThread(doSave);
 464 }
 465
 466 void wxPySelfRef::SetSelf(PyObject* self, bool clone) {
 467     bool doSave = wxPyRestoreThread();
 468     if (m_cloned)
 469         Py_DECREF(m_self);
 470     m_self = self;
 471     if (clone) {
 472         Py_INCREF(m_self);
 473         m_cloned = TRUE;
 474     }
 475     wxPySaveThread(doSave);
 476 }
 477
 478 PyObject* wxPySelfRef::GetSelf() const {
 479     Py_INCREF(m_self);
 480     return m_self;
 481 }
 482
 483
 484 wxPyEvent::wxPyEvent(int id)
 485     : wxEvent(id) {
 486 }
 487
 488 wxPyEvent::~wxPyEvent() {
 489 }
 490
 491 // This one is so the event object can be Cloned...
 492 void wxPyEvent::CopyObject(wxObject& dest) const {
 493     wxEvent::CopyObject(dest);
 494     ((wxPyEvent*)&dest)->SetSelf(m_self, TRUE);
 495 }
 496
 497
 498 IMPLEMENT_DYNAMIC_CLASS(wxPyEvent, wxEvent);
 499
 500
 501 wxPyCommandEvent::wxPyCommandEvent(wxEventType commandType, int id)
 502     : wxCommandEvent(commandType, id) {
 503 }
 504
 505 wxPyCommandEvent::~wxPyCommandEvent() {
 506 }
 507
 508 void wxPyCommandEvent::CopyObject(wxObject& dest) const {
 509     wxCommandEvent::CopyObject(dest);
 510     ((wxPyCommandEvent*)&dest)->SetSelf(m_self, TRUE);
 511 }
 512
 513
 514 IMPLEMENT_DYNAMIC_CLASS(wxPyCommandEvent, wxCommandEvent);
 515
 516
 517
 518 //---------------------------------------------------------------------------
 519 //---------------------------------------------------------------------------
 520
 521
 522 wxPyTimer::wxPyTimer(PyObject* callback) {
 523     func = callback;
 524     Py_INCREF(func);
 525 }
 526
 527 wxPyTimer::~wxPyTimer() {
 528     bool doSave = wxPyRestoreThread();
 529     Py_DECREF(func);
 530     wxPySaveThread(doSave);
 531 }
 532
 533 void wxPyTimer::Notify() {
 534     bool doSave = wxPyRestoreThread();
 535
 536     PyObject*   result;
 537     PyObject*   args = Py_BuildValue("()");
 538
 539     result = PyEval_CallObject(func, args);
 540     Py_DECREF(args);
 541     if (result) {
 542         Py_DECREF(result);
 543         PyErr_Clear();
 544     } else {
 545         PyErr_Print();
 546     }
 547     wxPySaveThread(doSave);
 548 }
 549
 550
 551
 552 //---------------------------------------------------------------------------
 553 //---------------------------------------------------------------------------
 554 // Convert a wxList to a Python List
 555
 556 PyObject* wxPy_ConvertList(wxListBase* list, const char* className) {
 557     PyObject*   pyList;
 558     PyObject*   pyObj;
 559     wxObject*   wxObj;
 560     wxNode*     node = list->First();
 561
 562     bool doSave = wxPyRestoreThread();
 563     pyList = PyList_New(0);
 564     while (node) {
 565         wxObj = node->Data();
 566         pyObj = wxPyConstructObject(wxObj, className);
 567         PyList_Append(pyList, pyObj);
 568         node = node->Next();
 569     }
 570     wxPySaveThread(doSave);
 571     return pyList;
 572 }
 573
 574 //----------------------------------------------------------------------
 575 // Some helper functions for typemaps in my_typemaps.i, so they won't be
 576 // included in every file...
 577
 578
 579 byte* byte_LIST_helper(PyObject* source) {
 580     if (!PyList_Check(source)) {
 581         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 582         return NULL;
 583     }
 584     int count = PyList_Size(source);
 585     byte* temp = new byte[count];
 586     if (! temp) {
 587         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 588         return NULL;
 589     }
 590     for (int x=0; x<count; x++) {
 591         PyObject* o = PyList_GetItem(source, x);
 592         if (! PyInt_Check(o)) {
 593             PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
 594             return NULL;
 595         }
 596         temp[x] = (byte)PyInt_AsLong(o);
 597     }
 598     return temp;
 599 }
 600
 601
 602 int* int_LIST_helper(PyObject* source) {
 603     if (!PyList_Check(source)) {
 604         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 605         return NULL;
 606     }
 607     int count = PyList_Size(source);
 608     int* temp = new int[count];
 609     if (! temp) {
 610         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 611         return NULL;
 612     }
 613     for (int x=0; x<count; x++) {
 614         PyObject* o = PyList_GetItem(source, x);
 615         if (! PyInt_Check(o)) {
 616             PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
 617             return NULL;
 618         }
 619         temp[x] = PyInt_AsLong(o);
 620     }
 621     return temp;
 622 }
 623
 624
 625 long* long_LIST_helper(PyObject* source) {
 626     if (!PyList_Check(source)) {
 627         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 628         return NULL;
 629     }
 630     int count = PyList_Size(source);
 631     long* temp = new long[count];
 632     if (! temp) {
 633         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 634         return NULL;
 635     }
 636     for (int x=0; x<count; x++) {
 637         PyObject* o = PyList_GetItem(source, x);
 638         if (! PyInt_Check(o)) {
 639             PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
 640             return NULL;
 641         }
 642         temp[x] = PyInt_AsLong(o);
 643     }
 644     return temp;
 645 }
 646
 647
 648 char** string_LIST_helper(PyObject* source) {
 649     if (!PyList_Check(source)) {
 650         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 651         return NULL;
 652     }
 653     int count = PyList_Size(source);
 654     char** temp = new char*[count];
 655     if (! temp) {
 656         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 657         return NULL;
 658     }
 659     for (int x=0; x<count; x++) {
 660         PyObject* o = PyList_GetItem(source, x);
 661         if (! PyString_Check(o)) {
 662             PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
 663             return NULL;
 664         }
 665         temp[x] = PyString_AsString(o);
 666     }
 667     return temp;
 668 }
 669
 670
 671
 672 wxPoint* wxPoint_LIST_helper(PyObject* source) {
 673     if (!PyList_Check(source)) {
 674         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 675         return NULL;
 676     }
 677     int count = PyList_Size(source);
 678     wxPoint* temp = new wxPoint[count];
 679     if (! temp) {
 680         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 681         return NULL;
 682     }
 683     for (int x=0; x<count; x++) {
 684         PyObject* o = PyList_GetItem(source, x);
 685         if (PyTuple_Check(o)) {
 686             PyObject* o1 = PyTuple_GetItem(o, 0);
 687             PyObject* o2 = PyTuple_GetItem(o, 1);
 688
 689             temp[x].x = PyInt_AsLong(o1);
 690             temp[x].y = PyInt_AsLong(o2);
 691         }
 692         else if (PyInstance_Check(o)) {
 693             wxPoint* pt;
 694             if (SWIG_GetPtrObj(o,(void **) &pt,"_wxPoint_p")) {
 695                 PyErr_SetString(PyExc_TypeError,"Expected _wxPoint_p.");
 696                 return NULL;
 697             }
 698             temp[x] = *pt;
 699         }
 700         else {
 701             PyErr_SetString(PyExc_TypeError, "Expected a list of 2-tuples or wxPoints.");
 702             return NULL;
 703         }
 704     }
 705     return temp;
 706 }
 707
 708
 709 wxBitmap** wxBitmap_LIST_helper(PyObject* source) {
 710     if (!PyList_Check(source)) {
 711         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 712         return NULL;
 713     }
 714     int count = PyList_Size(source);
 715     wxBitmap** temp = new wxBitmap*[count];
 716     if (! temp) {
 717         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 718         return NULL;
 719     }
 720     for (int x=0; x<count; x++) {
 721         PyObject* o = PyList_GetItem(source, x);
 722         if (PyInstance_Check(o)) {
 723             wxBitmap*    pt;
 724             if (SWIG_GetPtrObj(o, (void **) &pt,"_wxBitmap_p")) {
 725                 PyErr_SetString(PyExc_TypeError,"Expected _wxBitmap_p.");
 726                 return NULL;
 727             }
 728             temp[x] = pt;
 729         }
 730         else {
 731             PyErr_SetString(PyExc_TypeError, "Expected a list of wxBitmaps.");
 732             return NULL;
 733         }
 734     }
 735     return temp;
 736 }
 737
 738
 739
 740 wxString* wxString_LIST_helper(PyObject* source) {
 741     if (!PyList_Check(source)) {
 742         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 743         return NULL;
 744     }
 745     int count = PyList_Size(source);
 746     wxString* temp = new wxString[count];
 747     if (! temp) {
 748         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 749         return NULL;
 750     }
 751     for (int x=0; x<count; x++) {
 752         PyObject* o = PyList_GetItem(source, x);
 753         if (! PyString_Check(o)) {
 754             PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
 755             return NULL;
 756         }
 757         temp[x] = PyString_AsString(o);
 758     }
 759     return temp;
 760 }
 761
 762
 763 wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) {
 764     if (!PyList_Check(source)) {
 765         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 766         return NULL;
 767     }
 768     int count                = PyList_Size(source);
 769     wxAcceleratorEntry* temp = new wxAcceleratorEntry[count];
 770     if (! temp) {
 771         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 772         return NULL;
 773     }
 774     for (int x=0; x<count; x++) {
 775         PyObject* o = PyList_GetItem(source, x);
 776         if (PyInstance_Check(o)) {
 777             wxAcceleratorEntry* ae;
 778             if (SWIG_GetPtrObj(o, (void **) &ae,"_wxAcceleratorEntry_p")) {
 779                 PyErr_SetString(PyExc_TypeError,"Expected _wxAcceleratorEntry_p.");
 780                 return NULL;
 781             }
 782             temp[x] = *ae;
 783         }
 784         else if (PyTuple_Check(o)) {
 785             PyObject* o1 = PyTuple_GetItem(o, 0);
 786             PyObject* o2 = PyTuple_GetItem(o, 1);
 787             PyObject* o3 = PyTuple_GetItem(o, 2);
 788
 789             temp[x].m_flags   = PyInt_AsLong(o1);
 790             temp[x].m_keyCode = PyInt_AsLong(o2);
 791             temp[x].m_command = PyInt_AsLong(o3);
 792         }
 793         else {
 794             PyErr_SetString(PyExc_TypeError, "Expected a list of 3-tuples or wxAcceleratorEntry objects.");
 795             return NULL;
 796         }
 797     }
 798     return temp;
 799 }
 800
 801
 802
 803 //----------------------------------------------------------------------
 804
 805 bool wxSize_helper(PyObject* source, wxSize** obj) {
 806
 807     // If source is an object instance then it may already be the right type
 808     if (PyInstance_Check(source)) {
 809         wxSize* ptr;
 810         if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxSize_p"))
 811             goto error;
 812         *obj = ptr;
 813         return TRUE;
 814     }
 815     // otherwise a 2-tuple of integers is expected
 816     else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
 817         PyObject* o1 = PySequence_GetItem(source, 0);
 818         PyObject* o2 = PySequence_GetItem(source, 1);
 819         **obj = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
 820         return TRUE;
 821     }
 822
 823  error:
 824     PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxSize object.");
 825     return FALSE;
 826 }
 827
 828 bool wxPoint_helper(PyObject* source, wxPoint** obj) {
 829
 830     // If source is an object instance then it may already be the right type
 831     if (PyInstance_Check(source)) {
 832         wxPoint* ptr;
 833         if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxPoint_p"))
 834             goto error;
 835         *obj = ptr;
 836         return TRUE;
 837     }
 838     // otherwise a 2-tuple of integers is expected
 839     else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
 840         PyObject* o1 = PySequence_GetItem(source, 0);
 841         PyObject* o2 = PySequence_GetItem(source, 1);
 842         **obj = wxPoint(PyInt_AsLong(o1), PyInt_AsLong(o2));
 843         return TRUE;
 844     }
 845
 846  error:
 847     PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxPoint object.");
 848     return FALSE;
 849 }
 850
 851
 852
 853 bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj) {
 854
 855     // If source is an object instance then it may already be the right type
 856     if (PyInstance_Check(source)) {
 857         wxRealPoint* ptr;
 858         if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxRealPoint_p"))
 859             goto error;
 860         *obj = ptr;
 861         return TRUE;
 862     }
 863     // otherwise a 2-tuple of floats is expected
 864     else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
 865         PyObject* o1 = PySequence_GetItem(source, 0);
 866         PyObject* o2 = PySequence_GetItem(source, 1);
 867         **obj = wxRealPoint(PyFloat_AsDouble(o1), PyFloat_AsDouble(o2));
 868         return TRUE;
 869     }
 870
 871  error:
 872     PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of floats or a wxRealPoint object.");
 873     return FALSE;
 874 }
 875
 876
 877
 878
 879 bool wxRect_helper(PyObject* source, wxRect** obj) {
 880
 881     // If source is an object instance then it may already be the right type
 882     if (PyInstance_Check(source)) {
 883         wxRect* ptr;
 884         if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxRect_p"))
 885             goto error;
 886         *obj = ptr;
 887         return TRUE;
 888     }
 889     // otherwise a 4-tuple of integers is expected
 890     else if (PySequence_Check(source) && PyObject_Length(source) == 4) {
 891         PyObject* o1 = PySequence_GetItem(source, 0);
 892         PyObject* o2 = PySequence_GetItem(source, 1);
 893         PyObject* o3 = PySequence_GetItem(source, 2);
 894         PyObject* o4 = PySequence_GetItem(source, 3);
 895         **obj = wxRect(PyInt_AsLong(o1), PyInt_AsLong(o2),
 896                      PyInt_AsLong(o3), PyInt_AsLong(o4));
 897         return TRUE;
 898     }
 899
 900  error:
 901     PyErr_SetString(PyExc_TypeError, "Expected a 4-tuple of integers or a wxRect object.");
 902     return FALSE;
 903 }
 904
 905
 906
 907 //----------------------------------------------------------------------
 908 //----------------------------------------------------------------------
 909 //----------------------------------------------------------------------
 910
 911
 912