AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

reSWIGged

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@42105 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn 2006-10-18 23:51:19 +00:00
parent 72156afeb5
commit 24f6c4e865
9 changed files with 2373 additions and 1555 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

538
wxPython/src/gtk/_gdi.py
View File

@ -406,6 +406,18 @@ 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
@ -413,7 +425,24 @@ class Brush(GDIObject):
"""
__init__(self, Colour colour, int style=SOLID) -> Brush
Constructs a brush from a `wx.Colour` object and a style.
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`
"""
_gdi_.Brush_swiginit(self,_gdi_.new_Brush(*args, **kwargs))
__swig_destroy__ = _gdi_.delete_Brush
@ -509,6 +538,23 @@ 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
@ -517,6 +563,32 @@ 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
@ -1248,6 +1320,40 @@ 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
@ -1258,6 +1364,7 @@ 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
@ -1286,6 +1393,11 @@ 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
@ -1858,6 +1970,71 @@ 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
@ -3200,6 +3377,8 @@ 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)
@ -3210,6 +3389,8 @@ 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)
@ -3219,6 +3400,8 @@ 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)
@ -3228,6 +3411,8 @@ 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)
@ -3237,6 +3422,8 @@ 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)
@ -3268,6 +3455,13 @@ 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)
@ -3279,6 +3473,13 @@ 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)
@ -3296,6 +3497,8 @@ 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)
@ -3313,6 +3516,8 @@ 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)
@ -3326,6 +3531,8 @@ 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)
@ -3339,6 +3546,8 @@ 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)
@ -3352,6 +3561,23 @@ 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)
@ -3364,6 +3590,17 @@ 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)
@ -3381,6 +3618,8 @@ 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)
@ -3398,6 +3637,8 @@ 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)
@ -3415,6 +3656,8 @@ 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)
@ -3432,6 +3675,8 @@ 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)
@ -3469,6 +3714,8 @@ 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)
@ -3541,6 +3788,8 @@ 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)
@ -3552,6 +3801,8 @@ 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)
@ -3564,6 +3815,8 @@ 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)
@ -3593,6 +3846,8 @@ 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)
@ -3602,6 +3857,8 @@ 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)
@ -3847,6 +4104,8 @@ class DC(_core.Object):
Returns the current background mode, either ``wx.SOLID`` or
``wx.TRANSPARENT``.
:see: `SetBackgroundMode`
"""
return _gdi_.DC_GetBackgroundMode(*args, **kwargs)
@ -3855,6 +4114,8 @@ class DC(_core.Object):
GetBackground(self) -> Brush
Gets the brush used for painting the background.
:see: `SetBackground`
"""
return _gdi_.DC_GetBackground(*args, **kwargs)
@ -3939,6 +4200,18 @@ 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)
@ -4411,6 +4684,8 @@ 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):
@ -4442,88 +4717,6 @@ def MemoryDCFromDC(*args, **kwargs):
#---------------------------------------------------------------------------
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`.
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.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
__init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
Constructs a buffered DC.
"""
_gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
self.__dc = args[0] # save a ref so the other dc will not be deleted before self
__swig_destroy__ = _gdi_.delete_BufferedDC
__del__ = lambda self : None;
def UnMask(*args, **kwargs):
"""
UnMask(self)
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)
_gdi_.BufferedDC_swigregister(BufferedDC)
class BufferedPaintDC(BufferedDC):
"""
This is a subclass of `wx.BufferedDC` which can be used inside of an
EVT_PAINT event handler. Just create an object of this class instead
of `wx.PaintDC` and that's all you have to do to (mostly) avoid
flicker. The only thing to watch out for is that if you are using this
class together with `wx.ScrolledWindow`, you probably do **not** want
to call `wx.Window.PrepareDC` on it as it already does this internally
for the real underlying `wx.PaintDC`.
If your window is already fully buffered in a `wx.Bitmap` then your
EVT_PAINT handler can be as simple as just creating a
``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
automatically when it is destroyed. For example::
def OnPaint(self, event):
dc = wx.BufferedPaintDC(self, self.buffer)
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
Create a buffered paint DC. As with `wx.BufferedDC`, you may either
provide the bitmap to be used for buffering or let this object create
one internally (in the latter case, the size of the client part of the
window is automatically used).
"""
_gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
#---------------------------------------------------------------------------
class ScreenDC(DC):
"""
A wxScreenDC can be used to paint anywhere on the screen. This should
@ -4665,20 +4858,133 @@ _gdi_.PaintDC_swigregister(PaintDC)
#---------------------------------------------------------------------------
if 'wxMac' in wx.PlatformInfo or 'gtk2' in wx.PlatformInfo:
_AutoBufferedPaintDCBase = PaintDC
else:
_AutoBufferedPaintDCBase = BufferedPaintDC
class AutoBufferedPaintDC(_AutoBufferedPaintDCBase):
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`.
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.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
__init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
Constructs a buffered DC.
: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
__swig_destroy__ = _gdi_.delete_BufferedDC
__del__ = lambda self : None;
def UnMask(*args, **kwargs):
"""
UnMask(self)
Blits the buffer to the dc, and detaches the dc from the buffer (so it
can be effectively used once only). This is usually only called in
the destructor.
"""
return _gdi_.BufferedDC_UnMask(*args, **kwargs)
_gdi_.BufferedDC_swigregister(BufferedDC)
class BufferedPaintDC(BufferedDC):
"""
This is a subclass of `wx.BufferedDC` which can be used inside of an
EVT_PAINT event handler. Just create an object of this class instead
of `wx.PaintDC` and that's all you have to do to (mostly) avoid
flicker. The only thing to watch out for is that if you are using this
class together with `wx.ScrolledWindow`, you probably do **not** want
to call `wx.Window.PrepareDC` on it as it already does this internally
for the real underlying `wx.PaintDC`.
If your window is already fully buffered in a `wx.Bitmap` then your
EVT_PAINT handler can be as simple as just creating a
``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
automatically when it is destroyed. For example::
def OnPaint(self, event):
dc = wx.BufferedPaintDC(self, self.buffer)
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
Create a buffered paint DC. As with `wx.BufferedDC`, you may either
provide the bitmap to be used for buffering or let this object create
one internally (in the latter case, the size of the client part of the
window is automatically used).
"""
_gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
#---------------------------------------------------------------------------
class AutoBufferedPaintDC(DC):
"""
If the current platform double buffers by default then this DC is the
same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
:see: `wx.AutoBufferedPaintDCFactory`
"""
def __init__(self, window):
_AutoBufferedPaintDCBase.__init__(self, window)
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window win) -> AutoBufferedPaintDC
If the current platform double buffers by default then this DC is the
same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
:see: `wx.AutoBufferedPaintDCFactory`
"""
_gdi_.AutoBufferedPaintDC_swiginit(self,_gdi_.new_AutoBufferedPaintDC(*args, **kwargs))
_gdi_.AutoBufferedPaintDC_swigregister(AutoBufferedPaintDC)
def AutoBufferedPaintDCFactory(*args, **kwargs):
@ -4686,10 +4992,10 @@ def AutoBufferedPaintDCFactory(*args, **kwargs):
AutoBufferedPaintDCFactory(Window window) -> DC
Checks if the window is natively double buffered and will return a
`wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise. The
advantage of this function over `wx.AutoBufferedPaintDC` is that this
function will check if the the specified window supports has
double-buffering enabled rather than just going by platform defaults.
`wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise. The advantage of
this function over `wx.AutoBufferedPaintDC` is that this function will check
if the the specified window has double-buffering enabled rather than just
going by platform defaults.
"""
return _gdi_.AutoBufferedPaintDCFactory(*args, **kwargs)
#---------------------------------------------------------------------------
@ -6386,6 +6692,8 @@ 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)
@ -6396,6 +6704,8 @@ 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)
@ -6405,6 +6715,8 @@ 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)
@ -6414,6 +6726,8 @@ 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)
@ -6423,6 +6737,8 @@ 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)
@ -6454,6 +6770,13 @@ 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)
@ -6465,6 +6788,13 @@ 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)
@ -6484,6 +6814,8 @@ 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)
@ -6503,6 +6835,8 @@ 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)
@ -6516,6 +6850,8 @@ 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)
@ -6529,6 +6865,8 @@ 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)
@ -6566,6 +6904,8 @@ 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)
@ -6605,6 +6945,8 @@ 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)
@ -6616,6 +6958,8 @@ 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)
@ -6628,6 +6972,8 @@ 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)
@ -6657,6 +7003,8 @@ 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)

899
wxPython/src/gtk/_gdi_wrap.cpp
View File

File diff suppressed because one or more lines are too long

293
wxPython/src/gtk/_misc.py
View File

@ -2615,6 +2615,98 @@ class ArtProvider(object):
...
return bmp
Identifying art resources
-------------------------
Every bitmap is known to wx.ArtProvider under an unique ID that is
used when requesting a resource from it. The IDs can have one of the
following predefined values. Additionally, any string recognized by
custom art providers registered using `Push` may be used.
GTK+ Note
---------
When running under GTK+ 2, GTK+ stock item IDs (e.g. 'gtk-cdrom') may be used
as well. Additionally, if wxGTK was compiled against GTK+ >= 2.4, then it is
also possible to load icons from current icon theme by specifying their name
without the extension and directory components. Icon themes recognized by GTK+
follow the freedesktop.org Icon Themes specification. Note that themes are
not guaranteed to contain all icons, so wx.ArtProvider may return wx.NullBitmap
or wx.NullIcon. The default theme is typically installed in /usr/share/icons/hicolor.
* wx.ART_ADD_BOOKMARK
* wx.ART_DEL_BOOKMARK
* wx.ART_HELP_SIDE_PANEL
* wx.ART_HELP_SETTINGS
* wx.ART_HELP_BOOK
* wx.ART_HELP_FOLDER
* wx.ART_HELP_PAGE
* wx.ART_GO_BACK
* wx.ART_GO_FORWARD
* wx.ART_GO_UP
* wx.ART_GO_DOWN
* wx.ART_GO_TO_PARENT
* wx.ART_GO_HOME
* wx.ART_FILE_OPEN
* wx.ART_FILE_SAVE
* wx.ART_FILE_SAVE_AS
* wx.ART_PRINT
* wx.ART_HELP
* wx.ART_TIP
* wx.ART_REPORT_VIEW
* wx.ART_LIST_VIEW
* wx.ART_NEW_DIR
* wx.ART_HARDDISK
* wx.ART_FLOPPY
* wx.ART_CDROM
* wx.ART_REMOVABLE
* wx.ART_FOLDER
* wx.ART_FOLDER_OPEN
* wx.ART_GO_DIR_UP
* wx.ART_EXECUTABLE_FILE
* wx.ART_NORMAL_FILE
* wx.ART_TICK_MARK
* wx.ART_CROSS_MARK
* wx.ART_ERROR
* wx.ART_QUESTION
* wx.ART_WARNING
* wx.ART_INFORMATION
* wx.ART_MISSING_IMAGE
* wx.ART_COPY
* wx.ART_CUT
* wx.ART_PASTE
* wx.ART_DELETE
* wx.ART_NEW
* wx.ART_UNDO
* wx.ART_REDO
* wx.ART_QUIT
* wx.ART_FIND
* wx.ART_FIND_AND_REPLACE
Clients
-------
The Client is the entity that calls wx.ArtProvider's `GetBitmap` or
`GetIcon` function. Client IDs serve as a hint to wx.ArtProvider
that is supposed to help it to choose the best looking bitmap. For
example it is often desirable to use slightly different icons in menus
and toolbars even though they represent the same action (e.g.
wx.ART_FILE_OPEN). Remember that this is really only a hint for
wx.ArtProvider -- it is common that `wx.ArtProvider.GetBitmap` returns
identical bitmap for different client values!
* wx.ART_TOOLBAR
* wx.ART_MENU
* wx.ART_FRAME_ICON
* wx.ART_CMN_DIALOG
* wx.ART_HELP_BROWSER
* wx.ART_MESSAGE_BOX
* wx.ART_BUTTON
* wx.ART_OTHER (used for all requests that don't fit into any
of the categories above)
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@ -2639,6 +2731,98 @@ class ArtProvider(object):
...
return bmp
Identifying art resources
-------------------------
Every bitmap is known to wx.ArtProvider under an unique ID that is
used when requesting a resource from it. The IDs can have one of the
following predefined values. Additionally, any string recognized by
custom art providers registered using `Push` may be used.
GTK+ Note
---------
When running under GTK+ 2, GTK+ stock item IDs (e.g. 'gtk-cdrom') may be used
as well. Additionally, if wxGTK was compiled against GTK+ >= 2.4, then it is
also possible to load icons from current icon theme by specifying their name
without the extension and directory components. Icon themes recognized by GTK+
follow the freedesktop.org Icon Themes specification. Note that themes are
not guaranteed to contain all icons, so wx.ArtProvider may return wx.NullBitmap
or wx.NullIcon. The default theme is typically installed in /usr/share/icons/hicolor.
* wx.ART_ADD_BOOKMARK
* wx.ART_DEL_BOOKMARK
* wx.ART_HELP_SIDE_PANEL
* wx.ART_HELP_SETTINGS
* wx.ART_HELP_BOOK
* wx.ART_HELP_FOLDER
* wx.ART_HELP_PAGE
* wx.ART_GO_BACK
* wx.ART_GO_FORWARD
* wx.ART_GO_UP
* wx.ART_GO_DOWN
* wx.ART_GO_TO_PARENT
* wx.ART_GO_HOME
* wx.ART_FILE_OPEN
* wx.ART_FILE_SAVE
* wx.ART_FILE_SAVE_AS
* wx.ART_PRINT
* wx.ART_HELP
* wx.ART_TIP
* wx.ART_REPORT_VIEW
* wx.ART_LIST_VIEW
* wx.ART_NEW_DIR
* wx.ART_HARDDISK
* wx.ART_FLOPPY
* wx.ART_CDROM
* wx.ART_REMOVABLE
* wx.ART_FOLDER
* wx.ART_FOLDER_OPEN
* wx.ART_GO_DIR_UP
* wx.ART_EXECUTABLE_FILE
* wx.ART_NORMAL_FILE
* wx.ART_TICK_MARK
* wx.ART_CROSS_MARK
* wx.ART_ERROR
* wx.ART_QUESTION
* wx.ART_WARNING
* wx.ART_INFORMATION
* wx.ART_MISSING_IMAGE
* wx.ART_COPY
* wx.ART_CUT
* wx.ART_PASTE
* wx.ART_DELETE
* wx.ART_NEW
* wx.ART_UNDO
* wx.ART_REDO
* wx.ART_QUIT
* wx.ART_FIND
* wx.ART_FIND_AND_REPLACE
Clients
-------
The Client is the entity that calls wx.ArtProvider's `GetBitmap` or
`GetIcon` function. Client IDs serve as a hint to wx.ArtProvider
that is supposed to help it to choose the best looking bitmap. For
example it is often desirable to use slightly different icons in menus
and toolbars even though they represent the same action (e.g.
wx.ART_FILE_OPEN). Remember that this is really only a hint for
wx.ArtProvider -- it is common that `wx.ArtProvider.GetBitmap` returns
identical bitmap for different client values!
* wx.ART_TOOLBAR
* wx.ART_MENU
* wx.ART_FRAME_ICON
* wx.ART_CMN_DIALOG
* wx.ART_HELP_BROWSER
* wx.ART_MESSAGE_BOX
* wx.ART_BUTTON
* wx.ART_OTHER (used for all requests that don't fit into any
of the categories above)
"""
_misc_.ArtProvider_swiginit(self,_misc_.new_ArtProvider(*args, **kwargs))
self._setCallbackInfo(self, ArtProvider)
@ -4628,6 +4812,29 @@ class DataFormat(object):
example, pasting data from the clipboard only if the data is in a
format the program understands. A data format is is used to uniquely
identify this format.
On the system level, a data format is usually just a number, (which
may be the CLIPFORMAT under Windows or Atom under X11, for example.)
The standard format IDs are:
================ =====================================
wx.DF_INVALID An invalid format
wx.DF_TEXT Text format
wx.DF_BITMAP A bitmap (wx.Bitmap)
wx.DF_METAFILE A metafile (wx.Metafile, Windows only)
wx.DF_FILENAME A list of filenames
wx.DF_HTML An HTML string. This is only valid on
Windows and non-unicode builds
================ =====================================
Besies the standard formats, the application may also use custom
formats which are identified by their names (strings) and not numeric
identifiers. Although internally custom format must be created (or
registered) first, you shouldn't care about it because it is done
automatically the first time the wxDataFormat object corresponding to
a given format name is created.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@ -4718,6 +4925,39 @@ class DataObject(object):
you should instead derive from `wx.PyDataObjectSimple` or use
`wx.CustomDataObject`.
Not surprisingly, being 'smart' comes at a price of added
complexity. This is reasonable for the situations when you really need
to support multiple formats, but may be annoying if you only want to
do something simple like cut and paste text.
To provide a solution for both cases, wxWidgets has two predefined
classes which derive from wx.DataObject: `wx.DataObjectSimple` and
`wx.DataObjectComposite`. `wx.DataObjectSimple` is the simplest
wx.DataObject possible and only holds data in a single format (such as
text or bitmap) and `wx.DataObjectComposite` is the simplest way to
implement a wx.DataObject which supports multiple simultaneous formats
because it achievs this by simply holding several
`wx.DataObjectSimple` objects.
Please note that the easiest way to use drag and drop and the
clipboard with multiple formats is by using `wx.DataObjectComposite`,
but it is not the most efficient one as each `wx.DataObjectSimple`
would contain the whole data in its respective formats. Now imagine
that you want to paste 200 pages of text in your proprietary format,
as well as Word, RTF, HTML, Unicode and plain text to the clipboard
and even today's computers are in trouble. For this case, you will
have to derive from wx.DataObject directly and make it enumerate its
formats and provide the data in the requested format on
demand. (**TODO**: This is currently not possible from Python. Make
it so.)
Note that the platform transfer mechanisms for the clipboard and drag
and drop, do not copy any data out of the source application until
another application actually requests the data. This is in contrast to
the 'feel' offered to the user of a program who would normally think
that the data resides in the clipboard after having pressed 'Copy' -
in reality it is only declared to be available.
"""
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"
@ -4776,6 +5016,7 @@ class DataObject(object):
GetDataHere(self, DataFormat format) -> String
Get the data bytes in the specified format, returns None on failure.
:todo: This should use the python buffer interface isntead...
"""
return _misc_.DataObject_GetDataHere(*args, **kwargs)
@ -4785,6 +5026,7 @@ class DataObject(object):
Set the data in the specified format from the bytes in the the data string.
:todo: This should use the python buffer interface isntead...
"""
return _misc_.DataObject_SetData(*args, **kwargs)
@ -4872,6 +5114,29 @@ class PyDataObjectSimple(DataObjectSimple):
class and overload `GetDataSize`, `GetDataHere` and `SetData` when you
need to create your own simple single-format type of `wx.DataObject`.
Here is a simple example::
class MyDataObject(wx.PyDataObjectSimple):
def __init__(self):
wx.PyDataObjectSimple.__init__(
self, wx.CustomDataFormat('MyDOFormat'))
self.data = ''
def GetDataSize(self):
return len(self.data)
def GetDataHere(self):
return self.data # returns a string
def SetData(self, data):
self.data = data
return True
Note that there is already a `wx.CustomDataObject` class that behaves
very similarly to this example. The value of creating your own
derived class like this is to be able to do additional things when the
data is requested or given via the clipboard or drag and drop
operation, such as generate the data value or decode it into needed
data structures.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@ -4885,6 +5150,29 @@ class PyDataObjectSimple(DataObjectSimple):
class and overload `GetDataSize`, `GetDataHere` and `SetData` when you
need to create your own simple single-format type of `wx.DataObject`.
Here is a simple example::
class MyDataObject(wx.PyDataObjectSimple):
def __init__(self):
wx.PyDataObjectSimple.__init__(
self, wx.CustomDataFormat('MyDOFormat'))
self.data = ''
def GetDataSize(self):
return len(self.data)
def GetDataHere(self):
return self.data # returns a string
def SetData(self, data):
self.data = data
return True
Note that there is already a `wx.CustomDataObject` class that behaves
very similarly to this example. The value of creating your own
derived class like this is to be able to do additional things when the
data is requested or given via the clipboard or drag and drop
operation, such as generate the data value or decode it into needed
data structures.
"""
_misc_.PyDataObjectSimple_swiginit(self,_misc_.new_PyDataObjectSimple(*args, **kwargs))
self._setCallbackInfo(self, PyDataObjectSimple)
@ -5050,6 +5338,7 @@ class BitmapDataObject(DataObjectSimple):
data. It can be used without change to paste data into the `wx.Clipboard`
or a `wx.DropSource`.
:see: `wx.PyBitmapDataObject` if you wish to override `GetBitmap` to increase efficiency.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@ -6623,8 +6912,8 @@ def AboutBox(*args, **kwargs):
This function shows the standard about dialog containing the
information specified in ``info``. If the current platform has a
native about dialog which is capable of showing all the fields in
``info``, the native dialog is used, otherwise the function falls back
to the generic wxWidgets version of the dialog.
`wx.AboutDialogInfo`, the native dialog is used, otherwise the
function falls back to the generic wxWidgets version of the dialog.
"""
return _misc_.AboutBox(*args, **kwargs)

196
wxPython/src/mac/_gdi.py
View File

@ -4441,88 +4441,6 @@ def MemoryDCFromDC(*args, **kwargs):
#---------------------------------------------------------------------------
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`.
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.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
__init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
Constructs a buffered DC.
"""
_gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
self.__dc = args[0] # save a ref so the other dc will not be deleted before self
__swig_destroy__ = _gdi_.delete_BufferedDC
__del__ = lambda self : None;
def UnMask(*args, **kwargs):
"""
UnMask(self)
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)
_gdi_.BufferedDC_swigregister(BufferedDC)
class BufferedPaintDC(BufferedDC):
"""
This is a subclass of `wx.BufferedDC` which can be used inside of an
EVT_PAINT event handler. Just create an object of this class instead
of `wx.PaintDC` and that's all you have to do to (mostly) avoid
flicker. The only thing to watch out for is that if you are using this
class together with `wx.ScrolledWindow`, you probably do **not** want
to call `wx.Window.PrepareDC` on it as it already does this internally
for the real underlying `wx.PaintDC`.
If your window is already fully buffered in a `wx.Bitmap` then your
EVT_PAINT handler can be as simple as just creating a
``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
automatically when it is destroyed. For example::
def OnPaint(self, event):
dc = wx.BufferedPaintDC(self, self.buffer)
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
Create a buffered paint DC. As with `wx.BufferedDC`, you may either
provide the bitmap to be used for buffering or let this object create
one internally (in the latter case, the size of the client part of the
window is automatically used).
"""
_gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
#---------------------------------------------------------------------------
class ScreenDC(DC):
"""
A wxScreenDC can be used to paint anywhere on the screen. This should
@ -4664,20 +4582,110 @@ _gdi_.PaintDC_swigregister(PaintDC)
#---------------------------------------------------------------------------
if 'wxMac' in wx.PlatformInfo or 'gtk2' in wx.PlatformInfo:
_AutoBufferedPaintDCBase = PaintDC
else:
_AutoBufferedPaintDCBase = BufferedPaintDC
class AutoBufferedPaintDC(_AutoBufferedPaintDCBase):
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`.
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.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
__init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
Constructs a buffered DC.
"""
_gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
self.__dc = args[0] # save a ref so the other dc will not be deleted before self
__swig_destroy__ = _gdi_.delete_BufferedDC
__del__ = lambda self : None;
def UnMask(*args, **kwargs):
"""
UnMask(self)
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)
_gdi_.BufferedDC_swigregister(BufferedDC)
class BufferedPaintDC(BufferedDC):
"""
This is a subclass of `wx.BufferedDC` which can be used inside of an
EVT_PAINT event handler. Just create an object of this class instead
of `wx.PaintDC` and that's all you have to do to (mostly) avoid
flicker. The only thing to watch out for is that if you are using this
class together with `wx.ScrolledWindow`, you probably do **not** want
to call `wx.Window.PrepareDC` on it as it already does this internally
for the real underlying `wx.PaintDC`.
If your window is already fully buffered in a `wx.Bitmap` then your
EVT_PAINT handler can be as simple as just creating a
``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
automatically when it is destroyed. For example::
def OnPaint(self, event):
dc = wx.BufferedPaintDC(self, self.buffer)
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
Create a buffered paint DC. As with `wx.BufferedDC`, you may either
provide the bitmap to be used for buffering or let this object create
one internally (in the latter case, the size of the client part of the
window is automatically used).
"""
_gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
#---------------------------------------------------------------------------
class AutoBufferedPaintDC(DC):
"""
If the current platform double buffers by default then this DC is the
same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
:see: `wx.AutoBufferedPaintDCFactory`
"""
def __init__(self, window):
_AutoBufferedPaintDCBase.__init__(self, window)
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window win) -> AutoBufferedPaintDC
If the current platform double buffers by default then this DC is the
same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
:see: `wx.AutoBufferedPaintDCFactory`
"""
_gdi_.AutoBufferedPaintDC_swiginit(self,_gdi_.new_AutoBufferedPaintDC(*args, **kwargs))
_gdi_.AutoBufferedPaintDC_swigregister(AutoBufferedPaintDC)
def AutoBufferedPaintDCFactory(*args, **kwargs):
@ -4685,10 +4693,10 @@ def AutoBufferedPaintDCFactory(*args, **kwargs):
AutoBufferedPaintDCFactory(Window window) -> DC
Checks if the window is natively double buffered and will return a
`wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise. The
advantage of this function over `wx.AutoBufferedPaintDC` is that this
function will check if the the specified window supports has
double-buffering enabled rather than just going by platform defaults.
`wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise. The advantage of
this function over `wx.AutoBufferedPaintDC` is that this function will check
if the the specified window has double-buffering enabled rather than just
going by platform defaults.
"""
return _gdi_.AutoBufferedPaintDCFactory(*args, **kwargs)
#---------------------------------------------------------------------------

899
wxPython/src/mac/_gdi_wrap.cpp
View File

File diff suppressed because one or more lines are too long

4
wxPython/src/mac/_misc.py
View File

@ -6631,8 +6631,8 @@ def AboutBox(*args, **kwargs):
This function shows the standard about dialog containing the
information specified in ``info``. If the current platform has a
native about dialog which is capable of showing all the fields in
``info``, the native dialog is used, otherwise the function falls back
to the generic wxWidgets version of the dialog.
`wx.AboutDialogInfo`, the native dialog is used, otherwise the
function falls back to the generic wxWidgets version of the dialog.
"""
return _misc_.AboutBox(*args, **kwargs)

196
wxPython/src/msw/_gdi.py
View File

@ -4535,88 +4535,6 @@ def MemoryDCFromDC(*args, **kwargs):
#---------------------------------------------------------------------------
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`.
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.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
__init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
Constructs a buffered DC.
"""
_gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
self.__dc = args[0] # save a ref so the other dc will not be deleted before self
__swig_destroy__ = _gdi_.delete_BufferedDC
__del__ = lambda self : None;
def UnMask(*args, **kwargs):
"""
UnMask(self)
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)
_gdi_.BufferedDC_swigregister(BufferedDC)
class BufferedPaintDC(BufferedDC):
"""
This is a subclass of `wx.BufferedDC` which can be used inside of an
EVT_PAINT event handler. Just create an object of this class instead
of `wx.PaintDC` and that's all you have to do to (mostly) avoid
flicker. The only thing to watch out for is that if you are using this
class together with `wx.ScrolledWindow`, you probably do **not** want
to call `wx.Window.PrepareDC` on it as it already does this internally
for the real underlying `wx.PaintDC`.
If your window is already fully buffered in a `wx.Bitmap` then your
EVT_PAINT handler can be as simple as just creating a
``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
automatically when it is destroyed. For example::
def OnPaint(self, event):
dc = wx.BufferedPaintDC(self, self.buffer)
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
Create a buffered paint DC. As with `wx.BufferedDC`, you may either
provide the bitmap to be used for buffering or let this object create
one internally (in the latter case, the size of the client part of the
window is automatically used).
"""
_gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
#---------------------------------------------------------------------------
class ScreenDC(DC):
"""
A wxScreenDC can be used to paint anywhere on the screen. This should
@ -4758,20 +4676,110 @@ _gdi_.PaintDC_swigregister(PaintDC)
#---------------------------------------------------------------------------
if 'wxMac' in wx.PlatformInfo or 'gtk2' in wx.PlatformInfo:
_AutoBufferedPaintDCBase = PaintDC
else:
_AutoBufferedPaintDCBase = BufferedPaintDC
class AutoBufferedPaintDC(_AutoBufferedPaintDCBase):
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`.
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.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
__init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
Constructs a buffered DC.
"""
_gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
self.__dc = args[0] # save a ref so the other dc will not be deleted before self
__swig_destroy__ = _gdi_.delete_BufferedDC
__del__ = lambda self : None;
def UnMask(*args, **kwargs):
"""
UnMask(self)
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)
_gdi_.BufferedDC_swigregister(BufferedDC)
class BufferedPaintDC(BufferedDC):
"""
This is a subclass of `wx.BufferedDC` which can be used inside of an
EVT_PAINT event handler. Just create an object of this class instead
of `wx.PaintDC` and that's all you have to do to (mostly) avoid
flicker. The only thing to watch out for is that if you are using this
class together with `wx.ScrolledWindow`, you probably do **not** want
to call `wx.Window.PrepareDC` on it as it already does this internally
for the real underlying `wx.PaintDC`.
If your window is already fully buffered in a `wx.Bitmap` then your
EVT_PAINT handler can be as simple as just creating a
``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
automatically when it is destroyed. For example::
def OnPaint(self, event):
dc = wx.BufferedPaintDC(self, self.buffer)
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
Create a buffered paint DC. As with `wx.BufferedDC`, you may either
provide the bitmap to be used for buffering or let this object create
one internally (in the latter case, the size of the client part of the
window is automatically used).
"""
_gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
#---------------------------------------------------------------------------
class AutoBufferedPaintDC(DC):
"""
If the current platform double buffers by default then this DC is the
same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
:see: `wx.AutoBufferedPaintDCFactory`
"""
def __init__(self, window):
_AutoBufferedPaintDCBase.__init__(self, window)
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window win) -> AutoBufferedPaintDC
If the current platform double buffers by default then this DC is the
same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
:see: `wx.AutoBufferedPaintDCFactory`
"""
_gdi_.AutoBufferedPaintDC_swiginit(self,_gdi_.new_AutoBufferedPaintDC(*args, **kwargs))
_gdi_.AutoBufferedPaintDC_swigregister(AutoBufferedPaintDC)
def AutoBufferedPaintDCFactory(*args, **kwargs):
@ -4779,10 +4787,10 @@ def AutoBufferedPaintDCFactory(*args, **kwargs):
AutoBufferedPaintDCFactory(Window window) -> DC
Checks if the window is natively double buffered and will return a
`wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise. The
advantage of this function over `wx.AutoBufferedPaintDC` is that this
function will check if the the specified window supports has
double-buffering enabled rather than just going by platform defaults.
`wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise. The advantage of
this function over `wx.AutoBufferedPaintDC` is that this function will check
if the the specified window has double-buffering enabled rather than just
going by platform defaults.
"""
return _gdi_.AutoBufferedPaintDCFactory(*args, **kwargs)
#---------------------------------------------------------------------------

899
wxPython/src/msw/_gdi_wrap.cpp
View File

File diff suppressed because one or more lines are too long

4
wxPython/src/msw/_misc.py
View File

@ -6631,8 +6631,8 @@ def AboutBox(*args, **kwargs):
This function shows the standard about dialog containing the
information specified in ``info``. If the current platform has a
native about dialog which is capable of showing all the fields in
``info``, the native dialog is used, otherwise the function falls back
to the generic wxWidgets version of the dialog.
`wx.AboutDialogInfo`, the native dialog is used, otherwise the
function falls back to the generic wxWidgets version of the dialog.
"""
return _misc_.AboutBox(*args, **kwargs)