FontInfo.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 / FontInfo.cs / 1305376 / FontInfo.cs

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

namespace System.Web.UI.WebControls { 
 
    using System.ComponentModel.Design;
    using System; 
    using System.ComponentModel;
    using System.Collections;
    using System.Drawing;
    using System.Drawing.Design; 
    using System.Globalization;
    using System.Web; 
 
    /// 
    ///    Represents the font properties for text. This class cannot be inherited. 
    /// 
    [
        TypeConverterAttribute(typeof(ExpandableObjectConverter))
    ] 
    public sealed class FontInfo {
 
        private Style owner; 

 
        /// 
        /// 
        internal FontInfo(Style owner) {
            this.owner = owner; 
        }
 
 
        /// 
        ///    Indicates whether the text is bold. 
        /// 
        [
            WebCategory("Appearance"),
            DefaultValue(false), 
            WebSysDescription(SR.FontInfo_Bold),
            NotifyParentProperty(true) 
        ] 
        public bool Bold {
            get { 
                if (owner.IsSet(Style.PROP_FONT_BOLD)) {
                    return (bool)(owner.ViewState["Font_Bold"]);
                }
                return false; 
            }
            set { 
                owner.ViewState["Font_Bold"] = value; 
                owner.SetBit(Style.PROP_FONT_BOLD);
            } 
        }


        ///  
        ///    Indicates whether the text is italic.
        ///  
        [ 
            WebCategory("Appearance"),
            DefaultValue(false), 
            WebSysDescription(SR.FontInfo_Italic),
            NotifyParentProperty(true)
        ]
        public bool Italic { 
            get {
                if (owner.IsSet(Style.PROP_FONT_ITALIC)) { 
                    return (bool)(owner.ViewState["Font_Italic"]); 
                }
                return false; 
            }
            set {
                owner.ViewState["Font_Italic"] = value;
                owner.SetBit(Style.PROP_FONT_ITALIC); 
            }
        } 
 

        ///  
        ///    Indicates the name of the font.
        /// 
        [
            Editor("System.Drawing.Design.FontNameEditor, " + AssemblyRef.SystemDrawingDesign, typeof(UITypeEditor)), 
            TypeConverterAttribute(typeof(FontConverter.FontNameConverter)),
            WebCategory("Appearance"), 
            DefaultValue(""), 
            WebSysDescription(SR.FontInfo_Name),
            NotifyParentProperty(true), 
            RefreshProperties(RefreshProperties.Repaint),
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public string Name { 
            get {
                string[] names = Names; 
                if (names.Length > 0) 
                    return names[0];
                return String.Empty; 
            }
            set {
                if (value == null)
                    throw new ArgumentNullException("value"); 

                if (value.Length == 0) { 
                    Names = null; 
                }
                else { 
                    Names = new string[1] { value };
                }
            }
        } 

 
        ///  
        /// 
        [ 
            TypeConverterAttribute(typeof(FontNamesConverter)),
            WebCategory("Appearance"),
            Editor("System.Windows.Forms.Design.StringArrayEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
            WebSysDescription(SR.FontInfo_Names), 
            RefreshProperties(RefreshProperties.Repaint),
            NotifyParentProperty(true) 
        ] 
        public string[] Names {
            get { 
                if (owner.IsSet(Style.PROP_FONT_NAMES)) {
                    string[] names = (string[])owner.ViewState["Font_Names"];
                    if (names != null)
                        return names; 
                }
                return new string[0]; 
            } 
            set {
                owner.ViewState["Font_Names"] = value; 
                owner.SetBit(Style.PROP_FONT_NAMES);
            }
        }
 

        ///  
        ///    Indicates whether the text is overline. 
        /// 
        [ 
            WebCategory("Appearance"),
            DefaultValue(false),
            WebSysDescription(SR.FontInfo_Overline),
            NotifyParentProperty(true) 
        ]
        public bool Overline { 
            get { 
                if (owner.IsSet(Style.PROP_FONT_OVERLINE)) {
                    return (bool)(owner.ViewState["Font_Overline"]); 
                }
                return false;
            }
            set { 
                owner.ViewState["Font_Overline"] = value;
                owner.SetBit(Style.PROP_FONT_OVERLINE); 
            } 
        }
 

        /// 
        /// 
        internal Style Owner { 
            get {
                return owner; 
            } 
        }
 

        /// 
        ///    Indicates the font size.
        ///  
        [
            WebCategory("Appearance"), 
            DefaultValue(typeof(FontUnit), ""), 
            WebSysDescription(SR.FontInfo_Size),
            NotifyParentProperty(true), 
            RefreshProperties(RefreshProperties.Repaint)
        ]
        public FontUnit Size {
            get { 
                if (owner.IsSet(Style.PROP_FONT_SIZE)) {
                    return (FontUnit)(owner.ViewState["Font_Size"]); 
                } 
                return FontUnit.Empty;
            } 
            set {
                if ((value.Type == FontSize.AsUnit) && (value.Unit.Value < 0)) {
                    throw new ArgumentOutOfRangeException("value");
                } 
                owner.ViewState["Font_Size"] = value;
                owner.SetBit(Style.PROP_FONT_SIZE); 
            } 
        }
 

        /// 
        ///    Indicates whether the text is striked out.
        ///  
        [
            WebCategory("Appearance"), 
            DefaultValue(false), 
            WebSysDescription(SR.FontInfo_Strikeout),
            NotifyParentProperty(true) 
        ]
        public bool Strikeout {
            get {
                if (owner.IsSet(Style.PROP_FONT_STRIKEOUT)) { 
                    return (bool)(owner.ViewState["Font_Strikeout"]);
                } 
                return false; 
            }
            set { 
                owner.ViewState["Font_Strikeout"] = value;
                owner.SetBit(Style.PROP_FONT_STRIKEOUT);
            }
        } 

 
        ///  
        ///    Indicates whether the text is underlined.
        ///  
        [
            WebCategory("Appearance"),
            DefaultValue(false),
            WebSysDescription(SR.FontInfo_Underline), 
            NotifyParentProperty(true)
        ] 
        public bool Underline { 
            get {
                if (owner.IsSet(Style.PROP_FONT_UNDERLINE)) { 
                    return (bool)(owner.ViewState["Font_Underline"]);
                }
                return false;
            } 
            set {
                owner.ViewState["Font_Underline"] = value; 
                owner.SetBit(Style.PROP_FONT_UNDERLINE); 
            }
        } 


        /// 
        /// Resets all properties that have their default value to their unset state.  
        /// 
        public void ClearDefaults() { 
            if (Names.Length == 0) { 
                owner.ViewState.Remove("Font_Names");
                owner.ClearBit(Style.PROP_FONT_NAMES); 
            }
            if (Size == FontUnit.Empty) {
                owner.ViewState.Remove("Font_Size");
                owner.ClearBit(Style.PROP_FONT_SIZE); 
            }
            if (Bold == false) 
                ResetBold(); 
            if (Italic == false)
                ResetItalic(); 
            if (Underline == false)
                ResetUnderline();
            if (Overline == false)
                ResetOverline(); 
            if (Strikeout == false)
                ResetStrikeout(); 
        } 

 

        /// 
        /// Copies the font properties of another  into this instance. 
        ///  
        public void CopyFrom(FontInfo f) {
            if (f != null) { 
                Style fOwner = f.Owner; 
                if (fOwner.RegisteredCssClass.Length != 0) {
                    if (fOwner.IsSet(Style.PROP_FONT_NAMES)) 
                        ResetNames();
                    if (fOwner.IsSet(Style.PROP_FONT_SIZE) && (f.Size != FontUnit.Empty))
                        ResetFontSize();
                    if (fOwner.IsSet(Style.PROP_FONT_BOLD)) 
                        ResetBold();
                    if (fOwner.IsSet(Style.PROP_FONT_ITALIC)) 
                        ResetItalic(); 
                    if (fOwner.IsSet(Style.PROP_FONT_OVERLINE))
                        ResetOverline(); 
                    if (fOwner.IsSet(Style.PROP_FONT_STRIKEOUT))
                        ResetStrikeout();
                    if (fOwner.IsSet(Style.PROP_FONT_UNDERLINE))
                        ResetUnderline(); 
                }
                else { 
                    if (fOwner.IsSet(Style.PROP_FONT_NAMES)) { 
                        Names = f.Names;
                    } 
                    if (fOwner.IsSet(Style.PROP_FONT_SIZE) && (f.Size != FontUnit.Empty))
                        Size = f.Size;

                    // Only carry through true boolean values. Otherwise merging and copying 
                    // can do 3 different things for each property, but they are only persisted
                    // as 2 state values. 
                    if (fOwner.IsSet(Style.PROP_FONT_BOLD)) 
                        Bold = f.Bold;
                    if (fOwner.IsSet(Style.PROP_FONT_ITALIC)) 
                        Italic = f.Italic;
                    if (fOwner.IsSet(Style.PROP_FONT_OVERLINE))
                        Overline = f.Overline;
                    if (fOwner.IsSet(Style.PROP_FONT_STRIKEOUT)) 
                        Strikeout = f.Strikeout;
                    if (fOwner.IsSet(Style.PROP_FONT_UNDERLINE)) 
                        Underline = f.Underline; 
                }
            } 
        }


        ///  
        /// Combines the font properties of another  with this
        ///    instance.  
        ///  
        public void MergeWith(FontInfo f) {
            if (f != null) { 
                Style fOwner = f.Owner;
                if (fOwner.RegisteredCssClass.Length == 0) {
                    if (fOwner.IsSet(Style.PROP_FONT_NAMES) && !owner.IsSet(Style.PROP_FONT_NAMES))
                        Names = f.Names; 
                    if (fOwner.IsSet(Style.PROP_FONT_SIZE) && (!owner.IsSet(Style.PROP_FONT_SIZE) || (Size == FontUnit.Empty)))
                        Size = f.Size; 
                    if (fOwner.IsSet(Style.PROP_FONT_BOLD) && !owner.IsSet(Style.PROP_FONT_BOLD)) 
                        Bold = f.Bold;
                    if (fOwner.IsSet(Style.PROP_FONT_ITALIC) && !owner.IsSet(Style.PROP_FONT_ITALIC)) 
                        Italic = f.Italic;
                    if (fOwner.IsSet(Style.PROP_FONT_OVERLINE) && !owner.IsSet(Style.PROP_FONT_OVERLINE))
                        Overline = f.Overline;
                    if (fOwner.IsSet(Style.PROP_FONT_STRIKEOUT) && !owner.IsSet(Style.PROP_FONT_STRIKEOUT)) 
                        Strikeout = f.Strikeout;
                    if (fOwner.IsSet(Style.PROP_FONT_UNDERLINE) && !owner.IsSet(Style.PROP_FONT_UNDERLINE)) 
                        Underline = f.Underline; 
                }
            } 
        }


        ///  
        /// Resets all properties to their defaults.
        ///  
        internal void Reset() { 
            if (owner.IsSet(Style.PROP_FONT_NAMES))
                ResetNames(); 
            if (owner.IsSet(Style.PROP_FONT_SIZE))
                ResetFontSize();
            if (owner.IsSet(Style.PROP_FONT_BOLD))
                ResetBold(); 
            if (owner.IsSet(Style.PROP_FONT_ITALIC))
                ResetItalic(); 
            if (owner.IsSet(Style.PROP_FONT_UNDERLINE)) 
                ResetUnderline();
            if (owner.IsSet(Style.PROP_FONT_OVERLINE)) 
                ResetOverline();
            if (owner.IsSet(Style.PROP_FONT_STRIKEOUT))
                ResetStrikeout();
        } 

        ///  
        /// Only serialize if the Bold property has changed.  This means that we serialize "false" 
        /// if they were set to false in the designer.
        ///  
        private void ResetBold() {
            owner.ViewState.Remove("Font_Bold");
            owner.ClearBit(Style.PROP_FONT_BOLD);
        } 

        private void ResetNames() { 
            owner.ViewState.Remove("Font_Names"); 
            owner.ClearBit(Style.PROP_FONT_NAMES);
        } 

        private void ResetFontSize() {
            owner.ViewState.Remove("Font_Size");
            owner.ClearBit(Style.PROP_FONT_SIZE); 
        }
 
        ///  
        /// Only serialize if the Italic property has changed.  This means that we serialize "false"
        /// if they were set to false in the designer. 
        /// 
        private void ResetItalic() {
            owner.ViewState.Remove("Font_Italic");
            owner.ClearBit(Style.PROP_FONT_ITALIC); 
        }
 
        ///  
        /// Only serialize if the Overline property has changed.  This means that we serialize "false"
        /// if they were set to false in the designer. 
        /// 
        private void ResetOverline() {
            owner.ViewState.Remove("Font_Overline");
            owner.ClearBit(Style.PROP_FONT_OVERLINE); 
        }
 
        ///  
        /// Only serialize if the Strikeout property has changed.  This means that we serialize "false"
        /// if they were set to false in the designer. 
        /// 
        private void ResetStrikeout() {
            owner.ViewState.Remove("Font_Strikeout");
            owner.ClearBit(Style.PROP_FONT_STRIKEOUT); 
        }
 
        ///  
        /// Only serialize if the Underline property has changed.  This means that we serialize "false"
        /// if they were set to false in the designer. 
        /// 
        private void ResetUnderline() {
            owner.ViewState.Remove("Font_Underline");
            owner.ClearBit(Style.PROP_FONT_UNDERLINE); 
        }
 
        ///  
        /// Only serialize if the Bold property has changed.  This means that we serialize "false"
        /// if they were set to false in the designer. 
        /// 
        private bool ShouldSerializeBold() {
            return owner.IsSet(Style.PROP_FONT_BOLD);
        } 

        ///  
        /// Only serialize if the Italic property has changed.  This means that we serialize "false" 
        /// if they were set to false in the designer.
        ///  
        private bool ShouldSerializeItalic() {
            return owner.IsSet(Style.PROP_FONT_ITALIC);
        }
 
        /// 
        /// Only serialize if the Overline property has changed.  This means that we serialize "false" 
        /// if they were set to false in the designer. 
        /// 
        private bool ShouldSerializeOverline() { 
            return owner.IsSet(Style.PROP_FONT_OVERLINE);
        }

        ///  
        /// Only serialize if the Strikeout property has changed.  This means that we serialize "false"
        /// if they were set to false in the designer. 
        ///  
        private bool ShouldSerializeStrikeout() {
            return owner.IsSet(Style.PROP_FONT_STRIKEOUT); 
        }

        /// 
        /// Only serialize if the Underline property has changed.  This means that we serialize "false" 
        /// if they were set to false in the designer.
        ///  
        private bool ShouldSerializeUnderline() { 
            return owner.IsSet(Style.PROP_FONT_UNDERLINE);
        } 


        /// 
        public bool ShouldSerializeNames() { 
            string[] names = Names;
            return names.Length > 0; 
        } 

 
        /// 
        /// 
        public override string ToString() {
            string size = this.Size.ToString(CultureInfo.InvariantCulture); 
            string s = this.Name;
 
            if (size.Length != 0) { 
                if (s.Length != 0) {
                    s += ", " + size; 
                }
                else {
                    s = size;
                } 
            }
            return s; 
        } 
    }
} 


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