Ejemplo n.º 1
0
        ///<summary>
        /// Creates a new clipping region from the intersection of the current clipping region and the specified rectangle.
        ///</summary>
        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, _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();
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Selects a region as the current clipping region for the device context.
        /// Remarks (From MSDN):
        /// - Only a copy of the selected region is used. The region itself can be selected for any number of other device contexts or it can be deleted.
        /// - The SelectClipRgn function assumes that the coordinates for a region are specified in device units.
        /// - To remove a device-context's clipping region, specify a NULL region handle.
        /// </summary>
        public void SetClip(WindowsRegion region)
        {
            HandleRef hdc     = new HandleRef(this, _hDC);
            HandleRef hRegion = new HandleRef(region, region.HRegion);

            Interop.Gdi32.SelectClipRgn(hdc, hRegion);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Selects a region as the current clipping region for the device context.
        /// Remarks (From MSDN):
        /// - Only a copy of the selected region is used. The region itself can be selected for any number of other device contexts or it can be deleted.
        /// - The SelectClipRgn function assumes that the coordinates for a region are specified in device units.
        /// - To remove a device-context's clipping region, specify a NULL region handle.
        /// </summary>
        public void SetClip(WindowsRegion region)
        {
            HandleRef hdc     = new HandleRef(this, _hDC);
            HandleRef hRegion = new HandleRef(region, region.HRegion);

            IntUnsafeNativeMethods.SelectClipRgn(hdc, hRegion);
        }
        public void SetClip(WindowsRegion region)
        {
            HandleRef hDC  = new HandleRef(this, this.Hdc);
            HandleRef hRgn = new HandleRef(region, region.HRegion);

            IntUnsafeNativeMethods.SelectClipRgn(hDC, hRgn);
        }
Ejemplo n.º 5
0
        public static WindowsGraphics FromGraphics(Graphics g, ApplyGraphicsProperties properties)
        {
            Debug.Assert(g != null, "null Graphics object.");

            WindowsRegion?wr = null;

            PointF offset = default;

            if (properties != ApplyGraphicsProperties.None)
            {
                Region?clip = null;

                if (properties.HasFlag(ApplyGraphicsProperties.Clipping))
                {
                    g.GetContextInfo(out offset, out clip);
                }
                else
                {
                    g.GetContextInfo(out offset);
                }

                if (clip is not null)
                {
                    // We have to create the WindowsRegion and dipose the Region object before locking the Graphics object,
                    // in case of an unlikely exception before releasing the WindowsRegion, the finalizer will do it for us.
                    // (no try-finally block since this method is used frequently - perf).

                    // If clipping has not been set (Region.IsInfinite) GetContextInfo will return a null Region.

                    wr = WindowsRegion.FromRegion(clip, g); // WindowsRegion will take ownership of the hRegion.
                    clip.Dispose();                         // Disposing the Region object doesn't destroy the hRegion.
                }
            }

            WindowsGraphics wg = FromHdc(g.GetHdc()); // This locks the Graphics object.

            wg._graphics = g;

            // Apply transform and clip
            if (wr is not null)
            {
                using (wr)
                {
                    // If the Graphics object was created from a native DC the actual clipping region is the intersection
                    // beteween the original DC clip region and the GDI+ one - for display Graphics it is the same as
                    // Graphics.VisibleClipBounds.
                    wg.DeviceContext.IntersectClip(wr);
                }
            }

            if (offset != default)
            {
                // elements (XFORM) = [eM11, eM12, eM21, eM22, eDx, eDy], eDx/eDy specify the translation offset.
                wg.DeviceContext.TranslateTransform((int)offset.X, (int)offset.Y);
            }

            return(wg);
        }
 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);
         }
     }
 }
        public static WindowsGraphics FromGraphics(Graphics g, ApplyGraphicsProperties properties)
        {
            WindowsRegion wr = null;

            float[] elements = null;
            Region  region   = null;
            Matrix  matrix   = null;

            if (((properties & ApplyGraphicsProperties.TranslateTransform) != ApplyGraphicsProperties.None) || ((properties & ApplyGraphicsProperties.Clipping) != ApplyGraphicsProperties.None))
            {
                object[] contextInfo = g.GetContextInfo() as object[];
                if ((contextInfo != null) && (contextInfo.Length == 2))
                {
                    region = contextInfo[0] as Region;
                    matrix = contextInfo[1] as Matrix;
                }
                if (matrix != null)
                {
                    if ((properties & ApplyGraphicsProperties.TranslateTransform) != ApplyGraphicsProperties.None)
                    {
                        elements = matrix.Elements;
                    }
                    matrix.Dispose();
                }
                if (region != null)
                {
                    if (((properties & ApplyGraphicsProperties.Clipping) != ApplyGraphicsProperties.None) && !region.IsInfinite(g))
                    {
                        wr = WindowsRegion.FromRegion(region, g);
                    }
                    region.Dispose();
                }
            }
            WindowsGraphics graphics = FromHdc(g.GetHdc());

            graphics.graphics = g;
            if (wr != null)
            {
                using (wr)
                {
                    graphics.DeviceContext.IntersectClip(wr);
                }
            }
            if (elements != null)
            {
                graphics.DeviceContext.TranslateTransform((int)elements[4], (int)elements[5]);
            }
            return(graphics);
        }
Ejemplo n.º 8
0
        public static WindowsRegion FromHregion(IntPtr hRegion, bool takeOwnership)
        {
            WindowsRegion region = new WindowsRegion();

            if (hRegion != IntPtr.Zero)
            {
                region.nativeHandle = hRegion;
                if (takeOwnership)
                {
                    region.ownHandle = true;
                    System.Internal.HandleCollector.Add(hRegion, IntSafeNativeMethods.CommonHandles.GDI);
                }
            }
            return(region);
        }
Ejemplo n.º 9
0
        /// <devdoc>
        ///     Creates a WindowsRegion from a System.Drawing.Region.
        /// </devdoc>
        public static WindowsRegion FromRegion(Region region, Graphics g)
        {
            if (region.IsInfinite(g))
            {
                // An infinite region would cover the entire device region which is the same as
                // not having a clipping region. Observe that this is not the same as having an
                // empty region, which when clipping to it has the effect of excluding the entire
                // device region.
                // To remove the clip region from a dc the SelectClipRgn() function needs to be
                // called with a null region ptr - that's why we use the empty constructor here.
                // GDI+ will return IntPtr.Zero for Region.GetHrgn(Graphics) when the region is
                // Infinite.
                return(new WindowsRegion());
            }

            return(WindowsRegion.FromHregion(region.GetHrgn(g), true));
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Creates a WindowsRegion from a region handle, if 'takeOwnership' is true, the handle is added to the
        /// HandleCollector and is removed &amp; destroyed on dispose.
        /// </summary>
        public static WindowsRegion FromHregion(IntPtr hRegion, bool takeOwnership)
        {
            WindowsRegion wr = new WindowsRegion();

            // Note: Passing IntPtr.Zero for hRegion is ok.  GDI+ infinite regions will have hRegion == null.
            // GDI's SelectClipRgn interprets null region handle as resetting the clip region (all region will be available for painting).
            if (hRegion != IntPtr.Zero)
            {
                wr._nativeHandle = hRegion;

                if (takeOwnership)
                {
                    wr._ownHandle = true;
                }
            }
            return(wr);
        }
Ejemplo n.º 11
0
 /// <summary>
 /// Combines region1 &amp; region2 into this region. The regions cannot be null. The three regions need not be
 /// distinct. For example, the sourceRgn1 can equal this region.
 /// </summary>
 public IntNativeMethods.RegionFlags CombineRegion(WindowsRegion region1, WindowsRegion region2, RegionCombineMode mode)
 {
     return(IntUnsafeNativeMethods.CombineRgn(new HandleRef(this, HRegion), new HandleRef(region1, region1.HRegion), new HandleRef(region2, region2.HRegion), mode));
 }
Ejemplo n.º 12
0
        public static WindowsGraphics FromGraphics(Graphics g, ApplyGraphicsProperties properties)
        {
            Debug.Assert(g != null, "null Graphics object.");

            WindowsRegion wr = null;

            float[] elements = null;

            Region clipRgn     = null;
            Matrix worldTransf = null;

            if ((properties & ApplyGraphicsProperties.TranslateTransform) != 0 || (properties & ApplyGraphicsProperties.Clipping) != 0)
            {
                if (g.GetContextInfo() is object[] data && data.Length == 2)
                {
                    clipRgn     = data[0] as Region;
                    worldTransf = data[1] as Matrix;
                }

                if (worldTransf != null)
                {
                    if ((properties & ApplyGraphicsProperties.TranslateTransform) != 0)
                    {
                        elements = worldTransf.Elements;
                    }

                    worldTransf.Dispose();
                }

                if (clipRgn != null)
                {
                    if ((properties & ApplyGraphicsProperties.Clipping) != 0)
                    {
                        // We have to create the WindowsRegion and dipose the Region object before locking the Graphics object,
                        // in case of an unlikely exception before releasing the WindowsRegion, the finalizer will do it for us.
                        // (no try-finally block since this method is used frequently - perf).
                        // If the Graphics.Clip has not been set (Region.IsInfinite) we don't need to apply it to the DC.
                        if (!clipRgn.IsInfinite(g))
                        {
                            wr = WindowsRegion.FromRegion(clipRgn, g); // WindowsRegion will take ownership of the hRegion.
                        }
                    }

                    clipRgn.Dispose(); // Disposing the Region object doesn't destroy the hRegion.
                }
            }

            WindowsGraphics wg = FromHdc(g.GetHdc()); // This locks the Graphics object.

            wg._graphics = g;

            // Apply transform and clip
            if (wr != null)
            {
                using (wr)
                {
                    // If the Graphics object was created from a native DC the actual clipping region is the intersection
                    // beteween the original DC clip region and the GDI+ one - for display Graphics it is the same as
                    // Graphics.VisibleClipBounds.
                    wg.DeviceContext.IntersectClip(wr);
                }
            }

            if (elements != null)
            {
                // elements (XFORM) = [eM11, eM12, eM21, eM22, eDx, eDy], eDx/eDy specify the translation offset.
                wg.DeviceContext.TranslateTransform((int)elements[4], (int)elements[5]);
            }

            return(wg);
        }
Ejemplo n.º 13
0
 /// <summary>
 /// Combines region1 &amp; region2 into this region. The regions cannot be null. The three regions need not be
 /// distinct. For example, the sourceRgn1 can equal this region.
 /// </summary>
 public Interop.RegionType CombineRegion(WindowsRegion region1, WindowsRegion region2, Interop.Gdi32.CombineMode mode)
 {
     return(Interop.Gdi32.CombineRgn(new HandleRef(this, HRegion), new HandleRef(region1, region1.HRegion), new HandleRef(region2, region2.HRegion), mode));
 }