`CDC` Class

مقالة
08/03/2021

Defines a class of device-context objects.

Syntax

class CDC : public CObject

Members

Public Constructors

Name	Description
`CDC::CDC`	Constructs a `CDC` object.

Public Methods

Name	Description
`CDC::AbortDoc`	Terminates the current print job, erasing everything the application has written to the device since the last call of the `StartDoc` member function.
`CDC::AbortPath`	Closes and discards any paths in the device context.
`CDC::AddMetaFileComment`	Copies the comment from a buffer into a specified enhanced-format metafile.
`CDC::AlphaBlend`	Displays bitmaps that have transparent or semitransparent pixels.
`CDC::AngleArc`	Draws a line segment and an arc, and moves the current position to the ending point of the arc.
`CDC::Arc`	Draws an elliptical arc.
`CDC::ArcTo`	Draws an elliptical arc. This function is similar to `Arc`, except that the current position is updated.
`CDC::Attach`	Attaches a Windows device context to this `CDC` object.
`CDC::BeginPath`	Opens a path bracket in the device context.
`CDC::BitBlt`	Copies a bitmap from a specified device context.
`CDC::Chord`	Draws a chord (a closed figure bounded by the intersection of an ellipse and a line segment).
`CDC::CloseFigure`	Closes an open figure in a path.
`CDC::CreateCompatibleDC`	Creates a memory-device context that is compatible with another device context. You can use it to prepare images in memory.
`CDC::CreateDC`	Creates a device context for a specific device.
`CDC::CreateIC`	Creates an information context for a specific device. This provides a fast way to get information about the device without creating a device context.
`CDC::DeleteDC`	Deletes the Windows device context associated with this `CDC` object.
`CDC::DeleteTempMap`	Called by the `CWinApp` idle-time handler to delete any temporary `CDC` object created by `FromHandle`. Also detaches the device context.
`CDC::Detach`	Detaches the Windows device context from this `CDC` object.
`CDC::DPtoHIMETRIC`	Converts device units into `HIMETRIC` units.
`CDC::DPtoLP`	Converts device units into logical units.
`CDC::Draw3dRect`	Draws a three-dimensional rectangle.
`CDC::DrawDragRect`	Erases and redraws a rectangle as it's dragged.
`CDC::DrawEdge`	Draws the edges of a rectangle.
`CDC::DrawEscape`	Accesses drawing capabilities of a video display that aren't directly available through the graphics device interface (GDI).
`CDC::DrawFocusRect`	Draws a rectangle in the style used to indicate focus.
`CDC::DrawFrameControl`	Draw a frame control.
`CDC::DrawIcon`	Draws an icon.
`CDC::DrawState`	Displays an image and applies a visual effect to indicate a state.
`CDC::DrawText`	Draws formatted text in the specified rectangle.
`CDC::DrawTextEx`	Draws formatted text in the specified rectangle using other formats.
`CDC::Ellipse`	Draws an ellipse.
`CDC::EndDoc`	Ends a print job started by the `StartDoc` member function.
`CDC::EndPage`	Informs the device driver that a page is ending.
`CDC::EndPath`	Closes a path bracket and selects the path defined by the bracket into the device context.
`CDC::EnumObjects`	Enumerates the pens and brushes available in a device context.
`CDC::Escape`	Allows applications to access facilities that aren't directly available from a particular device through GDI. Also allows access to Windows escape functions. Escape calls made by an application are translated and sent to the device driver.
`CDC::ExcludeClipRect`	Creates a new clipping region that consists of the existing clipping region minus the specified rectangle.
`CDC::ExcludeUpdateRgn`	Prevents drawing within invalid areas of a window by excluding an updated region in the window from a clipping region.
`CDC::ExtFloodFill`	Fills an area with the current brush. Provides more flexibility than the `CDC::FloodFill` member function.
`CDC::ExtTextOut`	Writes a character string within a rectangular region using the currently selected font.
`CDC::FillPath`	Closes any open figures in the current path and fills the path's interior by using the current brush and polygon-filling mode.
`CDC::FillRect`	Fills a given rectangle by using a specific brush.
`CDC::FillRgn`	Fills a specific region with the specified brush.
`CDC::FillSolidRect`	Fills a rectangle with a solid color.
`CDC::FlattenPath`	Transforms any curves in the path selected into the current device context, and turns each curve into a sequence of lines.
`CDC::FloodFill`	Fills an area with the current brush.
`CDC::FrameRect`	Draws a border around a rectangle.
`CDC::FrameRgn`	Draws a border around a specific region using a brush.
`CDC::FromHandle`	Returns a pointer to a `CDC` object when given a handle to a device context. If a `CDC` object isn't attached to the handle, a temporary `CDC` object is created and attached.
`CDC::GetArcDirection`	Returns the current arc direction for the device context.
`CDC::GetAspectRatioFilter`	Retrieves the setting for the current aspect-ratio filter.
`CDC::GetBkColor`	Retrieves the current background color.
`CDC::GetBkMode`	Retrieves the background mode.
`CDC::GetBoundsRect`	Returns the current accumulated bounding rectangle for the specified device context.
`CDC::GetBrushOrg`	Retrieves the origin of the current brush.
`CDC::GetCharABCWidths`	Retrieves the widths, in logical units, of consecutive characters in a given range from the current font.
`CDC::GetCharABCWidthsI`	Retrieves the widths, in logical units, of consecutive glyph indices in a specified range from the current TrueType font.
`CDC::GetCharacterPlacement`	Retrieves various types of information on a character string.
`CDC::GetCharWidth`	Retrieves the fractional widths of consecutive characters in a given range from the current font.
`CDC::GetCharWidthI`	Retrieves the widths, in logical coordinates, of consecutive glyph indices in a specified range from the current font.
`CDC::GetClipBox`	Retrieves the dimensions of the tightest bounding rectangle around the current clipping boundary.
`CDC::GetColorAdjustment`	Retrieves the color adjustment values for the device context.
`CDC::GetCurrentBitmap`	Returns a pointer to the currently selected `CBitmap` object.
`CDC::GetCurrentBrush`	Returns a pointer to the currently selected `CBrush` object.
`CDC::GetCurrentFont`	Returns a pointer to the currently selected `CFont` object.
`CDC::GetCurrentPalette`	Returns a pointer to the currently selected `CPalette` object.
`CDC::GetCurrentPen`	Returns a pointer to the currently selected `CPen` object.
`CDC::GetCurrentPosition`	Retrieves the current position of the pen (in logical coordinates).
`CDC::GetDCBrushColor`	Retrieves the current brush color.
`CDC::GetDCPenColor`	Retrieves the current pen color.
`CDC::GetDeviceCaps`	Retrieves a specified kind of device-specific information about a given display device's capabilities.
`CDC::GetFontData`	Retrieves font metric information from a scalable font file. The information to retrieve is identified by specifying an offset into the font file and the length of the information to return.
`CDC::GetFontLanguageInfo`	Returns information about the currently selected font for the specified display context.
`CDC::GetGlyphOutline`	Retrieves the outline curve or bitmap for an outline character in the current font.
`CDC::GetGraphicsMode`	Retrieves the current graphics mode for the specified device context.
`CDC::GetHalftoneBrush`	Retrieves a halftone brush.
`CDC::GetKerningPairs`	Retrieves the character kerning pairs for the font that is currently selected in the specified device context.
`CDC::GetLayout`	Retrieves the layout of a device context (DC). The layout can be either left to right (default) or right to left (mirrored).
`CDC::GetMapMode`	Retrieves the current mapping mode.
`CDC::GetMiterLimit`	Returns the miter limit for the device context.
`CDC::GetNearestColor`	Retrieves the closest logical color to a specified logical color that the given device can represent.
`CDC::GetOutlineTextMetrics`	Retrieves font metric information for TrueType fonts.
`CDC::GetOutputCharWidth`	Retrieves the widths of individual characters in a consecutive group of characters from the current font using the output device context.
`CDC::GetOutputTabbedTextExtent`	Computes the width and height of a character string on the output device context.
`CDC::GetOutputTextExtent`	Computes the width and height of a line of text on the output device context using the current font to determine the dimensions.
`CDC::GetOutputTextMetrics`	Retrieves the metrics for the current font from the output device context.
`CDC::GetPath`	Retrieves the coordinates defining the endpoints of lines and the control points of curves found in the path that is selected into the device context.
`CDC::GetPixel`	Retrieves the RGB color value of the pixel at the specified point.
`CDC::GetPolyFillMode`	Retrieves the current polygon-filling mode.
`CDC::GetROP2`	Retrieves the current drawing mode.
`CDC::GetSafeHdc`	Returns `CDC::m_hDC`, the output device context.
`CDC::GetStretchBltMode`	Retrieves the current bitmap-stretching mode.
`CDC::GetTabbedTextExtent`	Computes the width and height of a character string on the attribute device context.
`CDC::GetTextAlign`	Retrieves the text-alignment flags.
`CDC::GetTextCharacterExtra`	Retrieves the current setting for the amount of intercharacter spacing.
`CDC::GetTextColor`	Retrieves the current text color.
`CDC::GetTextExtent`	Computes the width and height of a line of text on the attribute device context using the current font to determine the dimensions.
`CDC::GetTextExtentExPointI`	Retrieves the number of characters in a specified string that will fit within a specified space and fills an array with the text extent for each of those characters.
`CDC::GetTextExtentPointI`	Retrieves the width and height of the specified array of glyph indices.
`CDC::GetTextFace`	Copies the typeface name of the current font into a buffer as a null-terminated string.
`CDC::GetTextMetrics`	Retrieves the metrics for the current font from the attribute device context.
`CDC::GetViewportExt`	Retrieves the x- and y-extents of the viewport.
`CDC::GetViewportOrg`	Retrieves the x- and y-coordinates of the viewport origin.
`CDC::GetWindow`	Returns the window associated with the display device context.
`CDC::GetWindowExt`	Retrieves the x- and y-extents of the associated window.
`CDC::GetWindowOrg`	Retrieves the x- and y-coordinates of the origin of the associated window.
`CDC::GetWorldTransform`	Retrieves the current world-space to page-space transformation.
`CDC::GradientFill`	Fills rectangle and triangle structures with a gradating color.
`CDC::GrayString`	Draws dimmed (grayed) text at the given location.
`CDC::HIMETRICtoDP`	Converts HIMETRIC units into device units.
`CDC::HIMETRICtoLP`	Converts HIMETRIC units into logical units.
`CDC::IntersectClipRect`	Creates a new clipping region by forming the intersection of the current region and a rectangle.
`CDC::InvertRect`	Inverts the contents of a rectangle.
`CDC::InvertRgn`	Inverts the colors in a region.
`CDC::IsPrinting`	Determines whether the device context is being used for printing.
`CDC::LineTo`	Draws a line from the current position up to, but not including, a point.
`CDC::LPtoDP`	Converts logical units into device units.
`CDC::LPtoHIMETRIC`	Converts logical units into HIMETRIC units.
`CDC::MaskBlt`	Combines the color data for the source and destination bitmaps using the given mask and raster operation.
`CDC::ModifyWorldTransform`	Changes the world transformation for a device context using the specified mode.
`CDC::MoveTo`	Moves the current position.
`CDC::OffsetClipRgn`	Moves the clipping region of the given device.
`CDC::OffsetViewportOrg`	Modifies the viewport origin relative to the coordinates of the current viewport origin.
`CDC::OffsetWindowOrg`	Modifies the window origin relative to the coordinates of the current window origin.
`CDC::PaintRgn`	Fills a region with the selected brush.
`CDC::PatBlt`	Creates a bit pattern.
`CDC::Pie`	Draws a pie-shaped wedge.
`CDC::PlayMetaFile`	Plays the contents of the specified metafile on the given device. The enhanced version of `PlayMetaFile` displays the picture stored in the given enhanced-format metafile. The metafile can be played any number of times.
`CDC::PlgBlt`	Performs a bit-block transfer of the bits of color data from the specified rectangle in the source device context to the specified parallelogram in the given device context.
`CDC::PolyBezier`	Draws one or more Bzier splines. The current position isn't used or updated.
`CDC::PolyBezierTo`	Draws one or more Bzier splines, and moves the current position to the ending point of the last Bzier spline.
`CDC::PolyDraw`	Draws a set of line segments and Bzier splines. This function updates the current position.
`CDC::Polygon`	Draws a polygon consisting of two or more points (vertices) connected by lines.
`CDC::Polyline`	Draws a set of line segments connecting the specified points.
`CDC::PolylineTo`	Draws one or more straight lines and moves the current position to the ending point of the last line.
`CDC::PolyPolygon`	Creates two or more polygons that are filled using the current polygon-filling mode. The polygons may be disjoint or they may overlap.
`CDC::PolyPolyline`	Draws multiple series of connected line segments. The current position isn't used or updated by this function.
`CDC::PtVisible`	Specifies whether the given point is within the clipping region.
`CDC::RealizePalette`	Maps palette entries in the current logical palette to the system palette.
`CDC::Rectangle`	Draws a rectangle using the current pen and fills it using the current brush.
`CDC::RectVisible`	Determines whether any part of the given rectangle lies within the clipping region.
`CDC::ReleaseAttribDC`	Releases `m_hAttribDC`, the attribute device context.
`CDC::ReleaseOutputDC`	Releases `m_hDC`, the output device context.
`CDC::ResetDC`	Updates the `m_hAttribDC` device context.
`CDC::RestoreDC`	Restores the device context to a previous state saved with `SaveDC`.
`CDC::RoundRect`	Draws a rectangle with rounded corners using the current pen and filled using the current brush.
`CDC::SaveDC`	Saves the current state of the device context.
`CDC::ScaleViewportExt`	Modifies the viewport extent relative to the current values.
`CDC::ScaleWindowExt`	Modifies the window extents relative to the current values.
`CDC::ScrollDC`	Scrolls a rectangle of bits horizontally and vertically.
`CDC::SelectClipPath`	Selects the current path as a clipping region for the device context, combining the new region with any existing clipping region by using the specified mode.
`CDC::SelectClipRgn`	Combines the given region with the current clipping region by using the specified mode.
`CDC::SelectObject`	Selects a GDI drawing object such as a pen.
`CDC::SelectPalette`	Selects the logical palette.
`CDC::SelectStockObject`	Selects one of the predefined stock pens, brushes, or fonts provided by Windows.
`CDC::SetAbortProc`	Sets a programmer-supplied callback function that Windows calls if a print job must be aborted.
`CDC::SetArcDirection`	Sets the drawing direction to be used for arc and rectangle functions.
`CDC::SetAttribDC`	Sets `m_hAttribDC`, the attribute device context.
`CDC::SetBkColor`	Sets the current background color.
`CDC::SetBkMode`	Sets the background mode.
`CDC::SetBoundsRect`	Controls the accumulation of bounding-rectangle information for the specified device context.
`CDC::SetBrushOrg`	Specifies the origin for the next brush selected into a device context.
`CDC::SetColorAdjustment`	Sets the color adjustment values for the device context using the specified values.
`CDC::SetDCBrushColor`	Sets the current brush color.
`CDC::SetDCPenColor`	Sets the current pen color.
`CDC::SetGraphicsMode`	Sets the current graphics mode for the specified device context.
`CDC::SetLayout`	Changes the layout of a device context (DC).
`CDC::SetMapMode`	Sets the current mapping mode.
`CDC::SetMapperFlags`	Alters the algorithm that the font mapper uses when it maps logical fonts to physical fonts.
`CDC::SetMiterLimit`	Sets the limit for the length of miter joins for the device context.
`CDC::SetOutputDC`	Sets `m_hDC`, the output device context.
`CDC::SetPixel`	Sets the pixel at the specified point to the closest approximation of the specified color.
`CDC::SetPixelV`	Sets the pixel at the specified coordinates to the closest approximation of the specified color. `SetPixelV` is faster than `SetPixel` because it doesn't need to return the color value of the point painted.
`CDC::SetPolyFillMode`	Sets the polygon-filling mode.
`CDC::SetROP2`	Sets the current drawing mode.
`CDC::SetStretchBltMode`	Sets the bitmap-stretching mode.
`CDC::SetTextAlign`	Sets the text-alignment flags.
`CDC::SetTextCharacterExtra`	Sets the amount of intercharacter spacing.
`CDC::SetTextColor`	Sets the text color.
`CDC::SetTextJustification`	Adds space to the break characters in a string.
`CDC::SetViewportExt`	Sets the x- and y-extents of the viewport.
`CDC::SetViewportOrg`	Sets the viewport origin.
`CDC::SetWindowExt`	Sets the x- and y-extents of the associated window.
`CDC::SetWindowOrg`	Sets the window origin of the device context.
`CDC::SetWorldTransform`	Sets the current world-space to page-space transformation.
`CDC::StartDoc`	Informs the device driver that a new print job is starting.
`CDC::StartPage`	Informs the device driver that a new page is starting.
`CDC::StretchBlt`	Moves a bitmap from a source rectangle and device into a destination rectangle, stretching or compressing the bitmap if necessary to fit the dimensions of the destination rectangle.
`CDC::StrokeAndFillPath`	Closes any open figures in a path, strikes the outline of the path by using the current pen, and fills its interior by using the current brush.
`CDC::StrokePath`	Renders the specified path by using the current pen.
`CDC::TabbedTextOut`	Writes a character string at a specified location, expanding tabs to the values specified in an array of tab-stop positions.
`CDC::TextOut`	Writes a character string at a specified location using the currently selected font.
`CDC::TransparentBlt`	Transfers a bit-block of color data from the specified source device context into a destination device context, rendering a specified color transparent in the transfer.
`CDC::UpdateColors`	Updates the client area of the device context by matching the current colors in the client area to the system palette on a pixel-by-pixel basis.
`CDC::WidenPath`	Redefines the current path as the area that would be painted if the path were stroked using the pen currently selected into the device context.

Public Operators

Name	Description
`CDC::operator HDC`	Retrieves the handle of the device context.

Public Data Members

Name	Description
`CDC::m_hAttribDC`	The attribute-device context used by this `CDC` object.
`CDC::m_hDC`	The output-device context used by this `CDC` object.

Remarks

The CDC object provides member functions for working with a device context, such as a display or printer, and members for working with a display context associated with the client area of a window.

Do all drawing through the member functions of a CDC object. The class provides member functions for device-context operations, working with drawing tools, type-safe graphics device interface (GDI) object selection, and working with colors and palettes. It also provides member functions for getting and setting drawing attributes, mapping, working with the viewport, working with the window extent, converting coordinates, working with regions, clipping, drawing lines, and drawing simple shapes, ellipses, and polygons. Member functions are also provided for drawing text, working with fonts, using printer escapes, scrolling, and playing metafiles.

To use a CDC object, construct it, and then call its member functions that parallel Windows functions that use device contexts.

Note

Under Windows 95/98, all screen coordinates are limited to 16 bits. Therefore, an int passed to a CDC member function must lie in the range -32768 to 32767.

For specific uses, the Microsoft Foundation Class Library provides several classes derived from CDC . CPaintDC encapsulates calls to BeginPaint and EndPaint. CClientDC manages a display context associated with a window's client area. CWindowDC manages a display context associated with an entire window, including its frame and controls. CMetaFileDC associates a device context with a metafile.

CDC provides two member functions, GetLayout and SetLayout, for reversing the layout of a device context, which doesn't inherit its layout from a window. Such right-to-left orientation is necessary for applications written for cultures, such as Arabic or Hebrew, where the character layout isn't the European standard.

CDC contains two device contexts, m_hDC and m_hAttribDC, which, on creation of a CDC object, refer to the same device. CDC directs all output GDI calls to m_hDC and most attribute GDI calls to m_hAttribDC. (An example of an attribute call is GetTextColor, while SetTextColor is an output call.)

For example, the framework uses these two device contexts to implement a CMetaFileDC object that will send output to a metafile while reading attributes from a physical device. Print preview is implemented in the framework in a similar fashion. You can also use the two device contexts in a similar way in your application-specific code.

There are times when you may need text-metric information from both the m_hDC and m_hAttribDC device contexts. The following pairs of functions provide this capability:

Uses m_hAttribDC	Uses m_hDC
`GetTextExtent`	`GetOutputTextExtent`
`GetTabbedTextExtent`	`GetOutputTabbedTextExtent`
`GetTextMetrics`	`GetOutputTextMetrics`
`GetCharWidth`	`GetOutputCharWidth`

For more information on CDC, see Device Contexts.

Inheritance Hierarchy

CObject

CDC

Requirements

Header: afxwin.h

`CDC::AbortDoc`

Terminates the current print job and erases everything the application has written to the device since the last call to the StartDoc member function.

int AbortDoc();

Return Value

A value greater than or equal to 0 if successful, or a negative value if an error has occurred. The following list shows common error values and their meanings:

SP_ERROR General error.
SP_OUTOFDISK Not enough disk space is currently available for spooling, and no more space will become available.
SP_OUTOFMEMORY Not enough memory is available for spooling.
SP_USERABORT User terminated the job through the Print Manager.

Remarks

This member function replaces the ABORTDOC printer escape.

AbortDoc should be used to terminate the following:

Printing operations that don't specify an abort function using SetAbortProc.
Printing operations that have not yet reached their first NEWFRAME or NEXTBAND escape call.

If an application encounters a printing error or a canceled print operation, it must not attempt to terminate the operation by using either the EndDoc or AbortDoc member functions of class CDC. GDI automatically terminates the operation before returning the error value.

If the application displays a dialog box to allow the user to cancel the print operation, it must call AbortDoc before destroying the dialog box.

If Print Manager was used to start the print job, calling AbortDoc erases the entire spool job—the printer receives nothing. If Print Manager wasn't used to start the print job, the data may have been sent to the printer before AbortDoc was called. In this case, the printer driver would have reset the printer (when possible) and closed the print job.

Example

See the example for CDC::StartDoc.

`CDC::AbortPath`

Closes and discards any paths in the device context.

BOOL AbortPath();

Return Value

Nonzero if the function is successful; otherwise 0.

Remarks

If there's an open path bracket in the device context, the path bracket is closed and the path is discarded. If there's a closed path in the device context, the path is discarded.

`CDC::AddMetaFileComment`

Copies the comment from a buffer into a specified enhanced-format metafile.

BOOL AddMetaFileComment(
    UINT nDataSize,
    const BYTE* pCommentData);

Parameters

nDataSize
Specifies the length of the comment buffer, in bytes.

pCommentData
Points to the buffer that contains the comment.

Return Value

Nonzero if the function is successful; otherwise 0.

Remarks

A comment may include any private information — for example, the source of the picture and the date it was created. A comment should begin with an application signature, followed by the data. Comments shouldn't contain position-specific data. Position-specific data specifies the location of a record, and it shouldn't be included because one metafile may be embedded within another metafile. This function can only be used with enhanced metafiles.

`CDC::AlphaBlend`

Call this member function to display bitmaps that have transparent or semitransparent pixels.

BOOL AlphaBlend(
    int xDest,
    int yDest,
    int nDestWidth,
    int nDestHeight,
    CDC* pSrcDC,
    int xSrc,
    int ySrc,
    int nSrcWidth,
    int nSrcHeight,
    BLENDFUNCTION blend);

Parameters

xDest
Specifies the x-coordinate, in logical units, of the upper-left corner of the destination rectangle.

yDest
Specifies the y-coordinate, in logical units, of the upper-left corner of the destination rectangle.

nDestWidth
Specifies the width, in logical units, of the destination rectangle.

nDestHeight
Specifies the height, in logical units, of the destination rectangle.

pSrcDC
A pointer to the source device context.

xSrc
Specifies the x-coordinate, in logical units, of the upper-left corner of the source rectangle.

ySrc
Specifies the y-coordinate, in logical units, of the upper-left corner of the source rectangle.

nSrcWidth
Specifies the width, in logical units, of the source rectangle.

nSrcHeight
Specifies the height, in logical units, of the source rectangle.

blend
Specifies a BLENDFUNCTION structure.

Return Value

TRUE if successful; otherwise FALSE.

Remarks

See AlphaBlend in the Windows SDK for more information.

`CDC::AngleArc`

Draws a line segment and an arc.

BOOL AngleArc(
    int x,
    int y,
    int nRadius,
    float fStartAngle,
    float fSweepAngle);

Parameters

x
Specifies the logical x-coordinate of the center of the circle.

y
Specifies the logical y-coordinate of the center of the circle.

nRadius
Specifies the radius of the circle in logical units. This value must be positive.

fStartAngle
Specifies the starting angle in degrees relative to the x-axis.

fSweepAngle
Specifies the sweep angle in degrees relative to the starting angle.

Return Value

Nonzero if successful; otherwise 0.

Remarks

The line segment is drawn from the current position to the beginning of the arc. The arc is drawn along the perimeter of a circle with the given radius and center. The length of the arc is defined by the given start and sweep angles.

AngleArc moves the current position to the ending point of the arc. The arc drawn by this function may appear to be elliptical, depending on the current transformation and mapping mode. Before drawing the arc, this function draws the line segment from the current position to the beginning of the arc. The arc is drawn by constructing an imaginary circle with the specified radius around the specified center point. The starting point of the arc is determined by measuring counterclockwise from the x-axis of the circle by the number of degrees in the start angle. The ending point is similarly located by measuring counterclockwise from the starting point by the number of degrees in the sweep angle.

If the sweep angle is greater than 360 degrees the arc is swept multiple times. This function draws lines by using the current pen. The figure isn't filled.

`CDC::Arc`

Draws an elliptical arc.

BOOL Arc(
    int x1,
    int y1,
    int x2,
    int y2,
    int x3,
    int y3,
    int x4,
    int y4);

BOOL Arc(
    LPCRECT lpRect,
    POINT ptStart,
    POINT ptEnd);

Parameters

x1
Specifies the x-coordinate of the upper-left corner of the bounding rectangle (in logical units).

y1
Specifies the y-coordinate of the upper-left corner of the bounding rectangle (in logical units).

x2
Specifies the x-coordinate of the lower-right corner of the bounding rectangle (in logical units).

y2
Specifies the y-coordinate of the lower-right corner of the bounding rectangle (in logical units).

x3
Specifies the x-coordinate of the point that defines the arc's starting point (in logical units). This point doesn't have to lie exactly on the arc.

y3
Specifies the y-coordinate of the point that defines the arc's starting point (in logical units). This point doesn't have to lie exactly on the arc.

x4
Specifies the x-coordinate of the point that defines the arc's endpoint (in logical units). This point doesn't have to lie exactly on the arc.

y4
Specifies the y-coordinate of the point that defines the arc's endpoint (in logical units). This point doesn't have to lie exactly on the arc.

lpRect
Specifies the bounding rectangle (in logical units). You can pass either an LPRECT or a CRect object for this parameter.

ptStart
Specifies the x- and y-coordinates of the point that defines the arc's starting point (in logical units). This point doesn't have to lie exactly on the arc. You can pass either a POINT structure or a CPoint object for this parameter.

ptEnd
Specifies the x- and y-coordinates of the point that defines the arc's ending point (in logical units). This point doesn't have to lie exactly on the arc. You can pass either a POINT structure or a CPoint object for this parameter.

Return Value

Nonzero if the function is successful; otherwise 0.

Remarks

The arc drawn by using the function is a segment of the ellipse defined by the specified bounding rectangle.

The actual starting point of the arc is the point at which a ray drawn from the center of the bounding rectangle through the specified starting point intersects the ellipse. The actual ending point of the arc is the point at which a ray drawn from the center of the bounding rectangle through the specified ending point intersects the ellipse. The arc is drawn in a counterclockwise direction. Since an arc isn't a closed figure, it isn't filled. Both the width and height of the rectangle must be greater than 2 units and less than 32,767 units.

Example

void CDCView::DrawArc(CDC *pDC)
{
   // Fill the client area with a thin circle. The circle's
   // interior is not filled. The circle's perimeter is
   // blue from 6 o'clock to 3 o'clock and red from 3
   // o'clock to 6 o'clock.

   // Get the client area.
   CRect rectClient;
   GetClientRect(rectClient);

   // Make a couple of pens.
   CPen penBlue;
   CPen penRed;
   CPen *pOldPen;

   penBlue.CreatePen(PS_SOLID | PS_COSMETIC, 1, RGB(0, 0, 255));
   penRed.CreatePen(PS_SOLID | PS_COSMETIC, 1, RGB(255, 0, 0));

   // Draw from 3 o'clock to 6 o'clock, counterclockwise,
   // in a blue pen.

   pOldPen = pDC->SelectObject(&penBlue);

   pDC->Arc(rectClient,
            CPoint(rectClient.right, rectClient.CenterPoint().y),
            CPoint(rectClient.CenterPoint().x, rectClient.right));

   // Draw from 6 o'clock to 3 o'clock, counterclockwise,
   // in a red pen.
   pDC->SelectObject(&penRed);

   // Keep the same parameters, but reverse start
   // and end points.
   pDC->Arc(rectClient,
            CPoint(rectClient.CenterPoint().x, rectClient.right),
            CPoint(rectClient.right, rectClient.CenterPoint().y));

   // Restore the previous pen.
   pDC->SelectObject(pOldPen);
}

`CDC::ArcTo`

Draws an elliptical arc.

BOOL ArcTo(
    int x1,
    int y1,
    int x2,
    int y2,
    int x3,
    int y3,
    int x4,
    int y4);

BOOL ArcTo(
    LPCRECT lpRect,
    POINT ptStart,
    POINT ptEnd);