X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ac1edf3546bcb9305c288ab5c91cb6aaa08af69a..cd72551c2b6cbf67a4a5caf0ba00ba64e41183b2:/docs/latex/wx/dc.tex

diff --git a/docs/latex/wx/dc.tex b/docs/latex/wx/dc.tex
index 1cda5c4df9..b2d9573af9 100644
--- a/docs/latex/wx/dc.tex
+++ b/docs/latex/wx/dc.tex
@@ -9,6 +9,13 @@ if the device context is used as a parameter.
 Derived types of wxDC have documentation for specific features
 only, so refer to this section for most device context information.
 
+% VZ: we should really document them instead of this lame excuse, but I don't
+%     have time for it now, when it is done please remove this
+Please note that in addition to the versions of the methods documented here,
+there are also versions which accept single {\tt wxPoint} parameter instead of
+two {\tt wxCoord} ones or {\tt wxPoint} and {\tt wxSize} instead of four of
+them.
+
 \wxheading{Derived from}
 
 \helpref{wxObject}{wxobject}
@@ -52,13 +59,13 @@ released for each drawing operation.
 
 \membersection{wxDC::Blit}\label{wxdcblit}
 
-\func{bool}{Blit}{\param{long}{ xdest}, \param{long}{ ydest}, \param{long}{ width}, \param{long}{ height},
-  \param{wxDC* }{source}, \param{long}{ xsrc}, \param{long}{ ysrc}, \param{int}{ logicalFunc = wxCOPY},
-  \param{bool }{useMask = FALSE}}
+\func{bool}{Blit}{\param{wxCoord}{ xdest}, \param{wxCoord}{ ydest}, \param{wxCoord}{ width}, \param{wxCoord}{ height},
+  \param{wxDC* }{source}, \param{wxCoord}{ xsrc}, \param{wxCoord}{ ysrc}, \param{int}{ logicalFunc = wxCOPY},
+  \param{bool }{useMask = FALSE}, \param{wxCoord}{ xsrcMask = -1}, \param{wxCoord}{ ysrcMask = -1}}
 
 Copy from a source DC to this DC, specifying the destination
-coordinates, size of area to copy, source DC, source coordinates, and
-logical function.
+coordinates, size of area to copy, source DC, source coordinates,
+logical function, whether to use a bitmap mask, and mask source position.
 
 \wxheading{Parameters}
 
@@ -79,7 +86,7 @@ logical function.
 \docparam{logicalFunc}{Logical function to use: see \helpref{wxDC::SetLogicalFunction}{wxdcsetlogicalfunction}.}
 
 \docparam{useMask}{If TRUE, Blit does a transparent blit using the mask that is associated with the bitmap
-selected into the source device context. The Windows implementation does the following:
+selected into the source device context. The Windows implementation does the following if MaskBlt cannot be used:
 
 \begin{enumerate}
 \item Creates a temporary bitmap and copies the destination area into it.
@@ -96,8 +103,21 @@ and the background colour set to WHITE.
 
 This sequence of operations ensures that the source's transparent area need not be black,
 and logical functions are supported.
+
+{\bf Note:} on Windows, blitting with masks can be speeded up considerably by compiling
+wxWindows with the wxUSE\_DC\_CACHE option enabled. You can also influence whether MaskBlt
+or the explicit mask blitting code above is used, by using \helpref{wxSystemOptions}{wxsystemoptions} and
+setting the {\bf no-maskblt} option to 1.
+
 }
 
+\docparam{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. Currently only implemented on Windows.}
+
+\docparam{ysrcMask}{Source y position on the mask. If both xsrcMask and ysrcMask are -1, xsrc and ysrc
+will be assumed for the mask source position. Currently only implemented on Windows.}
+
+
 \wxheading{Remarks}
 
 There is partial support for Blit in wxPostScriptDC, under X.
@@ -108,15 +128,65 @@ See \helpref{wxMemoryDC}{wxmemorydc} for typical usage.
 
 \helpref{wxMemoryDC}{wxmemorydc}, \helpref{wxBitmap}{wxbitmap}, \helpref{wxMask}{wxmask}
 
+\begin{comment}
+\membersection{wxDC::CacheEnabled}\label{wxdccacheenabled}
+
+\func{static bool}{CacheEnabled}{\void}
+
+On supported platforms (currently only Windows), returns TRUE
+if the DC cache is enabled. The DC cache
+can speed up the \helpref{Blit}{wxdcblit} operation when
+drawing a large number of masked bitmaps.
+
+If using the cache functions in your code, please test for the
+wxUSE\_DC\_CACHEING preprocessor symbol for portability.
+
+\wxheading{See also}
+
+\helpref{wxDC::EnableCache}{wxdcenablecache}, \helpref{wxDC::ClearCache}
+\end{comment}
+
+\membersection{wxDC::CalcBoundingBox}\label{wxdccalcboundingbox}
+
+\func{void}{CalcBoundingBox}{\param{wxCoord }{x}, \param{wxCoord }{y}}
+
+Adds the specified point to the bounding box which can be retrieved with 
+\helpref{MinX}{wxdcminx}, \helpref{MaxX}{wxdcmaxx} and 
+\helpref{MinY}{wxdcminy}, \helpref{MaxY}{wxdcmaxy} functions.
+
+\wxheading{See also}
+
+\helpref{ResetBoundingBox}{wxdcresetboundingbox}
+
 \membersection{wxDC::Clear}\label{wxdcclear}
 
 \func{void}{Clear}{\void}
 
 Clears the device context using the current background brush.
 
+\begin{comment}
+\membersection{wxDC::ClearCache}\label{wxdcclearcache}
+
+\func{static void}{ClearCache}{\void}
+
+On supported platforms (currently only Windows), clears
+the contents of the DC cache (one bitmap and two Windows device contexts). The DC cache
+can speed up the \helpref{Blit}{wxdcblit} operation when
+drawing a large number of masked bitmaps. You should
+call ClearCache at the end of length DC operations if you wish to only use
+the cache transiently; you should also call it as your application exits.
+
+If using the cache functions in your code, please test for the
+wxUSE\_DC\_CACHEING preprocessor symbol for portability.
+
+\wxheading{See also}
+
+\helpref{wxDC::EnableCache}{wxdcenablecache}, \helpref{wxDC::CacheEnabled}
+\end{comment}
+
 \membersection{wxDC::CrossHair}\label{wxdccrosshair}
 
-\func{void}{CrossHair}{\param{long}{ x}, \param{long}{ y}}
+\func{void}{CrossHair}{\param{wxCoord}{ x}, \param{wxCoord}{ y}}
 
 Displays a cross hair using the current pen. This is a vertical
 and horizontal line the height and width of the window, centred
@@ -131,35 +201,37 @@ See also \helpref{wxDC::SetClippingRegion}{wxdcsetclippingregion}.
 
 \membersection{wxDC::DeviceToLogicalX}\label{wxdcdevicetologicalx}
 
-\func{long}{DeviceToLogicalX}{\param{long}{ x}}
+\func{wxCoord}{DeviceToLogicalX}{\param{wxCoord}{ x}}
 
 Convert device X coordinate to logical coordinate, using the current
 mapping mode.
 
 \membersection{wxDC::DeviceToLogicalXRel}\label{wxdcdevicetologicalxrel}
 
-\func{long}{DeviceToLogicalXRel}{\param{long}{ x}}
+\func{wxCoord}{DeviceToLogicalXRel}{\param{wxCoord}{ x}}
 
 Convert device X coordinate to relative logical coordinate, using the current
-mapping mode. Use this function for converting a width, for example.
+mapping mode but ignoring the x axis orientation.
+Use this function for converting a width, for example.
 
 \membersection{wxDC::DeviceToLogicalY}\label{wxdcdevicetologicaly}
 
-\func{long}{DeviceToLogicalY}{\param{long}{ y}}
+\func{wxCoord}{DeviceToLogicalY}{\param{wxCoord}{ y}}
 
 Converts device Y coordinate to logical coordinate, using the current
 mapping mode.
 
 \membersection{wxDC::DeviceToLogicalYRel}\label{wxdcdevicetologicalyrel}
 
-\func{long}{DeviceToLogicalYRel}{\param{long}{ y}}
+\func{wxCoord}{DeviceToLogicalYRel}{\param{wxCoord}{ y}}
 
 Convert device Y coordinate to relative logical coordinate, using the current
-mapping mode. Use this function for converting a height, for example.
+mapping mode but ignoring the y axis orientation.
+Use this function for converting a height, for example.
 
 \membersection{wxDC::DrawArc}\label{wxdcdrawarc}
 
-\func{void}{DrawArc}{\param{long}{ x1}, \param{long}{ y1}, \param{long}{ x2}, \param{long}{ y2}, \param{double}{ xc}, \param{double}{ yc}}
+\func{void}{DrawArc}{\param{wxCoord}{ x1}, \param{wxCoord}{ y1}, \param{wxCoord}{ x2}, \param{wxCoord}{ y2}, \param{double}{ xc}, \param{double}{ yc}}
 
 Draws an arc of a circle, centred on ({\it xc, yc}), with starting point ({\it x1, y1})
 and ending at ({\it x2, y2}).   The current pen is used for the outline
@@ -169,27 +241,59 @@ The arc is drawn in an anticlockwise direction from the start point to the end p
 
 \membersection{wxDC::DrawBitmap}\label{wxdcdrawbitmap}
 
-\func{void}{DrawBitmap}{\param{const wxBitmap\&}{ bitmap}, \param{long}{ x}, \param{long}{ y}, \param{bool}{ transparent}}
+\func{void}{DrawBitmap}{\param{const wxBitmap\&}{ bitmap}, \param{wxCoord}{ x}, \param{wxCoord}{ y}, \param{bool}{ transparent}}
 
 Draw a bitmap on the device context at the specified point. If {\it transparent} is TRUE and the bitmap has
 a transparency mask, 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 also \helpref{SetTextForeground}{wxdcsettextforeground}, 
+\helpref{SetTextBackground}{wxdcsettextbackground} and \helpref{wxMemoryDC}{wxmemorydc}.
+
+\membersection{wxDC::DrawCheckMark}\label{wxdcdrawcheckmark}
+
+\func{void}{DrawCheckMark}{\param{wxCoord}{ x}, \param{wxCoord}{ y}, \param{wxCoord}{ width}, \param{wxCoord}{ height}}
+
+\func{void}{DrawCheckMark}{\param{const wxRect \&}{rect}}
+
+Draws a check mark inside the given rectangle.
+
+\membersection{wxDC::DrawCircle}\label{wxdcdrawcircle}
+
+\func{void}{DrawCircle}{\param{wxCoord}{ x}, \param{wxCoord}{ y}, \param{wxCoord}{ radius}}
+
+\func{void}{DrawCircle}{\param{const wxPoint\&}{ pt}, \param{wxCoord}{ radius}}
+
+Draws a circle with the given centre and radius.
+
+\wxheading{See also}
+
+\helpref{DrawEllipse}{wxdcdrawellipse}
+
 \membersection{wxDC::DrawEllipse}\label{wxdcdrawellipse}
 
-\func{void}{DrawEllipse}{\param{long}{ x}, \param{long}{ y}, \param{long}{ width}, \param{long}{ height}}
+\func{void}{DrawEllipse}{\param{wxCoord}{ x}, \param{wxCoord}{ y}, \param{wxCoord}{ width}, \param{wxCoord}{ height}}
+
+\func{void}{DrawEllipse}{\param{const wxPoint\&}{ pt}, \param{const wxSize\&}{ size}}
+
+\func{void}{DrawEllipse}{\param{const wxRect\&}{ rect}}
 
-Draws an ellipse contained in the rectangle with the given top left corner, and with the
-given size.  The current pen is used for the outline and the current brush for
-filling the shape.
+Draws an ellipse contained in the rectangle specified either with the given top
+left corner and the given size or directly. The current pen is used for the
+outline and the current brush for filling the shape.
+
+\wxheading{See also}
+
+\helpref{DrawCircle}{wxdcdrawcircle}
 
 \membersection{wxDC::DrawEllipticArc}\label{wxdcdrawellipticarc}
 
-\func{void}{DrawEllipticArc}{\param{long}{ x}, \param{long}{ y}, \param{long}{ width}, \param{long}{ height},
+\func{void}{DrawEllipticArc}{\param{wxCoord}{ x}, \param{wxCoord}{ y}, \param{wxCoord}{ width}, \param{wxCoord}{ height},
  \param{double}{ start}, \param{double}{ end}}
 
 Draws an arc of an ellipse. The current pen is used for drawing the arc and
-the current brush is used for drawing the pie. This function is currently only available for
-X window and PostScript device contexts.
+the current brush is used for drawing the pie.
 
 {\it x} and {\it y} specify the x and y coordinates of the upper-left corner of the rectangle that contains
 the ellipse.
@@ -205,23 +309,23 @@ complete ellipse will be drawn.
 
 \membersection{wxDC::DrawIcon}\label{wxdcdrawicon}
 
-\func{void}{DrawIcon}{\param{const wxIcon\&}{ icon}, \param{long}{ x}, \param{long}{ y}}
+\func{void}{DrawIcon}{\param{const wxIcon\&}{ icon}, \param{wxCoord}{ x}, \param{wxCoord}{ y}}
 
 Draw an icon on the display (does nothing if the device context is PostScript).
 This can be the simplest way of drawing bitmaps on a window.
 
 \membersection{wxDC::DrawLine}\label{wxdcdrawline}
 
-\func{void}{DrawLine}{\param{long}{ x1}, \param{long}{ y1}, \param{long}{ x2}, \param{long}{ y2}}
+\func{void}{DrawLine}{\param{wxCoord}{ x1}, \param{wxCoord}{ y1}, \param{wxCoord}{ x2}, \param{wxCoord}{ y2}}
 
 Draws a line from the first point to the second. The current pen is used
 for drawing the line.
 
 \membersection{wxDC::DrawLines}\label{wxdcdrawlines}
 
-\func{void}{DrawLines}{\param{int}{ n}, \param{wxPoint}{ points[]}, \param{long}{ xoffset = 0}, \param{long}{ yoffset = 0}}
+\func{void}{DrawLines}{\param{int}{ n}, \param{wxPoint}{ points[]}, \param{wxCoord}{ xoffset = 0}, \param{wxCoord}{ yoffset = 0}}
 
-\func{void}{DrawLines}{\param{wxList *}{points}, \param{long}{ xoffset = 0}, \param{long}{ yoffset = 0}}
+\func{void}{DrawLines}{\param{wxList *}{points}, \param{wxCoord}{ xoffset = 0}, \param{wxCoord}{ yoffset = 0}}
 
 Draws lines using an array of {\it points} of size {\it n}, or list of
 pointers to points, adding the optional offset coordinate. The current
@@ -231,12 +335,16 @@ deleting the list of points.
 \pythonnote{The wxPython version of this method accepts a Python list
 of wxPoint objects.}
 
+\perlnote{The wxPerl version of this method accepts 
+  as its first parameter a reference to an array
+  of wxPoint objects.}
+
 \membersection{wxDC::DrawPolygon}\label{wxdcdrawpolygon}
 
-\func{void}{DrawPolygon}{\param{int}{ n}, \param{wxPoint}{ points[]}, \param{long}{ xoffset = 0}, \param{long}{ yoffset = 0},\\
+\func{void}{DrawPolygon}{\param{int}{ n}, \param{wxPoint}{ points[]}, \param{wxCoord}{ xoffset = 0}, \param{wxCoord}{ yoffset = 0},\\
   \param{int }{fill\_style = wxODDEVEN\_RULE}}
 
-\func{void}{DrawPolygon}{\param{wxList *}{points}, \param{long}{ xoffset = 0}, \param{long}{ yoffset = 0},\\
+\func{void}{DrawPolygon}{\param{wxList *}{points}, \param{wxCoord}{ xoffset = 0}, \param{wxCoord}{ yoffset = 0},\\
   \param{int }{fill\_style = wxODDEVEN\_RULE}}
 
 Draws a filled polygon using an array of {\it points} of size {\it n},
@@ -254,23 +362,42 @@ Note that wxWindows automatically closes the first and last points.
 \pythonnote{The wxPython version of this method accepts a Python list
 of wxPoint objects.}
 
+\perlnote{The wxPerl version of this method accepts 
+  as its first parameter a reference to an array
+  of wxPoint objects.}
+
 \membersection{wxDC::DrawPoint}\label{wxdcdrawpoint}
 
-\func{void}{DrawPoint}{\param{long}{ x}, \param{long}{ y}}
+\func{void}{DrawPoint}{\param{wxCoord}{ x}, \param{wxCoord}{ y}}
 
 Draws a point using the current pen.
 
 \membersection{wxDC::DrawRectangle}\label{wxdcdrawrectangle}
 
-\func{void}{DrawRectangle}{\param{long}{ x}, \param{long}{ y}, \param{long}{ width}, \param{long}{ height}}
+\func{void}{DrawRectangle}{\param{wxCoord}{ x}, \param{wxCoord}{ y}, \param{wxCoord}{ width}, \param{wxCoord}{ height}}
 
 Draws a rectangle with the given top left corner, and with the given
 size.  The current pen is used for the outline and the current brush
 for filling the shape.
 
+\membersection{wxDC::DrawRotatedText}\label{wxdcdrawrotatedtext}
+
+\func{void}{DrawRotatedText}{\param{const wxString\& }{text}, \param{wxCoord}{ x}, \param{wxCoord}{ y}, \param{double}{ angle}}
+
+Draws the text rotated by {\it angle} degrees.
+
+{\bf NB:} Under Win9x only TrueType fonts can be drawn by this function. In
+particular, a font different from {\tt wxNORMAL\_FONT} should be used as the
+latter is not a TrueType font. {\tt wxSWISS\_FONT} is an example of a font
+which is.
+
+\wxheading{See also}
+
+\helpref{DrawText}{wxdcdrawtext}
+
 \membersection{wxDC::DrawRoundedRectangle}\label{wxdcdrawroundedrectangle}
 
-\func{void}{DrawRoundedRectangle}{\param{long}{ x}, \param{long}{ y}, \param{long}{ width}, \param{long}{ height}, \param{double}{ radius = 20}}
+\func{void}{DrawRoundedRectangle}{\param{wxCoord}{ x}, \param{wxCoord}{ y}, \param{wxCoord}{ width}, \param{wxCoord}{ height}, \param{double}{ radius = 20}}
 
 Draws a rectangle with the given top left corner, and with the given
 size.  The corners are quarter-circles using the given radius. The
@@ -294,16 +421,19 @@ pen.  Doesn't delete the wxList and contents. The spline is drawn
 using a series of lines, using an algorithm taken from the X drawing
 program `XFIG'.
 
-\func{void}{DrawSpline}{\param{long}{ x1}, \param{long}{ y1}, \param{long}{ x2}, \param{long}{ y2}, \param{long}{ x3}, \param{long}{ y3}}
+\func{void}{DrawSpline}{\param{wxCoord}{ x1}, \param{wxCoord}{ y1}, \param{wxCoord}{ x2}, \param{wxCoord}{ y2}, \param{wxCoord}{ x3}, \param{wxCoord}{ y3}}
 
 Draws a three-point spline using the current pen.
 
 \pythonnote{The wxPython version of this method accepts a Python list
 of wxPoint objects.}
 
+\perlnote{The wxPerl version of this method accepts a reference to an array
+  of wxPoint objects.}
+
 \membersection{wxDC::DrawText}\label{wxdcdrawtext}
 
-\func{void}{DrawText}{\param{const wxString\& }{text}, \param{long}{ x}, \param{long}{ y}}
+\func{void}{DrawText}{\param{const wxString\& }{text}, \param{wxCoord}{ x}, \param{wxCoord}{ y}}
 
 Draws a text string at the specified point, using the current text font,
 and the current text foreground and background colours.
@@ -313,6 +443,28 @@ the string. See \helpref{wxDC::GetTextExtent}{wxdcgettextextent} for how
 to get the dimensions of a text string, which can be used to position the
 text more precisely.
 
+{\bf NB:} under wxGTK the current 
+\helpref{logical function}{wxdcgetlogicalfunction} is used by this function
+but it is ignored by wxMSW. Thus, you should avoid using logical functions
+with this function in portable programs.
+
+\begin{comment}
+\membersection{wxDC::EnableCache}\label{wxdcenablecache}
+
+\func{static void}{EnableCache}{\param{bool}{ enableCache}}
+
+On supported platforms (currently only Windows), enables the DC cache
+which can speed up the \helpref{Blit}{wxdcblit} operation when
+drawing a large number of masked bitmaps.
+
+If using the cache functions in your code, please test for the
+wxUSE\_DC\_CACHEING preprocessor symbol for portability.
+
+\wxheading{See also}
+
+\helpref{wxDC::CacheEnabled}{wxdccacheenabled}, \helpref{wxDC::ClearCache}
+\end{comment}
+
 \membersection{wxDC::EndDoc}\label{wxdcenddoc}
 
 \func{void}{EndDoc}{\void}
@@ -335,10 +487,10 @@ Ends a document page (only relevant when outputting to a printer).
 
 \membersection{wxDC::FloodFill}\label{wxdcfloodfill}
 
-\func{void}{FloodFill}{\param{long}{ x}, \param{long}{ y}, \param{wxColour *}{colour}, \param{int}{ style=wxFLOOD\_SURFACE}}
+\func{void}{FloodFill}{\param{wxCoord}{ x}, \param{wxCoord}{ y}, \param{const wxColour\&}{ colour}, \param{int}{ style=wxFLOOD\_SURFACE}}
 
-Flood fills the device context starting from the given point, in the given colour,
-and using a style:
+Flood fills the device context starting from the given point, using
+the {\it current brush colour}, and using a style:
 
 \begin{itemize}\itemsep=0pt
 \item wxFLOOD\_SURFACE: the flooding occurs until a colour other than the given colour is encountered.
@@ -351,39 +503,58 @@ and using a style:
 
 \func{wxBrush\&}{GetBackground}{\void}
 
+\constfunc{const wxBrush\&}{GetBackground}{\void}
+
 Gets the brush used for painting the background (see \helpref{wxDC::SetBackground}{wxdcsetbackground}).
 
+\membersection{wxDC::GetBackgroundMode}\label{wxdcgetbackgroundmode}
+
+\constfunc{int}{GetBackgroundMode}{\void}
+
+Returns the current background mode: {\tt wxSOLID} or {\tt wxTRANSPARENT}.
+
+\wxheading{See also}
+
+\helpref{SetBackgroundMode}{wxdcsetbackgroundmode}
+
 \membersection{wxDC::GetBrush}\label{wxdcgetbrush}
 
 \func{wxBrush\&}{GetBrush}{\void}
 
+\constfunc{const wxBrush\&}{GetBrush}{\void}
+
 Gets the current brush (see \helpref{wxDC::SetBrush}{wxdcsetbrush}).
 
 \membersection{wxDC::GetCharHeight}\label{wxdcgetcharheight}
 
-\func{long}{GetCharHeight}{\void}
+\func{wxCoord}{GetCharHeight}{\void}
 
 Gets the character height of the currently set font.
 
 \membersection{wxDC::GetCharWidth}\label{wxdcgetcharwidth}
 
-\func{long}{GetCharWidth}{\void}
+\func{wxCoord}{GetCharWidth}{\void}
 
 Gets the average character width of the currently set font.
 
 \membersection{wxDC::GetClippingBox}\label{wxdcgetclippingbox}
 
-\func{void}{GetClippingBox}{\param{long}{ *x}, \param{long}{ *y}, \param{long}{ *width}, \param{long}{ *height}}
+\func{void}{GetClippingBox}{\param{wxCoord}{ *x}, \param{wxCoord}{ *y}, \param{wxCoord}{ *width}, \param{wxCoord}{ *height}}
 
 Gets the rectangle surrounding the current clipping region.
 
 \pythonnote{No arguments are required and the four values defining the
 rectangle are returned as a tuple.}
 
+\perlnote{This method takes no arguments and returns a four element list
+{\tt ( x, y, width, height )}}
+
 \membersection{wxDC::GetFont}\label{wxdcgetfont}
 
 \func{wxFont\&}{GetFont}{\void}
 
+\constfunc{const wxFont\&}{GetFont}{\void}
+
 Gets the current font (see \helpref{wxDC::SetFont}{wxdcsetfont}).
 
 \membersection{wxDC::GetLogicalFunction}\label{wxdcgetlogicalfunction}
@@ -409,18 +580,26 @@ See \helpref{wxDC::SetOptimization}{wxsetoptimization} for details.
 
 \func{wxPen\&}{GetPen}{\void}
 
+\constfunc{const wxPen\&}{GetPen}{\void}
+
 Gets the current pen (see \helpref{wxDC::SetPen}{wxdcsetpen}).
 
 \membersection{wxDC::GetPixel}\label{wxdcgetpixel}
 
-\func{bool}{GetPixel}{\param{long}{ x}, \param{long}{ y}, \param{wxColour *}{colour}}
+\func{bool}{GetPixel}{\param{wxCoord}{ x}, \param{wxCoord}{ y}, \param{wxColour *}{colour}}
 
 Sets {\it colour} to the colour at the specified location. Windows only; an X implementation
 is being worked on. Not available for wxPostScriptDC or wxMetafileDC.
 
+\pythonnote{For wxPython the wxColour value is returned and is not
+required as a parameter.}
+
+\perlnote{This method only takes the parameters {\tt x} and {\tt y} and returns
+a Wx::Colour value}
+
 \membersection{wxDC::GetSize}\label{wxdcgetsize}
 
-\func{void}{GetSize}{\param{long *}{width}, \param{long *}{height}}
+\func{void}{GetSize}{\param{wxCoord *}{width}, \param{wxCoord *}{height}}
 
 For a PostScript device context, this gets the maximum size of graphics
 drawn so far on the device context.
@@ -433,7 +612,7 @@ application, the following code will scale the graphic to fit on the
 printer page:
 
 \begin{verbatim}
-  long w, h;
+  wxCoord w, h;
   dc.GetSize(&w, &h);
   double scaleX=(double)(maxX/w);
   double scaleY=(double)(maxY/h);
@@ -443,21 +622,31 @@ printer page:
 \pythonnote{In place of a single overloaded method name, wxPython
 implements the following methods:\par
 \indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{GetSize()}}{Returns a wxSize}
-\twocolitem{\bf{GetSizeTuple()}}{Returns a 2-tuple (width, height)}
+\twocolitem{{\bf GetSize()}}{Returns a wxSize}
+\twocolitem{{\bf GetSizeTuple()}}{Returns a 2-tuple (width, height)}
 \end{twocollist}}
 }
 
+\perlnote{In place of a single overloaded method, wxPerl uses:\par
+\indented{2cm}{\begin{twocollist}
+\twocolitem{{\bf GetSize()}}{Returns a Wx::Size}
+\twocolitem{{\bf GetSizeWH()}}{Returns a 2-element list
+  {\tt ( width, height )}}
+\end{twocollist}
+}}
+
 \membersection{wxDC::GetTextBackground}\label{wxdcgettextbackground}
 
 \func{wxColour\&}{GetTextBackground}{\void}
 
+\constfunc{const wxColour\&}{GetTextBackground}{\void}
+
 Gets the current text background colour (see \helpref{wxDC::SetTextBackground}{wxdcsettextbackground}).
 
 \membersection{wxDC::GetTextExtent}\label{wxdcgettextextent}
 
-\func{void}{GetTextExtent}{\param{const wxString\& }{string}, \param{long *}{w}, \param{long *}{h},\\
-  \param{long *}{descent = NULL}, \param{long *}{externalLeading = NULL}, \param{wxFont *}{font = NULL}}
+\func{void}{GetTextExtent}{\param{const wxString\& }{string}, \param{wxCoord *}{w}, \param{wxCoord *}{h},\\
+  \param{wxCoord *}{descent = NULL}, \param{wxCoord *}{externalLeading = NULL}, \param{wxFont *}{font = NULL}}
 
 Gets the dimensions of the string using the currently selected font.
 \rtfsp{\it string} is the text string to measure, {\it w} and {\it h} are
@@ -475,67 +664,86 @@ See also \helpref{wxFont}{wxfont}, \helpref{wxDC::SetFont}{wxdcsetfont}.
 
 \pythonnote{The following methods are implemented in wxPython:\par
 \indented{2cm}{\begin{twocollist}
-\twocolitem{\bf{GetTextExtent(string)}}{Returns a 2-tuple, (width, height)}
-\twocolitem{\bf{GetFullTextExtent(string, font=NULL)}}{Returns a
+\twocolitem{{\bf GetTextExtent(string)}}{Returns a 2-tuple, (width, height)}
+\twocolitem{{\bf GetFullTextExtent(string, font=NULL)}}{Returns a
 4-tuple, (width, height, descent, externalLeading) }
 \end{twocollist}}
 }
 
+\perlnote{In wxPerl this method is implemented as 
+  {\bf GetTextExtent( string, font = undef )} returning a four element
+  array {\tt ( width, height, descent, externalLeading )}
+}
+
 \membersection{wxDC::GetTextForeground}\label{wxdcgettextforeground}
 
 \func{wxColour\&}{GetTextForeground}{\void}
 
+\constfunc{const wxColour\&}{GetTextForeground}{\void}
+
 Gets the current text foreground colour (see \helpref{wxDC::SetTextForeground}{wxdcsettextforeground}).
 
+
+\membersection{wxDC::GetUserScale}\label{wxdcgetuserscale}
+
+\func{void}{GetUserScale}{\param{double}{ *x}, \param{double}{ *y}}
+
+Gets the current user scale factor (set by \helpref{SetUserScale}{wxdcsetuserscale}).
+
+\perlnote{In wxPerl this method takes no arguments and returna a two element
+ array {\tt ( x, y )}}
+
 \membersection{wxDC::LogicalToDeviceX}\label{wxdclogicaltodevicex}
 
-\func{long}{LogicalToDeviceX}{\param{long}{ x}}
+\func{wxCoord}{LogicalToDeviceX}{\param{wxCoord}{ x}}
 
 Converts logical X coordinate to device coordinate, using the current
 mapping mode.
 
 \membersection{wxDC::LogicalToDeviceXRel}\label{wxdclogicaltodevicexrel}
 
-\func{long}{LogicalToDeviceXRel}{\param{long}{ x}}
+\func{wxCoord}{LogicalToDeviceXRel}{\param{wxCoord}{ x}}
 
 Converts logical X coordinate to relative device coordinate, using the current
-mapping mode. Use this for converting a width, for example.
+mapping mode but ignoring the x axis orientation.
+Use this for converting a width, for example.
 
 \membersection{wxDC::LogicalToDeviceY}\label{wxdclogicaltodevicey}
 
-\func{long}{LogicalToDeviceY}{\param{long}{ y}}
+\func{wxCoord}{LogicalToDeviceY}{\param{wxCoord}{ y}}
 
 Converts logical Y coordinate to device coordinate, using the current
 mapping mode.
 
 \membersection{wxDC::LogicalToDeviceYRel}\label{wxdclogicaltodeviceyrel}
 
-\func{long}{LogicalToDeviceYRel}{\param{long}{ y}}
+\func{wxCoord}{LogicalToDeviceYRel}{\param{wxCoord}{ y}}
 
 Converts logical Y coordinate to relative device coordinate, using the current
-mapping mode. Use this for converting a height, for example.
+mapping mode but ignoring the y axis orientation.
+Use this for converting a height, for example.
 
 \membersection{wxDC::MaxX}\label{wxdcmaxx}
 
-\func{long}{MaxX}{\void}
+\func{wxCoord}{MaxX}{\void}
 
 Gets the maximum horizontal extent used in drawing commands so far.
 
 \membersection{wxDC::MaxY}\label{wxdcmaxy}
 
-\func{long}{MaxY}{\void}
+\func{wxCoord}{MaxY}{\void}
 
 Gets the maximum vertical extent used in drawing commands so far.
 
 \membersection{wxDC::MinX}\label{wxdcminx}
 
-\func{long}{MinX}{\void}
+\func{wxCoord}{MinX}{\void}
 
 Gets the minimum horizontal extent used in drawing commands so far.
 
 \membersection{wxDC::MinY}\label{wxdcminy}
 
-\func{long}{MinY}{\void}
+\func{wxCoord}{MinY}{\void}
 
 Gets the minimum vertical extent used in drawing commands so far.
 
@@ -545,9 +753,37 @@ Gets the minimum vertical extent used in drawing commands so far.
 
 Returns TRUE if the DC is ok to use.
 
+\membersection{wxDC::ResetBoundingBox}\label{wxdcresetboundingbox}
+
+\func{void}{ResetBoundingBox}{\void}
+
+Resets the bounding box: after a call to this function, the bounding box
+doesn't contain anything.
+
+\wxheading{See also}
+
+\helpref{CalcBoundingBox}{wxdccalcboundingbox}
+
+\membersection{wxDC::SetAxisOrientation}\label{wxdcsetaxisorientation}
+
+\func{void}{SetAxisOrientation}{\param{bool}{ xLeftRight},
+                                \param{bool}{ yBottomUp}}
+
+Sets the x and y axis orientation (i.e., the direction from lowest to
+highest values on the axis). The default orientation is the natural
+orientation, e.g. x axis from left to right and y axis from bottom up.
+
+\wxheading{Parameters}
+
+\docparam{xLeftRight}{True to set the x axis orientation to the natural
+left to right orientation, false to invert it.}
+
+\docparam{yBottomUp}{True to set the y axis orientation to the natural
+bottom up orientation, false to invert it.}
+
 \membersection{wxDC::SetDeviceOrigin}\label{wxdcsetdeviceorigin}
 
-\func{void}{SetDeviceOrigin}{\param{long}{ x}, \param{long}{ y}}
+\func{void}{SetDeviceOrigin}{\param{wxCoord}{ x}, \param{wxCoord}{ y}}
 
 Sets the device origin (i.e., the origin in pixels after scaling has been
 applied).
@@ -570,13 +806,23 @@ whether text will be drawn with a background colour or not.
 
 \membersection{wxDC::SetClippingRegion}\label{wxdcsetclippingregion}
 
-\func{void}{SetClippingRegion}{\param{long}{ x}, \param{long}{ y}, \param{long}{ width}, \param{long}{ height}}
+\func{void}{SetClippingRegion}{\param{wxCoord}{ x}, \param{wxCoord}{ y}, \param{wxCoord}{ width}, \param{wxCoord}{ height}}
+
+\func{void}{SetClippingRegion}{\param{const wxPoint\& }{pt}, \param{const wxSize\& }{sz}}
+
+\func{void}{SetClippingRegion}{\param{const wxRect\&}{ rect}}
 
 \func{void}{SetClippingRegion}{\param{const wxRegion\&}{ region}}
 
-Sets the clipping region for the DC. The clipping region is an area
-to which drawing is restricted. Possible uses for the clipping region are for clipping text
-or for speeding up window redraws when only a known area of the screen is damaged.
+Sets the clipping region for this device context to the intersection of the
+given region described by the parameters of this method and the previously set
+clipping region. You should call 
+\helpref{DestroyClippingRegion}{wxdcdestroyclippingregion} if you want to set
+the clipping region exactly to the region specified.
+
+The clipping region is an area to which drawing is restricted. Possible uses
+for the clipping region are for clipping text or for speeding up window redraws
+when only a known area of the screen is damaged.
 
 \wxheading{See also}
 
@@ -605,15 +851,15 @@ be destroyed safely.
 
 See also \helpref{wxBrush}{wxbrush}.
 
+See also \helpref{wxMemoryDC}{wxmemorydc} for the interpretation of colours
+when drawing into a monochrome bitmap.
+
 \membersection{wxDC::SetFont}\label{wxdcsetfont}
 
 \func{void}{SetFont}{\param{const wxFont\& }{font}}
 
-Sets the current font for the DC.
-
-If the argument is wxNullFont, the current font is selected out of the device
-context, and the original font restored, allowing the current font to
-be destroyed safely.
+Sets the current font for the DC. It must be a valid font, in particular you
+should not pass {\tt wxNullFont} to this method.
 
 See also \helpref{wxFont}{wxfont}.
 
@@ -707,6 +953,9 @@ Sets the current pen for the DC.
 If the argument is wxNullPen, the current pen is selected out of the device
 context, and the original pen restored.
 
+See also \helpref{wxMemoryDC}{wxmemorydc} for the interpretation of colours
+when drawing into a monochrome bitmap.
+
 \membersection{wxDC::SetTextBackground}\label{wxdcsettextbackground}
 
 \func{void}{SetTextBackground}{\param{const wxColour\& }{colour}}
@@ -719,6 +968,9 @@ Sets the current text background colour for the DC.
 
 Sets the current text foreground colour for the DC.
 
+See also \helpref{wxMemoryDC}{wxmemorydc} for the interpretation of colours
+when drawing into a monochrome bitmap.
+
 \membersection{wxDC::SetUserScale}\label{wxdcsetuserscale}
 
 \func{void}{SetUserScale}{\param{double}{ xScale}, \param{double}{ yScale}}
@@ -739,3 +991,38 @@ Message is a message to show whilst printing.
 
 Starts a document page (only relevant when outputting to a printer).
 
+\section{\class{wxDCClipper}}\label{wxdcclipper}
+
+This is a small helper class which sets the specified to its constructor
+clipping region and then automatically destroyes it in its destructor. Using
+it ensures that unwanted clipping region is not left set on the DC.
+
+\wxheading{Derived from}
+
+No base class
+
+\wxheading{Include files}
+
+<wx/dc.h>
+
+\wxheading{See also}
+
+\helpref{wxDC}{wxdc}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDCClipper::wxDCClipper}
+
+\func{}{wxDCClipper}{\param{wxDC\& }{dc}, \param{wxCoord }{x},\param{wxCoord }{y},\param{wxCoord }{w},\param{wxCoord }{h},}
+
+\func{}{wxDCClipper}{\param{wxDC\& }{dc}, \param{const wxRect\&}{ rect}}
+
+Constructor: sets the the clipping region for the given device context to the
+specified rectangle.
+
+\membersection{wxDCClipper::\destruct{wxDCClipper}}
+
+\func{}{\destruct{wxDCClipper}}{\void}
+
+Destructor: destroyes the clipping region set in the constructor.
+