Table.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / UI / WebControls / Table.cs / 2 / Table.cs
                        

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

namespace System.Web.UI.WebControls { 
 
    using System;
    using System.Collections; 
    using System.ComponentModel;
    using System.Drawing;
    using System.Drawing.Design;
    using System.Globalization; 
    using System.IO;
    using System.Web; 
    using System.Security.Permissions; 

 
    /// 
    ///    Constructs a table and defines its properties.
    /// 
    [ 
    DefaultProperty("Rows"),
    ParseChildren(true, "Rows"), 
    Designer("System.Web.UI.Design.WebControls.TableDesigner, " + AssemblyRef.SystemDesign), 
    SupportsEventValidation,
    ] 
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    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;
            }
        }
 

        ///  
        ///     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);
            string borderWidthString = "0"; 

            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));
                    }
                } 

                // 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";
                    } 
                    else {
                        borderWidthString = ((int)borderWidth.Value).ToString(NumberFormatInfo.InvariantInfo); 
                    } 
                }
            } 
            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(_adapter != null) {
                IPostBackEventHandler pbeh = _adapter 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 
}

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