Add *wxTopLevelWindowGTK*RequestUserAttention*int*;

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

diff --git a/wxPython/src/mac/_core.py b/wxPython/src/mac/_core.py
index f530d9352e0bca6b0dd9fcaf4f10218e150f7b5b..c3cdc53e95f49dcbc6b61c97e6c6ea3b41725f4b 100644 (file)
--- a/wxPython/src/mac/_core.py
+++ b/wxPython/src/mac/_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


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


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


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


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


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


@@ -2273,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.


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


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


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


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


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


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


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


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


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


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


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


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


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


@@ -3375,8 +3757,9 @@ 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 )
-
+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, 
 # Scrolling from wx.Slider and wx.ScrollBar, with an id
 EVT_COMMAND_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP, 
                                        wxEVT_SCROLL_BOTTOM, 


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


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


@@ -3736,11 +4120,12 @@ class CommandEvent(Event):
         """
         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.
+        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)
 
         """
         return _core_.CommandEvent_GetExtraLong(*args, **kwargs)
 


@@ -3752,9 +4137,9 @@ class CommandEvent(Event):
         """
         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.
+        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)
 
         """
         return _core_.CommandEvent_GetInt(*args, **kwargs)
 


@@ -4010,9 +4395,10 @@ class MouseEvent(Event):
         """
         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).
+        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)
 
         """
         return _core_.MouseEvent_ButtonDown(*args, **kwargs)
 


@@ -4032,8 +4418,8 @@ class MouseEvent(Event):
         ButtonUp(self, int but=MOUSE_BTN_ANY) -> bool
 
         If the argument is omitted, this returns true if the event was any
         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).
+        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)
 
         """
         return _core_.MouseEvent_ButtonUp(*args, **kwargs)
 


@@ -4109,7 +4495,7 @@ 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 often makes 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
         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`
         because Cmd key is used for the same thing under Mac as Ctrl
         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`


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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