// Purpose: interface of wxDC
// Author: wxWidgets team
// RCS-ID: $Id$
-// Licence: wxWindows license
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
wxMM_POINTS
};
+/**
+ Simple collection of various font metrics.
+
+ This object is returned by wxDC::GetFontMetrics().
+
+ @since 2.9.2
+
+ @library{wxcore}
+ @category{dc,gdi}
+ */
+struct wxFontMetrics
+{
+ /// Constructor initializes all fields to 0.
+ wxFontMetrics();
+
+ int height, ///< Total character height.
+ ascent, ///< Part of the height above the baseline.
+ descent, ///< Part of the height below the baseline.
+ internalLeading, ///< Intra-line spacing.
+ externalLeading, ///< Inter-line spacing.
+ averageWidth; ///< Average font width, a.k.a. "x-width".
+};
/**
wxWidgets offers an alternative drawing API based on the modern drawing
backends GDI+, CoreGraphics and Cairo. See wxGraphicsContext, wxGraphicsRenderer
and related classes. There is also a wxGCDC linking the APIs by offering
- the wxDC API ontop of a wxGraphicsContext.
+ the wxDC API on top of a wxGraphicsContext.
wxDC is an abstract base class and cannot be created directly.
Use wxPaintDC, wxClientDC, wxWindowDC, wxScreenDC, wxMemoryDC or
a device unit is a @e pixel. For a printer, the device unit is defined by the
resolution of the printer (usually given in @c DPI: dot-per-inch).
- All wxDC functions use instead @b logical units, unless where explicitely
+ All wxDC functions use instead @b logical units, unless where explicitly
stated. Logical units are arbitrary units mapped to device units using
the current mapping mode (see wxDC::SetMapMode).
@section dc_alpha_support Support for Transparency / Alpha Channel
- On Mac OS X colours with alpha channel are supported. Instances of wxPen
- or wxBrush that are built from wxColour use the colour's alpha values
- when stroking or filling.
+ In general wxDC methods don't support alpha transparency and the alpha
+ component of wxColour is simply ignored and you need to use wxGraphicsContext
+ for full transparency support. There are, however, a few exceptions: first,
+ under Mac OS X colours with alpha channel are supported in all the normal
+ wxDC-derived classes as they use wxGraphicsContext internally. Second,
+ under all platforms wxSVGFileDC also fully supports alpha channel. In both
+ of these cases the instances of wxPen or wxBrush that are built from
+ wxColour use the colour's alpha values when stroking or filling.
+
+
+ @section Support for Transformation Matrix
+
+ On some platforms (currently only under MSW and only on Windows NT, i.e.
+ not Windows 9x/ME, systems) wxDC has support for applying an arbitrary
+ affine transformation matrix to its coordinate system. Call
+ CanUseTransformMatrix() to check if this support is available and then call
+ SetTransformMatrix() if it is. If the transformation matrix is not
+ supported, SetTransformMatrix() always simply returns false and doesn't do
+ anything.
@library{wxcore}
/**
Draws an arc of a circle, centred on (@a xc, @a yc), with starting
- point (@a x1, @a y1) and ending at (@a x2, @a y2). The current pen is
- used for the outline and the current brush for filling the shape.
+ point (@a xStart, @a yStart) and ending at (@a xEnd, @a yEnd).
+ The current pen is used for the outline and the current brush for
+ filling the shape.
The arc is drawn in a counter-clockwise direction from the start point
to the end point.
*/
- void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
+ void DrawArc(wxCoord xStart, wxCoord yStart, wxCoord xEnd, wxCoord yEnd,
wxCoord xc, wxCoord yc);
+ /**
+ @overload
+ */
+ void DrawArc(const wxPoint& ptStart, const wxPoint& ptEnd, const wxPoint& centre);
+
/**
Draw a bitmap on the device context at the specified point. If
@a transparent is @true and the bitmap has a transparency mask, the
void DrawBitmap(const wxBitmap& bitmap, wxCoord x, wxCoord y,
bool useMask = false);
+ /**
+ @overload
+ */
+ void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt,
+ bool useMask = false);
+
/**
Draws a check mark inside the given rectangle.
*/
void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord width, wxCoord height,
double start, double end);
+ /**
+ @overload
+ */
+ void DrawEllipticArc(const wxPoint& pt, const wxSize& sz,
+ double sa, double ea);
+
/**
Draw an icon on the display (does nothing if the device context is
PostScript). This can be the simplest way of drawing bitmaps on a
*/
void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y);
+ /**
+ @overload
+ */
+ void DrawIcon(const wxIcon& icon, const wxPoint& pt);
+
/**
Draw optional bitmap and the text into the given rectangle and aligns
it as specified by alignment parameter; it also will emphasize the
character with the given index if it is != -1 and return the bounding
rectangle if required.
*/
- void DrawLabel(const wxString& text, const wxBitmap& image,
+ void DrawLabel(const wxString& text, const wxBitmap& bitmap,
const wxRect& rect,
int alignment = wxALIGN_LEFT | wxALIGN_TOP,
int indexAccel = -1, wxRect* rectBounding = NULL);
*/
void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
+ /**
+ @overload
+ */
+ void DrawLine(const wxPoint& pt1, const wxPoint& pt2);
+
/**
Draws lines using an array of points of size @a n adding the optional
offset coordinate. The current pen is used for drawing the lines.
- @beginWxPythonOnly
- The wxPython version of this method accepts a Python list of wxPoint
- objects.
- @endWxPythonOnly
+ @beginWxPerlOnly
+ Not supported by wxPerl.
+ @endWxPerlOnly
*/
void DrawLines(int n, wxPoint points[], wxCoord xoffset = 0,
wxCoord yoffset = 0);
coordinate. The programmer is responsible for deleting the list of
points.
- @beginWxPythonOnly
- The wxPython version of this method accepts a Python list of wxPoint
- objects.
- @endWxPythonOnly
+ @beginWxPerlOnly
+ The wxPerl version of this method accepts
+ as its first parameter a reference to an array
+ of wxPoint objects.
+ @endWxPerlOnly
*/
void DrawLines(const wxPointList* points,
wxCoord xoffset = 0, wxCoord yoffset = 0);
*/
void DrawPoint(wxCoord x, wxCoord y);
+ /**
+ @overload
+ */
+ void DrawPoint(const wxPoint& pt);
+
/**
Draws a filled polygon using an array of points of size @a n, adding
the optional offset coordinate. The first and last points are
The current pen is used for drawing the outline, and the current brush
for filling the shape. Using a transparent brush suppresses filling.
+
+ @beginWxPerlOnly
+ Not supported by wxPerl.
+ @endWxPerlOnly
*/
void DrawPolygon(int n, wxPoint points[], wxCoord xoffset = 0,
wxCoord yoffset = 0,
The programmer is responsible for deleting the list of points.
- @beginWxPythonOnly
- The wxPython version of this method accepts a Python list of wxPoint
- objects.
- @endWxPythonOnly
+ @beginWxPerlOnly
+ The wxPerl version of this method accepts
+ as its first parameter a reference to an array
+ of wxPoint objects.
+ @endWxPerlOnly
*/
void DrawPolygon(const wxPointList* points,
wxCoord xoffset = 0, wxCoord yoffset = 0,
call to DrawPolyPolygon() must be closed. Unlike polygons created by
the DrawPolygon() member function, the polygons created by this
method are not closed automatically.
-
- @beginWxPythonOnly
- Not implemented yet.
- @endWxPythonOnly
*/
void DrawPolyPolygon(int n, int count[], wxPoint points[],
wxCoord xoffset = 0, wxCoord yoffset = 0,
*/
void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
+ /**
+ @overload
+ */
+ void DrawRectangle(const wxPoint& pt, const wxSize& sz);
+
+ /**
+ @overload
+ */
+ void DrawRectangle(const wxRect& rect);
+
/**
Draws the text rotated by @a angle degrees
(positive angles are counterclockwise; the full angle is 360 degrees).
void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y,
double angle);
+ /**
+ @overload
+ */
+ void DrawRotatedText(const wxString& text, const wxPoint& point,
+ double angle);
+
/**
Draws a rectangle with the given top left corner, and with the given
size. The corners are quarter-circles using the given radius. The
void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width,
wxCoord height, double radius);
+ /**
+ @overload
+ */
+ void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz,
+ double radius);
+
+ /**
+ @overload
+ */
+ void DrawRoundedRectangle(const wxRect& rect, double radius);
+
/**
Draws a spline between all given points using the current pen.
- @beginWxPythonOnly
- The wxPython version of this method accepts a Python list of wxPoint
- objects.
- @endWxPythonOnly
+ @beginWxPerlOnly
+ Not supported by wxPerl.
+ @endWxPerlOnly
*/
void DrawSpline(int n, wxPoint points[]);
/**
@overload
+
+
+ @beginWxPerlOnly
+ The wxPerl version of this method accepts
+ as its first parameter a reference to an array
+ of wxPoint objects.
+ @endWxPerlOnly
*/
void DrawSpline(const wxPointList* points);
/**
@overload
+
+
+ @beginWxPerlOnly
+ Not supported by wxPerl.
+ @endWxPerlOnly
*/
void DrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
wxCoord x3, wxCoord y3);
The coordinates refer to the top-left corner of the rectangle bounding
the string. See GetTextExtent() for how to get the dimensions of a text
- string, which can be used to position the text more precisely.
+ string, which can be used to position the text more precisely and
+ DrawLabel() if you need to align the string differently.
+
+ Starting from wxWidgets 2.9.2 @a text parameter can be a multi-line
+ string, i.e. contain new line characters, and will be rendered
+ correctly.
@note The current @ref GetLogicalFunction() "logical function" is
ignored by this function.
*/
void DrawText(const wxString& text, wxCoord x, wxCoord y);
+ /**
+ @overload
+ */
+ void DrawText(const wxString& text, const wxPoint& pt);
+
/**
Fill the area specified by rect with a radial gradient, starting from
@a initialColour at the centre of the circle and fading to
@note The present implementation for non-Windows platforms may fail to
find colour borders if the pixels do not match the colour
exactly. However the function will still return @true.
+
+ @note This method shouldn't be used with wxPaintDC under non-Windows
+ platforms as it uses GetPixel() internally and this may give
+ wrong results, notably in wxGTK. If you need to flood fill
+ wxPaintDC, create a temporary wxMemoryDC, flood fill it and then
+ blit it to, or draw as a bitmap on, wxPaintDC. See the example of
+ doing this in the drawing sample and wxBufferedPaintDC class.
*/
bool FloodFill(wxCoord x, wxCoord y, const wxColour& colour,
wxFloodFillStyle style = wxFLOOD_SURFACE);
+ /**
+ @overload
+ */
+ bool FloodFill(const wxPoint& pt, const wxColour& col,
+ wxFloodFillStyle style = wxFLOOD_SURFACE);
+
/**
Displays a cross hair using the current pen. This is a vertical and
horizontal line the height and width of the window, centred on the
*/
void CrossHair(wxCoord x, wxCoord y);
+ /**
+ @overload
+ */
+ void CrossHair(const wxPoint& pt);
+
//@}
/**
Gets the rectangle surrounding the current clipping region.
-
- @beginWxPythonOnly
- No arguments are required and the four values defining the rectangle
- are returned as a tuple.
- @endWxPythonOnly
*/
void GetClippingBox(wxCoord *x, wxCoord *y, wxCoord *width, wxCoord *height) const;
*/
wxCoord GetCharWidth() const;
+ /**
+ Returns the various font characteristics.
+
+ This method allows to retrieve some of the font characteristics not
+ returned by GetTextExtent(), notably internal leading and average
+ character width.
+
+ Currently this method returns correct results only under wxMSW, in the
+ other ports the internal leading will always be 0 and the average
+ character width will be computed as the width of the character 'x'.
+
+ @since 2.9.2
+ */
+ wxFontMetrics GetFontMetrics() const;
+
/**
Gets the dimensions of the string using the currently selected font.
@a string is the text string to measure, @e heightLine, if non @NULL,
@note This function works with both single-line and multi-line strings.
+ @beginWxPerlOnly
+ In wxPerl this method is implemented as
+ GetMultiLineTextExtent(string, font = undef) returning a
+ 3-element list (width, height, line_height)
+ @endWxPerlOnly
+
@see wxFont, SetFont(), GetPartialTextExtents(), GetTextExtent()
*/
void GetMultiLineTextExtent(const wxString& string, wxCoord* w,
@note This function works with both single-line and multi-line strings.
+ @beginWxPerlOnly
+ Not supported by wxPerl.
+ @endWxPerlOnly
+
@see wxFont, SetFont(), GetPartialTextExtents(), GetTextExtent()
*/
wxSize GetMultiLineTextExtent(const wxString& string) const;
function that is faster or more accurate than the generic
implementation then it should be used instead.
- @beginWxPythonOnly
- This method only takes the @a text parameter and returns a Python list
- of integers.
- @endWxPythonOnly
+ @beginWxPerlOnly
+ In wxPerl this method only takes the @a text parameter and
+ returns the widths as a list of integers.
+ @endWxPerlOnly
@see GetMultiLineTextExtent(), GetTextExtent()
*/
@note This function only works with single-line strings.
- @beginWxPythonOnly
- The following methods are implemented in wxPython:
- - GetTextExtent(string) - Returns a 2-tuple, (width, height).
- - GetFullTextExtent(string, font=NULL) -
- Returns a 4-tuple, (width, height, descent, externalLeading).
- @endWxPythonOnly
+ @beginWxPerlOnly
+ In wxPerl this method is implemented as GetTextExtent(string,
+ font = undef) returning a 4-element list (width, height,
+ descent, externalLeading)
+ @endWxPerlOnly
@see wxFont, SetFont(), GetPartialTextExtents(),
GetMultiLineTextExtent()
/**
@overload
+
+
+ @beginWxPerlOnly
+ Not supported by wxPerl.
+ @endWxPerlOnly
*/
wxSize GetTextExtent(const wxString& string) const;
//@{
/**
- Copy from a source DC to this DC, specifying the destination
- coordinates, size of area to copy, source DC, source coordinates,
- logical function, whether to use a bitmap mask, and mask source
- position.
+ Copy from a source DC to this DC.
+
+ With this method you can specify the destination coordinates and the
+ size of area to copy which will be the same for both the source and
+ target DCs. If you need to apply scaling while copying, use
+ StretchBlit().
+
+ Notice that source DC coordinates @a xsrc and @a ysrc are interpreted
+ using the current source DC coordinate system, i.e. the scale, origin
+ position and axis directions are taken into account when transforming
+ them to physical (pixel) coordinates.
@param xdest
Destination device context x position.
This sequence of operations ensures that the source's transparent
area need not be black, and logical functions are supported.
@n @b Note: on Windows, blitting with masks can be speeded up
- considerably by compiling wxWidgets with the wxUSE_DC_CACHE option
+ considerably by compiling wxWidgets with the wxUSE_DC_CACHEING option
enabled. You can also influence whether MaskBlt or the explicit
mask blitting code above is used, by using wxSystemOptions and
setting the @c no-maskblt option to 1.
wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord);
/**
- Copy from a source DC to this DC, specifying the destination
- coordinates, destination size, source DC, source coordinates, size of
- source area to copy, logical function, whether to use a bitmap mask,
- and mask source position.
+ Copy from a source DC to this DC possibly changing the scale.
+
+ Unlike Blit(), this method allows to specify different source and
+ destination region sizes, meaning that it can stretch or shrink it
+ while copying. The same can be achieved by changing the scale of the
+ source or target DC but calling this method is simpler and can also be
+ more efficient if the platform provides a native implementation of it.
+
+ The meaning of its other parameters is the same as with Blit(), in
+ particular all source coordinates are interpreted using the source DC
+ coordinate system, i.e. are affected by its scale, origin translation
+ and axis direction.
@param xdest
Destination device context x position.
This sequence of operations ensures that the source's transparent
area need not be black, and logical functions are supported.
@n @b Note: on Windows, blitting with masks can be speeded up
- considerably by compiling wxWidgets with the wxUSE_DC_CACHE option
+ considerably by compiling wxWidgets with the wxUSE_DC_CACHEING option
enabled. You can also influence whether MaskBlt or the explicit
mask blitting code above is used, by using wxSystemOptions and
setting the @c no-maskblt option to 1.
There is partial support for Blit() in wxPostScriptDC, under X.
- StretchBlit() is only implemented under wxMAC and wxMSW.
-
See wxMemoryDC for typical usage.
@since 2.9.0
@note Setting a pixel can be done using DrawPoint().
- @beginWxPythonOnly
- The wxColour value is returned and is not required as a parameter.
- @endWxPythonOnly
+ @note This method shouldn't be used with wxPaintDC as accessing the DC
+ while drawing can result in unexpected results, notably in wxGTK.
*/
bool GetPixel(wxCoord x, wxCoord y, wxColour* colour) const;
dc.SetUserScale(min(scaleX, scaleY),min(scaleX, scaleY));
@endcode
- @beginWxPythonOnly
- In place of a single overloaded method name, wxPython implements the
- following methods:
- - GetSize() - Returns a wxSize.
- - GetSizeWH() - Returns a 2-tuple (width, height).
- @endWxPythonOnly
+ @beginWxPerlOnly
+ In wxPerl there are two methods instead of a single overloaded
+ method:
+ - GetSize(): returns a Wx::Size object.
+ - GetSizeWH(): returns a 2-element list (width, height).
+ @endWxPerlOnly
*/
void GetSize(wxCoord* width, wxCoord* height) const;
/**
Gets the current user scale factor.
+ @beginWxPerlOnly
+ In wxPerl this method takes no arguments and return a two
+ element array (x, y).
+ @endWxPerlOnly
+
@see SetUserScale()
*/
void GetUserScale(double* x, double* y) const;
'zooming'.
*/
void SetUserScale(double xScale, double yScale);
+
+
+ /**
+ @name Transformation matrix
+
+ See the notes about the availability of these functions in the class
+ documentation.
+ */
+ //@{
+
+ /**
+ Check if the use of transformation matrix is supported by the current
+ system.
+
+ Currently this function always returns @false for non-MSW platforms and
+ may return @false for old (Windows 9x/ME) Windows systems. Normally
+ support for the transformation matrix is always available in any
+ relatively recent Windows versions.
+
+ @since 2.9.2
+ */
+ bool CanUseTransformMatrix() const;
+
+ /**
+ Set the transformation matrix.
+
+ If transformation matrix is supported on the current system, the
+ specified @a matrix will be used to transform between wxDC and physical
+ coordinates. Otherwise the function returns @false and doesn't change
+ the coordinate mapping.
+
+ @since 2.9.2
+ */
+ bool SetTransformMatrix(const wxAffineMatrix2D& matrix);
+
+ /**
+ Return the transformation matrix used by this device context.
+
+ By default the transformation matrix is the identity matrix.
+
+ @since 2.9.2
+ */
+ wxAffineMatrix2D GetTransformMatrix() const;
+
+ /**
+ Revert the transformation matrix to identity matrix.
+
+ @since 2.9.2
+ */
+ void ResetTransformMatrix();
+
+ //@}
+
+
+ /**
+ @name query capabilities
+ */
+ //@{
+
+ /**
+ Does the DC support drawing bitmaps?
+ */
+ bool CanDrawBitmap() const;
+
+ /**
+ Does the DC supoprt calculating the size required to draw text?
+ */
+ bool CanGetTextExtent() const;
+
+ //@}
+
+ /**
+ Returns a value that can be used as a handle to the native drawing
+ context, if this wxDC has something that could be thought of in that
+ way. (Not all of them do.)
+
+ For example, on Windows the return value is an HDC, on OSX it is a
+ CGContextRef and on wxGTK it will be a GdkDrawable. If the DC is a
+ wxGCDC then the return value will be the value returned from
+ wxGraphicsContext::GetNativeContext. A value of NULL is returned if
+ the DC does not have anything that fits the handle concept.
+
+ @since 2.9.5
+ */
+ void* GetHandle() const;
+
+
+ /**
+ If supported by the platform and the type of DC, fetch the contents of the DC, or a subset of it, as a bitmap.
+ */
+ wxBitmap GetAsBitmap(const wxRect *subrect = NULL) const;
+
+
+ void SetLogicalScale(double x, double y);
+ void GetLogicalScale(double *x, double *y) const;
+ void SetLogicalOrigin(wxCoord x, wxCoord y);
+ void GetLogicalOrigin(wxCoord *x, wxCoord *y) const;
+ wxPoint GetLogicalOrigin() const;
+
};
/**
@class wxDCClipper
- wxDCClipper is a small helper class for setting a clipping region on a wxDC
- and unsetting it automatically. An object of wxDCClipper class is typically
- created on the stack so that it is automatically destroyed when the object
- goes out of scope. A typical usage example:
+ wxDCClipper is a helper class for setting a clipping region on a wxDC
+ during its lifetime.
+
+ An object of wxDCClipper class is typically created on the stack so that it
+ is automatically destroyed when the object goes out of scope. A typical
+ usage example:
@code
void MyFunction(wxDC& dc)
}
@endcode
+ @note Unlike other similar classes such as wxDCFontChanger, wxDCClipper
+ currently doesn't restore the previously active clipping region when it
+ is destroyed but simply resets clipping on the associated wxDC. This
+ may be changed in the future wxWidgets versions but has to be taken
+ into account explicitly in the current one.
+
@library{wxcore}
@category{gdi}
The clipping region is automatically unset when this object is destroyed.
*/
- wxDCClipper(wxDC& dc, const wxRegion& r);
+ wxDCClipper(wxDC& dc, const wxRegion& region);
wxDCClipper(wxDC& dc, const wxRect& rect);
wxDCClipper(wxDC& dc, wxCoord x, wxCoord y, wxCoord w, wxCoord h);
//@}
projects / wxWidgets.git / blobdiff