예제 #1
0
        internal void Dispose(bool disposing)
        {
            if (_disposed)
            {
                return;
            }

            Disposing?.Invoke(this, EventArgs.Empty);

            _disposed = true;

            DisposeFont(disposing);

            switch (DeviceContextType)
            {
            case DeviceContextType.Display:
                Debug.Assert(disposing, "WARNING: Finalizing a Display DeviceContext.\r\nReleaseDC may fail when not called from the same thread GetDC was called from.");

                ((IDeviceContext)this).ReleaseHdc();
                break;

            case DeviceContextType.Information:
            case DeviceContextType.NamedDevice:

                // CreateDC and CreateIC add an HDC handle to the HandleCollector; to remove it properly we need
                // to call DeleteHDC.
#if TRACK_HDC
                Debug.WriteLine(DbgUtil.StackTraceToStr(String.Format("DC.DeleteHDC(hdc=0x{0:x8})", unchecked ((int)this.hDC))));
#endif

                Gdi32.DeleteDC(_hDC);
                _hDC = IntPtr.Zero;
                break;

            case DeviceContextType.Memory:

                // CreatCompatibleDC adds a GDI handle to HandleCollector, to remove it properly we need to call
                // DeleteDC.
#if TRACK_HDC
                Debug.WriteLine(DbgUtil.StackTraceToStr(String.Format("DC.DeleteDC(hdc=0x{0:x8})", unchecked ((int)this.hDC))));
#endif
                Gdi32.DeleteDC(_hDC);
                _hDC = IntPtr.Zero;
                break;

            case DeviceContextType.Unknown:
            default:
                return;
                // do nothing, the hdc is not owned by this object.
                // in this case it is ok if disposed throught finalization.
            }

            DbgUtil.AssertFinalization(this, disposing);
        }
예제 #2
0
    static public void DrawXORRectangle(Graphics graphics, Pen pen, Rectangle rectangle)
    {
        IntPtr hDC  = graphics.GetHdc();
        IntPtr hPen = Gdi32.CreatePen(0, (int)pen.Width, ArgbToRGB(pen.Color.ToArgb()));

        Gdi32.SelectObject(hDC, hPen);
        Gdi32.SetROP2(hDC, (int)Gdi32.DrawingMode.R2_NOTXORPEN);
        Gdi32.Rectangle(hDC, rectangle.Left, rectangle.Top, rectangle.Right, rectangle.Bottom);
        Gdi32.DeleteObject(hPen);
        graphics.ReleaseHdc(hDC);
    }
예제 #3
0
        private static void Initialize()
        {
            if (s_isInitialized)
            {
                return;
            }

            using var dc    = User32.GetDcScope.ScreenDC;
            s_deviceDpi     = Gdi32.GetDeviceCaps(dc, Gdi32.DeviceCapability.LOGPIXELSX);
            s_isInitialized = true;
        }
예제 #4
0
        private static void Initialize()
        {
            if (isInitialized)
            {
                return;
            }

            using ScreenDC dc = ScreenDC.Create();
            deviceDpi         = Gdi32.GetDeviceCaps(dc, Gdi32.DeviceCapability.LOGPIXELSX);
            isInitialized     = true;
        }
예제 #5
0
파일: BmpObj.cs 프로젝트: rrossenbg/vprint
        /// <summary>
        /// Draws scanned image to an image object
        /// </summary>
        /// <param name="image"></param>
        public void CopyTo(Image image)
        {
            Debug.Assert(image != null);

            using (Graphics g = Graphics.FromImage(image))
            {
                IntPtr hdc = g.GetHdc();
                Gdi32.SetDIBitsToDevice(hdc, 0, 0, image.Width, image.Height, 0, 0, 0, Rect.Height, PxPtr, BmpPtr, 0);
                g.ReleaseHdc(hdc);
            }
        }
예제 #6
0
        public NotificationForm(string title, string desc)
        {
            InitializeComponent();
            this.components.SetStyle(this);
            Region = Region.FromHrgn(Gdi32.CreateRoundRectRgn(0, 0, Width, Height, 0, 0));

            // this.lbl_title.Text = title;
            this.txtBox_desc.Text = desc;

            lbl_time.Text = DateTime.Now.ToString("HH:mm");
        }
예제 #7
0
        public static FontCache.Scope GetHFONT(Font?font, Gdi32.QUALITY quality, Gdi32.HDC hdc)
        {
            if (font != null)
            {
                return(GetHFONT(font, quality));
            }

            // Font is null, build off of the specified HDC's current font.
            Gdi32.HFONT hfont = (Gdi32.HFONT)Gdi32.GetCurrentObject(hdc, Gdi32.OBJ.FONT);
            return(new FontCache.Scope(hfont));;
        }
예제 #8
0
 internal void Close()
 {
     if (Region != IntPtr.Zero)
     {
         User32.SetWindowRgn(Handle, IntPtr.Zero, false);
         Gdi32.DeleteObject(Region);
     }
     User32.CloseWindow(Handle);
     User32.SetParent((int)Handle, 0);
     User32.DestroyWindow(Handle);
 }
예제 #9
0
        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
            Gdi32.SelectObject(new HandleRef(this, Hdc), hInitialFont);
            selectedFont = null;
            hCurrentFont = hInitialFont;
        }
예제 #10
0
        public Color GetColor(int x, int y)
        {
            IntPtr hdc   = User32.GetDC(IntPtr.Zero);
            uint   pixel = Gdi32.GetPixel(hdc, x, y);

            User32.ReleaseDC(IntPtr.Zero, hdc);
            Color color = Color.FromArgb((int)(pixel & 0x000000FF),
                                         (int)(pixel & 0x0000FF00) >> 8,
                                         (int)(pixel & 0x00FF0000) >> 16);

            return(color);
        }
예제 #11
0
 /// <summary>Rounds the region of the control.</summary>
 /// <param name="control">The control to round.</param>
 /// <param name="rounding">The amount of rounding.</param>
 public static void RoundRegion(Control control, int rounding)
 {
     try
     {
         control.Region = Region.FromHrgn(Gdi32.CreateRoundRectRgn(0, 0, control.Width, control.Height, rounding, rounding));
     }
     catch (Exception e)
     {
         Console.WriteLine(e);
         throw;
     }
 }
예제 #12
0
        // Not all state is handled yet. Backfilling in as we write specific tests. Of special note is that we don't
        // have tracking for Save/RestoreDC yet.

        /// <summary>
        ///  Initialize the current state of <paramref name="hdc"/>.
        /// </summary>
        public DeviceContextState(Gdi32.HDC hdc)
        {
            MapMode   = Gdi32.GetMapMode(hdc);
            BackColor = Gdi32.GetBkColor(hdc);
            TextColor = Gdi32.GetTextColor(hdc);
            Point point = default;

            Gdi32.GetBrushOrgEx(hdc, ref point);
            BrushOrigin    = point;
            TextAlign      = Gdi32.GetTextAlign(hdc);
            BackgroundMode = Gdi32.GetBkMode(hdc);
        }
예제 #13
0
    static public void DrawXORLine(Graphics graphics, Pen pen, int x1, int y1, int x2, int y2)
    {
        IntPtr hDC  = graphics.GetHdc();
        IntPtr hPen = Gdi32.CreatePen(0, (int)pen.Width, ArgbToRGB(pen.Color.ToArgb()));

        Gdi32.SelectObject(hDC, hPen);
        Gdi32.SetROP2(hDC, (int)Gdi32.DrawingMode.R2_NOTXORPEN);
        Gdi32.MoveToEx(hDC, x1, y1, ref nullPoint);
        Gdi32.LineTo(hDC, x2, y2);
        Gdi32.DeleteObject(hPen);
        graphics.ReleaseHdc(hDC);
    }
        /// <para>Changes the current bitmap with a custom opacity level.  Here is where all happens!</para>
        public void SetBitmap(Bitmap bitmap, byte opacity)
        {
            if (bitmap.PixelFormat != PixelFormat.Format32bppArgb)
            {
                throw new ApplicationException("The bitmap must be 32ppp with alpha-channel.");
            }

            // The ideia of this is very simple,
            // 1. Create a compatible DC with screen;
            // 2. Select the bitmap with 32bpp with alpha-channel in the compatible DC;
            // 3. Call the UpdateLayeredWindow.

            var screenDc = Win32.GetDC(IntPtr.Zero);

            using (var memDc = new Gdi32.SafeDCHandle(Gdi32.CreateCompatibleDC(screenDc)))
            {
                var hBitmap   = IntPtr.Zero;
                var oldBitmap = IntPtr.Zero;

                try
                {
                    hBitmap   = bitmap.GetHbitmap(Color.FromArgb(0)); // grab a GDI handle from this GDI+ bitmap
                    oldBitmap = Gdi32.SelectObject(memDc, hBitmap);

                    var size        = new Win32.Size(bitmap.Width, bitmap.Height);
                    var pointSource = new Win32.Point(0, 0);
                    var topPos      = new Win32.Point(Left, Top);
                    var blend       = new Win32.Blendfunction
                    {
                        BlendOp             = Win32.AcSrcOver,
                        BlendFlags          = 0,
                        SourceConstantAlpha = opacity,
                        AlphaFormat         = Win32.AcSrcAlpha
                    };

                    Win32.UpdateLayeredWindow(Handle, screenDc, ref topPos, ref size, memDc.DangerousGetHandle(),
                                              ref pointSource, 0, ref blend,
                                              Win32.UlwAlpha);
                }
                finally
                {
                    Win32.ReleaseDC(IntPtr.Zero, screenDc);
                    if (hBitmap != IntPtr.Zero)
                    {
                        Gdi32.SelectObject(memDc, oldBitmap);
                        //Windows.DeleteObject(hBitmap); // The documentation says that we have to use the Windows.DeleteObject... but since there is no such method I use the normal DeleteObject from Win32 GDI and it's working fine without any resource leak.
                        Gdi32.DeleteObject(hBitmap);

                        Size = bitmap.Size;
                    }
                }
            }
        }
예제 #15
0
        public static BitmapSource GetImageSourceFromBitmap(Bitmap bmp)
        {
            IntPtr       hBmp = bmp.GetHbitmap();
            BitmapSource src  = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                hBmp,
                IntPtr.Zero,
                System.Windows.Int32Rect.Empty,
                BitmapSizeOptions.FromWidthAndHeight(bmp.Width, bmp.Height));

            Gdi32.DeleteObject(hBmp);
            return(src);
        }
예제 #16
0
        /*
         * DrawPoint
         */

        /// <summary>
        /// Draws the point on the specified graphics surface with the specified color at the specified
        /// coordinates.
        /// </summary>
        /// <exception cref="T:System.ArgumentNullException">
        /// <paramref name="g"/> is <see langword="null"/>.
        /// </exception>
        public static void DrawPoint(Graphics g, Color color, int x, int y)
        {
            if (g == null)
            {
                throw new ArgumentNullException("g");
            }

            IntPtr hDC = g.GetHdc();

            Gdi32.SetPixelV(hDC, x, y, color);
            g.ReleaseHdc(hDC);
        }
예제 #17
0
        protected override void CreateBrush()
        {
            IntPtr nativeHandle = Gdi32.CreateSolidBrush(ColorTranslator.ToWin32(Color));

            // Don't use Debug.Assert, DbgUtil.GetLastErrorStr would always be evaluated.
            if (nativeHandle == IntPtr.Zero)
            {
                Debug.Fail("CreateSolidBrush failed : " + DbgUtil.GetLastErrorStr());
            }

            HBrush = nativeHandle;
        }
예제 #18
0
        private void _IconsLoadingThreadRun()
        {
            while (true)
            {
                if (this._ShellViewEx != null && this._ShellViewEx.IsSearchNavigating)
                {
                    Thread.Sleep(1);
                    Application.DoEvents();
                }
                var index = 0;
                if (!ThreadRun_Helper(this._IconsForRetreval, false, ref index))
                {
                    continue;
                }
                var sho       = this._ShellViewEx.Items[index];
                var clonedSho = sho.Clone();
                if (!sho.IsIconLoaded || !sho.IsRCWSet)
                {
                    try {
                        //Thread.Sleep(1);
                        //Application.DoEvents();
                        //var temp = FileSystemListItem.ToFileSystemItem(sho.ParentHandle, sho.ParsingName.ToShellParsingName());
                        var icon          = clonedSho.GetHBitmap(this._CurrentSize, false, true);
                        var shieldOverlay = 0;

                        if (sho.ShieldedIconIndex == -1)
                        {
                            if ((clonedSho.GetShield() & IExtractIconPWFlags.GIL_SHIELD) != 0)
                            {
                                shieldOverlay = this._ShieldIconIndex;
                            }
                            sho.ShieldedIconIndex = shieldOverlay;
                        }

                        if (icon != IntPtr.Zero || shieldOverlay > 0)
                        {
                            sho.IsIconLoaded = true;
                            sho.IsRCWSet     = true;
                            Gdi32.DeleteObject(icon);
                            if (!this._RedrawQueue.Contains(index))
                            {
                                this._RedrawQueue.Enqueue(index);
                            }
                            // this._ShellViewEx.RedrawItem(index);
                        }
                        //Catch File not found exception since it happens if the file is laready deleted
                    } catch (FileNotFoundException) {
                    }
                }
                clonedSho.Dispose();
                sho.Dispose();
            }
        }
예제 #19
0
        private void DrawNCArea(IntPtr hRgn)
        {
            Region clipRegion = null;

            if (hRgn != TRUE)
            {
                clipRegion = Region.FromHrgn(hRgn);
            }

            RECT windowRect  = new RECT();
            RECT nclientRect = new RECT();
            RECT clientRect  = new RECT();


            User32.GetWindowRect(parentWindowHWnd, ref windowRect);
            User32.OffsetRect(ref windowRect, -windowRect.left, -windowRect.top);

            var height = windowRect.bottom;
            var width  = windowRect.right;


            User32.GetClientRect(parentWindowHWnd, ref clientRect);
            User32.OffsetRect(ref clientRect, -clientRect.left, -clientRect.top);

            User32.GetClientRect(parentWindowHWnd, ref nclientRect);

            User32.OffsetRect(ref nclientRect, -clientRect.left, -clientRect.top);
            User32.OffsetRect(ref nclientRect, borderSize, borderSize);


            IntPtr hDC = User32.GetWindowDC(parentWindowHWnd);

            var windowRectangle = new Rectangle(windowRect.left, windowRect.top, (int)windowRect.Width, (int)windowRect.Height);
            var clientRectangle = new Rectangle(nclientRect.left, nclientRect.top, (int)clientRect.Height, (int)clientRect.Width);



            try
            {
                COLORREF color  = new COLORREF(borderColor);
                IntPtr   hBrush = Gdi32.CreateSolidBrush(color.ColorDWORD);
                Gdi32.ExcludeClipRect(hDC, nclientRect.left, nclientRect.top, nclientRect.right, nclientRect.bottom);
                User32.FillRect(hDC, ref windowRect, hBrush);
                Gdi32.DeleteObject(hBrush);
            }
            catch (Exception ex)
            {
            }
            finally
            {
                User32.ReleaseDC(parentWindowHWnd, hDC);
            }
        }
예제 #20
0
 private unsafe void MirrorDcIfNeeded(Gdi32.HDC hdc)
 {
     if (_parent.IsMirrored)
     {
         // Mirror the DC
         Gdi32.SetMapMode(hdc, Gdi32.MM.ANISOTROPIC);
         Gdi32.GetViewportExtEx(hdc, out Size originalExtents);
         Gdi32.SetViewportExtEx(hdc, -originalExtents.Width, originalExtents.Height, null);
         Gdi32.GetViewportOrgEx(hdc, out Point originalOrigin);
         Gdi32.SetViewportOrgEx(hdc, originalOrigin.X + _windowBounds.Width - 1, originalOrigin.Y, null);
     }
 }
예제 #21
0
 public AccSettings()
 {
     InitializeComponent();
     this.components.SetStyle(this);
     Region = Region.FromHrgn(Gdi32.CreateRoundRectRgn(0, 0, Width, Height, 5, 5));
     foreach (var button in this.Controls.OfType <MetroFramework.Controls.MetroButton>())
     {
         IntPtr ptr = Gdi32.CreateRoundRectRgn(1, 1, button.Width, button.Height, 5, 5);
         button.Region = Region.FromHrgn(ptr);
         Gdi32.DeleteObject(ptr);
     }
 }
예제 #22
0
        public Rectangle ToRectangle()
        {
            if (IsInfinite)
            {
                return(new Rectangle(-int.MaxValue, -int.MaxValue, int.MaxValue, int.MaxValue));
            }

            var rect = new RECT();

            Gdi32.GetRgnBox(new HandleRef(this, nativeHandle), ref rect);
            return(new Rectangle(new Point(rect.left, rect.top), rect.Size));
        }
예제 #23
0
        internal unsafe static void DrawLine(this Gdi32.HDC hdc, Gdi32.HPEN pen, int x1, int y1, int x2, int y2)
        {
            using var ropScope  = new Gdi32.SetRop2Scope(hdc, Gdi32.R2.COPYPEN);
            using var bkScope   = new Gdi32.SetBkModeScope(hdc, Gdi32.BKMODE.TRANSPARENT);
            using var selection = new Gdi32.SelectObjectScope(hdc, pen);

            Point oldPoint = new Point();

            Gdi32.MoveToEx(hdc, x1, y1, &oldPoint);
            Gdi32.LineTo(hdc, x2, y2);
            Gdi32.MoveToEx(hdc, oldPoint.X, oldPoint.Y, &oldPoint);
        }
예제 #24
0
        public AddAcc()
        {
            InitializeComponent(); this.Activate();
            this.components.SetStyle(this);
            this.FormBorderStyle = FormBorderStyle.None;
            Region = System.Drawing.Region.FromHrgn(Gdi32.CreateRoundRectRgn(0, 0, Width, Height, 5, 5));

            IntPtr ptr = Gdi32.CreateRoundRectRgn(1, 1, btn_addAcc.Width, btn_addAcc.Height, 5, 5);

            btn_addAcc.Region = Region.FromHrgn(ptr);
            Gdi32.DeleteObject(ptr);
        }
예제 #25
0
        // capture a region of a the screen, defined by the hWnd
        public static BitmapSource CaptureRegion(
            IntPtr hWnd, int x, int y, int width, int height, bool addToClipboard)
        {
            IntPtr       sourceDC = IntPtr.Zero;
            IntPtr       targetDC = IntPtr.Zero;
            IntPtr       compatibleBitmapHandle = IntPtr.Zero;
            BitmapSource bitmap = null;

            try
            {
                // gets the main desktop and all open windows
                sourceDC = User32.GetDC(User32.GetDesktopWindow());
                //sourceDC = User32.GetDC(hWnd);
                targetDC = Gdi32.CreateCompatibleDC(sourceDC);

                // create a bitmap compatible with our target DC
                compatibleBitmapHandle = Gdi32.CreateCompatibleBitmap(sourceDC, width, height);

                // gets the bitmap into the target device context
                Gdi32.SelectObject(targetDC, compatibleBitmapHandle);

                // copy from source to destination
                Gdi32.BitBlt(targetDC, 0, 0, width, height, sourceDC, x, y, Gdi32.SRCCOPY);

                // Here's the WPF glue to make it all work. It converts from an
                // hBitmap to a BitmapSource. Love the WPF interop functions
                bitmap = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                    compatibleBitmapHandle, IntPtr.Zero, Int32Rect.Empty,
                    BitmapSizeOptions.FromEmptyOptions());

                if (addToClipboard)
                {
                    //Clipboard.SetImage(bitmap); // high memory usage for large images
                    IDataObject data = new DataObject();
                    data.SetData(DataFormats.Dib, bitmap, false);
                    Clipboard.SetDataObject(data, false);
                }
            }
            catch (Exception ex)
            {
                throw new ScreenCaptureException(string.Format("Error capturing region {0},{1},{2},{3}", x, y, width, height), ex);
            }
            finally
            {
                Gdi32.DeleteObject(compatibleBitmapHandle);

                User32.ReleaseDC(IntPtr.Zero, sourceDC);
                User32.ReleaseDC(IntPtr.Zero, targetDC);
            }

            return(bitmap);
        }
예제 #26
0
        /// <summary>
        ///  Draws the text in the given bounds, using the given Font, foreColor and backColor, and according to the specified
        ///  TextFormatFlags flags.
        ///
        ///  If font is null, the font currently selected in the hdc is used.
        ///
        ///  If foreColor and/or backColor are Color.Empty, the hdc current text and/or background color are used.
        /// </summary>
        public static void DrawText(
            this Gdi32.HDC hdc,
            ReadOnlySpan <char> text,
            FontCache.Scope font,
            Rectangle bounds,
            Color foreColor,
            User32.DT flags,
            Color backColor            = default,
            TextPaddingOptions padding = default)
        {
            if (text.IsEmpty || foreColor == Color.Transparent)
            {
                return;
            }

            ValidateFlags(flags);

            // DrawText requires default text alignment.
            using var alignment = new Gdi32.SetTextAlignmentScope(hdc, default);

            // Color empty means use the one currently selected in the dc.
            using var textColor = foreColor.IsEmpty ? default : new Gdi32.SetTextColorScope(hdc, foreColor);
                                  using var fontSelection = new Gdi32.SelectObjectScope(hdc, (Gdi32.HFONT)font);

                                  Gdi32.BKMODE newBackGroundMode = (backColor.IsEmpty || backColor == Color.Transparent) ?
                                                                   Gdi32.BKMODE.TRANSPARENT :
                                                                   Gdi32.BKMODE.OPAQUE;

                                  using var backgroundMode  = new Gdi32.SetBkModeScope(hdc, newBackGroundMode);
                                  using var backgroundColor = newBackGroundMode != Gdi32.BKMODE.TRANSPARENT
                ? new Gdi32.SetBackgroundColorScope(hdc, backColor)
                : default;

                                  User32.DRAWTEXTPARAMS dtparams = GetTextMargins(font, padding);

                                  bounds = AdjustForVerticalAlignment(hdc, text, bounds, flags, ref dtparams);

                                  // Adjust unbounded rect to avoid overflow since Rectangle ctr does not do param validation.
                                  if (bounds.Width == TextRenderer.MaxSize.Width)
                                  {
                                      bounds.Width -= bounds.X;
                                  }

                                  if (bounds.Height == TextRenderer.MaxSize.Height)
                                  {
                                      bounds.Height -= bounds.Y;
                                  }

                                  RECT rect = bounds;

                                  User32.DrawTextExW(hdc, text, ref rect, flags, ref dtparams);
        }
예제 #27
0
        public override void Create()
        {
            this.wndProc = new WndProc(WndProc);

            WndClass wndClass;

            wndClass.style         = ClassStyles.HorizontalRedraw | ClassStyles.VerticalRedraw | ClassStyles.OwnDC;
            wndClass.lpfnWndProc   = wndProc;
            wndClass.cbClsExtra    = 0;
            wndClass.cbWndExtra    = 0;
            wndClass.hInstance     = hInstance;
            wndClass.hIcon         = User32.LoadIcon(IntPtr.Zero, SystemIcons.Application);
            wndClass.hCursor       = User32.LoadCursor(IntPtr.Zero, IdcStandardCursors.Arrow);
            wndClass.hbrBackground = Gdi32.GetStockObject(StockObjects.BlackBrush);
            wndClass.lpszMenuName  = null;
            wndClass.lpszClassName = className;

            if (User32.RegisterClass(ref wndClass) == 0)
            {
                throw new WindowException("RegisterClass failed");
            }

            WindowStyles dwStyle = WindowStyles.Popup | WindowStyles.ClipChildren | WindowStyles.ClipSiblings;

            if (Mode == WindowMode.Windowed)
            {
                dwStyle |= WindowStyles.SysMenu | WindowStyles.Caption;
            }

            Handle = User32.CreateWindowEx(
                WindowStylesEx.Left,
                className,
                Title,
                dwStyle,
                X,
                Y,
                Width,
                Height,
                IntPtr.Zero,  // hWndParent
                IntPtr.Zero,  // hMenu
                hInstance,
                IntPtr.Zero); // lpParam

            if (Handle == IntPtr.Zero)
            {
                throw new WindowException("CreateWindowEx failed");
            }

            OnCreated();

            AdjustWindow(X, Y, Width, Height);
        }
예제 #28
0
        internal static void GetDevicePixels(HandleRef handleRef, out double x, out double y)
        {
            x = LogicalDpi;
            y = LogicalDpi;
            Gdi32.HDC hDC = User32.GetDC(handleRef);
            if (!hDC.IsNull)
            {
                x = Gdi32.GetDeviceCaps(hDC, Gdi32.DeviceCapability.LOGPIXELSX);
                y = Gdi32.GetDeviceCaps(hDC, Gdi32.DeviceCapability.LOGPIXELSY);

                User32.ReleaseDC(handleRef, hDC);
            }
        }
            private bool GetTextExtentPoint32(char item, out Size size)
            {
                size = new Size();

                using var hdc = new GetDcScope(_owningChildEdit.Handle);
                if (hdc.IsNull)
                {
                    return(false);
                }

                // Add the width of the character at that position.
                return(Gdi32.GetTextExtentPoint32W(hdc, item.ToString(), 1, ref size).IsTrue());
            }
예제 #30
0
 /// <summary>Rounds the region of the control.</summary>
 /// <param name="form">The form control to round.</param>
 /// <param name="rounding">The amount of rounding.</param>
 public static void RoundRegion(Form form, int rounding)
 {
     try
     {
         form.FormBorderStyle = FormBorderStyle.None;
         form.Region          = Region.FromHrgn(Gdi32.CreateRoundRectRgn(0, 0, form.Width, form.Height, rounding, rounding));
     }
     catch (Exception e)
     {
         Console.WriteLine(e);
         throw;
     }
 }