Table.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 / ndp / fx / src / xsp / System / Web / UI / WebControls / Table.cs / 1305376 / Table.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.UI.WebControls { 
 
    using System;
    using System.ComponentModel; 
    using System.Drawing;
    using System.Drawing.Design;
    using System.Globalization;
    using System.Web; 
    using System.Web.Util;
 
    ///  
    ///    Constructs a table and defines its properties.
    ///  
    [
    DefaultProperty("Rows"),
    ParseChildren(true, "Rows"),
    Designer("System.Web.UI.Design.WebControls.TableDesigner, " + AssemblyRef.SystemDesign), 
    SupportsEventValidation,
    ] 
    public class Table : WebControl, IPostBackEventHandler { 
        private TableRowCollection _rows;
        private bool _hasRowSections; 


        /// 
        ///     
        ///       Initializes a new instance of the  class.
        ///     
        ///  
        public Table() : base(HtmlTextWriterTag.Table) {
        } 



        ///  
        ///    Indicates the URL of the background image to display
        ///       behind the table. The image will be tiled if it is smaller than the table. 
        ///  
        [
        WebCategory("Appearance"), 
        DefaultValue(""),
        Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
        UrlProperty(),
        WebSysDescription(SR.Table_BackImageUrl) 
        ]
        public virtual string BackImageUrl { 
            get { 
                if (ControlStyleCreated == false) {
                    return String.Empty; 
                }
                return((TableStyle)ControlStyle).BackImageUrl;
            }
            set { 
                ((TableStyle)ControlStyle).BackImageUrl = value;
            } 
        } 

 
        [
        DefaultValue(""),
        Localizable(true),
        WebCategory("Accessibility"), 
        WebSysDescription(SR.Table_Caption)
        ] 
        public virtual string Caption { 
            get {
                string s = (string)ViewState["Caption"]; 
                return (s != null) ? s : String.Empty;
            }
            set {
                ViewState["Caption"] = value; 
            }
        } 
 

        [ 
        DefaultValue(TableCaptionAlign.NotSet),
        WebCategory("Accessibility"),
        WebSysDescription(SR.WebControl_CaptionAlign)
        ] 
        public virtual TableCaptionAlign CaptionAlign {
            get { 
                object o = ViewState["CaptionAlign"]; 
                return (o != null) ? (TableCaptionAlign)o : TableCaptionAlign.NotSet;
            } 
            set {
                if ((value < TableCaptionAlign.NotSet) ||
                    (value > TableCaptionAlign.Right)) {
                    throw new ArgumentOutOfRangeException("value"); 
                }
                ViewState["CaptionAlign"] = value; 
            } 
        }
 

        /// 
        ///    Gets or sets
        ///       the distance (in pixels) between the border and 
        ///       the contents of the table cell.
        ///  
        [ 
        WebCategory("Appearance"),
        DefaultValue(-1), 
        WebSysDescription(SR.Table_CellPadding)
        ]
        public virtual int CellPadding {
            get { 
                if (ControlStyleCreated == false) {
                    return -1; 
                } 
                return((TableStyle)ControlStyle).CellPadding;
            } 
            set {
                ((TableStyle)ControlStyle).CellPadding = value;
            }
        } 

 
        ///  
        ///    Gets or
        ///       sets 
        ///       the distance (in pixels) between table cells.
        /// 
        [
        WebCategory("Appearance"), 
        DefaultValue(-1),
        WebSysDescription(SR.Table_CellSpacing) 
        ] 
        public virtual int CellSpacing {
            get { 
                if (ControlStyleCreated == false) {
                    return -1;
                }
                return((TableStyle)ControlStyle).CellSpacing; 
            }
            set { 
                ((TableStyle)ControlStyle).CellSpacing = value; 
            }
        } 


        /// 
        /// Gets or sets the gridlines property of the  
        /// class.
        ///  
        [ 
        WebCategory("Appearance"),
        DefaultValue(GridLines.None), 
        WebSysDescription(SR.Table_GridLines)
        ]
        public virtual GridLines GridLines {
            get { 
                if (ControlStyleCreated == false) {
                    return GridLines.None; 
                } 
                return((TableStyle)ControlStyle).GridLines;
            } 
            set {
                ((TableStyle)ControlStyle).GridLines = value;
            }
        } 

        internal bool HasRowSections { 
            get { 
                return _hasRowSections;
            } 
            set {
                _hasRowSections = value;
            }
        } 

 
        ///  
        ///    Gets or sets the horizontal alignment of the table within the page.
        ///  
        [
        WebCategory("Layout"),
        DefaultValue(HorizontalAlign.NotSet),
        WebSysDescription(SR.Table_HorizontalAlign) 
        ]
        public virtual HorizontalAlign HorizontalAlign { 
            get { 
                if (ControlStyleCreated == false) {
                    return HorizontalAlign.NotSet; 
                }
                return((TableStyle)ControlStyle).HorizontalAlign;
            }
            set { 
                ((TableStyle)ControlStyle).HorizontalAlign = value;
            } 
        } 

        public override bool SupportsDisabledAttribute { 
            get {
                return RenderingCompatibility < VersionUtil.Framework40;
            }
        } 

        ///  
        ///     Gets the collection of rows within 
        ///       the table.
        ///  
        [
        MergableProperty(false),
        WebSysDescription(SR.Table_Rows),
        PersistenceMode(PersistenceMode.InnerDefaultProperty) 
        ]
        public virtual TableRowCollection Rows { 
            get { 
                if (_rows == null)
                    _rows = new TableRowCollection(this); 
                return _rows;
            }
        }
 

        ///  
        ///  
        ///    A protected method. Adds information about the border
        ///       color and border width HTML attributes to the list of attributes to render. 
        /// 
        protected override void AddAttributesToRender(HtmlTextWriter writer) {
            base.AddAttributesToRender(writer);
            if (ControlStyleCreated) { 
                if (EnableLegacyRendering || writer is Html32TextWriter) {
                    // Must render bordercolor attribute to affect cell borders. 
                    Color borderColor = BorderColor; 
                    if (!borderColor.IsEmpty) {
                        writer.AddAttribute(HtmlTextWriterAttribute.Bordercolor, ColorTranslator.ToHtml(borderColor)); 
                    }
                }
            }
 
            string borderWidthString = "0";
            bool renderBorder = false; 
            if (ControlStyleCreated) { 
                // GridLines property controls whether we render the "border" attribute, as "border" controls
                // whether gridlines appear in HTML 3.2. Always render a value for the border attribute. 
                Unit borderWidth = BorderWidth;
                GridLines gridLines = GridLines;
                if (gridLines != GridLines.None) {
                    if (borderWidth.IsEmpty || borderWidth.Type != UnitType.Pixel) { 
                        borderWidthString = "1";
                        renderBorder = true; 
                    } 
                    else {
                        borderWidthString = ((int)borderWidth.Value).ToString(NumberFormatInfo.InvariantInfo); 
                    }
                }
            }
            if ((RenderingCompatibility < VersionUtil.Framework40) || renderBorder) { 
                writer.AddAttribute(HtmlTextWriterAttribute.Border, borderWidthString);
            } 
        } 

 
        /// 
        ///    [To be supplied.]
        /// 
        protected override ControlCollection CreateControlCollection() { 
            return new RowControlCollection(this);
        } 
 

        ///  
        /// 
        ///    A protected method. Creates a table control style.
        /// 
        protected override Style CreateControlStyle() { 
            return new TableStyle(ViewState);
        } 
 

        ///  
        ///    [To be supplied.]
        /// 
        protected virtual void RaisePostBackEvent(string argument) {
            ValidateEvent(UniqueID, argument); 

            if (AdapterInternal != null) { 
                IPostBackEventHandler pbeh = AdapterInternal as IPostBackEventHandler; 
                if (pbeh != null) {
                    pbeh.RaisePostBackEvent(argument); 
                }
            }
        }
 

        ///  
        ///  
        ///   Renders out the caption of the table if needed, before any rows get rendered.
        ///  
        public override void RenderBeginTag(HtmlTextWriter writer) {
            base.RenderBeginTag(writer);

            string caption = Caption; 
            if (caption.Length != 0) {
                TableCaptionAlign alignment = CaptionAlign; 
 
                if (alignment != TableCaptionAlign.NotSet) {
                    string alignValue = "Right"; 

                    switch (alignment) {
                        case TableCaptionAlign.Top:
                            alignValue = "Top"; 
                            break;
                        case TableCaptionAlign.Bottom: 
                            alignValue = "Bottom"; 
                            break;
                        case TableCaptionAlign.Left: 
                            alignValue = "Left";
                            break;
                    }
                    writer.AddAttribute(HtmlTextWriterAttribute.Align, alignValue); 
                }
                writer.RenderBeginTag(HtmlTextWriterTag.Caption); 
                writer.Write(caption); 
                writer.RenderEndTag();
            } 
        }


        ///  
        ///    Render the table rows.
        ///  
        protected internal override void RenderContents(HtmlTextWriter writer) { 
            TableRowCollection rows = Rows;
            int rowCount = rows.Count; 
            if (rowCount > 0) {
                if (HasRowSections) {
                    TableRowSection currentSection = TableRowSection.TableHeader;
                    bool openedTag = false; 
                    foreach (TableRow row in rows) {
                        if (row.TableSection < currentSection) { 
                            // throw if table sections aren't in order 
                            throw new HttpException(SR.GetString(SR.Table_SectionsMustBeInOrder, ID));
                        } 
                        if (currentSection < row.TableSection || (row.TableSection == TableRowSection.TableHeader && !openedTag)) {
                            if (openedTag) {
                                writer.RenderEndTag();
                            } 
                            currentSection = row.TableSection;
                            openedTag = true; 
                            switch (currentSection) { 
                                case TableRowSection.TableHeader:
                                    writer.RenderBeginTag(HtmlTextWriterTag.Thead); 
                                    break;
                                case TableRowSection.TableBody:
                                    writer.RenderBeginTag(HtmlTextWriterTag.Tbody);
                                    break; 
                                case TableRowSection.TableFooter:
                                    writer.RenderBeginTag(HtmlTextWriterTag.Tfoot); 
                                    break; 
                            }
                        } 
                        row.RenderControl(writer);
                    }
                    writer.RenderEndTag();
                } 
                else {
                    foreach (TableRow row in rows) { 
                        row.RenderControl(writer); 
                    }
                } 
            }
        }

        void IPostBackEventHandler.RaisePostBackEvent(string eventArgument) { 
            RaisePostBackEvent(eventArgument);
        } 
 

        ///  
        ///    [To be supplied.]
        /// 
        protected class RowControlCollection : ControlCollection {
 
            internal RowControlCollection (Control owner) : base(owner) {
            } 
 

            ///  
            /// Adds the specified  object to the collection. The new control is added
            ///    to the end of the array.
            /// 
            public override void Add(Control child) { 
                if (child is TableRow)
                    base.Add(child); 
                else 
                    throw new ArgumentException(SR.GetString(SR.Cannot_Have_Children_Of_Type, "Table", child.GetType().Name.ToString(CultureInfo.InvariantCulture))); // throw an exception here
            } 


            /// 
            /// Adds the specified  object to the collection. The new control is added 
            ///    to the array at the specified index location.
            ///  
            public override void AddAt(int index, Control child) { 
                if (child is TableRow)
                    base.AddAt(index, child); 
                else
                    throw new ArgumentException(SR.GetString(SR.Cannot_Have_Children_Of_Type, "Table", child.GetType().Name.ToString(CultureInfo.InvariantCulture))); // throw an exception here
            }
        } // class RowControlCollection 
    } // class Table
} 
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

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