STATIC_BORDER = _core_.STATIC_BORDER
TRANSPARENT_WINDOW = _core_.TRANSPARENT_WINDOW
NO_BORDER = _core_.NO_BORDER
+DEFAULT_CONTROL_BORDER = _core_.DEFAULT_CONTROL_BORDER
+DEFAULT_STATUSBAR_STYLE = _core_.DEFAULT_STATUSBAR_STYLE
TAB_TRAVERSAL = _core_.TAB_TRAVERSAL
WANTS_CHARS = _core_.WANTS_CHARS
POPUP_WINDOW = _core_.POPUP_WINDOW
CENTER_FRAME = _core_.CENTER_FRAME
CENTRE_ON_SCREEN = _core_.CENTRE_ON_SCREEN
CENTER_ON_SCREEN = _core_.CENTER_ON_SCREEN
-ED_CLIENT_MARGIN = _core_.ED_CLIENT_MARGIN
-ED_BUTTONS_BOTTOM = _core_.ED_BUTTONS_BOTTOM
-ED_BUTTONS_RIGHT = _core_.ED_BUTTONS_RIGHT
-ED_STATIC_LINE = _core_.ED_STATIC_LINE
-EXT_DIALOG_STYLE = _core_.EXT_DIALOG_STYLE
CLIP_CHILDREN = _core_.CLIP_CHILDREN
CLIP_SIBLINGS = _core_.CLIP_SIBLINGS
ALWAYS_SHOW_SB = _core_.ALWAYS_SHOW_SB
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
WXK_WINDOWS_LEFT = _core_.WXK_WINDOWS_LEFT
WXK_WINDOWS_RIGHT = _core_.WXK_WINDOWS_RIGHT
WXK_WINDOWS_MENU = _core_.WXK_WINDOWS_MENU
+WXK_COMMAND = _core_.WXK_COMMAND
+WXK_SPECIAL1 = _core_.WXK_SPECIAL1
+WXK_SPECIAL2 = _core_.WXK_SPECIAL2
+WXK_SPECIAL3 = _core_.WXK_SPECIAL3
+WXK_SPECIAL4 = _core_.WXK_SPECIAL4
+WXK_SPECIAL5 = _core_.WXK_SPECIAL5
+WXK_SPECIAL6 = _core_.WXK_SPECIAL6
+WXK_SPECIAL7 = _core_.WXK_SPECIAL7
+WXK_SPECIAL8 = _core_.WXK_SPECIAL8
+WXK_SPECIAL9 = _core_.WXK_SPECIAL9
+WXK_SPECIAL10 = _core_.WXK_SPECIAL10
+WXK_SPECIAL11 = _core_.WXK_SPECIAL11
+WXK_SPECIAL12 = _core_.WXK_SPECIAL12
+WXK_SPECIAL13 = _core_.WXK_SPECIAL13
+WXK_SPECIAL14 = _core_.WXK_SPECIAL14
+WXK_SPECIAL15 = _core_.WXK_SPECIAL15
+WXK_SPECIAL16 = _core_.WXK_SPECIAL16
+WXK_SPECIAL17 = _core_.WXK_SPECIAL17
+WXK_SPECIAL18 = _core_.WXK_SPECIAL18
+WXK_SPECIAL19 = _core_.WXK_SPECIAL19
+WXK_SPECIAL20 = _core_.WXK_SPECIAL20
PAPER_NONE = _core_.PAPER_NONE
PAPER_LETTER = _core_.PAPER_LETTER
PAPER_LEGAL = _core_.PAPER_LEGAL
PAPER_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
"""SetSize(self, Size s)"""
return _core_.Rect_SetSize(*args, **kwargs)
+ def IsEmpty(*args, **kwargs):
+ """IsEmpty(self) -> bool"""
+ return _core_.Rect_IsEmpty(*args, **kwargs)
+
def GetTopLeft(*args, **kwargs):
"""GetTopLeft(self) -> Point"""
return _core_.Rect_GetTopLeft(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
- self.thisown = 0 # It will normally be deleted by the user of the wxFileSystem
+ self.thisown = 0 # It will normally be deleted by the user of the wx.FileSystem
def __del__(self, destroy=_core_.delete_FSFile):
"""__del__(self)"""
"""MemoryFSHandler_RemoveFile(String filename)"""
return _core_.MemoryFSHandler_RemoveFile(*args, **kwargs)
+IMAGE_ALPHA_TRANSPARENT = _core_.IMAGE_ALPHA_TRANSPARENT
+IMAGE_ALPHA_THRESHOLD = _core_.IMAGE_ALPHA_THRESHOLD
+IMAGE_ALPHA_OPAQUE = _core_.IMAGE_ALPHA_OPAQUE
#---------------------------------------------------------------------------
class ImageHandler(Object):
- """Proxy of C++ ImageHandler class"""
+ """
+ This is the base class for implementing image file loading/saving, and
+ image creation from data. It is used within `wx.Image` and is not
+ normally seen by the application.
+ """
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxImageHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
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
"""
"""
return _core_.ImageHistogram_FindFirstUnusedColour(*args, **kwargs)
+ def GetCount(*args, **kwargs):
+ """
+ GetCount(self, unsigned long key) -> unsigned long
+
+ Returns the pixel count for the given key. Use `MakeKey` to create a
+ key value from a RGB tripple.
+ """
+ return _core_.ImageHistogram_GetCount(*args, **kwargs)
+
+ def GetCountRGB(*args, **kwargs):
+ """
+ GetCountRGB(self, byte r, byte g, byte b) -> unsigned long
+
+ Returns the pixel count for the given RGB values.
+ """
+ return _core_.ImageHistogram_GetCountRGB(*args, **kwargs)
+
+ def GetCountColour(*args, **kwargs):
+ """
+ GetCountColour(self, Colour colour) -> unsigned long
+
+ Returns the pixel count for the given `wx.Colour` value.
+ """
+ return _core_.ImageHistogram_GetCountColour(*args, **kwargs)
+
class ImageHistogramPtr(ImageHistogram):
def __init__(self, this):
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):
- """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):
- """__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
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)
- 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):
- """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):
- """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):
- """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):
+ """
+ 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):
- """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):
+ """
+ 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):
- """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):
- """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):
- """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):
- """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):
- """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):
- """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_InitAlpha(*args, **kwargs)
+ def IsTransparent(*args, **kwargs):
+ """
+ IsTransparent(self, int x, int y, byte threshold=IMAGE_ALPHA_THRESHOLD) -> bool
+
+ Returns ``True`` if this pixel is masked or has an alpha value less
+ than the spcified threshold.
+ """
+ return _core_.Image_IsTransparent(*args, **kwargs)
+
def FindFirstUnusedColour(*args, **kwargs):
"""
FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)
def ConvertAlphaToMask(*args, **kwargs):
"""
- ConvertAlphaToMask(self, byte threshold=128) -> bool
+ ConvertAlphaToMask(self, byte threshold=IMAGE_ALPHA_THRESHOLD) -> bool
- If the image has alpha channel, this method converts it to mask. All pixels
- with alpha value less than ``threshold`` are replaced with mask colour and the
- alpha channel is removed. Mask colour is chosen automatically using
- `FindFirstUnusedColour`.
+ If the image has alpha channel, this method converts it to mask. All
+ pixels with alpha value less than ``threshold`` are replaced with the
+ mask colour and the alpha channel is removed. The mask colour is
+ chosen automatically using `FindFirstUnusedColour`.
If the image image doesn't have alpha channel, ConvertAlphaToMask does
nothing.
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)
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):
- """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):
- """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):
- """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):
- """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):
- """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):
- """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):
- """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):
- """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):
- """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):
- """Ok(self) -> bool"""
+ """
+ Ok(self) -> bool
+
+ Returns true if image data is present.
+ """
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):
- """GetHeight(self) -> int"""
+ """
+ GetHeight(self) -> int
+
+ Gets the height of the image in pixels.
+ """
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):
- """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):
+ """
+ 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):
- """Copy(self) -> Image"""
+ """
+ Copy(self) -> Image
+
+ Returns an identical copy of the image.
+ """
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):
- """GetData(self) -> PyObject"""
+ """
+ GetData(self) -> PyObject
+
+ Returns a string containing a copy of the RGB bytes of the image.
+ """
return _core_.Image_GetData(*args, **kwargs)
def SetData(*args, **kwargs):
- """SetData(self, PyObject data)"""
+ """
+ SetData(self, buffer data)
+
+ Resets the Image's RGB data from a buffer of RGB bytes. Accepts
+ either a string or a buffer object holding the data and the length of
+ the data must be width*height*3.
+ """
return _core_.Image_SetData(*args, **kwargs)
def GetDataBuffer(*args, **kwargs):
- """GetDataBuffer(self) -> PyObject"""
+ """
+ GetDataBuffer(self) -> PyObject
+
+ Returns a writable Python buffer object that is pointing at the RGB
+ image data buffer inside the wx.Image. You need to ensure that you do
+ not use this buffer object after the image has been destroyed.
+ """
return _core_.Image_GetDataBuffer(*args, **kwargs)
def SetDataBuffer(*args, **kwargs):
- """SetDataBuffer(self, PyObject data)"""
+ """
+ SetDataBuffer(self, buffer data)
+
+ Sets the internal image data pointer to point at a Python buffer
+ object. This can save making an extra copy of the data but you must
+ ensure that the buffer object lives longer than the wx.Image does.
+ """
return _core_.Image_SetDataBuffer(*args, **kwargs)
def GetAlphaData(*args, **kwargs):
- """GetAlphaData(self) -> PyObject"""
+ """
+ GetAlphaData(self) -> PyObject
+
+ Returns a string containing a copy of the alpha bytes of the image.
+ """
return _core_.Image_GetAlphaData(*args, **kwargs)
def SetAlphaData(*args, **kwargs):
- """SetAlphaData(self, PyObject data)"""
+ """
+ SetAlphaData(self, buffer alpha)
+
+ Resets the Image's alpha data from a buffer of bytes. Accepts either
+ a string or a buffer object holding the data and the length of the
+ data must be width*height.
+ """
return _core_.Image_SetAlphaData(*args, **kwargs)
def GetAlphaBuffer(*args, **kwargs):
return _core_.Image_GetAlphaBuffer(*args, **kwargs)
def SetAlphaBuffer(*args, **kwargs):
- """SetAlphaBuffer(self, PyObject data)"""
+ """SetAlphaBuffer(self, buffer alpha)"""
return _core_.Image_SetAlphaBuffer(*args, **kwargs)
def SetMaskColour(*args, **kwargs):
- """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):
+ """
+ GetOrFindMaskColour() -> (r,g,b)
+
+ Get the current mask colour or find a suitable colour.
+ """
+ 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):
- """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):
- """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):
- """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):
- """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
+
+ 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):
- """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):
- """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):
"""
- 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):
- """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):
- """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):
- """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):
- """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):
- """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):
- """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):
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_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()
_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):
- """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):
- """ImageFromStreamMime(InputStream stream, String mimetype, int index=-1) -> Image"""
+ """
+ ImageFromStreamMime(InputStream stream, String mimetype, int index=-1) -> Image
+
+ Loads an image from an input stream, or any readable Python file-like
+ object, specifying the image format with a MIME type string.
+ """
val = _core_.new_ImageFromStreamMime(*args, **kwargs)
val.thisown = 1
return val
def EmptyImage(*args, **kwargs):
- """EmptyImage(int width=0, int height=0, bool clear=True) -> Image"""
+ """
+ EmptyImage(int width=0, int height=0, bool clear=True) -> Image
+
+ Construct an empty image of a given size, optionally setting all
+ pixels to black.
+ """
val = _core_.new_EmptyImage(*args, **kwargs)
val.thisown = 1
return val
def ImageFromBitmap(*args, **kwargs):
- """ImageFromBitmap(Bitmap bitmap) -> Image"""
+ """
+ ImageFromBitmap(Bitmap bitmap) -> Image
+
+ Construct an Image from a `wx.Bitmap`.
+ """
val = _core_.new_ImageFromBitmap(*args, **kwargs)
val.thisown = 1
return val
def ImageFromData(*args, **kwargs):
- """ImageFromData(int width, int height, unsigned char data) -> Image"""
+ """
+ ImageFromData(int width, int height, buffer data) -> Image
+
+ Construct an Image from a buffer of RGB bytes. Accepts either a
+ string or a buffer object holding the data and the length of the data
+ must be width*height*3.
+ """
val = _core_.new_ImageFromData(*args, **kwargs)
val.thisown = 1
return val
def ImageFromDataWithAlpha(*args, **kwargs):
- """ImageFromDataWithAlpha(int width, int height, unsigned char data, unsigned char alpha) -> Image"""
+ """
+ ImageFromDataWithAlpha(int width, int height, buffer data, buffer alpha) -> Image
+
+ Construct an Image from a buffer of RGB bytes with an Alpha channel.
+ Accepts either a string or a buffer object holding the data and the
+ length of the data must be width*height*3 bytes, and the length of the
+ alpha data must be width*height bytes.
+ """
val = _core_.new_ImageFromDataWithAlpha(*args, **kwargs)
val.thisown = 1
return val
def Image_CanRead(*args, **kwargs):
- """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):
- """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):
- """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_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():
IMAGE_RESOLUTION_INCHES = _core_.IMAGE_RESOLUTION_INCHES
IMAGE_RESOLUTION_CM = _core_.IMAGE_RESOLUTION_CM
+PNG_TYPE_COLOUR = _core_.PNG_TYPE_COLOUR
+PNG_TYPE_GREY = _core_.PNG_TYPE_GREY
+PNG_TYPE_GREY_RED = _core_.PNG_TYPE_GREY_RED
BMP_24BPP = _core_.BMP_24BPP
BMP_8BPP = _core_.BMP_8BPP
BMP_8BPP_GREY = _core_.BMP_8BPP_GREY
BMP_1BPP = _core_.BMP_1BPP
BMP_1BPP_BW = _core_.BMP_1BPP_BW
class BMPHandler(ImageHandler):
- """Proxy of C++ BMPHandler class"""
+ """A `wx.ImageHandler` for \*.bmp bitmap files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxBMPHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self) -> BMPHandler"""
+ """
+ __init__(self) -> BMPHandler
+
+ A `wx.ImageHandler` for \*.bmp bitmap files.
+ """
newobj = _core_.new_BMPHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
IMAGE_OPTION_SAMPLESPERPIXEL = cvar.IMAGE_OPTION_SAMPLESPERPIXEL
IMAGE_OPTION_COMPRESSION = cvar.IMAGE_OPTION_COMPRESSION
IMAGE_OPTION_IMAGEDESCRIPTOR = cvar.IMAGE_OPTION_IMAGEDESCRIPTOR
+IMAGE_OPTION_PNG_FORMAT = cvar.IMAGE_OPTION_PNG_FORMAT
+IMAGE_OPTION_PNG_BITDEPTH = cvar.IMAGE_OPTION_PNG_BITDEPTH
class ICOHandler(BMPHandler):
- """Proxy of C++ ICOHandler class"""
+ """A `wx.ImageHandler` for \*.ico icon files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxICOHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self) -> ICOHandler"""
+ """
+ __init__(self) -> ICOHandler
+
+ A `wx.ImageHandler` for \*.ico icon files.
+ """
newobj = _core_.new_ICOHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
_core_.ICOHandler_swigregister(ICOHandlerPtr)
class CURHandler(ICOHandler):
- """Proxy of C++ CURHandler class"""
+ """A `wx.ImageHandler` for \*.cur cursor files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxCURHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self) -> CURHandler"""
+ """
+ __init__(self) -> CURHandler
+
+ A `wx.ImageHandler` for \*.cur cursor files.
+ """
newobj = _core_.new_CURHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
_core_.CURHandler_swigregister(CURHandlerPtr)
class ANIHandler(CURHandler):
- """Proxy of C++ ANIHandler class"""
+ """A `wx.ImageHandler` for \*.ani animated cursor files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxANIHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self) -> ANIHandler"""
+ """
+ __init__(self) -> ANIHandler
+
+ A `wx.ImageHandler` for \*.ani animated cursor files.
+ """
newobj = _core_.new_ANIHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
_core_.ANIHandler_swigregister(ANIHandlerPtr)
class PNGHandler(ImageHandler):
- """Proxy of C++ PNGHandler class"""
+ """A `wx.ImageHandler` for PNG image files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPNGHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self) -> PNGHandler"""
- newobj = _core_.new_PNGHandler(*args, **kwargs)
+ """
+ __init__(self) -> PNGHandler
+
+ A `wx.ImageHandler` for PNG image files.
+ """
+ newobj = _core_.new_PNGHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
_core_.PNGHandler_swigregister(PNGHandlerPtr)
class GIFHandler(ImageHandler):
- """Proxy of C++ GIFHandler class"""
+ """A `wx.ImageHandler` for GIF image files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxGIFHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self) -> GIFHandler"""
+ """
+ __init__(self) -> GIFHandler
+
+ A `wx.ImageHandler` for GIF image files.
+ """
newobj = _core_.new_GIFHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
_core_.GIFHandler_swigregister(GIFHandlerPtr)
class PCXHandler(ImageHandler):
- """Proxy of C++ PCXHandler class"""
+ """A `wx.ImageHandler` for PCX imager files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPCXHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self) -> PCXHandler"""
+ """
+ __init__(self) -> PCXHandler
+
+ A `wx.ImageHandler` for PCX imager files.
+ """
newobj = _core_.new_PCXHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
_core_.PCXHandler_swigregister(PCXHandlerPtr)
class JPEGHandler(ImageHandler):
- """Proxy of C++ JPEGHandler class"""
+ """A `wx.ImageHandler` for JPEG/JPG image files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxJPEGHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self) -> JPEGHandler"""
+ """
+ __init__(self) -> JPEGHandler
+
+ A `wx.ImageHandler` for JPEG/JPG image files.
+ """
newobj = _core_.new_JPEGHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
_core_.JPEGHandler_swigregister(JPEGHandlerPtr)
class PNMHandler(ImageHandler):
- """Proxy of C++ PNMHandler class"""
+ """A `wx.ImageHandler` for PNM image files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxPNMHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self) -> PNMHandler"""
+ """
+ __init__(self) -> PNMHandler
+
+ A `wx.ImageHandler` for PNM image files.
+ """
newobj = _core_.new_PNMHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
_core_.PNMHandler_swigregister(PNMHandlerPtr)
class XPMHandler(ImageHandler):
- """Proxy of C++ XPMHandler class"""
+ """A `wx.ImageHandler` for XPM image."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxXPMHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self) -> XPMHandler"""
+ """
+ __init__(self) -> XPMHandler
+
+ A `wx.ImageHandler` for XPM image.
+ """
newobj = _core_.new_XPMHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
_core_.XPMHandler_swigregister(XPMHandlerPtr)
class TIFFHandler(ImageHandler):
- """Proxy of C++ TIFFHandler class"""
+ """A `wx.ImageHandler` for TIFF image files."""
def __repr__(self):
return "<%s.%s; proxy of C++ wxTIFFHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self) -> TIFFHandler"""
+ """
+ __init__(self) -> TIFFHandler
+
+ A `wx.ImageHandler` for TIFF image files.
+ """
newobj = _core_.new_TIFFHandler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
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_UPDATE_UI = _core_.wxEVT_UPDATE_UI
wxEVT_SIZING = _core_.wxEVT_SIZING
wxEVT_MOVING = _core_.wxEVT_MOVING
+wxEVT_HIBERNATE = _core_.wxEVT_HIBERNATE
wxEVT_COMMAND_LEFT_CLICK = _core_.wxEVT_COMMAND_LEFT_CLICK
wxEVT_COMMAND_LEFT_DCLICK = _core_.wxEVT_COMMAND_LEFT_DCLICK
wxEVT_COMMAND_RIGHT_CLICK = _core_.wxEVT_COMMAND_RIGHT_CLICK
EVT_CHILD_FOCUS = wx.PyEventBinder( wxEVT_CHILD_FOCUS )
EVT_ACTIVATE = wx.PyEventBinder( wxEVT_ACTIVATE )
EVT_ACTIVATE_APP = wx.PyEventBinder( wxEVT_ACTIVATE_APP )
+EVT_HIBERNATE = wx.PyEventBinder( wxEVT_HIBERNATE )
EVT_END_SESSION = wx.PyEventBinder( wxEVT_END_SESSION )
EVT_QUERY_END_SESSION = wx.PyEventBinder( wxEVT_QUERY_END_SESSION )
EVT_DROP_FILES = wx.PyEventBinder( wxEVT_DROP_FILES )
EVT_SCROLLWIN_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBTRACK )
EVT_SCROLLWIN_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBRELEASE )
-# Scrolling from wxSlider and wxScrollBar
+# Scrolling from wx.Slider and wx.ScrollBar
EVT_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
wxEVT_SCROLL_BOTTOM,
wxEVT_SCROLL_LINEUP,
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_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN )
EVT_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK )
EVT_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE )
-EVT_SCROLL_ENDSCROLL = wx.PyEventBinder( wxEVT_SCROLL_ENDSCROLL )
-
-# Scrolling from wxSlider and wxScrollBar, with an id
+EVT_SCROLL_CHANGED = wx.PyEventBinder( wxEVT_SCROLL_CHANGED )
+EVT_SCROLL_ENDSCROLL = EVT_SCROLL_CHANGED
+
+# Scrolling from wx.Slider and wx.ScrollBar, with an id
EVT_COMMAND_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
wxEVT_SCROLL_BOTTOM,
wxEVT_SCROLL_LINEUP,
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)
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)
#---------------------------------------------------------------------------
class Event(Object):
- """Proxy of C++ Event class"""
+ """
+ An event is a structure holding information about an event passed to a
+ callback or member function. wx.Event is an abstract base class for
+ other event classes
+ """
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
except: pass
def SetEventType(*args, **kwargs):
- """SetEventType(self, wxEventType typ)"""
+ """
+ SetEventType(self, wxEventType typ)
+
+ Sets the specific type of the event.
+ """
return _core_.Event_SetEventType(*args, **kwargs)
def GetEventType(*args, **kwargs):
- """GetEventType(self) -> wxEventType"""
+ """
+ GetEventType(self) -> wxEventType
+
+ Returns the identifier of the given event type, such as
+ ``wxEVT_COMMAND_BUTTON_CLICKED``.
+ """
return _core_.Event_GetEventType(*args, **kwargs)
def GetEventObject(*args, **kwargs):
- """GetEventObject(self) -> Object"""
+ """
+ GetEventObject(self) -> Object
+
+ Returns the object (usually a window) associated with the event, if
+ any.
+ """
return _core_.Event_GetEventObject(*args, **kwargs)
def SetEventObject(*args, **kwargs):
- """SetEventObject(self, Object obj)"""
+ """
+ SetEventObject(self, Object obj)
+
+ Sets the originating object, or in other words, obj is normally the
+ object that is sending the event.
+ """
return _core_.Event_SetEventObject(*args, **kwargs)
def GetTimestamp(*args, **kwargs):
return _core_.Event_SetTimestamp(*args, **kwargs)
def GetId(*args, **kwargs):
- """GetId(self) -> int"""
+ """
+ GetId(self) -> int
+
+ Returns the identifier associated with this event, such as a button
+ command id.
+ """
return _core_.Event_GetId(*args, **kwargs)
def SetId(*args, **kwargs):
- """SetId(self, int Id)"""
+ """
+ SetId(self, int Id)
+
+ Set's the ID for the event. This is usually the ID of the window that
+ is sending the event, but it can also be a command id from a menu
+ item, etc.
+ """
return _core_.Event_SetId(*args, **kwargs)
def IsCommandEvent(*args, **kwargs):
- """IsCommandEvent(self) -> bool"""
+ """
+ IsCommandEvent(self) -> bool
+
+ Returns true if the event is or is derived from `wx.CommandEvent` else
+ it returns false. Note: Exists only for optimization purposes.
+ """
return _core_.Event_IsCommandEvent(*args, **kwargs)
def Skip(*args, **kwargs):
return _core_.Event_Skip(*args, **kwargs)
def GetSkipped(*args, **kwargs):
- """GetSkipped(self) -> bool"""
+ """
+ GetSkipped(self) -> bool
+
+ Returns true if the event handler should be skipped, false otherwise.
+ :see: `Skip`
+ """
return _core_.Event_GetSkipped(*args, **kwargs)
def ShouldPropagate(*args, **kwargs):
- """ShouldPropagate(self) -> bool"""
+ """
+ ShouldPropagate(self) -> bool
+
+ Test if this event should be propagated to the parent window or not,
+ i.e. if the propagation level is currently greater than 0.
+ """
return _core_.Event_ShouldPropagate(*args, **kwargs)
def StopPropagation(*args, **kwargs):
- """StopPropagation(self) -> int"""
+ """
+ StopPropagation(self) -> int
+
+ Stop the event from propagating to its parent window. Returns the old
+ propagation level value which may be later passed to
+ `ResumePropagation` to allow propagating the event again.
+ """
return _core_.Event_StopPropagation(*args, **kwargs)
def ResumePropagation(*args, **kwargs):
- """ResumePropagation(self, int propagationLevel)"""
+ """
+ ResumePropagation(self, int propagationLevel)
+
+ Resume the event propagation by restoring the propagation level. (For
+ example, you can use the value returned by an earlier call to
+ `StopPropagation`.)
+
+ """
return _core_.Event_ResumePropagation(*args, **kwargs)
def Clone(*args, **kwargs):
#---------------------------------------------------------------------------
class PropagationDisabler(object):
- """Proxy of C++ PropagationDisabler class"""
+ """
+ Helper class to temporarily change an event not to propagate. Simply
+ create an instance of this class and then whe it is destroyed the
+ propogation of the event will be restored.
+ """
def __repr__(self):
return "<%s.%s; proxy of C++ wxPropagationDisabler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self, Event event) -> PropagationDisabler"""
+ """
+ __init__(self, Event event) -> PropagationDisabler
+
+ Helper class to temporarily change an event not to propagate. Simply
+ create an instance of this class and then whe it is destroyed the
+ propogation of the event will be restored.
+ """
newobj = _core_.new_PropagationDisabler(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
_core_.PropagationDisabler_swigregister(PropagationDisablerPtr)
class PropagateOnce(object):
- """Proxy of C++ PropagateOnce class"""
+ """
+ A helper class that will temporarily lower propagation level of an
+ event. Simply create an instance of this class and then whe it is
+ destroyed the propogation of the event will be restored.
+ """
def __repr__(self):
return "<%s.%s; proxy of C++ wxPropagateOnce instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self, Event event) -> PropagateOnce"""
+ """
+ __init__(self, Event event) -> PropagateOnce
+
+ A helper class that will temporarily lower propagation level of an
+ event. Simply create an instance of this class and then whe it is
+ destroyed the propogation of the event will be restored.
+ """
newobj = _core_.new_PropagateOnce(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
#---------------------------------------------------------------------------
class CommandEvent(Event):
- """Proxy of C++ CommandEvent class"""
+ """
+ This event class contains information about command events, which
+ originate from a variety of simple controls, as well as menus and
+ toolbars.
+ """
def __repr__(self):
return "<%s.%s; proxy of C++ wxCommandEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self, wxEventType commandType=wxEVT_NULL, int winid=0) -> CommandEvent"""
+ """
+ __init__(self, wxEventType commandType=wxEVT_NULL, int winid=0) -> CommandEvent
+
+ This event class contains information about command events, which
+ originate from a variety of simple controls, as well as menus and
+ toolbars.
+ """
newobj = _core_.new_CommandEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetSelection(*args, **kwargs):
- """GetSelection(self) -> int"""
+ """
+ GetSelection(self) -> int
+
+ Returns item index for a listbox or choice selection event (not valid
+ for a deselection).
+ """
return _core_.CommandEvent_GetSelection(*args, **kwargs)
def SetString(*args, **kwargs):
return _core_.CommandEvent_SetString(*args, **kwargs)
def GetString(*args, **kwargs):
- """GetString(self) -> String"""
+ """
+ GetString(self) -> String
+
+ Returns item string for a listbox or choice selection event (not valid
+ for a deselection).
+ """
return _core_.CommandEvent_GetString(*args, **kwargs)
def IsChecked(*args, **kwargs):
- """IsChecked(self) -> bool"""
+ """
+ IsChecked(self) -> bool
+
+ This method can be used with checkbox and menu events: for the
+ checkboxes, the method returns true for a selection event and false
+ for a deselection one. For the menu events, this method indicates if
+ the menu item just has become checked or unchecked (and thus only
+ makes sense for checkable menu items).
+ """
return _core_.CommandEvent_IsChecked(*args, **kwargs)
Checked = IsChecked
def IsSelection(*args, **kwargs):
- """IsSelection(self) -> bool"""
+ """
+ IsSelection(self) -> bool
+
+ For a listbox or similar event, returns true if it is a selection,
+ false if it is a deselection.
+ """
return _core_.CommandEvent_IsSelection(*args, **kwargs)
def SetExtraLong(*args, **kwargs):
return _core_.CommandEvent_SetExtraLong(*args, **kwargs)
def GetExtraLong(*args, **kwargs):
- """GetExtraLong(self) -> long"""
+ """
+ GetExtraLong(self) -> long
+
+ Returns extra information dependant on the event objects type. If the
+ event comes from a listbox selection, it is a boolean determining
+ whether the event was a selection (true) or a deselection (false). A
+ listbox deselection only occurs for multiple-selection boxes, and in
+ this case the index and string values are indeterminate and the
+ listbox must be examined by the application.
+ """
return _core_.CommandEvent_GetExtraLong(*args, **kwargs)
def SetInt(*args, **kwargs):
return _core_.CommandEvent_SetInt(*args, **kwargs)
def GetInt(*args, **kwargs):
- """GetInt(self) -> long"""
+ """
+ GetInt(self) -> long
+
+ Returns the integer identifier corresponding to a listbox, choice or
+ radiobox selection (only if the event was a selection, not a
+ deselection), or a boolean value representing the value of a checkbox.
+ """
return _core_.CommandEvent_GetInt(*args, **kwargs)
def Clone(*args, **kwargs):
#---------------------------------------------------------------------------
class NotifyEvent(CommandEvent):
- """Proxy of C++ NotifyEvent class"""
+ """
+ An instance of this class (or one of its derived classes) is sent from
+ a control when the control's state is being changed and the control
+ allows that change to be prevented from happening. The event handler
+ can call `Veto` or `Allow` to tell the control what to do.
+ """
def __repr__(self):
return "<%s.%s; proxy of C++ wxNotifyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self, wxEventType commandType=wxEVT_NULL, int winid=0) -> NotifyEvent"""
+ """
+ __init__(self, wxEventType commandType=wxEVT_NULL, int winid=0) -> NotifyEvent
+
+ An instance of this class (or one of its derived classes) is sent from
+ a control when the control's state is being changed and the control
+ allows that change to be prevented from happening. The event handler
+ can call `Veto` or `Allow` to tell the control what to do.
+ """
newobj = _core_.new_NotifyEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def Veto(*args, **kwargs):
- """Veto(self)"""
+ """
+ Veto(self)
+
+ Prevents the change announced by this event from happening.
+
+ It is in general a good idea to notify the user about the reasons for
+ vetoing the change because otherwise the applications behaviour (which
+ just refuses to do what the user wants) might be quite surprising.
+ """
return _core_.NotifyEvent_Veto(*args, **kwargs)
def Allow(*args, **kwargs):
- """Allow(self)"""
+ """
+ Allow(self)
+
+ This is the opposite of `Veto`: it explicitly allows the event to be
+ processed. For most events it is not necessary to call this method as
+ the events are allowed anyhow but some are forbidden by default (this
+ will be mentioned in the corresponding event description).
+ """
return _core_.NotifyEvent_Allow(*args, **kwargs)
def IsAllowed(*args, **kwargs):
- """IsAllowed(self) -> bool"""
+ """
+ IsAllowed(self) -> bool
+
+ Returns true if the change is allowed (`Veto` hasn't been called) or
+ false otherwise (if it was).
+ """
return _core_.NotifyEvent_IsAllowed(*args, **kwargs)
#---------------------------------------------------------------------------
class ScrollEvent(CommandEvent):
- """Proxy of C++ ScrollEvent class"""
+ """
+ A scroll event holds information about events sent from stand-alone
+ scrollbars and sliders. Note that scrolled windows do not send
+ instnaces of this event class, but send the `wx.ScrollWinEvent`
+ instead.
+ """
def __repr__(self):
return "<%s.%s; proxy of C++ wxScrollEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
self.thisown = 1
del newobj.thisown
def GetOrientation(*args, **kwargs):
- """GetOrientation(self) -> int"""
+ """
+ GetOrientation(self) -> int
+
+ Returns wx.HORIZONTAL or wx.VERTICAL, depending on the orientation of
+ the scrollbar.
+ """
return _core_.ScrollEvent_GetOrientation(*args, **kwargs)
def GetPosition(*args, **kwargs):
- """GetPosition(self) -> int"""
+ """
+ GetPosition(self) -> int
+
+ Returns the position of the scrollbar.
+ """
return _core_.ScrollEvent_GetPosition(*args, **kwargs)
def SetOrientation(*args, **kwargs):
#---------------------------------------------------------------------------
class ScrollWinEvent(Event):
- """Proxy of C++ ScrollWinEvent class"""
+ """
+ A wx.ScrollWinEvent holds information about scrolling and is sent from
+ scrolling windows.
+ """
def __repr__(self):
return "<%s.%s; proxy of C++ wxScrollWinEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self, wxEventType commandType=wxEVT_NULL, int pos=0, int orient=0) -> ScrollWinEvent"""
+ """
+ __init__(self, wxEventType commandType=wxEVT_NULL, int pos=0, int orient=0) -> ScrollWinEvent
+
+ A wx.ScrollWinEvent holds information about scrolling and is sent from
+ scrolling windows.
+ """
newobj = _core_.new_ScrollWinEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetOrientation(*args, **kwargs):
- """GetOrientation(self) -> int"""
+ """
+ GetOrientation(self) -> int
+
+ Returns wx.HORIZONTAL or wx.VERTICAL, depending on the orientation of
+ the scrollbar.
+ """
return _core_.ScrollWinEvent_GetOrientation(*args, **kwargs)
def GetPosition(*args, **kwargs):
- """GetPosition(self) -> int"""
+ """
+ GetPosition(self) -> int
+
+ Returns the position of the scrollbar for the thumb track and release
+ events. Note that this field can't be used for the other events, you
+ need to query the window itself for the current position in that case.
+ """
return _core_.ScrollWinEvent_GetPosition(*args, **kwargs)
def SetOrientation(*args, **kwargs):
MOUSE_BTN_MIDDLE = _core_.MOUSE_BTN_MIDDLE
MOUSE_BTN_RIGHT = _core_.MOUSE_BTN_RIGHT
class MouseEvent(Event):
- """Proxy of C++ MouseEvent class"""
+ """
+ This event class contains information about the events generated by
+ the mouse: they include mouse buttons press and release events and
+ mouse move events.
+
+ All mouse events involving the buttons use ``wx.MOUSE_BTN_LEFT`` for
+ the left mouse button, ``wx.MOUSE_BTN_MIDDLE`` for the middle one and
+ ``wx.MOUSE_BTN_RIGHT`` for the right one. Note that not all mice have
+ a middle button so a portable application should avoid relying on the
+ events from it.
+
+ Note the difference between methods like `LeftDown` and `LeftIsDown`:
+ the former returns true when the event corresponds to the left mouse
+ button click while the latter returns true if the left mouse button is
+ currently being pressed. For example, when the user is dragging the
+ mouse you can use `LeftIsDown` to test whether the left mouse button
+ is (still) depressed. Also, by convention, if `LeftDown` returns true,
+ `LeftIsDown` will also return true in wxWidgets whatever the
+ underlying GUI behaviour is (which is platform-dependent). The same
+ applies, of course, to other mouse buttons as well.
+ """
def __repr__(self):
return "<%s.%s; proxy of C++ wxMouseEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(self, wxEventType mouseType=wxEVT_NULL) -> MouseEvent"""
+ """
+ __init__(self, wxEventType mouseType=wxEVT_NULL) -> MouseEvent
+
+ Constructs a wx.MouseEvent. Valid event types are:
+
+ * wxEVT_ENTER_WINDOW
+ * wxEVT_LEAVE_WINDOW
+ * wxEVT_LEFT_DOWN
+ * wxEVT_LEFT_UP
+ * wxEVT_LEFT_DCLICK
+ * wxEVT_MIDDLE_DOWN
+ * wxEVT_MIDDLE_UP
+ * wxEVT_MIDDLE_DCLICK
+ * wxEVT_RIGHT_DOWN
+ * wxEVT_RIGHT_UP
+ * wxEVT_RIGHT_DCLICK
+ * wxEVT_MOTION
+ * wxEVT_MOUSEWHEEL
+ """
newobj = _core_.new_MouseEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def IsButton(*args, **kwargs):
- """IsButton(self) -> bool"""
+ """
+ IsButton(self) -> bool
+
+ Returns true if the event was a mouse button event (not necessarily a
+ button down event - that may be tested using `ButtonDown`).
+ """
return _core_.MouseEvent_IsButton(*args, **kwargs)
def ButtonDown(*args, **kwargs):
- """ButtonDown(self, int but=MOUSE_BTN_ANY) -> bool"""
+ """
+ ButtonDown(self, int but=MOUSE_BTN_ANY) -> bool
+
+ If the argument is omitted, this returns true if the event was any
+ mouse button down event. Otherwise the argument specifies which
+ button-down event shold be checked for (see `Button` for the possible
+ values).
+ """
return _core_.MouseEvent_ButtonDown(*args, **kwargs)
def ButtonDClick(*args, **kwargs):
- """ButtonDClick(self, int but=MOUSE_BTN_ANY) -> bool"""
+ """
+ ButtonDClick(self, int but=MOUSE_BTN_ANY) -> bool
+
+ If the argument is omitted, this returns true if the event was any
+ mouse double click event. Otherwise the argument specifies which
+ double click event to check for (see `Button` for the possible
+ values).
+ """
return _core_.MouseEvent_ButtonDClick(*args, **kwargs)
def ButtonUp(*args, **kwargs):
- """ButtonUp(self, int but=MOUSE_BTN_ANY) -> bool"""
+ """
+ ButtonUp(self, int but=MOUSE_BTN_ANY) -> bool
+
+ If the argument is omitted, this returns true if the event was any
+ mouse button up event. Otherwise the argument specifies which button
+ up event to check for (see `Button` for the possible values).
+ """
return _core_.MouseEvent_ButtonUp(*args, **kwargs)
def Button(*args, **kwargs):
- """Button(self, int but) -> bool"""
+ """
+ Button(self, int button) -> bool
+
+ Returns true if the identified mouse button is changing state. Valid
+ values of button are:
+
+ ==================== =====================================
+ wx.MOUSE_BTN_LEFT check if left button was pressed
+ wx.MOUSE_BTN_MIDDLE check if middle button was pressed
+ wx.MOUSE_BTN_RIGHT check if right button was pressed
+ wx.MOUSE_BTN_ANY check if any button was pressed
+ ==================== =====================================
+
+ """
return _core_.MouseEvent_Button(*args, **kwargs)
def ButtonIsDown(*args, **kwargs):
return _core_.MouseEvent_ButtonIsDown(*args, **kwargs)
def GetButton(*args, **kwargs):
- """GetButton(self) -> int"""
+ """
+ GetButton(self) -> int
+
+ Returns the mouse button which generated this event or
+ wx.MOUSE_BTN_NONE if no button is involved (for mouse move, enter or
+ leave event, for example). Otherwise wx.MOUSE_BTN_LEFT is returned for
+ the left button down, up and double click events, wx.MOUSE_BTN_MIDDLE
+ and wx.MOUSE_BTN_RIGHT for the same events for the middle and the
+ right buttons respectively.
+ """
return _core_.MouseEvent_GetButton(*args, **kwargs)
def ControlDown(*args, **kwargs):
- """ControlDown(self) -> bool"""
+ """
+ ControlDown(self) -> bool
+
+ Returns true if the control key was down at the time of the event.
+ """
return _core_.MouseEvent_ControlDown(*args, **kwargs)
def MetaDown(*args, **kwargs):
- """MetaDown(self) -> bool"""
+ """
+ MetaDown(self) -> bool
+
+ Returns true if the Meta key was down at the time of the event.
+ """
return _core_.MouseEvent_MetaDown(*args, **kwargs)
def AltDown(*args, **kwargs):
- """AltDown(self) -> bool"""
+ """
+ AltDown(self) -> bool
+
+ Returns true if the Alt key was down at the time of the event.
+ """
return _core_.MouseEvent_AltDown(*args, **kwargs)
def ShiftDown(*args, **kwargs):
- """ShiftDown(self) -> bool"""
+ """
+ ShiftDown(self) -> bool
+
+ Returns true if the Shift key was down at the time of the event.
+ """
return _core_.MouseEvent_ShiftDown(*args, **kwargs)
def CmdDown(*args, **kwargs):
"Cmd" is a pseudo key which is the same as Control for PC and Unix
platforms but the special "Apple" (a.k.a as "Command") key on
- Macs: it makes often sense to use it instead of, say, `ControlDown`
+ Macs. It often makes sense to use it instead of, say, `ControlDown`
because Cmd key is used for the same thing under Mac as Ctrl
- elsewhere. The Ctrl still exists, it's just not used for this
+ elsewhere. The Ctrl key still exists, it's just not used for this
purpose. So for non-Mac platforms this is the same as `ControlDown`
and Macs this is the same as `MetaDown`.
"""
return _core_.MouseEvent_CmdDown(*args, **kwargs)
def LeftDown(*args, **kwargs):
- """LeftDown(self) -> bool"""
+ """
+ LeftDown(self) -> bool
+
+ Returns true if the left mouse button state changed to down.
+ """
return _core_.MouseEvent_LeftDown(*args, **kwargs)
def MiddleDown(*args, **kwargs):
- """MiddleDown(self) -> bool"""
+ """
+ MiddleDown(self) -> bool
+
+ Returns true if the middle mouse button state changed to down.
+ """
return _core_.MouseEvent_MiddleDown(*args, **kwargs)
def RightDown(*args, **kwargs):
- """RightDown(self) -> bool"""
+ """
+ RightDown(self) -> bool
+
+ Returns true if the right mouse button state changed to down.
+ """
return _core_.MouseEvent_RightDown(*args, **kwargs)
def LeftUp(*args, **kwargs):
- """LeftUp(self) -> bool"""
+ """
+ LeftUp(self) -> bool
+
+ Returns true if the left mouse button state changed to up.
+ """
return _core_.MouseEvent_LeftUp(*args, **kwargs)
def MiddleUp(*args, **kwargs):
- """MiddleUp(self) -> bool"""
+ """
+ MiddleUp(self) -> bool
+
+ Returns true if the middle mouse button state changed to up.
+ """
return _core_.MouseEvent_MiddleUp(*args, **kwargs)
def RightUp(*args, **kwargs):
- """RightUp(self) -> bool"""
+ """
+ RightUp(self) -> bool
+
+ Returns true if the right mouse button state changed to up.
+ """
return _core_.MouseEvent_RightUp(*args, **kwargs)
def LeftDClick(*args, **kwargs):
- """LeftDClick(self) -> bool"""
+ """
+ LeftDClick(self) -> bool
+
+ Returns true if the event was a left button double click.
+ """
return _core_.MouseEvent_LeftDClick(*args, **kwargs)
def MiddleDClick(*args, **kwargs):
- """MiddleDClick(self) -> bool"""
+ """
+ MiddleDClick(self) -> bool
+
+ Returns true if the event was a middle button double click.
+ """
return _core_.MouseEvent_MiddleDClick(*args, **kwargs)
def RightDClick(*args, **kwargs):
- """RightDClick(self) -> bool"""
+ """
+ RightDClick(self) -> bool
+
+ Returns true if the event was a right button double click.
+ """
return _core_.MouseEvent_RightDClick(*args, **kwargs)
def LeftIsDown(*args, **kwargs):
- """LeftIsDown(self) -> bool"""
+ """
+ LeftIsDown(self) -> bool
+
+ Returns true if the left mouse button is currently down, independent
+ of the current event type.
+
+ Please notice that it is not the same as LeftDown which returns true
+ if the left mouse button was just pressed. Rather, it describes the
+ state of the mouse button before the event happened.
+
+ This event is usually used in the mouse event handlers which process
+ "move mouse" messages to determine whether the user is (still)
+ dragging the mouse.
+ """
return _core_.MouseEvent_LeftIsDown(*args, **kwargs)
def MiddleIsDown(*args, **kwargs):
- """MiddleIsDown(self) -> bool"""
+ """
+ MiddleIsDown(self) -> bool
+
+ Returns true if the middle mouse button is currently down, independent
+ of the current event type.
+ """
return _core_.MouseEvent_MiddleIsDown(*args, **kwargs)
def RightIsDown(*args, **kwargs):
- """RightIsDown(self) -> bool"""
+ """
+ RightIsDown(self) -> bool
+
+ Returns true if the right mouse button is currently down, independent
+ of the current event type.
+ """
return _core_.MouseEvent_RightIsDown(*args, **kwargs)
def Dragging(*args, **kwargs):
- """Dragging(self) -> bool"""
+ """
+ Dragging(self) -> bool
+
+ Returns true if this was a dragging event (motion while a button is
+ depressed).
+ """
return _core_.MouseEvent_Dragging(*args, **kwargs)
def Moving(*args, **kwargs):
- """Moving(self) -> bool"""
+ """
+ Moving(self) -> bool
+
+ Returns true if this was a motion event and no mouse buttons were
+ pressed. If any mouse button is held pressed, then this method returns
+ false and Dragging returns true.
+ """
return _core_.MouseEvent_Moving(*args, **kwargs)
def Entering(*args, **kwargs):
- """Entering(self) -> bool"""
+ """
+ Entering(self) -> bool
+
+ Returns true if the mouse was entering the window.
+ """
return _core_.MouseEvent_Entering(*args, **kwargs)
def Leaving(*args, **kwargs):
- """Leaving(self) -> bool"""
+ """
+ Leaving(self) -> bool
+
+ Returns true if the mouse was leaving the window.
+ """
return _core_.MouseEvent_Leaving(*args, **kwargs)
def GetPosition(*args, **kwargs):
"""
GetPosition(self) -> Point
- Returns the position of the mouse in window coordinates when the event
- happened.
+ Returns the pixel position of the mouse in window coordinates when the
+ event happened.
"""
return _core_.MouseEvent_GetPosition(*args, **kwargs)
"""
GetPositionTuple() -> (x,y)
- Returns the position of the mouse in window coordinates when the event
- happened.
+ Returns the pixel position of the mouse in window coordinates when the
+ event happened.
"""
return _core_.MouseEvent_GetPositionTuple(*args, **kwargs)
def GetLogicalPosition(*args, **kwargs):
- """GetLogicalPosition(self, DC dc) -> Point"""
+ """
+ GetLogicalPosition(self, DC dc) -> Point
+
+ Returns the logical mouse position in pixels (i.e. translated
+ according to the translation set for the DC, which usually indicates
+ that the window has been scrolled).
+ """
return _core_.MouseEvent_GetLogicalPosition(*args, **kwargs)
def GetX(*args, **kwargs):
- """GetX(self) -> int"""
+ """
+ GetX(self) -> int
+
+ Returns X coordinate of the physical mouse event position.
+ """
return _core_.MouseEvent_GetX(*args, **kwargs)
def GetY(*args, **kwargs):
- """GetY(self) -> int"""
+ """
+ GetY(self) -> int
+
+ Returns Y coordinate of the physical mouse event position.
+ """
return _core_.MouseEvent_GetY(*args, **kwargs)
def GetWheelRotation(*args, **kwargs):
- """GetWheelRotation(self) -> int"""
+ """
+ GetWheelRotation(self) -> int
+
+ Get wheel rotation, positive or negative indicates direction of
+ rotation. Current devices all send an event when rotation is equal to
+ +/-WheelDelta, but this allows for finer resolution devices to be
+ created in the future. Because of this you shouldn't assume that one
+ event is equal to 1 line or whatever, but you should be able to either
+ do partial line scrolling or wait until +/-WheelDelta rotation values
+ have been accumulated before scrolling.
+ """
return _core_.MouseEvent_GetWheelRotation(*args, **kwargs)
def GetWheelDelta(*args, **kwargs):
- """GetWheelDelta(self) -> int"""
+ """
+ GetWheelDelta(self) -> int
+
+ Get wheel delta, normally 120. This is the threshold for action to be
+ taken, and one such action (for example, scrolling one increment)
+ should occur for each delta.
+ """
return _core_.MouseEvent_GetWheelDelta(*args, **kwargs)
def GetLinesPerAction(*args, **kwargs):
- """GetLinesPerAction(self) -> int"""
+ """
+ GetLinesPerAction(self) -> int
+
+ Returns the configured number of lines (or whatever) to be scrolled
+ per wheel action. Defaults to three.
+ """
return _core_.MouseEvent_GetLinesPerAction(*args, **kwargs)
def IsPageScroll(*args, **kwargs):
- """IsPageScroll(self) -> bool"""
+ """
+ IsPageScroll(self) -> bool
+
+ Returns true if the system has been setup to do page scrolling with
+ the mouse wheel instead of line scrolling.
+ """
return _core_.MouseEvent_IsPageScroll(*args, **kwargs)
m_x = property(_core_.MouseEvent_m_x_get, _core_.MouseEvent_m_x_set)
#---------------------------------------------------------------------------
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):
- """__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):
- """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):
- """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):
- """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):
- """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):
- """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)
#---------------------------------------------------------------------------
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):
- """__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):
- """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):
- """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):
- """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):
- """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):
"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`
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):
- """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):
- """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):
- """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):
- """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
- Find the position of the event.
+ Find the position of the event, if applicable.
"""
return _core_.KeyEvent_GetPosition(*args, **kwargs)
"""
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):
- """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):
- """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)
#---------------------------------------------------------------------------
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):
- """__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):
- """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):
#---------------------------------------------------------------------------
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):
- """__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):
- """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):
#---------------------------------------------------------------------------
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):
#---------------------------------------------------------------------------
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):
- """__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):
- """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)
#---------------------------------------------------------------------------
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):
- """__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):
- """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):
#---------------------------------------------------------------------------
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):
- """__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):
- """GetWindow(self) -> Window"""
+ """
+ GetWindow(self) -> Window
+
+ The window which has just received the focus.
+ """
return _core_.ChildFocusEvent_GetWindow(*args, **kwargs)
#---------------------------------------------------------------------------
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):
- """__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):
- """GetActive(self) -> bool"""
+ """
+ GetActive(self) -> bool
+
+ Returns true if the application or window is being activated, false
+ otherwise.
+ """
return _core_.ActivateEvent_GetActive(*args, **kwargs)
#---------------------------------------------------------------------------
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):
- """__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
#---------------------------------------------------------------------------
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):
- """__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):
- """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):
- """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):
- """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)
#---------------------------------------------------------------------------
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):
- """__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):
- """SetLoggingOff(self, bool logOff)"""
+ """
+ SetLoggingOff(self, bool logOff)
+
+ Sets the 'logging off' flag.
+ """
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):
- """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)
+ def GetVeto(*args, **kwargs):
+ """GetVeto(self) -> bool"""
+ return _core_.CloseEvent_GetVeto(*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):
- """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 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):
- """__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
#---------------------------------------------------------------------------
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):
- """__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):
- """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)
#---------------------------------------------------------------------------
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):
- """__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
#---------------------------------------------------------------------------
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):
- """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):
- """GetNumberOfFiles(self) -> int"""
+ """
+ GetNumberOfFiles(self) -> int
+
+ Returns the number of files dropped.
+ """
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)
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):
- """__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):
- """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):
- """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):
- """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):
- """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):
- """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):
- """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):
- """Check(self, bool check)"""
+ """
+ Check(self, bool check)
+
+ Check or uncheck the UI element.
+ """
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):
- """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):
- """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):
- """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):
- """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):
- """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):
- """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):
- """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)
_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):
- """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):
- """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):
- """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):
- """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):
- """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):
- """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):
- """__init__(self) -> SysColourChangedEvent"""
+ """
+ __init__(self) -> SysColourChangedEvent
+
+ Constructor
+ """
newobj = _core_.new_SysColourChangedEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
#---------------------------------------------------------------------------
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):
- """__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):
- """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)
#---------------------------------------------------------------------------
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):
#---------------------------------------------------------------------------
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):
- """__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
#---------------------------------------------------------------------------
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):
- """__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):
- """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):
#---------------------------------------------------------------------------
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):
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):
- """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):
- """IsWindowChange(self) -> bool"""
+ """
+ IsWindowChange(self) -> bool
+
+ Returns ``True`` if window change is allowed.
+ """
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):
- """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):
- """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):
- """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):
- """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):
- """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
#---------------------------------------------------------------------------
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):
- """__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):
- """GetWindow(self) -> Window"""
+ """
+ GetWindow(self) -> Window
+
+ Returns the window that this event refers to.
+ """
return _core_.WindowCreateEvent_GetWindow(*args, **kwargs)
_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):
- """__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):
- """GetWindow(self) -> Window"""
+ """
+ GetWindow(self) -> Window
+
+ Returns the window that this event refers to.
+ """
return _core_.WindowDestroyEvent_GetWindow(*args, **kwargs)
#---------------------------------------------------------------------------
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):
- """__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):
- """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):
- """SetPosition(self, Point pos)"""
+ """
+ SetPosition(self, Point pos)
+
+ Sets the position at which the menu should be shown.
+ """
return _core_.ContextMenuEvent_SetPosition(*args, **kwargs)
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):
- """__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):
- """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):
- """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):
- """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):
- """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):
- """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)
_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):
- """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):
- """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):
- """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):
- """__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
- self.SetSelf(self)
+ self._SetSelf(self)
def __del__(self, destroy=_core_.delete_PyEvent):
"""__del__(self)"""
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):
_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):
- """__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
- self.SetSelf(self)
+ self._SetSelf(self)
def __del__(self, destroy=_core_.delete_PyCommandEvent):
"""__del__(self)"""
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):
_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):
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):
- """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)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
- self._setCallbackInfo(self, PyApp)
- self._setOORInfo(self)
+ self._setCallbackInfo(self, PyApp, False)
+ self._setOORInfo(self, False)
def __del__(self, destroy=_core_.delete_PyApp):
"""__del__(self)"""
except: pass
def _setCallbackInfo(*args, **kwargs):
- """_setCallbackInfo(self, PyObject self, PyObject _class)"""
+ """_setCallbackInfo(self, PyObject self, PyObject _class, bool incref)"""
return _core_.PyApp__setCallbackInfo(*args, **kwargs)
def GetAppName(*args, **kwargs):
self._BootstrapApp()
- def __del__(self):
- try:
- self.RestoreStdio() # Just in case the MainLoop was overridden
- except:
- pass
+ def __del__(self, destroy=wx.PyApp.__del__):
+ self.RestoreStdio() # Just in case the MainLoop was overridden
+ destroy(self)
+ def Destroy(self):
+ wx.PyApp.Destroy(self)
+ self.thisown = 0
def SetTopWindow(self, frame):
"""Set the \"main\" top level window"""
def RestoreStdio(self):
- _sys.stdout, _sys.stderr = self.saveStdio
+ try:
+ _sys.stdout, _sys.stderr = self.saveStdio
+ except:
+ pass
def SetOutputWindowAttributes(self, title=None, pos=None, size=None):
"""
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
"""
return _core_.Window_GetForegroundColour(*args, **kwargs)
+ def InheritsBackgroundColour(*args, **kwargs):
+ """InheritsBackgroundColour(self) -> bool"""
+ return _core_.Window_InheritsBackgroundColour(*args, **kwargs)
+
+ def UseBgCol(*args, **kwargs):
+ """UseBgCol(self) -> bool"""
+ return _core_.Window_UseBgCol(*args, **kwargs)
+
def SetBackgroundStyle(*args, **kwargs):
"""
SetBackgroundStyle(self, int style) -> bool
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.
"""
"""
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 Window_FromHWND(*args, **kwargs):
"""Window_FromHWND(Window parent, unsigned long _hWnd) -> Window"""
return _core_.Window_FromHWND(*args, **kwargs)
+
+def GetTopLevelWindows(*args, **kwargs):
+ """
+ GetTopLevelWindows() -> PyObject
+
+ Returns a list of the the application's top-level windows, (frames,
+ dialogs, etc.) NOTE: Currently this is a copy of the list maintained
+ by wxWidgets, and so it is only valid as long as no top-level windows
+ are closed or new top-level windows are created.
+
+ """
+ return _core_.GetTopLevelWindows(*args, **kwargs)
#---------------------------------------------------------------------------
class Validator(EvtHandler):
"""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):
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):
self.Add(*item)
# for backwards compatibility only, please do not use in new code
- AddWindow = wx._deprecated(Add, "AddWindow is deprecated, use `Add` instead.")
- AddSizer = wx._deprecated(Add, "AddSizer is deprecated, use `Add` instead.")
- AddSpacer = wx._deprecated(Add, "AddSpacer is deprecated, use `Add` instead.")
- PrependWindow = wx._deprecated(Prepend, "PrependWindow is deprecated, use `Prepend` instead.")
- PrependSizer = wx._deprecated(Prepend, "PrependSizer is deprecated, use `Prepend` instead.")
- PrependSpacer = wx._deprecated(Prepend, "PrependSpacer is deprecated, use `Prepend` instead.")
- InsertWindow = wx._deprecated(Insert, "InsertWindow is deprecated, use `Insert` instead.")
- InsertSizer = wx._deprecated(Insert, "InsertSizer is deprecated, use `Insert` instead.")
- InsertSpacer = wx._deprecated(Insert, "InsertSpacer is deprecated, use `Insert` instead.")
- RemoveWindow = wx._deprecated(Remove, "RemoveWindow is deprecated, use `Remove` instead.")
- RemoveSizer = wx._deprecated(Remove, "RemoveSizer is deprecated, use `Remove` instead.")
- RemovePos = wx._deprecated(Remove, "RemovePos is deprecated, use `Remove` instead.")
+ def AddWindow(self, *args, **kw):
+ """Compatibility alias for `Add`."""
+ return self.Add(*args, **kw)
+ def AddSizer(self, *args, **kw):
+ """Compatibility alias for `Add`."""
+ return self.Add(*args, **kw)
+ def AddSpacer(self, *args, **kw):
+ """Compatibility alias for `Add`."""
+ return self.Add(*args, **kw)
+
+ def PrependWindow(self, *args, **kw):
+ """Compatibility alias for `Prepend`."""
+ return self.Prepend(*args, **kw)
+ def PrependSizer(self, *args, **kw):
+ """Compatibility alias for `Prepend`."""
+ return self.Prepend(*args, **kw)
+ def PrependSpacer(self, *args, **kw):
+ """Compatibility alias for `Prepend`."""
+ return self.Prepend(*args, **kw)
+
+ def InsertWindow(self, *args, **kw):
+ """Compatibility alias for `Insert`."""
+ return self.Insert(*args, **kw)
+ def InsertSizer(self, *args, **kw):
+ """Compatibility alias for `Insert`."""
+ return self.Insert(*args, **kw)
+ def InsertSpacer(self, *args, **kw):
+ """Compatibility alias for `Insert`."""
+ return self.Insert(*args, **kw)
+
+ def RemoveWindow(self, *args, **kw):
+ """Compatibility alias for `Remove`."""
+ return self.Remove(*args, **kw)
+ def RemoveSizer(self, *args, **kw):
+ """Compatibility alias for `Remove`."""
+ return self.Remove(*args, **kw)
+ def RemovePos(self, *args, **kw):
+ """Compatibility alias for `Remove`."""
+ return self.Remove(*args, **kw)
def SetDimension(*args, **kwargs):
def Hide(self, item, recursive=False):
"""
- A convenience method for Show(item, False, recursive).
+ A convenience method for `Show` (item, False, recursive).
"""
return self.Show(item, False, recursive)
#----------------------------------------------------------------------------
-# Set the default string<-->unicode conversion encoding from the
-# locale. This encoding is used when string or unicode objects need
-# to be converted in order to pass them to wxWidgets. Please be aware
-# that the default encoding within the same locale may be slightly
-# different on different platforms. For example, please see
+# Set wxPython's default string<-->unicode conversion encoding from
+# the locale, but only if Python's default hasn't been changed. (We
+# assume that if the user has customized it already then that is the
+# encoding we need to use as well.)
+#
+# The encoding selected here is used when string or unicode objects
+# need to be converted in order to pass them to wxWidgets. Please be
+# aware that the default encoding within the same locale may be
+# slightly different on different platforms. For example, please see
# http://www.alanwood.net/demos/charsetdiffs.html for differences
# between the common latin/roman encodings.
-import locale
-default = locale.getdefaultlocale()[1]
+
+default = _sys.getdefaultencoding()
+if default == 'ascii':
+ import locale
+ import codecs
+ try:
+ default = locale.getdefaultlocale()[1]
+ codecs.lookup(default)
+ except (ValueError, LookupError, TypeError):
+ default = _sys.getdefaultencoding()
+ del locale
+ del codecs
if default:
wx.SetDefaultPyEncoding(default)
del default
-del locale
#----------------------------------------------------------------------------
projects / wxWidgets.git / blobdiff