-# This file was created automatically by SWIG.
+# This file was created automatically by SWIG 1.3.29.
# Don't modify this file, modify the SWIG interface instead.
import _gdi_
+import new
+new_instancemethod = new.instancemethod
+def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
+ if (name == "thisown"): return self.this.own(value)
+ if (name == "this"):
+ if type(value).__name__ == 'PySwigObject':
+ self.__dict__[name] = value
+ return
+ method = class_type.__swig_setmethods__.get(name,None)
+ if method: return method(self,value)
+ if (not static) or hasattr(self,name):
+ self.__dict__[name] = value
+ else:
+ raise AttributeError("You cannot add attributes to %s" % self)
+
+def _swig_setattr(self,class_type,name,value):
+ return _swig_setattr_nondynamic(self,class_type,name,value,0)
+
+def _swig_getattr(self,class_type,name):
+ if (name == "thisown"): return self.this.own()
+ method = class_type.__swig_getmethods__.get(name,None)
+ if method: return method(self)
+ raise AttributeError,name
+
+def _swig_repr(self):
+ try: strthis = "proxy of " + self.this.__repr__()
+ except: strthis = ""
+ return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
+
+import types
+try:
+ _object = types.ObjectType
+ _newclass = 1
+except AttributeError:
+ class _object : pass
+ _newclass = 0
+del types
+
+
+def _swig_setattr_nondynamic_method(set):
+ def set_attr(self,name,value):
+ if (name == "thisown"): return self.this.own(value)
+ if hasattr(self,name) or (name == "this"):
+ set(self,name,value)
+ else:
+ raise AttributeError("You cannot add attributes to %s" % self)
+ return set_attr
+
import _core
wx = _core
-__docfilter__ = wx.__docfilter__
#---------------------------------------------------------------------------
class GDIObject(_core.Object):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxGDIObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ GDIObject class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self) -> GDIObject"""
- newobj = _gdi_.new_GDIObject(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_GDIObject):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.GDIObject_swiginit(self,_gdi_.new_GDIObject(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_GDIObject
+ __del__ = lambda self : None;
def GetVisible(*args, **kwargs):
"""GetVisible(self) -> bool"""
return _gdi_.GDIObject_GetVisible(*args, **kwargs)
"""IsNull(self) -> bool"""
return _gdi_.GDIObject_IsNull(*args, **kwargs)
-
-class GDIObjectPtr(GDIObject):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = GDIObject
-_gdi_.GDIObject_swigregister(GDIObjectPtr)
+GDIObject_swigregister = _gdi_.GDIObject_swigregister
+GDIObject_swigregister(GDIObject)
#---------------------------------------------------------------------------
class Colour(_core.Object):
"""
- A colour is an object representing a combination of Red, Green, and Blue (RGB)
- intensity values, and is used to determine drawing colours, window colours,
- etc. Valid RGB values are in the range 0 to 255.
+ A colour is an object representing a combination of Red, Green, and
+ Blue (RGB) intensity values, and is used to determine drawing colours,
+ window colours, etc. Valid RGB values are in the range 0 to 255.
- In wxPython there are typemaps that will automatically convert from a colour
- name, or from a '#RRGGBB' colour hex value string to a wx.Colour object when
- calling C++ methods that expect a wxColour. This means that the following are
- all equivallent:
+ In wxPython there are typemaps that will automatically convert from a
+ colour name, from a '#RRGGBB' colour hex value string, or from a 3
+ integer tuple to a wx.Colour object when calling C++ methods that
+ expect a wxColour. This means that the following are all
+ equivallent::
win.SetBackgroundColour(wxColour(0,0,255))
win.SetBackgroundColour('BLUE')
win.SetBackgroundColour('#0000FF')
+ win.SetBackgroundColour((0,0,255))
+
+ Additional colour names and their coresponding values can be added
+ using `wx.ColourDatabase`. Various system colours (as set in the
+ user's system preferences) can be retrieved with
+ `wx.SystemSettings.GetColour`.
- You can retrieve the various current system colour settings with
- wx.SystemSettings.GetColour.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxColour instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""
- __init__(self, unsigned char red=0, unsigned char green=0, unsigned char blue=0) -> Colour
+ __init__(self, byte red=0, byte green=0, byte blue=0) -> Colour
Constructs a colour from red, green and blue values.
- """
- newobj = _gdi_.new_Colour(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_Colour):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
+ :see: Alternate constructors `wx.NamedColour` and `wx.ColourRGB`.
+
+ """
+ _gdi_.Colour_swiginit(self,_gdi_.new_Colour(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_Colour
+ __del__ = lambda self : None;
def Red(*args, **kwargs):
"""
- Red(self) -> unsigned char
+ Red(self) -> byte
Returns the red intensity.
"""
def Green(*args, **kwargs):
"""
- Green(self) -> unsigned char
+ Green(self) -> byte
Returns the green intensity.
"""
def Blue(*args, **kwargs):
"""
- Blue(self) -> unsigned char
+ Blue(self) -> byte
Returns the blue intensity.
"""
def Set(*args, **kwargs):
"""
- Set(self, unsigned char red, unsigned char green, unsigned char blue)
+ Set(self, byte red, byte green, byte blue)
Sets the RGB intensity values.
"""
"""
SetFromName(self, String colourName)
- Sets the RGB intensity values using a colour name listed in wx.TheColourDatabase.
+ Sets the RGB intensity values using a colour name listed in
+ ``wx.TheColourDatabase``.
"""
return _gdi_.Colour_SetFromName(*args, **kwargs)
GetPixel(self) -> long
Returns a pixel value which is platform-dependent. On Windows, a
- COLORREF is returned. On X, an allocated pixel value is returned.
- -1 is returned if the pixel is invalid (on X, unallocated).
+ COLORREF is returned. On X, an allocated pixel value is returned. -1
+ is returned if the pixel is invalid (on X, unallocated).
"""
return _gdi_.Colour_GetPixel(*args, **kwargs)
"""
return _gdi_.Colour_GetRGB(*args, **kwargs)
- asTuple = Get
- def __str__(self): return str(self.asTuple())
- def __repr__(self): return 'wx.Colour' + str(self.asTuple())
+ asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
+ def __str__(self): return str(self.Get())
+ def __repr__(self): return 'wx.Colour' + str(self.Get())
def __nonzero__(self): return self.Ok()
__safe_for_unpickling__ = True
def __reduce__(self): return (Colour, self.Get())
-
-class ColourPtr(Colour):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Colour
-_gdi_.Colour_swigregister(ColourPtr)
+Colour_swigregister = _gdi_.Colour_swigregister
+Colour_swigregister(Colour)
def NamedColour(*args, **kwargs):
"""
NamedColour(String colorName) -> Colour
- Constructs a colour object using a colour name listed in wx.TheColourDatabase.
+ Constructs a colour object using a colour name listed in
+ ``wx.TheColourDatabase``.
"""
val = _gdi_.new_NamedColour(*args, **kwargs)
- val.thisown = 1
return val
def ColourRGB(*args, **kwargs):
Constructs a colour from a packed RGB value.
"""
val = _gdi_.new_ColourRGB(*args, **kwargs)
- val.thisown = 1
return val
Color = Colour
ColorRGB = ColourRGB
class Palette(GDIObject):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPalette instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ Palette class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self, int n, unsigned char red, unsigned char green, unsigned char blue) -> Palette"""
- newobj = _gdi_.new_Palette(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_Palette):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.Palette_swiginit(self,_gdi_.new_Palette(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_Palette
+ __del__ = lambda self : None;
def GetPixel(*args, **kwargs):
"""GetPixel(self, byte red, byte green, byte blue) -> int"""
return _gdi_.Palette_GetPixel(*args, **kwargs)
def GetRGB(*args, **kwargs):
- """GetRGB(int pixel) -> (R,G,B)"""
+ """GetRGB(self, int pixel) -> (R,G,B)"""
return _gdi_.Palette_GetRGB(*args, **kwargs)
+ def GetColoursCount(*args, **kwargs):
+ """GetColoursCount(self) -> int"""
+ return _gdi_.Palette_GetColoursCount(*args, **kwargs)
+
def Ok(*args, **kwargs):
"""Ok(self) -> bool"""
return _gdi_.Palette_Ok(*args, **kwargs)
def __nonzero__(self): return self.Ok()
-
-class PalettePtr(Palette):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Palette
-_gdi_.Palette_swigregister(PalettePtr)
+Palette_swigregister = _gdi_.Palette_swigregister
+Palette_swigregister(Palette)
#---------------------------------------------------------------------------
class Pen(GDIObject):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPen instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ Pen class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self, Colour colour, int width=1, int style=SOLID) -> Pen"""
- newobj = _gdi_.new_Pen(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_Pen):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.Pen_swiginit(self,_gdi_.new_Pen(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_Pen
+ __del__ = lambda self : None;
def GetCap(*args, **kwargs):
"""GetCap(self) -> int"""
return _gdi_.Pen_GetCap(*args, **kwargs)
return _gdi_.Pen_SetWidth(*args, **kwargs)
def SetDashes(*args, **kwargs):
- """SetDashes(self, int dashes, wxDash dashes_array)"""
+ """SetDashes(self, int dashes)"""
return _gdi_.Pen_SetDashes(*args, **kwargs)
def GetDashes(*args, **kwargs):
"""GetDashes(self) -> PyObject"""
return _gdi_.Pen_GetDashes(*args, **kwargs)
+ def _SetDashes(*args, **kwargs):
+ """_SetDashes(self, PyObject _self, PyObject pyDashes)"""
+ return _gdi_.Pen__SetDashes(*args, **kwargs)
+
+ def SetDashes(self, dashes):
+ """
+ Associate a list of dash lengths with the Pen.
+ """
+ self._SetDashes(self, dashes)
+
+ def GetDashCount(*args, **kwargs):
+ """GetDashCount(self) -> int"""
+ return _gdi_.Pen_GetDashCount(*args, **kwargs)
+
def __eq__(*args, **kwargs):
"""__eq__(self, Pen other) -> bool"""
return _gdi_.Pen___eq__(*args, **kwargs)
"""__ne__(self, Pen other) -> bool"""
return _gdi_.Pen___ne__(*args, **kwargs)
- def GetDashCount(*args, **kwargs):
- """GetDashCount(self) -> int"""
- return _gdi_.Pen_GetDashCount(*args, **kwargs)
-
def __nonzero__(self): return self.Ok()
+Pen_swigregister = _gdi_.Pen_swigregister
+Pen_swigregister(Pen)
-class PenPtr(Pen):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Pen
-_gdi_.Pen_swigregister(PenPtr)
-
-class PyPen(Pen):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPyPen instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, Colour colour, int width=1, int style=SOLID) -> PyPen"""
- newobj = _gdi_.new_PyPen(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_PyPen):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
- def SetDashes(*args, **kwargs):
- """SetDashes(self, int dashes, wxDash dashes_array)"""
- return _gdi_.PyPen_SetDashes(*args, **kwargs)
-
-
-class PyPenPtr(PyPen):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PyPen
-_gdi_.PyPen_swigregister(PyPenPtr)
-
-Pen = PyPen
#---------------------------------------------------------------------------
class Brush(GDIObject):
"""
- A brush is a drawing tool for filling in areas. It is used for painting the
- background of rectangles, ellipses, etc. It has a colour and a style.
+ A brush is a drawing tool for filling in areas. It is used for
+ painting the background of rectangles, ellipses, etc. when drawing on
+ a `wx.DC`. It has a colour and a style.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxBrush instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""
__init__(self, Colour colour, int style=SOLID) -> Brush
- Constructs a brush from a colour object and style.
+ Constructs a brush from a `wx.Colour` object and a style.
"""
- newobj = _gdi_.new_Brush(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_Brush):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.Brush_swiginit(self,_gdi_.new_Brush(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_Brush
+ __del__ = lambda self : None;
def SetColour(*args, **kwargs):
- """SetColour(self, Colour col)"""
+ """
+ SetColour(self, Colour col)
+
+ Set the brush's `wx.Colour`.
+ """
return _gdi_.Brush_SetColour(*args, **kwargs)
def SetStyle(*args, **kwargs):
- """SetStyle(self, int style)"""
+ """
+ SetStyle(self, int style)
+
+ Sets the style of the brush. See `__init__` for a listing of styles.
+ """
return _gdi_.Brush_SetStyle(*args, **kwargs)
def SetStipple(*args, **kwargs):
- """SetStipple(self, Bitmap stipple)"""
+ """
+ SetStipple(self, Bitmap stipple)
+
+ Sets the stipple `wx.Bitmap`.
+ """
return _gdi_.Brush_SetStipple(*args, **kwargs)
def GetColour(*args, **kwargs):
- """GetColour(self) -> Colour"""
+ """
+ GetColour(self) -> Colour
+
+ Returns the `wx.Colour` of the brush.
+ """
return _gdi_.Brush_GetColour(*args, **kwargs)
def GetStyle(*args, **kwargs):
- """GetStyle(self) -> int"""
+ """
+ GetStyle(self) -> int
+
+ Returns the style of the brush. See `__init__` for a listing of
+ styles.
+ """
return _gdi_.Brush_GetStyle(*args, **kwargs)
def GetStipple(*args, **kwargs):
- """GetStipple(self) -> Bitmap"""
+ """
+ GetStipple(self) -> Bitmap
+
+ Returns the stiple `wx.Bitmap` of the brush. If the brush does not
+ have a wx.STIPPLE style, then the return value may be non-None but an
+ uninitialised bitmap (`wx.Bitmap.Ok` returns False).
+ """
return _gdi_.Brush_GetStipple(*args, **kwargs)
+ def IsHatch(*args, **kwargs):
+ """
+ IsHatch(self) -> bool
+
+ Is the current style a hatch type?
+ """
+ return _gdi_.Brush_IsHatch(*args, **kwargs)
+
def Ok(*args, **kwargs):
- """Ok(self) -> bool"""
+ """
+ Ok(self) -> bool
+
+ Returns True if the brush is initialised and valid.
+ """
return _gdi_.Brush_Ok(*args, **kwargs)
def __nonzero__(self): return self.Ok()
+Brush_swigregister = _gdi_.Brush_swigregister
+Brush_swigregister(Brush)
+
+def BrushFromBitmap(*args, **kwargs):
+ """
+ BrushFromBitmap(Bitmap stippleBitmap) -> Brush
-class BrushPtr(Brush):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Brush
-_gdi_.Brush_swigregister(BrushPtr)
+ Constructs a stippled brush using a bitmap.
+ """
+ val = _gdi_.new_BrushFromBitmap(*args, **kwargs)
+ return val
class Bitmap(GDIObject):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxBitmap instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """
+ The wx.Bitmap class encapsulates the concept of a platform-dependent
+ bitmap. It can be either monochrome or colour, and either loaded from
+ a file or created dynamically. A bitmap can be selected into a memory
+ device context (instance of `wx.MemoryDC`). This enables the bitmap to
+ be copied to a window or memory device context using `wx.DC.Blit`, or
+ to be used as a drawing surface.
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""
__init__(self, String name, int type=BITMAP_TYPE_ANY) -> Bitmap
Loads a bitmap from a file.
"""
- newobj = _gdi_.new_Bitmap(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_Bitmap):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.Bitmap_swiginit(self,_gdi_.new_Bitmap(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_Bitmap
+ __del__ = lambda self : None;
def Ok(*args, **kwargs):
"""Ok(self) -> bool"""
return _gdi_.Bitmap_Ok(*args, **kwargs)
"""
ConvertToImage(self) -> Image
- Creates a platform-independent image from a platform-dependent bitmap. This
- preserves mask information so that bitmaps and images can be converted back
- and forth without loss in that respect.
+ Creates a platform-independent image from a platform-dependent
+ bitmap. This preserves mask information so that bitmaps and images can
+ be converted back and forth without loss in that respect.
"""
return _gdi_.Bitmap_ConvertToImage(*args, **kwargs)
"""
GetMask(self) -> Mask
- Gets the associated mask (if any) which may have been loaded from a file
- or explpicitly set for the bitmap.
+ Gets the associated mask (if any) which may have been loaded from a
+ file or explpicitly set for the bitmap.
+
+ :see: `SetMask`, `wx.Mask`
+
"""
return _gdi_.Bitmap_GetMask(*args, **kwargs)
SetMask(self, Mask mask)
Sets the mask for this bitmap.
+
+ :see: `GetMask`, `wx.Mask`
+
"""
return _gdi_.Bitmap_SetMask(*args, **kwargs)
"""
GetSubBitmap(self, Rect rect) -> Bitmap
- Returns a sub bitmap of the current one as long as the rect belongs entirely
- to the bitmap. This function preserves bit depth and mask information.
+ Returns a sub-bitmap of the current one as long as the rect belongs
+ entirely to the bitmap. This function preserves bit depth and mask
+ information.
"""
return _gdi_.Bitmap_GetSubBitmap(*args, **kwargs)
def SaveFile(*args, **kwargs):
"""
- SaveFile(self, String name, int type, Palette palette=(wxPalette *) NULL) -> bool
+ SaveFile(self, String name, int type, Palette palette=None) -> bool
- Saves a bitmap in the named file.
+ Saves a bitmap in the named file. See `__init__` for a description of
+ the ``type`` parameter.
"""
return _gdi_.Bitmap_SaveFile(*args, **kwargs)
"""
LoadFile(self, String name, int type) -> bool
- Loads a bitmap from a file
+ Loads a bitmap from a file. See `__init__` for a description of the
+ ``type`` parameter.
"""
return _gdi_.Bitmap_LoadFile(*args, **kwargs)
+ def GetPalette(*args, **kwargs):
+ """GetPalette(self) -> Palette"""
+ return _gdi_.Bitmap_GetPalette(*args, **kwargs)
+
def CopyFromIcon(*args, **kwargs):
"""CopyFromIcon(self, Icon icon) -> bool"""
return _gdi_.Bitmap_CopyFromIcon(*args, **kwargs)
"""
SetHeight(self, int height)
- Set the height property (does not affect the bitmap data).
+ Set the height property (does not affect the existing bitmap data).
"""
return _gdi_.Bitmap_SetHeight(*args, **kwargs)
"""
SetWidth(self, int width)
- Set the width property (does not affect the bitmap data).
+ Set the width property (does not affect the existing bitmap data).
"""
return _gdi_.Bitmap_SetWidth(*args, **kwargs)
"""
SetDepth(self, int depth)
- Set the depth property (does not affect the bitmap data).
+ Set the depth property (does not affect the existing bitmap data).
"""
return _gdi_.Bitmap_SetDepth(*args, **kwargs)
"""
SetSize(self, Size size)
- Set the bitmap size
+ Set the bitmap size (does not affect the existing bitmap data).
"""
return _gdi_.Bitmap_SetSize(*args, **kwargs)
"""__ne__(self, Bitmap other) -> bool"""
return _gdi_.Bitmap___ne__(*args, **kwargs)
+Bitmap_swigregister = _gdi_.Bitmap_swigregister
+Bitmap_swigregister(Bitmap)
+
+def EmptyBitmap(*args, **kwargs):
+ """
+ EmptyBitmap(int width, int height, int depth=-1) -> Bitmap
-class BitmapPtr(Bitmap):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Bitmap
-_gdi_.Bitmap_swigregister(BitmapPtr)
+ Creates a new bitmap of the given size. A depth of -1 indicates the
+ depth of the current screen or visual. Some platforms only support 1
+ for monochrome and -1 for the current display depth.
+ """
+ val = _gdi_.new_EmptyBitmap(*args, **kwargs)
+ return val
def BitmapFromIcon(*args, **kwargs):
"""
BitmapFromIcon(Icon icon) -> Bitmap
- Create a new bitmap from an Icon object.
+ Create a new bitmap from a `wx.Icon` object.
"""
val = _gdi_.new_BitmapFromIcon(*args, **kwargs)
- val.thisown = 1
return val
def BitmapFromImage(*args, **kwargs):
"""
BitmapFromImage(Image image, int depth=-1) -> Bitmap
- Creates bitmap object from the image. This has to be done to actually display
- an image as you cannot draw an image directly on a window. The resulting
- bitmap will use the provided colour depth (or that of the current system if
- depth is -1) which entails that a colour reduction has to take place.
+ Creates bitmap object from a `wx.Image`. This has to be done to
+ actually display a `wx.Image` as you cannot draw an image directly on
+ a window. The resulting bitmap will use the provided colour depth (or
+ that of the current screen colour depth if depth is -1) which entails
+ that a colour reduction may have to take place.
"""
val = _gdi_.new_BitmapFromImage(*args, **kwargs)
- val.thisown = 1
return val
def BitmapFromXPMData(*args, **kwargs):
Construct a Bitmap from a list of strings formatted as XPM data.
"""
val = _gdi_.new_BitmapFromXPMData(*args, **kwargs)
- val.thisown = 1
return val
def BitmapFromBits(*args, **kwargs):
"""
BitmapFromBits(PyObject bits, int width, int height, int depth=1) -> Bitmap
- Creates a bitmap from an array of bits. You should only use this function for
- monochrome bitmaps (depth 1) in portable programs: in this case the bits
- parameter should contain an XBM image. For other bit depths, the behaviour is
- platform dependent.
+ Creates a bitmap from an array of bits. You should only use this
+ function for monochrome bitmaps (depth 1) in portable programs: in
+ this case the bits parameter should contain an XBM image. For other
+ bit depths, the behaviour is platform dependent.
"""
val = _gdi_.new_BitmapFromBits(*args, **kwargs)
- val.thisown = 1
- return val
-
-def EmptyBitmap(*args):
- """
- EmptyBitmap(int width, int height, int depth=-1) -> Bitmap
- EmptyBitmap(Size size, int depth=-1) -> Bitmap
-
- Creates a new bitmap of the given size. A depth of -1 indicates
- the depth of the current screen or visual. Some platforms only
- support 1 for monochrome and -1 for the current colour setting.
- """
- val = _gdi_.new_EmptyBitmap(*args)
- val.thisown = 1
return val
class Mask(_core.Object):
"""
- This class encapsulates a monochrome mask bitmap, where the masked area is
- black and the unmasked area is white. When associated with a bitmap and drawn
- in a device context, the unmasked area of the bitmap will be drawn, and the
- masked area will not be drawn.
+ This class encapsulates a monochrome mask bitmap, where the masked
+ area is black and the unmasked area is white. When associated with a
+ bitmap and drawn in a device context, the unmasked area of the bitmap
+ will be drawn, and the masked area will not be drawn.
+
+ A mask may be associated with a `wx.Bitmap`. It is used in
+ `wx.DC.DrawBitmap` or `wx.DC.Blit` when the source device context is a
+ `wx.MemoryDC` with a `wx.Bitmap` selected into it that contains a
+ mask.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxMask instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""
__init__(self, Bitmap bitmap, Colour colour=NullColour) -> Mask
- Constructs a mask from a bitmap and a colour in that bitmap that indicates
- the transparent portions of the mask, by default BLACK is used.
- """
- newobj = _gdi_.new_Mask(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ Constructs a mask from a `wx.Bitmap` and a `wx.Colour` in that bitmap
+ that indicates the transparent portions of the mask. In other words,
+ the pixels in ``bitmap`` that match ``colour`` will be the transparent
+ portions of the mask. If no ``colour`` or an invalid ``colour`` is
+ passed then BLACK is used.
-class MaskPtr(Mask):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Mask
-_gdi_.Mask_swigregister(MaskPtr)
+ :see: `wx.Bitmap`, `wx.Colour`
+ """
+ _gdi_.Mask_swiginit(self,_gdi_.new_Mask(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_Mask
+ __del__ = lambda self : None;
+Mask_swigregister = _gdi_.Mask_swigregister
+Mask_swigregister(Mask)
-MaskColour = Mask
+MaskColour = wx._deprecated(Mask, "wx.MaskColour is deprecated, use `wx.Mask` instead.")
class Icon(GDIObject):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxIcon instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ Icon class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self, String name, int type, int desiredWidth=-1, int desiredHeight=-1) -> Icon"""
- newobj = _gdi_.new_Icon(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_Icon):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.Icon_swiginit(self,_gdi_.new_Icon(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_Icon
+ __del__ = lambda self : None;
def LoadFile(*args, **kwargs):
"""LoadFile(self, String name, int type) -> bool"""
return _gdi_.Icon_LoadFile(*args, **kwargs)
return _gdi_.Icon_CopyFromBitmap(*args, **kwargs)
def __nonzero__(self): return self.Ok()
-
-class IconPtr(Icon):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Icon
-_gdi_.Icon_swigregister(IconPtr)
+Icon_swigregister = _gdi_.Icon_swigregister
+Icon_swigregister(Icon)
def EmptyIcon(*args, **kwargs):
"""EmptyIcon() -> Icon"""
val = _gdi_.new_EmptyIcon(*args, **kwargs)
- val.thisown = 1
return val
def IconFromLocation(*args, **kwargs):
"""IconFromLocation(IconLocation loc) -> Icon"""
val = _gdi_.new_IconFromLocation(*args, **kwargs)
- val.thisown = 1
return val
def IconFromBitmap(*args, **kwargs):
"""IconFromBitmap(Bitmap bmp) -> Icon"""
val = _gdi_.new_IconFromBitmap(*args, **kwargs)
- val.thisown = 1
return val
def IconFromXPMData(*args, **kwargs):
"""IconFromXPMData(PyObject listOfStrings) -> Icon"""
val = _gdi_.new_IconFromXPMData(*args, **kwargs)
- val.thisown = 1
return val
class IconLocation(object):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxIconLocation instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ IconLocation class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self, String filename=&wxPyEmptyString, int num=0) -> IconLocation"""
- newobj = _gdi_.new_IconLocation(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_IconLocation):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.IconLocation_swiginit(self,_gdi_.new_IconLocation(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_IconLocation
+ __del__ = lambda self : None;
def IsOk(*args, **kwargs):
"""IsOk(self) -> bool"""
return _gdi_.IconLocation_IsOk(*args, **kwargs)
"""GetIndex(self) -> int"""
return _gdi_.IconLocation_GetIndex(*args, **kwargs)
-
-class IconLocationPtr(IconLocation):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = IconLocation
-_gdi_.IconLocation_swigregister(IconLocationPtr)
+IconLocation_swigregister = _gdi_.IconLocation_swigregister
+IconLocation_swigregister(IconLocation)
class IconBundle(object):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxIconBundle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ IconBundle class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self) -> IconBundle"""
- newobj = _gdi_.new_IconBundle(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_IconBundle):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.IconBundle_swiginit(self,_gdi_.new_IconBundle(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_IconBundle
+ __del__ = lambda self : None;
def AddIcon(*args, **kwargs):
"""AddIcon(self, Icon icon)"""
return _gdi_.IconBundle_AddIcon(*args, **kwargs)
"""GetIcon(self, Size size) -> Icon"""
return _gdi_.IconBundle_GetIcon(*args, **kwargs)
-
-class IconBundlePtr(IconBundle):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = IconBundle
-_gdi_.IconBundle_swigregister(IconBundlePtr)
+IconBundle_swigregister = _gdi_.IconBundle_swigregister
+IconBundle_swigregister(IconBundle)
def IconBundleFromFile(*args, **kwargs):
"""IconBundleFromFile(String file, long type) -> IconBundle"""
val = _gdi_.new_IconBundleFromFile(*args, **kwargs)
- val.thisown = 1
return val
def IconBundleFromIcon(*args, **kwargs):
"""IconBundleFromIcon(Icon icon) -> IconBundle"""
val = _gdi_.new_IconBundleFromIcon(*args, **kwargs)
- val.thisown = 1
return val
class Cursor(GDIObject):
"""
- A cursor is a small bitmap usually used for denoting where the
- mouse pointer is, with a picture that might indicate the
- interpretation of a mouse click.
+ A cursor is a small bitmap usually used for denoting where the mouse
+ pointer is, with a picture that might indicate the interpretation of a
+ mouse click.
A single cursor object may be used in many windows (any subwindow
- type). The wxWindows convention is to set the cursor for a
- window, as in X, rather than to set it globally as in MS Windows,
- although a global wx.SetCursor function is also available for use
- on MS Windows.
+ type). The wxWindows convention is to set the cursor for a window, as
+ in X, rather than to set it globally as in MS Windows, although a
+ global `wx.SetCursor` function is also available for use on MS Windows.
+
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxCursor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""
__init__(self, String cursorName, long type, int hotSpotX=0, int hotSpotY=0) -> Cursor
Construct a Cursor from a file. Specify the type of file using
- wx.BITAMP_TYPE* constants, and specify the hotspot if not using a
- .cur file.
-
- This cursor is not available on wxGTK, use wx.StockCursor,
- wx.CursorFromImage, or wx.CursorFromBits instead.
- """
- newobj = _gdi_.new_Cursor(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_Cursor):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ wx.BITAMP_TYPE* constants, and specify the hotspot if not using a .cur
+ file.
+ """
+ _gdi_.Cursor_swiginit(self,_gdi_.new_Cursor(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_Cursor
+ __del__ = lambda self : None;
def Ok(*args, **kwargs):
"""Ok(self) -> bool"""
return _gdi_.Cursor_Ok(*args, **kwargs)
def __nonzero__(self): return self.Ok()
-
-class CursorPtr(Cursor):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Cursor
-_gdi_.Cursor_swigregister(CursorPtr)
+Cursor_swigregister = _gdi_.Cursor_swigregister
+Cursor_swigregister(Cursor)
def StockCursor(*args, **kwargs):
"""
StockCursor(int id) -> Cursor
- Create a cursor using one of the stock cursors. Note that not
- all cursors are available on all platforms.
+ Create a cursor using one of the stock cursors. Note that not all
+ stock cursors are available on all platforms.
"""
val = _gdi_.new_StockCursor(*args, **kwargs)
- val.thisown = 1
return val
def CursorFromImage(*args, **kwargs):
"""
CursorFromImage(Image image) -> Cursor
- Constructs a cursor from a wxImage. The cursor is monochrome,
- colors with the RGB elements all greater than 127 will be
- foreground, colors less than this background. The mask (if any)
- will be used as transparent.
-
- In MSW the foreground will be white and the background black. The
- cursor is resized to 32x32 In GTK, the two most frequent colors
- will be used for foreground and background. The cursor will be
- displayed at the size of the image. On MacOS the cursor is
- resized to 16x16 and currently only shown as black/white (mask
- respected).
+ Constructs a cursor from a `wx.Image`. The mask (if any) will be used
+ for setting the transparent portions of the cursor.
"""
val = _gdi_.new_CursorFromImage(*args, **kwargs)
- val.thisown = 1
return val
#---------------------------------------------------------------------------
PartRegion = _gdi_.PartRegion
InRegion = _gdi_.InRegion
class Region(GDIObject):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxRegion instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ Region class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self, int x=0, int y=0, int width=0, int height=0) -> Region"""
- newobj = _gdi_.new_Region(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_Region):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.Region_swiginit(self,_gdi_.new_Region(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_Region
+ __del__ = lambda self : None;
def Clear(*args, **kwargs):
"""Clear(self)"""
return _gdi_.Region_Clear(*args, **kwargs)
return _gdi_.Region_ConvertToBitmap(*args, **kwargs)
def UnionBitmap(*args, **kwargs):
- """UnionBitmap(self, Bitmap bmp, Colour transColour=NullColour, int tolerance=0) -> bool"""
+ """UnionBitmap(self, Bitmap bmp) -> bool"""
return _gdi_.Region_UnionBitmap(*args, **kwargs)
+ def UnionBitmapColour(*args, **kwargs):
+ """UnionBitmapColour(self, Bitmap bmp, Colour transColour, int tolerance=0) -> bool"""
+ return _gdi_.Region_UnionBitmapColour(*args, **kwargs)
-class RegionPtr(Region):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Region
-_gdi_.Region_swigregister(RegionPtr)
+Region_swigregister = _gdi_.Region_swigregister
+Region_swigregister(Region)
def RegionFromBitmap(*args, **kwargs):
- """RegionFromBitmap(Bitmap bmp, Colour transColour=NullColour, int tolerance=0) -> Region"""
+ """RegionFromBitmap(Bitmap bmp) -> Region"""
val = _gdi_.new_RegionFromBitmap(*args, **kwargs)
- val.thisown = 1
+ return val
+
+def RegionFromBitmapColour(*args, **kwargs):
+ """RegionFromBitmapColour(Bitmap bmp, Colour transColour, int tolerance=0) -> Region"""
+ val = _gdi_.new_RegionFromBitmapColour(*args, **kwargs)
return val
def RegionFromPoints(*args, **kwargs):
- """RegionFromPoints(int points, Point points_array, int fillStyle=WINDING_RULE) -> Region"""
+ """RegionFromPoints(int points, int fillStyle=WINDING_RULE) -> Region"""
val = _gdi_.new_RegionFromPoints(*args, **kwargs)
- val.thisown = 1
return val
class RegionIterator(_core.Object):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxRegionIterator instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ RegionIterator class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self, Region region) -> RegionIterator"""
- newobj = _gdi_.new_RegionIterator(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_RegionIterator):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.RegionIterator_swiginit(self,_gdi_.new_RegionIterator(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_RegionIterator
+ __del__ = lambda self : None;
def GetX(*args, **kwargs):
"""GetX(self) -> int"""
return _gdi_.RegionIterator_GetX(*args, **kwargs)
"""__nonzero__(self) -> bool"""
return _gdi_.RegionIterator___nonzero__(*args, **kwargs)
-
-class RegionIteratorPtr(RegionIterator):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = RegionIterator
-_gdi_.RegionIterator_swigregister(RegionIteratorPtr)
+RegionIterator_swigregister = _gdi_.RegionIterator_swigregister
+RegionIterator_swigregister(RegionIterator)
#---------------------------------------------------------------------------
#---------------------------------------------------------------------------
class NativeFontInfo(object):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxNativeFontInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ NativeFontInfo class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self) -> NativeFontInfo"""
- newobj = _gdi_.new_NativeFontInfo(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_NativeFontInfo):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.NativeFontInfo_swiginit(self,_gdi_.new_NativeFontInfo(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_NativeFontInfo
+ __del__ = lambda self : None;
def Init(*args, **kwargs):
"""Init(self)"""
return _gdi_.NativeFontInfo_Init(*args, **kwargs)
"""ToUserString(self) -> String"""
return _gdi_.NativeFontInfo_ToUserString(*args, **kwargs)
-
-class NativeFontInfoPtr(NativeFontInfo):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = NativeFontInfo
-_gdi_.NativeFontInfo_swigregister(NativeFontInfoPtr)
+NativeFontInfo_swigregister = _gdi_.NativeFontInfo_swigregister
+NativeFontInfo_swigregister(NativeFontInfo)
class NativeEncodingInfo(object):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxNativeEncodingInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ """Proxy of C++ NativeEncodingInfo class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
facename = property(_gdi_.NativeEncodingInfo_facename_get, _gdi_.NativeEncodingInfo_facename_set)
encoding = property(_gdi_.NativeEncodingInfo_encoding_get, _gdi_.NativeEncodingInfo_encoding_set)
- def __init__(self, *args, **kwargs):
+ def __init__(self, *args, **kwargs):
"""__init__(self) -> NativeEncodingInfo"""
- newobj = _gdi_.new_NativeEncodingInfo(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_NativeEncodingInfo):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.NativeEncodingInfo_swiginit(self,_gdi_.new_NativeEncodingInfo(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_NativeEncodingInfo
+ __del__ = lambda self : None;
def FromString(*args, **kwargs):
"""FromString(self, String s) -> bool"""
return _gdi_.NativeEncodingInfo_FromString(*args, **kwargs)
"""ToString(self) -> String"""
return _gdi_.NativeEncodingInfo_ToString(*args, **kwargs)
-
-class NativeEncodingInfoPtr(NativeEncodingInfo):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = NativeEncodingInfo
-_gdi_.NativeEncodingInfo_swigregister(NativeEncodingInfoPtr)
+NativeEncodingInfo_swigregister = _gdi_.NativeEncodingInfo_swigregister
+NativeEncodingInfo_swigregister(NativeEncodingInfo)
def GetNativeFontEncoding(*args, **kwargs):
- """GetNativeFontEncoding(int encoding) -> NativeEncodingInfo"""
- return _gdi_.GetNativeFontEncoding(*args, **kwargs)
+ """GetNativeFontEncoding(int encoding) -> NativeEncodingInfo"""
+ return _gdi_.GetNativeFontEncoding(*args, **kwargs)
def TestFontEncoding(*args, **kwargs):
- """TestFontEncoding(NativeEncodingInfo info) -> bool"""
- return _gdi_.TestFontEncoding(*args, **kwargs)
+ """TestFontEncoding(NativeEncodingInfo info) -> bool"""
+ return _gdi_.TestFontEncoding(*args, **kwargs)
#---------------------------------------------------------------------------
class FontMapper(object):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxFontMapper instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ FontMapper class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self) -> FontMapper"""
- newobj = _gdi_.new_FontMapper(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_FontMapper):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.FontMapper_swiginit(self,_gdi_.new_FontMapper(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_FontMapper
+ __del__ = lambda self : None;
def Get(*args, **kwargs):
- """FontMapper.Get() -> FontMapper"""
+ """Get() -> FontMapper"""
return _gdi_.FontMapper_Get(*args, **kwargs)
Get = staticmethod(Get)
def Set(*args, **kwargs):
- """FontMapper.Set(FontMapper mapper) -> FontMapper"""
+ """Set(FontMapper mapper) -> FontMapper"""
return _gdi_.FontMapper_Set(*args, **kwargs)
Set = staticmethod(Set)
return _gdi_.FontMapper_CharsetToEncoding(*args, **kwargs)
def GetSupportedEncodingsCount(*args, **kwargs):
- """FontMapper.GetSupportedEncodingsCount() -> size_t"""
+ """GetSupportedEncodingsCount() -> size_t"""
return _gdi_.FontMapper_GetSupportedEncodingsCount(*args, **kwargs)
GetSupportedEncodingsCount = staticmethod(GetSupportedEncodingsCount)
def GetEncoding(*args, **kwargs):
- """FontMapper.GetEncoding(size_t n) -> int"""
+ """GetEncoding(size_t n) -> int"""
return _gdi_.FontMapper_GetEncoding(*args, **kwargs)
GetEncoding = staticmethod(GetEncoding)
def GetEncodingName(*args, **kwargs):
- """FontMapper.GetEncodingName(int encoding) -> String"""
+ """GetEncodingName(int encoding) -> String"""
return _gdi_.FontMapper_GetEncodingName(*args, **kwargs)
GetEncodingName = staticmethod(GetEncodingName)
def GetEncodingDescription(*args, **kwargs):
- """FontMapper.GetEncodingDescription(int encoding) -> String"""
+ """GetEncodingDescription(int encoding) -> String"""
return _gdi_.FontMapper_GetEncodingDescription(*args, **kwargs)
GetEncodingDescription = staticmethod(GetEncodingDescription)
def GetEncodingFromName(*args, **kwargs):
- """FontMapper.GetEncodingFromName(String name) -> int"""
+ """GetEncodingFromName(String name) -> int"""
return _gdi_.FontMapper_GetEncodingFromName(*args, **kwargs)
GetEncodingFromName = staticmethod(GetEncodingFromName)
- def SetConfig(*args, **kwargs):
- """SetConfig(self, ConfigBase config)"""
- return _gdi_.FontMapper_SetConfig(*args, **kwargs)
-
def SetConfigPath(*args, **kwargs):
"""SetConfigPath(self, String prefix)"""
return _gdi_.FontMapper_SetConfigPath(*args, **kwargs)
def GetDefaultConfigPath(*args, **kwargs):
- """FontMapper.GetDefaultConfigPath() -> String"""
+ """GetDefaultConfigPath() -> String"""
return _gdi_.FontMapper_GetDefaultConfigPath(*args, **kwargs)
GetDefaultConfigPath = staticmethod(GetDefaultConfigPath)
"""SetDialogTitle(self, String title)"""
return _gdi_.FontMapper_SetDialogTitle(*args, **kwargs)
+FontMapper_swigregister = _gdi_.FontMapper_swigregister
+FontMapper_swigregister(FontMapper)
-class FontMapperPtr(FontMapper):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = FontMapper
-_gdi_.FontMapper_swigregister(FontMapperPtr)
-
-def FontMapper_Get(*args, **kwargs):
- """FontMapper_Get() -> FontMapper"""
- return _gdi_.FontMapper_Get(*args, **kwargs)
+def FontMapper_Get(*args):
+ """FontMapper_Get() -> FontMapper"""
+ return _gdi_.FontMapper_Get(*args)
def FontMapper_Set(*args, **kwargs):
- """FontMapper_Set(FontMapper mapper) -> FontMapper"""
- return _gdi_.FontMapper_Set(*args, **kwargs)
+ """FontMapper_Set(FontMapper mapper) -> FontMapper"""
+ return _gdi_.FontMapper_Set(*args, **kwargs)
-def FontMapper_GetSupportedEncodingsCount(*args, **kwargs):
- """FontMapper_GetSupportedEncodingsCount() -> size_t"""
- return _gdi_.FontMapper_GetSupportedEncodingsCount(*args, **kwargs)
+def FontMapper_GetSupportedEncodingsCount(*args):
+ """FontMapper_GetSupportedEncodingsCount() -> size_t"""
+ return _gdi_.FontMapper_GetSupportedEncodingsCount(*args)
def FontMapper_GetEncoding(*args, **kwargs):
- """FontMapper_GetEncoding(size_t n) -> int"""
- return _gdi_.FontMapper_GetEncoding(*args, **kwargs)
+ """FontMapper_GetEncoding(size_t n) -> int"""
+ return _gdi_.FontMapper_GetEncoding(*args, **kwargs)
def FontMapper_GetEncodingName(*args, **kwargs):
- """FontMapper_GetEncodingName(int encoding) -> String"""
- return _gdi_.FontMapper_GetEncodingName(*args, **kwargs)
+ """FontMapper_GetEncodingName(int encoding) -> String"""
+ return _gdi_.FontMapper_GetEncodingName(*args, **kwargs)
def FontMapper_GetEncodingDescription(*args, **kwargs):
- """FontMapper_GetEncodingDescription(int encoding) -> String"""
- return _gdi_.FontMapper_GetEncodingDescription(*args, **kwargs)
+ """FontMapper_GetEncodingDescription(int encoding) -> String"""
+ return _gdi_.FontMapper_GetEncodingDescription(*args, **kwargs)
def FontMapper_GetEncodingFromName(*args, **kwargs):
- """FontMapper_GetEncodingFromName(String name) -> int"""
- return _gdi_.FontMapper_GetEncodingFromName(*args, **kwargs)
+ """FontMapper_GetEncodingFromName(String name) -> int"""
+ return _gdi_.FontMapper_GetEncodingFromName(*args, **kwargs)
-def FontMapper_GetDefaultConfigPath(*args, **kwargs):
- """FontMapper_GetDefaultConfigPath() -> String"""
- return _gdi_.FontMapper_GetDefaultConfigPath(*args, **kwargs)
+def FontMapper_GetDefaultConfigPath(*args):
+ """FontMapper_GetDefaultConfigPath() -> String"""
+ return _gdi_.FontMapper_GetDefaultConfigPath(*args)
#---------------------------------------------------------------------------
class Font(GDIObject):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxFont instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """
+ A font is an object which determines the appearance of text. Fonts are
+ used for drawing text to a device context, and setting the appearance
+ of a window's text.
+
+ You can retrieve the current system font settings with `wx.SystemSettings`.
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""
__init__(self, int pointSize, int family, int style, int weight, bool underline=False,
String face=EmptyString,
int encoding=FONTENCODING_DEFAULT) -> Font
- """
- newobj = _gdi_.new_Font(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_Font):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
+ Creates a font object with the specified attributes.
+
+ :param pointSize: The size of the font in points.
+
+ :param family: Font family. A generic way of referring to fonts
+ without specifying actual facename. It can be One of
+ the ``wx.FONTFAMILY_xxx`` constants.
+
+ :param style: One of the ``wx.FONTSTYLE_xxx`` constants.
+
+ :param weight: Font weight, sometimes also referred to as font
+ boldness. One of the ``wx.FONTWEIGHT_xxx`` constants.
+
+ :param underline: The value can be ``True`` or ``False`` and
+ indicates whether the font will include an underline. This
+ may not be supported on all platforms.
+
+ :param face: An optional string specifying the actual typeface to
+ be used. If it is an empty string, a default typeface will be
+ chosen based on the family.
+
+ :param encoding: An encoding which may be one of the
+ ``wx.FONTENCODING_xxx`` constants. If the specified encoding isn't
+ available, no font is created.
+
+ :see: `wx.FFont`, `wx.FontFromPixelSize`, `wx.FFontFromPixelSize`,
+ `wx.FontFromNativeInfoString`, `wx.FontFromNativeInfo`
+
+ """
+ if kwargs.has_key('faceName'): kwargs['face'] = kwargs['faceName'];del kwargs['faceName']
+ _gdi_.Font_swiginit(self,_gdi_.new_Font(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_Font
+ __del__ = lambda self : None;
def Ok(*args, **kwargs):
- """Ok(self) -> bool"""
+ """
+ Ok(self) -> bool
+
+ Returns ``True`` if this font was successfully created.
+ """
return _gdi_.Font_Ok(*args, **kwargs)
def __nonzero__(self): return self.Ok()
return _gdi_.Font___ne__(*args, **kwargs)
def GetPointSize(*args, **kwargs):
- """GetPointSize(self) -> int"""
+ """
+ GetPointSize(self) -> int
+
+ Gets the point size.
+ """
return _gdi_.Font_GetPointSize(*args, **kwargs)
+ def GetPixelSize(*args, **kwargs):
+ """
+ GetPixelSize(self) -> Size
+
+ Returns the size in pixels if the font was constructed with a pixel
+ size.
+ """
+ return _gdi_.Font_GetPixelSize(*args, **kwargs)
+
+ def IsUsingSizeInPixels(*args, **kwargs):
+ """
+ IsUsingSizeInPixels(self) -> bool
+
+ Returns ``True`` if the font is using a pixelSize.
+ """
+ return _gdi_.Font_IsUsingSizeInPixels(*args, **kwargs)
+
def GetFamily(*args, **kwargs):
- """GetFamily(self) -> int"""
+ """
+ GetFamily(self) -> int
+
+ Gets the font family.
+ """
return _gdi_.Font_GetFamily(*args, **kwargs)
def GetStyle(*args, **kwargs):
- """GetStyle(self) -> int"""
+ """
+ GetStyle(self) -> int
+
+ Gets the font style.
+ """
return _gdi_.Font_GetStyle(*args, **kwargs)
def GetWeight(*args, **kwargs):
- """GetWeight(self) -> int"""
+ """
+ GetWeight(self) -> int
+
+ Gets the font weight.
+ """
return _gdi_.Font_GetWeight(*args, **kwargs)
def GetUnderlined(*args, **kwargs):
- """GetUnderlined(self) -> bool"""
+ """
+ GetUnderlined(self) -> bool
+
+ Returns ``True`` if the font is underlined, ``False`` otherwise.
+ """
return _gdi_.Font_GetUnderlined(*args, **kwargs)
def GetFaceName(*args, **kwargs):
- """GetFaceName(self) -> String"""
+ """
+ GetFaceName(self) -> String
+
+ Returns the typeface name associated with the font, or the empty
+ string if there is no typeface information.
+ """
return _gdi_.Font_GetFaceName(*args, **kwargs)
def GetEncoding(*args, **kwargs):
- """GetEncoding(self) -> int"""
+ """
+ GetEncoding(self) -> int
+
+ Get the font's encoding.
+ """
return _gdi_.Font_GetEncoding(*args, **kwargs)
def GetNativeFontInfo(*args, **kwargs):
- """GetNativeFontInfo(self) -> NativeFontInfo"""
+ """
+ GetNativeFontInfo(self) -> NativeFontInfo
+
+ Constructs a `wx.NativeFontInfo` object from this font.
+ """
return _gdi_.Font_GetNativeFontInfo(*args, **kwargs)
def IsFixedWidth(*args, **kwargs):
- """IsFixedWidth(self) -> bool"""
+ """
+ IsFixedWidth(self) -> bool
+
+ Returns true if the font is a fixed width (or monospaced) font, false
+ if it is a proportional one or font is invalid.
+ """
return _gdi_.Font_IsFixedWidth(*args, **kwargs)
def GetNativeFontInfoDesc(*args, **kwargs):
- """GetNativeFontInfoDesc(self) -> String"""
+ """
+ GetNativeFontInfoDesc(self) -> String
+
+ Returns the platform-dependent string completely describing this font
+ or an empty string if the font isn't valid.
+ """
return _gdi_.Font_GetNativeFontInfoDesc(*args, **kwargs)
def GetNativeFontInfoUserDesc(*args, **kwargs):
- """GetNativeFontInfoUserDesc(self) -> String"""
+ """
+ GetNativeFontInfoUserDesc(self) -> String
+
+ Returns a human readable version of `GetNativeFontInfoDesc`.
+ """
return _gdi_.Font_GetNativeFontInfoUserDesc(*args, **kwargs)
def SetPointSize(*args, **kwargs):
- """SetPointSize(self, int pointSize)"""
+ """
+ SetPointSize(self, int pointSize)
+
+ Sets the point size.
+ """
return _gdi_.Font_SetPointSize(*args, **kwargs)
+ def SetPixelSize(*args, **kwargs):
+ """
+ SetPixelSize(self, Size pixelSize)
+
+ Sets the size in pixels rather than points. If there is platform API
+ support for this then it is used, otherwise a font with the closest
+ size is found using a binary search.
+ """
+ return _gdi_.Font_SetPixelSize(*args, **kwargs)
+
def SetFamily(*args, **kwargs):
- """SetFamily(self, int family)"""
+ """
+ SetFamily(self, int family)
+
+ Sets the font family.
+ """
return _gdi_.Font_SetFamily(*args, **kwargs)
def SetStyle(*args, **kwargs):
- """SetStyle(self, int style)"""
+ """
+ SetStyle(self, int style)
+
+ Sets the font style.
+ """
return _gdi_.Font_SetStyle(*args, **kwargs)
def SetWeight(*args, **kwargs):
- """SetWeight(self, int weight)"""
+ """
+ SetWeight(self, int weight)
+
+ Sets the font weight.
+ """
return _gdi_.Font_SetWeight(*args, **kwargs)
def SetFaceName(*args, **kwargs):
- """SetFaceName(self, String faceName)"""
+ """
+ SetFaceName(self, String faceName)
+
+ Sets the facename for the font. The facename, which should be a valid
+ font installed on the end-user's system.
+
+ To avoid portability problems, don't rely on a specific face, but
+ specify the font family instead or as well. A suitable font will be
+ found on the end-user's system. If both the family and the facename
+ are specified, wxWidgets will first search for the specific face, and
+ then for a font belonging to the same family.
+ """
return _gdi_.Font_SetFaceName(*args, **kwargs)
def SetUnderlined(*args, **kwargs):
- """SetUnderlined(self, bool underlined)"""
+ """
+ SetUnderlined(self, bool underlined)
+
+ Sets underlining.
+ """
return _gdi_.Font_SetUnderlined(*args, **kwargs)
def SetEncoding(*args, **kwargs):
- """SetEncoding(self, int encoding)"""
+ """
+ SetEncoding(self, int encoding)
+
+ Set the font encoding.
+ """
return _gdi_.Font_SetEncoding(*args, **kwargs)
def SetNativeFontInfo(*args, **kwargs):
- """SetNativeFontInfo(self, NativeFontInfo info)"""
+ """
+ SetNativeFontInfo(self, NativeFontInfo info)
+
+ Set the font's attributes from a `wx.NativeFontInfo` object.
+ """
return _gdi_.Font_SetNativeFontInfo(*args, **kwargs)
def SetNativeFontInfoFromString(*args, **kwargs):
- """SetNativeFontInfoFromString(self, String info)"""
+ """
+ SetNativeFontInfoFromString(self, String info)
+
+ Set the font's attributes from string representation of a
+ `wx.NativeFontInfo` object.
+ """
return _gdi_.Font_SetNativeFontInfoFromString(*args, **kwargs)
def SetNativeFontInfoUserDesc(*args, **kwargs):
- """SetNativeFontInfoUserDesc(self, String info)"""
+ """
+ SetNativeFontInfoUserDesc(self, String info)
+
+ Set the font's attributes from a string formerly returned from
+ `GetNativeFontInfoDesc`.
+ """
return _gdi_.Font_SetNativeFontInfoUserDesc(*args, **kwargs)
def GetFamilyString(*args, **kwargs):
- """GetFamilyString(self) -> String"""
+ """
+ GetFamilyString(self) -> String
+
+ Returns a string representation of the font family.
+ """
return _gdi_.Font_GetFamilyString(*args, **kwargs)
def GetStyleString(*args, **kwargs):
- """GetStyleString(self) -> String"""
+ """
+ GetStyleString(self) -> String
+
+ Returns a string representation of the font style.
+ """
return _gdi_.Font_GetStyleString(*args, **kwargs)
def GetWeightString(*args, **kwargs):
- """GetWeightString(self) -> String"""
+ """
+ GetWeightString(self) -> String
+
+ Return a string representation of the font weight.
+ """
return _gdi_.Font_GetWeightString(*args, **kwargs)
def SetNoAntiAliasing(*args, **kwargs):
return _gdi_.Font_GetNoAntiAliasing(*args, **kwargs)
def GetDefaultEncoding(*args, **kwargs):
- """Font.GetDefaultEncoding() -> int"""
+ """
+ GetDefaultEncoding() -> int
+
+ Returns the encoding used for all fonts created with an encoding of
+ ``wx.FONTENCODING_DEFAULT``.
+ """
return _gdi_.Font_GetDefaultEncoding(*args, **kwargs)
GetDefaultEncoding = staticmethod(GetDefaultEncoding)
def SetDefaultEncoding(*args, **kwargs):
- """Font.SetDefaultEncoding(int encoding)"""
+ """
+ SetDefaultEncoding(int encoding)
+
+ Sets the default font encoding.
+ """
return _gdi_.Font_SetDefaultEncoding(*args, **kwargs)
SetDefaultEncoding = staticmethod(SetDefaultEncoding)
-
-class FontPtr(Font):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Font
-_gdi_.Font_swigregister(FontPtr)
+Font_swigregister = _gdi_.Font_swigregister
+Font_swigregister(Font)
def FontFromNativeInfo(*args, **kwargs):
- """FontFromNativeInfo(NativeFontInfo info) -> Font"""
+ """
+ FontFromNativeInfo(NativeFontInfo info) -> Font
+
+ Construct a `wx.Font` from a `wx.NativeFontInfo` object.
+ """
+ if kwargs.has_key('faceName'): kwargs['face'] = kwargs['faceName'];del kwargs['faceName']
val = _gdi_.new_FontFromNativeInfo(*args, **kwargs)
- val.thisown = 1
return val
def FontFromNativeInfoString(*args, **kwargs):
- """FontFromNativeInfoString(String info) -> Font"""
+ """
+ FontFromNativeInfoString(String info) -> Font
+
+ Construct a `wx.Font` from the string representation of a
+ `wx.NativeFontInfo` object.
+ """
+ if kwargs.has_key('faceName'): kwargs['face'] = kwargs['faceName'];del kwargs['faceName']
val = _gdi_.new_FontFromNativeInfoString(*args, **kwargs)
- val.thisown = 1
return val
-def Font2(*args, **kwargs):
+def FFont(*args, **kwargs):
"""
- Font2(int pointSize, int family, int flags=FONTFLAG_DEFAULT,
+ FFont(int pointSize, int family, int flags=FONTFLAG_DEFAULT,
String face=EmptyString, int encoding=FONTENCODING_DEFAULT) -> Font
+
+ A bit of a simpler way to create a `wx.Font` using flags instead of
+ individual attribute settings. The value of flags can be a
+ combination of the following:
+
+ ============================ ==
+ wx.FONTFLAG_DEFAULT
+ wx.FONTFLAG_ITALIC
+ wx.FONTFLAG_SLANT
+ wx.FONTFLAG_LIGHT
+ wx.FONTFLAG_BOLD
+ wx.FONTFLAG_ANTIALIASED
+ wx.FONTFLAG_NOT_ANTIALIASED
+ wx.FONTFLAG_UNDERLINED
+ wx.FONTFLAG_STRIKETHROUGH
+ ============================ ==
+
+ :see: `wx.Font.__init__`
+ """
+ if kwargs.has_key('faceName'): kwargs['face'] = kwargs['faceName'];del kwargs['faceName']
+ val = _gdi_.new_FFont(*args, **kwargs)
+ return val
+
+def FontFromPixelSize(*args, **kwargs):
+ """
+ FontFromPixelSize(Size pixelSize, int family, int style, int weight,
+ bool underlined=False, String face=wxEmptyString,
+ int encoding=FONTENCODING_DEFAULT) -> Font
+
+ Creates a font using a size in pixels rather than points. If there is
+ platform API support for this then it is used, otherwise a font with
+ the closest size is found using a binary search.
+
+ :see: `wx.Font.__init__`
+ """
+ if kwargs.has_key('faceName'): kwargs['face'] = kwargs['faceName'];del kwargs['faceName']
+ val = _gdi_.new_FontFromPixelSize(*args, **kwargs)
+ return val
+
+def FFontFromPixelSize(*args, **kwargs):
"""
- val = _gdi_.new_Font2(*args, **kwargs)
- val.thisown = 1
+ FFontFromPixelSize(Size pixelSize, int family, int flags=FONTFLAG_DEFAULT,
+ String face=wxEmptyString, int encoding=FONTENCODING_DEFAULT) -> Font
+
+ Creates a font using a size in pixels rather than points. If there is
+ platform API support for this then it is used, otherwise a font with
+ the closest size is found using a binary search.
+
+ :see: `wx.Font.__init__`, `wx.FFont`
+ """
+ if kwargs.has_key('faceName'): kwargs['face'] = kwargs['faceName'];del kwargs['faceName']
+ val = _gdi_.new_FFontFromPixelSize(*args, **kwargs)
return val
-def Font_GetDefaultEncoding(*args, **kwargs):
- """Font_GetDefaultEncoding() -> int"""
- return _gdi_.Font_GetDefaultEncoding(*args, **kwargs)
+def Font_GetDefaultEncoding(*args):
+ """
+ Font_GetDefaultEncoding() -> int
+
+ Returns the encoding used for all fonts created with an encoding of
+ ``wx.FONTENCODING_DEFAULT``.
+ """
+ return _gdi_.Font_GetDefaultEncoding(*args)
def Font_SetDefaultEncoding(*args, **kwargs):
- """Font_SetDefaultEncoding(int encoding)"""
- return _gdi_.Font_SetDefaultEncoding(*args, **kwargs)
+ """
+ Font_SetDefaultEncoding(int encoding)
+
+ Sets the default font encoding.
+ """
+ return _gdi_.Font_SetDefaultEncoding(*args, **kwargs)
+Font2 = wx._deprecated(FFont, "Use `wx.FFont` instead.")
#---------------------------------------------------------------------------
class FontEnumerator(object):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPyFontEnumerator instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ FontEnumerator class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self) -> FontEnumerator"""
- newobj = _gdi_.new_FontEnumerator(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _gdi_.FontEnumerator_swiginit(self,_gdi_.new_FontEnumerator(*args, **kwargs))
self._setCallbackInfo(self, FontEnumerator, 0)
- def __del__(self, destroy=_gdi_.delete_FontEnumerator):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ __swig_destroy__ = _gdi_.delete_FontEnumerator
+ __del__ = lambda self : None;
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(self, PyObject self, PyObject _class, bool incref)"""
return _gdi_.FontEnumerator__setCallbackInfo(*args, **kwargs)
"""GetFacenames(self) -> PyObject"""
return _gdi_.FontEnumerator_GetFacenames(*args, **kwargs)
-
-class FontEnumeratorPtr(FontEnumerator):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = FontEnumerator
-_gdi_.FontEnumerator_swigregister(FontEnumeratorPtr)
+FontEnumerator_swigregister = _gdi_.FontEnumerator_swigregister
+FontEnumerator_swigregister(FontEnumerator)
#---------------------------------------------------------------------------
LANGUAGE_ZULU = _gdi_.LANGUAGE_ZULU
LANGUAGE_USER_DEFINED = _gdi_.LANGUAGE_USER_DEFINED
class LanguageInfo(object):
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxLanguageInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ """Proxy of C++ LanguageInfo class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ def __init__(self): raise AttributeError, "No constructor defined"
+ __repr__ = _swig_repr
Language = property(_gdi_.LanguageInfo_Language_get, _gdi_.LanguageInfo_Language_set)
CanonicalName = property(_gdi_.LanguageInfo_CanonicalName_get, _gdi_.LanguageInfo_CanonicalName_set)
Description = property(_gdi_.LanguageInfo_Description_get, _gdi_.LanguageInfo_Description_set)
-
-class LanguageInfoPtr(LanguageInfo):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = LanguageInfo
-_gdi_.LanguageInfo_swigregister(LanguageInfoPtr)
+LanguageInfo_swigregister = _gdi_.LanguageInfo_swigregister
+LanguageInfo_swigregister(LanguageInfo)
LOCALE_CAT_NUMBER = _gdi_.LOCALE_CAT_NUMBER
LOCALE_CAT_DATE = _gdi_.LOCALE_CAT_DATE
LOCALE_LOAD_DEFAULT = _gdi_.LOCALE_LOAD_DEFAULT
LOCALE_CONV_ENCODING = _gdi_.LOCALE_CONV_ENCODING
class Locale(object):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxLocale instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, int language=LANGUAGE_DEFAULT, int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING) -> Locale"""
- newobj = _gdi_.new_Locale(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_Locale):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ """Proxy of C++ Locale class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """__init__(self, int language=-1, int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING) -> Locale"""
+ _gdi_.Locale_swiginit(self,_gdi_.new_Locale(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_Locale
+ __del__ = lambda self : None;
def Init1(*args, **kwargs):
"""
Init1(self, String szName, String szShort=EmptyString, String szLocale=EmptyString,
return val
def GetSystemLanguage(*args, **kwargs):
- """Locale.GetSystemLanguage() -> int"""
+ """GetSystemLanguage() -> int"""
return _gdi_.Locale_GetSystemLanguage(*args, **kwargs)
GetSystemLanguage = staticmethod(GetSystemLanguage)
def GetSystemEncoding(*args, **kwargs):
- """Locale.GetSystemEncoding() -> int"""
+ """GetSystemEncoding() -> int"""
return _gdi_.Locale_GetSystemEncoding(*args, **kwargs)
GetSystemEncoding = staticmethod(GetSystemEncoding)
def GetSystemEncodingName(*args, **kwargs):
- """Locale.GetSystemEncodingName() -> String"""
+ """GetSystemEncodingName() -> String"""
return _gdi_.Locale_GetSystemEncodingName(*args, **kwargs)
GetSystemEncodingName = staticmethod(GetSystemEncodingName)
return _gdi_.Locale_GetCanonicalName(*args, **kwargs)
def AddCatalogLookupPathPrefix(*args, **kwargs):
- """Locale.AddCatalogLookupPathPrefix(String prefix)"""
+ """AddCatalogLookupPathPrefix(String prefix)"""
return _gdi_.Locale_AddCatalogLookupPathPrefix(*args, **kwargs)
AddCatalogLookupPathPrefix = staticmethod(AddCatalogLookupPathPrefix)
return _gdi_.Locale_IsLoaded(*args, **kwargs)
def GetLanguageInfo(*args, **kwargs):
- """Locale.GetLanguageInfo(int lang) -> LanguageInfo"""
+ """GetLanguageInfo(int lang) -> LanguageInfo"""
return _gdi_.Locale_GetLanguageInfo(*args, **kwargs)
GetLanguageInfo = staticmethod(GetLanguageInfo)
def GetLanguageName(*args, **kwargs):
- """Locale.GetLanguageName(int lang) -> String"""
+ """GetLanguageName(int lang) -> String"""
return _gdi_.Locale_GetLanguageName(*args, **kwargs)
GetLanguageName = staticmethod(GetLanguageName)
def FindLanguageInfo(*args, **kwargs):
- """Locale.FindLanguageInfo(String locale) -> LanguageInfo"""
+ """FindLanguageInfo(String locale) -> LanguageInfo"""
return _gdi_.Locale_FindLanguageInfo(*args, **kwargs)
FindLanguageInfo = staticmethod(FindLanguageInfo)
def AddLanguage(*args, **kwargs):
- """Locale.AddLanguage(LanguageInfo info)"""
+ """AddLanguage(LanguageInfo info)"""
return _gdi_.Locale_AddLanguage(*args, **kwargs)
AddLanguage = staticmethod(AddLanguage)
"""GetName(self) -> String"""
return _gdi_.Locale_GetName(*args, **kwargs)
+Locale_swigregister = _gdi_.Locale_swigregister
+Locale_swigregister(Locale)
-class LocalePtr(Locale):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Locale
-_gdi_.Locale_swigregister(LocalePtr)
-
-def Locale_GetSystemLanguage(*args, **kwargs):
- """Locale_GetSystemLanguage() -> int"""
- return _gdi_.Locale_GetSystemLanguage(*args, **kwargs)
+def Locale_GetSystemLanguage(*args):
+ """Locale_GetSystemLanguage() -> int"""
+ return _gdi_.Locale_GetSystemLanguage(*args)
-def Locale_GetSystemEncoding(*args, **kwargs):
- """Locale_GetSystemEncoding() -> int"""
- return _gdi_.Locale_GetSystemEncoding(*args, **kwargs)
+def Locale_GetSystemEncoding(*args):
+ """Locale_GetSystemEncoding() -> int"""
+ return _gdi_.Locale_GetSystemEncoding(*args)
-def Locale_GetSystemEncodingName(*args, **kwargs):
- """Locale_GetSystemEncodingName() -> String"""
- return _gdi_.Locale_GetSystemEncodingName(*args, **kwargs)
+def Locale_GetSystemEncodingName(*args):
+ """Locale_GetSystemEncodingName() -> String"""
+ return _gdi_.Locale_GetSystemEncodingName(*args)
def Locale_AddCatalogLookupPathPrefix(*args, **kwargs):
- """Locale_AddCatalogLookupPathPrefix(String prefix)"""
- return _gdi_.Locale_AddCatalogLookupPathPrefix(*args, **kwargs)
+ """Locale_AddCatalogLookupPathPrefix(String prefix)"""
+ return _gdi_.Locale_AddCatalogLookupPathPrefix(*args, **kwargs)
def Locale_GetLanguageInfo(*args, **kwargs):
- """Locale_GetLanguageInfo(int lang) -> LanguageInfo"""
- return _gdi_.Locale_GetLanguageInfo(*args, **kwargs)
+ """Locale_GetLanguageInfo(int lang) -> LanguageInfo"""
+ return _gdi_.Locale_GetLanguageInfo(*args, **kwargs)
def Locale_GetLanguageName(*args, **kwargs):
- """Locale_GetLanguageName(int lang) -> String"""
- return _gdi_.Locale_GetLanguageName(*args, **kwargs)
+ """Locale_GetLanguageName(int lang) -> String"""
+ return _gdi_.Locale_GetLanguageName(*args, **kwargs)
def Locale_FindLanguageInfo(*args, **kwargs):
- """Locale_FindLanguageInfo(String locale) -> LanguageInfo"""
- return _gdi_.Locale_FindLanguageInfo(*args, **kwargs)
+ """Locale_FindLanguageInfo(String locale) -> LanguageInfo"""
+ return _gdi_.Locale_FindLanguageInfo(*args, **kwargs)
def Locale_AddLanguage(*args, **kwargs):
- """Locale_AddLanguage(LanguageInfo info)"""
- return _gdi_.Locale_AddLanguage(*args, **kwargs)
+ """Locale_AddLanguage(LanguageInfo info)"""
+ return _gdi_.Locale_AddLanguage(*args, **kwargs)
-def GetLocale(*args, **kwargs):
- """GetLocale() -> Locale"""
- return _gdi_.GetLocale(*args, **kwargs)
+def GetLocale(*args):
+ """GetLocale() -> Locale"""
+ return _gdi_.GetLocale(*args)
#---------------------------------------------------------------------------
CONVERT_STRICT = _gdi_.CONVERT_STRICT
PLATFORM_OS2 = _gdi_.PLATFORM_OS2
PLATFORM_MAC = _gdi_.PLATFORM_MAC
class EncodingConverter(_core.Object):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxEncodingConverter instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ EncodingConverter class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self) -> EncodingConverter"""
- newobj = _gdi_.new_EncodingConverter(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_EncodingConverter):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.EncodingConverter_swiginit(self,_gdi_.new_EncodingConverter(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_EncodingConverter
+ __del__ = lambda self : None;
def Init(*args, **kwargs):
"""Init(self, int input_enc, int output_enc, int method=CONVERT_STRICT) -> bool"""
return _gdi_.EncodingConverter_Init(*args, **kwargs)
return _gdi_.EncodingConverter_Convert(*args, **kwargs)
def GetPlatformEquivalents(*args, **kwargs):
- """EncodingConverter.GetPlatformEquivalents(int enc, int platform=PLATFORM_CURRENT) -> wxFontEncodingArray"""
+ """GetPlatformEquivalents(int enc, int platform=PLATFORM_CURRENT) -> wxFontEncodingArray"""
return _gdi_.EncodingConverter_GetPlatformEquivalents(*args, **kwargs)
GetPlatformEquivalents = staticmethod(GetPlatformEquivalents)
def GetAllEquivalents(*args, **kwargs):
- """EncodingConverter.GetAllEquivalents(int enc) -> wxFontEncodingArray"""
+ """GetAllEquivalents(int enc) -> wxFontEncodingArray"""
return _gdi_.EncodingConverter_GetAllEquivalents(*args, **kwargs)
GetAllEquivalents = staticmethod(GetAllEquivalents)
def CanConvert(*args, **kwargs):
- """EncodingConverter.CanConvert(int encIn, int encOut) -> bool"""
+ """CanConvert(int encIn, int encOut) -> bool"""
return _gdi_.EncodingConverter_CanConvert(*args, **kwargs)
CanConvert = staticmethod(CanConvert)
def __nonzero__(self): return self.IsOk()
-
-class EncodingConverterPtr(EncodingConverter):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = EncodingConverter
-_gdi_.EncodingConverter_swigregister(EncodingConverterPtr)
+EncodingConverter_swigregister = _gdi_.EncodingConverter_swigregister
+EncodingConverter_swigregister(EncodingConverter)
def GetTranslation(*args):
- """
+ """
GetTranslation(String str) -> String
GetTranslation(String str, String strPlural, size_t n) -> String
"""
- return _gdi_.GetTranslation(*args)
+ return _gdi_.GetTranslation(*args)
def EncodingConverter_GetPlatformEquivalents(*args, **kwargs):
- """EncodingConverter_GetPlatformEquivalents(int enc, int platform=PLATFORM_CURRENT) -> wxFontEncodingArray"""
- return _gdi_.EncodingConverter_GetPlatformEquivalents(*args, **kwargs)
+ """EncodingConverter_GetPlatformEquivalents(int enc, int platform=PLATFORM_CURRENT) -> wxFontEncodingArray"""
+ return _gdi_.EncodingConverter_GetPlatformEquivalents(*args, **kwargs)
def EncodingConverter_GetAllEquivalents(*args, **kwargs):
- """EncodingConverter_GetAllEquivalents(int enc) -> wxFontEncodingArray"""
- return _gdi_.EncodingConverter_GetAllEquivalents(*args, **kwargs)
+ """EncodingConverter_GetAllEquivalents(int enc) -> wxFontEncodingArray"""
+ return _gdi_.EncodingConverter_GetAllEquivalents(*args, **kwargs)
def EncodingConverter_CanConvert(*args, **kwargs):
- """EncodingConverter_CanConvert(int encIn, int encOut) -> bool"""
- return _gdi_.EncodingConverter_CanConvert(*args, **kwargs)
+ """EncodingConverter_CanConvert(int encIn, int encOut) -> bool"""
+ return _gdi_.EncodingConverter_CanConvert(*args, **kwargs)
#----------------------------------------------------------------------------
-# wxGTK sets the locale when initialized. Doing this at the Python
-# level should set it up to match what GTK is doing at the C level.
-if wx.Platform == "__WXGTK__":
- try:
- import locale
- locale.setlocale(locale.LC_ALL, "")
- except:
- pass
-
-# On MSW add the directory where the wxWindows catalogs were installed
+# On MSW add the directory where the wxWidgets catalogs were installed
# to the default catalog path.
if wx.Platform == "__WXMSW__":
import os
- localedir = os.path.join(os.path.split(__file__)[0], "locale")
- Locale_AddCatalogLookupPathPrefix(localedir)
+ _localedir = os.path.join(os.path.split(__file__)[0], "locale")
+ Locale.AddCatalogLookupPathPrefix(_localedir)
del os
#----------------------------------------------------------------------------
#---------------------------------------------------------------------------
class DC(_core.Object):
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __del__(self, destroy=_gdi_.delete_DC):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
- def BeginDrawing(*args, **kwargs):
- """BeginDrawing(self)"""
- return _gdi_.DC_BeginDrawing(*args, **kwargs)
-
- def EndDrawing(*args, **kwargs):
- """EndDrawing(self)"""
- return _gdi_.DC_EndDrawing(*args, **kwargs)
-
- def FloodFillXY(*args, **kwargs):
- """FloodFillXY(self, int x, int y, Colour col, int style=FLOOD_SURFACE) -> bool"""
- return _gdi_.DC_FloodFillXY(*args, **kwargs)
+ """
+ A wx.DC is a device context onto which graphics and text can be
+ drawn. It is intended to represent a number of output devices in a
+ generic way, so a window can have a device context associated with it,
+ and a printer also has a device context. In this way, the same piece
+ of code may write to a number of different devices, if the device
+ context is used as a parameter.
+
+ Derived types of wxDC have documentation for specific features only,
+ so refer to this section for most device context information.
+
+ The wx.DC class is abstract and can not be instantiated, you must use
+ one of the derived classes instead. Which one will depend on the
+ situation in which it is used.
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ def __init__(self): raise AttributeError, "No constructor defined"
+ __repr__ = _swig_repr
+ __swig_destroy__ = _gdi_.delete_DC
+ __del__ = lambda self : None;
+ # These have been deprecated in wxWidgets. Since they never
+ # really did anything to begin with, just make them be NOPs.
+ def BeginDrawing(self): pass
+ def EndDrawing(self): pass
def FloodFill(*args, **kwargs):
- """FloodFill(self, Point pt, Colour col, int style=FLOOD_SURFACE) -> bool"""
+ """
+ FloodFill(self, int x, int y, Colour col, int style=FLOOD_SURFACE) -> bool
+
+ Flood fills the device context starting from the given point, using
+ the current brush colour, and using a style:
+
+ - **wxFLOOD_SURFACE**: the flooding occurs until a colour other than
+ the given colour is encountered.
+
+ - **wxFLOOD_BORDER**: the area to be flooded is bounded by the given
+ colour.
+
+ Returns False if the operation failed.
+
+ Note: The present implementation for non-Windows platforms may fail to
+ find colour borders if the pixels do not match the colour
+ exactly. However the function will still return true.
+ """
return _gdi_.DC_FloodFill(*args, **kwargs)
- def GetPixelXY(*args, **kwargs):
- """GetPixelXY(self, int x, int y) -> Colour"""
- return _gdi_.DC_GetPixelXY(*args, **kwargs)
+ def FloodFillPoint(*args, **kwargs):
+ """
+ FloodFillPoint(self, Point pt, Colour col, int style=FLOOD_SURFACE) -> bool
+
+ Flood fills the device context starting from the given point, using
+ the current brush colour, and using a style:
+
+ - **wxFLOOD_SURFACE**: the flooding occurs until a colour other than
+ the given colour is encountered.
+
+ - **wxFLOOD_BORDER**: the area to be flooded is bounded by the given
+ colour.
+
+ Returns False if the operation failed.
+
+ Note: The present implementation for non-Windows platforms may fail to
+ find colour borders if the pixels do not match the colour
+ exactly. However the function will still return true.
+ """
+ return _gdi_.DC_FloodFillPoint(*args, **kwargs)
+
+ def GradientFillConcentric(*args, **kwargs):
+ """
+ GradientFillConcentric(self, Rect rect, Colour initialColour, Colour destColour,
+ Point circleCenter)
+
+ Fill the area specified by rect with a radial gradient, starting from
+ initialColour in the center of the circle and fading to destColour on
+ the outside of the circle. The circleCenter argument is the relative
+ coordinants of the center of the circle in the specified rect.
+
+ Note: Currently this function is very slow, don't use it for real-time
+ drawing.
+ """
+ return _gdi_.DC_GradientFillConcentric(*args, **kwargs)
+
+ def GradientFillLinear(*args, **kwargs):
+ """
+ GradientFillLinear(self, Rect rect, Colour initialColour, Colour destColour,
+ int nDirection=EAST)
+
+ Fill the area specified by rect with a linear gradient, starting from
+ initialColour and eventually fading to destColour. The nDirection
+ parameter specifies the direction of the colour change, default is to
+ use initialColour on the left part of the rectangle and destColour on
+ the right side.
+ """
+ return _gdi_.DC_GradientFillLinear(*args, **kwargs)
def GetPixel(*args, **kwargs):
- """GetPixel(self, Point pt) -> Colour"""
+ """
+ GetPixel(self, int x, int y) -> Colour
+
+ Gets the colour at the specified location on the DC.
+ """
return _gdi_.DC_GetPixel(*args, **kwargs)
- def DrawLineXY(*args, **kwargs):
- """DrawLineXY(self, int x1, int y1, int x2, int y2)"""
- return _gdi_.DC_DrawLineXY(*args, **kwargs)
+ def GetPixelPoint(*args, **kwargs):
+ """GetPixelPoint(self, Point pt) -> Colour"""
+ return _gdi_.DC_GetPixelPoint(*args, **kwargs)
def DrawLine(*args, **kwargs):
- """DrawLine(self, Point pt1, Point pt2)"""
+ """
+ DrawLine(self, int x1, int y1, int x2, int y2)
+
+ Draws a line from the first point to the second. The current pen is
+ used for drawing the line. Note that the second point is *not* part of
+ the line and is not drawn by this function (this is consistent with
+ the behaviour of many other toolkits).
+ """
return _gdi_.DC_DrawLine(*args, **kwargs)
- def CrossHairXY(*args, **kwargs):
- """CrossHairXY(self, int x, int y)"""
- return _gdi_.DC_CrossHairXY(*args, **kwargs)
+ def DrawLinePoint(*args, **kwargs):
+ """
+ DrawLinePoint(self, Point pt1, Point pt2)
+
+ Draws a line from the first point to the second. The current pen is
+ used for drawing the line. Note that the second point is *not* part of
+ the line and is not drawn by this function (this is consistent with
+ the behaviour of many other toolkits).
+ """
+ return _gdi_.DC_DrawLinePoint(*args, **kwargs)
def CrossHair(*args, **kwargs):
- """CrossHair(self, Point pt)"""
+ """
+ CrossHair(self, int x, int y)
+
+ Displays a cross hair using the current pen. This is a vertical and
+ horizontal line the height and width of the window, centred on the
+ given point.
+ """
return _gdi_.DC_CrossHair(*args, **kwargs)
- def DrawArcXY(*args, **kwargs):
- """DrawArcXY(self, int x1, int y1, int x2, int y2, int xc, int yc)"""
- return _gdi_.DC_DrawArcXY(*args, **kwargs)
+ def CrossHairPoint(*args, **kwargs):
+ """
+ CrossHairPoint(self, Point pt)
+
+ Displays a cross hair using the current pen. This is a vertical and
+ horizontal line the height and width of the window, centred on the
+ given point.
+ """
+ return _gdi_.DC_CrossHairPoint(*args, **kwargs)
def DrawArc(*args, **kwargs):
- """DrawArc(self, Point pt1, Point pt2, Point centre)"""
+ """
+ DrawArc(self, int x1, int y1, int x2, int y2, int xc, int yc)
+
+ Draws an arc of a circle, centred on the *center* point (xc, yc), from
+ the first point to the second. The current pen is used for the outline
+ and the current brush for filling the shape.
+
+ The arc is drawn in an anticlockwise direction from the start point to
+ the end point.
+ """
return _gdi_.DC_DrawArc(*args, **kwargs)
- def DrawCheckMarkXY(*args, **kwargs):
- """DrawCheckMarkXY(self, int x, int y, int width, int height)"""
- return _gdi_.DC_DrawCheckMarkXY(*args, **kwargs)
+ def DrawArcPoint(*args, **kwargs):
+ """
+ DrawArcPoint(self, Point pt1, Point pt2, Point center)
+
+ Draws an arc of a circle, centred on the *center* point (xc, yc), from
+ the first point to the second. The current pen is used for the outline
+ and the current brush for filling the shape.
+
+ The arc is drawn in an anticlockwise direction from the start point to
+ the end point.
+ """
+ return _gdi_.DC_DrawArcPoint(*args, **kwargs)
def DrawCheckMark(*args, **kwargs):
- """DrawCheckMark(self, Rect rect)"""
+ """
+ DrawCheckMark(self, int x, int y, int width, int height)
+
+ Draws a check mark inside the given rectangle.
+ """
return _gdi_.DC_DrawCheckMark(*args, **kwargs)
- def DrawEllipticArcXY(*args, **kwargs):
- """DrawEllipticArcXY(self, int x, int y, int w, int h, double sa, double ea)"""
- return _gdi_.DC_DrawEllipticArcXY(*args, **kwargs)
+ def DrawCheckMarkRect(*args, **kwargs):
+ """
+ DrawCheckMarkRect(self, Rect rect)
+
+ Draws a check mark inside the given rectangle.
+ """
+ return _gdi_.DC_DrawCheckMarkRect(*args, **kwargs)
def DrawEllipticArc(*args, **kwargs):
- """DrawEllipticArc(self, Point pt, Size sz, double sa, double ea)"""
+ """
+ DrawEllipticArc(self, int x, int y, int w, int h, double start, double end)
+
+ Draws an arc of an ellipse, with the given rectangle defining the
+ bounds of the ellipse. The current pen is used for drawing the arc and
+ the current brush is used for drawing the pie.
+
+ The *start* and *end* parameters specify the start and end of the arc
+ relative to the three-o'clock position from the center of the
+ rectangle. Angles are specified in degrees (360 is a complete
+ circle). Positive values mean counter-clockwise motion. If start is
+ equal to end, a complete ellipse will be drawn.
+ """
return _gdi_.DC_DrawEllipticArc(*args, **kwargs)
- def DrawPointXY(*args, **kwargs):
- """DrawPointXY(self, int x, int y)"""
- return _gdi_.DC_DrawPointXY(*args, **kwargs)
+ def DrawEllipticArcPointSize(*args, **kwargs):
+ """
+ DrawEllipticArcPointSize(self, Point pt, Size sz, double start, double end)
+
+ Draws an arc of an ellipse, with the given rectangle defining the
+ bounds of the ellipse. The current pen is used for drawing the arc and
+ the current brush is used for drawing the pie.
+
+ The *start* and *end* parameters specify the start and end of the arc
+ relative to the three-o'clock position from the center of the
+ rectangle. Angles are specified in degrees (360 is a complete
+ circle). Positive values mean counter-clockwise motion. If start is
+ equal to end, a complete ellipse will be drawn.
+ """
+ return _gdi_.DC_DrawEllipticArcPointSize(*args, **kwargs)
def DrawPoint(*args, **kwargs):
- """DrawPoint(self, Point pt)"""
+ """
+ DrawPoint(self, int x, int y)
+
+ Draws a point using the current pen.
+ """
return _gdi_.DC_DrawPoint(*args, **kwargs)
- def DrawRectangleXY(*args, **kwargs):
- """DrawRectangleXY(self, int x, int y, int width, int height)"""
- return _gdi_.DC_DrawRectangleXY(*args, **kwargs)
+ def DrawPointPoint(*args, **kwargs):
+ """
+ DrawPointPoint(self, Point pt)
+
+ Draws a point using the current pen.
+ """
+ return _gdi_.DC_DrawPointPoint(*args, **kwargs)
def DrawRectangle(*args, **kwargs):
- """DrawRectangle(self, Point pt, Size sz)"""
+ """
+ DrawRectangle(self, int x, int y, int width, int height)
+
+ Draws a rectangle with the given top left corner, and with the given
+ size. The current pen is used for the outline and the current brush
+ for filling the shape.
+ """
return _gdi_.DC_DrawRectangle(*args, **kwargs)
def DrawRectangleRect(*args, **kwargs):
- """DrawRectangleRect(self, Rect rect)"""
+ """
+ DrawRectangleRect(self, Rect rect)
+
+ Draws a rectangle with the given top left corner, and with the given
+ size. The current pen is used for the outline and the current brush
+ for filling the shape.
+ """
return _gdi_.DC_DrawRectangleRect(*args, **kwargs)
- def DrawRoundedRectangleXY(*args, **kwargs):
- """DrawRoundedRectangleXY(self, int x, int y, int width, int height, double radius)"""
- return _gdi_.DC_DrawRoundedRectangleXY(*args, **kwargs)
+ def DrawRectanglePointSize(*args, **kwargs):
+ """
+ DrawRectanglePointSize(self, Point pt, Size sz)
+
+ Draws a rectangle with the given top left corner, and with the given
+ size. The current pen is used for the outline and the current brush
+ for filling the shape.
+ """
+ return _gdi_.DC_DrawRectanglePointSize(*args, **kwargs)
def DrawRoundedRectangle(*args, **kwargs):
- """DrawRoundedRectangle(self, Point pt, Size sz, double radius)"""
+ """
+ DrawRoundedRectangle(self, int x, int y, int width, int height, double radius)
+
+ Draws a rectangle with the given top left corner, and with the given
+ size. The corners are quarter-circles using the given radius. The
+ current pen is used for the outline and the current brush for filling
+ the shape.
+
+ If radius is positive, the value is assumed to be the radius of the
+ rounded corner. If radius is negative, the absolute value is assumed
+ to be the proportion of the smallest dimension of the rectangle. This
+ means that the corner can be a sensible size relative to the size of
+ the rectangle, and also avoids the strange effects X produces when the
+ corners are too big for the rectangle.
+ """
return _gdi_.DC_DrawRoundedRectangle(*args, **kwargs)
def DrawRoundedRectangleRect(*args, **kwargs):
- """DrawRoundedRectangleRect(self, Rect r, double radius)"""
+ """
+ DrawRoundedRectangleRect(self, Rect r, double radius)
+
+ Draws a rectangle with the given top left corner, and with the given
+ size. The corners are quarter-circles using the given radius. The
+ current pen is used for the outline and the current brush for filling
+ the shape.
+
+ If radius is positive, the value is assumed to be the radius of the
+ rounded corner. If radius is negative, the absolute value is assumed
+ to be the proportion of the smallest dimension of the rectangle. This
+ means that the corner can be a sensible size relative to the size of
+ the rectangle, and also avoids the strange effects X produces when the
+ corners are too big for the rectangle.
+ """
return _gdi_.DC_DrawRoundedRectangleRect(*args, **kwargs)
- def DrawCircleXY(*args, **kwargs):
- """DrawCircleXY(self, int x, int y, int radius)"""
- return _gdi_.DC_DrawCircleXY(*args, **kwargs)
+ def DrawRoundedRectanglePointSize(*args, **kwargs):
+ """
+ DrawRoundedRectanglePointSize(self, Point pt, Size sz, double radius)
+
+ Draws a rectangle with the given top left corner, and with the given
+ size. The corners are quarter-circles using the given radius. The
+ current pen is used for the outline and the current brush for filling
+ the shape.
+
+ If radius is positive, the value is assumed to be the radius of the
+ rounded corner. If radius is negative, the absolute value is assumed
+ to be the proportion of the smallest dimension of the rectangle. This
+ means that the corner can be a sensible size relative to the size of
+ the rectangle, and also avoids the strange effects X produces when the
+ corners are too big for the rectangle.
+ """
+ return _gdi_.DC_DrawRoundedRectanglePointSize(*args, **kwargs)
def DrawCircle(*args, **kwargs):
- """DrawCircle(self, Point pt, int radius)"""
+ """
+ DrawCircle(self, int x, int y, int radius)
+
+ Draws a circle with the given center point and radius. The current
+ pen is used for the outline and the current brush for filling the
+ shape.
+ """
return _gdi_.DC_DrawCircle(*args, **kwargs)
- def DrawEllipseXY(*args, **kwargs):
- """DrawEllipseXY(self, int x, int y, int width, int height)"""
- return _gdi_.DC_DrawEllipseXY(*args, **kwargs)
+ def DrawCirclePoint(*args, **kwargs):
+ """
+ DrawCirclePoint(self, Point pt, int radius)
+
+ Draws a circle with the given center point and radius. The current
+ pen is used for the outline and the current brush for filling the
+ shape.
+ """
+ return _gdi_.DC_DrawCirclePoint(*args, **kwargs)
def DrawEllipse(*args, **kwargs):
- """DrawEllipse(self, Point pt, Size sz)"""
+ """
+ DrawEllipse(self, int x, int y, int width, int height)
+
+ Draws an ellipse contained in the specified rectangle. The current pen
+ is used for the outline and the current brush for filling the shape.
+ """
return _gdi_.DC_DrawEllipse(*args, **kwargs)
def DrawEllipseRect(*args, **kwargs):
- """DrawEllipseRect(self, Rect rect)"""
+ """
+ DrawEllipseRect(self, Rect rect)
+
+ Draws an ellipse contained in the specified rectangle. The current pen
+ is used for the outline and the current brush for filling the shape.
+ """
return _gdi_.DC_DrawEllipseRect(*args, **kwargs)
- def DrawIconXY(*args, **kwargs):
- """DrawIconXY(self, Icon icon, int x, int y)"""
- return _gdi_.DC_DrawIconXY(*args, **kwargs)
+ def DrawEllipsePointSize(*args, **kwargs):
+ """
+ DrawEllipsePointSize(self, Point pt, Size sz)
+
+ Draws an ellipse contained in the specified rectangle. The current pen
+ is used for the outline and the current brush for filling the shape.
+ """
+ return _gdi_.DC_DrawEllipsePointSize(*args, **kwargs)
def DrawIcon(*args, **kwargs):
- """DrawIcon(self, Icon icon, Point pt)"""
+ """
+ DrawIcon(self, Icon icon, int x, int y)
+
+ Draw an icon on the display (does nothing if the device context is
+ PostScript). This can be the simplest way of drawing bitmaps on a
+ window.
+ """
return _gdi_.DC_DrawIcon(*args, **kwargs)
- def DrawBitmapXY(*args, **kwargs):
- """DrawBitmapXY(self, Bitmap bmp, int x, int y, bool useMask=False)"""
- return _gdi_.DC_DrawBitmapXY(*args, **kwargs)
+ def DrawIconPoint(*args, **kwargs):
+ """
+ DrawIconPoint(self, Icon icon, Point pt)
+
+ Draw an icon on the display (does nothing if the device context is
+ PostScript). This can be the simplest way of drawing bitmaps on a
+ window.
+ """
+ return _gdi_.DC_DrawIconPoint(*args, **kwargs)
def DrawBitmap(*args, **kwargs):
- """DrawBitmap(self, Bitmap bmp, Point pt, bool useMask=False)"""
+ """
+ DrawBitmap(self, Bitmap bmp, int x, int y, bool useMask=False)
+
+ Draw a bitmap on the device context at the specified point. If
+ *transparent* is true and the bitmap has a transparency mask, (or
+ alpha channel on the platforms that support it) then the bitmap will
+ be drawn transparently.
+ """
return _gdi_.DC_DrawBitmap(*args, **kwargs)
- def DrawTextXY(*args, **kwargs):
- """DrawTextXY(self, String text, int x, int y)"""
- return _gdi_.DC_DrawTextXY(*args, **kwargs)
+ def DrawBitmapPoint(*args, **kwargs):
+ """
+ DrawBitmapPoint(self, Bitmap bmp, Point pt, bool useMask=False)
+
+ Draw a bitmap on the device context at the specified point. If
+ *transparent* is true and the bitmap has a transparency mask, (or
+ alpha channel on the platforms that support it) then the bitmap will
+ be drawn transparently.
+ """
+ return _gdi_.DC_DrawBitmapPoint(*args, **kwargs)
def DrawText(*args, **kwargs):
- """DrawText(self, String text, Point pt)"""
+ """
+ DrawText(self, String text, int x, int y)
+
+ Draws a text string at the specified point, using the current text
+ font, and the current text foreground and background colours.
+
+ The coordinates refer to the top-left corner of the rectangle bounding
+ the string. See `GetTextExtent` for how to get the dimensions of a
+ text string, which can be used to position the text more precisely.
+
+ **NOTE**: under wxGTK the current logical function is used by this
+ function but it is ignored by wxMSW. Thus, you should avoid using
+ logical functions with this function in portable programs.
+ """
return _gdi_.DC_DrawText(*args, **kwargs)
- def DrawRotatedTextXY(*args, **kwargs):
- """DrawRotatedTextXY(self, String text, int x, int y, double angle)"""
- return _gdi_.DC_DrawRotatedTextXY(*args, **kwargs)
+ def DrawTextPoint(*args, **kwargs):
+ """
+ DrawTextPoint(self, String text, Point pt)
+
+ Draws a text string at the specified point, using the current text
+ font, and the current text foreground and background colours.
+
+ The coordinates refer to the top-left corner of the rectangle bounding
+ the string. See `GetTextExtent` for how to get the dimensions of a
+ text string, which can be used to position the text more precisely.
+
+ **NOTE**: under wxGTK the current logical function is used by this
+ function but it is ignored by wxMSW. Thus, you should avoid using
+ logical functions with this function in portable programs.
+ """
+ return _gdi_.DC_DrawTextPoint(*args, **kwargs)
def DrawRotatedText(*args, **kwargs):
- """DrawRotatedText(self, String text, Point pt, double angle)"""
+ """
+ DrawRotatedText(self, String text, int x, int y, double angle)
+
+ Draws the text rotated by *angle* degrees, if supported by the platform.
+
+ **NOTE**: Under Win9x only TrueType fonts can be drawn by this
+ function. In particular, a font different from ``wx.NORMAL_FONT``
+ should be used as the it is not normally a TrueType
+ font. ``wx.SWISS_FONT`` is an example of a font which is.
+ """
return _gdi_.DC_DrawRotatedText(*args, **kwargs)
- def BlitXY(*args, **kwargs):
+ def DrawRotatedTextPoint(*args, **kwargs):
+ """
+ DrawRotatedTextPoint(self, String text, Point pt, double angle)
+
+ Draws the text rotated by *angle* degrees, if supported by the platform.
+
+ **NOTE**: Under Win9x only TrueType fonts can be drawn by this
+ function. In particular, a font different from ``wx.NORMAL_FONT``
+ should be used as the it is not normally a TrueType
+ font. ``wx.SWISS_FONT`` is an example of a font which is.
+ """
+ return _gdi_.DC_DrawRotatedTextPoint(*args, **kwargs)
+
+ def Blit(*args, **kwargs):
"""
- BlitXY(self, int xdest, int ydest, int width, int height, DC source,
+ Blit(self, int xdest, int ydest, int width, int height, DC source,
int xsrc, int ysrc, int rop=COPY, bool useMask=False,
int xsrcMask=-1, int ysrcMask=-1) -> bool
+
+ Copy from a source DC to this DC. Parameters specify the destination
+ coordinates, size of area to copy, source DC, source coordinates,
+ logical function, whether to use a bitmap mask, and mask source
+ position.
"""
- return _gdi_.DC_BlitXY(*args, **kwargs)
+ return _gdi_.DC_Blit(*args, **kwargs)
- def Blit(*args, **kwargs):
+ def BlitPointSize(*args, **kwargs):
"""
- Blit(self, Point destPt, Size sz, DC source, Point srcPt, int rop=COPY,
+ BlitPointSize(self, Point destPt, Size sz, DC source, Point srcPt, int rop=COPY,
bool useMask=False, Point srcPtMask=DefaultPosition) -> bool
+
+ Copy from a source DC to this DC. Parameters specify the destination
+ coordinates, size of area to copy, source DC, source coordinates,
+ logical function, whether to use a bitmap mask, and mask source
+ position.
"""
- return _gdi_.DC_Blit(*args, **kwargs)
+ return _gdi_.DC_BlitPointSize(*args, **kwargs)
+
+ def SetClippingRegion(*args, **kwargs):
+ """
+ SetClippingRegion(self, int x, int y, int width, int height)
+
+ Sets the clipping region for this device context to the intersection
+ of the given region described by the parameters of this method and the
+ previously set clipping region. You should call `DestroyClippingRegion`
+ if you want to set the clipping region exactly to the region
+ specified.
+
+ The clipping region is an area to which drawing is
+ restricted. Possible uses for the clipping region are for clipping
+ text or for speeding up window redraws when only a known area of the
+ screen is damaged.
+ """
+ return _gdi_.DC_SetClippingRegion(*args, **kwargs)
+
+ def SetClippingRegionPointSize(*args, **kwargs):
+ """
+ SetClippingRegionPointSize(self, Point pt, Size sz)
+
+ Sets the clipping region for this device context to the intersection
+ of the given region described by the parameters of this method and the
+ previously set clipping region. You should call `DestroyClippingRegion`
+ if you want to set the clipping region exactly to the region
+ specified.
+
+ The clipping region is an area to which drawing is
+ restricted. Possible uses for the clipping region are for clipping
+ text or for speeding up window redraws when only a known area of the
+ screen is damaged.
+ """
+ return _gdi_.DC_SetClippingRegionPointSize(*args, **kwargs)
+
+ def SetClippingRegionAsRegion(*args, **kwargs):
+ """
+ SetClippingRegionAsRegion(self, Region region)
+
+ Sets the clipping region for this device context to the intersection
+ of the given region described by the parameters of this method and the
+ previously set clipping region. You should call `DestroyClippingRegion`
+ if you want to set the clipping region exactly to the region
+ specified.
+
+ The clipping region is an area to which drawing is
+ restricted. Possible uses for the clipping region are for clipping
+ text or for speeding up window redraws when only a known area of the
+ screen is damaged.
+ """
+ return _gdi_.DC_SetClippingRegionAsRegion(*args, **kwargs)
+
+ def SetClippingRect(*args, **kwargs):
+ """
+ SetClippingRect(self, Rect rect)
+
+ Sets the clipping region for this device context to the intersection
+ of the given region described by the parameters of this method and the
+ previously set clipping region. You should call `DestroyClippingRegion`
+ if you want to set the clipping region exactly to the region
+ specified.
+
+ The clipping region is an area to which drawing is
+ restricted. Possible uses for the clipping region are for clipping
+ text or for speeding up window redraws when only a known area of the
+ screen is damaged.
+ """
+ return _gdi_.DC_SetClippingRect(*args, **kwargs)
def DrawLines(*args, **kwargs):
- """DrawLines(self, int points, Point points_array, int xoffset=0, int yoffset=0)"""
+ """
+ DrawLines(self, List points, int xoffset=0, int yoffset=0)
+
+ Draws lines using a sequence of `wx.Point` objects, adding the
+ optional offset coordinate. The current pen is used for drawing the
+ lines.
+ """
return _gdi_.DC_DrawLines(*args, **kwargs)
def DrawPolygon(*args, **kwargs):
"""
- DrawPolygon(self, int points, Point points_array, int xoffset=0, int yoffset=0,
+ DrawPolygon(self, List points, int xoffset=0, int yoffset=0,
int fillStyle=ODDEVEN_RULE)
+
+ Draws a filled polygon using a sequence of `wx.Point` objects, adding
+ the optional offset coordinate. The last argument specifies the fill
+ rule: ``wx.ODDEVEN_RULE`` (the default) or ``wx.WINDING_RULE``.
+
+ The current pen is used for drawing the outline, and the current brush
+ for filling the shape. Using a transparent brush suppresses
+ filling. Note that wxWidgets automatically closes the first and last
+ points.
"""
return _gdi_.DC_DrawPolygon(*args, **kwargs)
"""
DrawLabel(self, String text, Rect rect, int alignment=wxALIGN_LEFT|wxALIGN_TOP,
int indexAccel=-1)
+
+ Draw *text* within the specified rectangle, abiding by the alignment
+ flags. Will additionally emphasize the character at *indexAccel* if
+ it is not -1.
"""
return _gdi_.DC_DrawLabel(*args, **kwargs)
"""
DrawImageLabel(self, String text, Bitmap image, Rect rect, int alignment=wxALIGN_LEFT|wxALIGN_TOP,
int indexAccel=-1) -> Rect
+
+ Draw *text* and an image (which may be ``wx.NullBitmap`` to skip
+ drawing it) within the specified rectangle, abiding by the alignment
+ flags. Will additionally emphasize the character at *indexAccel* if
+ it is not -1. Returns the bounding rectangle.
"""
return _gdi_.DC_DrawImageLabel(*args, **kwargs)
def DrawSpline(*args, **kwargs):
- """DrawSpline(self, int points, Point points_array)"""
+ """
+ DrawSpline(self, List points)
+
+ Draws a spline between all given control points, (a list of `wx.Point`
+ objects) using the current pen. The spline is drawn using a series of
+ lines, using an algorithm taken from the X drawing program 'XFIG'.
+ """
return _gdi_.DC_DrawSpline(*args, **kwargs)
def Clear(*args, **kwargs):
- """Clear(self)"""
+ """
+ Clear(self)
+
+ Clears the device context using the current background brush.
+ """
return _gdi_.DC_Clear(*args, **kwargs)
def StartDoc(*args, **kwargs):
- """StartDoc(self, String message) -> bool"""
+ """
+ StartDoc(self, String message) -> bool
+
+ Starts a document (only relevant when outputting to a
+ printer). *Message* is a message to show whilst printing.
+ """
return _gdi_.DC_StartDoc(*args, **kwargs)
def EndDoc(*args, **kwargs):
- """EndDoc(self)"""
+ """
+ EndDoc(self)
+
+ Ends a document (only relevant when outputting to a printer).
+ """
return _gdi_.DC_EndDoc(*args, **kwargs)
def StartPage(*args, **kwargs):
- """StartPage(self)"""
+ """
+ StartPage(self)
+
+ Starts a document page (only relevant when outputting to a printer).
+ """
return _gdi_.DC_StartPage(*args, **kwargs)
def EndPage(*args, **kwargs):
- """EndPage(self)"""
+ """
+ EndPage(self)
+
+ Ends a document page (only relevant when outputting to a printer).
+ """
return _gdi_.DC_EndPage(*args, **kwargs)
def SetFont(*args, **kwargs):
- """SetFont(self, Font font)"""
+ """
+ SetFont(self, Font font)
+
+ Sets the current font for the DC. It must be a valid font, in
+ particular you should not pass ``wx.NullFont`` to this method.
+ """
return _gdi_.DC_SetFont(*args, **kwargs)
def SetPen(*args, **kwargs):
- """SetPen(self, Pen pen)"""
+ """
+ SetPen(self, Pen pen)
+
+ Sets the current pen for the DC.
+
+ If the argument is ``wx.NullPen``, the current pen is selected out of the
+ device context, and the original pen restored.
+ """
return _gdi_.DC_SetPen(*args, **kwargs)
def SetBrush(*args, **kwargs):
- """SetBrush(self, Brush brush)"""
+ """
+ SetBrush(self, Brush brush)
+
+ Sets the current brush for the DC.
+
+ If the argument is ``wx.NullBrush``, the current brush is selected out
+ of the device context, and the original brush restored, allowing the
+ current brush to be destroyed safely.
+ """
return _gdi_.DC_SetBrush(*args, **kwargs)
def SetBackground(*args, **kwargs):
- """SetBackground(self, Brush brush)"""
+ """
+ SetBackground(self, Brush brush)
+
+ Sets the current background brush for the DC.
+ """
return _gdi_.DC_SetBackground(*args, **kwargs)
def SetBackgroundMode(*args, **kwargs):
- """SetBackgroundMode(self, int mode)"""
+ """
+ SetBackgroundMode(self, int mode)
+
+ *mode* may be one of ``wx.SOLID`` and ``wx.TRANSPARENT``. This setting
+ determines whether text will be drawn with a background colour or
+ not.
+ """
return _gdi_.DC_SetBackgroundMode(*args, **kwargs)
def SetPalette(*args, **kwargs):
- """SetPalette(self, Palette palette)"""
- return _gdi_.DC_SetPalette(*args, **kwargs)
-
- def SetClippingRegionXY(*args, **kwargs):
- """SetClippingRegionXY(self, int x, int y, int width, int height)"""
- return _gdi_.DC_SetClippingRegionXY(*args, **kwargs)
-
- def SetClippingRegion(*args, **kwargs):
- """SetClippingRegion(self, Point pt, Size sz)"""
- return _gdi_.DC_SetClippingRegion(*args, **kwargs)
-
- def SetClippingRect(*args, **kwargs):
- """SetClippingRect(self, Rect rect)"""
- return _gdi_.DC_SetClippingRect(*args, **kwargs)
+ """
+ SetPalette(self, Palette palette)
- def SetClippingRegionAsRegion(*args, **kwargs):
- """SetClippingRegionAsRegion(self, Region region)"""
- return _gdi_.DC_SetClippingRegionAsRegion(*args, **kwargs)
+ If this is a window DC or memory DC, assigns the given palette to the
+ window or bitmap associated with the DC. If the argument is
+ ``wx.NullPalette``, the current palette is selected out of the device
+ context, and the original palette restored.
+ """
+ return _gdi_.DC_SetPalette(*args, **kwargs)
def DestroyClippingRegion(*args, **kwargs):
- """DestroyClippingRegion(self)"""
+ """
+ DestroyClippingRegion(self)
+
+ Destroys the current clipping region so that none of the DC is
+ clipped.
+ """
return _gdi_.DC_DestroyClippingRegion(*args, **kwargs)
def GetClippingBox(*args, **kwargs):
- """GetClippingBox() -> (x, y, width, height)"""
+ """
+ GetClippingBox() -> (x, y, width, height)
+
+ Gets the rectangle surrounding the current clipping region.
+ """
return _gdi_.DC_GetClippingBox(*args, **kwargs)
def GetClippingRect(*args, **kwargs):
- """GetClippingRect(self) -> Rect"""
+ """
+ GetClippingRect(self) -> Rect
+
+ Gets the rectangle surrounding the current clipping region.
+ """
return _gdi_.DC_GetClippingRect(*args, **kwargs)
def GetCharHeight(*args, **kwargs):
- """GetCharHeight(self) -> int"""
+ """
+ GetCharHeight(self) -> int
+
+ Gets the character height of the currently set font.
+ """
return _gdi_.DC_GetCharHeight(*args, **kwargs)
def GetCharWidth(*args, **kwargs):
- """GetCharWidth(self) -> int"""
+ """
+ GetCharWidth(self) -> int
+
+ Gets the average character width of the currently set font.
+ """
return _gdi_.DC_GetCharWidth(*args, **kwargs)
def GetTextExtent(*args, **kwargs):
"""
GetTextExtent(wxString string) -> (width, height)
- Get the width and height of the text using the current font.
- Only works for single line strings.
+ Get the width and height of the text using the current font. Only
+ works for single line strings.
"""
return _gdi_.DC_GetTextExtent(*args, **kwargs)
GetFullTextExtent(wxString string, Font font=None) ->
(width, height, descent, externalLeading)
- Get the width, height, decent and leading of the text using the current or specified font.
- Only works for single line strings.
+ Get the width, height, decent and leading of the text using the
+ current or specified font. Only works for single line strings.
"""
return _gdi_.DC_GetFullTextExtent(*args, **kwargs)
GetMultiLineTextExtent(wxString string, Font font=None) ->
(width, height, descent, externalLeading)
- Get the width, height, decent and leading of the text using the current or specified font.
- Works for single as well as multi-line strings.
+ Get the width, height, decent and leading of the text using the
+ current or specified font. Works for single as well as multi-line
+ strings.
"""
return _gdi_.DC_GetMultiLineTextExtent(*args, **kwargs)
def GetPartialTextExtents(*args, **kwargs):
- """GetPartialTextExtents(self, String text) -> wxArrayInt"""
+ """
+ GetPartialTextExtents(self, text) -> [widths]
+
+ Returns a list of integers such that each value is the distance in
+ pixels from the begining of text to the coresponding character of
+ *text*. The generic version simply builds a running total of the widths
+ of each character using GetTextExtent, however if the various
+ platforms have a native API function that is faster or more accurate
+ than the generic implementation then it will be used instead.
+ """
return _gdi_.DC_GetPartialTextExtents(*args, **kwargs)
def GetSize(*args, **kwargs):
"""
GetSize(self) -> Size
- Get the DC size in device units.
+ This gets the horizontal and vertical resolution in device units. It
+ can be used to scale graphics to fit the page. For example, if *maxX*
+ and *maxY* represent the maximum horizontal and vertical 'pixel' values
+ used in your application, the following code will scale the graphic to
+ fit on the printer page::
+
+ w, h = dc.GetSize()
+ scaleX = maxX*1.0 / w
+ scaleY = maxY*1.0 / h
+ dc.SetUserScale(min(scaleX,scaleY),min(scaleX,scaleY))
+
"""
return _gdi_.DC_GetSize(*args, **kwargs)
"""
GetSizeTuple() -> (width, height)
- Get the DC size in device units.
+ This gets the horizontal and vertical resolution in device units. It
+ can be used to scale graphics to fit the page. For example, if *maxX*
+ and *maxY* represent the maximum horizontal and vertical 'pixel' values
+ used in your application, the following code will scale the graphic to
+ fit on the printer page::
+
+ w, h = dc.GetSize()
+ scaleX = maxX*1.0 / w
+ scaleY = maxY*1.0 / h
+ dc.SetUserScale(min(scaleX,scaleY),min(scaleX,scaleY))
+
"""
return _gdi_.DC_GetSizeTuple(*args, **kwargs)
return _gdi_.DC_GetSizeMMTuple(*args, **kwargs)
def DeviceToLogicalX(*args, **kwargs):
- """DeviceToLogicalX(self, int x) -> int"""
+ """
+ DeviceToLogicalX(self, int x) -> int
+
+ Convert device X coordinate to logical coordinate, using the current
+ mapping mode.
+ """
return _gdi_.DC_DeviceToLogicalX(*args, **kwargs)
def DeviceToLogicalY(*args, **kwargs):
- """DeviceToLogicalY(self, int y) -> int"""
+ """
+ DeviceToLogicalY(self, int y) -> int
+
+ Converts device Y coordinate to logical coordinate, using the current
+ mapping mode.
+ """
return _gdi_.DC_DeviceToLogicalY(*args, **kwargs)
def DeviceToLogicalXRel(*args, **kwargs):
- """DeviceToLogicalXRel(self, int x) -> int"""
+ """
+ DeviceToLogicalXRel(self, int x) -> int
+
+ Convert device X coordinate to relative logical coordinate, using the
+ current mapping mode but ignoring the x axis orientation. Use this
+ function for converting a width, for example.
+ """
return _gdi_.DC_DeviceToLogicalXRel(*args, **kwargs)
def DeviceToLogicalYRel(*args, **kwargs):
- """DeviceToLogicalYRel(self, int y) -> int"""
+ """
+ DeviceToLogicalYRel(self, int y) -> int
+
+ Convert device Y coordinate to relative logical coordinate, using the
+ current mapping mode but ignoring the y axis orientation. Use this
+ function for converting a height, for example.
+ """
return _gdi_.DC_DeviceToLogicalYRel(*args, **kwargs)
def LogicalToDeviceX(*args, **kwargs):
- """LogicalToDeviceX(self, int x) -> int"""
+ """
+ LogicalToDeviceX(self, int x) -> int
+
+ Converts logical X coordinate to device coordinate, using the current
+ mapping mode.
+ """
return _gdi_.DC_LogicalToDeviceX(*args, **kwargs)
def LogicalToDeviceY(*args, **kwargs):
- """LogicalToDeviceY(self, int y) -> int"""
+ """
+ LogicalToDeviceY(self, int y) -> int
+
+ Converts logical Y coordinate to device coordinate, using the current
+ mapping mode.
+ """
return _gdi_.DC_LogicalToDeviceY(*args, **kwargs)
def LogicalToDeviceXRel(*args, **kwargs):
- """LogicalToDeviceXRel(self, int x) -> int"""
+ """
+ LogicalToDeviceXRel(self, int x) -> int
+
+ Converts logical X coordinate to relative device coordinate, using the
+ current mapping mode but ignoring the x axis orientation. Use this for
+ converting a width, for example.
+ """
return _gdi_.DC_LogicalToDeviceXRel(*args, **kwargs)
def LogicalToDeviceYRel(*args, **kwargs):
- """LogicalToDeviceYRel(self, int y) -> int"""
+ """
+ LogicalToDeviceYRel(self, int y) -> int
+
+ Converts logical Y coordinate to relative device coordinate, using the
+ current mapping mode but ignoring the y axis orientation. Use this for
+ converting a height, for example.
+ """
return _gdi_.DC_LogicalToDeviceYRel(*args, **kwargs)
def CanDrawBitmap(*args, **kwargs):
return _gdi_.DC_CanGetTextExtent(*args, **kwargs)
def GetDepth(*args, **kwargs):
- """GetDepth(self) -> int"""
+ """
+ GetDepth(self) -> int
+
+ Returns the colour depth of the DC.
+ """
return _gdi_.DC_GetDepth(*args, **kwargs)
def GetPPI(*args, **kwargs):
- """GetPPI(self) -> Size"""
+ """
+ GetPPI(self) -> Size
+
+ Resolution in Pixels per inch
+ """
return _gdi_.DC_GetPPI(*args, **kwargs)
def Ok(*args, **kwargs):
- """Ok(self) -> bool"""
+ """
+ Ok(self) -> bool
+
+ Returns true if the DC is ok to use.
+ """
return _gdi_.DC_Ok(*args, **kwargs)
def GetBackgroundMode(*args, **kwargs):
- """GetBackgroundMode(self) -> int"""
+ """
+ GetBackgroundMode(self) -> int
+
+ Returns the current background mode, either ``wx.SOLID`` or
+ ``wx.TRANSPARENT``.
+ """
return _gdi_.DC_GetBackgroundMode(*args, **kwargs)
def GetBackground(*args, **kwargs):
- """GetBackground(self) -> Brush"""
+ """
+ GetBackground(self) -> Brush
+
+ Gets the brush used for painting the background.
+ """
return _gdi_.DC_GetBackground(*args, **kwargs)
def GetBrush(*args, **kwargs):
- """GetBrush(self) -> Brush"""
+ """
+ GetBrush(self) -> Brush
+
+ Gets the current brush
+ """
return _gdi_.DC_GetBrush(*args, **kwargs)
def GetFont(*args, **kwargs):
- """GetFont(self) -> Font"""
+ """
+ GetFont(self) -> Font
+
+ Gets the current font
+ """
return _gdi_.DC_GetFont(*args, **kwargs)
def GetPen(*args, **kwargs):
- """GetPen(self) -> Pen"""
+ """
+ GetPen(self) -> Pen
+
+ Gets the current pen
+ """
return _gdi_.DC_GetPen(*args, **kwargs)
def GetTextBackground(*args, **kwargs):
- """GetTextBackground(self) -> Colour"""
+ """
+ GetTextBackground(self) -> Colour
+
+ Gets the current text background colour
+ """
return _gdi_.DC_GetTextBackground(*args, **kwargs)
def GetTextForeground(*args, **kwargs):
- """GetTextForeground(self) -> Colour"""
+ """
+ GetTextForeground(self) -> Colour
+
+ Gets the current text foreground colour
+ """
return _gdi_.DC_GetTextForeground(*args, **kwargs)
def SetTextForeground(*args, **kwargs):
- """SetTextForeground(self, Colour colour)"""
+ """
+ SetTextForeground(self, Colour colour)
+
+ Sets the current text foreground colour for the DC.
+ """
return _gdi_.DC_SetTextForeground(*args, **kwargs)
def SetTextBackground(*args, **kwargs):
- """SetTextBackground(self, Colour colour)"""
+ """
+ SetTextBackground(self, Colour colour)
+
+ Sets the current text background colour for the DC.
+ """
return _gdi_.DC_SetTextBackground(*args, **kwargs)
def GetMapMode(*args, **kwargs):
- """GetMapMode(self) -> int"""
+ """
+ GetMapMode(self) -> int
+
+ Gets the current *mapping mode* for the device context
+ """
return _gdi_.DC_GetMapMode(*args, **kwargs)
def SetMapMode(*args, **kwargs):
- """SetMapMode(self, int mode)"""
+ """
+ SetMapMode(self, int mode)
+
+ The *mapping mode* of the device context defines the unit of
+ measurement used to convert logical units to device units. The
+ mapping mode can be one of the following:
+
+ ================ =============================================
+ wx.MM_TWIPS Each logical unit is 1/20 of a point, or 1/1440
+ of an inch.
+ wx.MM_POINTS Each logical unit is a point, or 1/72 of an inch.
+ wx.MM_METRIC Each logical unit is 1 mm.
+ wx.MM_LOMETRIC Each logical unit is 1/10 of a mm.
+ wx.MM_TEXT Each logical unit is 1 pixel.
+ ================ =============================================
+
+ """
return _gdi_.DC_SetMapMode(*args, **kwargs)
def GetUserScale(*args, **kwargs):
- """GetUserScale() -> (xScale, yScale)"""
+ """
+ GetUserScale(self) -> (xScale, yScale)
+
+ Gets the current user scale factor (set by `SetUserScale`).
+ """
return _gdi_.DC_GetUserScale(*args, **kwargs)
def SetUserScale(*args, **kwargs):
- """SetUserScale(self, double x, double y)"""
+ """
+ SetUserScale(self, double x, double y)
+
+ Sets the user scaling factor, useful for applications which require
+ 'zooming'.
+ """
return _gdi_.DC_SetUserScale(*args, **kwargs)
def GetLogicalScale(*args, **kwargs):
"""SetLogicalOrigin(self, int x, int y)"""
return _gdi_.DC_SetLogicalOrigin(*args, **kwargs)
+ def SetLogicalOriginPoint(*args, **kwargs):
+ """SetLogicalOriginPoint(self, Point point)"""
+ return _gdi_.DC_SetLogicalOriginPoint(*args, **kwargs)
+
def GetDeviceOrigin(*args, **kwargs):
"""GetDeviceOrigin(self) -> Point"""
return _gdi_.DC_GetDeviceOrigin(*args, **kwargs)
"""SetDeviceOrigin(self, int x, int y)"""
return _gdi_.DC_SetDeviceOrigin(*args, **kwargs)
+ def SetDeviceOriginPoint(*args, **kwargs):
+ """SetDeviceOriginPoint(self, Point point)"""
+ return _gdi_.DC_SetDeviceOriginPoint(*args, **kwargs)
+
def SetAxisOrientation(*args, **kwargs):
- """SetAxisOrientation(self, bool xLeftRight, bool yBottomUp)"""
+ """
+ SetAxisOrientation(self, bool xLeftRight, bool yBottomUp)
+
+ Sets the x and y axis orientation (i.e., the direction from lowest to
+ highest values on the axis). The default orientation is the natural
+ orientation, e.g. x axis from left to right and y axis from bottom up.
+ """
return _gdi_.DC_SetAxisOrientation(*args, **kwargs)
def GetLogicalFunction(*args, **kwargs):
- """GetLogicalFunction(self) -> int"""
+ """
+ GetLogicalFunction(self) -> int
+
+ Gets the current logical function (set by `SetLogicalFunction`).
+ """
return _gdi_.DC_GetLogicalFunction(*args, **kwargs)
def SetLogicalFunction(*args, **kwargs):
- """SetLogicalFunction(self, int function)"""
+ """
+ SetLogicalFunction(self, int function)
+
+ Sets the current logical function for the device context. This
+ determines how a source pixel (from a pen or brush colour, or source
+ device context if using `Blit`) combines with a destination pixel in
+ the current device context.
+
+ The possible values and their meaning in terms of source and
+ destination pixel values are as follows:
+
+ ================ ==========================
+ wx.AND src AND dst
+ wx.AND_INVERT (NOT src) AND dst
+ wx.AND_REVERSE src AND (NOT dst)
+ wx.CLEAR 0
+ wx.COPY src
+ wx.EQUIV (NOT src) XOR dst
+ wx.INVERT NOT dst
+ wx.NAND (NOT src) OR (NOT dst)
+ wx.NOR (NOT src) AND (NOT dst)
+ wx.NO_OP dst
+ wx.OR src OR dst
+ wx.OR_INVERT (NOT src) OR dst
+ wx.OR_REVERSE src OR (NOT dst)
+ wx.SET 1
+ wx.SRC_INVERT NOT src
+ wx.XOR src XOR dst
+ ================ ==========================
+
+ The default is wx.COPY, which simply draws with the current
+ colour. The others combine the current colour and the background using
+ a logical operation. wx.INVERT is commonly used for drawing rubber
+ bands or moving outlines, since drawing twice reverts to the original
+ colour.
+
+ """
return _gdi_.DC_SetLogicalFunction(*args, **kwargs)
- def SetOptimization(*args, **kwargs):
- """SetOptimization(self, bool opt)"""
- return _gdi_.DC_SetOptimization(*args, **kwargs)
+ def ComputeScaleAndOrigin(*args, **kwargs):
+ """
+ ComputeScaleAndOrigin(self)
+
+ Performs all necessary computations for given platform and context
+ type after each change of scale and origin parameters. Usually called
+ automatically internally after such changes.
+
+ """
+ return _gdi_.DC_ComputeScaleAndOrigin(*args, **kwargs)
+
+ def SetOptimization(self, optimize):
+ pass
+ def GetOptimization(self):
+ return False
- def GetOptimization(*args, **kwargs):
- """GetOptimization(self) -> bool"""
- return _gdi_.DC_GetOptimization(*args, **kwargs)
+ SetOptimization = wx._deprecated(SetOptimization)
+ GetOptimization = wx._deprecated(GetOptimization)
def CalcBoundingBox(*args, **kwargs):
- """CalcBoundingBox(self, int x, int y)"""
+ """
+ CalcBoundingBox(self, int x, int y)
+
+ Adds the specified point to the bounding box which can be retrieved
+ with `MinX`, `MaxX` and `MinY`, `MaxY` or `GetBoundingBox` functions.
+ """
return _gdi_.DC_CalcBoundingBox(*args, **kwargs)
+ def CalcBoundingBoxPoint(*args, **kwargs):
+ """
+ CalcBoundingBoxPoint(self, Point point)
+
+ Adds the specified point to the bounding box which can be retrieved
+ with `MinX`, `MaxX` and `MinY`, `MaxY` or `GetBoundingBox` functions.
+ """
+ return _gdi_.DC_CalcBoundingBoxPoint(*args, **kwargs)
+
def ResetBoundingBox(*args, **kwargs):
- """ResetBoundingBox(self)"""
+ """
+ ResetBoundingBox(self)
+
+ Resets the bounding box: after a call to this function, the bounding
+ box doesn't contain anything.
+ """
return _gdi_.DC_ResetBoundingBox(*args, **kwargs)
def MinX(*args, **kwargs):
- """MinX(self) -> int"""
+ """
+ MinX(self) -> int
+
+ Gets the minimum horizontal extent used in drawing commands so far.
+ """
return _gdi_.DC_MinX(*args, **kwargs)
def MaxX(*args, **kwargs):
- """MaxX(self) -> int"""
+ """
+ MaxX(self) -> int
+
+ Gets the maximum horizontal extent used in drawing commands so far.
+ """
return _gdi_.DC_MaxX(*args, **kwargs)
def MinY(*args, **kwargs):
- """MinY(self) -> int"""
+ """
+ MinY(self) -> int
+
+ Gets the minimum vertical extent used in drawing commands so far.
+ """
return _gdi_.DC_MinY(*args, **kwargs)
def MaxY(*args, **kwargs):
- """MaxY(self) -> int"""
+ """
+ MaxY(self) -> int
+
+ Gets the maximum vertical extent used in drawing commands so far.
+ """
return _gdi_.DC_MaxY(*args, **kwargs)
def GetBoundingBox(*args, **kwargs):
- """GetBoundingBox() -> (x1,y1, x2,y2)"""
+ """
+ GetBoundingBox() -> (x1,y1, x2,y2)
+
+ Returns the min and max points used in drawing commands so far.
+ """
return _gdi_.DC_GetBoundingBox(*args, **kwargs)
def __nonzero__(self): return self.Ok()
return _gdi_.DC__DrawTextList(*args, **kwargs)
def DrawPointList(self, points, pens=None):
+ """
+ Draw a list of points as quickly as possible.
+
+ :param points: A sequence of 2-element sequences representing
+ each point to draw, (x,y).
+ :param pens: If None, then the current pen is used. If a
+ single pen then it will be used for all points. If
+ a list of pens then there should be one for each point
+ in points.
+ """
if pens is None:
pens = []
elif isinstance(pens, wx.Pen):
def DrawLineList(self, lines, pens=None):
+ """
+ Draw a list of lines as quickly as possible.
+
+ :param lines: A sequence of 4-element sequences representing
+ each line to draw, (x1,y1, x2,y2).
+ :param pens: If None, then the current pen is used. If a
+ single pen then it will be used for all lines. If
+ a list of pens then there should be one for each line
+ in lines.
+ """
if pens is None:
pens = []
elif isinstance(pens, wx.Pen):
def DrawRectangleList(self, rectangles, pens=None, brushes=None):
+ """
+ Draw a list of rectangles as quickly as possible.
+
+ :param rectangles: A sequence of 4-element sequences representing
+ each rectangle to draw, (x,y, w,h).
+ :param pens: If None, then the current pen is used. If a
+ single pen then it will be used for all rectangles.
+ If a list of pens then there should be one for each
+ rectangle in rectangles.
+ :param brushes: A brush or brushes to be used to fill the rectagles,
+ with similar semantics as the pens parameter.
+ """
if pens is None:
pens = []
elif isinstance(pens, wx.Pen):
def DrawEllipseList(self, ellipses, pens=None, brushes=None):
+ """
+ Draw a list of ellipses as quickly as possible.
+
+ :param ellipses: A sequence of 4-element sequences representing
+ each ellipse to draw, (x,y, w,h).
+ :param pens: If None, then the current pen is used. If a
+ single pen then it will be used for all ellipses.
+ If a list of pens then there should be one for each
+ ellipse in ellipses.
+ :param brushes: A brush or brushes to be used to fill the ellipses,
+ with similar semantics as the pens parameter.
+ """
if pens is None:
pens = []
elif isinstance(pens, wx.Pen):
def DrawPolygonList(self, polygons, pens=None, brushes=None):
- ## Note: This does not currently support fill style or offset
- ## you can always use the non-List version if need be.
+ """
+ Draw a list of polygons, each of which is a list of points.
+
+ :param polygons: A sequence of sequences of sequences.
+ [[(x1,y1),(x2,y2),(x3,y3)...],
+ [(x1,y1),(x2,y2),(x3,y3)...]]
+
+ :param pens: If None, then the current pen is used. If a
+ single pen then it will be used for all polygons.
+ If a list of pens then there should be one for each
+ polygon.
+ :param brushes: A brush or brushes to be used to fill the polygons,
+ with similar semantics as the pens parameter.
+ """
if pens is None:
pens = []
elif isinstance(pens, wx.Pen):
return self._DrawPolygonList(polygons, pens, brushes)
- def DrawTextList(self, textList, coords, foregrounds = None, backgrounds = None, fonts = None):
- ## NOTE: this does not currently support changing the font
- ## Make sure you set Background mode to wxSolid (DC.SetBackgroundMode)
- ## If you want backgounds to do anything.
+ def DrawTextList(self, textList, coords, foregrounds = None, backgrounds = None):
+ """
+ Draw a list of strings using a list of coordinants for positioning each string.
+
+ :param textList: A list of strings
+ :param coords: A list of (x,y) positions
+ :param foregrounds: A list of `wx.Colour` objects to use for the
+ foregrounds of the strings.
+ :param backgrounds: A list of `wx.Colour` objects to use for the
+ backgrounds of the strings.
+
+ NOTE: Make sure you set Background mode to wx.Solid (DC.SetBackgroundMode)
+ If you want backgrounds to do anything.
+ """
if type(textList) == type(''):
textList = [textList]
elif len(textList) != len(coords):
raise ValueError('backgrounds and coords must have same length')
return self._DrawTextList(textList, coords, foregrounds, backgrounds)
-
-class DCPtr(DC):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = DC
-_gdi_.DC_swigregister(DCPtr)
+DC_swigregister = _gdi_.DC_swigregister
+DC_swigregister(DC)
#---------------------------------------------------------------------------
class MemoryDC(DC):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxMemoryDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self) -> MemoryDC"""
- newobj = _gdi_.new_MemoryDC(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ A memory device context provides a means to draw graphics onto a
+ bitmap. A bitmap must be selected into the new memory DC before it may
+ be used for anything. Typical usage is as follows::
+
+ dc = wx.MemoryDC()
+ dc.SelectObject(bitmap)
+ # draw on the dc usign any of the Draw methods
+ dc.SelectObject(wx.NullBitmap)
+ # the bitmap now contains wahtever was drawn upon it
+
+ Note that the memory DC *must* be deleted (or the bitmap selected out
+ of it) before a bitmap can be reselected into another memory DC.
+
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self) -> MemoryDC
+
+ Constructs a new memory device context.
+
+ Use the Ok member to test whether the constructor was successful in
+ creating a usable device context. Don't forget to select a bitmap into
+ the DC before drawing on it.
+ """
+ _gdi_.MemoryDC_swiginit(self,_gdi_.new_MemoryDC(*args, **kwargs))
def SelectObject(*args, **kwargs):
- """SelectObject(self, Bitmap bitmap)"""
- return _gdi_.MemoryDC_SelectObject(*args, **kwargs)
+ """
+ SelectObject(self, Bitmap bitmap)
+
+ Selects the bitmap into the device context, to use as the memory
+ bitmap. Selecting the bitmap into a memory DC allows you to draw into
+ the DC, and therefore the bitmap, and also to use Blit to copy the
+ bitmap to a window.
+ If the argument is wx.NullBitmap (or some other uninitialised
+ `wx.Bitmap`) the current bitmap is selected out of the device context,
+ and the original bitmap restored, allowing the current bitmap to be
+ destroyed safely.
+ """
+ return _gdi_.MemoryDC_SelectObject(*args, **kwargs)
-class MemoryDCPtr(MemoryDC):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = MemoryDC
-_gdi_.MemoryDC_swigregister(MemoryDCPtr)
+MemoryDC_swigregister = _gdi_.MemoryDC_swigregister
+MemoryDC_swigregister(MemoryDC)
def MemoryDCFromDC(*args, **kwargs):
- """MemoryDCFromDC(DC oldDC) -> MemoryDC"""
+ """
+ MemoryDCFromDC(DC oldDC) -> MemoryDC
+
+ Creates a DC that is compatible with the oldDC.
+ """
val = _gdi_.new_MemoryDCFromDC(*args, **kwargs)
- val.thisown = 1
return val
#---------------------------------------------------------------------------
+BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA
+BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA
class BufferedDC(MemoryDC):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxBufferedDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args):
- """
- __init__(self, DC dc, Bitmap buffer) -> BufferedDC
- __init__(self, DC dc, Size area) -> BufferedDC
+ """
+ This simple class provides a simple way to avoid flicker: when drawing
+ on it, everything is in fact first drawn on an in-memory buffer (a
+ `wx.Bitmap`) and then copied to the screen only once, when this object
+ is destroyed.
+
+ It can be used in the same way as any other device
+ context. wx.BufferedDC itself typically replaces `wx.ClientDC`, if you
+ want to use it in your EVT_PAINT handler, you should look at
+ `wx.BufferedPaintDC`.
+
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args):
"""
- newobj = _gdi_.new_BufferedDC(*args)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- self._dc = args[0] # save a ref so the other dc will not be deleted before self
+ __init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
+ __init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
- def __del__(self, destroy=_gdi_.delete_BufferedDC):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
+ Constructs a buffered DC.
+ """
+ _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
+ self.__dc = args[0] # save a ref so the other dc will not be deleted before self
+ __swig_destroy__ = _gdi_.delete_BufferedDC
+ __del__ = lambda self : None;
def UnMask(*args, **kwargs):
- """UnMask(self)"""
+ """
+ UnMask(self)
+
+ Blits the buffer to the dc, and detaches the dc from the buffer (so it
+ can be effectively used once only). This is usually only called in
+ the destructor.
+ """
return _gdi_.BufferedDC_UnMask(*args, **kwargs)
+BufferedDC_swigregister = _gdi_.BufferedDC_swigregister
+BufferedDC_swigregister(BufferedDC)
+
+class BufferedPaintDC(BufferedDC):
+ """
+ This is a subclass of `wx.BufferedDC` which can be used inside of an
+ EVT_PAINT event handler. Just create an object of this class instead
+ of `wx.PaintDC` and that's all you have to do to (mostly) avoid
+ flicker. The only thing to watch out for is that if you are using this
+ class together with `wx.ScrolledWindow`, you probably do **not** want
+ to call `wx.Window.PrepareDC` on it as it already does this internally
+ for the real underlying `wx.PaintDC`.
+
+ If your window is already fully buffered in a `wx.Bitmap` then your
+ EVT_PAINT handler can be as simple as just creating a
+ ``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
+ automatically when it is destroyed. For example::
+
+ def OnPaint(self, event):
+ dc = wx.BufferedPaintDC(self, self.buffer)
+
-class BufferedDCPtr(BufferedDC):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = BufferedDC
-_gdi_.BufferedDC_swigregister(BufferedDCPtr)
-def BufferedDCInternalBuffer(*args):
- """BufferedDCInternalBuffer(DC dc, Size area) -> BufferedDC"""
- val = _gdi_.new_BufferedDCInternalBuffer(*args)
- val.thisown = 1
- val._dc = args[0] # save a ref so the other dc will not be deleted before self
- return val
-class BufferedPaintDC(BufferedDC):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxBufferedPaintDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, Window window, Bitmap buffer=NullBitmap) -> BufferedPaintDC"""
- newobj = _gdi_.new_BufferedPaintDC(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class BufferedPaintDCPtr(BufferedPaintDC):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = BufferedPaintDC
-_gdi_.BufferedPaintDC_swigregister(BufferedPaintDCPtr)
+
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
+
+ Create a buffered paint DC. As with `wx.BufferedDC`, you may either
+ provide the bitmap to be used for buffering or let this object create
+ one internally (in the latter case, the size of the client part of the
+ window is automatically used).
+
+
+ """
+ _gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
+BufferedPaintDC_swigregister = _gdi_.BufferedPaintDC_swigregister
+BufferedPaintDC_swigregister(BufferedPaintDC)
#---------------------------------------------------------------------------
class ScreenDC(DC):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxScreenDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self) -> ScreenDC"""
- newobj = _gdi_.new_ScreenDC(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ A wxScreenDC can be used to paint anywhere on the screen. This should
+ normally be constructed as a temporary stack object; don't store a
+ wxScreenDC object.
+
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self) -> ScreenDC
+
+ A wxScreenDC can be used to paint anywhere on the screen. This should
+ normally be constructed as a temporary stack object; don't store a
+ wxScreenDC object.
+
+ """
+ _gdi_.ScreenDC_swiginit(self,_gdi_.new_ScreenDC(*args, **kwargs))
def StartDrawingOnTopWin(*args, **kwargs):
- """StartDrawingOnTopWin(self, Window window) -> bool"""
+ """
+ StartDrawingOnTopWin(self, Window window) -> bool
+
+ Specify that the area of the screen to be drawn upon coincides with
+ the given window.
+
+ :see: `EndDrawingOnTop`
+ """
return _gdi_.ScreenDC_StartDrawingOnTopWin(*args, **kwargs)
def StartDrawingOnTop(*args, **kwargs):
- """StartDrawingOnTop(self, Rect rect=None) -> bool"""
+ """
+ StartDrawingOnTop(self, Rect rect=None) -> bool
+
+ Specify that the area is the given rectangle, or the whole screen if
+ ``None`` is passed.
+
+ :see: `EndDrawingOnTop`
+ """
return _gdi_.ScreenDC_StartDrawingOnTop(*args, **kwargs)
def EndDrawingOnTop(*args, **kwargs):
- """EndDrawingOnTop(self) -> bool"""
- return _gdi_.ScreenDC_EndDrawingOnTop(*args, **kwargs)
+ """
+ EndDrawingOnTop(self) -> bool
+
+ Use this in conjunction with `StartDrawingOnTop` or
+ `StartDrawingOnTopWin` to ensure that drawing to the screen occurs on
+ top of existing windows. Without this, some window systems (such as X)
+ only allow drawing to take place underneath other windows.
+ You might use this pair of functions when implementing a drag feature,
+ for example as in the `wx.SplitterWindow` implementation.
-class ScreenDCPtr(ScreenDC):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ScreenDC
-_gdi_.ScreenDC_swigregister(ScreenDCPtr)
+ These functions are probably obsolete since the X implementations
+ allow drawing directly on the screen now. However, the fact that this
+ function allows the screen to be refreshed afterwards may be useful
+ to some applications.
+ """
+ return _gdi_.ScreenDC_EndDrawingOnTop(*args, **kwargs)
+
+ScreenDC_swigregister = _gdi_.ScreenDC_swigregister
+ScreenDC_swigregister(ScreenDC)
#---------------------------------------------------------------------------
class ClientDC(DC):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxClientDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, Window win) -> ClientDC"""
- newobj = _gdi_.new_ClientDC(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class ClientDCPtr(ClientDC):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ClientDC
-_gdi_.ClientDC_swigregister(ClientDCPtr)
+ """
+ A wx.ClientDC must be constructed if an application wishes to paint on
+ the client area of a window from outside an EVT_PAINT event. This should
+ normally be constructed as a temporary stack object; don't store a
+ wx.ClientDC object long term.
+
+ To draw on a window from within an EVT_PAINT handler, construct a
+ `wx.PaintDC` object.
+
+ To draw on the whole window including decorations, construct a
+ `wx.WindowDC` object (Windows only).
+
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, Window win) -> ClientDC
+
+ Constructor. Pass the window on which you wish to paint.
+ """
+ _gdi_.ClientDC_swiginit(self,_gdi_.new_ClientDC(*args, **kwargs))
+ClientDC_swigregister = _gdi_.ClientDC_swigregister
+ClientDC_swigregister(ClientDC)
#---------------------------------------------------------------------------
class PaintDC(DC):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPaintDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, Window win) -> PaintDC"""
- newobj = _gdi_.new_PaintDC(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class PaintDCPtr(PaintDC):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PaintDC
-_gdi_.PaintDC_swigregister(PaintDCPtr)
+ """
+ A wx.PaintDC must be constructed if an application wishes to paint on
+ the client area of a window from within an EVT_PAINT event
+ handler. This should normally be constructed as a temporary stack
+ object; don't store a wx.PaintDC object. If you have an EVT_PAINT
+ handler, you **must** create a wx.PaintDC object within it even if you
+ don't actually use it.
+
+ Using wx.PaintDC within EVT_PAINT handlers is important because it
+ automatically sets the clipping area to the damaged area of the
+ window. Attempts to draw outside this area do not appear.
+
+ To draw on a window from outside EVT_PAINT handlers, construct a
+ `wx.ClientDC` object.
+
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, Window win) -> PaintDC
+
+ Constructor. Pass the window on which you wish to paint.
+ """
+ _gdi_.PaintDC_swiginit(self,_gdi_.new_PaintDC(*args, **kwargs))
+PaintDC_swigregister = _gdi_.PaintDC_swigregister
+PaintDC_swigregister(PaintDC)
#---------------------------------------------------------------------------
class WindowDC(DC):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxWindowDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, Window win) -> WindowDC"""
- newobj = _gdi_.new_WindowDC(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class WindowDCPtr(WindowDC):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = WindowDC
-_gdi_.WindowDC_swigregister(WindowDCPtr)
+ """
+ A wx.WindowDC must be constructed if an application wishes to paint on
+ the whole area of a window (client and decorations). This should
+ normally be constructed as a temporary stack object; don't store a
+ wx.WindowDC object.
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, Window win) -> WindowDC
+
+ Constructor. Pass the window on which you wish to paint.
+ """
+ _gdi_.WindowDC_swiginit(self,_gdi_.new_WindowDC(*args, **kwargs))
+WindowDC_swigregister = _gdi_.WindowDC_swigregister
+WindowDC_swigregister(WindowDC)
#---------------------------------------------------------------------------
class MirrorDC(DC):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxMirrorDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, DC dc, bool mirror) -> MirrorDC"""
- newobj = _gdi_.new_MirrorDC(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class MirrorDCPtr(MirrorDC):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = MirrorDC
-_gdi_.MirrorDC_swigregister(MirrorDCPtr)
+ """
+ wx.MirrorDC is a simple wrapper class which is always associated with a
+ real `wx.DC` object and either forwards all of its operations to it
+ without changes (no mirroring takes place) or exchanges x and y
+ coordinates which makes it possible to reuse the same code to draw a
+ figure and its mirror -- i.e. reflection related to the diagonal line
+ x == y.
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, DC dc, bool mirror) -> MirrorDC
+
+ Creates a mirrored DC associated with the real *dc*. Everything drawn
+ on the wx.MirrorDC will appear on the *dc*, and will be mirrored if
+ *mirror* is True.
+ """
+ _gdi_.MirrorDC_swiginit(self,_gdi_.new_MirrorDC(*args, **kwargs))
+MirrorDC_swigregister = _gdi_.MirrorDC_swigregister
+MirrorDC_swigregister(MirrorDC)
#---------------------------------------------------------------------------
class PostScriptDC(DC):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPostScriptDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, wxPrintData printData) -> PostScriptDC"""
- newobj = _gdi_.new_PostScriptDC(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """This is a `wx.DC` that can write to PostScript files on any platform."""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, wxPrintData printData) -> PostScriptDC
+
+ Constructs a PostScript printer device context from a `wx.PrintData`
+ object.
+ """
+ _gdi_.PostScriptDC_swiginit(self,_gdi_.new_PostScriptDC(*args, **kwargs))
def GetPrintData(*args, **kwargs):
"""GetPrintData(self) -> wxPrintData"""
return _gdi_.PostScriptDC_GetPrintData(*args, **kwargs)
return _gdi_.PostScriptDC_SetPrintData(*args, **kwargs)
def SetResolution(*args, **kwargs):
- """PostScriptDC.SetResolution(int ppi)"""
+ """
+ SetResolution(int ppi)
+
+ Set resolution (in pixels per inch) that will be used in PostScript
+ output. Default is 720ppi.
+ """
return _gdi_.PostScriptDC_SetResolution(*args, **kwargs)
SetResolution = staticmethod(SetResolution)
def GetResolution(*args, **kwargs):
- """PostScriptDC.GetResolution() -> int"""
+ """
+ GetResolution() -> int
+
+ Return resolution used in PostScript output.
+ """
return _gdi_.PostScriptDC_GetResolution(*args, **kwargs)
GetResolution = staticmethod(GetResolution)
-
-class PostScriptDCPtr(PostScriptDC):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PostScriptDC
-_gdi_.PostScriptDC_swigregister(PostScriptDCPtr)
+PostScriptDC_swigregister = _gdi_.PostScriptDC_swigregister
+PostScriptDC_swigregister(PostScriptDC)
def PostScriptDC_SetResolution(*args, **kwargs):
- """PostScriptDC_SetResolution(int ppi)"""
- return _gdi_.PostScriptDC_SetResolution(*args, **kwargs)
+ """
+ PostScriptDC_SetResolution(int ppi)
+
+ Set resolution (in pixels per inch) that will be used in PostScript
+ output. Default is 720ppi.
+ """
+ return _gdi_.PostScriptDC_SetResolution(*args, **kwargs)
+
+def PostScriptDC_GetResolution(*args):
+ """
+ PostScriptDC_GetResolution() -> int
-def PostScriptDC_GetResolution(*args, **kwargs):
- """PostScriptDC_GetResolution() -> int"""
- return _gdi_.PostScriptDC_GetResolution(*args, **kwargs)
+ Return resolution used in PostScript output.
+ """
+ return _gdi_.PostScriptDC_GetResolution(*args)
#---------------------------------------------------------------------------
class MetaFile(_core.Object):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxMetaFile instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ MetaFile class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self, String filename=EmptyString) -> MetaFile"""
- newobj = _gdi_.new_MetaFile(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class MetaFilePtr(MetaFile):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = MetaFile
-_gdi_.MetaFile_swigregister(MetaFilePtr)
+ _gdi_.MetaFile_swiginit(self,_gdi_.new_MetaFile(*args, **kwargs))
+MetaFile_swigregister = _gdi_.MetaFile_swigregister
+MetaFile_swigregister(MetaFile)
class MetaFileDC(DC):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxMetaFileDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ MetaFileDC class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""
__init__(self, String filename=EmptyString, int width=0, int height=0,
String description=EmptyString) -> MetaFileDC
"""
- newobj = _gdi_.new_MetaFileDC(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class MetaFileDCPtr(MetaFileDC):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = MetaFileDC
-_gdi_.MetaFileDC_swigregister(MetaFileDCPtr)
+ _gdi_.MetaFileDC_swiginit(self,_gdi_.new_MetaFileDC(*args, **kwargs))
+MetaFileDC_swigregister = _gdi_.MetaFileDC_swigregister
+MetaFileDC_swigregister(MetaFileDC)
class PrinterDC(DC):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPrinterDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ PrinterDC class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self, wxPrintData printData) -> PrinterDC"""
- newobj = _gdi_.new_PrinterDC(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class PrinterDCPtr(PrinterDC):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PrinterDC
-_gdi_.PrinterDC_swigregister(PrinterDCPtr)
-
-class DC_old(DC):
- """DC class that has methods with 2.4 compatible parameters."""
- FloodFill = DC.FloodFillXY
- GetPixel = DC.GetPixelXY
- DrawLine = DC.DrawLineXY
- CrossHair = DC.CrossHairXY
- DrawArc = DC.DrawArcXY
- DrawCheckMark = DC.DrawCheckMarkXY
- DrawEllipticArc = DC.DrawEllipticArcXY
- DrawPoint = DC.DrawPointXY
- DrawRectangle = DC.DrawRectangleXY
- DrawRoundedRectangle = DC.DrawRoundedRectangleXY
- DrawCircle = DC.DrawCircleXY
- DrawEllipse = DC.DrawEllipseXY
- DrawIcon = DC.DrawIconXY
- DrawBitmap = DC.DrawBitmapXY
- DrawText = DC.DrawTextXY
- DrawRotatedText = DC.DrawRotatedTextXY
- Blit = DC.BlitXY
-
-class MemoryDC_old(MemoryDC):
- """DC class that has methods with 2.4 compatible parameters."""
- FloodFill = MemoryDC.FloodFillXY
- GetPixel = MemoryDC.GetPixelXY
- DrawLine = MemoryDC.DrawLineXY
- CrossHair = MemoryDC.CrossHairXY
- DrawArc = MemoryDC.DrawArcXY
- DrawCheckMark = MemoryDC.DrawCheckMarkXY
- DrawEllipticArc = MemoryDC.DrawEllipticArcXY
- DrawPoint = MemoryDC.DrawPointXY
- DrawRectangle = MemoryDC.DrawRectangleXY
- DrawRoundedRectangle = MemoryDC.DrawRoundedRectangleXY
- DrawCircle = MemoryDC.DrawCircleXY
- DrawEllipse = MemoryDC.DrawEllipseXY
- DrawIcon = MemoryDC.DrawIconXY
- DrawBitmap = MemoryDC.DrawBitmapXY
- DrawText = MemoryDC.DrawTextXY
- DrawRotatedText = MemoryDC.DrawRotatedTextXY
- Blit = MemoryDC.BlitXY
-
-class BufferedDC_old(BufferedDC):
- """DC class that has methods with 2.4 compatible parameters."""
- FloodFill = BufferedDC.FloodFillXY
- GetPixel = BufferedDC.GetPixelXY
- DrawLine = BufferedDC.DrawLineXY
- CrossHair = BufferedDC.CrossHairXY
- DrawArc = BufferedDC.DrawArcXY
- DrawCheckMark = BufferedDC.DrawCheckMarkXY
- DrawEllipticArc = BufferedDC.DrawEllipticArcXY
- DrawPoint = BufferedDC.DrawPointXY
- DrawRectangle = BufferedDC.DrawRectangleXY
- DrawRoundedRectangle = BufferedDC.DrawRoundedRectangleXY
- DrawCircle = BufferedDC.DrawCircleXY
- DrawEllipse = BufferedDC.DrawEllipseXY
- DrawIcon = BufferedDC.DrawIconXY
- DrawBitmap = BufferedDC.DrawBitmapXY
- DrawText = BufferedDC.DrawTextXY
- DrawRotatedText = BufferedDC.DrawRotatedTextXY
- Blit = BufferedDC.BlitXY
-
-class BufferedPaintDC_old(BufferedPaintDC):
- """DC class that has methods with 2.4 compatible parameters."""
- FloodFill = BufferedPaintDC.FloodFillXY
- GetPixel = BufferedPaintDC.GetPixelXY
- DrawLine = BufferedPaintDC.DrawLineXY
- CrossHair = BufferedPaintDC.CrossHairXY
- DrawArc = BufferedPaintDC.DrawArcXY
- DrawCheckMark = BufferedPaintDC.DrawCheckMarkXY
- DrawEllipticArc = BufferedPaintDC.DrawEllipticArcXY
- DrawPoint = BufferedPaintDC.DrawPointXY
- DrawRectangle = BufferedPaintDC.DrawRectangleXY
- DrawRoundedRectangle = BufferedPaintDC.DrawRoundedRectangleXY
- DrawCircle = BufferedPaintDC.DrawCircleXY
- DrawEllipse = BufferedPaintDC.DrawEllipseXY
- DrawIcon = BufferedPaintDC.DrawIconXY
- DrawBitmap = BufferedPaintDC.DrawBitmapXY
- DrawText = BufferedPaintDC.DrawTextXY
- DrawRotatedText = BufferedPaintDC.DrawRotatedTextXY
- Blit = BufferedPaintDC.BlitXY
-
-class ScreenDC_old(ScreenDC):
- """DC class that has methods with 2.4 compatible parameters."""
- FloodFill = ScreenDC.FloodFillXY
- GetPixel = ScreenDC.GetPixelXY
- DrawLine = ScreenDC.DrawLineXY
- CrossHair = ScreenDC.CrossHairXY
- DrawArc = ScreenDC.DrawArcXY
- DrawCheckMark = ScreenDC.DrawCheckMarkXY
- DrawEllipticArc = ScreenDC.DrawEllipticArcXY
- DrawPoint = ScreenDC.DrawPointXY
- DrawRectangle = ScreenDC.DrawRectangleXY
- DrawRoundedRectangle = ScreenDC.DrawRoundedRectangleXY
- DrawCircle = ScreenDC.DrawCircleXY
- DrawEllipse = ScreenDC.DrawEllipseXY
- DrawIcon = ScreenDC.DrawIconXY
- DrawBitmap = ScreenDC.DrawBitmapXY
- DrawText = ScreenDC.DrawTextXY
- DrawRotatedText = ScreenDC.DrawRotatedTextXY
- Blit = ScreenDC.BlitXY
-
-class ClientDC_old(ClientDC):
- """DC class that has methods with 2.4 compatible parameters."""
- FloodFill = ClientDC.FloodFillXY
- GetPixel = ClientDC.GetPixelXY
- DrawLine = ClientDC.DrawLineXY
- CrossHair = ClientDC.CrossHairXY
- DrawArc = ClientDC.DrawArcXY
- DrawCheckMark = ClientDC.DrawCheckMarkXY
- DrawEllipticArc = ClientDC.DrawEllipticArcXY
- DrawPoint = ClientDC.DrawPointXY
- DrawRectangle = ClientDC.DrawRectangleXY
- DrawRoundedRectangle = ClientDC.DrawRoundedRectangleXY
- DrawCircle = ClientDC.DrawCircleXY
- DrawEllipse = ClientDC.DrawEllipseXY
- DrawIcon = ClientDC.DrawIconXY
- DrawBitmap = ClientDC.DrawBitmapXY
- DrawText = ClientDC.DrawTextXY
- DrawRotatedText = ClientDC.DrawRotatedTextXY
- Blit = ClientDC.BlitXY
-
-class PaintDC_old(PaintDC):
- """DC class that has methods with 2.4 compatible parameters."""
- FloodFill = PaintDC.FloodFillXY
- GetPixel = PaintDC.GetPixelXY
- DrawLine = PaintDC.DrawLineXY
- CrossHair = PaintDC.CrossHairXY
- DrawArc = PaintDC.DrawArcXY
- DrawCheckMark = PaintDC.DrawCheckMarkXY
- DrawEllipticArc = PaintDC.DrawEllipticArcXY
- DrawPoint = PaintDC.DrawPointXY
- DrawRectangle = PaintDC.DrawRectangleXY
- DrawRoundedRectangle = PaintDC.DrawRoundedRectangleXY
- DrawCircle = PaintDC.DrawCircleXY
- DrawEllipse = PaintDC.DrawEllipseXY
- DrawIcon = PaintDC.DrawIconXY
- DrawBitmap = PaintDC.DrawBitmapXY
- DrawText = PaintDC.DrawTextXY
- DrawRotatedText = PaintDC.DrawRotatedTextXY
- Blit = PaintDC.BlitXY
-
-class WindowDC_old(WindowDC):
- """DC class that has methods with 2.4 compatible parameters."""
- FloodFill = WindowDC.FloodFillXY
- GetPixel = WindowDC.GetPixelXY
- DrawLine = WindowDC.DrawLineXY
- CrossHair = WindowDC.CrossHairXY
- DrawArc = WindowDC.DrawArcXY
- DrawCheckMark = WindowDC.DrawCheckMarkXY
- DrawEllipticArc = WindowDC.DrawEllipticArcXY
- DrawPoint = WindowDC.DrawPointXY
- DrawRectangle = WindowDC.DrawRectangleXY
- DrawRoundedRectangle = WindowDC.DrawRoundedRectangleXY
- DrawCircle = WindowDC.DrawCircleXY
- DrawEllipse = WindowDC.DrawEllipseXY
- DrawIcon = WindowDC.DrawIconXY
- DrawBitmap = WindowDC.DrawBitmapXY
- DrawText = WindowDC.DrawTextXY
- DrawRotatedText = WindowDC.DrawRotatedTextXY
- Blit = WindowDC.BlitXY
-
-class MirrorDC_old(MirrorDC):
- """DC class that has methods with 2.4 compatible parameters."""
- FloodFill = MirrorDC.FloodFillXY
- GetPixel = MirrorDC.GetPixelXY
- DrawLine = MirrorDC.DrawLineXY
- CrossHair = MirrorDC.CrossHairXY
- DrawArc = MirrorDC.DrawArcXY
- DrawCheckMark = MirrorDC.DrawCheckMarkXY
- DrawEllipticArc = MirrorDC.DrawEllipticArcXY
- DrawPoint = MirrorDC.DrawPointXY
- DrawRectangle = MirrorDC.DrawRectangleXY
- DrawRoundedRectangle = MirrorDC.DrawRoundedRectangleXY
- DrawCircle = MirrorDC.DrawCircleXY
- DrawEllipse = MirrorDC.DrawEllipseXY
- DrawIcon = MirrorDC.DrawIconXY
- DrawBitmap = MirrorDC.DrawBitmapXY
- DrawText = MirrorDC.DrawTextXY
- DrawRotatedText = MirrorDC.DrawRotatedTextXY
- Blit = MirrorDC.BlitXY
-
-class PostScriptDC_old(PostScriptDC):
- """DC class that has methods with 2.4 compatible parameters."""
- FloodFill = PostScriptDC.FloodFillXY
- GetPixel = PostScriptDC.GetPixelXY
- DrawLine = PostScriptDC.DrawLineXY
- CrossHair = PostScriptDC.CrossHairXY
- DrawArc = PostScriptDC.DrawArcXY
- DrawCheckMark = PostScriptDC.DrawCheckMarkXY
- DrawEllipticArc = PostScriptDC.DrawEllipticArcXY
- DrawPoint = PostScriptDC.DrawPointXY
- DrawRectangle = PostScriptDC.DrawRectangleXY
- DrawRoundedRectangle = PostScriptDC.DrawRoundedRectangleXY
- DrawCircle = PostScriptDC.DrawCircleXY
- DrawEllipse = PostScriptDC.DrawEllipseXY
- DrawIcon = PostScriptDC.DrawIconXY
- DrawBitmap = PostScriptDC.DrawBitmapXY
- DrawText = PostScriptDC.DrawTextXY
- DrawRotatedText = PostScriptDC.DrawRotatedTextXY
- Blit = PostScriptDC.BlitXY
-
-class MetaFileDC_old(MetaFileDC):
- """DC class that has methods with 2.4 compatible parameters."""
- FloodFill = MetaFileDC.FloodFillXY
- GetPixel = MetaFileDC.GetPixelXY
- DrawLine = MetaFileDC.DrawLineXY
- CrossHair = MetaFileDC.CrossHairXY
- DrawArc = MetaFileDC.DrawArcXY
- DrawCheckMark = MetaFileDC.DrawCheckMarkXY
- DrawEllipticArc = MetaFileDC.DrawEllipticArcXY
- DrawPoint = MetaFileDC.DrawPointXY
- DrawRectangle = MetaFileDC.DrawRectangleXY
- DrawRoundedRectangle = MetaFileDC.DrawRoundedRectangleXY
- DrawCircle = MetaFileDC.DrawCircleXY
- DrawEllipse = MetaFileDC.DrawEllipseXY
- DrawIcon = MetaFileDC.DrawIconXY
- DrawBitmap = MetaFileDC.DrawBitmapXY
- DrawText = MetaFileDC.DrawTextXY
- DrawRotatedText = MetaFileDC.DrawRotatedTextXY
- Blit = MetaFileDC.BlitXY
-
-class PrinterDC_old(PrinterDC):
- """DC class that has methods with 2.4 compatible parameters."""
- FloodFill = PrinterDC.FloodFillXY
- GetPixel = PrinterDC.GetPixelXY
- DrawLine = PrinterDC.DrawLineXY
- CrossHair = PrinterDC.CrossHairXY
- DrawArc = PrinterDC.DrawArcXY
- DrawCheckMark = PrinterDC.DrawCheckMarkXY
- DrawEllipticArc = PrinterDC.DrawEllipticArcXY
- DrawPoint = PrinterDC.DrawPointXY
- DrawRectangle = PrinterDC.DrawRectangleXY
- DrawRoundedRectangle = PrinterDC.DrawRoundedRectangleXY
- DrawCircle = PrinterDC.DrawCircleXY
- DrawEllipse = PrinterDC.DrawEllipseXY
- DrawIcon = PrinterDC.DrawIconXY
- DrawBitmap = PrinterDC.DrawBitmapXY
- DrawText = PrinterDC.DrawTextXY
- DrawRotatedText = PrinterDC.DrawRotatedTextXY
- Blit = PrinterDC.BlitXY
+ _gdi_.PrinterDC_swiginit(self,_gdi_.new_PrinterDC(*args, **kwargs))
+PrinterDC_swigregister = _gdi_.PrinterDC_swigregister
+PrinterDC_swigregister(PrinterDC)
#---------------------------------------------------------------------------
IMAGE_LIST_SMALL = _gdi_.IMAGE_LIST_SMALL
IMAGE_LIST_STATE = _gdi_.IMAGE_LIST_STATE
class ImageList(_core.Object):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxImageList instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ ImageList class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self, int width, int height, int mask=True, int initialCount=1) -> ImageList"""
- newobj = _gdi_.new_ImageList(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_ImageList):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.ImageList_swiginit(self,_gdi_.new_ImageList(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_ImageList
+ __del__ = lambda self : None;
def Add(*args, **kwargs):
"""Add(self, Bitmap bitmap, Bitmap mask=NullBitmap) -> int"""
return _gdi_.ImageList_Add(*args, **kwargs)
"""AddIcon(self, Icon icon) -> int"""
return _gdi_.ImageList_AddIcon(*args, **kwargs)
+ def GetBitmap(*args, **kwargs):
+ """GetBitmap(self, int index) -> Bitmap"""
+ return _gdi_.ImageList_GetBitmap(*args, **kwargs)
+
+ def GetIcon(*args, **kwargs):
+ """GetIcon(self, int index) -> Icon"""
+ return _gdi_.ImageList_GetIcon(*args, **kwargs)
+
def Replace(*args, **kwargs):
"""Replace(self, int index, Bitmap bitmap) -> bool"""
return _gdi_.ImageList_Replace(*args, **kwargs)
"""GetSize() -> (width,height)"""
return _gdi_.ImageList_GetSize(*args, **kwargs)
-
-class ImageListPtr(ImageList):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ImageList
-_gdi_.ImageList_swigregister(ImageListPtr)
+ImageList_swigregister = _gdi_.ImageList_swigregister
+ImageList_swigregister(ImageList)
#---------------------------------------------------------------------------
class PenList(_core.Object):
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPenList instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ """Proxy of C++ PenList class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ def __init__(self): raise AttributeError, "No constructor defined"
+ __repr__ = _swig_repr
def AddPen(*args, **kwargs):
"""AddPen(self, Pen pen)"""
return _gdi_.PenList_AddPen(*args, **kwargs)
"""GetCount(self) -> int"""
return _gdi_.PenList_GetCount(*args, **kwargs)
-
-class PenListPtr(PenList):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PenList
-_gdi_.PenList_swigregister(PenListPtr)
+PenList_swigregister = _gdi_.PenList_swigregister
+PenList_swigregister(PenList)
cvar = _gdi_.cvar
NORMAL_FONT = cvar.NORMAL_FONT
SMALL_FONT = cvar.SMALL_FONT
NullColour = cvar.NullColour
class BrushList(_core.Object):
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxBrushList instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ """Proxy of C++ BrushList class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ def __init__(self): raise AttributeError, "No constructor defined"
+ __repr__ = _swig_repr
def AddBrush(*args, **kwargs):
"""AddBrush(self, Brush brush)"""
return _gdi_.BrushList_AddBrush(*args, **kwargs)
def FindOrCreateBrush(*args, **kwargs):
- """FindOrCreateBrush(self, Colour colour, int style) -> Brush"""
+ """FindOrCreateBrush(self, Colour colour, int style=SOLID) -> Brush"""
return _gdi_.BrushList_FindOrCreateBrush(*args, **kwargs)
def RemoveBrush(*args, **kwargs):
"""GetCount(self) -> int"""
return _gdi_.BrushList_GetCount(*args, **kwargs)
-
-class BrushListPtr(BrushList):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = BrushList
-_gdi_.BrushList_swigregister(BrushListPtr)
+BrushList_swigregister = _gdi_.BrushList_swigregister
+BrushList_swigregister(BrushList)
class ColourDatabase(_core.Object):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxColourDatabase instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ ColourDatabase class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self) -> ColourDatabase"""
- newobj = _gdi_.new_ColourDatabase(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_gdi_.delete_ColourDatabase):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _gdi_.ColourDatabase_swiginit(self,_gdi_.new_ColourDatabase(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_ColourDatabase
+ __del__ = lambda self : None;
def Find(*args, **kwargs):
"""Find(self, String name) -> Colour"""
return _gdi_.ColourDatabase_Find(*args, **kwargs)
"""Append(self, String name, int red, int green, int blue)"""
return _gdi_.ColourDatabase_Append(*args, **kwargs)
-
-class ColourDatabasePtr(ColourDatabase):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ColourDatabase
-_gdi_.ColourDatabase_swigregister(ColourDatabasePtr)
+ColourDatabase_swigregister = _gdi_.ColourDatabase_swigregister
+ColourDatabase_swigregister(ColourDatabase)
class FontList(_core.Object):
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxFontList instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ """Proxy of C++ FontList class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ def __init__(self): raise AttributeError, "No constructor defined"
+ __repr__ = _swig_repr
def AddFont(*args, **kwargs):
"""AddFont(self, Font font)"""
return _gdi_.FontList_AddFont(*args, **kwargs)
"""GetCount(self) -> int"""
return _gdi_.FontList_GetCount(*args, **kwargs)
-
-class FontListPtr(FontList):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = FontList
-_gdi_.FontList_swigregister(FontListPtr)
+FontList_swigregister = _gdi_.FontList_swigregister
+FontList_swigregister(FontList)
#---------------------------------------------------------------------------
#---------------------------------------------------------------------------
class Effects(_core.Object):
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxEffects instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """Proxy of C++ Effects class"""
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""__init__(self) -> Effects"""
- newobj = _gdi_.new_Effects(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _gdi_.Effects_swiginit(self,_gdi_.new_Effects(*args, **kwargs))
def GetHighlightColour(*args, **kwargs):
"""GetHighlightColour(self) -> Colour"""
return _gdi_.Effects_GetHighlightColour(*args, **kwargs)
"""TileBitmap(self, Rect rect, DC dc, Bitmap bitmap) -> bool"""
return _gdi_.Effects_TileBitmap(*args, **kwargs)
-
-class EffectsPtr(Effects):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Effects
-_gdi_.Effects_swigregister(EffectsPtr)
+Effects_swigregister = _gdi_.Effects_swigregister
+Effects_swigregister(Effects)
TheFontList = cvar.TheFontList
ThePenList = cvar.ThePenList
TheBrushList = cvar.TheBrushList
TheColourDatabase = cvar.TheColourDatabase
+#---------------------------------------------------------------------------
+
+CONTROL_DISABLED = _gdi_.CONTROL_DISABLED
+CONTROL_FOCUSED = _gdi_.CONTROL_FOCUSED
+CONTROL_PRESSED = _gdi_.CONTROL_PRESSED
+CONTROL_ISDEFAULT = _gdi_.CONTROL_ISDEFAULT
+CONTROL_ISSUBMENU = _gdi_.CONTROL_ISSUBMENU
+CONTROL_EXPANDED = _gdi_.CONTROL_EXPANDED
+CONTROL_CURRENT = _gdi_.CONTROL_CURRENT
+CONTROL_SELECTED = _gdi_.CONTROL_SELECTED
+CONTROL_CHECKED = _gdi_.CONTROL_CHECKED
+CONTROL_CHECKABLE = _gdi_.CONTROL_CHECKABLE
+CONTROL_UNDETERMINED = _gdi_.CONTROL_UNDETERMINED
+CONTROL_FLAGS_MASK = _gdi_.CONTROL_FLAGS_MASK
+CONTROL_DIRTY = _gdi_.CONTROL_DIRTY
+class SplitterRenderParams(object):
+ """
+ This is just a simple struct used as a return value of
+ `wx.RendererNative.GetSplitterParams` and contains some platform
+ specific metrics about splitters.
+
+ * widthSash: the width of the splitter sash.
+ * border: the width of the border of the splitter window.
+ * isHotSensitive: ``True`` if the splitter changes its
+ appearance when the mouse is over it.
+
+
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, int widthSash_, int border_, bool isSens_) -> SplitterRenderParams
+
+ This is just a simple struct used as a return value of
+ `wx.RendererNative.GetSplitterParams` and contains some platform
+ specific metrics about splitters.
+
+ * widthSash: the width of the splitter sash.
+ * border: the width of the border of the splitter window.
+ * isHotSensitive: ``True`` if the splitter changes its
+ appearance when the mouse is over it.
+
+
+ """
+ _gdi_.SplitterRenderParams_swiginit(self,_gdi_.new_SplitterRenderParams(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_SplitterRenderParams
+ __del__ = lambda self : None;
+ widthSash = property(_gdi_.SplitterRenderParams_widthSash_get)
+ border = property(_gdi_.SplitterRenderParams_border_get)
+ isHotSensitive = property(_gdi_.SplitterRenderParams_isHotSensitive_get)
+SplitterRenderParams_swigregister = _gdi_.SplitterRenderParams_swigregister
+SplitterRenderParams_swigregister(SplitterRenderParams)
+
+class RendererVersion(object):
+ """
+ This simple struct represents the `wx.RendererNative` interface
+ version and is only used as the return value of
+ `wx.RendererNative.GetVersion`.
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, int version_, int age_) -> RendererVersion
+
+ This simple struct represents the `wx.RendererNative` interface
+ version and is only used as the return value of
+ `wx.RendererNative.GetVersion`.
+ """
+ _gdi_.RendererVersion_swiginit(self,_gdi_.new_RendererVersion(*args, **kwargs))
+ __swig_destroy__ = _gdi_.delete_RendererVersion
+ __del__ = lambda self : None;
+ Current_Version = _gdi_.RendererVersion_Current_Version
+ Current_Age = _gdi_.RendererVersion_Current_Age
+ def IsCompatible(*args, **kwargs):
+ """IsCompatible(RendererVersion ver) -> bool"""
+ return _gdi_.RendererVersion_IsCompatible(*args, **kwargs)
+
+ IsCompatible = staticmethod(IsCompatible)
+ version = property(_gdi_.RendererVersion_version_get)
+ age = property(_gdi_.RendererVersion_age_get)
+RendererVersion_swigregister = _gdi_.RendererVersion_swigregister
+RendererVersion_swigregister(RendererVersion)
+
+def RendererVersion_IsCompatible(*args, **kwargs):
+ """RendererVersion_IsCompatible(RendererVersion ver) -> bool"""
+ return _gdi_.RendererVersion_IsCompatible(*args, **kwargs)
+
+class RendererNative(object):
+ """
+ One of the design principles of wxWidgets is to use the native widgets
+ on every platform in order to be as close to the native look and feel
+ on every platform. However there are still cases when some generic
+ widgets are needed for various reasons, but it can sometimes take a
+ lot of messy work to make them conform to the native LnF.
+
+ The wx.RendererNative class is a collection of functions that have
+ platform-specific implementations for drawing certain parts of
+ genereic controls in ways that are as close to the native look as
+ possible.
+
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ def __init__(self): raise AttributeError, "No constructor defined"
+ __repr__ = _swig_repr
+ def DrawHeaderButton(*args, **kwargs):
+ """
+ DrawHeaderButton(self, Window win, DC dc, Rect rect, int flags=0)
+
+ Draw the header control button (such as what is used by `wx.ListCtrl`
+ in report mode.)
+ """
+ return _gdi_.RendererNative_DrawHeaderButton(*args, **kwargs)
+
+ def DrawTreeItemButton(*args, **kwargs):
+ """
+ DrawTreeItemButton(self, Window win, DC dc, Rect rect, int flags=0)
+
+ Draw the expanded/collapsed icon for a tree control item.
+ """
+ return _gdi_.RendererNative_DrawTreeItemButton(*args, **kwargs)
+
+ def DrawSplitterBorder(*args, **kwargs):
+ """
+ DrawSplitterBorder(self, Window win, DC dc, Rect rect, int flags=0)
+
+ Draw the border for a sash window: this border must be such that the
+ sash drawn by `DrawSplitterSash` blends into it well.
+ """
+ return _gdi_.RendererNative_DrawSplitterBorder(*args, **kwargs)
+
+ def DrawSplitterSash(*args, **kwargs):
+ """
+ DrawSplitterSash(self, Window win, DC dc, Size size, int position, int orient,
+ int flags=0)
+
+ Draw a sash. The orient parameter defines whether the sash should be
+ vertical or horizontal and how the position should be interpreted.
+ """
+ return _gdi_.RendererNative_DrawSplitterSash(*args, **kwargs)
+
+ def DrawComboBoxDropButton(*args, **kwargs):
+ """
+ DrawComboBoxDropButton(self, Window win, DC dc, Rect rect, int flags=0)
+
+ Draw a button like the one used by `wx.ComboBox` to show a drop down
+ window. The usual appearance is a downwards pointing arrow.
+
+ The ``flags`` parameter may have the ``wx.CONTROL_PRESSED`` or
+ ``wx.CONTROL_CURRENT`` bits set.
+ """
+ return _gdi_.RendererNative_DrawComboBoxDropButton(*args, **kwargs)
+
+ def DrawDropArrow(*args, **kwargs):
+ """
+ DrawDropArrow(self, Window win, DC dc, Rect rect, int flags=0)
+
+ Draw a drop down arrow that is suitable for use outside a combo
+ box. Arrow will have a transparent background.
+
+ ``rect`` is not entirely filled by the arrow. Instead, you should use
+ bounding rectangle of a drop down button which arrow matches the size
+ you need. ``flags`` may have the ``wx.CONTROL_PRESSED`` or
+ ``wx.CONTROL_CURRENT`` bit set.
+ """
+ return _gdi_.RendererNative_DrawDropArrow(*args, **kwargs)
+
+ def GetSplitterParams(*args, **kwargs):
+ """
+ GetSplitterParams(self, Window win) -> SplitterRenderParams
+
+ Get the splitter parameters, see `wx.SplitterRenderParams`.
+ """
+ return _gdi_.RendererNative_GetSplitterParams(*args, **kwargs)
+
+ def Get(*args, **kwargs):
+ """
+ Get() -> RendererNative
+
+ Return the currently used renderer
+ """
+ return _gdi_.RendererNative_Get(*args, **kwargs)
+
+ Get = staticmethod(Get)
+ def GetGeneric(*args, **kwargs):
+ """
+ GetGeneric() -> RendererNative
+
+ Return the generic implementation of the renderer. Under some
+ platforms, this is the default renderer implementation, others have
+ platform-specific default renderer which can be retrieved by calling
+ `GetDefault`.
+ """
+ return _gdi_.RendererNative_GetGeneric(*args, **kwargs)
+
+ GetGeneric = staticmethod(GetGeneric)
+ def GetDefault(*args, **kwargs):
+ """
+ GetDefault() -> RendererNative
+
+ Return the default (native) implementation for this platform -- this
+ is also the one used by default but this may be changed by calling `Set`
+ in which case the return value of this method may be different from
+ the return value of `Get`.
+ """
+ return _gdi_.RendererNative_GetDefault(*args, **kwargs)
+
+ GetDefault = staticmethod(GetDefault)
+ def Set(*args, **kwargs):
+ """
+ Set(RendererNative renderer) -> RendererNative
+
+ Set the renderer to use, passing None reverts to using the default
+ renderer. Returns the previous renderer used with Set or None.
+ """
+ return _gdi_.RendererNative_Set(*args, **kwargs)
+
+ Set = staticmethod(Set)
+ def GetVersion(*args, **kwargs):
+ """
+ GetVersion(self) -> RendererVersion
+
+ Returns the version of the renderer. Will be used for ensuring
+ compatibility of dynamically loaded renderers.
+ """
+ return _gdi_.RendererNative_GetVersion(*args, **kwargs)
+
+RendererNative_swigregister = _gdi_.RendererNative_swigregister
+RendererNative_swigregister(RendererNative)
+
+def RendererNative_Get(*args):
+ """
+ RendererNative_Get() -> RendererNative
+
+ Return the currently used renderer
+ """
+ return _gdi_.RendererNative_Get(*args)
+
+def RendererNative_GetGeneric(*args):
+ """
+ RendererNative_GetGeneric() -> RendererNative
+
+ Return the generic implementation of the renderer. Under some
+ platforms, this is the default renderer implementation, others have
+ platform-specific default renderer which can be retrieved by calling
+ `GetDefault`.
+ """
+ return _gdi_.RendererNative_GetGeneric(*args)
+
+def RendererNative_GetDefault(*args):
+ """
+ RendererNative_GetDefault() -> RendererNative
+
+ Return the default (native) implementation for this platform -- this
+ is also the one used by default but this may be changed by calling `Set`
+ in which case the return value of this method may be different from
+ the return value of `Get`.
+ """
+ return _gdi_.RendererNative_GetDefault(*args)
+
+def RendererNative_Set(*args, **kwargs):
+ """
+ RendererNative_Set(RendererNative renderer) -> RendererNative
+
+ Set the renderer to use, passing None reverts to using the default
+ renderer. Returns the previous renderer used with Set or None.
+ """
+ return _gdi_.RendererNative_Set(*args, **kwargs)
+
+
projects / wxWidgets.git / blobdiff