reSWIGged

[wxWidgets.git] / wxPython / src / msw / misc.py

diff --git a/wxPython/src/msw/misc.py b/wxPython/src/msw/misc.py
index 05ca825bbf338111f656958a168098280e45436a..f647c311c58499cd768e95eb8f0561fbe391122b 100644 (file)
--- a/wxPython/src/msw/misc.py
+++ b/wxPython/src/msw/misc.py
@@ -103,32 +103,32 @@ class SystemSettings(object):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxSystemSettings instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def GetColour(*args, **kwargs):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxSystemSettings instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def GetColour(*args, **kwargs):

-        """SystemSettings.GetColour(int index) -> Colour"""
+        """GetColour(int index) -> Colour"""

         return _misc.SystemSettings_GetColour(*args, **kwargs)
 
     GetColour = staticmethod(GetColour)
     def GetFont(*args, **kwargs):
         return _misc.SystemSettings_GetColour(*args, **kwargs)
 
     GetColour = staticmethod(GetColour)
     def GetFont(*args, **kwargs):

-        """SystemSettings.GetFont(int index) -> Font"""
+        """GetFont(int index) -> Font"""

         return _misc.SystemSettings_GetFont(*args, **kwargs)
 
     GetFont = staticmethod(GetFont)
     def GetMetric(*args, **kwargs):
         return _misc.SystemSettings_GetFont(*args, **kwargs)
 
     GetFont = staticmethod(GetFont)
     def GetMetric(*args, **kwargs):

-        """SystemSettings.GetMetric(int index) -> int"""
+        """GetMetric(int index) -> int"""

         return _misc.SystemSettings_GetMetric(*args, **kwargs)
 
     GetMetric = staticmethod(GetMetric)
     def HasFeature(*args, **kwargs):
         return _misc.SystemSettings_GetMetric(*args, **kwargs)
 
     GetMetric = staticmethod(GetMetric)
     def HasFeature(*args, **kwargs):

-        """SystemSettings.HasFeature(int index) -> bool"""
+        """HasFeature(int index) -> bool"""

         return _misc.SystemSettings_HasFeature(*args, **kwargs)
 
     HasFeature = staticmethod(HasFeature)
     def GetScreenType(*args, **kwargs):
         return _misc.SystemSettings_HasFeature(*args, **kwargs)
 
     HasFeature = staticmethod(HasFeature)
     def GetScreenType(*args, **kwargs):

-        """SystemSettings.GetScreenType() -> int"""
+        """GetScreenType() -> int"""

         return _misc.SystemSettings_GetScreenType(*args, **kwargs)
 
     GetScreenType = staticmethod(GetScreenType)
     def SetScreenType(*args, **kwargs):
         return _misc.SystemSettings_GetScreenType(*args, **kwargs)
 
     GetScreenType = staticmethod(GetScreenType)
     def SetScreenType(*args, **kwargs):

-        """SystemSettings.SetScreenType(int screen)"""
+        """SetScreenType(int screen)"""

         return _misc.SystemSettings_SetScreenType(*args, **kwargs)
 
     SetScreenType = staticmethod(SetScreenType)
         return _misc.SystemSettings_SetScreenType(*args, **kwargs)
 
     SetScreenType = staticmethod(SetScreenType)


@@ -174,27 +174,27 @@ class SystemOptions(core.Object):
         self.thisown = 1
         del newobj.thisown
     def SetOption(*args, **kwargs):
         self.thisown = 1
         del newobj.thisown
     def SetOption(*args, **kwargs):

-        """SystemOptions.SetOption(String name, String value)"""
+        """SetOption(String name, String value)"""

         return _misc.SystemOptions_SetOption(*args, **kwargs)
 
     SetOption = staticmethod(SetOption)
     def SetOptionInt(*args, **kwargs):
         return _misc.SystemOptions_SetOption(*args, **kwargs)
 
     SetOption = staticmethod(SetOption)
     def SetOptionInt(*args, **kwargs):

-        """SystemOptions.SetOptionInt(String name, int value)"""
+        """SetOptionInt(String name, int value)"""

         return _misc.SystemOptions_SetOptionInt(*args, **kwargs)
 
     SetOptionInt = staticmethod(SetOptionInt)
     def GetOption(*args, **kwargs):
         return _misc.SystemOptions_SetOptionInt(*args, **kwargs)
 
     SetOptionInt = staticmethod(SetOptionInt)
     def GetOption(*args, **kwargs):

-        """SystemOptions.GetOption(String name) -> String"""
+        """GetOption(String name) -> String"""

         return _misc.SystemOptions_GetOption(*args, **kwargs)
 
     GetOption = staticmethod(GetOption)
     def GetOptionInt(*args, **kwargs):
         return _misc.SystemOptions_GetOption(*args, **kwargs)
 
     GetOption = staticmethod(GetOption)
     def GetOptionInt(*args, **kwargs):

-        """SystemOptions.GetOptionInt(String name) -> int"""
+        """GetOptionInt(String name) -> int"""

         return _misc.SystemOptions_GetOptionInt(*args, **kwargs)
 
     GetOptionInt = staticmethod(GetOptionInt)
     def HasOption(*args, **kwargs):
         return _misc.SystemOptions_GetOptionInt(*args, **kwargs)
 
     GetOptionInt = staticmethod(GetOptionInt)
     def HasOption(*args, **kwargs):

-        """SystemOptions.HasOption(String name) -> bool"""
+        """HasOption(String name) -> bool"""

         return _misc.SystemOptions_HasOption(*args, **kwargs)
 
     HasOption = staticmethod(HasOption)
         return _misc.SystemOptions_HasOption(*args, **kwargs)
 
     HasOption = staticmethod(HasOption)


@@ -553,12 +553,12 @@ class ToolTip(core.Object):
         return _misc.ToolTip_GetWindow(*args, **kwargs)
 
     def Enable(*args, **kwargs):
         return _misc.ToolTip_GetWindow(*args, **kwargs)
 
     def Enable(*args, **kwargs):

-        """ToolTip.Enable(bool flag)"""
+        """Enable(bool flag)"""

         return _misc.ToolTip_Enable(*args, **kwargs)
 
     Enable = staticmethod(Enable)
     def SetDelay(*args, **kwargs):
         return _misc.ToolTip_Enable(*args, **kwargs)
 
     Enable = staticmethod(Enable)
     def SetDelay(*args, **kwargs):

-        """ToolTip.SetDelay(long milliseconds)"""
+        """SetDelay(long milliseconds)"""

         return _misc.ToolTip_SetDelay(*args, **kwargs)
 
     SetDelay = staticmethod(SetDelay)
         return _misc.ToolTip_SetDelay(*args, **kwargs)
 
     SetDelay = staticmethod(SetDelay)


@@ -823,6 +823,7 @@ class FileHistory(core.Object):
         """GetCount() -> int"""
         return _misc.FileHistory_GetCount(*args, **kwargs)
 
         """GetCount() -> int"""
         return _misc.FileHistory_GetCount(*args, **kwargs)
 

+    GetNoHistoryFiles = GetCount 

 
 class FileHistoryPtr(FileHistory):
     def __init__(self, this):
 
 class FileHistoryPtr(FileHistory):
     def __init__(self, this):


@@ -1093,17 +1094,17 @@ class Log(object):
         self.thisown = 1
         del newobj.thisown
     def IsEnabled(*args, **kwargs):
         self.thisown = 1
         del newobj.thisown
     def IsEnabled(*args, **kwargs):

-        """Log.IsEnabled() -> bool"""
+        """IsEnabled() -> bool"""

         return _misc.Log_IsEnabled(*args, **kwargs)
 
     IsEnabled = staticmethod(IsEnabled)
     def EnableLogging(*args, **kwargs):
         return _misc.Log_IsEnabled(*args, **kwargs)
 
     IsEnabled = staticmethod(IsEnabled)
     def EnableLogging(*args, **kwargs):

-        """Log.EnableLogging(bool doIt=True) -> bool"""
+        """EnableLogging(bool doIt=True) -> bool"""

         return _misc.Log_EnableLogging(*args, **kwargs)
 
     EnableLogging = staticmethod(EnableLogging)
     def OnLog(*args, **kwargs):
         return _misc.Log_EnableLogging(*args, **kwargs)
 
     EnableLogging = staticmethod(EnableLogging)
     def OnLog(*args, **kwargs):

-        """Log.OnLog(wxLogLevel level, wxChar szString, time_t t)"""
+        """OnLog(wxLogLevel level, wxChar szString, time_t t)"""

         return _misc.Log_OnLog(*args, **kwargs)
 
     OnLog = staticmethod(OnLog)
         return _misc.Log_OnLog(*args, **kwargs)
 
     OnLog = staticmethod(OnLog)


@@ -1112,102 +1113,102 @@ class Log(object):
         return _misc.Log_Flush(*args, **kwargs)
 
     def FlushActive(*args, **kwargs):
         return _misc.Log_Flush(*args, **kwargs)
 
     def FlushActive(*args, **kwargs):

-        """Log.FlushActive()"""
+        """FlushActive()"""

         return _misc.Log_FlushActive(*args, **kwargs)
 
     FlushActive = staticmethod(FlushActive)
     def GetActiveTarget(*args, **kwargs):
         return _misc.Log_FlushActive(*args, **kwargs)
 
     FlushActive = staticmethod(FlushActive)
     def GetActiveTarget(*args, **kwargs):

-        """Log.GetActiveTarget() -> Log"""
+        """GetActiveTarget() -> Log"""

         return _misc.Log_GetActiveTarget(*args, **kwargs)
 
     GetActiveTarget = staticmethod(GetActiveTarget)
     def SetActiveTarget(*args, **kwargs):
         return _misc.Log_GetActiveTarget(*args, **kwargs)
 
     GetActiveTarget = staticmethod(GetActiveTarget)
     def SetActiveTarget(*args, **kwargs):

-        """Log.SetActiveTarget(Log pLogger) -> Log"""
+        """SetActiveTarget(Log pLogger) -> Log"""

         return _misc.Log_SetActiveTarget(*args, **kwargs)
 
     SetActiveTarget = staticmethod(SetActiveTarget)
     def Suspend(*args, **kwargs):
         return _misc.Log_SetActiveTarget(*args, **kwargs)
 
     SetActiveTarget = staticmethod(SetActiveTarget)
     def Suspend(*args, **kwargs):

-        """Log.Suspend()"""
+        """Suspend()"""

         return _misc.Log_Suspend(*args, **kwargs)
 
     Suspend = staticmethod(Suspend)
     def Resume(*args, **kwargs):
         return _misc.Log_Suspend(*args, **kwargs)
 
     Suspend = staticmethod(Suspend)
     def Resume(*args, **kwargs):

-        """Log.Resume()"""
+        """Resume()"""

         return _misc.Log_Resume(*args, **kwargs)
 
     Resume = staticmethod(Resume)
     def SetVerbose(*args, **kwargs):
         return _misc.Log_Resume(*args, **kwargs)
 
     Resume = staticmethod(Resume)
     def SetVerbose(*args, **kwargs):

-        """Log.SetVerbose(bool bVerbose=True)"""
+        """SetVerbose(bool bVerbose=True)"""

         return _misc.Log_SetVerbose(*args, **kwargs)
 
     SetVerbose = staticmethod(SetVerbose)
     def SetLogLevel(*args, **kwargs):
         return _misc.Log_SetVerbose(*args, **kwargs)
 
     SetVerbose = staticmethod(SetVerbose)
     def SetLogLevel(*args, **kwargs):

-        """Log.SetLogLevel(wxLogLevel logLevel)"""
+        """SetLogLevel(wxLogLevel logLevel)"""

         return _misc.Log_SetLogLevel(*args, **kwargs)
 
     SetLogLevel = staticmethod(SetLogLevel)
     def DontCreateOnDemand(*args, **kwargs):
         return _misc.Log_SetLogLevel(*args, **kwargs)
 
     SetLogLevel = staticmethod(SetLogLevel)
     def DontCreateOnDemand(*args, **kwargs):

-        """Log.DontCreateOnDemand()"""
+        """DontCreateOnDemand()"""

         return _misc.Log_DontCreateOnDemand(*args, **kwargs)
 
     DontCreateOnDemand = staticmethod(DontCreateOnDemand)
     def SetTraceMask(*args, **kwargs):
         return _misc.Log_DontCreateOnDemand(*args, **kwargs)
 
     DontCreateOnDemand = staticmethod(DontCreateOnDemand)
     def SetTraceMask(*args, **kwargs):

-        """Log.SetTraceMask(wxTraceMask ulMask)"""
+        """SetTraceMask(wxTraceMask ulMask)"""

         return _misc.Log_SetTraceMask(*args, **kwargs)
 
     SetTraceMask = staticmethod(SetTraceMask)
     def AddTraceMask(*args, **kwargs):
         return _misc.Log_SetTraceMask(*args, **kwargs)
 
     SetTraceMask = staticmethod(SetTraceMask)
     def AddTraceMask(*args, **kwargs):

-        """Log.AddTraceMask(String str)"""
+        """AddTraceMask(String str)"""

         return _misc.Log_AddTraceMask(*args, **kwargs)
 
     AddTraceMask = staticmethod(AddTraceMask)
     def RemoveTraceMask(*args, **kwargs):
         return _misc.Log_AddTraceMask(*args, **kwargs)
 
     AddTraceMask = staticmethod(AddTraceMask)
     def RemoveTraceMask(*args, **kwargs):

-        """Log.RemoveTraceMask(String str)"""
+        """RemoveTraceMask(String str)"""

         return _misc.Log_RemoveTraceMask(*args, **kwargs)
 
     RemoveTraceMask = staticmethod(RemoveTraceMask)
     def ClearTraceMasks(*args, **kwargs):
         return _misc.Log_RemoveTraceMask(*args, **kwargs)
 
     RemoveTraceMask = staticmethod(RemoveTraceMask)
     def ClearTraceMasks(*args, **kwargs):

-        """Log.ClearTraceMasks()"""
+        """ClearTraceMasks()"""

         return _misc.Log_ClearTraceMasks(*args, **kwargs)
 
     ClearTraceMasks = staticmethod(ClearTraceMasks)
     def GetTraceMasks(*args, **kwargs):
         return _misc.Log_ClearTraceMasks(*args, **kwargs)
 
     ClearTraceMasks = staticmethod(ClearTraceMasks)
     def GetTraceMasks(*args, **kwargs):

-        """Log.GetTraceMasks() -> wxArrayString"""
+        """GetTraceMasks() -> wxArrayString"""

         return _misc.Log_GetTraceMasks(*args, **kwargs)
 
     GetTraceMasks = staticmethod(GetTraceMasks)
     def SetTimestamp(*args, **kwargs):
         return _misc.Log_GetTraceMasks(*args, **kwargs)
 
     GetTraceMasks = staticmethod(GetTraceMasks)
     def SetTimestamp(*args, **kwargs):

-        """Log.SetTimestamp(wxChar ts)"""
+        """SetTimestamp(wxChar ts)"""

         return _misc.Log_SetTimestamp(*args, **kwargs)
 
     SetTimestamp = staticmethod(SetTimestamp)
     def GetVerbose(*args, **kwargs):
         return _misc.Log_SetTimestamp(*args, **kwargs)
 
     SetTimestamp = staticmethod(SetTimestamp)
     def GetVerbose(*args, **kwargs):

-        """Log.GetVerbose() -> bool"""
+        """GetVerbose() -> bool"""

         return _misc.Log_GetVerbose(*args, **kwargs)
 
     GetVerbose = staticmethod(GetVerbose)
     def GetTraceMask(*args, **kwargs):
         return _misc.Log_GetVerbose(*args, **kwargs)
 
     GetVerbose = staticmethod(GetVerbose)
     def GetTraceMask(*args, **kwargs):

-        """Log.GetTraceMask() -> wxTraceMask"""
+        """GetTraceMask() -> wxTraceMask"""

         return _misc.Log_GetTraceMask(*args, **kwargs)
 
     GetTraceMask = staticmethod(GetTraceMask)
     def IsAllowedTraceMask(*args, **kwargs):
         return _misc.Log_GetTraceMask(*args, **kwargs)
 
     GetTraceMask = staticmethod(GetTraceMask)
     def IsAllowedTraceMask(*args, **kwargs):

-        """Log.IsAllowedTraceMask(wxChar mask) -> bool"""
+        """IsAllowedTraceMask(wxChar mask) -> bool"""

         return _misc.Log_IsAllowedTraceMask(*args, **kwargs)
 
     IsAllowedTraceMask = staticmethod(IsAllowedTraceMask)
     def GetLogLevel(*args, **kwargs):
         return _misc.Log_IsAllowedTraceMask(*args, **kwargs)
 
     IsAllowedTraceMask = staticmethod(IsAllowedTraceMask)
     def GetLogLevel(*args, **kwargs):

-        """Log.GetLogLevel() -> wxLogLevel"""
+        """GetLogLevel() -> wxLogLevel"""

         return _misc.Log_GetLogLevel(*args, **kwargs)
 
     GetLogLevel = staticmethod(GetLogLevel)
     def GetTimestamp(*args, **kwargs):
         return _misc.Log_GetLogLevel(*args, **kwargs)
 
     GetLogLevel = staticmethod(GetLogLevel)
     def GetTimestamp(*args, **kwargs):

-        """Log.GetTimestamp() -> wxChar"""
+        """GetTimestamp() -> wxChar"""

         return _misc.Log_GetTimestamp(*args, **kwargs)
 
     GetTimestamp = staticmethod(GetTimestamp)
     def TimeStamp(*args, **kwargs):
         return _misc.Log_GetTimestamp(*args, **kwargs)
 
     GetTimestamp = staticmethod(GetTimestamp)
     def TimeStamp(*args, **kwargs):

-        """Log.TimeStamp() -> String"""
+        """TimeStamp() -> String"""

         return _misc.Log_TimeStamp(*args, **kwargs)
 
     TimeStamp = staticmethod(TimeStamp)
         return _misc.Log_TimeStamp(*args, **kwargs)
 
     TimeStamp = staticmethod(TimeStamp)


@@ -1575,17 +1576,17 @@ class Process(core.EvtHandler):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxPyProcess instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def Kill(*args, **kwargs):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxPyProcess instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def Kill(*args, **kwargs):

-        """Process.Kill(int pid, int sig=SIGTERM) -> int"""
+        """Kill(int pid, int sig=SIGTERM) -> int"""

         return _misc.Process_Kill(*args, **kwargs)
 
     Kill = staticmethod(Kill)
     def Exists(*args, **kwargs):
         return _misc.Process_Kill(*args, **kwargs)
 
     Kill = staticmethod(Kill)
     def Exists(*args, **kwargs):

-        """Process.Exists(int pid) -> bool"""
+        """Exists(int pid) -> bool"""

         return _misc.Process_Exists(*args, **kwargs)
 
     Exists = staticmethod(Exists)
     def Open(*args, **kwargs):
         return _misc.Process_Exists(*args, **kwargs)
 
     Exists = staticmethod(Exists)
     def Open(*args, **kwargs):

-        """Process.Open(String cmd, int flags=EXEC_ASYNC) -> Process"""
+        """Open(String cmd, int flags=EXEC_ASYNC) -> Process"""

         return _misc.Process_Open(*args, **kwargs)
 
     Open = staticmethod(Open)
         return _misc.Process_Open(*args, **kwargs)
 
     Open = staticmethod(Open)


@@ -1768,7 +1769,7 @@ class Joystick(object):
         return _misc.Joystick_SetMovementThreshold(*args, **kwargs)
 
     def IsOk(*args, **kwargs):
         return _misc.Joystick_SetMovementThreshold(*args, **kwargs)
 
     def IsOk(*args, **kwargs):

-        """IsOk(void ??) -> bool"""
+        """IsOk() -> bool"""

         return _misc.Joystick_IsOk(*args, **kwargs)
 
     def GetNumberJoysticks(*args, **kwargs):
         return _misc.Joystick_IsOk(*args, **kwargs)
 
     def GetNumberJoysticks(*args, **kwargs):


@@ -2011,43 +2012,69 @@ EVT_JOYSTICK_EVENTS = wx.PyEventBinder([ wxEVT_JOY_BUTTON_DOWN,
 
 #---------------------------------------------------------------------------
 
 
 #---------------------------------------------------------------------------
 

-class Wave(object):
+SOUND_SYNC = _misc.SOUND_SYNC
+SOUND_ASYNC = _misc.SOUND_ASYNC
+SOUND_LOOP = _misc.SOUND_LOOP
+class Sound(object):

     def __repr__(self):
     def __repr__(self):

-        return "<%s.%s; proxy of C++ wxWave instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__(String fileName, bool isResource=False) -> Wave"""
-        newobj = _misc.new_Wave(*args, **kwargs)
+        return "<%s.%s; proxy of C++ wxSound instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args):
+        """
+        __init__() -> Sound
+        __init__(String fileName, bool isResource=false) -> Sound
+        __init__(int size, wxByte data) -> Sound
+        """
+        newobj = _misc.new_Sound(*args)

         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown

-    def __del__(self, destroy=_misc.delete_Wave):
+    def __del__(self, destroy=_misc.delete_Sound):

         """__del__()"""
         try:
             if self.thisown: destroy(self)
         except: pass
 
         """__del__()"""
         try:
             if self.thisown: destroy(self)
         except: pass
 

+    def Create(*args):
+        """
+        Create(String fileName, bool isResource=false) -> bool
+        Create(int size, wxByte data) -> bool
+        """
+        return _misc.Sound_Create(*args)
+

     def IsOk(*args, **kwargs):
         """IsOk() -> bool"""
     def IsOk(*args, **kwargs):
         """IsOk() -> bool"""

-        return _misc.Wave_IsOk(*args, **kwargs)
+        return _misc.Sound_IsOk(*args, **kwargs)
+
+    def Play(*args):
+        """Play(unsigned int flags=SOUND_ASYNC) -> bool"""
+        return _misc.Sound_Play(*args)

 
 

-    def Play(*args, **kwargs):
-        """Play(bool async=True, bool looped=False) -> bool"""
-        return _misc.Wave_Play(*args, **kwargs)
+    def PlaySound(*args):
+        """PlaySound(String filename, unsigned int flags=SOUND_ASYNC) -> bool"""
+        return _misc.Sound_PlaySound(*args)
+
+    PlaySound = staticmethod(PlaySound)
+    def Stop(*args, **kwargs):
+        """Stop()"""
+        return _misc.Sound_Stop(*args, **kwargs)

 
 

+    Stop = staticmethod(Stop)

     def __nonzero__(self): return self.IsOk() 
 
     def __nonzero__(self): return self.IsOk() 
 

-class WavePtr(Wave):
+class SoundPtr(Sound):

     def __init__(self, this):
         self.this = this
         if not hasattr(self,"thisown"): self.thisown = 0
     def __init__(self, this):
         self.this = this
         if not hasattr(self,"thisown"): self.thisown = 0

-        self.__class__ = Wave
-_misc.Wave_swigregister(WavePtr)
+        self.__class__ = Sound
+_misc.Sound_swigregister(SoundPtr)

 
 

-def WaveData(*args, **kwargs):
-    """WaveData(String data) -> Wave"""
-    val = _misc.new_WaveData(*args, **kwargs)
-    val.thisown = 1
-    return val
+def Sound_PlaySound(*args):
+    """Sound_PlaySound(String filename, unsigned int flags=SOUND_ASYNC) -> bool"""
+    return _misc.Sound_PlaySound(*args)
+
+def Sound_Stop(*args, **kwargs):
+    """Sound_Stop()"""
+    return _misc.Sound_Stop(*args, **kwargs)

 
 #---------------------------------------------------------------------------
 
 
 #---------------------------------------------------------------------------
 


@@ -2197,7 +2224,7 @@ class FileType(object):
         return _misc.FileType_Unassociate(*args, **kwargs)
 
     def ExpandCommand(*args, **kwargs):
         return _misc.FileType_Unassociate(*args, **kwargs)
 
     def ExpandCommand(*args, **kwargs):

-        """FileType.ExpandCommand(String command, String filename, String mimetype=EmptyString) -> String"""
+        """ExpandCommand(String command, String filename, String mimetype=EmptyString) -> String"""

         return _misc.FileType_ExpandCommand(*args, **kwargs)
 
     ExpandCommand = staticmethod(ExpandCommand)
         return _misc.FileType_ExpandCommand(*args, **kwargs)
 
     ExpandCommand = staticmethod(ExpandCommand)


@@ -2217,7 +2244,7 @@ class MimeTypesManager(object):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxMimeTypesManager instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def IsOfType(*args, **kwargs):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxMimeTypesManager instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def IsOfType(*args, **kwargs):

-        """MimeTypesManager.IsOfType(String mimeType, String wildcard) -> bool"""
+        """IsOfType(String mimeType, String wildcard) -> bool"""

         return _misc.MimeTypesManager_IsOfType(*args, **kwargs)
 
     IsOfType = staticmethod(IsOfType)
         return _misc.MimeTypesManager_IsOfType(*args, **kwargs)
 
     IsOfType = staticmethod(IsOfType)


@@ -2305,7 +2332,7 @@ class ArtProvider(object):
 
     def PushProvider(*args, **kwargs):
         """
 
     def PushProvider(*args, **kwargs):
         """

-        ArtProvider.PushProvider(ArtProvider provider)
+        PushProvider(ArtProvider provider)

 
         Add new provider to the top of providers stack.
         """
 
         Add new provider to the top of providers stack.
         """


@@ -2314,7 +2341,7 @@ class ArtProvider(object):
     PushProvider = staticmethod(PushProvider)
     def PopProvider(*args, **kwargs):
         """
     PushProvider = staticmethod(PushProvider)
     def PopProvider(*args, **kwargs):
         """

-        ArtProvider.PopProvider() -> bool
+        PopProvider() -> bool

 
         Remove latest added provider and delete it.
         """
 
         Remove latest added provider and delete it.
         """


@@ -2323,7 +2350,7 @@ class ArtProvider(object):
     PopProvider = staticmethod(PopProvider)
     def RemoveProvider(*args, **kwargs):
         """
     PopProvider = staticmethod(PopProvider)
     def RemoveProvider(*args, **kwargs):
         """

-        ArtProvider.RemoveProvider(ArtProvider provider) -> bool
+        RemoveProvider(ArtProvider provider) -> bool

 
         Remove provider. The provider must have been added previously!
         The provider is _not_ deleted.
 
         Remove provider. The provider must have been added previously!
         The provider is _not_ deleted.


@@ -2333,7 +2360,7 @@ class ArtProvider(object):
     RemoveProvider = staticmethod(RemoveProvider)
     def GetBitmap(*args, **kwargs):
         """
     RemoveProvider = staticmethod(RemoveProvider)
     def GetBitmap(*args, **kwargs):
         """

-        ArtProvider.GetBitmap(String id, String client=ART_OTHER, Size size=DefaultSize) -> Bitmap
+        GetBitmap(String id, String client=ART_OTHER, Size size=DefaultSize) -> Bitmap

 
         Query the providers for bitmap with given ID and return it. Return
         wx.NullBitmap if no provider provides it.
 
         Query the providers for bitmap with given ID and return it. Return
         wx.NullBitmap if no provider provides it.


@@ -2343,7 +2370,7 @@ class ArtProvider(object):
     GetBitmap = staticmethod(GetBitmap)
     def GetIcon(*args, **kwargs):
         """
     GetBitmap = staticmethod(GetBitmap)
     def GetIcon(*args, **kwargs):
         """

-        ArtProvider.GetIcon(String id, String client=ART_OTHER, Size size=DefaultSize) -> Icon
+        GetIcon(String id, String client=ART_OTHER, Size size=DefaultSize) -> Icon

 
         Query the providers for icon with given ID and return it. Return
         wx.NullIcon if no provider provides it.
 
         Query the providers for icon with given ID and return it. Return
         wx.NullIcon if no provider provides it.


@@ -2451,6 +2478,26 @@ CONFIG_USE_GLOBAL_FILE = _misc.CONFIG_USE_GLOBAL_FILE
 CONFIG_USE_RELATIVE_PATH = _misc.CONFIG_USE_RELATIVE_PATH
 CONFIG_USE_NO_ESCAPE_CHARACTERS = _misc.CONFIG_USE_NO_ESCAPE_CHARACTERS
 class ConfigBase(object):
 CONFIG_USE_RELATIVE_PATH = _misc.CONFIG_USE_RELATIVE_PATH
 CONFIG_USE_NO_ESCAPE_CHARACTERS = _misc.CONFIG_USE_NO_ESCAPE_CHARACTERS
 class ConfigBase(object):

+    """
+    wx.ConfigBase class defines the basic interface of all config
+    classes. It can not be used by itself (it is an abstract base
+    class) and you will always use one of its derivations: wx.Config
+    or wx.FileConfig.
+
+    wx.ConfigBase organizes the items in a tree-like structure
+    (modeled after the Unix/Dos filesystem). There are groups
+    (directories) and keys (files).  There is always one current
+    group given by the current path.  As in the file system case, to
+    specify a key in the config class you must use a path to it.
+    Config classes also support the notion of the current group,
+    which makes it possible to use relative paths.
+
+    Keys are pairs "key_name = value" where value may be of string, integer
+    floating point or boolean, you can not store binary data without first
+    encoding it as a string.  For performance reasons items should be kept small,
+    no more than a couple kilobytes.
+
+    """

     def __init__(self): raise RuntimeError, "No constructor defined"
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxConfigBase instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self): raise RuntimeError, "No constructor defined"
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxConfigBase instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)


@@ -2466,147 +2513,311 @@ class ConfigBase(object):
     Type_Integer = _misc.ConfigBase_Type_Integer
     Type_Float = _misc.ConfigBase_Type_Float
     def Set(*args, **kwargs):
     Type_Integer = _misc.ConfigBase_Type_Integer
     Type_Float = _misc.ConfigBase_Type_Float
     def Set(*args, **kwargs):

-        """ConfigBase.Set(ConfigBase pConfig) -> ConfigBase"""
+        """
+        Set(ConfigBase config) -> ConfigBase
+
+        Sets the global config object (the one returned by Get) and
+        returns a reference to the previous global config object.
+        """

         return _misc.ConfigBase_Set(*args, **kwargs)
 
     Set = staticmethod(Set)
     def Get(*args, **kwargs):
         return _misc.ConfigBase_Set(*args, **kwargs)
 
     Set = staticmethod(Set)
     def Get(*args, **kwargs):

-        """ConfigBase.Get(bool createOnDemand=True) -> ConfigBase"""
+        """
+        Get(bool createOnDemand=True) -> ConfigBase
+
+        Returns the current global config object, creating one if neccessary.
+        """

         return _misc.ConfigBase_Get(*args, **kwargs)
 
     Get = staticmethod(Get)
     def Create(*args, **kwargs):
         return _misc.ConfigBase_Get(*args, **kwargs)
 
     Get = staticmethod(Get)
     def Create(*args, **kwargs):

-        """ConfigBase.Create() -> ConfigBase"""
+        """
+        Create() -> ConfigBase
+
+        Create and return a new global config object.  This function will
+        create the "best" implementation of wx.Config available for the
+        current platform.
+        """

         return _misc.ConfigBase_Create(*args, **kwargs)
 
     Create = staticmethod(Create)
     def DontCreateOnDemand(*args, **kwargs):
         return _misc.ConfigBase_Create(*args, **kwargs)
 
     Create = staticmethod(Create)
     def DontCreateOnDemand(*args, **kwargs):

-        """ConfigBase.DontCreateOnDemand()"""
+        """
+        DontCreateOnDemand()
+
+        Should Get() try to create a new log object if there isn't a current one?
+        """

         return _misc.ConfigBase_DontCreateOnDemand(*args, **kwargs)
 
     DontCreateOnDemand = staticmethod(DontCreateOnDemand)
     def SetPath(*args, **kwargs):
         return _misc.ConfigBase_DontCreateOnDemand(*args, **kwargs)
 
     DontCreateOnDemand = staticmethod(DontCreateOnDemand)
     def SetPath(*args, **kwargs):

-        """SetPath(String strPath)"""
+        """
+        SetPath(String path)
+
+        Set current path: if the first character is '/', it's the absolute path,
+        otherwise it's a relative path. '..' is supported. If the strPath
+        doesn't exist it is created.
+        """

         return _misc.ConfigBase_SetPath(*args, **kwargs)
 
     def GetPath(*args, **kwargs):
         return _misc.ConfigBase_SetPath(*args, **kwargs)
 
     def GetPath(*args, **kwargs):

-        """GetPath() -> String"""
+        """
+        GetPath() -> String
+
+        Retrieve the current path (always as absolute path)
+        """

         return _misc.ConfigBase_GetPath(*args, **kwargs)
 
     def GetFirstGroup(*args, **kwargs):
         return _misc.ConfigBase_GetPath(*args, **kwargs)
 
     def GetFirstGroup(*args, **kwargs):

-        """GetFirstGroup() -> PyObject"""
+        """
+        GetFirstGroup() -> (more, value, index)
+
+        Allows enumerating the subgroups in a config object.  Returns
+        a tuple containing a flag indicating there are more items, the
+        name of the current item, and an index to pass to GetNextGroup to
+        fetch the next item.
+        """

         return _misc.ConfigBase_GetFirstGroup(*args, **kwargs)
 
     def GetNextGroup(*args, **kwargs):
         return _misc.ConfigBase_GetFirstGroup(*args, **kwargs)
 
     def GetNextGroup(*args, **kwargs):

-        """GetNextGroup(long index) -> PyObject"""
+        """
+        GetNextGroup(long index) -> (more, value, index)
+
+        Allows enumerating the subgroups in a config object.  Returns
+        a tuple containing a flag indicating there are more items, the
+        name of the current item, and an index to pass to GetNextGroup to
+        fetch the next item.
+        """

         return _misc.ConfigBase_GetNextGroup(*args, **kwargs)
 
     def GetFirstEntry(*args, **kwargs):
         return _misc.ConfigBase_GetNextGroup(*args, **kwargs)
 
     def GetFirstEntry(*args, **kwargs):

-        """GetFirstEntry() -> PyObject"""
+        """
+        GetFirstEntry() -> (more, value, index)
+
+        Allows enumerating the entries in the current group in a config
+        object.  Returns a tuple containing a flag indicating there are
+        more items, the name of the current item, and an index to pass to
+        GetNextGroup to fetch the next item.
+        """

         return _misc.ConfigBase_GetFirstEntry(*args, **kwargs)
 
     def GetNextEntry(*args, **kwargs):
         return _misc.ConfigBase_GetFirstEntry(*args, **kwargs)
 
     def GetNextEntry(*args, **kwargs):

-        """GetNextEntry(long index) -> PyObject"""
+        """
+        GetNextEntry(long index) -> (more, value, index)
+
+        Allows enumerating the entries in the current group in a config
+        object.  Returns a tuple containing a flag indicating there are
+        more items, the name of the current item, and an index to pass to
+        GetNextGroup to fetch the next item.
+        """

         return _misc.ConfigBase_GetNextEntry(*args, **kwargs)
 
     def GetNumberOfEntries(*args, **kwargs):
         return _misc.ConfigBase_GetNextEntry(*args, **kwargs)
 
     def GetNumberOfEntries(*args, **kwargs):

-        """GetNumberOfEntries(bool bRecursive=False) -> size_t"""
+        """
+        GetNumberOfEntries(bool recursive=False) -> size_t
+
+        Get the number of entries in the current group, with or
+        without its subgroups.
+        """

         return _misc.ConfigBase_GetNumberOfEntries(*args, **kwargs)
 
     def GetNumberOfGroups(*args, **kwargs):
         return _misc.ConfigBase_GetNumberOfEntries(*args, **kwargs)
 
     def GetNumberOfGroups(*args, **kwargs):

-        """GetNumberOfGroups(bool bRecursive=False) -> size_t"""
+        """
+        GetNumberOfGroups(bool recursive=False) -> size_t
+
+        Get the number of subgroups in the current group, with or
+        without its subgroups.
+        """

         return _misc.ConfigBase_GetNumberOfGroups(*args, **kwargs)
 
     def HasGroup(*args, **kwargs):
         return _misc.ConfigBase_GetNumberOfGroups(*args, **kwargs)
 
     def HasGroup(*args, **kwargs):

-        """HasGroup(String strName) -> bool"""
+        """
+        HasGroup(String name) -> bool
+
+        Returns True if the group by this name exists
+        """

         return _misc.ConfigBase_HasGroup(*args, **kwargs)
 
     def HasEntry(*args, **kwargs):
         return _misc.ConfigBase_HasGroup(*args, **kwargs)
 
     def HasEntry(*args, **kwargs):

-        """HasEntry(String strName) -> bool"""
+        """
+        HasEntry(String name) -> bool
+
+        Returns True if the entry by this name exists
+        """

         return _misc.ConfigBase_HasEntry(*args, **kwargs)
 
     def Exists(*args, **kwargs):
         return _misc.ConfigBase_HasEntry(*args, **kwargs)
 
     def Exists(*args, **kwargs):

-        """Exists(String strName) -> bool"""
+        """
+        Exists(String name) -> bool
+
+        Returns True if either a group or an entry with a given name exists
+        """

         return _misc.ConfigBase_Exists(*args, **kwargs)
 
     def GetEntryType(*args, **kwargs):
         return _misc.ConfigBase_Exists(*args, **kwargs)
 
     def GetEntryType(*args, **kwargs):

-        """GetEntryType(String name) -> int"""
+        """
+        GetEntryType(String name) -> int
+
+        Get the type of the entry.  Returns one of the wx.Config.Type_XXX values.
+        """

         return _misc.ConfigBase_GetEntryType(*args, **kwargs)
 
     def Read(*args, **kwargs):
         return _misc.ConfigBase_GetEntryType(*args, **kwargs)
 
     def Read(*args, **kwargs):

-        """Read(String key, String defaultVal=EmptyString) -> String"""
+        """
+        Read(String key, String defaultVal=EmptyString) -> String
+
+        Returns the value of key if it exists, defaultVal otherwise.
+        """

         return _misc.ConfigBase_Read(*args, **kwargs)
 
     def ReadInt(*args, **kwargs):
         return _misc.ConfigBase_Read(*args, **kwargs)
 
     def ReadInt(*args, **kwargs):

-        """ReadInt(String key, long defaultVal=0) -> long"""
+        """
+        ReadInt(String key, long defaultVal=0) -> long
+
+        Returns the value of key if it exists, defaultVal otherwise.
+        """

         return _misc.ConfigBase_ReadInt(*args, **kwargs)
 
     def ReadFloat(*args, **kwargs):
         return _misc.ConfigBase_ReadInt(*args, **kwargs)
 
     def ReadFloat(*args, **kwargs):

-        """ReadFloat(String key, double defaultVal=0.0) -> double"""
+        """
+        ReadFloat(String key, double defaultVal=0.0) -> double
+
+        Returns the value of key if it exists, defaultVal otherwise.
+        """

         return _misc.ConfigBase_ReadFloat(*args, **kwargs)
 
     def ReadBool(*args, **kwargs):
         return _misc.ConfigBase_ReadFloat(*args, **kwargs)
 
     def ReadBool(*args, **kwargs):

-        """ReadBool(String key, bool defaultVal=False) -> bool"""
+        """
+        ReadBool(String key, bool defaultVal=False) -> bool
+
+        Returns the value of key if it exists, defaultVal otherwise.
+        """

         return _misc.ConfigBase_ReadBool(*args, **kwargs)
 
     def Write(*args, **kwargs):
         return _misc.ConfigBase_ReadBool(*args, **kwargs)
 
     def Write(*args, **kwargs):

-        """Write(String key, String value) -> bool"""
+        """
+        Write(String key, String value) -> bool
+
+        write the value (return True on success)
+        """

         return _misc.ConfigBase_Write(*args, **kwargs)
 
     def WriteInt(*args, **kwargs):
         return _misc.ConfigBase_Write(*args, **kwargs)
 
     def WriteInt(*args, **kwargs):

-        """WriteInt(String key, long value) -> bool"""
+        """
+        WriteInt(String key, long value) -> bool
+
+        write the value (return True on success)
+        """

         return _misc.ConfigBase_WriteInt(*args, **kwargs)
 
     def WriteFloat(*args, **kwargs):
         return _misc.ConfigBase_WriteInt(*args, **kwargs)
 
     def WriteFloat(*args, **kwargs):

-        """WriteFloat(String key, double value) -> bool"""
+        """
+        WriteFloat(String key, double value) -> bool
+
+        write the value (return True on success)
+        """

         return _misc.ConfigBase_WriteFloat(*args, **kwargs)
 
     def WriteBool(*args, **kwargs):
         return _misc.ConfigBase_WriteFloat(*args, **kwargs)
 
     def WriteBool(*args, **kwargs):

-        """WriteBool(String key, bool value) -> bool"""
+        """
+        WriteBool(String key, bool value) -> bool
+
+        write the value (return True on success)
+        """

         return _misc.ConfigBase_WriteBool(*args, **kwargs)
 
     def Flush(*args, **kwargs):
         return _misc.ConfigBase_WriteBool(*args, **kwargs)
 
     def Flush(*args, **kwargs):

-        """Flush(bool bCurrentOnly=False) -> bool"""
+        """
+        Flush(bool currentOnly=False) -> bool
+
+        permanently writes all changes
+        """

         return _misc.ConfigBase_Flush(*args, **kwargs)
 
     def RenameEntry(*args, **kwargs):
         return _misc.ConfigBase_Flush(*args, **kwargs)
 
     def RenameEntry(*args, **kwargs):

-        """RenameEntry(String oldName, String newName) -> bool"""
+        """
+        RenameEntry(String oldName, String newName) -> bool
+
+        Rename an entry.  Returns False on failure (probably because the new
+        name is already taken by an existing entry)
+        """

         return _misc.ConfigBase_RenameEntry(*args, **kwargs)
 
     def RenameGroup(*args, **kwargs):
         return _misc.ConfigBase_RenameEntry(*args, **kwargs)
 
     def RenameGroup(*args, **kwargs):

-        """RenameGroup(String oldName, String newName) -> bool"""
+        """
+        RenameGroup(String oldName, String newName) -> bool
+
+        Rename aa group.  Returns False on failure (probably because the new
+        name is already taken by an existing entry)
+        """

         return _misc.ConfigBase_RenameGroup(*args, **kwargs)
 
     def DeleteEntry(*args, **kwargs):
         return _misc.ConfigBase_RenameGroup(*args, **kwargs)
 
     def DeleteEntry(*args, **kwargs):

-        """DeleteEntry(String key, bool bDeleteGroupIfEmpty=True) -> bool"""
+        """
+        DeleteEntry(String key, bool deleteGroupIfEmpty=True) -> bool
+
+        Deletes the specified entry and the group it belongs to if
+        it was the last key in it and the second parameter is True
+        """

         return _misc.ConfigBase_DeleteEntry(*args, **kwargs)
 
     def DeleteGroup(*args, **kwargs):
         return _misc.ConfigBase_DeleteEntry(*args, **kwargs)
 
     def DeleteGroup(*args, **kwargs):

-        """DeleteGroup(String key) -> bool"""
+        """
+        DeleteGroup(String key) -> bool
+
+        Delete the group (with all subgroups)
+        """

         return _misc.ConfigBase_DeleteGroup(*args, **kwargs)
 
     def DeleteAll(*args, **kwargs):
         return _misc.ConfigBase_DeleteGroup(*args, **kwargs)
 
     def DeleteAll(*args, **kwargs):

-        """DeleteAll() -> bool"""
-        return _misc.ConfigBase_DeleteAll(*args, **kwargs)
+        """
+        DeleteAll() -> bool

 
 

-    def IsExpandingEnvVars(*args, **kwargs):
-        """IsExpandingEnvVars() -> bool"""
-        return _misc.ConfigBase_IsExpandingEnvVars(*args, **kwargs)
+        Delete the whole underlying object (disk file, registry key, ...)
+        primarly intended for use by desinstallation routine.
+        """
+        return _misc.ConfigBase_DeleteAll(*args, **kwargs)

 
     def SetExpandEnvVars(*args, **kwargs):
 
     def SetExpandEnvVars(*args, **kwargs):

-        """SetExpandEnvVars(bool bDoIt=True)"""
+        """
+        SetExpandEnvVars(bool doIt=True)
+
+        We can automatically expand environment variables in the config entries
+        (this option is on by default, you can turn it on/off at any time)
+        """

         return _misc.ConfigBase_SetExpandEnvVars(*args, **kwargs)
 
         return _misc.ConfigBase_SetExpandEnvVars(*args, **kwargs)
 

+    def IsExpandingEnvVars(*args, **kwargs):
+        """
+        IsExpandingEnvVars() -> bool
+
+        Are we currently expanding environment variables?
+        """
+        return _misc.ConfigBase_IsExpandingEnvVars(*args, **kwargs)
+

     def SetRecordDefaults(*args, **kwargs):
     def SetRecordDefaults(*args, **kwargs):

-        """SetRecordDefaults(bool bDoIt=True)"""
+        """
+        SetRecordDefaults(bool doIt=True)
+
+        Set whether the config objec should record default values.
+        """

         return _misc.ConfigBase_SetRecordDefaults(*args, **kwargs)
 
     def IsRecordingDefaults(*args, **kwargs):
         return _misc.ConfigBase_SetRecordDefaults(*args, **kwargs)
 
     def IsRecordingDefaults(*args, **kwargs):

-        """IsRecordingDefaults() -> bool"""
+        """
+        IsRecordingDefaults() -> bool
+
+        Are we currently recording default values?
+        """

         return _misc.ConfigBase_IsRecordingDefaults(*args, **kwargs)
 
     def ExpandEnvVars(*args, **kwargs):
         return _misc.ConfigBase_IsRecordingDefaults(*args, **kwargs)
 
     def ExpandEnvVars(*args, **kwargs):

-        """ExpandEnvVars(String str) -> String"""
+        """
+        ExpandEnvVars(String str) -> String
+
+        Expand any environment variables in str and return the result
+        """

         return _misc.ConfigBase_ExpandEnvVars(*args, **kwargs)
 
     def GetAppName(*args, **kwargs):
         return _misc.ConfigBase_ExpandEnvVars(*args, **kwargs)
 
     def GetAppName(*args, **kwargs):


@@ -2642,49 +2853,45 @@ class ConfigBasePtr(ConfigBase):
 _misc.ConfigBase_swigregister(ConfigBasePtr)
 
 def ConfigBase_Set(*args, **kwargs):
 _misc.ConfigBase_swigregister(ConfigBasePtr)
 
 def ConfigBase_Set(*args, **kwargs):

-    """ConfigBase_Set(ConfigBase pConfig) -> ConfigBase"""
+    """
+    ConfigBase_Set(ConfigBase config) -> ConfigBase
+
+    Sets the global config object (the one returned by Get) and
+    returns a reference to the previous global config object.
+    """

     return _misc.ConfigBase_Set(*args, **kwargs)
 
 def ConfigBase_Get(*args, **kwargs):
     return _misc.ConfigBase_Set(*args, **kwargs)
 
 def ConfigBase_Get(*args, **kwargs):

-    """ConfigBase_Get(bool createOnDemand=True) -> ConfigBase"""
+    """
+    ConfigBase_Get(bool createOnDemand=True) -> ConfigBase
+
+    Returns the current global config object, creating one if neccessary.
+    """

     return _misc.ConfigBase_Get(*args, **kwargs)
 
 def ConfigBase_Create(*args, **kwargs):
     return _misc.ConfigBase_Get(*args, **kwargs)
 
 def ConfigBase_Create(*args, **kwargs):

-    """ConfigBase_Create() -> ConfigBase"""
+    """
+    ConfigBase_Create() -> ConfigBase
+
+    Create and return a new global config object.  This function will
+    create the "best" implementation of wx.Config available for the
+    current platform.
+    """

     return _misc.ConfigBase_Create(*args, **kwargs)
 
 def ConfigBase_DontCreateOnDemand(*args, **kwargs):
     return _misc.ConfigBase_Create(*args, **kwargs)
 
 def ConfigBase_DontCreateOnDemand(*args, **kwargs):

-    """ConfigBase_DontCreateOnDemand()"""
-    return _misc.ConfigBase_DontCreateOnDemand(*args, **kwargs)
-
-class ConfigPathChanger(object):
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxConfigPathChanger instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__(ConfigBase pContainer, String strEntry) -> ConfigPathChanger"""
-        newobj = _misc.new_ConfigPathChanger(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
-    def __del__(self, destroy=_misc.delete_ConfigPathChanger):
-        """__del__()"""
-        try:
-            if self.thisown: destroy(self)
-        except: pass
-
-    def Name(*args, **kwargs):
-        """Name() -> String"""
-        return _misc.ConfigPathChanger_Name(*args, **kwargs)
-
+    """
+    ConfigBase_DontCreateOnDemand()

 
 

-class ConfigPathChangerPtr(ConfigPathChanger):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = ConfigPathChanger
-_misc.ConfigPathChanger_swigregister(ConfigPathChangerPtr)
+    Should Get() try to create a new log object if there isn't a current one?
+    """
+    return _misc.ConfigBase_DontCreateOnDemand(*args, **kwargs)

 
 class Config(ConfigBase):
 
 class Config(ConfigBase):

+    """
+    This ConfigBase-derived class will use the registry on Windows,
+    and will be a wx.FileConfig on other platforms.
+    """

     def __repr__(self):
         return "<%s.%s; proxy of C++ wxConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):


@@ -2712,6 +2919,7 @@ class ConfigPtr(Config):
 _misc.Config_swigregister(ConfigPtr)
 
 class FileConfig(ConfigBase):
 _misc.Config_swigregister(ConfigPtr)
 
 class FileConfig(ConfigBase):

+    """This config class will use a file for storage on all platforms."""

     def __repr__(self):
         return "<%s.%s; proxy of C++ wxFileConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxFileConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):


@@ -2738,9 +2946,53 @@ class FileConfigPtr(FileConfig):
         self.__class__ = FileConfig
 _misc.FileConfig_swigregister(FileConfigPtr)
 
         self.__class__ = FileConfig
 _misc.FileConfig_swigregister(FileConfigPtr)
 

+class ConfigPathChanger(object):
+    """
+    A handy little class which changes current path to the path of
+    given entry and restores it in the destructoir: so if you declare
+    a local variable of this type, you work in the entry directory
+    and the path is automatically restored when the function returns.
+    """
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxConfigPathChanger instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(ConfigBase config, String entry) -> ConfigPathChanger"""
+        newobj = _misc.new_ConfigPathChanger(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+    def __del__(self, destroy=_misc.delete_ConfigPathChanger):
+        """__del__()"""
+        try:
+            if self.thisown: destroy(self)
+        except: pass
+
+    def Name(*args, **kwargs):
+        """
+        Name() -> String
+
+        Get the key name
+        """
+        return _misc.ConfigPathChanger_Name(*args, **kwargs)
+
+
+class ConfigPathChangerPtr(ConfigPathChanger):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = ConfigPathChanger
+_misc.ConfigPathChanger_swigregister(ConfigPathChangerPtr)
+

 
 def ExpandEnvVars(*args, **kwargs):
 
 def ExpandEnvVars(*args, **kwargs):

-    """ExpandEnvVars(String sz) -> String"""
+    """
+    ExpandEnvVars(String sz) -> String
+
+    Replace environment variables ($SOMETHING) with their values. The
+    format is $VARNAME or ${VARNAME} where VARNAME contains
+    alphanumeric characters and '_' only. '$' must be escaped ('\$')
+    in order to be taken literally.
+    """

     return _misc.ExpandEnvVars(*args, **kwargs)
 #---------------------------------------------------------------------------
 
     return _misc.ExpandEnvVars(*args, **kwargs)
 #---------------------------------------------------------------------------
 


@@ -2903,62 +3155,62 @@ class DateTime(object):
     Monday_First = _misc.DateTime_Monday_First
     Sunday_First = _misc.DateTime_Sunday_First
     def SetCountry(*args, **kwargs):
     Monday_First = _misc.DateTime_Monday_First
     Sunday_First = _misc.DateTime_Sunday_First
     def SetCountry(*args, **kwargs):

-        """DateTime.SetCountry(int country)"""
+        """SetCountry(int country)"""

         return _misc.DateTime_SetCountry(*args, **kwargs)
 
     SetCountry = staticmethod(SetCountry)
     def GetCountry(*args, **kwargs):
         return _misc.DateTime_SetCountry(*args, **kwargs)
 
     SetCountry = staticmethod(SetCountry)
     def GetCountry(*args, **kwargs):

-        """DateTime.GetCountry() -> int"""
+        """GetCountry() -> int"""

         return _misc.DateTime_GetCountry(*args, **kwargs)
 
     GetCountry = staticmethod(GetCountry)
     def IsWestEuropeanCountry(*args, **kwargs):
         return _misc.DateTime_GetCountry(*args, **kwargs)
 
     GetCountry = staticmethod(GetCountry)
     def IsWestEuropeanCountry(*args, **kwargs):

-        """DateTime.IsWestEuropeanCountry(int country=Country_Default) -> bool"""
+        """IsWestEuropeanCountry(int country=Country_Default) -> bool"""

         return _misc.DateTime_IsWestEuropeanCountry(*args, **kwargs)
 
     IsWestEuropeanCountry = staticmethod(IsWestEuropeanCountry)
     def GetCurrentYear(*args, **kwargs):
         return _misc.DateTime_IsWestEuropeanCountry(*args, **kwargs)
 
     IsWestEuropeanCountry = staticmethod(IsWestEuropeanCountry)
     def GetCurrentYear(*args, **kwargs):

-        """DateTime.GetCurrentYear(int cal=Gregorian) -> int"""
+        """GetCurrentYear(int cal=Gregorian) -> int"""

         return _misc.DateTime_GetCurrentYear(*args, **kwargs)
 
     GetCurrentYear = staticmethod(GetCurrentYear)
     def ConvertYearToBC(*args, **kwargs):
         return _misc.DateTime_GetCurrentYear(*args, **kwargs)
 
     GetCurrentYear = staticmethod(GetCurrentYear)
     def ConvertYearToBC(*args, **kwargs):

-        """DateTime.ConvertYearToBC(int year) -> int"""
+        """ConvertYearToBC(int year) -> int"""

         return _misc.DateTime_ConvertYearToBC(*args, **kwargs)
 
     ConvertYearToBC = staticmethod(ConvertYearToBC)
     def GetCurrentMonth(*args, **kwargs):
         return _misc.DateTime_ConvertYearToBC(*args, **kwargs)
 
     ConvertYearToBC = staticmethod(ConvertYearToBC)
     def GetCurrentMonth(*args, **kwargs):

-        """DateTime.GetCurrentMonth(int cal=Gregorian) -> int"""
+        """GetCurrentMonth(int cal=Gregorian) -> int"""

         return _misc.DateTime_GetCurrentMonth(*args, **kwargs)
 
     GetCurrentMonth = staticmethod(GetCurrentMonth)
     def IsLeapYear(*args, **kwargs):
         return _misc.DateTime_GetCurrentMonth(*args, **kwargs)
 
     GetCurrentMonth = staticmethod(GetCurrentMonth)
     def IsLeapYear(*args, **kwargs):

-        """DateTime.IsLeapYear(int year=Inv_Year, int cal=Gregorian) -> bool"""
+        """IsLeapYear(int year=Inv_Year, int cal=Gregorian) -> bool"""

         return _misc.DateTime_IsLeapYear(*args, **kwargs)
 
     IsLeapYear = staticmethod(IsLeapYear)
     def GetCentury(*args, **kwargs):
         return _misc.DateTime_IsLeapYear(*args, **kwargs)
 
     IsLeapYear = staticmethod(IsLeapYear)
     def GetCentury(*args, **kwargs):

-        """DateTime.GetCentury(int year=Inv_Year) -> int"""
+        """GetCentury(int year=Inv_Year) -> int"""

         return _misc.DateTime_GetCentury(*args, **kwargs)
 
     GetCentury = staticmethod(GetCentury)
     def GetNumberOfDaysinYear(*args, **kwargs):
         return _misc.DateTime_GetCentury(*args, **kwargs)
 
     GetCentury = staticmethod(GetCentury)
     def GetNumberOfDaysinYear(*args, **kwargs):

-        """DateTime.GetNumberOfDaysinYear(int year, int cal=Gregorian) -> int"""
+        """GetNumberOfDaysinYear(int year, int cal=Gregorian) -> int"""

         return _misc.DateTime_GetNumberOfDaysinYear(*args, **kwargs)
 
     GetNumberOfDaysinYear = staticmethod(GetNumberOfDaysinYear)
     def GetNumberOfDaysInMonth(*args, **kwargs):
         return _misc.DateTime_GetNumberOfDaysinYear(*args, **kwargs)
 
     GetNumberOfDaysinYear = staticmethod(GetNumberOfDaysinYear)
     def GetNumberOfDaysInMonth(*args, **kwargs):

-        """DateTime.GetNumberOfDaysInMonth(int month, int year=Inv_Year, int cal=Gregorian) -> int"""
+        """GetNumberOfDaysInMonth(int month, int year=Inv_Year, int cal=Gregorian) -> int"""

         return _misc.DateTime_GetNumberOfDaysInMonth(*args, **kwargs)
 
     GetNumberOfDaysInMonth = staticmethod(GetNumberOfDaysInMonth)
     def GetMonthName(*args, **kwargs):
         return _misc.DateTime_GetNumberOfDaysInMonth(*args, **kwargs)
 
     GetNumberOfDaysInMonth = staticmethod(GetNumberOfDaysInMonth)
     def GetMonthName(*args, **kwargs):

-        """DateTime.GetMonthName(int month, int flags=Name_Full) -> String"""
+        """GetMonthName(int month, int flags=Name_Full) -> String"""

         return _misc.DateTime_GetMonthName(*args, **kwargs)
 
     GetMonthName = staticmethod(GetMonthName)
     def GetWeekDayName(*args, **kwargs):
         return _misc.DateTime_GetMonthName(*args, **kwargs)
 
     GetMonthName = staticmethod(GetMonthName)
     def GetWeekDayName(*args, **kwargs):

-        """DateTime.GetWeekDayName(int weekday, int flags=Name_Full) -> String"""
+        """GetWeekDayName(int weekday, int flags=Name_Full) -> String"""

         return _misc.DateTime_GetWeekDayName(*args, **kwargs)
 
     GetWeekDayName = staticmethod(GetWeekDayName)
         return _misc.DateTime_GetWeekDayName(*args, **kwargs)
 
     GetWeekDayName = staticmethod(GetWeekDayName)


@@ -2972,32 +3224,32 @@ class DateTime(object):
 
     GetAmPmStrings = staticmethod(GetAmPmStrings)
     def IsDSTApplicable(*args, **kwargs):
 
     GetAmPmStrings = staticmethod(GetAmPmStrings)
     def IsDSTApplicable(*args, **kwargs):

-        """DateTime.IsDSTApplicable(int year=Inv_Year, int country=Country_Default) -> bool"""
+        """IsDSTApplicable(int year=Inv_Year, int country=Country_Default) -> bool"""

         return _misc.DateTime_IsDSTApplicable(*args, **kwargs)
 
     IsDSTApplicable = staticmethod(IsDSTApplicable)
     def GetBeginDST(*args, **kwargs):
         return _misc.DateTime_IsDSTApplicable(*args, **kwargs)
 
     IsDSTApplicable = staticmethod(IsDSTApplicable)
     def GetBeginDST(*args, **kwargs):

-        """DateTime.GetBeginDST(int year=Inv_Year, int country=Country_Default) -> DateTime"""
+        """GetBeginDST(int year=Inv_Year, int country=Country_Default) -> DateTime"""

         return _misc.DateTime_GetBeginDST(*args, **kwargs)
 
     GetBeginDST = staticmethod(GetBeginDST)
     def GetEndDST(*args, **kwargs):
         return _misc.DateTime_GetBeginDST(*args, **kwargs)
 
     GetBeginDST = staticmethod(GetBeginDST)
     def GetEndDST(*args, **kwargs):

-        """DateTime.GetEndDST(int year=Inv_Year, int country=Country_Default) -> DateTime"""
+        """GetEndDST(int year=Inv_Year, int country=Country_Default) -> DateTime"""

         return _misc.DateTime_GetEndDST(*args, **kwargs)
 
     GetEndDST = staticmethod(GetEndDST)
     def Now(*args, **kwargs):
         return _misc.DateTime_GetEndDST(*args, **kwargs)
 
     GetEndDST = staticmethod(GetEndDST)
     def Now(*args, **kwargs):

-        """DateTime.Now() -> DateTime"""
+        """Now() -> DateTime"""

         return _misc.DateTime_Now(*args, **kwargs)
 
     Now = staticmethod(Now)
     def UNow(*args, **kwargs):
         return _misc.DateTime_Now(*args, **kwargs)
 
     Now = staticmethod(Now)
     def UNow(*args, **kwargs):

-        """DateTime.UNow() -> DateTime"""
+        """UNow() -> DateTime"""

         return _misc.DateTime_UNow(*args, **kwargs)
 
     UNow = staticmethod(UNow)
     def Today(*args, **kwargs):
         return _misc.DateTime_UNow(*args, **kwargs)
 
     UNow = staticmethod(UNow)
     def Today(*args, **kwargs):

-        """DateTime.Today() -> DateTime"""
+        """Today() -> DateTime"""

         return _misc.DateTime_Today(*args, **kwargs)
 
     Today = staticmethod(Today)
         return _misc.DateTime_Today(*args, **kwargs)
 
     Today = staticmethod(Today)


@@ -3172,6 +3424,8 @@ class DateTime(object):
         """IsValid() -> bool"""
         return _misc.DateTime_IsValid(*args, **kwargs)
 
         """IsValid() -> bool"""
         return _misc.DateTime_IsValid(*args, **kwargs)
 

+    Ok = IsValid 
+    def __nonzero__(self): return self.Ok() 

     def GetTicks(*args, **kwargs):
         """GetTicks() -> time_t"""
         return _misc.DateTime_GetTicks(*args, **kwargs)
     def GetTicks(*args, **kwargs):
         """GetTicks() -> time_t"""
         return _misc.DateTime_GetTicks(*args, **kwargs)


@@ -3334,7 +3588,7 @@ class DateTime(object):
         return _misc.DateTime_ParseRfc822Date(*args, **kwargs)
 
     def ParseFormat(*args, **kwargs):
         return _misc.DateTime_ParseRfc822Date(*args, **kwargs)
 
     def ParseFormat(*args, **kwargs):

-        """ParseFormat(String date, String format=DateFormatStr, DateTime dateDef=wxDefaultDateTime) -> int"""
+        """ParseFormat(String date, String format=DateFormatStr, DateTime dateDef=DefaultDateTime) -> int"""

         return _misc.DateTime_ParseFormat(*args, **kwargs)
 
     def ParseDateTime(*args, **kwargs):
         return _misc.DateTime_ParseFormat(*args, **kwargs)
 
     def ParseDateTime(*args, **kwargs):


@@ -3495,52 +3749,52 @@ class TimeSpan(object):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxTimeSpan instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def Seconds(*args, **kwargs):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxTimeSpan instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def Seconds(*args, **kwargs):

-        """TimeSpan.Seconds(long sec) -> TimeSpan"""
+        """Seconds(long sec) -> TimeSpan"""

         return _misc.TimeSpan_Seconds(*args, **kwargs)
 
     Seconds = staticmethod(Seconds)
     def Second(*args, **kwargs):
         return _misc.TimeSpan_Seconds(*args, **kwargs)
 
     Seconds = staticmethod(Seconds)
     def Second(*args, **kwargs):

-        """TimeSpan.Second() -> TimeSpan"""
+        """Second() -> TimeSpan"""

         return _misc.TimeSpan_Second(*args, **kwargs)
 
     Second = staticmethod(Second)
     def Minutes(*args, **kwargs):
         return _misc.TimeSpan_Second(*args, **kwargs)
 
     Second = staticmethod(Second)
     def Minutes(*args, **kwargs):

-        """TimeSpan.Minutes(long min) -> TimeSpan"""
+        """Minutes(long min) -> TimeSpan"""

         return _misc.TimeSpan_Minutes(*args, **kwargs)
 
     Minutes = staticmethod(Minutes)
     def Minute(*args, **kwargs):
         return _misc.TimeSpan_Minutes(*args, **kwargs)
 
     Minutes = staticmethod(Minutes)
     def Minute(*args, **kwargs):

-        """TimeSpan.Minute() -> TimeSpan"""
+        """Minute() -> TimeSpan"""

         return _misc.TimeSpan_Minute(*args, **kwargs)
 
     Minute = staticmethod(Minute)
     def Hours(*args, **kwargs):
         return _misc.TimeSpan_Minute(*args, **kwargs)
 
     Minute = staticmethod(Minute)
     def Hours(*args, **kwargs):

-        """TimeSpan.Hours(long hours) -> TimeSpan"""
+        """Hours(long hours) -> TimeSpan"""

         return _misc.TimeSpan_Hours(*args, **kwargs)
 
     Hours = staticmethod(Hours)
     def Hour(*args, **kwargs):
         return _misc.TimeSpan_Hours(*args, **kwargs)
 
     Hours = staticmethod(Hours)
     def Hour(*args, **kwargs):

-        """TimeSpan.Hour() -> TimeSpan"""
+        """Hour() -> TimeSpan"""

         return _misc.TimeSpan_Hour(*args, **kwargs)
 
     Hour = staticmethod(Hour)
     def Days(*args, **kwargs):
         return _misc.TimeSpan_Hour(*args, **kwargs)
 
     Hour = staticmethod(Hour)
     def Days(*args, **kwargs):

-        """TimeSpan.Days(long days) -> TimeSpan"""
+        """Days(long days) -> TimeSpan"""

         return _misc.TimeSpan_Days(*args, **kwargs)
 
     Days = staticmethod(Days)
     def Day(*args, **kwargs):
         return _misc.TimeSpan_Days(*args, **kwargs)
 
     Days = staticmethod(Days)
     def Day(*args, **kwargs):

-        """TimeSpan.Day() -> TimeSpan"""
+        """Day() -> TimeSpan"""

         return _misc.TimeSpan_Day(*args, **kwargs)
 
     Day = staticmethod(Day)
     def Weeks(*args, **kwargs):
         return _misc.TimeSpan_Day(*args, **kwargs)
 
     Day = staticmethod(Day)
     def Weeks(*args, **kwargs):

-        """TimeSpan.Weeks(long days) -> TimeSpan"""
+        """Weeks(long days) -> TimeSpan"""

         return _misc.TimeSpan_Weeks(*args, **kwargs)
 
     Weeks = staticmethod(Weeks)
     def Week(*args, **kwargs):
         return _misc.TimeSpan_Weeks(*args, **kwargs)
 
     Weeks = staticmethod(Weeks)
     def Week(*args, **kwargs):

-        """TimeSpan.Week() -> TimeSpan"""
+        """Week() -> TimeSpan"""

         return _misc.TimeSpan_Week(*args, **kwargs)
 
     Week = staticmethod(Week)
         return _misc.TimeSpan_Week(*args, **kwargs)
 
     Week = staticmethod(Week)


@@ -3753,42 +4007,42 @@ class DateSpan(object):
         except: pass
 
     def Days(*args, **kwargs):
         except: pass
 
     def Days(*args, **kwargs):

-        """DateSpan.Days(int days) -> DateSpan"""
+        """Days(int days) -> DateSpan"""

         return _misc.DateSpan_Days(*args, **kwargs)
 
     Days = staticmethod(Days)
     def Day(*args, **kwargs):
         return _misc.DateSpan_Days(*args, **kwargs)
 
     Days = staticmethod(Days)
     def Day(*args, **kwargs):

-        """DateSpan.Day() -> DateSpan"""
+        """Day() -> DateSpan"""

         return _misc.DateSpan_Day(*args, **kwargs)
 
     Day = staticmethod(Day)
     def Weeks(*args, **kwargs):
         return _misc.DateSpan_Day(*args, **kwargs)
 
     Day = staticmethod(Day)
     def Weeks(*args, **kwargs):

-        """DateSpan.Weeks(int weeks) -> DateSpan"""
+        """Weeks(int weeks) -> DateSpan"""

         return _misc.DateSpan_Weeks(*args, **kwargs)
 
     Weeks = staticmethod(Weeks)
     def Week(*args, **kwargs):
         return _misc.DateSpan_Weeks(*args, **kwargs)
 
     Weeks = staticmethod(Weeks)
     def Week(*args, **kwargs):

-        """DateSpan.Week() -> DateSpan"""
+        """Week() -> DateSpan"""

         return _misc.DateSpan_Week(*args, **kwargs)
 
     Week = staticmethod(Week)
     def Months(*args, **kwargs):
         return _misc.DateSpan_Week(*args, **kwargs)
 
     Week = staticmethod(Week)
     def Months(*args, **kwargs):

-        """DateSpan.Months(int mon) -> DateSpan"""
+        """Months(int mon) -> DateSpan"""

         return _misc.DateSpan_Months(*args, **kwargs)
 
     Months = staticmethod(Months)
     def Month(*args, **kwargs):
         return _misc.DateSpan_Months(*args, **kwargs)
 
     Months = staticmethod(Months)
     def Month(*args, **kwargs):

-        """DateSpan.Month() -> DateSpan"""
+        """Month() -> DateSpan"""

         return _misc.DateSpan_Month(*args, **kwargs)
 
     Month = staticmethod(Month)
     def Years(*args, **kwargs):
         return _misc.DateSpan_Month(*args, **kwargs)
 
     Month = staticmethod(Month)
     def Years(*args, **kwargs):

-        """DateSpan.Years(int years) -> DateSpan"""
+        """Years(int years) -> DateSpan"""

         return _misc.DateSpan_Years(*args, **kwargs)
 
     Years = staticmethod(Years)
     def Year(*args, **kwargs):
         return _misc.DateSpan_Years(*args, **kwargs)
 
     Years = staticmethod(Years)
     def Year(*args, **kwargs):

-        """DateSpan.Year() -> DateSpan"""
+        """Year() -> DateSpan"""

         return _misc.DateSpan_Year(*args, **kwargs)
 
     Year = staticmethod(Year)
         return _misc.DateSpan_Year(*args, **kwargs)
 
     Year = staticmethod(Year)


@@ -4014,6 +4268,7 @@ class DataFormatPtr(DataFormat):
         if not hasattr(self,"thisown"): self.thisown = 0
         self.__class__ = DataFormat
 _misc.DataFormat_swigregister(DataFormatPtr)
         if not hasattr(self,"thisown"): self.thisown = 0
         self.__class__ = DataFormat
 _misc.DataFormat_swigregister(DataFormatPtr)

+DefaultDateTime = cvar.DefaultDateTime

 
 def CustomDataFormat(*args, **kwargs):
     """CustomDataFormat(String format) -> DataFormat"""
 
 def CustomDataFormat(*args, **kwargs):
     """CustomDataFormat(String format) -> DataFormat"""


@@ -4130,9 +4385,7 @@ class DataObjectComposite(DataObject):
         del newobj.thisown
     def Add(*args, **kwargs):
         """Add(DataObjectSimple dataObject, int preferred=False)"""
         del newobj.thisown
     def Add(*args, **kwargs):
         """Add(DataObjectSimple dataObject, int preferred=False)"""

-        val = _misc.DataObjectComposite_Add(*args, **kwargs)
-        args[1].thisown = 0
-        return val
+        return _misc.DataObjectComposite_Add(*args, **kwargs)

 
 
 class DataObjectCompositePtr(DataObjectComposite):
 
 
 class DataObjectCompositePtr(DataObjectComposite):


@@ -4334,6 +4587,14 @@ class MetafileDataObject(DataObjectSimple):
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown

+    def SetMetafile(*args, **kwargs):
+        """SetMetafile(wxMetafile metafile)"""
+        return _misc.MetafileDataObject_SetMetafile(*args, **kwargs)
+
+    def GetMetafile(*args, **kwargs):
+        """GetMetafile() -> wxMetafile"""
+        return _misc.MetafileDataObject_GetMetafile(*args, **kwargs)
+

 
 class MetafileDataObjectPtr(MetafileDataObject):
     def __init__(self, this):
 
 class MetafileDataObjectPtr(MetafileDataObject):
     def __init__(self, this):


@@ -4416,7 +4677,6 @@ class DropTarget(object):
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown

-        if args: args[0].thisown = 0;

         self._setCallbackInfo(self, DropTarget)
 
     def _setCallbackInfo(*args, **kwargs):
         self._setCallbackInfo(self, DropTarget)
 
     def _setCallbackInfo(*args, **kwargs):


@@ -4435,9 +4695,7 @@ class DropTarget(object):
 
     def SetDataObject(*args, **kwargs):
         """SetDataObject(DataObject dataObject)"""
 
     def SetDataObject(*args, **kwargs):
         """SetDataObject(DataObject dataObject)"""

-        val = _misc.DropTarget_SetDataObject(*args, **kwargs)
-        args[1].thisown = 0
-        return val
+        return _misc.DropTarget_SetDataObject(*args, **kwargs)

 
     def base_OnEnter(*args, **kwargs):
         """base_OnEnter(int x, int y, int def) -> int"""
 
     def base_OnEnter(*args, **kwargs):
         """base_OnEnter(int x, int y, int def) -> int"""


@@ -4557,6 +4815,18 @@ _misc.FileDropTarget_swigregister(FileDropTargetPtr)
 #---------------------------------------------------------------------------
 
 class Clipboard(core.Object):
 #---------------------------------------------------------------------------
 
 class Clipboard(core.Object):

+    """
+    wx.Clipboard represents the system clipboard and provides methods to copy data
+    to or paste data from it.  Normally, you should only use wx.TheClipboard which
+    is a reference to a global wx.Clipboard instance.
+
+    Call wx.TheClipboard.Open to get ownership of the clipboard. If this operation
+    returns True, you now own the clipboard. Call wx.TheClipboard.SetData to put
+    data on the clipboard, or wx.TheClipboard.GetData to retrieve data from the
+    clipboard.  Call wx.TheClipboard.Close to close the clipboard and relinquish
+    ownership. You should keep the clipboard open only momentarily.
+
+    """

     def __repr__(self):
         return "<%s.%s; proxy of C++ wxClipboard instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxClipboard instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):


@@ -4572,43 +4842,97 @@ class Clipboard(core.Object):
         except: pass
 
     def Open(*args, **kwargs):
         except: pass
 
     def Open(*args, **kwargs):

-        """Open() -> bool"""
+        """
+        Open() -> bool
+
+        Call this function to open the clipboard before calling SetData
+        and GetData.  Call Close when you have finished with the clipboard.
+        You should keep the clipboard open for only a very short time.
+        Returns true on success. 
+        """

         return _misc.Clipboard_Open(*args, **kwargs)
 
     def Close(*args, **kwargs):
         return _misc.Clipboard_Open(*args, **kwargs)
 
     def Close(*args, **kwargs):

-        """Close()"""
+        """
+        Close()
+
+        Closes the clipboard.
+        """

         return _misc.Clipboard_Close(*args, **kwargs)
 
     def IsOpened(*args, **kwargs):
         return _misc.Clipboard_Close(*args, **kwargs)
 
     def IsOpened(*args, **kwargs):

-        """IsOpened() -> bool"""
+        """
+        IsOpened() -> bool
+
+        Query whether the clipboard is opened
+        """

         return _misc.Clipboard_IsOpened(*args, **kwargs)
 
     def AddData(*args, **kwargs):
         return _misc.Clipboard_IsOpened(*args, **kwargs)
 
     def AddData(*args, **kwargs):

-        """AddData(DataObject data) -> bool"""
+        """
+        AddData(DataObject data) -> bool
+
+        Call this function to add the data object to the clipboard. You
+        may call this function repeatedly after having cleared the clipboard.
+        After this function has been called, the clipboard owns the data, so
+        do not delete the data explicitly.
+        """

         return _misc.Clipboard_AddData(*args, **kwargs)
 
     def SetData(*args, **kwargs):
         return _misc.Clipboard_AddData(*args, **kwargs)
 
     def SetData(*args, **kwargs):

-        """SetData(DataObject data) -> bool"""
+        """
+        SetData(DataObject data) -> bool
+
+        Set the clipboard data, this is the same as Clear followed by AddData.
+        """

         return _misc.Clipboard_SetData(*args, **kwargs)
 
     def IsSupported(*args, **kwargs):
         return _misc.Clipboard_SetData(*args, **kwargs)
 
     def IsSupported(*args, **kwargs):

-        """IsSupported(DataFormat format) -> bool"""
+        """
+        IsSupported(DataFormat format) -> bool
+
+        Returns True if the given format is available in the data object(s) on
+        the clipboard.
+        """

         return _misc.Clipboard_IsSupported(*args, **kwargs)
 
     def GetData(*args, **kwargs):
         return _misc.Clipboard_IsSupported(*args, **kwargs)
 
     def GetData(*args, **kwargs):

-        """GetData(DataObject data) -> bool"""
+        """
+        GetData(DataObject data) -> bool
+
+        Call this function to fill data with data on the clipboard, if available
+        in the required format. Returns true on success.
+        """

         return _misc.Clipboard_GetData(*args, **kwargs)
 
     def Clear(*args, **kwargs):
         return _misc.Clipboard_GetData(*args, **kwargs)
 
     def Clear(*args, **kwargs):

-        """Clear()"""
+        """
+        Clear()
+
+        Clears data from the clipboard object and also  the system's clipboard
+        if possible.
+        """

         return _misc.Clipboard_Clear(*args, **kwargs)
 
     def Flush(*args, **kwargs):
         return _misc.Clipboard_Clear(*args, **kwargs)
 
     def Flush(*args, **kwargs):

-        """Flush() -> bool"""
+        """
+        Flush() -> bool
+
+        Flushes the clipboard: this means that the data which is currently on
+        clipboard will stay available even after the application exits (possibly
+        eating memory), otherwise the clipboard will be emptied on exit.
+        Returns False if the operation is unsuccesful for any reason.
+        """

         return _misc.Clipboard_Flush(*args, **kwargs)
 
     def UsePrimarySelection(*args, **kwargs):
         return _misc.Clipboard_Flush(*args, **kwargs)
 
     def UsePrimarySelection(*args, **kwargs):

-        """UsePrimarySelection(bool primary=False)"""
+        """
+        UsePrimarySelection(bool primary=True)
+
+        On platforms supporting it (the X11 based platforms), selects the so
+        called PRIMARY SELECTION as the clipboard as opposed to the normal
+        clipboard, if primary is True.
+        """

         return _misc.Clipboard_UsePrimarySelection(*args, **kwargs)
 
 
         return _misc.Clipboard_UsePrimarySelection(*args, **kwargs)
 
 


@@ -4620,10 +4944,19 @@ class ClipboardPtr(Clipboard):
 _misc.Clipboard_swigregister(ClipboardPtr)
 
 class ClipboardLocker(object):
 _misc.Clipboard_swigregister(ClipboardPtr)
 
 class ClipboardLocker(object):

+    """
+    A helpful class for opening the clipboard and automatically closing it when
+    the locker is destroyed.
+    """

     def __repr__(self):
         return "<%s.%s; proxy of C++ wxClipboardLocker instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxClipboardLocker instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):

-        """__init__(Clipboard clipboard=None) -> ClipboardLocker"""
+        """
+        __init__(Clipboard clipboard=None) -> ClipboardLocker
+
+        A helpful class for opening the clipboard and automatically closing it when
+        the locker is destroyed.
+        """

         newobj = _misc.new_ClipboardLocker(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _misc.new_ClipboardLocker(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1


@@ -4635,7 +4968,12 @@ class ClipboardLocker(object):
         except: pass
 
     def __nonzero__(*args, **kwargs):
         except: pass
 
     def __nonzero__(*args, **kwargs):

-        """__nonzero__() -> bool"""
+        """
+        __nonzero__() -> bool
+
+        A ClipboardLocker instance evaluates to True if the clipboard was
+        successfully opened.
+        """

         return _misc.ClipboardLocker___nonzero__(*args, **kwargs)
 
 
         return _misc.ClipboardLocker___nonzero__(*args, **kwargs)