TableItemStyle.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / UI / WebControls / TableItemStyle.cs / 1 / TableItemStyle.cs
                        

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

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

 
    /// 
    ///    Specifies the style of the table item.
    /// 
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)] 
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    public class TableItemStyle : Style { 
 

        ///  
        ///    Specifies the horizontal alignment property. This field is
        ///       constant.
        /// 
        internal const int PROP_HORZALIGN = 0x00010000; 

        ///  
        ///    Specifies the vertical alignment property. This field is 
        ///       constant.
        ///  
        internal const int PROP_VERTALIGN = 0x00020000;

        /// 
        ///    Specifies the 
        ///       wrap property. This field is constant.
        ///  
        internal const int PROP_WRAP = 0x00040000; 

 
        /// 
        /// Creates a new instance of the  class.
        /// 
        public TableItemStyle() : base() { 
        }
 
 
        /// 
        ///     
        ///       Creates a new instance of the  class with the
        ///       specified state bag.
        ///    
        ///  
        public TableItemStyle(StateBag bag) : base(bag) {
        } 
 
        private bool EnableLegacyRendering {
            get { 
                return (RuntimeConfig.GetAppConfig().XhtmlConformance.Mode == XhtmlConformanceMode.Legacy);
            }
        }
 

        ///  
        ///    Gets or sets the horizontal alignment of the table item. 
        /// 
        [ 
        WebCategory("Layout"),
        DefaultValue(HorizontalAlign.NotSet),
        WebSysDescription(SR.TableItem_HorizontalAlign),
        NotifyParentProperty(true) 
        ]
        public virtual HorizontalAlign HorizontalAlign { 
            get { 
                if (IsSet(PROP_HORZALIGN)) {
                    return(HorizontalAlign)(ViewState["HorizontalAlign"]); 
                }
                return HorizontalAlign.NotSet;
            }
            set { 
                if (value < HorizontalAlign.NotSet || value > HorizontalAlign.Justify) {
                    throw new ArgumentOutOfRangeException("value"); 
                } 
                ViewState["HorizontalAlign"] = value;
                SetBit(PROP_HORZALIGN); 
            }
        }

 
        /// 
        ///    Gets or sets the vertical alignment of the table item. 
        ///  
        [
        WebCategory("Layout"), 
        DefaultValue(VerticalAlign.NotSet),
        WebSysDescription(SR.TableItem_VerticalAlign),
        NotifyParentProperty(true)
        ] 
        public virtual VerticalAlign VerticalAlign {
            get { 
                if (IsSet(PROP_VERTALIGN)) { 
                    return(VerticalAlign)(ViewState["VerticalAlign"]);
                } 
                return VerticalAlign.NotSet;
            }
            set {
                if (value < VerticalAlign.NotSet || value > VerticalAlign.Bottom) { 
                    throw new ArgumentOutOfRangeException("value");
                } 
                ViewState["VerticalAlign"] = value; 
                SetBit(PROP_VERTALIGN);
            } 
        }


        ///  
        ///    Gets or sets a value indicating whether the cell content wraps within the cell.
        ///  
        [ 
        WebCategory("Layout"),
        DefaultValue(true), 
        WebSysDescription(SR.TableItemStyle_Wrap),
        NotifyParentProperty(true)
        ]
        public virtual bool Wrap { 
            get {
                if (IsSet(PROP_WRAP)) { 
                    return(bool)(ViewState["Wrap"]); 
                }
                return true; 
            }
            set {
                ViewState["Wrap"] = value;
                SetBit(PROP_WRAP); 
            }
        } 
 

        ///  
        ///    Adds information about horizontal alignment, vertical alignment, and wrap to the list of attributes to render.
        /// 
        public override void AddAttributesToRender(HtmlTextWriter writer, WebControl owner) {
            base.AddAttributesToRender(writer, owner); 

            if (!Wrap) { 
                if (IsControlEnableLegacyRendering(owner)) { 
                    writer.AddAttribute(HtmlTextWriterAttribute.Nowrap, "nowrap");
                } 
                else {
                    writer.AddStyleAttribute(HtmlTextWriterStyle.WhiteSpace, "nowrap");
                }
            } 

            HorizontalAlign hAlign = HorizontalAlign; 
            if (hAlign != HorizontalAlign.NotSet) { 
                TypeConverter hac = TypeDescriptor.GetConverter(typeof(HorizontalAlign));
                writer.AddAttribute(HtmlTextWriterAttribute.Align, hac.ConvertToString(hAlign).ToLower(CultureInfo.InvariantCulture)); 
            }

            VerticalAlign vAlign = VerticalAlign;
            if (vAlign != VerticalAlign.NotSet) { 
                TypeConverter hac = TypeDescriptor.GetConverter(typeof(VerticalAlign));
                writer.AddAttribute(HtmlTextWriterAttribute.Valign, hac.ConvertToString(vAlign).ToLower(CultureInfo.InvariantCulture)); 
            } 
        }
 

        /// 
        ///    Copies non-blank elements from the specified style, overwriting existing
        ///       style elements if necessary. 
        /// 
        public override void CopyFrom(Style s) { 
            if (s != null && !s.IsEmpty) { 

                base.CopyFrom(s); 

                if (s is TableItemStyle) {
                    TableItemStyle ts = (TableItemStyle)s;
 
                    if (s.RegisteredCssClass.Length != 0) {
                        if (ts.IsSet(PROP_WRAP)) { 
                            ViewState.Remove("Wrap"); 
                            ClearBit(PROP_WRAP);
                        } 
                    }
                    else {
                        if (ts.IsSet(PROP_WRAP))
                            this.Wrap = ts.Wrap; 
                    }
 
                    if (ts.IsSet(PROP_HORZALIGN)) 
                        this.HorizontalAlign = ts.HorizontalAlign;
                    if (ts.IsSet(PROP_VERTALIGN)) 
                        this.VerticalAlign = ts.VerticalAlign;

                }
            } 
        }
 
        private bool IsControlEnableLegacyRendering(Control control) { 
            if (control != null) {
                return control.EnableLegacyRendering; 
            }
            else {
                return EnableLegacyRendering;
            } 
        }
 
 
        /// 
        ///    Copies non-blank elements from the specified style, but will not overwrite 
        ///       any existing style elements.
        /// 
        public override void MergeWith(Style s) {
            if (s != null && !s.IsEmpty) { 

                if (IsEmpty) { 
                    // merge into an empty style is equivalent to a copy, which 
                    // is more efficient
                    CopyFrom(s); 
                    return;
                }

                base.MergeWith(s); 

                if (s is TableItemStyle) { 
                    TableItemStyle ts = (TableItemStyle)s; 

                    // Since we're already copying the registered CSS class in base.MergeWith, we don't 
                    // need to any attributes that would be included in that class.
                    if (s.RegisteredCssClass.Length == 0) {
                        if (ts.IsSet(PROP_WRAP) && !this.IsSet(PROP_WRAP))
                            this.Wrap = ts.Wrap; 
                    }
 
                    if (ts.IsSet(PROP_HORZALIGN) && !this.IsSet(PROP_HORZALIGN)) 
                        this.HorizontalAlign = ts.HorizontalAlign;
                    if (ts.IsSet(PROP_VERTALIGN) && !this.IsSet(PROP_VERTALIGN)) 
                        this.VerticalAlign = ts.VerticalAlign;

                }
            } 
        }
 
 
        /// 
        ///     
        ///       Clears out any defined style elements from the state bag.
        ///    
        /// 
        public override void Reset() { 
            if (IsSet(PROP_HORZALIGN))
                ViewState.Remove("HorizontalAlign"); 
            if (IsSet(PROP_VERTALIGN)) 
                ViewState.Remove("VerticalAlign");
            if (IsSet(PROP_WRAP)) 
                ViewState.Remove("Wrap");

            base.Reset();
        } 

        ///  
        /// Only serialize if the Wrap property has changed.  This means that we serialize "false" 
        /// if they were set to false in the designer.
        ///  
        private void ResetWrap() {
            ViewState.Remove("Wrap");
            ClearBit(PROP_WRAP);
        } 

        ///  
        /// Only serialize if the Wrap property has changed.  This means that we serialize "false" 
        /// if they were set to false in the designer.
        ///  
        private bool ShouldSerializeWrap() {
            return IsSet(PROP_WRAP);
        }
 

    } 
}

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