mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
385 lines
13 KiB
C#
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);
|
|
}
|
|
}
|
|
}
|