73795abcef
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/branches/WX_2_8_BRANCH@44435 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
7567 lines
285 KiB
Python
7567 lines
285 KiB
Python
# 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
|
|
#---------------------------------------------------------------------------
|
|
|
|
class GDIObject(_core.Object):
|
|
"""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"""
|
|
_gdi_.GDIObject_swiginit(self,_gdi_.new_GDIObject(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_GDIObject
|
|
__del__ = lambda self : None;
|
|
def IsNull(*args, **kwargs):
|
|
"""IsNull(self) -> bool"""
|
|
return _gdi_.GDIObject_IsNull(*args, **kwargs)
|
|
|
|
_gdi_.GDIObject_swigregister(GDIObject)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
C2S_NAME = _gdi_.C2S_NAME
|
|
C2S_CSS_SYNTAX = _gdi_.C2S_CSS_SYNTAX
|
|
C2S_HTML_SYNTAX = _gdi_.C2S_HTML_SYNTAX
|
|
ALPHA_TRANSPARENT = _gdi_.ALPHA_TRANSPARENT
|
|
ALPHA_OPAQUE = _gdi_.ALPHA_OPAQUE
|
|
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.
|
|
|
|
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`.
|
|
|
|
"""
|
|
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, byte red=0, byte green=0, byte blue=0, byte alpha=ALPHA_OPAQUE) -> Colour
|
|
|
|
Constructs a colour from red, green and blue values.
|
|
|
|
: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) -> byte
|
|
|
|
Returns the red intensity.
|
|
"""
|
|
return _gdi_.Colour_Red(*args, **kwargs)
|
|
|
|
def Green(*args, **kwargs):
|
|
"""
|
|
Green(self) -> byte
|
|
|
|
Returns the green intensity.
|
|
"""
|
|
return _gdi_.Colour_Green(*args, **kwargs)
|
|
|
|
def Blue(*args, **kwargs):
|
|
"""
|
|
Blue(self) -> byte
|
|
|
|
Returns the blue intensity.
|
|
"""
|
|
return _gdi_.Colour_Blue(*args, **kwargs)
|
|
|
|
def Alpha(*args, **kwargs):
|
|
"""
|
|
Alpha(self) -> byte
|
|
|
|
Returns the Alpha value.
|
|
"""
|
|
return _gdi_.Colour_Alpha(*args, **kwargs)
|
|
|
|
def IsOk(*args, **kwargs):
|
|
"""
|
|
IsOk(self) -> bool
|
|
|
|
Returns True if the colour object is valid (the colour has been
|
|
initialised with RGB values).
|
|
"""
|
|
return _gdi_.Colour_IsOk(*args, **kwargs)
|
|
|
|
Ok = IsOk
|
|
def Set(*args, **kwargs):
|
|
"""
|
|
Set(self, byte red, byte green, byte blue, byte alpha=ALPHA_OPAQUE)
|
|
|
|
Sets the RGB intensity values.
|
|
"""
|
|
return _gdi_.Colour_Set(*args, **kwargs)
|
|
|
|
def SetRGB(*args, **kwargs):
|
|
"""
|
|
SetRGB(self, unsigned long colRGB)
|
|
|
|
Sets the RGB intensity values from a packed RGB value.
|
|
"""
|
|
return _gdi_.Colour_SetRGB(*args, **kwargs)
|
|
|
|
def SetFromName(*args, **kwargs):
|
|
"""
|
|
SetFromName(self, String colourName)
|
|
|
|
Sets the RGB intensity values using a colour name listed in
|
|
``wx.TheColourDatabase``.
|
|
"""
|
|
return _gdi_.Colour_SetFromName(*args, **kwargs)
|
|
|
|
def GetAsString(*args, **kwargs):
|
|
"""
|
|
GetAsString(self, long flags=wxC2S_NAME|wxC2S_CSS_SYNTAX) -> String
|
|
|
|
Return the colour as a string. Acceptable flags are:
|
|
|
|
=================== ==================================
|
|
wx.C2S_NAME return colour name, when possible
|
|
wx.C2S_CSS_SYNTAX return colour in rgb(r,g,b) syntax
|
|
wx.C2S_HTML_SYNTAX return colour in #rrggbb syntax
|
|
=================== ==================================
|
|
"""
|
|
return _gdi_.Colour_GetAsString(*args, **kwargs)
|
|
|
|
def GetPixel(*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).
|
|
"""
|
|
return _gdi_.Colour_GetPixel(*args, **kwargs)
|
|
|
|
def __eq__(*args, **kwargs):
|
|
"""
|
|
__eq__(self, PyObject other) -> bool
|
|
|
|
Compare colours for equality.
|
|
"""
|
|
return _gdi_.Colour___eq__(*args, **kwargs)
|
|
|
|
def __ne__(*args, **kwargs):
|
|
"""
|
|
__ne__(self, PyObject other) -> bool
|
|
|
|
Compare colours for inequality.
|
|
"""
|
|
return _gdi_.Colour___ne__(*args, **kwargs)
|
|
|
|
def Get(*args, **kwargs):
|
|
"""
|
|
Get() -> (r, g, b)
|
|
|
|
Returns the RGB intensity values as a tuple.
|
|
"""
|
|
return _gdi_.Colour_Get(*args, **kwargs)
|
|
|
|
def GetRGB(*args, **kwargs):
|
|
"""
|
|
GetRGB(self) -> unsigned long
|
|
|
|
Return the colour as a packed RGB value
|
|
"""
|
|
return _gdi_.Colour_GetRGB(*args, **kwargs)
|
|
|
|
asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
|
|
def __str__(self): return str(self.Get(True))
|
|
def __repr__(self): return 'wx.Colour' + str(self.Get(True))
|
|
def __len__(self): return len(self.Get())
|
|
def __getitem__(self, index): return self.Get()[index]
|
|
def __nonzero__(self): return self.IsOk()
|
|
__safe_for_unpickling__ = True
|
|
def __reduce__(self): return (Colour, self.Get(True))
|
|
|
|
Pixel = property(GetPixel,doc="See `GetPixel`")
|
|
RGB = property(GetRGB,SetRGB,doc="See `GetRGB` and `SetRGB`")
|
|
_gdi_.Colour_swigregister(Colour)
|
|
|
|
def NamedColour(*args, **kwargs):
|
|
"""
|
|
NamedColour(String colorName) -> Colour
|
|
|
|
Constructs a colour object using a colour name listed in
|
|
``wx.TheColourDatabase``.
|
|
"""
|
|
val = _gdi_.new_NamedColour(*args, **kwargs)
|
|
return val
|
|
|
|
def ColourRGB(*args, **kwargs):
|
|
"""
|
|
ColourRGB(unsigned long colRGB) -> Colour
|
|
|
|
Constructs a colour from a packed RGB value.
|
|
"""
|
|
val = _gdi_.new_ColourRGB(*args, **kwargs)
|
|
return val
|
|
|
|
Color = Colour
|
|
NamedColor = NamedColour
|
|
ColorRGB = ColourRGB
|
|
|
|
class Palette(GDIObject):
|
|
"""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"""
|
|
_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(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 IsOk(*args, **kwargs):
|
|
"""IsOk(self) -> bool"""
|
|
return _gdi_.Palette_IsOk(*args, **kwargs)
|
|
|
|
Ok = IsOk
|
|
def __nonzero__(self): return self.IsOk()
|
|
ColoursCount = property(GetColoursCount,doc="See `GetColoursCount`")
|
|
_gdi_.Palette_swigregister(Palette)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class Pen(GDIObject):
|
|
"""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"""
|
|
_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)
|
|
|
|
def GetColour(*args, **kwargs):
|
|
"""GetColour(self) -> Colour"""
|
|
return _gdi_.Pen_GetColour(*args, **kwargs)
|
|
|
|
def GetJoin(*args, **kwargs):
|
|
"""GetJoin(self) -> int"""
|
|
return _gdi_.Pen_GetJoin(*args, **kwargs)
|
|
|
|
def GetStyle(*args, **kwargs):
|
|
"""GetStyle(self) -> int"""
|
|
return _gdi_.Pen_GetStyle(*args, **kwargs)
|
|
|
|
def GetWidth(*args, **kwargs):
|
|
"""GetWidth(self) -> int"""
|
|
return _gdi_.Pen_GetWidth(*args, **kwargs)
|
|
|
|
def IsOk(*args, **kwargs):
|
|
"""IsOk(self) -> bool"""
|
|
return _gdi_.Pen_IsOk(*args, **kwargs)
|
|
|
|
Ok = IsOk
|
|
def SetCap(*args, **kwargs):
|
|
"""SetCap(self, int cap_style)"""
|
|
return _gdi_.Pen_SetCap(*args, **kwargs)
|
|
|
|
def SetColour(*args, **kwargs):
|
|
"""SetColour(self, Colour colour)"""
|
|
return _gdi_.Pen_SetColour(*args, **kwargs)
|
|
|
|
def SetJoin(*args, **kwargs):
|
|
"""SetJoin(self, int join_style)"""
|
|
return _gdi_.Pen_SetJoin(*args, **kwargs)
|
|
|
|
def SetStyle(*args, **kwargs):
|
|
"""SetStyle(self, int style)"""
|
|
return _gdi_.Pen_SetStyle(*args, **kwargs)
|
|
|
|
def SetWidth(*args, **kwargs):
|
|
"""SetWidth(self, int width)"""
|
|
return _gdi_.Pen_SetWidth(*args, **kwargs)
|
|
|
|
def SetDashes(*args, **kwargs):
|
|
"""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)
|
|
|
|
DashCount = property(GetDashCount,doc="See `GetDashCount`")
|
|
def __eq__(*args, **kwargs):
|
|
"""__eq__(self, Pen other) -> bool"""
|
|
return _gdi_.Pen___eq__(*args, **kwargs)
|
|
|
|
def __ne__(*args, **kwargs):
|
|
"""__ne__(self, Pen other) -> bool"""
|
|
return _gdi_.Pen___ne__(*args, **kwargs)
|
|
|
|
def __nonzero__(self): return self.IsOk()
|
|
Cap = property(GetCap,SetCap,doc="See `GetCap` and `SetCap`")
|
|
Colour = property(GetColour,SetColour,doc="See `GetColour` and `SetColour`")
|
|
Dashes = property(GetDashes,SetDashes,doc="See `GetDashes` and `SetDashes`")
|
|
Join = property(GetJoin,SetJoin,doc="See `GetJoin` and `SetJoin`")
|
|
Style = property(GetStyle,SetStyle,doc="See `GetStyle` and `SetStyle`")
|
|
Width = property(GetWidth,SetWidth,doc="See `GetWidth` and `SetWidth`")
|
|
_gdi_.Pen_swigregister(Pen)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class Brush(GDIObject):
|
|
"""
|
|
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.
|
|
"""
|
|
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 `wx.Colour` object and a style.
|
|
"""
|
|
_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)
|
|
|
|
Set the brush's `wx.Colour`.
|
|
"""
|
|
return _gdi_.Brush_SetColour(*args, **kwargs)
|
|
|
|
def SetStyle(*args, **kwargs):
|
|
"""
|
|
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)
|
|
|
|
Sets the stipple `wx.Bitmap`.
|
|
"""
|
|
return _gdi_.Brush_SetStipple(*args, **kwargs)
|
|
|
|
def GetColour(*args, **kwargs):
|
|
"""
|
|
GetColour(self) -> Colour
|
|
|
|
Returns the `wx.Colour` of the brush.
|
|
"""
|
|
return _gdi_.Brush_GetColour(*args, **kwargs)
|
|
|
|
def GetStyle(*args, **kwargs):
|
|
"""
|
|
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
|
|
|
|
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 IsOk(*args, **kwargs):
|
|
"""
|
|
IsOk(self) -> bool
|
|
|
|
Returns True if the brush is initialised and valid.
|
|
"""
|
|
return _gdi_.Brush_IsOk(*args, **kwargs)
|
|
|
|
Ok = IsOk
|
|
def __nonzero__(self): return self.IsOk()
|
|
Colour = property(GetColour,SetColour,doc="See `GetColour` and `SetColour`")
|
|
Stipple = property(GetStipple,SetStipple,doc="See `GetStipple` and `SetStipple`")
|
|
Style = property(GetStyle,SetStyle,doc="See `GetStyle` and `SetStyle`")
|
|
_gdi_.Brush_swigregister(Brush)
|
|
|
|
def BrushFromBitmap(*args, **kwargs):
|
|
"""
|
|
BrushFromBitmap(Bitmap stippleBitmap) -> Brush
|
|
|
|
Constructs a stippled brush using a bitmap.
|
|
"""
|
|
val = _gdi_.new_BrushFromBitmap(*args, **kwargs)
|
|
return val
|
|
|
|
class Bitmap(GDIObject):
|
|
"""
|
|
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.
|
|
"""
|
|
_gdi_.Bitmap_swiginit(self,_gdi_.new_Bitmap(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_Bitmap
|
|
__del__ = lambda self : None;
|
|
def IsOk(*args, **kwargs):
|
|
"""IsOk(self) -> bool"""
|
|
return _gdi_.Bitmap_IsOk(*args, **kwargs)
|
|
|
|
Ok = IsOk
|
|
def GetWidth(*args, **kwargs):
|
|
"""
|
|
GetWidth(self) -> int
|
|
|
|
Gets the width of the bitmap in pixels.
|
|
"""
|
|
return _gdi_.Bitmap_GetWidth(*args, **kwargs)
|
|
|
|
def GetHeight(*args, **kwargs):
|
|
"""
|
|
GetHeight(self) -> int
|
|
|
|
Gets the height of the bitmap in pixels.
|
|
"""
|
|
return _gdi_.Bitmap_GetHeight(*args, **kwargs)
|
|
|
|
def GetDepth(*args, **kwargs):
|
|
"""
|
|
GetDepth(self) -> int
|
|
|
|
Gets the colour depth of the bitmap. A value of 1 indicates a
|
|
monochrome bitmap.
|
|
"""
|
|
return _gdi_.Bitmap_GetDepth(*args, **kwargs)
|
|
|
|
def GetSize(*args, **kwargs):
|
|
"""
|
|
GetSize(self) -> Size
|
|
|
|
Get the size of the bitmap.
|
|
"""
|
|
return _gdi_.Bitmap_GetSize(*args, **kwargs)
|
|
|
|
def ConvertToImage(*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.
|
|
"""
|
|
return _gdi_.Bitmap_ConvertToImage(*args, **kwargs)
|
|
|
|
def GetMask(*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.
|
|
|
|
:see: `SetMask`, `wx.Mask`
|
|
|
|
"""
|
|
return _gdi_.Bitmap_GetMask(*args, **kwargs)
|
|
|
|
def SetMask(*args, **kwargs):
|
|
"""
|
|
SetMask(self, Mask mask)
|
|
|
|
Sets the mask for this bitmap.
|
|
|
|
:see: `GetMask`, `wx.Mask`
|
|
|
|
"""
|
|
return _gdi_.Bitmap_SetMask(*args, **kwargs)
|
|
|
|
def SetMaskColour(*args, **kwargs):
|
|
"""
|
|
SetMaskColour(self, Colour colour)
|
|
|
|
Create a Mask based on a specified colour in the Bitmap.
|
|
"""
|
|
return _gdi_.Bitmap_SetMaskColour(*args, **kwargs)
|
|
|
|
def GetSubBitmap(*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.
|
|
"""
|
|
return _gdi_.Bitmap_GetSubBitmap(*args, **kwargs)
|
|
|
|
def SaveFile(*args, **kwargs):
|
|
"""
|
|
SaveFile(self, String name, int type, Palette palette=None) -> bool
|
|
|
|
Saves a bitmap in the named file. See `__init__` for a description of
|
|
the ``type`` parameter.
|
|
"""
|
|
return _gdi_.Bitmap_SaveFile(*args, **kwargs)
|
|
|
|
def LoadFile(*args, **kwargs):
|
|
"""
|
|
LoadFile(self, String name, int type) -> bool
|
|
|
|
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)
|
|
|
|
def SetHeight(*args, **kwargs):
|
|
"""
|
|
SetHeight(self, int height)
|
|
|
|
Set the height property (does not affect the existing bitmap data).
|
|
"""
|
|
return _gdi_.Bitmap_SetHeight(*args, **kwargs)
|
|
|
|
def SetWidth(*args, **kwargs):
|
|
"""
|
|
SetWidth(self, int width)
|
|
|
|
Set the width property (does not affect the existing bitmap data).
|
|
"""
|
|
return _gdi_.Bitmap_SetWidth(*args, **kwargs)
|
|
|
|
def SetDepth(*args, **kwargs):
|
|
"""
|
|
SetDepth(self, int depth)
|
|
|
|
Set the depth property (does not affect the existing bitmap data).
|
|
"""
|
|
return _gdi_.Bitmap_SetDepth(*args, **kwargs)
|
|
|
|
def SetSize(*args, **kwargs):
|
|
"""
|
|
SetSize(self, Size size)
|
|
|
|
Set the bitmap size (does not affect the existing bitmap data).
|
|
"""
|
|
return _gdi_.Bitmap_SetSize(*args, **kwargs)
|
|
|
|
def CopyFromBuffer(*args, **kwargs):
|
|
"""
|
|
CopyFromBuffer(self, buffer data)
|
|
|
|
Copy data from a RGB buffer object to replace the bitmap pixel data.
|
|
See `wxBitmapFromBuffer` for more .
|
|
"""
|
|
return _gdi_.Bitmap_CopyFromBuffer(*args, **kwargs)
|
|
|
|
def CopyFromBufferRGBA(*args, **kwargs):
|
|
"""
|
|
CopyFromBufferRGBA(self, buffer data)
|
|
|
|
Copy data from a RGBA buffer object to replace the bitmap pixel data.
|
|
See `wxBitmapFromBufferRGBA` for more .
|
|
"""
|
|
return _gdi_.Bitmap_CopyFromBufferRGBA(*args, **kwargs)
|
|
|
|
def __nonzero__(self): return self.IsOk()
|
|
def __eq__(*args, **kwargs):
|
|
"""__eq__(self, Bitmap other) -> bool"""
|
|
return _gdi_.Bitmap___eq__(*args, **kwargs)
|
|
|
|
def __ne__(*args, **kwargs):
|
|
"""__ne__(self, Bitmap other) -> bool"""
|
|
return _gdi_.Bitmap___ne__(*args, **kwargs)
|
|
|
|
Depth = property(GetDepth,SetDepth,doc="See `GetDepth` and `SetDepth`")
|
|
Height = property(GetHeight,SetHeight,doc="See `GetHeight` and `SetHeight`")
|
|
Mask = property(GetMask,SetMask,doc="See `GetMask` and `SetMask`")
|
|
Palette = property(GetPalette,doc="See `GetPalette`")
|
|
Size = property(GetSize,SetSize,doc="See `GetSize` and `SetSize`")
|
|
SubBitmap = property(GetSubBitmap,doc="See `GetSubBitmap`")
|
|
Width = property(GetWidth,SetWidth,doc="See `GetWidth` and `SetWidth`")
|
|
_gdi_.Bitmap_swigregister(Bitmap)
|
|
|
|
def EmptyBitmap(*args, **kwargs):
|
|
"""
|
|
EmptyBitmap(int width, int height, 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 display depth.
|
|
"""
|
|
val = _gdi_.new_EmptyBitmap(*args, **kwargs)
|
|
return val
|
|
|
|
def BitmapFromIcon(*args, **kwargs):
|
|
"""
|
|
BitmapFromIcon(Icon icon) -> Bitmap
|
|
|
|
Create a new bitmap from a `wx.Icon` object.
|
|
"""
|
|
val = _gdi_.new_BitmapFromIcon(*args, **kwargs)
|
|
return val
|
|
|
|
def BitmapFromImage(*args, **kwargs):
|
|
"""
|
|
BitmapFromImage(Image image, int depth=-1) -> Bitmap
|
|
|
|
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)
|
|
return val
|
|
|
|
def BitmapFromXPMData(*args, **kwargs):
|
|
"""
|
|
BitmapFromXPMData(PyObject listOfStrings) -> Bitmap
|
|
|
|
Construct a Bitmap from a list of strings formatted as XPM data.
|
|
"""
|
|
val = _gdi_.new_BitmapFromXPMData(*args, **kwargs)
|
|
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.
|
|
"""
|
|
val = _gdi_.new_BitmapFromBits(*args, **kwargs)
|
|
return val
|
|
|
|
|
|
def _BitmapFromBufferAlpha(*args, **kwargs):
|
|
"""_BitmapFromBufferAlpha(int width, int height, buffer data, buffer alpha) -> Bitmap"""
|
|
return _gdi_._BitmapFromBufferAlpha(*args, **kwargs)
|
|
|
|
def _BitmapFromBuffer(*args, **kwargs):
|
|
"""_BitmapFromBuffer(int width, int height, buffer data) -> Bitmap"""
|
|
return _gdi_._BitmapFromBuffer(*args, **kwargs)
|
|
def BitmapFromBuffer(width, height, dataBuffer, alphaBuffer=None):
|
|
"""
|
|
Creates a `wx.Bitmap` from the data in dataBuffer. The dataBuffer
|
|
parameter must be a Python object that implements the buffer
|
|
interface, such as a string, array, etc. The dataBuffer object is
|
|
expected to contain a series of RGB bytes and be width*height*3
|
|
bytes long. A buffer object can optionally be supplied for the
|
|
image's alpha channel data, and it is expected to be width*height
|
|
bytes long. On Windows the RGB values are 'premultiplied' by the
|
|
alpha values. (The other platforms do the multiplication
|
|
themselves.)
|
|
|
|
Unlike `wx.ImageFromBuffer` the bitmap created with this function
|
|
does not share the memory buffer with the buffer object. This is
|
|
because the native pixel buffer format varies on different
|
|
platforms, and so instead an efficient as possible copy of the
|
|
data is made from the buffer objects to the bitmap's native pixel
|
|
buffer. For direct access to a bitmap's pixel buffer see
|
|
`wx.NativePixelData` and `wx.AlphaPixelData`.
|
|
|
|
:see: `wx.Bitmap`, `wx.BitmapFromBufferRGBA`, `wx.NativePixelData`,
|
|
`wx.AlphaPixelData`, `wx.ImageFromBuffer`
|
|
"""
|
|
if alphaBuffer is not None:
|
|
return _gdi_._BitmapFromBufferAlpha(width, height, dataBuffer, alphaBuffer)
|
|
else:
|
|
return _gdi_._BitmapFromBuffer(width, height, dataBuffer)
|
|
|
|
|
|
def _BitmapFromBufferRGBA(*args, **kwargs):
|
|
"""_BitmapFromBufferRGBA(int width, int height, buffer data) -> Bitmap"""
|
|
return _gdi_._BitmapFromBufferRGBA(*args, **kwargs)
|
|
def BitmapFromBufferRGBA(width, height, dataBuffer):
|
|
"""
|
|
Creates a `wx.Bitmap` from the data in dataBuffer. The dataBuffer
|
|
parameter must be a Python object that implements the buffer
|
|
interface, such as a string, array, etc. The dataBuffer object is
|
|
expected to contain a series of RGBA bytes (red, green, blue and
|
|
alpha) and be width*height*4 bytes long. On Windows the RGB
|
|
values are 'premultiplied' by the alpha values. (The other
|
|
platforms do the multiplication themselves.)
|
|
|
|
Unlike `wx.ImageFromBuffer` the bitmap created with this function
|
|
does not share the memory buffer with the buffer object. This is
|
|
because the native pixel buffer format varies on different
|
|
platforms, and so instead an efficient as possible copy of the
|
|
data is made from the buffer object to the bitmap's native pixel
|
|
buffer. For direct access to a bitmap's pixel buffer see
|
|
`wx.NativePixelData` and `wx.AlphaPixelData`.
|
|
|
|
:see: `wx.Bitmap`, `wx.BitmapFromBuffer`, `wx.NativePixelData`,
|
|
`wx.AlphaPixelData`, `wx.ImageFromBuffer`
|
|
"""
|
|
return _gdi_._BitmapFromBufferRGBA(width, height, dataBuffer)
|
|
|
|
class PixelDataBase(object):
|
|
"""Proxy of C++ PixelDataBase 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 GetOrigin(*args, **kwargs):
|
|
"""GetOrigin(self) -> Point"""
|
|
return _gdi_.PixelDataBase_GetOrigin(*args, **kwargs)
|
|
|
|
def GetWidth(*args, **kwargs):
|
|
"""GetWidth(self) -> int"""
|
|
return _gdi_.PixelDataBase_GetWidth(*args, **kwargs)
|
|
|
|
def GetHeight(*args, **kwargs):
|
|
"""GetHeight(self) -> int"""
|
|
return _gdi_.PixelDataBase_GetHeight(*args, **kwargs)
|
|
|
|
def GetSize(*args, **kwargs):
|
|
"""GetSize(self) -> Size"""
|
|
return _gdi_.PixelDataBase_GetSize(*args, **kwargs)
|
|
|
|
def GetRowStride(*args, **kwargs):
|
|
"""GetRowStride(self) -> int"""
|
|
return _gdi_.PixelDataBase_GetRowStride(*args, **kwargs)
|
|
|
|
Height = property(GetHeight,doc="See `GetHeight`")
|
|
Origin = property(GetOrigin,doc="See `GetOrigin`")
|
|
RowStride = property(GetRowStride,doc="See `GetRowStride`")
|
|
Size = property(GetSize,doc="See `GetSize`")
|
|
Width = property(GetWidth,doc="See `GetWidth`")
|
|
_gdi_.PixelDataBase_swigregister(PixelDataBase)
|
|
|
|
class NativePixelData(PixelDataBase):
|
|
"""Proxy of C++ NativePixelData 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):
|
|
"""
|
|
__init__(self, Bitmap bmp) -> NativePixelData
|
|
__init__(self, Bitmap bmp, Rect rect) -> NativePixelData
|
|
__init__(self, Bitmap bmp, Point pt, Size sz) -> NativePixelData
|
|
"""
|
|
_gdi_.NativePixelData_swiginit(self,_gdi_.new_NativePixelData(*args))
|
|
__swig_destroy__ = _gdi_.delete_NativePixelData
|
|
__del__ = lambda self : None;
|
|
def GetPixels(*args, **kwargs):
|
|
"""GetPixels(self) -> NativePixelData_Accessor"""
|
|
return _gdi_.NativePixelData_GetPixels(*args, **kwargs)
|
|
|
|
def UseAlpha(*args, **kwargs):
|
|
"""UseAlpha(self)"""
|
|
return _gdi_.NativePixelData_UseAlpha(*args, **kwargs)
|
|
|
|
def __nonzero__(*args, **kwargs):
|
|
"""__nonzero__(self) -> bool"""
|
|
return _gdi_.NativePixelData___nonzero__(*args, **kwargs)
|
|
|
|
def __iter__(self):
|
|
"""
|
|
Create and return an iterator object for this pixel data
|
|
object. (It's really a generator but I won't tell if you
|
|
don't tell.)
|
|
"""
|
|
width = self.GetWidth()
|
|
height = self.GetHeight()
|
|
pixels = self.GetPixels()
|
|
|
|
|
|
|
|
|
|
class PixelFacade(object):
|
|
def Get(self):
|
|
return pixels.Get()
|
|
def Set(self, *args, **kw):
|
|
return pixels.Set(*args, **kw)
|
|
def __str__(self):
|
|
return str(self.Get())
|
|
def __repr__(self):
|
|
return 'pixel(%d,%d): %s' % (x,y,self.Get())
|
|
X = property(lambda self: x)
|
|
Y = property(lambda self: y)
|
|
|
|
pf = PixelFacade()
|
|
for y in xrange(height):
|
|
for x in xrange(width):
|
|
|
|
|
|
|
|
yield pf
|
|
pixels.nextPixel()
|
|
pixels.MoveTo(self, 0, y)
|
|
|
|
Pixels = property(GetPixels,doc="See `GetPixels`")
|
|
_gdi_.NativePixelData_swigregister(NativePixelData)
|
|
|
|
class NativePixelData_Accessor(object):
|
|
"""Proxy of C++ NativePixelData_Accessor 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):
|
|
"""
|
|
__init__(self, NativePixelData data) -> NativePixelData_Accessor
|
|
__init__(self, Bitmap bmp, NativePixelData data) -> NativePixelData_Accessor
|
|
__init__(self) -> NativePixelData_Accessor
|
|
"""
|
|
_gdi_.NativePixelData_Accessor_swiginit(self,_gdi_.new_NativePixelData_Accessor(*args))
|
|
__swig_destroy__ = _gdi_.delete_NativePixelData_Accessor
|
|
__del__ = lambda self : None;
|
|
def Reset(*args, **kwargs):
|
|
"""Reset(self, NativePixelData data)"""
|
|
return _gdi_.NativePixelData_Accessor_Reset(*args, **kwargs)
|
|
|
|
def IsOk(*args, **kwargs):
|
|
"""IsOk(self) -> bool"""
|
|
return _gdi_.NativePixelData_Accessor_IsOk(*args, **kwargs)
|
|
|
|
def nextPixel(*args, **kwargs):
|
|
"""nextPixel(self)"""
|
|
return _gdi_.NativePixelData_Accessor_nextPixel(*args, **kwargs)
|
|
|
|
def Offset(*args, **kwargs):
|
|
"""Offset(self, NativePixelData data, int x, int y)"""
|
|
return _gdi_.NativePixelData_Accessor_Offset(*args, **kwargs)
|
|
|
|
def OffsetX(*args, **kwargs):
|
|
"""OffsetX(self, NativePixelData data, int x)"""
|
|
return _gdi_.NativePixelData_Accessor_OffsetX(*args, **kwargs)
|
|
|
|
def OffsetY(*args, **kwargs):
|
|
"""OffsetY(self, NativePixelData data, int y)"""
|
|
return _gdi_.NativePixelData_Accessor_OffsetY(*args, **kwargs)
|
|
|
|
def MoveTo(*args, **kwargs):
|
|
"""MoveTo(self, NativePixelData data, int x, int y)"""
|
|
return _gdi_.NativePixelData_Accessor_MoveTo(*args, **kwargs)
|
|
|
|
def Set(*args, **kwargs):
|
|
"""Set(self, byte red, byte green, byte blue)"""
|
|
return _gdi_.NativePixelData_Accessor_Set(*args, **kwargs)
|
|
|
|
def Get(*args, **kwargs):
|
|
"""Get(self) -> PyObject"""
|
|
return _gdi_.NativePixelData_Accessor_Get(*args, **kwargs)
|
|
|
|
_gdi_.NativePixelData_Accessor_swigregister(NativePixelData_Accessor)
|
|
|
|
class AlphaPixelData(PixelDataBase):
|
|
"""Proxy of C++ AlphaPixelData 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):
|
|
"""
|
|
__init__(self, Bitmap bmp) -> AlphaPixelData
|
|
__init__(self, Bitmap bmp, Rect rect) -> AlphaPixelData
|
|
__init__(self, Bitmap bmp, Point pt, Size sz) -> AlphaPixelData
|
|
"""
|
|
_gdi_.AlphaPixelData_swiginit(self,_gdi_.new_AlphaPixelData(*args))
|
|
self.UseAlpha()
|
|
|
|
__swig_destroy__ = _gdi_.delete_AlphaPixelData
|
|
__del__ = lambda self : None;
|
|
def GetPixels(*args, **kwargs):
|
|
"""GetPixels(self) -> AlphaPixelData_Accessor"""
|
|
return _gdi_.AlphaPixelData_GetPixels(*args, **kwargs)
|
|
|
|
def UseAlpha(*args, **kwargs):
|
|
"""UseAlpha(self)"""
|
|
return _gdi_.AlphaPixelData_UseAlpha(*args, **kwargs)
|
|
|
|
def __nonzero__(*args, **kwargs):
|
|
"""__nonzero__(self) -> bool"""
|
|
return _gdi_.AlphaPixelData___nonzero__(*args, **kwargs)
|
|
|
|
def __iter__(self):
|
|
"""
|
|
Create and return an iterator object for this pixel data
|
|
object. (It's really a generator but I won't tell if you
|
|
don't tell.)
|
|
"""
|
|
width = self.GetWidth()
|
|
height = self.GetHeight()
|
|
pixels = self.GetPixels()
|
|
|
|
|
|
|
|
|
|
class PixelFacade(object):
|
|
def Get(self):
|
|
return pixels.Get()
|
|
def Set(self, *args, **kw):
|
|
return pixels.Set(*args, **kw)
|
|
def __str__(self):
|
|
return str(self.Get())
|
|
def __repr__(self):
|
|
return 'pixel(%d,%d): %s' % (x,y,self.Get())
|
|
X = property(lambda self: x)
|
|
Y = property(lambda self: y)
|
|
|
|
pf = PixelFacade()
|
|
for y in xrange(height):
|
|
for x in xrange(width):
|
|
|
|
|
|
|
|
yield pf
|
|
pixels.nextPixel()
|
|
pixels.MoveTo(self, 0, y)
|
|
|
|
Pixels = property(GetPixels,doc="See `GetPixels`")
|
|
_gdi_.AlphaPixelData_swigregister(AlphaPixelData)
|
|
|
|
class AlphaPixelData_Accessor(object):
|
|
"""Proxy of C++ AlphaPixelData_Accessor 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):
|
|
"""
|
|
__init__(self, AlphaPixelData data) -> AlphaPixelData_Accessor
|
|
__init__(self, Bitmap bmp, AlphaPixelData data) -> AlphaPixelData_Accessor
|
|
__init__(self) -> AlphaPixelData_Accessor
|
|
"""
|
|
_gdi_.AlphaPixelData_Accessor_swiginit(self,_gdi_.new_AlphaPixelData_Accessor(*args))
|
|
__swig_destroy__ = _gdi_.delete_AlphaPixelData_Accessor
|
|
__del__ = lambda self : None;
|
|
def Reset(*args, **kwargs):
|
|
"""Reset(self, AlphaPixelData data)"""
|
|
return _gdi_.AlphaPixelData_Accessor_Reset(*args, **kwargs)
|
|
|
|
def IsOk(*args, **kwargs):
|
|
"""IsOk(self) -> bool"""
|
|
return _gdi_.AlphaPixelData_Accessor_IsOk(*args, **kwargs)
|
|
|
|
def nextPixel(*args, **kwargs):
|
|
"""nextPixel(self)"""
|
|
return _gdi_.AlphaPixelData_Accessor_nextPixel(*args, **kwargs)
|
|
|
|
def Offset(*args, **kwargs):
|
|
"""Offset(self, AlphaPixelData data, int x, int y)"""
|
|
return _gdi_.AlphaPixelData_Accessor_Offset(*args, **kwargs)
|
|
|
|
def OffsetX(*args, **kwargs):
|
|
"""OffsetX(self, AlphaPixelData data, int x)"""
|
|
return _gdi_.AlphaPixelData_Accessor_OffsetX(*args, **kwargs)
|
|
|
|
def OffsetY(*args, **kwargs):
|
|
"""OffsetY(self, AlphaPixelData data, int y)"""
|
|
return _gdi_.AlphaPixelData_Accessor_OffsetY(*args, **kwargs)
|
|
|
|
def MoveTo(*args, **kwargs):
|
|
"""MoveTo(self, AlphaPixelData data, int x, int y)"""
|
|
return _gdi_.AlphaPixelData_Accessor_MoveTo(*args, **kwargs)
|
|
|
|
def Set(*args, **kwargs):
|
|
"""Set(self, byte red, byte green, byte blue, byte alpha)"""
|
|
return _gdi_.AlphaPixelData_Accessor_Set(*args, **kwargs)
|
|
|
|
def Get(*args, **kwargs):
|
|
"""Get(self) -> PyObject"""
|
|
return _gdi_.AlphaPixelData_Accessor_Get(*args, **kwargs)
|
|
|
|
_gdi_.AlphaPixelData_Accessor_swigregister(AlphaPixelData_Accessor)
|
|
|
|
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.
|
|
|
|
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.
|
|
"""
|
|
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 `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.
|
|
|
|
:see: `wx.Bitmap`, `wx.Colour`
|
|
"""
|
|
_gdi_.Mask_swiginit(self,_gdi_.new_Mask(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_Mask
|
|
__del__ = lambda self : None;
|
|
_gdi_.Mask_swigregister(Mask)
|
|
|
|
MaskColour = wx._deprecated(Mask, "wx.MaskColour is deprecated, use `wx.Mask` instead.")
|
|
class Icon(GDIObject):
|
|
"""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"""
|
|
_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)
|
|
|
|
def IsOk(*args, **kwargs):
|
|
"""IsOk(self) -> bool"""
|
|
return _gdi_.Icon_IsOk(*args, **kwargs)
|
|
|
|
Ok = IsOk
|
|
def GetWidth(*args, **kwargs):
|
|
"""GetWidth(self) -> int"""
|
|
return _gdi_.Icon_GetWidth(*args, **kwargs)
|
|
|
|
def GetHeight(*args, **kwargs):
|
|
"""GetHeight(self) -> int"""
|
|
return _gdi_.Icon_GetHeight(*args, **kwargs)
|
|
|
|
def GetDepth(*args, **kwargs):
|
|
"""GetDepth(self) -> int"""
|
|
return _gdi_.Icon_GetDepth(*args, **kwargs)
|
|
|
|
def SetWidth(*args, **kwargs):
|
|
"""SetWidth(self, int w)"""
|
|
return _gdi_.Icon_SetWidth(*args, **kwargs)
|
|
|
|
def SetHeight(*args, **kwargs):
|
|
"""SetHeight(self, int h)"""
|
|
return _gdi_.Icon_SetHeight(*args, **kwargs)
|
|
|
|
def SetDepth(*args, **kwargs):
|
|
"""SetDepth(self, int d)"""
|
|
return _gdi_.Icon_SetDepth(*args, **kwargs)
|
|
|
|
def CopyFromBitmap(*args, **kwargs):
|
|
"""CopyFromBitmap(self, Bitmap bmp)"""
|
|
return _gdi_.Icon_CopyFromBitmap(*args, **kwargs)
|
|
|
|
def __nonzero__(self): return self.IsOk()
|
|
Depth = property(GetDepth,SetDepth,doc="See `GetDepth` and `SetDepth`")
|
|
Height = property(GetHeight,SetHeight,doc="See `GetHeight` and `SetHeight`")
|
|
Width = property(GetWidth,SetWidth,doc="See `GetWidth` and `SetWidth`")
|
|
_gdi_.Icon_swigregister(Icon)
|
|
|
|
def EmptyIcon(*args, **kwargs):
|
|
"""EmptyIcon() -> Icon"""
|
|
val = _gdi_.new_EmptyIcon(*args, **kwargs)
|
|
return val
|
|
|
|
def IconFromLocation(*args, **kwargs):
|
|
"""IconFromLocation(IconLocation loc) -> Icon"""
|
|
val = _gdi_.new_IconFromLocation(*args, **kwargs)
|
|
return val
|
|
|
|
def IconFromBitmap(*args, **kwargs):
|
|
"""IconFromBitmap(Bitmap bmp) -> Icon"""
|
|
val = _gdi_.new_IconFromBitmap(*args, **kwargs)
|
|
return val
|
|
|
|
def IconFromXPMData(*args, **kwargs):
|
|
"""IconFromXPMData(PyObject listOfStrings) -> Icon"""
|
|
val = _gdi_.new_IconFromXPMData(*args, **kwargs)
|
|
return val
|
|
|
|
class IconLocation(object):
|
|
"""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"""
|
|
_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)
|
|
|
|
def __nonzero__(self): return self.IsOk()
|
|
def SetFileName(*args, **kwargs):
|
|
"""SetFileName(self, String filename)"""
|
|
return _gdi_.IconLocation_SetFileName(*args, **kwargs)
|
|
|
|
def GetFileName(*args, **kwargs):
|
|
"""GetFileName(self) -> String"""
|
|
return _gdi_.IconLocation_GetFileName(*args, **kwargs)
|
|
|
|
def SetIndex(*args, **kwargs):
|
|
"""SetIndex(self, int num)"""
|
|
return _gdi_.IconLocation_SetIndex(*args, **kwargs)
|
|
|
|
def GetIndex(*args, **kwargs):
|
|
"""GetIndex(self) -> int"""
|
|
return _gdi_.IconLocation_GetIndex(*args, **kwargs)
|
|
|
|
FileName = property(GetFileName,SetFileName,doc="See `GetFileName` and `SetFileName`")
|
|
Index = property(GetIndex,SetIndex,doc="See `GetIndex` and `SetIndex`")
|
|
_gdi_.IconLocation_swigregister(IconLocation)
|
|
|
|
class IconBundle(object):
|
|
"""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"""
|
|
_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)
|
|
|
|
def AddIconFromFile(*args, **kwargs):
|
|
"""AddIconFromFile(self, String file, long type)"""
|
|
return _gdi_.IconBundle_AddIconFromFile(*args, **kwargs)
|
|
|
|
def GetIcon(*args, **kwargs):
|
|
"""GetIcon(self, Size size) -> Icon"""
|
|
return _gdi_.IconBundle_GetIcon(*args, **kwargs)
|
|
|
|
Icon = property(GetIcon,doc="See `GetIcon`")
|
|
_gdi_.IconBundle_swigregister(IconBundle)
|
|
|
|
def IconBundleFromFile(*args, **kwargs):
|
|
"""IconBundleFromFile(String file, long type) -> IconBundle"""
|
|
val = _gdi_.new_IconBundleFromFile(*args, **kwargs)
|
|
return val
|
|
|
|
def IconBundleFromIcon(*args, **kwargs):
|
|
"""IconBundleFromIcon(Icon icon) -> IconBundle"""
|
|
val = _gdi_.new_IconBundleFromIcon(*args, **kwargs)
|
|
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 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.
|
|
|
|
"""
|
|
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.
|
|
"""
|
|
_gdi_.Cursor_swiginit(self,_gdi_.new_Cursor(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_Cursor
|
|
__del__ = lambda self : None;
|
|
def IsOk(*args, **kwargs):
|
|
"""IsOk(self) -> bool"""
|
|
return _gdi_.Cursor_IsOk(*args, **kwargs)
|
|
|
|
Ok = IsOk
|
|
def __nonzero__(self): return self.IsOk()
|
|
_gdi_.Cursor_swigregister(Cursor)
|
|
|
|
def StockCursor(*args, **kwargs):
|
|
"""
|
|
StockCursor(int id) -> Cursor
|
|
|
|
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)
|
|
return val
|
|
|
|
def CursorFromImage(*args, **kwargs):
|
|
"""
|
|
CursorFromImage(Image image) -> Cursor
|
|
|
|
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)
|
|
return val
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
OutRegion = _gdi_.OutRegion
|
|
PartRegion = _gdi_.PartRegion
|
|
InRegion = _gdi_.InRegion
|
|
class Region(GDIObject):
|
|
"""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"""
|
|
_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)
|
|
|
|
def Offset(*args, **kwargs):
|
|
"""Offset(self, int x, int y) -> bool"""
|
|
return _gdi_.Region_Offset(*args, **kwargs)
|
|
|
|
def Contains(*args, **kwargs):
|
|
"""Contains(self, int x, int y) -> int"""
|
|
return _gdi_.Region_Contains(*args, **kwargs)
|
|
|
|
def ContainsPoint(*args, **kwargs):
|
|
"""ContainsPoint(self, Point pt) -> int"""
|
|
return _gdi_.Region_ContainsPoint(*args, **kwargs)
|
|
|
|
def ContainsRect(*args, **kwargs):
|
|
"""ContainsRect(self, Rect rect) -> int"""
|
|
return _gdi_.Region_ContainsRect(*args, **kwargs)
|
|
|
|
def ContainsRectDim(*args, **kwargs):
|
|
"""ContainsRectDim(self, int x, int y, int w, int h) -> int"""
|
|
return _gdi_.Region_ContainsRectDim(*args, **kwargs)
|
|
|
|
def GetBox(*args, **kwargs):
|
|
"""GetBox(self) -> Rect"""
|
|
return _gdi_.Region_GetBox(*args, **kwargs)
|
|
|
|
def Intersect(*args, **kwargs):
|
|
"""Intersect(self, int x, int y, int width, int height) -> bool"""
|
|
return _gdi_.Region_Intersect(*args, **kwargs)
|
|
|
|
def IntersectRect(*args, **kwargs):
|
|
"""IntersectRect(self, Rect rect) -> bool"""
|
|
return _gdi_.Region_IntersectRect(*args, **kwargs)
|
|
|
|
def IntersectRegion(*args, **kwargs):
|
|
"""IntersectRegion(self, Region region) -> bool"""
|
|
return _gdi_.Region_IntersectRegion(*args, **kwargs)
|
|
|
|
def IsEmpty(*args, **kwargs):
|
|
"""IsEmpty(self) -> bool"""
|
|
return _gdi_.Region_IsEmpty(*args, **kwargs)
|
|
|
|
def IsEqual(*args, **kwargs):
|
|
"""IsEqual(self, Region region) -> bool"""
|
|
return _gdi_.Region_IsEqual(*args, **kwargs)
|
|
|
|
def Union(*args, **kwargs):
|
|
"""Union(self, int x, int y, int width, int height) -> bool"""
|
|
return _gdi_.Region_Union(*args, **kwargs)
|
|
|
|
def UnionRect(*args, **kwargs):
|
|
"""UnionRect(self, Rect rect) -> bool"""
|
|
return _gdi_.Region_UnionRect(*args, **kwargs)
|
|
|
|
def UnionRegion(*args, **kwargs):
|
|
"""UnionRegion(self, Region region) -> bool"""
|
|
return _gdi_.Region_UnionRegion(*args, **kwargs)
|
|
|
|
def Subtract(*args, **kwargs):
|
|
"""Subtract(self, int x, int y, int width, int height) -> bool"""
|
|
return _gdi_.Region_Subtract(*args, **kwargs)
|
|
|
|
def SubtractRect(*args, **kwargs):
|
|
"""SubtractRect(self, Rect rect) -> bool"""
|
|
return _gdi_.Region_SubtractRect(*args, **kwargs)
|
|
|
|
def SubtractRegion(*args, **kwargs):
|
|
"""SubtractRegion(self, Region region) -> bool"""
|
|
return _gdi_.Region_SubtractRegion(*args, **kwargs)
|
|
|
|
def Xor(*args, **kwargs):
|
|
"""Xor(self, int x, int y, int width, int height) -> bool"""
|
|
return _gdi_.Region_Xor(*args, **kwargs)
|
|
|
|
def XorRect(*args, **kwargs):
|
|
"""XorRect(self, Rect rect) -> bool"""
|
|
return _gdi_.Region_XorRect(*args, **kwargs)
|
|
|
|
def XorRegion(*args, **kwargs):
|
|
"""XorRegion(self, Region region) -> bool"""
|
|
return _gdi_.Region_XorRegion(*args, **kwargs)
|
|
|
|
def ConvertToBitmap(*args, **kwargs):
|
|
"""ConvertToBitmap(self) -> Bitmap"""
|
|
return _gdi_.Region_ConvertToBitmap(*args, **kwargs)
|
|
|
|
def UnionBitmap(*args, **kwargs):
|
|
"""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)
|
|
|
|
Box = property(GetBox,doc="See `GetBox`")
|
|
_gdi_.Region_swigregister(Region)
|
|
|
|
def RegionFromBitmap(*args, **kwargs):
|
|
"""RegionFromBitmap(Bitmap bmp) -> Region"""
|
|
val = _gdi_.new_RegionFromBitmap(*args, **kwargs)
|
|
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, int fillStyle=WINDING_RULE) -> Region"""
|
|
val = _gdi_.new_RegionFromPoints(*args, **kwargs)
|
|
return val
|
|
|
|
class RegionIterator(_core.Object):
|
|
"""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"""
|
|
_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)
|
|
|
|
def GetY(*args, **kwargs):
|
|
"""GetY(self) -> int"""
|
|
return _gdi_.RegionIterator_GetY(*args, **kwargs)
|
|
|
|
def GetW(*args, **kwargs):
|
|
"""GetW(self) -> int"""
|
|
return _gdi_.RegionIterator_GetW(*args, **kwargs)
|
|
|
|
def GetWidth(*args, **kwargs):
|
|
"""GetWidth(self) -> int"""
|
|
return _gdi_.RegionIterator_GetWidth(*args, **kwargs)
|
|
|
|
def GetH(*args, **kwargs):
|
|
"""GetH(self) -> int"""
|
|
return _gdi_.RegionIterator_GetH(*args, **kwargs)
|
|
|
|
def GetHeight(*args, **kwargs):
|
|
"""GetHeight(self) -> int"""
|
|
return _gdi_.RegionIterator_GetHeight(*args, **kwargs)
|
|
|
|
def GetRect(*args, **kwargs):
|
|
"""GetRect(self) -> Rect"""
|
|
return _gdi_.RegionIterator_GetRect(*args, **kwargs)
|
|
|
|
def HaveRects(*args, **kwargs):
|
|
"""HaveRects(self) -> bool"""
|
|
return _gdi_.RegionIterator_HaveRects(*args, **kwargs)
|
|
|
|
def Reset(*args, **kwargs):
|
|
"""Reset(self)"""
|
|
return _gdi_.RegionIterator_Reset(*args, **kwargs)
|
|
|
|
def Next(*args, **kwargs):
|
|
"""Next(self)"""
|
|
return _gdi_.RegionIterator_Next(*args, **kwargs)
|
|
|
|
def __nonzero__(*args, **kwargs):
|
|
"""__nonzero__(self) -> bool"""
|
|
return _gdi_.RegionIterator___nonzero__(*args, **kwargs)
|
|
|
|
H = property(GetH,doc="See `GetH`")
|
|
Height = property(GetHeight,doc="See `GetHeight`")
|
|
Rect = property(GetRect,doc="See `GetRect`")
|
|
W = property(GetW,doc="See `GetW`")
|
|
Width = property(GetWidth,doc="See `GetWidth`")
|
|
X = property(GetX,doc="See `GetX`")
|
|
Y = property(GetY,doc="See `GetY`")
|
|
_gdi_.RegionIterator_swigregister(RegionIterator)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
FONTFAMILY_DEFAULT = _gdi_.FONTFAMILY_DEFAULT
|
|
FONTFAMILY_DECORATIVE = _gdi_.FONTFAMILY_DECORATIVE
|
|
FONTFAMILY_ROMAN = _gdi_.FONTFAMILY_ROMAN
|
|
FONTFAMILY_SCRIPT = _gdi_.FONTFAMILY_SCRIPT
|
|
FONTFAMILY_SWISS = _gdi_.FONTFAMILY_SWISS
|
|
FONTFAMILY_MODERN = _gdi_.FONTFAMILY_MODERN
|
|
FONTFAMILY_TELETYPE = _gdi_.FONTFAMILY_TELETYPE
|
|
FONTFAMILY_MAX = _gdi_.FONTFAMILY_MAX
|
|
FONTFAMILY_UNKNOWN = _gdi_.FONTFAMILY_UNKNOWN
|
|
FONTSTYLE_NORMAL = _gdi_.FONTSTYLE_NORMAL
|
|
FONTSTYLE_ITALIC = _gdi_.FONTSTYLE_ITALIC
|
|
FONTSTYLE_SLANT = _gdi_.FONTSTYLE_SLANT
|
|
FONTSTYLE_MAX = _gdi_.FONTSTYLE_MAX
|
|
FONTWEIGHT_NORMAL = _gdi_.FONTWEIGHT_NORMAL
|
|
FONTWEIGHT_LIGHT = _gdi_.FONTWEIGHT_LIGHT
|
|
FONTWEIGHT_BOLD = _gdi_.FONTWEIGHT_BOLD
|
|
FONTWEIGHT_MAX = _gdi_.FONTWEIGHT_MAX
|
|
FONTFLAG_DEFAULT = _gdi_.FONTFLAG_DEFAULT
|
|
FONTFLAG_ITALIC = _gdi_.FONTFLAG_ITALIC
|
|
FONTFLAG_SLANT = _gdi_.FONTFLAG_SLANT
|
|
FONTFLAG_LIGHT = _gdi_.FONTFLAG_LIGHT
|
|
FONTFLAG_BOLD = _gdi_.FONTFLAG_BOLD
|
|
FONTFLAG_ANTIALIASED = _gdi_.FONTFLAG_ANTIALIASED
|
|
FONTFLAG_NOT_ANTIALIASED = _gdi_.FONTFLAG_NOT_ANTIALIASED
|
|
FONTFLAG_UNDERLINED = _gdi_.FONTFLAG_UNDERLINED
|
|
FONTFLAG_STRIKETHROUGH = _gdi_.FONTFLAG_STRIKETHROUGH
|
|
FONTFLAG_MASK = _gdi_.FONTFLAG_MASK
|
|
FONTENCODING_SYSTEM = _gdi_.FONTENCODING_SYSTEM
|
|
FONTENCODING_DEFAULT = _gdi_.FONTENCODING_DEFAULT
|
|
FONTENCODING_ISO8859_1 = _gdi_.FONTENCODING_ISO8859_1
|
|
FONTENCODING_ISO8859_2 = _gdi_.FONTENCODING_ISO8859_2
|
|
FONTENCODING_ISO8859_3 = _gdi_.FONTENCODING_ISO8859_3
|
|
FONTENCODING_ISO8859_4 = _gdi_.FONTENCODING_ISO8859_4
|
|
FONTENCODING_ISO8859_5 = _gdi_.FONTENCODING_ISO8859_5
|
|
FONTENCODING_ISO8859_6 = _gdi_.FONTENCODING_ISO8859_6
|
|
FONTENCODING_ISO8859_7 = _gdi_.FONTENCODING_ISO8859_7
|
|
FONTENCODING_ISO8859_8 = _gdi_.FONTENCODING_ISO8859_8
|
|
FONTENCODING_ISO8859_9 = _gdi_.FONTENCODING_ISO8859_9
|
|
FONTENCODING_ISO8859_10 = _gdi_.FONTENCODING_ISO8859_10
|
|
FONTENCODING_ISO8859_11 = _gdi_.FONTENCODING_ISO8859_11
|
|
FONTENCODING_ISO8859_12 = _gdi_.FONTENCODING_ISO8859_12
|
|
FONTENCODING_ISO8859_13 = _gdi_.FONTENCODING_ISO8859_13
|
|
FONTENCODING_ISO8859_14 = _gdi_.FONTENCODING_ISO8859_14
|
|
FONTENCODING_ISO8859_15 = _gdi_.FONTENCODING_ISO8859_15
|
|
FONTENCODING_ISO8859_MAX = _gdi_.FONTENCODING_ISO8859_MAX
|
|
FONTENCODING_KOI8 = _gdi_.FONTENCODING_KOI8
|
|
FONTENCODING_KOI8_U = _gdi_.FONTENCODING_KOI8_U
|
|
FONTENCODING_ALTERNATIVE = _gdi_.FONTENCODING_ALTERNATIVE
|
|
FONTENCODING_BULGARIAN = _gdi_.FONTENCODING_BULGARIAN
|
|
FONTENCODING_CP437 = _gdi_.FONTENCODING_CP437
|
|
FONTENCODING_CP850 = _gdi_.FONTENCODING_CP850
|
|
FONTENCODING_CP852 = _gdi_.FONTENCODING_CP852
|
|
FONTENCODING_CP855 = _gdi_.FONTENCODING_CP855
|
|
FONTENCODING_CP866 = _gdi_.FONTENCODING_CP866
|
|
FONTENCODING_CP874 = _gdi_.FONTENCODING_CP874
|
|
FONTENCODING_CP932 = _gdi_.FONTENCODING_CP932
|
|
FONTENCODING_CP936 = _gdi_.FONTENCODING_CP936
|
|
FONTENCODING_CP949 = _gdi_.FONTENCODING_CP949
|
|
FONTENCODING_CP950 = _gdi_.FONTENCODING_CP950
|
|
FONTENCODING_CP1250 = _gdi_.FONTENCODING_CP1250
|
|
FONTENCODING_CP1251 = _gdi_.FONTENCODING_CP1251
|
|
FONTENCODING_CP1252 = _gdi_.FONTENCODING_CP1252
|
|
FONTENCODING_CP1253 = _gdi_.FONTENCODING_CP1253
|
|
FONTENCODING_CP1254 = _gdi_.FONTENCODING_CP1254
|
|
FONTENCODING_CP1255 = _gdi_.FONTENCODING_CP1255
|
|
FONTENCODING_CP1256 = _gdi_.FONTENCODING_CP1256
|
|
FONTENCODING_CP1257 = _gdi_.FONTENCODING_CP1257
|
|
FONTENCODING_CP12_MAX = _gdi_.FONTENCODING_CP12_MAX
|
|
FONTENCODING_UTF7 = _gdi_.FONTENCODING_UTF7
|
|
FONTENCODING_UTF8 = _gdi_.FONTENCODING_UTF8
|
|
FONTENCODING_EUC_JP = _gdi_.FONTENCODING_EUC_JP
|
|
FONTENCODING_UTF16BE = _gdi_.FONTENCODING_UTF16BE
|
|
FONTENCODING_UTF16LE = _gdi_.FONTENCODING_UTF16LE
|
|
FONTENCODING_UTF32BE = _gdi_.FONTENCODING_UTF32BE
|
|
FONTENCODING_UTF32LE = _gdi_.FONTENCODING_UTF32LE
|
|
FONTENCODING_MACROMAN = _gdi_.FONTENCODING_MACROMAN
|
|
FONTENCODING_MACJAPANESE = _gdi_.FONTENCODING_MACJAPANESE
|
|
FONTENCODING_MACCHINESETRAD = _gdi_.FONTENCODING_MACCHINESETRAD
|
|
FONTENCODING_MACKOREAN = _gdi_.FONTENCODING_MACKOREAN
|
|
FONTENCODING_MACARABIC = _gdi_.FONTENCODING_MACARABIC
|
|
FONTENCODING_MACHEBREW = _gdi_.FONTENCODING_MACHEBREW
|
|
FONTENCODING_MACGREEK = _gdi_.FONTENCODING_MACGREEK
|
|
FONTENCODING_MACCYRILLIC = _gdi_.FONTENCODING_MACCYRILLIC
|
|
FONTENCODING_MACDEVANAGARI = _gdi_.FONTENCODING_MACDEVANAGARI
|
|
FONTENCODING_MACGURMUKHI = _gdi_.FONTENCODING_MACGURMUKHI
|
|
FONTENCODING_MACGUJARATI = _gdi_.FONTENCODING_MACGUJARATI
|
|
FONTENCODING_MACORIYA = _gdi_.FONTENCODING_MACORIYA
|
|
FONTENCODING_MACBENGALI = _gdi_.FONTENCODING_MACBENGALI
|
|
FONTENCODING_MACTAMIL = _gdi_.FONTENCODING_MACTAMIL
|
|
FONTENCODING_MACTELUGU = _gdi_.FONTENCODING_MACTELUGU
|
|
FONTENCODING_MACKANNADA = _gdi_.FONTENCODING_MACKANNADA
|
|
FONTENCODING_MACMALAJALAM = _gdi_.FONTENCODING_MACMALAJALAM
|
|
FONTENCODING_MACSINHALESE = _gdi_.FONTENCODING_MACSINHALESE
|
|
FONTENCODING_MACBURMESE = _gdi_.FONTENCODING_MACBURMESE
|
|
FONTENCODING_MACKHMER = _gdi_.FONTENCODING_MACKHMER
|
|
FONTENCODING_MACTHAI = _gdi_.FONTENCODING_MACTHAI
|
|
FONTENCODING_MACLAOTIAN = _gdi_.FONTENCODING_MACLAOTIAN
|
|
FONTENCODING_MACGEORGIAN = _gdi_.FONTENCODING_MACGEORGIAN
|
|
FONTENCODING_MACARMENIAN = _gdi_.FONTENCODING_MACARMENIAN
|
|
FONTENCODING_MACCHINESESIMP = _gdi_.FONTENCODING_MACCHINESESIMP
|
|
FONTENCODING_MACTIBETAN = _gdi_.FONTENCODING_MACTIBETAN
|
|
FONTENCODING_MACMONGOLIAN = _gdi_.FONTENCODING_MACMONGOLIAN
|
|
FONTENCODING_MACETHIOPIC = _gdi_.FONTENCODING_MACETHIOPIC
|
|
FONTENCODING_MACCENTRALEUR = _gdi_.FONTENCODING_MACCENTRALEUR
|
|
FONTENCODING_MACVIATNAMESE = _gdi_.FONTENCODING_MACVIATNAMESE
|
|
FONTENCODING_MACARABICEXT = _gdi_.FONTENCODING_MACARABICEXT
|
|
FONTENCODING_MACSYMBOL = _gdi_.FONTENCODING_MACSYMBOL
|
|
FONTENCODING_MACDINGBATS = _gdi_.FONTENCODING_MACDINGBATS
|
|
FONTENCODING_MACTURKISH = _gdi_.FONTENCODING_MACTURKISH
|
|
FONTENCODING_MACCROATIAN = _gdi_.FONTENCODING_MACCROATIAN
|
|
FONTENCODING_MACICELANDIC = _gdi_.FONTENCODING_MACICELANDIC
|
|
FONTENCODING_MACROMANIAN = _gdi_.FONTENCODING_MACROMANIAN
|
|
FONTENCODING_MACCELTIC = _gdi_.FONTENCODING_MACCELTIC
|
|
FONTENCODING_MACGAELIC = _gdi_.FONTENCODING_MACGAELIC
|
|
FONTENCODING_MACKEYBOARD = _gdi_.FONTENCODING_MACKEYBOARD
|
|
FONTENCODING_MACMIN = _gdi_.FONTENCODING_MACMIN
|
|
FONTENCODING_MACMAX = _gdi_.FONTENCODING_MACMAX
|
|
FONTENCODING_MAX = _gdi_.FONTENCODING_MAX
|
|
FONTENCODING_UTF16 = _gdi_.FONTENCODING_UTF16
|
|
FONTENCODING_UTF32 = _gdi_.FONTENCODING_UTF32
|
|
FONTENCODING_UNICODE = _gdi_.FONTENCODING_UNICODE
|
|
FONTENCODING_GB2312 = _gdi_.FONTENCODING_GB2312
|
|
FONTENCODING_BIG5 = _gdi_.FONTENCODING_BIG5
|
|
FONTENCODING_SHIFT_JIS = _gdi_.FONTENCODING_SHIFT_JIS
|
|
#---------------------------------------------------------------------------
|
|
|
|
class NativeFontInfo(object):
|
|
"""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"""
|
|
_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)
|
|
|
|
def InitFromFont(*args, **kwargs):
|
|
"""InitFromFont(self, Font font)"""
|
|
return _gdi_.NativeFontInfo_InitFromFont(*args, **kwargs)
|
|
|
|
def GetPointSize(*args, **kwargs):
|
|
"""GetPointSize(self) -> int"""
|
|
return _gdi_.NativeFontInfo_GetPointSize(*args, **kwargs)
|
|
|
|
def GetStyle(*args, **kwargs):
|
|
"""GetStyle(self) -> int"""
|
|
return _gdi_.NativeFontInfo_GetStyle(*args, **kwargs)
|
|
|
|
def GetWeight(*args, **kwargs):
|
|
"""GetWeight(self) -> int"""
|
|
return _gdi_.NativeFontInfo_GetWeight(*args, **kwargs)
|
|
|
|
def GetUnderlined(*args, **kwargs):
|
|
"""GetUnderlined(self) -> bool"""
|
|
return _gdi_.NativeFontInfo_GetUnderlined(*args, **kwargs)
|
|
|
|
def GetFaceName(*args, **kwargs):
|
|
"""GetFaceName(self) -> String"""
|
|
return _gdi_.NativeFontInfo_GetFaceName(*args, **kwargs)
|
|
|
|
def GetFamily(*args, **kwargs):
|
|
"""GetFamily(self) -> int"""
|
|
return _gdi_.NativeFontInfo_GetFamily(*args, **kwargs)
|
|
|
|
def GetEncoding(*args, **kwargs):
|
|
"""GetEncoding(self) -> int"""
|
|
return _gdi_.NativeFontInfo_GetEncoding(*args, **kwargs)
|
|
|
|
def SetPointSize(*args, **kwargs):
|
|
"""SetPointSize(self, int pointsize)"""
|
|
return _gdi_.NativeFontInfo_SetPointSize(*args, **kwargs)
|
|
|
|
def SetStyle(*args, **kwargs):
|
|
"""SetStyle(self, int style)"""
|
|
return _gdi_.NativeFontInfo_SetStyle(*args, **kwargs)
|
|
|
|
def SetWeight(*args, **kwargs):
|
|
"""SetWeight(self, int weight)"""
|
|
return _gdi_.NativeFontInfo_SetWeight(*args, **kwargs)
|
|
|
|
def SetUnderlined(*args, **kwargs):
|
|
"""SetUnderlined(self, bool underlined)"""
|
|
return _gdi_.NativeFontInfo_SetUnderlined(*args, **kwargs)
|
|
|
|
def SetFaceName(*args, **kwargs):
|
|
"""SetFaceName(self, String facename) -> bool"""
|
|
return _gdi_.NativeFontInfo_SetFaceName(*args, **kwargs)
|
|
|
|
def SetFamily(*args, **kwargs):
|
|
"""SetFamily(self, int family)"""
|
|
return _gdi_.NativeFontInfo_SetFamily(*args, **kwargs)
|
|
|
|
def SetEncoding(*args, **kwargs):
|
|
"""SetEncoding(self, int encoding)"""
|
|
return _gdi_.NativeFontInfo_SetEncoding(*args, **kwargs)
|
|
|
|
def FromString(*args, **kwargs):
|
|
"""FromString(self, String s) -> bool"""
|
|
return _gdi_.NativeFontInfo_FromString(*args, **kwargs)
|
|
|
|
def ToString(*args, **kwargs):
|
|
"""ToString(self) -> String"""
|
|
return _gdi_.NativeFontInfo_ToString(*args, **kwargs)
|
|
|
|
def __str__(*args, **kwargs):
|
|
"""__str__(self) -> String"""
|
|
return _gdi_.NativeFontInfo___str__(*args, **kwargs)
|
|
|
|
def FromUserString(*args, **kwargs):
|
|
"""FromUserString(self, String s) -> bool"""
|
|
return _gdi_.NativeFontInfo_FromUserString(*args, **kwargs)
|
|
|
|
def ToUserString(*args, **kwargs):
|
|
"""ToUserString(self) -> String"""
|
|
return _gdi_.NativeFontInfo_ToUserString(*args, **kwargs)
|
|
|
|
Encoding = property(GetEncoding,SetEncoding,doc="See `GetEncoding` and `SetEncoding`")
|
|
FaceName = property(GetFaceName,SetFaceName,doc="See `GetFaceName` and `SetFaceName`")
|
|
Family = property(GetFamily,SetFamily,doc="See `GetFamily` and `SetFamily`")
|
|
PointSize = property(GetPointSize,SetPointSize,doc="See `GetPointSize` and `SetPointSize`")
|
|
Style = property(GetStyle,SetStyle,doc="See `GetStyle` and `SetStyle`")
|
|
Underlined = property(GetUnderlined,SetUnderlined,doc="See `GetUnderlined` and `SetUnderlined`")
|
|
Weight = property(GetWeight,SetWeight,doc="See `GetWeight` and `SetWeight`")
|
|
_gdi_.NativeFontInfo_swigregister(NativeFontInfo)
|
|
|
|
class NativeEncodingInfo(object):
|
|
"""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):
|
|
"""__init__(self) -> NativeEncodingInfo"""
|
|
_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)
|
|
|
|
def ToString(*args, **kwargs):
|
|
"""ToString(self) -> String"""
|
|
return _gdi_.NativeEncodingInfo_ToString(*args, **kwargs)
|
|
|
|
_gdi_.NativeEncodingInfo_swigregister(NativeEncodingInfo)
|
|
|
|
|
|
def 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)
|
|
#---------------------------------------------------------------------------
|
|
|
|
class FontMapper(object):
|
|
"""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"""
|
|
_gdi_.FontMapper_swiginit(self,_gdi_.new_FontMapper(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_FontMapper
|
|
__del__ = lambda self : None;
|
|
def Get(*args, **kwargs):
|
|
"""Get() -> FontMapper"""
|
|
return _gdi_.FontMapper_Get(*args, **kwargs)
|
|
|
|
Get = staticmethod(Get)
|
|
def Set(*args, **kwargs):
|
|
"""Set(FontMapper mapper) -> FontMapper"""
|
|
return _gdi_.FontMapper_Set(*args, **kwargs)
|
|
|
|
Set = staticmethod(Set)
|
|
def CharsetToEncoding(*args, **kwargs):
|
|
"""CharsetToEncoding(self, String charset, bool interactive=True) -> int"""
|
|
return _gdi_.FontMapper_CharsetToEncoding(*args, **kwargs)
|
|
|
|
def GetSupportedEncodingsCount(*args, **kwargs):
|
|
"""GetSupportedEncodingsCount() -> size_t"""
|
|
return _gdi_.FontMapper_GetSupportedEncodingsCount(*args, **kwargs)
|
|
|
|
GetSupportedEncodingsCount = staticmethod(GetSupportedEncodingsCount)
|
|
def GetEncoding(*args, **kwargs):
|
|
"""GetEncoding(size_t n) -> int"""
|
|
return _gdi_.FontMapper_GetEncoding(*args, **kwargs)
|
|
|
|
GetEncoding = staticmethod(GetEncoding)
|
|
def GetEncodingName(*args, **kwargs):
|
|
"""GetEncodingName(int encoding) -> String"""
|
|
return _gdi_.FontMapper_GetEncodingName(*args, **kwargs)
|
|
|
|
GetEncodingName = staticmethod(GetEncodingName)
|
|
def GetEncodingDescription(*args, **kwargs):
|
|
"""GetEncodingDescription(int encoding) -> String"""
|
|
return _gdi_.FontMapper_GetEncodingDescription(*args, **kwargs)
|
|
|
|
GetEncodingDescription = staticmethod(GetEncodingDescription)
|
|
def GetEncodingFromName(*args, **kwargs):
|
|
"""GetEncodingFromName(String name) -> int"""
|
|
return _gdi_.FontMapper_GetEncodingFromName(*args, **kwargs)
|
|
|
|
GetEncodingFromName = staticmethod(GetEncodingFromName)
|
|
def SetConfigPath(*args, **kwargs):
|
|
"""SetConfigPath(self, String prefix)"""
|
|
return _gdi_.FontMapper_SetConfigPath(*args, **kwargs)
|
|
|
|
def GetDefaultConfigPath(*args, **kwargs):
|
|
"""GetDefaultConfigPath() -> String"""
|
|
return _gdi_.FontMapper_GetDefaultConfigPath(*args, **kwargs)
|
|
|
|
GetDefaultConfigPath = staticmethod(GetDefaultConfigPath)
|
|
def GetAltForEncoding(*args, **kwargs):
|
|
"""GetAltForEncoding(self, int encoding, String facename=EmptyString, bool interactive=True) -> PyObject"""
|
|
return _gdi_.FontMapper_GetAltForEncoding(*args, **kwargs)
|
|
|
|
def IsEncodingAvailable(*args, **kwargs):
|
|
"""IsEncodingAvailable(self, int encoding, String facename=EmptyString) -> bool"""
|
|
return _gdi_.FontMapper_IsEncodingAvailable(*args, **kwargs)
|
|
|
|
def SetDialogParent(*args, **kwargs):
|
|
"""SetDialogParent(self, Window parent)"""
|
|
return _gdi_.FontMapper_SetDialogParent(*args, **kwargs)
|
|
|
|
def SetDialogTitle(*args, **kwargs):
|
|
"""SetDialogTitle(self, String title)"""
|
|
return _gdi_.FontMapper_SetDialogTitle(*args, **kwargs)
|
|
|
|
AltForEncoding = property(GetAltForEncoding,doc="See `GetAltForEncoding`")
|
|
_gdi_.FontMapper_swigregister(FontMapper)
|
|
|
|
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)
|
|
|
|
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)
|
|
|
|
def 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)
|
|
|
|
def FontMapper_GetEncodingFromName(*args, **kwargs):
|
|
"""FontMapper_GetEncodingFromName(String name) -> int"""
|
|
return _gdi_.FontMapper_GetEncodingFromName(*args, **kwargs)
|
|
|
|
def FontMapper_GetDefaultConfigPath(*args):
|
|
"""FontMapper_GetDefaultConfigPath() -> String"""
|
|
return _gdi_.FontMapper_GetDefaultConfigPath(*args)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class Font(GDIObject):
|
|
"""
|
|
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
|
|
|
|
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 IsOk(*args, **kwargs):
|
|
"""
|
|
IsOk(self) -> bool
|
|
|
|
Returns ``True`` if this font was successfully created.
|
|
"""
|
|
return _gdi_.Font_IsOk(*args, **kwargs)
|
|
|
|
Ok = IsOk
|
|
def __nonzero__(self): return self.IsOk()
|
|
def __eq__(*args, **kwargs):
|
|
"""__eq__(self, Font other) -> bool"""
|
|
return _gdi_.Font___eq__(*args, **kwargs)
|
|
|
|
def __ne__(*args, **kwargs):
|
|
"""__ne__(self, Font other) -> bool"""
|
|
return _gdi_.Font___ne__(*args, **kwargs)
|
|
|
|
def GetPointSize(*args, **kwargs):
|
|
"""
|
|
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
|
|
|
|
Gets the font family.
|
|
"""
|
|
return _gdi_.Font_GetFamily(*args, **kwargs)
|
|
|
|
def GetStyle(*args, **kwargs):
|
|
"""
|
|
GetStyle(self) -> int
|
|
|
|
Gets the font style.
|
|
"""
|
|
return _gdi_.Font_GetStyle(*args, **kwargs)
|
|
|
|
def GetWeight(*args, **kwargs):
|
|
"""
|
|
GetWeight(self) -> int
|
|
|
|
Gets the font weight.
|
|
"""
|
|
return _gdi_.Font_GetWeight(*args, **kwargs)
|
|
|
|
def GetUnderlined(*args, **kwargs):
|
|
"""
|
|
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
|
|
|
|
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
|
|
|
|
Get the font's encoding.
|
|
"""
|
|
return _gdi_.Font_GetEncoding(*args, **kwargs)
|
|
|
|
def GetNativeFontInfo(*args, **kwargs):
|
|
"""
|
|
GetNativeFontInfo(self) -> NativeFontInfo
|
|
|
|
Constructs a `wx.NativeFontInfo` object from this font.
|
|
"""
|
|
return _gdi_.Font_GetNativeFontInfo(*args, **kwargs)
|
|
|
|
def IsFixedWidth(*args, **kwargs):
|
|
"""
|
|
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
|
|
|
|
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
|
|
|
|
Returns a human readable version of `GetNativeFontInfoDesc`.
|
|
"""
|
|
return _gdi_.Font_GetNativeFontInfoUserDesc(*args, **kwargs)
|
|
|
|
def SetPointSize(*args, **kwargs):
|
|
"""
|
|
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)
|
|
|
|
Sets the font family.
|
|
"""
|
|
return _gdi_.Font_SetFamily(*args, **kwargs)
|
|
|
|
def SetStyle(*args, **kwargs):
|
|
"""
|
|
SetStyle(self, int style)
|
|
|
|
Sets the font style.
|
|
"""
|
|
return _gdi_.Font_SetStyle(*args, **kwargs)
|
|
|
|
def SetWeight(*args, **kwargs):
|
|
"""
|
|
SetWeight(self, int weight)
|
|
|
|
Sets the font weight.
|
|
"""
|
|
return _gdi_.Font_SetWeight(*args, **kwargs)
|
|
|
|
def SetFaceName(*args, **kwargs):
|
|
"""
|
|
SetFaceName(self, String faceName) -> bool
|
|
|
|
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)
|
|
|
|
Sets underlining.
|
|
"""
|
|
return _gdi_.Font_SetUnderlined(*args, **kwargs)
|
|
|
|
def SetEncoding(*args, **kwargs):
|
|
"""
|
|
SetEncoding(self, int encoding)
|
|
|
|
Set the font encoding.
|
|
"""
|
|
return _gdi_.Font_SetEncoding(*args, **kwargs)
|
|
|
|
def SetNativeFontInfo(*args, **kwargs):
|
|
"""
|
|
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) -> bool
|
|
|
|
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) -> bool
|
|
|
|
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
|
|
|
|
Returns a string representation of the font family.
|
|
"""
|
|
return _gdi_.Font_GetFamilyString(*args, **kwargs)
|
|
|
|
def GetStyleString(*args, **kwargs):
|
|
"""
|
|
GetStyleString(self) -> String
|
|
|
|
Returns a string representation of the font style.
|
|
"""
|
|
return _gdi_.Font_GetStyleString(*args, **kwargs)
|
|
|
|
def GetWeightString(*args, **kwargs):
|
|
"""
|
|
GetWeightString(self) -> String
|
|
|
|
Return a string representation of the font weight.
|
|
"""
|
|
return _gdi_.Font_GetWeightString(*args, **kwargs)
|
|
|
|
def SetNoAntiAliasing(*args, **kwargs):
|
|
"""SetNoAntiAliasing(self, bool no=True)"""
|
|
return _gdi_.Font_SetNoAntiAliasing(*args, **kwargs)
|
|
|
|
def GetNoAntiAliasing(*args, **kwargs):
|
|
"""GetNoAntiAliasing(self) -> bool"""
|
|
return _gdi_.Font_GetNoAntiAliasing(*args, **kwargs)
|
|
|
|
def GetDefaultEncoding(*args, **kwargs):
|
|
"""
|
|
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):
|
|
"""
|
|
SetDefaultEncoding(int encoding)
|
|
|
|
Sets the default font encoding.
|
|
"""
|
|
return _gdi_.Font_SetDefaultEncoding(*args, **kwargs)
|
|
|
|
SetDefaultEncoding = staticmethod(SetDefaultEncoding)
|
|
Encoding = property(GetEncoding,SetEncoding,doc="See `GetEncoding` and `SetEncoding`")
|
|
FaceName = property(GetFaceName,SetFaceName,doc="See `GetFaceName` and `SetFaceName`")
|
|
Family = property(GetFamily,SetFamily,doc="See `GetFamily` and `SetFamily`")
|
|
FamilyString = property(GetFamilyString,doc="See `GetFamilyString`")
|
|
NativeFontInfo = property(GetNativeFontInfo,SetNativeFontInfo,doc="See `GetNativeFontInfo` and `SetNativeFontInfo`")
|
|
NativeFontInfoDesc = property(GetNativeFontInfoDesc,doc="See `GetNativeFontInfoDesc`")
|
|
NativeFontInfoUserDesc = property(GetNativeFontInfoUserDesc,SetNativeFontInfoUserDesc,doc="See `GetNativeFontInfoUserDesc` and `SetNativeFontInfoUserDesc`")
|
|
NoAntiAliasing = property(GetNoAntiAliasing,SetNoAntiAliasing,doc="See `GetNoAntiAliasing` and `SetNoAntiAliasing`")
|
|
PixelSize = property(GetPixelSize,SetPixelSize,doc="See `GetPixelSize` and `SetPixelSize`")
|
|
PointSize = property(GetPointSize,SetPointSize,doc="See `GetPointSize` and `SetPointSize`")
|
|
Style = property(GetStyle,SetStyle,doc="See `GetStyle` and `SetStyle`")
|
|
StyleString = property(GetStyleString,doc="See `GetStyleString`")
|
|
Underlined = property(GetUnderlined,SetUnderlined,doc="See `GetUnderlined` and `SetUnderlined`")
|
|
Weight = property(GetWeight,SetWeight,doc="See `GetWeight` and `SetWeight`")
|
|
WeightString = property(GetWeightString,doc="See `GetWeightString`")
|
|
_gdi_.Font_swigregister(Font)
|
|
|
|
def FontFromNativeInfo(*args, **kwargs):
|
|
"""
|
|
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)
|
|
return val
|
|
|
|
def FontFromNativeInfoString(*args, **kwargs):
|
|
"""
|
|
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)
|
|
return val
|
|
|
|
def FFont(*args, **kwargs):
|
|
"""
|
|
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):
|
|
"""
|
|
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):
|
|
"""
|
|
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)
|
|
|
|
Sets the default font encoding.
|
|
"""
|
|
return _gdi_.Font_SetDefaultEncoding(*args, **kwargs)
|
|
|
|
Font2 = wx._deprecated(FFont, "Use `wx.FFont` instead.")
|
|
#---------------------------------------------------------------------------
|
|
|
|
class FontEnumerator(object):
|
|
"""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"""
|
|
_gdi_.FontEnumerator_swiginit(self,_gdi_.new_FontEnumerator(*args, **kwargs))
|
|
FontEnumerator._setCallbackInfo(self, self, FontEnumerator)
|
|
|
|
__swig_destroy__ = _gdi_.delete_FontEnumerator
|
|
__del__ = lambda self : None;
|
|
def _setCallbackInfo(*args, **kwargs):
|
|
"""_setCallbackInfo(self, PyObject self, PyObject _class, int incref=0)"""
|
|
return _gdi_.FontEnumerator__setCallbackInfo(*args, **kwargs)
|
|
|
|
def EnumerateFacenames(*args, **kwargs):
|
|
"""EnumerateFacenames(self, int encoding=FONTENCODING_SYSTEM, bool fixedWidthOnly=False) -> bool"""
|
|
return _gdi_.FontEnumerator_EnumerateFacenames(*args, **kwargs)
|
|
|
|
def EnumerateEncodings(*args, **kwargs):
|
|
"""EnumerateEncodings(self, String facename=EmptyString) -> bool"""
|
|
return _gdi_.FontEnumerator_EnumerateEncodings(*args, **kwargs)
|
|
|
|
def GetEncodings(*args, **kwargs):
|
|
"""GetEncodings() -> PyObject"""
|
|
return _gdi_.FontEnumerator_GetEncodings(*args, **kwargs)
|
|
|
|
GetEncodings = staticmethod(GetEncodings)
|
|
def GetFacenames(*args, **kwargs):
|
|
"""GetFacenames() -> PyObject"""
|
|
return _gdi_.FontEnumerator_GetFacenames(*args, **kwargs)
|
|
|
|
GetFacenames = staticmethod(GetFacenames)
|
|
def IsValidFacename(*args, **kwargs):
|
|
"""
|
|
IsValidFacename(String str) -> bool
|
|
|
|
Convenience function that returns true if the given face name exist in
|
|
the user's system
|
|
"""
|
|
return _gdi_.FontEnumerator_IsValidFacename(*args, **kwargs)
|
|
|
|
IsValidFacename = staticmethod(IsValidFacename)
|
|
_gdi_.FontEnumerator_swigregister(FontEnumerator)
|
|
|
|
def FontEnumerator_GetEncodings(*args):
|
|
"""FontEnumerator_GetEncodings() -> PyObject"""
|
|
return _gdi_.FontEnumerator_GetEncodings(*args)
|
|
|
|
def FontEnumerator_GetFacenames(*args):
|
|
"""FontEnumerator_GetFacenames() -> PyObject"""
|
|
return _gdi_.FontEnumerator_GetFacenames(*args)
|
|
|
|
def FontEnumerator_IsValidFacename(*args, **kwargs):
|
|
"""
|
|
FontEnumerator_IsValidFacename(String str) -> bool
|
|
|
|
Convenience function that returns true if the given face name exist in
|
|
the user's system
|
|
"""
|
|
return _gdi_.FontEnumerator_IsValidFacename(*args, **kwargs)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
LANGUAGE_DEFAULT = _gdi_.LANGUAGE_DEFAULT
|
|
LANGUAGE_UNKNOWN = _gdi_.LANGUAGE_UNKNOWN
|
|
LANGUAGE_ABKHAZIAN = _gdi_.LANGUAGE_ABKHAZIAN
|
|
LANGUAGE_AFAR = _gdi_.LANGUAGE_AFAR
|
|
LANGUAGE_AFRIKAANS = _gdi_.LANGUAGE_AFRIKAANS
|
|
LANGUAGE_ALBANIAN = _gdi_.LANGUAGE_ALBANIAN
|
|
LANGUAGE_AMHARIC = _gdi_.LANGUAGE_AMHARIC
|
|
LANGUAGE_ARABIC = _gdi_.LANGUAGE_ARABIC
|
|
LANGUAGE_ARABIC_ALGERIA = _gdi_.LANGUAGE_ARABIC_ALGERIA
|
|
LANGUAGE_ARABIC_BAHRAIN = _gdi_.LANGUAGE_ARABIC_BAHRAIN
|
|
LANGUAGE_ARABIC_EGYPT = _gdi_.LANGUAGE_ARABIC_EGYPT
|
|
LANGUAGE_ARABIC_IRAQ = _gdi_.LANGUAGE_ARABIC_IRAQ
|
|
LANGUAGE_ARABIC_JORDAN = _gdi_.LANGUAGE_ARABIC_JORDAN
|
|
LANGUAGE_ARABIC_KUWAIT = _gdi_.LANGUAGE_ARABIC_KUWAIT
|
|
LANGUAGE_ARABIC_LEBANON = _gdi_.LANGUAGE_ARABIC_LEBANON
|
|
LANGUAGE_ARABIC_LIBYA = _gdi_.LANGUAGE_ARABIC_LIBYA
|
|
LANGUAGE_ARABIC_MOROCCO = _gdi_.LANGUAGE_ARABIC_MOROCCO
|
|
LANGUAGE_ARABIC_OMAN = _gdi_.LANGUAGE_ARABIC_OMAN
|
|
LANGUAGE_ARABIC_QATAR = _gdi_.LANGUAGE_ARABIC_QATAR
|
|
LANGUAGE_ARABIC_SAUDI_ARABIA = _gdi_.LANGUAGE_ARABIC_SAUDI_ARABIA
|
|
LANGUAGE_ARABIC_SUDAN = _gdi_.LANGUAGE_ARABIC_SUDAN
|
|
LANGUAGE_ARABIC_SYRIA = _gdi_.LANGUAGE_ARABIC_SYRIA
|
|
LANGUAGE_ARABIC_TUNISIA = _gdi_.LANGUAGE_ARABIC_TUNISIA
|
|
LANGUAGE_ARABIC_UAE = _gdi_.LANGUAGE_ARABIC_UAE
|
|
LANGUAGE_ARABIC_YEMEN = _gdi_.LANGUAGE_ARABIC_YEMEN
|
|
LANGUAGE_ARMENIAN = _gdi_.LANGUAGE_ARMENIAN
|
|
LANGUAGE_ASSAMESE = _gdi_.LANGUAGE_ASSAMESE
|
|
LANGUAGE_AYMARA = _gdi_.LANGUAGE_AYMARA
|
|
LANGUAGE_AZERI = _gdi_.LANGUAGE_AZERI
|
|
LANGUAGE_AZERI_CYRILLIC = _gdi_.LANGUAGE_AZERI_CYRILLIC
|
|
LANGUAGE_AZERI_LATIN = _gdi_.LANGUAGE_AZERI_LATIN
|
|
LANGUAGE_BASHKIR = _gdi_.LANGUAGE_BASHKIR
|
|
LANGUAGE_BASQUE = _gdi_.LANGUAGE_BASQUE
|
|
LANGUAGE_BELARUSIAN = _gdi_.LANGUAGE_BELARUSIAN
|
|
LANGUAGE_BENGALI = _gdi_.LANGUAGE_BENGALI
|
|
LANGUAGE_BHUTANI = _gdi_.LANGUAGE_BHUTANI
|
|
LANGUAGE_BIHARI = _gdi_.LANGUAGE_BIHARI
|
|
LANGUAGE_BISLAMA = _gdi_.LANGUAGE_BISLAMA
|
|
LANGUAGE_BRETON = _gdi_.LANGUAGE_BRETON
|
|
LANGUAGE_BULGARIAN = _gdi_.LANGUAGE_BULGARIAN
|
|
LANGUAGE_BURMESE = _gdi_.LANGUAGE_BURMESE
|
|
LANGUAGE_CAMBODIAN = _gdi_.LANGUAGE_CAMBODIAN
|
|
LANGUAGE_CATALAN = _gdi_.LANGUAGE_CATALAN
|
|
LANGUAGE_CHINESE = _gdi_.LANGUAGE_CHINESE
|
|
LANGUAGE_CHINESE_SIMPLIFIED = _gdi_.LANGUAGE_CHINESE_SIMPLIFIED
|
|
LANGUAGE_CHINESE_TRADITIONAL = _gdi_.LANGUAGE_CHINESE_TRADITIONAL
|
|
LANGUAGE_CHINESE_HONGKONG = _gdi_.LANGUAGE_CHINESE_HONGKONG
|
|
LANGUAGE_CHINESE_MACAU = _gdi_.LANGUAGE_CHINESE_MACAU
|
|
LANGUAGE_CHINESE_SINGAPORE = _gdi_.LANGUAGE_CHINESE_SINGAPORE
|
|
LANGUAGE_CHINESE_TAIWAN = _gdi_.LANGUAGE_CHINESE_TAIWAN
|
|
LANGUAGE_CORSICAN = _gdi_.LANGUAGE_CORSICAN
|
|
LANGUAGE_CROATIAN = _gdi_.LANGUAGE_CROATIAN
|
|
LANGUAGE_CZECH = _gdi_.LANGUAGE_CZECH
|
|
LANGUAGE_DANISH = _gdi_.LANGUAGE_DANISH
|
|
LANGUAGE_DUTCH = _gdi_.LANGUAGE_DUTCH
|
|
LANGUAGE_DUTCH_BELGIAN = _gdi_.LANGUAGE_DUTCH_BELGIAN
|
|
LANGUAGE_ENGLISH = _gdi_.LANGUAGE_ENGLISH
|
|
LANGUAGE_ENGLISH_UK = _gdi_.LANGUAGE_ENGLISH_UK
|
|
LANGUAGE_ENGLISH_US = _gdi_.LANGUAGE_ENGLISH_US
|
|
LANGUAGE_ENGLISH_AUSTRALIA = _gdi_.LANGUAGE_ENGLISH_AUSTRALIA
|
|
LANGUAGE_ENGLISH_BELIZE = _gdi_.LANGUAGE_ENGLISH_BELIZE
|
|
LANGUAGE_ENGLISH_BOTSWANA = _gdi_.LANGUAGE_ENGLISH_BOTSWANA
|
|
LANGUAGE_ENGLISH_CANADA = _gdi_.LANGUAGE_ENGLISH_CANADA
|
|
LANGUAGE_ENGLISH_CARIBBEAN = _gdi_.LANGUAGE_ENGLISH_CARIBBEAN
|
|
LANGUAGE_ENGLISH_DENMARK = _gdi_.LANGUAGE_ENGLISH_DENMARK
|
|
LANGUAGE_ENGLISH_EIRE = _gdi_.LANGUAGE_ENGLISH_EIRE
|
|
LANGUAGE_ENGLISH_JAMAICA = _gdi_.LANGUAGE_ENGLISH_JAMAICA
|
|
LANGUAGE_ENGLISH_NEW_ZEALAND = _gdi_.LANGUAGE_ENGLISH_NEW_ZEALAND
|
|
LANGUAGE_ENGLISH_PHILIPPINES = _gdi_.LANGUAGE_ENGLISH_PHILIPPINES
|
|
LANGUAGE_ENGLISH_SOUTH_AFRICA = _gdi_.LANGUAGE_ENGLISH_SOUTH_AFRICA
|
|
LANGUAGE_ENGLISH_TRINIDAD = _gdi_.LANGUAGE_ENGLISH_TRINIDAD
|
|
LANGUAGE_ENGLISH_ZIMBABWE = _gdi_.LANGUAGE_ENGLISH_ZIMBABWE
|
|
LANGUAGE_ESPERANTO = _gdi_.LANGUAGE_ESPERANTO
|
|
LANGUAGE_ESTONIAN = _gdi_.LANGUAGE_ESTONIAN
|
|
LANGUAGE_FAEROESE = _gdi_.LANGUAGE_FAEROESE
|
|
LANGUAGE_FARSI = _gdi_.LANGUAGE_FARSI
|
|
LANGUAGE_FIJI = _gdi_.LANGUAGE_FIJI
|
|
LANGUAGE_FINNISH = _gdi_.LANGUAGE_FINNISH
|
|
LANGUAGE_FRENCH = _gdi_.LANGUAGE_FRENCH
|
|
LANGUAGE_FRENCH_BELGIAN = _gdi_.LANGUAGE_FRENCH_BELGIAN
|
|
LANGUAGE_FRENCH_CANADIAN = _gdi_.LANGUAGE_FRENCH_CANADIAN
|
|
LANGUAGE_FRENCH_LUXEMBOURG = _gdi_.LANGUAGE_FRENCH_LUXEMBOURG
|
|
LANGUAGE_FRENCH_MONACO = _gdi_.LANGUAGE_FRENCH_MONACO
|
|
LANGUAGE_FRENCH_SWISS = _gdi_.LANGUAGE_FRENCH_SWISS
|
|
LANGUAGE_FRISIAN = _gdi_.LANGUAGE_FRISIAN
|
|
LANGUAGE_GALICIAN = _gdi_.LANGUAGE_GALICIAN
|
|
LANGUAGE_GEORGIAN = _gdi_.LANGUAGE_GEORGIAN
|
|
LANGUAGE_GERMAN = _gdi_.LANGUAGE_GERMAN
|
|
LANGUAGE_GERMAN_AUSTRIAN = _gdi_.LANGUAGE_GERMAN_AUSTRIAN
|
|
LANGUAGE_GERMAN_BELGIUM = _gdi_.LANGUAGE_GERMAN_BELGIUM
|
|
LANGUAGE_GERMAN_LIECHTENSTEIN = _gdi_.LANGUAGE_GERMAN_LIECHTENSTEIN
|
|
LANGUAGE_GERMAN_LUXEMBOURG = _gdi_.LANGUAGE_GERMAN_LUXEMBOURG
|
|
LANGUAGE_GERMAN_SWISS = _gdi_.LANGUAGE_GERMAN_SWISS
|
|
LANGUAGE_GREEK = _gdi_.LANGUAGE_GREEK
|
|
LANGUAGE_GREENLANDIC = _gdi_.LANGUAGE_GREENLANDIC
|
|
LANGUAGE_GUARANI = _gdi_.LANGUAGE_GUARANI
|
|
LANGUAGE_GUJARATI = _gdi_.LANGUAGE_GUJARATI
|
|
LANGUAGE_HAUSA = _gdi_.LANGUAGE_HAUSA
|
|
LANGUAGE_HEBREW = _gdi_.LANGUAGE_HEBREW
|
|
LANGUAGE_HINDI = _gdi_.LANGUAGE_HINDI
|
|
LANGUAGE_HUNGARIAN = _gdi_.LANGUAGE_HUNGARIAN
|
|
LANGUAGE_ICELANDIC = _gdi_.LANGUAGE_ICELANDIC
|
|
LANGUAGE_INDONESIAN = _gdi_.LANGUAGE_INDONESIAN
|
|
LANGUAGE_INTERLINGUA = _gdi_.LANGUAGE_INTERLINGUA
|
|
LANGUAGE_INTERLINGUE = _gdi_.LANGUAGE_INTERLINGUE
|
|
LANGUAGE_INUKTITUT = _gdi_.LANGUAGE_INUKTITUT
|
|
LANGUAGE_INUPIAK = _gdi_.LANGUAGE_INUPIAK
|
|
LANGUAGE_IRISH = _gdi_.LANGUAGE_IRISH
|
|
LANGUAGE_ITALIAN = _gdi_.LANGUAGE_ITALIAN
|
|
LANGUAGE_ITALIAN_SWISS = _gdi_.LANGUAGE_ITALIAN_SWISS
|
|
LANGUAGE_JAPANESE = _gdi_.LANGUAGE_JAPANESE
|
|
LANGUAGE_JAVANESE = _gdi_.LANGUAGE_JAVANESE
|
|
LANGUAGE_KANNADA = _gdi_.LANGUAGE_KANNADA
|
|
LANGUAGE_KASHMIRI = _gdi_.LANGUAGE_KASHMIRI
|
|
LANGUAGE_KASHMIRI_INDIA = _gdi_.LANGUAGE_KASHMIRI_INDIA
|
|
LANGUAGE_KAZAKH = _gdi_.LANGUAGE_KAZAKH
|
|
LANGUAGE_KERNEWEK = _gdi_.LANGUAGE_KERNEWEK
|
|
LANGUAGE_KINYARWANDA = _gdi_.LANGUAGE_KINYARWANDA
|
|
LANGUAGE_KIRGHIZ = _gdi_.LANGUAGE_KIRGHIZ
|
|
LANGUAGE_KIRUNDI = _gdi_.LANGUAGE_KIRUNDI
|
|
LANGUAGE_KONKANI = _gdi_.LANGUAGE_KONKANI
|
|
LANGUAGE_KOREAN = _gdi_.LANGUAGE_KOREAN
|
|
LANGUAGE_KURDISH = _gdi_.LANGUAGE_KURDISH
|
|
LANGUAGE_LAOTHIAN = _gdi_.LANGUAGE_LAOTHIAN
|
|
LANGUAGE_LATIN = _gdi_.LANGUAGE_LATIN
|
|
LANGUAGE_LATVIAN = _gdi_.LANGUAGE_LATVIAN
|
|
LANGUAGE_LINGALA = _gdi_.LANGUAGE_LINGALA
|
|
LANGUAGE_LITHUANIAN = _gdi_.LANGUAGE_LITHUANIAN
|
|
LANGUAGE_MACEDONIAN = _gdi_.LANGUAGE_MACEDONIAN
|
|
LANGUAGE_MALAGASY = _gdi_.LANGUAGE_MALAGASY
|
|
LANGUAGE_MALAY = _gdi_.LANGUAGE_MALAY
|
|
LANGUAGE_MALAYALAM = _gdi_.LANGUAGE_MALAYALAM
|
|
LANGUAGE_MALAY_BRUNEI_DARUSSALAM = _gdi_.LANGUAGE_MALAY_BRUNEI_DARUSSALAM
|
|
LANGUAGE_MALAY_MALAYSIA = _gdi_.LANGUAGE_MALAY_MALAYSIA
|
|
LANGUAGE_MALTESE = _gdi_.LANGUAGE_MALTESE
|
|
LANGUAGE_MANIPURI = _gdi_.LANGUAGE_MANIPURI
|
|
LANGUAGE_MAORI = _gdi_.LANGUAGE_MAORI
|
|
LANGUAGE_MARATHI = _gdi_.LANGUAGE_MARATHI
|
|
LANGUAGE_MOLDAVIAN = _gdi_.LANGUAGE_MOLDAVIAN
|
|
LANGUAGE_MONGOLIAN = _gdi_.LANGUAGE_MONGOLIAN
|
|
LANGUAGE_NAURU = _gdi_.LANGUAGE_NAURU
|
|
LANGUAGE_NEPALI = _gdi_.LANGUAGE_NEPALI
|
|
LANGUAGE_NEPALI_INDIA = _gdi_.LANGUAGE_NEPALI_INDIA
|
|
LANGUAGE_NORWEGIAN_BOKMAL = _gdi_.LANGUAGE_NORWEGIAN_BOKMAL
|
|
LANGUAGE_NORWEGIAN_NYNORSK = _gdi_.LANGUAGE_NORWEGIAN_NYNORSK
|
|
LANGUAGE_OCCITAN = _gdi_.LANGUAGE_OCCITAN
|
|
LANGUAGE_ORIYA = _gdi_.LANGUAGE_ORIYA
|
|
LANGUAGE_OROMO = _gdi_.LANGUAGE_OROMO
|
|
LANGUAGE_PASHTO = _gdi_.LANGUAGE_PASHTO
|
|
LANGUAGE_POLISH = _gdi_.LANGUAGE_POLISH
|
|
LANGUAGE_PORTUGUESE = _gdi_.LANGUAGE_PORTUGUESE
|
|
LANGUAGE_PORTUGUESE_BRAZILIAN = _gdi_.LANGUAGE_PORTUGUESE_BRAZILIAN
|
|
LANGUAGE_PUNJABI = _gdi_.LANGUAGE_PUNJABI
|
|
LANGUAGE_QUECHUA = _gdi_.LANGUAGE_QUECHUA
|
|
LANGUAGE_RHAETO_ROMANCE = _gdi_.LANGUAGE_RHAETO_ROMANCE
|
|
LANGUAGE_ROMANIAN = _gdi_.LANGUAGE_ROMANIAN
|
|
LANGUAGE_RUSSIAN = _gdi_.LANGUAGE_RUSSIAN
|
|
LANGUAGE_RUSSIAN_UKRAINE = _gdi_.LANGUAGE_RUSSIAN_UKRAINE
|
|
LANGUAGE_SAMOAN = _gdi_.LANGUAGE_SAMOAN
|
|
LANGUAGE_SANGHO = _gdi_.LANGUAGE_SANGHO
|
|
LANGUAGE_SANSKRIT = _gdi_.LANGUAGE_SANSKRIT
|
|
LANGUAGE_SCOTS_GAELIC = _gdi_.LANGUAGE_SCOTS_GAELIC
|
|
LANGUAGE_SERBIAN = _gdi_.LANGUAGE_SERBIAN
|
|
LANGUAGE_SERBIAN_CYRILLIC = _gdi_.LANGUAGE_SERBIAN_CYRILLIC
|
|
LANGUAGE_SERBIAN_LATIN = _gdi_.LANGUAGE_SERBIAN_LATIN
|
|
LANGUAGE_SERBO_CROATIAN = _gdi_.LANGUAGE_SERBO_CROATIAN
|
|
LANGUAGE_SESOTHO = _gdi_.LANGUAGE_SESOTHO
|
|
LANGUAGE_SETSWANA = _gdi_.LANGUAGE_SETSWANA
|
|
LANGUAGE_SHONA = _gdi_.LANGUAGE_SHONA
|
|
LANGUAGE_SINDHI = _gdi_.LANGUAGE_SINDHI
|
|
LANGUAGE_SINHALESE = _gdi_.LANGUAGE_SINHALESE
|
|
LANGUAGE_SISWATI = _gdi_.LANGUAGE_SISWATI
|
|
LANGUAGE_SLOVAK = _gdi_.LANGUAGE_SLOVAK
|
|
LANGUAGE_SLOVENIAN = _gdi_.LANGUAGE_SLOVENIAN
|
|
LANGUAGE_SOMALI = _gdi_.LANGUAGE_SOMALI
|
|
LANGUAGE_SPANISH = _gdi_.LANGUAGE_SPANISH
|
|
LANGUAGE_SPANISH_ARGENTINA = _gdi_.LANGUAGE_SPANISH_ARGENTINA
|
|
LANGUAGE_SPANISH_BOLIVIA = _gdi_.LANGUAGE_SPANISH_BOLIVIA
|
|
LANGUAGE_SPANISH_CHILE = _gdi_.LANGUAGE_SPANISH_CHILE
|
|
LANGUAGE_SPANISH_COLOMBIA = _gdi_.LANGUAGE_SPANISH_COLOMBIA
|
|
LANGUAGE_SPANISH_COSTA_RICA = _gdi_.LANGUAGE_SPANISH_COSTA_RICA
|
|
LANGUAGE_SPANISH_DOMINICAN_REPUBLIC = _gdi_.LANGUAGE_SPANISH_DOMINICAN_REPUBLIC
|
|
LANGUAGE_SPANISH_ECUADOR = _gdi_.LANGUAGE_SPANISH_ECUADOR
|
|
LANGUAGE_SPANISH_EL_SALVADOR = _gdi_.LANGUAGE_SPANISH_EL_SALVADOR
|
|
LANGUAGE_SPANISH_GUATEMALA = _gdi_.LANGUAGE_SPANISH_GUATEMALA
|
|
LANGUAGE_SPANISH_HONDURAS = _gdi_.LANGUAGE_SPANISH_HONDURAS
|
|
LANGUAGE_SPANISH_MEXICAN = _gdi_.LANGUAGE_SPANISH_MEXICAN
|
|
LANGUAGE_SPANISH_MODERN = _gdi_.LANGUAGE_SPANISH_MODERN
|
|
LANGUAGE_SPANISH_NICARAGUA = _gdi_.LANGUAGE_SPANISH_NICARAGUA
|
|
LANGUAGE_SPANISH_PANAMA = _gdi_.LANGUAGE_SPANISH_PANAMA
|
|
LANGUAGE_SPANISH_PARAGUAY = _gdi_.LANGUAGE_SPANISH_PARAGUAY
|
|
LANGUAGE_SPANISH_PERU = _gdi_.LANGUAGE_SPANISH_PERU
|
|
LANGUAGE_SPANISH_PUERTO_RICO = _gdi_.LANGUAGE_SPANISH_PUERTO_RICO
|
|
LANGUAGE_SPANISH_URUGUAY = _gdi_.LANGUAGE_SPANISH_URUGUAY
|
|
LANGUAGE_SPANISH_US = _gdi_.LANGUAGE_SPANISH_US
|
|
LANGUAGE_SPANISH_VENEZUELA = _gdi_.LANGUAGE_SPANISH_VENEZUELA
|
|
LANGUAGE_SUNDANESE = _gdi_.LANGUAGE_SUNDANESE
|
|
LANGUAGE_SWAHILI = _gdi_.LANGUAGE_SWAHILI
|
|
LANGUAGE_SWEDISH = _gdi_.LANGUAGE_SWEDISH
|
|
LANGUAGE_SWEDISH_FINLAND = _gdi_.LANGUAGE_SWEDISH_FINLAND
|
|
LANGUAGE_TAGALOG = _gdi_.LANGUAGE_TAGALOG
|
|
LANGUAGE_TAJIK = _gdi_.LANGUAGE_TAJIK
|
|
LANGUAGE_TAMIL = _gdi_.LANGUAGE_TAMIL
|
|
LANGUAGE_TATAR = _gdi_.LANGUAGE_TATAR
|
|
LANGUAGE_TELUGU = _gdi_.LANGUAGE_TELUGU
|
|
LANGUAGE_THAI = _gdi_.LANGUAGE_THAI
|
|
LANGUAGE_TIBETAN = _gdi_.LANGUAGE_TIBETAN
|
|
LANGUAGE_TIGRINYA = _gdi_.LANGUAGE_TIGRINYA
|
|
LANGUAGE_TONGA = _gdi_.LANGUAGE_TONGA
|
|
LANGUAGE_TSONGA = _gdi_.LANGUAGE_TSONGA
|
|
LANGUAGE_TURKISH = _gdi_.LANGUAGE_TURKISH
|
|
LANGUAGE_TURKMEN = _gdi_.LANGUAGE_TURKMEN
|
|
LANGUAGE_TWI = _gdi_.LANGUAGE_TWI
|
|
LANGUAGE_UIGHUR = _gdi_.LANGUAGE_UIGHUR
|
|
LANGUAGE_UKRAINIAN = _gdi_.LANGUAGE_UKRAINIAN
|
|
LANGUAGE_URDU = _gdi_.LANGUAGE_URDU
|
|
LANGUAGE_URDU_INDIA = _gdi_.LANGUAGE_URDU_INDIA
|
|
LANGUAGE_URDU_PAKISTAN = _gdi_.LANGUAGE_URDU_PAKISTAN
|
|
LANGUAGE_UZBEK = _gdi_.LANGUAGE_UZBEK
|
|
LANGUAGE_UZBEK_CYRILLIC = _gdi_.LANGUAGE_UZBEK_CYRILLIC
|
|
LANGUAGE_UZBEK_LATIN = _gdi_.LANGUAGE_UZBEK_LATIN
|
|
LANGUAGE_VIETNAMESE = _gdi_.LANGUAGE_VIETNAMESE
|
|
LANGUAGE_VOLAPUK = _gdi_.LANGUAGE_VOLAPUK
|
|
LANGUAGE_WELSH = _gdi_.LANGUAGE_WELSH
|
|
LANGUAGE_WOLOF = _gdi_.LANGUAGE_WOLOF
|
|
LANGUAGE_XHOSA = _gdi_.LANGUAGE_XHOSA
|
|
LANGUAGE_YIDDISH = _gdi_.LANGUAGE_YIDDISH
|
|
LANGUAGE_YORUBA = _gdi_.LANGUAGE_YORUBA
|
|
LANGUAGE_ZHUANG = _gdi_.LANGUAGE_ZHUANG
|
|
LANGUAGE_ZULU = _gdi_.LANGUAGE_ZULU
|
|
LANGUAGE_USER_DEFINED = _gdi_.LANGUAGE_USER_DEFINED
|
|
class LanguageInfo(object):
|
|
"""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)
|
|
_gdi_.LanguageInfo_swigregister(LanguageInfo)
|
|
|
|
LOCALE_CAT_NUMBER = _gdi_.LOCALE_CAT_NUMBER
|
|
LOCALE_CAT_DATE = _gdi_.LOCALE_CAT_DATE
|
|
LOCALE_CAT_MONEY = _gdi_.LOCALE_CAT_MONEY
|
|
LOCALE_CAT_MAX = _gdi_.LOCALE_CAT_MAX
|
|
LOCALE_THOUSANDS_SEP = _gdi_.LOCALE_THOUSANDS_SEP
|
|
LOCALE_DECIMAL_POINT = _gdi_.LOCALE_DECIMAL_POINT
|
|
LOCALE_LOAD_DEFAULT = _gdi_.LOCALE_LOAD_DEFAULT
|
|
LOCALE_CONV_ENCODING = _gdi_.LOCALE_CONV_ENCODING
|
|
class Locale(object):
|
|
"""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,
|
|
bool bLoadDefault=True,
|
|
bool bConvertEncoding=False) -> bool
|
|
"""
|
|
return _gdi_.Locale_Init1(*args, **kwargs)
|
|
|
|
def Init2(*args, **kwargs):
|
|
"""Init2(self, int language=LANGUAGE_DEFAULT, int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING) -> bool"""
|
|
return _gdi_.Locale_Init2(*args, **kwargs)
|
|
|
|
def Init(self, *_args, **_kwargs):
|
|
if type(_args[0]) in [type(''), type(u'')]:
|
|
val = self.Init1(*_args, **_kwargs)
|
|
else:
|
|
val = self.Init2(*_args, **_kwargs)
|
|
return val
|
|
|
|
def GetSystemLanguage(*args, **kwargs):
|
|
"""GetSystemLanguage() -> int"""
|
|
return _gdi_.Locale_GetSystemLanguage(*args, **kwargs)
|
|
|
|
GetSystemLanguage = staticmethod(GetSystemLanguage)
|
|
def GetSystemEncoding(*args, **kwargs):
|
|
"""GetSystemEncoding() -> int"""
|
|
return _gdi_.Locale_GetSystemEncoding(*args, **kwargs)
|
|
|
|
GetSystemEncoding = staticmethod(GetSystemEncoding)
|
|
def GetSystemEncodingName(*args, **kwargs):
|
|
"""GetSystemEncodingName() -> String"""
|
|
return _gdi_.Locale_GetSystemEncodingName(*args, **kwargs)
|
|
|
|
GetSystemEncodingName = staticmethod(GetSystemEncodingName)
|
|
def IsOk(*args, **kwargs):
|
|
"""IsOk(self) -> bool"""
|
|
return _gdi_.Locale_IsOk(*args, **kwargs)
|
|
|
|
def __nonzero__(self): return self.IsOk()
|
|
def GetLocale(*args, **kwargs):
|
|
"""GetLocale(self) -> String"""
|
|
return _gdi_.Locale_GetLocale(*args, **kwargs)
|
|
|
|
def GetLanguage(*args, **kwargs):
|
|
"""GetLanguage(self) -> int"""
|
|
return _gdi_.Locale_GetLanguage(*args, **kwargs)
|
|
|
|
def GetSysName(*args, **kwargs):
|
|
"""GetSysName(self) -> String"""
|
|
return _gdi_.Locale_GetSysName(*args, **kwargs)
|
|
|
|
def GetCanonicalName(*args, **kwargs):
|
|
"""GetCanonicalName(self) -> String"""
|
|
return _gdi_.Locale_GetCanonicalName(*args, **kwargs)
|
|
|
|
def AddCatalogLookupPathPrefix(*args, **kwargs):
|
|
"""AddCatalogLookupPathPrefix(String prefix)"""
|
|
return _gdi_.Locale_AddCatalogLookupPathPrefix(*args, **kwargs)
|
|
|
|
AddCatalogLookupPathPrefix = staticmethod(AddCatalogLookupPathPrefix)
|
|
def AddCatalog(*args, **kwargs):
|
|
"""AddCatalog(self, String szDomain) -> bool"""
|
|
return _gdi_.Locale_AddCatalog(*args, **kwargs)
|
|
|
|
def IsAvailable(*args, **kwargs):
|
|
"""IsAvailable(int lang) -> bool"""
|
|
return _gdi_.Locale_IsAvailable(*args, **kwargs)
|
|
|
|
IsAvailable = staticmethod(IsAvailable)
|
|
def IsLoaded(*args, **kwargs):
|
|
"""IsLoaded(self, String szDomain) -> bool"""
|
|
return _gdi_.Locale_IsLoaded(*args, **kwargs)
|
|
|
|
def GetLanguageInfo(*args, **kwargs):
|
|
"""GetLanguageInfo(int lang) -> LanguageInfo"""
|
|
return _gdi_.Locale_GetLanguageInfo(*args, **kwargs)
|
|
|
|
GetLanguageInfo = staticmethod(GetLanguageInfo)
|
|
def GetLanguageName(*args, **kwargs):
|
|
"""GetLanguageName(int lang) -> String"""
|
|
return _gdi_.Locale_GetLanguageName(*args, **kwargs)
|
|
|
|
GetLanguageName = staticmethod(GetLanguageName)
|
|
def FindLanguageInfo(*args, **kwargs):
|
|
"""FindLanguageInfo(String locale) -> LanguageInfo"""
|
|
return _gdi_.Locale_FindLanguageInfo(*args, **kwargs)
|
|
|
|
FindLanguageInfo = staticmethod(FindLanguageInfo)
|
|
def AddLanguage(*args, **kwargs):
|
|
"""AddLanguage(LanguageInfo info)"""
|
|
return _gdi_.Locale_AddLanguage(*args, **kwargs)
|
|
|
|
AddLanguage = staticmethod(AddLanguage)
|
|
def GetString(*args, **kwargs):
|
|
"""GetString(self, String szOrigString, String szDomain=EmptyString) -> String"""
|
|
return _gdi_.Locale_GetString(*args, **kwargs)
|
|
|
|
def GetName(*args, **kwargs):
|
|
"""GetName(self) -> String"""
|
|
return _gdi_.Locale_GetName(*args, **kwargs)
|
|
|
|
CanonicalName = property(GetCanonicalName,doc="See `GetCanonicalName`")
|
|
Language = property(GetLanguage,doc="See `GetLanguage`")
|
|
Locale = property(GetLocale,doc="See `GetLocale`")
|
|
Name = property(GetName,doc="See `GetName`")
|
|
String = property(GetString,doc="See `GetString`")
|
|
SysName = property(GetSysName,doc="See `GetSysName`")
|
|
_gdi_.Locale_swigregister(Locale)
|
|
|
|
def Locale_GetSystemLanguage(*args):
|
|
"""Locale_GetSystemLanguage() -> int"""
|
|
return _gdi_.Locale_GetSystemLanguage(*args)
|
|
|
|
def Locale_GetSystemEncoding(*args):
|
|
"""Locale_GetSystemEncoding() -> int"""
|
|
return _gdi_.Locale_GetSystemEncoding(*args)
|
|
|
|
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)
|
|
|
|
def Locale_IsAvailable(*args, **kwargs):
|
|
"""Locale_IsAvailable(int lang) -> bool"""
|
|
return _gdi_.Locale_IsAvailable(*args, **kwargs)
|
|
|
|
def 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)
|
|
|
|
def 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)
|
|
|
|
class PyLocale(Locale):
|
|
"""Proxy of C++ PyLocale 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) -> PyLocale"""
|
|
_gdi_.PyLocale_swiginit(self,_gdi_.new_PyLocale(*args, **kwargs))
|
|
PyLocale._setCallbackInfo(self, self, PyLocale)
|
|
|
|
__swig_destroy__ = _gdi_.delete_PyLocale
|
|
__del__ = lambda self : None;
|
|
def _setCallbackInfo(*args, **kwargs):
|
|
"""_setCallbackInfo(self, PyObject self, PyObject _class)"""
|
|
return _gdi_.PyLocale__setCallbackInfo(*args, **kwargs)
|
|
|
|
def GetSingularString(*args, **kwargs):
|
|
"""GetSingularString(self, wxChar szOrigString, wxChar szDomain=None) -> wxChar"""
|
|
return _gdi_.PyLocale_GetSingularString(*args, **kwargs)
|
|
|
|
def GetPluralString(*args, **kwargs):
|
|
"""
|
|
GetPluralString(self, wxChar szOrigString, wxChar szOrigString2, size_t n,
|
|
wxChar szDomain=None) -> wxChar
|
|
"""
|
|
return _gdi_.PyLocale_GetPluralString(*args, **kwargs)
|
|
|
|
_gdi_.PyLocale_swigregister(PyLocale)
|
|
|
|
|
|
def GetLocale(*args):
|
|
"""GetLocale() -> Locale"""
|
|
return _gdi_.GetLocale(*args)
|
|
#---------------------------------------------------------------------------
|
|
|
|
CONVERT_STRICT = _gdi_.CONVERT_STRICT
|
|
CONVERT_SUBSTITUTE = _gdi_.CONVERT_SUBSTITUTE
|
|
PLATFORM_CURRENT = _gdi_.PLATFORM_CURRENT
|
|
PLATFORM_UNIX = _gdi_.PLATFORM_UNIX
|
|
PLATFORM_WINDOWS = _gdi_.PLATFORM_WINDOWS
|
|
PLATFORM_OS2 = _gdi_.PLATFORM_OS2
|
|
PLATFORM_MAC = _gdi_.PLATFORM_MAC
|
|
class EncodingConverter(_core.Object):
|
|
"""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"""
|
|
_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)
|
|
|
|
def Convert(*args, **kwargs):
|
|
"""Convert(self, String input) -> String"""
|
|
return _gdi_.EncodingConverter_Convert(*args, **kwargs)
|
|
|
|
def GetPlatformEquivalents(*args, **kwargs):
|
|
"""GetPlatformEquivalents(int enc, int platform=PLATFORM_CURRENT) -> wxFontEncodingArray"""
|
|
return _gdi_.EncodingConverter_GetPlatformEquivalents(*args, **kwargs)
|
|
|
|
GetPlatformEquivalents = staticmethod(GetPlatformEquivalents)
|
|
def GetAllEquivalents(*args, **kwargs):
|
|
"""GetAllEquivalents(int enc) -> wxFontEncodingArray"""
|
|
return _gdi_.EncodingConverter_GetAllEquivalents(*args, **kwargs)
|
|
|
|
GetAllEquivalents = staticmethod(GetAllEquivalents)
|
|
def CanConvert(*args, **kwargs):
|
|
"""CanConvert(int encIn, int encOut) -> bool"""
|
|
return _gdi_.EncodingConverter_CanConvert(*args, **kwargs)
|
|
|
|
CanConvert = staticmethod(CanConvert)
|
|
def __nonzero__(self): return self.IsOk()
|
|
_gdi_.EncodingConverter_swigregister(EncodingConverter)
|
|
|
|
def GetTranslation(*args):
|
|
"""
|
|
GetTranslation(String str) -> String
|
|
GetTranslation(String str, String domain) -> String
|
|
GetTranslation(String str, String strPlural, size_t n) -> String
|
|
GetTranslation(String str, String strPlural, size_t n, String domain) -> String
|
|
"""
|
|
return _gdi_.GetTranslation(*args)
|
|
|
|
def 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)
|
|
|
|
def EncodingConverter_CanConvert(*args, **kwargs):
|
|
"""EncodingConverter_CanConvert(int encIn, int encOut) -> bool"""
|
|
return _gdi_.EncodingConverter_CanConvert(*args, **kwargs)
|
|
|
|
#----------------------------------------------------------------------------
|
|
# 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)
|
|
del os
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class DC(_core.Object):
|
|
"""
|
|
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, 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 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, int x, int y) -> Colour
|
|
|
|
Gets the colour at the specified location on the DC.
|
|
"""
|
|
return _gdi_.DC_GetPixel(*args, **kwargs)
|
|
|
|
def GetPixelPoint(*args, **kwargs):
|
|
"""GetPixelPoint(self, Point pt) -> Colour"""
|
|
return _gdi_.DC_GetPixelPoint(*args, **kwargs)
|
|
|
|
def DrawLine(*args, **kwargs):
|
|
"""
|
|
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 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, 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 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, 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 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, int x, int y, int width, int height)
|
|
|
|
Draws a check mark inside the given rectangle.
|
|
"""
|
|
return _gdi_.DC_DrawCheckMark(*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, 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 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, int x, int y)
|
|
|
|
Draws a point using the current pen.
|
|
"""
|
|
return _gdi_.DC_DrawPoint(*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, 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)
|
|
|
|
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 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, 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)
|
|
|
|
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 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, 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 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, 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)
|
|
|
|
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 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, 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 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, 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 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, 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 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, 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 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):
|
|
"""
|
|
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_Blit(*args, **kwargs)
|
|
|
|
def BlitPointSize(*args, **kwargs):
|
|
"""
|
|
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_BlitPointSize(*args, **kwargs)
|
|
|
|
def GetAsBitmap(*args, **kwargs):
|
|
"""GetAsBitmap(self, Rect subrect=None) -> Bitmap"""
|
|
return _gdi_.DC_GetAsBitmap(*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, 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, 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)
|
|
|
|
def DrawLabel(*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)
|
|
|
|
def DrawImageLabel(*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, 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)
|
|
|
|
Clears the device context using the current background brush.
|
|
"""
|
|
return _gdi_.DC_Clear(*args, **kwargs)
|
|
|
|
def StartDoc(*args, **kwargs):
|
|
"""
|
|
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)
|
|
|
|
Ends a document (only relevant when outputting to a printer).
|
|
"""
|
|
return _gdi_.DC_EndDoc(*args, **kwargs)
|
|
|
|
def StartPage(*args, **kwargs):
|
|
"""
|
|
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)
|
|
|
|
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)
|
|
|
|
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)
|
|
|
|
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)
|
|
|
|
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)
|
|
|
|
Sets the current background brush for the DC.
|
|
"""
|
|
return _gdi_.DC_SetBackground(*args, **kwargs)
|
|
|
|
def SetBackgroundMode(*args, **kwargs):
|
|
"""
|
|
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)
|
|
|
|
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)
|
|
|
|
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)
|
|
|
|
Gets the rectangle surrounding the current clipping region.
|
|
"""
|
|
return _gdi_.DC_GetClippingBox(*args, **kwargs)
|
|
|
|
def GetClippingRect(*args, **kwargs):
|
|
"""
|
|
GetClippingRect(self) -> Rect
|
|
|
|
Gets the rectangle surrounding the current clipping region.
|
|
"""
|
|
return _gdi_.DC_GetClippingRect(*args, **kwargs)
|
|
|
|
def GetCharHeight(*args, **kwargs):
|
|
"""
|
|
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
|
|
|
|
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.
|
|
"""
|
|
return _gdi_.DC_GetTextExtent(*args, **kwargs)
|
|
|
|
def GetFullTextExtent(*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.
|
|
"""
|
|
return _gdi_.DC_GetFullTextExtent(*args, **kwargs)
|
|
|
|
def GetMultiLineTextExtent(*args, **kwargs):
|
|
"""
|
|
GetMultiLineTextExtent(wxString string, Font font=None) ->
|
|
(width, height, lineHeight)
|
|
|
|
Get the width, height, and line height 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, 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
|
|
|
|
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)
|
|
|
|
def GetSizeTuple(*args, **kwargs):
|
|
"""
|
|
GetSizeTuple() -> (width, height)
|
|
|
|
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)
|
|
|
|
def GetSizeMM(*args, **kwargs):
|
|
"""
|
|
GetSizeMM(self) -> Size
|
|
|
|
Get the DC size in milimeters.
|
|
"""
|
|
return _gdi_.DC_GetSizeMM(*args, **kwargs)
|
|
|
|
def GetSizeMMTuple(*args, **kwargs):
|
|
"""
|
|
GetSizeMMTuple() -> (width, height)
|
|
|
|
Get the DC size in milimeters.
|
|
"""
|
|
return _gdi_.DC_GetSizeMMTuple(*args, **kwargs)
|
|
|
|
def DeviceToLogicalX(*args, **kwargs):
|
|
"""
|
|
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
|
|
|
|
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
|
|
|
|
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
|
|
|
|
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
|
|
|
|
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
|
|
|
|
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
|
|
|
|
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
|
|
|
|
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):
|
|
"""CanDrawBitmap(self) -> bool"""
|
|
return _gdi_.DC_CanDrawBitmap(*args, **kwargs)
|
|
|
|
def CanGetTextExtent(*args, **kwargs):
|
|
"""CanGetTextExtent(self) -> bool"""
|
|
return _gdi_.DC_CanGetTextExtent(*args, **kwargs)
|
|
|
|
def GetDepth(*args, **kwargs):
|
|
"""
|
|
GetDepth(self) -> int
|
|
|
|
Returns the colour depth of the DC.
|
|
"""
|
|
return _gdi_.DC_GetDepth(*args, **kwargs)
|
|
|
|
def GetPPI(*args, **kwargs):
|
|
"""
|
|
GetPPI(self) -> Size
|
|
|
|
Resolution in pixels per inch
|
|
"""
|
|
return _gdi_.DC_GetPPI(*args, **kwargs)
|
|
|
|
def IsOk(*args, **kwargs):
|
|
"""
|
|
IsOk(self) -> bool
|
|
|
|
Returns true if the DC is ok to use.
|
|
"""
|
|
return _gdi_.DC_IsOk(*args, **kwargs)
|
|
|
|
Ok = IsOk
|
|
def GetBackgroundMode(*args, **kwargs):
|
|
"""
|
|
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
|
|
|
|
Gets the brush used for painting the background.
|
|
"""
|
|
return _gdi_.DC_GetBackground(*args, **kwargs)
|
|
|
|
def GetBrush(*args, **kwargs):
|
|
"""
|
|
GetBrush(self) -> Brush
|
|
|
|
Gets the current brush
|
|
"""
|
|
return _gdi_.DC_GetBrush(*args, **kwargs)
|
|
|
|
def GetFont(*args, **kwargs):
|
|
"""
|
|
GetFont(self) -> Font
|
|
|
|
Gets the current font
|
|
"""
|
|
return _gdi_.DC_GetFont(*args, **kwargs)
|
|
|
|
def GetPen(*args, **kwargs):
|
|
"""
|
|
GetPen(self) -> Pen
|
|
|
|
Gets the current pen
|
|
"""
|
|
return _gdi_.DC_GetPen(*args, **kwargs)
|
|
|
|
def GetTextBackground(*args, **kwargs):
|
|
"""
|
|
GetTextBackground(self) -> Colour
|
|
|
|
Gets the current text background colour
|
|
"""
|
|
return _gdi_.DC_GetTextBackground(*args, **kwargs)
|
|
|
|
def GetTextForeground(*args, **kwargs):
|
|
"""
|
|
GetTextForeground(self) -> Colour
|
|
|
|
Gets the current text foreground colour
|
|
"""
|
|
return _gdi_.DC_GetTextForeground(*args, **kwargs)
|
|
|
|
def SetTextForeground(*args, **kwargs):
|
|
"""
|
|
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)
|
|
|
|
Sets the current text background colour for the DC.
|
|
"""
|
|
return _gdi_.DC_SetTextBackground(*args, **kwargs)
|
|
|
|
def GetMapMode(*args, **kwargs):
|
|
"""
|
|
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)
|
|
|
|
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(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)
|
|
|
|
Sets the user scaling factor, useful for applications which require
|
|
'zooming'.
|
|
"""
|
|
return _gdi_.DC_SetUserScale(*args, **kwargs)
|
|
|
|
def GetLogicalScale(*args, **kwargs):
|
|
"""GetLogicalScale() -> (xScale, yScale)"""
|
|
return _gdi_.DC_GetLogicalScale(*args, **kwargs)
|
|
|
|
def SetLogicalScale(*args, **kwargs):
|
|
"""SetLogicalScale(self, double x, double y)"""
|
|
return _gdi_.DC_SetLogicalScale(*args, **kwargs)
|
|
|
|
def GetLogicalOrigin(*args, **kwargs):
|
|
"""GetLogicalOrigin(self) -> Point"""
|
|
return _gdi_.DC_GetLogicalOrigin(*args, **kwargs)
|
|
|
|
def GetLogicalOriginTuple(*args, **kwargs):
|
|
"""GetLogicalOriginTuple() -> (x,y)"""
|
|
return _gdi_.DC_GetLogicalOriginTuple(*args, **kwargs)
|
|
|
|
def SetLogicalOrigin(*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)
|
|
|
|
def GetDeviceOriginTuple(*args, **kwargs):
|
|
"""GetDeviceOriginTuple() -> (x,y)"""
|
|
return _gdi_.DC_GetDeviceOriginTuple(*args, **kwargs)
|
|
|
|
def SetDeviceOrigin(*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)
|
|
|
|
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
|
|
|
|
Gets the current logical function (set by `SetLogicalFunction`).
|
|
"""
|
|
return _gdi_.DC_GetLogicalFunction(*args, **kwargs)
|
|
|
|
def SetLogicalFunction(*args, **kwargs):
|
|
"""
|
|
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 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
|
|
|
|
SetOptimization = wx._deprecated(SetOptimization)
|
|
GetOptimization = wx._deprecated(GetOptimization)
|
|
|
|
def CalcBoundingBox(*args, **kwargs):
|
|
"""
|
|
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)
|
|
|
|
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
|
|
|
|
Gets the minimum horizontal extent used in drawing commands so far.
|
|
"""
|
|
return _gdi_.DC_MinX(*args, **kwargs)
|
|
|
|
def MaxX(*args, **kwargs):
|
|
"""
|
|
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
|
|
|
|
Gets the minimum vertical extent used in drawing commands so far.
|
|
"""
|
|
return _gdi_.DC_MinY(*args, **kwargs)
|
|
|
|
def MaxY(*args, **kwargs):
|
|
"""
|
|
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)
|
|
|
|
Returns the min and max points used in drawing commands so far.
|
|
"""
|
|
return _gdi_.DC_GetBoundingBox(*args, **kwargs)
|
|
|
|
def __nonzero__(self): return self.IsOk()
|
|
def GetLayoutDirection(*args, **kwargs):
|
|
"""
|
|
GetLayoutDirection(self) -> int
|
|
|
|
Get the layout direction (LTR or RTL)_ for this dc. On platforms
|
|
where RTL layout is supported, the return value will either be
|
|
``wx.Layout_LeftToRight`` or ``wx.Layout_RightToLeft``.
|
|
``wx.Layout_Default`` is returned if layout direction is not
|
|
supported.
|
|
"""
|
|
return _gdi_.DC_GetLayoutDirection(*args, **kwargs)
|
|
|
|
def SetLayoutDirection(*args, **kwargs):
|
|
"""
|
|
SetLayoutDirection(self, int dir)
|
|
|
|
Change the layout direction for this dc.
|
|
"""
|
|
return _gdi_.DC_SetLayoutDirection(*args, **kwargs)
|
|
|
|
def _DrawPointList(*args, **kwargs):
|
|
"""_DrawPointList(self, PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject"""
|
|
return _gdi_.DC__DrawPointList(*args, **kwargs)
|
|
|
|
def _DrawLineList(*args, **kwargs):
|
|
"""_DrawLineList(self, PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject"""
|
|
return _gdi_.DC__DrawLineList(*args, **kwargs)
|
|
|
|
def _DrawRectangleList(*args, **kwargs):
|
|
"""_DrawRectangleList(self, PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject"""
|
|
return _gdi_.DC__DrawRectangleList(*args, **kwargs)
|
|
|
|
def _DrawEllipseList(*args, **kwargs):
|
|
"""_DrawEllipseList(self, PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject"""
|
|
return _gdi_.DC__DrawEllipseList(*args, **kwargs)
|
|
|
|
def _DrawPolygonList(*args, **kwargs):
|
|
"""_DrawPolygonList(self, PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject"""
|
|
return _gdi_.DC__DrawPolygonList(*args, **kwargs)
|
|
|
|
def _DrawTextList(*args, **kwargs):
|
|
"""
|
|
_DrawTextList(self, PyObject textList, PyObject pyPoints, PyObject foregroundList,
|
|
PyObject backgroundList) -> PyObject
|
|
"""
|
|
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):
|
|
pens = [pens]
|
|
elif len(pens) != len(points):
|
|
raise ValueError('points and pens must have same length')
|
|
return self._DrawPointList(points, pens, [])
|
|
|
|
|
|
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):
|
|
pens = [pens]
|
|
elif len(pens) != len(lines):
|
|
raise ValueError('lines and pens must have same length')
|
|
return self._DrawLineList(lines, pens, [])
|
|
|
|
|
|
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):
|
|
pens = [pens]
|
|
elif len(pens) != len(rectangles):
|
|
raise ValueError('rectangles and pens must have same length')
|
|
if brushes is None:
|
|
brushes = []
|
|
elif isinstance(brushes, wx.Brush):
|
|
brushes = [brushes]
|
|
elif len(brushes) != len(rectangles):
|
|
raise ValueError('rectangles and brushes must have same length')
|
|
return self._DrawRectangleList(rectangles, pens, brushes)
|
|
|
|
|
|
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):
|
|
pens = [pens]
|
|
elif len(pens) != len(ellipses):
|
|
raise ValueError('ellipses and pens must have same length')
|
|
if brushes is None:
|
|
brushes = []
|
|
elif isinstance(brushes, wx.Brush):
|
|
brushes = [brushes]
|
|
elif len(brushes) != len(ellipses):
|
|
raise ValueError('ellipses and brushes must have same length')
|
|
return self._DrawEllipseList(ellipses, pens, brushes)
|
|
|
|
|
|
def DrawPolygonList(self, polygons, pens=None, brushes=None):
|
|
"""
|
|
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):
|
|
pens = [pens]
|
|
elif len(pens) != len(polygons):
|
|
raise ValueError('polygons and pens must have same length')
|
|
if brushes is None:
|
|
brushes = []
|
|
elif isinstance(brushes, wx.Brush):
|
|
brushes = [brushes]
|
|
elif len(brushes) != len(polygons):
|
|
raise ValueError('polygons and brushes must have same length')
|
|
return self._DrawPolygonList(polygons, pens, brushes)
|
|
|
|
|
|
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('textlist and coords must have same length')
|
|
if foregrounds is None:
|
|
foregrounds = []
|
|
elif isinstance(foregrounds, wx.Colour):
|
|
foregrounds = [foregrounds]
|
|
elif len(foregrounds) != len(coords):
|
|
raise ValueError('foregrounds and coords must have same length')
|
|
if backgrounds is None:
|
|
backgrounds = []
|
|
elif isinstance(backgrounds, wx.Colour):
|
|
backgrounds = [backgrounds]
|
|
elif len(backgrounds) != len(coords):
|
|
raise ValueError('backgrounds and coords must have same length')
|
|
return self._DrawTextList(textList, coords, foregrounds, backgrounds)
|
|
|
|
Background = property(GetBackground,SetBackground,doc="See `GetBackground` and `SetBackground`")
|
|
BackgroundMode = property(GetBackgroundMode,SetBackgroundMode,doc="See `GetBackgroundMode` and `SetBackgroundMode`")
|
|
BoundingBox = property(GetBoundingBox,doc="See `GetBoundingBox`")
|
|
Brush = property(GetBrush,SetBrush,doc="See `GetBrush` and `SetBrush`")
|
|
CharHeight = property(GetCharHeight,doc="See `GetCharHeight`")
|
|
CharWidth = property(GetCharWidth,doc="See `GetCharWidth`")
|
|
ClippingBox = property(GetClippingBox,doc="See `GetClippingBox`")
|
|
ClippingRect = property(GetClippingRect,SetClippingRect,doc="See `GetClippingRect` and `SetClippingRect`")
|
|
Depth = property(GetDepth,doc="See `GetDepth`")
|
|
DeviceOrigin = property(GetDeviceOrigin,SetDeviceOrigin,doc="See `GetDeviceOrigin` and `SetDeviceOrigin`")
|
|
Font = property(GetFont,SetFont,doc="See `GetFont` and `SetFont`")
|
|
FullTextExtent = property(GetFullTextExtent,doc="See `GetFullTextExtent`")
|
|
LogicalFunction = property(GetLogicalFunction,SetLogicalFunction,doc="See `GetLogicalFunction` and `SetLogicalFunction`")
|
|
LogicalOrigin = property(GetLogicalOrigin,SetLogicalOrigin,doc="See `GetLogicalOrigin` and `SetLogicalOrigin`")
|
|
LogicalScale = property(GetLogicalScale,SetLogicalScale,doc="See `GetLogicalScale` and `SetLogicalScale`")
|
|
MapMode = property(GetMapMode,SetMapMode,doc="See `GetMapMode` and `SetMapMode`")
|
|
MultiLineTextExtent = property(GetMultiLineTextExtent,doc="See `GetMultiLineTextExtent`")
|
|
Optimization = property(GetOptimization,SetOptimization,doc="See `GetOptimization` and `SetOptimization`")
|
|
PPI = property(GetPPI,doc="See `GetPPI`")
|
|
PartialTextExtents = property(GetPartialTextExtents,doc="See `GetPartialTextExtents`")
|
|
Pen = property(GetPen,SetPen,doc="See `GetPen` and `SetPen`")
|
|
Pixel = property(GetPixel,doc="See `GetPixel`")
|
|
PixelPoint = property(GetPixelPoint,doc="See `GetPixelPoint`")
|
|
Size = property(GetSize,doc="See `GetSize`")
|
|
SizeMM = property(GetSizeMM,doc="See `GetSizeMM`")
|
|
TextBackground = property(GetTextBackground,SetTextBackground,doc="See `GetTextBackground` and `SetTextBackground`")
|
|
TextExtent = property(GetTextExtent,doc="See `GetTextExtent`")
|
|
TextForeground = property(GetTextForeground,SetTextForeground,doc="See `GetTextForeground` and `SetTextForeground`")
|
|
UserScale = property(GetUserScale,SetUserScale,doc="See `GetUserScale` and `SetUserScale`")
|
|
LayoutDirection = property(GetLayoutDirection,SetLayoutDirection)
|
|
_gdi_.DC_swigregister(DC)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class DCTextColourChanger(object):
|
|
"""
|
|
wx.DCTextColourChanger can be used to temporarily change the DC text
|
|
colour and restore it automatically when the object goes out of scope
|
|
"""
|
|
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, Colour col) -> DCTextColourChanger
|
|
|
|
wx.DCTextColourChanger can be used to temporarily change the DC text
|
|
colour and restore it automatically when the object goes out of scope
|
|
"""
|
|
_gdi_.DCTextColourChanger_swiginit(self,_gdi_.new_DCTextColourChanger(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_DCTextColourChanger
|
|
__del__ = lambda self : None;
|
|
_gdi_.DCTextColourChanger_swigregister(DCTextColourChanger)
|
|
|
|
class DCPenChanger(object):
|
|
"""
|
|
wx.DCPenChanger can be used to temporarily change the DC pen and
|
|
restore it automatically when the object goes out of scope
|
|
"""
|
|
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, Pen pen) -> DCPenChanger
|
|
|
|
wx.DCPenChanger can be used to temporarily change the DC pen and
|
|
restore it automatically when the object goes out of scope
|
|
"""
|
|
_gdi_.DCPenChanger_swiginit(self,_gdi_.new_DCPenChanger(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_DCPenChanger
|
|
__del__ = lambda self : None;
|
|
_gdi_.DCPenChanger_swigregister(DCPenChanger)
|
|
|
|
class DCBrushChanger(object):
|
|
"""
|
|
wx.DCBrushChanger can be used to temporarily change the DC brush and
|
|
restore it automatically when the object goes out of scope
|
|
"""
|
|
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, Brush brush) -> DCBrushChanger
|
|
|
|
wx.DCBrushChanger can be used to temporarily change the DC brush and
|
|
restore it automatically when the object goes out of scope
|
|
"""
|
|
_gdi_.DCBrushChanger_swiginit(self,_gdi_.new_DCBrushChanger(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_DCBrushChanger
|
|
__del__ = lambda self : None;
|
|
_gdi_.DCBrushChanger_swigregister(DCBrushChanger)
|
|
|
|
class DCClipper(object):
|
|
"""
|
|
wx.wxDCClipper sets the DC's clipping region when it is constructed,
|
|
and then automatically destroys the clipping region when the clipper
|
|
goes out of scope.
|
|
"""
|
|
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):
|
|
"""
|
|
__init__(self, DC dc, Region r) -> DCClipper
|
|
__init__(self, DC dc, Rect r) -> DCClipper
|
|
__init__(self, DC dc, int x, int y, int w, int h) -> DCClipper
|
|
|
|
wx.wxDCClipper sets the DC's clipping region when it is constructed,
|
|
and then automatically destroys the clipping region when the clipper
|
|
goes out of scope.
|
|
"""
|
|
_gdi_.DCClipper_swiginit(self,_gdi_.new_DCClipper(*args))
|
|
__swig_destroy__ = _gdi_.delete_DCClipper
|
|
__del__ = lambda self : None;
|
|
_gdi_.DCClipper_swigregister(DCClipper)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class ScreenDC(DC):
|
|
"""
|
|
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
|
|
|
|
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
|
|
|
|
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
|
|
|
|
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.
|
|
|
|
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)
|
|
|
|
_gdi_.ScreenDC_swigregister(ScreenDC)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class WindowDC(DC):
|
|
"""
|
|
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))
|
|
_gdi_.WindowDC_swigregister(WindowDC)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class ClientDC(WindowDC):
|
|
"""
|
|
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))
|
|
_gdi_.ClientDC_swigregister(ClientDC)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class PaintDC(ClientDC):
|
|
"""
|
|
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))
|
|
_gdi_.PaintDC_swigregister(PaintDC)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class MemoryDC(WindowDC):
|
|
"""
|
|
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 using 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, Bitmap bitmap=NullBitmap) -> MemoryDC
|
|
|
|
Constructs a new memory device context.
|
|
|
|
Use the Ok member to test whether the constructor was successful in
|
|
creating a usable device context. If a bitmap is not given to this
|
|
constructor then 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)
|
|
|
|
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)
|
|
|
|
def SelectObjectAsSource(*args, **kwargs):
|
|
"""SelectObjectAsSource(self, Bitmap bmp)"""
|
|
return _gdi_.MemoryDC_SelectObjectAsSource(*args, **kwargs)
|
|
|
|
_gdi_.MemoryDC_swigregister(MemoryDC)
|
|
|
|
def MemoryDCFromDC(*args, **kwargs):
|
|
"""
|
|
MemoryDCFromDC(DC oldDC) -> MemoryDC
|
|
|
|
Creates a DC that is compatible with the oldDC.
|
|
"""
|
|
val = _gdi_.new_MemoryDCFromDC(*args, **kwargs)
|
|
return val
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA
|
|
BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA
|
|
class BufferedDC(MemoryDC):
|
|
"""
|
|
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. You can either provide a buffer bitmap yourself, and
|
|
reuse it the next time something needs painted, or you can let the
|
|
buffered DC create and provide a buffer bitmap itself.
|
|
|
|
Buffered DCs 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`. You can also use a wx.BufferedDC without
|
|
providing a target DC. In this case the operations done on the dc
|
|
will only be written to the buffer bitmap and *not* to any window, so
|
|
you will want to have provided the buffer bitmap and then reuse it
|
|
when it needs painted to the window.
|
|
|
|
Please note that GTK+ 2.0 and OS X provide double buffering themselves
|
|
natively. You may want to use `wx.Window.IsDoubleBuffered` to
|
|
determine whether you need to use buffering or not, or use
|
|
`wx.AutoBufferedPaintDC` to avoid needless double buffering on systems
|
|
that already do it automatically.
|
|
|
|
|
|
|
|
"""
|
|
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):
|
|
"""
|
|
__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
|
|
|
|
Constructs a buffered DC.
|
|
"""
|
|
_gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
|
|
# save a ref so the other dc will not be deleted before self
|
|
self.__dc = args[0]
|
|
# also save a ref to the bitmap
|
|
if len(args) > 1: self.__bmp = args[1]
|
|
|
|
|
|
__swig_destroy__ = _gdi_.delete_BufferedDC
|
|
__del__ = lambda self : None;
|
|
def UnMask(*args, **kwargs):
|
|
"""
|
|
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)
|
|
|
|
def SetStyle(*args, **kwargs):
|
|
"""SetStyle(self, int style)"""
|
|
return _gdi_.BufferedDC_SetStyle(*args, **kwargs)
|
|
|
|
def GetStyle(*args, **kwargs):
|
|
"""GetStyle(self) -> int"""
|
|
return _gdi_.BufferedDC_GetStyle(*args, **kwargs)
|
|
|
|
_gdi_.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)
|
|
|
|
|
|
|
|
"""
|
|
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))
|
|
if len(args) > 1: self.__bmp = args[1]
|
|
|
|
_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class AutoBufferedPaintDC(DC):
|
|
"""
|
|
If the current platform double buffers by default then this DC is the
|
|
same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
|
|
|
|
:see: `wx.AutoBufferedPaintDCFactory`
|
|
|
|
"""
|
|
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) -> AutoBufferedPaintDC
|
|
|
|
If the current platform double buffers by default then this DC is the
|
|
same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
|
|
|
|
:see: `wx.AutoBufferedPaintDCFactory`
|
|
|
|
"""
|
|
_gdi_.AutoBufferedPaintDC_swiginit(self,_gdi_.new_AutoBufferedPaintDC(*args, **kwargs))
|
|
_gdi_.AutoBufferedPaintDC_swigregister(AutoBufferedPaintDC)
|
|
|
|
|
|
def AutoBufferedPaintDCFactory(*args, **kwargs):
|
|
"""
|
|
AutoBufferedPaintDCFactory(Window window) -> DC
|
|
|
|
Checks if the window is natively double buffered and will return a
|
|
`wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise. The advantage of
|
|
this function over `wx.AutoBufferedPaintDC` is that this function will check
|
|
if the the specified window has double-buffering enabled rather than just
|
|
going by platform defaults.
|
|
"""
|
|
return _gdi_.AutoBufferedPaintDCFactory(*args, **kwargs)
|
|
#---------------------------------------------------------------------------
|
|
|
|
class MirrorDC(DC):
|
|
"""
|
|
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))
|
|
_gdi_.MirrorDC_swigregister(MirrorDC)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class PostScriptDC(DC):
|
|
"""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)
|
|
|
|
def SetPrintData(*args, **kwargs):
|
|
"""SetPrintData(self, wxPrintData data)"""
|
|
return _gdi_.PostScriptDC_SetPrintData(*args, **kwargs)
|
|
|
|
def SetResolution(*args, **kwargs):
|
|
"""
|
|
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):
|
|
"""
|
|
GetResolution() -> int
|
|
|
|
Return resolution used in PostScript output.
|
|
"""
|
|
return _gdi_.PostScriptDC_GetResolution(*args, **kwargs)
|
|
|
|
GetResolution = staticmethod(GetResolution)
|
|
PrintData = property(GetPrintData,SetPrintData,doc="See `GetPrintData` and `SetPrintData`")
|
|
_gdi_.PostScriptDC_swigregister(PostScriptDC)
|
|
|
|
def 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
|
|
|
|
Return resolution used in PostScript output.
|
|
"""
|
|
return _gdi_.PostScriptDC_GetResolution(*args)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class MetaFile(_core.Object):
|
|
"""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"""
|
|
_gdi_.MetaFile_swiginit(self,_gdi_.new_MetaFile(*args, **kwargs))
|
|
_gdi_.MetaFile_swigregister(MetaFile)
|
|
|
|
class MetaFileDC(DC):
|
|
"""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
|
|
"""
|
|
_gdi_.MetaFileDC_swiginit(self,_gdi_.new_MetaFileDC(*args, **kwargs))
|
|
_gdi_.MetaFileDC_swigregister(MetaFileDC)
|
|
|
|
class PrinterDC(DC):
|
|
"""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"""
|
|
_gdi_.PrinterDC_swiginit(self,_gdi_.new_PrinterDC(*args, **kwargs))
|
|
_gdi_.PrinterDC_swigregister(PrinterDC)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class GraphicsObject(_core.Object):
|
|
"""
|
|
This class is the superclass of native graphics objects like pens
|
|
etc. It provides the internal reference counting. It is not to be
|
|
instantiated by user code.
|
|
"""
|
|
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, GraphicsRenderer renderer=None) -> GraphicsObject
|
|
|
|
This class is the superclass of native graphics objects like pens
|
|
etc. It provides the internal reference counting. It is not to be
|
|
instantiated by user code.
|
|
"""
|
|
_gdi_.GraphicsObject_swiginit(self,_gdi_.new_GraphicsObject(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_GraphicsObject
|
|
__del__ = lambda self : None;
|
|
def IsNull(*args, **kwargs):
|
|
"""
|
|
IsNull(self) -> bool
|
|
|
|
Is this object valid (false) or still empty (true)?
|
|
"""
|
|
return _gdi_.GraphicsObject_IsNull(*args, **kwargs)
|
|
|
|
def GetRenderer(*args, **kwargs):
|
|
"""
|
|
GetRenderer(self) -> GraphicsRenderer
|
|
|
|
Returns the renderer that was used to create this instance, or
|
|
``None`` if it has not been initialized yet.
|
|
"""
|
|
return _gdi_.GraphicsObject_GetRenderer(*args, **kwargs)
|
|
|
|
_gdi_.GraphicsObject_swigregister(GraphicsObject)
|
|
|
|
class GraphicsPen(GraphicsObject):
|
|
"""
|
|
A wx.GraphicsPen is a native representation of a pen. It is used for
|
|
stroking a path on a `wx.GraphicsContext`. The contents are specific and
|
|
private to the respective renderer. The only way to get a valid instance
|
|
is via a CreatePen call on the graphics context or the renderer
|
|
instance.
|
|
"""
|
|
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) -> GraphicsPen
|
|
|
|
A wx.GraphicsPen is a native representation of a pen. It is used for
|
|
stroking a path on a `wx.GraphicsContext`. The contents are specific and
|
|
private to the respective renderer. The only way to get a valid instance
|
|
is via a CreatePen call on the graphics context or the renderer
|
|
instance.
|
|
"""
|
|
_gdi_.GraphicsPen_swiginit(self,_gdi_.new_GraphicsPen(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_GraphicsPen
|
|
__del__ = lambda self : None;
|
|
_gdi_.GraphicsPen_swigregister(GraphicsPen)
|
|
|
|
class GraphicsBrush(GraphicsObject):
|
|
"""
|
|
A wx.GraphicsBrush is a native representation of a brush. It is used
|
|
for filling a path on a `wx.GraphicsContext`. The contents are
|
|
specific and private to the respective renderer. The only way to get a
|
|
valid instance is via a Create...Brush call on the graphics context or
|
|
the renderer instance.
|
|
"""
|
|
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) -> GraphicsBrush
|
|
|
|
A wx.GraphicsBrush is a native representation of a brush. It is used
|
|
for filling a path on a `wx.GraphicsContext`. The contents are
|
|
specific and private to the respective renderer. The only way to get a
|
|
valid instance is via a Create...Brush call on the graphics context or
|
|
the renderer instance.
|
|
"""
|
|
_gdi_.GraphicsBrush_swiginit(self,_gdi_.new_GraphicsBrush(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_GraphicsBrush
|
|
__del__ = lambda self : None;
|
|
_gdi_.GraphicsBrush_swigregister(GraphicsBrush)
|
|
|
|
class GraphicsFont(GraphicsObject):
|
|
"""
|
|
A `wx.GraphicsFont` is a native representation of a font (including
|
|
text colour). The contents are specific an private to the respective
|
|
renderer. The only way to get a valid instance is via a CreateFont
|
|
call on the graphics context or the renderer instance.
|
|
"""
|
|
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) -> GraphicsFont
|
|
|
|
A `wx.GraphicsFont` is a native representation of a font (including
|
|
text colour). The contents are specific an private to the respective
|
|
renderer. The only way to get a valid instance is via a CreateFont
|
|
call on the graphics context or the renderer instance.
|
|
"""
|
|
_gdi_.GraphicsFont_swiginit(self,_gdi_.new_GraphicsFont(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_GraphicsFont
|
|
__del__ = lambda self : None;
|
|
_gdi_.GraphicsFont_swigregister(GraphicsFont)
|
|
|
|
class GraphicsMatrix(GraphicsObject):
|
|
"""
|
|
A wx.GraphicsMatrix is a native representation of an affine
|
|
matrix. The contents are specific and private to the respective
|
|
renderer. The only way to get a valid instance is via a CreateMatrix
|
|
call on the graphics context or the renderer instance.
|
|
"""
|
|
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_GraphicsMatrix
|
|
__del__ = lambda self : None;
|
|
def Concat(*args, **kwargs):
|
|
"""
|
|
Concat(self, GraphicsMatrix t)
|
|
|
|
Concatenates the passed in matrix to the current matrix.
|
|
"""
|
|
return _gdi_.GraphicsMatrix_Concat(*args, **kwargs)
|
|
|
|
def Set(*args, **kwargs):
|
|
"""
|
|
Set(self, Double a=1.0, Double b=0.0, Double c=0.0, Double d=1.0,
|
|
Double tx=0.0, Double ty=0.0)
|
|
|
|
Sets the matrix to the specified values (default values are the
|
|
identity matrix.)
|
|
"""
|
|
return _gdi_.GraphicsMatrix_Set(*args, **kwargs)
|
|
|
|
def Get(*args, **kwargs):
|
|
"""
|
|
Get(self) --> (a, b, c, d, tx, ty)
|
|
|
|
Gets the component values of the matrix and returns them as a tuple.
|
|
"""
|
|
return _gdi_.GraphicsMatrix_Get(*args, **kwargs)
|
|
|
|
def Invert(*args, **kwargs):
|
|
"""
|
|
Invert(self)
|
|
|
|
Inverts the matrix.
|
|
"""
|
|
return _gdi_.GraphicsMatrix_Invert(*args, **kwargs)
|
|
|
|
def IsEqual(*args, **kwargs):
|
|
"""
|
|
IsEqual(self, GraphicsMatrix t) -> bool
|
|
|
|
Returns ``True`` if the elements of the transformation matrix are
|
|
equal
|
|
"""
|
|
return _gdi_.GraphicsMatrix_IsEqual(*args, **kwargs)
|
|
|
|
def IsIdentity(*args, **kwargs):
|
|
"""
|
|
IsIdentity(self) -> bool
|
|
|
|
Returns ``True`` if this is the identity matrix
|
|
"""
|
|
return _gdi_.GraphicsMatrix_IsIdentity(*args, **kwargs)
|
|
|
|
def Translate(*args, **kwargs):
|
|
"""
|
|
Translate(self, Double dx, Double dy)
|
|
|
|
Add a translation to this matrix.
|
|
"""
|
|
return _gdi_.GraphicsMatrix_Translate(*args, **kwargs)
|
|
|
|
def Scale(*args, **kwargs):
|
|
"""
|
|
Scale(self, Double xScale, Double yScale)
|
|
|
|
Scales this matrix.
|
|
"""
|
|
return _gdi_.GraphicsMatrix_Scale(*args, **kwargs)
|
|
|
|
def Rotate(*args, **kwargs):
|
|
"""
|
|
Rotate(self, Double angle)
|
|
|
|
Rotates this matrix. The angle should be specified in radians.
|
|
"""
|
|
return _gdi_.GraphicsMatrix_Rotate(*args, **kwargs)
|
|
|
|
def TransformPoint(*args, **kwargs):
|
|
"""
|
|
TransformPoint(self, x, y) --> (x, y)
|
|
|
|
Applies this matrix to a point, returns the resulting point values
|
|
"""
|
|
return _gdi_.GraphicsMatrix_TransformPoint(*args, **kwargs)
|
|
|
|
def TransformDistance(*args, **kwargs):
|
|
"""
|
|
TransformDistance(self, dx, dy) --> (dx, dy)
|
|
|
|
Applies this matrix to a distance (ie. performs all transforms except
|
|
translations)
|
|
"""
|
|
return _gdi_.GraphicsMatrix_TransformDistance(*args, **kwargs)
|
|
|
|
def GetNativeMatrix(*args, **kwargs):
|
|
"""
|
|
GetNativeMatrix(self) -> void
|
|
|
|
Returns the native representation of the matrix. For CoreGraphics this
|
|
is a CFAffineMatrix pointer. For GDIPlus a Matrix Pointer and for
|
|
Cairo a cairo_matrix_t pointer. NOTE: For wxPython we still need a
|
|
way to make this value usable.
|
|
"""
|
|
return _gdi_.GraphicsMatrix_GetNativeMatrix(*args, **kwargs)
|
|
|
|
_gdi_.GraphicsMatrix_swigregister(GraphicsMatrix)
|
|
|
|
class GraphicsPath(GraphicsObject):
|
|
"""Proxy of C++ GraphicsPath 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
|
|
__swig_destroy__ = _gdi_.delete_GraphicsPath
|
|
__del__ = lambda self : None;
|
|
def MoveToPoint(*args):
|
|
"""
|
|
MoveToPoint(self, Double x, Double y)
|
|
MoveToPoint(self, Point2D p)
|
|
|
|
Begins a new subpath at the specified point.
|
|
"""
|
|
return _gdi_.GraphicsPath_MoveToPoint(*args)
|
|
|
|
def AddLineToPoint(*args):
|
|
"""
|
|
AddLineToPoint(self, Double x, Double y)
|
|
AddLineToPoint(self, Point2D p)
|
|
|
|
Adds a straight line from the current point to the specified point.
|
|
"""
|
|
return _gdi_.GraphicsPath_AddLineToPoint(*args)
|
|
|
|
def AddCurveToPoint(*args):
|
|
"""
|
|
AddCurveToPoint(self, Double cx1, Double cy1, Double cx2, Double cy2, Double x,
|
|
Double y)
|
|
AddCurveToPoint(self, Point2D c1, Point2D c2, Point2D e)
|
|
|
|
Adds a cubic Bezier curve from the current point, using two control
|
|
points and an end point
|
|
"""
|
|
return _gdi_.GraphicsPath_AddCurveToPoint(*args)
|
|
|
|
def AddPath(*args, **kwargs):
|
|
"""
|
|
AddPath(self, GraphicsPath path)
|
|
|
|
Adds another path
|
|
"""
|
|
return _gdi_.GraphicsPath_AddPath(*args, **kwargs)
|
|
|
|
def CloseSubpath(*args, **kwargs):
|
|
"""
|
|
CloseSubpath(self)
|
|
|
|
Closes the current sub-path.
|
|
"""
|
|
return _gdi_.GraphicsPath_CloseSubpath(*args, **kwargs)
|
|
|
|
def GetCurrentPoint(*args, **kwargs):
|
|
"""
|
|
GetCurrentPoint(self) -> Point2D
|
|
|
|
Gets the last point of the current path, (0,0) if not yet set
|
|
"""
|
|
return _gdi_.GraphicsPath_GetCurrentPoint(*args, **kwargs)
|
|
|
|
def AddArc(*args):
|
|
"""
|
|
AddArc(self, Double x, Double y, Double r, Double startAngle, Double endAngle,
|
|
bool clockwise=True)
|
|
AddArc(self, Point2D c, Double r, Double startAngle, Double endAngle,
|
|
bool clockwise=True)
|
|
|
|
Adds an arc of a circle centering at (x,y) with radius (r) from
|
|
startAngle to endAngle
|
|
"""
|
|
return _gdi_.GraphicsPath_AddArc(*args)
|
|
|
|
def AddQuadCurveToPoint(*args, **kwargs):
|
|
"""
|
|
AddQuadCurveToPoint(self, Double cx, Double cy, Double x, Double y)
|
|
|
|
Adds a quadratic Bezier curve from the current point, using a control
|
|
point and an end point
|
|
"""
|
|
return _gdi_.GraphicsPath_AddQuadCurveToPoint(*args, **kwargs)
|
|
|
|
def AddRectangle(*args, **kwargs):
|
|
"""
|
|
AddRectangle(self, Double x, Double y, Double w, Double h)
|
|
|
|
Appends a rectangle as a new closed subpath.
|
|
"""
|
|
return _gdi_.GraphicsPath_AddRectangle(*args, **kwargs)
|
|
|
|
def AddCircle(*args, **kwargs):
|
|
"""
|
|
AddCircle(self, Double x, Double y, Double r)
|
|
|
|
Appends a circle around (x,y) with radius r as a new closed subpath.
|
|
"""
|
|
return _gdi_.GraphicsPath_AddCircle(*args, **kwargs)
|
|
|
|
def AddArcToPoint(*args, **kwargs):
|
|
"""
|
|
AddArcToPoint(self, Double x1, Double y1, Double x2, Double y2, Double r)
|
|
|
|
Appends an arc to two tangents connecting (current) to (x1,y1) and
|
|
(x1,y1) to (x2,y2), also a straight line from (current) to (x1,y1)
|
|
"""
|
|
return _gdi_.GraphicsPath_AddArcToPoint(*args, **kwargs)
|
|
|
|
def AddEllipse(*args, **kwargs):
|
|
"""
|
|
AddEllipse(self, Double x, Double y, Double w, Double h)
|
|
|
|
Appends an ellipse fitting into the passed in rectangle.
|
|
"""
|
|
return _gdi_.GraphicsPath_AddEllipse(*args, **kwargs)
|
|
|
|
def AddRoundedRectangle(*args, **kwargs):
|
|
"""
|
|
AddRoundedRectangle(self, Double x, Double y, Double w, Double h, Double radius)
|
|
|
|
Appends a rounded rectangle.
|
|
"""
|
|
return _gdi_.GraphicsPath_AddRoundedRectangle(*args, **kwargs)
|
|
|
|
def GetNativePath(*args, **kwargs):
|
|
"""
|
|
GetNativePath(self) -> void
|
|
|
|
Returns the native path (CGPathRef for Core Graphics, Path pointer for
|
|
GDIPlus and a cairo_path_t pointer for cairo). NOTE: For wxPython we
|
|
still need a way to make this value usable.
|
|
"""
|
|
return _gdi_.GraphicsPath_GetNativePath(*args, **kwargs)
|
|
|
|
def UnGetNativePath(*args, **kwargs):
|
|
"""
|
|
UnGetNativePath(self, void p)
|
|
|
|
Gives back the native path returned by GetNativePath() because there
|
|
might be some deallocations necessary (eg on cairo the native path
|
|
returned by GetNativePath is newly allocated each time).
|
|
"""
|
|
return _gdi_.GraphicsPath_UnGetNativePath(*args, **kwargs)
|
|
|
|
def Transform(*args, **kwargs):
|
|
"""
|
|
Transform(self, GraphicsMatrix matrix)
|
|
|
|
Transforms each point of this path by the matrix
|
|
"""
|
|
return _gdi_.GraphicsPath_Transform(*args, **kwargs)
|
|
|
|
def GetBox(*args, **kwargs):
|
|
"""
|
|
GetBox(self) -> Rect2D
|
|
|
|
Gets the bounding box enclosing all points (possibly including control
|
|
points)
|
|
"""
|
|
return _gdi_.GraphicsPath_GetBox(*args, **kwargs)
|
|
|
|
def Contains(*args):
|
|
"""
|
|
Contains(self, Double x, Double y, int fillStyle=ODDEVEN_RULE) -> bool
|
|
Contains(self, Point2D c, int fillStyle=ODDEVEN_RULE) -> bool
|
|
|
|
Returns ``True`` if the point is within the path.
|
|
"""
|
|
return _gdi_.GraphicsPath_Contains(*args)
|
|
|
|
_gdi_.GraphicsPath_swigregister(GraphicsPath)
|
|
|
|
class GraphicsContext(GraphicsObject):
|
|
"""
|
|
A `wx.GraphicsContext` instance is the object that is drawn upon. It is
|
|
created by a renderer using the CreateContext calls, this can be done
|
|
either directly using a renderer instance, or indirectly using the
|
|
static convenience CreateXXX functions of wx.GraphicsContext that
|
|
always delegate the task to the default renderer.
|
|
"""
|
|
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_GraphicsContext
|
|
__del__ = lambda self : None;
|
|
def Create(*args):
|
|
"""
|
|
Create(WindowDC dc) -> GraphicsContext
|
|
Create(Window window) -> GraphicsContext
|
|
|
|
Creates a wx.GraphicsContext either from a window or a DC.
|
|
"""
|
|
val = _gdi_.GraphicsContext_Create(*args)
|
|
val.__dc = args[0] # save a ref so the dc will not be deleted before self
|
|
return val
|
|
|
|
Create = staticmethod(Create)
|
|
def CreateMeasuringContext(*args):
|
|
"""
|
|
CreateMeasuringContext() -> GraphicsContext
|
|
|
|
Create a lightwieght context that can be used for measuring text only.
|
|
"""
|
|
val = _gdi_.GraphicsContext_CreateMeasuringContext(*args)
|
|
val.__dc = args[0] # save a ref so the dc will not be deleted before self
|
|
return val
|
|
|
|
CreateMeasuringContext = staticmethod(CreateMeasuringContext)
|
|
def CreateFromNative(*args, **kwargs):
|
|
"""
|
|
CreateFromNative(void context) -> GraphicsContext
|
|
|
|
Creates a wx.GraphicsContext from a native context. This native
|
|
context must be eg a CGContextRef for Core Graphics, a Graphics
|
|
pointer for GDIPlus or a cairo_t pointer for Cairo.
|
|
"""
|
|
return _gdi_.GraphicsContext_CreateFromNative(*args, **kwargs)
|
|
|
|
CreateFromNative = staticmethod(CreateFromNative)
|
|
def CreateFromNativeWindow(*args, **kwargs):
|
|
"""
|
|
CreateFromNativeWindow(void window) -> GraphicsContext
|
|
|
|
Creates a wx.GraphicsContext from a native window.
|
|
"""
|
|
return _gdi_.GraphicsContext_CreateFromNativeWindow(*args, **kwargs)
|
|
|
|
CreateFromNativeWindow = staticmethod(CreateFromNativeWindow)
|
|
def CreatePath(*args, **kwargs):
|
|
"""
|
|
CreatePath(self) -> GraphicsPath
|
|
|
|
Creates a native graphics path which is initially empty.
|
|
"""
|
|
return _gdi_.GraphicsContext_CreatePath(*args, **kwargs)
|
|
|
|
def CreatePen(*args, **kwargs):
|
|
"""
|
|
CreatePen(self, Pen pen) -> GraphicsPen
|
|
|
|
Creates a native pen from a `wx.Pen`.
|
|
"""
|
|
return _gdi_.GraphicsContext_CreatePen(*args, **kwargs)
|
|
|
|
def CreateBrush(*args, **kwargs):
|
|
"""
|
|
CreateBrush(self, Brush brush) -> GraphicsBrush
|
|
|
|
Creates a native brush from a `wx.Brush`.
|
|
"""
|
|
return _gdi_.GraphicsContext_CreateBrush(*args, **kwargs)
|
|
|
|
def CreateLinearGradientBrush(*args, **kwargs):
|
|
"""
|
|
CreateLinearGradientBrush(self, Double x1, Double y1, Double x2, Double y2, Colour c1,
|
|
Colour c2) -> GraphicsBrush
|
|
|
|
Creates a native brush, having a linear gradient, starting at (x1,y1)
|
|
with color c1 to (x2,y2) with color c2.
|
|
"""
|
|
return _gdi_.GraphicsContext_CreateLinearGradientBrush(*args, **kwargs)
|
|
|
|
def CreateRadialGradientBrush(*args, **kwargs):
|
|
"""
|
|
CreateRadialGradientBrush(self, Double xo, Double yo, Double xc, Double yc, Double radius,
|
|
Colour oColor, Colour cColor) -> GraphicsBrush
|
|
|
|
Creates a native brush, having a radial gradient originating at point
|
|
(xo,yc) with color oColour and ends on a circle around (xc,yc) with
|
|
radius r and color cColour.
|
|
"""
|
|
return _gdi_.GraphicsContext_CreateRadialGradientBrush(*args, **kwargs)
|
|
|
|
def CreateFont(*args, **kwargs):
|
|
"""
|
|
CreateFont(self, Font font, Colour col=*wxBLACK) -> GraphicsFont
|
|
|
|
Creates a native graphics font from a `wx.Font` and a text colour.
|
|
"""
|
|
return _gdi_.GraphicsContext_CreateFont(*args, **kwargs)
|
|
|
|
def CreateMatrix(*args, **kwargs):
|
|
"""
|
|
CreateMatrix(self, Double a=1.0, Double b=0.0, Double c=0.0, Double d=1.0,
|
|
Double tx=0.0, Double ty=0.0) -> GraphicsMatrix
|
|
|
|
Creates a native affine transformation matrix from the passed in
|
|
values. The defaults result in an identity matrix.
|
|
"""
|
|
return _gdi_.GraphicsContext_CreateMatrix(*args, **kwargs)
|
|
|
|
def PushState(*args, **kwargs):
|
|
"""
|
|
PushState(self)
|
|
|
|
Push the current state of the context, (ie the transformation matrix)
|
|
on a stack
|
|
"""
|
|
return _gdi_.GraphicsContext_PushState(*args, **kwargs)
|
|
|
|
def PopState(*args, **kwargs):
|
|
"""
|
|
PopState(self)
|
|
|
|
Pops a stored state from the stack
|
|
"""
|
|
return _gdi_.GraphicsContext_PopState(*args, **kwargs)
|
|
|
|
def ClipRegion(*args, **kwargs):
|
|
"""
|
|
ClipRegion(self, Region region)
|
|
|
|
Clips drawings to the region, combined to current clipping region.
|
|
"""
|
|
return _gdi_.GraphicsContext_ClipRegion(*args, **kwargs)
|
|
|
|
def Clip(*args, **kwargs):
|
|
"""
|
|
Clip(self, Double x, Double y, Double w, Double h)
|
|
|
|
Clips drawings to the rectangle.
|
|
"""
|
|
return _gdi_.GraphicsContext_Clip(*args, **kwargs)
|
|
|
|
def ResetClip(*args, **kwargs):
|
|
"""
|
|
ResetClip(self)
|
|
|
|
Resets the clipping to original shape.
|
|
"""
|
|
return _gdi_.GraphicsContext_ResetClip(*args, **kwargs)
|
|
|
|
def GetNativeContext(*args, **kwargs):
|
|
"""
|
|
GetNativeContext(self) -> void
|
|
|
|
Returns the native context (CGContextRef for Core Graphics, Graphics
|
|
pointer for GDIPlus and cairo_t pointer for cairo).
|
|
"""
|
|
return _gdi_.GraphicsContext_GetNativeContext(*args, **kwargs)
|
|
|
|
def GetLogicalFunction(*args, **kwargs):
|
|
"""
|
|
GetLogicalFunction(self) -> int
|
|
|
|
Returns the current logical function.
|
|
"""
|
|
return _gdi_.GraphicsContext_GetLogicalFunction(*args, **kwargs)
|
|
|
|
def SetLogicalFunction(*args, **kwargs):
|
|
"""
|
|
SetLogicalFunction(self, int function) -> bool
|
|
|
|
Sets the current logical function, returns ``True`` if it supported
|
|
"""
|
|
return _gdi_.GraphicsContext_SetLogicalFunction(*args, **kwargs)
|
|
|
|
def Translate(*args, **kwargs):
|
|
"""
|
|
Translate(self, Double dx, Double dy)
|
|
|
|
Translates the current transformation matrix.
|
|
"""
|
|
return _gdi_.GraphicsContext_Translate(*args, **kwargs)
|
|
|
|
def Scale(*args, **kwargs):
|
|
"""
|
|
Scale(self, Double xScale, Double yScale)
|
|
|
|
Scale the current transformation matrix of the context.
|
|
"""
|
|
return _gdi_.GraphicsContext_Scale(*args, **kwargs)
|
|
|
|
def Rotate(*args, **kwargs):
|
|
"""
|
|
Rotate(self, Double angle)
|
|
|
|
Rotate the current transformation matrix of the context. ``angle`` is
|
|
specified in radians.
|
|
"""
|
|
return _gdi_.GraphicsContext_Rotate(*args, **kwargs)
|
|
|
|
def ConcatTransform(*args, **kwargs):
|
|
"""
|
|
ConcatTransform(self, GraphicsMatrix matrix)
|
|
|
|
Concatenates the passed in transform with the current transform of
|
|
this context.
|
|
"""
|
|
return _gdi_.GraphicsContext_ConcatTransform(*args, **kwargs)
|
|
|
|
def SetTransform(*args, **kwargs):
|
|
"""
|
|
SetTransform(self, GraphicsMatrix matrix)
|
|
|
|
Sets the current transform of this context.
|
|
"""
|
|
return _gdi_.GraphicsContext_SetTransform(*args, **kwargs)
|
|
|
|
def GetTransform(*args, **kwargs):
|
|
"""
|
|
GetTransform(self) -> GraphicsMatrix
|
|
|
|
Gets the current transformation matrix of this context.
|
|
"""
|
|
return _gdi_.GraphicsContext_GetTransform(*args, **kwargs)
|
|
|
|
def SetPen(*args):
|
|
"""
|
|
SetPen(self, GraphicsPen pen)
|
|
SetPen(self, Pen pen)
|
|
|
|
Sets the stroke pen
|
|
"""
|
|
return _gdi_.GraphicsContext_SetPen(*args)
|
|
|
|
def SetBrush(*args):
|
|
"""
|
|
SetBrush(self, GraphicsBrush brush)
|
|
SetBrush(self, Brush brush)
|
|
|
|
Sets the brush for filling
|
|
"""
|
|
return _gdi_.GraphicsContext_SetBrush(*args)
|
|
|
|
def SetFont(*args):
|
|
"""
|
|
SetFont(self, GraphicsFont font)
|
|
SetFont(self, Font font, Colour colour=*wxBLACK)
|
|
|
|
Sets the font
|
|
"""
|
|
return _gdi_.GraphicsContext_SetFont(*args)
|
|
|
|
def StrokePath(*args, **kwargs):
|
|
"""
|
|
StrokePath(self, GraphicsPath path)
|
|
|
|
Strokes along a path with the current pen.
|
|
"""
|
|
return _gdi_.GraphicsContext_StrokePath(*args, **kwargs)
|
|
|
|
def FillPath(*args, **kwargs):
|
|
"""
|
|
FillPath(self, GraphicsPath path, int fillStyle=ODDEVEN_RULE)
|
|
|
|
Fills a path with the current brush.
|
|
"""
|
|
return _gdi_.GraphicsContext_FillPath(*args, **kwargs)
|
|
|
|
def DrawPath(*args, **kwargs):
|
|
"""
|
|
DrawPath(self, GraphicsPath path, int fillStyle=ODDEVEN_RULE)
|
|
|
|
Draws the path by first filling and then stroking.
|
|
"""
|
|
return _gdi_.GraphicsContext_DrawPath(*args, **kwargs)
|
|
|
|
def DrawText(*args, **kwargs):
|
|
"""
|
|
DrawText(self, String str, Double x, Double y, GraphicsBrush backgroundBrush=NullGraphicsBrush)
|
|
|
|
Draws a text string at the defined position.
|
|
"""
|
|
return _gdi_.GraphicsContext_DrawText(*args, **kwargs)
|
|
|
|
def DrawRotatedText(*args, **kwargs):
|
|
"""
|
|
DrawRotatedText(self, String str, Double x, Double y, Double angle, GraphicsBrush backgroundBrush=NullGraphicsBrush)
|
|
|
|
Draws a text string at the defined position, at the specified angle,
|
|
which is given in radians.
|
|
"""
|
|
return _gdi_.GraphicsContext_DrawRotatedText(*args, **kwargs)
|
|
|
|
def GetFullTextExtent(*args, **kwargs):
|
|
"""
|
|
GetFullTextExtent(self, text) --> (width, height, descent, externalLeading)
|
|
|
|
Gets the dimensions of the string using the currently selected
|
|
font. ``text`` is the string to measure, ``w`` and ``h`` are the total
|
|
width and height respectively, ``descent`` is the dimension from the
|
|
baseline of the font to the bottom of the descender, and
|
|
``externalLeading`` is any extra vertical space added to the font by
|
|
the font designer (usually is zero).
|
|
"""
|
|
return _gdi_.GraphicsContext_GetFullTextExtent(*args, **kwargs)
|
|
|
|
def GetTextExtent(*args, **kwargs):
|
|
"""
|
|
GetTextExtent(self, text) --> (width, height)
|
|
|
|
Gets the dimensions of the string using the currently selected
|
|
font. ``text`` is the string to measure, ``w`` and ``h`` are the total
|
|
width and height respectively.
|
|
"""
|
|
return _gdi_.GraphicsContext_GetTextExtent(*args, **kwargs)
|
|
|
|
def GetPartialTextExtents(*args, **kwargs):
|
|
"""
|
|
GetPartialTextExtents(self, text) -> [widths]
|
|
|
|
Returns a list of widths from the beginning of ``text`` to the
|
|
coresponding character in ``text``.
|
|
"""
|
|
return _gdi_.GraphicsContext_GetPartialTextExtents(*args, **kwargs)
|
|
|
|
def DrawBitmap(*args, **kwargs):
|
|
"""
|
|
DrawBitmap(self, Bitmap bmp, Double x, Double y, Double w, Double h)
|
|
|
|
Draws the bitmap. In case of a mono bitmap, this is treated as a mask
|
|
and the current brush is used for filling.
|
|
"""
|
|
return _gdi_.GraphicsContext_DrawBitmap(*args, **kwargs)
|
|
|
|
def DrawIcon(*args, **kwargs):
|
|
"""
|
|
DrawIcon(self, Icon icon, Double x, Double y, Double w, Double h)
|
|
|
|
Draws the icon.
|
|
"""
|
|
return _gdi_.GraphicsContext_DrawIcon(*args, **kwargs)
|
|
|
|
def StrokeLine(*args, **kwargs):
|
|
"""
|
|
StrokeLine(self, Double x1, Double y1, Double x2, Double y2)
|
|
|
|
Strokes a single line.
|
|
"""
|
|
return _gdi_.GraphicsContext_StrokeLine(*args, **kwargs)
|
|
|
|
def StrokeLines(*args, **kwargs):
|
|
"""
|
|
StrokeLines(self, List points)
|
|
|
|
Stroke lines connecting each of the points
|
|
"""
|
|
return _gdi_.GraphicsContext_StrokeLines(*args, **kwargs)
|
|
|
|
def StrokeLineSegements(*args, **kwargs):
|
|
"""
|
|
StrokeLineSegements(self, PyObject beginPoints, PyObject endPoints)
|
|
|
|
Stroke disconnected lines from begin to end points
|
|
"""
|
|
return _gdi_.GraphicsContext_StrokeLineSegements(*args, **kwargs)
|
|
|
|
def DrawLines(*args, **kwargs):
|
|
"""
|
|
DrawLines(self, size_t points, int fillStyle=ODDEVEN_RULE)
|
|
|
|
Draws a polygon.
|
|
"""
|
|
return _gdi_.GraphicsContext_DrawLines(*args, **kwargs)
|
|
|
|
def DrawRectangle(*args, **kwargs):
|
|
"""
|
|
DrawRectangle(self, Double x, Double y, Double w, Double h)
|
|
|
|
Draws a rectangle.
|
|
"""
|
|
return _gdi_.GraphicsContext_DrawRectangle(*args, **kwargs)
|
|
|
|
def DrawEllipse(*args, **kwargs):
|
|
"""
|
|
DrawEllipse(self, Double x, Double y, Double w, Double h)
|
|
|
|
Draws an ellipse.
|
|
"""
|
|
return _gdi_.GraphicsContext_DrawEllipse(*args, **kwargs)
|
|
|
|
def DrawRoundedRectangle(*args, **kwargs):
|
|
"""
|
|
DrawRoundedRectangle(self, Double x, Double y, Double w, Double h, Double radius)
|
|
|
|
Draws a rounded rectangle
|
|
"""
|
|
return _gdi_.GraphicsContext_DrawRoundedRectangle(*args, **kwargs)
|
|
|
|
def ShouldOffset(*args, **kwargs):
|
|
"""
|
|
ShouldOffset(self) -> bool
|
|
|
|
helper to determine if a 0.5 offset should be applied for the drawing operation
|
|
"""
|
|
return _gdi_.GraphicsContext_ShouldOffset(*args, **kwargs)
|
|
|
|
_gdi_.GraphicsContext_swigregister(GraphicsContext)
|
|
cvar = _gdi_.cvar
|
|
NullGraphicsPen = cvar.NullGraphicsPen
|
|
NullGraphicsBrush = cvar.NullGraphicsBrush
|
|
NullGraphicsFont = cvar.NullGraphicsFont
|
|
NullGraphicsMatrix = cvar.NullGraphicsMatrix
|
|
NullGraphicsPath = cvar.NullGraphicsPath
|
|
|
|
def GraphicsContext_Create(*args):
|
|
"""
|
|
Create(WindowDC dc) -> GraphicsContext
|
|
GraphicsContext_Create(Window window) -> GraphicsContext
|
|
|
|
Creates a wx.GraphicsContext either from a window or a DC.
|
|
"""
|
|
val = _gdi_.GraphicsContext_Create(*args)
|
|
val.__dc = args[0] # save a ref so the dc will not be deleted before self
|
|
return val
|
|
|
|
def GraphicsContext_CreateMeasuringContext(*args):
|
|
"""
|
|
GraphicsContext_CreateMeasuringContext() -> GraphicsContext
|
|
|
|
Create a lightwieght context that can be used for measuring text only.
|
|
"""
|
|
val = _gdi_.GraphicsContext_CreateMeasuringContext(*args)
|
|
val.__dc = args[0] # save a ref so the dc will not be deleted before self
|
|
return val
|
|
|
|
def GraphicsContext_CreateFromNative(*args, **kwargs):
|
|
"""
|
|
GraphicsContext_CreateFromNative(void context) -> GraphicsContext
|
|
|
|
Creates a wx.GraphicsContext from a native context. This native
|
|
context must be eg a CGContextRef for Core Graphics, a Graphics
|
|
pointer for GDIPlus or a cairo_t pointer for Cairo.
|
|
"""
|
|
return _gdi_.GraphicsContext_CreateFromNative(*args, **kwargs)
|
|
|
|
def GraphicsContext_CreateFromNativeWindow(*args, **kwargs):
|
|
"""
|
|
GraphicsContext_CreateFromNativeWindow(void window) -> GraphicsContext
|
|
|
|
Creates a wx.GraphicsContext from a native window.
|
|
"""
|
|
return _gdi_.GraphicsContext_CreateFromNativeWindow(*args, **kwargs)
|
|
|
|
class GraphicsRenderer(_core.Object):
|
|
"""Proxy of C++ GraphicsRenderer 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
|
|
__swig_destroy__ = _gdi_.delete_GraphicsRenderer
|
|
__del__ = lambda self : None;
|
|
def GetDefaultRenderer(*args, **kwargs):
|
|
"""GetDefaultRenderer() -> GraphicsRenderer"""
|
|
return _gdi_.GraphicsRenderer_GetDefaultRenderer(*args, **kwargs)
|
|
|
|
GetDefaultRenderer = staticmethod(GetDefaultRenderer)
|
|
def CreateContext(*args):
|
|
"""
|
|
CreateContext(self, WindowDC dc) -> GraphicsContext
|
|
CreateContext(self, Window window) -> GraphicsContext
|
|
"""
|
|
return _gdi_.GraphicsRenderer_CreateContext(*args)
|
|
|
|
def CreateMeasuringContext(*args, **kwargs):
|
|
"""CreateMeasuringContext(self) -> GraphicsContext"""
|
|
return _gdi_.GraphicsRenderer_CreateMeasuringContext(*args, **kwargs)
|
|
|
|
def CreateContextFromNativeContext(*args, **kwargs):
|
|
"""CreateContextFromNativeContext(self, void context) -> GraphicsContext"""
|
|
return _gdi_.GraphicsRenderer_CreateContextFromNativeContext(*args, **kwargs)
|
|
|
|
def CreateContextFromNativeWindow(*args, **kwargs):
|
|
"""CreateContextFromNativeWindow(self, void window) -> GraphicsContext"""
|
|
return _gdi_.GraphicsRenderer_CreateContextFromNativeWindow(*args, **kwargs)
|
|
|
|
def CreatePath(*args, **kwargs):
|
|
"""CreatePath(self) -> GraphicsPath"""
|
|
return _gdi_.GraphicsRenderer_CreatePath(*args, **kwargs)
|
|
|
|
def CreateMatrix(*args, **kwargs):
|
|
"""
|
|
CreateMatrix(self, Double a=1.0, Double b=0.0, Double c=0.0, Double d=1.0,
|
|
Double tx=0.0, Double ty=0.0) -> GraphicsMatrix
|
|
"""
|
|
return _gdi_.GraphicsRenderer_CreateMatrix(*args, **kwargs)
|
|
|
|
def CreatePen(*args, **kwargs):
|
|
"""CreatePen(self, Pen pen) -> GraphicsPen"""
|
|
return _gdi_.GraphicsRenderer_CreatePen(*args, **kwargs)
|
|
|
|
def CreateBrush(*args, **kwargs):
|
|
"""CreateBrush(self, Brush brush) -> GraphicsBrush"""
|
|
return _gdi_.GraphicsRenderer_CreateBrush(*args, **kwargs)
|
|
|
|
def CreateLinearGradientBrush(*args, **kwargs):
|
|
"""
|
|
CreateLinearGradientBrush(self, Double x1, Double y1, Double x2, Double y2, Colour c1,
|
|
Colour c2) -> GraphicsBrush
|
|
"""
|
|
return _gdi_.GraphicsRenderer_CreateLinearGradientBrush(*args, **kwargs)
|
|
|
|
def CreateRadialGradientBrush(*args, **kwargs):
|
|
"""
|
|
CreateRadialGradientBrush(self, Double xo, Double yo, Double xc, Double yc, Double radius,
|
|
Colour oColor, Colour cColor) -> GraphicsBrush
|
|
"""
|
|
return _gdi_.GraphicsRenderer_CreateRadialGradientBrush(*args, **kwargs)
|
|
|
|
def CreateFont(*args, **kwargs):
|
|
"""CreateFont(self, Font font, Colour col=*wxBLACK) -> GraphicsFont"""
|
|
return _gdi_.GraphicsRenderer_CreateFont(*args, **kwargs)
|
|
|
|
_gdi_.GraphicsRenderer_swigregister(GraphicsRenderer)
|
|
|
|
def GraphicsRenderer_GetDefaultRenderer(*args):
|
|
"""GraphicsRenderer_GetDefaultRenderer() -> GraphicsRenderer"""
|
|
return _gdi_.GraphicsRenderer_GetDefaultRenderer(*args)
|
|
|
|
class GCDC(DC):
|
|
"""Proxy of C++ GCDC 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):
|
|
"""
|
|
__init__(self, WindowDC dc) -> GCDC
|
|
__init__(self, Window window) -> GCDC
|
|
"""
|
|
_gdi_.GCDC_swiginit(self,_gdi_.new_GCDC(*args))
|
|
self.__dc = args[0] # save a ref so the other dc will not be deleted before self
|
|
|
|
__swig_destroy__ = _gdi_.delete_GCDC
|
|
__del__ = lambda self : None;
|
|
def GetGraphicsContext(*args, **kwargs):
|
|
"""GetGraphicsContext(self) -> GraphicsContext"""
|
|
return _gdi_.GCDC_GetGraphicsContext(*args, **kwargs)
|
|
|
|
def SetGraphicsContext(*args, **kwargs):
|
|
"""SetGraphicsContext(self, GraphicsContext ctx)"""
|
|
return _gdi_.GCDC_SetGraphicsContext(*args, **kwargs)
|
|
|
|
GraphicsContext = property(GetGraphicsContext,SetGraphicsContext)
|
|
_gdi_.GCDC_swigregister(GCDC)
|
|
|
|
class Overlay(object):
|
|
"""Proxy of C++ Overlay 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) -> Overlay"""
|
|
_gdi_.Overlay_swiginit(self,_gdi_.new_Overlay(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_Overlay
|
|
__del__ = lambda self : None;
|
|
def Reset(*args, **kwargs):
|
|
"""Reset(self)"""
|
|
return _gdi_.Overlay_Reset(*args, **kwargs)
|
|
|
|
_gdi_.Overlay_swigregister(Overlay)
|
|
|
|
class DCOverlay(object):
|
|
"""Proxy of C++ DCOverlay 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):
|
|
"""
|
|
__init__(self, Overlay overlay, WindowDC dc, int x, int y, int width,
|
|
int height) -> DCOverlay
|
|
__init__(self, Overlay overlay, WindowDC dc) -> DCOverlay
|
|
"""
|
|
_gdi_.DCOverlay_swiginit(self,_gdi_.new_DCOverlay(*args))
|
|
__swig_destroy__ = _gdi_.delete_DCOverlay
|
|
__del__ = lambda self : None;
|
|
def Clear(*args, **kwargs):
|
|
"""Clear(self)"""
|
|
return _gdi_.DCOverlay_Clear(*args, **kwargs)
|
|
|
|
_gdi_.DCOverlay_swigregister(DCOverlay)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
IMAGELIST_DRAW_NORMAL = _gdi_.IMAGELIST_DRAW_NORMAL
|
|
IMAGELIST_DRAW_TRANSPARENT = _gdi_.IMAGELIST_DRAW_TRANSPARENT
|
|
IMAGELIST_DRAW_SELECTED = _gdi_.IMAGELIST_DRAW_SELECTED
|
|
IMAGELIST_DRAW_FOCUSED = _gdi_.IMAGELIST_DRAW_FOCUSED
|
|
IMAGE_LIST_NORMAL = _gdi_.IMAGE_LIST_NORMAL
|
|
IMAGE_LIST_SMALL = _gdi_.IMAGE_LIST_SMALL
|
|
IMAGE_LIST_STATE = _gdi_.IMAGE_LIST_STATE
|
|
class ImageList(_core.Object):
|
|
"""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"""
|
|
_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)
|
|
|
|
def AddWithColourMask(*args, **kwargs):
|
|
"""AddWithColourMask(self, Bitmap bitmap, Colour maskColour) -> int"""
|
|
return _gdi_.ImageList_AddWithColourMask(*args, **kwargs)
|
|
|
|
def AddIcon(*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, Bitmap mask=NullBitmap) -> bool"""
|
|
return _gdi_.ImageList_Replace(*args, **kwargs)
|
|
|
|
def Draw(*args, **kwargs):
|
|
"""
|
|
Draw(self, int index, DC dc, int x, int x, int flags=IMAGELIST_DRAW_NORMAL,
|
|
bool solidBackground=False) -> bool
|
|
"""
|
|
return _gdi_.ImageList_Draw(*args, **kwargs)
|
|
|
|
def GetImageCount(*args, **kwargs):
|
|
"""GetImageCount(self) -> int"""
|
|
return _gdi_.ImageList_GetImageCount(*args, **kwargs)
|
|
|
|
def Remove(*args, **kwargs):
|
|
"""Remove(self, int index) -> bool"""
|
|
return _gdi_.ImageList_Remove(*args, **kwargs)
|
|
|
|
def RemoveAll(*args, **kwargs):
|
|
"""RemoveAll(self) -> bool"""
|
|
return _gdi_.ImageList_RemoveAll(*args, **kwargs)
|
|
|
|
def GetSize(*args, **kwargs):
|
|
"""GetSize(index) -> (width,height)"""
|
|
return _gdi_.ImageList_GetSize(*args, **kwargs)
|
|
|
|
ImageCount = property(GetImageCount,doc="See `GetImageCount`")
|
|
Size = property(GetSize,doc="See `GetSize`")
|
|
_gdi_.ImageList_swigregister(ImageList)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class StockGDI(object):
|
|
"""Proxy of C++ StockGDI class"""
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
|
|
__repr__ = _swig_repr
|
|
BRUSH_BLACK = _gdi_.StockGDI_BRUSH_BLACK
|
|
BRUSH_BLUE = _gdi_.StockGDI_BRUSH_BLUE
|
|
BRUSH_CYAN = _gdi_.StockGDI_BRUSH_CYAN
|
|
BRUSH_GREEN = _gdi_.StockGDI_BRUSH_GREEN
|
|
BRUSH_GREY = _gdi_.StockGDI_BRUSH_GREY
|
|
BRUSH_LIGHTGREY = _gdi_.StockGDI_BRUSH_LIGHTGREY
|
|
BRUSH_MEDIUMGREY = _gdi_.StockGDI_BRUSH_MEDIUMGREY
|
|
BRUSH_RED = _gdi_.StockGDI_BRUSH_RED
|
|
BRUSH_TRANSPARENT = _gdi_.StockGDI_BRUSH_TRANSPARENT
|
|
BRUSH_WHITE = _gdi_.StockGDI_BRUSH_WHITE
|
|
COLOUR_BLACK = _gdi_.StockGDI_COLOUR_BLACK
|
|
COLOUR_BLUE = _gdi_.StockGDI_COLOUR_BLUE
|
|
COLOUR_CYAN = _gdi_.StockGDI_COLOUR_CYAN
|
|
COLOUR_GREEN = _gdi_.StockGDI_COLOUR_GREEN
|
|
COLOUR_LIGHTGREY = _gdi_.StockGDI_COLOUR_LIGHTGREY
|
|
COLOUR_RED = _gdi_.StockGDI_COLOUR_RED
|
|
COLOUR_WHITE = _gdi_.StockGDI_COLOUR_WHITE
|
|
CURSOR_CROSS = _gdi_.StockGDI_CURSOR_CROSS
|
|
CURSOR_HOURGLASS = _gdi_.StockGDI_CURSOR_HOURGLASS
|
|
CURSOR_STANDARD = _gdi_.StockGDI_CURSOR_STANDARD
|
|
FONT_ITALIC = _gdi_.StockGDI_FONT_ITALIC
|
|
FONT_NORMAL = _gdi_.StockGDI_FONT_NORMAL
|
|
FONT_SMALL = _gdi_.StockGDI_FONT_SMALL
|
|
FONT_SWISS = _gdi_.StockGDI_FONT_SWISS
|
|
PEN_BLACK = _gdi_.StockGDI_PEN_BLACK
|
|
PEN_BLACKDASHED = _gdi_.StockGDI_PEN_BLACKDASHED
|
|
PEN_CYAN = _gdi_.StockGDI_PEN_CYAN
|
|
PEN_GREEN = _gdi_.StockGDI_PEN_GREEN
|
|
PEN_GREY = _gdi_.StockGDI_PEN_GREY
|
|
PEN_LIGHTGREY = _gdi_.StockGDI_PEN_LIGHTGREY
|
|
PEN_MEDIUMGREY = _gdi_.StockGDI_PEN_MEDIUMGREY
|
|
PEN_RED = _gdi_.StockGDI_PEN_RED
|
|
PEN_TRANSPARENT = _gdi_.StockGDI_PEN_TRANSPARENT
|
|
PEN_WHITE = _gdi_.StockGDI_PEN_WHITE
|
|
ITEMCOUNT = _gdi_.StockGDI_ITEMCOUNT
|
|
def __init__(self, *args, **kwargs):
|
|
"""__init__(self) -> StockGDI"""
|
|
_gdi_.StockGDI_swiginit(self,_gdi_.new_StockGDI(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_StockGDI
|
|
__del__ = lambda self : None;
|
|
def DeleteAll(*args, **kwargs):
|
|
"""DeleteAll()"""
|
|
return _gdi_.StockGDI_DeleteAll(*args, **kwargs)
|
|
|
|
DeleteAll = staticmethod(DeleteAll)
|
|
def instance(*args, **kwargs):
|
|
"""instance() -> StockGDI"""
|
|
return _gdi_.StockGDI_instance(*args, **kwargs)
|
|
|
|
instance = staticmethod(instance)
|
|
def GetBrush(*args, **kwargs):
|
|
"""GetBrush(int item) -> Brush"""
|
|
return _gdi_.StockGDI_GetBrush(*args, **kwargs)
|
|
|
|
GetBrush = staticmethod(GetBrush)
|
|
def GetColour(*args, **kwargs):
|
|
"""GetColour(int item) -> Colour"""
|
|
return _gdi_.StockGDI_GetColour(*args, **kwargs)
|
|
|
|
GetColour = staticmethod(GetColour)
|
|
def GetCursor(*args, **kwargs):
|
|
"""GetCursor(int item) -> Cursor"""
|
|
return _gdi_.StockGDI_GetCursor(*args, **kwargs)
|
|
|
|
GetCursor = staticmethod(GetCursor)
|
|
def GetPen(*args, **kwargs):
|
|
"""GetPen(int item) -> Pen"""
|
|
return _gdi_.StockGDI_GetPen(*args, **kwargs)
|
|
|
|
GetPen = staticmethod(GetPen)
|
|
def GetFont(*args, **kwargs):
|
|
"""GetFont(self, int item) -> Font"""
|
|
return _gdi_.StockGDI_GetFont(*args, **kwargs)
|
|
|
|
def _initStockObjects():
|
|
import wx
|
|
wx.ITALIC_FONT.this = StockGDI.instance().GetFont(StockGDI.FONT_ITALIC).this
|
|
wx.NORMAL_FONT.this = StockGDI.instance().GetFont(StockGDI.FONT_NORMAL).this
|
|
wx.SMALL_FONT.this = StockGDI.instance().GetFont(StockGDI.FONT_SMALL).this
|
|
wx.SWISS_FONT.this = StockGDI.instance().GetFont(StockGDI.FONT_SWISS).this
|
|
|
|
wx.BLACK_DASHED_PEN.this = StockGDI.GetPen(StockGDI.PEN_BLACKDASHED).this
|
|
wx.BLACK_PEN.this = StockGDI.GetPen(StockGDI.PEN_BLACK).this
|
|
wx.CYAN_PEN.this = StockGDI.GetPen(StockGDI.PEN_CYAN).this
|
|
wx.GREEN_PEN.this = StockGDI.GetPen(StockGDI.PEN_GREEN).this
|
|
wx.GREY_PEN.this = StockGDI.GetPen(StockGDI.PEN_GREY).this
|
|
wx.LIGHT_GREY_PEN.this = StockGDI.GetPen(StockGDI.PEN_LIGHTGREY).this
|
|
wx.MEDIUM_GREY_PEN.this = StockGDI.GetPen(StockGDI.PEN_MEDIUMGREY).this
|
|
wx.RED_PEN.this = StockGDI.GetPen(StockGDI.PEN_RED).this
|
|
wx.TRANSPARENT_PEN.this = StockGDI.GetPen(StockGDI.PEN_TRANSPARENT).this
|
|
wx.WHITE_PEN.this = StockGDI.GetPen(StockGDI.PEN_WHITE).this
|
|
|
|
wx.BLACK_BRUSH.this = StockGDI.GetBrush(StockGDI.BRUSH_BLACK).this
|
|
wx.BLUE_BRUSH.this = StockGDI.GetBrush(StockGDI.BRUSH_BLUE).this
|
|
wx.CYAN_BRUSH.this = StockGDI.GetBrush(StockGDI.BRUSH_CYAN).this
|
|
wx.GREEN_BRUSH.this = StockGDI.GetBrush(StockGDI.BRUSH_GREEN).this
|
|
wx.GREY_BRUSH.this = StockGDI.GetBrush(StockGDI.BRUSH_GREY).this
|
|
wx.LIGHT_GREY_BRUSH.this = StockGDI.GetBrush(StockGDI.BRUSH_LIGHTGREY).this
|
|
wx.MEDIUM_GREY_BRUSH.this = StockGDI.GetBrush(StockGDI.BRUSH_MEDIUMGREY).this
|
|
wx.RED_BRUSH.this = StockGDI.GetBrush(StockGDI.BRUSH_RED).this
|
|
wx.TRANSPARENT_BRUSH.this = StockGDI.GetBrush(StockGDI.BRUSH_TRANSPARENT).this
|
|
wx.WHITE_BRUSH.this = StockGDI.GetBrush(StockGDI.BRUSH_WHITE).this
|
|
|
|
wx.BLACK.this = StockGDI.GetColour(StockGDI.COLOUR_BLACK).this
|
|
wx.BLUE.this = StockGDI.GetColour(StockGDI.COLOUR_BLUE).this
|
|
wx.CYAN.this = StockGDI.GetColour(StockGDI.COLOUR_CYAN).this
|
|
wx.GREEN.this = StockGDI.GetColour(StockGDI.COLOUR_GREEN).this
|
|
wx.LIGHT_GREY.this = StockGDI.GetColour(StockGDI.COLOUR_LIGHTGREY).this
|
|
wx.RED.this = StockGDI.GetColour(StockGDI.COLOUR_RED).this
|
|
wx.WHITE.this = StockGDI.GetColour(StockGDI.COLOUR_WHITE).this
|
|
|
|
wx.CROSS_CURSOR.this = StockGDI.GetCursor(StockGDI.CURSOR_CROSS).this
|
|
wx.HOURGLASS_CURSOR.this = StockGDI.GetCursor(StockGDI.CURSOR_HOURGLASS).this
|
|
wx.STANDARD_CURSOR.this = StockGDI.GetCursor(StockGDI.CURSOR_STANDARD).this
|
|
|
|
wx.TheFontList.this = _wxPyInitTheFontList().this
|
|
wx.ThePenList.this = _wxPyInitThePenList().this
|
|
wx.TheBrushList.this = _wxPyInitTheBrushList().this
|
|
wx.TheColourDatabase.this = _wxPyInitTheColourDatabase().this
|
|
|
|
|
|
_initStockObjects = staticmethod(_initStockObjects)
|
|
|
|
_gdi_.StockGDI_swigregister(StockGDI)
|
|
|
|
def StockGDI_DeleteAll(*args):
|
|
"""StockGDI_DeleteAll()"""
|
|
return _gdi_.StockGDI_DeleteAll(*args)
|
|
|
|
def StockGDI_instance(*args):
|
|
"""StockGDI_instance() -> StockGDI"""
|
|
return _gdi_.StockGDI_instance(*args)
|
|
|
|
def StockGDI_GetBrush(*args, **kwargs):
|
|
"""StockGDI_GetBrush(int item) -> Brush"""
|
|
return _gdi_.StockGDI_GetBrush(*args, **kwargs)
|
|
|
|
def StockGDI_GetColour(*args, **kwargs):
|
|
"""StockGDI_GetColour(int item) -> Colour"""
|
|
return _gdi_.StockGDI_GetColour(*args, **kwargs)
|
|
|
|
def StockGDI_GetCursor(*args, **kwargs):
|
|
"""StockGDI_GetCursor(int item) -> Cursor"""
|
|
return _gdi_.StockGDI_GetCursor(*args, **kwargs)
|
|
|
|
def StockGDI_GetPen(*args, **kwargs):
|
|
"""StockGDI_GetPen(int item) -> Pen"""
|
|
return _gdi_.StockGDI_GetPen(*args, **kwargs)
|
|
|
|
# Create an uninitialized instance for the stock objects, they will
|
|
# be initialized later when the wx.App object is created.
|
|
ITALIC_FONT = Font.__new__(Font)
|
|
NORMAL_FONT = Font.__new__(Font)
|
|
SMALL_FONT = Font.__new__(Font)
|
|
SWISS_FONT = Font.__new__(Font)
|
|
|
|
BLACK_DASHED_PEN = Pen.__new__(Pen)
|
|
BLACK_PEN = Pen.__new__(Pen)
|
|
CYAN_PEN = Pen.__new__(Pen)
|
|
GREEN_PEN = Pen.__new__(Pen)
|
|
GREY_PEN = Pen.__new__(Pen)
|
|
LIGHT_GREY_PEN = Pen.__new__(Pen)
|
|
MEDIUM_GREY_PEN = Pen.__new__(Pen)
|
|
RED_PEN = Pen.__new__(Pen)
|
|
TRANSPARENT_PEN = Pen.__new__(Pen)
|
|
WHITE_PEN = Pen.__new__(Pen)
|
|
|
|
BLACK_BRUSH = Brush.__new__(Brush)
|
|
BLUE_BRUSH = Brush.__new__(Brush)
|
|
CYAN_BRUSH = Brush.__new__(Brush)
|
|
GREEN_BRUSH = Brush.__new__(Brush)
|
|
GREY_BRUSH = Brush.__new__(Brush)
|
|
LIGHT_GREY_BRUSH = Brush.__new__(Brush)
|
|
MEDIUM_GREY_BRUSH = Brush.__new__(Brush)
|
|
RED_BRUSH = Brush.__new__(Brush)
|
|
TRANSPARENT_BRUSH = Brush.__new__(Brush)
|
|
WHITE_BRUSH = Brush.__new__(Brush)
|
|
|
|
BLACK = Colour.__new__(Colour)
|
|
BLUE = Colour.__new__(Colour)
|
|
CYAN = Colour.__new__(Colour)
|
|
GREEN = Colour.__new__(Colour)
|
|
LIGHT_GREY = Colour.__new__(Colour)
|
|
RED = Colour.__new__(Colour)
|
|
WHITE = Colour.__new__(Colour)
|
|
|
|
CROSS_CURSOR = Cursor.__new__(Cursor)
|
|
HOURGLASS_CURSOR = Cursor.__new__(Cursor)
|
|
STANDARD_CURSOR = Cursor.__new__(Cursor)
|
|
|
|
class GDIObjListBase(object):
|
|
"""Proxy of C++ GDIObjListBase 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) -> GDIObjListBase"""
|
|
_gdi_.GDIObjListBase_swiginit(self,_gdi_.new_GDIObjListBase(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_GDIObjListBase
|
|
__del__ = lambda self : None;
|
|
_gdi_.GDIObjListBase_swigregister(GDIObjListBase)
|
|
NullBitmap = cvar.NullBitmap
|
|
NullIcon = cvar.NullIcon
|
|
NullCursor = cvar.NullCursor
|
|
NullPen = cvar.NullPen
|
|
NullBrush = cvar.NullBrush
|
|
NullPalette = cvar.NullPalette
|
|
NullFont = cvar.NullFont
|
|
NullColour = cvar.NullColour
|
|
|
|
class PenList(GDIObjListBase):
|
|
"""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 FindOrCreatePen(*args, **kwargs):
|
|
"""FindOrCreatePen(self, Colour colour, int width, int style) -> Pen"""
|
|
return _gdi_.PenList_FindOrCreatePen(*args, **kwargs)
|
|
|
|
def AddPen(*args, **kwargs):
|
|
"""AddPen(self, Pen pen)"""
|
|
return _gdi_.PenList_AddPen(*args, **kwargs)
|
|
|
|
def RemovePen(*args, **kwargs):
|
|
"""RemovePen(self, Pen pen)"""
|
|
return _gdi_.PenList_RemovePen(*args, **kwargs)
|
|
|
|
AddPen = wx._deprecated(AddPen)
|
|
RemovePen = wx._deprecated(RemovePen)
|
|
|
|
_gdi_.PenList_swigregister(PenList)
|
|
|
|
class BrushList(GDIObjListBase):
|
|
"""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 FindOrCreateBrush(*args, **kwargs):
|
|
"""FindOrCreateBrush(self, Colour colour, int style=SOLID) -> Brush"""
|
|
return _gdi_.BrushList_FindOrCreateBrush(*args, **kwargs)
|
|
|
|
def AddBrush(*args, **kwargs):
|
|
"""AddBrush(self, Brush brush)"""
|
|
return _gdi_.BrushList_AddBrush(*args, **kwargs)
|
|
|
|
def RemoveBrush(*args, **kwargs):
|
|
"""RemoveBrush(self, Brush brush)"""
|
|
return _gdi_.BrushList_RemoveBrush(*args, **kwargs)
|
|
|
|
AddBrush = wx._deprecated(AddBrush)
|
|
RemoveBrush = wx._deprecated(RemoveBrush)
|
|
|
|
_gdi_.BrushList_swigregister(BrushList)
|
|
|
|
class FontList(GDIObjListBase):
|
|
"""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 FindOrCreateFont(*args, **kwargs):
|
|
"""
|
|
FindOrCreateFont(self, int point_size, int family, int style, int weight,
|
|
bool underline=False, String facename=EmptyString,
|
|
int encoding=FONTENCODING_DEFAULT) -> Font
|
|
"""
|
|
return _gdi_.FontList_FindOrCreateFont(*args, **kwargs)
|
|
|
|
def AddFont(*args, **kwargs):
|
|
"""AddFont(self, Font font)"""
|
|
return _gdi_.FontList_AddFont(*args, **kwargs)
|
|
|
|
def RemoveFont(*args, **kwargs):
|
|
"""RemoveFont(self, Font font)"""
|
|
return _gdi_.FontList_RemoveFont(*args, **kwargs)
|
|
|
|
AddFont = wx._deprecated(AddFont)
|
|
RemoveFont = wx._deprecated(RemoveFont)
|
|
|
|
_gdi_.FontList_swigregister(FontList)
|
|
|
|
class ColourDatabase(object):
|
|
"""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"""
|
|
_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)
|
|
|
|
def FindName(*args, **kwargs):
|
|
"""FindName(self, Colour colour) -> String"""
|
|
return _gdi_.ColourDatabase_FindName(*args, **kwargs)
|
|
|
|
FindColour = Find
|
|
def AddColour(*args, **kwargs):
|
|
"""AddColour(self, String name, Colour colour)"""
|
|
return _gdi_.ColourDatabase_AddColour(*args, **kwargs)
|
|
|
|
def Append(*args, **kwargs):
|
|
"""Append(self, String name, int red, int green, int blue)"""
|
|
return _gdi_.ColourDatabase_Append(*args, **kwargs)
|
|
|
|
_gdi_.ColourDatabase_swigregister(ColourDatabase)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
|
|
def _wxPyInitTheFontList(*args):
|
|
"""_wxPyInitTheFontList() -> FontList"""
|
|
return _gdi_._wxPyInitTheFontList(*args)
|
|
|
|
def _wxPyInitThePenList(*args):
|
|
"""_wxPyInitThePenList() -> PenList"""
|
|
return _gdi_._wxPyInitThePenList(*args)
|
|
|
|
def _wxPyInitTheBrushList(*args):
|
|
"""_wxPyInitTheBrushList() -> BrushList"""
|
|
return _gdi_._wxPyInitTheBrushList(*args)
|
|
|
|
def _wxPyInitTheColourDatabase(*args):
|
|
"""_wxPyInitTheColourDatabase() -> ColourDatabase"""
|
|
return _gdi_._wxPyInitTheColourDatabase(*args)
|
|
# Create an uninitialized instance for the stock objects, they will
|
|
# be initialized later when the wx.App object is created.
|
|
TheFontList = FontList.__new__(FontList)
|
|
ThePenList = PenList.__new__(PenList)
|
|
TheBrushList = BrushList.__new__(BrushList)
|
|
TheColourDatabase = ColourDatabase.__new__(ColourDatabase)
|
|
|
|
NullColor = NullColour
|
|
#---------------------------------------------------------------------------
|
|
|
|
class Effects(_core.Object):
|
|
"""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"""
|
|
_gdi_.Effects_swiginit(self,_gdi_.new_Effects(*args, **kwargs))
|
|
def GetHighlightColour(*args, **kwargs):
|
|
"""GetHighlightColour(self) -> Colour"""
|
|
return _gdi_.Effects_GetHighlightColour(*args, **kwargs)
|
|
|
|
def GetLightShadow(*args, **kwargs):
|
|
"""GetLightShadow(self) -> Colour"""
|
|
return _gdi_.Effects_GetLightShadow(*args, **kwargs)
|
|
|
|
def GetFaceColour(*args, **kwargs):
|
|
"""GetFaceColour(self) -> Colour"""
|
|
return _gdi_.Effects_GetFaceColour(*args, **kwargs)
|
|
|
|
def GetMediumShadow(*args, **kwargs):
|
|
"""GetMediumShadow(self) -> Colour"""
|
|
return _gdi_.Effects_GetMediumShadow(*args, **kwargs)
|
|
|
|
def GetDarkShadow(*args, **kwargs):
|
|
"""GetDarkShadow(self) -> Colour"""
|
|
return _gdi_.Effects_GetDarkShadow(*args, **kwargs)
|
|
|
|
def SetHighlightColour(*args, **kwargs):
|
|
"""SetHighlightColour(self, Colour c)"""
|
|
return _gdi_.Effects_SetHighlightColour(*args, **kwargs)
|
|
|
|
def SetLightShadow(*args, **kwargs):
|
|
"""SetLightShadow(self, Colour c)"""
|
|
return _gdi_.Effects_SetLightShadow(*args, **kwargs)
|
|
|
|
def SetFaceColour(*args, **kwargs):
|
|
"""SetFaceColour(self, Colour c)"""
|
|
return _gdi_.Effects_SetFaceColour(*args, **kwargs)
|
|
|
|
def SetMediumShadow(*args, **kwargs):
|
|
"""SetMediumShadow(self, Colour c)"""
|
|
return _gdi_.Effects_SetMediumShadow(*args, **kwargs)
|
|
|
|
def SetDarkShadow(*args, **kwargs):
|
|
"""SetDarkShadow(self, Colour c)"""
|
|
return _gdi_.Effects_SetDarkShadow(*args, **kwargs)
|
|
|
|
def Set(*args, **kwargs):
|
|
"""
|
|
Set(self, Colour highlightColour, Colour lightShadow, Colour faceColour,
|
|
Colour mediumShadow, Colour darkShadow)
|
|
"""
|
|
return _gdi_.Effects_Set(*args, **kwargs)
|
|
|
|
def DrawSunkenEdge(*args, **kwargs):
|
|
"""DrawSunkenEdge(self, DC dc, Rect rect, int borderSize=1)"""
|
|
return _gdi_.Effects_DrawSunkenEdge(*args, **kwargs)
|
|
|
|
def TileBitmap(*args, **kwargs):
|
|
"""TileBitmap(self, Rect rect, DC dc, Bitmap bitmap) -> bool"""
|
|
return _gdi_.Effects_TileBitmap(*args, **kwargs)
|
|
|
|
DarkShadow = property(GetDarkShadow,SetDarkShadow,doc="See `GetDarkShadow` and `SetDarkShadow`")
|
|
FaceColour = property(GetFaceColour,SetFaceColour,doc="See `GetFaceColour` and `SetFaceColour`")
|
|
HighlightColour = property(GetHighlightColour,SetHighlightColour,doc="See `GetHighlightColour` and `SetHighlightColour`")
|
|
LightShadow = property(GetLightShadow,SetLightShadow,doc="See `GetLightShadow` and `SetLightShadow`")
|
|
MediumShadow = property(GetMediumShadow,SetMediumShadow,doc="See `GetMediumShadow` and `SetMediumShadow`")
|
|
_gdi_.Effects_swigregister(Effects)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
CONTROL_DISABLED = _gdi_.CONTROL_DISABLED
|
|
CONTROL_FOCUSED = _gdi_.CONTROL_FOCUSED
|
|
CONTROL_PRESSED = _gdi_.CONTROL_PRESSED
|
|
CONTROL_SPECIAL = _gdi_.CONTROL_SPECIAL
|
|
CONTROL_ISDEFAULT = _gdi_.CONTROL_ISDEFAULT
|
|
CONTROL_ISSUBMENU = _gdi_.CONTROL_ISSUBMENU
|
|
CONTROL_EXPANDED = _gdi_.CONTROL_EXPANDED
|
|
CONTROL_SIZEGRIP = _gdi_.CONTROL_SIZEGRIP
|
|
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)
|
|
_gdi_.SplitterRenderParams_swigregister(SplitterRenderParams)
|
|
|
|
class HeaderButtonParams(object):
|
|
"""Extra (optional) parameters for `wx.RendererNative.DrawHeaderButton`"""
|
|
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) -> HeaderButtonParams
|
|
|
|
Extra (optional) parameters for `wx.RendererNative.DrawHeaderButton`
|
|
"""
|
|
_gdi_.HeaderButtonParams_swiginit(self,_gdi_.new_HeaderButtonParams(*args, **kwargs))
|
|
__swig_destroy__ = _gdi_.delete_HeaderButtonParams
|
|
__del__ = lambda self : None;
|
|
m_arrowColour = property(_gdi_.HeaderButtonParams_m_arrowColour_get, _gdi_.HeaderButtonParams_m_arrowColour_set)
|
|
m_selectionColour = property(_gdi_.HeaderButtonParams_m_selectionColour_get, _gdi_.HeaderButtonParams_m_selectionColour_set)
|
|
m_labelText = property(_gdi_.HeaderButtonParams_m_labelText_get, _gdi_.HeaderButtonParams_m_labelText_set)
|
|
m_labelFont = property(_gdi_.HeaderButtonParams_m_labelFont_get, _gdi_.HeaderButtonParams_m_labelFont_set)
|
|
m_labelColour = property(_gdi_.HeaderButtonParams_m_labelColour_get, _gdi_.HeaderButtonParams_m_labelColour_set)
|
|
m_labelBitmap = property(_gdi_.HeaderButtonParams_m_labelBitmap_get, _gdi_.HeaderButtonParams_m_labelBitmap_set)
|
|
m_labelAlignment = property(_gdi_.HeaderButtonParams_m_labelAlignment_get, _gdi_.HeaderButtonParams_m_labelAlignment_set)
|
|
_gdi_.HeaderButtonParams_swigregister(HeaderButtonParams)
|
|
|
|
HDR_SORT_ICON_NONE = _gdi_.HDR_SORT_ICON_NONE
|
|
HDR_SORT_ICON_UP = _gdi_.HDR_SORT_ICON_UP
|
|
HDR_SORT_ICON_DOWN = _gdi_.HDR_SORT_ICON_DOWN
|
|
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)
|
|
_gdi_.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 as possible 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.
|
|
|
|
Note that each drawing function restores the `wx.DC` attributes if it
|
|
changes them, so it is safe to assume that the same pen, brush and
|
|
colours that were active before the call to this function are still in
|
|
effect after it.
|
|
|
|
"""
|
|
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, int sortArrow=HDR_SORT_ICON_NONE,
|
|
HeaderButtonParams params=None) -> int
|
|
|
|
Draw a header control button (such as what is used by `wx.ListCtrl` in report
|
|
mode.) The optimal size of the label (text and icons) is returned.
|
|
"""
|
|
return _gdi_.RendererNative_DrawHeaderButton(*args, **kwargs)
|
|
|
|
def DrawHeaderButtonContents(*args, **kwargs):
|
|
"""
|
|
DrawHeaderButtonContents(self, Window win, DC dc, Rect rect, int flags=0, int sortArrow=HDR_SORT_ICON_NONE,
|
|
HeaderButtonParams params=None) -> int
|
|
|
|
Draw the contents of a header control button, (label, sort
|
|
arrows, etc.) Normally this is only called by `DrawHeaderButton`.
|
|
"""
|
|
return _gdi_.RendererNative_DrawHeaderButtonContents(*args, **kwargs)
|
|
|
|
def GetHeaderButtonHeight(*args, **kwargs):
|
|
"""
|
|
GetHeaderButtonHeight(self, Window win) -> int
|
|
|
|
Returns the default height of a header button, either a fixed platform
|
|
height if available, or a generic height based on the window's font.
|
|
"""
|
|
return _gdi_.RendererNative_GetHeaderButtonHeight(*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 DrawCheckBox(*args, **kwargs):
|
|
"""
|
|
DrawCheckBox(self, Window win, DC dc, Rect rect, int flags=0)
|
|
|
|
Draw a check button. Flags may use wx.CONTROL_CHECKED,
|
|
wx.CONTROL_UNDETERMINED and wx.CONTROL_CURRENT.
|
|
"""
|
|
return _gdi_.RendererNative_DrawCheckBox(*args, **kwargs)
|
|
|
|
def DrawPushButton(*args, **kwargs):
|
|
"""
|
|
DrawPushButton(self, Window win, DC dc, Rect rect, int flags=0)
|
|
|
|
Draw a blank button. Flags may be wx.CONTROL_PRESSED, wx.CONTROL_CURRENT and
|
|
wx.CONTROL_ISDEFAULT
|
|
"""
|
|
return _gdi_.RendererNative_DrawPushButton(*args, **kwargs)
|
|
|
|
def DrawItemSelectionRect(*args, **kwargs):
|
|
"""
|
|
DrawItemSelectionRect(self, Window win, DC dc, Rect rect, int flags=0)
|
|
|
|
Draw rectangle indicating that an item in e.g. a list control has been
|
|
selected or focused
|
|
|
|
The flags parameter may be:
|
|
|
|
==================== ============================================
|
|
wx.CONTROL_SELECTED item is selected, e.g. draw background
|
|
wx.CONTROL_CURRENT item is the current item, e.g. dotted border
|
|
wx.CONTROL_FOCUSED the whole control has focus, e.g. blue
|
|
background vs. grey otherwise
|
|
==================== ============================================
|
|
|
|
"""
|
|
return _gdi_.RendererNative_DrawItemSelectionRect(*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
|
|
`wx.RendererNative.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
|
|
`wx.RendererNative.Set` in which case the return value of this method
|
|
may be different from the return value of `wx.RendererNative.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)
|
|
|
|
SplitterParams = property(GetSplitterParams,doc="See `GetSplitterParams`")
|
|
Version = property(GetVersion,doc="See `GetVersion`")
|
|
_gdi_.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
|
|
`wx.RendererNative.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
|
|
`wx.RendererNative.Set` in which case the return value of this method
|
|
may be different from the return value of `wx.RendererNative.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)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class PseudoDC(_core.Object):
|
|
"""
|
|
A PseudoDC is an object that can be used as if it were a `wx.DC`. All
|
|
commands issued to the PseudoDC are stored in a list. You can then
|
|
play these commands back to a real DC object using the DrawToDC
|
|
method. Commands in the command list are indexed by ID. You can use
|
|
this to clear the operations associated with a single ID and then
|
|
re-draw the object associated with that ID.
|
|
"""
|
|
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) -> PseudoDC
|
|
|
|
Constructs a new Pseudo device context for recording dc operations
|
|
"""
|
|
_gdi_.PseudoDC_swiginit(self,_gdi_.new_PseudoDC(*args, **kwargs))
|
|
def BeginDrawing(*args, **kwargs):
|
|
"""
|
|
BeginDrawing(self)
|
|
|
|
Allows for optimization of drawing code on platforms that need it. On
|
|
other platforms this is just an empty function and is harmless. To
|
|
take advantage of this postential optimization simply enclose each
|
|
group of calls to the drawing primitives within calls to
|
|
`BeginDrawing` and `EndDrawing`.
|
|
"""
|
|
return _gdi_.PseudoDC_BeginDrawing(*args, **kwargs)
|
|
|
|
def EndDrawing(*args, **kwargs):
|
|
"""
|
|
EndDrawing(self)
|
|
|
|
Ends the group of drawing primitives started with `BeginDrawing`, and
|
|
invokes whatever optimization is available for this DC type on the
|
|
current platform.
|
|
"""
|
|
return _gdi_.PseudoDC_EndDrawing(*args, **kwargs)
|
|
|
|
__swig_destroy__ = _gdi_.delete_PseudoDC
|
|
__del__ = lambda self : None;
|
|
def RemoveAll(*args, **kwargs):
|
|
"""
|
|
RemoveAll(self)
|
|
|
|
Removes all objects and operations from the recorded list.
|
|
"""
|
|
return _gdi_.PseudoDC_RemoveAll(*args, **kwargs)
|
|
|
|
def GetLen(*args, **kwargs):
|
|
"""
|
|
GetLen(self) -> int
|
|
|
|
Returns the number of operations in the recorded list.
|
|
"""
|
|
return _gdi_.PseudoDC_GetLen(*args, **kwargs)
|
|
|
|
def SetId(*args, **kwargs):
|
|
"""
|
|
SetId(self, int id)
|
|
|
|
Sets the id to be associated with subsequent operations.
|
|
"""
|
|
return _gdi_.PseudoDC_SetId(*args, **kwargs)
|
|
|
|
def ClearId(*args, **kwargs):
|
|
"""
|
|
ClearId(self, int id)
|
|
|
|
Removes all operations associated with id so the object can be redrawn.
|
|
"""
|
|
return _gdi_.PseudoDC_ClearId(*args, **kwargs)
|
|
|
|
def RemoveId(*args, **kwargs):
|
|
"""
|
|
RemoveId(self, int id)
|
|
|
|
Remove the object node (and all operations) associated with an id.
|
|
"""
|
|
return _gdi_.PseudoDC_RemoveId(*args, **kwargs)
|
|
|
|
def TranslateId(*args, **kwargs):
|
|
"""
|
|
TranslateId(self, int id, int dx, int dy)
|
|
|
|
Translate the operations of id by dx,dy.
|
|
"""
|
|
return _gdi_.PseudoDC_TranslateId(*args, **kwargs)
|
|
|
|
def SetIdGreyedOut(*args, **kwargs):
|
|
"""
|
|
SetIdGreyedOut(self, int id, bool greyout=True)
|
|
|
|
Set whether an object is drawn greyed out or not.
|
|
"""
|
|
return _gdi_.PseudoDC_SetIdGreyedOut(*args, **kwargs)
|
|
|
|
def GetIdGreyedOut(*args, **kwargs):
|
|
"""
|
|
GetIdGreyedOut(self, int id) -> bool
|
|
|
|
Get whether an object is drawn greyed out or not.
|
|
"""
|
|
return _gdi_.PseudoDC_GetIdGreyedOut(*args, **kwargs)
|
|
|
|
def FindObjects(*args, **kwargs):
|
|
"""
|
|
FindObjects(self, int x, int y, int radius=1, Colour bg=*wxWHITE) -> PyObject
|
|
|
|
Returns a list of all the id's that draw a pixel with color
|
|
not equal to bg within radius of (x,y).
|
|
Returns an empty list if nothing is found. The list is in
|
|
reverse drawing order so list[0] is the top id.
|
|
"""
|
|
return _gdi_.PseudoDC_FindObjects(*args, **kwargs)
|
|
|
|
def FindObjectsByBBox(*args, **kwargs):
|
|
"""
|
|
FindObjectsByBBox(self, int x, int y) -> PyObject
|
|
|
|
Returns a list of all the id's whose bounding boxes include (x,y).
|
|
Returns an empty list if nothing is found. The list is in
|
|
reverse drawing order so list[0] is the top id.
|
|
"""
|
|
return _gdi_.PseudoDC_FindObjectsByBBox(*args, **kwargs)
|
|
|
|
def DrawIdToDC(*args, **kwargs):
|
|
"""
|
|
DrawIdToDC(self, int id, DC dc)
|
|
|
|
Draw recorded operations of id to dc.
|
|
"""
|
|
return _gdi_.PseudoDC_DrawIdToDC(*args, **kwargs)
|
|
|
|
def SetIdBounds(*args, **kwargs):
|
|
"""
|
|
SetIdBounds(self, int id, Rect rect)
|
|
|
|
Set the bounding rect of a given object. This will create
|
|
an object node if one doesn't exist.
|
|
"""
|
|
return _gdi_.PseudoDC_SetIdBounds(*args, **kwargs)
|
|
|
|
def GetIdBounds(*args, **kwargs):
|
|
"""
|
|
GetIdBounds(self, int id) -> Rect
|
|
|
|
Returns the bounding rectangle previouly set with SetIdBounds. If
|
|
no bounds have been set, it returns wx.Rect(0,0,0,0).
|
|
"""
|
|
return _gdi_.PseudoDC_GetIdBounds(*args, **kwargs)
|
|
|
|
def DrawToDCClipped(*args, **kwargs):
|
|
"""
|
|
DrawToDCClipped(self, DC dc, Rect rect)
|
|
|
|
Draws the recorded operations to dc unless the operation is known to
|
|
be outside rect.
|
|
"""
|
|
return _gdi_.PseudoDC_DrawToDCClipped(*args, **kwargs)
|
|
|
|
def DrawToDCClippedRgn(*args, **kwargs):
|
|
"""
|
|
DrawToDCClippedRgn(self, DC dc, Region region)
|
|
|
|
Draws the recorded operations to dc unless the operation is known to
|
|
be outside rect.
|
|
"""
|
|
return _gdi_.PseudoDC_DrawToDCClippedRgn(*args, **kwargs)
|
|
|
|
def DrawToDC(*args, **kwargs):
|
|
"""
|
|
DrawToDC(self, DC dc)
|
|
|
|
Draws the recorded operations to dc.
|
|
"""
|
|
return _gdi_.PseudoDC_DrawToDC(*args, **kwargs)
|
|
|
|
def FloodFill(*args, **kwargs):
|
|
"""
|
|
FloodFill(self, int x, int y, Colour col, int style=FLOOD_SURFACE)
|
|
|
|
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_.PseudoDC_FloodFill(*args, **kwargs)
|
|
|
|
def FloodFillPoint(*args, **kwargs):
|
|
"""
|
|
FloodFillPoint(self, Point pt, Colour col, int style=FLOOD_SURFACE)
|
|
|
|
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_.PseudoDC_FloodFillPoint(*args, **kwargs)
|
|
|
|
def DrawLine(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawLine(*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_.PseudoDC_DrawLinePoint(*args, **kwargs)
|
|
|
|
def CrossHair(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_CrossHair(*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_.PseudoDC_CrossHairPoint(*args, **kwargs)
|
|
|
|
def DrawArc(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawArc(*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_.PseudoDC_DrawArcPoint(*args, **kwargs)
|
|
|
|
def DrawCheckMark(*args, **kwargs):
|
|
"""
|
|
DrawCheckMark(self, int x, int y, int width, int height)
|
|
|
|
Draws a check mark inside the given rectangle.
|
|
"""
|
|
return _gdi_.PseudoDC_DrawCheckMark(*args, **kwargs)
|
|
|
|
def DrawCheckMarkRect(*args, **kwargs):
|
|
"""
|
|
DrawCheckMarkRect(self, Rect rect)
|
|
|
|
Draws a check mark inside the given rectangle.
|
|
"""
|
|
return _gdi_.PseudoDC_DrawCheckMarkRect(*args, **kwargs)
|
|
|
|
def DrawEllipticArc(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawEllipticArc(*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_.PseudoDC_DrawEllipticArcPointSize(*args, **kwargs)
|
|
|
|
def DrawPoint(*args, **kwargs):
|
|
"""
|
|
DrawPoint(self, int x, int y)
|
|
|
|
Draws a point using the current pen.
|
|
"""
|
|
return _gdi_.PseudoDC_DrawPoint(*args, **kwargs)
|
|
|
|
def DrawPointPoint(*args, **kwargs):
|
|
"""
|
|
DrawPointPoint(self, Point pt)
|
|
|
|
Draws a point using the current pen.
|
|
"""
|
|
return _gdi_.PseudoDC_DrawPointPoint(*args, **kwargs)
|
|
|
|
def DrawRectangle(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawRectangle(*args, **kwargs)
|
|
|
|
def DrawRectangleRect(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawRectangleRect(*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_.PseudoDC_DrawRectanglePointSize(*args, **kwargs)
|
|
|
|
def DrawRoundedRectangle(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawRoundedRectangle(*args, **kwargs)
|
|
|
|
def DrawRoundedRectangleRect(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawRoundedRectangleRect(*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_.PseudoDC_DrawRoundedRectanglePointSize(*args, **kwargs)
|
|
|
|
def DrawCircle(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawCircle(*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_.PseudoDC_DrawCirclePoint(*args, **kwargs)
|
|
|
|
def DrawEllipse(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawEllipse(*args, **kwargs)
|
|
|
|
def DrawEllipseRect(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawEllipseRect(*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_.PseudoDC_DrawEllipsePointSize(*args, **kwargs)
|
|
|
|
def DrawIcon(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawIcon(*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_.PseudoDC_DrawIconPoint(*args, **kwargs)
|
|
|
|
def DrawBitmap(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawBitmap(*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_.PseudoDC_DrawBitmapPoint(*args, **kwargs)
|
|
|
|
def DrawText(*args, **kwargs):
|
|
"""
|
|
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 `wx.DC.GetTextExtent` for how to get the dimensions of
|
|
a text string, which can be used to position the text more precisely,
|
|
(you will need to use a real DC with GetTextExtent as wx.PseudoDC does
|
|
not implement it.)
|
|
|
|
**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_.PseudoDC_DrawText(*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 `wx.DC.GetTextExtent` for how to get the dimensions of
|
|
a text string, which can be used to position the text more precisely,
|
|
(you will need to use a real DC with GetTextExtent as wx.PseudoDC does
|
|
not implement it.)
|
|
|
|
**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_.PseudoDC_DrawTextPoint(*args, **kwargs)
|
|
|
|
def DrawRotatedText(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawRotatedText(*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_.PseudoDC_DrawRotatedTextPoint(*args, **kwargs)
|
|
|
|
def DrawLines(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawLines(*args, **kwargs)
|
|
|
|
def DrawPolygon(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawPolygon(*args, **kwargs)
|
|
|
|
def DrawLabel(*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_.PseudoDC_DrawLabel(*args, **kwargs)
|
|
|
|
def DrawImageLabel(*args, **kwargs):
|
|
"""
|
|
DrawImageLabel(self, String text, Bitmap image, Rect rect, int alignment=wxALIGN_LEFT|wxALIGN_TOP,
|
|
int indexAccel=-1)
|
|
|
|
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.
|
|
"""
|
|
return _gdi_.PseudoDC_DrawImageLabel(*args, **kwargs)
|
|
|
|
def DrawSpline(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_DrawSpline(*args, **kwargs)
|
|
|
|
def Clear(*args, **kwargs):
|
|
"""
|
|
Clear(self)
|
|
|
|
Clears the device context using the current background brush.
|
|
"""
|
|
return _gdi_.PseudoDC_Clear(*args, **kwargs)
|
|
|
|
def SetFont(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_SetFont(*args, **kwargs)
|
|
|
|
def SetPen(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_SetPen(*args, **kwargs)
|
|
|
|
def SetBrush(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_SetBrush(*args, **kwargs)
|
|
|
|
def SetBackground(*args, **kwargs):
|
|
"""
|
|
SetBackground(self, Brush brush)
|
|
|
|
Sets the current background brush for the DC.
|
|
"""
|
|
return _gdi_.PseudoDC_SetBackground(*args, **kwargs)
|
|
|
|
def SetBackgroundMode(*args, **kwargs):
|
|
"""
|
|
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_.PseudoDC_SetBackgroundMode(*args, **kwargs)
|
|
|
|
def SetPalette(*args, **kwargs):
|
|
"""
|
|
SetPalette(self, Palette palette)
|
|
|
|
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_.PseudoDC_SetPalette(*args, **kwargs)
|
|
|
|
def SetTextForeground(*args, **kwargs):
|
|
"""
|
|
SetTextForeground(self, Colour colour)
|
|
|
|
Sets the current text foreground colour for the DC.
|
|
"""
|
|
return _gdi_.PseudoDC_SetTextForeground(*args, **kwargs)
|
|
|
|
def SetTextBackground(*args, **kwargs):
|
|
"""
|
|
SetTextBackground(self, Colour colour)
|
|
|
|
Sets the current text background colour for the DC.
|
|
"""
|
|
return _gdi_.PseudoDC_SetTextBackground(*args, **kwargs)
|
|
|
|
def SetLogicalFunction(*args, **kwargs):
|
|
"""
|
|
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, 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_.PseudoDC_SetLogicalFunction(*args, **kwargs)
|
|
|
|
IdBounds = property(GetIdBounds,SetIdBounds,doc="See `GetIdBounds` and `SetIdBounds`")
|
|
Len = property(GetLen,doc="See `GetLen`")
|
|
_gdi_.PseudoDC_swigregister(PseudoDC)
|
|
|
|
|
|
|