WindowsBrush.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Misc / GDI / WindowsBrush.cs / 1305376 / WindowsBrush.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope="member", Target="System.Windows.Forms.Internal.WindowsBrush.FromLogBrush(System.Windows.Forms.Internal.IntNativeMethods+LOGBRUSH):System.Windows.Forms.Internal.WindowsBrush")] 
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope="member", Target="System.Windows.Forms.Internal.WindowsBrush.FromHdc(System.IntPtr):System.Windows.Forms.Internal.WindowsBrush")] 
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope="member", Target="System.Windows.Forms.Internal.WindowsBrush.FromBrush(System.Drawing.Brush):System.Windows.Forms.Internal.WindowsBrush")]
 
#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.Drawing;
    using System.Runtime.Versioning; 
 
    /// 
    ///      
    ///         Encapsulates a GDI Brush object.
    ///     
    /// 
#if [....]_PUBLIC_GRAPHICS_LIBRARY 
    public
#else 
    internal 
#endif
    abstract class WindowsBrush : MarshalByRefObject, ICloneable, IDisposable 
    {
        // Handle to the native Windows brush object.
        //
        private  DeviceContext dc; 
        private IntPtr nativeHandle;        // Cannot be protected because the class is internal (C# doesn't allow it).
        private Color color = Color.White;  // GDI brushes have just one color as opposed to GDI+ that can have background color. 
        // Note: We may need to implement background color too. 

#if WINGRAPHICS_FINALIZATION_WATCH 
        private string AllocationSite = DbgUtil.StackTrace;
#endif

        public abstract object Clone();     // Declaration required by C# even though this is an abstract class. 

        protected abstract void CreateBrush(); 
 
        /// 
        ///     Parameterless constructor to use default color. 
        ///     Notice that the actual object construction is done in the derived classes.
        /// 
        [ResourceExposure(ResourceScope.Process)]
        public WindowsBrush(DeviceContext dc) 
        {
            this.dc = dc; 
        } 

        [ResourceExposure(ResourceScope.Process)] 
        public WindowsBrush(DeviceContext dc, Color color)
        {
            this.dc = dc;
            this.color = color; 
        }
 
        ~WindowsBrush() 
        {
            Dispose(false); 
        }

        protected DeviceContext DC {
            get { 
                return this.dc;
            } 
        } 

        public void Dispose() 
        {
            Dispose(true);
        }
 
        protected virtual void Dispose(bool disposing)
        { 
            if (dc != null && this.nativeHandle != IntPtr.Zero) 
            {
                DbgUtil.AssertFinalization(this, disposing); 

                dc.DeleteObject(this.nativeHandle, GdiObjectType.Brush);

                this.nativeHandle = IntPtr.Zero; 
            }
 
            if (disposing) 
            {
                GC.SuppressFinalize(this); 
            }
        }

        public Color Color 
        {
            get 
            { 
                return this.color;
            } 
        }

        /// 
        ///       Gets the native Win32 brush handle. It creates it on demand. 
        /// 
        protected IntPtr NativeHandle 
        { 
            get
            { 
                if( this.nativeHandle == IntPtr.Zero )
                {
                    CreateBrush();
                } 

                return this.nativeHandle; 
            } 

            set 
            {
                Debug.Assert(this.nativeHandle == IntPtr.Zero, "WindowsBrush object is immutable");
                Debug.Assert(value != IntPtr.Zero, "WARNING: assigning IntPtr.Zero to the nativeHandle object.");
 
                this.nativeHandle = value;
            } 
        } 

#if [....]_PUBLIC_GRAPHICS_LIBRARY 

        /// 
        ///     Derived classes implement this method to get a native GDI brush wrapper with the same
        ///     properties as this object. 
        /// 
        [ResourceExposure(ResourceScope.Process)] 
        [ResourceConsumption(ResourceScope.Process)] 
        public static WindowsBrush FromBrush(DeviceContext dc, Brush originalBrush)
        { 
            if(originalBrush is SolidBrush) {
                return  new WindowsSolidBrush(dc, ((SolidBrush)originalBrush).Color);
            }
 
            if(originalBrush is System.Drawing.Drawing2D.HatchBrush) {
                System.Drawing.Drawing2D.HatchBrush hatchBrush = ((System.Drawing.Drawing2D.HatchBrush)originalBrush); 
                return new WindowsHatchBrush(dc, (WindowsHatchStyle) hatchBrush.HatchStyle, hatchBrush.ForegroundColor, hatchBrush.BackgroundColor); 
            }
 
            /*


 
*/
            Debug.Fail("Don't know how to convert this brush!"); 
            return null; 
        }
 
        /// 
        ///     Creates a WindowsBrush from the DC currently selected HBRUSH
        /// 
        [ResourceExposure(ResourceScope.Process)] 
        [ResourceConsumption(ResourceScope.Process)]
        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 );
        } 
 
        /// 
        ///     Creates a WindowsBrush from a LOGBRUSH. 
        /// 
        [ResourceExposure(ResourceScope.Process)]
        [ResourceConsumption(ResourceScope.Process)]
        public static WindowsBrush FromLogBrush( DeviceContext dc, IntNativeMethods.LOGBRUSH logBrush ) 
        {
            Debug.Assert( logBrush != null, "logBrush is null" ); 
 
            switch( logBrush.lbStyle )
            { 
                // currently supported brushes:
                case IntNativeMethods.BS_HATCHED:
                    return new WindowsHatchBrush(dc, (WindowsHatchStyle) logBrush.lbHatch );
 
                case IntNativeMethods.BS_SOLID:
                    return new WindowsSolidBrush( dc, Color.FromArgb(logBrush.lbColor) ); 
 
                default:
                    Debug.Fail( "Don't know how to create WindowsBrush from specified logBrush" ); 
                    return null;
            }
        }
#endif 

        ///  
        ///     
        ///       Returns the native Win32 brush handle.
        ///     
        /// 
        public IntPtr HBrush
        {
            get 
            {
                return this.NativeHandle; 
            } 
        }
    } 

}

// 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
WindowsBrush.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
