DrawingContext.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Core / System / Windows / Media / DrawingContext.cs / 2 / DrawingContext.cs
                        

                        
                            //------------------------------------------------------------------------------ 
//  Microsoft Avalon
//  Copyright (c) Microsoft Corporation, 2003
//
//  File:       DrawingContext.cs 
//
//  History: 
//      [....]: 04/19/2003 
//          Created it based on the RetainedDrawingContext used in the AvPhat branch.
//      [....]: 07/02/2003 
//          Turned this class into an abstract base class for RetainedDrawingContext
//          and PaintingDrawingContext.
//
//----------------------------------------------------------------------------- 

using System; 
using System.Security.Permissions; 
using System.Windows;
using System.Windows.Threading; 

using System.Windows.Media.Animation;
using System.Windows.Media;
using System.Diagnostics; 
using MS.Internal;
using System.Runtime.InteropServices; 
 
using MS.Utility;
 
namespace System.Windows.Media
{
    /// 
    /// Drawing context. 
    /// 
    public abstract partial class DrawingContext : DispatcherObject, IDisposable 
    { 
        #region Constructors
        ///  
        /// Default constructor for DrawingContext - this uses the current Dispatcher.
        /// 
        internal DrawingContext()
        { 
            // Nothing to do here
        } 
 
        #endregion Constructors
 
        #region Public Methods

        /// 
        /// Draw Text at the location specified. 
        /// 
        ///  The FormattedText to draw.  
        ///  The location at which to draw the text.  
        /// 
        /// This call is illegal if this object has already been closed or disposed. 
        /// 
        public void DrawText(FormattedText formattedText,
                             Point origin)
        { 

            if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.verbose)) 
            { 
                EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.GENERICSTRINGGUID),
                                                    EventType.StartEvent, 
                                                    "DrawingContext.DrawText Start");
            }

            VerifyApiNonstructuralChange(); 
#if DEBUG
            MediaTrace.DrawingContextOp.Trace("DrawText(const)"); 
#endif 
            if (formattedText == null)
            { 
                return;
            }

            formattedText.Draw(this, origin); 

            if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.verbose)) 
            { 
                EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.GENERICSTRINGGUID),
                                                    EventType.EndEvent, 
                                                    "DrawingContext.DrawText End");
            }
        }
 
        /// 
        /// Closes the DrawingContext and flushes the content. 
        /// Afterwards the DrawingContext can not be used anymore. 
        /// This call does not require all Push calls to have been Popped.
        ///  
        /// 
        /// This call is illegal if this object has already been closed or disposed.
        /// 
        public abstract void Close(); 

        ///  
        /// This is the same as the Close call: 
        /// Closes the DrawingContext and flushes the content.
        /// Afterwards the DrawingContext can not be used anymore. 
        /// This call does not require all Push calls to have been Popped.
        /// 
        /// 
        /// This call is illegal if this object has already been closed or disposed. 
        /// 
        void IDisposable.Dispose() 
        { 
            // Call a virtual method for derived Dispose implementations
            // 
            // Attempting to override a explicit interface member implementation causes
            // the most-derived implementation to always be called, and the base
            // implementation becomes uncallable.  But FxCop requires the base Dispose
            // method is always be called.  To avoid this situation, we use the *Core 
            // pattern for derived classes, instead of attempting to override
            // IDisposable.Dispose. 
 
            VerifyAccess();
 
            DisposeCore();
        }

        #endregion Public Methods 

        #region Protected Methods 
 

        ///  
        /// Dispose functionality implemented by subclasses
        /// 
        /// 
        /// This call is illegal if this object has already been closed or disposed. 
        /// 
        protected abstract void DisposeCore(); 
 
        /// 
        /// This verifies that the API can be called for read only access. 
        /// 
        protected virtual void VerifyApiNonstructuralChange()
        {
            this.VerifyAccess(); 
        }
 
        #endregion Protected Methods 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

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