Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

385 lines
13 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="Unit.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
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 {
/// <devdoc>
/// Specifies an empty unit.
/// </devdoc>
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;
/// <devdoc>
/// <para>Initializes a new instance of the <see cref='System.Web.UI.WebControls.Unit'/> structure with the specified 32-bit signed integer as
/// the unit value and <see langword='Pixel'/> as the (default) unit type.</para>
/// </devdoc>
public Unit(int value) {
if ((value < MinValue) || (value > MaxValue)) {
throw new ArgumentOutOfRangeException("value");
}
this.value = value;
this.type = UnitType.Pixel;
}
/// <devdoc>
/// <para> Initializes a new instance of the <see cref='System.Web.UI.WebControls.Unit'/> structure with the
/// specified double-precision
/// floating point number as the unit value and <see langword='Pixel'/>
/// as the (default) unit type.</para>
/// </devdoc>
public Unit(double value) {
if ((value < MinValue) || (value > MaxValue)) {
throw new ArgumentOutOfRangeException("value");
}
this.value = (int)value;
this.type = UnitType.Pixel;
}
/// <devdoc>
/// <para>Initializes a new instance of the <see cref='System.Web.UI.WebControls.Unit'/> structure with the specified
/// double-precision floating point number as the unit value and the specified
/// <see cref='System.Web.UI.WebControls.UnitType'/> as the unit type.</para>
/// </devdoc>
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;
}
/// <devdoc>
/// <para>Initializes a new instance of the <see cref='System.Web.UI.WebControls.Unit'/> structure with the specified text
/// string that contains the unit value and unit type. If the unit type is not
/// specified, the default is <see langword='Pixel'/>
/// . </para>
/// </devdoc>
public Unit(string value) : this(value, CultureInfo.CurrentCulture, UnitType.Pixel) {
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
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");
}
}
}
/// <devdoc>
/// <para>Gets a value indicating whether the <see cref='System.Web.UI.WebControls.Unit'/> is empty.</para>
/// </devdoc>
public bool IsEmpty {
get {
return type == (UnitType)0;
}
}
/// <devdoc>
/// <para>Gets or sets the type of the <see cref='System.Web.UI.WebControls.Unit'/> .</para>
/// </devdoc>
public UnitType Type {
get {
if (!IsEmpty) {
return this.type;
}
else {
return UnitType.Pixel;
}
}
}
/// <devdoc>
/// <para>Gets the value of the <see cref='System.Web.UI.WebControls.Unit'/> .</para>
/// </devdoc>
public double Value {
get {
return this.value;
}
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public override int GetHashCode() {
return HashCodeCombiner.CombineHashCodes(type.GetHashCode(), value.GetHashCode());
}
/// <devdoc>
/// <para>Compares this <see cref='System.Web.UI.WebControls.Unit'/> with the specified object.</para>
/// </devdoc>
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;
}
/// <devdoc>
/// <para>Compares two units to find out if they have the same value and type.</para>
/// </devdoc>
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);
}
/// <devdoc>
/// <para>Compares two units to find out if they have different
/// values and/or types.</para>
/// </devdoc>
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);
}
/// <devdoc>
/// Converts UnitType to persistence string.
/// </devdoc>
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;
}
/// <devdoc>
/// Converts persistence string to UnitType.
/// </devdoc>
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;
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public static Unit Parse(string s) {
return new Unit(s, CultureInfo.CurrentCulture);
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public static Unit Parse(string s, CultureInfo culture) {
return new Unit(s, culture);
}
/// <devdoc>
/// <para>Creates a <see cref='System.Web.UI.WebControls.Unit'/> of type <see langword='Percentage'/> from the specified 32-bit signed integer.</para>
/// </devdoc>
public static Unit Percentage(double n) {
return new Unit(n,UnitType.Percentage);
}
/// <devdoc>
/// <para>Creates a <see cref='System.Web.UI.WebControls.Unit'/> of type <see langword='Pixel'/> from the specified 32-bit signed integer.</para>
/// </devdoc>
public static Unit Pixel(int n) {
return new Unit(n);
}
/// <devdoc>
/// <para>Creates a <see cref='System.Web.UI.WebControls.Unit'/> of type <see langword='Point'/> from the
/// specified 32-bit signed integer.</para>
/// </devdoc>
public static Unit Point(int n) {
return new Unit(n,UnitType.Point);
}
/// <internalonly/>
/// <devdoc>
/// <para>Converts a <see cref='System.Web.UI.WebControls.Unit'/> to a <see cref='System.String' qualify='true'/> .</para>
/// </devdoc>
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);
}
/// <devdoc>
/// <para>Implicitly creates a <see cref='System.Web.UI.WebControls.Unit'/> of type <see langword='Pixel'/> from the specified 32-bit unsigned integer.</para>
/// </devdoc>
public static implicit operator Unit(int n) {
return Unit.Pixel(n);
}
}
}