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 #undef DEBUG
  14 #include <Python.h>
  15 #include "helpers.h"
  16
  17 #ifdef __WXGTK__
  18 #ifdef USE_GDK_IMLIB
  19 #include "gdk_imlib/gdk_imlib.h"
  20 #endif
  21 #endif
  22
  23 //---------------------------------------------------------------------------
  24
  25 //wxHashTable*  wxPyWindows = NULL;
  26
  27
  28 wxPoint     wxPyDefaultPosition;        //wxDefaultPosition);
  29 wxSize      wxPyDefaultSize;            //wxDefaultSize);
  30 wxString    wxPyEmptyStr("");
  31
  32
  33
  34 //----------------------------------------------------------------------
  35 // Class for implementing the wxp main application shell.
  36 //----------------------------------------------------------------------
  37
  38 wxPyApp *wxPythonApp = NULL;            // Global instance of application object
  39
  40
  41 // This one isn't acutally called...  See __wxStart()
  42 bool wxPyApp::OnInit(void) {
  43     return false;
  44 }
  45
  46 int  wxPyApp::MainLoop(void) {
  47     int retval = wxApp::MainLoop();
  48     AfterMainLoop();
  49     return retval;
  50 }
  51
  52 void wxPyApp::AfterMainLoop(void) {
  53     // more stuff from wxEntry...
  54     if (wxPythonApp->GetTopWindow()) {
  55         // Forcibly delete the window.
  56         if (wxPythonApp->GetTopWindow()->IsKindOf(CLASSINFO(wxFrame)) ||
  57             wxPythonApp->GetTopWindow()->IsKindOf(CLASSINFO(wxDialog))) {
  58
  59             wxPythonApp->GetTopWindow()->Close(TRUE);
  60             wxPythonApp->DeletePendingObjects();
  61         }
  62         else {
  63             delete wxPythonApp->GetTopWindow();
  64             wxPythonApp->SetTopWindow(NULL);
  65         }
  66     }
  67
  68     wxPythonApp->OnExit();
  69 #ifdef __WXMSW__
  70     wxApp::CleanUp();
  71 #endif
  72 #ifdef __WXGTK__
  73     wxApp::CommonCleanUp();
  74 #endif
  75     delete wxPythonApp;
  76 }
  77
  78
  79 //---------------------------------------------------------------------
  80 // a few native methods to add to the module
  81 //----------------------------------------------------------------------
  82
  83
  84 // Start the user application, user App's OnInit method is a parameter here
  85 PyObject* __wxStart(PyObject* /* self */, PyObject* args)
  86 {
  87     PyObject*   onInitFunc = NULL;
  88     PyObject*   arglist;
  89     PyObject*   result;
  90     long        bResult;
  91
  92     if (!PyArg_ParseTuple(args, "O", &onInitFunc))
  93         return NULL;
  94
  95     // This is where we pick up one part of the wxEntry functionality...
  96     // the rest is in AfterMainLoop.
  97 #ifdef __WXMSW__
  98     wxPythonApp->argc = 0;
  99     wxPythonApp->argv = NULL;
 100     wxPythonApp->OnInitGui();
 101 #endif
 102 #ifdef __WXGTK__
 103     wxClassInfo::InitializeClasses();
 104     PyObject* sysargv = PySys_GetObject("argv");
 105     int argc = PyList_Size(sysargv);
 106     char** argv = new char*[argc+1];
 107     int x;
 108     for(x=0; x<argc; x++)
 109         argv[x] = PyString_AsString(PyList_GetItem(sysargv, x));
 110     argv[argc] = NULL;
 111
 112
 113     wxTheApp->argc = argc;
 114     wxTheApp->argv = argv;
 115
 116     gtk_init( &wxTheApp->argc, &wxTheApp->argv );
 117
 118 #ifdef USE_GDK_IMLIB
 119
 120     gdk_imlib_init();
 121
 122     gtk_widget_push_visual(gdk_imlib_get_visual());
 123
 124     gtk_widget_push_colormap(gdk_imlib_get_colormap());
 125
 126 #endif
 127
 128     wxApp::CommonInit();
 129
 130     wxTheApp->OnInitGui();
 131
 132 #endif
 133
 134
 135     // Call the Python App's OnInit function
 136     arglist = PyTuple_New(0);
 137     result = PyEval_CallObject(onInitFunc, arglist);
 138     if (!result) {
 139         PyErr_Print();
 140         exit(1);
 141     }
 142
 143     if (! PyInt_Check(result)) {
 144         PyErr_SetString(PyExc_TypeError, "OnInit should return a boolean value");
 145         return NULL;
 146     }
 147     bResult = PyInt_AS_LONG(result);
 148     if (! bResult) {
 149         wxPythonApp->DeletePendingObjects();
 150         wxPythonApp->OnExit();
 151 #ifdef __WXMSW__
 152         wxApp::CleanUp();
 153 #endif
 154 #ifdef __WXGTK__
 155         wxApp::CommonCleanUp();
 156 #endif
 157         PyErr_SetString(PyExc_SystemExit, "OnInit returned false, exiting...");
 158         return NULL;
 159     }
 160
 161 #ifdef __WXGTK__
 162     wxTheApp->m_initialized = (wxTopLevelWindows.Number() > 0);
 163 #endif
 164
 165     Py_INCREF(Py_None);
 166     return Py_None;
 167 }
 168
 169
 170 //PyObject* __wxMainLoop(PyObject* /* self */, PyObject* /* args */)
 171 //{
 172 //    wxPythonApp->MainLoop();
 173 //    if (wxPythonApp->wx_frame) {
 174 //        wxPythonApp->wx_frame->GetEventHandler()->OnClose();
 175 //        delete wxPythonApp->wx_frame;
 176 //    }
 177 //    wxCleanUp();
 178
 179 //    Py_INCREF(Py_None);
 180 //    return Py_None;
 181 //}
 182
 183
 184 //PyObject* __wxExitMainLoop(PyObject* /* self */, PyObject* /* args */)
 185 //{
 186 //    wxPythonApp->ExitMainLoop();
 187 //    Py_INCREF(Py_None);
 188 //    return Py_None;
 189 //}
 190
 191
 192
 193 //PyObject* __wxAddCallback(PyObject* /* self */, PyObject* args)
 194 //{
 195 //    char*           swigPtr;
 196 //    char*           name;
 197 //    PyObject*       callback;
 198 //    wxWindow*       win;
 199 //    wxPyEvtHandlers* evtHdlr;
 200
 201 //    if (!PyArg_ParseTuple(args, "ssO", &swigPtr, &name, &callback))
 202 //        return NULL;
 203
 204 //    if (!PyCallable_Check(callback)) {
 205 //        PyErr_SetString(PyExc_TypeError, "Expected a callable object.");
 206 //        return NULL;
 207 //    }
 208
 209 //    if (SWIG_GetPtr(swigPtr, (void **)&win, "_wxWindow_p")) {
 210 //        PyErr_SetString(PyExc_TypeError, "Expected class derived from wxWindow.");
 211 //        return NULL;
 212 //    }
 213
 214 //    evtHdlr = (wxPyEvtHandlers*)win->GetClientData();
 215 //    if (! evtHdlr->addCallback(name, callback)) {
 216 //        PyErr_SetString(PyExc_TypeError, "Unknown callback name.");
 217 //        return NULL;
 218 //    }
 219
 220 //    Py_INCREF(Py_None);
 221 //    return Py_None;
 222 //}
 223
 224
 225
 226 //PyObject* __wxSetWinEvtHdlr(PyObject* /* self */, PyObject* args)
 227 //{
 228 //    char*           swigPtr;
 229 //    wxWindow*       win;
 230 //    wxPyEvtHandlers* evtHdlr;
 231
 232 //    if (!PyArg_ParseTuple(args, "s", &swigPtr))
 233 //        return NULL;
 234
 235 //    if (SWIG_GetPtr(swigPtr, (void **)&win, "_wxWindow_p")) {
 236 //        PyErr_SetString(PyExc_TypeError, "Expected class derived from wxWindow.");
 237 //        return NULL;
 238 //    }
 239
 240 //    evtHdlr = new wxPyEvtHandlers;
 241 //    win->SetClientData((char*)evtHdlr);
 242
 243 //    Py_INCREF(Py_None);
 244 //    return Py_None;
 245 //}
 246
 247
 248
 249 //PyObject* __wxDelWinEvtHdlr(PyObject* /* self */, PyObject* args)
 250 //{
 251 //    char*               swigPtr;
 252 //    wxWindow*           win;
 253 //    wxPyEvtHandlers*    evtHdlr;
 254
 255 //    if (!PyArg_ParseTuple(args, "s", &swigPtr))
 256 //        return NULL;
 257
 258 //    if (SWIG_GetPtr(swigPtr, (void **)&win, "_wxWindow_p")) {
 259 //        PyErr_SetString(PyExc_TypeError, "Expected class derived from wxWindow.");
 260 //        return NULL;
 261 //    }
 262
 263 //    evtHdlr = (wxPyEvtHandlers*)win->GetClientData();
 264 //    printf("__wxDelWinEvtHdlr: %p\n", evtHdlr);
 265 //    delete evtHdlr;
 266
 267 //    Py_INCREF(Py_None);
 268 //    return Py_None;
 269 //}
 270
 271
 272
 273 PyObject* wxPython_dict;
 274 PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args)
 275 {
 276
 277     if (!PyArg_ParseTuple(args, "O", &wxPython_dict))
 278         return NULL;
 279
 280     if (!PyDict_Check(wxPython_dict)) {
 281         PyErr_SetString(PyExc_TypeError, "_wxSetDictionary must have dictionary object!");
 282         return NULL;
 283     }
 284 #ifdef __WXMOTIF__
 285 #define wxPlatform "__MOTIF__"
 286 #endif
 287 #ifdef __WXGTK__
 288 #define wxPlatform "__GTK__"
 289 #endif
 290 #if defined(__WIN32__) || defined(__WXMSW__)
 291 #define wxPlatform "__WXMSW__"
 292 #endif
 293 #ifdef __WXMAC__
 294 #define wxPlatform "__MAC__"
 295 #endif
 296
 297     PyDict_SetItemString(wxPython_dict, "wxPlatform", PyString_FromString(wxPlatform));
 298
 299     Py_INCREF(Py_None);
 300     return Py_None;
 301 }
 302
 303
 304 //---------------------------------------------------------------------------
 305
 306
 307 static
 308 PyObject* wxPyConstructObject(void* ptr, char* className)
 309 {
 310     char    buff[64];               // should be big enough...
 311     char    swigptr[64];
 312
 313     sprintf(buff, "_%s_p", className);
 314     SWIG_MakePtr(swigptr, ptr, buff);
 315
 316     sprintf(buff, "%sPtr", className);
 317     PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
 318     if (! classobj) {
 319         Py_INCREF(Py_None);
 320         return Py_None;
 321     }
 322
 323     PyObject* arg = Py_BuildValue("(s)", swigptr);
 324     PyObject* obj = PyInstance_New(classobj, arg, NULL);
 325     Py_DECREF(arg);
 326
 327     return obj;
 328 }
 329
 330
 331 // This function is used for all events destined for Python event handlers.
 332 void wxPyCallback::EventThunker(wxEvent& event) {
 333     wxPyCallback*   cb = (wxPyCallback*)event.m_callbackUserData;
 334     PyObject*       func = cb->m_func;
 335     PyObject*       result;
 336     PyObject*       arg;
 337     PyObject*       tuple;
 338
 339     arg = wxPyConstructObject((void*)&event, event.GetClassInfo()->GetClassName());
 340
 341     tuple = PyTuple_New(1);
 342     PyTuple_SET_ITEM(tuple, 0, arg);
 343     result = PyEval_CallObject(func, tuple);
 344     Py_DECREF(arg);
 345     Py_DECREF(tuple);
 346     if (result) {
 347         Py_DECREF(result);
 348         PyErr_Clear();
 349     } else {
 350         PyErr_Print();
 351     }
 352 }
 353
 354
 355 //---------------------------------------------------------------------------
 356
 357 wxPyMenu::wxPyMenu(const wxString& title, PyObject* _func)
 358     : wxMenu(title, (wxFunction)(func ? MenuCallback : NULL)), func(0) {
 359
 360     if (_func) {
 361         func = _func;
 362         Py_INCREF(func);
 363     }
 364 }
 365
 366 wxPyMenu::~wxPyMenu() {
 367     if (func)
 368         Py_DECREF(func);
 369 }
 370
 371
 372 void wxPyMenu::MenuCallback(wxMenu& menu, wxCommandEvent& evt) {
 373     PyObject* evtobj  = wxPyConstructObject((void*)&evt, "wxCommandEvent");
 374     PyObject* menuobj = wxPyConstructObject((void*)&menu, "wxMenu");
 375     if (PyErr_Occurred()) {
 376         // bail out if a problem
 377         PyErr_Print();
 378         return;
 379     }
 380     // Now call the callback...
 381     PyObject* func = ((wxPyMenu*)&menu)->func;
 382     PyObject* args = Py_BuildValue("(OO)", menuobj, evtobj);
 383     PyObject* res  = PyEval_CallObject(func, args);
 384     Py_DECREF(args);
 385     Py_DECREF(res);
 386     Py_DECREF(evtobj);
 387     Py_DECREF(menuobj);
 388 }
 389
 390
 391 //---------------------------------------------------------------------------
 392
 393 wxPyTimer::wxPyTimer(PyObject* callback) {
 394     func = callback;
 395     Py_INCREF(func);
 396 }
 397
 398 wxPyTimer::~wxPyTimer() {
 399     Py_DECREF(func);
 400 }
 401
 402 void wxPyTimer::Notify() {
 403     PyObject*   result;
 404     PyObject*   args = Py_BuildValue("()");
 405
 406     result = PyEval_CallObject(func, args);
 407     Py_DECREF(args);
 408     if (result) {
 409         Py_DECREF(result);
 410         PyErr_Clear();
 411     } else {
 412         PyErr_Print();
 413     }
 414 }
 415
 416
 417
 418 //----------------------------------------------------------------------
 419 // wxPyEvtHandlers class
 420 //----------------------------------------------------------------------
 421
 422 //wxPyEvtHandlers::wxPyEvtHandlers()
 423 //    :   pyOnActivate(0),
 424 //        pyOnChar(0),
 425 //        pyOnCharHook(0),
 426 //        pyOnClose(0),
 427 //        pyOnCommand(0),
 428 //        pyOnDropFiles(0),
 429 //        pyOnDefaultAction(0),
 430 //        pyOnEvent(0),
 431 //        pyOnInitMenuPopup(0),
 432 //        pyOnKillFocus(0),
 433 //        pyOnMenuCommand(0),
 434 //        pyOnMenuSelect(0),
 435 //        pyOnMove(0),
 436 //        pyOnPaint(0),
 437 //        pyOnScroll(0),
 438 //        pyOnSetFocus(0),
 439 //        pyOnSize(0),
 440 //        pyOnSysColourChange(0),
 441 //        pyOnLeftClick(0),
 442 //        pyOnMouseEnter(0),
 443 //        pyOnRightClick(0),
 444 //        pyOnDoubleClickSash(0),
 445 //        pyOnUnsplit(0)
 446 //{
 447 //}
 448
 449
 450 //wxPyEvtHandlers::~wxPyEvtHandlers()
 451 //{
 452 //    Py_XDECREF(pyOnActivate);
 453 //    Py_XDECREF(pyOnChar);
 454 //    Py_XDECREF(pyOnCharHook);
 455 //    Py_XDECREF(pyOnClose);
 456 //    Py_XDECREF(pyOnCommand);
 457 //    Py_XDECREF(pyOnDropFiles);
 458 //    Py_XDECREF(pyOnDefaultAction);
 459 //    Py_XDECREF(pyOnEvent);
 460 //    Py_XDECREF(pyOnInitMenuPopup);
 461 //    Py_XDECREF(pyOnKillFocus);
 462 //    Py_XDECREF(pyOnMenuCommand);
 463 //    Py_XDECREF(pyOnMenuSelect);
 464 //    Py_XDECREF(pyOnMove);
 465 //    Py_XDECREF(pyOnPaint);
 466 //    Py_XDECREF(pyOnScroll);
 467 //    Py_XDECREF(pyOnSetFocus);
 468 //    Py_XDECREF(pyOnSize);
 469 //    Py_XDECREF(pyOnSysColourChange);
 470 //    Py_XDECREF(pyOnLeftClick);
 471 //    Py_XDECREF(pyOnMouseEnter);
 472 //    Py_XDECREF(pyOnRightClick);
 473 //    Py_XDECREF(pyOnDoubleClickSash);
 474 //    Py_XDECREF(pyOnUnsplit);
 475
 476 //    wxNode* node = cleanupList.First();
 477 //    while (node) {
 478 //        delete (wxPyEvtHandlers*)node->Data();
 479 //        delete node;
 480 //        node = cleanupList.First();
 481 //    }
 482
 483 //    node = decrefList.First();
 484 //    while (node) {
 485 //        PyObject* obj = (PyObject*)node->Data();
 486 //        Py_DECREF(obj);
 487 //        delete node;
 488 //        node = decrefList.First();
 489 //    }
 490 ////    printf("~wxPyEvtHandlers: %p\n", this);
 491 //}
 492
 493 ////----------------------------------------------------------------------
 494
 495 //Bool wxPyEvtHandlers::addCallback(char* name, PyObject* callback)
 496 //{
 497 //    Py_INCREF(callback);
 498
 499 //    if (strcmp(name, "OnActivate") == 0) {
 500 //        pyOnActivate = callback;
 501 //        return TRUE;
 502 //    }
 503 //    if (strcmp(name, "OnChar") == 0) {
 504 //        pyOnChar = callback;
 505 //        return TRUE;
 506 //    }
 507 //    if (strcmp(name, "OnCharHook") == 0) {
 508 //        pyOnCharHook = callback;
 509 //        return TRUE;
 510 //    }
 511 //    if (strcmp(name, "OnClose") == 0) {
 512 //        pyOnClose = callback;
 513 //        return TRUE;
 514 //    }
 515 //    if (strcmp(name, "OnCommand") == 0) {
 516 //        pyOnCommand = callback;
 517 //        return TRUE;
 518 //    }
 519 //    if (strcmp(name, "OnDropFiles") == 0) {
 520 //        pyOnDropFiles = callback;
 521 //        return TRUE;
 522 //    }
 523 //    if (strcmp(name, "OnDefaultAction") == 0) {
 524 //        pyOnDefaultAction = callback;
 525 //        return TRUE;
 526 //    }
 527 //    if (strcmp(name, "OnEvent") == 0) {
 528 //        pyOnEvent = callback;
 529 //        return TRUE;
 530 //    }
 531 //    if (strcmp(name, "OnInitMenuPopup") == 0) {
 532 //        pyOnInitMenuPopup = callback;
 533 //        return TRUE;
 534 //    }
 535 //    if (strcmp(name, "OnKillFocus") == 0) {
 536 //        pyOnKillFocus = callback;
 537 //        return TRUE;
 538 //    }
 539 //    if (strcmp(name, "OnMenuCommand") == 0) {
 540 //        pyOnMenuCommand = callback;
 541 //        return TRUE;
 542 //    }
 543 //    if (strcmp(name, "OnMenuSelect") == 0) {
 544 //        pyOnMenuSelect = callback;
 545 //        return TRUE;
 546 //    }
 547 //    if (strcmp(name, "OnMove") == 0) {
 548 //        pyOnMove = callback;
 549 //        return TRUE;
 550 //    }
 551 //    if (strcmp(name, "OnPaint") == 0) {
 552 //        pyOnPaint = callback;
 553 //        return TRUE;
 554 //    }
 555 //    if (strcmp(name, "OnScroll") == 0) {
 556 //        pyOnScroll = callback;
 557 //        return TRUE;
 558 //    }
 559 //    if (strcmp(name, "OnSetFocus") == 0) {
 560 //        pyOnSetFocus = callback;
 561 //        return TRUE;
 562 //    }
 563 //    if (strcmp(name, "OnSize") == 0) {
 564 //        pyOnSize = callback;
 565 //        return TRUE;
 566 //    }
 567 //    if (strcmp(name, "OnSysColourChange") == 0) {
 568 //        pyOnSysColourChange = callback;
 569 //        return TRUE;
 570 //    }
 571 //    if (strcmp(name, "OnLeftClick") == 0) {
 572 //        pyOnLeftClick = callback;
 573 //        return TRUE;
 574 //    }
 575 //    if (strcmp(name, "OnMouseEnter") == 0) {
 576 //        pyOnMouseEnter = callback;
 577 //        return TRUE;
 578 //    }
 579 //    if (strcmp(name, "OnRightClick") == 0) {
 580 //        pyOnRightClick = callback;
 581 //        return TRUE;
 582 //    }
 583 //    if (strcmp(name, "OnDoubleClickSash") == 0) {
 584 //        pyOnDoubleClickSash = callback;
 585 //        return TRUE;
 586 //    }
 587 //    if (strcmp(name, "OnUnsplit") == 0) {
 588 //        pyOnUnsplit = callback;
 589 //        return TRUE;
 590 //    }
 591
 592 //    // If we get here, there was no match.
 593 //    Py_DECREF(callback);
 594 //    return FALSE;
 595 //}
 596
 597
 598 ////----------------------------------------------------------------------
 599 //// Helpers to assist in calling the python callable objects
 600 ////----------------------------------------------------------------------
 601
 602 //PyObject* wxPyEvtHandlers::constructObject(void* ptr, char* className)
 603 //{
 604 //    char    buff[64];               // should be big enough...
 605 //    char    swigptr[64];
 606
 607 //    sprintf(buff, "_%s_p", className);
 608 //    SWIG_MakePtr(swigptr, ptr, buff);
 609
 610 //    sprintf(buff, "%sPtr", className);
 611 //    PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
 612 //    PyObject* arg = Py_BuildValue("(s)", swigptr);
 613 //    PyObject* obj = PyInstance_New(classobj, arg, NULL);
 614 //    Py_DECREF(arg);
 615
 616 //    return obj;
 617 //}
 618
 619
 620
 621 //int wxPyEvtHandlers::callFunc(PyObject* func, PyObject* arglist)
 622 //{
 623 //    PyObject*   result;
 624 //    int         retval = FALSE;
 625
 626 //    result = PyEval_CallObject(func, arglist);
 627 //    Py_DECREF(arglist);
 628 //    if (result) {                       // Assumes an integer return type...
 629 //        retval = PyInt_AsLong(result);
 630 //        Py_DECREF(result);
 631 //        PyErr_Clear();                  // forget about it if it's not...
 632 //    } else {
 633 //        PyErr_Print();
 634 //    }
 635 //    return retval;
 636 //}
 637
 638 ////---------------------------------------------------------------------------
 639 //// Methods and helpers of the wxPy* classes
 640 ////---------------------------------------------------------------------------
 641
 642 //IMP_OnActivate(wxFrame, wxPyFrame);
 643 //IMP_OnCharHook(wxFrame, wxPyFrame);
 644 //IMP_OnClose(wxFrame, wxPyFrame);
 645 //IMP_OnMenuCommand(wxFrame, wxPyFrame);
 646 //IMP_OnMenuSelect(wxFrame, wxPyFrame);
 647 //IMP_OnSize(wxFrame, wxPyFrame);
 648 //IMP_OnDropFiles(wxFrame, wxPyFrame);
 649
 650 //IMP_OnChar(wxCanvas, wxPyCanvas);
 651 //IMP_OnEvent(wxCanvas, wxPyCanvas);
 652 //IMP_OnPaint(wxCanvas, wxPyCanvas);
 653 //IMP_OnScroll(wxCanvas, wxPyCanvas);
 654 //IMP_OnDropFiles(wxCanvas, wxPyCanvas);
 655
 656 //IMP_OnChar(wxPanel, wxPyPanel);
 657 //IMP_OnEvent(wxPanel, wxPyPanel);
 658 //IMP_OnPaint(wxPanel, wxPyPanel);
 659 //IMP_OnScroll(wxPanel, wxPyPanel);
 660 //IMP_OnCommand(wxPanel, wxPyPanel);
 661 //IMP_OnDefaultAction(wxPanel, wxPyPanel);
 662 //IMP_OnDropFiles(wxPanel, wxPyPanel);
 663
 664 //IMP_OnChar(wxTextWindow, wxPyTextWindow);
 665 //IMP_OnDropFiles(wxTextWindow, wxPyTextWindow);
 666
 667 //IMP_OnCharHook(wxDialogBox, wxPyDialogBox);
 668 //IMP_OnClose(wxDialogBox, wxPyDialogBox);
 669 //IMP_OnSize(wxDialogBox, wxPyDialogBox);
 670 //IMP_OnDropFiles(wxDialogBox, wxPyDialogBox);
 671 //IMP_OnChar(wxDialogBox, wxPyDialogBox);
 672 //IMP_OnEvent(wxDialogBox, wxPyDialogBox);
 673 //IMP_OnPaint(wxDialogBox, wxPyDialogBox);
 674 //IMP_OnScroll(wxDialogBox, wxPyDialogBox);
 675 //IMP_OnCommand(wxDialogBox, wxPyDialogBox);
 676 //IMP_OnDefaultAction(wxDialogBox, wxPyDialogBox);
 677
 678 //IMP_OnChar(wxToolBar, wxPyToolBar);
 679 //IMP_OnEvent(wxToolBar, wxPyToolBar);
 680 //IMP_OnPaint(wxToolBar, wxPyToolBar);
 681 //IMP_OnScroll(wxToolBar, wxPyToolBar);
 682 //IMP_OnCommand(wxToolBar, wxPyToolBar);
 683 //IMP_OnDefaultAction(wxToolBar, wxPyToolBar);
 684 //IMP_OnDropFiles(wxToolBar, wxPyToolBar);
 685 //IMP_OnMouseEnter(wxToolBar, wxPyToolBar);
 686 //IMP_OnRightClick(wxToolBar, wxPyToolBar);
 687
 688 //IMP_OnChar(wxButtonBar, wxPyButtonBar);
 689 //IMP_OnEvent(wxButtonBar, wxPyButtonBar);
 690 //IMP_OnPaint(wxButtonBar, wxPyButtonBar);
 691 //IMP_OnScroll(wxButtonBar, wxPyButtonBar);
 692 //IMP_OnCommand(wxButtonBar, wxPyButtonBar);
 693 //IMP_OnDefaultAction(wxButtonBar, wxPyButtonBar);
 694 //IMP_OnDropFiles(wxButtonBar, wxPyButtonBar);
 695 //IMP_OnMouseEnter(wxButtonBar, wxPyButtonBar);
 696 //IMP_OnRightClick(wxButtonBar, wxPyButtonBar);
 697
 698 //IMP_OnDoubleClickSash(wxSplitterWindow, wxPySplitterWindow);
 699 //IMP_OnUnsplit(wxSplitterWindow, wxPySplitterWindow);
 700
 701
 702
 703 //Bool wxPyToolBar::OnLeftClick(int a, int b) {
 704 //    wxPyEvtHandlers* peh=(wxPyEvtHandlers*)GetClientData();
 705 //    if (peh->pyOnLeftClick)
 706 //        return peh->callFunc(peh->pyOnLeftClick, Py_BuildValue("(ii)",a,b));
 707 //    else {
 708 //        // If there is no Python callback, redirect the request to
 709 //        // the OnMenuCommand of the parent frame.
 710 //        wxFrame* frame = (wxFrame*)GetParent();
 711 //        frame->OnMenuCommand(a);
 712 //        return TRUE;
 713 //    }
 714 ////    else
 715 ////        return wxToolBar::OnLeftClick(a,b);
 716 //}
 717 //Bool wxPyToolBar::baseclass_OnLeftClick(int a, int b) {
 718 //    return wxToolBar::OnLeftClick(a,b);
 719 //}
 720
 721
 722 //Bool wxPyButtonBar::OnLeftClick(int a, int b) {
 723 //    wxPyEvtHandlers* peh=(wxPyEvtHandlers*)GetClientData();
 724 //    if (peh->pyOnLeftClick)
 725 //        return peh->callFunc(peh->pyOnLeftClick, Py_BuildValue("(ii)",a,b));
 726 //    else {
 727 //        // If there is no Python callback, redirect the request to
 728 //        // the OnMenuCommand of the parent frame.
 729 //        wxFrame* frame = (wxFrame*)GetParent();
 730 //        frame->OnMenuCommand(a);
 731 //        return TRUE;
 732 //    }
 733 //}
 734 //Bool wxPyButtonBar::baseclass_OnLeftClick(int a, int b) {
 735 //    return wxButtonBar::OnLeftClick(a,b);
 736 //}
 737
 738
 739
 740 //wxPyMenu::wxPyMenu(PyObject* _func)
 741 //    : wxMenu(NULL, (wxFunction)(func ? MenuCallback : NULL)), func(0) {
 742
 743 //    if (_func) {
 744 //        func = _func;
 745 //        Py_INCREF(func);
 746 //    }
 747 //}
 748
 749 //wxPyMenu::~wxPyMenu() {
 750 //    if (func)
 751 //        Py_DECREF(func);
 752 //}
 753
 754
 755 //void wxPyMenu::MenuCallback(wxWindow& win, wxCommandEvent& evt) {
 756 //    wxPyEvtHandlers* peh= new wxPyEvtHandlers;  // Used for the helper methods
 757 //    PyObject* evtobj = peh->constructObject((void*)&evt, "wxCommandEvent");
 758 //    PyObject* winobj = peh->constructObject((void*)&win, "wxWindow");
 759 //    if (PyErr_Occurred()) {
 760 //        // bail out if a problem
 761 //        PyErr_Print();
 762 //        delete peh;
 763 //        return;
 764 //    }
 765 //    // Now call the callback...
 766 //    PyObject* func = ((wxPyMenu*)&win)->func;
 767 //    peh->callFunc(func, Py_BuildValue("(OO)", winobj, evtobj));
 768 //    Py_DECREF(evtobj);
 769 //    Py_DECREF(winobj);
 770 //    delete peh;
 771 //}
 772
 773
 774
 775 //wxPyTimer::wxPyTimer(PyObject* callback) {
 776 //    func = callback;
 777 //    Py_INCREF(func);
 778 //}
 779
 780 //wxPyTimer::~wxPyTimer() {
 781 //    Py_DECREF(func);
 782 //}
 783
 784 //void wxPyTimer::Notify() {
 785 //    wxPyEvtHandlers* peh= new wxPyEvtHandlers;  // just for the helper methods
 786 //    peh->callFunc(func, Py_BuildValue("()"));
 787 //    delete peh;
 788 //}
 789
 790 //----------------------------------------------------------------------
 791 //----------------------------------------------------------------------
 792 // Some helper functions for typemaps in my_typemaps.i, so they won't be
 793 // imcluded in every file...
 794
 795
 796 int* int_LIST_helper(PyObject* source) {
 797     if (!PyList_Check(source)) {
 798         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 799         return NULL;
 800     }
 801     int count = PyList_Size(source);
 802     int* temp = new int[count];
 803     if (! temp) {
 804         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 805         return NULL;
 806     }
 807     for (int x=0; x<count; x++) {
 808         PyObject* o = PyList_GetItem(source, x);
 809         if (! PyInt_Check(o)) {
 810             PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
 811             return NULL;
 812         }
 813         temp[x] = PyInt_AsLong(o);
 814     }
 815     return temp;
 816 }
 817
 818
 819 long* long_LIST_helper(PyObject* source) {
 820     if (!PyList_Check(source)) {
 821         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 822         return NULL;
 823     }
 824     int count = PyList_Size(source);
 825     long* temp = new long[count];
 826     if (! temp) {
 827         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 828         return NULL;
 829     }
 830     for (int x=0; x<count; x++) {
 831         PyObject* o = PyList_GetItem(source, x);
 832         if (! PyInt_Check(o)) {
 833             PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
 834             return NULL;
 835         }
 836         temp[x] = PyInt_AsLong(o);
 837     }
 838     return temp;
 839 }
 840
 841
 842 char** string_LIST_helper(PyObject* source) {
 843     if (!PyList_Check(source)) {
 844         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 845         return NULL;
 846     }
 847     int count = PyList_Size(source);
 848     char** temp = new char*[count];
 849     if (! temp) {
 850         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 851         return NULL;
 852     }
 853     for (int x=0; x<count; x++) {
 854         PyObject* o = PyList_GetItem(source, x);
 855         if (! PyString_Check(o)) {
 856             PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
 857             return NULL;
 858         }
 859         temp[x] = PyString_AsString(o);
 860     }
 861     return temp;
 862 }
 863
 864
 865
 866 wxPoint* wxPoint_LIST_helper(PyObject* source) {
 867     if (!PyList_Check(source)) {
 868         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 869         return NULL;
 870     }
 871     int count = PyList_Size(source);
 872     wxPoint* temp = new wxPoint[count];
 873     if (! temp) {
 874         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 875         return NULL;
 876     }
 877     for (int x=0; x<count; x++) {
 878         PyObject* o = PyList_GetItem(source, x);
 879         if (PyString_Check(o)) {
 880             char*       st = PyString_AsString(o);
 881             wxPoint*    pt;
 882             if (SWIG_GetPtr(st,(void **) &pt,"_wxPoint_p")) {
 883                 PyErr_SetString(PyExc_TypeError,"Expected _wxPoint_p.");
 884                 return NULL;
 885             }
 886             temp[x] = *pt;
 887         }
 888         else if (PyTuple_Check(o)) {
 889             PyObject* o1 = PyTuple_GetItem(o, 0);
 890             PyObject* o2 = PyTuple_GetItem(o, 1);
 891
 892             temp[x].x = PyInt_AsLong(o1);
 893             temp[x].y = PyInt_AsLong(o2);
 894         }
 895         else {
 896             PyErr_SetString(PyExc_TypeError, "Expected a list of 2-tuples or wxPoints.");
 897             return NULL;
 898         }
 899     }
 900     return temp;
 901 }
 902
 903
 904 wxBitmap** wxBitmap_LIST_helper(PyObject* source) {
 905     if (!PyList_Check(source)) {
 906         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 907         return NULL;
 908     }
 909     int count = PyList_Size(source);
 910     wxBitmap** temp = new wxBitmap*[count];
 911     if (! temp) {
 912         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 913         return NULL;
 914     }
 915     for (int x=0; x<count; x++) {
 916         PyObject* o = PyList_GetItem(source, x);
 917         if (PyString_Check(o)) {
 918             char*       st = PyString_AsString(o);
 919             wxBitmap*    pt;
 920             if (SWIG_GetPtr(st,(void **) &pt,"_wxBitmap_p")) {
 921                 PyErr_SetString(PyExc_TypeError,"Expected _wxBitmap_p.");
 922                 return NULL;
 923             }
 924             temp[x] = pt;
 925         }
 926         else {
 927             PyErr_SetString(PyExc_TypeError, "Expected a list of wxBitmaps.");
 928             return NULL;
 929         }
 930     }
 931     return temp;
 932 }
 933
 934
 935
 936 wxString* wxString_LIST_helper(PyObject* source) {
 937     if (!PyList_Check(source)) {
 938         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 939         return NULL;
 940     }
 941     int count = PyList_Size(source);
 942     wxString* temp = new wxString[count];
 943     if (! temp) {
 944         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 945         return NULL;
 946     }
 947     for (int x=0; x<count; x++) {
 948         PyObject* o = PyList_GetItem(source, x);
 949         if (! PyString_Check(o)) {
 950             PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
 951             return NULL;
 952         }
 953         temp[x] = PyString_AsString(o);
 954     }
 955     return temp;
 956 }
 957
 958
 959 #ifdef __WXMSW__
 960 wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) {
 961     if (!PyList_Check(source)) {
 962         PyErr_SetString(PyExc_TypeError, "Expected a list object.");
 963         return NULL;
 964     }
 965     int count                = PyList_Size(source);
 966     wxAcceleratorEntry* temp = new wxAcceleratorEntry[count];
 967     if (! temp) {
 968         PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
 969         return NULL;
 970     }
 971     for (int x=0; x<count; x++) {
 972         PyObject* o = PyList_GetItem(source, x);
 973         if (PyString_Check(o)) {
 974             char*               st = PyString_AsString(o);
 975             wxAcceleratorEntry* ae;
 976             if (SWIG_GetPtr(st,(void **) &ae,"_wxAcceleratorEntry_p")) {
 977                 PyErr_SetString(PyExc_TypeError,"Expected _wxAcceleratorEntry_p.");
 978                 return NULL;
 979             }
 980             temp[x] = *ae;
 981         }
 982         else if (PyTuple_Check(o)) {
 983             PyObject* o1 = PyTuple_GetItem(o, 0);
 984             PyObject* o2 = PyTuple_GetItem(o, 1);
 985             PyObject* o3 = PyTuple_GetItem(o, 2);
 986
 987             temp[x].m_flags   = PyInt_AsLong(o1);
 988             temp[x].m_keyCode = PyInt_AsLong(o2);
 989             temp[x].m_command = PyInt_AsLong(o3);
 990         }
 991         else {
 992             PyErr_SetString(PyExc_TypeError, "Expected a list of 3-tuples or wxAcceleratorEntry objects.");
 993             return NULL;
 994         }
 995     }
 996     return temp;
 997 }
 998
 999 #endif
1000
1001 //----------------------------------------------------------------------
1002 // A WinMain for when wxWindows and Python are linked together in a single
1003 // application, instead of as a dynamic module
1004
1005
1006 //#if !defined(WIN_PYD) && defined(WIN32)
1007
1008 //extern "C" int Py_Main(int argc, char** argv);
1009
1010 //int APIENTRY WinMain(HANDLE hInstance, HANDLE hPrevInstance, LPSTR m_lpCmdLine,
1011 //                    int nCmdShow )
1012 //{
1013
1014 //    wxpCreateApp();
1015
1016 //        // Initialize wxWindows, but don't start the main loop
1017 //    wxEntry(hInstance, hPrevInstance, m_lpCmdLine, nCmdShow, FALSE);
1018
1019 //    Py_Initialize();
1020 //    PyObject *argvList = PyList_New(0);
1021
1022 //    char*   stderrfilename = "wxpstderr.log";
1023 //    int     pyargc = 1;
1024 //    char*   script = NULL;
1025 //    int     argc = wxPythonApp->argc;
1026 //    char**  argv = wxPythonApp->argv;
1027
1028 //    for (int i = 1; i < argc; i++) {
1029 //        if (strncmp(argv[i], "wxpstderr=", 10) == 0)
1030 //            stderrfilename = argv[i]+10;
1031 //        else {
1032 //            PyList_Append(argvList, PyString_FromString(argv[i]));
1033 //            if (!script)
1034 //                script = argv[i];
1035 //            pyargc++;
1036 //        }
1037 //    }
1038
1039 //    PySys_SetObject("argv", argvList);
1040
1041 //#if 1
1042 //    char buf[256];
1043 ////    //PyRun_SimpleString("import sys; sys.stdout=open('wxpstdout.log','w')");
1044 //    sprintf(buf, "import sys; sys.stdout=sys.stderr=open('%s','w')", stderrfilename);
1045 //    PyRun_SimpleString(buf);
1046 //#endif
1047
1048 //    initwxPythonc();
1049
1050 //    if (script) {
1051 //        FILE *fp = fopen(script, "r");
1052 //        if (fp) {
1053 //            PyRun_SimpleFile(fp, script);// This returns after wxpApp constructor
1054 //            fclose(fp);
1055 //        }
1056 //        else {
1057 //            char msg[256];
1058 //            sprintf(msg, "Cannot open %s", script);
1059 //            wxMessageBox(msg);
1060 //        }
1061 //    }
1062 //    else
1063 //        PyRun_SimpleString("import wxpide");
1064
1065 //    return 0;
1066 //}
1067
1068
1069 //#endif
1070
1071 //----------------------------------------------------------------------
1072
1073 /////////////////////////////////////////////////////////////////////////////
1074 //
1075 // $Log$
1076 // Revision 1.6  1998/08/18 21:54:12  RD
1077 // ifdef out some wxGTK specific code
1078 //
1079 // Revision 1.5  1998/08/18 19:48:17  RD
1080 // more wxGTK compatibility things.
1081 //
1082 // It builds now but there are serious runtime problems...
1083 //
1084 // Revision 1.4  1998/08/16 04:31:06  RD
1085 // More wxGTK work.
1086 //
1087 // Revision 1.3  1998/08/15 07:36:36  RD
1088 // - Moved the header in the .i files out of the code that gets put into
1089 // the .cpp files.  It caused CVS conflicts because of the RCS ID being
1090 // different each time.
1091 //
1092 // - A few minor fixes.
1093 //
1094 // Revision 1.2  1998/08/14 23:36:36  RD
1095 // Beginings of wxGTK compatibility
1096 //
1097 // Revision 1.1  1998/08/09 08:25:51  RD
1098 // Initial version
1099 //
1100 //