/// Drawing methods.
/// <devdoc>
/// </devdoc>
public void DrawPie(WindowsPen pen, Rectangle bounds, float startAngle, float sweepAngle)
{
HandleRef hdc = new HandleRef(this.dc, this.dc.Hdc);
if (pen != null)
{
// 1. Select the pen in the DC
IntUnsafeNativeMethods.SelectObject(hdc, new HandleRef(pen, pen.HPen));
}
// 2. call the functions
// we first draw a path that goes :
// from center of pie, draw arc (this draw the line to the beginning of the arc
// then, draw the closing line.
// paint the path with the pen
int sideLength = Math.Min(bounds.Width, bounds.Height);
Point p = new Point(bounds.X + sideLength / 2, bounds.Y + sideLength / 2);
int radius = sideLength / 2;
IntUnsafeNativeMethods.BeginPath(hdc);
IntUnsafeNativeMethods.MoveToEx(hdc, p.X, p.Y, null);
IntUnsafeNativeMethods.AngleArc(hdc, p.X, p.Y, radius, startAngle, sweepAngle);
IntUnsafeNativeMethods.LineTo(hdc, p.X, p.Y);
IntUnsafeNativeMethods.EndPath(hdc);
IntUnsafeNativeMethods.StrokePath(hdc);
}
public int SaveHdc()
{
HandleRef hdc = new HandleRef(this, this.Hdc);
int state = IntUnsafeNativeMethods.SaveDC(hdc);
if (contextStack == null)
{
contextStack = new Stack();
}
GraphicsState g = new GraphicsState();
g.hBitmap = hCurrentBmp;
g.hBrush = hCurrentBrush;
g.hPen = hCurrentPen;
g.hFont = hCurrentFont;
#if !DRAWING_NAMESPACE
g.font = new WeakReference(selectedFont);
#endif
contextStack.Push(g);
#if TRACK_HDC
Debug.WriteLine(DbgUtil.StackTraceToStr(String.Format("state[0]=DC.SaveHdc(hDc=0x{1:x8})", state, unchecked ((int)this.hDC))));
#endif
return(state);
}
/// <include file='doc\WindowsGraphics.uex' path='docs/doc[@for="WindowsGraphics.DrawRectangle3"]/*' />
public void DrawRectangle(WindowsPen pen, int x, int y, int width, int height)
{
Debug.Assert(pen != null, "pen == null");
HandleRef hdc = new HandleRef(this.dc, this.dc.Hdc);
if (pen != null)
{
this.dc.SelectObject(pen.HPen, GdiObjectType.Pen);
}
DeviceContextBinaryRasterOperationFlags rasterOp = this.dc.BinaryRasterOperation;
if (rasterOp != DeviceContextBinaryRasterOperationFlags.CopyPen)
{
rasterOp = this.dc.SetRasterOperation(DeviceContextBinaryRasterOperationFlags.CopyPen);
}
IntUnsafeNativeMethods.SelectObject(hdc, new HandleRef(null, IntUnsafeNativeMethods.GetStockObject(IntNativeMethods.HOLLOW_BRUSH)));
// Microsoft
IntUnsafeNativeMethods.Rectangle(hdc, x, y, x + width, y + height);
if (rasterOp != DeviceContextBinaryRasterOperationFlags.CopyPen)
{
this.dc.SetRasterOperation(rasterOp);
}
}
/// <devdoc>
/// <para>
/// Returns the Size of the given text using the specified font if not null, otherwise the font currently
/// set in the dc is used.
/// This method is used to get the size in points of a line of text; it uses GetTextExtentPoint32 function
/// which computes the width and height of the text ignoring TAB\CR\LF characters.
/// A text extent is the distance between the beginning of the space and a character that will fit in the space.
/// </para>
/// </devdoc>
public Size GetTextExtent(string text, WindowsFont font)
{
if (string.IsNullOrEmpty(text))
{
return(Size.Empty);
}
IntNativeMethods.SIZE size = new IntNativeMethods.SIZE();
HandleRef hdc = new HandleRef(null, this.dc.Hdc);
if (font != null)
{
this.dc.SelectFont(font);
}
IntUnsafeNativeMethods.GetTextExtentPoint32(hdc, text, size);
// Unselect, but not from Measurement DC as it keeps the same
// font selected for perf reasons.
if (font != null && !MeasurementDCInfo.IsMeasurementDC(this.dc))
{
this.dc.ResetFont();
}
return(new Size(size.cx, size.cy));
}
public static int GetTextMetrics(HandleRef hDC, ref IntNativeMethods.TEXTMETRIC lptm)
{
int retVal = IntUnsafeNativeMethods.GetTextMetricsW(hDC, ref lptm);
DbgUtil.AssertWin32(retVal != 0, "GetTextMetrics(hdc=[0x{0:X8}], [out TEXTMETRIC] failed.", hDC.Handle);
return(retVal);
}
public void SetClip(WindowsRegion region)
{
HandleRef hdc = new HandleRef(this, this.Hdc);
HandleRef hRegion = new HandleRef(region, region.HRegion);
IntUnsafeNativeMethods.SelectClipRgn(hdc, hRegion);
}
public void IntersectClip(WindowsRegion wr)
{
//if the incoming windowsregion is infinite, there is no need to do any intersecting.
if (wr.HRegion == IntPtr.Zero)
{
return;
}
WindowsRegion clip = new WindowsRegion(0, 0, 0, 0);
try {
int result = IntUnsafeNativeMethods.GetClipRgn(new HandleRef(this, this.Hdc), new HandleRef(clip, clip.HRegion));
// If the function succeeds and there is a clipping region for the given device context, the return value is 1.
if (result == 1)
{
Debug.Assert(clip.HRegion != IntPtr.Zero);
wr.CombineRegion(clip, wr, RegionCombineMode.AND); //1 = AND (or Intersect)
}
SetClip(wr);
}
finally {
clip.Dispose();
}
}
/// <devdoc>
/// Sets the DC Viewport origin to the specified value and returns its previous value; origin values are in device units.
/// </devdoc>
public Point SetViewportOrigin(Point newOrigin)
{
IntNativeMethods.POINT oldOrigin = new IntNativeMethods.POINT();
IntUnsafeNativeMethods.SetViewportOrgEx(new HandleRef(this, this.Hdc), newOrigin.X, newOrigin.Y, oldOrigin);
return(oldOrigin.ToPoint());
}
public static int DrawTextEx(HandleRef hDC, string text, ref IntNativeMethods.RECT lpRect, int nFormat, [In, Out] IntNativeMethods.DRAWTEXTPARAMS lpDTParams)
{
int retVal;
if (Marshal.SystemDefaultCharSize == 1)
{
// CapRectangleForWin9x(ref lpRect);
// we have to do this because if we pass too big of a value (<= 2^31) to win9x
// it fails and returns negative values as the rect in which it painted the text
lpRect.top = Math.Min(Int16.MaxValue, lpRect.top);
lpRect.left = Math.Min(Int16.MaxValue, lpRect.left);
lpRect.right = Math.Min(Int16.MaxValue, lpRect.right);
lpRect.bottom = Math.Min(Int16.MaxValue, lpRect.bottom);
// Convert Unicode string to ANSI.
int byteCount = IntUnsafeNativeMethods.WideCharToMultiByte(IntNativeMethods.CP_ACP, 0, text, text.Length, null, 0, IntPtr.Zero, IntPtr.Zero);
byte[] textBytes = new byte[byteCount];
IntUnsafeNativeMethods.WideCharToMultiByte(IntNativeMethods.CP_ACP, 0, text, text.Length, textBytes, textBytes.Length, IntPtr.Zero, IntPtr.Zero);
// Security: Windows 95/98/Me: This value may not exceed 8192.
byteCount = Math.Min(byteCount, IntNativeMethods.MaxTextLengthInWin9x);
retVal = DrawTextExA(hDC, textBytes, byteCount, ref lpRect, nFormat, lpDTParams);
}
else
{
retVal = DrawTextExW(hDC, text, text.Length, ref lpRect, nFormat, lpDTParams);
}
DbgUtil.AssertWin32(retVal != 0, "DrawTextEx(hdc=[0x{0:X8}], text=[{1}], rect=[{2}], flags=[{3}] failed.", hDC.Handle, text, lpRect, nFormat);
return(retVal);
}
/// <devdoc>
/// </devdoc>
public Color GetNearestColor(Color color)
{
HandleRef hdc = new HandleRef(null, this.dc.Hdc);
int colorResult = IntUnsafeNativeMethods.GetNearestColor(hdc, ColorTranslator.ToWin32(color));
return(ColorTranslator.FromWin32(colorResult));
}
/// <summary>
/// Creates the font handle.
/// </summary>
private void CreateFont()
{
Debug.Assert(hFont == IntPtr.Zero, "hFont is not null, this will generate a handle leak.");
Debug.Assert(this.logFont != null, "WindowsFont.logFont not initialized.");
this.hFont = IntUnsafeNativeMethods.CreateFontIndirect(this.logFont);
#if TRACK_HFONT
Debug.WriteLine(DbgUtil.StackTraceToStr(String.Format("HFONT[0x{0:x8}] = CreateFontIndirect( LOGFONT={1} )", (int)this.hFont, this.logFont)));
#endif
if (this.hFont == IntPtr.Zero)
{
this.logFont.lfFaceName = defaultFaceName;
this.logFont.lfOutPrecision = IntNativeMethods.OUT_TT_ONLY_PRECIS; // True Type only.
this.hFont = IntUnsafeNativeMethods.CreateFontIndirect(this.logFont);
#if TRACK_HFONT
Debug.WriteLine(DbgUtil.StackTraceToStr(String.Format("HFONT[0x{0:x8}] = CreateFontIndirect( LOGFONT={1} )", (int)this.hFont, this.logFont)));
#endif
}
// Update logFont height and other adjusted parameters.
//
IntUnsafeNativeMethods.GetObject(new HandleRef(this, this.hFont), this.logFont);
// We created the hFont, we will delete it on dispose.
this.ownHandle = true;
}
internal void Dispose(bool disposing)
{
bool deletedHandle = false;
if (this.ownHandle)
{
if (!ownedByCacheManager || !disposing)
{
// If we were ever owned by the CacheManger and we're being disposed
// we can be sure that we're not in use by any DC's (otherwise Dispose() wouldn't have been called)
// skip the check IsFontInUse check in this case.
// Also skip the check if disposing == false, because the cache is thread-static
// and that means we're being called from the finalizer.
if (everOwnedByCacheManager || !disposing || !DeviceContexts.IsFontInUse(this))
{
Debug.Assert(this.hFont != IntPtr.Zero, "Unexpected null hFont.");
DbgUtil.AssertFinalization(this, disposing);
IntUnsafeNativeMethods.DeleteObject(new HandleRef(this, this.hFont));
#if TRACK_HFONT
Debug.WriteLine(DbgUtil.StackTraceToStr(String.Format("DeleteObject(HFONT[0x{0:x8}]))", (int)this.hFont)));
#endif
this.hFont = IntPtr.Zero;
this.ownHandle = false;
deletedHandle = true;
}
}
}
if (disposing && (deletedHandle || !ownHandle))
{
GC.SuppressFinalize(this);
}
}
/// <devdoc>
/// Sets the DC Viewport extent to the specified value and returns its previous value; extent values are in device units.
/// </devdoc>
public Size SetViewportExtent(Size newExtent)
{
IntNativeMethods.SIZE oldExtent = new IntNativeMethods.SIZE();
IntUnsafeNativeMethods.SetViewportExtEx(new HandleRef(this, this.Hdc), newExtent.Width, newExtent.Height, oldExtent);
return(oldExtent.ToSize());
}
/// <summary>
/// Creates a WindowsFont from the font selected in the supplied dc.
/// </summary>
public static WindowsFont FromHdc(IntPtr hdc)
{
IntPtr hFont = IntUnsafeNativeMethods.GetCurrentObject(new HandleRef(null, hdc), IntNativeMethods.OBJ_FONT);
// don't call DeleteObject on handle from GetCurrentObject, it is the one selected in the hdc.
return(FromHfont(hFont));
}
public unsafe void CreateFontIndirect()
{
NativeMethods.LOGFONTW logFont = default;
IntPtr handle = IntUnsafeNativeMethods.CreateFontIndirectW(ref logFont);
Assert.NotEqual(IntPtr.Zero, handle);
Assert.True(Gdi32.DeleteObject(handle) != BOOL.FALSE);
}
// Due to a problem with calling DeleteObject() on currently selected GDI objects,
// we now track the initial set of objects when a DeviceContext is created. Then,
// we also track which objects are currently selected in the DeviceContext. When
// a currently selected object is disposed, it is first replaced in the DC and then
// deleted.
private void CacheInitialState()
{
Debug.Assert(this.hDC != IntPtr.Zero, "Cannot get initial state without a valid HDC");
hCurrentPen = hInitialPen = IntUnsafeNativeMethods.GetCurrentObject(new HandleRef(this, hDC), IntNativeMethods.OBJ_PEN);
hCurrentBrush = hInitialBrush = IntUnsafeNativeMethods.GetCurrentObject(new HandleRef(this, hDC), IntNativeMethods.OBJ_BRUSH);
hCurrentBmp = hInitialBmp = IntUnsafeNativeMethods.GetCurrentObject(new HandleRef(this, hDC), IntNativeMethods.OBJ_BITMAP);
hCurrentFont = hInitialFont = IntUnsafeNativeMethods.GetCurrentObject(new HandleRef(this, hDC), IntNativeMethods.OBJ_FONT);
}
/// <devdoc>
/// CreateIC creates a DeviceContext object wrapping an hdc created with the Win32 CreateIC function.
/// </devdoc>
public static DeviceContext CreateIC(string driverName, string deviceName, string fileName, HandleRef devMode)
{
// Note: All input params can be null but not at the same time. See MSDN for information.
IntPtr hdc = IntUnsafeNativeMethods.CreateIC(driverName, deviceName, fileName, devMode);
return(new DeviceContext(hdc, DeviceContextType.Information));
}
private void DrawTreeItem(string itemText, int imageIndex, IntPtr dc, System.Windows.Forms.NativeMethods.RECT rcIn, int state, int backColor, int textColor)
{
IntNativeMethods.SIZE size = new IntNativeMethods.SIZE();
IntNativeMethods.RECT lpRect = new IntNativeMethods.RECT();
IntNativeMethods.RECT rect = new IntNativeMethods.RECT(rcIn.left, rcIn.top, rcIn.right, rcIn.bottom);
ImageList imageList = base.ImageList;
IntPtr zero = IntPtr.Zero;
if ((state & 2) != 0)
{
zero = System.Windows.Forms.SafeNativeMethods.SelectObject(new HandleRef(null, dc), new HandleRef(base.Parent, base.Parent.FontHandle));
}
if (((state & 1) != 0) && (this.hbrushDither != IntPtr.Zero))
{
this.FillRectDither(dc, rcIn);
System.Windows.Forms.SafeNativeMethods.SetBkMode(new HandleRef(null, dc), 1);
}
else
{
System.Windows.Forms.SafeNativeMethods.SetBkColor(new HandleRef(null, dc), backColor);
IntUnsafeNativeMethods.ExtTextOut(new HandleRef(null, dc), 0, 0, 6, ref rect, null, 0, null);
}
IntUnsafeNativeMethods.GetTextExtentPoint32(new HandleRef(null, dc), itemText, size);
lpRect.left = (rect.left + 0x10) + 8;
lpRect.top = rect.top + (((rect.bottom - rect.top) - size.cy) >> 1);
lpRect.bottom = lpRect.top + size.cy;
lpRect.right = rect.right;
System.Windows.Forms.SafeNativeMethods.SetTextColor(new HandleRef(null, dc), textColor);
IntUnsafeNativeMethods.DrawText(new HandleRef(null, dc), itemText, ref lpRect, 0x8804);
System.Windows.Forms.SafeNativeMethods.ImageList_Draw(new HandleRef(imageList, imageList.Handle), imageIndex, new HandleRef(null, dc), 4, rect.top + (((rect.bottom - rect.top) - 0x10) >> 1), 1);
if ((state & 2) != 0)
{
int clr = System.Windows.Forms.SafeNativeMethods.SetBkColor(new HandleRef(null, dc), ColorTranslator.ToWin32(SystemColors.ControlLightLight));
lpRect.left = rect.left;
lpRect.top = rect.top;
lpRect.bottom = rect.top + 1;
lpRect.right = rect.right;
IntUnsafeNativeMethods.ExtTextOut(new HandleRef(null, dc), 0, 0, 2, ref lpRect, null, 0, null);
lpRect.bottom = rect.bottom;
lpRect.right = rect.left + 1;
IntUnsafeNativeMethods.ExtTextOut(new HandleRef(null, dc), 0, 0, 2, ref lpRect, null, 0, null);
System.Windows.Forms.SafeNativeMethods.SetBkColor(new HandleRef(null, dc), ColorTranslator.ToWin32(SystemColors.ControlDark));
lpRect.left = rect.left;
lpRect.right = rect.right;
lpRect.top = rect.bottom - 1;
lpRect.bottom = rect.bottom;
IntUnsafeNativeMethods.ExtTextOut(new HandleRef(null, dc), 0, 0, 2, ref lpRect, null, 0, null);
lpRect.left = rect.right - 1;
lpRect.top = rect.top;
IntUnsafeNativeMethods.ExtTextOut(new HandleRef(null, dc), 0, 0, 2, ref lpRect, null, 0, null);
System.Windows.Forms.SafeNativeMethods.SetBkColor(new HandleRef(null, dc), clr);
}
if (zero != IntPtr.Zero)
{
System.Windows.Forms.SafeNativeMethods.SelectObject(new HandleRef(null, dc), new HandleRef(null, zero));
}
}
/// <devdoc>
/// Creates a DeviceContext object wrapping a memory DC compatible with the specified device.
/// </devdoc>
public static DeviceContext FromCompatibleDC(IntPtr hdc)
{
// If hdc is null, the function creates a memory DC compatible with the application's current screen.
// In this case the thread that calls CreateCompatibleDC owns the HDC that is created. When this thread is destroyed,
// the HDC is no longer valid.
IntPtr compatibleDc = IntUnsafeNativeMethods.CreateCompatibleDC(new HandleRef(null, hdc));
return(new DeviceContext(compatibleDc, DeviceContextType.Memory));
}
public static WindowsBrush FromDC(DeviceContext dc)
{
IntPtr hBrush = IntUnsafeNativeMethods.GetCurrentObject(new HandleRef(null, dc.Hdc), IntNativeMethods.OBJ_BRUSH);
IntNativeMethods.LOGBRUSH logBrush = new IntNativeMethods.LOGBRUSH();
IntUnsafeNativeMethods.GetObject(new HandleRef(null, hBrush), logBrush);
// don't call DeleteObject on handle from GetCurrentObject, it is the one selected in the hdc.
return(WindowsBrush.FromLogBrush(dc, logBrush));
}
/// <devdoc>
/// A rectangle representing the window region set with the SetWindowRgn function.
/// </devdoc>
public Rectangle ToRectangle()
{
if (this.IsInfinite)
{
return(new Rectangle(-int.MaxValue, -int.MaxValue, int.MaxValue, int.MaxValue));
}
IntNativeMethods.RECT rect = new IntNativeMethods.RECT();
IntUnsafeNativeMethods.GetRgnBox(new HandleRef(this, this.nativeHandle), ref rect);
return(new Rectangle(new Point(rect.left, rect.top), rect.Size));
}
/// <devdoc>
/// Creates a WindowsFont from the handle to a native GDI font and optionally takes ownership of managing
/// the lifetime of the handle.
/// </devdoc>
public static WindowsFont FromHfont(IntPtr hFont, bool takeOwnership)
{
IntNativeMethods.LOGFONT lf = new IntNativeMethods.LOGFONT();
IntUnsafeNativeMethods.GetObject(new HandleRef(null, hFont), lf);
WindowsFont wf = new WindowsFont(lf, /*createHandle*/ false);
wf.hFont = hFont;
wf.ownHandle = takeOwnership; // if true, hFont will be deleted on dispose.
return(wf);
}
public void ResetFont()
{
#if OPTIMIZED_MEASUREMENTDC
// in this case, GDI will copy back the previously saved font into the DC.
// we dont actually know what the font is in our measurement DC so
// we need to clear it off.
MeasurementDCInfo.ResetIfIsMeasurementDC(this.Hdc);
#endif
IntUnsafeNativeMethods.SelectObject(new HandleRef(this, this.Hdc), new HandleRef(null, hInitialFont));
selectedFont = null;
hCurrentFont = hInitialFont;
}
/// <summary>
/// Returns a handle to this <see cref='Font'/>.
/// </summary>
public IntPtr ToHfont()
{
SafeNativeMethods.LOGFONT lf = new SafeNativeMethods.LOGFONT();
ToLogFont(lf);
IntPtr handle = IntUnsafeNativeMethods.IntCreateFontIndirect(lf);
if (handle == IntPtr.Zero)
{
throw new Win32Exception();
}
return(handle);
}
/// <summary>
/// Returns a handle to this <see cref='Font'/>.
/// </summary>
public IntPtr ToHfont()
{
using (ScreenDC dc = ScreenDC.Create())
using (Graphics graphics = Graphics.FromHdcInternal(dc))
{
SafeNativeMethods.LOGFONT lf = ToLogFontInternal(graphics);
IntPtr handle = IntUnsafeNativeMethods.CreateFontIndirect(ref lf);
if (handle == IntPtr.Zero)
{
throw new Win32Exception();
}
return(handle);
}
}
/// <include file='doc\IDeviceContext.uex' path='docs/doc[@for="DeviceContext.ReleaseHdc"]/*' />
///<devdoc>
/// If the object was created from a DC, this object doesn't 'own' the dc so we just ignore
/// this call.
///</devdoc>
void IDeviceContext.ReleaseHdc()
{
if (this.hDC != IntPtr.Zero && this.dcType == DeviceContextType.Display)
{
#if TRACK_HDC
int retVal =
#endif
IntUnsafeNativeMethods.ReleaseDC(new HandleRef(this, this.hWnd), new HandleRef(this, this.hDC));
// Note: retVal == 0 means it was not released but doesn't necessarily means an error; class or private DCs are never released.
#if TRACK_HDC
Debug.WriteLine(DbgUtil.StackTraceToStr(String.Format("[ret={0}]=DC.ReleaseDC(hDc=0x{1:x8}, hWnd=0x{2:x8})", retVal, unchecked ((int)this.hDC), unchecked ((int)this.hWnd))));
#endif
this.hDC = IntPtr.Zero;
}
}
/// <include file='doc\IDeviceContext.uex' path='docs/doc[@for="DeviceContext.GetHdc"]/*' />
/// <devdoc>
/// Explicit interface method implementation to hide them a bit for usability reasons so the object is seen
/// as a wrapper around an hdc that is always available, and for performance reasons since it caches the hdc
/// if used in this way.
/// </devdoc>
IntPtr IDeviceContext.GetHdc()
{
if (this.hDC == IntPtr.Zero)
{
Debug.Assert(this.dcType == DeviceContextType.Display, "Calling GetDC from a non display/window device.");
// Note: for common DCs, GetDC assigns default attributes to the DC each time it is retrieved.
// For example, the default font is System.
this.hDC = IntUnsafeNativeMethods.GetDC(new HandleRef(this, this.hWnd));
#if TRACK_HDC
Debug.WriteLine(DbgUtil.StackTraceToStr(String.Format("hdc[0x{0:x8}]=DC.GetHdc(hWnd=0x{1:x8})", unchecked ((int)this.hDC), unchecked ((int)this.hWnd))));
#endif
}
return(this.hDC);
}
/// <devdoc>
/// Constructor to contruct a DeviceContext object from an existing Win32 device context handle.
/// </devdoc>
private DeviceContext(IntPtr hDC, DeviceContextType dcType)
{
this.hDC = hDC;
this.dcType = dcType;
CacheInitialState();
DeviceContexts.AddDeviceContext(this);
if (dcType == DeviceContextType.Display)
{
this.hWnd = IntUnsafeNativeMethods.WindowFromDC(new HandleRef(this, this.hDC));
}
#if TRACK_HDC
Debug.WriteLine(DbgUtil.StackTraceToStr(String.Format("DeviceContext( hDC=0x{0:X8}, Type={1} )", unchecked ((int)hDC), dcType)));
#endif
}
/// <devdoc>
/// Restores the device context to the specified state. The DC is restored by popping state information off a
/// stack created by earlier calls to the SaveHdc function.
/// The stack can contain the state information for several instances of the DC. If the state specified by the
/// specified parameter is not at the top of the stack, RestoreDC deletes all state information between the top
/// of the stack and the specified instance.
/// Specifies the saved state to be restored. If this parameter is positive, nSavedDC represents a specific
/// instance of the state to be restored. If this parameter is negative, nSavedDC represents an instance relative
/// to the current state. For example, -1 restores the most recently saved state.
/// See MSDN for more info.
/// </devdoc>
public void RestoreHdc()
{
#if TRACK_HDC
bool result =
#endif
// Note: Don't use the Hdc property here, it would force handle creation.
IntUnsafeNativeMethods.RestoreDC(new HandleRef(this, this.hDC), -1);
#if TRACK_HDC
// Note: Winforms may call this method during app exit at which point the DC may have been finalized already causing this assert to popup.
Debug.WriteLine(DbgUtil.StackTraceToStr(String.Format("ret[0]=DC.RestoreHdc(hDc=0x{1:x8})", result, unchecked ((int)this.hDC))));
#endif
Debug.Assert(contextStack != null, "Someone is calling RestoreHdc() before SaveHdc()");
if (contextStack != null)
{
GraphicsState g = (GraphicsState)contextStack.Pop();
hCurrentBmp = g.hBitmap;
hCurrentBrush = g.hBrush;
hCurrentPen = g.hPen;
hCurrentFont = g.hFont;
#if !DRAWING_NAMESPACE
if (g.font != null && g.font.IsAlive)
{
selectedFont = g.font.Target as WindowsFont;
}
else
{
WindowsFont previousFont = selectedFont;
selectedFont = null;
if (previousFont != null && MeasurementDCInfo.IsMeasurementDC(this))
{
previousFont.Dispose();
}
}
#endif
}
#if OPTIMIZED_MEASUREMENTDC
// in this case, GDI will copy back the previously saved font into the DC.
// we dont actually know what the font is in our measurement DC so
// we need to clear it off.
MeasurementDCInfo.ResetIfIsMeasurementDC(this.hDC);
#endif
}
/// <devdoc>
/// Selects the specified object into the dc and returns the old object.
/// </devdoc>
public IntPtr SelectObject(IntPtr hObj, GdiObjectType type)
{
switch (type)
{
case GdiObjectType.Pen:
hCurrentPen = hObj;
break;
case GdiObjectType.Brush:
hCurrentBrush = hObj;
break;
case GdiObjectType.Bitmap:
hCurrentBmp = hObj;
break;
}
return(IntUnsafeNativeMethods.SelectObject(new HandleRef(this, this.Hdc), new HandleRef(null, hObj)));
}