WindowsRegion.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Misc / GDI / WindowsRegion.cs / 1305376 / WindowsRegion.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

#if [....]_NAMESPACE 
namespace System.Windows.Forms.Internal 
#elif DRAWING_NAMESPACE
namespace System.Drawing.Internal 
#else
namespace System.Experimental.Gdi
#endif
{ 
    using System;
    using System.Internal; 
    using System.Runtime.InteropServices; 
    using System.ComponentModel;
    using System.Diagnostics; 
    using System.Diagnostics.CodeAnalysis;
    using System.Drawing;
    using System.Globalization;
    using System.Runtime.Versioning; 

    ///  
    ///      
    ///         Encapsulates a GDI Region object.
    ///      
    /// 

#if [....]_PUBLIC_GRAPHICS_LIBRARY
    public 
#else
    internal 
#endif 
    sealed partial class WindowsRegion : MarshalByRefObject, ICloneable, IDisposable
    { 
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2006:UseSafeHandleToEncapsulateNativeResources")]
        private IntPtr nativeHandle; // The hRegion, this class always takes ownership of the hRegion.
        private bool ownHandle;
 
#if GDI_FINALIZATION_WATCH
        private string AllocationSite = DbgUtil.StackTrace; 
#endif 

        ///  
        /// 
        private WindowsRegion() {
        }
 
        /// 
        ///  
        [ResourceExposure(ResourceScope.Process)] 
        [ResourceConsumption(ResourceScope.Process)]
        public WindowsRegion(Rectangle rect) { 
            CreateRegion(rect);
        }

        ///  
        /// 
        [ResourceExposure(ResourceScope.Process)] 
        [ResourceConsumption(ResourceScope.Process)] 
        public WindowsRegion(int x, int y, int width, int height) {
            CreateRegion(new Rectangle(x,y,width, height)); 
        }

        // Consider implementing a constructor that calls ExtCreateRegion(XFORM lpXform, DWORD nCount, RGNDATA lpRgnData) if needed.
 
        /// 
        ///     Creates a WindowsRegion from a region handle, if 'takeOwnership' is true, the handle is added to the HandleCollector 
        ///     and is removed & destroyed on dispose. 
        /// 
        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; 
                    System.Internal.HandleCollector.Add(hRegion, IntSafeNativeMethods.CommonHandles.GDI);
                }
            }
            return wr; 
        }
 
        ///  
        ///     Creates a WindowsRegion from a System.Drawing.Region.
        ///  
        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);
        } 
 
        /// 
        ///  
        [ResourceExposure(ResourceScope.Process)]
        [ResourceConsumption(ResourceScope.Process)]
        public object Clone() {
            // WARNING: WindowsRegion currently supports rectangulare regions only, if the WindowsRegion was created 
            //          from an HRegion and it is not rectangular this method won't work as expected.
            // Note:    This method is currently not used and is here just to implement ICloneable. 
            return this.IsInfinite ? 
                new WindowsRegion() :
                new WindowsRegion(this.ToRectangle()); 
        }

        /// 
        ///     Combines region1 & region2 into this region.   The regions cannot be null. 
        ///     The three regions need not be distinct. For example, the sourceRgn1 can equal this region.
        ///  
        public IntNativeMethods.RegionFlags CombineRegion(WindowsRegion region1, WindowsRegion region2, RegionCombineMode mode) { 
            return IntUnsafeNativeMethods.CombineRgn(new HandleRef(this, this.HRegion), new HandleRef(region1, region1.HRegion), new HandleRef(region2, region2.HRegion), mode);
        } 

        /// 
        /// 
        [ResourceExposure(ResourceScope.Process)] 
        [ResourceConsumption(ResourceScope.Process)]
        private void CreateRegion(Rectangle rect) { 
            Debug.Assert(nativeHandle == IntPtr.Zero, "nativeHandle should be null, we're leaking handle"); 
            this.nativeHandle = IntSafeNativeMethods.CreateRectRgn(rect.X, rect.Y, rect.X+rect.Width, rect.Y+rect.Height);
            ownHandle = true; 
        }

        /// 
        ///  
        public void Dispose() {
            Dispose(true); 
        } 

        ///  
        /// 
        public void Dispose(bool disposing) {
            if (this.nativeHandle != IntPtr.Zero) {
                DbgUtil.AssertFinalization(this, disposing); 

                if( this.ownHandle ) { 
                    IntUnsafeNativeMethods.DeleteObject(new HandleRef(this, this.nativeHandle)); 
                }
 
                this.nativeHandle = IntPtr.Zero;

                if (disposing) {
                    GC.SuppressFinalize(this); 
                }
            } 
        } 

         ///  
        /// 
       ~WindowsRegion() {
            Dispose(false);
        } 

        ///  
        ///     The native region handle. 
        /// 
        public IntPtr HRegion { 
            get {
                return this.nativeHandle;
            }
        } 

        ///  
        ///  
        public bool IsInfinite {
            get { 
                return this.nativeHandle == IntPtr.Zero;
            }
        }
 
        /// 
        ///     A rectangle representing the window region set with the SetWindowRgn function. 
        ///  
        public Rectangle ToRectangle() {
            if( this.IsInfinite ) { 
                return new Rectangle( -Int32.MaxValue, -Int32.MaxValue, Int32.MaxValue, Int32.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); 
        } 
    }
} 


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK