TableItemStyle.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 / TableItemStyle.cs / 1305376 / 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; 
 
    /// 
    ///    Specifies the style of the table item. 
    /// 
    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); 
        }
 

    }
}
 

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