]> git.saurik.com Git - wxWidgets.git/blobdiff - wxPython/src/misc2.i
compilation error fix (trailing comma in an enum)
[wxWidgets.git] / wxPython / src / misc2.i
index 7cea032de86071df22eaa95855cd14b29deb63f2..22a8d2d7b7cce589e4692b433247b0e5a359611b 100644 (file)
 
 %{
 #include "helpers.h"
 
 %{
 #include "helpers.h"
+#include "pyistream.h"
 #include <wx/resource.h>
 #include <wx/tooltip.h>
 #include <wx/caret.h>
 #include <wx/resource.h>
 #include <wx/tooltip.h>
 #include <wx/caret.h>
-#include <wx/fontenum.h>
 #include <wx/tipdlg.h>
 #include <wx/process.h>
 
 #include <wx/tipdlg.h>
 #include <wx/process.h>
 
@@ -30,6 +30,8 @@
 #if wxUSE_WAVE || defined(__WXMSW__)
 #include <wx/wave.h>
 #endif
 #if wxUSE_WAVE || defined(__WXMSW__)
 #include <wx/wave.h>
 #endif
+
+#include <wx/mimetype.h>
 %}
 
 //----------------------------------------------------------------------
 %}
 
 //----------------------------------------------------------------------
 %import gdi.i
 %import events.i
 %import streams.i
 %import gdi.i
 %import events.i
 %import streams.i
+%import utils.i
+
+
+//----------------------------------------------------------------------
 
 %{
 
 %{
-    static wxString wxPyEmptyStr("");
+    // Put some wx default wxChar* values into wxStrings.
+    DECLARE_DEF_STRING(FileSelectorPromptStr);
+    DECLARE_DEF_STRING(FileSelectorDefaultWildcardStr);
+    DECLARE_DEF_STRING(DirSelectorPromptStr);
+    static const wxString wxPyEmptyString(wxT(""));
 %}
 
 //---------------------------------------------------------------------------
 // Dialog Functions
 
 %}
 
 //---------------------------------------------------------------------------
 // Dialog Functions
 
-wxString wxFileSelector(char* message,
-                        char* default_path = NULL,
-                        char* default_filename = NULL,
-                        char* default_extension = NULL,
-                        char* wildcard = "*.*",
+wxString wxFileSelector(const wxString& message = wxPyFileSelectorPromptStr,
+                        const wxString& default_path = wxPyEmptyString,
+                        const wxString& default_filename = wxPyEmptyString,
+                        const wxString& default_extension = wxPyEmptyString,
+                        const wxString& wildcard = wxPyFileSelectorDefaultWildcardStr,
                         int flags = 0,
                         wxWindow *parent = NULL,
                         int x = -1, int y = -1);
 
                         int flags = 0,
                         wxWindow *parent = NULL,
                         int x = -1, int y = -1);
 
+// Ask for filename to load
+wxString wxLoadFileSelector(const wxString& what,
+                            const wxString& extension,
+                            const wxString& default_name = wxPyEmptyString,
+                            wxWindow *parent = NULL);
+
+// Ask for filename to save
+wxString wxSaveFileSelector(const wxString& what,
+                            const wxString& extension,
+                            const wxString& default_name = wxPyEmptyString,
+                            wxWindow *parent = NULL);
+
+
+wxString wxDirSelector(const wxString& message = wxPyDirSelectorPromptStr,
+                       const wxString& defaultPath = wxPyEmptyString,
+                       long style = wxDD_DEFAULT_STYLE,
+                       const wxPoint& pos = wxDefaultPosition,
+                       wxWindow *parent = NULL);
+
 wxString wxGetTextFromUser(const wxString& message,
 wxString wxGetTextFromUser(const wxString& message,
-                           const wxString& caption = wxPyEmptyStr,
-                           const wxString& default_value = wxPyEmptyStr,
+                           const wxString& caption = wxPyEmptyString,
+                           const wxString& default_value = wxPyEmptyString,
                            wxWindow *parent = NULL,
                            int x = -1, int y = -1,
                            bool centre = TRUE);
 
 wxString wxGetPasswordFromUser(const wxString& message,
                            wxWindow *parent = NULL,
                            int x = -1, int y = -1,
                            bool centre = TRUE);
 
 wxString wxGetPasswordFromUser(const wxString& message,
-                               const wxString& caption = wxPyEmptyStr,
-                               const wxString& default_value = wxPyEmptyStr,
+                               const wxString& caption = wxPyEmptyString,
+                               const wxString& default_value = wxPyEmptyString,
                                wxWindow *parent = NULL);
 
 
                                wxWindow *parent = NULL);
 
 
@@ -98,7 +127,7 @@ int wxGetSingleChoiceIndex(const wxString& message, const wxString& caption,
 
 
 int wxMessageBox(const wxString& message,
 
 
 int wxMessageBox(const wxString& message,
-                 const wxString& caption = wxPyEmptyStr,
+                 const wxString& caption = wxPyEmptyString,
                  int style = wxOK | wxCENTRE,
                  wxWindow *parent = NULL,
                  int x = -1, int y = -1);
                  int style = wxOK | wxCENTRE,
                  wxWindow *parent = NULL,
                  int x = -1, int y = -1);
@@ -133,9 +162,6 @@ void wxSetCursor(wxCursor& cursor);
 //----------------------------------------------------------------------
 // Miscellaneous functions
 
 //----------------------------------------------------------------------
 // Miscellaneous functions
 
-wxWindow * wxFindWindowByLabel(const wxString& label, wxWindow *parent=NULL);
-wxWindow * wxFindWindowByName(const wxString& name, wxWindow *parent=NULL);
-
 void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);
 wxWindow * wxGetActiveWindow();
 
 void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);
 wxWindow * wxGetActiveWindow();
 
@@ -147,44 +173,45 @@ bool wxCheckForInterrupt(wxWindow *wnd);
 void wxFlushEvents();
 #endif
 
 void wxFlushEvents();
 #endif
 
+wxWindow* wxGetTopLevelParent(wxWindow *win);
+
 //---------------------------------------------------------------------------
 // Resource System
 
 //---------------------------------------------------------------------------
 // Resource System
 
-bool wxResourceAddIdentifier(char *name, int value);
+bool wxResourceAddIdentifier(charname, int value);
 void wxResourceClear(void);
 void wxResourceClear(void);
-wxBitmap  wxResourceCreateBitmap(char *resource);
-wxIcon  wxResourceCreateIcon(char *resource);
-wxMenuBar * wxResourceCreateMenuBar(char *resource);
-int wxResourceGetIdentifier(char *name);
-bool wxResourceParseData(char *resource, wxResourceTable *table = NULL);
-bool wxResourceParseFile(char *filename, wxResourceTable *table = NULL);
-bool wxResourceParseString(char *resource, wxResourceTable *table = NULL);
+wxBitmap  wxResourceCreateBitmap(charresource);
+wxIcon  wxResourceCreateIcon(charresource);
+wxMenuBar * wxResourceCreateMenuBar(charresource);
+int wxResourceGetIdentifier(charname);
+bool wxResourceParseData(charresource, wxResourceTable *table = NULL);
+bool wxResourceParseFile(charfilename, wxResourceTable *table = NULL);
+bool wxResourceParseString(charresource, wxResourceTable *table = NULL);
 
 //---------------------------------------------------------------------------
 // System Settings
 
 
 //---------------------------------------------------------------------------
 // System Settings
 
-enum {
-    wxSYS_WHITE_BRUSH,
-    wxSYS_LTGRAY_BRUSH,
-    wxSYS_GRAY_BRUSH,
-    wxSYS_DKGRAY_BRUSH,
-    wxSYS_BLACK_BRUSH,
-    wxSYS_NULL_BRUSH,
-    wxSYS_HOLLOW_BRUSH,
-    wxSYS_WHITE_PEN,
-    wxSYS_BLACK_PEN,
-    wxSYS_NULL_PEN,
-    wxSYS_OEM_FIXED_FONT,
+// possible values for wxSystemSettings::GetFont() parameter
+//
+enum wxSystemFont
+{
+    wxSYS_OEM_FIXED_FONT = 10,
     wxSYS_ANSI_FIXED_FONT,
     wxSYS_ANSI_VAR_FONT,
     wxSYS_SYSTEM_FONT,
     wxSYS_DEVICE_DEFAULT_FONT,
     wxSYS_DEFAULT_PALETTE,
     wxSYS_SYSTEM_FIXED_FONT,
     wxSYS_ANSI_FIXED_FONT,
     wxSYS_ANSI_VAR_FONT,
     wxSYS_SYSTEM_FONT,
     wxSYS_DEVICE_DEFAULT_FONT,
     wxSYS_DEFAULT_PALETTE,
     wxSYS_SYSTEM_FIXED_FONT,
-    wxSYS_DEFAULT_GUI_FONT,
+    wxSYS_DEFAULT_GUI_FONT
+};
 
 
+// possible values for wxSystemSettings::GetColour() parameter
+//
+enum wxSystemColour
+{
     wxSYS_COLOUR_SCROLLBAR,
     wxSYS_COLOUR_BACKGROUND,
     wxSYS_COLOUR_SCROLLBAR,
     wxSYS_COLOUR_BACKGROUND,
+    wxSYS_COLOUR_DESKTOP = wxSYS_COLOUR_BACKGROUND,
     wxSYS_COLOUR_ACTIVECAPTION,
     wxSYS_COLOUR_INACTIVECAPTION,
     wxSYS_COLOUR_MENU,
     wxSYS_COLOUR_ACTIVECAPTION,
     wxSYS_COLOUR_INACTIVECAPTION,
     wxSYS_COLOUR_MENU,
@@ -199,25 +226,35 @@ enum {
     wxSYS_COLOUR_HIGHLIGHT,
     wxSYS_COLOUR_HIGHLIGHTTEXT,
     wxSYS_COLOUR_BTNFACE,
     wxSYS_COLOUR_HIGHLIGHT,
     wxSYS_COLOUR_HIGHLIGHTTEXT,
     wxSYS_COLOUR_BTNFACE,
+    wxSYS_COLOUR_3DFACE = wxSYS_COLOUR_BTNFACE,
     wxSYS_COLOUR_BTNSHADOW,
     wxSYS_COLOUR_BTNSHADOW,
+    wxSYS_COLOUR_3DSHADOW = wxSYS_COLOUR_BTNSHADOW,
     wxSYS_COLOUR_GRAYTEXT,
     wxSYS_COLOUR_BTNTEXT,
     wxSYS_COLOUR_INACTIVECAPTIONTEXT,
     wxSYS_COLOUR_BTNHIGHLIGHT,
     wxSYS_COLOUR_GRAYTEXT,
     wxSYS_COLOUR_BTNTEXT,
     wxSYS_COLOUR_INACTIVECAPTIONTEXT,
     wxSYS_COLOUR_BTNHIGHLIGHT,
-
+    wxSYS_COLOUR_BTNHILIGHT = wxSYS_COLOUR_BTNHIGHLIGHT,
+    wxSYS_COLOUR_3DHIGHLIGHT = wxSYS_COLOUR_BTNHIGHLIGHT,
+    wxSYS_COLOUR_3DHILIGHT = wxSYS_COLOUR_BTNHIGHLIGHT,
     wxSYS_COLOUR_3DDKSHADOW,
     wxSYS_COLOUR_3DLIGHT,
     wxSYS_COLOUR_INFOTEXT,
     wxSYS_COLOUR_INFOBK,
     wxSYS_COLOUR_3DDKSHADOW,
     wxSYS_COLOUR_3DLIGHT,
     wxSYS_COLOUR_INFOTEXT,
     wxSYS_COLOUR_INFOBK,
+    wxSYS_COLOUR_LISTBOX,
+    wxSYS_COLOUR_HOTLIGHT,
+    wxSYS_COLOUR_GRADIENTACTIVECAPTION,
+    wxSYS_COLOUR_GRADIENTINACTIVECAPTION,
+    wxSYS_COLOUR_MENUHILIGHT,
+    wxSYS_COLOUR_MENUBAR,
+
+    wxSYS_COLOUR_MAX
+};
 
 
-    wxSYS_COLOUR_DESKTOP,
-    wxSYS_COLOUR_3DFACE,
-    wxSYS_COLOUR_3DSHADOW,
-    wxSYS_COLOUR_3DHIGHLIGHT,
-    wxSYS_COLOUR_3DHILIGHT,
-    wxSYS_COLOUR_BTNHILIGHT,
-
-    wxSYS_MOUSE_BUTTONS,
+// possible values for wxSystemSettings::GetMetric() parameter
+//
+enum wxSystemMetric
+{
+    wxSYS_MOUSE_BUTTONS = 1,
     wxSYS_BORDER_X,
     wxSYS_BORDER_Y,
     wxSYS_CURSOR_X,
     wxSYS_BORDER_X,
     wxSYS_BORDER_Y,
     wxSYS_CURSOR_X,
@@ -253,25 +290,51 @@ enum {
     wxSYS_NETWORK_PRESENT,
     wxSYS_PENWINDOWS_PRESENT,
     wxSYS_SHOW_SOUNDS,
     wxSYS_NETWORK_PRESENT,
     wxSYS_PENWINDOWS_PRESENT,
     wxSYS_SHOW_SOUNDS,
-    wxSYS_SWAP_BUTTONS,
+    wxSYS_SWAP_BUTTONS
 };
 
 };
 
+// possible values for wxSystemSettings::HasFeature() parameter
+enum wxSystemFeature
+{
+    wxSYS_CAN_DRAW_FRAME_DECORATIONS = 1,
+    wxSYS_CAN_ICONIZE_FRAME
+};
 
 
+enum wxSystemScreenType
+{
+    wxSYS_SCREEN_NONE = 0,  //   not yet defined
 
 
-%inline %{
+    wxSYS_SCREEN_TINY,      //   <
+    wxSYS_SCREEN_PDA,       //   >= 320x240
+    wxSYS_SCREEN_SMALL,     //   >= 640x480
+    wxSYS_SCREEN_DESKTOP    //   >= 800x600
+};
 
 
-    wxColour wxSystemSettings_GetSystemColour(int index) {
-        return wxSystemSettings::GetSystemColour(index);
-    }
 
 
-    wxFont wxSystemSettings_GetSystemFont(int index) {
-        return wxSystemSettings::GetSystemFont(index);
-    }
+class wxSystemSettings {
+public:
+    // get a standard system colour
+    static wxColour GetColour(wxSystemColour index);
+
+    // get a standard system font
+    static wxFont GetFont(wxSystemFont index);
+
+    // get a system-dependent metric
+    static int GetMetric(wxSystemMetric index);
+
+    // return true if the port has certain feature
+    static bool HasFeature(wxSystemFeature index);
+
+   // Get system screen design (desktop, pda, ..) used for
+   // laying out various dialogs.
+   static wxSystemScreenType GetScreenType();
+
+   // Override default.
+   static void SetScreenType( wxSystemScreenType screen );
+
+};
+
 
 
-    int wxSystemSettings_GetSystemMetric(int index) {
-        return wxSystemSettings::GetSystemMetric(index);
-    }
-%}
 
 //---------------------------------------------------------------------------
 // wxToolTip
 
 //---------------------------------------------------------------------------
 // wxToolTip
@@ -323,58 +386,6 @@ public:
 
 //----------------------------------------------------------------------
 
 
 //----------------------------------------------------------------------
 
-%{
-class wxPyFontEnumerator : public wxFontEnumerator {
-public:
-    wxPyFontEnumerator() {}
-    ~wxPyFontEnumerator() {}
-
-    DEC_PYCALLBACK_BOOL_STRING(OnFacename);
-    DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
-
-    PYPRIVATE;
-};
-
-IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
-IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
-
-%}
-
-%name(wxFontEnumerator) class wxPyFontEnumerator {
-public:
-    wxPyFontEnumerator();
-    ~wxPyFontEnumerator();
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxFontEnumerator)"
-
-    bool EnumerateFacenames(
-        wxFontEncoding encoding = wxFONTENCODING_SYSTEM, // all
-        bool fixedWidthOnly = FALSE);
-    bool EnumerateEncodings(const char* facename = "");
-
-    //wxArrayString* GetEncodings();
-    //wxArrayString* GetFacenames();
-    %addmethods {
-        PyObject* GetEncodings() {
-            wxArrayString* arr = self->GetEncodings();
-            PyObject* list = PyList_New(0);
-            for (size_t x=0; x<arr->GetCount(); x++)
-                PyList_Append(list, PyString_FromString((*arr)[x]));
-            return list;
-        }
-
-        PyObject* GetFacenames() {
-            wxArrayString* arr = self->GetFacenames();
-            PyObject* list = PyList_New(0);
-            for (size_t x=0; x<arr->GetCount(); x++)
-                PyList_Append(list, PyString_FromString((*arr)[x]));
-            return list;
-        }
-    }
-};
-
-//----------------------------------------------------------------------
-
 class  wxBusyCursor {
 public:
     wxBusyCursor(wxCursor* cursor = wxHOURGLASS_CURSOR);
 class  wxBusyCursor {
 public:
     wxBusyCursor(wxCursor* cursor = wxHOURGLASS_CURSOR);
@@ -413,7 +424,11 @@ public:
 
 %inline %{
     bool wxThread_IsMain() {
 
 %inline %{
     bool wxThread_IsMain() {
+#ifdef WXP_WITH_THREAD
         return wxThread::IsMain();
         return wxThread::IsMain();
+#else
+        return TRUE;
+#endif
     }
 %}
 
     }
 %}
 
@@ -514,6 +529,22 @@ public:
     void Stop();
 };
 
     void Stop();
 };
 
+
+class wxStopWatch
+{
+public:
+    // ctor starts the stop watch
+    wxStopWatch();
+    ~wxStopWatch();
+    void Start(long t = 0);
+    void Pause();
+    void Resume();
+
+    // get elapsed time since the last Start() or Pause() in milliseconds
+    long Time() const;
+};
+
+
 //----------------------------------------------------------------------
 //----------------------------------------------------------------------
 
 //----------------------------------------------------------------------
 //----------------------------------------------------------------------
 
@@ -532,6 +563,27 @@ enum
     wxLOG_User = 100  // user defined levels start here
 };
 
     wxLOG_User = 100  // user defined levels start here
 };
 
+#define wxTRACE_MemAlloc "memalloc" // trace memory allocation (new/delete)
+#define wxTRACE_Messages "messages" // trace window messages/X callbacks
+#define wxTRACE_ResAlloc "resalloc" // trace GDI resource allocation
+#define wxTRACE_RefCount "refcount" // trace various ref counting operations
+
+#ifdef  __WXMSW__
+#define wxTRACE_OleCalls "ole"      // OLE interface calls
+#endif
+
+enum {
+    wxTraceMemAlloc,
+    wxTraceMessages,
+    wxTraceResAlloc,
+    wxTraceRefCount,
+
+#ifdef  __WXMSW__
+    wxTraceOleCalls,
+#endif
+};
+
+
 
 class wxLog
 {
 
 class wxLog
 {
@@ -540,7 +592,7 @@ public:
 
     static bool IsEnabled();
     static bool EnableLogging(bool doIt = TRUE);
 
     static bool IsEnabled();
     static bool EnableLogging(bool doIt = TRUE);
-    static void OnLog(wxLogLevel level, const char *szString, int t=0);
+    static void OnLog(unsigned long level, const wxString& szString, int t=0);
 
     virtual void Flush();
     bool HasPendingMessages() const;
 
     virtual void Flush();
     bool HasPendingMessages() const;
@@ -552,17 +604,30 @@ public:
     static void Suspend();
     static void Resume();
 
     static void Suspend();
     static void Resume();
 
-    void SetVerbose(bool bVerbose = TRUE);
+    static void SetVerbose(bool bVerbose = TRUE);
 
     static void DontCreateOnDemand();
 
     static void DontCreateOnDemand();
-    static void SetTraceMask(wxTraceMask ulMask);
+    static void SetTraceMask(long ulMask);
     static void AddTraceMask(const wxString& str);
     static void RemoveTraceMask(const wxString& str);
     static void AddTraceMask(const wxString& str);
     static void RemoveTraceMask(const wxString& str);
+    static void ClearTraceMasks();
 
 
-    bool GetVerbose() const { return m_bVerbose; }
+    static void SetTimestamp(const wxString& ts);
+    static const wxString& GetTimestamp();
 
 
-    static wxTraceMask GetTraceMask();
-    static bool IsAllowedTraceMask(const char *mask);
+    bool GetVerbose() const;
+
+    static unsigned long GetTraceMask();
+    static bool IsAllowedTraceMask(const wxString& mask);
+
+    // static void TimeStamp(wxString *str);
+    %addmethods {
+        wxString TimeStamp() {
+            wxString msg;
+            wxLog::TimeStamp(&msg);
+            return msg;
+        }
+    }
 
 };
 
 
 };
 
@@ -591,7 +656,7 @@ class wxLogWindow : public wxLog
 {
 public:
     wxLogWindow(wxFrame *pParent,         // the parent frame (can be NULL)
 {
 public:
     wxLogWindow(wxFrame *pParent,         // the parent frame (can be NULL)
-            const char *szTitle,          // the title of the frame
+            const wxString& szTitle,      // the title of the frame
             bool bShow = TRUE,            // show window immediately?
             bool bPassToOld = TRUE);      // pass log messages to the old target?
 
             bool bShow = TRUE,            // show window immediately?
             bool bPassToOld = TRUE);      // pass log messages to the old target?
 
@@ -599,10 +664,45 @@ public:
     wxFrame *GetFrame() const;
     wxLog *GetOldLog() const;
     bool IsPassingMessages() const;
     wxFrame *GetFrame() const;
     wxLog *GetOldLog() const;
     bool IsPassingMessages() const;
-    void PassMessages(bool bDoPass) { m_bPassMessages = bDoPass; }
+    void PassMessages(bool bDoPass);
 };
 
 
 };
 
 
+class wxLogChain : public wxLog
+{
+public:
+    wxLogChain(wxLog *logger);
+    void SetLog(wxLog *logger);
+    void PassMessages(bool bDoPass);
+    bool IsPassingMessages();
+    wxLog *GetOldLog();
+};
+
+
+unsigned long wxSysErrorCode();
+const wxString wxSysErrorMsg(unsigned long nErrCode = 0);
+void wxLogFatalError(const wxString& msg);
+void wxLogError(const wxString& msg);
+void wxLogWarning(const wxString& msg);
+void wxLogMessage(const wxString& msg);
+void wxLogInfo(const wxString& msg);
+void wxLogVerbose(const wxString& msg);
+void wxLogStatus(const wxString& msg);
+%name(wxLogStatusFrame)void wxLogStatus(wxFrame *pFrame, const wxString& msg);
+void wxLogSysError(const wxString& msg);
+
+void wxLogTrace(const wxString& msg);
+%name(wxLogTraceMask)void wxLogTrace(const wxString& mask, const wxString& msg);
+
+void wxLogGeneric(unsigned long level, const wxString& msg);
+
+// wxLogFatalError helper: show the (fatal) error to the user in a safe way,
+// i.e. without using wxMessageBox() for example because it could crash
+void wxSafeShowMessage(const wxString& title, const wxString& text);
+
+
+
+// Suspress logging while an instance of this class exists
 class wxLogNull
 {
 public:
 class wxLogNull
 {
 public:
@@ -611,19 +711,54 @@ public:
 };
 
 
 };
 
 
-unsigned long wxSysErrorCode();
-const char* wxSysErrorMsg(unsigned long nErrCode = 0);
-void wxLogFatalError(const char *szFormat);
-void wxLogError(const char *szFormat);
-void wxLogWarning(const char *szFormat);
-void wxLogMessage(const char *szFormat);
-void wxLogInfo(const char *szFormat);
-void wxLogVerbose(const char *szFormat);
-void wxLogStatus(const char *szFormat);
-%name(wxLogStatusFrame)void wxLogStatus(wxFrame *pFrame, const char *szFormat);
-void wxLogSysError(const char *szFormat);
 
 
 
 
+%{
+// A wxLog class that can be derived from in wxPython
+class wxPyLog : public wxLog {
+public:
+    wxPyLog() : wxLog() {}
+
+    virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
+        bool found;
+        wxPyBeginBlockThreads();
+        if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
+            PyObject* s = wx2PyString(szString);
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
+            Py_DECREF(s);
+        }
+        wxPyEndBlockThreads();
+        if (! found)
+            wxLog::DoLog(level, szString, t);
+    }
+
+    virtual void DoLogString(const wxChar *szString, time_t t) {
+        bool found;
+        wxPyBeginBlockThreads();
+        if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
+            PyObject* s = wx2PyString(szString);
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
+            Py_DECREF(s);
+        }
+        wxPyEndBlockThreads();
+        if (! found)
+            wxLog::DoLogString(szString, t);
+    }
+
+    PYPRIVATE;
+};
+%}
+
+// Now tell SWIG about it
+class wxPyLog : public wxLog {
+public:
+    wxPyLog();
+    void _setCallbackInfo(PyObject* self, PyObject* _class);
+    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyLog)"
+    %addmethods { void Destroy() { delete self; } }
+
+};
+
 
 //----------------------------------------------------------------------
 
 
 //----------------------------------------------------------------------
 
@@ -668,8 +803,8 @@ public:
     wxPyProcess(wxEvtHandler *parent = NULL, int id = -1);
     %addmethods { void Destroy() { delete self; } }
 
     wxPyProcess(wxEvtHandler *parent = NULL, int id = -1);
     %addmethods { void Destroy() { delete self; } }
 
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxProcess)"
+    void _setCallbackInfo(PyObject* self, PyObject* _class);
+    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxProcess)"
 
     void base_OnTerminate(int pid, int status);
 
 
     void base_OnTerminate(int pid, int status);
 
@@ -685,22 +820,58 @@ public:
 };
 
 
 };
 
 
+enum
+{
+    // execute the process asynchronously
+    wxEXEC_ASYNC    = 0,
+
+    // execute it synchronously, i.e. wait until it finishes
+    wxEXEC_SYNC     = 1,
+
+    // under Windows, don't hide the child even if it's IO is redirected (this
+    // is done by default)
+    wxEXEC_NOHIDE   = 2,
+
+    // under Unix, if the process is the group leader then killing -pid kills
+    // all children as well as pid
+    wxEXEC_MAKE_GROUP_LEADER = 4
+};
+
 
 long wxExecute(const wxString& command,
 
 long wxExecute(const wxString& command,
-               int sync = FALSE,
+               int flags = wxEXEC_ASYNC,
                wxPyProcess *process = NULL);
 
 //----------------------------------------------------------------------
 
                wxPyProcess *process = NULL);
 
 //----------------------------------------------------------------------
 
+
+// Which joystick? Same as Windows ids so no conversion necessary.
+enum
+{
+    wxJOYSTICK1,
+    wxJOYSTICK2
+};
+
+// Which button is down?
+enum
+{
+    wxJOY_BUTTON_ANY,
+    wxJOY_BUTTON1,
+    wxJOY_BUTTON2,
+    wxJOY_BUTTON3,
+    wxJOY_BUTTON4,
+};
+
+
 %{
 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
 // A C++ stub class for wxJoystick for platforms that don't have it.
 class wxJoystick : public wxObject {
 public:
     wxJoystick(int joystick = wxJOYSTICK1) {
 %{
 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
 // A C++ stub class for wxJoystick for platforms that don't have it.
 class wxJoystick : public wxObject {
 public:
     wxJoystick(int joystick = wxJOYSTICK1) {
-        bool doSave = wxPyRestoreThread();
+        wxPyBeginBlockThreads();
         PyErr_SetString(PyExc_NotImplementedError, "wxJoystick is not available on this platform.");
         PyErr_SetString(PyExc_NotImplementedError, "wxJoystick is not available on this platform.");
-        wxPySaveThread(doSave);
+        wxPyEndBlockThreads();
     }
     wxPoint GetPosition() { return wxPoint(-1,-1); }
     int GetZPosition() { return -1; }
     }
     wxPoint GetPosition() { return wxPoint(-1,-1); }
     int GetZPosition() { return -1; }
@@ -813,14 +984,14 @@ class wxWave : public wxObject
 {
 public:
     wxWave(const wxString& fileName, bool isResource = FALSE) {
 {
 public:
     wxWave(const wxString& fileName, bool isResource = FALSE) {
-        wxPyTState* state = wxPyBeginBlockThreads();
+        wxPyBeginBlockThreads();
         PyErr_SetString(PyExc_NotImplementedError, "wxWave is not available on this platform.");
         PyErr_SetString(PyExc_NotImplementedError, "wxWave is not available on this platform.");
-        wxPyEndBlockThreads(state);
+        wxPyEndBlockThreads();
     }
     wxWave(int size, const wxByte* data) {
     }
     wxWave(int size, const wxByte* data) {
-        wxPyTState* state = wxPyBeginBlockThreads();
+        wxPyBeginBlockThreads();
         PyErr_SetString(PyExc_NotImplementedError, "wxWave is not available on this platform.");
         PyErr_SetString(PyExc_NotImplementedError, "wxWave is not available on this platform.");
-        wxPyEndBlockThreads(state);
+        wxPyEndBlockThreads();
     }
 
     ~wxWave() {}
     }
 
     ~wxWave() {}
@@ -850,14 +1021,560 @@ public:
 %}
 
 
 %}
 
 
+//----------------------------------------------------------------------
+
+enum wxMailcapStyle
+{
+    wxMAILCAP_STANDARD = 1,
+    wxMAILCAP_NETSCAPE = 2,
+    wxMAILCAP_KDE = 4,
+    wxMAILCAP_GNOME = 8,
+
+    wxMAILCAP_ALL = 15
+};
+
+
+
+class wxFileTypeInfo
+{
+public:
+    // ctors
+        // a normal item
+    wxFileTypeInfo(const char* mimeType,
+                   const char* openCmd,
+                   const char* printCmd,
+                   const char* desc);
+
+
+        // the array elements correspond to the parameters of the ctor above in
+        // the same order
+    %name(wxFileTypeInfoSequence)wxFileTypeInfo(const wxArrayString& sArray);
+
+        // invalid item - use this to terminate the array passed to
+        // wxMimeTypesManager::AddFallbacks
+    %name(wxNullFileTypeInfo)wxFileTypeInfo();
+
+
+    // test if this object can be used
+    bool IsValid() const;
+
+    // setters
+        // set the icon info
+    void SetIcon(const wxString& iconFile, int iconIndex = 0);
+
+        // set the short desc
+    void SetShortDesc(const wxString& shortDesc);
+
+    // accessors
+        // get the MIME type
+    const wxString& GetMimeType() const;
+        // get the open command
+    const wxString& GetOpenCommand() const;
+        // get the print command
+    const wxString& GetPrintCommand() const;
+        // get the short description (only used under Win32 so far)
+    const wxString& GetShortDesc() const;
+        // get the long, user visible description
+    const wxString& GetDescription() const;
+
+
+        // get the array of all extensions
+    //const wxArrayString& GetExtensions() const;
+    %addmethods {
+        PyObject* GetExtensions() {
+            wxArrayString& arr = (wxArrayString&)self->GetExtensions();
+            return wxArrayString2PyList_helper(arr);
+        }
+    }
+
+    int GetExtensionsCount() const;
+
+    // get the icon info
+    const wxString& GetIconFile() const;
+    int GetIconIndex() const;
+};
+
+
+
+
+class wxFileType
+{
+public:
+
+    // TODO: Make a wxPyMessageParameters with virtual GetParamValue...
+
+    // An object of this class must be passed to Get{Open|Print}Command. The
+    // default implementation is trivial and doesn't know anything at all about
+    // parameters, only filename and MIME type are used (so it's probably ok for
+    // Windows where %{param} is not used anyhow)
+    class MessageParameters
+    {
+    public:
+        // ctors
+        MessageParameters(const wxString& filename=wxPyEmptyString,
+                          const wxString& mimetype=wxPyEmptyString);
+
+        // accessors (called by GetOpenCommand)
+            // filename
+        const wxString& GetFileName() const;
+            // mime type
+        const wxString& GetMimeType() const;;
+
+        // override this function in derived class
+        virtual wxString GetParamValue(const wxString& name) const;
+
+        // virtual dtor as in any base class
+        virtual ~MessageParameters();
+    };
+
+
+    // ctor from static data
+    wxFileType(const wxFileTypeInfo& ftInfo);
+
+    // return the MIME type for this file type
+    %addmethods {
+        PyObject* GetMimeType() {
+            wxString str;
+            if (self->GetMimeType(&str)) {
+#if wxUSE_UNICODE
+             return PyUnicode_FromUnicode(str.c_str(), str.Len());
+#else
+             return PyString_FromStringAndSize(str.c_str(), str.Len());
+#endif
+           }
+            else
+                RETURN_NONE();
+        }
+        PyObject* GetMimeTypes() {
+            wxArrayString arr;
+            if (self->GetMimeTypes(arr))
+                return wxArrayString2PyList_helper(arr);
+            else
+                RETURN_NONE();
+        }
+    }
+
+
+    // Get all extensions associated with this file type
+    %addmethods {
+        PyObject* GetExtensions() {
+            wxArrayString arr;
+            if (self->GetExtensions(arr))
+                return wxArrayString2PyList_helper(arr);
+            else
+                RETURN_NONE();
+        }
+    }
+
+
+    %addmethods {
+        // Get the icon corresponding to this file type
+        %new wxIcon* GetIcon() {
+            wxIcon icon;
+            if (self->GetIcon(&icon))
+                return new wxIcon(icon);
+            else
+                return NULL;
+        }
+
+        // Get the icon corresponding to this file type, the name of the file
+        // where this icon resides, and its index in this file if applicable.
+        PyObject* GetIconInfo() {
+            wxIcon icon;
+            wxString iconFile;
+            int iconIndex;
+            if (self->GetIcon(&icon, &iconFile, &iconIndex)) {
+                wxPyBeginBlockThreads();
+                PyObject* tuple = PyTuple_New(3);
+                PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(icon),
+                                                              "wxIcon", TRUE));
+#if wxUSE_UNICODE
+                PyTuple_SetItem(tuple, 1, PyUnicode_FromUnicode(iconFile.c_str(), iconFile.Len()));
+#else
+                PyTuple_SetItem(tuple, 1, PyString_FromStringAndSize(iconFile.c_str(), iconFile.Len()));
+#endif
+                PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
+                wxPyEndBlockThreads();
+                return tuple;
+            }
+            else
+                RETURN_NONE();
+        }
+    }
+
+    %addmethods {
+        // get a brief file type description ("*.txt" => "text document")
+        PyObject* GetDescription() {
+            wxString str;
+            if (self->GetDescription(&str)) {
+#if  wxUSE_UNICODE
+             return PyUnicode_FromUnicode(str.c_str(), str.Len());
+#else
+             return PyString_FromStringAndSize(str.c_str(), str.Len());
+#endif
+            } else
+                RETURN_NONE();
+        }
+    }
+
+
+    // get the command to open/execute the file of given type
+    %addmethods {
+        PyObject* GetOpenCommand(const wxString& filename,
+                                 const wxString& mimetype=wxPyEmptyString) {
+            wxString str;
+            if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype))) {
+#if  wxUSE_UNICODE
+                return PyUnicode_FromUnicode(str.c_str(), str.Len());
+#else
+                return PyString_FromStringAndSize(str.c_str(), str.Len());
+#endif
+            } else
+                RETURN_NONE();
+        }
+    }
+
+
+    // get the command to print the file of given type
+    %addmethods {
+        PyObject* GetPrintCommand(const wxString& filename,
+                                  const wxString& mimetype=wxPyEmptyString) {
+            wxString str;
+            if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype))) {
+#if wxUSE_UNICODE
+                return PyUnicode_FromUnicode(str.c_str(), str.Len());
+#else
+                return PyString_FromStringAndSize(str.c_str(), str.Len());
+#endif
+            } else
+                RETURN_NONE();
+        }
+    }
+
+
+    // Get all commands defined for this file type
+    %addmethods {
+        PyObject* GetAllCommands(const wxString& filename,
+                                 const wxString& mimetype=wxPyEmptyString) {
+            wxArrayString verbs;
+            wxArrayString commands;
+            if (self->GetAllCommands(&verbs, &commands,
+                                     wxFileType::MessageParameters(filename, mimetype))) {
+                wxPyBeginBlockThreads();
+                PyObject* tuple = PyTuple_New(2);
+                PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
+                PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
+                wxPyEndBlockThreads();
+                return tuple;
+            }
+            else
+                RETURN_NONE();
+        }
+    }
+
+
+    // set an arbitrary command, ask confirmation if it already exists and
+    // overwriteprompt is TRUE
+    bool SetCommand(const wxString& cmd, const wxString& verb,
+                    bool overwriteprompt = TRUE);
+
+    bool SetDefaultIcon(const wxString& cmd = wxPyEmptyString, int index = 0);
+
+
+    // remove the association for this filetype from the system MIME database:
+    // notice that it will only work if the association is defined in the user
+    // file/registry part, we will never modify the system-wide settings
+    bool Unassociate();
+
+    // operations
+        // expand a string in the format of GetOpenCommand (which may contain
+        // '%s' and '%t' format specificators for the file name and mime type
+        // and %{param} constructions).
+    static wxString ExpandCommand(const wxString& command,
+                                  const MessageParameters& params);
+
+    // dtor (not virtual, shouldn't be derived from)
+    ~wxFileType();
+
+};
+
+
+
+
+class wxMimeTypesManager
+{
+public:
+    // static helper functions
+    // -----------------------
+
+        // check if the given MIME type is the same as the other one: the
+        // second argument may contain wildcards ('*'), but not the first. If
+        // the types are equal or if the mimeType matches wildcard the function
+        // returns TRUE, otherwise it returns FALSE
+    static bool IsOfType(const wxString& mimeType, const wxString& wildcard);
+
+    // ctor
+    wxMimeTypesManager();
+
+    // loads data from standard files according to the mailcap styles
+    // specified: this is a bitwise OR of wxMailcapStyle values
+    //
+    // use the extraDir parameter if you want to look for files in another
+    // directory
+    void Initialize(int mailcapStyle = wxMAILCAP_STANDARD,
+                    const wxString& extraDir = wxPyEmptyString);
+
+    // and this function clears all the data from the manager
+    void ClearData();
+
+    // Database lookup: all functions return a pointer to wxFileType object
+    // whose methods may be used to query it for the information you're
+    // interested in. If the return value is !NULL, caller is responsible for
+    // deleting it.
+    // get file type from file extension
+    %new wxFileType *GetFileTypeFromExtension(const wxString& ext);
+
+    // get file type from MIME type (in format <category>/<format>)
+    %new wxFileType *GetFileTypeFromMimeType(const wxString& mimeType);
+
+    // other operations: return TRUE if there were no errors or FALSE if there
+    // were some unreckognized entries (the good entries are always read anyhow)
+    //
+
+        // read in additional file (the standard ones are read automatically)
+        // in mailcap format (see mimetype.cpp for description)
+        //
+        // 'fallback' parameter may be set to TRUE to avoid overriding the
+        // settings from other, previously parsed, files by this one: normally,
+        // the files read most recently would override the older files, but with
+        // fallback == TRUE this won't happen
+    bool ReadMailcap(const wxString& filename, bool fallback = FALSE);
+
+    // read in additional file in mime.types format
+    bool ReadMimeTypes(const wxString& filename);
+
+    // enumerate all known MIME types
+    %addmethods {
+        PyObject* EnumAllFileTypes() {
+            wxArrayString arr;
+            self->EnumAllFileTypes(arr);
+            return wxArrayString2PyList_helper(arr);
+        }
+    }
+
+    // these functions can be used to provide default values for some of the
+    // MIME types inside the program itself (you may also use
+    // ReadMailcap(filenameWithDefaultTypes, TRUE /* use as fallback */) to
+    // achieve the same goal, but this requires having this info in a file).
+    //
+    void AddFallback(const wxFileTypeInfo& ft);
+
+
+    // create or remove associations
+
+        // create a new association using the fields of wxFileTypeInfo (at least
+        // the MIME type and the extension should be set)
+        // if the other fields are empty, the existing values should be left alone
+    %new wxFileType *Associate(const wxFileTypeInfo& ftInfo);
+
+        // undo Associate()
+    bool Unassociate(wxFileType *ft) ;
+
+    // dtor (not virtual, shouldn't be derived from)
+    ~wxMimeTypesManager();
+};
+
+
+%readonly
+%{
+#if 0
+%}
+extern wxMimeTypesManager* wxTheMimeTypesManager;
+%{
+#endif
+%}
+%readwrite
+
+//----------------------------------------------------------------------
+
+%{
+#include <wx/artprov.h>
+
+    DECLARE_DEF_STRING(ART_OTHER);
+
+%}
+
+// Art clients
+#define wxART_TOOLBAR                  "toolbar_C"
+#define wxART_MENU                     "menu_C"
+#define wxART_FRAME_ICON               "frame_icon_C"
+
+#define wxART_CMN_DIALOG               "cmn_dialog_C"
+#define wxART_HELP_BROWSER             "help_browser_C"
+#define wxART_MESSAGE_BOX              "message_box_C"
+
+#define wxART_OTHER                    "other_C"
+
+// Art IDs
+#define wxART_ADD_BOOKMARK             "add_bookmark"
+#define wxART_DEL_BOOKMARK             "del_bookmark"
+#define wxART_HELP_SIDE_PANEL          "help_side_panel"
+#define wxART_HELP_SETTINGS            "help_settings"
+#define wxART_HELP_BOOK                "help_book"
+#define wxART_HELP_FOLDER              "help_folder"
+#define wxART_HELP_PAGE                "help_page"
+#define wxART_GO_BACK                  "go_back"
+#define wxART_GO_FORWARD               "go_forward"
+#define wxART_GO_UP                    "go_up"
+#define wxART_GO_DOWN                  "go_down"
+#define wxART_GO_TO_PARENT             "go_to_parent"
+#define wxART_GO_HOME                  "go_home"
+#define wxART_FILE_OPEN                "file_open"
+#define wxART_PRINT                    "print"
+#define wxART_HELP                     "help"
+#define wxART_TIP                      "tip"
+#define wxART_REPORT_VIEW              "report_view"
+#define wxART_LIST_VIEW                "list_view"
+#define wxART_NEW_DIR                  "new_dir"
+#define wxART_FOLDER                   "folder"
+#define wxART_GO_DIR_UP                "go_dir_up"
+#define wxART_EXECUTABLE_FILE          "executable_file"
+#define wxART_NORMAL_FILE              "normal_file"
+#define wxART_TICK_MARK                "tick"
+#define wxART_CROSS_MARK               "cross"
+#define wxART_ERROR                    "error"
+#define wxART_QUESTION                 "question"
+#define wxART_WARNING                  "warning"
+#define wxART_INFORMATION              "information"
+
+
+%{  // Python aware wxArtProvider
+class wxPyArtProvider : public wxArtProvider  {
+public:
+
+    virtual wxBitmap CreateBitmap(const wxArtID& id,
+                                  const wxArtClient& client,
+                                  const wxSize& size) {
+        wxBitmap rval = wxNullBitmap;
+        wxPyBeginBlockThreads();
+        if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
+            PyObject* so = wxPyConstructObject((void*)&size, "wxSize", 0);
+            PyObject* ro;
+            wxBitmap* ptr;
+            PyObject* s1, *s2;
+            s1 = wx2PyString(id);
+            s2 = wx2PyString(client);
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
+            Py_DECREF(so);
+            Py_DECREF(s1);
+            Py_DECREF(s2);
+            if (ro) {
+                if (!SWIG_GetPtrObj(ro, (void**)&ptr, "_wxBitmap_p"))
+                    rval = *ptr;
+                Py_DECREF(ro);
+            }
+        }
+        wxPyEndBlockThreads();
+        return rval;
+    }
+
+    PYPRIVATE;
+};
+%}
+
+// The one for SWIG to see
+%name(wxArtProvider) class wxPyArtProvider : public wxObject
+{
+public:
+    wxPyArtProvider();
+
+    void _setCallbackInfo(PyObject* self, PyObject* _class);
+    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxArtProvider)"
+
+    // Add new provider to the top of providers stack.
+    static void PushProvider(wxPyArtProvider *provider);
+
+    // Remove latest added provider and delete it.
+    static bool PopProvider();
+
+    // Remove provider. The provider must have been added previously!
+    // The provider is _not_ deleted.
+    static bool RemoveProvider(wxPyArtProvider *provider);
+
+    // Query the providers for bitmap with given ID and return it. Return
+    // wxNullBitmap if no provider provides it.
+    static wxBitmap GetBitmap(const wxString& id,
+                              const wxString& client = wxPyART_OTHER,
+                              const wxSize& size = wxDefaultSize);
+
+    // Query the providers for icon with given ID and return it. Return
+    // wxNullIcon if no provider provides it.
+    static wxIcon GetIcon(const wxString& id,
+                          const wxString& client = wxPyART_OTHER,
+                          const wxSize& size = wxDefaultSize);
+
+    // Destroy caches & all providers
+    static void CleanUpProviders();
+};
+
+
+//----------------------------------------------------------------------
+
+%{
+#include <wx/docview.h>
+%}
+
+class wxFileHistory : public wxObject
+{
+public:
+    wxFileHistory(int maxFiles = 9);
+    ~wxFileHistory();
+
+    // Operations
+    void AddFileToHistory(const wxString& file);
+    void RemoveFileFromHistory(int i);
+    int GetMaxFiles() const;
+    void UseMenu(wxMenu *menu);
+
+    // Remove menu from the list (MDI child may be closing)
+    void RemoveMenu(wxMenu *menu);
+
+    void Load(wxConfigBase& config);
+    void Save(wxConfigBase& config);
+
+    void AddFilesToMenu();
+    %name(AddFilesToThisMenu)void AddFilesToMenu(wxMenu* menu);
+
+    // Accessors
+    wxString GetHistoryFile(int i) const;
+
+    // A synonym for GetNoHistoryFiles
+    int GetCount() const;
+    int GetNoHistoryFiles() const;
+
+};
+
 //----------------------------------------------------------------------
 //----------------------------------------------------------------------
 
 //----------------------------------------------------------------------
 //----------------------------------------------------------------------
 
+// %{
+// #if wxUSE_UNICODE
+// #define ADD_STRING(dict, str) \
+//     wxString tmp##str(str); \
+//     PyDict_SetItemString(dict, #str, \
+//                          PyUnicode_FromUnicode(tmp##str.c_str(), tmp##str.Len()))
+// #else
+// #define ADD_STRING(dict, str) \
+//     PyDict_SetItemString(d, #str, PyString_FromString(str))
+// #endif
+// %}
+
 
 %init %{
 
 %init %{
-    wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
     wxPyPtrTypeMap_Add("wxDragImage", "wxGenericDragImage");
     wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
     wxPyPtrTypeMap_Add("wxDragImage", "wxGenericDragImage");
     wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
+    wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
+
 %}
 
 //----------------------------------------------------------------------
 %}
 
 //----------------------------------------------------------------------