projects / wxWidgets.git / blob
? search:


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