X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/83448d71476c44b449f09395cda06fa72b19a50e..8179a16812e66ff0ac32bb09803e95756350c76c:/wxPython/src/msw/misc.py?ds=inline

diff --git a/wxPython/src/msw/misc.py b/wxPython/src/msw/misc.py
index ba361c577d..6e629d117e 100644
--- a/wxPython/src/msw/misc.py
+++ b/wxPython/src/msw/misc.py
@@ -948,7 +948,7 @@ class Timer(core.EvtHandler):
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
-        self._setCallbackInfo(self, Timer)
+        self._setCallbackInfo(self, Timer, 0)
 
     def __del__(self, destroy=_misc.delete_Timer):
         """__del__()"""
@@ -957,7 +957,7 @@ class Timer(core.EvtHandler):
         except: pass
 
     def _setCallbackInfo(*args, **kwargs):
-        """_setCallbackInfo(PyObject self, PyObject _class)"""
+        """_setCallbackInfo(PyObject self, PyObject _class, int incref=1)"""
         return _misc.Timer__setCallbackInfo(*args, **kwargs)
 
     def SetOwner(*args, **kwargs):
@@ -1008,7 +1008,7 @@ class PyTimer(Timer):
 
 
 EVT_TIMER = wx.PyEventBinder( wxEVT_TIMER, 1 )
-                   
+
 
 class TimerEvent(core.Event):
     def __repr__(self):
@@ -1769,7 +1769,7 @@ class Joystick(object):
         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):
@@ -2012,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):
-        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
-    def __del__(self, destroy=_misc.delete_Wave):
+    def __del__(self, destroy=_misc.delete_Sound):
         """__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"""
-        return _misc.Wave_IsOk(*args, **kwargs)
+        return _misc.Sound_IsOk(*args, **kwargs)
 
-    def Play(*args, **kwargs):
-        """Play(bool async=True, bool looped=False) -> bool"""
-        return _misc.Wave_Play(*args, **kwargs)
+    def Play(*args):
+        """Play(unsigned int flags=SOUND_ASYNC) -> bool"""
+        return _misc.Sound_Play(*args)
 
+    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() 
 
-class WavePtr(Wave):
+class SoundPtr(Sound):
     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)
 
 #---------------------------------------------------------------------------
 
@@ -2452,6 +2478,27 @@ 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):
+    """
+    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 that act
+    like directories and entries, key/value pairs that act like
+    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,)
@@ -2467,147 +2514,311 @@ class ConfigBase(object):
     Type_Integer = _misc.ConfigBase_Type_Integer
     Type_Float = _misc.ConfigBase_Type_Float
     def Set(*args, **kwargs):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """GetPath() -> String"""
+        """
+        GetPath() -> String
+
+        Retrieve the current path (always as absolute path)
+        """
         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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """Flush(bool bCurrentOnly=False) -> bool"""
+        """
+        Flush(bool currentOnly=False) -> bool
+
+        permanently writes all changes
+        """
         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):
-        """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):
-        """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):
-        """DeleteGroup(String key) -> bool"""
+        """
+        DeleteGroup(String key) -> bool
+
+        Delete the group (with all subgroups)
+        """
         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):
-        """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)
 
+    def IsExpandingEnvVars(*args, **kwargs):
+        """
+        IsExpandingEnvVars() -> bool
+
+        Are we currently expanding environment variables?
+        """
+        return _misc.ConfigBase_IsExpandingEnvVars(*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):
-        """IsRecordingDefaults() -> bool"""
+        """
+        IsRecordingDefaults() -> bool
+
+        Are we currently recording default values?
+        """
         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):
@@ -2643,49 +2854,45 @@ class ConfigBasePtr(ConfigBase):
 _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):
-    """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):
-    """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):
-    """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):
+    """
+    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):
@@ -2713,13 +2920,14 @@ class ConfigPtr(Config):
 _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):
         """
         __init__(String appName=EmptyString, String vendorName=EmptyString, 
             String localFilename=EmptyString, String globalFilename=EmptyString, 
-            long style=0) -> FileConfig
+            long style=wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE) -> FileConfig
         """
         newobj = _misc.new_FileConfig(*args, **kwargs)
         self.this = newobj.this
@@ -2739,9 +2947,53 @@ class FileConfigPtr(FileConfig):
         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):
-    """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)
 #---------------------------------------------------------------------------
 
@@ -3173,6 +3425,8 @@ class DateTime(object):
         """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)
@@ -3335,7 +3589,7 @@ class DateTime(object):
         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):
@@ -3964,10 +4218,27 @@ DF_PRIVATE = _misc.DF_PRIVATE
 DF_HTML = _misc.DF_HTML
 DF_MAX = _misc.DF_MAX
 class DataFormat(object):
+    """
+    A wx.DataFormat is an encapsulation of a platform-specific format
+    handle which is used by the system for the clipboard and drag and
+    drop operations. The applications are usually only interested in,
+    for example, pasting data from the clipboard only if the data is
+    in a format the program understands.  A data format is is used to
+    uniquely identify this format.
+
+    On the system level, a data format is usually just a number
+    (CLIPFORMAT under Windows or Atom under X11, for example).
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxDataFormat instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(int type) -> DataFormat"""
+        """
+        __init__(int type) -> DataFormat
+
+        Constructs a data format object for one of the standard data
+        formats or an empty data object (use SetType or SetId later in
+        this case)
+        """
         newobj = _misc.new_DataFormat(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -3993,19 +4264,35 @@ class DataFormat(object):
         return _misc.DataFormat___ne__(*args)
 
     def SetType(*args, **kwargs):
-        """SetType(int format)"""
+        """
+        SetType(int format)
+
+        Sets the format to the given value, which should be one of wx.DF_XXX constants.
+        """
         return _misc.DataFormat_SetType(*args, **kwargs)
 
     def GetType(*args, **kwargs):
-        """GetType() -> int"""
+        """
+        GetType() -> int
+
+        Returns the platform-specific number identifying the format.
+        """
         return _misc.DataFormat_GetType(*args, **kwargs)
 
     def GetId(*args, **kwargs):
-        """GetId() -> String"""
+        """
+        GetId() -> String
+
+        Returns the name of a custom format (this function will fail for a standard format).
+        """
         return _misc.DataFormat_GetId(*args, **kwargs)
 
     def SetId(*args, **kwargs):
-        """SetId(String format)"""
+        """
+        SetId(String format)
+
+        Sets the format to be the custom format identified by the given name.
+        """
         return _misc.DataFormat_SetId(*args, **kwargs)
 
 
@@ -4015,9 +4302,14 @@ class DataFormatPtr(DataFormat):
         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"""
+    """
+    CustomDataFormat(String format) -> DataFormat
+
+    Constructs a data format object for a custom format identified by its name.
+    """
     val = _misc.new_CustomDataFormat(*args, **kwargs)
     val.thisown = 1
     return val
@@ -4131,9 +4423,7 @@ class DataObjectComposite(DataObject):
         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):
@@ -4420,12 +4710,11 @@ class DropTarget(object):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxPyDropTarget instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """PyDropTarget(DataObject dataObject=None) -> DropTarget"""
-        newobj = _misc.new_PyDropTarget(*args, **kwargs)
+        """__init__(DataObject dataObject=None) -> DropTarget"""
+        newobj = _misc.new_DropTarget(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
-        if args: args[0].thisown = 0;
         self._setCallbackInfo(self, DropTarget)
 
     def _setCallbackInfo(*args, **kwargs):
@@ -4444,9 +4733,7 @@ class DropTarget(object):
 
     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"""
@@ -4566,6 +4853,18 @@ _misc.FileDropTarget_swigregister(FileDropTargetPtr)
 #---------------------------------------------------------------------------
 
 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):
@@ -4581,43 +4880,97 @@ class Clipboard(core.Object):
         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):
-        """Close()"""
+        """
+        Close()
+
+        Closes the clipboard.
+        """
         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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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):
-        """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)
 
 
@@ -4629,10 +4982,19 @@ class ClipboardPtr(Clipboard):
 _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):
-        """__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
@@ -4644,7 +5006,12 @@ class ClipboardLocker(object):
         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)
 
 
@@ -4656,4 +5023,252 @@ class ClipboardLockerPtr(ClipboardLocker):
 _misc.ClipboardLocker_swigregister(ClipboardLockerPtr)
 TheClipboard = cvar.TheClipboard
 
+#---------------------------------------------------------------------------
+
+class VideoMode(object):
+    """A simple struct containing video mode parameters for a display"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxVideoMode instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """
+        __init__(int width=0, int height=0, int depth=0, int freq=0) -> VideoMode
+
+        A simple struct containing video mode parameters for a display
+        """
+        newobj = _misc.new_VideoMode(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+    def __del__(self, destroy=_misc.delete_VideoMode):
+        """__del__()"""
+        try:
+            if self.thisown: destroy(self)
+        except: pass
+
+    def Matches(*args, **kwargs):
+        """
+        Matches(VideoMode other) -> bool
+
+        Returns true if this mode matches the other one in the sense that
+        all non zero fields of the other mode have the same value in this
+        one (except for refresh which is allowed to have a greater value)
+        """
+        return _misc.VideoMode_Matches(*args, **kwargs)
+
+    def GetWidth(*args, **kwargs):
+        """
+        GetWidth() -> int
+
+        Returns the screen width in pixels (e.g. 640*480), 0 means
+        unspecified
+        """
+        return _misc.VideoMode_GetWidth(*args, **kwargs)
+
+    def GetHeight(*args, **kwargs):
+        """
+        GetHeight() -> int
+
+        Returns the screen width in pixels (e.g. 640*480), 0 means
+        unspecified
+        """
+        return _misc.VideoMode_GetHeight(*args, **kwargs)
+
+    def GetDepth(*args, **kwargs):
+        """
+        GetDepth() -> int
+
+        Returns the screen's bits per pixel (e.g. 32), 1 is monochrome
+        and 0 means unspecified/known
+        """
+        return _misc.VideoMode_GetDepth(*args, **kwargs)
+
+    def IsOk(*args, **kwargs):
+        """
+        IsOk() -> bool
+
+        returns true if the object has been initialized
+        """
+        return _misc.VideoMode_IsOk(*args, **kwargs)
+
+    def __nonzero__(self): return self.IsOk() 
+    def __eq__(*args, **kwargs):
+        """__eq__(VideoMode other) -> bool"""
+        return _misc.VideoMode___eq__(*args, **kwargs)
+
+    def __ne__(*args, **kwargs):
+        """__ne__(VideoMode other) -> bool"""
+        return _misc.VideoMode___ne__(*args, **kwargs)
+
+    w = property(_misc.VideoMode_w_get, _misc.VideoMode_w_set)
+    h = property(_misc.VideoMode_h_get, _misc.VideoMode_h_set)
+    bpp = property(_misc.VideoMode_bpp_get, _misc.VideoMode_bpp_set)
+    refresh = property(_misc.VideoMode_refresh_get, _misc.VideoMode_refresh_set)
+
+class VideoModePtr(VideoMode):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = VideoMode
+_misc.VideoMode_swigregister(VideoModePtr)
+
+class Display(object):
+    """Represents a display/monitor attached to the system"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxDisplay instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """
+        __init__(size_t index=0) -> Display
+
+        Set up a Display instance with the specified display.  The
+        displays are numbered from 0 to GetCount() - 1, 0 is always the
+        primary display and the only one which is always supported
+        """
+        newobj = _misc.new_Display(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+    def __del__(self, destroy=_misc.delete_Display):
+        """__del__()"""
+        try:
+            if self.thisown: destroy(self)
+        except: pass
+
+    def GetCount(*args, **kwargs):
+        """
+        GetCount() -> size_t
+
+        Return the number of available displays.
+        """
+        return _misc.Display_GetCount(*args, **kwargs)
+
+    GetCount = staticmethod(GetCount)
+    def GetFromPoint(*args, **kwargs):
+        """
+        GetFromPoint(Point pt) -> int
+
+        Find the display where the given point lies, return wx.NOT_FOUND
+        if it doesn't belong to any display
+        """
+        return _misc.Display_GetFromPoint(*args, **kwargs)
+
+    GetFromPoint = staticmethod(GetFromPoint)
+    def GetFromWindow(*args, **kwargs):
+        """
+        GetFromWindow(Window window) -> int
+
+        Find the display where the given window lies, return wx.NOT_FOUND
+        if it is not shown at all.
+        """
+        return _misc.Display_GetFromWindow(*args, **kwargs)
+
+    GetFromWindow = staticmethod(GetFromWindow)
+    def IsOk(*args, **kwargs):
+        """
+        IsOk() -> bool
+
+        Return true if the object was initialized successfully
+        """
+        return _misc.Display_IsOk(*args, **kwargs)
+
+    def __nonzero__(self): return self.IsOk() 
+    def GetGeometry(*args, **kwargs):
+        """
+        GetGeometry() -> Rect
+
+        Returns the bounding rectangle of the display whose index was
+        passed to the constructor.
+        """
+        return _misc.Display_GetGeometry(*args, **kwargs)
+
+    def GetName(*args, **kwargs):
+        """
+        GetName() -> String
+
+        Returns the display's name. A name is not available on all platforms.
+        """
+        return _misc.Display_GetName(*args, **kwargs)
+
+    def IsPrimary(*args, **kwargs):
+        """
+        IsPrimary() -> bool
+
+        Returns true if the display is the primary display. The primary
+        display is the one whose index is 0.
+        """
+        return _misc.Display_IsPrimary(*args, **kwargs)
+
+    def GetModes(*args, **kwargs):
+        """
+        GetModes(VideoMode mode=DefaultVideoMode) -> [videoMode...]
+
+        Enumerate all video modes supported by this display matching the
+        given one (in the sense of VideoMode.Match()).
+
+        As any mode matches the default value of the argument and there
+        is always at least one video mode supported by display, the
+        returned array is only empty for the default value of the
+        argument if this function is not supported at all on this
+        platform.
+        """
+        return _misc.Display_GetModes(*args, **kwargs)
+
+    def GetCurrentMode(*args, **kwargs):
+        """
+        GetCurrentMode() -> VideoMode
+
+        Get the current video mode.
+        """
+        return _misc.Display_GetCurrentMode(*args, **kwargs)
+
+    def ChangeMode(*args, **kwargs):
+        """
+        ChangeMode(VideoMode mode=DefaultVideoMode) -> bool
+
+        Change current mode, return true if succeeded, false otherwise
+        """
+        return _misc.Display_ChangeMode(*args, **kwargs)
+
+    def ResetMode(*args, **kwargs):
+        """
+        ResetMode()
+
+        Restore the default video mode (just a more readable synonym)
+        """
+        return _misc.Display_ResetMode(*args, **kwargs)
+
+
+class DisplayPtr(Display):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = Display
+_misc.Display_swigregister(DisplayPtr)
+DefaultVideoMode = cvar.DefaultVideoMode
+
+def Display_GetCount(*args, **kwargs):
+    """
+    Display_GetCount() -> size_t
+
+    Return the number of available displays.
+    """
+    return _misc.Display_GetCount(*args, **kwargs)
+
+def Display_GetFromPoint(*args, **kwargs):
+    """
+    Display_GetFromPoint(Point pt) -> int
+
+    Find the display where the given point lies, return wx.NOT_FOUND
+    if it doesn't belong to any display
+    """
+    return _misc.Display_GetFromPoint(*args, **kwargs)
+
+def Display_GetFromWindow(*args, **kwargs):
+    """
+    Display_GetFromWindow(Window window) -> int
+
+    Find the display where the given window lies, return wx.NOT_FOUND
+    if it is not shown at all.
+    """
+    return _misc.Display_GetFromWindow(*args, **kwargs)
+