]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: misc2.i | |
3 | // Purpose: Definitions of miscelaneous functions and classes that need | |
4 | // to know about wxWindow. (So they can't be in misc.i or an | |
5 | // import loop will happen.) | |
6 | // | |
7 | // Author: Robin Dunn | |
8 | // | |
9 | // Created: 18-June-1999 | |
10 | // RCS-ID: $Id$ | |
11 | // Copyright: (c) 1998 by Total Control Software | |
12 | // Licence: wxWindows license | |
13 | ///////////////////////////////////////////////////////////////////////////// | |
14 | ||
15 | %module misc2 | |
16 | ||
17 | %{ | |
18 | #include "helpers.h" | |
19 | #include "pyistream.h" | |
20 | #include <wx/tooltip.h> | |
21 | #include <wx/caret.h> | |
22 | #include <wx/tipdlg.h> | |
23 | #include <wx/process.h> | |
24 | ||
25 | #if wxUSE_JOYSTICK || defined(__WXMSW__) | |
26 | #include <wx/joystick.h> | |
27 | #endif | |
28 | ||
29 | #if wxUSE_WAVE || defined(__WXMSW__) | |
30 | #include <wx/wave.h> | |
31 | #endif | |
32 | ||
33 | #include <wx/mimetype.h> | |
34 | #include <wx/snglinst.h> | |
35 | #include <wx/effects.h> | |
36 | #include <wx/sysopt.h> | |
37 | %} | |
38 | ||
39 | //---------------------------------------------------------------------- | |
40 | ||
41 | %include typemaps.i | |
42 | %include my_typemaps.i | |
43 | ||
44 | // Import some definitions of other classes, etc. | |
45 | %import _defs.i | |
46 | %import windows.i | |
47 | %import misc.i | |
48 | %import gdi.i | |
49 | %import events.i | |
50 | %import streams.i | |
51 | %import utils.i | |
52 | ||
53 | ||
54 | //---------------------------------------------------------------------- | |
55 | ||
56 | %{ | |
57 | // Put some wx default wxChar* values into wxStrings. | |
58 | DECLARE_DEF_STRING(FileSelectorPromptStr); | |
59 | DECLARE_DEF_STRING(FileSelectorDefaultWildcardStr); | |
60 | DECLARE_DEF_STRING(DirSelectorPromptStr); | |
61 | static const wxString wxPyEmptyString(wxT("")); | |
62 | %} | |
63 | ||
64 | //--------------------------------------------------------------------------- | |
65 | // Dialog Functions | |
66 | ||
67 | wxString wxFileSelector(const wxString& message = wxPyFileSelectorPromptStr, | |
68 | const wxString& default_path = wxPyEmptyString, | |
69 | const wxString& default_filename = wxPyEmptyString, | |
70 | const wxString& default_extension = wxPyEmptyString, | |
71 | const wxString& wildcard = wxPyFileSelectorDefaultWildcardStr, | |
72 | int flags = 0, | |
73 | wxWindow *parent = NULL, | |
74 | int x = -1, int y = -1); | |
75 | ||
76 | // TODO: wxFileSelectorEx | |
77 | ||
78 | ||
79 | // Ask for filename to load | |
80 | wxString wxLoadFileSelector(const wxString& what, | |
81 | const wxString& extension, | |
82 | const wxString& default_name = wxPyEmptyString, | |
83 | wxWindow *parent = NULL); | |
84 | ||
85 | // Ask for filename to save | |
86 | wxString wxSaveFileSelector(const wxString& what, | |
87 | const wxString& extension, | |
88 | const wxString& default_name = wxPyEmptyString, | |
89 | wxWindow *parent = NULL); | |
90 | ||
91 | ||
92 | wxString wxDirSelector(const wxString& message = wxPyDirSelectorPromptStr, | |
93 | const wxString& defaultPath = wxPyEmptyString, | |
94 | long style = wxDD_DEFAULT_STYLE, | |
95 | const wxPoint& pos = wxDefaultPosition, | |
96 | wxWindow *parent = NULL); | |
97 | ||
98 | wxString wxGetTextFromUser(const wxString& message, | |
99 | const wxString& caption = wxPyEmptyString, | |
100 | const wxString& default_value = wxPyEmptyString, | |
101 | wxWindow *parent = NULL, | |
102 | int x = -1, int y = -1, | |
103 | bool centre = TRUE); | |
104 | ||
105 | wxString wxGetPasswordFromUser(const wxString& message, | |
106 | const wxString& caption = wxPyEmptyString, | |
107 | const wxString& default_value = wxPyEmptyString, | |
108 | wxWindow *parent = NULL); | |
109 | ||
110 | ||
111 | // TODO: Need to custom wrap this one... | |
112 | // int wxGetMultipleChoice(char* message, char* caption, | |
113 | // int LCOUNT, char** choices, | |
114 | // int nsel, int *selection, | |
115 | // wxWindow *parent = NULL, int x = -1, int y = -1, | |
116 | // bool centre = TRUE, int width=150, int height=200); | |
117 | ||
118 | ||
119 | wxString wxGetSingleChoice(const wxString& message, const wxString& caption, | |
120 | int LCOUNT, wxString* choices, | |
121 | wxWindow *parent = NULL, | |
122 | int x = -1, int y = -1, | |
123 | bool centre = TRUE, | |
124 | int width=150, int height=200); | |
125 | ||
126 | int wxGetSingleChoiceIndex(const wxString& message, const wxString& caption, | |
127 | int LCOUNT, wxString* choices, | |
128 | wxWindow *parent = NULL, | |
129 | int x = -1, int y = -1, | |
130 | bool centre = TRUE, | |
131 | int width=150, int height=200); | |
132 | ||
133 | ||
134 | int wxMessageBox(const wxString& message, | |
135 | const wxString& caption = wxPyEmptyString, | |
136 | int style = wxOK | wxCENTRE, | |
137 | wxWindow *parent = NULL, | |
138 | int x = -1, int y = -1); | |
139 | ||
140 | long wxGetNumberFromUser(const wxString& message, | |
141 | const wxString& prompt, | |
142 | const wxString& caption, | |
143 | long value, | |
144 | long min = 0, long max = 100, | |
145 | wxWindow *parent = NULL, | |
146 | const wxPoint& pos = wxDefaultPosition); | |
147 | ||
148 | //--------------------------------------------------------------------------- | |
149 | // GDI Functions | |
150 | ||
151 | bool wxColourDisplay(); | |
152 | ||
153 | int wxDisplayDepth(); | |
154 | int wxGetDisplayDepth(); | |
155 | ||
156 | void wxDisplaySize(int* OUTPUT, int* OUTPUT); | |
157 | wxSize wxGetDisplaySize(); | |
158 | ||
159 | void wxDisplaySizeMM(int* OUTPUT, int* OUTPUT); | |
160 | wxSize wxGetDisplaySizeMM(); | |
161 | ||
162 | void wxClientDisplayRect(int *OUTPUT, int *OUTPUT, int *OUTPUT, int *OUTPUT); | |
163 | wxRect wxGetClientDisplayRect(); | |
164 | ||
165 | void wxSetCursor(wxCursor& cursor); | |
166 | ||
167 | //---------------------------------------------------------------------- | |
168 | // Miscellaneous functions | |
169 | ||
170 | void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR); | |
171 | wxWindow * wxGetActiveWindow(); | |
172 | ||
173 | wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt); | |
174 | wxWindow* wxFindWindowAtPoint(const wxPoint& pt); | |
175 | ||
176 | #ifdef __WXMSW__ | |
177 | bool wxCheckForInterrupt(wxWindow *wnd); | |
178 | // link error? void wxFlushEvents(); | |
179 | #endif | |
180 | ||
181 | wxWindow* wxGetTopLevelParent(wxWindow *win); | |
182 | ||
183 | //bool wxSpawnBrowser(wxWindow *parent, wxString href); | |
184 | ||
185 | //--------------------------------------------------------------------------- | |
186 | // Resource System | |
187 | ||
188 | #ifdef wxUSE_WX_RESOURCES | |
189 | bool wxResourceAddIdentifier(char* name, int value); | |
190 | void wxResourceClear(void); | |
191 | wxBitmap wxResourceCreateBitmap(char* resource); | |
192 | wxIcon wxResourceCreateIcon(char* resource); | |
193 | wxMenuBar * wxResourceCreateMenuBar(char* resource); | |
194 | int wxResourceGetIdentifier(char* name); | |
195 | bool wxResourceParseData(char* resource, wxResourceTable *table = NULL); | |
196 | bool wxResourceParseFile(char* filename, wxResourceTable *table = NULL); | |
197 | bool wxResourceParseString(char* resource, wxResourceTable *table = NULL); | |
198 | #endif | |
199 | ||
200 | //--------------------------------------------------------------------------- | |
201 | // System Settings | |
202 | ||
203 | // possible values for wxSystemSettings::GetFont() parameter | |
204 | // | |
205 | enum wxSystemFont | |
206 | { | |
207 | wxSYS_OEM_FIXED_FONT = 10, | |
208 | wxSYS_ANSI_FIXED_FONT, | |
209 | wxSYS_ANSI_VAR_FONT, | |
210 | wxSYS_SYSTEM_FONT, | |
211 | wxSYS_DEVICE_DEFAULT_FONT, | |
212 | wxSYS_DEFAULT_PALETTE, | |
213 | wxSYS_SYSTEM_FIXED_FONT, | |
214 | wxSYS_DEFAULT_GUI_FONT | |
215 | }; | |
216 | ||
217 | // possible values for wxSystemSettings::GetColour() parameter | |
218 | // | |
219 | enum wxSystemColour | |
220 | { | |
221 | wxSYS_COLOUR_SCROLLBAR, | |
222 | wxSYS_COLOUR_BACKGROUND, | |
223 | wxSYS_COLOUR_DESKTOP = wxSYS_COLOUR_BACKGROUND, | |
224 | wxSYS_COLOUR_ACTIVECAPTION, | |
225 | wxSYS_COLOUR_INACTIVECAPTION, | |
226 | wxSYS_COLOUR_MENU, | |
227 | wxSYS_COLOUR_WINDOW, | |
228 | wxSYS_COLOUR_WINDOWFRAME, | |
229 | wxSYS_COLOUR_MENUTEXT, | |
230 | wxSYS_COLOUR_WINDOWTEXT, | |
231 | wxSYS_COLOUR_CAPTIONTEXT, | |
232 | wxSYS_COLOUR_ACTIVEBORDER, | |
233 | wxSYS_COLOUR_INACTIVEBORDER, | |
234 | wxSYS_COLOUR_APPWORKSPACE, | |
235 | wxSYS_COLOUR_HIGHLIGHT, | |
236 | wxSYS_COLOUR_HIGHLIGHTTEXT, | |
237 | wxSYS_COLOUR_BTNFACE, | |
238 | wxSYS_COLOUR_3DFACE = wxSYS_COLOUR_BTNFACE, | |
239 | wxSYS_COLOUR_BTNSHADOW, | |
240 | wxSYS_COLOUR_3DSHADOW = wxSYS_COLOUR_BTNSHADOW, | |
241 | wxSYS_COLOUR_GRAYTEXT, | |
242 | wxSYS_COLOUR_BTNTEXT, | |
243 | wxSYS_COLOUR_INACTIVECAPTIONTEXT, | |
244 | wxSYS_COLOUR_BTNHIGHLIGHT, | |
245 | wxSYS_COLOUR_BTNHILIGHT = wxSYS_COLOUR_BTNHIGHLIGHT, | |
246 | wxSYS_COLOUR_3DHIGHLIGHT = wxSYS_COLOUR_BTNHIGHLIGHT, | |
247 | wxSYS_COLOUR_3DHILIGHT = wxSYS_COLOUR_BTNHIGHLIGHT, | |
248 | wxSYS_COLOUR_3DDKSHADOW, | |
249 | wxSYS_COLOUR_3DLIGHT, | |
250 | wxSYS_COLOUR_INFOTEXT, | |
251 | wxSYS_COLOUR_INFOBK, | |
252 | wxSYS_COLOUR_LISTBOX, | |
253 | wxSYS_COLOUR_HOTLIGHT, | |
254 | wxSYS_COLOUR_GRADIENTACTIVECAPTION, | |
255 | wxSYS_COLOUR_GRADIENTINACTIVECAPTION, | |
256 | wxSYS_COLOUR_MENUHILIGHT, | |
257 | wxSYS_COLOUR_MENUBAR, | |
258 | ||
259 | wxSYS_COLOUR_MAX | |
260 | }; | |
261 | ||
262 | // possible values for wxSystemSettings::GetMetric() parameter | |
263 | // | |
264 | enum wxSystemMetric | |
265 | { | |
266 | wxSYS_MOUSE_BUTTONS = 1, | |
267 | wxSYS_BORDER_X, | |
268 | wxSYS_BORDER_Y, | |
269 | wxSYS_CURSOR_X, | |
270 | wxSYS_CURSOR_Y, | |
271 | wxSYS_DCLICK_X, | |
272 | wxSYS_DCLICK_Y, | |
273 | wxSYS_DRAG_X, | |
274 | wxSYS_DRAG_Y, | |
275 | wxSYS_EDGE_X, | |
276 | wxSYS_EDGE_Y, | |
277 | wxSYS_HSCROLL_ARROW_X, | |
278 | wxSYS_HSCROLL_ARROW_Y, | |
279 | wxSYS_HTHUMB_X, | |
280 | wxSYS_ICON_X, | |
281 | wxSYS_ICON_Y, | |
282 | wxSYS_ICONSPACING_X, | |
283 | wxSYS_ICONSPACING_Y, | |
284 | wxSYS_WINDOWMIN_X, | |
285 | wxSYS_WINDOWMIN_Y, | |
286 | wxSYS_SCREEN_X, | |
287 | wxSYS_SCREEN_Y, | |
288 | wxSYS_FRAMESIZE_X, | |
289 | wxSYS_FRAMESIZE_Y, | |
290 | wxSYS_SMALLICON_X, | |
291 | wxSYS_SMALLICON_Y, | |
292 | wxSYS_HSCROLL_Y, | |
293 | wxSYS_VSCROLL_X, | |
294 | wxSYS_VSCROLL_ARROW_X, | |
295 | wxSYS_VSCROLL_ARROW_Y, | |
296 | wxSYS_VTHUMB_Y, | |
297 | wxSYS_CAPTION_Y, | |
298 | wxSYS_MENU_Y, | |
299 | wxSYS_NETWORK_PRESENT, | |
300 | wxSYS_PENWINDOWS_PRESENT, | |
301 | wxSYS_SHOW_SOUNDS, | |
302 | wxSYS_SWAP_BUTTONS | |
303 | }; | |
304 | ||
305 | // possible values for wxSystemSettings::HasFeature() parameter | |
306 | enum wxSystemFeature | |
307 | { | |
308 | wxSYS_CAN_DRAW_FRAME_DECORATIONS = 1, | |
309 | wxSYS_CAN_ICONIZE_FRAME | |
310 | }; | |
311 | ||
312 | enum wxSystemScreenType | |
313 | { | |
314 | wxSYS_SCREEN_NONE = 0, // not yet defined | |
315 | ||
316 | wxSYS_SCREEN_TINY, // < | |
317 | wxSYS_SCREEN_PDA, // >= 320x240 | |
318 | wxSYS_SCREEN_SMALL, // >= 640x480 | |
319 | wxSYS_SCREEN_DESKTOP // >= 800x600 | |
320 | }; | |
321 | ||
322 | ||
323 | class wxSystemSettings { | |
324 | public: | |
325 | // get a standard system colour | |
326 | static wxColour GetColour(wxSystemColour index); | |
327 | ||
328 | // get a standard system font | |
329 | static wxFont GetFont(wxSystemFont index); | |
330 | ||
331 | // get a system-dependent metric | |
332 | static int GetMetric(wxSystemMetric index); | |
333 | ||
334 | // return true if the port has certain feature | |
335 | static bool HasFeature(wxSystemFeature index); | |
336 | ||
337 | // Get system screen design (desktop, pda, ..) used for | |
338 | // laying out various dialogs. | |
339 | static wxSystemScreenType GetScreenType(); | |
340 | ||
341 | // Override default. | |
342 | static void SetScreenType( wxSystemScreenType screen ); | |
343 | ||
344 | }; | |
345 | ||
346 | ||
347 | ||
348 | class wxSystemOptions : public wxObject | |
349 | { | |
350 | public: | |
351 | wxSystemOptions() { } | |
352 | ||
353 | // User-customizable hints to wxWindows or associated libraries | |
354 | // These could also be used to influence GetSystem... calls, indeed | |
355 | // to implement SetSystemColour/Font/Metric | |
356 | ||
357 | static void SetOption(const wxString& name, const wxString& value); | |
358 | %name(SetOptionInt)static void SetOption(const wxString& name, int value); | |
359 | static wxString GetOption(const wxString& name) ; | |
360 | static int GetOptionInt(const wxString& name) ; | |
361 | static bool HasOption(const wxString& name) ; | |
362 | }; | |
363 | ||
364 | ||
365 | //--------------------------------------------------------------------------- | |
366 | // wxToolTip | |
367 | ||
368 | class wxToolTip : public wxObject { | |
369 | public: | |
370 | wxToolTip(const wxString &tip); | |
371 | ||
372 | void SetTip(const wxString& tip); | |
373 | wxString GetTip(); | |
374 | // *** Not in the "public" interface void SetWindow(wxWindow *win); | |
375 | wxWindow *GetWindow(); | |
376 | ||
377 | static void Enable(bool flag); | |
378 | static void SetDelay(long milliseconds); | |
379 | }; | |
380 | ||
381 | //---------------------------------------------------------------------- | |
382 | ||
383 | class wxCaret { | |
384 | public: | |
385 | wxCaret(wxWindow* window, const wxSize& size); | |
386 | ~wxCaret(); | |
387 | ||
388 | bool IsOk(); | |
389 | bool IsVisible(); | |
390 | %name(GetPositionTuple)void GetPosition(int *OUTPUT, int *OUTPUT); | |
391 | wxPoint GetPosition(); | |
392 | %name(GetSizeTuple)void GetSize(int *OUTPUT, int *OUTPUT); | |
393 | wxSize GetSize(); | |
394 | wxWindow *GetWindow(); | |
395 | %name(MoveXY)void Move(int x, int y); | |
396 | void Move(const wxPoint& pt); | |
397 | %name(SetSizeWH) void SetSize(int width, int height); | |
398 | void SetSize(const wxSize& size); | |
399 | void Show(int show = TRUE); | |
400 | void Hide(); | |
401 | ||
402 | %pragma(python) addtoclass = "def __nonzero__(self): return self.IsOk()" | |
403 | }; | |
404 | ||
405 | %inline %{ | |
406 | int wxCaret_GetBlinkTime() { | |
407 | return wxCaret::GetBlinkTime(); | |
408 | } | |
409 | ||
410 | void wxCaret_SetBlinkTime(int milliseconds) { | |
411 | wxCaret::SetBlinkTime(milliseconds); | |
412 | } | |
413 | %} | |
414 | ||
415 | //---------------------------------------------------------------------- | |
416 | ||
417 | class wxBusyCursor { | |
418 | public: | |
419 | wxBusyCursor(wxCursor* cursor = wxHOURGLASS_CURSOR); | |
420 | ~wxBusyCursor(); | |
421 | }; | |
422 | ||
423 | //---------------------------------------------------------------------- | |
424 | ||
425 | class wxWindowDisabler { | |
426 | public: | |
427 | wxWindowDisabler(wxWindow *winToSkip = NULL); | |
428 | ~wxWindowDisabler(); | |
429 | }; | |
430 | ||
431 | //---------------------------------------------------------------------- | |
432 | ||
433 | bool wxSafeYield(wxWindow* win=NULL, bool onlyIfNeeded=FALSE); | |
434 | void wxPostEvent(wxEvtHandler *dest, wxEvent& event); | |
435 | void wxWakeUpIdle(); | |
436 | ||
437 | ||
438 | #ifdef __WXMSW__ | |
439 | void wxWakeUpMainThread(); | |
440 | #endif | |
441 | ||
442 | void wxMutexGuiEnter(); | |
443 | void wxMutexGuiLeave(); | |
444 | ||
445 | ||
446 | class wxMutexGuiLocker { | |
447 | public: | |
448 | wxMutexGuiLocker(); | |
449 | ~wxMutexGuiLocker(); | |
450 | }; | |
451 | ||
452 | ||
453 | %inline %{ | |
454 | bool wxThread_IsMain() { | |
455 | #ifdef WXP_WITH_THREAD | |
456 | return wxThread::IsMain(); | |
457 | #else | |
458 | return TRUE; | |
459 | #endif | |
460 | } | |
461 | %} | |
462 | ||
463 | //---------------------------------------------------------------------- | |
464 | ||
465 | ||
466 | class wxTipProvider | |
467 | { | |
468 | public: | |
469 | // wxTipProvider(size_t currentTip); **** Abstract base class | |
470 | ~wxTipProvider(); | |
471 | ||
472 | virtual wxString GetTip() = 0; | |
473 | size_t GetCurrentTip(); | |
474 | virtual wxString PreprocessTip(const wxString& tip); | |
475 | }; | |
476 | ||
477 | ||
478 | // The C++ version of wxPyTipProvider | |
479 | %{ | |
480 | class wxPyTipProvider : public wxTipProvider { | |
481 | public: | |
482 | wxPyTipProvider(size_t currentTip) | |
483 | : wxTipProvider(currentTip) {} | |
484 | ||
485 | DEC_PYCALLBACK_STRING__pure(GetTip); | |
486 | DEC_PYCALLBACK_STRING_STRING(PreprocessTip); | |
487 | PYPRIVATE; | |
488 | }; | |
489 | ||
490 | IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip); | |
491 | IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip); | |
492 | %} | |
493 | ||
494 | ||
495 | // Now let SWIG know about it | |
496 | class wxPyTipProvider : public wxTipProvider { | |
497 | public: | |
498 | wxPyTipProvider(size_t currentTip); | |
499 | ||
500 | void _setCallbackInfo(PyObject* self, PyObject* _class); | |
501 | %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyTipProvider)" | |
502 | }; | |
503 | ||
504 | ||
505 | ||
506 | bool wxShowTip(wxWindow *parent, wxTipProvider *tipProvider, bool showAtStartup = TRUE); | |
507 | %new wxTipProvider * wxCreateFileTipProvider(const wxString& filename, size_t currentTip); | |
508 | ||
509 | ||
510 | //---------------------------------------------------------------------- | |
511 | ||
512 | %{ | |
513 | #include <wx/generic/dragimgg.h> | |
514 | %} | |
515 | ||
516 | %name (wxDragImage) class wxGenericDragImage : public wxObject | |
517 | { | |
518 | public: | |
519 | ||
520 | wxGenericDragImage(const wxBitmap& image, | |
521 | const wxCursor& cursor = wxNullCursor); | |
522 | %name(wxDragIcon)wxGenericDragImage(const wxIcon& image, | |
523 | const wxCursor& cursor = wxNullCursor); | |
524 | %name(wxDragString)wxGenericDragImage(const wxString& str, | |
525 | const wxCursor& cursor = wxNullCursor); | |
526 | %name(wxDragTreeItem)wxGenericDragImage(const wxTreeCtrl& treeCtrl, wxTreeItemId& id); | |
527 | %name(wxDragListItem)wxGenericDragImage(const wxListCtrl& listCtrl, long id); | |
528 | ||
529 | ~wxGenericDragImage(); | |
530 | ||
531 | void SetBackingBitmap(wxBitmap* bitmap); | |
532 | bool BeginDrag(const wxPoint& hotspot, wxWindow* window, | |
533 | bool fullScreen = FALSE, wxRect* rect = NULL); | |
534 | ||
535 | %name(BeginDragBounded) bool BeginDrag(const wxPoint& hotspot, wxWindow* window, | |
536 | wxWindow* boundingWindow); | |
537 | ||
538 | %pragma(python) addtoclass = "BeginDrag2 = BeginDragBounded" | |
539 | ||
540 | bool EndDrag(); | |
541 | bool Move(const wxPoint& pt); | |
542 | bool Show(); | |
543 | bool Hide(); | |
544 | ||
545 | wxRect GetImageRect(const wxPoint& pos) const; | |
546 | bool RedrawImage(const wxPoint& oldPos, const wxPoint& newPos, | |
547 | bool eraseOld, bool drawNew); | |
548 | }; | |
549 | ||
550 | ||
551 | //---------------------------------------------------------------------- | |
552 | ||
553 | class wxPyTimer : public wxObject { | |
554 | public: | |
555 | wxPyTimer(PyObject* notify); | |
556 | ~wxPyTimer(); | |
557 | int GetInterval(); | |
558 | bool IsOneShot(); | |
559 | bool IsRunning(); | |
560 | void SetOwner(wxEvtHandler *owner, int id = -1); | |
561 | bool Start(int milliseconds=-1, int oneShot=FALSE); | |
562 | void Stop(); | |
563 | }; | |
564 | ||
565 | ||
566 | class wxStopWatch | |
567 | { | |
568 | public: | |
569 | // ctor starts the stop watch | |
570 | wxStopWatch(); | |
571 | ~wxStopWatch(); | |
572 | void Start(long t = 0); | |
573 | void Pause(); | |
574 | void Resume(); | |
575 | ||
576 | // get elapsed time since the last Start() or Pause() in milliseconds | |
577 | long Time() const; | |
578 | }; | |
579 | ||
580 | ||
581 | //---------------------------------------------------------------------- | |
582 | //---------------------------------------------------------------------- | |
583 | ||
584 | ||
585 | enum | |
586 | { | |
587 | wxLOG_FatalError, // program can't continue, abort immediately | |
588 | wxLOG_Error, // a serious error, user must be informed about it | |
589 | wxLOG_Warning, // user is normally informed about it but may be ignored | |
590 | wxLOG_Message, // normal message (i.e. normal output of a non GUI app) | |
591 | wxLOG_Info, // informational message (a.k.a. 'Verbose') | |
592 | wxLOG_Status, // informational: might go to the status line of GUI app | |
593 | wxLOG_Debug, // never shown to the user, disabled in release mode | |
594 | wxLOG_Trace, // trace messages are also only enabled in debug mode | |
595 | wxLOG_Progress, // used for progress indicator (not yet) | |
596 | wxLOG_User = 100 // user defined levels start here | |
597 | }; | |
598 | ||
599 | #define wxTRACE_MemAlloc "memalloc" // trace memory allocation (new/delete) | |
600 | #define wxTRACE_Messages "messages" // trace window messages/X callbacks | |
601 | #define wxTRACE_ResAlloc "resalloc" // trace GDI resource allocation | |
602 | #define wxTRACE_RefCount "refcount" // trace various ref counting operations | |
603 | ||
604 | #ifdef __WXMSW__ | |
605 | #define wxTRACE_OleCalls "ole" // OLE interface calls | |
606 | #endif | |
607 | ||
608 | enum { | |
609 | wxTraceMemAlloc, | |
610 | wxTraceMessages, | |
611 | wxTraceResAlloc, | |
612 | wxTraceRefCount, | |
613 | ||
614 | #ifdef __WXMSW__ | |
615 | wxTraceOleCalls, | |
616 | #endif | |
617 | }; | |
618 | ||
619 | ||
620 | ||
621 | class wxLog | |
622 | { | |
623 | public: | |
624 | wxLog(); | |
625 | ||
626 | static bool IsEnabled(); | |
627 | static bool EnableLogging(bool doIt = TRUE); | |
628 | static void OnLog(unsigned long level, const wxString& szString, int t=0); | |
629 | ||
630 | virtual void Flush(); | |
631 | static void FlushActive(); | |
632 | static wxLog *GetActiveTarget(); | |
633 | static wxLog *SetActiveTarget(wxLog *pLogger); | |
634 | ||
635 | static void Suspend(); | |
636 | static void Resume(); | |
637 | ||
638 | static void SetVerbose(bool bVerbose = TRUE); | |
639 | ||
640 | static void DontCreateOnDemand(); | |
641 | static void SetTraceMask(long ulMask); | |
642 | static void AddTraceMask(const wxString& str); | |
643 | static void RemoveTraceMask(const wxString& str); | |
644 | static void ClearTraceMasks(); | |
645 | static const wxArrayString &GetTraceMasks(); | |
646 | ||
647 | static void SetTimestamp(const wxString& ts); | |
648 | static const wxString& GetTimestamp(); | |
649 | ||
650 | bool GetVerbose() const; | |
651 | ||
652 | static unsigned long GetTraceMask(); | |
653 | static bool IsAllowedTraceMask(const wxString& mask); | |
654 | ||
655 | static void SetLogLevel(unsigned long logLevel); | |
656 | static unsigned long GetLogLevel(); | |
657 | ||
658 | ||
659 | // static void TimeStamp(wxString *str); | |
660 | %addmethods { | |
661 | wxString TimeStamp() { | |
662 | wxString msg; | |
663 | wxLog::TimeStamp(&msg); | |
664 | return msg; | |
665 | } | |
666 | } | |
667 | ||
668 | }; | |
669 | ||
670 | ||
671 | class wxLogStderr : public wxLog | |
672 | { | |
673 | public: | |
674 | wxLogStderr(/* TODO: FILE *fp = (FILE *) NULL*/); | |
675 | }; | |
676 | ||
677 | ||
678 | class wxLogTextCtrl : public wxLog | |
679 | { | |
680 | public: | |
681 | wxLogTextCtrl(wxTextCtrl *pTextCtrl); | |
682 | }; | |
683 | ||
684 | ||
685 | class wxLogGui : public wxLog | |
686 | { | |
687 | public: | |
688 | wxLogGui(); | |
689 | }; | |
690 | ||
691 | class wxLogWindow : public wxLog | |
692 | { | |
693 | public: | |
694 | wxLogWindow(wxFrame *pParent, // the parent frame (can be NULL) | |
695 | const wxString& szTitle, // the title of the frame | |
696 | bool bShow = TRUE, // show window immediately? | |
697 | bool bPassToOld = TRUE); // pass log messages to the old target? | |
698 | ||
699 | void Show(bool bShow = TRUE); | |
700 | wxFrame *GetFrame() const; | |
701 | wxLog *GetOldLog() const; | |
702 | bool IsPassingMessages() const; | |
703 | void PassMessages(bool bDoPass); | |
704 | }; | |
705 | ||
706 | ||
707 | class wxLogChain : public wxLog | |
708 | { | |
709 | public: | |
710 | wxLogChain(wxLog *logger); | |
711 | void SetLog(wxLog *logger); | |
712 | void PassMessages(bool bDoPass); | |
713 | bool IsPassingMessages(); | |
714 | wxLog *GetOldLog(); | |
715 | }; | |
716 | ||
717 | ||
718 | unsigned long wxSysErrorCode(); | |
719 | const wxString wxSysErrorMsg(unsigned long nErrCode = 0); | |
720 | void wxLogFatalError(const wxString& msg); | |
721 | void wxLogError(const wxString& msg); | |
722 | void wxLogWarning(const wxString& msg); | |
723 | void wxLogMessage(const wxString& msg); | |
724 | void wxLogInfo(const wxString& msg); | |
725 | void wxLogDebug(const wxString& msg); | |
726 | void wxLogVerbose(const wxString& msg); | |
727 | void wxLogStatus(const wxString& msg); | |
728 | %name(wxLogStatusFrame)void wxLogStatus(wxFrame *pFrame, const wxString& msg); | |
729 | void wxLogSysError(const wxString& msg); | |
730 | ||
731 | void wxLogTrace(const wxString& msg); | |
732 | %name(wxLogTraceMask)void wxLogTrace(const wxString& mask, const wxString& msg); | |
733 | ||
734 | void wxLogGeneric(unsigned long level, const wxString& msg); | |
735 | ||
736 | // wxLogFatalError helper: show the (fatal) error to the user in a safe way, | |
737 | // i.e. without using wxMessageBox() for example because it could crash | |
738 | void wxSafeShowMessage(const wxString& title, const wxString& text); | |
739 | ||
740 | ||
741 | ||
742 | // Suspress logging while an instance of this class exists | |
743 | class wxLogNull | |
744 | { | |
745 | public: | |
746 | wxLogNull(); | |
747 | ~wxLogNull(); | |
748 | }; | |
749 | ||
750 | ||
751 | ||
752 | ||
753 | %{ | |
754 | // A wxLog class that can be derived from in wxPython | |
755 | class wxPyLog : public wxLog { | |
756 | public: | |
757 | wxPyLog() : wxLog() {} | |
758 | ||
759 | virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) { | |
760 | bool found; | |
761 | wxPyBeginBlockThreads(); | |
762 | if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) { | |
763 | PyObject* s = wx2PyString(szString); | |
764 | wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t)); | |
765 | Py_DECREF(s); | |
766 | } | |
767 | wxPyEndBlockThreads(); | |
768 | if (! found) | |
769 | wxLog::DoLog(level, szString, t); | |
770 | } | |
771 | ||
772 | virtual void DoLogString(const wxChar *szString, time_t t) { | |
773 | bool found; | |
774 | wxPyBeginBlockThreads(); | |
775 | if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) { | |
776 | PyObject* s = wx2PyString(szString); | |
777 | wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t)); | |
778 | Py_DECREF(s); | |
779 | } | |
780 | wxPyEndBlockThreads(); | |
781 | if (! found) | |
782 | wxLog::DoLogString(szString, t); | |
783 | } | |
784 | ||
785 | PYPRIVATE; | |
786 | }; | |
787 | %} | |
788 | ||
789 | // Now tell SWIG about it | |
790 | class wxPyLog : public wxLog { | |
791 | public: | |
792 | wxPyLog(); | |
793 | void _setCallbackInfo(PyObject* self, PyObject* _class); | |
794 | %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyLog)" | |
795 | %addmethods { void Destroy() { delete self; } } | |
796 | ||
797 | }; | |
798 | ||
799 | ||
800 | //---------------------------------------------------------------------- | |
801 | ||
802 | ||
803 | enum wxKillError | |
804 | { | |
805 | wxKILL_OK, // no error | |
806 | wxKILL_BAD_SIGNAL, // no such signal | |
807 | wxKILL_ACCESS_DENIED, // permission denied | |
808 | wxKILL_NO_PROCESS, // no such process | |
809 | wxKILL_ERROR // another, unspecified error | |
810 | }; | |
811 | ||
812 | enum wxSignal | |
813 | { | |
814 | wxSIGNONE = 0, // verify if the process exists under Unix | |
815 | wxSIGHUP, | |
816 | wxSIGINT, | |
817 | wxSIGQUIT, | |
818 | wxSIGILL, | |
819 | wxSIGTRAP, | |
820 | wxSIGABRT, | |
821 | wxSIGIOT = wxSIGABRT, // another name | |
822 | wxSIGEMT, | |
823 | wxSIGFPE, | |
824 | wxSIGKILL, | |
825 | wxSIGBUS, | |
826 | wxSIGSEGV, | |
827 | wxSIGSYS, | |
828 | wxSIGPIPE, | |
829 | wxSIGALRM, | |
830 | wxSIGTERM | |
831 | ||
832 | // further signals are different in meaning between different Unix systems | |
833 | }; | |
834 | ||
835 | ||
836 | ||
837 | enum { | |
838 | /* event type */ | |
839 | wxEVT_END_PROCESS | |
840 | }; | |
841 | ||
842 | ||
843 | ||
844 | class wxProcessEvent : public wxEvent { | |
845 | public: | |
846 | wxProcessEvent(int id = 0, int pid = 0, int exitcode = 0); | |
847 | int GetPid(); | |
848 | int GetExitCode(); | |
849 | int m_pid, m_exitcode; | |
850 | }; | |
851 | ||
852 | ||
853 | ||
854 | ||
855 | %{ // C++ version of wxProcess derived class | |
856 | ||
857 | class wxPyProcess : public wxProcess { | |
858 | public: | |
859 | wxPyProcess(wxEvtHandler *parent = NULL, int id = -1) | |
860 | : wxProcess(parent, id) | |
861 | {} | |
862 | ||
863 | DEC_PYCALLBACK_VOID_INTINT(OnTerminate); | |
864 | ||
865 | PYPRIVATE; | |
866 | }; | |
867 | ||
868 | IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate); | |
869 | ||
870 | %} | |
871 | ||
872 | ||
873 | %name(wxProcess)class wxPyProcess : public wxEvtHandler { | |
874 | public: | |
875 | // kill the process with the given PID | |
876 | static wxKillError Kill(int pid, wxSignal sig = wxSIGTERM); | |
877 | ||
878 | // test if the given process exists | |
879 | static bool Exists(int pid); | |
880 | ||
881 | // this function replaces the standard popen() one: it launches a process | |
882 | // asynchronously and allows the caller to get the streams connected to its | |
883 | // std{in|out|err} | |
884 | // | |
885 | // on error NULL is returned, in any case the process object will be | |
886 | // deleted automatically when the process terminates and should *not* be | |
887 | // deleted by the caller | |
888 | static wxPyProcess *Open(const wxString& cmd, int flags = wxEXEC_ASYNC); | |
889 | ||
890 | ||
891 | ||
892 | wxPyProcess(wxEvtHandler *parent = NULL, int id = -1); | |
893 | %addmethods { void Destroy() { delete self; } } | |
894 | ||
895 | void _setCallbackInfo(PyObject* self, PyObject* _class); | |
896 | %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxProcess)" | |
897 | ||
898 | void base_OnTerminate(int pid, int status); | |
899 | ||
900 | void Redirect(); | |
901 | bool IsRedirected(); | |
902 | void Detach(); | |
903 | ||
904 | wxInputStream *GetInputStream(); | |
905 | wxInputStream *GetErrorStream(); | |
906 | wxOutputStream *GetOutputStream(); | |
907 | ||
908 | void CloseOutput(); | |
909 | ||
910 | // return TRUE if the child process stdout is not closed | |
911 | bool IsInputOpened() const; | |
912 | ||
913 | // return TRUE if any input is available on the child process stdout/err | |
914 | bool IsInputAvailable() const; | |
915 | bool IsErrorAvailable() const; | |
916 | }; | |
917 | ||
918 | ||
919 | enum | |
920 | { | |
921 | // execute the process asynchronously | |
922 | wxEXEC_ASYNC = 0, | |
923 | ||
924 | // execute it synchronously, i.e. wait until it finishes | |
925 | wxEXEC_SYNC = 1, | |
926 | ||
927 | // under Windows, don't hide the child even if it's IO is redirected (this | |
928 | // is done by default) | |
929 | wxEXEC_NOHIDE = 2, | |
930 | ||
931 | // under Unix, if the process is the group leader then killing -pid kills | |
932 | // all children as well as pid | |
933 | wxEXEC_MAKE_GROUP_LEADER = 4 | |
934 | }; | |
935 | ||
936 | ||
937 | long wxExecute(const wxString& command, | |
938 | int flags = wxEXEC_ASYNC, | |
939 | wxPyProcess *process = NULL); | |
940 | ||
941 | //---------------------------------------------------------------------- | |
942 | ||
943 | ||
944 | // Which joystick? Same as Windows ids so no conversion necessary. | |
945 | enum | |
946 | { | |
947 | wxJOYSTICK1, | |
948 | wxJOYSTICK2 | |
949 | }; | |
950 | ||
951 | // Which button is down? | |
952 | enum | |
953 | { | |
954 | wxJOY_BUTTON_ANY, | |
955 | wxJOY_BUTTON1, | |
956 | wxJOY_BUTTON2, | |
957 | wxJOY_BUTTON3, | |
958 | wxJOY_BUTTON4, | |
959 | }; | |
960 | ||
961 | ||
962 | %{ | |
963 | #if !wxUSE_JOYSTICK && !defined(__WXMSW__) | |
964 | // A C++ stub class for wxJoystick for platforms that don't have it. | |
965 | class wxJoystick : public wxObject { | |
966 | public: | |
967 | wxJoystick(int joystick = wxJOYSTICK1) { | |
968 | wxPyBeginBlockThreads(); | |
969 | PyErr_SetString(PyExc_NotImplementedError, "wxJoystick is not available on this platform."); | |
970 | wxPyEndBlockThreads(); | |
971 | } | |
972 | wxPoint GetPosition() { return wxPoint(-1,-1); } | |
973 | int GetZPosition() { return -1; } | |
974 | int GetButtonState() { return -1; } | |
975 | int GetPOVPosition() { return -1; } | |
976 | int GetPOVCTSPosition() { return -1; } | |
977 | int GetRudderPosition() { return -1; } | |
978 | int GetUPosition() { return -1; } | |
979 | int GetVPosition() { return -1; } | |
980 | int GetMovementThreshold() { return -1; } | |
981 | void SetMovementThreshold(int threshold) {} | |
982 | ||
983 | bool IsOk(void) { return FALSE; } | |
984 | int GetNumberJoysticks() { return -1; } | |
985 | int GetManufacturerId() { return -1; } | |
986 | int GetProductId() { return -1; } | |
987 | wxString GetProductName() { return ""; } | |
988 | int GetXMin() { return -1; } | |
989 | int GetYMin() { return -1; } | |
990 | int GetZMin() { return -1; } | |
991 | int GetXMax() { return -1; } | |
992 | int GetYMax() { return -1; } | |
993 | int GetZMax() { return -1; } | |
994 | int GetNumberButtons() { return -1; } | |
995 | int GetNumberAxes() { return -1; } | |
996 | int GetMaxButtons() { return -1; } | |
997 | int GetMaxAxes() { return -1; } | |
998 | int GetPollingMin() { return -1; } | |
999 | int GetPollingMax() { return -1; } | |
1000 | int GetRudderMin() { return -1; } | |
1001 | int GetRudderMax() { return -1; } | |
1002 | int GetUMin() { return -1; } | |
1003 | int GetUMax() { return -1; } | |
1004 | int GetVMin() { return -1; } | |
1005 | int GetVMax() { return -1; } | |
1006 | ||
1007 | bool HasRudder() { return FALSE; } | |
1008 | bool HasZ() { return FALSE; } | |
1009 | bool HasU() { return FALSE; } | |
1010 | bool HasV() { return FALSE; } | |
1011 | bool HasPOV() { return FALSE; } | |
1012 | bool HasPOV4Dir() { return FALSE; } | |
1013 | bool HasPOVCTS() { return FALSE; } | |
1014 | ||
1015 | bool SetCapture(wxWindow* win, int pollingFreq = 0) { return FALSE; } | |
1016 | bool ReleaseCapture() { return FALSE; } | |
1017 | }; | |
1018 | #endif | |
1019 | %} | |
1020 | ||
1021 | ||
1022 | class wxJoystick : public wxObject { | |
1023 | public: | |
1024 | wxJoystick(int joystick = wxJOYSTICK1); | |
1025 | ~wxJoystick(); | |
1026 | ||
1027 | wxPoint GetPosition(); | |
1028 | int GetZPosition(); | |
1029 | int GetButtonState(); | |
1030 | int GetPOVPosition(); | |
1031 | int GetPOVCTSPosition(); | |
1032 | int GetRudderPosition(); | |
1033 | int GetUPosition(); | |
1034 | int GetVPosition(); | |
1035 | int GetMovementThreshold(); | |
1036 | void SetMovementThreshold(int threshold) ; | |
1037 | ||
1038 | bool IsOk(void); | |
1039 | int GetNumberJoysticks(); | |
1040 | int GetManufacturerId(); | |
1041 | int GetProductId(); | |
1042 | wxString GetProductName(); | |
1043 | int GetXMin(); | |
1044 | int GetYMin(); | |
1045 | int GetZMin(); | |
1046 | int GetXMax(); | |
1047 | int GetYMax(); | |
1048 | int GetZMax(); | |
1049 | int GetNumberButtons(); | |
1050 | int GetNumberAxes(); | |
1051 | int GetMaxButtons(); | |
1052 | int GetMaxAxes(); | |
1053 | int GetPollingMin(); | |
1054 | int GetPollingMax(); | |
1055 | int GetRudderMin(); | |
1056 | int GetRudderMax(); | |
1057 | int GetUMin(); | |
1058 | int GetUMax(); | |
1059 | int GetVMin(); | |
1060 | int GetVMax(); | |
1061 | ||
1062 | bool HasRudder(); | |
1063 | bool HasZ(); | |
1064 | bool HasU(); | |
1065 | bool HasV(); | |
1066 | bool HasPOV(); | |
1067 | bool HasPOV4Dir(); | |
1068 | bool HasPOVCTS(); | |
1069 | ||
1070 | bool SetCapture(wxWindow* win, int pollingFreq = 0); | |
1071 | bool ReleaseCapture(); | |
1072 | ||
1073 | %pragma(python) addtoclass = "def __nonzero__(self): return self.IsOk()" | |
1074 | }; | |
1075 | ||
1076 | //---------------------------------------------------------------------- | |
1077 | ||
1078 | %{ | |
1079 | #if !wxUSE_WAVE | |
1080 | // A C++ stub class for wxWave for platforms that don't have it. | |
1081 | class wxWave : public wxObject | |
1082 | { | |
1083 | public: | |
1084 | wxWave(const wxString& fileName, bool isResource = FALSE) { | |
1085 | wxPyBeginBlockThreads(); | |
1086 | PyErr_SetString(PyExc_NotImplementedError, "wxWave is not available on this platform."); | |
1087 | wxPyEndBlockThreads(); | |
1088 | } | |
1089 | wxWave(int size, const wxByte* data) { | |
1090 | wxPyBeginBlockThreads(); | |
1091 | PyErr_SetString(PyExc_NotImplementedError, "wxWave is not available on this platform."); | |
1092 | wxPyEndBlockThreads(); | |
1093 | } | |
1094 | ||
1095 | ~wxWave() {} | |
1096 | ||
1097 | bool IsOk() const { return FALSE; } | |
1098 | bool Play(bool async = TRUE, bool looped = FALSE) const { return FALSE; } | |
1099 | }; | |
1100 | ||
1101 | #endif | |
1102 | %} | |
1103 | ||
1104 | class wxWave : public wxObject | |
1105 | { | |
1106 | public: | |
1107 | wxWave(const wxString& fileName, bool isResource = FALSE); | |
1108 | ~wxWave(); | |
1109 | ||
1110 | bool IsOk() const; | |
1111 | bool Play(bool async = TRUE, bool looped = FALSE) const; | |
1112 | ||
1113 | %pragma(python) addtoclass = "def __nonzero__(self): return self.IsOk()" | |
1114 | }; | |
1115 | ||
1116 | %new wxWave* wxWaveData(const wxString& data); | |
1117 | %{ // Implementations of some alternate "constructors" | |
1118 | wxWave* wxWaveData(const wxString& data) { | |
1119 | return new wxWave(data.Len(), (wxByte*)data.c_str()); | |
1120 | } | |
1121 | %} | |
1122 | ||
1123 | ||
1124 | //---------------------------------------------------------------------- | |
1125 | ||
1126 | enum wxMailcapStyle | |
1127 | { | |
1128 | wxMAILCAP_STANDARD = 1, | |
1129 | wxMAILCAP_NETSCAPE = 2, | |
1130 | wxMAILCAP_KDE = 4, | |
1131 | wxMAILCAP_GNOME = 8, | |
1132 | ||
1133 | wxMAILCAP_ALL = 15 | |
1134 | }; | |
1135 | ||
1136 | ||
1137 | ||
1138 | class wxFileTypeInfo | |
1139 | { | |
1140 | public: | |
1141 | // ctors | |
1142 | // a normal item | |
1143 | wxFileTypeInfo(const wxString& mimeType, | |
1144 | const wxString& openCmd, | |
1145 | const wxString& printCmd, | |
1146 | const wxString& desc); | |
1147 | ||
1148 | ||
1149 | // the array elements correspond to the parameters of the ctor above in | |
1150 | // the same order | |
1151 | %name(wxFileTypeInfoSequence)wxFileTypeInfo(const wxArrayString& sArray); | |
1152 | ||
1153 | // invalid item - use this to terminate the array passed to | |
1154 | // wxMimeTypesManager::AddFallbacks | |
1155 | %name(wxNullFileTypeInfo)wxFileTypeInfo(); | |
1156 | ||
1157 | ||
1158 | // test if this object can be used | |
1159 | bool IsValid() const; | |
1160 | ||
1161 | // setters | |
1162 | // set the icon info | |
1163 | void SetIcon(const wxString& iconFile, int iconIndex = 0); | |
1164 | ||
1165 | // set the short desc | |
1166 | void SetShortDesc(const wxString& shortDesc); | |
1167 | ||
1168 | // accessors | |
1169 | // get the MIME type | |
1170 | const wxString& GetMimeType() const; | |
1171 | // get the open command | |
1172 | const wxString& GetOpenCommand() const; | |
1173 | // get the print command | |
1174 | const wxString& GetPrintCommand() const; | |
1175 | // get the short description (only used under Win32 so far) | |
1176 | const wxString& GetShortDesc() const; | |
1177 | // get the long, user visible description | |
1178 | const wxString& GetDescription() const; | |
1179 | ||
1180 | ||
1181 | // get the array of all extensions | |
1182 | //const wxArrayString& GetExtensions() const; | |
1183 | %addmethods { | |
1184 | PyObject* GetExtensions() { | |
1185 | wxArrayString& arr = (wxArrayString&)self->GetExtensions(); | |
1186 | return wxArrayString2PyList_helper(arr); | |
1187 | } | |
1188 | } | |
1189 | ||
1190 | int GetExtensionsCount() const; | |
1191 | ||
1192 | // get the icon info | |
1193 | const wxString& GetIconFile() const; | |
1194 | int GetIconIndex() const; | |
1195 | }; | |
1196 | ||
1197 | ||
1198 | ||
1199 | ||
1200 | class wxFileType | |
1201 | { | |
1202 | public: | |
1203 | ||
1204 | // TODO: Make a wxPyMessageParameters with virtual GetParamValue... | |
1205 | ||
1206 | // An object of this class must be passed to Get{Open|Print}Command. The | |
1207 | // default implementation is trivial and doesn't know anything at all about | |
1208 | // parameters, only filename and MIME type are used (so it's probably ok for | |
1209 | // Windows where %{param} is not used anyhow) | |
1210 | class MessageParameters | |
1211 | { | |
1212 | public: | |
1213 | // ctors | |
1214 | MessageParameters(const wxString& filename=wxPyEmptyString, | |
1215 | const wxString& mimetype=wxPyEmptyString); | |
1216 | ||
1217 | // accessors (called by GetOpenCommand) | |
1218 | // filename | |
1219 | const wxString& GetFileName() const; | |
1220 | // mime type | |
1221 | const wxString& GetMimeType() const;; | |
1222 | ||
1223 | // override this function in derived class | |
1224 | virtual wxString GetParamValue(const wxString& name) const; | |
1225 | ||
1226 | // virtual dtor as in any base class | |
1227 | virtual ~MessageParameters(); | |
1228 | }; | |
1229 | ||
1230 | ||
1231 | // ctor from static data | |
1232 | wxFileType(const wxFileTypeInfo& ftInfo); | |
1233 | ||
1234 | // return the MIME type for this file type | |
1235 | %addmethods { | |
1236 | PyObject* GetMimeType() { | |
1237 | wxString str; | |
1238 | if (self->GetMimeType(&str)) { | |
1239 | #if wxUSE_UNICODE | |
1240 | return PyUnicode_FromWideChar(str.c_str(), str.Len()); | |
1241 | #else | |
1242 | return PyString_FromStringAndSize(str.c_str(), str.Len()); | |
1243 | #endif | |
1244 | } | |
1245 | else | |
1246 | RETURN_NONE(); | |
1247 | } | |
1248 | PyObject* GetMimeTypes() { | |
1249 | wxArrayString arr; | |
1250 | if (self->GetMimeTypes(arr)) | |
1251 | return wxArrayString2PyList_helper(arr); | |
1252 | else | |
1253 | RETURN_NONE(); | |
1254 | } | |
1255 | } | |
1256 | ||
1257 | ||
1258 | // Get all extensions associated with this file type | |
1259 | %addmethods { | |
1260 | PyObject* GetExtensions() { | |
1261 | wxArrayString arr; | |
1262 | if (self->GetExtensions(arr)) | |
1263 | return wxArrayString2PyList_helper(arr); | |
1264 | else | |
1265 | RETURN_NONE(); | |
1266 | } | |
1267 | } | |
1268 | ||
1269 | ||
1270 | %addmethods { | |
1271 | // Get the icon corresponding to this file type | |
1272 | %new wxIcon* GetIcon() { | |
1273 | wxIconLocation loc; | |
1274 | if (self->GetIcon(&loc)) | |
1275 | return new wxIcon(loc); | |
1276 | else | |
1277 | return NULL; | |
1278 | } | |
1279 | ||
1280 | // Get the icon corresponding to this file type, the name of the file | |
1281 | // where this icon resides, and its index in this file if applicable. | |
1282 | PyObject* GetIconInfo() { | |
1283 | wxIconLocation loc; | |
1284 | if (self->GetIcon(&loc)) { | |
1285 | wxString iconFile = loc.GetFileName(); | |
1286 | int iconIndex = -1; | |
1287 | #ifdef __WXMSW__ | |
1288 | iconIndex = loc.GetIndex(); | |
1289 | #endif | |
1290 | // Make a tuple and put the values in it | |
1291 | wxPyBeginBlockThreads(); | |
1292 | PyObject* tuple = PyTuple_New(3); | |
1293 | PyTuple_SetItem(tuple, 0, | |
1294 | wxPyConstructObject(new wxIcon(loc), wxT("wxIcon"), TRUE)); | |
1295 | #if wxUSE_UNICODE | |
1296 | PyTuple_SetItem(tuple, 1, PyUnicode_FromWideChar(iconFile.c_str(), iconFile.Len())); | |
1297 | #else | |
1298 | PyTuple_SetItem(tuple, 1, PyString_FromStringAndSize(iconFile.c_str(), iconFile.Len())); | |
1299 | #endif | |
1300 | PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex)); | |
1301 | wxPyEndBlockThreads(); | |
1302 | return tuple; | |
1303 | } | |
1304 | else | |
1305 | RETURN_NONE(); | |
1306 | } | |
1307 | } | |
1308 | ||
1309 | %addmethods { | |
1310 | // get a brief file type description ("*.txt" => "text document") | |
1311 | PyObject* GetDescription() { | |
1312 | wxString str; | |
1313 | if (self->GetDescription(&str)) { | |
1314 | #if wxUSE_UNICODE | |
1315 | return PyUnicode_FromWideChar(str.c_str(), str.Len()); | |
1316 | #else | |
1317 | return PyString_FromStringAndSize(str.c_str(), str.Len()); | |
1318 | #endif | |
1319 | } else | |
1320 | RETURN_NONE(); | |
1321 | } | |
1322 | } | |
1323 | ||
1324 | ||
1325 | // get the command to open/execute the file of given type | |
1326 | %addmethods { | |
1327 | PyObject* GetOpenCommand(const wxString& filename, | |
1328 | const wxString& mimetype=wxPyEmptyString) { | |
1329 | wxString str; | |
1330 | if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype))) { | |
1331 | #if wxUSE_UNICODE | |
1332 | return PyUnicode_FromWideChar(str.c_str(), str.Len()); | |
1333 | #else | |
1334 | return PyString_FromStringAndSize(str.c_str(), str.Len()); | |
1335 | #endif | |
1336 | } else | |
1337 | RETURN_NONE(); | |
1338 | } | |
1339 | } | |
1340 | ||
1341 | ||
1342 | // get the command to print the file of given type | |
1343 | %addmethods { | |
1344 | PyObject* GetPrintCommand(const wxString& filename, | |
1345 | const wxString& mimetype=wxPyEmptyString) { | |
1346 | wxString str; | |
1347 | if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype))) { | |
1348 | #if wxUSE_UNICODE | |
1349 | return PyUnicode_FromWideChar(str.c_str(), str.Len()); | |
1350 | #else | |
1351 | return PyString_FromStringAndSize(str.c_str(), str.Len()); | |
1352 | #endif | |
1353 | } else | |
1354 | RETURN_NONE(); | |
1355 | } | |
1356 | } | |
1357 | ||
1358 | ||
1359 | // Get all commands defined for this file type | |
1360 | %addmethods { | |
1361 | PyObject* GetAllCommands(const wxString& filename, | |
1362 | const wxString& mimetype=wxPyEmptyString) { | |
1363 | wxArrayString verbs; | |
1364 | wxArrayString commands; | |
1365 | if (self->GetAllCommands(&verbs, &commands, | |
1366 | wxFileType::MessageParameters(filename, mimetype))) { | |
1367 | wxPyBeginBlockThreads(); | |
1368 | PyObject* tuple = PyTuple_New(2); | |
1369 | PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs)); | |
1370 | PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands)); | |
1371 | wxPyEndBlockThreads(); | |
1372 | return tuple; | |
1373 | } | |
1374 | else | |
1375 | RETURN_NONE(); | |
1376 | } | |
1377 | } | |
1378 | ||
1379 | ||
1380 | // set an arbitrary command, ask confirmation if it already exists and | |
1381 | // overwriteprompt is TRUE | |
1382 | bool SetCommand(const wxString& cmd, const wxString& verb, | |
1383 | bool overwriteprompt = TRUE); | |
1384 | ||
1385 | bool SetDefaultIcon(const wxString& cmd = wxPyEmptyString, int index = 0); | |
1386 | ||
1387 | ||
1388 | // remove the association for this filetype from the system MIME database: | |
1389 | // notice that it will only work if the association is defined in the user | |
1390 | // file/registry part, we will never modify the system-wide settings | |
1391 | bool Unassociate(); | |
1392 | ||
1393 | // operations | |
1394 | // expand a string in the format of GetOpenCommand (which may contain | |
1395 | // '%s' and '%t' format specificators for the file name and mime type | |
1396 | // and %{param} constructions). | |
1397 | static wxString ExpandCommand(const wxString& command, | |
1398 | const MessageParameters& params); | |
1399 | ||
1400 | // dtor (not virtual, shouldn't be derived from) | |
1401 | ~wxFileType(); | |
1402 | ||
1403 | }; | |
1404 | ||
1405 | ||
1406 | ||
1407 | ||
1408 | class wxMimeTypesManager | |
1409 | { | |
1410 | public: | |
1411 | // static helper functions | |
1412 | // ----------------------- | |
1413 | ||
1414 | // check if the given MIME type is the same as the other one: the | |
1415 | // second argument may contain wildcards ('*'), but not the first. If | |
1416 | // the types are equal or if the mimeType matches wildcard the function | |
1417 | // returns TRUE, otherwise it returns FALSE | |
1418 | static bool IsOfType(const wxString& mimeType, const wxString& wildcard); | |
1419 | ||
1420 | // ctor | |
1421 | wxMimeTypesManager(); | |
1422 | ||
1423 | // loads data from standard files according to the mailcap styles | |
1424 | // specified: this is a bitwise OR of wxMailcapStyle values | |
1425 | // | |
1426 | // use the extraDir parameter if you want to look for files in another | |
1427 | // directory | |
1428 | void Initialize(int mailcapStyle = wxMAILCAP_ALL, | |
1429 | const wxString& extraDir = wxPyEmptyString); | |
1430 | ||
1431 | // and this function clears all the data from the manager | |
1432 | void ClearData(); | |
1433 | ||
1434 | // Database lookup: all functions return a pointer to wxFileType object | |
1435 | // whose methods may be used to query it for the information you're | |
1436 | // interested in. If the return value is !NULL, caller is responsible for | |
1437 | // deleting it. | |
1438 | // get file type from file extension | |
1439 | %new wxFileType *GetFileTypeFromExtension(const wxString& ext); | |
1440 | ||
1441 | // get file type from MIME type (in format <category>/<format>) | |
1442 | %new wxFileType *GetFileTypeFromMimeType(const wxString& mimeType); | |
1443 | ||
1444 | // other operations: return TRUE if there were no errors or FALSE if there | |
1445 | // were some unreckognized entries (the good entries are always read anyhow) | |
1446 | // | |
1447 | ||
1448 | // read in additional file (the standard ones are read automatically) | |
1449 | // in mailcap format (see mimetype.cpp for description) | |
1450 | // | |
1451 | // 'fallback' parameter may be set to TRUE to avoid overriding the | |
1452 | // settings from other, previously parsed, files by this one: normally, | |
1453 | // the files read most recently would override the older files, but with | |
1454 | // fallback == TRUE this won't happen | |
1455 | bool ReadMailcap(const wxString& filename, bool fallback = FALSE); | |
1456 | ||
1457 | // read in additional file in mime.types format | |
1458 | bool ReadMimeTypes(const wxString& filename); | |
1459 | ||
1460 | // enumerate all known MIME types | |
1461 | %addmethods { | |
1462 | PyObject* EnumAllFileTypes() { | |
1463 | wxArrayString arr; | |
1464 | self->EnumAllFileTypes(arr); | |
1465 | return wxArrayString2PyList_helper(arr); | |
1466 | } | |
1467 | } | |
1468 | ||
1469 | // these functions can be used to provide default values for some of the | |
1470 | // MIME types inside the program itself (you may also use | |
1471 | // ReadMailcap(filenameWithDefaultTypes, TRUE /* use as fallback */) to | |
1472 | // achieve the same goal, but this requires having this info in a file). | |
1473 | // | |
1474 | void AddFallback(const wxFileTypeInfo& ft); | |
1475 | ||
1476 | ||
1477 | // create or remove associations | |
1478 | ||
1479 | // create a new association using the fields of wxFileTypeInfo (at least | |
1480 | // the MIME type and the extension should be set) | |
1481 | // if the other fields are empty, the existing values should be left alone | |
1482 | %new wxFileType *Associate(const wxFileTypeInfo& ftInfo); | |
1483 | ||
1484 | // undo Associate() | |
1485 | bool Unassociate(wxFileType *ft) ; | |
1486 | ||
1487 | // dtor (not virtual, shouldn't be derived from) | |
1488 | ~wxMimeTypesManager(); | |
1489 | }; | |
1490 | ||
1491 | ||
1492 | %readonly | |
1493 | %{ | |
1494 | #if 0 | |
1495 | %} | |
1496 | // See also wxPy_ReinitStockObjects in helpers.cpp | |
1497 | extern wxMimeTypesManager* wxTheMimeTypesManager; | |
1498 | %{ | |
1499 | #endif | |
1500 | %} | |
1501 | %readwrite | |
1502 | ||
1503 | //---------------------------------------------------------------------- | |
1504 | ||
1505 | %{ | |
1506 | #include <wx/artprov.h> | |
1507 | ||
1508 | DECLARE_DEF_STRING(ART_OTHER); | |
1509 | ||
1510 | %} | |
1511 | ||
1512 | %pragma(python) code = " | |
1513 | # Art clients | |
1514 | wxART_TOOLBAR = 'wxART_TOOLBAR_C' | |
1515 | wxART_MENU = 'wxART_MENU_C' | |
1516 | wxART_FRAME_ICON = 'wxART_FRAME_ICON_C' | |
1517 | wxART_CMN_DIALOG = 'wxART_CMN_DIALOG_C' | |
1518 | wxART_HELP_BROWSER = 'wxART_HELP_BROWSER_C' | |
1519 | wxART_MESSAGE_BOX = 'wxART_MESSAGE_BOX_C' | |
1520 | wxART_OTHER = 'wxART_OTHER_C' | |
1521 | ||
1522 | # Art IDs | |
1523 | wxART_ADD_BOOKMARK = 'wxART_ADD_BOOKMARK' | |
1524 | wxART_DEL_BOOKMARK = 'wxART_DEL_BOOKMARK' | |
1525 | wxART_HELP_SIDE_PANEL = 'wxART_HELP_SIDE_PANEL' | |
1526 | wxART_HELP_SETTINGS = 'wxART_HELP_SETTINGS' | |
1527 | wxART_HELP_BOOK = 'wxART_HELP_BOOK' | |
1528 | wxART_HELP_FOLDER = 'wxART_HELP_FOLDER' | |
1529 | wxART_HELP_PAGE = 'wxART_HELP_PAGE' | |
1530 | wxART_GO_BACK = 'wxART_GO_BACK' | |
1531 | wxART_GO_FORWARD = 'wxART_GO_FORWARD' | |
1532 | wxART_GO_UP = 'wxART_GO_UP' | |
1533 | wxART_GO_DOWN = 'wxART_GO_DOWN' | |
1534 | wxART_GO_TO_PARENT = 'wxART_GO_TO_PARENT' | |
1535 | wxART_GO_HOME = 'wxART_GO_HOME' | |
1536 | wxART_FILE_OPEN = 'wxART_FILE_OPEN' | |
1537 | wxART_PRINT = 'wxART_PRINT' | |
1538 | wxART_HELP = 'wxART_HELP' | |
1539 | wxART_TIP = 'wxART_TIP' | |
1540 | wxART_REPORT_VIEW = 'wxART_REPORT_VIEW' | |
1541 | wxART_LIST_VIEW = 'wxART_LIST_VIEW' | |
1542 | wxART_NEW_DIR = 'wxART_NEW_DIR' | |
1543 | wxART_FOLDER = 'wxART_FOLDER' | |
1544 | wxART_GO_DIR_UP = 'wxART_GO_DIR_UP' | |
1545 | wxART_EXECUTABLE_FILE = 'wxART_EXECUTABLE_FILE' | |
1546 | wxART_NORMAL_FILE = 'wxART_NORMAL_FILE' | |
1547 | wxART_TICK_MARK = 'wxART_TICK_MARK' | |
1548 | wxART_CROSS_MARK = 'wxART_CROSS_MARK' | |
1549 | wxART_ERROR = 'wxART_ERROR' | |
1550 | wxART_QUESTION = 'wxART_QUESTION' | |
1551 | wxART_WARNING = 'wxART_WARNING' | |
1552 | wxART_INFORMATION = 'wxART_INFORMATION' | |
1553 | wxART_MISSING_IMAGE = 'wxART_MISSING_IMAGE' | |
1554 | " | |
1555 | ||
1556 | %{ // Python aware wxArtProvider | |
1557 | class wxPyArtProvider : public wxArtProvider { | |
1558 | public: | |
1559 | ||
1560 | virtual wxBitmap CreateBitmap(const wxArtID& id, | |
1561 | const wxArtClient& client, | |
1562 | const wxSize& size) { | |
1563 | wxBitmap rval = wxNullBitmap; | |
1564 | wxPyBeginBlockThreads(); | |
1565 | if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) { | |
1566 | PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0); | |
1567 | PyObject* ro; | |
1568 | wxBitmap* ptr; | |
1569 | PyObject* s1, *s2; | |
1570 | s1 = wx2PyString(id); | |
1571 | s2 = wx2PyString(client); | |
1572 | ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so)); | |
1573 | Py_DECREF(so); | |
1574 | Py_DECREF(s1); | |
1575 | Py_DECREF(s2); | |
1576 | if (ro) { | |
1577 | if (!SWIG_GetPtrObj(ro, (void**)&ptr, "_wxBitmap_p")) | |
1578 | rval = *ptr; | |
1579 | Py_DECREF(ro); | |
1580 | } | |
1581 | } | |
1582 | wxPyEndBlockThreads(); | |
1583 | return rval; | |
1584 | } | |
1585 | ||
1586 | PYPRIVATE; | |
1587 | }; | |
1588 | %} | |
1589 | ||
1590 | // The one for SWIG to see | |
1591 | %name(wxArtProvider) class wxPyArtProvider : public wxObject | |
1592 | { | |
1593 | public: | |
1594 | wxPyArtProvider(); | |
1595 | ||
1596 | void _setCallbackInfo(PyObject* self, PyObject* _class); | |
1597 | %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxArtProvider)" | |
1598 | ||
1599 | // Add new provider to the top of providers stack. | |
1600 | static void PushProvider(wxPyArtProvider *provider); | |
1601 | ||
1602 | // Remove latest added provider and delete it. | |
1603 | static bool PopProvider(); | |
1604 | ||
1605 | // Remove provider. The provider must have been added previously! | |
1606 | // The provider is _not_ deleted. | |
1607 | static bool RemoveProvider(wxPyArtProvider *provider); | |
1608 | ||
1609 | // Query the providers for bitmap with given ID and return it. Return | |
1610 | // wxNullBitmap if no provider provides it. | |
1611 | static wxBitmap GetBitmap(const wxString& id, | |
1612 | const wxString& client = wxPyART_OTHER, | |
1613 | const wxSize& size = wxDefaultSize); | |
1614 | ||
1615 | // Query the providers for icon with given ID and return it. Return | |
1616 | // wxNullIcon if no provider provides it. | |
1617 | static wxIcon GetIcon(const wxString& id, | |
1618 | const wxString& client = wxPyART_OTHER, | |
1619 | const wxSize& size = wxDefaultSize); | |
1620 | ||
1621 | }; | |
1622 | ||
1623 | ||
1624 | //---------------------------------------------------------------------- | |
1625 | ||
1626 | %{ | |
1627 | #include <wx/docview.h> | |
1628 | %} | |
1629 | ||
1630 | class wxFileHistory : public wxObject | |
1631 | { | |
1632 | public: | |
1633 | wxFileHistory(int maxFiles = 9); | |
1634 | ~wxFileHistory(); | |
1635 | ||
1636 | // Operations | |
1637 | void AddFileToHistory(const wxString& file); | |
1638 | void RemoveFileFromHistory(int i); | |
1639 | int GetMaxFiles() const; | |
1640 | void UseMenu(wxMenu *menu); | |
1641 | ||
1642 | // Remove menu from the list (MDI child may be closing) | |
1643 | void RemoveMenu(wxMenu *menu); | |
1644 | ||
1645 | void Load(wxConfigBase& config); | |
1646 | void Save(wxConfigBase& config); | |
1647 | ||
1648 | void AddFilesToMenu(); | |
1649 | %name(AddFilesToThisMenu)void AddFilesToMenu(wxMenu* menu); | |
1650 | ||
1651 | // Accessors | |
1652 | wxString GetHistoryFile(int i) const; | |
1653 | ||
1654 | int GetCount() const; | |
1655 | %pragma(python) addtoclass = "GetNoHistoryFiles = GetCount" | |
1656 | ||
1657 | }; | |
1658 | ||
1659 | //---------------------------------------------------------------------- | |
1660 | ||
1661 | class wxEffects: public wxObject | |
1662 | { | |
1663 | public: | |
1664 | // Assume system colours | |
1665 | wxEffects(); | |
1666 | ||
1667 | wxColour GetHighlightColour() const; | |
1668 | wxColour GetLightShadow() const; | |
1669 | wxColour GetFaceColour() const; | |
1670 | wxColour GetMediumShadow() const; | |
1671 | wxColour GetDarkShadow() const; | |
1672 | ||
1673 | void SetHighlightColour(const wxColour& c); | |
1674 | void SetLightShadow(const wxColour& c); | |
1675 | void SetFaceColour(const wxColour& c); | |
1676 | void SetMediumShadow(const wxColour& c); | |
1677 | void SetDarkShadow(const wxColour& c); | |
1678 | ||
1679 | void Set(const wxColour& highlightColour, const wxColour& lightShadow, | |
1680 | const wxColour& faceColour, const wxColour& mediumShadow, | |
1681 | const wxColour& darkShadow); | |
1682 | ||
1683 | // Draw a sunken edge | |
1684 | void DrawSunkenEdge(wxDC& dc, const wxRect& rect, int borderSize = 1); | |
1685 | ||
1686 | // Tile a bitmap | |
1687 | bool TileBitmap(const wxRect& rect, wxDC& dc, wxBitmap& bitmap); | |
1688 | ||
1689 | }; | |
1690 | ||
1691 | //---------------------------------------------------------------------- | |
1692 | ||
1693 | class wxSingleInstanceChecker | |
1694 | { | |
1695 | public: | |
1696 | // like Create() but no error checking (dangerous!) | |
1697 | wxSingleInstanceChecker(const wxString& name, | |
1698 | const wxString& path = wxPyEmptyString); | |
1699 | ||
1700 | // default ctor, use Create() after it | |
1701 | %name(wxPreSingleInstanceChecker) wxSingleInstanceChecker(); | |
1702 | ||
1703 | ~wxSingleInstanceChecker(); | |
1704 | ||
1705 | ||
1706 | // name must be given and be as unique as possible, it is used as the mutex | |
1707 | // name under Win32 and the lock file name under Unix - | |
1708 | // wxTheApp->GetAppName() may be a good value for this parameter | |
1709 | // | |
1710 | // path is optional and is ignored under Win32 and used as the directory to | |
1711 | // create the lock file in under Unix (default is wxGetHomeDir()) | |
1712 | // | |
1713 | // returns FALSE if initialization failed, it doesn't mean that another | |
1714 | // instance is running - use IsAnotherRunning() to check it | |
1715 | bool Create(const wxString& name, const wxString& path = wxPyEmptyString); | |
1716 | ||
1717 | // is another copy of this program already running? | |
1718 | bool IsAnotherRunning() const; | |
1719 | }; | |
1720 | ||
1721 | //---------------------------------------------------------------------- | |
1722 | ||
1723 | ||
1724 | %init %{ | |
1725 | wxPyPtrTypeMap_Add("wxDragImage", "wxGenericDragImage"); | |
1726 | wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess"); | |
1727 | wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider"); | |
1728 | ||
1729 | %} | |
1730 | ||
1731 | //---------------------------------------------------------------------- | |
1732 |