FixedSOMTable.cs source code in C# .NET

                        Code:
                         / DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Framework / System / Windows / Documents / FixedSOMTable.cs / 1 / FixedSOMTable.cs
                        
                        
                            /*++ 

    File: FixedSOMTable.cs

    Copyright (C) 2005 Microsoft Corporation. All rights reserved. 

    Description: 
        This class reprsents a table on the page 

    History: 
       05/17/2005: [....] - Created

--*/
 
namespace System.Windows.Documents
{ 
    using System.Windows.Shapes; 
    using System.Windows.Media;
    using System.Diagnostics; 
    using System.Windows;
    using System.Globalization;

    internal sealed class FixedSOMTable : FixedSOMPageElement 
    {
        //-------------------------------------------------------------------- 
        // 
        // Constructors
        // 
        //---------------------------------------------------------------------

        #region Constructors
        public FixedSOMTable(FixedSOMPage page) : base(page) 
        {
            _numCols = 0; 
        } 
        #endregion Constructors
 
        //-------------------------------------------------------------------
        //
        // Public Methods
        // 
        //---------------------------------------------------------------------
 
        #region Public Methods 
#if DEBUG
        public override void Render(DrawingContext dc, string label, DrawDebugVisual debugVisual) 
        {
            Pen pen = new Pen(Brushes.Green, 5);
            Rect rect = _boundingRect;
            dc.DrawRectangle(null, pen , rect); 

            CultureInfo EnglishCulture = CultureInfo.GetCultureInfoByIetfLanguageTag("en-US"); 
            FormattedText ft = new FormattedText(label, 
                                        EnglishCulture,
                                        FlowDirection.LeftToRight, 
                                        new Typeface("Courier New"),
                                        20,
                                        Brushes.Blue);
            Point labelLocation = new Point(rect.Left-25, (rect.Bottom + rect.Top)/2 - 10); 
          //  dc.DrawText(ft, labelLocation);
 
            for (int i = 0; i < _semanticBoxes.Count; i++) 
            {
                _semanticBoxes[i].Render(dc, label + " " + i.ToString(),debugVisual); 
            }
        }
#endif
        public void AddRow(FixedSOMTableRow row) 
        {
            base.Add(row); 
            int colCount = row.SemanticBoxes.Count; 
            if (colCount > _numCols)
            { 
                _numCols = colCount;
            }
        }
 
        public bool AddContainer(FixedSOMContainer container)
        { 
            Rect bounds = container.BoundingRect; 

 
            //Allow couple pixels margin
            double verticalOverlap = bounds.Height * 0.2;
            double horizontalOverlap = bounds.Width * 0.2;
            bounds.Inflate(-horizontalOverlap,-verticalOverlap); 

            if (this.BoundingRect.Contains(bounds)) 
            { 
                foreach (FixedSOMTableRow row in this.SemanticBoxes)
                { 
                    if (row.BoundingRect.Contains(bounds))
                    {
                        foreach (FixedSOMTableCell cell in row.SemanticBoxes)
                        { 
                            if (cell.BoundingRect.Contains(bounds))
                            { 
                                cell.AddContainer(container); 
                                FixedSOMFixedBlock block = container as FixedSOMFixedBlock;
                                if (block != null) 
                                {
                                    if (block.IsRTL)
                                    {
                                        _RTLCount++; 
                                    }
                                    else 
                                    {
 
                                        _LTRCount++;
                                    } 
                                }
                                return true;
                            }
                        } 
                    }
                } 
            } 
            return false;
        } 


        public override void SetRTFProperties(FixedElement element)
        { 
            if (element.Type == typeof(Table))
            { 
                element.SetValue(Table.CellSpacingProperty, 0.0); 
            }
        } 


        #endregion Public Methods
 
        #region Public Properties
        public override bool IsRTL 
        { 
            get
            { 
                return _RTLCount > _LTRCount;
            }
        }
        #endregion Public Properties 

        #region Internal Properties 
        internal override FixedElement.ElementType[] ElementTypes 
        {
            get 
            {
                return new FixedElement.ElementType[2] { FixedElement.ElementType.Table, FixedElement.ElementType.TableRowGroup };
            }
        } 

        internal bool IsEmpty 
        { 
            get
            { 
                foreach (FixedSOMTableRow row in this.SemanticBoxes)
                {
                    if (!row.IsEmpty)
                    { 
                        return false;
                    } 
                } 
                return true;
            } 
        }

        internal bool IsSingleCelled
        { 
            get
            { 
                if (this.SemanticBoxes.Count == 1) 
                {
                    FixedSOMTableRow row = this.SemanticBoxes[0] as FixedSOMTableRow; 
                    Debug.Assert(row != null);
                    return (row.SemanticBoxes.Count == 1);
                }
                return false; 
            }
        } 
 

        #endregion Internal Properties 

        #region Internal methods
        internal void DeleteEmptyRows()
        { 
            for (int i=0; i nextCol)
                        { 
                            deleteCol = false;
                        }
                    }
                } 

                if (deleteCol) 
                { 
                    for (r = 0; r < nRows; r++)
                    { 
                        FixedSOMTableRow row = (FixedSOMTableRow)(this.SemanticBoxes[r]);
                        row.SemanticBoxes.RemoveAt(indexInRow[r]);
                    }
 
                    if (nextCol == double.MaxValue)
                    { 
                        break; 
                    }
                    else 
                    {
                        continue;
                    }
                } 
                // are we done?
                if (nextCol == double.MaxValue) 
                { 
                    break;
                } 
                // increment ColumnSpans, indexInRow
                for (r = 0; r < nRows; r++)
                {
                    FixedSOMTableRow row = (FixedSOMTableRow)(this.SemanticBoxes[r]); 
                    int idx = indexInRow[r];
                    if (idx + 1 < row.SemanticBoxes.Count && row.SemanticBoxes[idx + 1].BoundingRect.Left == nextCol) 
                    { 
                        indexInRow[r] = idx + 1;
                    } 
                    else
                    {
                        ((FixedSOMTableCell)row.SemanticBoxes[idx]).ColumnSpan++;
                    } 
                }
 
            } 
        }
 


        #endregion Internal methods
 
        //--------------------------------------------------------------------
        // 
        // Private Fields 
        //
        //--------------------------------------------------------------------- 
        #region Private Fields
        const double _minColumnWidth = 5; // empty columns narrower than this will be deleted
        const double _minRowHeight = 10; //empty rows smaller than this will be deleted
 
        private int _RTLCount;
        private int _LTRCount; 
 
        int _numCols;
 
        #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
FixedSOMTable.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
