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, 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     arg = wxPyConstructObject((void*)&event, event.GetClassInfo()->GetClassName());
 358
 359     tuple = PyTuple_New(1);
 360     PyTuple_SET_ITEM(tuple, 0, arg);
 361     result = PyEval_CallObject(func, tuple);
 362     Py_DECREF(tuple);
 363     if (result) {
 364         Py_DECREF(result);
 365         PyErr_Clear();
 366     } else {
 367         PyErr_Print();
 368     }
 369     wxPySaveThread(doSave);
 370 }
 371
 372
 373 //----------------------------------------------------------------------
 374
 375 wxPyCallbackHelper::wxPyCallbackHelper() {
 376     m_self = NULL;
 377     m_lastFound = NULL;
 378 }
 379
 380
 381 wxPyCallbackHelper::~wxPyCallbackHelper() {
 382     bool doSave = wxPyRestoreThread();
 383     Py_XDECREF(m_self);
 384     wxPySaveThread(doSave);
 385 }
 386
 387 wxPyCallbackHelper::wxPyCallbackHelper(const wxPyCallbackHelper& other) {
 388       m_lastFound = NULL;
 389       m_self = other.m_self;
 390       if (m_self)
 391           Py_INCREF(m_self);
 392 }
 393
 394
 395 void wxPyCallbackHelper::setSelf(PyObject* self, int incref) {
 396     m_self = self;
 397     if (incref)
 398         Py_INCREF(m_self);
 399 }
 400
 401
 402 bool wxPyCallbackHelper::findCallback(const wxString& name) {
 403     m_lastFound = NULL;
 404     if (m_self && PyObject_HasAttrString(m_self, (char*)name.c_str()))
 405         m_lastFound = PyObject_GetAttrString(m_self, (char*)name.c_str());
 406
 407     return m_lastFound != NULL;
 408 }
 409
 410
 411 int wxPyCallbackHelper::callCallback(PyObject* argTuple) {
 412     PyObject*   result;
 413     int         retval = FALSE;
 414
 415     result = callCallbackObj(argTuple);
 416     if (result) {                       // Assumes an integer return type...
 417         retval = PyInt_AsLong(result);
 418         Py_DECREF(result);
 419         PyErr_Clear();                  // forget about it if it's not...
 420     }
 421     return retval;
 422 }
 423
 424 // Invoke the Python callable object, returning the raw PyObject return
 425 // value.  Caller should DECREF the return value and also call PyEval_SaveThread.
 426 PyObject* wxPyCallbackHelper::callCallbackObj(PyObject* argTuple) {
 427     PyObject*   result;
 428
 429     result = PyEval_CallObject(m_lastFound, argTuple);
 430     Py_DECREF(argTuple);
 431     if (!result) {
 432         PyErr_Print();
 433     }
 434     return result;
 435 }
 436
 437
 438
 439 //---------------------------------------------------------------------------
 440 //---------------------------------------------------------------------------
 441
 442
 443 wxPyTimer::wxPyTimer(PyObject* callback) {
 444     func = callback;
 445     Py_INCREF(func);
 446 }
 447
 448 wxPyTimer::~wxPyTimer() {
 449     bool doSave = wxPyRestoreThread();
 450     Py_DECREF(func);
 451     wxPySaveThread(doSave);
 452 }
 453
 454 void wxPyTimer::Notify() {
 455     bool doSave = wxPyRestoreThread();
 456
 457     PyObject*   result;
 458     PyObject*   args = Py_BuildValue("()");
 459
 460     result = PyEval_CallObject(func, args);
 461     Py_DECREF(args);
 462     if (result) {
 463         Py_DECREF(result);
 464         PyErr_Clear();
 465     } else {
 466         PyErr_Print();
 467     }
 468     wxPySaveThread(doSave);
 469 }
 470
 471
 472
 473 //---------------------------------------------------------------------------
 474 //---------------------------------------------------------------------------
 475 // Convert a wxList to a Python List
 476
 477 PyObject* wxPy_ConvertList(wxListBase* list, char* className) {
 478     PyObject*   pyList;
 479     PyObject*   pyObj;
 480     wxObject*   wxObj;
 481     wxNode*     node = list->First();
 482
 483     bool doSave = wxPyRestoreThread();
 484     pyList = PyList_New(0);
 485     while (node) {
 486         wxObj = node->Data();
 487         pyObj = wxPyConstructObject(wxObj, className);
 488         PyList_Append(pyList, pyObj);
 489         node = node->Next();
 490     }
 491     wxPySaveThread(doSave);
 492     return pyList;
 493 }
 494
 495 //----------------------------------------------------------------------
 496 // Some helper functions for typemaps in my_typemaps.i, so they won't be
 497 // included in every file...
 498
 499
 500 byte* byte_LIST_helper(PyObject* source) {
 501     if (!PyList_Check(source)) {
 502         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 503         return NULL;
 504     }
 505     int count = PyList_Size(source);
 506     byte* temp = new byte[count];
 507     if (! temp) {
 508         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 509         return NULL;
 510     }
 511     for (int x=0; x<count; x++) {
 512         PyObject* o = PyList_GetItem(source, x);
 513         if (! PyInt_Check(o)) {
 514             PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
 515             return NULL;
 516         }
 517         temp[x] = (byte)PyInt_AsLong(o);
 518     }
 519     return temp;
 520 }
 521
 522
 523 int* int_LIST_helper(PyObject* source) {
 524     if (!PyList_Check(source)) {
 525         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 526         return NULL;
 527     }
 528     int count = PyList_Size(source);
 529     int* temp = new int[count];
 530     if (! temp) {
 531         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 532         return NULL;
 533     }
 534     for (int x=0; x<count; x++) {
 535         PyObject* o = PyList_GetItem(source, x);
 536         if (! PyInt_Check(o)) {
 537             PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
 538             return NULL;
 539         }
 540         temp[x] = PyInt_AsLong(o);
 541     }
 542     return temp;
 543 }
 544
 545
 546 long* long_LIST_helper(PyObject* source) {
 547     if (!PyList_Check(source)) {
 548         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 549         return NULL;
 550     }
 551     int count = PyList_Size(source);
 552     long* temp = new long[count];
 553     if (! temp) {
 554         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 555         return NULL;
 556     }
 557     for (int x=0; x<count; x++) {
 558         PyObject* o = PyList_GetItem(source, x);
 559         if (! PyInt_Check(o)) {
 560             PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
 561             return NULL;
 562         }
 563         temp[x] = PyInt_AsLong(o);
 564     }
 565     return temp;
 566 }
 567
 568
 569 char** string_LIST_helper(PyObject* source) {
 570     if (!PyList_Check(source)) {
 571         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 572         return NULL;
 573     }
 574     int count = PyList_Size(source);
 575     char** temp = new char*[count];
 576     if (! temp) {
 577         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 578         return NULL;
 579     }
 580     for (int x=0; x<count; x++) {
 581         PyObject* o = PyList_GetItem(source, x);
 582         if (! PyString_Check(o)) {
 583             PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
 584             return NULL;
 585         }
 586         temp[x] = PyString_AsString(o);
 587     }
 588     return temp;
 589 }
 590
 591
 592
 593 wxPoint* wxPoint_LIST_helper(PyObject* source) {
 594     if (!PyList_Check(source)) {
 595         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 596         return NULL;
 597     }
 598     int count = PyList_Size(source);
 599     wxPoint* temp = new wxPoint[count];
 600     if (! temp) {
 601         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 602         return NULL;
 603     }
 604     for (int x=0; x<count; x++) {
 605         PyObject* o = PyList_GetItem(source, x);
 606         if (PyTuple_Check(o)) {
 607             PyObject* o1 = PyTuple_GetItem(o, 0);
 608             PyObject* o2 = PyTuple_GetItem(o, 1);
 609
 610             temp[x].x = PyInt_AsLong(o1);
 611             temp[x].y = PyInt_AsLong(o2);
 612         }
 613         else if (PyInstance_Check(o)) {
 614             wxPoint* pt;
 615             if (SWIG_GetPtrObj(o,(void **) &pt,"_wxPoint_p")) {
 616                 PyErr_SetString(PyExc_TypeError,"Expected _wxPoint_p.");
 617                 return NULL;
 618             }
 619             temp[x] = *pt;
 620         }
 621         else {
 622             PyErr_SetString(PyExc_TypeError, "Expected a list of 2-tuples or wxPoints.");
 623             return NULL;
 624         }
 625     }
 626     return temp;
 627 }
 628
 629
 630 wxBitmap** wxBitmap_LIST_helper(PyObject* source) {
 631     if (!PyList_Check(source)) {
 632         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 633         return NULL;
 634     }
 635     int count = PyList_Size(source);
 636     wxBitmap** temp = new wxBitmap*[count];
 637     if (! temp) {
 638         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 639         return NULL;
 640     }
 641     for (int x=0; x<count; x++) {
 642         PyObject* o = PyList_GetItem(source, x);
 643         if (PyInstance_Check(o)) {
 644             wxBitmap*    pt;
 645             if (SWIG_GetPtrObj(o, (void **) &pt,"_wxBitmap_p")) {
 646                 PyErr_SetString(PyExc_TypeError,"Expected _wxBitmap_p.");
 647                 return NULL;
 648             }
 649             temp[x] = pt;
 650         }
 651         else {
 652             PyErr_SetString(PyExc_TypeError, "Expected a list of wxBitmaps.");
 653             return NULL;
 654         }
 655     }
 656     return temp;
 657 }
 658
 659
 660
 661 wxString* wxString_LIST_helper(PyObject* source) {
 662     if (!PyList_Check(source)) {
 663         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 664         return NULL;
 665     }
 666     int count = PyList_Size(source);
 667     wxString* temp = new wxString[count];
 668     if (! temp) {
 669         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 670         return NULL;
 671     }
 672     for (int x=0; x<count; x++) {
 673         PyObject* o = PyList_GetItem(source, x);
 674         if (! PyString_Check(o)) {
 675             PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
 676             return NULL;
 677         }
 678         temp[x] = PyString_AsString(o);
 679     }
 680     return temp;
 681 }
 682
 683
 684 wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) {
 685     if (!PyList_Check(source)) {
 686         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 687         return NULL;
 688     }
 689     int count                = PyList_Size(source);
 690     wxAcceleratorEntry* temp = new wxAcceleratorEntry[count];
 691     if (! temp) {
 692         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 693         return NULL;
 694     }
 695     for (int x=0; x<count; x++) {
 696         PyObject* o = PyList_GetItem(source, x);
 697         if (PyInstance_Check(o)) {
 698             wxAcceleratorEntry* ae;
 699             if (SWIG_GetPtrObj(o, (void **) &ae,"_wxAcceleratorEntry_p")) {
 700                 PyErr_SetString(PyExc_TypeError,"Expected _wxAcceleratorEntry_p.");
 701                 return NULL;
 702             }
 703             temp[x] = *ae;
 704         }
 705         else if (PyTuple_Check(o)) {
 706             PyObject* o1 = PyTuple_GetItem(o, 0);
 707             PyObject* o2 = PyTuple_GetItem(o, 1);
 708             PyObject* o3 = PyTuple_GetItem(o, 2);
 709
 710             temp[x].m_flags   = PyInt_AsLong(o1);
 711             temp[x].m_keyCode = PyInt_AsLong(o2);
 712             temp[x].m_command = PyInt_AsLong(o3);
 713         }
 714         else {
 715             PyErr_SetString(PyExc_TypeError, "Expected a list of 3-tuples or wxAcceleratorEntry objects.");
 716             return NULL;
 717         }
 718     }
 719     return temp;
 720 }
 721
 722
 723
 724 //----------------------------------------------------------------------
 725
 726 bool wxSize_helper(PyObject* source, wxSize** obj) {
 727
 728     // If source is an object instance then it may already be the right type
 729     if (PyInstance_Check(source)) {
 730         wxSize* ptr;
 731         if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxSize_p"))
 732             goto error;
 733         *obj = ptr;
 734         return TRUE;
 735     }
 736     // otherwise a 2-tuple of integers is expected
 737     else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
 738         PyObject* o1 = PySequence_GetItem(source, 0);
 739         PyObject* o2 = PySequence_GetItem(source, 1);
 740         **obj = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
 741         return TRUE;
 742     }
 743
 744  error:
 745     PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxSize object.");
 746     return FALSE;
 747 }
 748
 749 bool wxPoint_helper(PyObject* source, wxPoint** obj) {
 750
 751     // If source is an object instance then it may already be the right type
 752     if (PyInstance_Check(source)) {
 753         wxPoint* ptr;
 754         if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxPoint_p"))
 755             goto error;
 756         *obj = ptr;
 757         return TRUE;
 758     }
 759     // otherwise a 2-tuple of integers is expected
 760     else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
 761         PyObject* o1 = PySequence_GetItem(source, 0);
 762         PyObject* o2 = PySequence_GetItem(source, 1);
 763         **obj = wxPoint(PyInt_AsLong(o1), PyInt_AsLong(o2));
 764         return TRUE;
 765     }
 766
 767  error:
 768     PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxPoint object.");
 769     return FALSE;
 770 }
 771
 772
 773
 774 bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj) {
 775
 776     // If source is an object instance then it may already be the right type
 777     if (PyInstance_Check(source)) {
 778         wxRealPoint* ptr;
 779         if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxRealPoint_p"))
 780             goto error;
 781         *obj = ptr;
 782         return TRUE;
 783     }
 784     // otherwise a 2-tuple of floats is expected
 785     else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
 786         PyObject* o1 = PySequence_GetItem(source, 0);
 787         PyObject* o2 = PySequence_GetItem(source, 1);
 788         **obj = wxRealPoint(PyFloat_AsDouble(o1), PyFloat_AsDouble(o2));
 789         return TRUE;
 790     }
 791
 792  error:
 793     PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of floats or a wxRealPoint object.");
 794     return FALSE;
 795 }
 796
 797
 798
 799
 800 bool wxRect_helper(PyObject* source, wxRect** obj) {
 801
 802     // If source is an object instance then it may already be the right type
 803     if (PyInstance_Check(source)) {
 804         wxRect* ptr;
 805         if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxRect_p"))
 806             goto error;
 807         *obj = ptr;
 808         return TRUE;
 809     }
 810     // otherwise a 4-tuple of integers is expected
 811     else if (PySequence_Check(source) && PyObject_Length(source) == 4) {
 812         PyObject* o1 = PySequence_GetItem(source, 0);
 813         PyObject* o2 = PySequence_GetItem(source, 1);
 814         PyObject* o3 = PySequence_GetItem(source, 2);
 815         PyObject* o4 = PySequence_GetItem(source, 3);
 816         **obj = wxRect(PyInt_AsLong(o1), PyInt_AsLong(o2),
 817                      PyInt_AsLong(o3), PyInt_AsLong(o4));
 818         return TRUE;
 819     }
 820
 821  error:
 822     PyErr_SetString(PyExc_TypeError, "Expected a 4-tuple of integers or a wxRect object.");
 823     return FALSE;
 824 }
 825
 826
 827
 828 //----------------------------------------------------------------------
 829 //----------------------------------------------------------------------
 830 //----------------------------------------------------------------------
 831
 832
 833