PaintEvent.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 / WinForms / Managed / System / WinForms / PaintEvent.cs / 1305376 / PaintEvent.cs

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

namespace System.Windows.Forms { 
 
    using Microsoft.Win32;
    using System; 
    using System.ComponentModel;
    using System.Diagnostics;
    using System.Drawing;
    using System.Windows.Forms.Internal; 
    using System.Drawing.Drawing2D;
    using System.Runtime.InteropServices; 
 
    /// 
    ///  
    ///    
    ///       Provides data for the 
    ///       event.
    ///     
    /// 
    // NOTE: Please keep this class consistent with PrintPageEventArgs. 
    public class PaintEventArgs : EventArgs, IDisposable { 
        /// 
        ///     Graphics object with which painting should be done. 
        /// 
        private Graphics graphics = null;

        // See ResetGraphics() 
        private GraphicsState savedGraphicsState = null;
 
        ///  
        ///     DC (Display context) for obtaining the graphics object. Used to delay getting the graphics
        ///     object until absolutely necessary (for perf reasons) 
        /// 
        private readonly IntPtr dc = IntPtr.Zero;
        IntPtr oldPal = IntPtr.Zero;
 
        /// 
        ///     Rectangle into which all painting should be done. 
        ///  
        private readonly Rectangle clipRect;
        //private Control paletteSource; 

#if DEBUG
        static readonly TraceSwitch PaintEventFinalizationSwitch = new TraceSwitch("PaintEventFinalization", "Tracks the creation and finalization of PaintEvent objects");
        internal static string GetAllocationStack() 
        {
            if (PaintEventFinalizationSwitch.TraceVerbose) 
            { 
                return Environment.StackTrace;
            } 
            else
            {
                return "Enabled 'PaintEventFinalization' trace switch to see stack of allocation";
            } 
        }
        private string AllocationSite = PaintEventArgs.GetAllocationStack(); 
#endif 

        ///  
        /// 
        ///    
        ///       Initializes a new instance of the  class with the specified graphics and
        ///       clipping rectangle. 
        ///    
        ///  
        public PaintEventArgs(Graphics graphics, Rectangle clipRect) { 
            if( graphics == null ){
                throw new ArgumentNullException("graphics"); 
            }

            this.graphics = graphics;
            this.clipRect = clipRect; 
        }
 
        // Internal version of constructor for performance 
        // We try to avoid getting the graphics object until needed
        internal PaintEventArgs(IntPtr dc, Rectangle clipRect) { 
            Debug.Assert(dc != IntPtr.Zero, "dc is not initialized.");

            this.dc = dc;
            this.clipRect = clipRect; 
        }
 
        ///  
        ~PaintEventArgs() {
            Dispose(false); 
        }

        /// 
        ///  
        ///    
        ///       Gets the 
        ///       rectangle in which to paint. 
        ///    
        ///  
        public Rectangle ClipRectangle {
            get {
                return clipRect;
            } 
        }
 
        ///  
        ///     Gets the HDC this paint event is connected to.  If there is no associated
        ///     HDC, or the GDI+ Graphics object has been created (meaning GDI+ now owns the 
        ///     HDC), 0 is returned.
        ///
        /// 
        internal IntPtr HDC { 
            get {
                if (graphics == null) 
                    return dc; 
                else
                    return IntPtr.Zero; 
            }
        }

        ///  
        /// 
        ///     
        ///       Gets the  
        ///       object used to
        ///       paint. 
        ///    
        /// 
        public System.Drawing.Graphics Graphics {
            get { 
                if (graphics == null && dc != IntPtr.Zero) {
                    oldPal = Control.SetUpPalette(dc, false /*force*/, false /*realize*/); 
                    graphics = Graphics.FromHdcInternal(dc); 
                    graphics.PageUnit = GraphicsUnit.Pixel;
                    savedGraphicsState = graphics.Save(); // See ResetGraphics() below 
                }
                return graphics;
            }
        } 

        // We want a way to dispose the GDI+ Graphics, but we don't want to create one 
        // simply to dispose it 
        // cpr: should be internal
        ///  
        /// 
        ///    
        ///       Disposes
        ///       of the resources (other than memory) used by the . 
        ///    
        ///  
        public void Dispose() { 
            Dispose(true);
            GC.SuppressFinalize(this); 
        }

        /// 
        protected virtual void Dispose(bool disposing) { 
#if DEBUG
            Debug.Assert(disposing, "PaintEvent object should be explicitly disposed. Potential GDI multithreading lock issue. Allocation stack:\r\n" + AllocationSite); 
#endif 
           if (disposing) {
                //only dispose the graphics object if we created it via the dc. 
                if (graphics != null && dc != IntPtr.Zero) {
                    graphics.Dispose();
                }
            } 

            if (oldPal != IntPtr.Zero && dc != IntPtr.Zero) { 
                SafeNativeMethods.SelectPalette(new HandleRef(this, dc), new HandleRef(this, oldPal), 0); 
                oldPal = IntPtr.Zero;
            } 
        }

        // If ControlStyles.AllPaintingInWmPaint, we call this method
        // after OnPaintBackground so it appears to OnPaint that it's getting a fresh 
        // Graphics.  We want to make sure AllPaintingInWmPaint is purely an optimization,
        // and doesn't change behavior, so we need to make sure any clipping regions established 
        // in OnPaintBackground don't apply to OnPaint. See ASURT 44682. 
        internal void ResetGraphics() {
            if (graphics != null) { 
                Debug.Assert(dc == IntPtr.Zero || savedGraphicsState != null, "Called ResetGraphics more than once?");
                if (savedGraphicsState != null) {
                    graphics.Restore(savedGraphicsState);
                    savedGraphicsState = null; 
                }
            } 
        } 
    }
} 

// 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