SemanticBasicElement.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 / wpf / src / Framework / System / Windows / Documents / DocumentStructures / SemanticBasicElement.cs / 1305600 / SemanticBasicElement.cs

                            //---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// History: 
//  05/12/2005 : mingliu - created. 
//
// 
//---------------------------------------------------------------------------
using MS.Internal.Documents;
using MS.Utility;
using System; 
using System.Collections;
using System.Collections.Generic; 
using System.Collections.ObjectModel; 
using System.Diagnostics;
using System.Reflection; 
using System.Security.Permissions;
using System.Windows.Controls.Primitives;
using System.Windows.Documents;
using System.Windows.Media; 
using System.Windows.Shapes;
using System.Windows.Markup; 
 
[assembly: XmlnsDefinition(
    "http://schemas.microsoft.com/xps/2005/06/documentstructure", 
    "System.Windows.Documents.DocumentStructures")]
namespace System.Windows.Documents.DocumentStructures
{
 
    /// 
    /// 
    ///  
    public class SemanticBasicElement : BlockElement
    { 
        /// 
        ///
        /// 
        internal SemanticBasicElement() 
        {
            _elementList = new List(); 
        } 

        internal List BlockElementList 
        {
            get
            {
                return _elementList; 
            }
        } 
 
        /// 
        /// 
        /// 
        internal List _elementList;
    }
 
    /// 
    /// 
    ///  
    public class SectionStructure : SemanticBasicElement, IAddChild, IEnumerable, IEnumerable
    { 

        /// 
        ///
        ///  
        public SectionStructure()
        { 
            _elementType = FixedElement.ElementType.Section; 
        }
 
        public void Add(BlockElement element)
        {
            if (element == null)
            { 
                throw new ArgumentNullException("element");
            } 
            ((IAddChild) this).AddChild(element); 
        }
 
        void IAddChild.AddChild(object value)
        {
            if (value is ParagraphStructure || value is FigureStructure
                || value is ListStructure || value is TableStructure ) 
            {
                _elementList.Add((BlockElement)value); 
                return; 
            }
 
            throw new ArgumentException(SR.Get(SRID.DocumentStructureUnexpectedParameterType4, value.GetType(),
                typeof(ParagraphStructure), typeof(FigureStructure), typeof(ListStructure), typeof(TableStructure)),
                "value");
        } 

        void IAddChild.AddText(string text) { } 
 
        IEnumerator IEnumerable.GetEnumerator()
        { 
            throw new NotSupportedException();
        }

        IEnumerator IEnumerable.GetEnumerator() 
        {
            return ((IEnumerable)this).GetEnumerator(); 
        } 
    }
 
    /// 
    ///
    /// 
    public class ParagraphStructure : SemanticBasicElement, IAddChild, IEnumerable, IEnumerable 
    {
 
        ///  
        ///
        ///  
        public ParagraphStructure()
        {
            _elementType = FixedElement.ElementType.Paragraph;
        } 

        public void Add(NamedElement element) 
        { 
            if (element == null)
            { 
                throw new ArgumentNullException("element");
            }
            ((IAddChild) this).AddChild(element);
        } 

        void IAddChild.AddChild(object value) 
        { 
            if (value is NamedElement)
            { 
                _elementList.Add((BlockElement)value);
                return;
            }
 
            throw new ArgumentException(SR.Get(SRID.DocumentStructureUnexpectedParameterType1, value.GetType(),
                typeof(NamedElement)), 
                "value"); 
        }
 
        void IAddChild.AddText(string text) { }

        IEnumerator IEnumerable.GetEnumerator()
        { 
            throw new NotSupportedException();
        } 
 
        IEnumerator IEnumerable.GetEnumerator()
        { 
            return ((IEnumerable)this).GetEnumerator();
        }
    }
 
    /// 
    /// 
    ///  
    public class FigureStructure : SemanticBasicElement, IAddChild, IEnumerable, IEnumerable
    { 
        /// 
        ///
        /// 
        public FigureStructure() 
        {
            _elementType = FixedElement.ElementType.Figure; 
        } 

        void IAddChild.AddChild(object value) 
        {
            if (value is NamedElement)
            {
                _elementList.Add((BlockElement)value); 
                return;
            } 
            throw new ArgumentException(SR.Get(SRID.UnexpectedParameterType, value.GetType(), typeof(NamedElement)), "value"); 
        }
 
        void IAddChild.AddText(string text) { }

        public void Add(NamedElement element)
        { 
            if (element == null)
            { 
                throw new ArgumentNullException("element"); 
            }
            ((IAddChild) this).AddChild(element); 
        }

        IEnumerator IEnumerable.GetEnumerator()
        { 
            throw new NotSupportedException();
        } 
 
        IEnumerator IEnumerable.GetEnumerator()
        { 
            return ((IEnumerable)this).GetEnumerator();
        }
    }
 
    /// 
    /// 
    ///  
    public class ListStructure : SemanticBasicElement, IAddChild, IEnumerable, IEnumerable
    { 
        /// 
        ///
        /// 
        public ListStructure() 
        {
            _elementType = FixedElement.ElementType.List; 
        } 

        public void Add(ListItemStructure listItem) 
        {
            if (listItem == null)
            {
                throw new ArgumentNullException("listItem"); 
            }
            ((IAddChild) this).AddChild(listItem); 
        } 

        void IAddChild.AddChild(object value) 
        {
            if (value is ListItemStructure)
            {
                _elementList.Add((ListItemStructure)value); 
                return;
            } 
 
            throw new ArgumentException(SR.Get(SRID.UnexpectedParameterType, value.GetType(), typeof(ListItemStructure)), "value");
        } 

        void IAddChild.AddText(string text) { }

        IEnumerator IEnumerable.GetEnumerator() 
        {
            throw new NotSupportedException(); 
        } 

        IEnumerator IEnumerable.GetEnumerator() 
        {
            return ((IEnumerable)this).GetEnumerator();
        }
    } 
    /// 
    /// 
    ///  
    public class ListItemStructure : SemanticBasicElement, IAddChild, IEnumerable, IEnumerable
    { 
        /// 
        ///
        /// 
        public ListItemStructure() 
        {
            _elementType = FixedElement.ElementType.ListItem; 
        } 

        public void Add(BlockElement element) 
        {
            if (element == null)
            {
                throw new ArgumentNullException("element"); 
            }
            ((IAddChild) this).AddChild(element); 
        } 

        void IAddChild.AddChild(object value) 
        {
            if (value is ParagraphStructure || value is TableStructure || value is ListStructure || value is FigureStructure)
            {
                _elementList.Add((BlockElement)value); 
                return;
            } 
 
            throw new ArgumentException(SR.Get(SRID.DocumentStructureUnexpectedParameterType4, value.GetType(),
                typeof(ParagraphStructure), typeof(TableStructure), typeof(ListStructure), typeof(FigureStructure)), "value"); 
        }
        void IAddChild.AddText(string text) { }

        IEnumerator IEnumerable.GetEnumerator() 
        {
            throw new NotSupportedException(); 
        } 

        IEnumerator IEnumerable.GetEnumerator() 
        {
            return ((IEnumerable)this).GetEnumerator();
        }
 
        /// 
        /// 
        ///  
        public String Marker
        { 
            get { return _markerName; }
            set { _markerName = value; }
        }
 
        private String _markerName;
 
    } 
    /// 
    /// 
    /// 
    public class TableStructure : SemanticBasicElement, IAddChild, IEnumerable, IEnumerable
    {
        ///  
        ///
        ///  
        public TableStructure() 
        {
            _elementType = FixedElement.ElementType.Table; 
        }

        public void Add(TableRowGroupStructure tableRowGroup)
        { 
            if (tableRowGroup == null)
            { 
                throw new ArgumentNullException("tableRowGroup"); 
            }
            ((IAddChild) this).AddChild(tableRowGroup); 
        }

        void IAddChild.AddChild(object value)
        { 
            if (value is TableRowGroupStructure)
            { 
                _elementList.Add((TableRowGroupStructure)value); 
                return;
            } 
            throw new ArgumentException(SR.Get(SRID.UnexpectedParameterType, value.GetType(), typeof(TableRowGroupStructure)), "value");
        }

        void IAddChild.AddText(string text) { } 

        IEnumerator IEnumerable.GetEnumerator() 
        { 
            throw new NotSupportedException();
        } 

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)this).GetEnumerator(); 
        }
    } 
 
    /// 
    /// 
    /// 
    public class TableRowGroupStructure : SemanticBasicElement, IAddChild, IEnumerable, IEnumerable
    {
        ///  
        ///
        ///  
        public TableRowGroupStructure() 
        {
            _elementType = FixedElement.ElementType.TableRowGroup; 
        }

        public void Add(TableRowStructure tableRow)
        { 
            if (tableRow == null)
            { 
                throw new ArgumentNullException("tableRow"); 
            }
            ((IAddChild) this).AddChild(tableRow); 
        }

        void IAddChild.AddChild(object value)
        { 
            if (value is TableRowStructure)
            { 
                _elementList.Add((TableRowStructure)value); 
                return;
            } 
            throw new ArgumentException(SR.Get(SRID.UnexpectedParameterType, value.GetType(), typeof(TableRowStructure)), "value");
        }

        void IAddChild.AddText(string text) { } 

 
        IEnumerator IEnumerable.GetEnumerator() 
        {
            throw new NotSupportedException(); 
        }

        IEnumerator IEnumerable.GetEnumerator()
        { 
            return ((IEnumerable)this).GetEnumerator();
        } 
    } 

    ///  
    ///
    /// 
    public class TableRowStructure : SemanticBasicElement, IAddChild, IEnumerable, IEnumerable
    { 
        /// 
        /// 
        ///  
        public TableRowStructure()
        { 
            _elementType = FixedElement.ElementType.TableRow;
        }

        public void Add(TableCellStructure tableCell) 
        {
            if (tableCell == null) 
            { 
                throw new ArgumentNullException("tableCell");
            } 
            ((IAddChild) this).AddChild(tableCell);
        }

        void IAddChild.AddChild(object value) 
        {
            if (value is TableCellStructure) 
            { 
                _elementList.Add((TableCellStructure)value);
                return; 
            }
            throw new ArgumentException(SR.Get(SRID.UnexpectedParameterType, value.GetType(), typeof(TableCellStructure)), "value");
        }
 
        void IAddChild.AddText(string text) { }
 
        IEnumerator IEnumerable.GetEnumerator() 
        {
            throw new NotSupportedException(); 
        }

        IEnumerator IEnumerable.GetEnumerator()
        { 
            return ((IEnumerable)this).GetEnumerator();
        } 
    } 

    ///  
    ///
    /// 
    public class TableCellStructure : SemanticBasicElement, IAddChild, IEnumerable, IEnumerable
    { 
        /// 
        /// 
        ///  
        public TableCellStructure()
        { 
            _elementType = FixedElement.ElementType.TableCell;
            _rowSpan = 1;
            _columnSpan = 1;
        } 

        public void Add(BlockElement element) 
        { 
            if (element == null)
            { 
                throw new ArgumentNullException("element");
            }
            ((IAddChild) this).AddChild(element);
        } 

        void IAddChild.AddChild(object value) 
        { 
            if (value is ParagraphStructure || value is TableStructure || value is ListStructure || value is FigureStructure)
            { 
                _elementList.Add((BlockElement)value);
                return;
            }
            throw new ArgumentException(SR.Get(SRID.DocumentStructureUnexpectedParameterType4, value.GetType(), 
                typeof(ParagraphStructure), typeof(TableStructure), typeof(ListStructure), typeof(FigureStructure)), "value");
        } 
 
        void IAddChild.AddText(string text) { }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            throw new NotSupportedException();
        } 

        IEnumerator IEnumerable.GetEnumerator() 
        { 
            return ((IEnumerable)this).GetEnumerator();
        } 

        /// 
        ///
        ///  
        public int RowSpan
        { 
            get { return _rowSpan; } 
            set {_rowSpan = value; }
        } 

        /// 
        ///
        ///  
        public int ColumnSpan
        { 
            get { return _columnSpan; } 
            set {_columnSpan = value; }
        } 

        private int _rowSpan;
        private int _columnSpan;
    } 
 }
 

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