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
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
- __init__(self, byte red=0, byte green=0, byte blue=0) -> Colour
+ __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.
"""
return _gdi_.Colour_Blue(*args, **kwargs)
+ def Alpha(*args, **kwargs):
+ """
+ Alpha(self) -> byte
+
+ Returns the Alpha value.
+ """
+ return _gdi_.Colour_Alpha(*args, **kwargs)
+
def Ok(*args, **kwargs):
"""
Ok(self) -> bool
def Set(*args, **kwargs):
"""
- Set(self, byte red, byte green, byte blue)
+ Set(self, byte red, byte green, byte blue, byte alpha=ALPHA_OPAQUE)
Sets the RGB intensity values.
"""
return _gdi_.Colour_GetRGB(*args, **kwargs)
asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
- def __str__(self): return str(self.Get())
- def __repr__(self): return 'wx.Colour' + str(self.Get())
+ def __str__(self): return str(self.Get(True))
+ def __repr__(self): return 'wx.Colour' + str(self.Get(True))
def __nonzero__(self): return self.Ok()
__safe_for_unpickling__ = True
- def __reduce__(self): return (Colour, self.Get())
+ 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):
return _gdi_.Brush_Ok(*args, **kwargs)
def __nonzero__(self): return self.Ok()
+ 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):
"""__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):
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)
+
+_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
return _gdi_.Icon_CopyFromBitmap(*args, **kwargs)
def __nonzero__(self): return self.Ok()
+ 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):
"""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):
"""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):
"""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):
"""SetDialogTitle(self, String title)"""
return _gdi_.FontMapper_SetDialogTitle(*args, **kwargs)
+ AltForEncoding = property(GetAltForEncoding,doc="See `GetAltForEncoding`")
_gdi_.FontMapper_swigregister(FontMapper)
def FontMapper_Get(*args):
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):
#---------------------------------------------------------------------------
+Layout_Default = _gdi_.Layout_Default
+Layout_LeftToRight = _gdi_.Layout_LeftToRight
+Layout_RightToLeft = _gdi_.Layout_RightToLeft
LANGUAGE_DEFAULT = _gdi_.LANGUAGE_DEFAULT
LANGUAGE_UNKNOWN = _gdi_.LANGUAGE_UNKNOWN
LANGUAGE_ABKHAZIAN = _gdi_.LANGUAGE_ABKHAZIAN
"""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_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))
+ self._setCallbackInfo(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"""
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)
# to the default catalog path.
if wx.Platform == "__WXMSW__":
import os
- _localedir = os.path.join(os.path.split(__file__)[0], "locale")
+ _localedir = os.path.join(os.path.split(__file__)[0], "i18n")
Locale.AddCatalogLookupPathPrefix(_localedir)
del os
def GetMultiLineTextExtent(*args, **kwargs):
"""
GetMultiLineTextExtent(wxString string, Font font=None) ->
- (width, height, descent, externalLeading)
+ (width, height, lineHeight)
Get the width, height, decent and leading of the text using the
current or specified font. Works for single as well as multi-line
"""
GetPPI(self) -> Size
- Resolution in Pixels per inch
+ Resolution in pixels per inch
"""
return _gdi_.DC_GetPPI(*args, **kwargs)
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`")
_gdi_.DC_swigregister(DC)
#---------------------------------------------------------------------------
"""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)
#---------------------------------------------------------------------------
"""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)
#---------------------------------------------------------------------------
Return the generic implementation of the renderer. Under some
platforms, this is the default renderer implementation, others have
platform-specific default renderer which can be retrieved by calling
- `GetDefault`.
+ `wx.RendererNative.GetDefault`.
"""
return _gdi_.RendererNative_GetGeneric(*args, **kwargs)
GetDefault() -> RendererNative
Return the default (native) implementation for this platform -- this
- is also the one used by default but this may be changed by calling `Set`
- in which case the return value of this method may be different from
- the return value of `Get`.
+ 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)
Return the generic implementation of the renderer. Under some
platforms, this is the default renderer implementation, others have
platform-specific default renderer which can be retrieved by calling
- `GetDefault`.
+ `wx.RendererNative.GetDefault`.
"""
return _gdi_.RendererNative_GetGeneric(*args)
RendererNative_GetDefault() -> RendererNative
Return the default (native) implementation for this platform -- this
- is also the one used by default but this may be changed by calling `Set`
- in which case the return value of this method may be different from
- the return value of `Get`.
+ 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)
"""
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 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)
+
+_gdi_.PseudoDC_swigregister(PseudoDC)
+
projects / wxWidgets.git / blobdiff