Uranium-and-Waffles/27Aug2021-Cpp2IL-Dump
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
27Aug2021-Cpp2IL-Dump/System/ComponentModel/MaskedTextProvider.cs
T
niko c12fbe3fc6 m
2026-04-12 16:51:38 +02:00

1543 lines
79 KiB
C#
Raw Permalink Blame History

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Globalization;
using System.Text;
using Cpp2IlInjected;
namespace System.ComponentModel
{
/// <summary>Represents a mask-parsing service that can be used by any number of controls that support masking, such as the <see cref="T:System.Windows.Forms.MaskedTextBox" /> control.</summary>
// Token: 0x02000163 RID: 355
[Token(Token = "0x2000163")]
public class MaskedTextProvider : ICloneable
{
/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.MaskedTextProvider" /> class using the specified mask.</summary>
/// <param name="mask">A <see cref="T:System.String" /> that represents the input mask.</param>
// Token: 0x06000891 RID: 2193 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000891")]
[Address(RVA = "0xC63AB0", Offset = "0xC62AB0", VA = "0x180C63AB0")]
public MaskedTextProvider(string mask)
{
}
/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.MaskedTextProvider" /> class using the specified mask and ASCII restriction value.</summary>
/// <param name="mask">A <see cref="T:System.String" /> that represents the input mask.</param>
/// <param name="restrictToAscii">
/// <see langword="true" /> to restrict input to ASCII-compatible characters; otherwise <see langword="false" /> to allow the entire Unicode set.</param>
// Token: 0x06000892 RID: 2194 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000892")]
[Address(RVA = "0xC639D0", Offset = "0xC629D0", VA = "0x180C639D0")]
public MaskedTextProvider(string mask, bool restrictToAscii)
{
}
/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.MaskedTextProvider" /> class using the specified mask and culture.</summary>
/// <param name="mask">A <see cref="T:System.String" /> that represents the input mask.</param>
/// <param name="culture">A <see cref="T:System.Globalization.CultureInfo" /> that is used to set region-sensitive separator characters.</param>
// Token: 0x06000893 RID: 2195 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000893")]
[Address(RVA = "0xC63A80", Offset = "0xC62A80", VA = "0x180C63A80")]
public MaskedTextProvider(string mask, CultureInfo culture)
{
}
/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.MaskedTextProvider" /> class using the specified mask, culture, and ASCII restriction value.</summary>
/// <param name="mask">A <see cref="T:System.String" /> that represents the input mask.</param>
/// <param name="culture">A <see cref="T:System.Globalization.CultureInfo" /> that is used to set region-sensitive separator characters.</param>
/// <param name="restrictToAscii">
/// <see langword="true" /> to restrict input to ASCII-compatible characters; otherwise <see langword="false" /> to allow the entire Unicode set.</param>
// Token: 0x06000894 RID: 2196 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000894")]
[Address(RVA = "0xC639A0", Offset = "0xC629A0", VA = "0x180C639A0")]
public MaskedTextProvider(string mask, CultureInfo culture, bool restrictToAscii)
{
}
/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.MaskedTextProvider" /> class using the specified mask, password character, and prompt usage value.</summary>
/// <param name="mask">A <see cref="T:System.String" /> that represents the input mask.</param>
/// <param name="passwordChar">A <see cref="T:System.Char" /> that will be displayed for characters entered into a password string.</param>
/// <param name="allowPromptAsInput">
/// <see langword="true" /> to allow the prompt character as input; otherwise <see langword="false" />.</param>
// Token: 0x06000895 RID: 2197 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000895")]
[Address(RVA = "0xC63A10", Offset = "0xC62A10", VA = "0x180C63A10")]
public MaskedTextProvider(string mask, char passwordChar, bool allowPromptAsInput)
{
}
/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.MaskedTextProvider" /> class using the specified mask, culture, password character, and prompt usage value.</summary>
/// <param name="mask">A <see cref="T:System.String" /> that represents the input mask.</param>
/// <param name="culture">A <see cref="T:System.Globalization.CultureInfo" /> that is used to set region-sensitive separator characters.</param>
/// <param name="passwordChar">A <see cref="T:System.Char" /> that will be displayed for characters entered into a password string.</param>
/// <param name="allowPromptAsInput">
/// <see langword="true" /> to allow the prompt character as input; otherwise <see langword="false" />.</param>
// Token: 0x06000896 RID: 2198 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000896")]
[Address(RVA = "0xC63A40", Offset = "0xC62A40", VA = "0x180C63A40")]
public MaskedTextProvider(string mask, CultureInfo culture, char passwordChar, bool allowPromptAsInput)
{
}
/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.MaskedTextProvider" /> class using the specified mask, culture, prompt usage value, prompt character, password character, and ASCII restriction value.</summary>
/// <param name="mask">A <see cref="T:System.String" /> that represents the input mask.</param>
/// <param name="culture">A <see cref="T:System.Globalization.CultureInfo" /> that is used to set region-sensitive separator characters.</param>
/// <param name="allowPromptAsInput">A <see cref="T:System.Boolean" /> value that specifies whether the prompt character should be allowed as a valid input character.</param>
/// <param name="promptChar">A <see cref="T:System.Char" /> that will be displayed as a placeholder for user input.</param>
/// <param name="passwordChar">A <see cref="T:System.Char" /> that will be displayed for characters entered into a password string.</param>
/// <param name="restrictToAscii">
/// <see langword="true" /> to restrict input to ASCII-compatible characters; otherwise <see langword="false" /> to allow the entire Unicode set.</param>
/// <exception cref="T:System.ArgumentException">The mask parameter is <see langword="null" /> or <see cref="F:System.String.Empty" />.
/// -or-
/// The mask contains one or more non-printable characters.</exception>
// Token: 0x06000897 RID: 2199 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000897")]
[Address(RVA = "0xC63AE0", Offset = "0xC62AE0", VA = "0x180C63AE0")]
public MaskedTextProvider(string mask, CultureInfo culture, bool allowPromptAsInput, char promptChar, char passwordChar, bool restrictToAscii)
{
}
// Token: 0x06000898 RID: 2200 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000898")]
[Address(RVA = "0xC5FB30", Offset = "0xC5EB30", VA = "0x180C5FB30")]
private void Initialize()
{
}
/// <summary>Gets a value indicating whether the prompt character should be treated as a valid input character or not.</summary>
/// <returns>
/// <see langword="true" /> if the user can enter <see cref="P:System.ComponentModel.MaskedTextProvider.PromptChar" /> into the control; otherwise, <see langword="false" />. The default is <see langword="true" />.</returns>
// Token: 0x170001A2 RID: 418
// (get) Token: 0x06000899 RID: 2201 RVA: 0x00005388 File Offset: 0x00003588
[Token(Token = "0x170001A2")]
public bool AllowPromptAsInput
{
[Token(Token = "0x6000899")]
[Address(RVA = "0xC63EE0", Offset = "0xC62EE0", VA = "0x180C63EE0")]
get
{
return default(bool);
}
}
/// <summary>Gets the number of editable character positions that have already been successfully assigned an input value.</summary>
/// <returns>An <see cref="T:System.Int32" /> containing the number of editable character positions in the input mask that have already been assigned a character value in the formatted string.</returns>
// Token: 0x170001A3 RID: 419
// (get) Token: 0x0600089A RID: 2202 RVA: 0x000053A0 File Offset: 0x000035A0
[Token(Token = "0x170001A3")]
public int AssignedEditPositionCount
{
[Token(Token = "0x600089A")]
[Address(RVA = "0x471180", Offset = "0x470180", VA = "0x180471180")]
get
{
return 0;
}
}
/// <summary>Gets the number of editable character positions in the input mask that have not yet been assigned an input value.</summary>
/// <returns>An <see cref="T:System.Int32" /> containing the number of editable character positions that not yet been assigned a character value.</returns>
// Token: 0x170001A4 RID: 420
// (get) Token: 0x0600089B RID: 2203 RVA: 0x000053B8 File Offset: 0x000035B8
[Token(Token = "0x170001A4")]
public int AvailableEditPositionCount
{
[Token(Token = "0x600089B")]
[Address(RVA = "0xC63FC0", Offset = "0xC62FC0", VA = "0x180C63FC0")]
get
{
return 0;
}
}
/// <summary>Creates a copy of the current <see cref="T:System.ComponentModel.MaskedTextProvider" />.</summary>
/// <returns>The <see cref="T:System.ComponentModel.MaskedTextProvider" /> object this method creates, cast as an object.</returns>
// Token: 0x0600089C RID: 2204 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x600089C")]
[Address(RVA = "0xC5E9E0", Offset = "0xC5D9E0", VA = "0x180C5E9E0", Slot = "4")]
public object Clone()
{
return null;
}
/// <summary>Gets the culture that determines the value of the localizable separators and placeholders in the input mask.</summary>
/// <returns>A <see cref="T:System.Globalization.CultureInfo" /> containing the culture information associated with the input mask.</returns>
// Token: 0x170001A5 RID: 421
// (get) Token: 0x0600089D RID: 2205 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x170001A5")]
public CultureInfo Culture
{
[Token(Token = "0x600089D")]
[Address(RVA = "0x4157B0", Offset = "0x4147B0", VA = "0x1804157B0")]
get
{
return null;
}
}
/// <summary>Gets the default password character used obscure user input.</summary>
/// <returns>A <see cref="T:System.Char" /> that represents the default password character.</returns>
// Token: 0x170001A6 RID: 422
// (get) Token: 0x0600089E RID: 2206 RVA: 0x000053D0 File Offset: 0x000035D0
[Token(Token = "0x170001A6")]
public static char DefaultPasswordChar
{
[Token(Token = "0x600089E")]
[Address(RVA = "0xC45B10", Offset = "0xC44B10", VA = "0x180C45B10")]
get
{
return '\0';
}
}
/// <summary>Gets the number of editable positions in the formatted string.</summary>
/// <returns>An <see cref="T:System.Int32" /> containing the number of editable positions in the formatted string.</returns>
// Token: 0x170001A7 RID: 423
// (get) Token: 0x0600089F RID: 2207 RVA: 0x000053E8 File Offset: 0x000035E8
[Token(Token = "0x170001A7")]
public int EditPositionCount
{
[Token(Token = "0x600089F")]
[Address(RVA = "0xC63FD0", Offset = "0xC62FD0", VA = "0x180C63FD0")]
get
{
return 0;
}
}
/// <summary>Gets a newly created enumerator for the editable positions in the formatted string.</summary>
/// <returns>An <see cref="T:System.Collections.IEnumerator" /> that supports enumeration over the editable positions in the formatted string.</returns>
// Token: 0x170001A8 RID: 424
// (get) Token: 0x060008A0 RID: 2208 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x170001A8")]
public IEnumerator EditPositions
{
[Token(Token = "0x60008A0")]
[Address(RVA = "0xC63FE0", Offset = "0xC62FE0", VA = "0x180C63FE0")]
get
{
return null;
}
}
/// <summary>Gets or sets a value that indicates whether literal characters in the input mask should be included in the formatted string.</summary>
/// <returns>
/// <see langword="true" /> if literals are included; otherwise, <see langword="false" />. The default is <see langword="true" />.</returns>
// Token: 0x170001A9 RID: 425
// (get) Token: 0x060008A1 RID: 2209 RVA: 0x00005400 File Offset: 0x00003600
// (set) Token: 0x060008A2 RID: 2210 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x170001A9")]
public bool IncludeLiterals
{
[Token(Token = "0x60008A1")]
[Address(RVA = "0xC64170", Offset = "0xC63170", VA = "0x180C64170")]
get
{
return default(bool);
}
[Token(Token = "0x60008A2")]
[Address(RVA = "0xC64540", Offset = "0xC63540", VA = "0x180C64540")]
set
{
}
}
/// <summary>Gets or sets a value indicating whether <see cref="P:System.Windows.Forms.MaskedTextBox.PromptChar" /> is used to represent the absence of user input when displaying the formatted string.</summary>
/// <returns>
/// <see langword="true" /> if the prompt character is used to represent the positions where no user input was provided; otherwise, <see langword="false" />. The default is <see langword="true" />.</returns>
// Token: 0x170001AA RID: 426
// (get) Token: 0x060008A3 RID: 2211 RVA: 0x00005418 File Offset: 0x00003618
// (set) Token: 0x060008A4 RID: 2212 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x170001AA")]
public bool IncludePrompt
{
[Token(Token = "0x60008A3")]
[Address(RVA = "0xC641E0", Offset = "0xC631E0", VA = "0x180C641E0")]
get
{
return default(bool);
}
[Token(Token = "0x60008A4")]
[Address(RVA = "0xC645C0", Offset = "0xC635C0", VA = "0x180C645C0")]
set
{
}
}
/// <summary>Gets a value indicating whether the mask accepts characters outside of the ASCII character set.</summary>
/// <returns>
/// <see langword="true" /> if only ASCII is accepted; <see langword="false" /> if <see cref="T:System.ComponentModel.MaskedTextProvider" /> can accept any arbitrary Unicode character. The default is <see langword="false" />.</returns>
// Token: 0x170001AB RID: 427
// (get) Token: 0x060008A5 RID: 2213 RVA: 0x00005430 File Offset: 0x00003630
[Token(Token = "0x170001AB")]
public bool AsciiOnly
{
[Token(Token = "0x60008A5")]
[Address(RVA = "0xC63F50", Offset = "0xC62F50", VA = "0x180C63F50")]
get
{
return default(bool);
}
}
/// <summary>Gets or sets a value that determines whether password protection should be applied to the formatted string.</summary>
/// <returns>
/// <see langword="true" /> if the input string is to be treated as a password string; otherwise, <see langword="false" />. The default is <see langword="false" />.</returns>
// Token: 0x170001AC RID: 428
// (get) Token: 0x060008A6 RID: 2214 RVA: 0x00005448 File Offset: 0x00003648
// (set) Token: 0x060008A7 RID: 2215 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x170001AC")]
public bool IsPassword
{
[Token(Token = "0x60008A6")]
[Address(RVA = "0xC64250", Offset = "0xC63250", VA = "0x180C64250")]
get
{
return default(bool);
}
[Token(Token = "0x60008A7")]
[Address(RVA = "0xC64640", Offset = "0xC63640", VA = "0x180C64640")]
set
{
}
}
/// <summary>Gets the upper bound of the range of invalid indexes.</summary>
/// <returns>A value representing the largest invalid index, as determined by the provider implementation. For example, if the lowest valid index is 0, this property will return -1.</returns>
// Token: 0x170001AD RID: 429
// (get) Token: 0x060008A8 RID: 2216 RVA: 0x00005460 File Offset: 0x00003660
[Token(Token = "0x170001AD")]
public static int InvalidIndex
{
[Token(Token = "0x60008A8")]
[Address(RVA = "0x716A60", Offset = "0x715A60", VA = "0x180716A60")]
get
{
return 0;
}
}
/// <summary>Gets the index in the mask of the rightmost input character that has been assigned to the mask.</summary>
/// <returns>If at least one input character has been assigned to the mask, an <see cref="T:System.Int32" /> containing the index of rightmost assigned position; otherwise, if no position has been assigned, <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
// Token: 0x170001AE RID: 430
// (get) Token: 0x060008A9 RID: 2217 RVA: 0x00005478 File Offset: 0x00003678
[Token(Token = "0x170001AE")]
public int LastAssignedPosition
{
[Token(Token = "0x60008A9")]
[Address(RVA = "0xC64340", Offset = "0xC63340", VA = "0x180C64340")]
get
{
return 0;
}
}
/// <summary>Gets the length of the mask, absent any mask modifier characters.</summary>
/// <returns>An <see cref="T:System.Int32" /> containing the number of positions in the mask, excluding characters that modify mask input.</returns>
// Token: 0x170001AF RID: 431
// (get) Token: 0x060008AA RID: 2218 RVA: 0x00005490 File Offset: 0x00003690
[Token(Token = "0x170001AF")]
public int Length
{
[Token(Token = "0x60008AA")]
[Address(RVA = "0xC64390", Offset = "0xC63390", VA = "0x180C64390")]
get
{
return 0;
}
}
/// <summary>Gets the input mask.</summary>
/// <returns>A <see cref="T:System.String" /> containing the full mask.</returns>
// Token: 0x170001B0 RID: 432
// (get) Token: 0x060008AB RID: 2219 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x170001B0")]
public string Mask
{
[Token(Token = "0x60008AB")]
[Address(RVA = "0x41CEF0", Offset = "0x41BEF0", VA = "0x18041CEF0")]
get
{
return null;
}
}
/// <summary>Gets a value indicating whether all required inputs have been entered into the formatted string.</summary>
/// <returns>
/// <see langword="true" /> if all required input has been entered into the mask; otherwise, <see langword="false" />.</returns>
// Token: 0x170001B1 RID: 433
// (get) Token: 0x060008AC RID: 2220 RVA: 0x000054A8 File Offset: 0x000036A8
[Token(Token = "0x170001B1")]
public bool MaskCompleted
{
[Token(Token = "0x60008AC")]
[Address(RVA = "0xC643B0", Offset = "0xC633B0", VA = "0x180C643B0")]
get
{
return default(bool);
}
}
/// <summary>Gets a value indicating whether all required and optional inputs have been entered into the formatted string.</summary>
/// <returns>
/// <see langword="true" /> if all required and optional inputs have been entered; otherwise, <see langword="false" />.</returns>
// Token: 0x170001B2 RID: 434
// (get) Token: 0x060008AD RID: 2221 RVA: 0x000054C0 File Offset: 0x000036C0
[Token(Token = "0x170001B2")]
public bool MaskFull
{
[Token(Token = "0x60008AD")]
[Address(RVA = "0xC643C0", Offset = "0xC633C0", VA = "0x180C643C0")]
get
{
return default(bool);
}
}
/// <summary>Gets or sets the character to be substituted for the actual input characters.</summary>
/// <returns>The <see cref="T:System.Char" /> value used as the password character.</returns>
/// <exception cref="T:System.InvalidOperationException">The password character specified when setting this property is the same as the current prompt character, <see cref="P:System.ComponentModel.MaskedTextProvider.PromptChar" />. The two are required to be different.</exception>
/// <exception cref="T:System.ArgumentException">The character specified when setting this property is not a valid password character, as determined by the <see cref="M:System.ComponentModel.MaskedTextProvider.IsValidPasswordChar(System.Char)" /> method.</exception>
// Token: 0x170001B3 RID: 435
// (get) Token: 0x060008AE RID: 2222 RVA: 0x000054D8 File Offset: 0x000036D8
// (set) Token: 0x060008AF RID: 2223 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x170001B3")]
public char PasswordChar
{
[Token(Token = "0x60008AE")]
[Address(RVA = "0xC643D0", Offset = "0xC633D0", VA = "0x180C643D0")]
get
{
return '\0';
}
[Token(Token = "0x60008AF")]
[Address(RVA = "0xC646C0", Offset = "0xC636C0", VA = "0x180C646C0")]
set
{
}
}
/// <summary>Gets or sets the character used to represent the absence of user input for all available edit positions.</summary>
/// <returns>The character used to prompt the user for input. The default is an underscore (_).</returns>
/// <exception cref="T:System.InvalidOperationException">The prompt character specified when setting this property is the same as the current password character, <see cref="P:System.ComponentModel.MaskedTextProvider.PasswordChar" />. The two are required to be different.</exception>
/// <exception cref="T:System.ArgumentException">The character specified when setting this property is not a valid password character, as determined by the <see cref="M:System.ComponentModel.MaskedTextProvider.IsValidPasswordChar(System.Char)" /> method.</exception>
// Token: 0x170001B4 RID: 436
// (get) Token: 0x060008B0 RID: 2224 RVA: 0x000054F0 File Offset: 0x000036F0
// (set) Token: 0x060008B1 RID: 2225 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x170001B4")]
public char PromptChar
{
[Token(Token = "0x60008B0")]
[Address(RVA = "0xC643E0", Offset = "0xC633E0", VA = "0x180C643E0")]
get
{
return '\0';
}
[Token(Token = "0x60008B1")]
[Address(RVA = "0xC64800", Offset = "0xC63800", VA = "0x180C64800")]
set
{
}
}
/// <summary>Gets or sets a value that determines how an input character that matches the prompt character should be handled.</summary>
/// <returns>
/// <see langword="true" /> if the prompt character entered as input causes the current editable position in the mask to be reset; otherwise, <see langword="false" /> to indicate that the prompt character is to be processed as a normal input character. The default is <see langword="true" />.</returns>
// Token: 0x170001B5 RID: 437
// (get) Token: 0x060008B2 RID: 2226 RVA: 0x00005508 File Offset: 0x00003708
// (set) Token: 0x060008B3 RID: 2227 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x170001B5")]
public bool ResetOnPrompt
{
[Token(Token = "0x60008B2")]
[Address(RVA = "0xC643F0", Offset = "0xC633F0", VA = "0x180C643F0")]
get
{
return default(bool);
}
[Token(Token = "0x60008B3")]
[Address(RVA = "0xC649A0", Offset = "0xC639A0", VA = "0x180C649A0")]
set
{
}
}
/// <summary>Gets or sets a value that determines how a space input character should be handled.</summary>
/// <returns>
/// <see langword="true" /> if the space input character causes the current editable position in the mask to be reset; otherwise, <see langword="false" /> to indicate that it is to be processed as a normal input character. The default is <see langword="true" />.</returns>
// Token: 0x170001B6 RID: 438
// (get) Token: 0x060008B4 RID: 2228 RVA: 0x00005520 File Offset: 0x00003720
// (set) Token: 0x060008B5 RID: 2229 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x170001B6")]
public bool ResetOnSpace
{
[Token(Token = "0x60008B4")]
[Address(RVA = "0xC64460", Offset = "0xC63460", VA = "0x180C64460")]
get
{
return default(bool);
}
[Token(Token = "0x60008B5")]
[Address(RVA = "0xC64A20", Offset = "0xC63A20", VA = "0x180C64A20")]
set
{
}
}
/// <summary>Gets or sets a value indicating whether literal character positions in the mask can be overwritten by their same values.</summary>
/// <returns>
/// <see langword="true" /> to allow literals to be added back; otherwise, <see langword="false" /> to not allow the user to overwrite literal characters. The default is <see langword="true" />.</returns>
// Token: 0x170001B7 RID: 439
// (get) Token: 0x060008B6 RID: 2230 RVA: 0x00005538 File Offset: 0x00003738
// (set) Token: 0x060008B7 RID: 2231 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x170001B7")]
public bool SkipLiterals
{
[Token(Token = "0x60008B6")]
[Address(RVA = "0xC644D0", Offset = "0xC634D0", VA = "0x180C644D0")]
get
{
return default(bool);
}
[Token(Token = "0x60008B7")]
[Address(RVA = "0xC64AA0", Offset = "0xC63AA0", VA = "0x180C64AA0")]
set
{
}
}
/// <summary>Gets the element at the specified position in the formatted string.</summary>
/// <param name="index">A zero-based index of the element to retrieve.</param>
/// <returns>The <see cref="T:System.Char" /> at the specified position in the formatted string.</returns>
/// <exception cref="T:System.IndexOutOfRangeException">
/// <paramref name="index" /> is less than zero or greater than or equal to the <see cref="P:System.ComponentModel.MaskedTextProvider.Length" /> of the mask.</exception>
// Token: 0x170001B8 RID: 440
[Token(Token = "0x170001B8")]
public char this[int index]
{
[Token(Token = "0x60008B8")]
[Address(RVA = "0xC64260", Offset = "0xC63260", VA = "0x180C64260")]
get
{
return '\0';
}
}
/// <summary>Adds the specified input character to the end of the formatted string.</summary>
/// <param name="input">A <see cref="T:System.Char" /> value to be appended to the formatted string.</param>
/// <returns>
/// <see langword="true" /> if the input character was added successfully; otherwise <see langword="false" />.</returns>
// Token: 0x060008B9 RID: 2233 RVA: 0x00005568 File Offset: 0x00003768
[Token(Token = "0x60008B9")]
[Address(RVA = "0xC5E670", Offset = "0xC5D670", VA = "0x180C5E670")]
public bool Add(char input)
{
return default(bool);
}
/// <summary>Adds the specified input character to the end of the formatted string, and then outputs position and descriptive information.</summary>
/// <param name="input">A <see cref="T:System.Char" /> value to be appended to the formatted string.</param>
/// <param name="testPosition">The zero-based position in the formatted string where the attempt was made to add the character. An output parameter.</param>
/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the operation. An output parameter.</param>
/// <returns>
/// <see langword="true" /> if the input character was added successfully; otherwise <see langword="false" />.</returns>
// Token: 0x060008BA RID: 2234 RVA: 0x00005580 File Offset: 0x00003780
[Token(Token = "0x60008BA")]
[Address(RVA = "0xC5E770", Offset = "0xC5D770", VA = "0x180C5E770")]
public bool Add(char input, out int testPosition, out MaskedTextResultHint resultHint)
{
return default(bool);
}
/// <summary>Adds the characters in the specified input string to the end of the formatted string.</summary>
/// <param name="input">A <see cref="T:System.String" /> containing character values to be appended to the formatted string.</param>
/// <returns>
/// <see langword="true" /> if all the characters from the input string were added successfully; otherwise <see langword="false" /> to indicate that no characters were added.</returns>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="input" /> parameter is <see langword="null" />.</exception>
// Token: 0x060008BB RID: 2235 RVA: 0x00005598 File Offset: 0x00003798
[Token(Token = "0x60008BB")]
[Address(RVA = "0xC5E420", Offset = "0xC5D420", VA = "0x180C5E420")]
public bool Add(string input)
{
return default(bool);
}
/// <summary>Adds the characters in the specified input string to the end of the formatted string, and then outputs position and descriptive information.</summary>
/// <param name="input">A <see cref="T:System.String" /> containing character values to be appended to the formatted string.</param>
/// <param name="testPosition">The zero-based position in the formatted string where the attempt was made to add the character. An output parameter.</param>
/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the operation. An output parameter.</param>
/// <returns>
/// <see langword="true" /> if all the characters from the input string were added successfully; otherwise <see langword="false" /> to indicate that no characters were added.</returns>
// Token: 0x060008BC RID: 2236 RVA: 0x000055B0 File Offset: 0x000037B0
[Token(Token = "0x60008BC")]
[Address(RVA = "0xC5E540", Offset = "0xC5D540", VA = "0x180C5E540")]
public bool Add(string input, out int testPosition, out MaskedTextResultHint resultHint)
{
return default(bool);
}
/// <summary>Clears all the editable input characters from the formatted string, replacing them with prompt characters.</summary>
// Token: 0x060008BD RID: 2237 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x60008BD")]
[Address(RVA = "0xC5E8B0", Offset = "0xC5D8B0", VA = "0x180C5E8B0")]
public void Clear()
{
}
/// <summary>Clears all the editable input characters from the formatted string, replacing them with prompt characters, and then outputs descriptive information.</summary>
/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the operation. An output parameter.</param>
// Token: 0x060008BE RID: 2238 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x60008BE")]
[Address(RVA = "0xC5E8D0", Offset = "0xC5D8D0", VA = "0x180C5E8D0")]
public void Clear(out MaskedTextResultHint resultHint)
{
}
/// <summary>Returns the position of the first assigned editable position after the specified position using the specified search direction.</summary>
/// <param name="position">The zero-based position in the formatted string to start the search.</param>
/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first assigned editable position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
// Token: 0x060008BF RID: 2239 RVA: 0x000055C8 File Offset: 0x000037C8
[Token(Token = "0x60008BF")]
[Address(RVA = "0xC5F3F0", Offset = "0xC5E3F0", VA = "0x180C5F3F0")]
public int FindAssignedEditPositionFrom(int position, bool direction)
{
return 0;
}
/// <summary>Returns the position of the first assigned editable position between the specified positions using the specified search direction.</summary>
/// <param name="startPosition">The zero-based position in the formatted string where the search starts.</param>
/// <param name="endPosition">The zero-based position in the formatted string where the search ends.</param>
/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first assigned editable position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
// Token: 0x060008C0 RID: 2240 RVA: 0x000055E0 File Offset: 0x000037E0
[Token(Token = "0x60008C0")]
[Address(RVA = "0xC5F470", Offset = "0xC5E470", VA = "0x180C5F470")]
public int FindAssignedEditPositionInRange(int startPosition, int endPosition, bool direction)
{
return 0;
}
/// <summary>Returns the position of the first editable position after the specified position using the specified search direction.</summary>
/// <param name="position">The zero-based position in the formatted string to start the search.</param>
/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first editable position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
// Token: 0x060008C1 RID: 2241 RVA: 0x000055F8 File Offset: 0x000037F8
[Token(Token = "0x60008C1")]
[Address(RVA = "0xC5F590", Offset = "0xC5E590", VA = "0x180C5F590")]
public int FindEditPositionFrom(int position, bool direction)
{
return 0;
}
/// <summary>Returns the position of the first editable position between the specified positions using the specified search direction.</summary>
/// <param name="startPosition">The zero-based position in the formatted string where the search starts.</param>
/// <param name="endPosition">The zero-based position in the formatted string where the search ends.</param>
/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first editable position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
// Token: 0x060008C2 RID: 2242 RVA: 0x00005610 File Offset: 0x00003810
[Token(Token = "0x60008C2")]
[Address(RVA = "0xC5F730", Offset = "0xC5E730", VA = "0x180C5F730")]
public int FindEditPositionInRange(int startPosition, int endPosition, bool direction)
{
return 0;
}
// Token: 0x060008C3 RID: 2243 RVA: 0x00005628 File Offset: 0x00003828
[Token(Token = "0x60008C3")]
[Address(RVA = "0xC5F600", Offset = "0xC5E600", VA = "0x180C5F600")]
private int FindEditPositionInRange(int startPosition, int endPosition, bool direction, byte assignedStatus)
{
return 0;
}
/// <summary>Returns the position of the first non-editable position after the specified position using the specified search direction.</summary>
/// <param name="position">The zero-based position in the formatted string to start the search.</param>
/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first literal position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
// Token: 0x060008C4 RID: 2244 RVA: 0x00005640 File Offset: 0x00003840
[Token(Token = "0x60008C4")]
[Address(RVA = "0xC5F750", Offset = "0xC5E750", VA = "0x180C5F750")]
public int FindNonEditPositionFrom(int position, bool direction)
{
return 0;
}
/// <summary>Returns the position of the first non-editable position between the specified positions using the specified search direction.</summary>
/// <param name="startPosition">The zero-based position in the formatted string where the search starts.</param>
/// <param name="endPosition">The zero-based position in the formatted string where the search ends.</param>
/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first literal position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
// Token: 0x060008C5 RID: 2245 RVA: 0x00005658 File Offset: 0x00003858
[Token(Token = "0x60008C5")]
[Address(RVA = "0xC5F7C0", Offset = "0xC5E7C0", VA = "0x180C5F7C0")]
public int FindNonEditPositionInRange(int startPosition, int endPosition, bool direction)
{
return 0;
}
// Token: 0x060008C6 RID: 2246 RVA: 0x00005670 File Offset: 0x00003870
[Token(Token = "0x60008C6")]
[Address(RVA = "0xC5F7E0", Offset = "0xC5E7E0", VA = "0x180C5F7E0")]
private int FindPositionInRange(int startPosition, int endPosition, bool direction, MaskedTextProvider.CharType charTypeFlags)
{
return 0;
}
/// <summary>Returns the position of the first unassigned editable position after the specified position using the specified search direction.</summary>
/// <param name="position">The zero-based position in the formatted string to start the search.</param>
/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first unassigned editable position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
// Token: 0x060008C7 RID: 2247 RVA: 0x00005688 File Offset: 0x00003888
[Token(Token = "0x60008C7")]
[Address(RVA = "0xC5F8D0", Offset = "0xC5E8D0", VA = "0x180C5F8D0")]
public int FindUnassignedEditPositionFrom(int position, bool direction)
{
return 0;
}
/// <summary>Returns the position of the first unassigned editable position between the specified positions using the specified search direction.</summary>
/// <param name="startPosition">The zero-based position in the formatted string where the search starts.</param>
/// <param name="endPosition">The zero-based position in the formatted string where the search ends.</param>
/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first unassigned editable position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
// Token: 0x060008C8 RID: 2248 RVA: 0x000056A0 File Offset: 0x000038A0
[Token(Token = "0x60008C8")]
[Address(RVA = "0xC5FA00", Offset = "0xC5EA00", VA = "0x180C5FA00")]
public int FindUnassignedEditPositionInRange(int startPosition, int endPosition, bool direction)
{
return 0;
}
/// <summary>Determines whether the specified <see cref="T:System.ComponentModel.MaskedTextResultHint" /> denotes success or failure.</summary>
/// <param name="hint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> value typically obtained as an output parameter from a previous operation.</param>
/// <returns>
/// <see langword="true" /> if the specified <see cref="T:System.ComponentModel.MaskedTextResultHint" /> value represents a success; otherwise, <see langword="false" /> if it represents failure.</returns>
// Token: 0x060008C9 RID: 2249 RVA: 0x000056B8 File Offset: 0x000038B8
[Token(Token = "0x60008C9")]
[Address(RVA = "0xC5FB20", Offset = "0xC5EB20", VA = "0x180C5FB20")]
public static bool GetOperationResultFromHint(MaskedTextResultHint hint)
{
return default(bool);
}
/// <summary>Inserts the specified character at the specified position within the formatted string.</summary>
/// <param name="input">The <see cref="T:System.Char" /> to be inserted.</param>
/// <param name="position">The zero-based position in the formatted string to insert the character.</param>
/// <returns>
/// <see langword="true" /> if the insertion was successful; otherwise, <see langword="false" />.</returns>
// Token: 0x060008CA RID: 2250 RVA: 0x000056D0 File Offset: 0x000038D0
[Token(Token = "0x60008CA")]
[Address(RVA = "0xC60590", Offset = "0xC5F590", VA = "0x180C60590")]
public bool InsertAt(char input, int position)
{
return default(bool);
}
/// <summary>Inserts the specified character at the specified position within the formatted string, returning the last insertion position and the status of the operation.</summary>
/// <param name="input">The <see cref="T:System.Char" /> to be inserted.</param>
/// <param name="position">The zero-based position in the formatted string to insert the character.</param>
/// <param name="testPosition">If the method is successful, the last position where a character was inserted; otherwise, the first position where the insertion failed. An output parameter.</param>
/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the insertion operation. An output parameter.</param>
/// <returns>
/// <see langword="true" /> if the insertion was successful; otherwise, <see langword="false" />.</returns>
// Token: 0x060008CB RID: 2251 RVA: 0x000056E8 File Offset: 0x000038E8
[Token(Token = "0x60008CB")]
[Address(RVA = "0xC60530", Offset = "0xC5F530", VA = "0x180C60530")]
public bool InsertAt(char input, int position, out int testPosition, out MaskedTextResultHint resultHint)
{
return default(bool);
}
/// <summary>Inserts the specified string at a specified position within the formatted string.</summary>
/// <param name="input">The <see cref="T:System.String" /> to be inserted.</param>
/// <param name="position">The zero-based position in the formatted string to insert the input string.</param>
/// <returns>
/// <see langword="true" /> if the insertion was successful; otherwise, <see langword="false" />.</returns>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="input" /> parameter is <see langword="null" />.</exception>
// Token: 0x060008CC RID: 2252 RVA: 0x00005700 File Offset: 0x00003900
[Token(Token = "0x60008CC")]
[Address(RVA = "0xC60440", Offset = "0xC5F440", VA = "0x180C60440")]
public bool InsertAt(string input, int position)
{
return default(bool);
}
/// <summary>Inserts the specified string at a specified position within the formatted string, returning the last insertion position and the status of the operation.</summary>
/// <param name="input">The <see cref="T:System.String" /> to be inserted.</param>
/// <param name="position">The zero-based position in the formatted string to insert the input string.</param>
/// <param name="testPosition">If the method is successful, the last position where a character was inserted; otherwise, the first position where the insertion failed. An output parameter.</param>
/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the insertion operation. An output parameter.</param>
/// <returns>
/// <see langword="true" /> if the insertion was successful; otherwise, <see langword="false" />.</returns>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="input" /> parameter is <see langword="null" />.</exception>
// Token: 0x060008CD RID: 2253 RVA: 0x00005718 File Offset: 0x00003918
[Token(Token = "0x60008CD")]
[Address(RVA = "0xC60350", Offset = "0xC5F350", VA = "0x180C60350")]
public bool InsertAt(string input, int position, out int testPosition, out MaskedTextResultHint resultHint)
{
return default(bool);
}
// Token: 0x060008CE RID: 2254 RVA: 0x00005730 File Offset: 0x00003930
[Token(Token = "0x60008CE")]
[Address(RVA = "0xC5FF50", Offset = "0xC5EF50", VA = "0x180C5FF50")]
private bool InsertAtInt(string input, int position, out int testPosition, out MaskedTextResultHint resultHint, bool testOnly)
{
return default(bool);
}
// Token: 0x060008CF RID: 2255 RVA: 0x00005748 File Offset: 0x00003948
[Token(Token = "0x60008CF")]
[Address(RVA = "0xC60790", Offset = "0xC5F790", VA = "0x180C60790")]
private static bool IsAscii(char c)
{
return default(bool);
}
// Token: 0x060008D0 RID: 2256 RVA: 0x00005760 File Offset: 0x00003960
[Token(Token = "0x60008D0")]
[Address(RVA = "0xC606B0", Offset = "0xC5F6B0", VA = "0x180C606B0")]
private static bool IsAciiAlphanumeric(char c)
{
return default(bool);
}
// Token: 0x060008D1 RID: 2257 RVA: 0x00005778 File Offset: 0x00003978
[Token(Token = "0x60008D1")]
[Address(RVA = "0xC606E0", Offset = "0xC5F6E0", VA = "0x180C606E0")]
private static bool IsAlphanumeric(char c)
{
return default(bool);
}
// Token: 0x060008D2 RID: 2258 RVA: 0x00005790 File Offset: 0x00003990
[Token(Token = "0x60008D2")]
[Address(RVA = "0xC60770", Offset = "0xC5F770", VA = "0x180C60770")]
private static bool IsAsciiLetter(char c)
{
return default(bool);
}
/// <summary>Determines whether the specified position is available for assignment.</summary>
/// <param name="position">The zero-based position in the mask to test.</param>
/// <returns>
/// <see langword="true" /> if the specified position in the formatted string is editable and has not been assigned to yet; otherwise <see langword="false" />.</returns>
// Token: 0x060008D3 RID: 2259 RVA: 0x000057A8 File Offset: 0x000039A8
[Token(Token = "0x60008D3")]
[Address(RVA = "0xC607B0", Offset = "0xC5F7B0", VA = "0x180C607B0")]
public bool IsAvailablePosition(int position)
{
return default(bool);
}
/// <summary>Determines whether the specified position is editable.</summary>
/// <param name="position">The zero-based position in the mask to test.</param>
/// <returns>
/// <see langword="true" /> if the specified position in the formatted string is editable; otherwise <see langword="false" />.</returns>
// Token: 0x060008D4 RID: 2260 RVA: 0x000057C0 File Offset: 0x000039C0
[Token(Token = "0x60008D4")]
[Address(RVA = "0xC608A0", Offset = "0xC5F8A0", VA = "0x180C608A0")]
public bool IsEditPosition(int position)
{
return default(bool);
}
// Token: 0x060008D5 RID: 2261 RVA: 0x000057D8 File Offset: 0x000039D8
[Token(Token = "0x60008D5")]
[Address(RVA = "0xC60870", Offset = "0xC5F870", VA = "0x180C60870")]
private static bool IsEditPosition(MaskedTextProvider.CharDescriptor charDescriptor)
{
return default(bool);
}
// Token: 0x060008D6 RID: 2262 RVA: 0x000057F0 File Offset: 0x000039F0
[Token(Token = "0x60008D6")]
[Address(RVA = "0xC60960", Offset = "0xC5F960", VA = "0x180C60960")]
private static bool IsLiteralPosition(MaskedTextProvider.CharDescriptor charDescriptor)
{
return default(bool);
}
// Token: 0x060008D7 RID: 2263 RVA: 0x00005808 File Offset: 0x00003A08
[Token(Token = "0x60008D7")]
[Address(RVA = "0xC60990", Offset = "0xC5F990", VA = "0x180C60990")]
private static bool IsPrintableChar(char c)
{
return default(bool);
}
/// <summary>Determines whether the specified character is a valid input character.</summary>
/// <param name="c">The <see cref="T:System.Char" /> value to test.</param>
/// <returns>
/// <see langword="true" /> if the specified character contains a valid input value; otherwise <see langword="false" />.</returns>
// Token: 0x060008D8 RID: 2264 RVA: 0x00005820 File Offset: 0x00003A20
[Token(Token = "0x60008D8")]
[Address(RVA = "0xC60A50", Offset = "0xC5FA50", VA = "0x180C60A50")]
public static bool IsValidInputChar(char c)
{
return default(bool);
}
/// <summary>Determines whether the specified character is a valid mask character.</summary>
/// <param name="c">The <see cref="T:System.Char" /> value to test.</param>
/// <returns>
/// <see langword="true" /> if the specified character contains a valid mask value; otherwise <see langword="false" />.</returns>
// Token: 0x060008D9 RID: 2265 RVA: 0x00005838 File Offset: 0x00003A38
[Token(Token = "0x60008D9")]
[Address(RVA = "0xC60AB0", Offset = "0xC5FAB0", VA = "0x180C60AB0")]
public static bool IsValidMaskChar(char c)
{
return default(bool);
}
/// <summary>Determines whether the specified character is a valid password character.</summary>
/// <param name="c">The <see cref="T:System.Char" /> value to test.</param>
/// <returns>
/// <see langword="true" /> if the specified character contains a valid password value; otherwise <see langword="false" />.</returns>
// Token: 0x060008DA RID: 2266 RVA: 0x00005850 File Offset: 0x00003A50
[Token(Token = "0x60008DA")]
[Address(RVA = "0xC60B10", Offset = "0xC5FB10", VA = "0x180C60B10")]
public static bool IsValidPasswordChar(char c)
{
return default(bool);
}
/// <summary>Removes the last assigned character from the formatted string.</summary>
/// <returns>
/// <see langword="true" /> if the character was successfully removed; otherwise, <see langword="false" />.</returns>
// Token: 0x060008DB RID: 2267 RVA: 0x00005868 File Offset: 0x00003A68
[Token(Token = "0x60008DB")]
[Address(RVA = "0xC611B0", Offset = "0xC601B0", VA = "0x180C611B0")]
public bool Remove()
{
return default(bool);
}
/// <summary>Removes the last assigned character from the formatted string, and then outputs the removal position and descriptive information.</summary>
/// <param name="testPosition">The zero-based position in the formatted string where the character was actually removed. An output parameter.</param>
/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the operation. An output parameter.</param>
/// <returns>
/// <see langword="true" /> if the character was successfully removed; otherwise, <see langword="false" />.</returns>
// Token: 0x060008DC RID: 2268 RVA: 0x00005880 File Offset: 0x00003A80
[Token(Token = "0x60008DC")]
[Address(RVA = "0xC61110", Offset = "0xC60110", VA = "0x180C61110")]
public bool Remove(out int testPosition, out MaskedTextResultHint resultHint)
{
return default(bool);
}
/// <summary>Removes the assigned character at the specified position from the formatted string.</summary>
/// <param name="position">The zero-based position of the assigned character to remove.</param>
/// <returns>
/// <see langword="true" /> if the character was successfully removed; otherwise, <see langword="false" />.</returns>
// Token: 0x060008DD RID: 2269 RVA: 0x00005898 File Offset: 0x00003A98
[Token(Token = "0x60008DD")]
[Address(RVA = "0xC61090", Offset = "0xC60090", VA = "0x180C61090")]
public bool RemoveAt(int position)
{
return default(bool);
}
/// <summary>Removes the assigned characters between the specified positions from the formatted string.</summary>
/// <param name="startPosition">The zero-based index of the first assigned character to remove.</param>
/// <param name="endPosition">The zero-based index of the last assigned character to remove.</param>
/// <returns>
/// <see langword="true" /> if the character was successfully removed; otherwise, <see langword="false" />.</returns>
// Token: 0x060008DE RID: 2270 RVA: 0x000058B0 File Offset: 0x00003AB0
[Token(Token = "0x60008DE")]
[Address(RVA = "0xC60F50", Offset = "0xC5FF50", VA = "0x180C60F50")]
public bool RemoveAt(int startPosition, int endPosition)
{
return default(bool);
}
/// <summary>Removes the assigned characters between the specified positions from the formatted string, and then outputs the removal position and descriptive information.</summary>
/// <param name="startPosition">The zero-based index of the first assigned character to remove.</param>
/// <param name="endPosition">The zero-based index of the last assigned character to remove.</param>
/// <param name="testPosition">If successful, the zero-based position in the formatted string of where the characters were actually removed; otherwise, the first position where the operation failed. An output parameter.</param>
/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the operation. An output parameter.</param>
/// <returns>
/// <see langword="true" /> if the character was successfully removed; otherwise, <see langword="false" />.</returns>
// Token: 0x060008DF RID: 2271 RVA: 0x000058C8 File Offset: 0x00003AC8
[Token(Token = "0x60008DF")]
[Address(RVA = "0xC60FF0", Offset = "0xC5FFF0", VA = "0x180C60FF0")]
public bool RemoveAt(int startPosition, int endPosition, out int testPosition, out MaskedTextResultHint resultHint)
{
return default(bool);
}
// Token: 0x060008E0 RID: 2272 RVA: 0x000058E0 File Offset: 0x00003AE0
[Token(Token = "0x60008E0")]
[Address(RVA = "0xC60B80", Offset = "0xC5FB80", VA = "0x180C60B80")]
private bool RemoveAtInt(int startPosition, int endPosition, out int testPosition, out MaskedTextResultHint resultHint, bool testOnly)
{
return default(bool);
}
/// <summary>Replaces a single character at or beyond the specified position with the specified character value.</summary>
/// <param name="input">The <see cref="T:System.Char" /> value that replaces the existing value.</param>
/// <param name="position">The zero-based position to search for the first editable character to replace.</param>
/// <returns>
/// <see langword="true" /> if the character was successfully replaced; otherwise, <see langword="false" />.</returns>
// Token: 0x060008E1 RID: 2273 RVA: 0x000058F8 File Offset: 0x00003AF8
[Token(Token = "0x60008E1")]
[Address(RVA = "0xC61320", Offset = "0xC60320", VA = "0x180C61320")]
public bool Replace(char input, int position)
{
return default(bool);
}
/// <summary>Replaces a single character at or beyond the specified position with the specified character value, and then outputs the removal position and descriptive information.</summary>
/// <param name="input">The <see cref="T:System.Char" /> value that replaces the existing value.</param>
/// <param name="position">The zero-based position to search for the first editable character to replace.</param>
/// <param name="testPosition">If successful, the zero-based position in the formatted string where the last character was actually replaced; otherwise, the first position where the operation failed. An output parameter.</param>
/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the replacement operation. An output parameter.</param>
/// <returns>
/// <see langword="true" /> if the character was successfully replaced; otherwise, <see langword="false" />.</returns>
// Token: 0x060008E2 RID: 2274 RVA: 0x00005910 File Offset: 0x00003B10
[Token(Token = "0x60008E2")]
[Address(RVA = "0xC61210", Offset = "0xC60210", VA = "0x180C61210")]
public bool Replace(char input, int position, out int testPosition, out MaskedTextResultHint resultHint)
{
return default(bool);
}
/// <summary>Replaces a single character between the specified starting and ending positions with the specified character value, and then outputs the removal position and descriptive information.</summary>
/// <param name="input">The <see cref="T:System.Char" /> value that replaces the existing value.</param>
/// <param name="startPosition">The zero-based position in the formatted string where the replacement starts.</param>
/// <param name="endPosition">The zero-based position in the formatted string where the replacement ends.</param>
/// <param name="testPosition">If successful, the zero-based position in the formatted string where the last character was actually replaced; otherwise, the first position where the operation failed. An output parameter.</param>
/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the replacement operation. An output parameter.</param>
/// <returns>
/// <see langword="true" /> if the character was successfully replaced; otherwise, <see langword="false" />.</returns>
// Token: 0x060008E3 RID: 2275 RVA: 0x00005928 File Offset: 0x00003B28
[Token(Token = "0x60008E3")]
[Address(RVA = "0xC619A0", Offset = "0xC609A0", VA = "0x180C619A0")]
public bool Replace(char input, int startPosition, int endPosition, out int testPosition, out MaskedTextResultHint resultHint)
{
return default(bool);
}
/// <summary>Replaces a range of editable characters starting at the specified position with the specified string.</summary>
/// <param name="input">The <see cref="T:System.String" /> value used to replace the existing editable characters.</param>
/// <param name="position">The zero-based position to search for the first editable character to replace.</param>
/// <returns>
/// <see langword="true" /> if all the characters were successfully replaced; otherwise, <see langword="false" />.</returns>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="input" /> parameter is <see langword="null" />.</exception>
// Token: 0x060008E4 RID: 2276 RVA: 0x00005940 File Offset: 0x00003B40
[Token(Token = "0x60008E4")]
[Address(RVA = "0xC618B0", Offset = "0xC608B0", VA = "0x180C618B0")]
public bool Replace(string input, int position)
{
return default(bool);
}
/// <summary>Replaces a range of editable characters starting at the specified position with the specified string, and then outputs the removal position and descriptive information.</summary>
/// <param name="input">The <see cref="T:System.String" /> value used to replace the existing editable characters.</param>
/// <param name="position">The zero-based position to search for the first editable character to replace.</param>
/// <param name="testPosition">If successful, the zero-based position in the formatted string where the last character was actually replaced; otherwise, the first position where the operation failed. An output parameter.</param>
/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the replacement operation. An output parameter.</param>
/// <returns>
/// <see langword="true" /> if all the characters were successfully replaced; otherwise, <see langword="false" />.</returns>
// Token: 0x060008E5 RID: 2277 RVA: 0x00005958 File Offset: 0x00003B58
[Token(Token = "0x60008E5")]
[Address(RVA = "0xC617B0", Offset = "0xC607B0", VA = "0x180C617B0")]
public bool Replace(string input, int position, out int testPosition, out MaskedTextResultHint resultHint)
{
return default(bool);
}
/// <summary>Replaces a range of editable characters between the specified starting and ending positions with the specified string, and then outputs the removal position and descriptive information.</summary>
/// <param name="input">The <see cref="T:System.String" /> value used to replace the existing editable characters.</param>
/// <param name="startPosition">The zero-based position in the formatted string where the replacement starts.</param>
/// <param name="endPosition">The zero-based position in the formatted string where the replacement ends.</param>
/// <param name="testPosition">If successful, the zero-based position in the formatted string where the last character was actually replaced; otherwise, the first position where the operation failed. An output parameter.</param>
/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the replacement operation. An output parameter.</param>
/// <returns>
/// <see langword="true" /> if all the characters were successfully replaced; otherwise, <see langword="false" />.</returns>
// Token: 0x060008E6 RID: 2278 RVA: 0x00005970 File Offset: 0x00003B70
[Token(Token = "0x60008E6")]
[Address(RVA = "0xC61400", Offset = "0xC60400", VA = "0x180C61400")]
public bool Replace(string input, int startPosition, int endPosition, out int testPosition, out MaskedTextResultHint resultHint)
{
return default(bool);
}
// Token: 0x060008E7 RID: 2279 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x60008E7")]
[Address(RVA = "0xC61AA0", Offset = "0xC60AA0", VA = "0x180C61AA0")]
private void ResetChar(int testPosition)
{
}
// Token: 0x060008E8 RID: 2280 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x60008E8")]
[Address(RVA = "0xC61B50", Offset = "0xC60B50", VA = "0x180C61B50")]
private void ResetString(int startPosition, int endPosition)
{
}
/// <summary>Sets the formatted string to the specified input string.</summary>
/// <param name="input">The <see cref="T:System.String" /> value used to set the formatted string.</param>
/// <returns>
/// <see langword="true" /> if all the characters were successfully set; otherwise, <see langword="false" />.</returns>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="input" /> parameter is <see langword="null" />.</exception>
// Token: 0x060008E9 RID: 2281 RVA: 0x00005988 File Offset: 0x00003B88
[Token(Token = "0x60008E9")]
[Address(RVA = "0xC62060", Offset = "0xC61060", VA = "0x180C62060")]
public bool Set(string input)
{
return default(bool);
}
/// <summary>Sets the formatted string to the specified input string, and then outputs the removal position and descriptive information.</summary>
/// <param name="input">The <see cref="T:System.String" /> value used to set the formatted string.</param>
/// <param name="testPosition">If successful, the zero-based position in the formatted string where the last character was actually set; otherwise, the first position where the operation failed. An output parameter.</param>
/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the set operation. An output parameter.</param>
/// <returns>
/// <see langword="true" /> if all the characters were successfully set; otherwise, <see langword="false" />.</returns>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="input" /> parameter is <see langword="null" />.</exception>
// Token: 0x060008EA RID: 2282 RVA: 0x000059A0 File Offset: 0x00003BA0
[Token(Token = "0x60008EA")]
[Address(RVA = "0xC621D0", Offset = "0xC611D0", VA = "0x180C621D0")]
public bool Set(string input, out int testPosition, out MaskedTextResultHint resultHint)
{
return default(bool);
}
// Token: 0x060008EB RID: 2283 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x60008EB")]
[Address(RVA = "0xC61CD0", Offset = "0xC60CD0", VA = "0x180C61CD0")]
private void SetChar(char input, int position)
{
}
// Token: 0x060008EC RID: 2284 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x60008EC")]
[Address(RVA = "0xC61D60", Offset = "0xC60D60", VA = "0x180C61D60")]
private void SetChar(char input, int position, MaskedTextProvider.CharDescriptor charDescriptor)
{
}
// Token: 0x060008ED RID: 2285 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x60008ED")]
[Address(RVA = "0xC61F30", Offset = "0xC60F30", VA = "0x180C61F30")]
private void SetString(string input, int testPosition)
{
}
// Token: 0x060008EE RID: 2286 RVA: 0x000059B8 File Offset: 0x00003BB8
[Token(Token = "0x60008EE")]
[Address(RVA = "0xC62320", Offset = "0xC61320", VA = "0x180C62320")]
private bool TestChar(char input, int position, out MaskedTextResultHint resultHint)
{
return default(bool);
}
// Token: 0x060008EF RID: 2287 RVA: 0x000059D0 File Offset: 0x00003BD0
[Token(Token = "0x60008EF")]
[Address(RVA = "0xC62850", Offset = "0xC61850", VA = "0x180C62850")]
private bool TestEscapeChar(char input, int position)
{
return default(bool);
}
// Token: 0x060008F0 RID: 2288 RVA: 0x000059E8 File Offset: 0x00003BE8
[Token(Token = "0x60008F0")]
[Address(RVA = "0xC628E0", Offset = "0xC618E0", VA = "0x180C628E0")]
private bool TestEscapeChar(char input, int position, MaskedTextProvider.CharDescriptor charDex)
{
return default(bool);
}
// Token: 0x060008F1 RID: 2289 RVA: 0x00005A00 File Offset: 0x00003C00
[Token(Token = "0x60008F1")]
[Address(RVA = "0xC62A80", Offset = "0xC61A80", VA = "0x180C62A80")]
private bool TestSetChar(char input, int position, out MaskedTextResultHint resultHint)
{
return default(bool);
}
// Token: 0x060008F2 RID: 2290 RVA: 0x00005A18 File Offset: 0x00003C18
[Token(Token = "0x60008F2")]
[Address(RVA = "0xC62AF0", Offset = "0xC61AF0", VA = "0x180C62AF0")]
private bool TestSetString(string input, int position, out int testPosition, out MaskedTextResultHint resultHint)
{
return default(bool);
}
// Token: 0x060008F3 RID: 2291 RVA: 0x00005A30 File Offset: 0x00003C30
[Token(Token = "0x60008F3")]
[Address(RVA = "0xC62B60", Offset = "0xC61B60", VA = "0x180C62B60")]
private bool TestString(string input, int position, out int testPosition, out MaskedTextResultHint resultHint)
{
return default(bool);
}
/// <summary>Returns the formatted string in a displayable form.</summary>
/// <returns>The formatted <see cref="T:System.String" /> that includes prompts and mask literals.</returns>
// Token: 0x060008F4 RID: 2292 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x60008F4")]
[Address(RVA = "0xC62CD0", Offset = "0xC61CD0", VA = "0x180C62CD0")]
public string ToDisplayString()
{
return null;
}
/// <summary>Returns the formatted string that includes all the assigned character values.</summary>
/// <returns>The formatted <see cref="T:System.String" /> that includes all the assigned character values.</returns>
// Token: 0x060008F5 RID: 2293 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x60008F5")]
[Address(RVA = "0xC63190", Offset = "0xC62190", VA = "0x180C63190", Slot = "3")]
public override string ToString()
{
return null;
}
/// <summary>Returns the formatted string, optionally including password characters.</summary>
/// <param name="ignorePasswordChar">
/// <see langword="true" /> to return the actual editable characters; otherwise, <see langword="false" /> to indicate that the <see cref="P:System.ComponentModel.MaskedTextProvider.PasswordChar" /> property is to be honored.</param>
/// <returns>The formatted <see cref="T:System.String" /> that includes literals, prompts, and optionally password characters.</returns>
// Token: 0x060008F6 RID: 2294 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x60008F6")]
[Address(RVA = "0xC63580", Offset = "0xC62580", VA = "0x180C63580")]
public string ToString(bool ignorePasswordChar)
{
return null;
}
/// <summary>Returns a substring of the formatted string.</summary>
/// <param name="startPosition">The zero-based position in the formatted string where the output begins.</param>
/// <param name="length">The number of characters to return.</param>
/// <returns>If successful, a substring of the formatted <see cref="T:System.String" />, which includes all the assigned character values; otherwise the <see cref="F:System.String.Empty" /> string.</returns>
// Token: 0x060008F7 RID: 2295 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x60008F7")]
[Address(RVA = "0xC63460", Offset = "0xC62460", VA = "0x180C63460")]
public string ToString(int startPosition, int length)
{
return null;
}
/// <summary>Returns a substring of the formatted string, optionally including password characters.</summary>
/// <param name="ignorePasswordChar">
/// <see langword="true" /> to return the actual editable characters; otherwise, <see langword="false" /> to indicate that the <see cref="P:System.ComponentModel.MaskedTextProvider.PasswordChar" /> property is to be honored.</param>
/// <param name="startPosition">The zero-based position in the formatted string where the output begins.</param>
/// <param name="length">The number of characters to return.</param>
/// <returns>If successful, a substring of the formatted <see cref="T:System.String" />, which includes literals, prompts, and optionally password characters; otherwise the <see cref="F:System.String.Empty" /> string.</returns>
// Token: 0x060008F8 RID: 2296 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x60008F8")]
[Address(RVA = "0xC632E0", Offset = "0xC622E0", VA = "0x180C632E0")]
public string ToString(bool ignorePasswordChar, int startPosition, int length)
{
return null;
}
/// <summary>Returns the formatted string, optionally including prompt and literal characters.</summary>
/// <param name="includePrompt">
/// <see langword="true" /> to include prompt characters in the return string; otherwise, <see langword="false" />.</param>
/// <param name="includeLiterals">
/// <see langword="true" /> to include literal characters in the return string; otherwise, <see langword="false" />.</param>
/// <returns>The formatted <see cref="T:System.String" /> that includes all the assigned character values and optionally includes literals and prompts.</returns>
// Token: 0x060008F9 RID: 2297 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x60008F9")]
[Address(RVA = "0xC63400", Offset = "0xC62400", VA = "0x180C63400")]
public string ToString(bool includePrompt, bool includeLiterals)
{
return null;
}
/// <summary>Returns a substring of the formatted string, optionally including prompt and literal characters.</summary>
/// <param name="includePrompt">
/// <see langword="true" /> to include prompt characters in the return string; otherwise, <see langword="false" />.</param>
/// <param name="includeLiterals">
/// <see langword="true" /> to include literal characters in the return string; otherwise, <see langword="false" />.</param>
/// <param name="startPosition">The zero-based position in the formatted string where the output begins.</param>
/// <param name="length">The number of characters to return.</param>
/// <returns>If successful, a substring of the formatted <see cref="T:System.String" />, which includes all the assigned character values and optionally includes literals and prompts; otherwise the <see cref="F:System.String.Empty" /> string.</returns>
// Token: 0x060008FA RID: 2298 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x60008FA")]
[Address(RVA = "0xC632B0", Offset = "0xC622B0", VA = "0x180C632B0")]
public string ToString(bool includePrompt, bool includeLiterals, int startPosition, int length)
{
return null;
}
/// <summary>Returns a substring of the formatted string, optionally including prompt, literal, and password characters.</summary>
/// <param name="ignorePasswordChar">
/// <see langword="true" /> to return the actual editable characters; otherwise, <see langword="false" /> to indicate that the <see cref="P:System.ComponentModel.MaskedTextProvider.PasswordChar" /> property is to be honored.</param>
/// <param name="includePrompt">
/// <see langword="true" /> to include prompt characters in the return string; otherwise, <see langword="false" />.</param>
/// <param name="includeLiterals">
/// <see langword="true" /> to return literal characters in the return string; otherwise, <see langword="false" />.</param>
/// <param name="startPosition">The zero-based position in the formatted string where the output begins.</param>
/// <param name="length">The number of characters to return.</param>
/// <returns>If successful, a substring of the formatted <see cref="T:System.String" />, which includes all the assigned character values and optionally includes literals, prompts, and password characters; otherwise the <see cref="F:System.String.Empty" /> string.</returns>
// Token: 0x060008FB RID: 2299 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x60008FB")]
[Address(RVA = "0xC62E60", Offset = "0xC61E60", VA = "0x180C62E60")]
public string ToString(bool ignorePasswordChar, bool includePrompt, bool includeLiterals, int startPosition, int length)
{
return null;
}
/// <summary>Tests whether the specified character could be set successfully at the specified position.</summary>
/// <param name="input">The <see cref="T:System.Char" /> value to test.</param>
/// <param name="position">The position in the mask to test the input character against.</param>
/// <param name="hint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the operation. An output parameter.</param>
/// <returns>
/// <see langword="true" /> if the specified character is valid for the specified position; otherwise, <see langword="false" />.</returns>
// Token: 0x060008FC RID: 2300 RVA: 0x00005A48 File Offset: 0x00003C48
[Token(Token = "0x60008FC")]
[Address(RVA = "0xC636B0", Offset = "0xC626B0", VA = "0x180C636B0")]
public bool VerifyChar(char input, int position, out MaskedTextResultHint hint)
{
return default(bool);
}
/// <summary>Tests whether the specified character would be escaped at the specified position.</summary>
/// <param name="input">The <see cref="T:System.Char" /> value to test.</param>
/// <param name="position">The position in the mask to test the input character against.</param>
/// <returns>
/// <see langword="true" /> if the specified character would be escaped at the specified position; otherwise, <see langword="false" />.</returns>
// Token: 0x060008FD RID: 2301 RVA: 0x00005A60 File Offset: 0x00003C60
[Token(Token = "0x60008FD")]
[Address(RVA = "0xC63730", Offset = "0xC62730", VA = "0x180C63730")]
public bool VerifyEscapeChar(char input, int position)
{
return default(bool);
}
/// <summary>Tests whether the specified string could be set successfully.</summary>
/// <param name="input">The <see cref="T:System.String" /> value to test.</param>
/// <returns>
/// <see langword="true" /> if the specified string represents valid input; otherwise, <see langword="false" />.</returns>
// Token: 0x060008FE RID: 2302 RVA: 0x00005A78 File Offset: 0x00003C78
[Token(Token = "0x60008FE")]
[Address(RVA = "0xC637E0", Offset = "0xC627E0", VA = "0x180C637E0")]
public bool VerifyString(string input)
{
return default(bool);
}
/// <summary>Tests whether the specified string could be set successfully, and then outputs position and descriptive information.</summary>
/// <param name="input">The <see cref="T:System.String" /> value to test.</param>
/// <param name="testPosition">If successful, the zero-based position of the last character actually tested; otherwise, the first position where the test failed. An output parameter.</param>
/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the test operation. An output parameter.</param>
/// <returns>
/// <see langword="true" /> if the specified string represents valid input; otherwise, <see langword="false" />.</returns>
// Token: 0x060008FF RID: 2303 RVA: 0x00005A90 File Offset: 0x00003C90
[Token(Token = "0x60008FF")]
[Address(RVA = "0xC637A0", Offset = "0xC627A0", VA = "0x180C637A0")]
public bool VerifyString(string input, out int testPosition, out MaskedTextResultHint resultHint)
{
return default(bool);
}
// Token: 0x04000529 RID: 1321
[Token(Token = "0x4000529")]
private const char spaceChar = ' ';
// Token: 0x0400052A RID: 1322
[Token(Token = "0x400052A")]
private const char defaultPromptChar = '_';
// Token: 0x0400052B RID: 1323
[Token(Token = "0x400052B")]
private const char nullPasswordChar = '\0';
// Token: 0x0400052C RID: 1324
[Token(Token = "0x400052C")]
private const bool defaultAllowPrompt = true;
// Token: 0x0400052D RID: 1325
[Token(Token = "0x400052D")]
private const int invalidIndex = -1;
// Token: 0x0400052E RID: 1326
[Token(Token = "0x400052E")]
private const byte editAny = 0;
// Token: 0x0400052F RID: 1327
[Token(Token = "0x400052F")]
private const byte editUnassigned = 1;
// Token: 0x04000530 RID: 1328
[Token(Token = "0x4000530")]
private const byte editAssigned = 2;
// Token: 0x04000531 RID: 1329
[Token(Token = "0x4000531")]
private const bool forward = true;
// Token: 0x04000532 RID: 1330
[Token(Token = "0x4000532")]
private const bool backward = false;
// Token: 0x04000533 RID: 1331
[Token(Token = "0x4000533")]
private static int ASCII_ONLY;
// Token: 0x04000534 RID: 1332
[Token(Token = "0x4000534")]
private static int ALLOW_PROMPT_AS_INPUT;
// Token: 0x04000535 RID: 1333
[Token(Token = "0x4000535")]
private static int INCLUDE_PROMPT;
// Token: 0x04000536 RID: 1334
[Token(Token = "0x4000536")]
private static int INCLUDE_LITERALS;
// Token: 0x04000537 RID: 1335
[Token(Token = "0x4000537")]
private static int RESET_ON_PROMPT;
// Token: 0x04000538 RID: 1336
[Token(Token = "0x4000538")]
private static int RESET_ON_LITERALS;
// Token: 0x04000539 RID: 1337
[Token(Token = "0x4000539")]
private static int SKIP_SPACE;
// Token: 0x0400053A RID: 1338
[Token(Token = "0x400053A")]
private static Type maskTextProviderType;
// Token: 0x0400053B RID: 1339
[FieldOffset(Offset = "0x10")]
[Token(Token = "0x400053B")]
private BitVector32 flagState;
// Token: 0x0400053C RID: 1340
[FieldOffset(Offset = "0x18")]
[Token(Token = "0x400053C")]
private CultureInfo culture;
// Token: 0x0400053D RID: 1341
[FieldOffset(Offset = "0x20")]
[Token(Token = "0x400053D")]
private StringBuilder testString;
// Token: 0x0400053E RID: 1342
[FieldOffset(Offset = "0x28")]
[Token(Token = "0x400053E")]
private int assignedCharCount;
// Token: 0x0400053F RID: 1343
[FieldOffset(Offset = "0x2C")]
[Token(Token = "0x400053F")]
private int requiredCharCount;
// Token: 0x04000540 RID: 1344
[FieldOffset(Offset = "0x30")]
[Token(Token = "0x4000540")]
private int requiredEditChars;
// Token: 0x04000541 RID: 1345
[FieldOffset(Offset = "0x34")]
[Token(Token = "0x4000541")]
private int optionalEditChars;
// Token: 0x04000542 RID: 1346
[FieldOffset(Offset = "0x38")]
[Token(Token = "0x4000542")]
private string mask;
// Token: 0x04000543 RID: 1347
[FieldOffset(Offset = "0x40")]
[Token(Token = "0x4000543")]
private char passwordChar;
// Token: 0x04000544 RID: 1348
[FieldOffset(Offset = "0x42")]
[Token(Token = "0x4000544")]
private char promptChar;
// Token: 0x04000545 RID: 1349
[FieldOffset(Offset = "0x48")]
[Token(Token = "0x4000545")]
private List<MaskedTextProvider.CharDescriptor> stringDescriptor;
// Token: 0x02000164 RID: 356
[Token(Token = "0x2000164")]
private enum CaseConversion
{
// Token: 0x04000547 RID: 1351
[Token(Token = "0x4000547")]
None,
// Token: 0x04000548 RID: 1352
[Token(Token = "0x4000548")]
ToLower,
// Token: 0x04000549 RID: 1353
[Token(Token = "0x4000549")]
ToUpper
}
// Token: 0x02000165 RID: 357
[Token(Token = "0x2000165")]
[Flags]
private enum CharType
{
// Token: 0x0400054B RID: 1355
[Token(Token = "0x400054B")]
EditOptional = 1,
// Token: 0x0400054C RID: 1356
[Token(Token = "0x400054C")]
EditRequired = 2,
// Token: 0x0400054D RID: 1357
[Token(Token = "0x400054D")]
Separator = 4,
// Token: 0x0400054E RID: 1358
[Token(Token = "0x400054E")]
Literal = 8,
// Token: 0x0400054F RID: 1359
[Token(Token = "0x400054F")]
Modifier = 16
}
// Token: 0x02000166 RID: 358
[Token(Token = "0x2000166")]
private class CharDescriptor
{
// Token: 0x06000901 RID: 2305 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000901")]
[Address(RVA = "0xC514F0", Offset = "0xC504F0", VA = "0x180C514F0")]
public CharDescriptor(int maskPos, MaskedTextProvider.CharType charType)
{
}
// Token: 0x06000902 RID: 2306 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6000902")]
[Address(RVA = "0xC512C0", Offset = "0xC502C0", VA = "0x180C512C0", Slot = "3")]
public override string ToString()
{
return null;
}
// Token: 0x04000550 RID: 1360
[FieldOffset(Offset = "0x10")]
[Token(Token = "0x4000550")]
public int MaskPosition;
// Token: 0x04000551 RID: 1361
[FieldOffset(Offset = "0x14")]
[Token(Token = "0x4000551")]
public MaskedTextProvider.CaseConversion CaseConversion;
// Token: 0x04000552 RID: 1362
[FieldOffset(Offset = "0x18")]
[Token(Token = "0x4000552")]
public MaskedTextProvider.CharType CharType;
// Token: 0x04000553 RID: 1363
[FieldOffset(Offset = "0x1C")]
[Token(Token = "0x4000553")]
public bool IsAssigned;
}
}
}
Reference in New Issue View Git Blame Copy Permalink