/// <summary> /// Sets the DC Viewport extent to the specified value and returns its previous value; /// extent values are in device units. /// </summary> public Size SetViewportExtent(Size newExtent) { Size oldExtent = new Size(); IntUnsafeNativeMethods.SetViewportExtEx(new HandleRef(this, Hdc), newExtent.Width, newExtent.Height, ref oldExtent); return(oldExtent); }
/// <summary> /// Creates a WindowsFont from the handle to a native GDI font and optionally takes ownership of managing /// the lifetime of the handle. /// </summary> public unsafe static WindowsFont FromHfont(IntPtr hFont, bool takeOwnership = false) { NativeMethods.LOGFONTW logFont = new NativeMethods.LOGFONTW(); IntUnsafeNativeMethods.GetObjectW(new HandleRef(null, hFont), sizeof(NativeMethods.LOGFONTW), ref logFont); FontStyle style = FontStyle.Regular; if (logFont.lfWeight == IntNativeMethods.FW_BOLD) { style |= FontStyle.Bold; } if (logFont.lfItalic == True) { style |= FontStyle.Italic; } if (logFont.lfUnderline == True) { style |= FontStyle.Underline; } if (logFont.lfStrikeOut == True) { style |= FontStyle.Strikeout; } WindowsFont wf = new WindowsFont(logFont, style, createHandle: false) { Hfont = hFont, _ownHandle = takeOwnership // if true, hFont will be deleted on dispose. }; return(wf); }
public IntNativeMethods.TEXTMETRIC GetTextMetrics() { IntNativeMethods.TEXTMETRIC lptm = new IntNativeMethods.TEXTMETRIC(); HandleRef hDC = new HandleRef(this.dc, this.dc.Hdc); bool flag = this.dc.MapMode != DeviceContextMapMode.Text; if (flag) { this.dc.SaveHdc(); } try { if (flag) { DeviceContextMapMode mode = this.dc.SetMapMode(DeviceContextMapMode.Text); } IntUnsafeNativeMethods.GetTextMetrics(hDC, ref lptm); } finally { if (flag) { this.dc.RestoreHdc(); } } return(lptm); }
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 DrawLine(WindowsPen pen, int x1, int y1, int x2, int y2) { HandleRef hdc = new HandleRef(this.dc, this.dc.Hdc); DeviceContextBinaryRasterOperationFlags binaryRasterOperation = this.dc.BinaryRasterOperation; DeviceContextBackgroundMode backgroundMode = this.dc.BackgroundMode; if (binaryRasterOperation != DeviceContextBinaryRasterOperationFlags.CopyPen) { binaryRasterOperation = this.dc.SetRasterOperation(DeviceContextBinaryRasterOperationFlags.CopyPen); } if (backgroundMode != DeviceContextBackgroundMode.Transparent) { backgroundMode = this.dc.SetBackgroundMode(DeviceContextBackgroundMode.Transparent); } if (pen != null) { this.dc.SelectObject(pen.HPen, GdiObjectType.Pen); } IntNativeMethods.POINT pt = new IntNativeMethods.POINT(); IntUnsafeNativeMethods.MoveToEx(hdc, x1, y1, pt); IntUnsafeNativeMethods.LineTo(hdc, x2, y2); if (backgroundMode != DeviceContextBackgroundMode.Transparent) { this.dc.SetBackgroundMode(backgroundMode); } if (binaryRasterOperation != DeviceContextBinaryRasterOperationFlags.CopyPen) { this.dc.SetRasterOperation(binaryRasterOperation); } IntUnsafeNativeMethods.MoveToEx(hdc, pt.x, pt.y, null); }
public Color GetNearestColor(Color color) { HandleRef hdc = new HandleRef(null, DeviceContext.Hdc); int colorResult = IntUnsafeNativeMethods.GetNearestColor(hdc, ColorTranslator.ToWin32(color)); return(ColorTranslator.FromWin32(colorResult)); }
/// Drawing methods. public unsafe void DrawPie(WindowsPen pen, Rectangle bounds, float startAngle, float sweepAngle) { HandleRef hdc = new HandleRef(DeviceContext, DeviceContext.Hdc); if (pen != null) { // 1. Select the pen in the DC Gdi32.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); Point oldPoint = default; IntUnsafeNativeMethods.MoveToEx(hdc, p.X, p.Y, &oldPoint); IntUnsafeNativeMethods.AngleArc(hdc, p.X, p.Y, radius, startAngle, sweepAngle); IntUnsafeNativeMethods.LineTo(hdc, p.X, p.Y); IntUnsafeNativeMethods.EndPath(hdc); IntUnsafeNativeMethods.StrokePath(hdc); }
public void DrawRectangle(WindowsPen pen, int x, int y, int width, int height) { Debug.Assert(pen != null, "pen == null"); HandleRef hdc = new HandleRef(DeviceContext, DeviceContext.Hdc); if (pen != null) { DeviceContext.SelectObject(pen.HPen, GdiObjectType.Pen); } Gdi32.R2 rasterOp = DeviceContext.BinaryRasterOperation; if (rasterOp != Gdi32.R2.COPYPEN) { rasterOp = DeviceContext.SetRasterOperation(Gdi32.R2.COPYPEN); } Gdi32.SelectObject(hdc, Gdi32.GetStockObject(Gdi32.StockObject.HOLLOW_BRUSH)); // Add 1 to width and height to create the 'bounding box' (convert from point to size). IntUnsafeNativeMethods.Rectangle(hdc, x, y, x + width, y + height); if (rasterOp != Gdi32.R2.COPYPEN) { DeviceContext.SetRasterOperation(rasterOp); } }
/// <summary> /// Sets the DC Viewport origin to the specified value and returns its previous value; /// origin values are in device units. /// </summary> public unsafe Point SetViewportOrigin(Point newOrigin) { var oldOrigin = new Point(); IntUnsafeNativeMethods.SetViewportOrgEx(new HandleRef(this, Hdc), newOrigin.X, newOrigin.Y, &oldOrigin); return(oldOrigin); }
/// <summary> /// Creates the font handle. /// </summary> private unsafe WindowsFont(NativeMethods.LOGFONTW logFont, FontStyle style, bool createHandle) { Debug.Assert(Hfont == IntPtr.Zero, "hFont is not null, this will generate a handle leak."); _logFont = logFont; if (_logFont.FaceName.Length == 0) { _logFont.FaceName = DefaultFaceName; } Style = style; if (createHandle) { Hfont = IntUnsafeNativeMethods.CreateFontIndirectW(ref _logFont); if (Hfont == IntPtr.Zero) { _logFont.FaceName = DefaultFaceName; _logFont.lfOutPrecision = IntNativeMethods.OUT_TT_ONLY_PRECIS; // TrueType only. Hfont = IntUnsafeNativeMethods.CreateFontIndirectW(ref _logFont); } // Update logFont height and other adjusted parameters. IntUnsafeNativeMethods.GetObjectW(new HandleRef(this, Hfont), sizeof(NativeMethods.LOGFONTW), ref _logFont); // We created the hFont, we will delete it on dispose. _ownHandle = true; } }
// 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(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); }
public void FillRectangle(WindowsBrush brush, int x, int y, int width, int height) { HandleRef hDC = new HandleRef(this.dc, this.dc.Hdc); IntPtr hBrush = brush.HBrush; IntNativeMethods.RECT rect = new IntNativeMethods.RECT(x, y, x + width, y + height); IntUnsafeNativeMethods.FillRect(hDC, ref rect, new HandleRef(brush, hBrush)); }
void IDeviceContext.ReleaseHdc() { if ((this.hDC != IntPtr.Zero) && (this.dcType == System.Windows.Forms.Internal.DeviceContextType.Display)) { IntUnsafeNativeMethods.ReleaseDC(new HandleRef(this, this.hWnd), new HandleRef(this, this.hDC)); this.hDC = IntPtr.Zero; } }
IntPtr IDeviceContext.GetHdc() { if (this.hDC == IntPtr.Zero) { this.hDC = IntUnsafeNativeMethods.GetDC(new HandleRef(this, this.hWnd)); } return(this.hDC); }
/// <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 static WindowsFont FromHfont(IntPtr hFont, bool takeOwnership) { IntNativeMethods.LOGFONT lp = new IntNativeMethods.LOGFONT(); IntUnsafeNativeMethods.GetObject(new HandleRef(null, hFont), lp); return(new WindowsFont(lp, false) { hFont = hFont, ownHandle = takeOwnership }); }
public Rectangle ToRectangle() { if (this.IsInfinite) { return(new Rectangle(-2147483647, -2147483647, 0x7fffffff, 0x7fffffff)); } IntNativeMethods.RECT clipRect = new IntNativeMethods.RECT(); IntUnsafeNativeMethods.GetRgnBox(new HandleRef(this, this.nativeHandle), ref clipRect); return(new Rectangle(new Point(clipRect.left, clipRect.top), clipRect.Size)); }
public void FillRectangle(WindowsBrush brush, int x, int y, int width, int height) { Debug.Assert(brush != null, "brush == null"); HandleRef hdc = new HandleRef(dc, dc.Hdc); IntPtr hBrush = brush.HBrush; // We don't delete this handle since we didn't create it. RECT rect = new RECT(x, y, x + width, y + height); IntUnsafeNativeMethods.FillRect(hdc, ref rect, new HandleRef(brush, hBrush)); }
/// <summary> /// A rectangle representing the window region set with the SetWindowRgn function. /// </summary> public Rectangle ToRectangle() { if (IsInfinite) { return(new Rectangle(-int.MaxValue, -int.MaxValue, int.MaxValue, int.MaxValue)); } IntNativeMethods.RECT rect = new IntNativeMethods.RECT(); IntUnsafeNativeMethods.GetRgnBox(new HandleRef(this, nativeHandle), ref rect); return(new Rectangle(new Point(rect.left, rect.top), rect.Size)); }
private DeviceContext(IntPtr hDC, System.Windows.Forms.Internal.DeviceContextType dcType) { this.hWnd = (IntPtr)(-1); this.hDC = hDC; this.dcType = dcType; this.CacheInitialState(); DeviceContexts.AddDeviceContext(this); if (dcType == System.Windows.Forms.Internal.DeviceContextType.Display) { this.hWnd = IntUnsafeNativeMethods.WindowFromDC(new HandleRef(this, this.hDC)); } }
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(Hdc); #endif IntUnsafeNativeMethods.SelectObject(new HandleRef(this, Hdc), new HandleRef(null, hInitialFont)); selectedFont = null; hCurrentFont = hInitialFont; }
private void CreateFont() { this.hFont = IntUnsafeNativeMethods.CreateFontIndirect(this.logFont); if (this.hFont == IntPtr.Zero) { this.logFont.lfFaceName = "Microsoft Sans Serif"; this.logFont.lfOutPrecision = 7; this.hFont = IntUnsafeNativeMethods.CreateFontIndirect(this.logFont); } IntUnsafeNativeMethods.GetObject(new HandleRef(this, this.hFont), this.logFont); this.ownHandle = true; }
public void IntersectClip(WindowsRegion wr) { if (wr.HRegion != IntPtr.Zero) { using (WindowsRegion region = new WindowsRegion(0, 0, 0, 0)) { if (IntUnsafeNativeMethods.GetClipRgn(new HandleRef(this, this.Hdc), new HandleRef(region, region.HRegion)) == 1) { wr.CombineRegion(region, wr, RegionCombineMode.AND); } this.SetClip(wr); } } }
private void DrawEllipse(WindowsPen pen, WindowsBrush brush, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect) { HandleRef hdc = new HandleRef(this.dc, this.dc.Hdc); if (pen != null) { IntUnsafeNativeMethods.SelectObject(hdc, new HandleRef(pen, pen.HPen)); } if (brush != null) { IntUnsafeNativeMethods.SelectObject(hdc, new HandleRef(brush, brush.HBrush)); } IntUnsafeNativeMethods.Ellipse(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect); }
public void Dispose(bool disposing) { if (this.nativeHandle != IntPtr.Zero) { if (this.ownHandle) { IntUnsafeNativeMethods.DeleteObject(new HandleRef(this, this.nativeHandle)); } this.nativeHandle = IntPtr.Zero; if (disposing) { GC.SuppressFinalize(this); } } }
internal void Dispose(bool disposing) { bool flag = false; if ((this.ownHandle && (!this.ownedByCacheManager || !disposing)) && ((this.everOwnedByCacheManager || !disposing) || !DeviceContexts.IsFontInUse(this))) { IntUnsafeNativeMethods.DeleteObject(new HandleRef(this, this.hFont)); this.hFont = IntPtr.Zero; this.ownHandle = false; flag = true; } if (disposing && (flag || !this.ownHandle)) { GC.SuppressFinalize(this); } }
/// <summary> /// Constructor to contruct a DeviceContext object from an existing Win32 device context handle. /// </summary> private DeviceContext(IntPtr hDC, DeviceContextType dcType) { this.hDC = hDC; this.dcType = dcType; CacheInitialState(); DeviceContexts.AddDeviceContext(this); if (dcType == DeviceContextType.Display) { 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 }
internal void DisposeFont(bool disposing) { if (disposing) { DeviceContexts.RemoveDeviceContext(this); } if ((this.selectedFont != null) && (this.selectedFont.Hfont != IntPtr.Zero)) { if (IntUnsafeNativeMethods.GetCurrentObject(new HandleRef(this, this.hDC), 6) == this.selectedFont.Hfont) { IntUnsafeNativeMethods.SelectObject(new HandleRef(this, this.Hdc), new HandleRef(null, this.hInitialFont)); IntPtr hInitialFont = this.hInitialFont; } this.selectedFont.Dispose(disposing); this.selectedFont = null; } }
public IntPtr SelectObject(IntPtr hObj, GdiObjectType type) { switch (type) { case GdiObjectType.Pen: this.hCurrentPen = hObj; break; case GdiObjectType.Brush: this.hCurrentBrush = hObj; break; case GdiObjectType.Bitmap: this.hCurrentBmp = hObj; break; } return(IntUnsafeNativeMethods.SelectObject(new HandleRef(this, this.Hdc), new HandleRef(null, hObj))); }
/// <summary> /// 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. /// </summary> 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, 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 (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(); } } } #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(hDC); #endif }