]>
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 <wx/resource.h> | |
20 | #include <wx/tooltip.h> | |
21 | #include <wx/caret.h> | |
22 | #include <wx/fontenum.h> | |
23 | #include <wx/tipdlg.h> | |
24 | #include <wx/process.h> | |
25 | ||
26 | #if wxUSE_JOYSTICK || defined(__WXMSW__) | |
27 | #include <wx/joystick.h> | |
28 | #endif | |
29 | ||
30 | #if wxUSE_WAVE || defined(__WXMSW__) | |
31 | #include <wx/wave.h> | |
32 | #endif | |
33 | ||
34 | #include <wx/mimetype.h> | |
35 | %} | |
36 | ||
37 | //---------------------------------------------------------------------- | |
38 | ||
39 | %include typemaps.i | |
40 | %include my_typemaps.i | |
41 | ||
42 | // Import some definitions of other classes, etc. | |
43 | %import _defs.i | |
44 | %import windows.i | |
45 | %import misc.i | |
46 | %import gdi.i | |
47 | %import events.i | |
48 | %import streams.i | |
49 | %import utils.i | |
50 | ||
51 | %{ | |
52 | static wxString wxPyEmptyStr(""); | |
53 | %} | |
54 | ||
55 | //--------------------------------------------------------------------------- | |
56 | // Dialog Functions | |
57 | ||
58 | wxString wxFileSelector(char* message, | |
59 | char* default_path = NULL, | |
60 | char* default_filename = NULL, | |
61 | char* default_extension = NULL, | |
62 | char* wildcard = "*.*", | |
63 | int flags = 0, | |
64 | wxWindow *parent = NULL, | |
65 | int x = -1, int y = -1); | |
66 | ||
67 | wxString wxGetTextFromUser(const wxString& message, | |
68 | const wxString& caption = wxPyEmptyStr, | |
69 | const wxString& default_value = wxPyEmptyStr, | |
70 | wxWindow *parent = NULL, | |
71 | int x = -1, int y = -1, | |
72 | bool centre = TRUE); | |
73 | ||
74 | wxString wxGetPasswordFromUser(const wxString& message, | |
75 | const wxString& caption = wxPyEmptyStr, | |
76 | const wxString& default_value = wxPyEmptyStr, | |
77 | wxWindow *parent = NULL); | |
78 | ||
79 | ||
80 | // TODO: Need to custom wrap this one... | |
81 | // int wxGetMultipleChoice(char* message, char* caption, | |
82 | // int LCOUNT, char** choices, | |
83 | // int nsel, int *selection, | |
84 | // wxWindow *parent = NULL, int x = -1, int y = -1, | |
85 | // bool centre = TRUE, int width=150, int height=200); | |
86 | ||
87 | ||
88 | wxString wxGetSingleChoice(const wxString& message, const wxString& caption, | |
89 | int LCOUNT, wxString* choices, | |
90 | wxWindow *parent = NULL, | |
91 | int x = -1, int y = -1, | |
92 | bool centre = TRUE, | |
93 | int width=150, int height=200); | |
94 | ||
95 | int wxGetSingleChoiceIndex(const wxString& message, const wxString& caption, | |
96 | int LCOUNT, wxString* choices, | |
97 | wxWindow *parent = NULL, | |
98 | int x = -1, int y = -1, | |
99 | bool centre = TRUE, | |
100 | int width=150, int height=200); | |
101 | ||
102 | ||
103 | int wxMessageBox(const wxString& message, | |
104 | const wxString& caption = wxPyEmptyStr, | |
105 | int style = wxOK | wxCENTRE, | |
106 | wxWindow *parent = NULL, | |
107 | int x = -1, int y = -1); | |
108 | ||
109 | long wxGetNumberFromUser(const wxString& message, | |
110 | const wxString& prompt, | |
111 | const wxString& caption, | |
112 | long value, | |
113 | long min = 0, long max = 100, | |
114 | wxWindow *parent = NULL, | |
115 | const wxPoint& pos = wxDefaultPosition); | |
116 | ||
117 | //--------------------------------------------------------------------------- | |
118 | // GDI Functions | |
119 | ||
120 | bool wxColourDisplay(); | |
121 | ||
122 | int wxDisplayDepth(); | |
123 | int wxGetDisplayDepth(); | |
124 | ||
125 | void wxDisplaySize(int* OUTPUT, int* OUTPUT); | |
126 | wxSize wxGetDisplaySize(); | |
127 | ||
128 | void wxDisplaySizeMM(int* OUTPUT, int* OUTPUT); | |
129 | wxSize wxGetDisplaySizeMM(); | |
130 | ||
131 | void wxClientDisplayRect(int *OUTPUT, int *OUTPUT, int *OUTPUT, int *OUTPUT); | |
132 | wxRect wxGetClientDisplayRect(); | |
133 | ||
134 | void wxSetCursor(wxCursor& cursor); | |
135 | ||
136 | //---------------------------------------------------------------------- | |
137 | // Miscellaneous functions | |
138 | ||
139 | wxWindow * wxFindWindowByLabel(const wxString& label, wxWindow *parent=NULL); | |
140 | wxWindow * wxFindWindowByName(const wxString& name, wxWindow *parent=NULL); | |
141 | ||
142 | void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR); | |
143 | wxWindow * wxGetActiveWindow(); | |
144 | ||
145 | wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt); | |
146 | wxWindow* wxFindWindowAtPoint(const wxPoint& pt); | |
147 | ||
148 | #ifdef __WXMSW__ | |
149 | bool wxCheckForInterrupt(wxWindow *wnd); | |
150 | void wxFlushEvents(); | |
151 | #endif | |
152 | ||
153 | //--------------------------------------------------------------------------- | |
154 | // Resource System | |
155 | ||
156 | bool wxResourceAddIdentifier(char *name, int value); | |
157 | void wxResourceClear(void); | |
158 | wxBitmap wxResourceCreateBitmap(char *resource); | |
159 | wxIcon wxResourceCreateIcon(char *resource); | |
160 | wxMenuBar * wxResourceCreateMenuBar(char *resource); | |
161 | int wxResourceGetIdentifier(char *name); | |
162 | bool wxResourceParseData(char *resource, wxResourceTable *table = NULL); | |
163 | bool wxResourceParseFile(char *filename, wxResourceTable *table = NULL); | |
164 | bool wxResourceParseString(char *resource, wxResourceTable *table = NULL); | |
165 | ||
166 | //--------------------------------------------------------------------------- | |
167 | // System Settings | |
168 | ||
169 | enum { | |
170 | wxSYS_WHITE_BRUSH, | |
171 | wxSYS_LTGRAY_BRUSH, | |
172 | wxSYS_GRAY_BRUSH, | |
173 | wxSYS_DKGRAY_BRUSH, | |
174 | wxSYS_BLACK_BRUSH, | |
175 | wxSYS_NULL_BRUSH, | |
176 | wxSYS_HOLLOW_BRUSH, | |
177 | wxSYS_WHITE_PEN, | |
178 | wxSYS_BLACK_PEN, | |
179 | wxSYS_NULL_PEN, | |
180 | wxSYS_OEM_FIXED_FONT, | |
181 | wxSYS_ANSI_FIXED_FONT, | |
182 | wxSYS_ANSI_VAR_FONT, | |
183 | wxSYS_SYSTEM_FONT, | |
184 | wxSYS_DEVICE_DEFAULT_FONT, | |
185 | wxSYS_DEFAULT_PALETTE, | |
186 | wxSYS_SYSTEM_FIXED_FONT, | |
187 | wxSYS_DEFAULT_GUI_FONT, | |
188 | ||
189 | wxSYS_COLOUR_SCROLLBAR, | |
190 | wxSYS_COLOUR_BACKGROUND, | |
191 | wxSYS_COLOUR_ACTIVECAPTION, | |
192 | wxSYS_COLOUR_INACTIVECAPTION, | |
193 | wxSYS_COLOUR_MENU, | |
194 | wxSYS_COLOUR_WINDOW, | |
195 | wxSYS_COLOUR_WINDOWFRAME, | |
196 | wxSYS_COLOUR_MENUTEXT, | |
197 | wxSYS_COLOUR_WINDOWTEXT, | |
198 | wxSYS_COLOUR_CAPTIONTEXT, | |
199 | wxSYS_COLOUR_ACTIVEBORDER, | |
200 | wxSYS_COLOUR_INACTIVEBORDER, | |
201 | wxSYS_COLOUR_APPWORKSPACE, | |
202 | wxSYS_COLOUR_HIGHLIGHT, | |
203 | wxSYS_COLOUR_HIGHLIGHTTEXT, | |
204 | wxSYS_COLOUR_BTNFACE, | |
205 | wxSYS_COLOUR_BTNSHADOW, | |
206 | wxSYS_COLOUR_GRAYTEXT, | |
207 | wxSYS_COLOUR_BTNTEXT, | |
208 | wxSYS_COLOUR_INACTIVECAPTIONTEXT, | |
209 | wxSYS_COLOUR_BTNHIGHLIGHT, | |
210 | ||
211 | wxSYS_COLOUR_3DDKSHADOW, | |
212 | wxSYS_COLOUR_3DLIGHT, | |
213 | wxSYS_COLOUR_INFOTEXT, | |
214 | wxSYS_COLOUR_INFOBK, | |
215 | ||
216 | wxSYS_COLOUR_DESKTOP, | |
217 | wxSYS_COLOUR_3DFACE, | |
218 | wxSYS_COLOUR_3DSHADOW, | |
219 | wxSYS_COLOUR_3DHIGHLIGHT, | |
220 | wxSYS_COLOUR_3DHILIGHT, | |
221 | wxSYS_COLOUR_BTNHILIGHT, | |
222 | ||
223 | wxSYS_MOUSE_BUTTONS, | |
224 | wxSYS_BORDER_X, | |
225 | wxSYS_BORDER_Y, | |
226 | wxSYS_CURSOR_X, | |
227 | wxSYS_CURSOR_Y, | |
228 | wxSYS_DCLICK_X, | |
229 | wxSYS_DCLICK_Y, | |
230 | wxSYS_DRAG_X, | |
231 | wxSYS_DRAG_Y, | |
232 | wxSYS_EDGE_X, | |
233 | wxSYS_EDGE_Y, | |
234 | wxSYS_HSCROLL_ARROW_X, | |
235 | wxSYS_HSCROLL_ARROW_Y, | |
236 | wxSYS_HTHUMB_X, | |
237 | wxSYS_ICON_X, | |
238 | wxSYS_ICON_Y, | |
239 | wxSYS_ICONSPACING_X, | |
240 | wxSYS_ICONSPACING_Y, | |
241 | wxSYS_WINDOWMIN_X, | |
242 | wxSYS_WINDOWMIN_Y, | |
243 | wxSYS_SCREEN_X, | |
244 | wxSYS_SCREEN_Y, | |
245 | wxSYS_FRAMESIZE_X, | |
246 | wxSYS_FRAMESIZE_Y, | |
247 | wxSYS_SMALLICON_X, | |
248 | wxSYS_SMALLICON_Y, | |
249 | wxSYS_HSCROLL_Y, | |
250 | wxSYS_VSCROLL_X, | |
251 | wxSYS_VSCROLL_ARROW_X, | |
252 | wxSYS_VSCROLL_ARROW_Y, | |
253 | wxSYS_VTHUMB_Y, | |
254 | wxSYS_CAPTION_Y, | |
255 | wxSYS_MENU_Y, | |
256 | wxSYS_NETWORK_PRESENT, | |
257 | wxSYS_PENWINDOWS_PRESENT, | |
258 | wxSYS_SHOW_SOUNDS, | |
259 | wxSYS_SWAP_BUTTONS, | |
260 | }; | |
261 | ||
262 | ||
263 | ||
264 | %inline %{ | |
265 | ||
266 | wxColour wxSystemSettings_GetSystemColour(int index) { | |
267 | return wxSystemSettings::GetSystemColour(index); | |
268 | } | |
269 | ||
270 | wxFont wxSystemSettings_GetSystemFont(int index) { | |
271 | return wxSystemSettings::GetSystemFont(index); | |
272 | } | |
273 | ||
274 | int wxSystemSettings_GetSystemMetric(int index) { | |
275 | return wxSystemSettings::GetSystemMetric(index); | |
276 | } | |
277 | %} | |
278 | ||
279 | //--------------------------------------------------------------------------- | |
280 | // wxToolTip | |
281 | ||
282 | class wxToolTip : public wxObject { | |
283 | public: | |
284 | wxToolTip(const wxString &tip); | |
285 | ||
286 | void SetTip(const wxString& tip); | |
287 | wxString GetTip(); | |
288 | // *** Not in the "public" interface void SetWindow(wxWindow *win); | |
289 | wxWindow *GetWindow(); | |
290 | ||
291 | static void Enable(bool flag); | |
292 | static void SetDelay(long milliseconds); | |
293 | }; | |
294 | ||
295 | //---------------------------------------------------------------------- | |
296 | ||
297 | class wxCaret { | |
298 | public: | |
299 | wxCaret(wxWindow* window, const wxSize& size); | |
300 | ~wxCaret(); | |
301 | ||
302 | bool IsOk(); | |
303 | bool IsVisible(); | |
304 | %name(GetPositionTuple)void GetPosition(int *OUTPUT, int *OUTPUT); | |
305 | wxPoint GetPosition(); | |
306 | %name(GetSizeTuple)void GetSize(int *OUTPUT, int *OUTPUT); | |
307 | wxSize GetSize(); | |
308 | wxWindow *GetWindow(); | |
309 | %name(MoveXY)void Move(int x, int y); | |
310 | void Move(const wxPoint& pt); | |
311 | %name(SetSizeWH) void SetSize(int width, int height); | |
312 | void SetSize(const wxSize& size); | |
313 | void Show(int show = TRUE); | |
314 | void Hide(); | |
315 | }; | |
316 | ||
317 | %inline %{ | |
318 | int wxCaret_GetBlinkTime() { | |
319 | return wxCaret::GetBlinkTime(); | |
320 | } | |
321 | ||
322 | void wxCaret_SetBlinkTime(int milliseconds) { | |
323 | wxCaret::SetBlinkTime(milliseconds); | |
324 | } | |
325 | %} | |
326 | ||
327 | //---------------------------------------------------------------------- | |
328 | ||
329 | %{ | |
330 | class wxPyFontEnumerator : public wxFontEnumerator { | |
331 | public: | |
332 | wxPyFontEnumerator() {} | |
333 | ~wxPyFontEnumerator() {} | |
334 | ||
335 | DEC_PYCALLBACK_BOOL_STRING(OnFacename); | |
336 | DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding); | |
337 | ||
338 | PYPRIVATE; | |
339 | }; | |
340 | ||
341 | IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename); | |
342 | IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding); | |
343 | ||
344 | %} | |
345 | ||
346 | %name(wxFontEnumerator) class wxPyFontEnumerator { | |
347 | public: | |
348 | wxPyFontEnumerator(); | |
349 | ~wxPyFontEnumerator(); | |
350 | void _setCallbackInfo(PyObject* self, PyObject* _class, bool incref); | |
351 | %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxFontEnumerator, 0)" | |
352 | ||
353 | bool EnumerateFacenames( | |
354 | wxFontEncoding encoding = wxFONTENCODING_SYSTEM, // all | |
355 | bool fixedWidthOnly = FALSE); | |
356 | bool EnumerateEncodings(const char* facename = ""); | |
357 | ||
358 | //wxArrayString* GetEncodings(); | |
359 | //wxArrayString* GetFacenames(); | |
360 | %addmethods { | |
361 | PyObject* GetEncodings() { | |
362 | wxArrayString* arr = self->GetEncodings(); | |
363 | return wxArrayString2PyList_helper(*arr); | |
364 | } | |
365 | ||
366 | PyObject* GetFacenames() { | |
367 | wxArrayString* arr = self->GetFacenames(); | |
368 | return wxArrayString2PyList_helper(*arr); | |
369 | } | |
370 | } | |
371 | }; | |
372 | ||
373 | //---------------------------------------------------------------------- | |
374 | ||
375 | class wxBusyCursor { | |
376 | public: | |
377 | wxBusyCursor(wxCursor* cursor = wxHOURGLASS_CURSOR); | |
378 | ~wxBusyCursor(); | |
379 | }; | |
380 | ||
381 | //---------------------------------------------------------------------- | |
382 | ||
383 | class wxWindowDisabler { | |
384 | public: | |
385 | wxWindowDisabler(wxWindow *winToSkip = NULL); | |
386 | ~wxWindowDisabler(); | |
387 | }; | |
388 | ||
389 | //---------------------------------------------------------------------- | |
390 | ||
391 | bool wxSafeYield(wxWindow* win=NULL); | |
392 | void wxPostEvent(wxEvtHandler *dest, wxEvent& event); | |
393 | void wxWakeUpIdle(); | |
394 | ||
395 | ||
396 | #ifdef __WXMSW__ | |
397 | void wxWakeUpMainThread(); | |
398 | #endif | |
399 | ||
400 | void wxMutexGuiEnter(); | |
401 | void wxMutexGuiLeave(); | |
402 | ||
403 | ||
404 | class wxMutexGuiLocker { | |
405 | public: | |
406 | wxMutexGuiLocker(); | |
407 | ~wxMutexGuiLocker(); | |
408 | }; | |
409 | ||
410 | ||
411 | %inline %{ | |
412 | bool wxThread_IsMain() { | |
413 | #ifdef WXP_WITH_THREAD | |
414 | return wxThread::IsMain(); | |
415 | #else | |
416 | return TRUE; | |
417 | #endif | |
418 | } | |
419 | %} | |
420 | ||
421 | //---------------------------------------------------------------------- | |
422 | ||
423 | ||
424 | class wxTipProvider | |
425 | { | |
426 | public: | |
427 | // wxTipProvider(size_t currentTip); **** Abstract base class | |
428 | ~wxTipProvider(); | |
429 | ||
430 | virtual wxString GetTip() = 0; | |
431 | size_t GetCurrentTip(); | |
432 | ||
433 | }; | |
434 | ||
435 | ||
436 | // The C++ version of wxPyTipProvider | |
437 | %{ | |
438 | class wxPyTipProvider : public wxTipProvider { | |
439 | public: | |
440 | wxPyTipProvider(size_t currentTip) | |
441 | : wxTipProvider(currentTip) {} | |
442 | ||
443 | DEC_PYCALLBACK_STRING__pure(GetTip); | |
444 | ||
445 | PYPRIVATE; | |
446 | }; | |
447 | ||
448 | IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip); | |
449 | ||
450 | %} | |
451 | ||
452 | ||
453 | // Now let SWIG know about it | |
454 | class wxPyTipProvider : public wxTipProvider { | |
455 | public: | |
456 | wxPyTipProvider(size_t currentTip); | |
457 | }; | |
458 | ||
459 | ||
460 | ||
461 | bool wxShowTip(wxWindow *parent, wxTipProvider *tipProvider, bool showAtStartup = TRUE); | |
462 | %new wxTipProvider * wxCreateFileTipProvider(const wxString& filename, size_t currentTip); | |
463 | ||
464 | ||
465 | //---------------------------------------------------------------------- | |
466 | ||
467 | %{ | |
468 | #include <wx/generic/dragimgg.h> | |
469 | %} | |
470 | ||
471 | %name (wxDragImage) class wxGenericDragImage : public wxObject | |
472 | { | |
473 | public: | |
474 | ||
475 | wxGenericDragImage(const wxBitmap& image, | |
476 | const wxCursor& cursor = wxNullCursor); | |
477 | %name(wxDragIcon)wxGenericDragImage(const wxIcon& image, | |
478 | const wxCursor& cursor = wxNullCursor); | |
479 | %name(wxDragString)wxGenericDragImage(const wxString& str, | |
480 | const wxCursor& cursor = wxNullCursor); | |
481 | %name(wxDragTreeItem)wxGenericDragImage(const wxTreeCtrl& treeCtrl, wxTreeItemId& id); | |
482 | %name(wxDragListItem)wxGenericDragImage(const wxListCtrl& listCtrl, long id); | |
483 | ||
484 | ~wxGenericDragImage(); | |
485 | ||
486 | void SetBackingBitmap(wxBitmap* bitmap); | |
487 | bool BeginDrag(const wxPoint& hotspot, wxWindow* window, | |
488 | bool fullScreen = FALSE, wxRect* rect = NULL); | |
489 | ||
490 | %name(BeginDrag2) bool BeginDrag(const wxPoint& hotspot, wxWindow* window, | |
491 | wxWindow* fullScreenRect); | |
492 | ||
493 | bool EndDrag(); | |
494 | bool Move(const wxPoint& pt); | |
495 | bool Show(); | |
496 | bool Hide(); | |
497 | ||
498 | wxRect GetImageRect(const wxPoint& pos) const; | |
499 | bool RedrawImage(const wxPoint& oldPos, const wxPoint& newPos, | |
500 | bool eraseOld, bool drawNew); | |
501 | }; | |
502 | ||
503 | ||
504 | //---------------------------------------------------------------------- | |
505 | ||
506 | class wxPyTimer : public wxObject { | |
507 | public: | |
508 | wxPyTimer(PyObject* notify); | |
509 | ~wxPyTimer(); | |
510 | int GetInterval(); | |
511 | bool IsOneShot(); | |
512 | bool IsRunning(); | |
513 | void SetOwner(wxEvtHandler *owner, int id = -1); | |
514 | void Start(int milliseconds=-1, int oneShot=FALSE); | |
515 | void Stop(); | |
516 | }; | |
517 | ||
518 | ||
519 | class wxStopWatch | |
520 | { | |
521 | public: | |
522 | // ctor starts the stop watch | |
523 | wxStopWatch(); | |
524 | void Start(long t = 0); | |
525 | void Pause(); | |
526 | void Resume(); | |
527 | ||
528 | // get elapsed time since the last Start() or Pause() in milliseconds | |
529 | long Time() const; | |
530 | }; | |
531 | ||
532 | ||
533 | //---------------------------------------------------------------------- | |
534 | //---------------------------------------------------------------------- | |
535 | ||
536 | ||
537 | enum | |
538 | { | |
539 | wxLOG_FatalError, // program can't continue, abort immediately | |
540 | wxLOG_Error, // a serious error, user must be informed about it | |
541 | wxLOG_Warning, // user is normally informed about it but may be ignored | |
542 | wxLOG_Message, // normal message (i.e. normal output of a non GUI app) | |
543 | wxLOG_Info, // informational message (a.k.a. 'Verbose') | |
544 | wxLOG_Status, // informational: might go to the status line of GUI app | |
545 | wxLOG_Debug, // never shown to the user, disabled in release mode | |
546 | wxLOG_Trace, // trace messages are also only enabled in debug mode | |
547 | wxLOG_Progress, // used for progress indicator (not yet) | |
548 | wxLOG_User = 100 // user defined levels start here | |
549 | }; | |
550 | ||
551 | ||
552 | class wxLog | |
553 | { | |
554 | public: | |
555 | wxLog(); | |
556 | ||
557 | static bool IsEnabled(); | |
558 | static bool EnableLogging(bool doIt = TRUE); | |
559 | static void OnLog(wxLogLevel level, const char *szString, int t=0); | |
560 | ||
561 | virtual void Flush(); | |
562 | bool HasPendingMessages() const; | |
563 | ||
564 | static void FlushActive(); | |
565 | static wxLog *GetActiveTarget(); | |
566 | static wxLog *SetActiveTarget(wxLog *pLogger); | |
567 | ||
568 | static void Suspend(); | |
569 | static void Resume(); | |
570 | ||
571 | void SetVerbose(bool bVerbose = TRUE); | |
572 | ||
573 | static void DontCreateOnDemand(); | |
574 | static void SetTraceMask(wxTraceMask ulMask); | |
575 | static void AddTraceMask(const wxString& str); | |
576 | static void RemoveTraceMask(const wxString& str); | |
577 | static void ClearTraceMasks(); | |
578 | ||
579 | static void SetTimestamp(const wxChar *ts); | |
580 | static const wxChar *GetTimestamp(); | |
581 | ||
582 | bool GetVerbose() const { return m_bVerbose; } | |
583 | ||
584 | static wxTraceMask GetTraceMask(); | |
585 | static bool IsAllowedTraceMask(const char *mask); | |
586 | ||
587 | // static void TimeStamp(wxString *str); | |
588 | %addmethods { | |
589 | wxString TimeStamp() { | |
590 | wxString msg; | |
591 | wxLog::TimeStamp(&msg); | |
592 | return msg; | |
593 | } | |
594 | } | |
595 | }; | |
596 | ||
597 | ||
598 | class wxLogStderr : public wxLog | |
599 | { | |
600 | public: | |
601 | wxLogStderr(/* TODO: FILE *fp = (FILE *) NULL*/); | |
602 | }; | |
603 | ||
604 | ||
605 | class wxLogTextCtrl : public wxLog | |
606 | { | |
607 | public: | |
608 | wxLogTextCtrl(wxTextCtrl *pTextCtrl); | |
609 | }; | |
610 | ||
611 | ||
612 | class wxLogGui : public wxLog | |
613 | { | |
614 | public: | |
615 | wxLogGui(); | |
616 | }; | |
617 | ||
618 | class wxLogWindow : public wxLog | |
619 | { | |
620 | public: | |
621 | wxLogWindow(wxFrame *pParent, // the parent frame (can be NULL) | |
622 | const char *szTitle, // the title of the frame | |
623 | bool bShow = TRUE, // show window immediately? | |
624 | bool bPassToOld = TRUE); // pass log messages to the old target? | |
625 | ||
626 | void Show(bool bShow = TRUE); | |
627 | wxFrame *GetFrame() const; | |
628 | wxLog *GetOldLog() const; | |
629 | bool IsPassingMessages() const; | |
630 | void PassMessages(bool bDoPass) { m_bPassMessages = bDoPass; } | |
631 | }; | |
632 | ||
633 | ||
634 | class wxLogNull | |
635 | { | |
636 | public: | |
637 | wxLogNull(); | |
638 | ~wxLogNull(); | |
639 | }; | |
640 | ||
641 | ||
642 | class wxLogChain : public wxLog | |
643 | { | |
644 | public: | |
645 | wxLogChain(wxLog *logger); | |
646 | void SetLog(wxLog *logger); | |
647 | void PassMessages(bool bDoPass); | |
648 | bool IsPassingMessages(); | |
649 | wxLog *GetOldLog(); | |
650 | }; | |
651 | ||
652 | ||
653 | unsigned long wxSysErrorCode(); | |
654 | const char* wxSysErrorMsg(unsigned long nErrCode = 0); | |
655 | void wxLogFatalError(const char *szFormat); | |
656 | void wxLogError(const char *szFormat); | |
657 | void wxLogWarning(const char *szFormat); | |
658 | void wxLogMessage(const char *szFormat); | |
659 | void wxLogInfo(const char *szFormat); | |
660 | void wxLogVerbose(const char *szFormat); | |
661 | void wxLogStatus(const char *szFormat); | |
662 | %name(wxLogStatusFrame)void wxLogStatus(wxFrame *pFrame, const char *szFormat); | |
663 | void wxLogSysError(const char *szFormat); | |
664 | ||
665 | ||
666 | %{ | |
667 | // A Log class that can be derived from in wxPython | |
668 | class wxPyLog : public wxLog { | |
669 | public: | |
670 | wxPyLog() : wxLog() {} | |
671 | ||
672 | virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) { | |
673 | bool found; | |
674 | wxPyBeginBlockThreads(); | |
675 | if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) | |
676 | wxPyCBH_callCallback(m_myInst, Py_BuildValue("(isi)", level, szString, t)); | |
677 | wxPyEndBlockThreads(); | |
678 | if (! found) | |
679 | wxLog::DoLog(level, szString, t); | |
680 | } | |
681 | ||
682 | virtual void DoLogString(const wxChar *szString, time_t t) { | |
683 | bool found; | |
684 | wxPyBeginBlockThreads(); | |
685 | if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) | |
686 | wxPyCBH_callCallback(m_myInst, Py_BuildValue("(si)", szString, t)); | |
687 | wxPyEndBlockThreads(); | |
688 | if (! found) | |
689 | wxLog::DoLogString(szString, t); | |
690 | } | |
691 | ||
692 | PYPRIVATE; | |
693 | }; | |
694 | %} | |
695 | ||
696 | // Now tell SWIG about it | |
697 | class wxPyLog : public wxLog { | |
698 | public: | |
699 | wxPyLog(); | |
700 | void _setCallbackInfo(PyObject* self, PyObject* _class); | |
701 | %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyLog)" | |
702 | %addmethods { void Destroy() { delete self; } } | |
703 | ||
704 | }; | |
705 | ||
706 | ||
707 | //---------------------------------------------------------------------- | |
708 | ||
709 | ||
710 | enum { | |
711 | /* event type */ | |
712 | wxEVT_END_PROCESS | |
713 | }; | |
714 | ||
715 | ||
716 | class wxProcessEvent : public wxEvent { | |
717 | public: | |
718 | wxProcessEvent(int id = 0, int pid = 0, int exitcode = 0); | |
719 | int GetPid(); | |
720 | int GetExitCode(); | |
721 | int m_pid, m_exitcode; | |
722 | }; | |
723 | ||
724 | ||
725 | ||
726 | ||
727 | %{ // C++ version of wxProcess derived class | |
728 | ||
729 | class wxPyProcess : public wxProcess { | |
730 | public: | |
731 | wxPyProcess(wxEvtHandler *parent = NULL, int id = -1) | |
732 | : wxProcess(parent, id) | |
733 | {} | |
734 | ||
735 | DEC_PYCALLBACK_VOID_INTINT(OnTerminate); | |
736 | ||
737 | PYPRIVATE; | |
738 | }; | |
739 | ||
740 | IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate); | |
741 | ||
742 | %} | |
743 | ||
744 | ||
745 | %name(wxProcess)class wxPyProcess : public wxEvtHandler { | |
746 | public: | |
747 | wxPyProcess(wxEvtHandler *parent = NULL, int id = -1); | |
748 | %addmethods { void Destroy() { delete self; } } | |
749 | ||
750 | void _setCallbackInfo(PyObject* self, PyObject* _class); | |
751 | %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxProcess)" | |
752 | ||
753 | void base_OnTerminate(int pid, int status); | |
754 | ||
755 | void Redirect(); | |
756 | bool IsRedirected(); | |
757 | void Detach(); | |
758 | ||
759 | wxInputStream *GetInputStream(); | |
760 | wxInputStream *GetErrorStream(); | |
761 | wxOutputStream *GetOutputStream(); | |
762 | ||
763 | void CloseOutput(); | |
764 | }; | |
765 | ||
766 | ||
767 | ||
768 | long wxExecute(const wxString& command, | |
769 | int sync = FALSE, | |
770 | wxPyProcess *process = NULL); | |
771 | ||
772 | //---------------------------------------------------------------------- | |
773 | ||
774 | %{ | |
775 | #if !wxUSE_JOYSTICK && !defined(__WXMSW__) | |
776 | // A C++ stub class for wxJoystick for platforms that don't have it. | |
777 | class wxJoystick : public wxObject { | |
778 | public: | |
779 | wxJoystick(int joystick = wxJOYSTICK1) { | |
780 | wxPyBeginBlockThreads(); | |
781 | PyErr_SetString(PyExc_NotImplementedError, "wxJoystick is not available on this platform."); | |
782 | wxPyEndBlockThreads(); | |
783 | } | |
784 | wxPoint GetPosition() { return wxPoint(-1,-1); } | |
785 | int GetZPosition() { return -1; } | |
786 | int GetButtonState() { return -1; } | |
787 | int GetPOVPosition() { return -1; } | |
788 | int GetPOVCTSPosition() { return -1; } | |
789 | int GetRudderPosition() { return -1; } | |
790 | int GetUPosition() { return -1; } | |
791 | int GetVPosition() { return -1; } | |
792 | int GetMovementThreshold() { return -1; } | |
793 | void SetMovementThreshold(int threshold) {} | |
794 | ||
795 | bool IsOk(void) { return FALSE; } | |
796 | int GetNumberJoysticks() { return -1; } | |
797 | int GetManufacturerId() { return -1; } | |
798 | int GetProductId() { return -1; } | |
799 | wxString GetProductName() { return ""; } | |
800 | int GetXMin() { return -1; } | |
801 | int GetYMin() { return -1; } | |
802 | int GetZMin() { return -1; } | |
803 | int GetXMax() { return -1; } | |
804 | int GetYMax() { return -1; } | |
805 | int GetZMax() { return -1; } | |
806 | int GetNumberButtons() { return -1; } | |
807 | int GetNumberAxes() { return -1; } | |
808 | int GetMaxButtons() { return -1; } | |
809 | int GetMaxAxes() { return -1; } | |
810 | int GetPollingMin() { return -1; } | |
811 | int GetPollingMax() { return -1; } | |
812 | int GetRudderMin() { return -1; } | |
813 | int GetRudderMax() { return -1; } | |
814 | int GetUMin() { return -1; } | |
815 | int GetUMax() { return -1; } | |
816 | int GetVMin() { return -1; } | |
817 | int GetVMax() { return -1; } | |
818 | ||
819 | bool HasRudder() { return FALSE; } | |
820 | bool HasZ() { return FALSE; } | |
821 | bool HasU() { return FALSE; } | |
822 | bool HasV() { return FALSE; } | |
823 | bool HasPOV() { return FALSE; } | |
824 | bool HasPOV4Dir() { return FALSE; } | |
825 | bool HasPOVCTS() { return FALSE; } | |
826 | ||
827 | bool SetCapture(wxWindow* win, int pollingFreq = 0) { return FALSE; } | |
828 | bool ReleaseCapture() { return FALSE; } | |
829 | }; | |
830 | #endif | |
831 | %} | |
832 | ||
833 | ||
834 | class wxJoystick : public wxObject { | |
835 | public: | |
836 | wxJoystick(int joystick = wxJOYSTICK1); | |
837 | ~wxJoystick(); | |
838 | ||
839 | wxPoint GetPosition(); | |
840 | int GetZPosition(); | |
841 | int GetButtonState(); | |
842 | int GetPOVPosition(); | |
843 | int GetPOVCTSPosition(); | |
844 | int GetRudderPosition(); | |
845 | int GetUPosition(); | |
846 | int GetVPosition(); | |
847 | int GetMovementThreshold(); | |
848 | void SetMovementThreshold(int threshold) ; | |
849 | ||
850 | bool IsOk(void); | |
851 | int GetNumberJoysticks(); | |
852 | int GetManufacturerId(); | |
853 | int GetProductId(); | |
854 | wxString GetProductName(); | |
855 | int GetXMin(); | |
856 | int GetYMin(); | |
857 | int GetZMin(); | |
858 | int GetXMax(); | |
859 | int GetYMax(); | |
860 | int GetZMax(); | |
861 | int GetNumberButtons(); | |
862 | int GetNumberAxes(); | |
863 | int GetMaxButtons(); | |
864 | int GetMaxAxes(); | |
865 | int GetPollingMin(); | |
866 | int GetPollingMax(); | |
867 | int GetRudderMin(); | |
868 | int GetRudderMax(); | |
869 | int GetUMin(); | |
870 | int GetUMax(); | |
871 | int GetVMin(); | |
872 | int GetVMax(); | |
873 | ||
874 | bool HasRudder(); | |
875 | bool HasZ(); | |
876 | bool HasU(); | |
877 | bool HasV(); | |
878 | bool HasPOV(); | |
879 | bool HasPOV4Dir(); | |
880 | bool HasPOVCTS(); | |
881 | ||
882 | bool SetCapture(wxWindow* win, int pollingFreq = 0); | |
883 | bool ReleaseCapture(); | |
884 | }; | |
885 | ||
886 | //---------------------------------------------------------------------- | |
887 | ||
888 | %{ | |
889 | #if !wxUSE_WAVE | |
890 | // A C++ stub class for wxWave for platforms that don't have it. | |
891 | class wxWave : public wxObject | |
892 | { | |
893 | public: | |
894 | wxWave(const wxString& fileName, bool isResource = FALSE) { | |
895 | wxPyBeginBlockThreads(); | |
896 | PyErr_SetString(PyExc_NotImplementedError, "wxWave is not available on this platform."); | |
897 | wxPyEndBlockThreads(); | |
898 | } | |
899 | wxWave(int size, const wxByte* data) { | |
900 | wxPyBeginBlockThreads(); | |
901 | PyErr_SetString(PyExc_NotImplementedError, "wxWave is not available on this platform."); | |
902 | wxPyEndBlockThreads(); | |
903 | } | |
904 | ||
905 | ~wxWave() {} | |
906 | ||
907 | bool IsOk() const { return FALSE; } | |
908 | bool Play(bool async = TRUE, bool looped = FALSE) const { return FALSE; } | |
909 | }; | |
910 | ||
911 | #endif | |
912 | %} | |
913 | ||
914 | class wxWave : public wxObject | |
915 | { | |
916 | public: | |
917 | wxWave(const wxString& fileName, bool isResource = FALSE); | |
918 | ~wxWave(); | |
919 | ||
920 | bool IsOk() const; | |
921 | bool Play(bool async = TRUE, bool looped = FALSE) const; | |
922 | }; | |
923 | ||
924 | %new wxWave* wxWaveData(const wxString& data); | |
925 | %{ // Implementations of some alternate "constructors" | |
926 | wxWave* wxWaveData(const wxString& data) { | |
927 | return new wxWave(data.Len(), (wxByte*)data.c_str()); | |
928 | } | |
929 | %} | |
930 | ||
931 | ||
932 | //---------------------------------------------------------------------- | |
933 | ||
934 | enum wxMailcapStyle | |
935 | { | |
936 | wxMAILCAP_STANDARD = 1, | |
937 | wxMAILCAP_NETSCAPE = 2, | |
938 | wxMAILCAP_KDE = 4, | |
939 | wxMAILCAP_GNOME = 8, | |
940 | ||
941 | wxMAILCAP_ALL = 15 | |
942 | }; | |
943 | ||
944 | ||
945 | ||
946 | class wxFileTypeInfo | |
947 | { | |
948 | public: | |
949 | // ctors | |
950 | // a normal item | |
951 | wxFileTypeInfo(const char *mimeType, | |
952 | const char *openCmd, | |
953 | const char *printCmd, | |
954 | const char *desc); | |
955 | ||
956 | ||
957 | // the array elements correspond to the parameters of the ctor above in | |
958 | // the same order | |
959 | %name(wxFileTypeInfoSequence)wxFileTypeInfo(const wxArrayString& sArray); | |
960 | ||
961 | // invalid item - use this to terminate the array passed to | |
962 | // wxMimeTypesManager::AddFallbacks | |
963 | %name(wxNullFileTypeInfo)wxFileTypeInfo(); | |
964 | ||
965 | ||
966 | // test if this object can be used | |
967 | bool IsValid() const; | |
968 | ||
969 | // setters | |
970 | // set the icon info | |
971 | void SetIcon(const wxString& iconFile, int iconIndex = 0); | |
972 | ||
973 | // set the short desc | |
974 | void SetShortDesc(const wxString& shortDesc); | |
975 | ||
976 | // accessors | |
977 | // get the MIME type | |
978 | const wxString& GetMimeType() const; | |
979 | // get the open command | |
980 | const wxString& GetOpenCommand() const; | |
981 | // get the print command | |
982 | const wxString& GetPrintCommand() const; | |
983 | // get the short description (only used under Win32 so far) | |
984 | const wxString& GetShortDesc() const; | |
985 | // get the long, user visible description | |
986 | const wxString& GetDescription() const; | |
987 | ||
988 | ||
989 | // get the array of all extensions | |
990 | //const wxArrayString& GetExtensions() const; | |
991 | %addmethods { | |
992 | PyObject* GetExtensions() { | |
993 | wxArrayString& arr = (wxArrayString&)self->GetExtensions(); | |
994 | return wxArrayString2PyList_helper(arr); | |
995 | } | |
996 | } | |
997 | ||
998 | int GetExtensionsCount() const; | |
999 | ||
1000 | // get the icon info | |
1001 | const wxString& GetIconFile() const; | |
1002 | int GetIconIndex() const; | |
1003 | }; | |
1004 | ||
1005 | ||
1006 | ||
1007 | ||
1008 | class wxFileType | |
1009 | { | |
1010 | public: | |
1011 | ||
1012 | // TODO: Make a wxPyMessageParameters with virtual GetParamValue... | |
1013 | ||
1014 | // An object of this class must be passed to Get{Open|Print}Command. The | |
1015 | // default implementation is trivial and doesn't know anything at all about | |
1016 | // parameters, only filename and MIME type are used (so it's probably ok for | |
1017 | // Windows where %{param} is not used anyhow) | |
1018 | class MessageParameters | |
1019 | { | |
1020 | public: | |
1021 | // ctors | |
1022 | MessageParameters(const wxString& filename=wxPyEmptyStr, | |
1023 | const wxString& mimetype=wxPyEmptyStr); | |
1024 | ||
1025 | // accessors (called by GetOpenCommand) | |
1026 | // filename | |
1027 | const wxString& GetFileName() const; | |
1028 | // mime type | |
1029 | const wxString& GetMimeType() const;; | |
1030 | ||
1031 | // override this function in derived class | |
1032 | virtual wxString GetParamValue(const wxString& name) const; | |
1033 | ||
1034 | // virtual dtor as in any base class | |
1035 | virtual ~MessageParameters(); | |
1036 | }; | |
1037 | ||
1038 | ||
1039 | // ctor from static data | |
1040 | wxFileType(const wxFileTypeInfo& ftInfo); | |
1041 | ||
1042 | // return the MIME type for this file type | |
1043 | %addmethods { | |
1044 | PyObject* GetMimeType() { | |
1045 | wxString str; | |
1046 | if (self->GetMimeType(&str)) | |
1047 | return PyString_FromString(str.c_str()); | |
1048 | else | |
1049 | RETURN_NONE(); | |
1050 | } | |
1051 | PyObject* GetMimeTypes() { | |
1052 | wxArrayString arr; | |
1053 | if (self->GetMimeTypes(arr)) | |
1054 | return wxArrayString2PyList_helper(arr); | |
1055 | else | |
1056 | RETURN_NONE(); | |
1057 | } | |
1058 | } | |
1059 | ||
1060 | ||
1061 | // Get all extensions associated with this file type | |
1062 | %addmethods { | |
1063 | PyObject* GetExtensions() { | |
1064 | wxArrayString arr; | |
1065 | if (self->GetExtensions(arr)) | |
1066 | return wxArrayString2PyList_helper(arr); | |
1067 | else | |
1068 | RETURN_NONE(); | |
1069 | } | |
1070 | } | |
1071 | ||
1072 | ||
1073 | %addmethods { | |
1074 | // Get the icon corresponding to this file type | |
1075 | %new wxIcon* GetIcon() { | |
1076 | wxIcon icon; | |
1077 | if (self->GetIcon(&icon)) | |
1078 | return new wxIcon(icon); | |
1079 | else | |
1080 | return NULL; | |
1081 | } | |
1082 | ||
1083 | // Get the icon corresponding to this file type, the name of the file | |
1084 | // where this icon resides, and its index in this file if applicable. | |
1085 | PyObject* GetIconInfo() { | |
1086 | wxIcon icon; | |
1087 | wxString iconFile; | |
1088 | int iconIndex; | |
1089 | if (self->GetIcon(&icon, &iconFile, &iconIndex)) { | |
1090 | wxPyBeginBlockThreads(); | |
1091 | PyObject* tuple = PyTuple_New(3); | |
1092 | PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(icon), | |
1093 | "wxIcon", TRUE)); | |
1094 | PyTuple_SetItem(tuple, 1, PyString_FromString(iconFile.c_str())); | |
1095 | PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex)); | |
1096 | wxPyEndBlockThreads(); | |
1097 | return tuple; | |
1098 | } | |
1099 | else | |
1100 | RETURN_NONE(); | |
1101 | } | |
1102 | } | |
1103 | ||
1104 | %addmethods { | |
1105 | // get a brief file type description ("*.txt" => "text document") | |
1106 | PyObject* GetDescription() { | |
1107 | wxString str; | |
1108 | if (self->GetDescription(&str)) | |
1109 | return PyString_FromString(str.c_str()); | |
1110 | else | |
1111 | RETURN_NONE(); | |
1112 | } | |
1113 | } | |
1114 | ||
1115 | ||
1116 | // get the command to open/execute the file of given type | |
1117 | %addmethods { | |
1118 | PyObject* GetOpenCommand(const wxString& filename, | |
1119 | const wxString& mimetype=wxPyEmptyStr) { | |
1120 | wxString str; | |
1121 | if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype))) | |
1122 | return PyString_FromString(str.c_str()); | |
1123 | else | |
1124 | RETURN_NONE(); | |
1125 | } | |
1126 | } | |
1127 | ||
1128 | ||
1129 | // get the command to print the file of given type | |
1130 | %addmethods { | |
1131 | PyObject* GetPrintCommand(const wxString& filename, | |
1132 | const wxString& mimetype=wxPyEmptyStr) { | |
1133 | wxString str; | |
1134 | if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype))) | |
1135 | return PyString_FromString(str.c_str()); | |
1136 | else | |
1137 | RETURN_NONE(); | |
1138 | } | |
1139 | } | |
1140 | ||
1141 | ||
1142 | // Get all commands defined for this file type | |
1143 | %addmethods { | |
1144 | PyObject* GetAllCommands(const wxString& filename, | |
1145 | const wxString& mimetype=wxPyEmptyStr) { | |
1146 | wxArrayString verbs; | |
1147 | wxArrayString commands; | |
1148 | if (self->GetAllCommands(&verbs, &commands, | |
1149 | wxFileType::MessageParameters(filename, mimetype))) { | |
1150 | wxPyBeginBlockThreads(); | |
1151 | PyObject* tuple = PyTuple_New(2); | |
1152 | PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs)); | |
1153 | PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands)); | |
1154 | wxPyEndBlockThreads(); | |
1155 | return tuple; | |
1156 | } | |
1157 | else | |
1158 | RETURN_NONE(); | |
1159 | } | |
1160 | } | |
1161 | ||
1162 | ||
1163 | // set an arbitrary command, ask confirmation if it already exists and | |
1164 | // overwriteprompt is TRUE | |
1165 | bool SetCommand(const wxString& cmd, const wxString& verb, | |
1166 | bool overwriteprompt = TRUE); | |
1167 | ||
1168 | bool SetDefaultIcon(const wxString& cmd = wxEmptyString, int index = 0); | |
1169 | ||
1170 | ||
1171 | // remove the association for this filetype from the system MIME database: | |
1172 | // notice that it will only work if the association is defined in the user | |
1173 | // file/registry part, we will never modify the system-wide settings | |
1174 | bool Unassociate(); | |
1175 | ||
1176 | // operations | |
1177 | // expand a string in the format of GetOpenCommand (which may contain | |
1178 | // '%s' and '%t' format specificators for the file name and mime type | |
1179 | // and %{param} constructions). | |
1180 | static wxString ExpandCommand(const wxString& command, | |
1181 | const MessageParameters& params); | |
1182 | ||
1183 | // dtor (not virtual, shouldn't be derived from) | |
1184 | ~wxFileType(); | |
1185 | ||
1186 | }; | |
1187 | ||
1188 | ||
1189 | ||
1190 | ||
1191 | class wxMimeTypesManager | |
1192 | { | |
1193 | public: | |
1194 | // static helper functions | |
1195 | // ----------------------- | |
1196 | ||
1197 | // check if the given MIME type is the same as the other one: the | |
1198 | // second argument may contain wildcards ('*'), but not the first. If | |
1199 | // the types are equal or if the mimeType matches wildcard the function | |
1200 | // returns TRUE, otherwise it returns FALSE | |
1201 | static bool IsOfType(const wxString& mimeType, const wxString& wildcard); | |
1202 | ||
1203 | // ctor | |
1204 | wxMimeTypesManager(); | |
1205 | ||
1206 | // loads data from standard files according to the mailcap styles | |
1207 | // specified: this is a bitwise OR of wxMailcapStyle values | |
1208 | // | |
1209 | // use the extraDir parameter if you want to look for files in another | |
1210 | // directory | |
1211 | void Initialize(int mailcapStyle = wxMAILCAP_STANDARD, | |
1212 | const wxString& extraDir = wxEmptyString); | |
1213 | ||
1214 | // and this function clears all the data from the manager | |
1215 | void ClearData(); | |
1216 | ||
1217 | // Database lookup: all functions return a pointer to wxFileType object | |
1218 | // whose methods may be used to query it for the information you're | |
1219 | // interested in. If the return value is !NULL, caller is responsible for | |
1220 | // deleting it. | |
1221 | // get file type from file extension | |
1222 | %new wxFileType *GetFileTypeFromExtension(const wxString& ext); | |
1223 | ||
1224 | // get file type from MIME type (in format <category>/<format>) | |
1225 | %new wxFileType *GetFileTypeFromMimeType(const wxString& mimeType); | |
1226 | ||
1227 | // other operations: return TRUE if there were no errors or FALSE if there | |
1228 | // were some unreckognized entries (the good entries are always read anyhow) | |
1229 | // | |
1230 | ||
1231 | // read in additional file (the standard ones are read automatically) | |
1232 | // in mailcap format (see mimetype.cpp for description) | |
1233 | // | |
1234 | // 'fallback' parameter may be set to TRUE to avoid overriding the | |
1235 | // settings from other, previously parsed, files by this one: normally, | |
1236 | // the files read most recently would override the older files, but with | |
1237 | // fallback == TRUE this won't happen | |
1238 | bool ReadMailcap(const wxString& filename, bool fallback = FALSE); | |
1239 | ||
1240 | // read in additional file in mime.types format | |
1241 | bool ReadMimeTypes(const wxString& filename); | |
1242 | ||
1243 | // enumerate all known MIME types | |
1244 | %addmethods { | |
1245 | PyObject* EnumAllFileTypes() { | |
1246 | wxArrayString arr; | |
1247 | self->EnumAllFileTypes(arr); | |
1248 | return wxArrayString2PyList_helper(arr); | |
1249 | } | |
1250 | } | |
1251 | ||
1252 | // these functions can be used to provide default values for some of the | |
1253 | // MIME types inside the program itself (you may also use | |
1254 | // ReadMailcap(filenameWithDefaultTypes, TRUE /* use as fallback */) to | |
1255 | // achieve the same goal, but this requires having this info in a file). | |
1256 | // | |
1257 | void AddFallback(const wxFileTypeInfo& ft); | |
1258 | ||
1259 | ||
1260 | // create or remove associations | |
1261 | ||
1262 | // create a new association using the fields of wxFileTypeInfo (at least | |
1263 | // the MIME type and the extension should be set) | |
1264 | // if the other fields are empty, the existing values should be left alone | |
1265 | %new wxFileType *Associate(const wxFileTypeInfo& ftInfo); | |
1266 | ||
1267 | // undo Associate() | |
1268 | bool Unassociate(wxFileType *ft) ; | |
1269 | ||
1270 | // dtor (not virtual, shouldn't be derived from) | |
1271 | ~wxMimeTypesManager(); | |
1272 | }; | |
1273 | ||
1274 | ||
1275 | %readonly | |
1276 | %{ | |
1277 | #if 0 | |
1278 | %} | |
1279 | extern wxMimeTypesManager* wxTheMimeTypesManager; | |
1280 | %{ | |
1281 | #endif | |
1282 | %} | |
1283 | %readwrite | |
1284 | ||
1285 | //---------------------------------------------------------------------- | |
1286 | ||
1287 | %{ | |
1288 | #include <wx/docview.h> | |
1289 | %} | |
1290 | ||
1291 | class wxFileHistory : public wxObject | |
1292 | { | |
1293 | public: | |
1294 | wxFileHistory(int maxFiles = 9); | |
1295 | ~wxFileHistory(); | |
1296 | ||
1297 | // Operations | |
1298 | void AddFileToHistory(const wxString& file); | |
1299 | void RemoveFileFromHistory(int i); | |
1300 | int GetMaxFiles() const; | |
1301 | void UseMenu(wxMenu *menu); | |
1302 | ||
1303 | // Remove menu from the list (MDI child may be closing) | |
1304 | void RemoveMenu(wxMenu *menu); | |
1305 | ||
1306 | void Load(wxConfigBase& config); | |
1307 | void Save(wxConfigBase& config); | |
1308 | ||
1309 | void AddFilesToMenu(); | |
1310 | %name(AddFilesToSingleMenu)void AddFilesToMenu(wxMenu* menu); | |
1311 | ||
1312 | // Accessors | |
1313 | wxString GetHistoryFile(int i) const; | |
1314 | ||
1315 | // A synonym for GetNoHistoryFiles | |
1316 | int GetCount() const; | |
1317 | int GetNoHistoryFiles() const; | |
1318 | ||
1319 | }; | |
1320 | ||
1321 | //---------------------------------------------------------------------- | |
1322 | //---------------------------------------------------------------------- | |
1323 | ||
1324 | ||
1325 | %init %{ | |
1326 | wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator"); | |
1327 | wxPyPtrTypeMap_Add("wxDragImage", "wxGenericDragImage"); | |
1328 | wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess"); | |
1329 | %} | |
1330 | ||
1331 | //---------------------------------------------------------------------- | |
1332 |