Unit.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 / Unit.cs / 1 / Unit.cs
                        

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

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

    [ 
        TypeConverterAttribute(typeof(UnitConverter)) 
    ]
    [Serializable] 
    public struct Unit {


        ///  
        ///   Specifies an empty unit.
        ///  
        public static readonly Unit Empty = new Unit(); 

        internal const int MaxValue = 32767; 
        internal const int MinValue = -32768;

        private readonly UnitType type;
        private readonly double value; 

 
        ///  
        /// Initializes a new instance of the  structure with the specified 32-bit signed integer as
        ///    the unit value and  as the (default) unit type. 
        /// 
        public Unit(int value) {
            if ((value < MinValue) || (value > MaxValue)) {
                throw new ArgumentOutOfRangeException("value"); 
            }
 
            this.value = value; 
            this.type = UnitType.Pixel;
        } 


        /// 
        ///  Initializes a new instance of the  structure with the 
        ///    specified double-precision
        ///    floating point number as the unit value and  
        ///    as the (default) unit type. 
        /// 
        public Unit(double value) { 
            if ((value < MinValue) || (value > MaxValue)) {
                throw new ArgumentOutOfRangeException("value");
            }
            this.value = (int)value; 
            this.type = UnitType.Pixel;
        } 
 

        ///  
        /// Initializes a new instance of the  structure with the specified
        ///    double-precision floating point number as the unit value and the specified
        ///  as the unit type.
        ///  
        public Unit(double value, UnitType type) {
            if ((value < MinValue) || (value > MaxValue)) { 
                throw new ArgumentOutOfRangeException("value"); 
            }
            if (type == UnitType.Pixel) { 
                this.value = (int)value;
            }
            else {
                this.value = value; 
            }
            this.type = type; 
        } 

 
        /// 
        /// Initializes a new instance of the  structure with the specified text
        ///    string that contains the unit value and unit type. If the unit type is not
        ///    specified, the default is  
        ///    . 
        ///  
        public Unit(string value) : this(value, CultureInfo.CurrentCulture, UnitType.Pixel) { 
        }
 

        /// 
        ///    [To be supplied.]
        ///  
        public Unit(string value, CultureInfo culture) : this(value, culture, UnitType.Pixel) {
        } 
 
        internal Unit(string value, CultureInfo culture, UnitType defaultType) {
            if (String.IsNullOrEmpty(value)) { 
                this.value = 0;
                this.type = (UnitType)0;
            }
            else { 
                if (culture == null) {
                    culture = CultureInfo.CurrentCulture; 
                } 

                // This is invariant because it acts like an enum with a number together. 
                // The enum part is invariant, but the number uses current culture.
                string trimLcase = value.Trim().ToLower(CultureInfo.InvariantCulture);
                int len = trimLcase.Length;
 
                int lastDigit = -1;
                for (int i = 0; i < len; i++) { 
                    char ch = trimLcase[i]; 
                    if (((ch < '0') || (ch > '9')) && (ch != '-') && (ch != '.') && (ch != ','))
                        break; 
                    lastDigit = i;
                }
                if (lastDigit == -1) {
                    throw new FormatException(SR.GetString(SR.UnitParseNoDigits, value)); 
                }
                if (lastDigit < len - 1) { 
                    type = (UnitType)GetTypeFromString(trimLcase.Substring(lastDigit+1).Trim()); 
                }
                else { 
                    type = defaultType;
                }

                string numericPart = trimLcase.Substring(0, lastDigit+1); 
                // Cannot use Double.FromString, because we don't use it in the ToString implementation
                try { 
                    TypeConverter converter = new SingleConverter(); 
                    this.value = (Single)converter.ConvertFromString(null, culture, numericPart);
 
                    if (type == UnitType.Pixel) {
                        this.value = (int)this.value;
                    }
                } 
                catch {
                    throw new FormatException(SR.GetString(SR.UnitParseNumericPart, value, numericPart, type.ToString("G"))); 
                } 
                if ((this.value < MinValue) || (this.value > MaxValue)) {
                    throw new ArgumentOutOfRangeException("value"); 
                }
            }
        }
 

        ///  
        /// Gets a value indicating whether the  is empty. 
        /// 
        public bool IsEmpty { 
            get {
                return type == (UnitType)0;
            }
        } 

 
        ///  
        /// Gets or sets the type of the  .
        ///  
        public UnitType Type {
            get {
                if (!IsEmpty) {
                    return this.type; 
                }
                else { 
                    return UnitType.Pixel; 
                }
            } 
        }


        ///  
        /// Gets the value of the  .
        ///  
        public double Value { 
            get {
                return this.value; 
            }
        }

 
        /// 
        ///    [To be supplied.] 
        ///  
        public override int GetHashCode() {
            return HashCodeCombiner.CombineHashCodes(type.GetHashCode(), value.GetHashCode()); 
        }


        ///  
        /// Compares this  with the specified object.
        ///  
        public override bool Equals(object obj) { 
            if (obj == null || !(obj is Unit)) {
                return false; 
            }
            Unit u = (Unit)obj;

            // compare internal values to avoid "defaulting" in the case of "Empty" 
            //
            if (u.type == type && u.value == value) { 
                return true; 
            }
 
            return false;
        }

 
        /// 
        ///    Compares two units to find out if they have the same value and type. 
        ///  
        public static bool operator ==(Unit left, Unit right) {
 
            // compare internal values to avoid "defaulting" in the case of "Empty"
            //
            return (left.type == right.type && left.value == right.value);
        } 

 
        ///  
        ///    Compares two units to find out if they have different
        ///       values and/or types. 
        /// 
        public static bool operator !=(Unit left, Unit right) {

            // compare internal values to avoid "defaulting" in the case of "Empty" 
            //
            return (left.type != right.type || left.value != right.value); 
        } 

 

        /// 
        ///  Converts UnitType to persistence string.
        ///  
        private static string GetStringFromType(UnitType type) {
            switch (type) { 
                case UnitType.Pixel: 
                    return "px";
                case UnitType.Point: 
                    return "pt";
                case UnitType.Pica:
                    return "pc";
                case UnitType.Inch: 
                    return "in";
                case UnitType.Mm: 
                    return "mm"; 
                case UnitType.Cm:
                    return "cm"; 
                case UnitType.Percentage:
                    return "%";
                case UnitType.Em:
                    return "em"; 
                case UnitType.Ex:
                    return "ex"; 
            } 
            return String.Empty;
        } 


        /// 
        ///  Converts persistence string to UnitType. 
        /// 
        private static UnitType GetTypeFromString(string value) { 
            if (!String.IsNullOrEmpty(value)) { 
                if (value.Equals("px")) {
                    return UnitType.Pixel; 
                }
                else if (value.Equals("pt")) {
                    return UnitType.Point;
                } 
                else if (value.Equals("%")) {
                    return UnitType.Percentage; 
                } 
                else if (value.Equals("pc")) {
                    return UnitType.Pica; 
                }
                else if (value.Equals("in")) {
                    return UnitType.Inch;
                } 
                else if (value.Equals("mm")) {
                    return UnitType.Mm; 
                } 
                else if (value.Equals("cm")) {
                    return UnitType.Cm; 
                }
                else if (value.Equals("em")) {
                    return UnitType.Em;
                } 
                else if (value.Equals("ex")) {
                    return UnitType.Ex; 
                } 
                else {
                    throw new ArgumentOutOfRangeException("value"); 
                }
            }
            return UnitType.Pixel;
        } 

 
        ///  
        ///    [To be supplied.]
        ///  
        public static Unit Parse(string s) {
            return new Unit(s, CultureInfo.CurrentCulture);
        }
 

        ///  
        ///    [To be supplied.] 
        /// 
        public static Unit Parse(string s, CultureInfo culture) { 
            return new Unit(s, culture);
        }

 
        /// 
        /// Creates a  of type  from the specified 32-bit signed integer. 
        ///  
        public static Unit Percentage(double n) {
            return new Unit(n,UnitType.Percentage); 
        }


        ///  
        /// Creates a  of type  from the specified 32-bit signed integer.
        ///  
        public static Unit Pixel(int n) { 
            return new Unit(n);
        } 


        /// 
        /// Creates a  of type  from the 
        ///    specified 32-bit signed integer.
        ///  
        public static Unit Point(int n) { 
            return new Unit(n,UnitType.Point);
        } 


        /// 
        ///  
        /// Converts a  to a  .
        ///  
        public override string ToString() { 
            return ToString((IFormatProvider)CultureInfo.CurrentCulture);
        } 


        public string ToString(CultureInfo culture) {
            return ToString((IFormatProvider)culture); 
        }
 
 
        public string ToString(IFormatProvider formatProvider) {
            if (IsEmpty) 
                return String.Empty;

            // Double.ToString does not do the right thing, we get extra bits at the end
            string valuePart; 
            if (type == UnitType.Pixel) {
                valuePart = ((int)value).ToString(formatProvider); 
            } 
            else {
                valuePart = ((float)value).ToString(formatProvider); 
            }

            return valuePart + Unit.GetStringFromType(type);
        } 

 
        ///  
        /// Implicitly creates a  of type  from the specified 32-bit unsigned integer.
        ///  
        public static implicit operator Unit(int n) {
            return Unit.Pixel(n);
        }
    } 
}

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