]> git.saurik.com Git - wxWidgets.git/blobdiff - wxPython/src/mac/_core.py
'[1219035] cleanup: miscellaneous' and minor source cleaning.
[wxWidgets.git] / wxPython / src / mac / _core.py
index 49665132d292b6558176b9807bcdaeb9adf2fe40..22ecb6ff627cc624c156f0e81240a3f69143a29f 100644 (file)
@@ -85,17 +85,14 @@ SIMPLE_BORDER = _core_.SIMPLE_BORDER
 STATIC_BORDER = _core_.STATIC_BORDER
 TRANSPARENT_WINDOW = _core_.TRANSPARENT_WINDOW
 NO_BORDER = _core_.NO_BORDER
 STATIC_BORDER = _core_.STATIC_BORDER
 TRANSPARENT_WINDOW = _core_.TRANSPARENT_WINDOW
 NO_BORDER = _core_.NO_BORDER
+DEFAULT_CONTROL_BORDER = _core_.DEFAULT_CONTROL_BORDER
+DEFAULT_STATUSBAR_STYLE = _core_.DEFAULT_STATUSBAR_STYLE
 TAB_TRAVERSAL = _core_.TAB_TRAVERSAL
 WANTS_CHARS = _core_.WANTS_CHARS
 POPUP_WINDOW = _core_.POPUP_WINDOW
 CENTER_FRAME = _core_.CENTER_FRAME
 CENTRE_ON_SCREEN = _core_.CENTRE_ON_SCREEN
 CENTER_ON_SCREEN = _core_.CENTER_ON_SCREEN
 TAB_TRAVERSAL = _core_.TAB_TRAVERSAL
 WANTS_CHARS = _core_.WANTS_CHARS
 POPUP_WINDOW = _core_.POPUP_WINDOW
 CENTER_FRAME = _core_.CENTER_FRAME
 CENTRE_ON_SCREEN = _core_.CENTRE_ON_SCREEN
 CENTER_ON_SCREEN = _core_.CENTER_ON_SCREEN
-ED_CLIENT_MARGIN = _core_.ED_CLIENT_MARGIN
-ED_BUTTONS_BOTTOM = _core_.ED_BUTTONS_BOTTOM
-ED_BUTTONS_RIGHT = _core_.ED_BUTTONS_RIGHT
-ED_STATIC_LINE = _core_.ED_STATIC_LINE
-EXT_DIALOG_STYLE = _core_.EXT_DIALOG_STYLE
 CLIP_CHILDREN = _core_.CLIP_CHILDREN
 CLIP_SIBLINGS = _core_.CLIP_SIBLINGS
 ALWAYS_SHOW_SB = _core_.ALWAYS_SHOW_SB
 CLIP_CHILDREN = _core_.CLIP_CHILDREN
 CLIP_SIBLINGS = _core_.CLIP_SIBLINGS
 ALWAYS_SHOW_SB = _core_.ALWAYS_SHOW_SB
@@ -121,20 +118,12 @@ RA_HORIZONTAL = _core_.RA_HORIZONTAL
 RA_VERTICAL = _core_.RA_VERTICAL
 RA_SPECIFY_ROWS = _core_.RA_SPECIFY_ROWS
 RA_SPECIFY_COLS = _core_.RA_SPECIFY_COLS
 RA_VERTICAL = _core_.RA_VERTICAL
 RA_SPECIFY_ROWS = _core_.RA_SPECIFY_ROWS
 RA_SPECIFY_COLS = _core_.RA_SPECIFY_COLS
+RA_USE_CHECKBOX = _core_.RA_USE_CHECKBOX
 RB_GROUP = _core_.RB_GROUP
 RB_SINGLE = _core_.RB_SINGLE
 RB_GROUP = _core_.RB_GROUP
 RB_SINGLE = _core_.RB_SINGLE
-SL_HORIZONTAL = _core_.SL_HORIZONTAL
-SL_VERTICAL = _core_.SL_VERTICAL
-SL_AUTOTICKS = _core_.SL_AUTOTICKS
-SL_LABELS = _core_.SL_LABELS
-SL_LEFT = _core_.SL_LEFT
-SL_TOP = _core_.SL_TOP
-SL_RIGHT = _core_.SL_RIGHT
-SL_BOTTOM = _core_.SL_BOTTOM
-SL_BOTH = _core_.SL_BOTH
-SL_SELRANGE = _core_.SL_SELRANGE
 SB_HORIZONTAL = _core_.SB_HORIZONTAL
 SB_VERTICAL = _core_.SB_VERTICAL
 SB_HORIZONTAL = _core_.SB_HORIZONTAL
 SB_VERTICAL = _core_.SB_VERTICAL
+RB_USE_CHECKBOX = _core_.RB_USE_CHECKBOX
 ST_SIZEGRIP = _core_.ST_SIZEGRIP
 ST_NO_AUTORESIZE = _core_.ST_NO_AUTORESIZE
 FLOOD_SURFACE = _core_.FLOOD_SURFACE
 ST_SIZEGRIP = _core_.ST_SIZEGRIP
 ST_NO_AUTORESIZE = _core_.ST_NO_AUTORESIZE
 FLOOD_SURFACE = _core_.FLOOD_SURFACE
@@ -288,6 +277,8 @@ PD_CAN_ABORT = _core_.PD_CAN_ABORT
 PD_ELAPSED_TIME = _core_.PD_ELAPSED_TIME
 PD_ESTIMATED_TIME = _core_.PD_ESTIMATED_TIME
 PD_REMAINING_TIME = _core_.PD_REMAINING_TIME
 PD_ELAPSED_TIME = _core_.PD_ELAPSED_TIME
 PD_ESTIMATED_TIME = _core_.PD_ESTIMATED_TIME
 PD_REMAINING_TIME = _core_.PD_REMAINING_TIME
+PD_SMOOTH = _core_.PD_SMOOTH
+PD_CAN_SKIP = _core_.PD_CAN_SKIP
 DD_NEW_DIR_BUTTON = _core_.DD_NEW_DIR_BUTTON
 DD_DEFAULT_STYLE = _core_.DD_DEFAULT_STYLE
 MENU_TEAROFF = _core_.MENU_TEAROFF
 DD_NEW_DIR_BUTTON = _core_.DD_NEW_DIR_BUTTON
 DD_DEFAULT_STYLE = _core_.DD_DEFAULT_STYLE
 MENU_TEAROFF = _core_.MENU_TEAROFF
@@ -381,6 +372,8 @@ DOT_DASH = _core_.DOT_DASH
 USER_DASH = _core_.USER_DASH
 TRANSPARENT = _core_.TRANSPARENT
 STIPPLE = _core_.STIPPLE
 USER_DASH = _core_.USER_DASH
 TRANSPARENT = _core_.TRANSPARENT
 STIPPLE = _core_.STIPPLE
+STIPPLE_MASK = _core_.STIPPLE_MASK
+STIPPLE_MASK_OPAQUE = _core_.STIPPLE_MASK_OPAQUE
 BDIAGONAL_HATCH = _core_.BDIAGONAL_HATCH
 CROSSDIAG_HATCH = _core_.CROSSDIAG_HATCH
 FDIAGONAL_HATCH = _core_.FDIAGONAL_HATCH
 BDIAGONAL_HATCH = _core_.BDIAGONAL_HATCH
 CROSSDIAG_HATCH = _core_.CROSSDIAG_HATCH
 FDIAGONAL_HATCH = _core_.FDIAGONAL_HATCH
@@ -515,6 +508,27 @@ WXK_NUMPAD_DIVIDE = _core_.WXK_NUMPAD_DIVIDE
 WXK_WINDOWS_LEFT = _core_.WXK_WINDOWS_LEFT
 WXK_WINDOWS_RIGHT = _core_.WXK_WINDOWS_RIGHT
 WXK_WINDOWS_MENU = _core_.WXK_WINDOWS_MENU
 WXK_WINDOWS_LEFT = _core_.WXK_WINDOWS_LEFT
 WXK_WINDOWS_RIGHT = _core_.WXK_WINDOWS_RIGHT
 WXK_WINDOWS_MENU = _core_.WXK_WINDOWS_MENU
+WXK_COMMAND = _core_.WXK_COMMAND
+WXK_SPECIAL1 = _core_.WXK_SPECIAL1
+WXK_SPECIAL2 = _core_.WXK_SPECIAL2
+WXK_SPECIAL3 = _core_.WXK_SPECIAL3
+WXK_SPECIAL4 = _core_.WXK_SPECIAL4
+WXK_SPECIAL5 = _core_.WXK_SPECIAL5
+WXK_SPECIAL6 = _core_.WXK_SPECIAL6
+WXK_SPECIAL7 = _core_.WXK_SPECIAL7
+WXK_SPECIAL8 = _core_.WXK_SPECIAL8
+WXK_SPECIAL9 = _core_.WXK_SPECIAL9
+WXK_SPECIAL10 = _core_.WXK_SPECIAL10
+WXK_SPECIAL11 = _core_.WXK_SPECIAL11
+WXK_SPECIAL12 = _core_.WXK_SPECIAL12
+WXK_SPECIAL13 = _core_.WXK_SPECIAL13
+WXK_SPECIAL14 = _core_.WXK_SPECIAL14
+WXK_SPECIAL15 = _core_.WXK_SPECIAL15
+WXK_SPECIAL16 = _core_.WXK_SPECIAL16
+WXK_SPECIAL17 = _core_.WXK_SPECIAL17
+WXK_SPECIAL18 = _core_.WXK_SPECIAL18
+WXK_SPECIAL19 = _core_.WXK_SPECIAL19
+WXK_SPECIAL20 = _core_.WXK_SPECIAL20
 PAPER_NONE = _core_.PAPER_NONE
 PAPER_LETTER = _core_.PAPER_LETTER
 PAPER_LEGAL = _core_.PAPER_LEGAL
 PAPER_NONE = _core_.PAPER_NONE
 PAPER_LETTER = _core_.PAPER_LETTER
 PAPER_LEGAL = _core_.PAPER_LEGAL
@@ -582,6 +596,56 @@ PAPER_B5_EXTRA = _core_.PAPER_B5_EXTRA
 PAPER_A2 = _core_.PAPER_A2
 PAPER_A3_TRANSVERSE = _core_.PAPER_A3_TRANSVERSE
 PAPER_A3_EXTRA_TRANSVERSE = _core_.PAPER_A3_EXTRA_TRANSVERSE
 PAPER_A2 = _core_.PAPER_A2
 PAPER_A3_TRANSVERSE = _core_.PAPER_A3_TRANSVERSE
 PAPER_A3_EXTRA_TRANSVERSE = _core_.PAPER_A3_EXTRA_TRANSVERSE
+PAPER_DBL_JAPANESE_POSTCARD = _core_.PAPER_DBL_JAPANESE_POSTCARD
+PAPER_A6 = _core_.PAPER_A6
+PAPER_JENV_KAKU2 = _core_.PAPER_JENV_KAKU2
+PAPER_JENV_KAKU3 = _core_.PAPER_JENV_KAKU3
+PAPER_JENV_CHOU3 = _core_.PAPER_JENV_CHOU3
+PAPER_JENV_CHOU4 = _core_.PAPER_JENV_CHOU4
+PAPER_LETTER_ROTATED = _core_.PAPER_LETTER_ROTATED
+PAPER_A3_ROTATED = _core_.PAPER_A3_ROTATED
+PAPER_A4_ROTATED = _core_.PAPER_A4_ROTATED
+PAPER_A5_ROTATED = _core_.PAPER_A5_ROTATED
+PAPER_B4_JIS_ROTATED = _core_.PAPER_B4_JIS_ROTATED
+PAPER_B5_JIS_ROTATED = _core_.PAPER_B5_JIS_ROTATED
+PAPER_JAPANESE_POSTCARD_ROTATED = _core_.PAPER_JAPANESE_POSTCARD_ROTATED
+PAPER_DBL_JAPANESE_POSTCARD_ROTATED = _core_.PAPER_DBL_JAPANESE_POSTCARD_ROTATED
+PAPER_A6_ROTATED = _core_.PAPER_A6_ROTATED
+PAPER_JENV_KAKU2_ROTATED = _core_.PAPER_JENV_KAKU2_ROTATED
+PAPER_JENV_KAKU3_ROTATED = _core_.PAPER_JENV_KAKU3_ROTATED
+PAPER_JENV_CHOU3_ROTATED = _core_.PAPER_JENV_CHOU3_ROTATED
+PAPER_JENV_CHOU4_ROTATED = _core_.PAPER_JENV_CHOU4_ROTATED
+PAPER_B6_JIS = _core_.PAPER_B6_JIS
+PAPER_B6_JIS_ROTATED = _core_.PAPER_B6_JIS_ROTATED
+PAPER_12X11 = _core_.PAPER_12X11
+PAPER_JENV_YOU4 = _core_.PAPER_JENV_YOU4
+PAPER_JENV_YOU4_ROTATED = _core_.PAPER_JENV_YOU4_ROTATED
+PAPER_P16K = _core_.PAPER_P16K
+PAPER_P32K = _core_.PAPER_P32K
+PAPER_P32KBIG = _core_.PAPER_P32KBIG
+PAPER_PENV_1 = _core_.PAPER_PENV_1
+PAPER_PENV_2 = _core_.PAPER_PENV_2
+PAPER_PENV_3 = _core_.PAPER_PENV_3
+PAPER_PENV_4 = _core_.PAPER_PENV_4
+PAPER_PENV_5 = _core_.PAPER_PENV_5
+PAPER_PENV_6 = _core_.PAPER_PENV_6
+PAPER_PENV_7 = _core_.PAPER_PENV_7
+PAPER_PENV_8 = _core_.PAPER_PENV_8
+PAPER_PENV_9 = _core_.PAPER_PENV_9
+PAPER_PENV_10 = _core_.PAPER_PENV_10
+PAPER_P16K_ROTATED = _core_.PAPER_P16K_ROTATED
+PAPER_P32K_ROTATED = _core_.PAPER_P32K_ROTATED
+PAPER_P32KBIG_ROTATED = _core_.PAPER_P32KBIG_ROTATED
+PAPER_PENV_1_ROTATED = _core_.PAPER_PENV_1_ROTATED
+PAPER_PENV_2_ROTATED = _core_.PAPER_PENV_2_ROTATED
+PAPER_PENV_3_ROTATED = _core_.PAPER_PENV_3_ROTATED
+PAPER_PENV_4_ROTATED = _core_.PAPER_PENV_4_ROTATED
+PAPER_PENV_5_ROTATED = _core_.PAPER_PENV_5_ROTATED
+PAPER_PENV_6_ROTATED = _core_.PAPER_PENV_6_ROTATED
+PAPER_PENV_7_ROTATED = _core_.PAPER_PENV_7_ROTATED
+PAPER_PENV_8_ROTATED = _core_.PAPER_PENV_8_ROTATED
+PAPER_PENV_9_ROTATED = _core_.PAPER_PENV_9_ROTATED
+PAPER_PENV_10_ROTATED = _core_.PAPER_PENV_10_ROTATED
 DUPLEX_SIMPLEX = _core_.DUPLEX_SIMPLEX
 DUPLEX_HORIZONTAL = _core_.DUPLEX_HORIZONTAL
 DUPLEX_VERTICAL = _core_.DUPLEX_VERTICAL
 DUPLEX_SIMPLEX = _core_.DUPLEX_SIMPLEX
 DUPLEX_HORIZONTAL = _core_.DUPLEX_HORIZONTAL
 DUPLEX_VERTICAL = _core_.DUPLEX_VERTICAL
@@ -1141,6 +1205,10 @@ class Rect(object):
         """SetSize(self, Size s)"""
         return _core_.Rect_SetSize(*args, **kwargs)
 
         """SetSize(self, Size s)"""
         return _core_.Rect_SetSize(*args, **kwargs)
 
+    def IsEmpty(*args, **kwargs):
+        """IsEmpty(self) -> bool"""
+        return _core_.Rect_IsEmpty(*args, **kwargs)
+
     def GetTopLeft(*args, **kwargs):
         """GetTopLeft(self) -> Point"""
         return _core_.Rect_GetTopLeft(*args, **kwargs)
     def GetTopLeft(*args, **kwargs):
         """GetTopLeft(self) -> Point"""
         return _core_.Rect_GetTopLeft(*args, **kwargs)
@@ -1200,9 +1268,24 @@ class Rect(object):
         """
         Inflate(self, int dx, int dy) -> Rect
 
         """
         Inflate(self, int dx, int dy) -> Rect
 
-        Increase the rectangle size by dx in x direction and dy in y
-        direction. Both (or one of) parameters may be negative to decrease the
-        rectangle size.
+        Increases the size of the rectangle.
+
+        The left border is moved farther left and the right border is moved
+        farther right by ``dx``. The upper border is moved farther up and the
+        bottom border is moved farther down by ``dy``. (Note the the width and
+        height of the rectangle thus change by ``2*dx`` and ``2*dy``,
+        respectively.) If one or both of ``dx`` and ``dy`` are negative, the
+        opposite happens: the rectangle size decreases in the respective
+        direction.
+
+        The change is made to the rectangle inplace, if instead you need a
+        copy that is inflated, preserving the original then make the copy
+        first::
+
+            copy = wx.Rect(*original)
+            copy.Inflate(10,15)
+
+
         """
         return _core_.Rect_Inflate(*args, **kwargs)
 
         """
         return _core_.Rect_Inflate(*args, **kwargs)
 
@@ -1210,9 +1293,9 @@ class Rect(object):
         """
         Deflate(self, int dx, int dy) -> Rect
 
         """
         Deflate(self, int dx, int dy) -> Rect
 
-        Decrease the rectangle size by dx in x direction and dy in y
-        direction. Both (or one of) parameters may be negative to increase the
-        rectngle size. This method is the opposite of Inflate.
+        Decrease the rectangle size. This method is the opposite of `Inflate`
+        in that Deflate(a,b) is equivalent to Inflate(-a,-b).  Please refer to
+        `Inflate` for a full description.
         """
         return _core_.Rect_Deflate(*args, **kwargs)
 
         """
         return _core_.Rect_Deflate(*args, **kwargs)
 
@@ -1682,7 +1765,7 @@ class FSFile(Object):
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
-        self.thisown = 0   # It will normally be deleted by the user of the wxFileSystem
+        self.thisown = 0   # It will normally be deleted by the user of the wx.FileSystem
 
     def __del__(self, destroy=_core_.delete_FSFile):
         """__del__(self)"""
 
     def __del__(self, destroy=_core_.delete_FSFile):
         """__del__(self)"""
@@ -2004,10 +2087,17 @@ def MemoryFSHandler_RemoveFile(*args, **kwargs):
     """MemoryFSHandler_RemoveFile(String filename)"""
     return _core_.MemoryFSHandler_RemoveFile(*args, **kwargs)
 
     """MemoryFSHandler_RemoveFile(String filename)"""
     return _core_.MemoryFSHandler_RemoveFile(*args, **kwargs)
 
+IMAGE_ALPHA_TRANSPARENT = _core_.IMAGE_ALPHA_TRANSPARENT
+IMAGE_ALPHA_THRESHOLD = _core_.IMAGE_ALPHA_THRESHOLD
+IMAGE_ALPHA_OPAQUE = _core_.IMAGE_ALPHA_OPAQUE
 #---------------------------------------------------------------------------
 
 class ImageHandler(Object):
 #---------------------------------------------------------------------------
 
 class ImageHandler(Object):
-    """Proxy of C++ ImageHandler class"""
+    """
+    This is the base class for implementing image file loading/saving, and
+    image creation from data. It is used within `wx.Image` and is not
+    normally seen by the application.
+    """
     def __init__(self): raise RuntimeError, "No constructor defined"
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxImageHandler 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++ wxImageHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
@@ -2067,7 +2157,7 @@ class ImageHistogram(object):
         del newobj.thisown
     def MakeKey(*args, **kwargs):
         """
         del newobj.thisown
     def MakeKey(*args, **kwargs):
         """
-        MakeKey(unsigned char r, unsigned char g, unsigned char b) -> unsigned long
+        MakeKey(byte r, byte g, byte b) -> unsigned long
 
         Get the key in the histogram for the given RGB values
         """
 
         Get the key in the histogram for the given RGB values
         """
@@ -2084,6 +2174,31 @@ class ImageHistogram(object):
         """
         return _core_.ImageHistogram_FindFirstUnusedColour(*args, **kwargs)
 
         """
         return _core_.ImageHistogram_FindFirstUnusedColour(*args, **kwargs)
 
+    def GetCount(*args, **kwargs):
+        """
+        GetCount(self, unsigned long key) -> unsigned long
+
+        Returns the pixel count for the given key.  Use `MakeKey` to create a
+        key value from a RGB tripple.
+        """
+        return _core_.ImageHistogram_GetCount(*args, **kwargs)
+
+    def GetCountRGB(*args, **kwargs):
+        """
+        GetCountRGB(self, byte r, byte g, byte b) -> unsigned long
+
+        Returns the pixel count for the given RGB values.
+        """
+        return _core_.ImageHistogram_GetCountRGB(*args, **kwargs)
+
+    def GetCountColour(*args, **kwargs):
+        """
+        GetCountColour(self, Colour colour) -> unsigned long
+
+        Returns the pixel count for the given `wx.Colour` value.
+        """
+        return _core_.ImageHistogram_GetCountColour(*args, **kwargs)
+
 
 class ImageHistogramPtr(ImageHistogram):
     def __init__(self, this):
 
 class ImageHistogramPtr(ImageHistogram):
     def __init__(self, this):
@@ -2094,18 +2209,47 @@ _core_.ImageHistogram_swigregister(ImageHistogramPtr)
 
 def ImageHistogram_MakeKey(*args, **kwargs):
     """
 
 def ImageHistogram_MakeKey(*args, **kwargs):
     """
-    ImageHistogram_MakeKey(unsigned char r, unsigned char g, unsigned char b) -> unsigned long
+    ImageHistogram_MakeKey(byte r, byte g, byte b) -> unsigned long
 
     Get the key in the histogram for the given RGB values
     """
     return _core_.ImageHistogram_MakeKey(*args, **kwargs)
 
 class Image(Object):
 
     Get the key in the histogram for the given RGB values
     """
     return _core_.ImageHistogram_MakeKey(*args, **kwargs)
 
 class Image(Object):
-    """Proxy of C++ Image class"""
+    """
+    A platform-independent image class.  An image can be created from
+    data, or using `wx.Bitmap.ConvertToImage`, or loaded from a file in a
+    variety of formats.  Functions are available to set and get image
+    bits, so it can be used for basic image manipulation.
+
+    A wx.Image cannot be drawn directly to a `wx.DC`.  Instead, a
+    platform-specific `wx.Bitmap` object must be created from it using the
+    `wx.BitmapFromImage` constructor. This bitmap can then be drawn in a
+    device context, using `wx.DC.DrawBitmap`.
+
+    One colour value of the image may be used as a mask colour which will
+    lead to the automatic creation of a `wx.Mask` object associated to the
+    bitmap object.
+
+    wx.Image supports alpha channel data, that is in addition to a byte
+    for the red, green and blue colour components for each pixel it also
+    stores a byte representing the pixel opacity. An alpha value of 0
+    corresponds to a transparent pixel (null opacity) while a value of 255
+    means that the pixel is 100% opaque.
+
+    Unlike RGB data, not all images have an alpha channel and before using
+    `GetAlpha` you should check if this image contains an alpha channel
+    with `HasAlpha`. Note that currently only images loaded from PNG files
+    with transparency information will have an alpha channel.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxImage 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++ wxImage instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, String name, long type=BITMAP_TYPE_ANY, int index=-1) -> Image"""
+        """
+        __init__(self, String name, long type=BITMAP_TYPE_ANY, int index=-1) -> Image
+
+        Loads an image from a file.
+        """
         newobj = _core_.new_Image(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_Image(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -2117,57 +2261,165 @@ class Image(Object):
         except: pass
 
     def Create(*args, **kwargs):
         except: pass
 
     def Create(*args, **kwargs):
-        """Create(self, int width, int height)"""
+        """
+        Create(self, int width, int height, bool clear=True)
+
+        Creates a fresh image.  If clear is ``True``, the new image will be
+        initialized to black. Otherwise, the image data will be uninitialized.
+        """
         return _core_.Image_Create(*args, **kwargs)
 
     def Destroy(*args, **kwargs):
         """
         Destroy(self)
 
         return _core_.Image_Create(*args, **kwargs)
 
     def Destroy(*args, **kwargs):
         """
         Destroy(self)
 
-        Deletes the C++ object this Python object is a proxy for.
+        Destroys the image data.
         """
         return _core_.Image_Destroy(*args, **kwargs)
 
     def Scale(*args, **kwargs):
         """
         return _core_.Image_Destroy(*args, **kwargs)
 
     def Scale(*args, **kwargs):
-        """Scale(self, int width, int height) -> Image"""
+        """
+        Scale(self, int width, int height) -> Image
+
+        Returns a scaled version of the image. This is also useful for scaling
+        bitmaps in general as the only other way to scale bitmaps is to blit a
+        `wx.MemoryDC` into another `wx.MemoryDC`.
+        """
         return _core_.Image_Scale(*args, **kwargs)
 
     def ShrinkBy(*args, **kwargs):
         return _core_.Image_Scale(*args, **kwargs)
 
     def ShrinkBy(*args, **kwargs):
-        """ShrinkBy(self, int xFactor, int yFactor) -> Image"""
+        """
+        ShrinkBy(self, int xFactor, int yFactor) -> Image
+
+        Return a version of the image scaled smaller by the given factors.
+        """
         return _core_.Image_ShrinkBy(*args, **kwargs)
 
     def Rescale(*args, **kwargs):
         return _core_.Image_ShrinkBy(*args, **kwargs)
 
     def Rescale(*args, **kwargs):
-        """Rescale(self, int width, int height) -> Image"""
+        """
+        Rescale(self, int width, int height) -> Image
+
+        Changes the size of the image in-place by scaling it: after a call to
+        this function, the image will have the given width and height.
+
+        Returns the (modified) image itself.
+        """
         return _core_.Image_Rescale(*args, **kwargs)
 
         return _core_.Image_Rescale(*args, **kwargs)
 
+    def Resize(*args, **kwargs):
+        """
+        Resize(self, Size size, Point pos, int r=-1, int g=-1, int b=-1) -> Image
+
+        Changes the size of the image in-place without scaling it, by adding
+        either a border with the given colour or cropping as necessary. The
+        image is pasted into a new image with the given size and background
+        colour at the position pos relative to the upper left of the new
+        image. If red = green = blue = -1 then use either the current mask
+        colour if set or find, use, and set a suitable mask colour for any
+        newly exposed areas.
+
+        Returns the (modified) image itself.
+        """
+        return _core_.Image_Resize(*args, **kwargs)
+
     def SetRGB(*args, **kwargs):
     def SetRGB(*args, **kwargs):
-        """SetRGB(self, int x, int y, unsigned char r, unsigned char g, unsigned char b)"""
+        """
+        SetRGB(self, int x, int y, byte r, byte g, byte b)
+
+        Sets the pixel at the given coordinate. This routine performs
+        bounds-checks for the coordinate so it can be considered a safe way to
+        manipulate the data, but in some cases this might be too slow so that
+        the data will have to be set directly. In that case you will have to
+        get access to the image data using the `GetData` method.
+        """
         return _core_.Image_SetRGB(*args, **kwargs)
 
         return _core_.Image_SetRGB(*args, **kwargs)
 
+    def SetRGBRect(*args, **kwargs):
+        """
+        SetRGBRect(self, Rect rect, byte r, byte g, byte b)
+
+        Sets the colour of the pixels within the given rectangle. This routine
+        performs bounds-checks for the rectangle so it can be considered a
+        safe way to manipulate the data.
+        """
+        return _core_.Image_SetRGBRect(*args, **kwargs)
+
     def GetRed(*args, **kwargs):
     def GetRed(*args, **kwargs):
-        """GetRed(self, int x, int y) -> unsigned char"""
+        """
+        GetRed(self, int x, int y) -> byte
+
+        Returns the red intensity at the given coordinate.
+        """
         return _core_.Image_GetRed(*args, **kwargs)
 
     def GetGreen(*args, **kwargs):
         return _core_.Image_GetRed(*args, **kwargs)
 
     def GetGreen(*args, **kwargs):
-        """GetGreen(self, int x, int y) -> unsigned char"""
+        """
+        GetGreen(self, int x, int y) -> byte
+
+        Returns the green intensity at the given coordinate.
+        """
         return _core_.Image_GetGreen(*args, **kwargs)
 
     def GetBlue(*args, **kwargs):
         return _core_.Image_GetGreen(*args, **kwargs)
 
     def GetBlue(*args, **kwargs):
-        """GetBlue(self, int x, int y) -> unsigned char"""
+        """
+        GetBlue(self, int x, int y) -> byte
+
+        Returns the blue intensity at the given coordinate.
+        """
         return _core_.Image_GetBlue(*args, **kwargs)
 
     def SetAlpha(*args, **kwargs):
         return _core_.Image_GetBlue(*args, **kwargs)
 
     def SetAlpha(*args, **kwargs):
-        """SetAlpha(self, int x, int y, unsigned char alpha)"""
+        """
+        SetAlpha(self, int x, int y, byte alpha)
+
+        Sets the alpha value for the given pixel. This function should only be
+        called if the image has alpha channel data, use `HasAlpha` to check
+        for this.
+        """
         return _core_.Image_SetAlpha(*args, **kwargs)
 
     def GetAlpha(*args, **kwargs):
         return _core_.Image_SetAlpha(*args, **kwargs)
 
     def GetAlpha(*args, **kwargs):
-        """GetAlpha(self, int x, int y) -> unsigned char"""
+        """
+        GetAlpha(self, int x, int y) -> byte
+
+        Returns the alpha value for the given pixel. This function may only be
+        called for the images with alpha channel, use `HasAlpha` to check for
+        this.
+
+        The returned value is the *opacity* of the image, i.e. the value of 0
+        corresponds to the fully transparent pixels while the value of 255 to
+        the fully opaque pixels.
+        """
         return _core_.Image_GetAlpha(*args, **kwargs)
 
     def HasAlpha(*args, **kwargs):
         return _core_.Image_GetAlpha(*args, **kwargs)
 
     def HasAlpha(*args, **kwargs):
-        """HasAlpha(self) -> bool"""
+        """
+        HasAlpha(self) -> bool
+
+        Returns true if this image has alpha channel, false otherwise.
+        """
         return _core_.Image_HasAlpha(*args, **kwargs)
 
         return _core_.Image_HasAlpha(*args, **kwargs)
 
+    def InitAlpha(*args, **kwargs):
+        """
+        InitAlpha(self)
+
+        Initializes the image alpha channel data. It is an error to call it if
+        the image already has alpha data. If it doesn't, alpha data will be by
+        default initialized to all pixels being fully opaque. But if the image
+        has a a mask colour, all mask pixels will be completely transparent.
+        """
+        return _core_.Image_InitAlpha(*args, **kwargs)
+
+    def IsTransparent(*args, **kwargs):
+        """
+        IsTransparent(self, int x, int y, byte threshold=IMAGE_ALPHA_THRESHOLD) -> bool
+
+        Returns ``True`` if this pixel is masked or has an alpha value less
+        than the spcified threshold.
+        """
+        return _core_.Image_IsTransparent(*args, **kwargs)
+
     def FindFirstUnusedColour(*args, **kwargs):
         """
         FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)
     def FindFirstUnusedColour(*args, **kwargs):
         """
         FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)
@@ -2180,12 +2432,12 @@ class Image(Object):
 
     def ConvertAlphaToMask(*args, **kwargs):
         """
 
     def ConvertAlphaToMask(*args, **kwargs):
         """
-        ConvertAlphaToMask(self, byte threshold=128) -> bool
+        ConvertAlphaToMask(self, byte threshold=IMAGE_ALPHA_THRESHOLD) -> bool
 
 
-        If the image has alpha channel, this method converts it to mask. All pixels
-        with alpha value less than ``threshold`` are replaced with mask colour and the
-        alpha channel is removed. Mask colour is chosen automatically using
-        `FindFirstUnusedColour`.
+        If the image has alpha channel, this method converts it to mask. All
+        pixels with alpha value less than ``threshold`` are replaced with the
+        mask colour and the alpha channel is removed. The mask colour is
+        chosen automatically using `FindFirstUnusedColour`.
 
         If the image image doesn't have alpha channel, ConvertAlphaToMask does
         nothing.
 
         If the image image doesn't have alpha channel, ConvertAlphaToMask does
         nothing.
@@ -2194,7 +2446,7 @@ class Image(Object):
 
     def ConvertColourToAlpha(*args, **kwargs):
         """
 
     def ConvertColourToAlpha(*args, **kwargs):
         """
-        ConvertColourToAlpha(self, unsigned char r, unsigned char g, unsigned char b) -> bool
+        ConvertColourToAlpha(self, byte r, byte g, byte b) -> bool
 
         This method converts an image where the original alpha information is
         only available as a shades of a colour (actually shades of grey)
 
         This method converts an image where the original alpha information is
         only available as a shades of a colour (actually shades of grey)
@@ -2207,98 +2459,234 @@ class Image(Object):
         return _core_.Image_ConvertColourToAlpha(*args, **kwargs)
 
     def SetMaskFromImage(*args, **kwargs):
         return _core_.Image_ConvertColourToAlpha(*args, **kwargs)
 
     def SetMaskFromImage(*args, **kwargs):
-        """SetMaskFromImage(self, Image mask, byte mr, byte mg, byte mb) -> bool"""
+        """
+        SetMaskFromImage(self, Image mask, byte mr, byte mg, byte mb) -> bool
+
+        Sets the image's mask so that the pixels that have RGB value of
+        ``(mr,mg,mb)`` in ``mask`` will be masked in this image. This is done
+        by first finding an unused colour in the image, setting this colour as
+        the mask colour and then using this colour to draw all pixels in the
+        image who corresponding pixel in mask has given RGB value.
+
+        Returns ``False`` if ``mask`` does not have same dimensions as the
+        image or if there is no unused colour left. Returns ``True`` if the
+        mask was successfully applied.
+
+        Note that this method involves computing the histogram, which is
+        computationally intensive operation.
+        """
         return _core_.Image_SetMaskFromImage(*args, **kwargs)
 
     def CanRead(*args, **kwargs):
         return _core_.Image_SetMaskFromImage(*args, **kwargs)
 
     def CanRead(*args, **kwargs):
-        """CanRead(String name) -> bool"""
+        """
+        CanRead(String filename) -> bool
+
+        Returns True if the image handlers can read this file.
+        """
         return _core_.Image_CanRead(*args, **kwargs)
 
     CanRead = staticmethod(CanRead)
     def GetImageCount(*args, **kwargs):
         return _core_.Image_CanRead(*args, **kwargs)
 
     CanRead = staticmethod(CanRead)
     def GetImageCount(*args, **kwargs):
-        """GetImageCount(String name, long type=BITMAP_TYPE_ANY) -> int"""
+        """
+        GetImageCount(String filename, long type=BITMAP_TYPE_ANY) -> int
+
+        If the image file contains more than one image and the image handler
+        is capable of retrieving these individually, this function will return
+        the number of available images.
+        """
         return _core_.Image_GetImageCount(*args, **kwargs)
 
     GetImageCount = staticmethod(GetImageCount)
     def LoadFile(*args, **kwargs):
         return _core_.Image_GetImageCount(*args, **kwargs)
 
     GetImageCount = staticmethod(GetImageCount)
     def LoadFile(*args, **kwargs):
-        """LoadFile(self, String name, long type=BITMAP_TYPE_ANY, int index=-1) -> bool"""
+        """
+        LoadFile(self, String name, long type=BITMAP_TYPE_ANY, int index=-1) -> bool
+
+        Loads an image from a file. If no handler type is provided, the
+        library will try to autodetect the format.
+        """
         return _core_.Image_LoadFile(*args, **kwargs)
 
     def LoadMimeFile(*args, **kwargs):
         return _core_.Image_LoadFile(*args, **kwargs)
 
     def LoadMimeFile(*args, **kwargs):
-        """LoadMimeFile(self, String name, String mimetype, int index=-1) -> bool"""
+        """
+        LoadMimeFile(self, String name, String mimetype, int index=-1) -> bool
+
+        Loads an image from a file, specifying the image type with a MIME type
+        string.
+        """
         return _core_.Image_LoadMimeFile(*args, **kwargs)
 
     def SaveFile(*args, **kwargs):
         return _core_.Image_LoadMimeFile(*args, **kwargs)
 
     def SaveFile(*args, **kwargs):
-        """SaveFile(self, String name, int type) -> bool"""
+        """
+        SaveFile(self, String name, int type) -> bool
+
+        Saves an image in the named file.
+        """
         return _core_.Image_SaveFile(*args, **kwargs)
 
     def SaveMimeFile(*args, **kwargs):
         return _core_.Image_SaveFile(*args, **kwargs)
 
     def SaveMimeFile(*args, **kwargs):
-        """SaveMimeFile(self, String name, String mimetype) -> bool"""
+        """
+        SaveMimeFile(self, String name, String mimetype) -> bool
+
+        Saves an image in the named file.
+        """
         return _core_.Image_SaveMimeFile(*args, **kwargs)
 
     def CanReadStream(*args, **kwargs):
         return _core_.Image_SaveMimeFile(*args, **kwargs)
 
     def CanReadStream(*args, **kwargs):
-        """CanReadStream(InputStream stream) -> bool"""
+        """
+        CanReadStream(InputStream stream) -> bool
+
+        Returns True if the image handlers can read an image file from the
+        data currently on the input stream, or a readable Python file-like
+        object.
+        """
         return _core_.Image_CanReadStream(*args, **kwargs)
 
     CanReadStream = staticmethod(CanReadStream)
     def LoadStream(*args, **kwargs):
         return _core_.Image_CanReadStream(*args, **kwargs)
 
     CanReadStream = staticmethod(CanReadStream)
     def LoadStream(*args, **kwargs):
-        """LoadStream(self, InputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> bool"""
+        """
+        LoadStream(self, InputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> bool
+
+        Loads an image from an input stream or a readable Python file-like
+        object. If no handler type is provided, the library will try to
+        autodetect the format.
+        """
         return _core_.Image_LoadStream(*args, **kwargs)
 
     def LoadMimeStream(*args, **kwargs):
         return _core_.Image_LoadStream(*args, **kwargs)
 
     def LoadMimeStream(*args, **kwargs):
-        """LoadMimeStream(self, InputStream stream, String mimetype, int index=-1) -> bool"""
+        """
+        LoadMimeStream(self, InputStream stream, String mimetype, int index=-1) -> bool
+
+        Loads an image from an input stream or a readable Python file-like
+        object, using a MIME type string to specify the image file format.
+        """
         return _core_.Image_LoadMimeStream(*args, **kwargs)
 
     def Ok(*args, **kwargs):
         return _core_.Image_LoadMimeStream(*args, **kwargs)
 
     def Ok(*args, **kwargs):
-        """Ok(self) -> bool"""
+        """
+        Ok(self) -> bool
+
+        Returns true if image data is present.
+        """
         return _core_.Image_Ok(*args, **kwargs)
 
     def GetWidth(*args, **kwargs):
         return _core_.Image_Ok(*args, **kwargs)
 
     def GetWidth(*args, **kwargs):
-        """GetWidth(self) -> int"""
+        """
+        GetWidth(self) -> int
+
+        Gets the width of the image in pixels.
+        """
         return _core_.Image_GetWidth(*args, **kwargs)
 
     def GetHeight(*args, **kwargs):
         return _core_.Image_GetWidth(*args, **kwargs)
 
     def GetHeight(*args, **kwargs):
-        """GetHeight(self) -> int"""
+        """
+        GetHeight(self) -> int
+
+        Gets the height of the image in pixels.
+        """
         return _core_.Image_GetHeight(*args, **kwargs)
 
     def GetSize(*args, **kwargs):
         return _core_.Image_GetHeight(*args, **kwargs)
 
     def GetSize(*args, **kwargs):
-        """GetSize(self) -> Size"""
+        """
+        GetSize(self) -> Size
+
+        Returns the size of the image in pixels.
+        """
         return _core_.Image_GetSize(*args, **kwargs)
 
     def GetSubImage(*args, **kwargs):
         return _core_.Image_GetSize(*args, **kwargs)
 
     def GetSubImage(*args, **kwargs):
-        """GetSubImage(self, Rect rect) -> Image"""
+        """
+        GetSubImage(self, Rect rect) -> Image
+
+        Returns a sub image of the current one as long as the rect belongs
+        entirely to the image.
+        """
         return _core_.Image_GetSubImage(*args, **kwargs)
 
         return _core_.Image_GetSubImage(*args, **kwargs)
 
+    def Size(*args, **kwargs):
+        """
+        Size(self, Size size, Point pos, int r=-1, int g=-1, int b=-1) -> Image
+
+        Returns a resized version of this image without scaling it by adding
+        either a border with the given colour or cropping as necessary. The
+        image is pasted into a new image with the given size and background
+        colour at the position ``pos`` relative to the upper left of the new
+        image. If red = green = blue = -1 then use either the current mask
+        colour if set or find, use, and set a suitable mask colour for any
+        newly exposed areas.
+        """
+        return _core_.Image_Size(*args, **kwargs)
+
     def Copy(*args, **kwargs):
     def Copy(*args, **kwargs):
-        """Copy(self) -> Image"""
+        """
+        Copy(self) -> Image
+
+        Returns an identical copy of the image.
+        """
         return _core_.Image_Copy(*args, **kwargs)
 
     def Paste(*args, **kwargs):
         return _core_.Image_Copy(*args, **kwargs)
 
     def Paste(*args, **kwargs):
-        """Paste(self, Image image, int x, int y)"""
+        """
+        Paste(self, Image image, int x, int y)
+
+        Pastes ``image`` into this instance and takes care of the mask colour
+        and any out of bounds problems.
+        """
         return _core_.Image_Paste(*args, **kwargs)
 
     def GetData(*args, **kwargs):
         return _core_.Image_Paste(*args, **kwargs)
 
     def GetData(*args, **kwargs):
-        """GetData(self) -> PyObject"""
+        """
+        GetData(self) -> PyObject
+
+        Returns a string containing a copy of the RGB bytes of the image.
+        """
         return _core_.Image_GetData(*args, **kwargs)
 
     def SetData(*args, **kwargs):
         return _core_.Image_GetData(*args, **kwargs)
 
     def SetData(*args, **kwargs):
-        """SetData(self, PyObject data)"""
+        """
+        SetData(self, buffer data)
+
+        Resets the Image's RGB data from a buffer of RGB bytes.  Accepts
+        either a string or a buffer object holding the data and the length of
+        the data must be width*height*3.
+        """
         return _core_.Image_SetData(*args, **kwargs)
 
     def GetDataBuffer(*args, **kwargs):
         return _core_.Image_SetData(*args, **kwargs)
 
     def GetDataBuffer(*args, **kwargs):
-        """GetDataBuffer(self) -> PyObject"""
+        """
+        GetDataBuffer(self) -> PyObject
+
+        Returns a writable Python buffer object that is pointing at the RGB
+        image data buffer inside the wx.Image. You need to ensure that you do
+        not use this buffer object after the image has been destroyed.
+        """
         return _core_.Image_GetDataBuffer(*args, **kwargs)
 
     def SetDataBuffer(*args, **kwargs):
         return _core_.Image_GetDataBuffer(*args, **kwargs)
 
     def SetDataBuffer(*args, **kwargs):
-        """SetDataBuffer(self, PyObject data)"""
+        """
+        SetDataBuffer(self, buffer data)
+
+        Sets the internal image data pointer to point at a Python buffer
+        object.  This can save making an extra copy of the data but you must
+        ensure that the buffer object lives longer than the wx.Image does.
+        """
         return _core_.Image_SetDataBuffer(*args, **kwargs)
 
     def GetAlphaData(*args, **kwargs):
         return _core_.Image_SetDataBuffer(*args, **kwargs)
 
     def GetAlphaData(*args, **kwargs):
-        """GetAlphaData(self) -> PyObject"""
+        """
+        GetAlphaData(self) -> PyObject
+
+        Returns a string containing a copy of the alpha bytes of the image.
+        """
         return _core_.Image_GetAlphaData(*args, **kwargs)
 
     def SetAlphaData(*args, **kwargs):
         return _core_.Image_GetAlphaData(*args, **kwargs)
 
     def SetAlphaData(*args, **kwargs):
-        """SetAlphaData(self, PyObject data)"""
+        """
+        SetAlphaData(self, buffer alpha)
+
+        Resets the Image's alpha data from a buffer of bytes.  Accepts either
+        a string or a buffer object holding the data and the length of the
+        data must be width*height.
+        """
         return _core_.Image_SetAlphaData(*args, **kwargs)
 
     def GetAlphaBuffer(*args, **kwargs):
         return _core_.Image_SetAlphaData(*args, **kwargs)
 
     def GetAlphaBuffer(*args, **kwargs):
@@ -2306,77 +2694,160 @@ class Image(Object):
         return _core_.Image_GetAlphaBuffer(*args, **kwargs)
 
     def SetAlphaBuffer(*args, **kwargs):
         return _core_.Image_GetAlphaBuffer(*args, **kwargs)
 
     def SetAlphaBuffer(*args, **kwargs):
-        """SetAlphaBuffer(self, PyObject data)"""
+        """SetAlphaBuffer(self, buffer alpha)"""
         return _core_.Image_SetAlphaBuffer(*args, **kwargs)
 
     def SetMaskColour(*args, **kwargs):
         return _core_.Image_SetAlphaBuffer(*args, **kwargs)
 
     def SetMaskColour(*args, **kwargs):
-        """SetMaskColour(self, unsigned char r, unsigned char g, unsigned char b)"""
+        """
+        SetMaskColour(self, byte r, byte g, byte b)
+
+        Sets the mask colour for this image (and tells the image to use the
+        mask).
+        """
         return _core_.Image_SetMaskColour(*args, **kwargs)
 
         return _core_.Image_SetMaskColour(*args, **kwargs)
 
+    def GetOrFindMaskColour(*args, **kwargs):
+        """
+        GetOrFindMaskColour() -> (r,g,b)
+
+        Get the current mask colour or find a suitable colour.
+        """
+        return _core_.Image_GetOrFindMaskColour(*args, **kwargs)
+
     def GetMaskRed(*args, **kwargs):
     def GetMaskRed(*args, **kwargs):
-        """GetMaskRed(self) -> unsigned char"""
+        """
+        GetMaskRed(self) -> byte
+
+        Gets the red component of the mask colour.
+        """
         return _core_.Image_GetMaskRed(*args, **kwargs)
 
     def GetMaskGreen(*args, **kwargs):
         return _core_.Image_GetMaskRed(*args, **kwargs)
 
     def GetMaskGreen(*args, **kwargs):
-        """GetMaskGreen(self) -> unsigned char"""
+        """
+        GetMaskGreen(self) -> byte
+
+        Gets the green component of the mask colour.
+        """
         return _core_.Image_GetMaskGreen(*args, **kwargs)
 
     def GetMaskBlue(*args, **kwargs):
         return _core_.Image_GetMaskGreen(*args, **kwargs)
 
     def GetMaskBlue(*args, **kwargs):
-        """GetMaskBlue(self) -> unsigned char"""
+        """
+        GetMaskBlue(self) -> byte
+
+        Gets the blue component of the mask colour.
+        """
         return _core_.Image_GetMaskBlue(*args, **kwargs)
 
     def SetMask(*args, **kwargs):
         return _core_.Image_GetMaskBlue(*args, **kwargs)
 
     def SetMask(*args, **kwargs):
-        """SetMask(self, bool mask=True)"""
+        """
+        SetMask(self, bool mask=True)
+
+        Specifies whether there is a mask or not. The area of the mask is
+        determined by the current mask colour.
+        """
         return _core_.Image_SetMask(*args, **kwargs)
 
     def HasMask(*args, **kwargs):
         return _core_.Image_SetMask(*args, **kwargs)
 
     def HasMask(*args, **kwargs):
-        """HasMask(self) -> bool"""
+        """
+        HasMask(self) -> bool
+
+        Returns ``True`` if there is a mask active, ``False`` otherwise.
+        """
         return _core_.Image_HasMask(*args, **kwargs)
 
     def Rotate(*args, **kwargs):
         """
         Rotate(self, double angle, Point centre_of_rotation, bool interpolating=True, 
             Point offset_after_rotation=None) -> Image
         return _core_.Image_HasMask(*args, **kwargs)
 
     def Rotate(*args, **kwargs):
         """
         Rotate(self, double angle, Point centre_of_rotation, bool interpolating=True, 
             Point offset_after_rotation=None) -> Image
+
+        Rotates the image about the given point, by ``angle`` radians. Passing
+        ``True`` to ``interpolating`` results in better image quality, but is
+        slower. If the image has a mask, then the mask colour is used for the
+        uncovered pixels in the rotated image background. Otherwise, black
+        will be used as the fill colour.
+
+        Returns the rotated image, leaving this image intact.
         """
         return _core_.Image_Rotate(*args, **kwargs)
 
     def Rotate90(*args, **kwargs):
         """
         return _core_.Image_Rotate(*args, **kwargs)
 
     def Rotate90(*args, **kwargs):
-        """Rotate90(self, bool clockwise=True) -> Image"""
+        """
+        Rotate90(self, bool clockwise=True) -> Image
+
+        Returns a copy of the image rotated 90 degrees in the direction
+        indicated by ``clockwise``.
+        """
         return _core_.Image_Rotate90(*args, **kwargs)
 
     def Mirror(*args, **kwargs):
         return _core_.Image_Rotate90(*args, **kwargs)
 
     def Mirror(*args, **kwargs):
-        """Mirror(self, bool horizontally=True) -> Image"""
+        """
+        Mirror(self, bool horizontally=True) -> Image
+
+        Returns a mirrored copy of the image. The parameter ``horizontally``
+        indicates the orientation.
+        """
         return _core_.Image_Mirror(*args, **kwargs)
 
     def Replace(*args, **kwargs):
         """
         return _core_.Image_Mirror(*args, **kwargs)
 
     def Replace(*args, **kwargs):
         """
-        Replace(self, unsigned char r1, unsigned char g1, unsigned char b1, 
-            unsigned char r2, unsigned char g2, unsigned char b2)
+        Replace(self, byte r1, byte g1, byte b1, byte r2, byte g2, byte b2)
+
+        Replaces the colour specified by ``(r1,g1,b1)`` by the colour
+        ``(r2,g2,b2)``.
         """
         return _core_.Image_Replace(*args, **kwargs)
 
     def ConvertToMono(*args, **kwargs):
         """
         return _core_.Image_Replace(*args, **kwargs)
 
     def ConvertToMono(*args, **kwargs):
-        """ConvertToMono(self, unsigned char r, unsigned char g, unsigned char b) -> Image"""
+        """
+        ConvertToMono(self, byte r, byte g, byte b) -> Image
+
+        Returns monochromatic version of the image. The returned image has
+        white colour where the original has ``(r,g,b)`` colour and black
+        colour everywhere else.
+        """
         return _core_.Image_ConvertToMono(*args, **kwargs)
 
     def SetOption(*args, **kwargs):
         return _core_.Image_ConvertToMono(*args, **kwargs)
 
     def SetOption(*args, **kwargs):
-        """SetOption(self, String name, String value)"""
+        """
+        SetOption(self, String name, String value)
+
+        Sets an image handler defined option.  For example, when saving as a
+        JPEG file, the option ``wx.IMAGE_OPTION_QUALITY`` is used, which is a
+        number between 0 and 100 (0 is terrible, 100 is very good).
+        """
         return _core_.Image_SetOption(*args, **kwargs)
 
     def SetOptionInt(*args, **kwargs):
         return _core_.Image_SetOption(*args, **kwargs)
 
     def SetOptionInt(*args, **kwargs):
-        """SetOptionInt(self, String name, int value)"""
+        """
+        SetOptionInt(self, String name, int value)
+
+        Sets an image option as an integer.
+        """
         return _core_.Image_SetOptionInt(*args, **kwargs)
 
     def GetOption(*args, **kwargs):
         return _core_.Image_SetOptionInt(*args, **kwargs)
 
     def GetOption(*args, **kwargs):
-        """GetOption(self, String name) -> String"""
+        """
+        GetOption(self, String name) -> String
+
+        Gets the value of an image handler option.
+        """
         return _core_.Image_GetOption(*args, **kwargs)
 
     def GetOptionInt(*args, **kwargs):
         return _core_.Image_GetOption(*args, **kwargs)
 
     def GetOptionInt(*args, **kwargs):
-        """GetOptionInt(self, String name) -> int"""
+        """
+        GetOptionInt(self, String name) -> int
+
+        Gets the value of an image handler option as an integer.  If the given
+        option is not present, the function returns 0.
+        """
         return _core_.Image_GetOptionInt(*args, **kwargs)
 
     def HasOption(*args, **kwargs):
         return _core_.Image_GetOptionInt(*args, **kwargs)
 
     def HasOption(*args, **kwargs):
-        """HasOption(self, String name) -> bool"""
+        """
+        HasOption(self, String name) -> bool
+
+        Returns true if the given option is present.
+        """
         return _core_.Image_HasOption(*args, **kwargs)
 
     def CountColours(*args, **kwargs):
         return _core_.Image_HasOption(*args, **kwargs)
 
     def CountColours(*args, **kwargs):
@@ -2403,7 +2874,13 @@ class Image(Object):
 
     RemoveHandler = staticmethod(RemoveHandler)
     def GetImageExtWildcard(*args, **kwargs):
 
     RemoveHandler = staticmethod(RemoveHandler)
     def GetImageExtWildcard(*args, **kwargs):
-        """GetImageExtWildcard() -> String"""
+        """
+        GetImageExtWildcard() -> String
+
+        Iterates all registered wxImageHandler objects, and returns a string
+        containing file extension masks suitable for passing to file open/save
+        dialog boxes.
+        """
         return _core_.Image_GetImageExtWildcard(*args, **kwargs)
 
     GetImageExtWildcard = staticmethod(GetImageExtWildcard)
         return _core_.Image_GetImageExtWildcard(*args, **kwargs)
 
     GetImageExtWildcard = staticmethod(GetImageExtWildcard)
@@ -2412,7 +2889,7 @@ class Image(Object):
         return _core_.Image_ConvertToBitmap(*args, **kwargs)
 
     def ConvertToMonoBitmap(*args, **kwargs):
         return _core_.Image_ConvertToBitmap(*args, **kwargs)
 
     def ConvertToMonoBitmap(*args, **kwargs):
-        """ConvertToMonoBitmap(self, unsigned char red, unsigned char green, unsigned char blue) -> Bitmap"""
+        """ConvertToMonoBitmap(self, byte red, byte green, byte blue) -> Bitmap"""
         return _core_.Image_ConvertToMonoBitmap(*args, **kwargs)
 
     def __nonzero__(self): return self.Ok() 
         return _core_.Image_ConvertToMonoBitmap(*args, **kwargs)
 
     def __nonzero__(self): return self.Ok() 
@@ -2425,57 +2902,110 @@ class ImagePtr(Image):
 _core_.Image_swigregister(ImagePtr)
 
 def ImageFromMime(*args, **kwargs):
 _core_.Image_swigregister(ImagePtr)
 
 def ImageFromMime(*args, **kwargs):
-    """ImageFromMime(String name, String mimetype, int index=-1) -> Image"""
+    """
+    ImageFromMime(String name, String mimetype, int index=-1) -> Image
+
+    Loads an image from a file, using a MIME type string (such as
+    'image/jpeg') to specify image type.
+    """
     val = _core_.new_ImageFromMime(*args, **kwargs)
     val.thisown = 1
     return val
 
 def ImageFromStream(*args, **kwargs):
     val = _core_.new_ImageFromMime(*args, **kwargs)
     val.thisown = 1
     return val
 
 def ImageFromStream(*args, **kwargs):
-    """ImageFromStream(InputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> Image"""
+    """
+    ImageFromStream(InputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> Image
+
+    Loads an image from an input stream, or any readable Python file-like
+    object.
+    """
     val = _core_.new_ImageFromStream(*args, **kwargs)
     val.thisown = 1
     return val
 
 def ImageFromStreamMime(*args, **kwargs):
     val = _core_.new_ImageFromStream(*args, **kwargs)
     val.thisown = 1
     return val
 
 def ImageFromStreamMime(*args, **kwargs):
-    """ImageFromStreamMime(InputStream stream, String mimetype, int index=-1) -> Image"""
+    """
+    ImageFromStreamMime(InputStream stream, String mimetype, int index=-1) -> Image
+
+    Loads an image from an input stream, or any readable Python file-like
+    object, specifying the image format with a MIME type string.
+    """
     val = _core_.new_ImageFromStreamMime(*args, **kwargs)
     val.thisown = 1
     return val
 
 def EmptyImage(*args, **kwargs):
     val = _core_.new_ImageFromStreamMime(*args, **kwargs)
     val.thisown = 1
     return val
 
 def EmptyImage(*args, **kwargs):
-    """EmptyImage(int width=0, int height=0, bool clear=True) -> Image"""
+    """
+    EmptyImage(int width=0, int height=0, bool clear=True) -> Image
+
+    Construct an empty image of a given size, optionally setting all
+    pixels to black.
+    """
     val = _core_.new_EmptyImage(*args, **kwargs)
     val.thisown = 1
     return val
 
 def ImageFromBitmap(*args, **kwargs):
     val = _core_.new_EmptyImage(*args, **kwargs)
     val.thisown = 1
     return val
 
 def ImageFromBitmap(*args, **kwargs):
-    """ImageFromBitmap(Bitmap bitmap) -> Image"""
+    """
+    ImageFromBitmap(Bitmap bitmap) -> Image
+
+    Construct an Image from a `wx.Bitmap`.
+    """
     val = _core_.new_ImageFromBitmap(*args, **kwargs)
     val.thisown = 1
     return val
 
 def ImageFromData(*args, **kwargs):
     val = _core_.new_ImageFromBitmap(*args, **kwargs)
     val.thisown = 1
     return val
 
 def ImageFromData(*args, **kwargs):
-    """ImageFromData(int width, int height, unsigned char data) -> Image"""
+    """
+    ImageFromData(int width, int height, buffer data) -> Image
+
+    Construct an Image from a buffer of RGB bytes.  Accepts either a
+    string or a buffer object holding the data and the length of the data
+    must be width*height*3.
+    """
     val = _core_.new_ImageFromData(*args, **kwargs)
     val.thisown = 1
     return val
 
 def ImageFromDataWithAlpha(*args, **kwargs):
     val = _core_.new_ImageFromData(*args, **kwargs)
     val.thisown = 1
     return val
 
 def ImageFromDataWithAlpha(*args, **kwargs):
-    """ImageFromDataWithAlpha(int width, int height, unsigned char data, unsigned char alpha) -> Image"""
+    """
+    ImageFromDataWithAlpha(int width, int height, buffer data, buffer alpha) -> Image
+
+    Construct an Image from a buffer of RGB bytes with an Alpha channel.
+    Accepts either a string or a buffer object holding the data and the
+    length of the data must be width*height*3 bytes, and the length of the
+    alpha data must be width*height bytes.
+    """
     val = _core_.new_ImageFromDataWithAlpha(*args, **kwargs)
     val.thisown = 1
     return val
 
 def Image_CanRead(*args, **kwargs):
     val = _core_.new_ImageFromDataWithAlpha(*args, **kwargs)
     val.thisown = 1
     return val
 
 def Image_CanRead(*args, **kwargs):
-    """Image_CanRead(String name) -> bool"""
+    """
+    Image_CanRead(String filename) -> bool
+
+    Returns True if the image handlers can read this file.
+    """
     return _core_.Image_CanRead(*args, **kwargs)
 
 def Image_GetImageCount(*args, **kwargs):
     return _core_.Image_CanRead(*args, **kwargs)
 
 def Image_GetImageCount(*args, **kwargs):
-    """Image_GetImageCount(String name, long type=BITMAP_TYPE_ANY) -> int"""
+    """
+    Image_GetImageCount(String filename, long type=BITMAP_TYPE_ANY) -> int
+
+    If the image file contains more than one image and the image handler
+    is capable of retrieving these individually, this function will return
+    the number of available images.
+    """
     return _core_.Image_GetImageCount(*args, **kwargs)
 
 def Image_CanReadStream(*args, **kwargs):
     return _core_.Image_GetImageCount(*args, **kwargs)
 
 def Image_CanReadStream(*args, **kwargs):
-    """Image_CanReadStream(InputStream stream) -> bool"""
+    """
+    Image_CanReadStream(InputStream stream) -> bool
+
+    Returns True if the image handlers can read an image file from the
+    data currently on the input stream, or a readable Python file-like
+    object.
+    """
     return _core_.Image_CanReadStream(*args, **kwargs)
 
 def Image_AddHandler(*args, **kwargs):
     return _core_.Image_CanReadStream(*args, **kwargs)
 
 def Image_AddHandler(*args, **kwargs):
@@ -2491,7 +3021,13 @@ def Image_RemoveHandler(*args, **kwargs):
     return _core_.Image_RemoveHandler(*args, **kwargs)
 
 def Image_GetImageExtWildcard(*args, **kwargs):
     return _core_.Image_RemoveHandler(*args, **kwargs)
 
 def Image_GetImageExtWildcard(*args, **kwargs):
-    """Image_GetImageExtWildcard() -> String"""
+    """
+    Image_GetImageExtWildcard() -> String
+
+    Iterates all registered wxImageHandler objects, and returns a string
+    containing file extension masks suitable for passing to file open/save
+    dialog boxes.
+    """
     return _core_.Image_GetImageExtWildcard(*args, **kwargs)
 
 def InitAllImageHandlers():
     return _core_.Image_GetImageExtWildcard(*args, **kwargs)
 
 def InitAllImageHandlers():
@@ -2503,6 +3039,9 @@ def InitAllImageHandlers():
 
 IMAGE_RESOLUTION_INCHES = _core_.IMAGE_RESOLUTION_INCHES
 IMAGE_RESOLUTION_CM = _core_.IMAGE_RESOLUTION_CM
 
 IMAGE_RESOLUTION_INCHES = _core_.IMAGE_RESOLUTION_INCHES
 IMAGE_RESOLUTION_CM = _core_.IMAGE_RESOLUTION_CM
+PNG_TYPE_COLOUR = _core_.PNG_TYPE_COLOUR
+PNG_TYPE_GREY = _core_.PNG_TYPE_GREY
+PNG_TYPE_GREY_RED = _core_.PNG_TYPE_GREY_RED
 BMP_24BPP = _core_.BMP_24BPP
 BMP_8BPP = _core_.BMP_8BPP
 BMP_8BPP_GREY = _core_.BMP_8BPP_GREY
 BMP_24BPP = _core_.BMP_24BPP
 BMP_8BPP = _core_.BMP_8BPP
 BMP_8BPP_GREY = _core_.BMP_8BPP_GREY
@@ -2513,11 +3052,15 @@ BMP_4BPP = _core_.BMP_4BPP
 BMP_1BPP = _core_.BMP_1BPP
 BMP_1BPP_BW = _core_.BMP_1BPP_BW
 class BMPHandler(ImageHandler):
 BMP_1BPP = _core_.BMP_1BPP
 BMP_1BPP_BW = _core_.BMP_1BPP_BW
 class BMPHandler(ImageHandler):
-    """Proxy of C++ BMPHandler class"""
+    """A `wx.ImageHandler` for \*.bmp bitmap files."""
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxBMPHandler 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++ wxBMPHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self) -> BMPHandler"""
+        """
+        __init__(self) -> BMPHandler
+
+        A `wx.ImageHandler` for \*.bmp bitmap files.
+        """
         newobj = _core_.new_BMPHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_BMPHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -2530,19 +3073,33 @@ class BMPHandlerPtr(BMPHandler):
         self.__class__ = BMPHandler
 _core_.BMPHandler_swigregister(BMPHandlerPtr)
 NullImage = cvar.NullImage
         self.__class__ = BMPHandler
 _core_.BMPHandler_swigregister(BMPHandlerPtr)
 NullImage = cvar.NullImage
+IMAGE_OPTION_FILENAME = cvar.IMAGE_OPTION_FILENAME
 IMAGE_OPTION_BMP_FORMAT = cvar.IMAGE_OPTION_BMP_FORMAT
 IMAGE_OPTION_CUR_HOTSPOT_X = cvar.IMAGE_OPTION_CUR_HOTSPOT_X
 IMAGE_OPTION_CUR_HOTSPOT_Y = cvar.IMAGE_OPTION_CUR_HOTSPOT_Y
 IMAGE_OPTION_RESOLUTION = cvar.IMAGE_OPTION_RESOLUTION
 IMAGE_OPTION_BMP_FORMAT = cvar.IMAGE_OPTION_BMP_FORMAT
 IMAGE_OPTION_CUR_HOTSPOT_X = cvar.IMAGE_OPTION_CUR_HOTSPOT_X
 IMAGE_OPTION_CUR_HOTSPOT_Y = cvar.IMAGE_OPTION_CUR_HOTSPOT_Y
 IMAGE_OPTION_RESOLUTION = cvar.IMAGE_OPTION_RESOLUTION
+IMAGE_OPTION_RESOLUTIONX = cvar.IMAGE_OPTION_RESOLUTIONX
+IMAGE_OPTION_RESOLUTIONY = cvar.IMAGE_OPTION_RESOLUTIONY
 IMAGE_OPTION_RESOLUTIONUNIT = cvar.IMAGE_OPTION_RESOLUTIONUNIT
 IMAGE_OPTION_RESOLUTIONUNIT = cvar.IMAGE_OPTION_RESOLUTIONUNIT
+IMAGE_OPTION_QUALITY = cvar.IMAGE_OPTION_QUALITY
+IMAGE_OPTION_BITSPERSAMPLE = cvar.IMAGE_OPTION_BITSPERSAMPLE
+IMAGE_OPTION_SAMPLESPERPIXEL = cvar.IMAGE_OPTION_SAMPLESPERPIXEL
+IMAGE_OPTION_COMPRESSION = cvar.IMAGE_OPTION_COMPRESSION
+IMAGE_OPTION_IMAGEDESCRIPTOR = cvar.IMAGE_OPTION_IMAGEDESCRIPTOR
+IMAGE_OPTION_PNG_FORMAT = cvar.IMAGE_OPTION_PNG_FORMAT
+IMAGE_OPTION_PNG_BITDEPTH = cvar.IMAGE_OPTION_PNG_BITDEPTH
 
 class ICOHandler(BMPHandler):
 
 class ICOHandler(BMPHandler):
-    """Proxy of C++ ICOHandler class"""
+    """A `wx.ImageHandler` for \*.ico icon files."""
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxICOHandler 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++ wxICOHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self) -> ICOHandler"""
-        newobj = _core_.new_ICOHandler(*args, **kwargs)
+        """
+        __init__(self) -> ICOHandler
+
+        A `wx.ImageHandler` for \*.ico icon files.
+        """
+        newobj = _core_.new_ICOHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
@@ -2555,11 +3112,15 @@ class ICOHandlerPtr(ICOHandler):
 _core_.ICOHandler_swigregister(ICOHandlerPtr)
 
 class CURHandler(ICOHandler):
 _core_.ICOHandler_swigregister(ICOHandlerPtr)
 
 class CURHandler(ICOHandler):
-    """Proxy of C++ CURHandler class"""
+    """A `wx.ImageHandler` for \*.cur cursor files."""
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxCURHandler 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++ wxCURHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self) -> CURHandler"""
+        """
+        __init__(self) -> CURHandler
+
+        A `wx.ImageHandler` for \*.cur cursor files.
+        """
         newobj = _core_.new_CURHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_CURHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -2573,11 +3134,15 @@ class CURHandlerPtr(CURHandler):
 _core_.CURHandler_swigregister(CURHandlerPtr)
 
 class ANIHandler(CURHandler):
 _core_.CURHandler_swigregister(CURHandlerPtr)
 
 class ANIHandler(CURHandler):
-    """Proxy of C++ ANIHandler class"""
+    """A `wx.ImageHandler` for \*.ani animated cursor files."""
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxANIHandler 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++ wxANIHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self) -> ANIHandler"""
+        """
+        __init__(self) -> ANIHandler
+
+        A `wx.ImageHandler` for \*.ani animated cursor files.
+        """
         newobj = _core_.new_ANIHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_ANIHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -2591,11 +3156,15 @@ class ANIHandlerPtr(ANIHandler):
 _core_.ANIHandler_swigregister(ANIHandlerPtr)
 
 class PNGHandler(ImageHandler):
 _core_.ANIHandler_swigregister(ANIHandlerPtr)
 
 class PNGHandler(ImageHandler):
-    """Proxy of C++ PNGHandler class"""
+    """A `wx.ImageHandler` for PNG image files."""
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxPNGHandler 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++ wxPNGHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self) -> PNGHandler"""
+        """
+        __init__(self) -> PNGHandler
+
+        A `wx.ImageHandler` for PNG image files.
+        """
         newobj = _core_.new_PNGHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_PNGHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -2609,11 +3178,15 @@ class PNGHandlerPtr(PNGHandler):
 _core_.PNGHandler_swigregister(PNGHandlerPtr)
 
 class GIFHandler(ImageHandler):
 _core_.PNGHandler_swigregister(PNGHandlerPtr)
 
 class GIFHandler(ImageHandler):
-    """Proxy of C++ GIFHandler class"""
+    """A `wx.ImageHandler` for GIF image files."""
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxGIFHandler 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++ wxGIFHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self) -> GIFHandler"""
+        """
+        __init__(self) -> GIFHandler
+
+        A `wx.ImageHandler` for GIF image files.
+        """
         newobj = _core_.new_GIFHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_GIFHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -2627,11 +3200,15 @@ class GIFHandlerPtr(GIFHandler):
 _core_.GIFHandler_swigregister(GIFHandlerPtr)
 
 class PCXHandler(ImageHandler):
 _core_.GIFHandler_swigregister(GIFHandlerPtr)
 
 class PCXHandler(ImageHandler):
-    """Proxy of C++ PCXHandler class"""
+    """A `wx.ImageHandler` for PCX imager files."""
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxPCXHandler 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++ wxPCXHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self) -> PCXHandler"""
+        """
+        __init__(self) -> PCXHandler
+
+        A `wx.ImageHandler` for PCX imager files.
+        """
         newobj = _core_.new_PCXHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_PCXHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -2645,11 +3222,15 @@ class PCXHandlerPtr(PCXHandler):
 _core_.PCXHandler_swigregister(PCXHandlerPtr)
 
 class JPEGHandler(ImageHandler):
 _core_.PCXHandler_swigregister(PCXHandlerPtr)
 
 class JPEGHandler(ImageHandler):
-    """Proxy of C++ JPEGHandler class"""
+    """A `wx.ImageHandler` for JPEG/JPG image files."""
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxJPEGHandler 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++ wxJPEGHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self) -> JPEGHandler"""
+        """
+        __init__(self) -> JPEGHandler
+
+        A `wx.ImageHandler` for JPEG/JPG image files.
+        """
         newobj = _core_.new_JPEGHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_JPEGHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -2663,11 +3244,15 @@ class JPEGHandlerPtr(JPEGHandler):
 _core_.JPEGHandler_swigregister(JPEGHandlerPtr)
 
 class PNMHandler(ImageHandler):
 _core_.JPEGHandler_swigregister(JPEGHandlerPtr)
 
 class PNMHandler(ImageHandler):
-    """Proxy of C++ PNMHandler class"""
+    """A `wx.ImageHandler` for PNM image files."""
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxPNMHandler 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++ wxPNMHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self) -> PNMHandler"""
+        """
+        __init__(self) -> PNMHandler
+
+        A `wx.ImageHandler` for PNM image files.
+        """
         newobj = _core_.new_PNMHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_PNMHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -2681,11 +3266,15 @@ class PNMHandlerPtr(PNMHandler):
 _core_.PNMHandler_swigregister(PNMHandlerPtr)
 
 class XPMHandler(ImageHandler):
 _core_.PNMHandler_swigregister(PNMHandlerPtr)
 
 class XPMHandler(ImageHandler):
-    """Proxy of C++ XPMHandler class"""
+    """A `wx.ImageHandler` for XPM image."""
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxXPMHandler 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++ wxXPMHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self) -> XPMHandler"""
+        """
+        __init__(self) -> XPMHandler
+
+        A `wx.ImageHandler` for XPM image.
+        """
         newobj = _core_.new_XPMHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_XPMHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -2699,11 +3288,15 @@ class XPMHandlerPtr(XPMHandler):
 _core_.XPMHandler_swigregister(XPMHandlerPtr)
 
 class TIFFHandler(ImageHandler):
 _core_.XPMHandler_swigregister(XPMHandlerPtr)
 
 class TIFFHandler(ImageHandler):
-    """Proxy of C++ TIFFHandler class"""
+    """A `wx.ImageHandler` for TIFF image files."""
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxTIFFHandler 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++ wxTIFFHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self) -> TIFFHandler"""
+        """
+        __init__(self) -> TIFFHandler
+
+        A `wx.ImageHandler` for TIFF image files.
+        """
         newobj = _core_.new_TIFFHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_TIFFHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -2996,7 +3589,8 @@ wxEVT_SCROLL_PAGEUP = _core_.wxEVT_SCROLL_PAGEUP
 wxEVT_SCROLL_PAGEDOWN = _core_.wxEVT_SCROLL_PAGEDOWN
 wxEVT_SCROLL_THUMBTRACK = _core_.wxEVT_SCROLL_THUMBTRACK
 wxEVT_SCROLL_THUMBRELEASE = _core_.wxEVT_SCROLL_THUMBRELEASE
 wxEVT_SCROLL_PAGEDOWN = _core_.wxEVT_SCROLL_PAGEDOWN
 wxEVT_SCROLL_THUMBTRACK = _core_.wxEVT_SCROLL_THUMBTRACK
 wxEVT_SCROLL_THUMBRELEASE = _core_.wxEVT_SCROLL_THUMBRELEASE
-wxEVT_SCROLL_ENDSCROLL = _core_.wxEVT_SCROLL_ENDSCROLL
+wxEVT_SCROLL_CHANGED = _core_.wxEVT_SCROLL_CHANGED
+wxEVT_SCROLL_ENDSCROLL = wxEVT_SCROLL_CHANGED 
 wxEVT_SCROLLWIN_TOP = _core_.wxEVT_SCROLLWIN_TOP
 wxEVT_SCROLLWIN_BOTTOM = _core_.wxEVT_SCROLLWIN_BOTTOM
 wxEVT_SCROLLWIN_LINEUP = _core_.wxEVT_SCROLLWIN_LINEUP
 wxEVT_SCROLLWIN_TOP = _core_.wxEVT_SCROLLWIN_TOP
 wxEVT_SCROLLWIN_BOTTOM = _core_.wxEVT_SCROLLWIN_BOTTOM
 wxEVT_SCROLLWIN_LINEUP = _core_.wxEVT_SCROLLWIN_LINEUP
@@ -3041,6 +3635,7 @@ wxEVT_IDLE = _core_.wxEVT_IDLE
 wxEVT_UPDATE_UI = _core_.wxEVT_UPDATE_UI
 wxEVT_SIZING = _core_.wxEVT_SIZING
 wxEVT_MOVING = _core_.wxEVT_MOVING
 wxEVT_UPDATE_UI = _core_.wxEVT_UPDATE_UI
 wxEVT_SIZING = _core_.wxEVT_SIZING
 wxEVT_MOVING = _core_.wxEVT_MOVING
+wxEVT_HIBERNATE = _core_.wxEVT_HIBERNATE
 wxEVT_COMMAND_LEFT_CLICK = _core_.wxEVT_COMMAND_LEFT_CLICK
 wxEVT_COMMAND_LEFT_DCLICK = _core_.wxEVT_COMMAND_LEFT_DCLICK
 wxEVT_COMMAND_RIGHT_CLICK = _core_.wxEVT_COMMAND_RIGHT_CLICK
 wxEVT_COMMAND_LEFT_CLICK = _core_.wxEVT_COMMAND_LEFT_CLICK
 wxEVT_COMMAND_LEFT_DCLICK = _core_.wxEVT_COMMAND_LEFT_DCLICK
 wxEVT_COMMAND_RIGHT_CLICK = _core_.wxEVT_COMMAND_RIGHT_CLICK
@@ -3074,6 +3669,7 @@ EVT_KILL_FOCUS = wx.PyEventBinder( wxEVT_KILL_FOCUS )
 EVT_CHILD_FOCUS = wx.PyEventBinder( wxEVT_CHILD_FOCUS )
 EVT_ACTIVATE = wx.PyEventBinder( wxEVT_ACTIVATE )
 EVT_ACTIVATE_APP = wx.PyEventBinder( wxEVT_ACTIVATE_APP )
 EVT_CHILD_FOCUS = wx.PyEventBinder( wxEVT_CHILD_FOCUS )
 EVT_ACTIVATE = wx.PyEventBinder( wxEVT_ACTIVATE )
 EVT_ACTIVATE_APP = wx.PyEventBinder( wxEVT_ACTIVATE_APP )
+EVT_HIBERNATE = wx.PyEventBinder( wxEVT_HIBERNATE )     
 EVT_END_SESSION = wx.PyEventBinder( wxEVT_END_SESSION )
 EVT_QUERY_END_SESSION = wx.PyEventBinder( wxEVT_QUERY_END_SESSION )
 EVT_DROP_FILES = wx.PyEventBinder( wxEVT_DROP_FILES )
 EVT_END_SESSION = wx.PyEventBinder( wxEVT_END_SESSION )
 EVT_QUERY_END_SESSION = wx.PyEventBinder( wxEVT_QUERY_END_SESSION )
 EVT_DROP_FILES = wx.PyEventBinder( wxEVT_DROP_FILES )
@@ -3141,7 +3737,7 @@ EVT_SCROLLWIN_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLLWIN_PAGEDOWN )
 EVT_SCROLLWIN_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBTRACK )
 EVT_SCROLLWIN_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBRELEASE )
 
 EVT_SCROLLWIN_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBTRACK )
 EVT_SCROLLWIN_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBRELEASE )
 
-# Scrolling from wxSlider and wxScrollBar
+# Scrolling from wx.Slider and wx.ScrollBar
 EVT_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP, 
                                wxEVT_SCROLL_BOTTOM, 
                                wxEVT_SCROLL_LINEUP, 
 EVT_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP, 
                                wxEVT_SCROLL_BOTTOM, 
                                wxEVT_SCROLL_LINEUP, 
@@ -3150,7 +3746,7 @@ EVT_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
                                wxEVT_SCROLL_PAGEDOWN, 
                                wxEVT_SCROLL_THUMBTRACK, 
                                wxEVT_SCROLL_THUMBRELEASE, 
                                wxEVT_SCROLL_PAGEDOWN, 
                                wxEVT_SCROLL_THUMBTRACK, 
                                wxEVT_SCROLL_THUMBRELEASE, 
-                               wxEVT_SCROLL_ENDSCROLL,
+                               wxEVT_SCROLL_CHANGED,
                                ])
 
 EVT_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP )
                                ])
 
 EVT_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP )
@@ -3161,9 +3757,10 @@ EVT_SCROLL_PAGEUP = wx.PyEventBinder( wxEVT_SCROLL_PAGEUP )
 EVT_SCROLL_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN )
 EVT_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK )
 EVT_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE )
 EVT_SCROLL_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN )
 EVT_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK )
 EVT_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE )
-EVT_SCROLL_ENDSCROLL = wx.PyEventBinder( wxEVT_SCROLL_ENDSCROLL )
-
-# Scrolling from wxSlider and wxScrollBar, with an id
+EVT_SCROLL_CHANGED = wx.PyEventBinder( wxEVT_SCROLL_CHANGED )
+EVT_SCROLL_ENDSCROLL = EVT_SCROLL_CHANGED
+     
+# Scrolling from wx.Slider and wx.ScrollBar, with an id
 EVT_COMMAND_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP, 
                                        wxEVT_SCROLL_BOTTOM, 
                                        wxEVT_SCROLL_LINEUP, 
 EVT_COMMAND_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP, 
                                        wxEVT_SCROLL_BOTTOM, 
                                        wxEVT_SCROLL_LINEUP, 
@@ -3172,7 +3769,7 @@ EVT_COMMAND_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
                                        wxEVT_SCROLL_PAGEDOWN, 
                                        wxEVT_SCROLL_THUMBTRACK, 
                                        wxEVT_SCROLL_THUMBRELEASE,
                                        wxEVT_SCROLL_PAGEDOWN, 
                                        wxEVT_SCROLL_THUMBTRACK, 
                                        wxEVT_SCROLL_THUMBRELEASE,
-                                       wxEVT_SCROLL_ENDSCROLL,
+                                       wxEVT_SCROLL_CHANGED,
                                        ], 1)
 
 EVT_COMMAND_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP, 1)
                                        ], 1)
 
 EVT_COMMAND_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP, 1)
@@ -3183,7 +3780,8 @@ EVT_COMMAND_SCROLL_PAGEUP = wx.PyEventBinder( wxEVT_SCROLL_PAGEUP, 1)
 EVT_COMMAND_SCROLL_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN, 1)
 EVT_COMMAND_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK, 1)
 EVT_COMMAND_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE, 1)
 EVT_COMMAND_SCROLL_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN, 1)
 EVT_COMMAND_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK, 1)
 EVT_COMMAND_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE, 1)
-EVT_COMMAND_SCROLL_ENDSCROLL = wx.PyEventBinder( wxEVT_SCROLL_ENDSCROLL, 1)
+EVT_COMMAND_SCROLL_CHANGED = wx.PyEventBinder( wxEVT_SCROLL_CHANGED, 1)
+EVT_COMMAND_SCROLL_ENDSCROLL = EVT_COMMAND_SCROLL_CHANGED
 
 EVT_BUTTON = wx.PyEventBinder( wxEVT_COMMAND_BUTTON_CLICKED, 1)
 EVT_CHECKBOX = wx.PyEventBinder( wxEVT_COMMAND_CHECKBOX_CLICKED, 1)
 
 EVT_BUTTON = wx.PyEventBinder( wxEVT_COMMAND_BUTTON_CLICKED, 1)
 EVT_CHECKBOX = wx.PyEventBinder( wxEVT_COMMAND_CHECKBOX_CLICKED, 1)
@@ -3227,7 +3825,11 @@ EVT_CONTEXT_MENU = wx.PyEventBinder( wxEVT_CONTEXT_MENU )
 #---------------------------------------------------------------------------
 
 class Event(Object):
 #---------------------------------------------------------------------------
 
 class Event(Object):
-    """Proxy of C++ Event class"""
+    """
+    An event is a structure holding information about an event passed to a
+    callback or member function. wx.Event is an abstract base class for
+    other event classes
+    """
     def __init__(self): raise RuntimeError, "No constructor defined"
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxEvent 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++ wxEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
@@ -3238,19 +3840,38 @@ class Event(Object):
         except: pass
 
     def SetEventType(*args, **kwargs):
         except: pass
 
     def SetEventType(*args, **kwargs):
-        """SetEventType(self, wxEventType typ)"""
+        """
+        SetEventType(self, wxEventType typ)
+
+        Sets the specific type of the event.
+        """
         return _core_.Event_SetEventType(*args, **kwargs)
 
     def GetEventType(*args, **kwargs):
         return _core_.Event_SetEventType(*args, **kwargs)
 
     def GetEventType(*args, **kwargs):
-        """GetEventType(self) -> wxEventType"""
+        """
+        GetEventType(self) -> wxEventType
+
+        Returns the identifier of the given event type, such as
+        ``wxEVT_COMMAND_BUTTON_CLICKED``.
+        """
         return _core_.Event_GetEventType(*args, **kwargs)
 
     def GetEventObject(*args, **kwargs):
         return _core_.Event_GetEventType(*args, **kwargs)
 
     def GetEventObject(*args, **kwargs):
-        """GetEventObject(self) -> Object"""
+        """
+        GetEventObject(self) -> Object
+
+        Returns the object (usually a window) associated with the event, if
+        any.
+        """
         return _core_.Event_GetEventObject(*args, **kwargs)
 
     def SetEventObject(*args, **kwargs):
         return _core_.Event_GetEventObject(*args, **kwargs)
 
     def SetEventObject(*args, **kwargs):
-        """SetEventObject(self, Object obj)"""
+        """
+        SetEventObject(self, Object obj)
+
+        Sets the originating object, or in other words, obj is normally the
+        object that is sending the event.
+        """
         return _core_.Event_SetEventObject(*args, **kwargs)
 
     def GetTimestamp(*args, **kwargs):
         return _core_.Event_SetEventObject(*args, **kwargs)
 
     def GetTimestamp(*args, **kwargs):
@@ -3262,35 +3883,85 @@ class Event(Object):
         return _core_.Event_SetTimestamp(*args, **kwargs)
 
     def GetId(*args, **kwargs):
         return _core_.Event_SetTimestamp(*args, **kwargs)
 
     def GetId(*args, **kwargs):
-        """GetId(self) -> int"""
+        """
+        GetId(self) -> int
+
+        Returns the identifier associated with this event, such as a button
+        command id.
+        """
         return _core_.Event_GetId(*args, **kwargs)
 
     def SetId(*args, **kwargs):
         return _core_.Event_GetId(*args, **kwargs)
 
     def SetId(*args, **kwargs):
-        """SetId(self, int Id)"""
+        """
+        SetId(self, int Id)
+
+        Set's the ID for the event.  This is usually the ID of the window that
+        is sending the event, but it can also be a command id from a menu
+        item, etc.
+        """
         return _core_.Event_SetId(*args, **kwargs)
 
     def IsCommandEvent(*args, **kwargs):
         return _core_.Event_SetId(*args, **kwargs)
 
     def IsCommandEvent(*args, **kwargs):
-        """IsCommandEvent(self) -> bool"""
+        """
+        IsCommandEvent(self) -> bool
+
+        Returns true if the event is or is derived from `wx.CommandEvent` else
+        it returns false. Note: Exists only for optimization purposes.
+        """
         return _core_.Event_IsCommandEvent(*args, **kwargs)
 
     def Skip(*args, **kwargs):
         return _core_.Event_IsCommandEvent(*args, **kwargs)
 
     def Skip(*args, **kwargs):
-        """Skip(self, bool skip=True)"""
+        """
+        Skip(self, bool skip=True)
+
+        Called by an event handler, it controls whether additional event
+        handlers bound to this event will be called after the current event
+        handler returns.  Skip(false) (the default setting) will prevent
+        additional event handlers from being called and control will be
+        returned to the sender of the event immediately after the current
+        handler has finished.  Skip(True) will cause the event processing
+        system to continue searching for a handler function for this event.
+
+        """
         return _core_.Event_Skip(*args, **kwargs)
 
     def GetSkipped(*args, **kwargs):
         return _core_.Event_Skip(*args, **kwargs)
 
     def GetSkipped(*args, **kwargs):
-        """GetSkipped(self) -> bool"""
+        """
+        GetSkipped(self) -> bool
+
+        Returns true if the event handler should be skipped, false otherwise.
+        :see: `Skip`
+        """
         return _core_.Event_GetSkipped(*args, **kwargs)
 
     def ShouldPropagate(*args, **kwargs):
         return _core_.Event_GetSkipped(*args, **kwargs)
 
     def ShouldPropagate(*args, **kwargs):
-        """ShouldPropagate(self) -> bool"""
+        """
+        ShouldPropagate(self) -> bool
+
+        Test if this event should be propagated to the parent window or not,
+        i.e. if the propagation level is currently greater than 0.
+        """
         return _core_.Event_ShouldPropagate(*args, **kwargs)
 
     def StopPropagation(*args, **kwargs):
         return _core_.Event_ShouldPropagate(*args, **kwargs)
 
     def StopPropagation(*args, **kwargs):
-        """StopPropagation(self) -> int"""
+        """
+        StopPropagation(self) -> int
+
+        Stop the event from propagating to its parent window.  Returns the old
+        propagation level value which may be later passed to
+        `ResumePropagation` to allow propagating the event again.
+        """
         return _core_.Event_StopPropagation(*args, **kwargs)
 
     def ResumePropagation(*args, **kwargs):
         return _core_.Event_StopPropagation(*args, **kwargs)
 
     def ResumePropagation(*args, **kwargs):
-        """ResumePropagation(self, int propagationLevel)"""
+        """
+        ResumePropagation(self, int propagationLevel)
+
+        Resume the event propagation by restoring the propagation level.  (For
+        example, you can use the value returned by an earlier call to
+        `StopPropagation`.)
+
+        """
         return _core_.Event_ResumePropagation(*args, **kwargs)
 
     def Clone(*args, **kwargs):
         return _core_.Event_ResumePropagation(*args, **kwargs)
 
     def Clone(*args, **kwargs):
@@ -3308,11 +3979,21 @@ _core_.Event_swigregister(EventPtr)
 #---------------------------------------------------------------------------
 
 class PropagationDisabler(object):
 #---------------------------------------------------------------------------
 
 class PropagationDisabler(object):
-    """Proxy of C++ PropagationDisabler class"""
+    """
+    Helper class to temporarily change an event not to propagate.  Simply
+    create an instance of this class and then whe it is destroyed the
+    propogation of the event will be restored.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxPropagationDisabler 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++ wxPropagationDisabler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, Event event) -> PropagationDisabler"""
+        """
+        __init__(self, Event event) -> PropagationDisabler
+
+        Helper class to temporarily change an event not to propagate.  Simply
+        create an instance of this class and then whe it is destroyed the
+        propogation of the event will be restored.
+        """
         newobj = _core_.new_PropagationDisabler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_PropagationDisabler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -3332,11 +4013,21 @@ class PropagationDisablerPtr(PropagationDisabler):
 _core_.PropagationDisabler_swigregister(PropagationDisablerPtr)
 
 class PropagateOnce(object):
 _core_.PropagationDisabler_swigregister(PropagationDisablerPtr)
 
 class PropagateOnce(object):
-    """Proxy of C++ PropagateOnce class"""
+    """
+    A helper class that will temporarily lower propagation level of an
+    event.  Simply create an instance of this class and then whe it is
+    destroyed the propogation of the event will be restored.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxPropagateOnce 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++ wxPropagateOnce instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, Event event) -> PropagateOnce"""
+        """
+        __init__(self, Event event) -> PropagateOnce
+
+        A helper class that will temporarily lower propagation level of an
+        event.  Simply create an instance of this class and then whe it is
+        destroyed the propogation of the event will be restored.
+        """
         newobj = _core_.new_PropagateOnce(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_PropagateOnce(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -3358,17 +4049,32 @@ _core_.PropagateOnce_swigregister(PropagateOncePtr)
 #---------------------------------------------------------------------------
 
 class CommandEvent(Event):
 #---------------------------------------------------------------------------
 
 class CommandEvent(Event):
-    """Proxy of C++ CommandEvent class"""
+    """
+    This event class contains information about command events, which
+    originate from a variety of simple controls, as well as menus and
+    toolbars.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxCommandEvent 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++ wxCommandEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, wxEventType commandType=wxEVT_NULL, int winid=0) -> CommandEvent"""
+        """
+        __init__(self, wxEventType commandType=wxEVT_NULL, int winid=0) -> CommandEvent
+
+        This event class contains information about command events, which
+        originate from a variety of simple controls, as well as menus and
+        toolbars.
+        """
         newobj = _core_.new_CommandEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetSelection(*args, **kwargs):
         newobj = _core_.new_CommandEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetSelection(*args, **kwargs):
-        """GetSelection(self) -> int"""
+        """
+        GetSelection(self) -> int
+
+        Returns item index for a listbox or choice selection event (not valid
+        for a deselection).
+        """
         return _core_.CommandEvent_GetSelection(*args, **kwargs)
 
     def SetString(*args, **kwargs):
         return _core_.CommandEvent_GetSelection(*args, **kwargs)
 
     def SetString(*args, **kwargs):
@@ -3376,16 +4082,34 @@ class CommandEvent(Event):
         return _core_.CommandEvent_SetString(*args, **kwargs)
 
     def GetString(*args, **kwargs):
         return _core_.CommandEvent_SetString(*args, **kwargs)
 
     def GetString(*args, **kwargs):
-        """GetString(self) -> String"""
+        """
+        GetString(self) -> String
+
+        Returns item string for a listbox or choice selection event (not valid
+        for a deselection).
+        """
         return _core_.CommandEvent_GetString(*args, **kwargs)
 
     def IsChecked(*args, **kwargs):
         return _core_.CommandEvent_GetString(*args, **kwargs)
 
     def IsChecked(*args, **kwargs):
-        """IsChecked(self) -> bool"""
+        """
+        IsChecked(self) -> bool
+
+        This method can be used with checkbox and menu events: for the
+        checkboxes, the method returns true for a selection event and false
+        for a deselection one. For the menu events, this method indicates if
+        the menu item just has become checked or unchecked (and thus only
+        makes sense for checkable menu items).
+        """
         return _core_.CommandEvent_IsChecked(*args, **kwargs)
 
     Checked = IsChecked 
     def IsSelection(*args, **kwargs):
         return _core_.CommandEvent_IsChecked(*args, **kwargs)
 
     Checked = IsChecked 
     def IsSelection(*args, **kwargs):
-        """IsSelection(self) -> bool"""
+        """
+        IsSelection(self) -> bool
+
+        For a listbox or similar event, returns true if it is a selection,
+        false if it is a deselection.
+        """
         return _core_.CommandEvent_IsSelection(*args, **kwargs)
 
     def SetExtraLong(*args, **kwargs):
         return _core_.CommandEvent_IsSelection(*args, **kwargs)
 
     def SetExtraLong(*args, **kwargs):
@@ -3393,7 +4117,16 @@ class CommandEvent(Event):
         return _core_.CommandEvent_SetExtraLong(*args, **kwargs)
 
     def GetExtraLong(*args, **kwargs):
         return _core_.CommandEvent_SetExtraLong(*args, **kwargs)
 
     def GetExtraLong(*args, **kwargs):
-        """GetExtraLong(self) -> long"""
+        """
+        GetExtraLong(self) -> long
+
+        Returns extra information dependant on the event objects type. If the
+        event comes from a listbox selection, it is a boolean determining
+        whether the event was a selection (true) or a deselection (false). A
+        listbox deselection only occurs for multiple-selection boxes, and in
+        this case the index and string values are indeterminate and the
+        listbox must be examined by the application.
+        """
         return _core_.CommandEvent_GetExtraLong(*args, **kwargs)
 
     def SetInt(*args, **kwargs):
         return _core_.CommandEvent_GetExtraLong(*args, **kwargs)
 
     def SetInt(*args, **kwargs):
@@ -3401,7 +4134,13 @@ class CommandEvent(Event):
         return _core_.CommandEvent_SetInt(*args, **kwargs)
 
     def GetInt(*args, **kwargs):
         return _core_.CommandEvent_SetInt(*args, **kwargs)
 
     def GetInt(*args, **kwargs):
-        """GetInt(self) -> long"""
+        """
+        GetInt(self) -> long
+
+        Returns the integer identifier corresponding to a listbox, choice or
+        radiobox selection (only if the event was a selection, not a
+        deselection), or a boolean value representing the value of a checkbox.
+        """
         return _core_.CommandEvent_GetInt(*args, **kwargs)
 
     def Clone(*args, **kwargs):
         return _core_.CommandEvent_GetInt(*args, **kwargs)
 
     def Clone(*args, **kwargs):
@@ -3419,25 +4158,57 @@ _core_.CommandEvent_swigregister(CommandEventPtr)
 #---------------------------------------------------------------------------
 
 class NotifyEvent(CommandEvent):
 #---------------------------------------------------------------------------
 
 class NotifyEvent(CommandEvent):
-    """Proxy of C++ NotifyEvent class"""
+    """
+    An instance of this class (or one of its derived classes) is sent from
+    a control when the control's state is being changed and the control
+    allows that change to be prevented from happening.  The event handler
+    can call `Veto` or `Allow` to tell the control what to do.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxNotifyEvent 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++ wxNotifyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, wxEventType commandType=wxEVT_NULL, int winid=0) -> NotifyEvent"""
+        """
+        __init__(self, wxEventType commandType=wxEVT_NULL, int winid=0) -> NotifyEvent
+
+        An instance of this class (or one of its derived classes) is sent from
+        a control when the control's state is being changed and the control
+        allows that change to be prevented from happening.  The event handler
+        can call `Veto` or `Allow` to tell the control what to do.
+        """
         newobj = _core_.new_NotifyEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def Veto(*args, **kwargs):
         newobj = _core_.new_NotifyEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def Veto(*args, **kwargs):
-        """Veto(self)"""
+        """
+        Veto(self)
+
+        Prevents the change announced by this event from happening.
+
+        It is in general a good idea to notify the user about the reasons for
+        vetoing the change because otherwise the applications behaviour (which
+        just refuses to do what the user wants) might be quite surprising.
+        """
         return _core_.NotifyEvent_Veto(*args, **kwargs)
 
     def Allow(*args, **kwargs):
         return _core_.NotifyEvent_Veto(*args, **kwargs)
 
     def Allow(*args, **kwargs):
-        """Allow(self)"""
+        """
+        Allow(self)
+
+        This is the opposite of `Veto`: it explicitly allows the event to be
+        processed. For most events it is not necessary to call this method as
+        the events are allowed anyhow but some are forbidden by default (this
+        will be mentioned in the corresponding event description).
+        """
         return _core_.NotifyEvent_Allow(*args, **kwargs)
 
     def IsAllowed(*args, **kwargs):
         return _core_.NotifyEvent_Allow(*args, **kwargs)
 
     def IsAllowed(*args, **kwargs):
-        """IsAllowed(self) -> bool"""
+        """
+        IsAllowed(self) -> bool
+
+        Returns true if the change is allowed (`Veto` hasn't been called) or
+        false otherwise (if it was).
+        """
         return _core_.NotifyEvent_IsAllowed(*args, **kwargs)
 
 
         return _core_.NotifyEvent_IsAllowed(*args, **kwargs)
 
 
@@ -3451,7 +4222,12 @@ _core_.NotifyEvent_swigregister(NotifyEventPtr)
 #---------------------------------------------------------------------------
 
 class ScrollEvent(CommandEvent):
 #---------------------------------------------------------------------------
 
 class ScrollEvent(CommandEvent):
-    """Proxy of C++ ScrollEvent class"""
+    """
+    A scroll event holds information about events sent from stand-alone
+    scrollbars and sliders. Note that scrolled windows do not send
+    instnaces of this event class, but send the `wx.ScrollWinEvent`
+    instead.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxScrollEvent 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++ wxScrollEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
@@ -3464,11 +4240,20 @@ class ScrollEvent(CommandEvent):
         self.thisown = 1
         del newobj.thisown
     def GetOrientation(*args, **kwargs):
         self.thisown = 1
         del newobj.thisown
     def GetOrientation(*args, **kwargs):
-        """GetOrientation(self) -> int"""
+        """
+        GetOrientation(self) -> int
+
+        Returns wx.HORIZONTAL or wx.VERTICAL, depending on the orientation of
+        the scrollbar.
+        """
         return _core_.ScrollEvent_GetOrientation(*args, **kwargs)
 
     def GetPosition(*args, **kwargs):
         return _core_.ScrollEvent_GetOrientation(*args, **kwargs)
 
     def GetPosition(*args, **kwargs):
-        """GetPosition(self) -> int"""
+        """
+        GetPosition(self) -> int
+
+        Returns the position of the scrollbar.
+        """
         return _core_.ScrollEvent_GetPosition(*args, **kwargs)
 
     def SetOrientation(*args, **kwargs):
         return _core_.ScrollEvent_GetPosition(*args, **kwargs)
 
     def SetOrientation(*args, **kwargs):
@@ -3490,21 +4275,40 @@ _core_.ScrollEvent_swigregister(ScrollEventPtr)
 #---------------------------------------------------------------------------
 
 class ScrollWinEvent(Event):
 #---------------------------------------------------------------------------
 
 class ScrollWinEvent(Event):
-    """Proxy of C++ ScrollWinEvent class"""
+    """
+    A wx.ScrollWinEvent holds information about scrolling and is sent from
+    scrolling windows.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxScrollWinEvent 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++ wxScrollWinEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, wxEventType commandType=wxEVT_NULL, int pos=0, int orient=0) -> ScrollWinEvent"""
+        """
+        __init__(self, wxEventType commandType=wxEVT_NULL, int pos=0, int orient=0) -> ScrollWinEvent
+
+        A wx.ScrollWinEvent holds information about scrolling and is sent from
+        scrolling windows.
+        """
         newobj = _core_.new_ScrollWinEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetOrientation(*args, **kwargs):
         newobj = _core_.new_ScrollWinEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetOrientation(*args, **kwargs):
-        """GetOrientation(self) -> int"""
+        """
+        GetOrientation(self) -> int
+
+        Returns wx.HORIZONTAL or wx.VERTICAL, depending on the orientation of
+        the scrollbar.
+        """
         return _core_.ScrollWinEvent_GetOrientation(*args, **kwargs)
 
     def GetPosition(*args, **kwargs):
         return _core_.ScrollWinEvent_GetOrientation(*args, **kwargs)
 
     def GetPosition(*args, **kwargs):
-        """GetPosition(self) -> int"""
+        """
+        GetPosition(self) -> int
+
+        Returns the position of the scrollbar for the thumb track and release
+        events. Note that this field can't be used for the other events, you
+        need to query the window itself for the current position in that case.
+        """
         return _core_.ScrollWinEvent_GetPosition(*args, **kwargs)
 
     def SetOrientation(*args, **kwargs):
         return _core_.ScrollWinEvent_GetPosition(*args, **kwargs)
 
     def SetOrientation(*args, **kwargs):
@@ -3531,33 +4335,109 @@ MOUSE_BTN_LEFT = _core_.MOUSE_BTN_LEFT
 MOUSE_BTN_MIDDLE = _core_.MOUSE_BTN_MIDDLE
 MOUSE_BTN_RIGHT = _core_.MOUSE_BTN_RIGHT
 class MouseEvent(Event):
 MOUSE_BTN_MIDDLE = _core_.MOUSE_BTN_MIDDLE
 MOUSE_BTN_RIGHT = _core_.MOUSE_BTN_RIGHT
 class MouseEvent(Event):
-    """Proxy of C++ MouseEvent class"""
+    """
+    This event class contains information about the events generated by
+    the mouse: they include mouse buttons press and release events and
+    mouse move events.
+
+    All mouse events involving the buttons use ``wx.MOUSE_BTN_LEFT`` for
+    the left mouse button, ``wx.MOUSE_BTN_MIDDLE`` for the middle one and
+    ``wx.MOUSE_BTN_RIGHT`` for the right one. Note that not all mice have
+    a middle button so a portable application should avoid relying on the
+    events from it.
+
+    Note the difference between methods like `LeftDown` and `LeftIsDown`:
+    the former returns true when the event corresponds to the left mouse
+    button click while the latter returns true if the left mouse button is
+    currently being pressed. For example, when the user is dragging the
+    mouse you can use `LeftIsDown` to test whether the left mouse button
+    is (still) depressed. Also, by convention, if `LeftDown` returns true,
+    `LeftIsDown` will also return true in wxWidgets whatever the
+    underlying GUI behaviour is (which is platform-dependent). The same
+    applies, of course, to other mouse buttons as well.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxMouseEvent 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++ wxMouseEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, wxEventType mouseType=wxEVT_NULL) -> MouseEvent"""
+        """
+        __init__(self, wxEventType mouseType=wxEVT_NULL) -> MouseEvent
+
+        Constructs a wx.MouseEvent.  Valid event types are:
+
+            * wxEVT_ENTER_WINDOW
+            * wxEVT_LEAVE_WINDOW
+            * wxEVT_LEFT_DOWN
+            * wxEVT_LEFT_UP
+            * wxEVT_LEFT_DCLICK
+            * wxEVT_MIDDLE_DOWN
+            * wxEVT_MIDDLE_UP
+            * wxEVT_MIDDLE_DCLICK
+            * wxEVT_RIGHT_DOWN
+            * wxEVT_RIGHT_UP
+            * wxEVT_RIGHT_DCLICK
+            * wxEVT_MOTION
+            * wxEVT_MOUSEWHEEL 
+        """
         newobj = _core_.new_MouseEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def IsButton(*args, **kwargs):
         newobj = _core_.new_MouseEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def IsButton(*args, **kwargs):
-        """IsButton(self) -> bool"""
+        """
+        IsButton(self) -> bool
+
+        Returns true if the event was a mouse button event (not necessarily a
+        button down event - that may be tested using `ButtonDown`).
+        """
         return _core_.MouseEvent_IsButton(*args, **kwargs)
 
     def ButtonDown(*args, **kwargs):
         return _core_.MouseEvent_IsButton(*args, **kwargs)
 
     def ButtonDown(*args, **kwargs):
-        """ButtonDown(self, int but=MOUSE_BTN_ANY) -> bool"""
+        """
+        ButtonDown(self, int but=MOUSE_BTN_ANY) -> bool
+
+        If the argument is omitted, this returns true if the event was any
+        mouse button down event. Otherwise the argument specifies which
+        button-down event shold be checked for (see `Button` for the possible
+        values).
+        """
         return _core_.MouseEvent_ButtonDown(*args, **kwargs)
 
     def ButtonDClick(*args, **kwargs):
         return _core_.MouseEvent_ButtonDown(*args, **kwargs)
 
     def ButtonDClick(*args, **kwargs):
-        """ButtonDClick(self, int but=MOUSE_BTN_ANY) -> bool"""
+        """
+        ButtonDClick(self, int but=MOUSE_BTN_ANY) -> bool
+
+        If the argument is omitted, this returns true if the event was any
+        mouse double click event. Otherwise the argument specifies which
+        double click event to check for (see `Button` for the possible
+        values).
+        """
         return _core_.MouseEvent_ButtonDClick(*args, **kwargs)
 
     def ButtonUp(*args, **kwargs):
         return _core_.MouseEvent_ButtonDClick(*args, **kwargs)
 
     def ButtonUp(*args, **kwargs):
-        """ButtonUp(self, int but=MOUSE_BTN_ANY) -> bool"""
+        """
+        ButtonUp(self, int but=MOUSE_BTN_ANY) -> bool
+
+        If the argument is omitted, this returns true if the event was any
+        mouse button up event. Otherwise the argument specifies which button
+        up event to check for (see `Button` for the possible values).
+        """
         return _core_.MouseEvent_ButtonUp(*args, **kwargs)
 
     def Button(*args, **kwargs):
         return _core_.MouseEvent_ButtonUp(*args, **kwargs)
 
     def Button(*args, **kwargs):
-        """Button(self, int but) -> bool"""
+        """
+        Button(self, int button) -> bool
+
+        Returns true if the identified mouse button is changing state. Valid
+        values of button are:
+
+             ====================      =====================================
+             wx.MOUSE_BTN_LEFT         check if left button was pressed
+             wx.MOUSE_BTN_MIDDLE       check if middle button was pressed
+             wx.MOUSE_BTN_RIGHT        check if right button was pressed
+             wx.MOUSE_BTN_ANY          check if any button was pressed
+             ====================      =====================================
+
+        """
         return _core_.MouseEvent_Button(*args, **kwargs)
 
     def ButtonIsDown(*args, **kwargs):
         return _core_.MouseEvent_Button(*args, **kwargs)
 
     def ButtonIsDown(*args, **kwargs):
@@ -3565,23 +4445,48 @@ class MouseEvent(Event):
         return _core_.MouseEvent_ButtonIsDown(*args, **kwargs)
 
     def GetButton(*args, **kwargs):
         return _core_.MouseEvent_ButtonIsDown(*args, **kwargs)
 
     def GetButton(*args, **kwargs):
-        """GetButton(self) -> int"""
+        """
+        GetButton(self) -> int
+
+        Returns the mouse button which generated this event or
+        wx.MOUSE_BTN_NONE if no button is involved (for mouse move, enter or
+        leave event, for example). Otherwise wx.MOUSE_BTN_LEFT is returned for
+        the left button down, up and double click events, wx.MOUSE_BTN_MIDDLE
+        and wx.MOUSE_BTN_RIGHT for the same events for the middle and the
+        right buttons respectively.
+        """
         return _core_.MouseEvent_GetButton(*args, **kwargs)
 
     def ControlDown(*args, **kwargs):
         return _core_.MouseEvent_GetButton(*args, **kwargs)
 
     def ControlDown(*args, **kwargs):
-        """ControlDown(self) -> bool"""
+        """
+        ControlDown(self) -> bool
+
+        Returns true if the control key was down at the time of the event.
+        """
         return _core_.MouseEvent_ControlDown(*args, **kwargs)
 
     def MetaDown(*args, **kwargs):
         return _core_.MouseEvent_ControlDown(*args, **kwargs)
 
     def MetaDown(*args, **kwargs):
-        """MetaDown(self) -> bool"""
+        """
+        MetaDown(self) -> bool
+
+        Returns true if the Meta key was down at the time of the event.
+        """
         return _core_.MouseEvent_MetaDown(*args, **kwargs)
 
     def AltDown(*args, **kwargs):
         return _core_.MouseEvent_MetaDown(*args, **kwargs)
 
     def AltDown(*args, **kwargs):
-        """AltDown(self) -> bool"""
+        """
+        AltDown(self) -> bool
+
+        Returns true if the Alt key was down at the time of the event.
+        """
         return _core_.MouseEvent_AltDown(*args, **kwargs)
 
     def ShiftDown(*args, **kwargs):
         return _core_.MouseEvent_AltDown(*args, **kwargs)
 
     def ShiftDown(*args, **kwargs):
-        """ShiftDown(self) -> bool"""
+        """
+        ShiftDown(self) -> bool
+
+        Returns true if the Shift key was down at the time of the event.
+        """
         return _core_.MouseEvent_ShiftDown(*args, **kwargs)
 
     def CmdDown(*args, **kwargs):
         return _core_.MouseEvent_ShiftDown(*args, **kwargs)
 
     def CmdDown(*args, **kwargs):
@@ -3590,84 +4495,162 @@ class MouseEvent(Event):
 
         "Cmd" is a pseudo key which is the same as Control for PC and Unix
         platforms but the special "Apple" (a.k.a as "Command") key on
 
         "Cmd" is a pseudo key which is the same as Control for PC and Unix
         platforms but the special "Apple" (a.k.a as "Command") key on
-        Macs: it makes often sense to use it instead of, say, `ControlDown`
+        Macs. It often makes sense to use it instead of, say, `ControlDown`
         because Cmd key is used for the same thing under Mac as Ctrl
         because Cmd key is used for the same thing under Mac as Ctrl
-        elsewhere. The Ctrl still exists, it's just not used for this
+        elsewhere. The Ctrl key still exists, it's just not used for this
         purpose. So for non-Mac platforms this is the same as `ControlDown`
         and Macs this is the same as `MetaDown`.
         """
         return _core_.MouseEvent_CmdDown(*args, **kwargs)
 
     def LeftDown(*args, **kwargs):
         purpose. So for non-Mac platforms this is the same as `ControlDown`
         and Macs this is the same as `MetaDown`.
         """
         return _core_.MouseEvent_CmdDown(*args, **kwargs)
 
     def LeftDown(*args, **kwargs):
-        """LeftDown(self) -> bool"""
+        """
+        LeftDown(self) -> bool
+
+        Returns true if the left mouse button state changed to down.
+        """
         return _core_.MouseEvent_LeftDown(*args, **kwargs)
 
     def MiddleDown(*args, **kwargs):
         return _core_.MouseEvent_LeftDown(*args, **kwargs)
 
     def MiddleDown(*args, **kwargs):
-        """MiddleDown(self) -> bool"""
+        """
+        MiddleDown(self) -> bool
+
+        Returns true if the middle mouse button state changed to down.
+        """
         return _core_.MouseEvent_MiddleDown(*args, **kwargs)
 
     def RightDown(*args, **kwargs):
         return _core_.MouseEvent_MiddleDown(*args, **kwargs)
 
     def RightDown(*args, **kwargs):
-        """RightDown(self) -> bool"""
+        """
+        RightDown(self) -> bool
+
+        Returns true if the right mouse button state changed to down.
+        """
         return _core_.MouseEvent_RightDown(*args, **kwargs)
 
     def LeftUp(*args, **kwargs):
         return _core_.MouseEvent_RightDown(*args, **kwargs)
 
     def LeftUp(*args, **kwargs):
-        """LeftUp(self) -> bool"""
+        """
+        LeftUp(self) -> bool
+
+        Returns true if the left mouse button state changed to up.
+        """
         return _core_.MouseEvent_LeftUp(*args, **kwargs)
 
     def MiddleUp(*args, **kwargs):
         return _core_.MouseEvent_LeftUp(*args, **kwargs)
 
     def MiddleUp(*args, **kwargs):
-        """MiddleUp(self) -> bool"""
+        """
+        MiddleUp(self) -> bool
+
+        Returns true if the middle mouse button state changed to up.
+        """
         return _core_.MouseEvent_MiddleUp(*args, **kwargs)
 
     def RightUp(*args, **kwargs):
         return _core_.MouseEvent_MiddleUp(*args, **kwargs)
 
     def RightUp(*args, **kwargs):
-        """RightUp(self) -> bool"""
+        """
+        RightUp(self) -> bool
+
+        Returns true if the right mouse button state changed to up.
+        """
         return _core_.MouseEvent_RightUp(*args, **kwargs)
 
     def LeftDClick(*args, **kwargs):
         return _core_.MouseEvent_RightUp(*args, **kwargs)
 
     def LeftDClick(*args, **kwargs):
-        """LeftDClick(self) -> bool"""
+        """
+        LeftDClick(self) -> bool
+
+        Returns true if the event was a left button double click.
+        """
         return _core_.MouseEvent_LeftDClick(*args, **kwargs)
 
     def MiddleDClick(*args, **kwargs):
         return _core_.MouseEvent_LeftDClick(*args, **kwargs)
 
     def MiddleDClick(*args, **kwargs):
-        """MiddleDClick(self) -> bool"""
+        """
+        MiddleDClick(self) -> bool
+
+        Returns true if the event was a middle button double click.
+        """
         return _core_.MouseEvent_MiddleDClick(*args, **kwargs)
 
     def RightDClick(*args, **kwargs):
         return _core_.MouseEvent_MiddleDClick(*args, **kwargs)
 
     def RightDClick(*args, **kwargs):
-        """RightDClick(self) -> bool"""
+        """
+        RightDClick(self) -> bool
+
+        Returns true if the event was a right button double click.
+        """
         return _core_.MouseEvent_RightDClick(*args, **kwargs)
 
     def LeftIsDown(*args, **kwargs):
         return _core_.MouseEvent_RightDClick(*args, **kwargs)
 
     def LeftIsDown(*args, **kwargs):
-        """LeftIsDown(self) -> bool"""
+        """
+        LeftIsDown(self) -> bool
+
+        Returns true if the left mouse button is currently down, independent
+        of the current event type.
+
+        Please notice that it is not the same as LeftDown which returns true
+        if the left mouse button was just pressed. Rather, it describes the
+        state of the mouse button before the event happened.
+
+        This event is usually used in the mouse event handlers which process
+        "move mouse" messages to determine whether the user is (still)
+        dragging the mouse.
+        """
         return _core_.MouseEvent_LeftIsDown(*args, **kwargs)
 
     def MiddleIsDown(*args, **kwargs):
         return _core_.MouseEvent_LeftIsDown(*args, **kwargs)
 
     def MiddleIsDown(*args, **kwargs):
-        """MiddleIsDown(self) -> bool"""
+        """
+        MiddleIsDown(self) -> bool
+
+        Returns true if the middle mouse button is currently down, independent
+        of the current event type.
+        """
         return _core_.MouseEvent_MiddleIsDown(*args, **kwargs)
 
     def RightIsDown(*args, **kwargs):
         return _core_.MouseEvent_MiddleIsDown(*args, **kwargs)
 
     def RightIsDown(*args, **kwargs):
-        """RightIsDown(self) -> bool"""
+        """
+        RightIsDown(self) -> bool
+
+        Returns true if the right mouse button is currently down, independent
+        of the current event type.
+        """
         return _core_.MouseEvent_RightIsDown(*args, **kwargs)
 
     def Dragging(*args, **kwargs):
         return _core_.MouseEvent_RightIsDown(*args, **kwargs)
 
     def Dragging(*args, **kwargs):
-        """Dragging(self) -> bool"""
+        """
+        Dragging(self) -> bool
+
+        Returns true if this was a dragging event (motion while a button is
+        depressed).
+        """
         return _core_.MouseEvent_Dragging(*args, **kwargs)
 
     def Moving(*args, **kwargs):
         return _core_.MouseEvent_Dragging(*args, **kwargs)
 
     def Moving(*args, **kwargs):
-        """Moving(self) -> bool"""
+        """
+        Moving(self) -> bool
+
+        Returns true if this was a motion event and no mouse buttons were
+        pressed. If any mouse button is held pressed, then this method returns
+        false and Dragging returns true.
+        """
         return _core_.MouseEvent_Moving(*args, **kwargs)
 
     def Entering(*args, **kwargs):
         return _core_.MouseEvent_Moving(*args, **kwargs)
 
     def Entering(*args, **kwargs):
-        """Entering(self) -> bool"""
+        """
+        Entering(self) -> bool
+
+        Returns true if the mouse was entering the window.
+        """
         return _core_.MouseEvent_Entering(*args, **kwargs)
 
     def Leaving(*args, **kwargs):
         return _core_.MouseEvent_Entering(*args, **kwargs)
 
     def Leaving(*args, **kwargs):
-        """Leaving(self) -> bool"""
+        """
+        Leaving(self) -> bool
+
+        Returns true if the mouse was leaving the window.
+        """
         return _core_.MouseEvent_Leaving(*args, **kwargs)
 
     def GetPosition(*args, **kwargs):
         """
         GetPosition(self) -> Point
 
         return _core_.MouseEvent_Leaving(*args, **kwargs)
 
     def GetPosition(*args, **kwargs):
         """
         GetPosition(self) -> Point
 
-        Returns the position of the mouse in window coordinates when the event
-        happened.
+        Returns the pixel position of the mouse in window coordinates when the
+        event happened.
         """
         return _core_.MouseEvent_GetPosition(*args, **kwargs)
 
         """
         return _core_.MouseEvent_GetPosition(*args, **kwargs)
 
@@ -3675,38 +4658,78 @@ class MouseEvent(Event):
         """
         GetPositionTuple() -> (x,y)
 
         """
         GetPositionTuple() -> (x,y)
 
-        Returns the position of the mouse in window coordinates when the event
-        happened.
+        Returns the pixel position of the mouse in window coordinates when the
+        event happened.
         """
         return _core_.MouseEvent_GetPositionTuple(*args, **kwargs)
 
     def GetLogicalPosition(*args, **kwargs):
         """
         return _core_.MouseEvent_GetPositionTuple(*args, **kwargs)
 
     def GetLogicalPosition(*args, **kwargs):
-        """GetLogicalPosition(self, DC dc) -> Point"""
+        """
+        GetLogicalPosition(self, DC dc) -> Point
+
+        Returns the logical mouse position in pixels (i.e. translated
+        according to the translation set for the DC, which usually indicates
+        that the window has been scrolled).
+        """
         return _core_.MouseEvent_GetLogicalPosition(*args, **kwargs)
 
     def GetX(*args, **kwargs):
         return _core_.MouseEvent_GetLogicalPosition(*args, **kwargs)
 
     def GetX(*args, **kwargs):
-        """GetX(self) -> int"""
+        """
+        GetX(self) -> int
+
+        Returns X coordinate of the physical mouse event position.
+        """
         return _core_.MouseEvent_GetX(*args, **kwargs)
 
     def GetY(*args, **kwargs):
         return _core_.MouseEvent_GetX(*args, **kwargs)
 
     def GetY(*args, **kwargs):
-        """GetY(self) -> int"""
+        """
+        GetY(self) -> int
+
+        Returns Y coordinate of the physical mouse event position.
+        """
         return _core_.MouseEvent_GetY(*args, **kwargs)
 
     def GetWheelRotation(*args, **kwargs):
         return _core_.MouseEvent_GetY(*args, **kwargs)
 
     def GetWheelRotation(*args, **kwargs):
-        """GetWheelRotation(self) -> int"""
+        """
+        GetWheelRotation(self) -> int
+
+        Get wheel rotation, positive or negative indicates direction of
+        rotation. Current devices all send an event when rotation is equal to
+        +/-WheelDelta, but this allows for finer resolution devices to be
+        created in the future. Because of this you shouldn't assume that one
+        event is equal to 1 line or whatever, but you should be able to either
+        do partial line scrolling or wait until +/-WheelDelta rotation values
+        have been accumulated before scrolling.
+        """
         return _core_.MouseEvent_GetWheelRotation(*args, **kwargs)
 
     def GetWheelDelta(*args, **kwargs):
         return _core_.MouseEvent_GetWheelRotation(*args, **kwargs)
 
     def GetWheelDelta(*args, **kwargs):
-        """GetWheelDelta(self) -> int"""
+        """
+        GetWheelDelta(self) -> int
+
+        Get wheel delta, normally 120. This is the threshold for action to be
+        taken, and one such action (for example, scrolling one increment)
+        should occur for each delta.
+        """
         return _core_.MouseEvent_GetWheelDelta(*args, **kwargs)
 
     def GetLinesPerAction(*args, **kwargs):
         return _core_.MouseEvent_GetWheelDelta(*args, **kwargs)
 
     def GetLinesPerAction(*args, **kwargs):
-        """GetLinesPerAction(self) -> int"""
+        """
+        GetLinesPerAction(self) -> int
+
+        Returns the configured number of lines (or whatever) to be scrolled
+        per wheel action. Defaults to three.
+        """
         return _core_.MouseEvent_GetLinesPerAction(*args, **kwargs)
 
     def IsPageScroll(*args, **kwargs):
         return _core_.MouseEvent_GetLinesPerAction(*args, **kwargs)
 
     def IsPageScroll(*args, **kwargs):
-        """IsPageScroll(self) -> bool"""
-        return _core_.MouseEvent_IsPageScroll(*args, **kwargs)
+        """
+        IsPageScroll(self) -> bool
+
+        Returns true if the system has been setup to do page scrolling with
+        the mouse wheel instead of line scrolling.
+        """
+        return _core_.MouseEvent_IsPageScroll(*args, **kwargs)
 
     m_x = property(_core_.MouseEvent_m_x_get, _core_.MouseEvent_m_x_set)
     m_y = property(_core_.MouseEvent_m_y_get, _core_.MouseEvent_m_y_set)
 
     m_x = property(_core_.MouseEvent_m_x_get, _core_.MouseEvent_m_x_set)
     m_y = property(_core_.MouseEvent_m_y_get, _core_.MouseEvent_m_y_set)
@@ -3731,33 +4754,63 @@ _core_.MouseEvent_swigregister(MouseEventPtr)
 #---------------------------------------------------------------------------
 
 class SetCursorEvent(Event):
 #---------------------------------------------------------------------------
 
 class SetCursorEvent(Event):
-    """Proxy of C++ SetCursorEvent class"""
+    """
+    A SetCursorEvent is generated when the mouse cursor is about to be set
+    as a result of mouse motion. This event gives the application the
+    chance to perform specific mouse cursor processing based on the
+    current position of the mouse within the window. Use the `SetCursor`
+    method to specify the cursor you want to be displayed.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxSetCursorEvent 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++ wxSetCursorEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, int x=0, int y=0) -> SetCursorEvent"""
+        """
+        __init__(self, int x=0, int y=0) -> SetCursorEvent
+
+        Construct a new `wx.SetCursorEvent`.
+        """
         newobj = _core_.new_SetCursorEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetX(*args, **kwargs):
         newobj = _core_.new_SetCursorEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetX(*args, **kwargs):
-        """GetX(self) -> int"""
+        """
+        GetX(self) -> int
+
+        Returns the X coordinate of the mouse in client coordinates.
+        """
         return _core_.SetCursorEvent_GetX(*args, **kwargs)
 
     def GetY(*args, **kwargs):
         return _core_.SetCursorEvent_GetX(*args, **kwargs)
 
     def GetY(*args, **kwargs):
-        """GetY(self) -> int"""
+        """
+        GetY(self) -> int
+
+        Returns the Y coordinate of the mouse in client coordinates.
+        """
         return _core_.SetCursorEvent_GetY(*args, **kwargs)
 
     def SetCursor(*args, **kwargs):
         return _core_.SetCursorEvent_GetY(*args, **kwargs)
 
     def SetCursor(*args, **kwargs):
-        """SetCursor(self, Cursor cursor)"""
+        """
+        SetCursor(self, Cursor cursor)
+
+        Sets the cursor associated with this event.
+        """
         return _core_.SetCursorEvent_SetCursor(*args, **kwargs)
 
     def GetCursor(*args, **kwargs):
         return _core_.SetCursorEvent_SetCursor(*args, **kwargs)
 
     def GetCursor(*args, **kwargs):
-        """GetCursor(self) -> Cursor"""
+        """
+        GetCursor(self) -> Cursor
+
+        Returns a reference to the cursor specified by this event.
+        """
         return _core_.SetCursorEvent_GetCursor(*args, **kwargs)
 
     def HasCursor(*args, **kwargs):
         return _core_.SetCursorEvent_GetCursor(*args, **kwargs)
 
     def HasCursor(*args, **kwargs):
-        """HasCursor(self) -> bool"""
+        """
+        HasCursor(self) -> bool
+
+        Returns true if the cursor specified by this event is a valid cursor.
+        """
         return _core_.SetCursorEvent_HasCursor(*args, **kwargs)
 
 
         return _core_.SetCursorEvent_HasCursor(*args, **kwargs)
 
 
@@ -3771,29 +4824,111 @@ _core_.SetCursorEvent_swigregister(SetCursorEventPtr)
 #---------------------------------------------------------------------------
 
 class KeyEvent(Event):
 #---------------------------------------------------------------------------
 
 class KeyEvent(Event):
-    """Proxy of C++ KeyEvent class"""
+    """
+    This event class contains information about keypress and character
+    events.  These events are only sent to the widget that currently has
+    the keyboard focus.
+
+    Notice that there are three different kinds of keyboard events in
+    wxWidgets: key down and up events and char events. The difference
+    between the first two is clear - the first corresponds to a key press
+    and the second to a key release - otherwise they are identical. Just
+    note that if the key is maintained in a pressed state you will
+    typically get a lot of (automatically generated) down events but only
+    one up so it is wrong to assume that there is one up event
+    corresponding to each down one.
+
+    Both key events provide untranslated key codes while the char event
+    carries the translated one. The untranslated code for alphanumeric
+    keys is always an upper case value. For the other keys it is one of
+    WXK_XXX values from the keycodes table. The translated key is, in
+    general, the character the user expects to appear as the result of the
+    key combination when typing the text into a text entry zone, for
+    example.
+
+    A few examples to clarify this (all assume that CAPS LOCK is unpressed
+    and the standard US keyboard): when the 'A' key is pressed, the key
+    down event key code is equal to ASCII A == 65. But the char event key
+    code is ASCII a == 97. On the other hand, if you press both SHIFT and
+    'A' keys simultaneously , the key code in key down event will still be
+    just 'A' while the char event key code parameter will now be 'A' as
+    well.
+
+    Although in this simple case it is clear that the correct key code
+    could be found in the key down event handler by checking the value
+    returned by `ShiftDown`, in general you should use EVT_CHAR for this
+    as for non alphanumeric keys or non-US keyboard layouts the
+    translation is keyboard-layout dependent and can only be done properly
+    by the system itself.
+
+    Another kind of translation is done when the control key is pressed:
+    for example, for CTRL-A key press the key down event still carries the
+    same key code 'A' as usual but the char event will have key code of 1,
+    the ASCII value of this key combination.
+
+    You may discover how the other keys on your system behave
+    interactively by running the KeyEvents sample in the wxPython demo and
+    pressing some keys while the blue box at the top has the keyboard
+    focus.
+
+    **Note**: If a key down event is caught and the event handler does not
+    call event.Skip() then the coresponding char event will not
+    happen. This is by design and enables the programs that handle both
+    types of events to be a bit simpler.
+
+    **Note for Windows programmers**: The key and char events in wxWidgets
+    are similar to but slightly different from Windows WM_KEYDOWN and
+    WM_CHAR events. In particular, Alt-x combination will generate a char
+    event in wxWidgets (unless it is used as an accelerator).
+
+    **Tip**: be sure to call event.Skip() for events that you don't
+    process in key event function, otherwise menu shortcuts may cease to
+    work under Windows.
+
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxKeyEvent 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++ wxKeyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, wxEventType keyType=wxEVT_NULL) -> KeyEvent"""
+        """
+        __init__(self, wxEventType eventType=wxEVT_NULL) -> KeyEvent
+
+        Construct a new `wx.KeyEvent`.  Valid event types are:
+            * 
+        """
         newobj = _core_.new_KeyEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def ControlDown(*args, **kwargs):
         newobj = _core_.new_KeyEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def ControlDown(*args, **kwargs):
-        """ControlDown(self) -> bool"""
+        """
+        ControlDown(self) -> bool
+
+        Returns ``True`` if the Control key was down at the time of the event.
+        """
         return _core_.KeyEvent_ControlDown(*args, **kwargs)
 
     def MetaDown(*args, **kwargs):
         return _core_.KeyEvent_ControlDown(*args, **kwargs)
 
     def MetaDown(*args, **kwargs):
-        """MetaDown(self) -> bool"""
+        """
+        MetaDown(self) -> bool
+
+        Returns ``True`` if the Meta key was down at the time of the event.
+        """
         return _core_.KeyEvent_MetaDown(*args, **kwargs)
 
     def AltDown(*args, **kwargs):
         return _core_.KeyEvent_MetaDown(*args, **kwargs)
 
     def AltDown(*args, **kwargs):
-        """AltDown(self) -> bool"""
+        """
+        AltDown(self) -> bool
+
+        Returns ``True`` if the Alt key was down at the time of the event.
+        """
         return _core_.KeyEvent_AltDown(*args, **kwargs)
 
     def ShiftDown(*args, **kwargs):
         return _core_.KeyEvent_AltDown(*args, **kwargs)
 
     def ShiftDown(*args, **kwargs):
-        """ShiftDown(self) -> bool"""
+        """
+        ShiftDown(self) -> bool
+
+        Returns ``True`` if the Shift key was down at the time of the event.
+        """
         return _core_.KeyEvent_ShiftDown(*args, **kwargs)
 
     def CmdDown(*args, **kwargs):
         return _core_.KeyEvent_ShiftDown(*args, **kwargs)
 
     def CmdDown(*args, **kwargs):
@@ -3802,7 +4937,7 @@ class KeyEvent(Event):
 
         "Cmd" is a pseudo key which is the same as Control for PC and Unix
         platforms but the special "Apple" (a.k.a as "Command") key on
 
         "Cmd" is a pseudo key which is the same as Control for PC and Unix
         platforms but the special "Apple" (a.k.a as "Command") key on
-        Macs: it makes often sense to use it instead of, say, `ControlDown`
+        Macs. It makes often sense to use it instead of, say, `ControlDown`
         because Cmd key is used for the same thing under Mac as Ctrl
         elsewhere. The Ctrl still exists, it's just not used for this
         purpose. So for non-Mac platforms this is the same as `ControlDown`
         because Cmd key is used for the same thing under Mac as Ctrl
         elsewhere. The Ctrl still exists, it's just not used for this
         purpose. So for non-Mac platforms this is the same as `ControlDown`
@@ -3811,32 +4946,71 @@ class KeyEvent(Event):
         return _core_.KeyEvent_CmdDown(*args, **kwargs)
 
     def HasModifiers(*args, **kwargs):
         return _core_.KeyEvent_CmdDown(*args, **kwargs)
 
     def HasModifiers(*args, **kwargs):
-        """HasModifiers(self) -> bool"""
+        """
+        HasModifiers(self) -> bool
+
+        Returns true if either CTRL or ALT keys was down at the time of the
+        key event. Note that this function does not take into account neither
+        SHIFT nor META key states (the reason for ignoring the latter is that
+        it is common for NUMLOCK key to be configured as META under X but the
+        key presses even while NUMLOCK is on should be still processed
+        normally).
+        """
         return _core_.KeyEvent_HasModifiers(*args, **kwargs)
 
     def GetKeyCode(*args, **kwargs):
         return _core_.KeyEvent_HasModifiers(*args, **kwargs)
 
     def GetKeyCode(*args, **kwargs):
-        """GetKeyCode(self) -> int"""
+        """
+        GetKeyCode(self) -> int
+
+        Returns the virtual key code. ASCII events return normal ASCII values,
+        while non-ASCII events return values such as WXK_LEFT for the left
+        cursor key. See `wx.KeyEvent` for a full list of the virtual key
+        codes.
+
+        Note that in Unicode build, the returned value is meaningful only if
+        the user entered a character that can be represented in current
+        locale's default charset. You can obtain the corresponding Unicode
+        character using `GetUnicodeKey`.
+        """
         return _core_.KeyEvent_GetKeyCode(*args, **kwargs)
 
     KeyCode = GetKeyCode 
     def GetUnicodeKey(*args, **kwargs):
         return _core_.KeyEvent_GetKeyCode(*args, **kwargs)
 
     KeyCode = GetKeyCode 
     def GetUnicodeKey(*args, **kwargs):
-        """GetUnicodeKey(self) -> int"""
+        """
+        GetUnicodeKey(self) -> int
+
+        Returns the Unicode character corresponding to this key event.  This
+        function is only meaningfule in a Unicode build of wxPython.
+        """
         return _core_.KeyEvent_GetUnicodeKey(*args, **kwargs)
 
     GetUniChar = GetUnicodeKey 
     def GetRawKeyCode(*args, **kwargs):
         return _core_.KeyEvent_GetUnicodeKey(*args, **kwargs)
 
     GetUniChar = GetUnicodeKey 
     def GetRawKeyCode(*args, **kwargs):
-        """GetRawKeyCode(self) -> unsigned int"""
+        """
+        GetRawKeyCode(self) -> unsigned int
+
+        Returns the raw key code for this event. This is a platform-dependent
+        scan code which should only be used in advanced
+        applications. Currently the raw key codes are not supported by all
+        ports.
+        """
         return _core_.KeyEvent_GetRawKeyCode(*args, **kwargs)
 
     def GetRawKeyFlags(*args, **kwargs):
         return _core_.KeyEvent_GetRawKeyCode(*args, **kwargs)
 
     def GetRawKeyFlags(*args, **kwargs):
-        """GetRawKeyFlags(self) -> unsigned int"""
+        """
+        GetRawKeyFlags(self) -> unsigned int
+
+        Returns the low level key flags for this event. The flags are
+        platform-dependent and should only be used in advanced applications.
+        Currently the raw key flags are not supported by all ports.
+        """
         return _core_.KeyEvent_GetRawKeyFlags(*args, **kwargs)
 
     def GetPosition(*args, **kwargs):
         """
         GetPosition(self) -> Point
 
         return _core_.KeyEvent_GetRawKeyFlags(*args, **kwargs)
 
     def GetPosition(*args, **kwargs):
         """
         GetPosition(self) -> Point
 
-        Find the position of the event.
+        Find the position of the event, if applicable.
         """
         return _core_.KeyEvent_GetPosition(*args, **kwargs)
 
         """
         return _core_.KeyEvent_GetPosition(*args, **kwargs)
 
@@ -3844,16 +5018,26 @@ class KeyEvent(Event):
         """
         GetPositionTuple() -> (x,y)
 
         """
         GetPositionTuple() -> (x,y)
 
-        Find the position of the event.
+        Find the position of the event, if applicable.
         """
         return _core_.KeyEvent_GetPositionTuple(*args, **kwargs)
 
     def GetX(*args, **kwargs):
         """
         return _core_.KeyEvent_GetPositionTuple(*args, **kwargs)
 
     def GetX(*args, **kwargs):
-        """GetX(self) -> int"""
+        """
+        GetX(self) -> int
+
+        Returns the X position (in client coordinates) of the event, if
+        applicable.
+        """
         return _core_.KeyEvent_GetX(*args, **kwargs)
 
     def GetY(*args, **kwargs):
         return _core_.KeyEvent_GetX(*args, **kwargs)
 
     def GetY(*args, **kwargs):
-        """GetY(self) -> int"""
+        """
+        GetY(self) -> int
+
+        Returns the Y position (in client coordinates) of the event, if
+        applicable.
+        """
         return _core_.KeyEvent_GetY(*args, **kwargs)
 
     m_x = property(_core_.KeyEvent_m_x_get, _core_.KeyEvent_m_x_set)
         return _core_.KeyEvent_GetY(*args, **kwargs)
 
     m_x = property(_core_.KeyEvent_m_x_get, _core_.KeyEvent_m_x_set)
@@ -3877,17 +5061,42 @@ _core_.KeyEvent_swigregister(KeyEventPtr)
 #---------------------------------------------------------------------------
 
 class SizeEvent(Event):
 #---------------------------------------------------------------------------
 
 class SizeEvent(Event):
-    """Proxy of C++ SizeEvent class"""
+    """
+    A size event holds information about size change events.  The EVT_SIZE
+    handler function will be called when the window it is bound to has
+    been resized.
+
+    Note that the size passed is of the whole window: call
+    `wx.Window.GetClientSize` for the area which may be used by the
+    application.
+
+    When a window is resized, usually only a small part of the window is
+    damaged and and that area is all that is in the update region for the
+    next paint event. However, if your drawing depends on the size of the
+    window, you may need to clear the DC explicitly and repaint the whole
+    window. In which case, you may need to call `wx.Window.Refresh` to
+    invalidate the entire window.
+
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxSizeEvent 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++ wxSizeEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, Size sz=DefaultSize, int winid=0) -> SizeEvent"""
+        """
+        __init__(self, Size sz=DefaultSize, int winid=0) -> SizeEvent
+
+        Construct a new ``wx.SizeEvent``.
+        """
         newobj = _core_.new_SizeEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetSize(*args, **kwargs):
         newobj = _core_.new_SizeEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetSize(*args, **kwargs):
-        """GetSize(self) -> Size"""
+        """
+        GetSize(self) -> Size
+
+        Returns the entire size of the window generating the size change
+        event.
+        """
         return _core_.SizeEvent_GetSize(*args, **kwargs)
 
     def GetRect(*args, **kwargs):
         return _core_.SizeEvent_GetSize(*args, **kwargs)
 
     def GetRect(*args, **kwargs):
@@ -3915,17 +5124,28 @@ _core_.SizeEvent_swigregister(SizeEventPtr)
 #---------------------------------------------------------------------------
 
 class MoveEvent(Event):
 #---------------------------------------------------------------------------
 
 class MoveEvent(Event):
-    """Proxy of C++ MoveEvent class"""
+    """
+    This event object is sent for EVT_MOVE event bindings when a window is
+    moved to a new position.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxMoveEvent 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++ wxMoveEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, Point pos=DefaultPosition, int winid=0) -> MoveEvent"""
+        """
+        __init__(self, Point pos=DefaultPosition, int winid=0) -> MoveEvent
+
+        Constructor.
+        """
         newobj = _core_.new_MoveEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetPosition(*args, **kwargs):
         newobj = _core_.new_MoveEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetPosition(*args, **kwargs):
-        """GetPosition(self) -> Point"""
+        """
+        GetPosition(self) -> Point
+
+        Returns the position of the window generating the move change event.
+        """
         return _core_.MoveEvent_GetPosition(*args, **kwargs)
 
     def GetRect(*args, **kwargs):
         return _core_.MoveEvent_GetPosition(*args, **kwargs)
 
     def GetRect(*args, **kwargs):
@@ -3940,8 +5160,9 @@ class MoveEvent(Event):
         """SetPosition(self, Point pos)"""
         return _core_.MoveEvent_SetPosition(*args, **kwargs)
 
         """SetPosition(self, Point pos)"""
         return _core_.MoveEvent_SetPosition(*args, **kwargs)
 
-    m_pos = property(_core_.MoveEvent_m_pos_get, _core_.MoveEvent_m_pos_set)
-    m_rect = property(_core_.MoveEvent_m_rect_get, _core_.MoveEvent_m_rect_set)
+    m_pos =  property(GetPosition, SetPosition)
+    m_rect = property(GetRect, SetRect)
+
 
 class MoveEventPtr(MoveEvent):
     def __init__(self, this):
 
 class MoveEventPtr(MoveEvent):
     def __init__(self, this):
@@ -3953,7 +5174,21 @@ _core_.MoveEvent_swigregister(MoveEventPtr)
 #---------------------------------------------------------------------------
 
 class PaintEvent(Event):
 #---------------------------------------------------------------------------
 
 class PaintEvent(Event):
-    """Proxy of C++ PaintEvent class"""
+    """
+    A paint event is sent when a window's contents needs to be repainted.
+    Note that in an EVT_PAINT handler the application must *always* create
+    a `wx.PaintDC` object, even if you do not use it.  Otherwise MS
+    Windows assumes that the window has not been painted yet and will send
+    the event again, causing endless refreshes.
+
+    You can optimize painting by retrieving the rectangles that have been
+    damaged using `wx.Window.GetUpdateRegion` and/or `wx.RegionIterator`,
+    and only repainting these rectangles. The rectangles are in terms of
+    the client area, and are unscrolled, so you will need to do some
+    calculations using the current view position to obtain logical,
+    scrolled units.
+
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxPaintEvent 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++ wxPaintEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
@@ -3991,17 +5226,37 @@ _core_.NcPaintEvent_swigregister(NcPaintEventPtr)
 #---------------------------------------------------------------------------
 
 class EraseEvent(Event):
 #---------------------------------------------------------------------------
 
 class EraseEvent(Event):
-    """Proxy of C++ EraseEvent class"""
+    """
+    An erase event is sent whenever the background of a window needs to be
+    repainted.  To intercept this event use the EVT_ERASE_BACKGROUND event
+    binder.  On some platforms, such as GTK+, this event is simulated
+    (simply generated just before the paint event) and may cause flicker.
+
+    To paint a custom background use the `GetDC` method and use the returned
+    device context if it is not ``None``, otherwise create a temporary
+    `wx.ClientDC` and draw on that.
+
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxEraseEvent 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++ wxEraseEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, int Id=0, DC dc=(wxDC *) NULL) -> EraseEvent"""
+        """
+        __init__(self, int Id=0, DC dc=None) -> EraseEvent
+
+        Constructor
+        """
         newobj = _core_.new_EraseEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetDC(*args, **kwargs):
         newobj = _core_.new_EraseEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetDC(*args, **kwargs):
-        """GetDC(self) -> DC"""
+        """
+        GetDC(self) -> DC
+
+        Returns the device context the event handler should draw upon.  If
+        ``None`` is returned then create a temporary `wx.ClientDC` and use
+        that instead.
+        """
         return _core_.EraseEvent_GetDC(*args, **kwargs)
 
 
         return _core_.EraseEvent_GetDC(*args, **kwargs)
 
 
@@ -4015,17 +5270,38 @@ _core_.EraseEvent_swigregister(EraseEventPtr)
 #---------------------------------------------------------------------------
 
 class FocusEvent(Event):
 #---------------------------------------------------------------------------
 
 class FocusEvent(Event):
-    """Proxy of C++ FocusEvent class"""
+    """
+    A focus event is sent when a window's focus changes. The window losing
+    focus receives an EVT_KILL_FOCUS event while the window gaining it
+    gets an EVT_SET_FOCUS event.
+
+    Notice that the set focus event happens both when the user gives focus
+    to the window (whether using the mouse or keyboard) and when it is
+    done from the program itself using `wx.Window.SetFocus`.
+
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxFocusEvent 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++ wxFocusEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, wxEventType type=wxEVT_NULL, int winid=0) -> FocusEvent"""
+        """
+        __init__(self, wxEventType type=wxEVT_NULL, int winid=0) -> FocusEvent
+
+        Constructor
+        """
         newobj = _core_.new_FocusEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetWindow(*args, **kwargs):
         newobj = _core_.new_FocusEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetWindow(*args, **kwargs):
-        """GetWindow(self) -> Window"""
+        """
+        GetWindow(self) -> Window
+
+        Returns the other window associated with this event, that is the
+        window which had the focus before for the EVT_SET_FOCUS event and the
+        window which is going to receive focus for the wxEVT_KILL_FOCUS event.
+
+        Warning: the window returned may be None!
+        """
         return _core_.FocusEvent_GetWindow(*args, **kwargs)
 
     def SetWindow(*args, **kwargs):
         return _core_.FocusEvent_GetWindow(*args, **kwargs)
 
     def SetWindow(*args, **kwargs):
@@ -4043,17 +5319,29 @@ _core_.FocusEvent_swigregister(FocusEventPtr)
 #---------------------------------------------------------------------------
 
 class ChildFocusEvent(CommandEvent):
 #---------------------------------------------------------------------------
 
 class ChildFocusEvent(CommandEvent):
-    """Proxy of C++ ChildFocusEvent class"""
+    """
+    wx.ChildFocusEvent notifies the parent that a child has received the
+    focus.  Unlike `wx.FocusEvent` it is propagated up the window
+    heirarchy.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxChildFocusEvent 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++ wxChildFocusEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, Window win=None) -> ChildFocusEvent"""
+        """
+        __init__(self, Window win=None) -> ChildFocusEvent
+
+        Constructor
+        """
         newobj = _core_.new_ChildFocusEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetWindow(*args, **kwargs):
         newobj = _core_.new_ChildFocusEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetWindow(*args, **kwargs):
-        """GetWindow(self) -> Window"""
+        """
+        GetWindow(self) -> Window
+
+        The window which has just received the focus.
+        """
         return _core_.ChildFocusEvent_GetWindow(*args, **kwargs)
 
 
         return _core_.ChildFocusEvent_GetWindow(*args, **kwargs)
 
 
@@ -4067,17 +5355,41 @@ _core_.ChildFocusEvent_swigregister(ChildFocusEventPtr)
 #---------------------------------------------------------------------------
 
 class ActivateEvent(Event):
 #---------------------------------------------------------------------------
 
 class ActivateEvent(Event):
-    """Proxy of C++ ActivateEvent class"""
+    """
+    An activate event is sent when a top-level window or the entire
+    application is being activated or deactivated.
+
+    A top-level window (a dialog or frame) receives an activate event when
+    is being activated or deactivated. This is indicated visually by the
+    title bar changing colour, and a subwindow gaining the keyboard focus.
+    An application is activated or deactivated when one of its frames
+    becomes activated, or a frame becomes inactivate resulting in all
+    application frames being inactive.
+
+    Please note that usually you should call event.Skip() in your handlers
+    for these events so the default handlers will still be called, as not
+    doing so can result in strange effects.
+
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxActivateEvent 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++ wxActivateEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, wxEventType type=wxEVT_NULL, bool active=True, int Id=0) -> ActivateEvent"""
+        """
+        __init__(self, wxEventType type=wxEVT_NULL, bool active=True, int Id=0) -> ActivateEvent
+
+        Constructor
+        """
         newobj = _core_.new_ActivateEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetActive(*args, **kwargs):
         newobj = _core_.new_ActivateEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetActive(*args, **kwargs):
-        """GetActive(self) -> bool"""
+        """
+        GetActive(self) -> bool
+
+        Returns true if the application or window is being activated, false
+        otherwise.
+        """
         return _core_.ActivateEvent_GetActive(*args, **kwargs)
 
 
         return _core_.ActivateEvent_GetActive(*args, **kwargs)
 
 
@@ -4091,11 +5403,21 @@ _core_.ActivateEvent_swigregister(ActivateEventPtr)
 #---------------------------------------------------------------------------
 
 class InitDialogEvent(Event):
 #---------------------------------------------------------------------------
 
 class InitDialogEvent(Event):
-    """Proxy of C++ InitDialogEvent class"""
+    """
+    A wx.InitDialogEvent is sent as a dialog is being initialised, or for
+    any window when `wx.Window.InitDialog` is called.  Handlers for this
+    event can transfer data to the window, or anything else that should be
+    done before the user begins editing the form. The default handler
+    calls `wx.Window.TransferDataToWindow`.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxInitDialogEvent 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++ wxInitDialogEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, int Id=0) -> InitDialogEvent"""
+        """
+        __init__(self, int Id=0) -> InitDialogEvent
+
+        Constructor
+        """
         newobj = _core_.new_InitDialogEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_InitDialogEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -4111,25 +5433,52 @@ _core_.InitDialogEvent_swigregister(InitDialogEventPtr)
 #---------------------------------------------------------------------------
 
 class MenuEvent(Event):
 #---------------------------------------------------------------------------
 
 class MenuEvent(Event):
-    """Proxy of C++ MenuEvent class"""
+    """
+    This class is used for a variety of menu-related events.  Note that
+    these do not include menu command events, which are handled by sending
+    `wx.CommandEvent` objects.
+
+    The default handler for wx.EVT_MENU_HIGHLIGHT displays menu item help
+    text in the first field of the status bar.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxMenuEvent 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++ wxMenuEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, wxEventType type=wxEVT_NULL, int winid=0, Menu menu=None) -> MenuEvent"""
+        """
+        __init__(self, wxEventType type=wxEVT_NULL, int winid=0, Menu menu=None) -> MenuEvent
+
+        Constructor
+        """
         newobj = _core_.new_MenuEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetMenuId(*args, **kwargs):
         newobj = _core_.new_MenuEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetMenuId(*args, **kwargs):
-        """GetMenuId(self) -> int"""
+        """
+        GetMenuId(self) -> int
+
+        Returns the menu identifier associated with the event. This method
+        should be only used with the HIGHLIGHT events.
+        """
         return _core_.MenuEvent_GetMenuId(*args, **kwargs)
 
     def IsPopup(*args, **kwargs):
         return _core_.MenuEvent_GetMenuId(*args, **kwargs)
 
     def IsPopup(*args, **kwargs):
-        """IsPopup(self) -> bool"""
+        """
+        IsPopup(self) -> bool
+
+        Returns ``True`` if the menu which is being opened or closed is a
+        popup menu, ``False`` if it is a normal one.  This method should only
+        be used with the OPEN and CLOSE events.
+        """
         return _core_.MenuEvent_IsPopup(*args, **kwargs)
 
     def GetMenu(*args, **kwargs):
         return _core_.MenuEvent_IsPopup(*args, **kwargs)
 
     def GetMenu(*args, **kwargs):
-        """GetMenu(self) -> Menu"""
+        """
+        GetMenu(self) -> Menu
+
+        Returns the menu which is being opened or closed. This method should
+        only be used with the OPEN and CLOSE events.
+        """
         return _core_.MenuEvent_GetMenu(*args, **kwargs)
 
 
         return _core_.MenuEvent_GetMenu(*args, **kwargs)
 
 
@@ -4143,38 +5492,92 @@ _core_.MenuEvent_swigregister(MenuEventPtr)
 #---------------------------------------------------------------------------
 
 class CloseEvent(Event):
 #---------------------------------------------------------------------------
 
 class CloseEvent(Event):
-    """Proxy of C++ CloseEvent class"""
+    """
+    This event class contains information about window and session close
+    events.
+
+    The handler function for EVT_CLOSE is called when the user has tried
+    to close a a frame or dialog box using the window manager controls or
+    the system menu. It can also be invoked by the application itself
+    programmatically, for example by calling the `wx.Window.Close`
+    function.
+
+    You should check whether the application is forcing the deletion of
+    the window using `CanVeto`. If it returns ``False``, you must destroy
+    the window using `wx.Window.Destroy`. If the return value is ``True``,
+    it is up to you whether you respond by destroying the window or not.
+    For example you may wish to display a message dialog prompting to save
+    files or to cancel the close.
+
+    If you don't destroy the window, you should call `Veto` to let the
+    calling code know that you did not destroy the window. This allows the
+    `wx.Window.Close` function to return ``True`` or ``False`` depending
+    on whether the close instruction was honored or not.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxCloseEvent 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++ wxCloseEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, wxEventType type=wxEVT_NULL, int winid=0) -> CloseEvent"""
+        """
+        __init__(self, wxEventType type=wxEVT_NULL, int winid=0) -> CloseEvent
+
+        Constructor.
+        """
         newobj = _core_.new_CloseEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def SetLoggingOff(*args, **kwargs):
         newobj = _core_.new_CloseEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def SetLoggingOff(*args, **kwargs):
-        """SetLoggingOff(self, bool logOff)"""
+        """
+        SetLoggingOff(self, bool logOff)
+
+        Sets the 'logging off' flag.
+        """
         return _core_.CloseEvent_SetLoggingOff(*args, **kwargs)
 
     def GetLoggingOff(*args, **kwargs):
         return _core_.CloseEvent_SetLoggingOff(*args, **kwargs)
 
     def GetLoggingOff(*args, **kwargs):
-        """GetLoggingOff(self) -> bool"""
+        """
+        GetLoggingOff(self) -> bool
+
+        Returns ``True`` if the user is logging off or ``False`` if the
+        system is shutting down. This method can only be called for end
+        session and query end session events, it doesn't make sense for close
+        window event.
+        """
         return _core_.CloseEvent_GetLoggingOff(*args, **kwargs)
 
     def Veto(*args, **kwargs):
         return _core_.CloseEvent_GetLoggingOff(*args, **kwargs)
 
     def Veto(*args, **kwargs):
-        """Veto(self, bool veto=True)"""
+        """
+        Veto(self, bool veto=True)
+
+        Call this from your event handler to veto a system shutdown or to
+        signal to the calling application that a window close did not happen.
+
+        You can only veto a shutdown or close if `CanVeto` returns true.
+        """
         return _core_.CloseEvent_Veto(*args, **kwargs)
 
         return _core_.CloseEvent_Veto(*args, **kwargs)
 
+    def GetVeto(*args, **kwargs):
+        """GetVeto(self) -> bool"""
+        return _core_.CloseEvent_GetVeto(*args, **kwargs)
+
     def SetCanVeto(*args, **kwargs):
     def SetCanVeto(*args, **kwargs):
-        """SetCanVeto(self, bool canVeto)"""
+        """
+        SetCanVeto(self, bool canVeto)
+
+        Sets the 'can veto' flag.
+        """
         return _core_.CloseEvent_SetCanVeto(*args, **kwargs)
 
     def CanVeto(*args, **kwargs):
         return _core_.CloseEvent_SetCanVeto(*args, **kwargs)
 
     def CanVeto(*args, **kwargs):
-        """CanVeto(self) -> bool"""
-        return _core_.CloseEvent_CanVeto(*args, **kwargs)
+        """
+        CanVeto(self) -> bool
 
 
-    def GetVeto(*args, **kwargs):
-        """GetVeto(self) -> bool"""
-        return _core_.CloseEvent_GetVeto(*args, **kwargs)
+        Returns true if you can veto a system shutdown or a window close
+        event. Vetoing a window close event is not possible if the calling
+        code wishes to force the application to exit, and so this function
+        must be called to check this.
+        """
+        return _core_.CloseEvent_CanVeto(*args, **kwargs)
 
 
 class CloseEventPtr(CloseEvent):
 
 
 class CloseEventPtr(CloseEvent):
@@ -4187,11 +5590,15 @@ _core_.CloseEvent_swigregister(CloseEventPtr)
 #---------------------------------------------------------------------------
 
 class ShowEvent(Event):
 #---------------------------------------------------------------------------
 
 class ShowEvent(Event):
-    """Proxy of C++ ShowEvent class"""
+    """An EVT_SHOW event is sent when a window is shown or hidden."""
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxShowEvent 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++ wxShowEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, int winid=0, bool show=False) -> ShowEvent"""
+        """
+        __init__(self, int winid=0, bool show=False) -> ShowEvent
+
+        An EVT_SHOW event is sent when a window is shown or hidden.
+        """
         newobj = _core_.new_ShowEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_ShowEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -4215,17 +5622,30 @@ _core_.ShowEvent_swigregister(ShowEventPtr)
 #---------------------------------------------------------------------------
 
 class IconizeEvent(Event):
 #---------------------------------------------------------------------------
 
 class IconizeEvent(Event):
-    """Proxy of C++ IconizeEvent class"""
+    """
+    An EVT_ICONIZE event is sent when a frame is iconized (minimized) or
+    restored.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxIconizeEvent 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++ wxIconizeEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, int id=0, bool iconized=True) -> IconizeEvent"""
+        """
+        __init__(self, int id=0, bool iconized=True) -> IconizeEvent
+
+        An EVT_ICONIZE event is sent when a frame is iconized (minimized) or
+        restored.
+        """
         newobj = _core_.new_IconizeEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def Iconized(*args, **kwargs):
         newobj = _core_.new_IconizeEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def Iconized(*args, **kwargs):
-        """Iconized(self) -> bool"""
+        """
+        Iconized(self) -> bool
+
+        Returns ``True`` if the frame has been iconized, ``False`` if it has
+        been restored.
+        """
         return _core_.IconizeEvent_Iconized(*args, **kwargs)
 
 
         return _core_.IconizeEvent_Iconized(*args, **kwargs)
 
 
@@ -4239,11 +5659,15 @@ _core_.IconizeEvent_swigregister(IconizeEventPtr)
 #---------------------------------------------------------------------------
 
 class MaximizeEvent(Event):
 #---------------------------------------------------------------------------
 
 class MaximizeEvent(Event):
-    """Proxy of C++ MaximizeEvent class"""
+    """An EVT_MAXIMIZE event is sent when a frame is maximized or restored."""
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxMaximizeEvent 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++ wxMaximizeEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, int id=0) -> MaximizeEvent"""
+        """
+        __init__(self, int id=0) -> MaximizeEvent
+
+        An EVT_MAXIMIZE event is sent when a frame is maximized or restored.
+        """
         newobj = _core_.new_MaximizeEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_MaximizeEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -4259,20 +5683,46 @@ _core_.MaximizeEvent_swigregister(MaximizeEventPtr)
 #---------------------------------------------------------------------------
 
 class DropFilesEvent(Event):
 #---------------------------------------------------------------------------
 
 class DropFilesEvent(Event):
-    """Proxy of C++ DropFilesEvent class"""
+    """
+    This class is used for drop files events, that is, when files have
+    been dropped onto the window. This functionality is only available
+    under Windows. The window must have previously been enabled for
+    dropping by calling `wx.Window.DragAcceptFiles`.
+
+    Important note: this is a separate implementation to the more general
+    drag and drop implementation using `wx.FileDropTarget`, and etc. This
+    implementation uses the older, Windows message-based approach of
+    dropping files.
+
+    Use wx.EVT_DROP_FILES to bind an event handler to receive file drop
+    events.
+
+    """
     def __init__(self): raise RuntimeError, "No constructor defined"
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxDropFilesEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def GetPosition(*args, **kwargs):
     def __init__(self): raise RuntimeError, "No constructor defined"
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxDropFilesEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def GetPosition(*args, **kwargs):
-        """GetPosition(self) -> Point"""
+        """
+        GetPosition(self) -> Point
+
+        Returns the position at which the files were dropped.
+        """
         return _core_.DropFilesEvent_GetPosition(*args, **kwargs)
 
     def GetNumberOfFiles(*args, **kwargs):
         return _core_.DropFilesEvent_GetPosition(*args, **kwargs)
 
     def GetNumberOfFiles(*args, **kwargs):
-        """GetNumberOfFiles(self) -> int"""
+        """
+        GetNumberOfFiles(self) -> int
+
+        Returns the number of files dropped.
+        """
         return _core_.DropFilesEvent_GetNumberOfFiles(*args, **kwargs)
 
     def GetFiles(*args, **kwargs):
         return _core_.DropFilesEvent_GetNumberOfFiles(*args, **kwargs)
 
     def GetFiles(*args, **kwargs):
-        """GetFiles(self) -> PyObject"""
+        """
+        GetFiles(self) -> PyObject
+
+        Returns a list of the filenames that were dropped.
+        """
         return _core_.DropFilesEvent_GetFiles(*args, **kwargs)
 
 
         return _core_.DropFilesEvent_GetFiles(*args, **kwargs)
 
 
@@ -4288,78 +5738,233 @@ _core_.DropFilesEvent_swigregister(DropFilesEventPtr)
 UPDATE_UI_PROCESS_ALL = _core_.UPDATE_UI_PROCESS_ALL
 UPDATE_UI_PROCESS_SPECIFIED = _core_.UPDATE_UI_PROCESS_SPECIFIED
 class UpdateUIEvent(CommandEvent):
 UPDATE_UI_PROCESS_ALL = _core_.UPDATE_UI_PROCESS_ALL
 UPDATE_UI_PROCESS_SPECIFIED = _core_.UPDATE_UI_PROCESS_SPECIFIED
 class UpdateUIEvent(CommandEvent):
-    """Proxy of C++ UpdateUIEvent class"""
+    """
+    This class is used for EVT_UPDATE_UI pseudo-events which are sent by
+    wxWidgets to give an application the chance to update various user
+    interface elements.
+
+    Without update UI events, an application has to work hard to
+    check/uncheck, enable/disable, and set the text for elements such as
+    menu items and toolbar buttons. The code for doing this has to be
+    mixed up with the code that is invoked when an action is invoked for a
+    menu item or button.
+
+    With update UI events, you define an event handler to look at the
+    state of the application and change UI elements accordingly. wxWidgets
+    will call your handler functions in idle time, so you don't have to
+    worry where to call this code. In addition to being a clearer and more
+    declarative method, it also means you don't have to worry whether
+    you're updating a toolbar or menubar identifier. The same handler can
+    update a menu item and toolbar button, if the ID values are the same.
+
+    Instead of directly manipulating the menu or button, you call
+    functions in the event object, such as `Check`. wxWidgets will
+    determine whether such a call has been made, and which UI element to
+    update.
+
+    These events will work for popup menus as well as menubars. Just
+    before a menu is popped up, `wx.Menu.UpdateUI` is called to process
+    any UI events for the window that owns the menu.
+
+    If you find that the overhead of UI update processing is affecting
+    your application, you can do one or both of the following:
+
+       1. Call `wx.UpdateUIEvent.SetMode` with a value of
+          wx.UPDATE_UI_PROCESS_SPECIFIED, and set the extra style
+          wx.WS_EX_PROCESS_UPDATE_EVENTS for every window that should
+          receive update events. No other windows will receive update
+          events.
+
+       2. Call `wx.UpdateUIEvent.SetUpdateInterval` with a millisecond
+          value to set the delay between updates. You may need to call
+          `wx.Window.UpdateWindowUI` at critical points, for example when
+          a dialog is about to be shown, in case the user sees a slight
+          delay before windows are updated.
+
+    Note that although events are sent in idle time, defining a EVT_IDLE
+    handler for a window does not affect this because the events are sent
+    from an internal idle handler.
+
+    wxWidgets tries to optimize update events on some platforms. On
+    Windows and GTK+, events for menubar items are only sent when the menu
+    is about to be shown, and not in idle time.
+
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxUpdateUIEvent 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++ wxUpdateUIEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, int commandId=0) -> UpdateUIEvent"""
+        """
+        __init__(self, int commandId=0) -> UpdateUIEvent
+
+        Constructor
+        """
         newobj = _core_.new_UpdateUIEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetChecked(*args, **kwargs):
         newobj = _core_.new_UpdateUIEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetChecked(*args, **kwargs):
-        """GetChecked(self) -> bool"""
+        """
+        GetChecked(self) -> bool
+
+        Returns ``True`` if the UI element should be checked.
+        """
         return _core_.UpdateUIEvent_GetChecked(*args, **kwargs)
 
     def GetEnabled(*args, **kwargs):
         return _core_.UpdateUIEvent_GetChecked(*args, **kwargs)
 
     def GetEnabled(*args, **kwargs):
-        """GetEnabled(self) -> bool"""
+        """
+        GetEnabled(self) -> bool
+
+        Returns ``True`` if the UI element should be enabled.
+        """
         return _core_.UpdateUIEvent_GetEnabled(*args, **kwargs)
 
     def GetText(*args, **kwargs):
         return _core_.UpdateUIEvent_GetEnabled(*args, **kwargs)
 
     def GetText(*args, **kwargs):
-        """GetText(self) -> String"""
+        """
+        GetText(self) -> String
+
+        Returns the text that should be set for the UI element.
+        """
         return _core_.UpdateUIEvent_GetText(*args, **kwargs)
 
     def GetSetText(*args, **kwargs):
         return _core_.UpdateUIEvent_GetText(*args, **kwargs)
 
     def GetSetText(*args, **kwargs):
-        """GetSetText(self) -> bool"""
+        """
+        GetSetText(self) -> bool
+
+        Returns ``True`` if the application has called `SetText`. For
+        wxWidgets internal use only.
+        """
         return _core_.UpdateUIEvent_GetSetText(*args, **kwargs)
 
     def GetSetChecked(*args, **kwargs):
         return _core_.UpdateUIEvent_GetSetText(*args, **kwargs)
 
     def GetSetChecked(*args, **kwargs):
-        """GetSetChecked(self) -> bool"""
+        """
+        GetSetChecked(self) -> bool
+
+        Returns ``True`` if the application has called `Check`. For wxWidgets
+        internal use only.
+        """
         return _core_.UpdateUIEvent_GetSetChecked(*args, **kwargs)
 
     def GetSetEnabled(*args, **kwargs):
         return _core_.UpdateUIEvent_GetSetChecked(*args, **kwargs)
 
     def GetSetEnabled(*args, **kwargs):
-        """GetSetEnabled(self) -> bool"""
+        """
+        GetSetEnabled(self) -> bool
+
+        Returns ``True`` if the application has called `Enable`. For wxWidgets
+        internal use only.
+        """
         return _core_.UpdateUIEvent_GetSetEnabled(*args, **kwargs)
 
     def Check(*args, **kwargs):
         return _core_.UpdateUIEvent_GetSetEnabled(*args, **kwargs)
 
     def Check(*args, **kwargs):
-        """Check(self, bool check)"""
+        """
+        Check(self, bool check)
+
+        Check or uncheck the UI element.
+        """
         return _core_.UpdateUIEvent_Check(*args, **kwargs)
 
     def Enable(*args, **kwargs):
         return _core_.UpdateUIEvent_Check(*args, **kwargs)
 
     def Enable(*args, **kwargs):
-        """Enable(self, bool enable)"""
+        """
+        Enable(self, bool enable)
+
+        Enable or disable the UI element.
+        """
         return _core_.UpdateUIEvent_Enable(*args, **kwargs)
 
     def SetText(*args, **kwargs):
         return _core_.UpdateUIEvent_Enable(*args, **kwargs)
 
     def SetText(*args, **kwargs):
-        """SetText(self, String text)"""
+        """
+        SetText(self, String text)
+
+        Sets the text for this UI element.
+        """
         return _core_.UpdateUIEvent_SetText(*args, **kwargs)
 
     def SetUpdateInterval(*args, **kwargs):
         return _core_.UpdateUIEvent_SetText(*args, **kwargs)
 
     def SetUpdateInterval(*args, **kwargs):
-        """SetUpdateInterval(long updateInterval)"""
+        """
+        SetUpdateInterval(long updateInterval)
+
+        Sets the interval between updates in milliseconds. Set to -1 to
+        disable updates, or to 0 to update as frequently as possible. The
+        default is 0.
+
+        Use this to reduce the overhead of UI update events if your
+        application has a lot of windows. If you set the value to -1 or
+        greater than 0, you may also need to call `wx.Window.UpdateWindowUI`
+        at appropriate points in your application, such as when a dialog is
+        about to be shown.
+        """
         return _core_.UpdateUIEvent_SetUpdateInterval(*args, **kwargs)
 
     SetUpdateInterval = staticmethod(SetUpdateInterval)
     def GetUpdateInterval(*args, **kwargs):
         return _core_.UpdateUIEvent_SetUpdateInterval(*args, **kwargs)
 
     SetUpdateInterval = staticmethod(SetUpdateInterval)
     def GetUpdateInterval(*args, **kwargs):
-        """GetUpdateInterval() -> long"""
+        """
+        GetUpdateInterval() -> long
+
+        Returns the current interval between updates in milliseconds. -1
+        disables updates, 0 updates as frequently as possible.
+        """
         return _core_.UpdateUIEvent_GetUpdateInterval(*args, **kwargs)
 
     GetUpdateInterval = staticmethod(GetUpdateInterval)
     def CanUpdate(*args, **kwargs):
         return _core_.UpdateUIEvent_GetUpdateInterval(*args, **kwargs)
 
     GetUpdateInterval = staticmethod(GetUpdateInterval)
     def CanUpdate(*args, **kwargs):
-        """CanUpdate(Window win) -> bool"""
+        """
+        CanUpdate(Window win) -> bool
+
+        Returns ``True`` if it is appropriate to update (send UI update events
+        to) this window.
+
+        This function looks at the mode used (see `wx.UpdateUIEvent.SetMode`),
+        the wx.WS_EX_PROCESS_UPDATE_EVENTS flag in window, the time update
+        events were last sent in idle time, and the update interval, to
+        determine whether events should be sent to this window now. By default
+        this will always return true because the update mode is initially
+        wx.UPDATE_UI_PROCESS_ALL and the interval is set to 0; so update
+        events will be sent as often as possible. You can reduce the frequency
+        that events are sent by changing the mode and/or setting an update
+        interval.
+
+        """
         return _core_.UpdateUIEvent_CanUpdate(*args, **kwargs)
 
     CanUpdate = staticmethod(CanUpdate)
     def ResetUpdateTime(*args, **kwargs):
         return _core_.UpdateUIEvent_CanUpdate(*args, **kwargs)
 
     CanUpdate = staticmethod(CanUpdate)
     def ResetUpdateTime(*args, **kwargs):
-        """ResetUpdateTime()"""
+        """
+        ResetUpdateTime()
+
+        Used internally to reset the last-updated time to the current time. It
+        is assumed that update events are normally sent in idle time, so this
+        is called at the end of idle processing.
+        """
         return _core_.UpdateUIEvent_ResetUpdateTime(*args, **kwargs)
 
     ResetUpdateTime = staticmethod(ResetUpdateTime)
     def SetMode(*args, **kwargs):
         return _core_.UpdateUIEvent_ResetUpdateTime(*args, **kwargs)
 
     ResetUpdateTime = staticmethod(ResetUpdateTime)
     def SetMode(*args, **kwargs):
-        """SetMode(int mode)"""
+        """
+        SetMode(int mode)
+
+        Specify how wxWidgets will send update events: to all windows, or only
+        to those which specify that they will process the events.
+
+        The mode may be one of the following values:
+
+            =============================   ==========================================
+            wxUPDATE_UI_PROCESS_ALL         Send UI update events to all windows.  This
+                                            is the default setting.
+            wxUPDATE_UI_PROCESS_SPECIFIED   Send UI update events only to windows that
+                                            have the wx.WS_EX_PROCESS_UI_UPDATES extra
+                                            style set.
+            =============================   ==========================================
+
+        """
         return _core_.UpdateUIEvent_SetMode(*args, **kwargs)
 
     SetMode = staticmethod(SetMode)
     def GetMode(*args, **kwargs):
         return _core_.UpdateUIEvent_SetMode(*args, **kwargs)
 
     SetMode = staticmethod(SetMode)
     def GetMode(*args, **kwargs):
-        """GetMode() -> int"""
+        """
+        GetMode() -> int
+
+        Returns a value specifying how wxWidgets will send update events: to
+        all windows, or only to those which specify that they will process the
+        events.
+        """
         return _core_.UpdateUIEvent_GetMode(*args, **kwargs)
 
     GetMode = staticmethod(GetMode)
         return _core_.UpdateUIEvent_GetMode(*args, **kwargs)
 
     GetMode = staticmethod(GetMode)
@@ -4372,37 +5977,113 @@ class UpdateUIEventPtr(UpdateUIEvent):
 _core_.UpdateUIEvent_swigregister(UpdateUIEventPtr)
 
 def UpdateUIEvent_SetUpdateInterval(*args, **kwargs):
 _core_.UpdateUIEvent_swigregister(UpdateUIEventPtr)
 
 def UpdateUIEvent_SetUpdateInterval(*args, **kwargs):
-    """UpdateUIEvent_SetUpdateInterval(long updateInterval)"""
+    """
+    UpdateUIEvent_SetUpdateInterval(long updateInterval)
+
+    Sets the interval between updates in milliseconds. Set to -1 to
+    disable updates, or to 0 to update as frequently as possible. The
+    default is 0.
+
+    Use this to reduce the overhead of UI update events if your
+    application has a lot of windows. If you set the value to -1 or
+    greater than 0, you may also need to call `wx.Window.UpdateWindowUI`
+    at appropriate points in your application, such as when a dialog is
+    about to be shown.
+    """
     return _core_.UpdateUIEvent_SetUpdateInterval(*args, **kwargs)
 
 def UpdateUIEvent_GetUpdateInterval(*args, **kwargs):
     return _core_.UpdateUIEvent_SetUpdateInterval(*args, **kwargs)
 
 def UpdateUIEvent_GetUpdateInterval(*args, **kwargs):
-    """UpdateUIEvent_GetUpdateInterval() -> long"""
+    """
+    UpdateUIEvent_GetUpdateInterval() -> long
+
+    Returns the current interval between updates in milliseconds. -1
+    disables updates, 0 updates as frequently as possible.
+    """
     return _core_.UpdateUIEvent_GetUpdateInterval(*args, **kwargs)
 
 def UpdateUIEvent_CanUpdate(*args, **kwargs):
     return _core_.UpdateUIEvent_GetUpdateInterval(*args, **kwargs)
 
 def UpdateUIEvent_CanUpdate(*args, **kwargs):
-    """UpdateUIEvent_CanUpdate(Window win) -> bool"""
+    """
+    UpdateUIEvent_CanUpdate(Window win) -> bool
+
+    Returns ``True`` if it is appropriate to update (send UI update events
+    to) this window.
+
+    This function looks at the mode used (see `wx.UpdateUIEvent.SetMode`),
+    the wx.WS_EX_PROCESS_UPDATE_EVENTS flag in window, the time update
+    events were last sent in idle time, and the update interval, to
+    determine whether events should be sent to this window now. By default
+    this will always return true because the update mode is initially
+    wx.UPDATE_UI_PROCESS_ALL and the interval is set to 0; so update
+    events will be sent as often as possible. You can reduce the frequency
+    that events are sent by changing the mode and/or setting an update
+    interval.
+
+    """
     return _core_.UpdateUIEvent_CanUpdate(*args, **kwargs)
 
 def UpdateUIEvent_ResetUpdateTime(*args, **kwargs):
     return _core_.UpdateUIEvent_CanUpdate(*args, **kwargs)
 
 def UpdateUIEvent_ResetUpdateTime(*args, **kwargs):
-    """UpdateUIEvent_ResetUpdateTime()"""
+    """
+    UpdateUIEvent_ResetUpdateTime()
+
+    Used internally to reset the last-updated time to the current time. It
+    is assumed that update events are normally sent in idle time, so this
+    is called at the end of idle processing.
+    """
     return _core_.UpdateUIEvent_ResetUpdateTime(*args, **kwargs)
 
 def UpdateUIEvent_SetMode(*args, **kwargs):
     return _core_.UpdateUIEvent_ResetUpdateTime(*args, **kwargs)
 
 def UpdateUIEvent_SetMode(*args, **kwargs):
-    """UpdateUIEvent_SetMode(int mode)"""
+    """
+    UpdateUIEvent_SetMode(int mode)
+
+    Specify how wxWidgets will send update events: to all windows, or only
+    to those which specify that they will process the events.
+
+    The mode may be one of the following values:
+
+        =============================   ==========================================
+        wxUPDATE_UI_PROCESS_ALL         Send UI update events to all windows.  This
+                                        is the default setting.
+        wxUPDATE_UI_PROCESS_SPECIFIED   Send UI update events only to windows that
+                                        have the wx.WS_EX_PROCESS_UI_UPDATES extra
+                                        style set.
+        =============================   ==========================================
+
+    """
     return _core_.UpdateUIEvent_SetMode(*args, **kwargs)
 
 def UpdateUIEvent_GetMode(*args, **kwargs):
     return _core_.UpdateUIEvent_SetMode(*args, **kwargs)
 
 def UpdateUIEvent_GetMode(*args, **kwargs):
-    """UpdateUIEvent_GetMode() -> int"""
+    """
+    UpdateUIEvent_GetMode() -> int
+
+    Returns a value specifying how wxWidgets will send update events: to
+    all windows, or only to those which specify that they will process the
+    events.
+    """
     return _core_.UpdateUIEvent_GetMode(*args, **kwargs)
 
 #---------------------------------------------------------------------------
 
 class SysColourChangedEvent(Event):
     return _core_.UpdateUIEvent_GetMode(*args, **kwargs)
 
 #---------------------------------------------------------------------------
 
 class SysColourChangedEvent(Event):
-    """Proxy of C++ SysColourChangedEvent class"""
+    """
+    This class is used for EVT_SYS_COLOUR_CHANGED, which are generated
+    when the user changes the colour settings using the control
+    panel. This is only applicable under Windows.
+
+    The default event handler for this event propagates the event to child
+    windows, since Windows only sends the events to top-level windows. If
+    intercepting this event for a top-level window, remember to call
+    `Skip` so the the base class handler will still be executed, or to
+    pass the event on to the window's children explicitly.
+
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxSysColourChangedEvent 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++ wxSysColourChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self) -> SysColourChangedEvent"""
+        """
+        __init__(self) -> SysColourChangedEvent
+
+        Constructor
+        """
         newobj = _core_.new_SysColourChangedEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_SysColourChangedEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -4418,17 +6099,34 @@ _core_.SysColourChangedEvent_swigregister(SysColourChangedEventPtr)
 #---------------------------------------------------------------------------
 
 class MouseCaptureChangedEvent(Event):
 #---------------------------------------------------------------------------
 
 class MouseCaptureChangedEvent(Event):
-    """Proxy of C++ MouseCaptureChangedEvent class"""
+    """
+    An mouse capture changed event (EVT_MOUSE_CAPTURE_CHANGED) is sent to
+    a window that loses its mouse capture. This is called even if
+    `wx.Window.ReleaseMouse` was called by the application code. Handling
+    this event allows an application to cater for unexpected capture
+    releases which might otherwise confuse mouse handling code.
+
+    This event is implemented under Windows only.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxMouseCaptureChangedEvent 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++ wxMouseCaptureChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, int winid=0, Window gainedCapture=None) -> MouseCaptureChangedEvent"""
+        """
+        __init__(self, int winid=0, Window gainedCapture=None) -> MouseCaptureChangedEvent
+
+        Constructor
+        """
         newobj = _core_.new_MouseCaptureChangedEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetCapturedWindow(*args, **kwargs):
         newobj = _core_.new_MouseCaptureChangedEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetCapturedWindow(*args, **kwargs):
-        """GetCapturedWindow(self) -> Window"""
+        """
+        GetCapturedWindow(self) -> Window
+
+        Returns the window that gained the capture, or ``None`` if it was a
+        non-wxWidgets window.
+        """
         return _core_.MouseCaptureChangedEvent_GetCapturedWindow(*args, **kwargs)
 
 
         return _core_.MouseCaptureChangedEvent_GetCapturedWindow(*args, **kwargs)
 
 
@@ -4442,7 +6140,12 @@ _core_.MouseCaptureChangedEvent_swigregister(MouseCaptureChangedEventPtr)
 #---------------------------------------------------------------------------
 
 class DisplayChangedEvent(Event):
 #---------------------------------------------------------------------------
 
 class DisplayChangedEvent(Event):
-    """Proxy of C++ DisplayChangedEvent class"""
+    """
+    An EVT_DISPLAY_CHANGED event is sent to all windows when the display
+    resolution has changed.
+
+    This event is implemented under Windows only.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxDisplayChangedEvent 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++ wxDisplayChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
@@ -4462,11 +6165,25 @@ _core_.DisplayChangedEvent_swigregister(DisplayChangedEventPtr)
 #---------------------------------------------------------------------------
 
 class PaletteChangedEvent(Event):
 #---------------------------------------------------------------------------
 
 class PaletteChangedEvent(Event):
-    """Proxy of C++ PaletteChangedEvent class"""
+    """
+    An EVT_PALETTE_CHANGED event is sent when the system palette has
+    changed, thereby giving each window a chance to redo their own to
+    match.
+
+    This event is implemented under Windows only.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxPaletteChangedEvent 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++ wxPaletteChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, int id=0) -> PaletteChangedEvent"""
+        """
+        __init__(self, int id=0) -> PaletteChangedEvent
+
+        An EVT_PALETTE_CHANGED event is sent when the system palette has
+        changed, thereby giving each window a chance to redo their own to
+        match.
+
+        This event is implemented under Windows only.
+        """
         newobj = _core_.new_PaletteChangedEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_PaletteChangedEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -4490,17 +6207,30 @@ _core_.PaletteChangedEvent_swigregister(PaletteChangedEventPtr)
 #---------------------------------------------------------------------------
 
 class QueryNewPaletteEvent(Event):
 #---------------------------------------------------------------------------
 
 class QueryNewPaletteEvent(Event):
-    """Proxy of C++ QueryNewPaletteEvent class"""
+    """
+    An EVT_QUERY_NEW_PALETE event indicates the window is getting keyboard
+    focus and should re-do its palette.
+
+    This event is implemented under Windows only.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxQueryNewPaletteEvent 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++ wxQueryNewPaletteEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, int winid=0) -> QueryNewPaletteEvent"""
+        """
+        __init__(self, int winid=0) -> QueryNewPaletteEvent
+
+        Constructor.
+        """
         newobj = _core_.new_QueryNewPaletteEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def SetPaletteRealized(*args, **kwargs):
         newobj = _core_.new_QueryNewPaletteEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def SetPaletteRealized(*args, **kwargs):
-        """SetPaletteRealized(self, bool realized)"""
+        """
+        SetPaletteRealized(self, bool realized)
+
+        App should set this if it changes the palette.
+        """
         return _core_.QueryNewPaletteEvent_SetPaletteRealized(*args, **kwargs)
 
     def GetPaletteRealized(*args, **kwargs):
         return _core_.QueryNewPaletteEvent_SetPaletteRealized(*args, **kwargs)
 
     def GetPaletteRealized(*args, **kwargs):
@@ -4518,7 +6248,15 @@ _core_.QueryNewPaletteEvent_swigregister(QueryNewPaletteEventPtr)
 #---------------------------------------------------------------------------
 
 class NavigationKeyEvent(Event):
 #---------------------------------------------------------------------------
 
 class NavigationKeyEvent(Event):
-    """Proxy of C++ NavigationKeyEvent class"""
+    """
+    EVT_NAVIGATION_KEY events are used to control moving the focus between
+    widgets, otherwise known as tab-traversal.  You woudl normally not
+    catch navigation events in applications as there are already
+    appropriate handlers in `wx.Dialog` and `wx.Panel`, but you may find
+    it useful to send navigation events in certain situations to change
+    the focus in certain ways, although it's probably easier to just call
+    `wx.Window.Navigate`.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxNavigationKeyEvent 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++ wxNavigationKeyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
@@ -4528,36 +6266,93 @@ class NavigationKeyEvent(Event):
         self.thisown = 1
         del newobj.thisown
     def GetDirection(*args, **kwargs):
         self.thisown = 1
         del newobj.thisown
     def GetDirection(*args, **kwargs):
-        """GetDirection(self) -> bool"""
+        """
+        GetDirection(self) -> bool
+
+        Returns ``True`` if the direction is forward, ``False`` otherwise.
+        """
         return _core_.NavigationKeyEvent_GetDirection(*args, **kwargs)
 
     def SetDirection(*args, **kwargs):
         return _core_.NavigationKeyEvent_GetDirection(*args, **kwargs)
 
     def SetDirection(*args, **kwargs):
-        """SetDirection(self, bool forward)"""
+        """
+        SetDirection(self, bool forward)
+
+        Specify the direction that the navigation should take.  Usually the
+        difference between using Tab and Shift-Tab.
+        """
         return _core_.NavigationKeyEvent_SetDirection(*args, **kwargs)
 
     def IsWindowChange(*args, **kwargs):
         return _core_.NavigationKeyEvent_SetDirection(*args, **kwargs)
 
     def IsWindowChange(*args, **kwargs):
-        """IsWindowChange(self) -> bool"""
+        """
+        IsWindowChange(self) -> bool
+
+        Returns ``True`` if window change is allowed.
+        """
         return _core_.NavigationKeyEvent_IsWindowChange(*args, **kwargs)
 
     def SetWindowChange(*args, **kwargs):
         return _core_.NavigationKeyEvent_IsWindowChange(*args, **kwargs)
 
     def SetWindowChange(*args, **kwargs):
-        """SetWindowChange(self, bool ischange)"""
+        """
+        SetWindowChange(self, bool ischange)
+
+        Specify if the navigation should be able to change parent windows.
+        For example, changing notebook pages, etc. This is usually implemented
+        by using Control-Tab.
+        """
         return _core_.NavigationKeyEvent_SetWindowChange(*args, **kwargs)
 
         return _core_.NavigationKeyEvent_SetWindowChange(*args, **kwargs)
 
+    def IsFromTab(*args, **kwargs):
+        """
+        IsFromTab(self) -> bool
+
+        Returns ``True`` if the navigation event is originated from the Tab
+        key.
+        """
+        return _core_.NavigationKeyEvent_IsFromTab(*args, **kwargs)
+
+    def SetFromTab(*args, **kwargs):
+        """
+        SetFromTab(self, bool bIs)
+
+        Set to true under MSW if the event was generated using the tab key.
+        This is required for proper navogation over radio buttons.
+        """
+        return _core_.NavigationKeyEvent_SetFromTab(*args, **kwargs)
+
     def SetFlags(*args, **kwargs):
     def SetFlags(*args, **kwargs):
-        """SetFlags(self, long flags)"""
+        """
+        SetFlags(self, long flags)
+
+        Set the navigation flags to a combination of the following:
+
+            * wx.NavigationKeyEvent.IsBackward
+            * wx.NavigationKeyEvent.IsForward
+            * wx.NavigationKeyEvent.WinChange
+            * wx.NavigationKeyEvent.FromTab
+
+        """
         return _core_.NavigationKeyEvent_SetFlags(*args, **kwargs)
 
     def GetCurrentFocus(*args, **kwargs):
         return _core_.NavigationKeyEvent_SetFlags(*args, **kwargs)
 
     def GetCurrentFocus(*args, **kwargs):
-        """GetCurrentFocus(self) -> Window"""
+        """
+        GetCurrentFocus(self) -> Window
+
+        Returns the child window which currenty has the focus.  May be
+        ``None``.
+        """
         return _core_.NavigationKeyEvent_GetCurrentFocus(*args, **kwargs)
 
     def SetCurrentFocus(*args, **kwargs):
         return _core_.NavigationKeyEvent_GetCurrentFocus(*args, **kwargs)
 
     def SetCurrentFocus(*args, **kwargs):
-        """SetCurrentFocus(self, Window win)"""
+        """
+        SetCurrentFocus(self, Window win)
+
+        Set the window that has the focus.
+        """
         return _core_.NavigationKeyEvent_SetCurrentFocus(*args, **kwargs)
 
     IsBackward = _core_.NavigationKeyEvent_IsBackward
     IsForward = _core_.NavigationKeyEvent_IsForward
     WinChange = _core_.NavigationKeyEvent_WinChange
         return _core_.NavigationKeyEvent_SetCurrentFocus(*args, **kwargs)
 
     IsBackward = _core_.NavigationKeyEvent_IsBackward
     IsForward = _core_.NavigationKeyEvent_IsForward
     WinChange = _core_.NavigationKeyEvent_WinChange
+    FromTab = _core_.NavigationKeyEvent_FromTab
 
 class NavigationKeyEventPtr(NavigationKeyEvent):
     def __init__(self, this):
 
 class NavigationKeyEventPtr(NavigationKeyEvent):
     def __init__(self, this):
@@ -4569,17 +6364,29 @@ _core_.NavigationKeyEvent_swigregister(NavigationKeyEventPtr)
 #---------------------------------------------------------------------------
 
 class WindowCreateEvent(CommandEvent):
 #---------------------------------------------------------------------------
 
 class WindowCreateEvent(CommandEvent):
-    """Proxy of C++ WindowCreateEvent class"""
+    """
+    The EVT_WINDOW_CREATE event is sent as soon as the window object (the
+    underlying GUI object) exists.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxWindowCreateEvent 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++ wxWindowCreateEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, Window win=None) -> WindowCreateEvent"""
+        """
+        __init__(self, Window win=None) -> WindowCreateEvent
+
+        The EVT_WINDOW_CREATE event is sent as soon as the window object (the
+        underlying GUI object) exists.
+        """
         newobj = _core_.new_WindowCreateEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetWindow(*args, **kwargs):
         newobj = _core_.new_WindowCreateEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetWindow(*args, **kwargs):
-        """GetWindow(self) -> Window"""
+        """
+        GetWindow(self) -> Window
+
+        Returns the window that this event refers to.
+        """
         return _core_.WindowCreateEvent_GetWindow(*args, **kwargs)
 
 
         return _core_.WindowCreateEvent_GetWindow(*args, **kwargs)
 
 
@@ -4591,17 +6398,29 @@ class WindowCreateEventPtr(WindowCreateEvent):
 _core_.WindowCreateEvent_swigregister(WindowCreateEventPtr)
 
 class WindowDestroyEvent(CommandEvent):
 _core_.WindowCreateEvent_swigregister(WindowCreateEventPtr)
 
 class WindowDestroyEvent(CommandEvent):
-    """Proxy of C++ WindowDestroyEvent class"""
+    """
+    The EVT_WINDOW_DESTROY event is sent right before the window is
+    destroyed.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxWindowDestroyEvent 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++ wxWindowDestroyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, Window win=None) -> WindowDestroyEvent"""
+        """
+        __init__(self, Window win=None) -> WindowDestroyEvent
+
+        The EVT_WINDOW_DESTROY event is sent right before the window is
+        destroyed.
+        """
         newobj = _core_.new_WindowDestroyEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetWindow(*args, **kwargs):
         newobj = _core_.new_WindowDestroyEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetWindow(*args, **kwargs):
-        """GetWindow(self) -> Window"""
+        """
+        GetWindow(self) -> Window
+
+        Returns the window that this event refers to.
+        """
         return _core_.WindowDestroyEvent_GetWindow(*args, **kwargs)
 
 
         return _core_.WindowDestroyEvent_GetWindow(*args, **kwargs)
 
 
@@ -4615,21 +6434,37 @@ _core_.WindowDestroyEvent_swigregister(WindowDestroyEventPtr)
 #---------------------------------------------------------------------------
 
 class ContextMenuEvent(CommandEvent):
 #---------------------------------------------------------------------------
 
 class ContextMenuEvent(CommandEvent):
-    """Proxy of C++ ContextMenuEvent class"""
+    """
+    This class is used for context menu events (EVT_CONTECT_MENU,) sent to
+    give the application a chance to show a context (popup) menu.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxContextMenuEvent 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++ wxContextMenuEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, wxEventType type=wxEVT_NULL, int winid=0, Point pt=DefaultPosition) -> ContextMenuEvent"""
+        """
+        __init__(self, wxEventType type=wxEVT_NULL, int winid=0, Point pt=DefaultPosition) -> ContextMenuEvent
+
+        Constructor.
+        """
         newobj = _core_.new_ContextMenuEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetPosition(*args, **kwargs):
         newobj = _core_.new_ContextMenuEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def GetPosition(*args, **kwargs):
-        """GetPosition(self) -> Point"""
+        """
+        GetPosition(self) -> Point
+
+        Returns the position (in screen coordinants) at which the menu should
+        be shown.
+        """
         return _core_.ContextMenuEvent_GetPosition(*args, **kwargs)
 
     def SetPosition(*args, **kwargs):
         return _core_.ContextMenuEvent_GetPosition(*args, **kwargs)
 
     def SetPosition(*args, **kwargs):
-        """SetPosition(self, Point pos)"""
+        """
+        SetPosition(self, Point pos)
+
+        Sets the position at which the menu should be shown.
+        """
         return _core_.ContextMenuEvent_SetPosition(*args, **kwargs)
 
 
         return _core_.ContextMenuEvent_SetPosition(*args, **kwargs)
 
 
@@ -4645,35 +6480,102 @@ _core_.ContextMenuEvent_swigregister(ContextMenuEventPtr)
 IDLE_PROCESS_ALL = _core_.IDLE_PROCESS_ALL
 IDLE_PROCESS_SPECIFIED = _core_.IDLE_PROCESS_SPECIFIED
 class IdleEvent(Event):
 IDLE_PROCESS_ALL = _core_.IDLE_PROCESS_ALL
 IDLE_PROCESS_SPECIFIED = _core_.IDLE_PROCESS_SPECIFIED
 class IdleEvent(Event):
-    """Proxy of C++ IdleEvent class"""
+    """
+    This class is used for EVT_IDLE events, which are generated and sent
+    when the application *becomes* idle.  In other words, the when the
+    event queue becomes empty then idle events are sent to all windows (by
+    default) and as long as none of them call `RequestMore` then there are
+    no more idle events until after the system event queue has some normal
+    events and then becomes empty again.
+
+    By default, idle events are sent to all windows. If this is causing a
+    significant overhead in your application, you can call
+    `wx.IdleEvent.SetMode` with the value wx.IDLE_PROCESS_SPECIFIED, and
+    set the wx.WS_EX_PROCESS_IDLE extra window style for every window
+    which should receive idle events.  Then idle events will only be sent
+    to those windows and not to any others.
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxIdleEvent 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++ wxIdleEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self) -> IdleEvent"""
+        """
+        __init__(self) -> IdleEvent
+
+        Constructor
+        """
         newobj = _core_.new_IdleEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def RequestMore(*args, **kwargs):
         newobj = _core_.new_IdleEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
     def RequestMore(*args, **kwargs):
-        """RequestMore(self, bool needMore=True)"""
+        """
+        RequestMore(self, bool needMore=True)
+
+        Tells wxWidgets that more processing is required. This function can be
+        called by an EVT_IDLE handler for a window to indicate that the
+        application should forward the EVT_IDLE event once more to the
+        application windows. If no window calls this function during its
+        EVT_IDLE handler, then the application will remain in a passive event
+        loop until a new event is posted to the application by the windowing
+        system.
+        """
         return _core_.IdleEvent_RequestMore(*args, **kwargs)
 
     def MoreRequested(*args, **kwargs):
         return _core_.IdleEvent_RequestMore(*args, **kwargs)
 
     def MoreRequested(*args, **kwargs):
-        """MoreRequested(self) -> bool"""
+        """
+        MoreRequested(self) -> bool
+
+        Returns ``True`` if the OnIdle function processing this event
+        requested more processing time.
+        """
         return _core_.IdleEvent_MoreRequested(*args, **kwargs)
 
     def SetMode(*args, **kwargs):
         return _core_.IdleEvent_MoreRequested(*args, **kwargs)
 
     def SetMode(*args, **kwargs):
-        """SetMode(int mode)"""
+        """
+        SetMode(int mode)
+
+        Static method for specifying how wxWidgets will send idle events: to
+        all windows, or only to those which specify that they will process the
+        events.
+
+        The mode can be one of the following values:
+
+            =========================   ========================================
+            wx.IDLE_PROCESS_ALL         Send idle events to all windows
+            wx.IDLE_PROCESS_SPECIFIED   Send idle events only to windows that have
+                                        the wx.WS_EX_PROCESS_IDLE extra style
+                                        flag set.
+            =========================   ========================================
+
+        """
         return _core_.IdleEvent_SetMode(*args, **kwargs)
 
     SetMode = staticmethod(SetMode)
     def GetMode(*args, **kwargs):
         return _core_.IdleEvent_SetMode(*args, **kwargs)
 
     SetMode = staticmethod(SetMode)
     def GetMode(*args, **kwargs):
-        """GetMode() -> int"""
+        """
+        GetMode() -> int
+
+        Static method returning a value specifying how wxWidgets will send
+        idle events: to all windows, or only to those which specify that they
+        will process the events.
+        """
         return _core_.IdleEvent_GetMode(*args, **kwargs)
 
     GetMode = staticmethod(GetMode)
     def CanSend(*args, **kwargs):
         return _core_.IdleEvent_GetMode(*args, **kwargs)
 
     GetMode = staticmethod(GetMode)
     def CanSend(*args, **kwargs):
-        """CanSend(Window win) -> bool"""
+        """
+        CanSend(Window win) -> bool
+
+        Returns ``True`` if it is appropriate to send idle events to this
+        window.
+
+        This function looks at the mode used (see `wx.IdleEvent.SetMode`), and
+        the wx.WS_EX_PROCESS_IDLE style in window to determine whether idle
+        events should be sent to this window now. By default this will always
+        return ``True`` because the update mode is initially
+        wx.IDLE_PROCESS_ALL. You can change the mode to only send idle events
+        to windows with the wx.WS_EX_PROCESS_IDLE extra window style set.
+        """
         return _core_.IdleEvent_CanSend(*args, **kwargs)
 
     CanSend = staticmethod(CanSend)
         return _core_.IdleEvent_CanSend(*args, **kwargs)
 
     CanSend = staticmethod(CanSend)
@@ -4686,30 +6588,73 @@ class IdleEventPtr(IdleEvent):
 _core_.IdleEvent_swigregister(IdleEventPtr)
 
 def IdleEvent_SetMode(*args, **kwargs):
 _core_.IdleEvent_swigregister(IdleEventPtr)
 
 def IdleEvent_SetMode(*args, **kwargs):
-    """IdleEvent_SetMode(int mode)"""
+    """
+    IdleEvent_SetMode(int mode)
+
+    Static method for specifying how wxWidgets will send idle events: to
+    all windows, or only to those which specify that they will process the
+    events.
+
+    The mode can be one of the following values:
+
+        =========================   ========================================
+        wx.IDLE_PROCESS_ALL         Send idle events to all windows
+        wx.IDLE_PROCESS_SPECIFIED   Send idle events only to windows that have
+                                    the wx.WS_EX_PROCESS_IDLE extra style
+                                    flag set.
+        =========================   ========================================
+
+    """
     return _core_.IdleEvent_SetMode(*args, **kwargs)
 
 def IdleEvent_GetMode(*args, **kwargs):
     return _core_.IdleEvent_SetMode(*args, **kwargs)
 
 def IdleEvent_GetMode(*args, **kwargs):
-    """IdleEvent_GetMode() -> int"""
+    """
+    IdleEvent_GetMode() -> int
+
+    Static method returning a value specifying how wxWidgets will send
+    idle events: to all windows, or only to those which specify that they
+    will process the events.
+    """
     return _core_.IdleEvent_GetMode(*args, **kwargs)
 
 def IdleEvent_CanSend(*args, **kwargs):
     return _core_.IdleEvent_GetMode(*args, **kwargs)
 
 def IdleEvent_CanSend(*args, **kwargs):
-    """IdleEvent_CanSend(Window win) -> bool"""
+    """
+    IdleEvent_CanSend(Window win) -> bool
+
+    Returns ``True`` if it is appropriate to send idle events to this
+    window.
+
+    This function looks at the mode used (see `wx.IdleEvent.SetMode`), and
+    the wx.WS_EX_PROCESS_IDLE style in window to determine whether idle
+    events should be sent to this window now. By default this will always
+    return ``True`` because the update mode is initially
+    wx.IDLE_PROCESS_ALL. You can change the mode to only send idle events
+    to windows with the wx.WS_EX_PROCESS_IDLE extra window style set.
+    """
     return _core_.IdleEvent_CanSend(*args, **kwargs)
 
 #---------------------------------------------------------------------------
 
 class PyEvent(Event):
     return _core_.IdleEvent_CanSend(*args, **kwargs)
 
 #---------------------------------------------------------------------------
 
 class PyEvent(Event):
-    """Proxy of C++ PyEvent class"""
+    """
+    wx.PyEvent can be used as a base class for implementing custom event
+    types in Python.  You should derived from this class instead of
+    `wx.Event` because this class is Python-aware and is able to transport
+    its Python bits safely through the wxWidgets event system and have
+    them still be there when the event handler is invoked.
+
+    :see: `wx.PyCommandEvent`
+
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxPyEvent 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++ wxPyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, int winid=0, wxEventType commandType=wxEVT_NULL) -> PyEvent"""
+        """__init__(self, int winid=0, wxEventType eventType=wxEVT_NULL) -> PyEvent"""
         newobj = _core_.new_PyEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
         newobj = _core_.new_PyEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
-        self.SetSelf(self)
+        self._SetSelf(self)
 
     def __del__(self, destroy=_core_.delete_PyEvent):
         """__del__(self)"""
 
     def __del__(self, destroy=_core_.delete_PyEvent):
         """__del__(self)"""
@@ -4717,13 +6662,13 @@ class PyEvent(Event):
             if self.thisown: destroy(self)
         except: pass
 
             if self.thisown: destroy(self)
         except: pass
 
-    def SetSelf(*args, **kwargs):
-        """SetSelf(self, PyObject self)"""
-        return _core_.PyEvent_SetSelf(*args, **kwargs)
+    def _SetSelf(*args, **kwargs):
+        """_SetSelf(self, PyObject self)"""
+        return _core_.PyEvent__SetSelf(*args, **kwargs)
 
 
-    def GetSelf(*args, **kwargs):
-        """GetSelf(self) -> PyObject"""
-        return _core_.PyEvent_GetSelf(*args, **kwargs)
+    def _GetSelf(*args, **kwargs):
+        """_GetSelf(self) -> PyObject"""
+        return _core_.PyEvent__GetSelf(*args, **kwargs)
 
 
 class PyEventPtr(PyEvent):
 
 
 class PyEventPtr(PyEvent):
@@ -4734,16 +6679,26 @@ class PyEventPtr(PyEvent):
 _core_.PyEvent_swigregister(PyEventPtr)
 
 class PyCommandEvent(CommandEvent):
 _core_.PyEvent_swigregister(PyEventPtr)
 
 class PyCommandEvent(CommandEvent):
-    """Proxy of C++ PyCommandEvent class"""
+    """
+    wx.PyCommandEvent can be used as a base class for implementing custom
+    event types in Python, where the event shoudl travel up to parent
+    windows looking for a handler.  You should derived from this class
+    instead of `wx.CommandEvent` because this class is Python-aware and is
+    able to transport its Python bits safely through the wxWidgets event
+    system and have them still be there when the event handler is invoked.
+
+    :see: `wx.PyEvent`
+
+    """
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxPyCommandEvent 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++ wxPyCommandEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(self, wxEventType commandType=wxEVT_NULL, int id=0) -> PyCommandEvent"""
+        """__init__(self, wxEventType eventType=wxEVT_NULL, int id=0) -> PyCommandEvent"""
         newobj = _core_.new_PyCommandEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
         newobj = _core_.new_PyCommandEvent(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
-        self.SetSelf(self)
+        self._SetSelf(self)
 
     def __del__(self, destroy=_core_.delete_PyCommandEvent):
         """__del__(self)"""
 
     def __del__(self, destroy=_core_.delete_PyCommandEvent):
         """__del__(self)"""
@@ -4751,13 +6706,13 @@ class PyCommandEvent(CommandEvent):
             if self.thisown: destroy(self)
         except: pass
 
             if self.thisown: destroy(self)
         except: pass
 
-    def SetSelf(*args, **kwargs):
-        """SetSelf(self, PyObject self)"""
-        return _core_.PyCommandEvent_SetSelf(*args, **kwargs)
+    def _SetSelf(*args, **kwargs):
+        """_SetSelf(self, PyObject self)"""
+        return _core_.PyCommandEvent__SetSelf(*args, **kwargs)
 
 
-    def GetSelf(*args, **kwargs):
-        """GetSelf(self) -> PyObject"""
-        return _core_.PyCommandEvent_GetSelf(*args, **kwargs)
+    def _GetSelf(*args, **kwargs):
+        """_GetSelf(self) -> PyObject"""
+        return _core_.PyCommandEvent__GetSelf(*args, **kwargs)
 
 
 class PyCommandEventPtr(PyCommandEvent):
 
 
 class PyCommandEventPtr(PyCommandEvent):
@@ -4767,6 +6722,49 @@ class PyCommandEventPtr(PyCommandEvent):
         self.__class__ = PyCommandEvent
 _core_.PyCommandEvent_swigregister(PyCommandEventPtr)
 
         self.__class__ = PyCommandEvent
 _core_.PyCommandEvent_swigregister(PyCommandEventPtr)
 
+class DateEvent(CommandEvent):
+    """
+    This event class holds information about a date change event and is
+    used together with `wx.DatePickerCtrl`. It also serves as a base class
+    for `wx.calendar.CalendarEvent`.  Bind these event types with
+    EVT_DATE_CHANGED.
+    """
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxDateEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(self, Window win, DateTime dt, wxEventType type) -> DateEvent"""
+        newobj = _core_.new_DateEvent(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+    def GetDate(*args, **kwargs):
+        """
+        GetDate(self) -> DateTime
+
+        Returns the date.
+        """
+        return _core_.DateEvent_GetDate(*args, **kwargs)
+
+    def SetDate(*args, **kwargs):
+        """
+        SetDate(self, DateTime date)
+
+        Sets the date carried by the event, normally only used by the library
+        internally.
+        """
+        return _core_.DateEvent_SetDate(*args, **kwargs)
+
+
+class DateEventPtr(DateEvent):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = DateEvent
+_core_.DateEvent_swigregister(DateEventPtr)
+
+wxEVT_DATE_CHANGED = _core_.wxEVT_DATE_CHANGED
+EVT_DATE_CHANGED = wx.PyEventBinder( wxEVT_DATE_CHANGED, 1 )
+
 #---------------------------------------------------------------------------
 
 PYAPP_ASSERT_SUPPRESS = _core_.PYAPP_ASSERT_SUPPRESS
 #---------------------------------------------------------------------------
 
 PYAPP_ASSERT_SUPPRESS = _core_.PYAPP_ASSERT_SUPPRESS
@@ -4792,8 +6790,8 @@ class PyApp(EvtHandler):
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
-        self._setCallbackInfo(self, PyApp)
-        self._setOORInfo(self)
+        self._setCallbackInfo(self, PyApp, False)
+        self._setOORInfo(self, False)
 
     def __del__(self, destroy=_core_.delete_PyApp):
         """__del__(self)"""
 
     def __del__(self, destroy=_core_.delete_PyApp):
         """__del__(self)"""
@@ -4802,7 +6800,7 @@ class PyApp(EvtHandler):
         except: pass
 
     def _setCallbackInfo(*args, **kwargs):
         except: pass
 
     def _setCallbackInfo(*args, **kwargs):
-        """_setCallbackInfo(self, PyObject self, PyObject _class)"""
+        """_setCallbackInfo(self, PyObject self, PyObject _class, bool incref)"""
         return _core_.PyApp__setCallbackInfo(*args, **kwargs)
 
     def GetAppName(*args, **kwargs):
         return _core_.PyApp__setCallbackInfo(*args, **kwargs)
 
     def GetAppName(*args, **kwargs):
@@ -5284,6 +7282,12 @@ def SetDefaultPyEncoding(*args, **kwargs):
 
     Sets the encoding that wxPython will use when it needs to convert a
     Python string or unicode object to or from a wxString.
 
     Sets the encoding that wxPython will use when it needs to convert a
     Python string or unicode object to or from a wxString.
+
+    The default encoding is the value of ``locale.getdefaultlocale()[1]``
+    but please be aware that the default encoding within the same locale
+    may be slightly different on different platforms.  For example, please
+    see http://www.alanwood.net/demos/charsetdiffs.html for differences
+    between the common latin/roman encodings.
     """
     return _core_.SetDefaultPyEncoding(*args, **kwargs)
 
     """
     return _core_.SetDefaultPyEncoding(*args, **kwargs)
 
@@ -5469,12 +7473,13 @@ your Mac."""
         self._BootstrapApp()
 
 
         self._BootstrapApp()
 
 
-    def __del__(self):
-        try:
-            self.RestoreStdio()  # Just in case the MainLoop was overridden
-        except:
-            pass
+    def __del__(self, destroy=wx.PyApp.__del__):
+        self.RestoreStdio()  # Just in case the MainLoop was overridden
+        destroy(self)
 
 
+    def Destroy(self):
+        wx.PyApp.Destroy(self)
+        self.thisown = 0
 
     def SetTopWindow(self, frame):
         """Set the \"main\" top level window"""
 
     def SetTopWindow(self, frame):
         """Set the \"main\" top level window"""
@@ -5499,7 +7504,10 @@ your Mac."""
 
 
     def RestoreStdio(self):
 
 
     def RestoreStdio(self):
-        _sys.stdout, _sys.stderr = self.saveStdio
+        try:
+            _sys.stdout, _sys.stderr = self.saveStdio
+        except:
+            pass
 
 
     def SetOutputWindowAttributes(self, title=None, pos=None, size=None):
 
 
     def SetOutputWindowAttributes(self, title=None, pos=None, size=None):
@@ -6023,11 +8031,18 @@ class Window(EvtHandler):
 
         Sets the position and size of the window in pixels.  The sizeFlags
         parameter indicates the interpretation of the other params if they are
 
         Sets the position and size of the window in pixels.  The sizeFlags
         parameter indicates the interpretation of the other params if they are
-        -1.  wx.SIZE_AUTO*: a -1 indicates that a class-specific default
-        shoudl be used.  wx.SIZE_USE_EXISTING: existing dimensions should be
-        used if -1 values are supplied.  wxSIZE_ALLOW_MINUS_ONE: allow
-        dimensions of -1 and less to be interpreted as real dimensions, not
-        default values.
+        equal to -1.
+
+            ========================  ======================================
+            wx.SIZE_AUTO              A -1 indicates that a class-specific
+                                      default should be used.
+            wx.SIZE_USE_EXISTING      Axisting dimensions should be used if
+                                      -1 values are supplied.
+            wxSIZE_ALLOW_MINUS_ONE    Allow dimensions of -1 and less to be
+                                      interpreted as real dimensions, not
+                                      default values.
+            ========================  ======================================
+
         """
         return _core_.Window_SetDimensions(*args, **kwargs)
 
         """
         return _core_.Window_SetDimensions(*args, **kwargs)
 
@@ -6240,6 +8255,15 @@ class Window(EvtHandler):
         """
         return _core_.Window_InvalidateBestSize(*args, **kwargs)
 
         """
         return _core_.Window_InvalidateBestSize(*args, **kwargs)
 
+    def CacheBestSize(*args, **kwargs):
+        """
+        CacheBestSize(self, Size size)
+
+        Cache the best size so it doesn't need to be calculated again, (at least until
+        some properties of the window change.)
+        """
+        return _core_.Window_CacheBestSize(*args, **kwargs)
+
     def GetBestFittingSize(*args, **kwargs):
         """
         GetBestFittingSize(self) -> Size
     def GetBestFittingSize(*args, **kwargs):
         """
         GetBestFittingSize(self) -> Size
@@ -7087,7 +9111,7 @@ class Window(EvtHandler):
 
     def RefreshRect(*args, **kwargs):
         """
 
     def RefreshRect(*args, **kwargs):
         """
-        RefreshRect(self, Rect rect)
+        RefreshRect(self, Rect rect, bool eraseBackground=True)
 
         Redraws the contents of the given rectangle: the area inside it will
         be repainted.  This is the same as Refresh but has a nicer syntax.
 
         Redraws the contents of the given rectangle: the area inside it will
         be repainted.  This is the same as Refresh but has a nicer syntax.
@@ -7293,6 +9317,14 @@ class Window(EvtHandler):
         """
         return _core_.Window_GetForegroundColour(*args, **kwargs)
 
         """
         return _core_.Window_GetForegroundColour(*args, **kwargs)
 
+    def InheritsBackgroundColour(*args, **kwargs):
+        """InheritsBackgroundColour(self) -> bool"""
+        return _core_.Window_InheritsBackgroundColour(*args, **kwargs)
+
+    def UseBgCol(*args, **kwargs):
+        """UseBgCol(self) -> bool"""
+        return _core_.Window_UseBgCol(*args, **kwargs)
+
     def SetBackgroundStyle(*args, **kwargs):
         """
         SetBackgroundStyle(self, int style) -> bool
     def SetBackgroundStyle(*args, **kwargs):
         """
         SetBackgroundStyle(self, int style) -> bool
@@ -7326,6 +9358,21 @@ class Window(EvtHandler):
         """
         return _core_.Window_GetBackgroundStyle(*args, **kwargs)
 
         """
         return _core_.Window_GetBackgroundStyle(*args, **kwargs)
 
+    def HasTransparentBackground(*args, **kwargs):
+        """
+        HasTransparentBackground(self) -> bool
+
+        Returns True if this window's background is transparent (as, for
+        example, for `wx.StaticText`) and should show the parent window's
+        background.
+
+        This method is mostly used internally by the library itself and you
+        normally shouldn't have to call it. You may, however, have to override
+        it in your custom control classes to ensure that background is painted
+        correctly.
+        """
+        return _core_.Window_HasTransparentBackground(*args, **kwargs)
+
     def SetCursor(*args, **kwargs):
         """
         SetCursor(self, Cursor cursor) -> bool
     def SetCursor(*args, **kwargs):
         """
         SetCursor(self, Cursor cursor) -> bool
@@ -7484,7 +9531,7 @@ class Window(EvtHandler):
         function from your application to ensure that your UI is up-to-date at
         a particular point in time (as far as your EVT_UPDATE_UI handlers are
         concerned). This may be necessary if you have called
         function from your application to ensure that your UI is up-to-date at
         a particular point in time (as far as your EVT_UPDATE_UI handlers are
         concerned). This may be necessary if you have called
-        wx.UpdateUIEvent.SetMode or wx.UpdateUIEvent.SetUpdateInterval to
+        `wx.UpdateUIEvent.SetMode` or `wx.UpdateUIEvent.SetUpdateInterval` to
         limit the overhead that wxWindows incurs by sending update UI events
         in idle time.
         """
         limit the overhead that wxWindows incurs by sending update UI events
         in idle time.
         """
@@ -7724,6 +9771,15 @@ class Window(EvtHandler):
         """
         return _core_.Window_GetDropTarget(*args, **kwargs)
 
         """
         return _core_.Window_GetDropTarget(*args, **kwargs)
 
+    def DragAcceptFiles(*args, **kwargs):
+        """
+        DragAcceptFiles(self, bool accept)
+
+        Enables or disables eligibility for drop file events, EVT_DROP_FILES.
+        Only functional on Windows.
+        """
+        return _core_.Window_DragAcceptFiles(*args, **kwargs)
+
     def SetConstraints(*args, **kwargs):
         """
         SetConstraints(self, LayoutConstraints constraints)
     def SetConstraints(*args, **kwargs):
         """
         SetConstraints(self, LayoutConstraints constraints)
@@ -8025,6 +10081,18 @@ def FindWindowByLabel(*args, **kwargs):
 def Window_FromHWND(*args, **kwargs):
     """Window_FromHWND(Window parent, unsigned long _hWnd) -> Window"""
     return _core_.Window_FromHWND(*args, **kwargs)
 def Window_FromHWND(*args, **kwargs):
     """Window_FromHWND(Window parent, unsigned long _hWnd) -> Window"""
     return _core_.Window_FromHWND(*args, **kwargs)
+
+def GetTopLevelWindows(*args, **kwargs):
+    """
+    GetTopLevelWindows() -> PyObject
+
+    Returns a list of the the application's top-level windows, (frames,
+    dialogs, etc.)  NOTE: Currently this is a copy of the list maintained
+    by wxWidgets, and so it is only valid as long as no top-level windows
+    are closed or new top-level windows are created.
+
+    """
+    return _core_.GetTopLevelWindows(*args, **kwargs)
 #---------------------------------------------------------------------------
 
 class Validator(EvtHandler):
 #---------------------------------------------------------------------------
 
 class Validator(EvtHandler):
@@ -8479,6 +10547,16 @@ class MenuBar(Window):
         """Detach(self)"""
         return _core_.MenuBar_Detach(*args, **kwargs)
 
         """Detach(self)"""
         return _core_.MenuBar_Detach(*args, **kwargs)
 
+    def SetAutoWindowMenu(*args, **kwargs):
+        """SetAutoWindowMenu(bool enable)"""
+        return _core_.MenuBar_SetAutoWindowMenu(*args, **kwargs)
+
+    SetAutoWindowMenu = staticmethod(SetAutoWindowMenu)
+    def GetAutoWindowMenu(*args, **kwargs):
+        """GetAutoWindowMenu() -> bool"""
+        return _core_.MenuBar_GetAutoWindowMenu(*args, **kwargs)
+
+    GetAutoWindowMenu = staticmethod(GetAutoWindowMenu)
 
 class MenuBarPtr(MenuBar):
     def __init__(self, this):
 
 class MenuBarPtr(MenuBar):
     def __init__(self, this):
@@ -8487,6 +10565,14 @@ class MenuBarPtr(MenuBar):
         self.__class__ = MenuBar
 _core_.MenuBar_swigregister(MenuBarPtr)
 
         self.__class__ = MenuBar
 _core_.MenuBar_swigregister(MenuBarPtr)
 
+def MenuBar_SetAutoWindowMenu(*args, **kwargs):
+    """MenuBar_SetAutoWindowMenu(bool enable)"""
+    return _core_.MenuBar_SetAutoWindowMenu(*args, **kwargs)
+
+def MenuBar_GetAutoWindowMenu(*args, **kwargs):
+    """MenuBar_GetAutoWindowMenu() -> bool"""
+    return _core_.MenuBar_GetAutoWindowMenu(*args, **kwargs)
+
 #---------------------------------------------------------------------------
 
 class MenuItem(Object):
 #---------------------------------------------------------------------------
 
 class MenuItem(Object):
@@ -8604,11 +10690,67 @@ class MenuItem(Object):
         """SetAccel(self, AcceleratorEntry accel)"""
         return _core_.MenuItem_SetAccel(*args, **kwargs)
 
         """SetAccel(self, AcceleratorEntry accel)"""
         return _core_.MenuItem_SetAccel(*args, **kwargs)
 
+    def SetFont(*args, **kwargs):
+        """SetFont(self, Font font)"""
+        return _core_.MenuItem_SetFont(*args, **kwargs)
+
+    def GetFont(*args, **kwargs):
+        """GetFont(self) -> Font"""
+        return _core_.MenuItem_GetFont(*args, **kwargs)
+
+    def SetTextColour(*args, **kwargs):
+        """SetTextColour(self, Colour colText)"""
+        return _core_.MenuItem_SetTextColour(*args, **kwargs)
+
+    def GetTextColour(*args, **kwargs):
+        """GetTextColour(self) -> Colour"""
+        return _core_.MenuItem_GetTextColour(*args, **kwargs)
+
+    def SetBackgroundColour(*args, **kwargs):
+        """SetBackgroundColour(self, Colour colBack)"""
+        return _core_.MenuItem_SetBackgroundColour(*args, **kwargs)
+
+    def GetBackgroundColour(*args, **kwargs):
+        """GetBackgroundColour(self) -> Colour"""
+        return _core_.MenuItem_GetBackgroundColour(*args, **kwargs)
+
+    def SetBitmaps(*args, **kwargs):
+        """SetBitmaps(self, Bitmap bmpChecked, Bitmap bmpUnchecked=wxNullBitmap)"""
+        return _core_.MenuItem_SetBitmaps(*args, **kwargs)
+
+    def SetDisabledBitmap(*args, **kwargs):
+        """SetDisabledBitmap(self, Bitmap bmpDisabled)"""
+        return _core_.MenuItem_SetDisabledBitmap(*args, **kwargs)
+
+    def GetDisabledBitmap(*args, **kwargs):
+        """GetDisabledBitmap(self) -> Bitmap"""
+        return _core_.MenuItem_GetDisabledBitmap(*args, **kwargs)
+
+    def SetMarginWidth(*args, **kwargs):
+        """SetMarginWidth(self, int nWidth)"""
+        return _core_.MenuItem_SetMarginWidth(*args, **kwargs)
+
+    def GetMarginWidth(*args, **kwargs):
+        """GetMarginWidth(self) -> int"""
+        return _core_.MenuItem_GetMarginWidth(*args, **kwargs)
+
     def GetDefaultMarginWidth(*args, **kwargs):
         """GetDefaultMarginWidth() -> int"""
         return _core_.MenuItem_GetDefaultMarginWidth(*args, **kwargs)
 
     GetDefaultMarginWidth = staticmethod(GetDefaultMarginWidth)
     def GetDefaultMarginWidth(*args, **kwargs):
         """GetDefaultMarginWidth() -> int"""
         return _core_.MenuItem_GetDefaultMarginWidth(*args, **kwargs)
 
     GetDefaultMarginWidth = staticmethod(GetDefaultMarginWidth)
+    def IsOwnerDrawn(*args, **kwargs):
+        """IsOwnerDrawn(self) -> bool"""
+        return _core_.MenuItem_IsOwnerDrawn(*args, **kwargs)
+
+    def SetOwnerDrawn(*args, **kwargs):
+        """SetOwnerDrawn(self, bool ownerDrawn=True)"""
+        return _core_.MenuItem_SetOwnerDrawn(*args, **kwargs)
+
+    def ResetOwnerDrawn(*args, **kwargs):
+        """ResetOwnerDrawn(self)"""
+        return _core_.MenuItem_ResetOwnerDrawn(*args, **kwargs)
+
     def SetBitmap(*args, **kwargs):
         """SetBitmap(self, Bitmap bitmap)"""
         return _core_.MenuItem_SetBitmap(*args, **kwargs)
     def SetBitmap(*args, **kwargs):
         """SetBitmap(self, Bitmap bitmap)"""
         return _core_.MenuItem_SetBitmap(*args, **kwargs)
@@ -8754,10 +10896,10 @@ def Control_GetClassDefaultAttributes(*args, **kwargs):
 
 class ItemContainer(object):
     """
 
 class ItemContainer(object):
     """
-    wx.ItemContainer defines an interface which is implemented by all
-    controls which have string subitems, each of which may be selected,
-    such as `wx.ListBox`, `wx.CheckListBox`, `wx.Choice` as well as
-    `wx.ComboBox` which implements an extended interface deriving from
+    The wx.ItemContainer class defines an interface which is implemented
+    by all controls which have string subitems, each of which may be
+    selected, such as `wx.ListBox`, `wx.CheckListBox`, `wx.Choice` as well
+    as `wx.ComboBox` which implements an extended interface deriving from
     this one.
 
     It defines the methods for accessing the control's items and although
     this one.
 
     It defines the methods for accessing the control's items and although
@@ -8820,6 +10962,22 @@ class ItemContainer(object):
         """
         return _core_.ItemContainer_Delete(*args, **kwargs)
 
         """
         return _core_.ItemContainer_Delete(*args, **kwargs)
 
+    def GetClientData(*args, **kwargs):
+        """
+        GetClientData(self, int n) -> PyObject
+
+        Returns the client data associated with the given item, (if any.)
+        """
+        return _core_.ItemContainer_GetClientData(*args, **kwargs)
+
+    def SetClientData(*args, **kwargs):
+        """
+        SetClientData(self, int n, PyObject clientData)
+
+        Associate the given client data with the item at position n.
+        """
+        return _core_.ItemContainer_SetClientData(*args, **kwargs)
+
     def GetCount(*args, **kwargs):
         """
         GetCount(self) -> int
     def GetCount(*args, **kwargs):
         """
         GetCount(self) -> int
@@ -8866,15 +11024,14 @@ class ItemContainer(object):
         """
         return _core_.ItemContainer_FindString(*args, **kwargs)
 
         """
         return _core_.ItemContainer_FindString(*args, **kwargs)
 
-    def Select(*args, **kwargs):
+    def SetSelection(*args, **kwargs):
         """
         """
-        Select(self, int n)
+        SetSelection(self, int n)
 
         Sets the item at index 'n' to be the selected item.
         """
 
         Sets the item at index 'n' to be the selected item.
         """
-        return _core_.ItemContainer_Select(*args, **kwargs)
+        return _core_.ItemContainer_SetSelection(*args, **kwargs)
 
 
-    SetSelection = Select 
     def GetSelection(*args, **kwargs):
         """
         GetSelection(self) -> int
     def GetSelection(*args, **kwargs):
         """
         GetSelection(self) -> int
@@ -8884,6 +11041,10 @@ class ItemContainer(object):
         """
         return _core_.ItemContainer_GetSelection(*args, **kwargs)
 
         """
         return _core_.ItemContainer_GetSelection(*args, **kwargs)
 
+    def SetStringSelection(*args, **kwargs):
+        """SetStringSelection(self, String s) -> bool"""
+        return _core_.ItemContainer_SetStringSelection(*args, **kwargs)
+
     def GetStringSelection(*args, **kwargs):
         """
         GetStringSelection(self) -> String
     def GetStringSelection(*args, **kwargs):
         """
         GetStringSelection(self) -> String
@@ -8893,21 +11054,14 @@ class ItemContainer(object):
         """
         return _core_.ItemContainer_GetStringSelection(*args, **kwargs)
 
         """
         return _core_.ItemContainer_GetStringSelection(*args, **kwargs)
 
-    def GetClientData(*args, **kwargs):
-        """
-        GetClientData(self, int n) -> PyObject
-
-        Returns the client data associated with the given item, (if any.)
-        """
-        return _core_.ItemContainer_GetClientData(*args, **kwargs)
-
-    def SetClientData(*args, **kwargs):
+    def Select(*args, **kwargs):
         """
         """
-        SetClientData(self, int n, PyObject clientData)
+        Select(self, int n)
 
 
-        Associate the given client data with the item at position n.
+        This is the same as `SetSelection` and exists only because it is
+        slightly more natural for controls which support multiple selection.
         """
         """
-        return _core_.ItemContainer_SetClientData(*args, **kwargs)
+        return _core_.ItemContainer_Select(*args, **kwargs)
 
 
 class ItemContainerPtr(ItemContainer):
 
 
 class ItemContainerPtr(ItemContainer):
@@ -9428,18 +11582,45 @@ class Sizer(Object):
             self.Add(*item)
 
     # for backwards compatibility only, please do not use in new code
             self.Add(*item)
 
     # for backwards compatibility only, please do not use in new code
-    AddWindow     = wx._deprecated(Add, "AddWindow is deprecated, use `Add` instead.")
-    AddSizer      = wx._deprecated(Add, "AddSizer is deprecated, use `Add` instead.")
-    AddSpacer     = wx._deprecated(Add, "AddSpacer is deprecated, use `Add` instead.")
-    PrependWindow = wx._deprecated(Prepend, "PrependWindow is deprecated, use `Prepend` instead.")
-    PrependSizer  = wx._deprecated(Prepend, "PrependSizer is deprecated, use `Prepend` instead.")
-    PrependSpacer = wx._deprecated(Prepend, "PrependSpacer is deprecated, use `Prepend` instead.")
-    InsertWindow  = wx._deprecated(Insert, "InsertWindow is deprecated, use `Insert` instead.")
-    InsertSizer   = wx._deprecated(Insert, "InsertSizer is deprecated, use `Insert` instead.")
-    InsertSpacer  = wx._deprecated(Insert, "InsertSpacer is deprecated, use `Insert` instead.")
-    RemoveWindow  = wx._deprecated(Remove, "RemoveWindow is deprecated, use `Remove` instead.")
-    RemoveSizer   = wx._deprecated(Remove, "RemoveSizer is deprecated, use `Remove` instead.")
-    RemovePos     = wx._deprecated(Remove, "RemovePos is deprecated, use `Remove` instead.")
+    def AddWindow(self, *args, **kw):
+        """Compatibility alias for `Add`."""
+        return self.Add(*args, **kw)
+    def AddSizer(self, *args, **kw):
+        """Compatibility alias for `Add`."""
+        return self.Add(*args, **kw)
+    def AddSpacer(self, *args, **kw):
+        """Compatibility alias for `Add`."""
+        return self.Add(*args, **kw)
+
+    def PrependWindow(self, *args, **kw):
+        """Compatibility alias for `Prepend`."""
+        return self.Prepend(*args, **kw)
+    def PrependSizer(self, *args, **kw):
+        """Compatibility alias for `Prepend`."""
+        return self.Prepend(*args, **kw)
+    def PrependSpacer(self, *args, **kw):
+        """Compatibility alias for `Prepend`."""
+        return self.Prepend(*args, **kw)
+
+    def InsertWindow(self, *args, **kw):
+        """Compatibility alias for `Insert`."""
+        return self.Insert(*args, **kw)
+    def InsertSizer(self, *args, **kw):
+        """Compatibility alias for `Insert`."""
+        return self.Insert(*args, **kw)
+    def InsertSpacer(self, *args, **kw):
+        """Compatibility alias for `Insert`."""
+        return self.Insert(*args, **kw)
+
+    def RemoveWindow(self, *args, **kw):
+        """Compatibility alias for `Remove`."""
+        return self.Remove(*args, **kw)
+    def RemoveSizer(self, *args, **kw):
+        """Compatibility alias for `Remove`."""
+        return self.Remove(*args, **kw)
+    def RemovePos(self, *args, **kw):
+        """Compatibility alias for `Remove`."""
+        return self.Remove(*args, **kw)
 
 
     def SetDimension(*args, **kwargs):
 
 
     def SetDimension(*args, **kwargs):
@@ -9603,7 +11784,7 @@ class Sizer(Object):
 
     def GetChildren(*args, **kwargs):
         """
 
     def GetChildren(*args, **kwargs):
         """
-        GetChildren(sefl) -> list
+        GetChildren(self) -> list
 
         Returns a list of all the `wx.SizerItem` objects managed by the sizer.
         """
 
         Returns a list of all the `wx.SizerItem` objects managed by the sizer.
         """
@@ -9634,7 +11815,7 @@ class Sizer(Object):
 
     def Hide(self, item, recursive=False):
         """
 
     def Hide(self, item, recursive=False):
         """
-        A convenience method for Show(item, False, recursive).
+        A convenience method for `Show` (item, False, recursive).
         """
         return self.Show(item, False, recursive)
 
         """
         return self.Show(item, False, recursive)
 
@@ -9690,7 +11871,7 @@ class PySizer(Sizer):
 
     When `Layout` is called it first calls `CalcMin` followed by
     `RecalcSizes` so you can optimize a bit by saving the results of
 
     When `Layout` is called it first calls `CalcMin` followed by
     `RecalcSizes` so you can optimize a bit by saving the results of
-    `CalcMin` and resuing them in `RecalcSizes`.
+    `CalcMin` and reusing them in `RecalcSizes`.
 
     :see: `wx.SizerItem`, `wx.Sizer.GetChildren`
 
 
     :see: `wx.SizerItem`, `wx.Sizer.GetChildren`
 
@@ -10098,6 +12279,82 @@ class FlexGridSizerPtr(FlexGridSizer):
         self.__class__ = FlexGridSizer
 _core_.FlexGridSizer_swigregister(FlexGridSizerPtr)
 
         self.__class__ = FlexGridSizer
 _core_.FlexGridSizer_swigregister(FlexGridSizerPtr)
 
+class StdDialogButtonSizer(BoxSizer):
+    """
+    A special sizer that knows how to order and position standard buttons
+    in order to conform to the current platform's standards.  You simply
+    need to add each `wx.Button` to the sizer, and be sure to create the
+    buttons using the standard ID's.  Then call `Realize` and the sizer
+    will take care of the rest.
+
+    """
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxStdDialogButtonSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(self) -> StdDialogButtonSizer"""
+        newobj = _core_.new_StdDialogButtonSizer(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+    def AddButton(*args, **kwargs):
+        """
+        AddButton(self, wxButton button)
+
+        Use this to add the buttons to this sizer.  Do not use the `Add`
+        method in the base class.
+        """
+        return _core_.StdDialogButtonSizer_AddButton(*args, **kwargs)
+
+    def Realize(*args, **kwargs):
+        """
+        Realize(self)
+
+        This funciton needs to be called after all the buttons have been added
+        to the sizer.  It will reorder them and position them in a platform
+        specifc manner.
+        """
+        return _core_.StdDialogButtonSizer_Realize(*args, **kwargs)
+
+    def SetAffirmativeButton(*args, **kwargs):
+        """SetAffirmativeButton(self, wxButton button)"""
+        return _core_.StdDialogButtonSizer_SetAffirmativeButton(*args, **kwargs)
+
+    def SetNegativeButton(*args, **kwargs):
+        """SetNegativeButton(self, wxButton button)"""
+        return _core_.StdDialogButtonSizer_SetNegativeButton(*args, **kwargs)
+
+    def SetCancelButton(*args, **kwargs):
+        """SetCancelButton(self, wxButton button)"""
+        return _core_.StdDialogButtonSizer_SetCancelButton(*args, **kwargs)
+
+    def GetAffirmativeButton(*args, **kwargs):
+        """GetAffirmativeButton(self) -> wxButton"""
+        return _core_.StdDialogButtonSizer_GetAffirmativeButton(*args, **kwargs)
+
+    def GetApplyButton(*args, **kwargs):
+        """GetApplyButton(self) -> wxButton"""
+        return _core_.StdDialogButtonSizer_GetApplyButton(*args, **kwargs)
+
+    def GetNegativeButton(*args, **kwargs):
+        """GetNegativeButton(self) -> wxButton"""
+        return _core_.StdDialogButtonSizer_GetNegativeButton(*args, **kwargs)
+
+    def GetCancelButton(*args, **kwargs):
+        """GetCancelButton(self) -> wxButton"""
+        return _core_.StdDialogButtonSizer_GetCancelButton(*args, **kwargs)
+
+    def GetHelpButton(*args, **kwargs):
+        """GetHelpButton(self) -> wxButton"""
+        return _core_.StdDialogButtonSizer_GetHelpButton(*args, **kwargs)
+
+
+class StdDialogButtonSizerPtr(StdDialogButtonSizer):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = StdDialogButtonSizer
+_core_.StdDialogButtonSizer_swigregister(StdDialogButtonSizerPtr)
+
 #---------------------------------------------------------------------------
 
 class GBPosition(object):
 #---------------------------------------------------------------------------
 
 class GBPosition(object):
@@ -10899,13 +13156,32 @@ if RELEASE_VERSION != _core_.RELEASE_VERSION:
 
 #----------------------------------------------------------------------------
 
 
 #----------------------------------------------------------------------------
 
-# Set the default string conversion encoding from the locale
-import locale
-default = locale.getdefaultlocale()[1]
+# Set wxPython's default string<-->unicode conversion encoding from
+# the locale, but only if Python's default hasn't been changed.  (We
+# assume that if the user has customized it already then that is the
+# encoding we need to use as well.)
+#
+# The encoding selected here is used when string or unicode objects
+# need to be converted in order to pass them to wxWidgets.  Please be
+# aware that the default encoding within the same locale may be
+# slightly different on different platforms.  For example, please see
+# http://www.alanwood.net/demos/charsetdiffs.html for differences
+# between the common latin/roman encodings.
+
+default = _sys.getdefaultencoding()
+if default == 'ascii':
+    import locale
+    import codecs
+    try:
+        default = locale.getdefaultlocale()[1]
+        codecs.lookup(default)
+    except (ValueError, LookupError, TypeError):
+        default = _sys.getdefaultencoding()
+    del locale
+    del codecs
 if default:
     wx.SetDefaultPyEncoding(default)
 del default
 if default:
     wx.SetDefaultPyEncoding(default)
 del default
-del locale
 
 #----------------------------------------------------------------------------
 
 
 #----------------------------------------------------------------------------