BackgroundFormatInfo.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 / Framework / MS / Internal / PtsHost / BackgroundFormatInfo.cs / 1 / BackgroundFormatInfo.cs
                        

                        
                            //---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// 
// Description: Background format information 
//
// History: 
//  10/28/04 : [....] - Created
//
//---------------------------------------------------------------------------
 
using System;
using MS.Internal.Documents; // FlowDocumentFormatter 
using System.Windows.Threading; // DispatcherTimer 

namespace MS.Internal.PtsHost 
{
    internal sealed class BackgroundFormatInfo
    {
        //------------------------------------------------------------------- 
        //
        //  Constructors 
        // 
        //-------------------------------------------------------------------
 
        #region Constructors

        /// 
        /// Structural Cache contructor 
        /// 
        internal BackgroundFormatInfo(StructuralCache structuralCache) 
        { 
            _structuralCache = structuralCache;
        } 

        #endregion Constructors

        //-------------------------------------------------------------------- 
        //
        //  Internal Methods 
        // 
        //-------------------------------------------------------------------
 
        #region Internal Methods

        /// 
        /// Updates background layout information from a structuralCache 
        /// 
        internal void UpdateBackgroundFormatInfo() 
        { 
            _cpInterrupted = -1;
            _lastCPUninterruptible = 0; 
            _doesFinalDTRCoverRestOfText = false;

            _cchAllText = _structuralCache.TextContainer.SymbolCount;
 
            if(_structuralCache.DtrList != null)
            { 
                int positionsAdded = 0; 

                // Sum for all dtrs but the last 
                for(int dtrIndex = 0; dtrIndex < _structuralCache.DtrList.Length - 1; dtrIndex++)
                {
                    positionsAdded += _structuralCache.DtrList[dtrIndex].PositionsAdded - _structuralCache.DtrList[dtrIndex].PositionsRemoved;
                } 

                DirtyTextRange dtrLast = _structuralCache.DtrList[_structuralCache.DtrList.Length - 1]; 
 
                if((dtrLast.StartIndex + positionsAdded + dtrLast.PositionsAdded) >= _cchAllText)
                { 
                    _doesFinalDTRCoverRestOfText = true;
                    _lastCPUninterruptible = dtrLast.StartIndex + positionsAdded;
                }
            } 
            else
            { 
                _doesFinalDTRCoverRestOfText = true; 
            }
 
            // And set a good stop time for formatting
            _backgroundFormatStopTime = DateTime.Now.AddMilliseconds(_stopTimeDelta);
        }
 
        /// 
        /// This method is called after user input. 
        /// Temporarily disable background layout to cut down on ui latency. 
        /// 
        internal void ThrottleBackgroundFormatting() 
        {
            if (_throttleBackgroundTimer == null)
            {
                // Start up a timer.  Until the timer fires, we'll disable 
                // all background layout.  This leaves the control responsive
                // to user input. 
                _throttleBackgroundTimer = new DispatcherTimer(DispatcherPriority.Background); 
                _throttleBackgroundTimer.Interval = new TimeSpan(0, 0, (int)_throttleBackgroundSeconds);
                _throttleBackgroundTimer.Tick += new EventHandler(OnThrottleBackgroundTimeout); 
            }
            else
            {
                // Reset the timer. 
                _throttleBackgroundTimer.Stop();
            } 
 
            _throttleBackgroundTimer.Start();
        } 

        /// 
        /// Run one iteration of background formatting.  Currently that simply requires
        /// that we invalidate the content. 
        /// 
        internal void BackgroundFormat(IFlowDocumentFormatter formatter, bool ignoreThrottle) 
        { 
            if (_throttleBackgroundTimer == null)
            { 
                formatter.OnContentInvalidated(true);
            }
            else if (ignoreThrottle)
            { 
                OnThrottleBackgroundTimeout(null, EventArgs.Empty);
            } 
            else 
            {
                // If we had recent user input, wait until the timeout passes 
                // to invalidate.
                _pendingBackgroundFormatter = formatter;
            }
        } 

        #endregion Internal Methods 
 
        //--------------------------------------------------------------------
        // 
        //  Internal Properties
        //
        //--------------------------------------------------------------------
 
        #region Internal Properties
 
        ///  
        /// Last CP Uninterruptible
        ///  
        internal int LastCPUninterruptible { get { return _lastCPUninterruptible; } }

        /// 
        /// Stop time for background formatting timeslice 
        /// 
        internal DateTime BackgroundFormatStopTime { get { return _backgroundFormatStopTime; } } 
 
        /// 
        /// Cch of all text in container 
        /// 
        internal int CchAllText { get { return _cchAllText; } }

        ///  
        /// Whether background layout is globally enabled
        ///  
        static internal bool IsBackgroundFormatEnabled { get { return _isBackgroundFormatEnabled; } } 

        ///  
        /// Does the final dtr extend through the sum of the text
        /// 
        internal bool DoesFinalDTRCoverRestOfText { get { return _doesFinalDTRCoverRestOfText; } }
 
        /// 
        /// Current last cp formatted 
        ///  
        internal int CPInterrupted { get { return _cpInterrupted; } set { _cpInterrupted = value; } }
 
        /// 
        /// Height of the viewport
        /// 
        internal double ViewportHeight 
        {
            get { return _viewportHeight; } 
            set { _viewportHeight = value; } 
        }
 
        #endregion Internal Properties

        //-------------------------------------------------------------------
        // 
        //  Private Methods
        // 
        //-------------------------------------------------------------------- 

        #region Private Methods 

        // Callback for the background layout throttle timer.
        // Resumes backgound layout.
        private void OnThrottleBackgroundTimeout(object sender, EventArgs e) 
        {
            _throttleBackgroundTimer.Stop(); 
            _throttleBackgroundTimer = null; 

            if (_pendingBackgroundFormatter != null) 
            {
                BackgroundFormat(_pendingBackgroundFormatter, true /* ignoreThrottle */);
                _pendingBackgroundFormatter = null;
            } 
        }
 
        #endregion Private Methods 

        //------------------------------------------------------------------- 
        //
        //  Private Fields
        //
        //------------------------------------------------------------------- 

        #region Private Fields 
 
        //-------------------------------------------------------------------
        // Height of the viewport. 
        //--------------------------------------------------------------------
        private double _viewportHeight;

        //------------------------------------------------------------------- 
        // Does the final DTR cover the entirety of the range?
        //-------------------------------------------------------------------- 
        private bool _doesFinalDTRCoverRestOfText; 

        //-------------------------------------------------------------------- 
        // What is the last uninterruptible cp ?
        //-------------------------------------------------------------------
        private int _lastCPUninterruptible;
 
        //--------------------------------------------------------------------
        // Stop time for background layout 
        // Used for background layout 
        //-------------------------------------------------------------------
        private DateTime _backgroundFormatStopTime; 

        //-------------------------------------------------------------------
        // Cch of all text in container
        //------------------------------------------------------------------- 
        private int _cchAllText;
 
        //-------------------------------------------------------------------- 
        // Cp Interrupted
        // Used for background layout 
        //-------------------------------------------------------------------
        private int _cpInterrupted;

        //-------------------------------------------------------------------- 
        // Global enabling flag for whether background format is enabled.
        //-------------------------------------------------------------------- 
        private static bool _isBackgroundFormatEnabled = true; 

        //------------------------------------------------------------------- 
        // Structural cache
        //--------------------------------------------------------------------
        private StructuralCache _structuralCache;
 
        //-------------------------------------------------------------------
        // Time after a user input until which we use a minimal time slice 
        // to remain responsive to future input. 
        //-------------------------------------------------------------------
        private DateTime _throttleTimeout = DateTime.Now; 

        //-------------------------------------------------------------------
        // Timer used to disable background layout during user interaction.
        //-------------------------------------------------------------------- 
        private DispatcherTimer _throttleBackgroundTimer;
 
        //------------------------------------------------------------------- 
        // Holds the formatter to invalidate when _throttleBackgroundTimer
        // fires. 
        //--------------------------------------------------------------------
        IFlowDocumentFormatter _pendingBackgroundFormatter;

        //-------------------------------------------------------------------- 
        // Number of seconds to disable background layout after receiving
        // user input. 
        //------------------------------------------------------------------- 
        private const uint _throttleBackgroundSeconds = 2;
 
        //--------------------------------------------------------------------
        // Max time slice (ms) for one background format iteration.
        //-------------------------------------------------------------------
        private const uint _stopTimeDelta = 200; 

        #endregion Private Fields 
    } 
}

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