BaseParagraph.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 / BaseParagraph.cs / 1 / BaseParagraph.cs
                        

                        
                            //---------------------------------------------------------------------------- 
//
// Copyright (C) Microsoft Corporation.  All rights reserved.
//
// Description: BaseParagraph represents a paragraph corresponding to part 
//              of a text based content.
// 
// History: 
//  05/05/2003 : [....] - moving from Avalon branch.
//  10/30/2004 : [....] - ElementReference cleanup. 
//
//---------------------------------------------------------------------------

using System; 
using System.Diagnostics;
using System.Windows; 
using System.Windows.Documents; 
using MS.Internal.Documents;
using MS.Internal.Text; 

using MS.Internal.PtsHost.UnsafeNativeMethods;

namespace MS.Internal.PtsHost 
{
    ///  
    /// BaseParagraph represents a paragraph corresponding to part of a text 
    /// based content.
    ///  
    internal abstract class BaseParagraph : UnmanagedHandle
    {
        //-------------------------------------------------------------------
        // 
        //  Constructors
        // 
        //------------------------------------------------------------------- 

        #region Constructors 

        /// 
        /// Constructor.
        ///  
        /// 
        /// Element associated with paragraph. 
        ///  
        /// 
        /// Content's structural cache 
        /// 
        protected BaseParagraph(DependencyObject element, StructuralCache structuralCache)
            : base(structuralCache.PtsContext)
        { 
            _element = element;
            _structuralCache = structuralCache; 
            _changeType = PTS.FSKCHANGE.fskchNone; 
            _stopAsking = false;
 
            UpdateLastFormatPositions();
        }

        #endregion Constructors 

        // ------------------------------------------------------------------ 
        // 
        //  PTS callbacks
        // 
        // -----------------------------------------------------------------

        #region PTS callbacks
 
        /// 
        /// UpdGetParaChange 
        ///  
        /// 
        /// OUT: kind of change 
        /// 
        /// 
        /// OUT: no changes after?
        ///  
        internal virtual void UpdGetParaChange(
            out PTS.FSKCHANGE fskch, 
            out int fNoFurtherChanges) 
        {
            fskch = _changeType; 
            fNoFurtherChanges = PTS.FromBoolean(_stopAsking);

#if TEXTPANELLAYOUTDEBUG
            if (StructuralCache.CurrentFormatContext.IncrementalUpdate) 
            {
                TextPanelDebug.Log("Para.UpdGetParaChange, Para=" + this.GetType().Name + " Change=" + _changeType.ToString(), TextPanelDebug.Category.ContentChange); 
            } 
#endif
        } 

        /// 
        /// Collapse margins
        ///  
        /// 
        /// IN: Paragraph's para client 
        ///  
        /// 
        /// IN: input margin collapsing state 
        /// 
        /// 
        /// IN: current direction (of the track, in which margin collapsing is happening)
        ///  
        /// 
        /// IN: suppress empty space at the top of page 
        ///  
        /// 
        /// OUT: dvr, calculated based on margin collapsing state 
        /// 
        internal virtual void CollapseMargin(
            BaseParaClient paraClient,
            MarginCollapsingState mcs, 
            uint fswdir,
            bool suppressTopSpace, 
            out int dvr) 
        {
            // Suppress top space only in paginated scenarios. 
            dvr = (mcs == null || (suppressTopSpace)) ? 0 : mcs.Margin;
        }

        ///  
        /// Get Para Properties
        ///  
        ///  
        /// OUT: paragraph properties
        ///  
        internal abstract void GetParaProperties(
            ref PTS.FSPAP fspap);

        ///  
        /// CreateParaclient
        ///  
        ///  
        /// OUT: opaque to PTS paragraph client
        ///  
        internal abstract void CreateParaclient(
            out IntPtr pfsparaclient);

        #endregion PTS callbacks 

        // ------------------------------------------------------------------ 
        // 
        //  Internal Methods
        // 
        // ------------------------------------------------------------------

        #region Internal Methods
 
        /// 
        /// Set update info. Those flags are used later by PTS to decide 
        /// if paragraph needs to be updated and when to stop asking for 
        /// update information.
        ///  
        /// 
        /// Type of change within the paragraph.
        /// 
        ///  
        /// Synchronization point is reached?
        ///  
        internal virtual void SetUpdateInfo(PTS.FSKCHANGE fskch, bool stopAsking) 
        {
            _changeType = fskch; 
            _stopAsking = stopAsking;
        }

        ///  
        /// Clear previously accumulated update info.
        ///  
        internal virtual void ClearUpdateInfo() 
        {
            _changeType = PTS.FSKCHANGE.fskchNone; 
            _stopAsking = true;
        }

        ///  
        /// Invalidate content's structural cache. Returns: 'true' if entire paragraph
        /// is invalid. 
        ///  
        /// 
        /// Position to start invalidation from. 
        /// 
        internal virtual bool InvalidateStructure(int startPosition)
        {
            Debug.Assert(ParagraphEndCharacterPosition >= startPosition); 
            int openEdgeCp = TextContainerHelper.GetCPFromElement(StructuralCache.TextContainer, Element, ElementEdge.BeforeStart);
            return (openEdgeCp == startPosition); 
        } 

        ///  
        /// Invalidate accumulated format caches.
        /// 
        internal virtual void InvalidateFormatCache()
        { 
        }
 
        ///  
        /// Update number of characters consumed by the paragraph.
        ///  
        internal void UpdateLastFormatPositions()
        {
            _lastFormatCch = Cch;
        } 

        #endregion Internal Methods 
 
        //-------------------------------------------------------------------
        // 
        //  Protected Methods
        //
        //--------------------------------------------------------------------
 
        #region Protected Methods
 
        ///  
        /// Retrieve PTS paragraph properties.
        ///  
        /// 
        /// Paragraph properties to initialize.
        /// 
        ///  
        /// Ignore element properties?
        ///  
        protected void GetParaProperties(ref PTS.FSPAP fspap, bool ignoreElementProps) 
        {
            if (!ignoreElementProps) 
            {
                fspap.fKeepWithNext      = PTS.FromBoolean(DynamicPropertyReader.GetKeepWithNext(_element));
                // Can be broken only if Block.BreakPageBefore is set
                fspap.fBreakPageBefore   = _element is Block ? PTS.FromBoolean(StructuralCache.CurrentFormatContext.FinitePage && ((Block)_element).BreakPageBefore) : PTS.FromBoolean(false); 
                // Can be broken only if Block.BreakColumnBefore is set
                fspap.fBreakColumnBefore = _element is Block ? PTS.FromBoolean(((Block)_element).BreakColumnBefore) : PTS.FromBoolean(false); 
            } 
        }
 
        #endregion Protected Methods

        //-------------------------------------------------------------------
        // 
        //  Properties / Fields
        // 
        //------------------------------------------------------------------- 

        #region Properties / Fields 

        /// 
        /// CharacterPosition at the start of paragraph.
        ///  
        internal int ParagraphStartCharacterPosition
        { 
            get 
            {
                // This is done here, rather than deriving for two reasons - This is special cased for text paragraph - no other 
                // paras should use their cps in this way, and this is also not a virtual method, so can be used from C'Tor.
                if(this is TextParagraph)
                {
                    return TextContainerHelper.GetCPFromElement(StructuralCache.TextContainer, Element, ElementEdge.AfterStart); 
                }
                else 
                { 
                    return TextContainerHelper.GetCPFromElement(StructuralCache.TextContainer, Element, ElementEdge.BeforeStart);
                } 
            }
        }

        ///  
        /// CharacterPosition at the end of paragraph. The first character
        /// that does not belong to the paragraph. 
        ///  
        internal int ParagraphEndCharacterPosition
        { 
            get
            {
                // This is done here, rather than deriving for two reasons - This is special cased for text paragraph - no other
                // paras should use their cps in this way, and this is also not a virtual method, so can be used from C'Tor. 
                if(this is TextParagraph)
                { 
                    return TextContainerHelper.GetCPFromElement(StructuralCache.TextContainer, Element, ElementEdge.BeforeEnd); 
                }
                else 
                {
                    return TextContainerHelper.GetCPFromElement(StructuralCache.TextContainer, Element, ElementEdge.AfterEnd);
                }
            } 
        }
 
        ///  
        /// Incremental update information for the paragraph.
        /// Those fields are used only during incremental update process. 
        /// 
        protected PTS.FSKCHANGE _changeType;
        protected bool _stopAsking;
 
        /// 
        /// Number of characters consumed by the paragraph. 
        ///  
        internal int Cch
        { 
            get
            {
                int cch = TextContainerHelper.GetCchFromElement(StructuralCache.TextContainer, Element);
 
                // This is done here, rather than deriving for two reasons - This is special cased for text paragraph - no other
                // paras should use their cps in this way, and this is also not a virtual method, so can be used from C'Tor. 
                if (this is TextParagraph && Element is TextElement) 
                {
                    Invariant.Assert(cch >= 2); 
                    cch -= 2;
                }

                return cch; 
            }
        } 
 
        /// 
        /// Cch paragraph had during last format 
        /// 
        internal int LastFormatCch
        {
            get 
            {
                return _lastFormatCch; 
            } 
        }
 
        protected int _lastFormatCch;


        ///  
        /// The next and previous sibling in paragraph list.
        ///  
        internal BaseParagraph Next; 
        internal BaseParagraph Previous;
 

        /// 
        /// Content's structural cache.
        ///  
        internal StructuralCache StructuralCache
        { 
            get 
            {
                return _structuralCache; 
            }
        }
        protected readonly StructuralCache _structuralCache;
 
        /// 
        /// Object associated with the paragraph. 
        ///  
        internal DependencyObject Element
        { 
            get
            {
                return _element;
            } 
        }
        protected readonly DependencyObject _element; 
 
        #endregion Properties / 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