X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/24f6c4e8658ae2884f136c15a0ae6ff72ede7e25..170acdc90e9f92f8b8120fa6c04acdbf45c89582:/wxPython/src/gtk/_gdi.py diff --git a/wxPython/src/gtk/_gdi.py b/wxPython/src/gtk/_gdi.py index 335c1b37a1..76d9f151ea 100644 --- a/wxPython/src/gtk/_gdi.py +++ b/wxPython/src/gtk/_gdi.py @@ -406,18 +406,6 @@ class Brush(GDIObject): A brush is a drawing tool for filling in areas. It is used for painting the background of rectangles, ellipses, etc. when drawing on a `wx.DC`. It has a colour and a style. - - :warning: Do not create instances of wx.Brush before the `wx.App` - object has been created because, depending on the platform, - required internal data structures may not have been initialized - yet. Instead create your brushes in the app's OnInit or as they - are needed for drawing. - - :note: On monochrome displays all brushes are white, unless the colour - really is black. - - :see: `wx.BrushList`, `wx.DC`, `wx.DC.SetBrush` - """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr @@ -425,24 +413,7 @@ class Brush(GDIObject): """ __init__(self, Colour colour, int style=SOLID) -> Brush - Constructs a brush from a `wx.Colour` object and a style.The style parameter may be one of the following: - - =================== ============================= - Style Meaning - =================== ============================= - wx.TRANSPARENT Transparent (no fill). - wx.SOLID Solid. - wx.STIPPLE Uses a bitmap as a stipple. - wx.BDIAGONAL_HATCH Backward diagonal hatch. - wx.CROSSDIAG_HATCH Cross-diagonal hatch. - wx.FDIAGONAL_HATCH Forward diagonal hatch. - wx.CROSS_HATCH Cross hatch. - wx.HORIZONTAL_HATCH Horizontal hatch. - wx.VERTICAL_HATCH Vertical hatch. - =================== ============================= - - :see: `wx.BrushFromBitmap` - + Constructs a brush from a `wx.Colour` object and a style. """ _gdi_.Brush_swiginit(self,_gdi_.new_Brush(*args, **kwargs)) __swig_destroy__ = _gdi_.delete_Brush @@ -538,23 +509,6 @@ class Bitmap(GDIObject): device context (instance of `wx.MemoryDC`). This enables the bitmap to be copied to a window or memory device context using `wx.DC.Blit`, or to be used as a drawing surface. - - The BMP and XMP image file formats are supported on all platforms by - wx.Bitmap. Other formats are automatically loaded by `wx.Image` and - converted to a wx.Bitmap, so any image file format supported by - `wx.Image` can be used. - - :todo: Add wrappers and support for raw bitmap data access. Can this - be be put into Python without losing the speed benefits of the - teplates and iterators in rawbmp.h? - - :todo: Find a way to do very efficient PIL Image <--> wx.Bitmap - converstions. - - :see: `wx.EmptyBitmap`, `wx.BitmapFromIcon`, `wx.BitmapFromImage`, - `wx.BitmapFromXPMData`, `wx.BitmapFromBits`, `wx.BitmapFromBuffer`, - `wx.BitmapFromBufferRGBA`, `wx.Image` - """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr @@ -563,32 +517,6 @@ class Bitmap(GDIObject): __init__(self, String name, int type=BITMAP_TYPE_ANY) -> Bitmap Loads a bitmap from a file. - :param name: Name of the file to load the bitmap from. - :param type: The type of image to expect. Can be one of the following - constants (assuming that the neccessary `wx.Image` handlers are - loaded): - - * wx.BITMAP_TYPE_ANY - * wx.BITMAP_TYPE_BMP - * wx.BITMAP_TYPE_ICO - * wx.BITMAP_TYPE_CUR - * wx.BITMAP_TYPE_XBM - * wx.BITMAP_TYPE_XPM - * wx.BITMAP_TYPE_TIF - * wx.BITMAP_TYPE_GIF - * wx.BITMAP_TYPE_PNG - * wx.BITMAP_TYPE_JPEG - * wx.BITMAP_TYPE_PNM - * wx.BITMAP_TYPE_PCX - * wx.BITMAP_TYPE_PICT - * wx.BITMAP_TYPE_ICON - * wx.BITMAP_TYPE_ANI - * wx.BITMAP_TYPE_IFF - - :see: Alternate constructors `wx.EmptyBitmap`, `wx.BitmapFromIcon`, - `wx.BitmapFromImage`, `wx.BitmapFromXPMData`, `wx.BitmapFromBits`, - `wx.BitmapFromBuffer`, `wx.BitmapFromBufferRGBA`, - """ _gdi_.Bitmap_swiginit(self,_gdi_.new_Bitmap(*args, **kwargs)) __swig_destroy__ = _gdi_.delete_Bitmap @@ -740,6 +668,24 @@ class Bitmap(GDIObject): """ return _gdi_.Bitmap_SetSize(*args, **kwargs) + def CopyFromBuffer(*args, **kwargs): + """ + CopyFromBuffer(self, buffer data) + + Copy data from a RGB buffer object to replace the bitmap pixel data. + See `wxBitmapFromBuffer` for more . + """ + return _gdi_.Bitmap_CopyFromBuffer(*args, **kwargs) + + def CopyFromBufferRGBA(*args, **kwargs): + """ + CopyFromBufferRGBA(self, buffer data) + + Copy data from a RGBA buffer object to replace the bitmap pixel data. + See `wxBitmapFromBufferRGBA` for more . + """ + return _gdi_.Bitmap_CopyFromBufferRGBA(*args, **kwargs) + def __nonzero__(self): return self.IsOk() def __eq__(*args, **kwargs): """__eq__(self, Bitmap other) -> bool""" @@ -1320,40 +1266,6 @@ class Cursor(GDIObject): in X, rather than to set it globally as in MS Windows, although a global `wx.SetCursor` function is also available for use on MS Windows. - - Stock Cursor IDs - ----------------- - ======================== ====================================== - wx.CURSOR_ARROW A standard arrow cursor. - wx.CURSOR_RIGHT_ARROW A standard arrow cursor pointing to the right. - wx.CURSOR_BLANK Transparent cursor. - wx.CURSOR_BULLSEYE Bullseye cursor. - wx.CURSOR_CHAR Rectangular character cursor. - wx.CURSOR_CROSS A cross cursor. - wx.CURSOR_HAND A hand cursor. - wx.CURSOR_IBEAM An I-beam cursor (vertical line). - wx.CURSOR_LEFT_BUTTON Represents a mouse with the left button depressed. - wx.CURSOR_MAGNIFIER A magnifier icon. - wx.CURSOR_MIDDLE_BUTTON Represents a mouse with the middle button depressed. - wx.CURSOR_NO_ENTRY A no-entry sign cursor. - wx.CURSOR_PAINT_BRUSH A paintbrush cursor. - wx.CURSOR_PENCIL A pencil cursor. - wx.CURSOR_POINT_LEFT A cursor that points left. - wx.CURSOR_POINT_RIGHT A cursor that points right. - wx.CURSOR_QUESTION_ARROW An arrow and question mark. - wx.CURSOR_RIGHT_BUTTON Represents a mouse with the right button depressed. - wx.CURSOR_SIZENESW A sizing cursor pointing NE-SW. - wx.CURSOR_SIZENS A sizing cursor pointing N-S. - wx.CURSOR_SIZENWSE A sizing cursor pointing NW-SE. - wx.CURSOR_SIZEWE A sizing cursor pointing W-E. - wx.CURSOR_SIZING A general sizing cursor. - wx.CURSOR_SPRAYCAN A spraycan cursor. - wx.CURSOR_WAIT A wait cursor. - wx.CURSOR_WATCH A watch cursor. - wx.CURSOR_ARROWWAIT A cursor with both an arrow and an hourglass, (windows.) - ======================== ====================================== - - """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr @@ -1364,7 +1276,6 @@ class Cursor(GDIObject): Construct a Cursor from a file. Specify the type of file using wx.BITAMP_TYPE* constants, and specify the hotspot if not using a .cur file. - :see: Alternate constructors `wx.StockCursor`,`wx.CursorFromImage` """ _gdi_.Cursor_swiginit(self,_gdi_.new_Cursor(*args, **kwargs)) __swig_destroy__ = _gdi_.delete_Cursor @@ -1393,11 +1304,6 @@ def CursorFromImage(*args, **kwargs): Constructs a cursor from a `wx.Image`. The mask (if any) will be used for setting the transparent portions of the cursor. - In MSW the cursor is resized to 32x32 if it was larger. - - In GTK the cursor will be displayed at the size of the image. - - On MacOS the cursor is resized to 16x16 if it was larger. """ val = _gdi_.new_CursorFromImage(*args, **kwargs) return val @@ -1970,71 +1876,6 @@ class Font(GDIObject): of a window's text. You can retrieve the current system font settings with `wx.SystemSettings`. - - The possible values for the family parameter of wx.Font constructor are: - - ======================== ============================= - wx.FONTFAMILY_DEFAULT Chooses a default font. - wx.FONTFAMILY_DECORATIVE A decorative font. - wx.FONTFAMILY_ROMAN A formal, serif font. - wx.FONTFAMILY_SCRIPT A handwriting font. - wx.FONTFAMILY_SWISS A sans-serif font. - wx.FONTFAMILY_MODERN Usually a fixed pitch font. - wx.FONTFAMILY_TELETYPE A teletype font. - ======================== ============================= - - The possible values for the weight parameter are: - - ==================== == - wx.FONTWEIGHT_NORMAL - wx.FONTWEIGHT_LIGHT - wx.FONTWEIGHT_BOLD - ==================== == - - The known font encodings are: - - =========================== ==================================== - wx.FONTENCODING_SYSTEM system default - wx.FONTENCODING_DEFAULT current default encoding - wx.FONTENCODING_ISO8859_1 West European (Latin1) - wx.FONTENCODING_ISO8859_2 Central and East European (Latin2) - wx.FONTENCODING_ISO8859_3 Esperanto (Latin3) - wx.FONTENCODING_ISO8859_4 Baltic (old) (Latin4) - wx.FONTENCODING_ISO8859_5 Cyrillic - wx.FONTENCODING_ISO8859_6 Arabic - wx.FONTENCODING_ISO8859_7 Greek - wx.FONTENCODING_ISO8859_8 Hebrew - wx.FONTENCODING_ISO8859_9 Turkish (Latin5) - wx.FONTENCODING_ISO8859_10 Variation of Latin4 (Latin6) - wx.FONTENCODING_ISO8859_11 Thai - wx.FONTENCODING_ISO8859_12 doesn't exist currently, but put it - here anyhow to make all ISO8859 - consecutive numbers - wx.FONTENCODING_ISO8859_13 Baltic (Latin7) - wx.FONTENCODING_ISO8859_14 Latin8 - wx.FONTENCODING_ISO8859_15 Latin9 (a.k.a. Latin0, includes euro) - wx.FONTENCODING_KOI8 Cyrillic charset - wx.FONTENCODING_ALTERNATIVE same as MS-DOS CP866 - wx.FONTENCODING_BULGARIAN used under Linux in Bulgaria - wx.FONTENCODING_CP437 original MS-DOS codepage - wx.FONTENCODING_CP850 CP437 merged with Latin1 - wx.FONTENCODING_CP852 CP437 merged with Latin2 - wx.FONTENCODING_CP855 another cyrillic encoding - wx.FONTENCODING_CP866 and another one - wx.FONTENCODING_CP874 WinThai - wx.FONTENCODING_CP1250 WinLatin2 - wx.FONTENCODING_CP1251 WinCyrillic - wx.FONTENCODING_CP1252 WinLatin1 - wx.FONTENCODING_CP1253 WinGreek (8859-7) - wx.FONTENCODING_CP1254 WinTurkish - wx.FONTENCODING_CP1255 WinHebrew - wx.FONTENCODING_CP1256 WinArabic - wx.FONTENCODING_CP1257 WinBaltic (same as Latin 7) - wx.FONTENCODING_UTF7 UTF-7 Unicode encoding - wx.FONTENCODING_UTF8 UTF-8 Unicode encoding - =========================== ==================================== - - """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr @@ -3377,8 +3218,6 @@ class DC(_core.Object): 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. - - :see: `DrawEllipse` """ return _gdi_.DC_DrawCircle(*args, **kwargs) @@ -3389,8 +3228,6 @@ class DC(_core.Object): 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. - - :see: `DrawEllipse` """ return _gdi_.DC_DrawCirclePoint(*args, **kwargs) @@ -3400,8 +3237,6 @@ class DC(_core.Object): Draws an ellipse contained in the specified rectangle. The current pen is used for the outline and the current brush for filling the shape. - - :see: `DrawCircle` """ return _gdi_.DC_DrawEllipse(*args, **kwargs) @@ -3411,8 +3246,6 @@ class DC(_core.Object): Draws an ellipse contained in the specified rectangle. The current pen is used for the outline and the current brush for filling the shape. - - :see: `DrawCircle` """ return _gdi_.DC_DrawEllipseRect(*args, **kwargs) @@ -3422,8 +3255,6 @@ class DC(_core.Object): Draws an ellipse contained in the specified rectangle. The current pen is used for the outline and the current brush for filling the shape. - - :see: `DrawCircle` """ return _gdi_.DC_DrawEllipsePointSize(*args, **kwargs) @@ -3455,13 +3286,6 @@ class DC(_core.Object): *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. - - When drawing a mono-bitmap, the current text foreground colour will be - used to draw the foreground of the bitmap (all bits set to 1), and the - current text background colour to draw the background (all bits set to - 0). - - :see: `SetTextForeground`, `SetTextBackground` and `wx.MemoryDC` """ return _gdi_.DC_DrawBitmap(*args, **kwargs) @@ -3473,13 +3297,6 @@ class DC(_core.Object): *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. - - When drawing a mono-bitmap, the current text foreground colour will be - used to draw the foreground of the bitmap (all bits set to 1), and the - current text background colour to draw the background (all bits set to - 0). - - :see: `SetTextForeground`, `SetTextBackground` and `wx.MemoryDC` """ return _gdi_.DC_DrawBitmapPoint(*args, **kwargs) @@ -3497,8 +3314,6 @@ class DC(_core.Object): **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. - - :see: `DrawRotatedText` """ return _gdi_.DC_DrawText(*args, **kwargs) @@ -3516,8 +3331,6 @@ class DC(_core.Object): **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. - - :see: `DrawRotatedText` """ return _gdi_.DC_DrawTextPoint(*args, **kwargs) @@ -3531,8 +3344,6 @@ class DC(_core.Object): 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. - - :see: `DrawText` """ return _gdi_.DC_DrawRotatedText(*args, **kwargs) @@ -3546,8 +3357,6 @@ class DC(_core.Object): 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. - - :see: `DrawText` """ return _gdi_.DC_DrawRotatedTextPoint(*args, **kwargs) @@ -3561,23 +3370,6 @@ class DC(_core.Object): coordinates, size of area to copy, source DC, source coordinates, logical function, whether to use a bitmap mask, and mask source position. - - :param xdest: Destination device context x position. - :param ydest: Destination device context y position. - :param width: Width of source area to be copied. - :param height: Height of source area to be copied. - :param source: Source device context. - :param xsrc: Source device context x position. - :param ysrc: Source device context y position. - :param rop: Logical function to use: see `SetLogicalFunction`. - :param useMask: If true, Blit does a transparent blit using the mask - that is associated with the bitmap selected into the - source device context. - :param xsrcMask: Source x position on the mask. If both xsrcMask and - ysrcMask are -1, xsrc and ysrc will be assumed for - the mask source position. - :param ysrcMask: Source y position on the mask. - """ return _gdi_.DC_Blit(*args, **kwargs) @@ -3590,20 +3382,13 @@ class DC(_core.Object): coordinates, size of area to copy, source DC, source coordinates, logical function, whether to use a bitmap mask, and mask source position. - - :param destPt: Destination device context position. - :param sz: Size of source area to be copied. - :param source: Source device context. - :param srcPt: Source device context position. - :param rop: Logical function to use: see `SetLogicalFunction`. - :param useMask: If true, Blit does a transparent blit using the mask - that is associated with the bitmap selected into the - source device context. - :param srcPtMask: Source position on the mask. - """ return _gdi_.DC_BlitPointSize(*args, **kwargs) + def GetAsBitmap(*args, **kwargs): + """GetAsBitmap(self, Rect subrect=None) -> Bitmap""" + return _gdi_.DC_GetAsBitmap(*args, **kwargs) + def SetClippingRegion(*args, **kwargs): """ SetClippingRegion(self, int x, int y, int width, int height) @@ -3618,8 +3403,6 @@ class DC(_core.Object): 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. - - :see: `DestroyClippingRegion`, `wx.Region` """ return _gdi_.DC_SetClippingRegion(*args, **kwargs) @@ -3637,8 +3420,6 @@ class DC(_core.Object): 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. - - :see: `DestroyClippingRegion`, `wx.Region` """ return _gdi_.DC_SetClippingRegionPointSize(*args, **kwargs) @@ -3656,8 +3437,6 @@ class DC(_core.Object): 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. - - :see: `DestroyClippingRegion`, `wx.Region` """ return _gdi_.DC_SetClippingRegionAsRegion(*args, **kwargs) @@ -3675,8 +3454,6 @@ class DC(_core.Object): 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. - - :see: `DestroyClippingRegion`, `wx.Region` """ return _gdi_.DC_SetClippingRect(*args, **kwargs) @@ -3714,8 +3491,6 @@ class DC(_core.Object): Draw *text* within the specified rectangle, abiding by the alignment flags. Will additionally emphasize the character at *indexAccel* if it is not -1. - - :see: `DrawImageLabel` """ return _gdi_.DC_DrawLabel(*args, **kwargs) @@ -3788,8 +3563,6 @@ class DC(_core.Object): Sets the current font for the DC. It must be a valid font, in particular you should not pass ``wx.NullFont`` to this method. - - :see: `wx.Font` """ return _gdi_.DC_SetFont(*args, **kwargs) @@ -3801,8 +3574,6 @@ class DC(_core.Object): If the argument is ``wx.NullPen``, the current pen is selected out of the device context, and the original pen restored. - - :see: `wx.Pen` """ return _gdi_.DC_SetPen(*args, **kwargs) @@ -3815,8 +3586,6 @@ class DC(_core.Object): 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. - - :see: `wx.Brush` """ return _gdi_.DC_SetBrush(*args, **kwargs) @@ -3846,8 +3615,6 @@ class DC(_core.Object): 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. - - :see: `wx.Palette` """ return _gdi_.DC_SetPalette(*args, **kwargs) @@ -3857,8 +3624,6 @@ class DC(_core.Object): Destroys the current clipping region so that none of the DC is clipped. - - :see: `SetClippingRegion` """ return _gdi_.DC_DestroyClippingRegion(*args, **kwargs) @@ -4104,8 +3869,6 @@ class DC(_core.Object): Returns the current background mode, either ``wx.SOLID`` or ``wx.TRANSPARENT``. - - :see: `SetBackgroundMode` """ return _gdi_.DC_GetBackgroundMode(*args, **kwargs) @@ -4114,8 +3877,6 @@ class DC(_core.Object): GetBackground(self) -> Brush Gets the brush used for painting the background. - - :see: `SetBackground` """ return _gdi_.DC_GetBackground(*args, **kwargs) @@ -4200,18 +3961,6 @@ class DC(_core.Object): wx.MM_TEXT Each logical unit is 1 pixel. ================ ============================================= - Note that in X, text drawing isn't handled consistently with the - mapping mode; a font is always specified in point size. However, - setting the user scale (see `SetUserScale`) scales the text - appropriately. In Windows, scalable TrueType fonts are always used; in - X, results depend on availability of fonts, but usually a reasonable - match is found. - - The coordinate origin is always at the top left of the screen/printer. - - Drawing to a Windows printer device context uses the current mapping - mode, but mapping mode is currently ignored for PostScript output. - """ return _gdi_.DC_SetMapMode(*args, **kwargs) @@ -4656,6 +4405,88 @@ _gdi_.DC_swigregister(DC) #--------------------------------------------------------------------------- +class DCTextColourChanger(object): + """ + wx.DCTextColourChanger can be used to temporarily change the DC text + colour and restore it automatically when the object goes out of scope + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, DC dc, Colour col) -> DCTextColourChanger + + wx.DCTextColourChanger can be used to temporarily change the DC text + colour and restore it automatically when the object goes out of scope + """ + _gdi_.DCTextColourChanger_swiginit(self,_gdi_.new_DCTextColourChanger(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_DCTextColourChanger + __del__ = lambda self : None; +_gdi_.DCTextColourChanger_swigregister(DCTextColourChanger) + +class DCPenChanger(object): + """ + wx.DCPenChanger can be used to temporarily change the DC pen and + restore it automatically when the object goes out of scope + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, DC dc, Pen pen) -> DCPenChanger + + wx.DCPenChanger can be used to temporarily change the DC pen and + restore it automatically when the object goes out of scope + """ + _gdi_.DCPenChanger_swiginit(self,_gdi_.new_DCPenChanger(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_DCPenChanger + __del__ = lambda self : None; +_gdi_.DCPenChanger_swigregister(DCPenChanger) + +class DCBrushChanger(object): + """ + wx.DCBrushChanger can be used to temporarily change the DC brush and + restore it automatically when the object goes out of scope + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, DC dc, Brush brush) -> DCBrushChanger + + wx.DCBrushChanger can be used to temporarily change the DC brush and + restore it automatically when the object goes out of scope + """ + _gdi_.DCBrushChanger_swiginit(self,_gdi_.new_DCBrushChanger(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_DCBrushChanger + __del__ = lambda self : None; +_gdi_.DCBrushChanger_swigregister(DCBrushChanger) + +class DCClipper(object): + """ + wx.wxDCClipper sets the DC's clipping region when it is constructed, + and then automatically destroys the clipping region when the clipper + goes out of scope. + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(self, DC dc, Region r) -> DCClipper + __init__(self, DC dc, Rect r) -> DCClipper + __init__(self, DC dc, int x, int y, int w, int h) -> DCClipper + + wx.wxDCClipper sets the DC's clipping region when it is constructed, + and then automatically destroys the clipping region when the clipper + goes out of scope. + """ + _gdi_.DCClipper_swiginit(self,_gdi_.new_DCClipper(*args)) + __swig_destroy__ = _gdi_.delete_DCClipper + __del__ = lambda self : None; +_gdi_.DCClipper_swigregister(DCClipper) + +#--------------------------------------------------------------------------- + class MemoryDC(DC): """ A memory device context provides a means to draw graphics onto a @@ -4684,8 +4515,6 @@ class MemoryDC(DC): creating a usable device context. If a bitmap is not given to this constructor then don't forget to select a bitmap into the DC before drawing on it. - - :see: `MemoryDCFromDC` """ _gdi_.MemoryDC_swiginit(self,_gdi_.new_MemoryDC(*args, **kwargs)) def SelectObject(*args, **kwargs): @@ -4704,6 +4533,10 @@ class MemoryDC(DC): """ return _gdi_.MemoryDC_SelectObject(*args, **kwargs) + def SelectObjectAsSource(*args, **kwargs): + """SelectObjectAsSource(self, Bitmap bmp)""" + return _gdi_.MemoryDC_SelectObjectAsSource(*args, **kwargs) + _gdi_.MemoryDC_swigregister(MemoryDC) def MemoryDCFromDC(*args, **kwargs): @@ -4865,16 +4698,26 @@ 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. + is destroyed. You can either provide a buffer bitmap yourself, and + reuse it the next time something needs painted, or you can let the + buffered DC create and provide a buffer bitmap itself. - It can be used in the same way as any other device context. + Buffered DCs can be used in the same way as any other device context. wx.BufferedDC itself typically replaces `wx.ClientDC`, if you want to use it in your EVT_PAINT handler, you should look at - `wx.BufferedPaintDC`. + `wx.BufferedPaintDC`. You can also use a wx.BufferedDC without + providing a target DC. In this case the operations done on the dc + will only be written to the buffer bitmap and *not* to any window, so + you will want to have provided the buffer bitmap and then reuse it + when it needs painted to the window. Please note that GTK+ 2.0 and OS X provide double buffering themselves - natively. wxBufferedDC is aware of this however, and will bypass the buffering - unless an explicit buffer bitmap is given. + natively. You may want to use `wx.Window.IsDoubleBuffered` to + determine whether you need to use buffering or not, or use + `wx.AutoBufferedPaintDC` to avoid needless double buffering on systems + that already do it automatically. + + """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') @@ -4885,29 +4728,6 @@ class BufferedDC(MemoryDC): __init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC Constructs a buffered DC. - - :param dc: The underlying DC: everything drawn to this object will - be flushed to this DC when this object is destroyed. You may - pass ``None`` in order to just initialize the buffer, and not - flush it. - - :param buffer: If a `wx.Size` object is passed as the 2nd arg then - it is the size of the bitmap that will be created internally - and used for an implicit buffer. If the 2nd arg is a - `wx.Bitmap` then it is the explicit buffer that will be - used. Using an explicit buffer is the most efficient solution - as the bitmap doesn't have to be recreated each time but it - also requires more memory as the bitmap is never freed. The - bitmap should have appropriate size, anything drawn outside of - its bounds is clipped. If wx.NullBitmap is used then a new - buffer will be allocated that is the same size as the dc. - - :param style: The style parameter indicates whether the supplied buffer is - intended to cover the entire virtual size of a `wx.ScrolledWindow` or - if it only covers the client area. Acceptable values are - ``wx.BUFFER_VIRTUAL_AREA`` and ``wx.BUFFER_CLIENT_AREA``. - - """ _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args)) self.__dc = args[0] # save a ref so the other dc will not be deleted before self @@ -5117,38 +4937,211 @@ _gdi_.PrinterDC_swigregister(PrinterDC) #--------------------------------------------------------------------------- -class GraphicsPath(object): +class GraphicsObject(_core.Object): + """Proxy of C++ GraphicsObject class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """__init__(self, GraphicsRenderer renderer=None) -> GraphicsObject""" + _gdi_.GraphicsObject_swiginit(self,_gdi_.new_GraphicsObject(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_GraphicsObject + __del__ = lambda self : None; + def IsNull(*args, **kwargs): + """IsNull(self) -> bool""" + return _gdi_.GraphicsObject_IsNull(*args, **kwargs) + + def GetRenderer(*args, **kwargs): + """GetRenderer(self) -> GraphicsRenderer""" + return _gdi_.GraphicsObject_GetRenderer(*args, **kwargs) + +_gdi_.GraphicsObject_swigregister(GraphicsObject) + +class GraphicsPen(GraphicsObject): + """Proxy of C++ GraphicsPen class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """__init__(self) -> GraphicsPen""" + _gdi_.GraphicsPen_swiginit(self,_gdi_.new_GraphicsPen(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_GraphicsPen + __del__ = lambda self : None; +_gdi_.GraphicsPen_swigregister(GraphicsPen) + +class GraphicsBrush(GraphicsObject): + """Proxy of C++ GraphicsBrush class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """__init__(self) -> GraphicsBrush""" + _gdi_.GraphicsBrush_swiginit(self,_gdi_.new_GraphicsBrush(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_GraphicsBrush + __del__ = lambda self : None; +_gdi_.GraphicsBrush_swigregister(GraphicsBrush) + +class GraphicsFont(GraphicsObject): + """Proxy of C++ GraphicsFont class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """__init__(self) -> GraphicsFont""" + _gdi_.GraphicsFont_swiginit(self,_gdi_.new_GraphicsFont(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_GraphicsFont + __del__ = lambda self : None; +_gdi_.GraphicsFont_swigregister(GraphicsFont) + +class GraphicsMatrix(GraphicsObject): + """Proxy of C++ GraphicsMatrix class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """__init__(self) -> GraphicsMatrix""" + _gdi_.GraphicsMatrix_swiginit(self,_gdi_.new_GraphicsMatrix(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_GraphicsMatrix + __del__ = lambda self : None; + def Concat(*args, **kwargs): + """ + Concat(self, GraphicsMatrix t) + + concatenates the matrix + """ + return _gdi_.GraphicsMatrix_Concat(*args, **kwargs) + + def Copy(*args, **kwargs): + """ + Copy(self, GraphicsMatrix t) + + Copy the passed in matrix to this one. + """ + return _gdi_.GraphicsMatrix_Copy(*args, **kwargs) + + def Set(*args, **kwargs): + """ + Set(self, Double a=1.0, Double b=0.0, Double c=0.0, Double d=1.0, + Double tx=0.0, Double ty=0.0) + + sets the matrix to the respective values + """ + return _gdi_.GraphicsMatrix_Set(*args, **kwargs) + + def Invert(*args, **kwargs): + """ + Invert(self) + + makes this the inverse matrix + """ + return _gdi_.GraphicsMatrix_Invert(*args, **kwargs) + + def IsEqual(*args, **kwargs): + """ + IsEqual(self, GraphicsMatrix t) -> bool + + returns true if the elements of the transformation matrix are equal + """ + return _gdi_.GraphicsMatrix_IsEqual(*args, **kwargs) + + def IsIdentity(*args, **kwargs): + """ + IsIdentity(self) -> bool + + return true if this is the identity matrix + """ + return _gdi_.GraphicsMatrix_IsIdentity(*args, **kwargs) + + def Translate(*args, **kwargs): + """ + Translate(self, Double dx, Double dy) + + add the translation to this matrix + """ + return _gdi_.GraphicsMatrix_Translate(*args, **kwargs) + + def Scale(*args, **kwargs): + """ + Scale(self, Double xScale, Double yScale) + + add the scale to this matrix + """ + return _gdi_.GraphicsMatrix_Scale(*args, **kwargs) + + def Rotate(*args, **kwargs): + """ + Rotate(self, Double angle) + + add the rotation to this matrix (radians) + """ + return _gdi_.GraphicsMatrix_Rotate(*args, **kwargs) + + def TransformPoint(*args, **kwargs): + """ + TransformPoint(self, x, y) --> (x, y) + + applies that matrix to the point + """ + return _gdi_.GraphicsMatrix_TransformPoint(*args, **kwargs) + + def TransformDistance(*args, **kwargs): + """ + TransformDistance(self, dx, dy) --> (dx, dy) + + applies the matrix except for translations + """ + return _gdi_.GraphicsMatrix_TransformDistance(*args, **kwargs) + + def GetNativeMatrix(*args, **kwargs): + """ + GetNativeMatrix(self) -> void + + returns the native representation + """ + return _gdi_.GraphicsMatrix_GetNativeMatrix(*args, **kwargs) + +_gdi_.GraphicsMatrix_swigregister(GraphicsMatrix) + +class GraphicsPath(GraphicsObject): """Proxy of C++ GraphicsPath class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - def __init__(self): raise AttributeError, "No constructor defined" __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """__init__(self) -> GraphicsPath""" + _gdi_.GraphicsPath_swiginit(self,_gdi_.new_GraphicsPath(*args, **kwargs)) __swig_destroy__ = _gdi_.delete_GraphicsPath __del__ = lambda self : None; - def MoveToPoint(*args, **kwargs): + def MoveToPoint(*args): """ MoveToPoint(self, Double x, Double y) + MoveToPoint(self, Point2D p) Begins a new subpath at (x,y) """ - return _gdi_.GraphicsPath_MoveToPoint(*args, **kwargs) + return _gdi_.GraphicsPath_MoveToPoint(*args) - def AddLineToPoint(*args, **kwargs): + def AddLineToPoint(*args): """ AddLineToPoint(self, Double x, Double y) + AddLineToPoint(self, Point2D p) Adds a straight line from the current point to (x,y) """ - return _gdi_.GraphicsPath_AddLineToPoint(*args, **kwargs) + return _gdi_.GraphicsPath_AddLineToPoint(*args) - def AddCurveToPoint(*args, **kwargs): + def AddCurveToPoint(*args): """ AddCurveToPoint(self, Double cx1, Double cy1, Double cx2, Double cy2, Double x, Double y) + AddCurveToPoint(self, Point2D c1, Point2D c2, Point2D e) Adds a cubic Bezier curve from the current point, using two control points and an end point """ - return _gdi_.GraphicsPath_AddCurveToPoint(*args, **kwargs) + return _gdi_.GraphicsPath_AddCurveToPoint(*args) + + def AddPath(*args, **kwargs): + """ + AddPath(self, GraphicsPath path) + + adds another path + """ + return _gdi_.GraphicsPath_AddPath(*args, **kwargs) def CloseSubpath(*args, **kwargs): """ @@ -5166,15 +5159,17 @@ class GraphicsPath(object): """ return _gdi_.GraphicsPath_GetCurrentPoint(*args, **kwargs) - def AddArc(*args, **kwargs): + def AddArc(*args): """ AddArc(self, Double x, Double y, Double r, Double startAngle, Double endAngle, bool clockwise) + AddArc(self, Point2D c, Double r, Double startAngle, Double endAngle, + bool clockwise) Adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle """ - return _gdi_.GraphicsPath_AddArc(*args, **kwargs) + return _gdi_.GraphicsPath_AddArc(*args) def AddQuadCurveToPoint(*args, **kwargs): """ @@ -5210,90 +5205,291 @@ class GraphicsPath(object): """ return _gdi_.GraphicsPath_AddArcToPoint(*args, **kwargs) + def AddEllipse(*args, **kwargs): + """ + AddEllipse(self, Double x, Double y, Double w, Double h) + + appends an ellipse + """ + return _gdi_.GraphicsPath_AddEllipse(*args, **kwargs) + + def AddRoundedRectangle(*args, **kwargs): + """ + AddRoundedRectangle(self, Double x, Double y, Double w, Double h, Double radius) + + appends a rounded rectangle + """ + return _gdi_.GraphicsPath_AddRoundedRectangle(*args, **kwargs) + + def GetNativePath(*args, **kwargs): + """ + GetNativePath(self) -> void + + returns the native path + """ + return _gdi_.GraphicsPath_GetNativePath(*args, **kwargs) + + def UnGetNativePath(*args, **kwargs): + """ + UnGetNativePath(self, void p) + + give the native path returned by GetNativePath() back (there might be some + deallocations necessary) + """ + return _gdi_.GraphicsPath_UnGetNativePath(*args, **kwargs) + + def Transform(*args, **kwargs): + """ + Transform(self, GraphicsMatrix matrix) + + transforms each point of this path by the matrix + """ + return _gdi_.GraphicsPath_Transform(*args, **kwargs) + + def GetBox(*args, **kwargs): + """ + GetBox(self) -> wxRect2DDouble + + gets the bounding box enclosing all points (possibly including control points) + """ + return _gdi_.GraphicsPath_GetBox(*args, **kwargs) + + def Contains(*args): + """ + Contains(self, Double x, Double y, int fillStyle=ODDEVEN_RULE) -> bool + Contains(self, wxPoint2DDouble c, int fillStyle=ODDEVEN_RULE) -> bool + """ + return _gdi_.GraphicsPath_Contains(*args) + _gdi_.GraphicsPath_swigregister(GraphicsPath) -class GraphicsContext(object): +class GraphicsContext(GraphicsObject): """Proxy of C++ GraphicsContext class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self): raise AttributeError, "No constructor defined" __repr__ = _swig_repr __swig_destroy__ = _gdi_.delete_GraphicsContext __del__ = lambda self : None; - def Create(*args, **kwargs): - """Create(WindowDC dc) -> GraphicsContext""" - val = _gdi_.GraphicsContext_Create(*args, **kwargs) - val.__dc = args[0] # save a ref so the other dc will not be deleted before self + def Create(*args): + """ + Create(WindowDC dc) -> GraphicsContext + Create(Window window) -> GraphicsContext + """ + val = _gdi_.GraphicsContext_Create(*args) + val.__dc = args[0] # save a ref so the dc will not be deleted before self return val Create = staticmethod(Create) + def CreateFromNative(*args, **kwargs): + """CreateFromNative(void context) -> GraphicsContext""" + return _gdi_.GraphicsContext_CreateFromNative(*args, **kwargs) + + CreateFromNative = staticmethod(CreateFromNative) + def CreateFromNativeWindow(*args, **kwargs): + """CreateFromNativeWindow(void window) -> GraphicsContext""" + return _gdi_.GraphicsContext_CreateFromNativeWindow(*args, **kwargs) + + CreateFromNativeWindow = staticmethod(CreateFromNativeWindow) def CreatePath(*args, **kwargs): - """CreatePath(self) -> GraphicsPath""" + """ + CreatePath(self) -> GraphicsPath + + creates a path instance that corresponds to the type of graphics context, ie GDIPlus, Cairo, CoreGraphics ... + """ return _gdi_.GraphicsContext_CreatePath(*args, **kwargs) + def CreatePen(*args, **kwargs): + """CreatePen(self, Pen pen) -> GraphicsPen""" + return _gdi_.GraphicsContext_CreatePen(*args, **kwargs) + + def CreateBrush(*args, **kwargs): + """CreateBrush(self, Brush brush) -> GraphicsBrush""" + return _gdi_.GraphicsContext_CreateBrush(*args, **kwargs) + + def CreateLinearGradientBrush(*args, **kwargs): + """ + CreateLinearGradientBrush(self, Double x1, Double y1, Double x2, Double y2, Colour c1, + Colour c2) -> GraphicsBrush + + sets the brush to a linear gradient, starting at (x1,y1) with color c1 + to (x2,y2) with color c2 + """ + return _gdi_.GraphicsContext_CreateLinearGradientBrush(*args, **kwargs) + + def CreateRadialGradientBrush(*args, **kwargs): + """ + CreateRadialGradientBrush(self, Double xo, Double yo, Double xc, Double yc, Double radius, + Colour oColor, Colour cColor) -> GraphicsBrush + + sets the brush to a radial gradient originating at (xo,yc) with color + oColor and ends on a circle around (xc,yc) with radius r and color + cColor + + """ + return _gdi_.GraphicsContext_CreateRadialGradientBrush(*args, **kwargs) + + def CreateFont(*args, **kwargs): + """ + CreateFont(self, Font font, Colour col=*wxBLACK) -> GraphicsFont + + sets the font + """ + return _gdi_.GraphicsContext_CreateFont(*args, **kwargs) + + def CreateMatrix(*args, **kwargs): + """ + CreateMatrix(self, Double a=1.0, Double b=0.0, Double c=0.0, Double d=1.0, + Double tx=0.0, Double ty=0.0) -> GraphicsMatrix + + create a 'native' matrix corresponding to these values + """ + return _gdi_.GraphicsContext_CreateMatrix(*args, **kwargs) + def PushState(*args, **kwargs): - """PushState(self)""" + """ + PushState(self) + + push the current state of the context, ie the transformation matrix on a stack + """ return _gdi_.GraphicsContext_PushState(*args, **kwargs) def PopState(*args, **kwargs): - """PopState(self)""" + """ + PopState(self) + + pops a stored state from the stack + """ return _gdi_.GraphicsContext_PopState(*args, **kwargs) + def ClipRegion(*args, **kwargs): + """ + ClipRegion(self, Region region) + + clips drawings to the region + """ + return _gdi_.GraphicsContext_ClipRegion(*args, **kwargs) + def Clip(*args, **kwargs): - """Clip(self, Region region)""" + """ + Clip(self, Double x, Double y, Double w, Double h) + + clips drawings to the rect + """ return _gdi_.GraphicsContext_Clip(*args, **kwargs) + def ResetClip(*args, **kwargs): + """ + ResetClip(self) + + resets the clipping to original extent + """ + return _gdi_.GraphicsContext_ResetClip(*args, **kwargs) + + def GetNativeContext(*args, **kwargs): + """ + GetNativeContext(self) -> void + + returns the native context + """ + return _gdi_.GraphicsContext_GetNativeContext(*args, **kwargs) + def Translate(*args, **kwargs): - """Translate(self, Double dx, Double dy)""" + """ + Translate(self, Double dx, Double dy) + + translate the current transformation matrix CTM of the context + """ return _gdi_.GraphicsContext_Translate(*args, **kwargs) def Scale(*args, **kwargs): - """Scale(self, Double xScale, Double yScale)""" + """ + Scale(self, Double xScale, Double yScale) + + scale the current transformation matrix CTM of the context + """ return _gdi_.GraphicsContext_Scale(*args, **kwargs) def Rotate(*args, **kwargs): - """Rotate(self, Double angle)""" + """ + Rotate(self, Double angle) + + rotate (radians) the current transformation matrix CTM of the context + """ return _gdi_.GraphicsContext_Rotate(*args, **kwargs) - def SetPen(*args, **kwargs): - """SetPen(self, Pen pen)""" - return _gdi_.GraphicsContext_SetPen(*args, **kwargs) + def ConcatTransform(*args, **kwargs): + """ + ConcatTransform(self, GraphicsMatrix matrix) - def SetBrush(*args, **kwargs): - """SetBrush(self, Brush brush)""" - return _gdi_.GraphicsContext_SetBrush(*args, **kwargs) + concatenates this transform with the current transform of this context + """ + return _gdi_.GraphicsContext_ConcatTransform(*args, **kwargs) - def SetLinearGradientBrush(*args, **kwargs): + def SetTransform(*args, **kwargs): """ - SetLinearGradientBrush(self, Double x1, Double y1, Double x2, Double y2, Colour c1, - Colour c2) + SetTransform(self, GraphicsMatrix matrix) + + sets the transform of this context """ - return _gdi_.GraphicsContext_SetLinearGradientBrush(*args, **kwargs) + return _gdi_.GraphicsContext_SetTransform(*args, **kwargs) - def SetRadialGradientBrush(*args, **kwargs): + def GetTransform(*args, **kwargs): """ - SetRadialGradientBrush(self, Double xo, Double yo, Double xc, Double yc, Double radius, - Colour oColor, Colour cColor) + GetTransform(self) -> GraphicsMatrix + + gets the matrix of this context """ - return _gdi_.GraphicsContext_SetRadialGradientBrush(*args, **kwargs) + return _gdi_.GraphicsContext_GetTransform(*args, **kwargs) - def SetFont(*args, **kwargs): - """SetFont(self, Font font)""" - return _gdi_.GraphicsContext_SetFont(*args, **kwargs) + def SetPen(*args): + """ + SetPen(self, GraphicsPen pen) + SetPen(self, Pen pen) - def SetTextColor(*args, **kwargs): - """SetTextColor(self, Colour col)""" - return _gdi_.GraphicsContext_SetTextColor(*args, **kwargs) + sets the stroke pen + """ + return _gdi_.GraphicsContext_SetPen(*args) + + def SetBrush(*args): + """ + SetBrush(self, GraphicsBrush brush) + SetBrush(self, Brush brush) + + sets the brush for filling + """ + return _gdi_.GraphicsContext_SetBrush(*args) + + def SetFont(*args): + """ + SetFont(self, GraphicsFont font) + SetFont(self, Font font, Colour colour=*wxBLACK) + + sets the font + """ + return _gdi_.GraphicsContext_SetFont(*args) def StrokePath(*args, **kwargs): - """StrokePath(self, GraphicsPath path)""" + """ + StrokePath(self, GraphicsPath path) + + strokes along a path with the current pen + """ return _gdi_.GraphicsContext_StrokePath(*args, **kwargs) def FillPath(*args, **kwargs): - """FillPath(self, GraphicsPath path, int fillStyle=WINDING_RULE)""" + """ + FillPath(self, GraphicsPath path, int fillStyle=ODDEVEN_RULE) + + fills a path with the current brush + """ return _gdi_.GraphicsContext_FillPath(*args, **kwargs) def DrawPath(*args, **kwargs): - """DrawPath(self, GraphicsPath path, int fillStyle=WINDING_RULE)""" + """ + DrawPath(self, GraphicsPath path, int fillStyle=ODDEVEN_RULE) + + draws a path by first filling and then stroking + """ return _gdi_.GraphicsContext_DrawPath(*args, **kwargs) def DrawText(*args, **kwargs): @@ -5304,8 +5500,12 @@ class GraphicsContext(object): """DrawRotatedText(self, String str, Double x, Double y, Double angle)""" return _gdi_.GraphicsContext_DrawRotatedText(*args, **kwargs) + def GetFullTextExtent(*args, **kwargs): + """GetFullTextExtent(self, text) --> (width, height, descent, externalLeading)""" + return _gdi_.GraphicsContext_GetFullTextExtent(*args, **kwargs) + def GetTextExtent(*args, **kwargs): - """GetTextExtend(self, text) --> (width, height, descent, externalLeading)""" + """GetTextExtent(self, text) --> (width, height)""" return _gdi_.GraphicsContext_GetTextExtent(*args, **kwargs) def GetPartialTextExtents(*args, **kwargs): @@ -5321,41 +5521,164 @@ class GraphicsContext(object): return _gdi_.GraphicsContext_DrawIcon(*args, **kwargs) def StrokeLine(*args, **kwargs): - """StrokeLine(self, Double x1, Double y1, Double x2, Double y2)""" + """ + StrokeLine(self, Double x1, Double y1, Double x2, Double y2) + + strokes a single line + """ return _gdi_.GraphicsContext_StrokeLine(*args, **kwargs) def StrokeLines(*args, **kwargs): - """StrokeLines(self, List points)""" + """ + StrokeLines(self, List points) + + stroke lines connecting each of the points + """ return _gdi_.GraphicsContext_StrokeLines(*args, **kwargs) def StrokeLineSegements(*args, **kwargs): - """StrokeLineSegements(self, PyObject beginPoints, PyObject endPoints)""" + """ + StrokeLineSegements(self, PyObject beginPoints, PyObject endPoints) + + stroke disconnected lines from begin to end points + """ return _gdi_.GraphicsContext_StrokeLineSegements(*args, **kwargs) def DrawLines(*args, **kwargs): - """DrawLines(self, size_t points, int fillStyle=WINDING_RULE)""" + """ + DrawLines(self, size_t points, int fillStyle=ODDEVEN_RULE) + + draws a polygon + """ return _gdi_.GraphicsContext_DrawLines(*args, **kwargs) def DrawRectangle(*args, **kwargs): - """DrawRectangle(self, Double x, Double y, Double w, Double h)""" + """ + DrawRectangle(self, Double x, Double y, Double w, Double h) + + draws a rectangle + """ return _gdi_.GraphicsContext_DrawRectangle(*args, **kwargs) def DrawEllipse(*args, **kwargs): - """DrawEllipse(self, Double x, Double y, Double w, Double h)""" + """ + DrawEllipse(self, Double x, Double y, Double w, Double h) + + draws an ellipse + """ return _gdi_.GraphicsContext_DrawEllipse(*args, **kwargs) def DrawRoundedRectangle(*args, **kwargs): - """DrawRoundedRectangle(self, Double x, Double y, Double w, Double h, Double radius)""" + """ + DrawRoundedRectangle(self, Double x, Double y, Double w, Double h, Double radius) + + draws a rounded rectangle + """ return _gdi_.GraphicsContext_DrawRoundedRectangle(*args, **kwargs) + def ShouldOffset(*args, **kwargs): + """ + ShouldOffset(self) -> bool + + helper to determine if a 0.5 offset should be applied for the drawing operation + """ + return _gdi_.GraphicsContext_ShouldOffset(*args, **kwargs) + _gdi_.GraphicsContext_swigregister(GraphicsContext) +cvar = _gdi_.cvar +NullGraphicsPen = cvar.NullGraphicsPen +NullGraphicsBrush = cvar.NullGraphicsBrush +NullGraphicsFont = cvar.NullGraphicsFont +NullGraphicsMatrix = cvar.NullGraphicsMatrix +NullGraphicsPath = cvar.NullGraphicsPath -def GraphicsContext_Create(*args, **kwargs): - """GraphicsContext_Create(WindowDC dc) -> GraphicsContext""" - val = _gdi_.GraphicsContext_Create(*args, **kwargs) - val.__dc = args[0] # save a ref so the other dc will not be deleted before self +def GraphicsContext_Create(*args): + """ + Create(WindowDC dc) -> GraphicsContext + GraphicsContext_Create(Window window) -> GraphicsContext + """ + val = _gdi_.GraphicsContext_Create(*args) + val.__dc = args[0] # save a ref so the dc will not be deleted before self return val +def GraphicsContext_CreateFromNative(*args, **kwargs): + """GraphicsContext_CreateFromNative(void context) -> GraphicsContext""" + return _gdi_.GraphicsContext_CreateFromNative(*args, **kwargs) + +def GraphicsContext_CreateFromNativeWindow(*args, **kwargs): + """GraphicsContext_CreateFromNativeWindow(void window) -> GraphicsContext""" + return _gdi_.GraphicsContext_CreateFromNativeWindow(*args, **kwargs) + +class GraphicsRenderer(_core.Object): + """Proxy of C++ GraphicsRenderer class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + def __init__(self): raise AttributeError, "No constructor defined" + __repr__ = _swig_repr + __swig_destroy__ = _gdi_.delete_GraphicsRenderer + __del__ = lambda self : None; + def GetDefaultRenderer(*args, **kwargs): + """GetDefaultRenderer() -> GraphicsRenderer""" + return _gdi_.GraphicsRenderer_GetDefaultRenderer(*args, **kwargs) + + GetDefaultRenderer = staticmethod(GetDefaultRenderer) + def CreateContext(*args): + """ + CreateContext(self, WindowDC dc) -> GraphicsContext + CreateContext(self, Window window) -> GraphicsContext + """ + return _gdi_.GraphicsRenderer_CreateContext(*args) + + def CreateContextFromNativeContext(*args, **kwargs): + """CreateContextFromNativeContext(self, void context) -> GraphicsContext""" + return _gdi_.GraphicsRenderer_CreateContextFromNativeContext(*args, **kwargs) + + def CreateContextFromNativeWindow(*args, **kwargs): + """CreateContextFromNativeWindow(self, void window) -> GraphicsContext""" + return _gdi_.GraphicsRenderer_CreateContextFromNativeWindow(*args, **kwargs) + + def CreatePath(*args, **kwargs): + """CreatePath(self) -> GraphicsPath""" + return _gdi_.GraphicsRenderer_CreatePath(*args, **kwargs) + + def CreateMatrix(*args, **kwargs): + """ + CreateMatrix(self, Double a=1.0, Double b=0.0, Double c=0.0, Double d=1.0, + Double tx=0.0, Double ty=0.0) -> GraphicsMatrix + """ + return _gdi_.GraphicsRenderer_CreateMatrix(*args, **kwargs) + + def CreatePen(*args, **kwargs): + """CreatePen(self, Pen pen) -> GraphicsPen""" + return _gdi_.GraphicsRenderer_CreatePen(*args, **kwargs) + + def CreateBrush(*args, **kwargs): + """CreateBrush(self, Brush brush) -> GraphicsBrush""" + return _gdi_.GraphicsRenderer_CreateBrush(*args, **kwargs) + + def CreateLinearGradientBrush(*args, **kwargs): + """ + CreateLinearGradientBrush(self, Double x1, Double y1, Double x2, Double y2, Colour c1, + Colour c2) -> GraphicsBrush + """ + return _gdi_.GraphicsRenderer_CreateLinearGradientBrush(*args, **kwargs) + + def CreateRadialGradientBrush(*args, **kwargs): + """ + CreateRadialGradientBrush(self, Double xo, Double yo, Double xc, Double yc, Double radius, + Colour oColor, Colour cColor) -> GraphicsBrush + """ + return _gdi_.GraphicsRenderer_CreateRadialGradientBrush(*args, **kwargs) + + def CreateFont(*args, **kwargs): + """CreateFont(self, Font font, Colour col=*wxBLACK) -> GraphicsFont""" + return _gdi_.GraphicsRenderer_CreateFont(*args, **kwargs) + +_gdi_.GraphicsRenderer_swigregister(GraphicsRenderer) + +def GraphicsRenderer_GetDefaultRenderer(*args): + """GraphicsRenderer_GetDefaultRenderer() -> GraphicsRenderer""" + return _gdi_.GraphicsRenderer_GetDefaultRenderer(*args) + class GCDC(DC): """Proxy of C++ GCDC class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') @@ -5367,10 +5690,15 @@ class GCDC(DC): __swig_destroy__ = _gdi_.delete_GCDC __del__ = lambda self : None; - def GetGraphicContext(*args, **kwargs): - """GetGraphicContext(self) -> GraphicsContext""" - return _gdi_.GCDC_GetGraphicContext(*args, **kwargs) + def GetGraphicsContext(*args, **kwargs): + """GetGraphicsContext(self) -> GraphicsContext""" + return _gdi_.GCDC_GetGraphicsContext(*args, **kwargs) + + def SetGraphicsContext(*args, **kwargs): + """SetGraphicsContext(self, GraphicsContext ctx)""" + return _gdi_.GCDC_SetGraphicsContext(*args, **kwargs) + GraphicsContext = property(GetGraphicsContext,SetGraphicsContext) _gdi_.GCDC_swigregister(GCDC) class Overlay(object): @@ -5682,7 +6010,6 @@ class GDIObjListBase(object): __swig_destroy__ = _gdi_.delete_GDIObjListBase __del__ = lambda self : None; _gdi_.GDIObjListBase_swigregister(GDIObjListBase) -cvar = _gdi_.cvar NullBitmap = cvar.NullBitmap NullIcon = cvar.NullIcon NullCursor = cvar.NullCursor @@ -6692,8 +7019,6 @@ class PseudoDC(_core.Object): 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. - - :see: `DrawEllipse` """ return _gdi_.PseudoDC_DrawCircle(*args, **kwargs) @@ -6704,8 +7029,6 @@ class PseudoDC(_core.Object): 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. - - :see: `DrawEllipse` """ return _gdi_.PseudoDC_DrawCirclePoint(*args, **kwargs) @@ -6715,8 +7038,6 @@ class PseudoDC(_core.Object): Draws an ellipse contained in the specified rectangle. The current pen is used for the outline and the current brush for filling the shape. - - :see: `DrawCircle` """ return _gdi_.PseudoDC_DrawEllipse(*args, **kwargs) @@ -6726,8 +7047,6 @@ class PseudoDC(_core.Object): Draws an ellipse contained in the specified rectangle. The current pen is used for the outline and the current brush for filling the shape. - - :see: `DrawCircle` """ return _gdi_.PseudoDC_DrawEllipseRect(*args, **kwargs) @@ -6737,8 +7056,6 @@ class PseudoDC(_core.Object): Draws an ellipse contained in the specified rectangle. The current pen is used for the outline and the current brush for filling the shape. - - :see: `DrawCircle` """ return _gdi_.PseudoDC_DrawEllipsePointSize(*args, **kwargs) @@ -6770,13 +7087,6 @@ class PseudoDC(_core.Object): *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. - - When drawing a mono-bitmap, the current text foreground colour will be - used to draw the foreground of the bitmap (all bits set to 1), and the - current text background colour to draw the background (all bits set to - 0). - - :see: `SetTextForeground`, `SetTextBackground` and `wx.MemoryDC` """ return _gdi_.PseudoDC_DrawBitmap(*args, **kwargs) @@ -6788,13 +7098,6 @@ class PseudoDC(_core.Object): *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. - - When drawing a mono-bitmap, the current text foreground colour will be - used to draw the foreground of the bitmap (all bits set to 1), and the - current text background colour to draw the background (all bits set to - 0). - - :see: `SetTextForeground`, `SetTextBackground` and `wx.MemoryDC` """ return _gdi_.PseudoDC_DrawBitmapPoint(*args, **kwargs) @@ -6814,8 +7117,6 @@ class PseudoDC(_core.Object): **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. - - :see: `DrawRotatedText` """ return _gdi_.PseudoDC_DrawText(*args, **kwargs) @@ -6835,8 +7136,6 @@ class PseudoDC(_core.Object): **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. - - :see: `DrawRotatedText` """ return _gdi_.PseudoDC_DrawTextPoint(*args, **kwargs) @@ -6850,8 +7149,6 @@ class PseudoDC(_core.Object): 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. - - :see: `DrawText` """ return _gdi_.PseudoDC_DrawRotatedText(*args, **kwargs) @@ -6865,8 +7162,6 @@ class PseudoDC(_core.Object): 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. - - :see: `DrawText` """ return _gdi_.PseudoDC_DrawRotatedTextPoint(*args, **kwargs) @@ -6904,8 +7199,6 @@ class PseudoDC(_core.Object): Draw *text* within the specified rectangle, abiding by the alignment flags. Will additionally emphasize the character at *indexAccel* if it is not -1. - - :see: `DrawImageLabel` """ return _gdi_.PseudoDC_DrawLabel(*args, **kwargs) @@ -6945,8 +7238,6 @@ class PseudoDC(_core.Object): Sets the current font for the DC. It must be a valid font, in particular you should not pass ``wx.NullFont`` to this method. - - :see: `wx.Font` """ return _gdi_.PseudoDC_SetFont(*args, **kwargs) @@ -6958,8 +7249,6 @@ class PseudoDC(_core.Object): If the argument is ``wx.NullPen``, the current pen is selected out of the device context, and the original pen restored. - - :see: `wx.Pen` """ return _gdi_.PseudoDC_SetPen(*args, **kwargs) @@ -6972,8 +7261,6 @@ class PseudoDC(_core.Object): 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. - - :see: `wx.Brush` """ return _gdi_.PseudoDC_SetBrush(*args, **kwargs) @@ -7003,8 +7290,6 @@ class PseudoDC(_core.Object): 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. - - :see: `wx.Palette` """ return _gdi_.PseudoDC_SetPalette(*args, **kwargs)