]> git.saurik.com Git - wxWidgets.git/blob - utils/wxPython/src/helpers.cpp
projects / wxWidgets.git / blob
? search:


508ad137c515890b3c6457aa8a771e1547ac3828
[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 #ifdef __WXMSW__
344 wxPyMenu::wxPyMenu(const wxString& title, PyObject* _func)
345 : wxMenu(title, (wxFunction)(func ? MenuCallback : NULL)), func(0) {
346
347 if (_func) {
348 func = _func;
349 Py_INCREF(func);
350 }
351 }
352
353 wxPyMenu::~wxPyMenu() {
354 if (func)
355 Py_DECREF(func);
356 }
357
358
359 void wxPyMenu::MenuCallback(wxMenu& menu, wxCommandEvent& evt) {
360 PyObject* evtobj = wxPyConstructObject((void*)&evt, "wxCommandEvent");
361 PyObject* menuobj = wxPyConstructObject((void*)&menu, "wxMenu");
362 if (PyErr_Occurred()) {
363 // bail out if a problem
364 PyErr_Print();
365 return;
366 }
367 // Now call the callback...
368 PyObject* func = ((wxPyMenu*)&menu)->func;
369 PyObject* args = Py_BuildValue("(OO)", menuobj, evtobj);
370 PyObject* res = PyEval_CallObject(func, args);
371 Py_DECREF(args);
372 Py_DECREF(res);
373 Py_DECREF(evtobj);
374 Py_DECREF(menuobj);
375 }
376 #endif
377
378 //---------------------------------------------------------------------------
379
380 wxPyTimer::wxPyTimer(PyObject* callback) {
381 func = callback;
382 Py_INCREF(func);
383 }
384
385 wxPyTimer::~wxPyTimer() {
386 Py_DECREF(func);
387 }
388
389 void wxPyTimer::Notify() {
390 PyObject* result;
391 PyObject* args = Py_BuildValue("()");
392
393 result = PyEval_CallObject(func, args);
394 Py_DECREF(args);
395 if (result) {
396 Py_DECREF(result);
397 PyErr_Clear();
398 } else {
399 PyErr_Print();
400 }
401 }
402
403
404
405 //----------------------------------------------------------------------
406 // wxPyEvtHandlers class
407 //----------------------------------------------------------------------
408
409 //wxPyEvtHandlers::wxPyEvtHandlers()
410 // : pyOnActivate(0),
411 // pyOnChar(0),
412 // pyOnCharHook(0),
413 // pyOnClose(0),
414 // pyOnCommand(0),
415 // pyOnDropFiles(0),
416 // pyOnDefaultAction(0),
417 // pyOnEvent(0),
418 // pyOnInitMenuPopup(0),
419 // pyOnKillFocus(0),
420 // pyOnMenuCommand(0),
421 // pyOnMenuSelect(0),
422 // pyOnMove(0),
423 // pyOnPaint(0),
424 // pyOnScroll(0),
425 // pyOnSetFocus(0),
426 // pyOnSize(0),
427 // pyOnSysColourChange(0),
428 // pyOnLeftClick(0),
429 // pyOnMouseEnter(0),
430 // pyOnRightClick(0),
431 // pyOnDoubleClickSash(0),
432 // pyOnUnsplit(0)
433 //{
434 //}
435
436
437 //wxPyEvtHandlers::~wxPyEvtHandlers()
438 //{
439 // Py_XDECREF(pyOnActivate);
440 // Py_XDECREF(pyOnChar);
441 // Py_XDECREF(pyOnCharHook);
442 // Py_XDECREF(pyOnClose);
443 // Py_XDECREF(pyOnCommand);
444 // Py_XDECREF(pyOnDropFiles);
445 // Py_XDECREF(pyOnDefaultAction);
446 // Py_XDECREF(pyOnEvent);
447 // Py_XDECREF(pyOnInitMenuPopup);
448 // Py_XDECREF(pyOnKillFocus);
449 // Py_XDECREF(pyOnMenuCommand);
450 // Py_XDECREF(pyOnMenuSelect);
451 // Py_XDECREF(pyOnMove);
452 // Py_XDECREF(pyOnPaint);
453 // Py_XDECREF(pyOnScroll);
454 // Py_XDECREF(pyOnSetFocus);
455 // Py_XDECREF(pyOnSize);
456 // Py_XDECREF(pyOnSysColourChange);
457 // Py_XDECREF(pyOnLeftClick);
458 // Py_XDECREF(pyOnMouseEnter);
459 // Py_XDECREF(pyOnRightClick);
460 // Py_XDECREF(pyOnDoubleClickSash);
461 // Py_XDECREF(pyOnUnsplit);
462
463 // wxNode* node = cleanupList.First();
464 // while (node) {
465 // delete (wxPyEvtHandlers*)node->Data();
466 // delete node;
467 // node = cleanupList.First();
468 // }
469
470 // node = decrefList.First();
471 // while (node) {
472 // PyObject* obj = (PyObject*)node->Data();
473 // Py_DECREF(obj);
474 // delete node;
475 // node = decrefList.First();
476 // }
477 //// printf("~wxPyEvtHandlers: %p\n", this);
478 //}
479
480 ////----------------------------------------------------------------------
481
482 //Bool wxPyEvtHandlers::addCallback(char* name, PyObject* callback)
483 //{
484 // Py_INCREF(callback);
485
486 // if (strcmp(name, "OnActivate") == 0) {
487 // pyOnActivate = callback;
488 // return TRUE;
489 // }
490 // if (strcmp(name, "OnChar") == 0) {
491 // pyOnChar = callback;
492 // return TRUE;
493 // }
494 // if (strcmp(name, "OnCharHook") == 0) {
495 // pyOnCharHook = callback;
496 // return TRUE;
497 // }
498 // if (strcmp(name, "OnClose") == 0) {
499 // pyOnClose = callback;
500 // return TRUE;
501 // }
502 // if (strcmp(name, "OnCommand") == 0) {
503 // pyOnCommand = callback;
504 // return TRUE;
505 // }
506 // if (strcmp(name, "OnDropFiles") == 0) {
507 // pyOnDropFiles = callback;
508 // return TRUE;
509 // }
510 // if (strcmp(name, "OnDefaultAction") == 0) {
511 // pyOnDefaultAction = callback;
512 // return TRUE;
513 // }
514 // if (strcmp(name, "OnEvent") == 0) {
515 // pyOnEvent = callback;
516 // return TRUE;
517 // }
518 // if (strcmp(name, "OnInitMenuPopup") == 0) {
519 // pyOnInitMenuPopup = callback;
520 // return TRUE;
521 // }
522 // if (strcmp(name, "OnKillFocus") == 0) {
523 // pyOnKillFocus = callback;
524 // return TRUE;
525 // }
526 // if (strcmp(name, "OnMenuCommand") == 0) {
527 // pyOnMenuCommand = callback;
528 // return TRUE;
529 // }
530 // if (strcmp(name, "OnMenuSelect") == 0) {
531 // pyOnMenuSelect = callback;
532 // return TRUE;
533 // }
534 // if (strcmp(name, "OnMove") == 0) {
535 // pyOnMove = callback;
536 // return TRUE;
537 // }
538 // if (strcmp(name, "OnPaint") == 0) {
539 // pyOnPaint = callback;
540 // return TRUE;
541 // }
542 // if (strcmp(name, "OnScroll") == 0) {
543 // pyOnScroll = callback;
544 // return TRUE;
545 // }
546 // if (strcmp(name, "OnSetFocus") == 0) {
547 // pyOnSetFocus = callback;
548 // return TRUE;
549 // }
550 // if (strcmp(name, "OnSize") == 0) {
551 // pyOnSize = callback;
552 // return TRUE;
553 // }
554 // if (strcmp(name, "OnSysColourChange") == 0) {
555 // pyOnSysColourChange = callback;
556 // return TRUE;
557 // }
558 // if (strcmp(name, "OnLeftClick") == 0) {
559 // pyOnLeftClick = callback;
560 // return TRUE;
561 // }
562 // if (strcmp(name, "OnMouseEnter") == 0) {
563 // pyOnMouseEnter = callback;
564 // return TRUE;
565 // }
566 // if (strcmp(name, "OnRightClick") == 0) {
567 // pyOnRightClick = callback;
568 // return TRUE;
569 // }
570 // if (strcmp(name, "OnDoubleClickSash") == 0) {
571 // pyOnDoubleClickSash = callback;
572 // return TRUE;
573 // }
574 // if (strcmp(name, "OnUnsplit") == 0) {
575 // pyOnUnsplit = callback;
576 // return TRUE;
577 // }
578
579 // // If we get here, there was no match.
580 // Py_DECREF(callback);
581 // return FALSE;
582 //}
583
584
585 ////----------------------------------------------------------------------
586 //// Helpers to assist in calling the python callable objects
587 ////----------------------------------------------------------------------
588
589 //PyObject* wxPyEvtHandlers::constructObject(void* ptr, char* className)
590 //{
591 // char buff[64]; // should be big enough...
592 // char swigptr[64];
593
594 // sprintf(buff, "_%s_p", className);
595 // SWIG_MakePtr(swigptr, ptr, buff);
596
597 // sprintf(buff, "%sPtr", className);
598 // PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
599 // PyObject* arg = Py_BuildValue("(s)", swigptr);
600 // PyObject* obj = PyInstance_New(classobj, arg, NULL);
601 // Py_DECREF(arg);
602
603 // return obj;
604 //}
605
606
607
608 //int wxPyEvtHandlers::callFunc(PyObject* func, PyObject* arglist)
609 //{
610 // PyObject* result;
611 // int retval = FALSE;
612
613 // result = PyEval_CallObject(func, arglist);
614 // Py_DECREF(arglist);
615 // if (result) { // Assumes an integer return type...
616 // retval = PyInt_AsLong(result);
617 // Py_DECREF(result);
618 // PyErr_Clear(); // forget about it if it's not...
619 // } else {
620 // PyErr_Print();
621 // }
622 // return retval;
623 //}
624
625 ////---------------------------------------------------------------------------
626 //// Methods and helpers of the wxPy* classes
627 ////---------------------------------------------------------------------------
628
629 //IMP_OnActivate(wxFrame, wxPyFrame);
630 //IMP_OnCharHook(wxFrame, wxPyFrame);
631 //IMP_OnClose(wxFrame, wxPyFrame);
632 //IMP_OnMenuCommand(wxFrame, wxPyFrame);
633 //IMP_OnMenuSelect(wxFrame, wxPyFrame);
634 //IMP_OnSize(wxFrame, wxPyFrame);
635 //IMP_OnDropFiles(wxFrame, wxPyFrame);
636
637 //IMP_OnChar(wxCanvas, wxPyCanvas);
638 //IMP_OnEvent(wxCanvas, wxPyCanvas);
639 //IMP_OnPaint(wxCanvas, wxPyCanvas);
640 //IMP_OnScroll(wxCanvas, wxPyCanvas);
641 //IMP_OnDropFiles(wxCanvas, wxPyCanvas);
642
643 //IMP_OnChar(wxPanel, wxPyPanel);
644 //IMP_OnEvent(wxPanel, wxPyPanel);
645 //IMP_OnPaint(wxPanel, wxPyPanel);
646 //IMP_OnScroll(wxPanel, wxPyPanel);
647 //IMP_OnCommand(wxPanel, wxPyPanel);
648 //IMP_OnDefaultAction(wxPanel, wxPyPanel);
649 //IMP_OnDropFiles(wxPanel, wxPyPanel);
650
651 //IMP_OnChar(wxTextWindow, wxPyTextWindow);
652 //IMP_OnDropFiles(wxTextWindow, wxPyTextWindow);
653
654 //IMP_OnCharHook(wxDialogBox, wxPyDialogBox);
655 //IMP_OnClose(wxDialogBox, wxPyDialogBox);
656 //IMP_OnSize(wxDialogBox, wxPyDialogBox);
657 //IMP_OnDropFiles(wxDialogBox, wxPyDialogBox);
658 //IMP_OnChar(wxDialogBox, wxPyDialogBox);
659 //IMP_OnEvent(wxDialogBox, wxPyDialogBox);
660 //IMP_OnPaint(wxDialogBox, wxPyDialogBox);
661 //IMP_OnScroll(wxDialogBox, wxPyDialogBox);
662 //IMP_OnCommand(wxDialogBox, wxPyDialogBox);
663 //IMP_OnDefaultAction(wxDialogBox, wxPyDialogBox);
664
665 //IMP_OnChar(wxToolBar, wxPyToolBar);
666 //IMP_OnEvent(wxToolBar, wxPyToolBar);
667 //IMP_OnPaint(wxToolBar, wxPyToolBar);
668 //IMP_OnScroll(wxToolBar, wxPyToolBar);
669 //IMP_OnCommand(wxToolBar, wxPyToolBar);
670 //IMP_OnDefaultAction(wxToolBar, wxPyToolBar);
671 //IMP_OnDropFiles(wxToolBar, wxPyToolBar);
672 //IMP_OnMouseEnter(wxToolBar, wxPyToolBar);
673 //IMP_OnRightClick(wxToolBar, wxPyToolBar);
674
675 //IMP_OnChar(wxButtonBar, wxPyButtonBar);
676 //IMP_OnEvent(wxButtonBar, wxPyButtonBar);
677 //IMP_OnPaint(wxButtonBar, wxPyButtonBar);
678 //IMP_OnScroll(wxButtonBar, wxPyButtonBar);
679 //IMP_OnCommand(wxButtonBar, wxPyButtonBar);
680 //IMP_OnDefaultAction(wxButtonBar, wxPyButtonBar);
681 //IMP_OnDropFiles(wxButtonBar, wxPyButtonBar);
682 //IMP_OnMouseEnter(wxButtonBar, wxPyButtonBar);
683 //IMP_OnRightClick(wxButtonBar, wxPyButtonBar);
684
685 //IMP_OnDoubleClickSash(wxSplitterWindow, wxPySplitterWindow);
686 //IMP_OnUnsplit(wxSplitterWindow, wxPySplitterWindow);
687
688
689
690 //Bool wxPyToolBar::OnLeftClick(int a, int b) {
691 // wxPyEvtHandlers* peh=(wxPyEvtHandlers*)GetClientData();
692 // if (peh->pyOnLeftClick)
693 // return peh->callFunc(peh->pyOnLeftClick, Py_BuildValue("(ii)",a,b));
694 // else {
695 // // If there is no Python callback, redirect the request to
696 // // the OnMenuCommand of the parent frame.
697 // wxFrame* frame = (wxFrame*)GetParent();
698 // frame->OnMenuCommand(a);
699 // return TRUE;
700 // }
701 //// else
702 //// return wxToolBar::OnLeftClick(a,b);
703 //}
704 //Bool wxPyToolBar::baseclass_OnLeftClick(int a, int b) {
705 // return wxToolBar::OnLeftClick(a,b);
706 //}
707
708
709 //Bool wxPyButtonBar::OnLeftClick(int a, int b) {
710 // wxPyEvtHandlers* peh=(wxPyEvtHandlers*)GetClientData();
711 // if (peh->pyOnLeftClick)
712 // return peh->callFunc(peh->pyOnLeftClick, Py_BuildValue("(ii)",a,b));
713 // else {
714 // // If there is no Python callback, redirect the request to
715 // // the OnMenuCommand of the parent frame.
716 // wxFrame* frame = (wxFrame*)GetParent();
717 // frame->OnMenuCommand(a);
718 // return TRUE;
719 // }
720 //}
721 //Bool wxPyButtonBar::baseclass_OnLeftClick(int a, int b) {
722 // return wxButtonBar::OnLeftClick(a,b);
723 //}
724
725
726
727 //wxPyMenu::wxPyMenu(PyObject* _func)
728 // : wxMenu(NULL, (wxFunction)(func ? MenuCallback : NULL)), func(0) {
729
730 // if (_func) {
731 // func = _func;
732 // Py_INCREF(func);
733 // }
734 //}
735
736 //wxPyMenu::~wxPyMenu() {
737 // if (func)
738 // Py_DECREF(func);
739 //}
740
741
742 //void wxPyMenu::MenuCallback(wxWindow& win, wxCommandEvent& evt) {
743 // wxPyEvtHandlers* peh= new wxPyEvtHandlers; // Used for the helper methods
744 // PyObject* evtobj = peh->constructObject((void*)&evt, "wxCommandEvent");
745 // PyObject* winobj = peh->constructObject((void*)&win, "wxWindow");
746 // if (PyErr_Occurred()) {
747 // // bail out if a problem
748 // PyErr_Print();
749 // delete peh;
750 // return;
751 // }
752 // // Now call the callback...
753 // PyObject* func = ((wxPyMenu*)&win)->func;
754 // peh->callFunc(func, Py_BuildValue("(OO)", winobj, evtobj));
755 // Py_DECREF(evtobj);
756 // Py_DECREF(winobj);
757 // delete peh;
758 //}
759
760
761
762 //wxPyTimer::wxPyTimer(PyObject* callback) {
763 // func = callback;
764 // Py_INCREF(func);
765 //}
766
767 //wxPyTimer::~wxPyTimer() {
768 // Py_DECREF(func);
769 //}
770
771 //void wxPyTimer::Notify() {
772 // wxPyEvtHandlers* peh= new wxPyEvtHandlers; // just for the helper methods
773 // peh->callFunc(func, Py_BuildValue("()"));
774 // delete peh;
775 //}
776
777 //----------------------------------------------------------------------
778 //----------------------------------------------------------------------
779 // Some helper functions for typemaps in my_typemaps.i, so they won't be
780 // imcluded in every file...
781
782
783 int* int_LIST_helper(PyObject* source) {
784 if (!PyList_Check(source)) {
785 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
786 return NULL;
787 }
788 int count = PyList_Size(source);
789 int* temp = new int[count];
790 if (! temp) {
791 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
792 return NULL;
793 }
794 for (int x=0; x<count; x++) {
795 PyObject* o = PyList_GetItem(source, x);
796 if (! PyInt_Check(o)) {
797 PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
798 return NULL;
799 }
800 temp[x] = PyInt_AsLong(o);
801 }
802 return temp;
803 }
804
805
806 long* long_LIST_helper(PyObject* source) {
807 if (!PyList_Check(source)) {
808 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
809 return NULL;
810 }
811 int count = PyList_Size(source);
812 long* temp = new long[count];
813 if (! temp) {
814 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
815 return NULL;
816 }
817 for (int x=0; x<count; x++) {
818 PyObject* o = PyList_GetItem(source, x);
819 if (! PyInt_Check(o)) {
820 PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
821 return NULL;
822 }
823 temp[x] = PyInt_AsLong(o);
824 }
825 return temp;
826 }
827
828
829 char** string_LIST_helper(PyObject* source) {
830 if (!PyList_Check(source)) {
831 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
832 return NULL;
833 }
834 int count = PyList_Size(source);
835 char** temp = new char*[count];
836 if (! temp) {
837 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
838 return NULL;
839 }
840 for (int x=0; x<count; x++) {
841 PyObject* o = PyList_GetItem(source, x);
842 if (! PyString_Check(o)) {
843 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
844 return NULL;
845 }
846 temp[x] = PyString_AsString(o);
847 }
848 return temp;
849 }
850
851
852
853 wxPoint* wxPoint_LIST_helper(PyObject* source) {
854 if (!PyList_Check(source)) {
855 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
856 return NULL;
857 }
858 int count = PyList_Size(source);
859 wxPoint* temp = new wxPoint[count];
860 if (! temp) {
861 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
862 return NULL;
863 }
864 for (int x=0; x<count; x++) {
865 PyObject* o = PyList_GetItem(source, x);
866 if (PyString_Check(o)) {
867 char* st = PyString_AsString(o);
868 wxPoint* pt;
869 if (SWIG_GetPtr(st,(void **) &pt,"_wxPoint_p")) {
870 PyErr_SetString(PyExc_TypeError,"Expected _wxPoint_p.");
871 return NULL;
872 }
873 temp[x] = *pt;
874 }
875 else if (PyTuple_Check(o)) {
876 PyObject* o1 = PyTuple_GetItem(o, 0);
877 PyObject* o2 = PyTuple_GetItem(o, 1);
878
879 temp[x].x = PyInt_AsLong(o1);
880 temp[x].y = PyInt_AsLong(o2);
881 }
882 else {
883 PyErr_SetString(PyExc_TypeError, "Expected a list of 2-tuples or wxPoints.");
884 return NULL;
885 }
886 }
887 return temp;
888 }
889
890
891 wxBitmap** wxBitmap_LIST_helper(PyObject* source) {
892 if (!PyList_Check(source)) {
893 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
894 return NULL;
895 }
896 int count = PyList_Size(source);
897 wxBitmap** temp = new wxBitmap*[count];
898 if (! temp) {
899 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
900 return NULL;
901 }
902 for (int x=0; x<count; x++) {
903 PyObject* o = PyList_GetItem(source, x);
904 if (PyString_Check(o)) {
905 char* st = PyString_AsString(o);
906 wxBitmap* pt;
907 if (SWIG_GetPtr(st,(void **) &pt,"_wxBitmap_p")) {
908 PyErr_SetString(PyExc_TypeError,"Expected _wxBitmap_p.");
909 return NULL;
910 }
911 temp[x] = pt;
912 }
913 else {
914 PyErr_SetString(PyExc_TypeError, "Expected a list of wxBitmaps.");
915 return NULL;
916 }
917 }
918 return temp;
919 }
920
921
922
923 wxString* wxString_LIST_helper(PyObject* source) {
924 if (!PyList_Check(source)) {
925 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
926 return NULL;
927 }
928 int count = PyList_Size(source);
929 wxString* temp = new wxString[count];
930 if (! temp) {
931 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
932 return NULL;
933 }
934 for (int x=0; x<count; x++) {
935 PyObject* o = PyList_GetItem(source, x);
936 if (! PyString_Check(o)) {
937 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
938 return NULL;
939 }
940 temp[x] = PyString_AsString(o);
941 }
942 return temp;
943 }
944
945
946 #ifdef __WXMSW__
947 wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) {
948 if (!PyList_Check(source)) {
949 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
950 return NULL;
951 }
952 int count = PyList_Size(source);
953 wxAcceleratorEntry* temp = new wxAcceleratorEntry[count];
954 if (! temp) {
955 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
956 return NULL;
957 }
958 for (int x=0; x<count; x++) {
959 PyObject* o = PyList_GetItem(source, x);
960 if (PyString_Check(o)) {
961 char* st = PyString_AsString(o);
962 wxAcceleratorEntry* ae;
963 if (SWIG_GetPtr(st,(void **) &ae,"_wxAcceleratorEntry_p")) {
964 PyErr_SetString(PyExc_TypeError,"Expected _wxAcceleratorEntry_p.");
965 return NULL;
966 }
967 temp[x] = *ae;
968 }
969 else if (PyTuple_Check(o)) {
970 PyObject* o1 = PyTuple_GetItem(o, 0);
971 PyObject* o2 = PyTuple_GetItem(o, 1);
972 PyObject* o3 = PyTuple_GetItem(o, 2);
973
974 temp[x].m_flags = PyInt_AsLong(o1);
975 temp[x].m_keyCode = PyInt_AsLong(o2);
976 temp[x].m_command = PyInt_AsLong(o3);
977 }
978 else {
979 PyErr_SetString(PyExc_TypeError, "Expected a list of 3-tuples or wxAcceleratorEntry objects.");
980 return NULL;
981 }
982 }
983 return temp;
984 }
985
986 #endif
987
988 //----------------------------------------------------------------------
989 // A WinMain for when wxWindows and Python are linked together in a single
990 // application, instead of as a dynamic module
991
992
993 //#if !defined(WIN_PYD) && defined(WIN32)
994
995 //extern "C" int Py_Main(int argc, char** argv);
996
997 //int APIENTRY WinMain(HANDLE hInstance, HANDLE hPrevInstance, LPSTR m_lpCmdLine,
998 // int nCmdShow )
999 //{
1000
1001 // wxpCreateApp();
1002
1003 // // Initialize wxWindows, but don't start the main loop
1004 // wxEntry(hInstance, hPrevInstance, m_lpCmdLine, nCmdShow, FALSE);
1005
1006 // Py_Initialize();
1007 // PyObject *argvList = PyList_New(0);
1008
1009 // char* stderrfilename = "wxpstderr.log";
1010 // int pyargc = 1;
1011 // char* script = NULL;
1012 // int argc = wxPythonApp->argc;
1013 // char** argv = wxPythonApp->argv;
1014
1015 // for (int i = 1; i < argc; i++) {
1016 // if (strncmp(argv[i], "wxpstderr=", 10) == 0)
1017 // stderrfilename = argv[i]+10;
1018 // else {
1019 // PyList_Append(argvList, PyString_FromString(argv[i]));
1020 // if (!script)
1021 // script = argv[i];
1022 // pyargc++;
1023 // }
1024 // }
1025
1026 // PySys_SetObject("argv", argvList);
1027
1028 //#if 1
1029 // char buf[256];
1030 //// //PyRun_SimpleString("import sys; sys.stdout=open('wxpstdout.log','w')");
1031 // sprintf(buf, "import sys; sys.stdout=sys.stderr=open('%s','w')", stderrfilename);
1032 // PyRun_SimpleString(buf);
1033 //#endif
1034
1035 // initwxPythonc();
1036
1037 // if (script) {
1038 // FILE *fp = fopen(script, "r");
1039 // if (fp) {
1040 // PyRun_SimpleFile(fp, script);// This returns after wxpApp constructor
1041 // fclose(fp);
1042 // }
1043 // else {
1044 // char msg[256];
1045 // sprintf(msg, "Cannot open %s", script);
1046 // wxMessageBox(msg);
1047 // }
1048 // }
1049 // else
1050 // PyRun_SimpleString("import wxpide");
1051
1052 // return 0;
1053 //}
1054
1055
1056 //#endif
1057
1058 //----------------------------------------------------------------------
1059
1060 /////////////////////////////////////////////////////////////////////////////
1061 //
1062 // $Log$
1063 // Revision 1.3 1998/08/15 07:36:36 RD
1064 // - Moved the header in the .i files out of the code that gets put into
1065 // the .cpp files. It caused CVS conflicts because of the RCS ID being
1066 // different each time.
1067 //
1068 // - A few minor fixes.
1069 //
1070 // Revision 1.2 1998/08/14 23:36:36 RD
1071 // Beginings of wxGTK compatibility
1072 //
1073 // Revision 1.1 1998/08/09 08:25:51 RD
1074 // Initial version
1075 //
1076 //
wxWidgets (Impactor)