Get/SetTitle only for wxTopLevelWindow (wxGTK part).

[wxWidgets.git] / wxPython / src / gtk / _core.py

diff --git a/wxPython/src/gtk/_core.py b/wxPython/src/gtk/_core.py
index 156482c38bc5d858ce50c8c4e4180c2d7fd39ba6..c3cdc53e95f49dcbc6b61c97e6c6ea3b41725f4b 100644 (file)
--- a/wxPython/src/gtk/_core.py
+++ b/wxPython/src/gtk/_core.py
@@ -372,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


@@ -594,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


@@ -2041,7 +2093,11 @@ 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,)


@@ -2101,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
         """


@@ -2129,7 +2185,7 @@ class ImageHistogram(object):
 
     def GetCountRGB(*args, **kwargs):
         """
 
     def GetCountRGB(*args, **kwargs):
         """

-        GetCountRGB(self, unsigned char r, unsigned char g, unsigned char b) -> unsigned long
+        GetCountRGB(self, byte r, byte g, byte b) -> unsigned long

 
         Returns the pixel count for the given RGB values.
         """
 
         Returns the pixel count for the given RGB values.
         """


@@ -2153,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


@@ -2176,63 +2261,143 @@ 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)
 
     def Resize(*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"""
+        """
+        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):
         return _core_.Image_Resize(*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)
 
     def SetRGBRect(*args, **kwargs):
         return _core_.Image_SetRGB(*args, **kwargs)
 
     def SetRGBRect(*args, **kwargs):

-        """SetRGBRect(self, Rect rect, unsigned char r, unsigned char g, unsigned char b)"""
+        """
+        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):
         return _core_.Image_SetRGBRect(*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)
 
     def InitAlpha(*args, **kwargs):
         return _core_.Image_HasAlpha(*args, **kwargs)
 
     def InitAlpha(*args, **kwargs):


@@ -2248,10 +2413,10 @@ class Image(Object):
 
     def IsTransparent(*args, **kwargs):
         """
 
     def IsTransparent(*args, **kwargs):
         """

-        IsTransparent(self, int x, int y, unsigned char threshold=IMAGE_ALPHA_THRESHOLD) -> bool
+        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.
+        Returns ``True`` if this pixel is masked or has an alpha value less
+        than the spcified threshold.

         """
         return _core_.Image_IsTransparent(*args, **kwargs)
 
         """
         return _core_.Image_IsTransparent(*args, **kwargs)
 


@@ -2269,10 +2434,10 @@ class Image(Object):
         """
         ConvertAlphaToMask(self, byte threshold=IMAGE_ALPHA_THRESHOLD) -> 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.


@@ -2281,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)


@@ -2294,78 +2459,178 @@ 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)
 
     def Size(*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"""
+        """
+        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):
         return _core_.Image_Size(*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):


@@ -2391,7 +2656,8 @@ class Image(Object):
         GetDataBuffer(self) -> PyObject
 
         Returns a writable Python buffer object that is pointing at the RGB
         GetDataBuffer(self) -> PyObject
 
         Returns a writable Python buffer object that is pointing at the RGB

-        image data buffer inside the wx.Image.
+        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)
 
         """
         return _core_.Image_GetDataBuffer(*args, **kwargs)
 


@@ -2400,8 +2666,8 @@ class Image(Object):
         SetDataBuffer(self, buffer data)
 
         Sets the internal image data pointer to point at a Python buffer
         SetDataBuffer(self, buffer data)
 
         Sets the internal image data pointer to point at a Python buffer

-        object.  This can save a copy of the data but you must ensure that the
-        buffer object lives longer than the wx.Image does.
+        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)
 
         """
         return _core_.Image_SetDataBuffer(*args, **kwargs)
 


@@ -2432,7 +2698,12 @@ class Image(Object):
         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)
 
     def GetOrFindMaskColour(*args, **kwargs):
         return _core_.Image_SetMaskColour(*args, **kwargs)
 
     def GetOrFindMaskColour(*args, **kwargs):


@@ -2444,69 +2715,139 @@ class Image(Object):
         return _core_.Image_GetOrFindMaskColour(*args, **kwargs)
 
     def GetMaskRed(*args, **kwargs):
         return _core_.Image_GetOrFindMaskColour(*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):


@@ -2533,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)


@@ -2542,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() 


@@ -2555,19 +2902,34 @@ 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
     val = _core_.new_ImageFromStreamMime(*args, **kwargs)
     val.thisown = 1
     return val


@@ -2611,22 +2973,39 @@ def ImageFromDataWithAlpha(*args, **kwargs):
 
     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
 
     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.
+    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):


@@ -2642,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():


@@ -2667,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


@@ -2701,11 +3090,15 @@ IMAGE_OPTION_PNG_FORMAT = cvar.IMAGE_OPTION_PNG_FORMAT
 IMAGE_OPTION_PNG_BITDEPTH = cvar.IMAGE_OPTION_PNG_BITDEPTH
 
 class ICOHandler(BMPHandler):
 IMAGE_OPTION_PNG_BITDEPTH = cvar.IMAGE_OPTION_PNG_BITDEPTH
 
 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"""
+        """
+        __init__(self) -> ICOHandler
+
+        A `wx.ImageHandler` for \*.ico icon files.
+        """

         newobj = _core_.new_ICOHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
         newobj = _core_.new_ICOHandler(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1


@@ -2719,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


@@ -2737,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


@@ -2755,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


@@ -2773,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


@@ -2791,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


@@ -2809,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


@@ -2827,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


@@ -2845,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


@@ -2863,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


@@ -3160,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


@@ -3307,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, 


@@ -3316,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 )


@@ -3327,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, 


@@ -3338,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)


@@ -3349,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)


@@ -3393,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,)


@@ -3404,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):


@@ -3428,15 +3883,31 @@ 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):


@@ -3455,20 +3926,43 @@ class Event(Object):
         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)"""
-        return _core_.Event_ResumePropagation(*args, **kwargs)
+        """
+        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):
         """Clone(self) -> Event"""
 
     def Clone(*args, **kwargs):
         """Clone(self) -> Event"""


@@ -3485,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


@@ -3509,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


@@ -3535,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):


@@ -3553,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):


@@ -3570,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):


@@ -3578,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):


@@ -3596,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)
 
 


@@ -3628,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):


@@ -3641,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):


@@ -3667,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):


@@ -3708,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):


@@ -3742,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):


@@ -3767,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)
 


@@ -3852,37 +4658,77 @@ 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"""
+        """
+        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)
         return _core_.MouseEvent_IsPageScroll(*args, **kwargs)
 
     m_x = property(_core_.MouseEvent_m_x_get, _core_.MouseEvent_m_x_set)


@@ -3908,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)
 
 


@@ -3948,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):


@@ -3979,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`


@@ -3988,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)
 


@@ -4021,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)


@@ -4054,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):


@@ -4092,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):


@@ -4131,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):


@@ -4169,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)
 
 


@@ -4193,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):


@@ -4221,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)
 
 


@@ -4245,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)
 
 


@@ -4269,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


@@ -4289,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)
 
 


@@ -4321,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):


@@ -4365,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


@@ -4393,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)
 
 


@@ -4417,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


@@ -4437,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)
 
 


@@ -4466,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)


@@ -4550,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


@@ -4596,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)
 
 


@@ -4620,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):


@@ -4640,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


@@ -4668,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):


@@ -4696,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):


@@ -4706,39 +6266,87 @@ 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)
 
     def IsFromTab(*args, **kwargs):
         return _core_.NavigationKeyEvent_SetWindowChange(*args, **kwargs)
 
     def IsFromTab(*args, **kwargs):

-        """IsFromTab(self) -> bool"""
+        """
+        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):
         return _core_.NavigationKeyEvent_IsFromTab(*args, **kwargs)
 
     def SetFromTab(*args, **kwargs):

-        """SetFromTab(self, bool bIs)"""
+        """
+        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):
         return _core_.NavigationKeyEvent_SetFromTab(*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
         return _core_.NavigationKeyEvent_SetCurrentFocus(*args, **kwargs)
 
     IsBackward = _core_.NavigationKeyEvent_IsBackward


@@ -4756,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)
 
 


@@ -4778,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)
 
 


@@ -4802,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)
 
 


@@ -4832,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)


@@ -4873,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)"""


@@ -4904,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):


@@ -4921,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)"""


@@ -4938,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):


@@ -4955,7 +6723,12 @@ class PyCommandEventPtr(PyCommandEvent):
 _core_.PyCommandEvent_swigregister(PyCommandEventPtr)
 
 class DateEvent(CommandEvent):
 _core_.PyCommandEvent_swigregister(PyCommandEventPtr)
 
 class DateEvent(CommandEvent):

-    """Proxy of C++ DateEvent class"""
+    """
+    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):
     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):


@@ -4965,11 +6738,20 @@ class DateEvent(CommandEvent):
         self.thisown = 1
         del newobj.thisown
     def GetDate(*args, **kwargs):
         self.thisown = 1
         del newobj.thisown
     def GetDate(*args, **kwargs):

-        """GetDate(self) -> DateTime"""
+        """
+        GetDate(self) -> DateTime
+
+        Returns the date.
+        """

         return _core_.DateEvent_GetDate(*args, **kwargs)
 
     def SetDate(*args, **kwargs):
         return _core_.DateEvent_GetDate(*args, **kwargs)
 
     def SetDate(*args, **kwargs):

-        """SetDate(self, DateTime date)"""
+        """
+        SetDate(self, DateTime date)
+
+        Sets the date carried by the event, normally only used by the library
+        internally.
+        """

         return _core_.DateEvent_SetDate(*args, **kwargs)
 
 
         return _core_.DateEvent_SetDate(*args, **kwargs)
 
 


@@ -5008,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)"""


@@ -5018,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):


@@ -5691,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"""


@@ -5721,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):


@@ -6469,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


@@ -7736,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.
         """


@@ -7976,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)


@@ -8743,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):


@@ -8751,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):


@@ -9700,7 +11522,7 @@ class Sizer(Object):
 
         Returns the `wx.SizerItem` which holds the *item* given.  The *item*
         parameter can be either a window, a sizer, or the zero-based index of
 
         Returns the `wx.SizerItem` which holds the *item* given.  The *item*
         parameter can be either a window, a sizer, or the zero-based index of

-        the item to be detached.
+        the item to be found.

         """
         return _core_.Sizer_GetItem(*args, **kwargs)
 
         """
         return _core_.Sizer_GetItem(*args, **kwargs)
 


@@ -9993,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)
 


@@ -11334,11 +13156,15 @@ if RELEASE_VERSION != _core_.RELEASE_VERSION:
 
 #----------------------------------------------------------------------------
 
 
 #----------------------------------------------------------------------------
 

-# Set the default string<-->unicode conversion encoding from the
-# locale.  This encoding 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
+# 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.
 
 # http://www.alanwood.net/demos/charsetdiffs.html for differences
 # between the common latin/roman encodings.
 


@@ -11349,7 +13175,7 @@ if default == 'ascii':
     try:
         default = locale.getdefaultlocale()[1]
         codecs.lookup(default)
     try:
         default = locale.getdefaultlocale()[1]
         codecs.lookup(default)

-    except (ValueError, LookupError):
+    except (ValueError, LookupError, TypeError):

         default = _sys.getdefaultencoding()
     del locale
     del codecs
         default = _sys.getdefaultencoding()
     del locale
     del codecs