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     // Bail out if there is already windows created.  This means that the
 125     // toolkit has already been initialized, as in embedding wxPython in
 126     // a C++ wxWindows app.
 127     if (wxTopLevelWindows.Number() > 0)
 128         return;
 129
 130 #ifdef __WXMSW__
 131     wxApp::Initialize();
 132 #endif
 133
 134 #ifdef __WXGTK__
 135     PyObject* sysargv = PySys_GetObject("argv");
 136     int argc = PyList_Size(sysargv);
 137     char** argv = new char*[argc+1];
 138     int x;
 139     for(x=0; x<argc; x++)
 140         argv[x] = PyString_AsString(PyList_GetItem(sysargv, x));
 141     argv[argc] = NULL;
 142
 143     gtk_set_locale();
 144     if (!wxOKlibc()) wxConvCurrent = &wxConvLocal;
 145     gtk_init( &argc, &argv );
 146     wxSetDetectableAutoRepeat( TRUE );
 147     delete [] argv;
 148
 149     wxApp::Initialize();     // may return FALSE. Should we check?
 150 #endif
 151
 152 }
 153
 154
 155 #ifdef WXP_WITH_THREAD
 156 PyThreadState*  wxPyEventThreadState = NULL;
 157 #endif
 158 static char* __nullArgv[1] = { 0 };
 159
 160
 161
 162 // Start the user application, user App's OnInit method is a parameter here
 163 PyObject* __wxStart(PyObject* /* self */, PyObject* args)
 164 {
 165     PyObject*   onInitFunc = NULL;
 166     PyObject*   arglist;
 167     PyObject*   result;
 168     long        bResult;
 169
 170 #ifdef WXP_WITH_THREAD
 171     wxPyEventThreadState = PyThreadState_Get();
 172 #endif
 173
 174     if (!PyArg_ParseTuple(args, "O", &onInitFunc))
 175         return NULL;
 176
 177     if (wxTopLevelWindows.Number() > 0) {
 178         PyErr_SetString(PyExc_TypeError, "Only 1 wxApp per process!");
 179         return NULL;
 180     }
 181
 182
 183     // This is the next part of the wxEntry functionality...
 184     wxPythonApp->argc = 0;
 185     wxPythonApp->argv = NULL;
 186     wxPythonApp->OnInitGui();
 187
 188
 189     // Call the Python App's OnInit function
 190     arglist = PyTuple_New(0);
 191     result = PyEval_CallObject(onInitFunc, arglist);
 192     if (!result) {      // an exception was raised.
 193         return NULL;
 194     }
 195
 196     if (! PyInt_Check(result)) {
 197         PyErr_SetString(PyExc_TypeError, "OnInit should return a boolean value");
 198         return NULL;
 199     }
 200     bResult = PyInt_AS_LONG(result);
 201     if (! bResult) {
 202         PyErr_SetString(PyExc_SystemExit, "OnInit returned false, exiting...");
 203         return NULL;
 204     }
 205
 206 #ifdef __WXGTK__
 207     wxTheApp->m_initialized = (wxTopLevelWindows.Number() > 0);
 208 #endif
 209
 210     Py_INCREF(Py_None);
 211     return Py_None;
 212 }
 213
 214
 215
 216
 217
 218 PyObject* wxPython_dict;
 219 PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args)
 220 {
 221
 222     if (!PyArg_ParseTuple(args, "O", &wxPython_dict))
 223         return NULL;
 224
 225     if (!PyDict_Check(wxPython_dict)) {
 226         PyErr_SetString(PyExc_TypeError, "_wxSetDictionary must have dictionary object!");
 227         return NULL;
 228     }
 229 #ifdef __WXMOTIF__
 230 #define wxPlatform "__WXMOTIF__"
 231 #endif
 232 #ifdef __WXQT__
 233 #define wxPlatform "__WXQT__"
 234 #endif
 235 #ifdef __WXGTK__
 236 #define wxPlatform "__WXGTK__"
 237 #endif
 238 #if defined(__WIN32__) || defined(__WXMSW__)
 239 #define wxPlatform "__WXMSW__"
 240 #endif
 241 #ifdef __WXMAC__
 242 #define wxPlatform "__WXMAC__"
 243 #endif
 244
 245     PyDict_SetItemString(wxPython_dict, "wxPlatform", PyString_FromString(wxPlatform));
 246
 247     Py_INCREF(Py_None);
 248     return Py_None;
 249 }
 250
 251
 252 //---------------------------------------------------------------------------
 253
 254 PyObject* wxPyConstructObject(void* ptr, char* className) {
 255     char    buff[64];               // should always be big enough...
 256     char    swigptr[64];
 257
 258     sprintf(buff, "_%s_p", className);
 259     SWIG_MakePtr(swigptr, ptr, buff);
 260
 261     sprintf(buff, "%sPtr", className);
 262     PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
 263     if (! classobj) {
 264         Py_INCREF(Py_None);
 265         return Py_None;
 266     }
 267
 268     PyObject* arg = Py_BuildValue("(s)", swigptr);
 269     PyObject* obj = PyInstance_New(classobj, arg, NULL);
 270     Py_DECREF(arg);
 271
 272     return obj;
 273 }
 274
 275 //---------------------------------------------------------------------------
 276
 277 //static bool _wxPyInEvent = false;
 278 static unsigned int _wxPyNestCount = 0;
 279
 280 HELPEREXPORT bool wxPyRestoreThread() {
 281 //  #ifdef WXP_WITH_THREAD
 282 //      //if (wxPyEventThreadState != PyThreadState_Get()) {
 283 //      if (! _wxPyInEvent) {
 284 //          PyEval_RestoreThread(wxPyEventThreadState);
 285 //          _wxPyInEvent = true;
 286 //          return TRUE;
 287 //      } else
 288 //  #endif
 289 //          return FALSE;
 290
 291     // NOTE: The Python API docs state that if a thread already has the
 292     // interpreter lock and calls PyEval_RestoreThread again a deadlock
 293     // occurs, so I put in the above code as a guard condition since there are
 294     // many possibilites for nested events and callbacks in wxPython.
 295     //
 296     // Unfortunately, it seems like somebody was lying (or I'm not
 297     // understanding...) because each of the nested calls to this function
 298     // MUST call PyEval_RestoreThread or Python pukes with a thread error (at
 299     // least on Win32.)
 300     //
 301     // until I know better, this is how I am doing it instead:
 302 #ifdef WXP_WITH_THREAD
 303     PyEval_RestoreThread(wxPyEventThreadState);
 304     _wxPyNestCount += 1;
 305     if (_wxPyNestCount == 1)
 306         return TRUE;
 307     else
 308 #endif
 309         return FALSE;
 310 }
 311
 312
 313 HELPEREXPORT void wxPySaveThread(bool doSave) {
 314 #ifdef WXP_WITH_THREAD
 315     if (doSave) {
 316         PyEval_SaveThread();
 317         //_wxPyInEvent = false;
 318     }
 319     _wxPyNestCount -= 1;
 320 #endif
 321 }
 322
 323 //---------------------------------------------------------------------------
 324
 325
 326 wxPyCallback::wxPyCallback(PyObject* func) {
 327     m_func = func;
 328     Py_INCREF(m_func);
 329 }
 330
 331 wxPyCallback::~wxPyCallback() {
 332     bool doSave = wxPyRestoreThread();
 333     Py_DECREF(m_func);
 334     wxPySaveThread(doSave);
 335 }
 336
 337
 338
 339
 340 // This function is used for all events destined for Python event handlers.
 341 void wxPyCallback::EventThunker(wxEvent& event) {
 342     wxPyCallback*   cb = (wxPyCallback*)event.m_callbackUserData;
 343     PyObject*       func = cb->m_func;
 344     PyObject*       result;
 345     PyObject*       arg;
 346     PyObject*       tuple;
 347
 348
 349     bool doSave = wxPyRestoreThread();
 350     arg = wxPyConstructObject((void*)&event, event.GetClassInfo()->GetClassName());
 351
 352     tuple = PyTuple_New(1);
 353     PyTuple_SET_ITEM(tuple, 0, arg);
 354     result = PyEval_CallObject(func, tuple);
 355     Py_DECREF(tuple);
 356     if (result) {
 357         Py_DECREF(result);
 358         PyErr_Clear();
 359     } else {
 360         PyErr_Print();
 361     }
 362     wxPySaveThread(doSave);
 363 }
 364
 365
 366 //----------------------------------------------------------------------
 367
 368 wxPyCallbackHelper::wxPyCallbackHelper() {
 369     m_self = NULL;
 370     m_lastFound = NULL;
 371 }
 372
 373
 374 wxPyCallbackHelper::~wxPyCallbackHelper() {
 375     bool doSave = wxPyRestoreThread();
 376     Py_XDECREF(m_self);
 377     wxPySaveThread(doSave);
 378 }
 379
 380 void wxPyCallbackHelper::setSelf(PyObject* self) {
 381     m_self = self;
 382     Py_INCREF(m_self);
 383 }
 384
 385
 386 bool wxPyCallbackHelper::findCallback(const wxString& name) {
 387     m_lastFound = NULL;
 388     if (m_self && PyObject_HasAttrString(m_self, (char*)name.c_str()))
 389         m_lastFound = PyObject_GetAttrString(m_self, (char*)name.c_str());
 390
 391     return m_lastFound != NULL;
 392 }
 393
 394
 395 int wxPyCallbackHelper::callCallback(PyObject* argTuple) {
 396     PyObject*   result;
 397     int         retval = FALSE;
 398
 399     result = callCallbackObj(argTuple);
 400     if (result) {                       // Assumes an integer return type...
 401         retval = PyInt_AsLong(result);
 402         Py_DECREF(result);
 403         PyErr_Clear();                  // forget about it if it's not...
 404     }
 405     return retval;
 406 }
 407
 408 // Invoke the Python callable object, returning the raw PyObject return
 409 // value.  Caller should DECREF the return value and also call PyEval_SaveThread.
 410 PyObject* wxPyCallbackHelper::callCallbackObj(PyObject* argTuple) {
 411     PyObject*   result;
 412
 413     result = PyEval_CallObject(m_lastFound, argTuple);
 414     Py_DECREF(argTuple);
 415     if (!result) {
 416         PyErr_Print();
 417     }
 418     return result;
 419 }
 420
 421
 422
 423 //---------------------------------------------------------------------------
 424 //---------------------------------------------------------------------------
 425
 426
 427 wxPyTimer::wxPyTimer(PyObject* callback) {
 428     func = callback;
 429     Py_INCREF(func);
 430 }
 431
 432 wxPyTimer::~wxPyTimer() {
 433     bool doSave = wxPyRestoreThread();
 434     Py_DECREF(func);
 435     wxPySaveThread(doSave);
 436 }
 437
 438 void wxPyTimer::Notify() {
 439     bool doSave = wxPyRestoreThread();
 440
 441     PyObject*   result;
 442     PyObject*   args = Py_BuildValue("()");
 443
 444     result = PyEval_CallObject(func, args);
 445     Py_DECREF(args);
 446     if (result) {
 447         Py_DECREF(result);
 448         PyErr_Clear();
 449     } else {
 450         PyErr_Print();
 451     }
 452     wxPySaveThread(doSave);
 453 }
 454
 455
 456 //----------------------------------------------------------------------
 457
 458 IMPLEMENT_DYNAMIC_CLASS(wxPyEvent, wxCommandEvent)
 459
 460 wxPyEvent::wxPyEvent(wxEventType commandType, PyObject* userData)
 461     : wxCommandEvent(commandType), m_userData(Py_None)
 462 {
 463     m_userData = userData;
 464     if (m_userData != Py_None) {
 465         Py_INCREF(m_userData);
 466     }
 467 }
 468
 469
 470 wxPyEvent::~wxPyEvent() {
 471     bool doSave = wxPyRestoreThread();
 472     if (m_userData != Py_None) {
 473         Py_DECREF(m_userData);
 474         m_userData = Py_None;
 475     }
 476     wxPySaveThread(doSave);
 477 }
 478
 479
 480 void wxPyEvent::SetUserData(PyObject* userData) {
 481     if (m_userData != Py_None) {
 482         Py_DECREF(m_userData);
 483         m_userData = Py_None;
 484     }
 485     m_userData = userData;
 486     if (m_userData != Py_None) {
 487         Py_INCREF(m_userData);
 488     }
 489 }
 490
 491
 492 PyObject* wxPyEvent::GetUserData() {
 493     return m_userData;
 494 }
 495
 496 //----------------------------------------------------------------------
 497 //---------------------------------------------------------------------------
 498 // Convert a wxList to a Python List
 499
 500 PyObject* wxPy_ConvertList(wxListBase* list, char* className) {
 501     PyObject*   pyList;
 502     PyObject*   pyObj;
 503     wxObject*   wxObj;
 504     wxNode*     node = list->First();
 505
 506     bool doSave = wxPyRestoreThread();
 507     pyList = PyList_New(0);
 508     while (node) {
 509         wxObj = node->Data();
 510         pyObj = wxPyConstructObject(wxObj, className);
 511         PyList_Append(pyList, pyObj);
 512         node = node->Next();
 513     }
 514     wxPySaveThread(doSave);
 515     return pyList;
 516 }
 517
 518 //----------------------------------------------------------------------
 519 // Some helper functions for typemaps in my_typemaps.i, so they won't be
 520 // included in every file...
 521
 522
 523 HELPEREXPORT byte* byte_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     byte* temp = new byte[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] = (byte)PyInt_AsLong(o);
 541     }
 542     return temp;
 543 }
 544
 545
 546 HELPEREXPORT int* int_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     int* temp = new int[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 HELPEREXPORT long* long_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     long* temp = new long[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 (! PyInt_Check(o)) {
 583             PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
 584             return NULL;
 585         }
 586         temp[x] = PyInt_AsLong(o);
 587     }
 588     return temp;
 589 }
 590
 591
 592 HELPEREXPORT char** string_LIST_helper(PyObject* source) {
 593     if (!PyList_Check(source)) {
 594         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 595         return NULL;
 596     }
 597     int count = PyList_Size(source);
 598     char** temp = new char*[count];
 599     if (! temp) {
 600         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 601         return NULL;
 602     }
 603     for (int x=0; x<count; x++) {
 604         PyObject* o = PyList_GetItem(source, x);
 605         if (! PyString_Check(o)) {
 606             PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
 607             return NULL;
 608         }
 609         temp[x] = PyString_AsString(o);
 610     }
 611     return temp;
 612 }
 613
 614
 615
 616 HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source) {
 617     if (!PyList_Check(source)) {
 618         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 619         return NULL;
 620     }
 621     int count = PyList_Size(source);
 622     wxPoint* temp = new wxPoint[count];
 623     if (! temp) {
 624         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 625         return NULL;
 626     }
 627     for (int x=0; x<count; x++) {
 628         PyObject* o = PyList_GetItem(source, x);
 629         if (PyTuple_Check(o)) {
 630             PyObject* o1 = PyTuple_GetItem(o, 0);
 631             PyObject* o2 = PyTuple_GetItem(o, 1);
 632
 633             temp[x].x = PyInt_AsLong(o1);
 634             temp[x].y = PyInt_AsLong(o2);
 635         }
 636         else if (PyInstance_Check(o)) {
 637             wxPoint* pt;
 638             if (SWIG_GetPtrObj(o,(void **) &pt,"_wxPoint_p")) {
 639                 PyErr_SetString(PyExc_TypeError,"Expected _wxPoint_p.");
 640                 return NULL;
 641             }
 642             temp[x] = *pt;
 643         }
 644         else {
 645             PyErr_SetString(PyExc_TypeError, "Expected a list of 2-tuples or wxPoints.");
 646             return NULL;
 647         }
 648     }
 649     return temp;
 650 }
 651
 652
 653 HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source) {
 654     if (!PyList_Check(source)) {
 655         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 656         return NULL;
 657     }
 658     int count = PyList_Size(source);
 659     wxBitmap** temp = new wxBitmap*[count];
 660     if (! temp) {
 661         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 662         return NULL;
 663     }
 664     for (int x=0; x<count; x++) {
 665         PyObject* o = PyList_GetItem(source, x);
 666         if (PyString_Check(o)) {
 667             char*       st = PyString_AsString(o);
 668             wxBitmap*    pt;
 669             if (SWIG_GetPtr(st,(void **) &pt,"_wxBitmap_p")) {
 670                 PyErr_SetString(PyExc_TypeError,"Expected _wxBitmap_p.");
 671                 return NULL;
 672             }
 673             temp[x] = pt;
 674         }
 675         else {
 676             PyErr_SetString(PyExc_TypeError, "Expected a list of wxBitmaps.");
 677             return NULL;
 678         }
 679     }
 680     return temp;
 681 }
 682
 683
 684
 685 HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source) {
 686     if (!PyList_Check(source)) {
 687         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 688         return NULL;
 689     }
 690     int count = PyList_Size(source);
 691     wxString* temp = new wxString[count];
 692     if (! temp) {
 693         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 694         return NULL;
 695     }
 696     for (int x=0; x<count; x++) {
 697         PyObject* o = PyList_GetItem(source, x);
 698         if (! PyString_Check(o)) {
 699             PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
 700             return NULL;
 701         }
 702         temp[x] = PyString_AsString(o);
 703     }
 704     return temp;
 705 }
 706
 707
 708 HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) {
 709     if (!PyList_Check(source)) {
 710         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 711         return NULL;
 712     }
 713     int count                = PyList_Size(source);
 714     wxAcceleratorEntry* temp = new wxAcceleratorEntry[count];
 715     if (! temp) {
 716         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 717         return NULL;
 718     }
 719     for (int x=0; x<count; x++) {
 720         PyObject* o = PyList_GetItem(source, x);
 721         if (PyString_Check(o)) {
 722             char*               st = PyString_AsString(o);
 723             wxAcceleratorEntry* ae;
 724             if (SWIG_GetPtr(st,(void **) &ae,"_wxAcceleratorEntry_p")) {
 725                 PyErr_SetString(PyExc_TypeError,"Expected _wxAcceleratorEntry_p.");
 726                 return NULL;
 727             }
 728             temp[x] = *ae;
 729         }
 730         else if (PyTuple_Check(o)) {
 731             PyObject* o1 = PyTuple_GetItem(o, 0);
 732             PyObject* o2 = PyTuple_GetItem(o, 1);
 733             PyObject* o3 = PyTuple_GetItem(o, 2);
 734
 735             temp[x].m_flags   = PyInt_AsLong(o1);
 736             temp[x].m_keyCode = PyInt_AsLong(o2);
 737             temp[x].m_command = PyInt_AsLong(o3);
 738         }
 739         else {
 740             PyErr_SetString(PyExc_TypeError, "Expected a list of 3-tuples or wxAcceleratorEntry objects.");
 741             return NULL;
 742         }
 743     }
 744     return temp;
 745 }
 746
 747
 748
 749 //----------------------------------------------------------------------
 750
 751 //----------------------------------------------------------------------
 752 //----------------------------------------------------------------------
 753 //----------------------------------------------------------------------
 754
 755
 756