FixedElement.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 / System / Windows / Documents / FixedElement.cs / 1 / FixedElement.cs

                            //---------------------------------------------------------------------------- 
// 
//      Copyright (C) 2004 by Microsoft Corporation.  All rights reserved.
// 
// 
// Description:
//      FixedElement represents a flow element/object in the Fixed Document. 
// 
// History:
//      02/05/2004 - [....] ([....]) - Created. 
//
//---------------------------------------------------------------------------
namespace System.Windows.Documents
{ 
    using MS.Internal.Documents;
    using System.Windows; 
    using System.Windows.Automation; 
    using System.Windows.Controls;
    using System.Windows.Shapes; 
    using System.Windows.Markup;    // for XmlLanguage
    using System.Windows.Media;
    using System.Windows.Navigation;
    using System; 
    using System.Collections;
    using System.Collections.Generic; 
    using System.Diagnostics; 
    using System.Globalization;
    using System.Text; 

    /// 
    /// FixedElement represents a flow element/object in the Fixed Document.
    /// Its children collection is used for DependencyProperty evaluation. 
    /// No Z-order is implied!
    ///  
    // suggestion: derive from TextElement to get text properties like FontSize 
    // will we also need TableCell.ColumnSpan?  Would we want to make this derive from TableCell?  Probably not.
    internal sealed class FixedElement : DependencyObject 
    {

        internal enum ElementType
        { 
            Paragraph,
            Inline, 
            Run, 
            Span,
            Bold, 
            Italic,
            Underline,
            Object,
            Container, 
            Section,
            Figure, 
            Table, 
            TableRowGroup,
            TableRow, 
            TableCell,
            List,
            ListItem,
            Header, 
            Footer,
            Hyperlink, 
            InlineUIContainer, 
        }
 
        // apply to everything
        public static readonly DependencyProperty LanguageProperty =
                    FrameworkElement.LanguageProperty.AddOwner(
                                typeof(FixedElement)); 

        // only apply to ElementType.Run 
        public static readonly DependencyProperty FontFamilyProperty = 
                    TextElement.FontFamilyProperty.AddOwner(
                                typeof(FixedElement)); 

        public static readonly DependencyProperty FontStyleProperty =
                    TextElement.FontStyleProperty.AddOwner(
                                typeof(FixedElement)); 

        public static readonly DependencyProperty FontWeightProperty = 
                    TextElement.FontWeightProperty.AddOwner( 
                                typeof(FixedElement));
 
        public static readonly DependencyProperty FontStretchProperty =
                    TextElement.FontStretchProperty.AddOwner(
                                typeof(FixedElement));
 
        public static readonly DependencyProperty FontSizeProperty =
                    TextElement.FontSizeProperty.AddOwner( 
                                typeof(FixedElement)); 

        public static readonly DependencyProperty ForegroundProperty = 
                    TextElement.ForegroundProperty.AddOwner(
                                typeof(FixedElement));

        public static readonly DependencyProperty FlowDirectionProperty = 
                    FrameworkElement.FlowDirectionProperty.AddOwner(
                                typeof(FixedElement)); 
 

 
        //Applies only to Table
        public static readonly DependencyProperty CellSpacingProperty =
                    Table.CellSpacingProperty.AddOwner(
                                typeof(FixedElement)); 

 
        //Applies only to TableCell 
        public static readonly DependencyProperty BorderThicknessProperty =
                    Block.BorderThicknessProperty.AddOwner(typeof(FixedElement)); 

        public static readonly DependencyProperty BorderBrushProperty =
                    Block.BorderBrushProperty.AddOwner(typeof(FixedElement));
 
        public static readonly DependencyProperty ColumnSpanProperty =
                    TableCell.ColumnSpanProperty.AddOwner(typeof(FixedElement)); 
 
        //Applies only to Hyperlink
        public static readonly DependencyProperty NavigateUriProperty = 
            Hyperlink.NavigateUriProperty.AddOwner(
                        typeof(FixedElement));

        //Applies only to images 
        public static readonly DependencyProperty NameProperty =
            AutomationProperties.NameProperty.AddOwner( 
                        typeof(FixedElement)); 

        public static readonly DependencyProperty HelpTextProperty = 
            AutomationProperties.HelpTextProperty.AddOwner(
                        typeof(FixedElement));

        //----------------------------------------------------- 
        //
        //  Constructors 
        // 
        //-----------------------------------------------------
        #region Constructors 
        // Ctor always set mutable flag to false
        internal FixedElement(ElementType type, FixedTextPointer start, FixedTextPointer end, int pageIndex)
        {
            _type = type; 
#if DEBUG
            if (_type == ElementType.Object) // is EmbeddedObject 
            { 
                Debug.Assert((object)_start == (object)_end);
            } 
            _children = new List();
#endif
            _start = start;
            _end = end; 
            _pageIndex = pageIndex;
 
        } 

        #endregion Constructors 


        //------------------------------------------------------
        // 
        //  Public Methods
        // 
        //----------------------------------------------------- 

#if DEBUG 
        /// 
        /// Create a string representation of this object
        /// 
        /// string - A string representation of this object 
        public override string ToString()
        { 
            return String.Format(CultureInfo.InvariantCulture, "{{S@{0}---E@{1}}} {2}", _start, _end, System.Enum.GetName(typeof(ElementType), _type)); 
        }
#endif 

        //------------------------------------------------------
        //
        //  Public Properties 
        //
        //------------------------------------------------------ 
 
        //-----------------------------------------------------
        // 
        //  Public Events
        //
        //------------------------------------------------------
 
        //-----------------------------------------------------
        // 
        //  Internal Methods 
        //
        //----------------------------------------------------- 

        #region Internal Methods

        // Method to allow append of element 
        // Note element order doesn't imply Z-order in this implementation!
        internal void Append(FixedElement e) 
        { 
#if DEBUG
            _children.Add(e); 
#endif
            if (_type == ElementType.InlineUIContainer)
            {
                Debug.Assert(_object == null && e._type == ElementType.Object); 
                _object = e._object; // To generate InlineUIContainer with child with object;
            } 
        } 

        internal object GetObject() 
        {
            if (_type == ElementType.Hyperlink || _type == ElementType.Paragraph ||
                (_type >= ElementType.Table && _type <= ElementType.TableCell))
            { 
                if (_object == null)
                { 
                    _object = BuildObjectTree(); 
                }
                return _object; 
            }

            if (!(_type == ElementType.Object || _type == ElementType.InlineUIContainer))
            { 
                // This is currently not implemented for any other type
                return null; 
            } 

            Image im = GetImage(); 
            object o = im;
            if (_type == ElementType.InlineUIContainer)
            {
                InlineUIContainer c = new InlineUIContainer(); 
                c.Child = im;
                o = c; 
            } 
            return o;
        } 

        internal object BuildObjectTree()
        {
            IAddChild root; 
            switch (_type)
            { 
                case ElementType.Table: 
                    root = new Table();
                    break; 
                case ElementType.TableRowGroup:
                    root = new TableRowGroup();
                    break;
                case ElementType.TableRow: 
                    root = new TableRow();
                    break; 
                case ElementType.TableCell: 
                    root = new TableCell();
                    break; 
                case ElementType.Paragraph:
                    root = new Paragraph();
                    break;
                case ElementType.Hyperlink: 
                    Hyperlink link = new Hyperlink();
                    link.NavigateUri = GetValue(NavigateUriProperty) as Uri; 
                    link.RequestNavigate += new RequestNavigateEventHandler(ClickHyperlink); 
                    AutomationProperties.SetHelpText(link, (String)this.GetValue(HelpTextProperty));
                    AutomationProperties.SetName(link, (String)this.GetValue(NameProperty)); 
                    root = link;
                    break;
                default:
                    Debug.Assert(false); 
                    root = null;
                    break; 
            } 

            ITextPointer pos = ((ITextPointer)_start).CreatePointer(); 

            while (pos.CompareTo((ITextPointer)_end) < 0)
            {
                TextPointerContext tpc = pos.GetPointerContext(LogicalDirection.Forward); 
                if (tpc == TextPointerContext.Text)
                { 
                    root.AddText(pos.GetTextInRun(LogicalDirection.Forward)); 
                }
                else if (tpc == TextPointerContext.EmbeddedElement) 
                {
                    root.AddChild(pos.GetAdjacentElement(LogicalDirection.Forward));
                }
                else if (tpc == TextPointerContext.ElementStart) 
                {
                    object obj = pos.GetAdjacentElement(LogicalDirection.Forward); 
                    if (obj != null) 
                    {
                        root.AddChild(obj); 
                        pos.MoveToNextContextPosition(LogicalDirection.Forward);
                        pos.MoveToElementEdge(ElementEdge.BeforeEnd);
                    }
                } 

                pos.MoveToNextContextPosition(LogicalDirection.Forward); 
 
            }
            return root; 
        }

        private Image GetImage()
        { 
            Image image = null; // return value
            Uri source = _object as Uri; 
            if (source != null) 
            {
                image = new Image(); 
                image.Source = new System.Windows.Media.Imaging.BitmapImage(source);
                image.Width = image.Source.Width;
                image.Height = image.Source.Height;
 
                AutomationProperties.SetName(image, (String)this.GetValue(NameProperty));
                AutomationProperties.SetHelpText(image, (String)this.GetValue(HelpTextProperty)); 
            } 
            return image;
        } 

        private void ClickHyperlink(Object sender, RequestNavigateEventArgs args)
        {
            FixedDocument doc = _start.FixedTextContainer.FixedDocument; 
            int pageno = doc.GetPageNumber(_start);
            FixedPage page = doc.SyncGetPage(pageno, false); 
 
            //have page raise click event
            FixedPage.RaiseNavigateFromPage(page, args.Uri); 
        }

        #endregion Internal Methods
 
#if DEBUG
        internal void Dump() 
        { 
            DumpTree(0);
        } 

        internal void DumpTree(int indent)
        {
            if (DocumentsTrace.FixedTextOM.Map.IsEnabled) 
            {
                StringBuilder dp = new StringBuilder(); 
 
                dp.Append("\r\n");
                for (int kk = 0; kk < indent; kk++) 
                {
                    dp.Append("    ");
                }
                dp.Append(this.ToString()); 
                for(int i = 0, n = _children.Count; i < n; i++)
                { 
                    ((FixedElement)_children[i]).DumpTree(indent+1); 
                }
 
                DocumentsTrace.FixedTextOM.Map.Trace(dp.ToString());
            }
        }
#endif 
        //-----------------------------------------------------
        // 
        //  Internal Properties 
        //
        //------------------------------------------------------ 

        #region Internal Properties
        internal bool IsTextElement
        { 
            get
            { 
                return ! (_type == ElementType.Object 
                    || _type == ElementType.Container);
            } 
        }

        internal Type Type
        { 
            get
            { 
                switch (_type) 
                {
                    case ElementType.Paragraph: 
                        return typeof(Paragraph);

                    case ElementType.Inline:
                        return typeof(Inline); 

                    case ElementType.Run: 
                        return typeof(Run); 

                    case ElementType.Span: 
                        return typeof(Span);

                    case ElementType.Bold:
                        return typeof(Bold); 

                    case ElementType.Italic: 
                        return typeof(Italic); 

                    case ElementType.Underline: 
                        return typeof(Underline);

                    case ElementType.Object:
                        return typeof(Object); 

                    case ElementType.Table: 
                        return typeof(Table); 

                    case ElementType.TableRowGroup: 
                        return typeof(TableRowGroup);

                    case ElementType.TableRow:
                        return typeof(TableRow); 

                    case ElementType.TableCell: 
                        return typeof(TableCell); 

                    case ElementType.List: 
                        return typeof(List);

                    case ElementType.ListItem:
                        return typeof(ListItem); 

                    case ElementType.Section: 
                        return typeof(Section); 

                    case ElementType.Figure: 
                        return typeof(Figure);

                    case ElementType.Hyperlink:
                        return typeof(Hyperlink); 

                    case ElementType.InlineUIContainer: 
                        return typeof(InlineUIContainer); 
                    default:
                        return typeof(Object); 
                }
            }
        }
 
        internal FixedTextPointer Start
        { 
            get { return _start; } 
        }
 

        internal FixedTextPointer End
        {
            get { return _end; } 
        }
 
        internal int PageIndex 
        {
            get { return _pageIndex; } 
        }

        internal object Object
        { 
            set { _object = value; }
        } 
        #endregion Internal Properties 

        //----------------------------------------------------- 
        //
        //  Private Fields
        //
        //------------------------------------------------------ 
        #region Private Fields
#if DEBUG 
        private List      _children; 
#endif
        private ElementType  _type;             // logical type that this element represents 
        private FixedTextPointer  _start;      // start position for this element
        private FixedTextPointer  _end;        // end position for this element
        private object _object;                 // embedded object
        private int _pageIndex; 
        #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