X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/1a10c4833a49d0d627296e5b7b30a3af0e556cd1..4d170c95f6b8e6210ff6ac8f95c023b4bddbf6d6:/wxPython/src/gtk/_gdi.py diff --git a/wxPython/src/gtk/_gdi.py b/wxPython/src/gtk/_gdi.py index 1ec7f972d4..cf314168f2 100644 --- a/wxPython/src/gtk/_gdi.py +++ b/wxPython/src/gtk/_gdi.py @@ -3,11 +3,53 @@ import _gdi_ +def _swig_setattr_nondynamic(self,class_type,name,value,static=1): + if (name == "this"): + if isinstance(value, class_type): + self.__dict__[name] = value.this + if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown + del value.thisown + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + if (not static) or hasattr(self,name) or (name == "thisown"): + 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): + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError,name + +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 hasattr(self,name) or (name in ("this", "thisown")): + 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""" def __repr__(self): return "<%s.%s; proxy of C++ wxGDIObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -227,6 +269,7 @@ NamedColor = NamedColour ColorRGB = ColourRGB class Palette(GDIObject): + """Proxy of C++ Palette class""" def __repr__(self): return "<%s.%s; proxy of C++ wxPalette instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -246,9 +289,13 @@ class Palette(GDIObject): return _gdi_.Palette_GetPixel(*args, **kwargs) def GetRGB(*args, **kwargs): - """GetRGB(int pixel) -> (R,G,B)""" + """GetRGB(self, int pixel) -> (R,G,B)""" return _gdi_.Palette_GetRGB(*args, **kwargs) + def GetColoursCount(*args, **kwargs): + """GetColoursCount(self) -> int""" + return _gdi_.Palette_GetColoursCount(*args, **kwargs) + def Ok(*args, **kwargs): """Ok(self) -> bool""" return _gdi_.Palette_Ok(*args, **kwargs) @@ -265,6 +312,7 @@ _gdi_.Palette_swigregister(PalettePtr) #--------------------------------------------------------------------------- class Pen(GDIObject): + """Proxy of C++ Pen class""" def __repr__(self): return "<%s.%s; proxy of C++ wxPen instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -324,7 +372,7 @@ class Pen(GDIObject): return _gdi_.Pen_SetWidth(*args, **kwargs) def SetDashes(*args, **kwargs): - """SetDashes(self, int dashes, wxDash dashes_array)""" + """SetDashes(self, int dashes)""" return _gdi_.Pen_SetDashes(*args, **kwargs) def GetDashes(*args, **kwargs): @@ -439,6 +487,14 @@ class Brush(GDIObject): """ return _gdi_.Brush_GetStipple(*args, **kwargs) + def IsHatch(*args, **kwargs): + """ + IsHatch(self) -> bool + + Is the current style a hatch type? + """ + return _gdi_.Brush_IsHatch(*args, **kwargs) + def Ok(*args, **kwargs): """ Ok(self) -> bool @@ -456,6 +512,16 @@ class BrushPtr(Brush): self.__class__ = Brush _gdi_.Brush_swigregister(BrushPtr) +def BrushFromBitmap(*args, **kwargs): + """ + BrushFromBitmap(Bitmap stippleBitmap) -> Brush + + Constructs a stippled brush using a bitmap. + """ + val = _gdi_.new_BrushFromBitmap(*args, **kwargs) + val.thisown = 1 + return val + class Bitmap(GDIObject): """ The wx.Bitmap class encapsulates the concept of a platform-dependent @@ -589,6 +655,10 @@ class Bitmap(GDIObject): """ 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) @@ -741,6 +811,7 @@ _gdi_.Mask_swigregister(MaskPtr) MaskColour = wx._deprecated(Mask, "wx.MaskColour is deprecated, use `wx.Mask` instead.") class Icon(GDIObject): + """Proxy of C++ Icon class""" def __repr__(self): return "<%s.%s; proxy of C++ wxIcon instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -825,6 +896,7 @@ def IconFromXPMData(*args, **kwargs): return val class IconLocation(object): + """Proxy of C++ IconLocation class""" def __repr__(self): return "<%s.%s; proxy of C++ wxIconLocation instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -869,6 +941,7 @@ class IconLocationPtr(IconLocation): _gdi_.IconLocation_swigregister(IconLocationPtr) class IconBundle(object): + """Proxy of C++ IconBundle class""" def __repr__(self): return "<%s.%s; proxy of C++ wxIconBundle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -934,11 +1007,8 @@ class Cursor(GDIObject): __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 + wx.BITAMP_TYPE* constants, and specify the hotspot if not using a .cur file. - - This constructor is not available on wxGTK, use ``wx.StockCursor``, - ``wx.CursorFromImage``, or ``wx.CursorFromBits`` instead. """ newobj = _gdi_.new_Cursor(*args, **kwargs) self.this = newobj.this @@ -968,7 +1038,7 @@ def StockCursor(*args, **kwargs): StockCursor(int id) -> Cursor Create a cursor using one of the stock cursors. Note that not all - cursors are available on all platforms. + stock cursors are available on all platforms. """ val = _gdi_.new_StockCursor(*args, **kwargs) val.thisown = 1 @@ -978,10 +1048,8 @@ def CursorFromImage(*args, **kwargs): """ CursorFromImage(Image image) -> Cursor - Constructs a cursor from a wxImage. The cursor is monochrome, colors - with the RGB elements all greater than 127 will be foreground, colors - less than this background. The mask (if any) will be used as - transparent. + Constructs a cursor from a `wx.Image`. The mask (if any) will be used + for setting the transparent portions of the cursor. """ val = _gdi_.new_CursorFromImage(*args, **kwargs) val.thisown = 1 @@ -993,6 +1061,7 @@ OutRegion = _gdi_.OutRegion PartRegion = _gdi_.PartRegion InRegion = _gdi_.InRegion class Region(GDIObject): + """Proxy of C++ Region class""" def __repr__(self): return "<%s.%s; proxy of C++ wxRegion instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -1092,9 +1161,13 @@ class Region(GDIObject): return _gdi_.Region_ConvertToBitmap(*args, **kwargs) def UnionBitmap(*args, **kwargs): - """UnionBitmap(self, Bitmap bmp, Colour transColour=NullColour, int tolerance=0) -> bool""" + """UnionBitmap(self, Bitmap bmp) -> bool""" return _gdi_.Region_UnionBitmap(*args, **kwargs) + def UnionBitmapColour(*args, **kwargs): + """UnionBitmapColour(self, Bitmap bmp, Colour transColour, int tolerance=0) -> bool""" + return _gdi_.Region_UnionBitmapColour(*args, **kwargs) + class RegionPtr(Region): def __init__(self, this): @@ -1104,18 +1177,25 @@ class RegionPtr(Region): _gdi_.Region_swigregister(RegionPtr) def RegionFromBitmap(*args, **kwargs): - """RegionFromBitmap(Bitmap bmp, Colour transColour=NullColour, int tolerance=0) -> Region""" + """RegionFromBitmap(Bitmap bmp) -> Region""" val = _gdi_.new_RegionFromBitmap(*args, **kwargs) val.thisown = 1 return val +def RegionFromBitmapColour(*args, **kwargs): + """RegionFromBitmapColour(Bitmap bmp, Colour transColour, int tolerance=0) -> Region""" + val = _gdi_.new_RegionFromBitmapColour(*args, **kwargs) + val.thisown = 1 + return val + def RegionFromPoints(*args, **kwargs): - """RegionFromPoints(int points, Point points_array, int fillStyle=WINDING_RULE) -> Region""" + """RegionFromPoints(int points, int fillStyle=WINDING_RULE) -> Region""" val = _gdi_.new_RegionFromPoints(*args, **kwargs) val.thisown = 1 return val class RegionIterator(_core.Object): + """Proxy of C++ RegionIterator class""" def __repr__(self): return "<%s.%s; proxy of C++ wxRegionIterator instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -1311,6 +1391,7 @@ FONTENCODING_SHIFT_JIS = _gdi_.FONTENCODING_SHIFT_JIS #--------------------------------------------------------------------------- class NativeFontInfo(object): + """Proxy of C++ NativeFontInfo class""" def __repr__(self): return "<%s.%s; proxy of C++ wxNativeFontInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -1418,6 +1499,7 @@ class NativeFontInfoPtr(NativeFontInfo): _gdi_.NativeFontInfo_swigregister(NativeFontInfoPtr) class NativeEncodingInfo(object): + """Proxy of C++ NativeEncodingInfo class""" def __repr__(self): return "<%s.%s; proxy of C++ wxNativeEncodingInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) facename = property(_gdi_.NativeEncodingInfo_facename_get, _gdi_.NativeEncodingInfo_facename_set) @@ -1461,6 +1543,7 @@ def TestFontEncoding(*args, **kwargs): #--------------------------------------------------------------------------- class FontMapper(object): + """Proxy of C++ FontMapper class""" def __repr__(self): return "<%s.%s; proxy of C++ wxFontMapper instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -1586,6 +1669,13 @@ def FontMapper_GetDefaultConfigPath(*args, **kwargs): #--------------------------------------------------------------------------- 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`. + """ def __repr__(self): return "<%s.%s; proxy of C++ wxFont instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -1593,6 +1683,35 @@ class Font(GDIObject): __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'] newobj = _gdi_.new_Font(*args, **kwargs) @@ -1606,7 +1725,11 @@ class Font(GDIObject): except: pass def Ok(*args, **kwargs): - """Ok(self) -> bool""" + """ + Ok(self) -> bool + + Returns ``True`` if this font was successfully created. + """ return _gdi_.Font_Ok(*args, **kwargs) def __nonzero__(self): return self.Ok() @@ -1619,99 +1742,234 @@ class Font(GDIObject): return _gdi_.Font___ne__(*args, **kwargs) def GetPointSize(*args, **kwargs): - """GetPointSize(self) -> int""" + """ + GetPointSize(self) -> int + + Gets the point size. + """ return _gdi_.Font_GetPointSize(*args, **kwargs) + def GetPixelSize(*args, **kwargs): + """ + GetPixelSize(self) -> Size + + Returns the size in pixels if the font was constructed with a pixel + size. + """ + return _gdi_.Font_GetPixelSize(*args, **kwargs) + + def IsUsingSizeInPixels(*args, **kwargs): + """ + IsUsingSizeInPixels(self) -> bool + + Returns ``True`` if the font is using a pixelSize. + """ + return _gdi_.Font_IsUsingSizeInPixels(*args, **kwargs) + def GetFamily(*args, **kwargs): - """GetFamily(self) -> int""" + """ + GetFamily(self) -> int + + Gets the font family. + """ return _gdi_.Font_GetFamily(*args, **kwargs) def GetStyle(*args, **kwargs): - """GetStyle(self) -> int""" + """ + GetStyle(self) -> int + + Gets the font style. + """ return _gdi_.Font_GetStyle(*args, **kwargs) def GetWeight(*args, **kwargs): - """GetWeight(self) -> int""" + """ + GetWeight(self) -> int + + Gets the font weight. + """ return _gdi_.Font_GetWeight(*args, **kwargs) def GetUnderlined(*args, **kwargs): - """GetUnderlined(self) -> bool""" + """ + GetUnderlined(self) -> bool + + Returns ``True`` if the font is underlined, ``False`` otherwise. + """ return _gdi_.Font_GetUnderlined(*args, **kwargs) def GetFaceName(*args, **kwargs): - """GetFaceName(self) -> String""" + """ + GetFaceName(self) -> String + + Returns the typeface name associated with the font, or the empty + string if there is no typeface information. + """ return _gdi_.Font_GetFaceName(*args, **kwargs) def GetEncoding(*args, **kwargs): - """GetEncoding(self) -> int""" + """ + GetEncoding(self) -> int + + Get the font's encoding. + """ return _gdi_.Font_GetEncoding(*args, **kwargs) def GetNativeFontInfo(*args, **kwargs): - """GetNativeFontInfo(self) -> NativeFontInfo""" + """ + GetNativeFontInfo(self) -> NativeFontInfo + + Constructs a `wx.NativeFontInfo` object from this font. + """ return _gdi_.Font_GetNativeFontInfo(*args, **kwargs) def IsFixedWidth(*args, **kwargs): - """IsFixedWidth(self) -> bool""" + """ + IsFixedWidth(self) -> bool + + Returns true if the font is a fixed width (or monospaced) font, false + if it is a proportional one or font is invalid. + """ return _gdi_.Font_IsFixedWidth(*args, **kwargs) def GetNativeFontInfoDesc(*args, **kwargs): - """GetNativeFontInfoDesc(self) -> String""" + """ + GetNativeFontInfoDesc(self) -> String + + Returns the platform-dependent string completely describing this font + or an empty string if the font isn't valid. + """ return _gdi_.Font_GetNativeFontInfoDesc(*args, **kwargs) def GetNativeFontInfoUserDesc(*args, **kwargs): - """GetNativeFontInfoUserDesc(self) -> String""" + """ + GetNativeFontInfoUserDesc(self) -> String + + Returns a human readable version of `GetNativeFontInfoDesc`. + """ return _gdi_.Font_GetNativeFontInfoUserDesc(*args, **kwargs) def SetPointSize(*args, **kwargs): - """SetPointSize(self, int pointSize)""" + """ + SetPointSize(self, int pointSize) + + Sets the point size. + """ return _gdi_.Font_SetPointSize(*args, **kwargs) + def SetPixelSize(*args, **kwargs): + """ + SetPixelSize(self, Size pixelSize) + + Sets the size in pixels rather than points. If there is platform API + support for this then it is used, otherwise a font with the closest + size is found using a binary search. + """ + return _gdi_.Font_SetPixelSize(*args, **kwargs) + def SetFamily(*args, **kwargs): - """SetFamily(self, int family)""" + """ + SetFamily(self, int family) + + Sets the font family. + """ return _gdi_.Font_SetFamily(*args, **kwargs) def SetStyle(*args, **kwargs): - """SetStyle(self, int style)""" + """ + SetStyle(self, int style) + + Sets the font style. + """ return _gdi_.Font_SetStyle(*args, **kwargs) def SetWeight(*args, **kwargs): - """SetWeight(self, int weight)""" + """ + SetWeight(self, int weight) + + Sets the font weight. + """ return _gdi_.Font_SetWeight(*args, **kwargs) def SetFaceName(*args, **kwargs): - """SetFaceName(self, String faceName)""" + """ + SetFaceName(self, String faceName) + + Sets the facename for the font. The facename, which should be a valid + font installed on the end-user's system. + + To avoid portability problems, don't rely on a specific face, but + specify the font family instead or as well. A suitable font will be + found on the end-user's system. If both the family and the facename + are specified, wxWidgets will first search for the specific face, and + then for a font belonging to the same family. + """ return _gdi_.Font_SetFaceName(*args, **kwargs) def SetUnderlined(*args, **kwargs): - """SetUnderlined(self, bool underlined)""" + """ + SetUnderlined(self, bool underlined) + + Sets underlining. + """ return _gdi_.Font_SetUnderlined(*args, **kwargs) def SetEncoding(*args, **kwargs): - """SetEncoding(self, int encoding)""" + """ + SetEncoding(self, int encoding) + + Set the font encoding. + """ return _gdi_.Font_SetEncoding(*args, **kwargs) def SetNativeFontInfo(*args, **kwargs): - """SetNativeFontInfo(self, NativeFontInfo info)""" + """ + SetNativeFontInfo(self, NativeFontInfo info) + + Set the font's attributes from a `wx.NativeFontInfo` object. + """ return _gdi_.Font_SetNativeFontInfo(*args, **kwargs) def SetNativeFontInfoFromString(*args, **kwargs): - """SetNativeFontInfoFromString(self, String info)""" + """ + SetNativeFontInfoFromString(self, String info) + + Set the font's attributes from string representation of a + `wx.NativeFontInfo` object. + """ return _gdi_.Font_SetNativeFontInfoFromString(*args, **kwargs) def SetNativeFontInfoUserDesc(*args, **kwargs): - """SetNativeFontInfoUserDesc(self, String info)""" + """ + SetNativeFontInfoUserDesc(self, String info) + + Set the font's attributes from a string formerly returned from + `GetNativeFontInfoDesc`. + """ return _gdi_.Font_SetNativeFontInfoUserDesc(*args, **kwargs) def GetFamilyString(*args, **kwargs): - """GetFamilyString(self) -> String""" + """ + GetFamilyString(self) -> String + + Returns a string representation of the font family. + """ return _gdi_.Font_GetFamilyString(*args, **kwargs) def GetStyleString(*args, **kwargs): - """GetStyleString(self) -> String""" + """ + GetStyleString(self) -> String + + Returns a string representation of the font style. + """ return _gdi_.Font_GetStyleString(*args, **kwargs) def GetWeightString(*args, **kwargs): - """GetWeightString(self) -> String""" + """ + GetWeightString(self) -> String + + Return a string representation of the font weight. + """ return _gdi_.Font_GetWeightString(*args, **kwargs) def SetNoAntiAliasing(*args, **kwargs): @@ -1723,12 +1981,21 @@ class Font(GDIObject): return _gdi_.Font_GetNoAntiAliasing(*args, **kwargs) def GetDefaultEncoding(*args, **kwargs): - """GetDefaultEncoding() -> int""" + """ + GetDefaultEncoding() -> int + + Returns the encoding used for all fonts created with an encoding of + ``wx.FONTENCODING_DEFAULT``. + """ return _gdi_.Font_GetDefaultEncoding(*args, **kwargs) GetDefaultEncoding = staticmethod(GetDefaultEncoding) def SetDefaultEncoding(*args, **kwargs): - """SetDefaultEncoding(int encoding)""" + """ + SetDefaultEncoding(int encoding) + + Sets the default font encoding. + """ return _gdi_.Font_SetDefaultEncoding(*args, **kwargs) SetDefaultEncoding = staticmethod(SetDefaultEncoding) @@ -1741,40 +2008,111 @@ class FontPtr(Font): _gdi_.Font_swigregister(FontPtr) def FontFromNativeInfo(*args, **kwargs): - """FontFromNativeInfo(NativeFontInfo info) -> Font""" + """ + FontFromNativeInfo(NativeFontInfo info) -> Font + + Construct a `wx.Font` from a `wx.NativeFontInfo` object. + """ if kwargs.has_key('faceName'): kwargs['face'] = kwargs['faceName'];del kwargs['faceName'] val = _gdi_.new_FontFromNativeInfo(*args, **kwargs) val.thisown = 1 return val def FontFromNativeInfoString(*args, **kwargs): - """FontFromNativeInfoString(String info) -> Font""" + """ + FontFromNativeInfoString(String info) -> Font + + Construct a `wx.Font` from the string representation of a + `wx.NativeFontInfo` object. + """ if kwargs.has_key('faceName'): kwargs['face'] = kwargs['faceName'];del kwargs['faceName'] val = _gdi_.new_FontFromNativeInfoString(*args, **kwargs) val.thisown = 1 return val -def Font2(*args, **kwargs): +def FFont(*args, **kwargs): """ - Font2(int pointSize, int family, int flags=FONTFLAG_DEFAULT, + FFont(int pointSize, int family, int flags=FONTFLAG_DEFAULT, String face=EmptyString, int encoding=FONTENCODING_DEFAULT) -> Font + + A bit of a simpler way to create a `wx.Font` using flags instead of + individual attribute settings. The value of flags can be a + combination of the following: + + ============================ == + wx.FONTFLAG_DEFAULT + wx.FONTFLAG_ITALIC + wx.FONTFLAG_SLANT + wx.FONTFLAG_LIGHT + wx.FONTFLAG_BOLD + wx.FONTFLAG_ANTIALIASED + wx.FONTFLAG_NOT_ANTIALIASED + wx.FONTFLAG_UNDERLINED + wx.FONTFLAG_STRIKETHROUGH + ============================ == + + :see: `wx.Font.__init__` + """ + if kwargs.has_key('faceName'): kwargs['face'] = kwargs['faceName'];del kwargs['faceName'] + val = _gdi_.new_FFont(*args, **kwargs) + val.thisown = 1 + 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) + val.thisown = 1 + 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_Font2(*args, **kwargs) + val = _gdi_.new_FFontFromPixelSize(*args, **kwargs) val.thisown = 1 return val def Font_GetDefaultEncoding(*args, **kwargs): - """Font_GetDefaultEncoding() -> int""" + """ + Font_GetDefaultEncoding() -> int + + Returns the encoding used for all fonts created with an encoding of + ``wx.FONTENCODING_DEFAULT``. + """ return _gdi_.Font_GetDefaultEncoding(*args, **kwargs) def Font_SetDefaultEncoding(*args, **kwargs): - """Font_SetDefaultEncoding(int encoding)""" + """ + 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""" def __repr__(self): return "<%s.%s; proxy of C++ wxPyFontEnumerator instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -2053,6 +2391,7 @@ 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""" def __init__(self): raise RuntimeError, "No constructor defined" def __repr__(self): return "<%s.%s; proxy of C++ wxLanguageInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) @@ -2076,6 +2415,7 @@ 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""" def __repr__(self): return "<%s.%s; proxy of C++ wxLocale instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -2240,6 +2580,7 @@ PLATFORM_WINDOWS = _gdi_.PLATFORM_WINDOWS PLATFORM_OS2 = _gdi_.PLATFORM_OS2 PLATFORM_MAC = _gdi_.PLATFORM_MAC class EncodingConverter(_core.Object): + """Proxy of C++ EncodingConverter class""" def __repr__(self): return "<%s.%s; proxy of C++ wxEncodingConverter instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -2310,8 +2651,8 @@ def EncodingConverter_CanConvert(*args, **kwargs): # to the default catalog path. if wx.Platform == "__WXMSW__": import os - localedir = os.path.join(os.path.split(__file__)[0], "locale") - Locale_AddCatalogLookupPathPrefix(localedir) + _localedir = os.path.join(os.path.split(__file__)[0], "locale") + Locale.AddCatalogLookupPathPrefix(_localedir) del os #---------------------------------------------------------------------------- @@ -2319,6 +2660,21 @@ if wx.Platform == "__WXMSW__": #--------------------------------------------------------------------------- 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. + """ def __init__(self): raise RuntimeError, "No constructor defined" def __repr__(self): return "<%s.%s; proxy of C++ wxDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) @@ -2329,23 +2685,75 @@ class DC(_core.Object): except: pass def BeginDrawing(*args, **kwargs): - """BeginDrawing(self)""" + """ + 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_.DC_BeginDrawing(*args, **kwargs) def EndDrawing(*args, **kwargs): - """EndDrawing(self)""" + """ + 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_.DC_EndDrawing(*args, **kwargs) def FloodFill(*args, **kwargs): - """FloodFill(self, int x, int y, Colour col, int style=FLOOD_SURFACE) -> bool""" + """ + FloodFill(self, int x, int y, Colour col, int style=FLOOD_SURFACE) -> bool + + Flood fills the device context starting from the given point, using + the current brush colour, and using a style: + + - **wxFLOOD_SURFACE**: the flooding occurs until a colour other than + the given colour is encountered. + + - **wxFLOOD_BORDER**: the area to be flooded is bounded by the given + colour. + + Returns False if the operation failed. + + Note: The present implementation for non-Windows platforms may fail to + find colour borders if the pixels do not match the colour + exactly. However the function will still return true. + """ return _gdi_.DC_FloodFill(*args, **kwargs) def FloodFillPoint(*args, **kwargs): - """FloodFillPoint(self, Point pt, Colour col, int style=FLOOD_SURFACE) -> bool""" + """ + 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 GetPixel(*args, **kwargs): - """GetPixel(self, int x, int y) -> Colour""" + """ + GetPixel(self, int x, int y) -> Colour + + Gets the colour at the specified location on the DC. + """ return _gdi_.DC_GetPixel(*args, **kwargs) def GetPixelPoint(*args, **kwargs): @@ -2353,127 +2761,368 @@ class DC(_core.Object): return _gdi_.DC_GetPixelPoint(*args, **kwargs) def DrawLine(*args, **kwargs): - """DrawLine(self, int x1, int y1, int x2, int y2)""" + """ + 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)""" + """ + 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)""" + """ + 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)""" + """ + 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)""" + """ + 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 centre)""" + """ + 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)""" + """ + 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)""" + """ + 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 sa, double ea)""" + """ + DrawEllipticArc(self, int x, int y, int w, int h, double start, double end) + + Draws an arc of an ellipse, with the given rectangle defining the + bounds of the ellipse. The current pen is used for drawing the arc and + the current brush is used for drawing the pie. + + The *start* and *end* parameters specify the start and end of the arc + relative to the three-o'clock position from the center of the + rectangle. Angles are specified in degrees (360 is a complete + circle). Positive values mean counter-clockwise motion. If start is + equal to end, a complete ellipse will be drawn. + """ return _gdi_.DC_DrawEllipticArc(*args, **kwargs) def DrawEllipticArcPointSize(*args, **kwargs): - """DrawEllipticArcPointSize(self, Point pt, Size sz, double sa, double ea)""" + """ + 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)""" + """ + 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)""" + """ + 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)""" + """ + DrawRectangle(self, int x, int y, int width, int height) + + Draws a rectangle with the given top left corner, and with the given + size. The current pen is used for the outline and the current brush + for filling the shape. + """ return _gdi_.DC_DrawRectangle(*args, **kwargs) def DrawRectangleRect(*args, **kwargs): - """DrawRectangleRect(self, Rect rect)""" + """ + DrawRectangleRect(self, Rect rect) + + Draws a rectangle with the given top left corner, and with the given + size. The current pen is used for the outline and the current brush + for filling the shape. + """ return _gdi_.DC_DrawRectangleRect(*args, **kwargs) def DrawRectanglePointSize(*args, **kwargs): - """DrawRectanglePointSize(self, Point pt, Size sz)""" + """ + 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)""" + """ + DrawRoundedRectangle(self, int x, int y, int width, int height, double radius) + + Draws a rectangle with the given top left corner, and with the given + size. The corners are quarter-circles using the given radius. The + current pen is used for the outline and the current brush for filling + the shape. + + If radius is positive, the value is assumed to be the radius of the + rounded corner. If radius is negative, the absolute value is assumed + to be the proportion of the smallest dimension of the rectangle. This + means that the corner can be a sensible size relative to the size of + the rectangle, and also avoids the strange effects X produces when the + corners are too big for the rectangle. + """ return _gdi_.DC_DrawRoundedRectangle(*args, **kwargs) def DrawRoundedRectangleRect(*args, **kwargs): - """DrawRoundedRectangleRect(self, Rect r, double radius)""" + """ + DrawRoundedRectangleRect(self, Rect r, double radius) + + Draws a rectangle with the given top left corner, and with the given + size. The corners are quarter-circles using the given radius. The + current pen is used for the outline and the current brush for filling + the shape. + + If radius is positive, the value is assumed to be the radius of the + rounded corner. If radius is negative, the absolute value is assumed + to be the proportion of the smallest dimension of the rectangle. This + means that the corner can be a sensible size relative to the size of + the rectangle, and also avoids the strange effects X produces when the + corners are too big for the rectangle. + """ return _gdi_.DC_DrawRoundedRectangleRect(*args, **kwargs) def DrawRoundedRectanglePointSize(*args, **kwargs): - """DrawRoundedRectanglePointSize(self, Point pt, Size sz, double radius)""" + """ + 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)""" + """ + 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)""" - return _gdi_.DC_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)""" + """ + DrawEllipse(self, int x, int y, int width, int height) + + Draws an ellipse contained in the specified rectangle. The current pen + is used for the outline and the current brush for filling the shape. + """ return _gdi_.DC_DrawEllipse(*args, **kwargs) def DrawEllipseRect(*args, **kwargs): - """DrawEllipseRect(self, Rect rect)""" + """ + DrawEllipseRect(self, Rect rect) + + Draws an ellipse contained in the specified rectangle. The current pen + is used for the outline and the current brush for filling the shape. + """ return _gdi_.DC_DrawEllipseRect(*args, **kwargs) def DrawEllipsePointSize(*args, **kwargs): - """DrawEllipsePointSize(self, Point pt, Size sz)""" + """ + 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)""" + """ + 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)""" + """ + 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)""" + """ + 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)""" + """ + 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)""" + """ + 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)""" + """ + 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)""" + """ + 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)""" + """ + 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): @@ -2481,6 +3130,11 @@ class DC(_core.Object): 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) @@ -2488,33 +3142,105 @@ class DC(_core.Object): """ 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 SetClippingRegion(*args, **kwargs): - """SetClippingRegion(self, int x, int y, int width, int height)""" + """ + 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)""" + """ + 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)""" + """ + 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)""" + """ + SetClippingRect(self, Rect rect) + + Sets the clipping region for this device context to the intersection + of the given region described by the parameters of this method and the + previously set clipping region. You should call `DestroyClippingRegion` + if you want to set the clipping region exactly to the region + specified. + + The clipping region is an area to which drawing is + restricted. Possible uses for the clipping region are for clipping + text or for speeding up window redraws when only a known area of the + screen is damaged. + """ return _gdi_.DC_SetClippingRect(*args, **kwargs) def DrawLines(*args, **kwargs): - """DrawLines(self, int points, Point points_array, int xoffset=0, int yoffset=0)""" + """ + DrawLines(self, List points, int xoffset=0, int yoffset=0) + + Draws lines using a sequence of `wx.Point` objects, adding the + optional offset coordinate. The current pen is used for drawing the + lines. + """ return _gdi_.DC_DrawLines(*args, **kwargs) def DrawPolygon(*args, **kwargs): """ - DrawPolygon(self, int points, Point points_array, int xoffset=0, int yoffset=0, + DrawPolygon(self, List points, int xoffset=0, int yoffset=0, int fillStyle=ODDEVEN_RULE) + + Draws a filled polygon using a sequence of `wx.Point` objects, adding + the optional offset coordinate. The last argument specifies the fill + rule: ``wx.ODDEVEN_RULE`` (the default) or ``wx.WINDING_RULE``. + + The current pen is used for drawing the outline, and the current brush + for filling the shape. Using a transparent brush suppresses + filling. Note that wxWidgets automatically closes the first and last + points. """ return _gdi_.DC_DrawPolygon(*args, **kwargs) @@ -2522,6 +3248,10 @@ class DC(_core.Object): """ 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) @@ -2529,79 +3259,174 @@ class DC(_core.Object): """ DrawImageLabel(self, String text, Bitmap image, Rect rect, int alignment=wxALIGN_LEFT|wxALIGN_TOP, int indexAccel=-1) -> Rect + + Draw *text* and an image (which may be ``wx.NullBitmap`` to skip + drawing it) within the specified rectangle, abiding by the alignment + flags. Will additionally emphasize the character at *indexAccel* if + it is not -1. Returns the bounding rectangle. """ return _gdi_.DC_DrawImageLabel(*args, **kwargs) def DrawSpline(*args, **kwargs): - """DrawSpline(self, int points, Point points_array)""" + """ + DrawSpline(self, List points) + + Draws a spline between all given control points, (a list of `wx.Point` + objects) using the current pen. The spline is drawn using a series of + lines, using an algorithm taken from the X drawing program 'XFIG'. + """ return _gdi_.DC_DrawSpline(*args, **kwargs) def Clear(*args, **kwargs): - """Clear(self)""" + """ + Clear(self) + + Clears the device context using the current background brush. + """ return _gdi_.DC_Clear(*args, **kwargs) def StartDoc(*args, **kwargs): - """StartDoc(self, String message) -> bool""" + """ + StartDoc(self, String message) -> bool + + Starts a document (only relevant when outputting to a + printer). *Message* is a message to show whilst printing. + """ return _gdi_.DC_StartDoc(*args, **kwargs) def EndDoc(*args, **kwargs): - """EndDoc(self)""" + """ + EndDoc(self) + + Ends a document (only relevant when outputting to a printer). + """ return _gdi_.DC_EndDoc(*args, **kwargs) def StartPage(*args, **kwargs): - """StartPage(self)""" + """ + StartPage(self) + + Starts a document page (only relevant when outputting to a printer). + """ return _gdi_.DC_StartPage(*args, **kwargs) def EndPage(*args, **kwargs): - """EndPage(self)""" + """ + EndPage(self) + + Ends a document page (only relevant when outputting to a printer). + """ return _gdi_.DC_EndPage(*args, **kwargs) def SetFont(*args, **kwargs): - """SetFont(self, Font font)""" + """ + SetFont(self, Font font) + + Sets the current font for the DC. It must be a valid font, in + particular you should not pass ``wx.NullFont`` to this method. + """ return _gdi_.DC_SetFont(*args, **kwargs) def SetPen(*args, **kwargs): - """SetPen(self, Pen pen)""" + """ + SetPen(self, Pen pen) + + Sets the current pen for the DC. + + If the argument is ``wx.NullPen``, the current pen is selected out of the + device context, and the original pen restored. + """ return _gdi_.DC_SetPen(*args, **kwargs) def SetBrush(*args, **kwargs): - """SetBrush(self, Brush brush)""" + """ + SetBrush(self, Brush brush) + + Sets the current brush for the DC. + + If the argument is ``wx.NullBrush``, the current brush is selected out + of the device context, and the original brush restored, allowing the + current brush to be destroyed safely. + """ return _gdi_.DC_SetBrush(*args, **kwargs) def SetBackground(*args, **kwargs): - """SetBackground(self, Brush brush)""" + """ + SetBackground(self, Brush brush) + + Sets the current background brush for the DC. + """ return _gdi_.DC_SetBackground(*args, **kwargs) def SetBackgroundMode(*args, **kwargs): - """SetBackgroundMode(self, int mode)""" + """ + SetBackgroundMode(self, int mode) + + *mode* may be one of ``wx.SOLID`` and ``wx.TRANSPARENT``. This setting + determines whether text will be drawn with a background colour or + not. + """ return _gdi_.DC_SetBackgroundMode(*args, **kwargs) def SetPalette(*args, **kwargs): - """SetPalette(self, Palette palette)""" + """ + 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)""" + """ + DestroyClippingRegion(self) + + Destroys the current clipping region so that none of the DC is + clipped. + """ return _gdi_.DC_DestroyClippingRegion(*args, **kwargs) def GetClippingBox(*args, **kwargs): - """GetClippingBox() -> (x, y, width, height)""" + """ + GetClippingBox() -> (x, y, width, height) + + Gets the rectangle surrounding the current clipping region. + """ return _gdi_.DC_GetClippingBox(*args, **kwargs) def GetClippingRect(*args, **kwargs): - """GetClippingRect(self) -> Rect""" + """ + GetClippingRect(self) -> Rect + + Gets the rectangle surrounding the current clipping region. + """ return _gdi_.DC_GetClippingRect(*args, **kwargs) def GetCharHeight(*args, **kwargs): - """GetCharHeight(self) -> int""" + """ + GetCharHeight(self) -> int + + Gets the character height of the currently set font. + """ return _gdi_.DC_GetCharHeight(*args, **kwargs) def GetCharWidth(*args, **kwargs): - """GetCharWidth(self) -> int""" + """ + GetCharWidth(self) -> int + + Gets the average character width of the currently set font. + """ return _gdi_.DC_GetCharWidth(*args, **kwargs) def GetTextExtent(*args, **kwargs): - """GetTextExtent(wxString string) -> (width, height)""" + """ + 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): @@ -2618,18 +3443,41 @@ class DC(_core.Object): """ GetMultiLineTextExtent(wxString string, Font font=None) -> (width, height, descent, externalLeading) + + Get the width, height, decent and leading of the text using the + current or specified font. Works for single as well as multi-line + strings. """ return _gdi_.DC_GetMultiLineTextExtent(*args, **kwargs) def GetPartialTextExtents(*args, **kwargs): - """GetPartialTextExtents(self, String text) -> wxArrayInt""" + """ + GetPartialTextExtents(self, text) -> [widths] + + Returns a list of integers such that each value is the distance in + pixels from the begining of text to the coresponding character of + *text*. The generic version simply builds a running total of the widths + of each character using GetTextExtent, however if the various + platforms have a native API function that is faster or more accurate + than the generic implementation then it will be used instead. + """ return _gdi_.DC_GetPartialTextExtents(*args, **kwargs) def GetSize(*args, **kwargs): """ GetSize(self) -> Size - Get the DC size in device units. + This gets the horizontal and vertical resolution in device units. It + can be used to scale graphics to fit the page. For example, if *maxX* + and *maxY* represent the maximum horizontal and vertical 'pixel' values + used in your application, the following code will scale the graphic to + fit on the printer page:: + + w, h = dc.GetSize() + scaleX = maxX*1.0 / w + scaleY = maxY*1.0 / h + dc.SetUserScale(min(scaleX,scaleY),min(scaleX,scaleY)) + """ return _gdi_.DC_GetSize(*args, **kwargs) @@ -2637,7 +3485,17 @@ class DC(_core.Object): """ GetSizeTuple() -> (width, height) - Get the DC size in device units. + This gets the horizontal and vertical resolution in device units. It + can be used to scale graphics to fit the page. For example, if *maxX* + and *maxY* represent the maximum horizontal and vertical 'pixel' values + used in your application, the following code will scale the graphic to + fit on the printer page:: + + w, h = dc.GetSize() + scaleX = maxX*1.0 / w + scaleY = maxY*1.0 / h + dc.SetUserScale(min(scaleX,scaleY),min(scaleX,scaleY)) + """ return _gdi_.DC_GetSizeTuple(*args, **kwargs) @@ -2658,35 +3516,79 @@ class DC(_core.Object): return _gdi_.DC_GetSizeMMTuple(*args, **kwargs) def DeviceToLogicalX(*args, **kwargs): - """DeviceToLogicalX(self, int x) -> int""" + """ + DeviceToLogicalX(self, int x) -> int + + Convert device X coordinate to logical coordinate, using the current + mapping mode. + """ return _gdi_.DC_DeviceToLogicalX(*args, **kwargs) def DeviceToLogicalY(*args, **kwargs): - """DeviceToLogicalY(self, int y) -> int""" + """ + DeviceToLogicalY(self, int y) -> int + + Converts device Y coordinate to logical coordinate, using the current + mapping mode. + """ return _gdi_.DC_DeviceToLogicalY(*args, **kwargs) def DeviceToLogicalXRel(*args, **kwargs): - """DeviceToLogicalXRel(self, int x) -> int""" + """ + DeviceToLogicalXRel(self, int x) -> int + + Convert device X coordinate to relative logical coordinate, using the + current mapping mode but ignoring the x axis orientation. Use this + function for converting a width, for example. + """ return _gdi_.DC_DeviceToLogicalXRel(*args, **kwargs) def DeviceToLogicalYRel(*args, **kwargs): - """DeviceToLogicalYRel(self, int y) -> int""" + """ + DeviceToLogicalYRel(self, int y) -> int + + Convert device Y coordinate to relative logical coordinate, using the + current mapping mode but ignoring the y axis orientation. Use this + function for converting a height, for example. + """ return _gdi_.DC_DeviceToLogicalYRel(*args, **kwargs) def LogicalToDeviceX(*args, **kwargs): - """LogicalToDeviceX(self, int x) -> int""" + """ + LogicalToDeviceX(self, int x) -> int + + Converts logical X coordinate to device coordinate, using the current + mapping mode. + """ return _gdi_.DC_LogicalToDeviceX(*args, **kwargs) def LogicalToDeviceY(*args, **kwargs): - """LogicalToDeviceY(self, int y) -> int""" + """ + LogicalToDeviceY(self, int y) -> int + + Converts logical Y coordinate to device coordinate, using the current + mapping mode. + """ return _gdi_.DC_LogicalToDeviceY(*args, **kwargs) def LogicalToDeviceXRel(*args, **kwargs): - """LogicalToDeviceXRel(self, int x) -> int""" + """ + LogicalToDeviceXRel(self, int x) -> int + + Converts logical X coordinate to relative device coordinate, using the + current mapping mode but ignoring the x axis orientation. Use this for + converting a width, for example. + """ return _gdi_.DC_LogicalToDeviceXRel(*args, **kwargs) def LogicalToDeviceYRel(*args, **kwargs): - """LogicalToDeviceYRel(self, int y) -> int""" + """ + LogicalToDeviceYRel(self, int y) -> int + + Converts logical Y coordinate to relative device coordinate, using the + current mapping mode but ignoring the y axis orientation. Use this for + converting a height, for example. + """ return _gdi_.DC_LogicalToDeviceYRel(*args, **kwargs) def CanDrawBitmap(*args, **kwargs): @@ -2698,67 +3600,145 @@ class DC(_core.Object): return _gdi_.DC_CanGetTextExtent(*args, **kwargs) def GetDepth(*args, **kwargs): - """GetDepth(self) -> int""" + """ + GetDepth(self) -> int + + Returns the colour depth of the DC. + """ return _gdi_.DC_GetDepth(*args, **kwargs) def GetPPI(*args, **kwargs): - """GetPPI(self) -> Size""" + """ + GetPPI(self) -> Size + + Resolution in Pixels per inch + """ return _gdi_.DC_GetPPI(*args, **kwargs) def Ok(*args, **kwargs): - """Ok(self) -> bool""" + """ + Ok(self) -> bool + + Returns true if the DC is ok to use. + """ return _gdi_.DC_Ok(*args, **kwargs) def GetBackgroundMode(*args, **kwargs): - """GetBackgroundMode(self) -> int""" + """ + GetBackgroundMode(self) -> int + + Returns the current background mode, either ``wx.SOLID`` or + ``wx.TRANSPARENT``. + """ return _gdi_.DC_GetBackgroundMode(*args, **kwargs) def GetBackground(*args, **kwargs): - """GetBackground(self) -> Brush""" + """ + GetBackground(self) -> Brush + + Gets the brush used for painting the background. + """ return _gdi_.DC_GetBackground(*args, **kwargs) def GetBrush(*args, **kwargs): - """GetBrush(self) -> Brush""" + """ + GetBrush(self) -> Brush + + Gets the current brush + """ return _gdi_.DC_GetBrush(*args, **kwargs) def GetFont(*args, **kwargs): - """GetFont(self) -> Font""" + """ + GetFont(self) -> Font + + Gets the current font + """ return _gdi_.DC_GetFont(*args, **kwargs) def GetPen(*args, **kwargs): - """GetPen(self) -> Pen""" + """ + GetPen(self) -> Pen + + Gets the current pen + """ return _gdi_.DC_GetPen(*args, **kwargs) def GetTextBackground(*args, **kwargs): - """GetTextBackground(self) -> Colour""" + """ + GetTextBackground(self) -> Colour + + Gets the current text background colour + """ return _gdi_.DC_GetTextBackground(*args, **kwargs) def GetTextForeground(*args, **kwargs): - """GetTextForeground(self) -> Colour""" + """ + GetTextForeground(self) -> Colour + + Gets the current text foreground colour + """ return _gdi_.DC_GetTextForeground(*args, **kwargs) def SetTextForeground(*args, **kwargs): - """SetTextForeground(self, Colour colour)""" + """ + SetTextForeground(self, Colour colour) + + Sets the current text foreground colour for the DC. + """ return _gdi_.DC_SetTextForeground(*args, **kwargs) def SetTextBackground(*args, **kwargs): - """SetTextBackground(self, Colour colour)""" + """ + SetTextBackground(self, Colour colour) + + Sets the current text background colour for the DC. + """ return _gdi_.DC_SetTextBackground(*args, **kwargs) def GetMapMode(*args, **kwargs): - """GetMapMode(self) -> int""" + """ + GetMapMode(self) -> int + + Gets the current *mapping mode* for the device context + """ return _gdi_.DC_GetMapMode(*args, **kwargs) def SetMapMode(*args, **kwargs): - """SetMapMode(self, int mode)""" + """ + SetMapMode(self, int mode) + + The *mapping mode* of the device context defines the unit of + measurement used to convert logical units to device units. The + mapping mode can be one of the following: + + ================ ============================================= + wx.MM_TWIPS Each logical unit is 1/20 of a point, or 1/1440 + of an inch. + wx.MM_POINTS Each logical unit is a point, or 1/72 of an inch. + wx.MM_METRIC Each logical unit is 1 mm. + wx.MM_LOMETRIC Each logical unit is 1/10 of a mm. + wx.MM_TEXT Each logical unit is 1 pixel. + ================ ============================================= + + """ return _gdi_.DC_SetMapMode(*args, **kwargs) def GetUserScale(*args, **kwargs): - """GetUserScale() -> (xScale, yScale)""" + """ + GetUserScale(self) -> (xScale, yScale) + + Gets the current user scale factor (set by `SetUserScale`). + """ return _gdi_.DC_GetUserScale(*args, **kwargs) def SetUserScale(*args, **kwargs): - """SetUserScale(self, double x, double y)""" + """ + SetUserScale(self, double x, double y) + + Sets the user scaling factor, useful for applications which require + 'zooming'. + """ return _gdi_.DC_SetUserScale(*args, **kwargs) def GetLogicalScale(*args, **kwargs): @@ -2802,55 +3782,147 @@ class DC(_core.Object): return _gdi_.DC_SetDeviceOriginPoint(*args, **kwargs) def SetAxisOrientation(*args, **kwargs): - """SetAxisOrientation(self, bool xLeftRight, bool yBottomUp)""" + """ + SetAxisOrientation(self, bool xLeftRight, bool yBottomUp) + + Sets the x and y axis orientation (i.e., the direction from lowest to + highest values on the axis). The default orientation is the natural + orientation, e.g. x axis from left to right and y axis from bottom up. + """ return _gdi_.DC_SetAxisOrientation(*args, **kwargs) def GetLogicalFunction(*args, **kwargs): - """GetLogicalFunction(self) -> int""" + """ + GetLogicalFunction(self) -> int + + Gets the current logical function (set by `SetLogicalFunction`). + """ return _gdi_.DC_GetLogicalFunction(*args, **kwargs) def SetLogicalFunction(*args, **kwargs): - """SetLogicalFunction(self, int function)""" + """ + SetLogicalFunction(self, int function) + + Sets the current logical function for the device context. This + determines how a source pixel (from a pen or brush colour, or source + device context if using `Blit`) combines with a destination pixel in + the current device context. + + The possible values and their meaning in terms of source and + destination pixel values are as follows: + + ================ ========================== + wx.AND src AND dst + wx.AND_INVERT (NOT src) AND dst + wx.AND_REVERSE src AND (NOT dst) + wx.CLEAR 0 + wx.COPY src + wx.EQUIV (NOT src) XOR dst + wx.INVERT NOT dst + wx.NAND (NOT src) OR (NOT dst) + wx.NOR (NOT src) AND (NOT dst) + wx.NO_OP dst + wx.OR src OR dst + wx.OR_INVERT (NOT src) OR dst + wx.OR_REVERSE src OR (NOT dst) + wx.SET 1 + wx.SRC_INVERT NOT src + wx.XOR src XOR dst + ================ ========================== + + The default is wx.COPY, which simply draws with the current + colour. The others combine the current colour and the background using + a logical operation. wx.INVERT is commonly used for drawing rubber + bands or moving outlines, since drawing twice reverts to the original + colour. + + """ return _gdi_.DC_SetLogicalFunction(*args, **kwargs) - def SetOptimization(*args, **kwargs): - """SetOptimization(self, bool opt)""" - return _gdi_.DC_SetOptimization(*args, **kwargs) + def ComputeScaleAndOrigin(*args, **kwargs): + """ + ComputeScaleAndOrigin(self) + + Performs all necessary computations for given platform and context + type after each change of scale and origin parameters. Usually called + automatically internally after such changes. + + """ + return _gdi_.DC_ComputeScaleAndOrigin(*args, **kwargs) + + def SetOptimization(self, optimize): + pass + def GetOptimization(self): + return False - def GetOptimization(*args, **kwargs): - """GetOptimization(self) -> bool""" - return _gdi_.DC_GetOptimization(*args, **kwargs) + SetOptimization = wx._deprecated(SetOptimization) + GetOptimization = wx._deprecated(GetOptimization) def CalcBoundingBox(*args, **kwargs): - """CalcBoundingBox(self, int x, int y)""" + """ + CalcBoundingBox(self, int x, int y) + + Adds the specified point to the bounding box which can be retrieved + with `MinX`, `MaxX` and `MinY`, `MaxY` or `GetBoundingBox` functions. + """ return _gdi_.DC_CalcBoundingBox(*args, **kwargs) def CalcBoundingBoxPoint(*args, **kwargs): - """CalcBoundingBoxPoint(self, Point point)""" + """ + CalcBoundingBoxPoint(self, Point point) + + Adds the specified point to the bounding box which can be retrieved + with `MinX`, `MaxX` and `MinY`, `MaxY` or `GetBoundingBox` functions. + """ return _gdi_.DC_CalcBoundingBoxPoint(*args, **kwargs) def ResetBoundingBox(*args, **kwargs): - """ResetBoundingBox(self)""" + """ + ResetBoundingBox(self) + + Resets the bounding box: after a call to this function, the bounding + box doesn't contain anything. + """ return _gdi_.DC_ResetBoundingBox(*args, **kwargs) def MinX(*args, **kwargs): - """MinX(self) -> int""" + """ + MinX(self) -> int + + Gets the minimum horizontal extent used in drawing commands so far. + """ return _gdi_.DC_MinX(*args, **kwargs) def MaxX(*args, **kwargs): - """MaxX(self) -> int""" + """ + MaxX(self) -> int + + Gets the maximum horizontal extent used in drawing commands so far. + """ return _gdi_.DC_MaxX(*args, **kwargs) def MinY(*args, **kwargs): - """MinY(self) -> int""" + """ + MinY(self) -> int + + Gets the minimum vertical extent used in drawing commands so far. + """ return _gdi_.DC_MinY(*args, **kwargs) def MaxY(*args, **kwargs): - """MaxY(self) -> int""" + """ + MaxY(self) -> int + + Gets the maximum vertical extent used in drawing commands so far. + """ return _gdi_.DC_MaxY(*args, **kwargs) def GetBoundingBox(*args, **kwargs): - """GetBoundingBox() -> (x1,y1, x2,y2)""" + """ + GetBoundingBox() -> (x1,y1, x2,y2) + + Returns the min and max points used in drawing commands so far. + """ return _gdi_.DC_GetBoundingBox(*args, **kwargs) def __nonzero__(self): return self.Ok() @@ -2882,6 +3954,16 @@ class DC(_core.Object): 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): @@ -2892,6 +3974,16 @@ class DC(_core.Object): 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): @@ -2902,6 +3994,18 @@ class DC(_core.Object): 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): @@ -2918,6 +4022,18 @@ class DC(_core.Object): 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): @@ -2934,8 +4050,20 @@ class DC(_core.Object): def DrawPolygonList(self, polygons, pens=None, brushes=None): - ## Note: This does not currently support fill style or offset - ## you can always use the non-List version if need be. + """ + Draw a list of polygons, each of which is a list of points. + + :param polygons: A sequence of sequences of sequences. + [[(x1,y1),(x2,y2),(x3,y3)...], + [(x1,y1),(x2,y2),(x3,y3)...]] + + :param pens: If None, then the current pen is used. If a + single pen then it will be used for all polygons. + If a list of pens then there should be one for each + polygon. + :param brushes: A brush or brushes to be used to fill the polygons, + with similar semantics as the pens parameter. + """ if pens is None: pens = [] elif isinstance(pens, wx.Pen): @@ -2951,10 +4079,20 @@ class DC(_core.Object): return self._DrawPolygonList(polygons, pens, brushes) - def DrawTextList(self, textList, coords, foregrounds = None, backgrounds = None, fonts = None): - ## NOTE: this does not currently support changing the font - ## Make sure you set Background mode to wxSolid (DC.SetBackgroundMode) - ## If you want backgounds to do anything. + def DrawTextList(self, textList, coords, foregrounds = None, backgrounds = None): + """ + Draw a list of strings using a list of coordinants for positioning each string. + + :param textList: A list of strings + :param coords: A list of (x,y) positions + :param foregrounds: A list of `wx.Colour` objects to use for the + foregrounds of the strings. + :param backgrounds: A list of `wx.Colour` objects to use for the + backgrounds of the strings. + + NOTE: Make sure you set Background mode to wx.Solid (DC.SetBackgroundMode) + If you want backgrounds to do anything. + """ if type(textList) == type(''): textList = [textList] elif len(textList) != len(coords): @@ -2984,16 +4122,51 @@ _gdi_.DC_swigregister(DCPtr) #--------------------------------------------------------------------------- class MemoryDC(DC): + """ + A memory device context provides a means to draw graphics onto a + bitmap. A bitmap must be selected into the new memory DC before it may + be used for anything. Typical usage is as follows:: + + dc = wx.MemoryDC() + dc.SelectObject(bitmap) + # draw on the dc usign any of the Draw methods + dc.SelectObject(wx.NullBitmap) + # the bitmap now contains wahtever was drawn upon it + + Note that the memory DC *must* be deleted (or the bitmap selected out + of it) before a bitmap can be reselected into another memory DC. + + """ def __repr__(self): return "<%s.%s; proxy of C++ wxMemoryDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): - """__init__(self) -> MemoryDC""" + """ + __init__(self) -> MemoryDC + + Constructs a new memory device context. + + Use the Ok member to test whether the constructor was successful in + creating a usable device context. Don't forget to select a bitmap into + the DC before drawing on it. + """ newobj = _gdi_.new_MemoryDC(*args, **kwargs) self.this = newobj.this self.thisown = 1 del newobj.thisown def SelectObject(*args, **kwargs): - """SelectObject(self, Bitmap bitmap)""" + """ + 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) @@ -3005,35 +4178,66 @@ class MemoryDCPtr(MemoryDC): _gdi_.MemoryDC_swigregister(MemoryDCPtr) def MemoryDCFromDC(*args, **kwargs): - """MemoryDCFromDC(DC oldDC) -> MemoryDC""" + """ + MemoryDCFromDC(DC oldDC) -> MemoryDC + + Creates a DC that is compatible with the oldDC. + """ val = _gdi_.new_MemoryDCFromDC(*args, **kwargs) val.thisown = 1 return val #--------------------------------------------------------------------------- +BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA +BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA class BufferedDC(MemoryDC): + """ + This simple class provides a simple way to avoid flicker: when drawing + on it, everything is in fact first drawn on an in-memory buffer (a + `wx.Bitmap`) and then copied to the screen only once, when this object + is destroyed. + + It can be used in the same way as any other device + context. wx.BufferedDC itself typically replaces `wx.ClientDC`, if you + want to use it in your EVT_PAINT handler, you should look at + `wx.BufferedPaintDC`. + + """ def __repr__(self): return "<%s.%s; proxy of C++ wxBufferedDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args): """ - __init__(self, DC dc, Bitmap buffer) -> BufferedDC - __init__(self, DC dc, Size area) -> BufferedDC + __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. """ newobj = _gdi_.new_BufferedDC(*args) self.this = newobj.this self.thisown = 1 del newobj.thisown - self._dc = args[0] # save a ref so the other dc will not be deleted before self + self.__dc = args[0] # save a ref so the other dc will not be deleted before self def __del__(self, destroy=_gdi_.delete_BufferedDC): - """__del__(self)""" + """ + __del__(self) + + Copies everything drawn on the DC so far to the underlying DC + associated with this object, if any. + """ try: if self.thisown: destroy(self) except: pass def UnMask(*args, **kwargs): - """UnMask(self)""" + """ + UnMask(self) + + Blits the buffer to the dc, and detaches the dc from the buffer (so it + can be effectively used once only). This is usually only called in + the destructor. + """ return _gdi_.BufferedDC_UnMask(*args, **kwargs) @@ -3044,18 +4248,42 @@ class BufferedDCPtr(BufferedDC): self.__class__ = BufferedDC _gdi_.BufferedDC_swigregister(BufferedDCPtr) -def BufferedDCInternalBuffer(*args): - """BufferedDCInternalBuffer(DC dc, Size area) -> BufferedDC""" - val = _gdi_.new_BufferedDCInternalBuffer(*args) - val.thisown = 1 - val._dc = args[0] # save a ref so the other dc will not be deleted before self - return val - class BufferedPaintDC(BufferedDC): + """ + 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) + + + + + + """ def __repr__(self): return "<%s.%s; proxy of C++ wxBufferedPaintDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): - """__init__(self, Window window, Bitmap buffer=NullBitmap) -> BufferedPaintDC""" + """ + __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). + + + """ newobj = _gdi_.new_BufferedPaintDC(*args, **kwargs) self.this = newobj.this self.thisown = 1 @@ -3071,24 +4299,66 @@ _gdi_.BufferedPaintDC_swigregister(BufferedPaintDCPtr) #--------------------------------------------------------------------------- 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. + + """ def __repr__(self): return "<%s.%s; proxy of C++ wxScreenDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): - """__init__(self) -> ScreenDC""" + """ + __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. + + """ newobj = _gdi_.new_ScreenDC(*args, **kwargs) self.this = newobj.this self.thisown = 1 del newobj.thisown def StartDrawingOnTopWin(*args, **kwargs): - """StartDrawingOnTopWin(self, Window window) -> bool""" + """ + StartDrawingOnTopWin(self, Window window) -> bool + + Specify that the area of the screen to be drawn upon coincides with + the given window. + + :see: `EndDrawingOnTop` + """ return _gdi_.ScreenDC_StartDrawingOnTopWin(*args, **kwargs) def StartDrawingOnTop(*args, **kwargs): - """StartDrawingOnTop(self, Rect rect=None) -> bool""" + """ + StartDrawingOnTop(self, Rect rect=None) -> bool + + Specify that the area is the given rectangle, or the whole screen if + ``None`` is passed. + + :see: `EndDrawingOnTop` + """ return _gdi_.ScreenDC_StartDrawingOnTop(*args, **kwargs) def EndDrawingOnTop(*args, **kwargs): - """EndDrawingOnTop(self) -> bool""" + """ + 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) @@ -3102,10 +4372,27 @@ _gdi_.ScreenDC_swigregister(ScreenDCPtr) #--------------------------------------------------------------------------- class ClientDC(DC): + """ + 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). + + """ def __repr__(self): return "<%s.%s; proxy of C++ wxClientDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): - """__init__(self, Window win) -> ClientDC""" + """ + __init__(self, Window win) -> ClientDC + + Constructor. Pass the window on which you wish to paint. + """ newobj = _gdi_.new_ClientDC(*args, **kwargs) self.this = newobj.this self.thisown = 1 @@ -3121,10 +4408,30 @@ _gdi_.ClientDC_swigregister(ClientDCPtr) #--------------------------------------------------------------------------- class PaintDC(DC): + """ + 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. + + """ def __repr__(self): return "<%s.%s; proxy of C++ wxPaintDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): - """__init__(self, Window win) -> PaintDC""" + """ + __init__(self, Window win) -> PaintDC + + Constructor. Pass the window on which you wish to paint. + """ newobj = _gdi_.new_PaintDC(*args, **kwargs) self.this = newobj.this self.thisown = 1 @@ -3140,10 +4447,20 @@ _gdi_.PaintDC_swigregister(PaintDCPtr) #--------------------------------------------------------------------------- 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. + """ def __repr__(self): return "<%s.%s; proxy of C++ wxWindowDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): - """__init__(self, Window win) -> WindowDC""" + """ + __init__(self, Window win) -> WindowDC + + Constructor. Pass the window on which you wish to paint. + """ newobj = _gdi_.new_WindowDC(*args, **kwargs) self.this = newobj.this self.thisown = 1 @@ -3159,10 +4476,24 @@ _gdi_.WindowDC_swigregister(WindowDCPtr) #--------------------------------------------------------------------------- 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. + """ def __repr__(self): return "<%s.%s; proxy of C++ wxMirrorDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): - """__init__(self, DC dc, bool mirror) -> MirrorDC""" + """ + __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. + """ newobj = _gdi_.new_MirrorDC(*args, **kwargs) self.this = newobj.this self.thisown = 1 @@ -3178,10 +4509,16 @@ _gdi_.MirrorDC_swigregister(MirrorDCPtr) #--------------------------------------------------------------------------- class PostScriptDC(DC): + """This is a `wx.DC` that can write to PostScript files on any platform.""" def __repr__(self): return "<%s.%s; proxy of C++ wxPostScriptDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): - """__init__(self, wxPrintData printData) -> PostScriptDC""" + """ + __init__(self, wxPrintData printData) -> PostScriptDC + + Constructs a PostScript printer device context from a `wx.PrintData` + object. + """ newobj = _gdi_.new_PostScriptDC(*args, **kwargs) self.this = newobj.this self.thisown = 1 @@ -3195,12 +4532,21 @@ class PostScriptDC(DC): return _gdi_.PostScriptDC_SetPrintData(*args, **kwargs) def SetResolution(*args, **kwargs): - """SetResolution(int ppi)""" + """ + SetResolution(int ppi) + + Set resolution (in pixels per inch) that will be used in PostScript + output. Default is 720ppi. + """ return _gdi_.PostScriptDC_SetResolution(*args, **kwargs) SetResolution = staticmethod(SetResolution) def GetResolution(*args, **kwargs): - """GetResolution() -> int""" + """ + GetResolution() -> int + + Return resolution used in PostScript output. + """ return _gdi_.PostScriptDC_GetResolution(*args, **kwargs) GetResolution = staticmethod(GetResolution) @@ -3213,16 +4559,26 @@ class PostScriptDCPtr(PostScriptDC): _gdi_.PostScriptDC_swigregister(PostScriptDCPtr) def PostScriptDC_SetResolution(*args, **kwargs): - """PostScriptDC_SetResolution(int ppi)""" + """ + 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, **kwargs): - """PostScriptDC_GetResolution() -> int""" + """ + PostScriptDC_GetResolution() -> int + + Return resolution used in PostScript output. + """ return _gdi_.PostScriptDC_GetResolution(*args, **kwargs) #--------------------------------------------------------------------------- class MetaFile(_core.Object): + """Proxy of C++ MetaFile class""" def __repr__(self): return "<%s.%s; proxy of C++ wxMetaFile instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -3240,6 +4596,7 @@ class MetaFilePtr(MetaFile): _gdi_.MetaFile_swigregister(MetaFilePtr) class MetaFileDC(DC): + """Proxy of C++ MetaFileDC class""" def __repr__(self): return "<%s.%s; proxy of C++ wxMetaFileDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -3260,6 +4617,7 @@ class MetaFileDCPtr(MetaFileDC): _gdi_.MetaFileDC_swigregister(MetaFileDCPtr) class PrinterDC(DC): + """Proxy of C++ PrinterDC class""" def __repr__(self): return "<%s.%s; proxy of C++ wxPrinterDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -3286,6 +4644,7 @@ 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""" def __repr__(self): return "<%s.%s; proxy of C++ wxImageList instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -3312,6 +4671,14 @@ class ImageList(_core.Object): """AddIcon(self, Icon icon) -> int""" return _gdi_.ImageList_AddIcon(*args, **kwargs) + def GetBitmap(*args, **kwargs): + """GetBitmap(self, int index) -> Bitmap""" + return _gdi_.ImageList_GetBitmap(*args, **kwargs) + + def GetIcon(*args, **kwargs): + """GetIcon(self, int index) -> Icon""" + return _gdi_.ImageList_GetIcon(*args, **kwargs) + def Replace(*args, **kwargs): """Replace(self, int index, Bitmap bitmap) -> bool""" return _gdi_.ImageList_Replace(*args, **kwargs) @@ -3350,6 +4717,7 @@ _gdi_.ImageList_swigregister(ImageListPtr) #--------------------------------------------------------------------------- class PenList(_core.Object): + """Proxy of C++ PenList class""" def __init__(self): raise RuntimeError, "No constructor defined" def __repr__(self): return "<%s.%s; proxy of C++ wxPenList instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) @@ -3421,6 +4789,7 @@ NullFont = cvar.NullFont NullColour = cvar.NullColour class BrushList(_core.Object): + """Proxy of C++ BrushList class""" def __init__(self): raise RuntimeError, "No constructor defined" def __repr__(self): return "<%s.%s; proxy of C++ wxBrushList instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) @@ -3429,7 +4798,7 @@ class BrushList(_core.Object): return _gdi_.BrushList_AddBrush(*args, **kwargs) def FindOrCreateBrush(*args, **kwargs): - """FindOrCreateBrush(self, Colour colour, int style) -> Brush""" + """FindOrCreateBrush(self, Colour colour, int style=SOLID) -> Brush""" return _gdi_.BrushList_FindOrCreateBrush(*args, **kwargs) def RemoveBrush(*args, **kwargs): @@ -3449,6 +4818,7 @@ class BrushListPtr(BrushList): _gdi_.BrushList_swigregister(BrushListPtr) class ColourDatabase(_core.Object): + """Proxy of C++ ColourDatabase class""" def __repr__(self): return "<%s.%s; proxy of C++ wxColourDatabase instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -3489,6 +4859,7 @@ class ColourDatabasePtr(ColourDatabase): _gdi_.ColourDatabase_swigregister(ColourDatabasePtr) class FontList(_core.Object): + """Proxy of C++ FontList class""" def __init__(self): raise RuntimeError, "No constructor defined" def __repr__(self): return "<%s.%s; proxy of C++ wxFontList instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) @@ -3526,6 +4897,7 @@ NullColor = NullColour #--------------------------------------------------------------------------- class Effects(_core.Object): + """Proxy of C++ Effects class""" def __repr__(self): return "<%s.%s; proxy of C++ wxEffects instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): @@ -3601,4 +4973,303 @@ ThePenList = cvar.ThePenList TheBrushList = cvar.TheBrushList TheColourDatabase = cvar.TheColourDatabase +#--------------------------------------------------------------------------- + +CONTROL_DISABLED = _gdi_.CONTROL_DISABLED +CONTROL_FOCUSED = _gdi_.CONTROL_FOCUSED +CONTROL_PRESSED = _gdi_.CONTROL_PRESSED +CONTROL_ISDEFAULT = _gdi_.CONTROL_ISDEFAULT +CONTROL_ISSUBMENU = _gdi_.CONTROL_ISSUBMENU +CONTROL_EXPANDED = _gdi_.CONTROL_EXPANDED +CONTROL_CURRENT = _gdi_.CONTROL_CURRENT +CONTROL_SELECTED = _gdi_.CONTROL_SELECTED +CONTROL_CHECKED = _gdi_.CONTROL_CHECKED +CONTROL_CHECKABLE = _gdi_.CONTROL_CHECKABLE +CONTROL_UNDETERMINED = _gdi_.CONTROL_UNDETERMINED +CONTROL_FLAGS_MASK = _gdi_.CONTROL_FLAGS_MASK +CONTROL_DIRTY = _gdi_.CONTROL_DIRTY +class SplitterRenderParams(object): + """ + This is just a simple struct used as a return value of + `wx.RendererNative.GetSplitterParams` and contains some platform + specific metrics about splitters. + + * widthSash: the width of the splitter sash. + * border: the width of the border of the splitter window. + * isHotSensitive: ``True`` if the splitter changes its + appearance when the mouse is over it. + + + """ + def __repr__(self): + return "<%s.%s; proxy of C++ wxSplitterRenderParams instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + 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. + + + """ + newobj = _gdi_.new_SplitterRenderParams(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi_.delete_SplitterRenderParams): + """__del__(self)""" + try: + if self.thisown: destroy(self) + except: pass + + widthSash = property(_gdi_.SplitterRenderParams_widthSash_get) + border = property(_gdi_.SplitterRenderParams_border_get) + isHotSensitive = property(_gdi_.SplitterRenderParams_isHotSensitive_get) + +class SplitterRenderParamsPtr(SplitterRenderParams): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = SplitterRenderParams +_gdi_.SplitterRenderParams_swigregister(SplitterRenderParamsPtr) + +class RendererVersion(object): + """ + This simple struct represents the `wx.RendererNative` interface + version and is only used as the return value of + `wx.RendererNative.GetVersion`. + """ + def __repr__(self): + return "<%s.%s; proxy of C++ wxRendererVersion instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + 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`. + """ + newobj = _gdi_.new_RendererVersion(*args, **kwargs) + self.this = newobj.this + self.thisown = 1 + del newobj.thisown + def __del__(self, destroy=_gdi_.delete_RendererVersion): + """__del__(self)""" + try: + if self.thisown: destroy(self) + except: pass + + 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) + +class RendererVersionPtr(RendererVersion): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = RendererVersion +_gdi_.RendererVersion_swigregister(RendererVersionPtr) + +def RendererVersion_IsCompatible(*args, **kwargs): + """RendererVersion_IsCompatible(RendererVersion ver) -> bool""" + return _gdi_.RendererVersion_IsCompatible(*args, **kwargs) + +class RendererNative(object): + """ + One of the design principles of wxWidgets is to use the native widgets + on every platform in order to be as close to the native look and feel + on every platform. However there are still cases when some generic + widgets are needed for various reasons, but it can sometimes take a + lot of messy work to make them conform to the native LnF. + + The wx.RendererNative class is a collection of functions that have + platform-specific implementations for drawing certain parts of + genereic controls in ways that are as close to the native look as + possible. + + """ + def __init__(self): raise RuntimeError, "No constructor defined" + def __repr__(self): + return "<%s.%s; proxy of C++ wxRendererNative instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) + def DrawHeaderButton(*args, **kwargs): + """ + DrawHeaderButton(self, Window win, DC dc, Rect rect, int flags=0) + + Draw the header control button (such as whar is used by `wx.ListCtrl` + in report mode.) + """ + return _gdi_.RendererNative_DrawHeaderButton(*args, **kwargs) + + def DrawTreeItemButton(*args, **kwargs): + """ + DrawTreeItemButton(self, Window win, DC dc, Rect rect, int flags=0) + + Draw the expanded/collapsed icon for a tree control item. + """ + return _gdi_.RendererNative_DrawTreeItemButton(*args, **kwargs) + + def DrawSplitterBorder(*args, **kwargs): + """ + DrawSplitterBorder(self, Window win, DC dc, Rect rect, int flags=0) + + Draw the border for a sash window: this border must be such that the + sash drawn by `DrawSplitterSash` blends into it well. + """ + return _gdi_.RendererNative_DrawSplitterBorder(*args, **kwargs) + + def DrawSplitterSash(*args, **kwargs): + """ + DrawSplitterSash(self, Window win, DC dc, Size size, int position, int orient, + int flags=0) + + Draw a sash. The orient parameter defines whether the sash should be + vertical or horizontal and how the position should be interpreted. + """ + return _gdi_.RendererNative_DrawSplitterSash(*args, **kwargs) + + def DrawComboBoxDropButton(*args, **kwargs): + """ + DrawComboBoxDropButton(self, Window win, DC dc, Rect rect, int flags=0) + + Draw a button like the one used by `wx.ComboBox` to show a drop down + window. The usual appearance is a downwards pointing arrow. + + The ``flags`` parameter may have the ``wx.CONTROL_PRESSED`` or + ``wx.CONTROL_CURRENT`` bits set. + """ + return _gdi_.RendererNative_DrawComboBoxDropButton(*args, **kwargs) + + def DrawDropArrow(*args, **kwargs): + """ + DrawDropArrow(self, Window win, DC dc, Rect rect, int flags=0) + + Draw a drop down arrow that is suitable for use outside a combo + box. Arrow will have a transparent background. + + ``rect`` is not entirely filled by the arrow. Instead, you should use + bounding rectangle of a drop down button which arrow matches the size + you need. ``flags`` may have the ``wx.CONTROL_PRESSED`` or + ``wx.CONTROL_CURRENT`` bit set. + """ + return _gdi_.RendererNative_DrawDropArrow(*args, **kwargs) + + def GetSplitterParams(*args, **kwargs): + """ + GetSplitterParams(self, Window win) -> SplitterRenderParams + + Get the splitter parameters, see `wx.SplitterRenderParams`. + """ + return _gdi_.RendererNative_GetSplitterParams(*args, **kwargs) + + def Get(*args, **kwargs): + """ + Get() -> RendererNative + + Return the currently used renderer + """ + return _gdi_.RendererNative_Get(*args, **kwargs) + + Get = staticmethod(Get) + def GetGeneric(*args, **kwargs): + """ + GetGeneric() -> RendererNative + + Return the generic implementation of the renderer. Under some + platforms, this is the default renderer implementation, others have + platform-specific default renderer which can be retrieved by calling + `GetDefault`. + """ + return _gdi_.RendererNative_GetGeneric(*args, **kwargs) + + GetGeneric = staticmethod(GetGeneric) + def GetDefault(*args, **kwargs): + """ + GetDefault() -> RendererNative + + Return the default (native) implementation for this platform -- this + is also the one used by default but this may be changed by calling `Set` + in which case the return value of this method may be different from + the return value of `Get`. + """ + return _gdi_.RendererNative_GetDefault(*args, **kwargs) + + GetDefault = staticmethod(GetDefault) + def Set(*args, **kwargs): + """ + Set(RendererNative renderer) -> RendererNative + + Set the renderer to use, passing None reverts to using the default + renderer. Returns the previous renderer used with Set or None. + """ + return _gdi_.RendererNative_Set(*args, **kwargs) + + Set = staticmethod(Set) + def GetVersion(*args, **kwargs): + """ + GetVersion(self) -> RendererVersion + + Returns the version of the renderer. Will be used for ensuring + compatibility of dynamically loaded renderers. + """ + return _gdi_.RendererNative_GetVersion(*args, **kwargs) + + +class RendererNativePtr(RendererNative): + def __init__(self, this): + self.this = this + if not hasattr(self,"thisown"): self.thisown = 0 + self.__class__ = RendererNative +_gdi_.RendererNative_swigregister(RendererNativePtr) + +def RendererNative_Get(*args, **kwargs): + """ + RendererNative_Get() -> RendererNative + + Return the currently used renderer + """ + return _gdi_.RendererNative_Get(*args, **kwargs) + +def RendererNative_GetGeneric(*args, **kwargs): + """ + RendererNative_GetGeneric() -> RendererNative + + Return the generic implementation of the renderer. Under some + platforms, this is the default renderer implementation, others have + platform-specific default renderer which can be retrieved by calling + `GetDefault`. + """ + return _gdi_.RendererNative_GetGeneric(*args, **kwargs) + +def RendererNative_GetDefault(*args, **kwargs): + """ + RendererNative_GetDefault() -> RendererNative + + Return the default (native) implementation for this platform -- this + is also the one used by default but this may be changed by calling `Set` + in which case the return value of this method may be different from + the return value of `Get`. + """ + return _gdi_.RendererNative_GetDefault(*args, **kwargs) + +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) +