Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / wpf / src / Core / CSharp / MS / Internal / TextFormatting / TextMarkerSource.cs / 1 / TextMarkerSource.cs
//------------------------------------------------------------------------ // // Microsoft Windows Client Platform // Copyright (C) Microsoft Corporation, 2001 // // File: TextMarkerSource.cs // // Contents: Generated content for marker symbol // // Created: 3-10-2003 Worachai Chaoweeraprasit (wchao) // //----------------------------------------------------------------------- using System; using System.Diagnostics; using System.Windows.Threading; using System.Text; using System.Globalization; using System.Windows; using System.Windows.Media; using System.Windows.Media.TextFormatting; using MS.Internal; using SR=MS.Internal.PresentationCore.SR; using SRID=MS.Internal.PresentationCore.SRID; namespace MS.Internal.TextFormatting { ////// Implementation of TextSource for used by marker /// internal sealed class TextMarkerSource : TextSource { private char[] _characterArray; private TextRunProperties _textRunProperties; private TextParagraphProperties _textParagraphProperties; private const char NumberSuffix = '.'; private const string DecimalNumerics = "0123456789"; private const string LowerLatinNumerics = "abcdefghijklmnopqrstuvwxyz"; private const string UpperLatinNumerics = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; private static string[][] RomanNumerics = new string[][] { new string[] { "m??", "cdm", "xlc", "ivx" }, new string[] { "M??", "CDM", "XLC", "IVX" } }; internal TextMarkerSource( TextParagraphProperties textParagraphProperties, TextMarkerStyle markerStyle, int autoNumberingIndex ) { Debug.Assert(markerStyle != TextMarkerStyle.None); _textParagraphProperties = textParagraphProperties; TextRunProperties defaultRunProperties = _textParagraphProperties.DefaultTextRunProperties; string symbolString = null; if(IsKnownSymbolMarkerStyle(markerStyle)) { switch(markerStyle) { case TextMarkerStyle.Disc: symbolString = "\x9f"; break; case TextMarkerStyle.Circle: symbolString = "\xa1"; break; case TextMarkerStyle.Square: symbolString = "\x71"; break; case TextMarkerStyle.Box: symbolString = "\xa7"; break; } Typeface defaultTypeface = defaultRunProperties.Typeface; // recreate a new marker run properties based on symbol typeface e.g. Wingding _textRunProperties = new GenericTextRunProperties( new Typeface( new FontFamily("Wingdings"), defaultTypeface.Style, defaultTypeface.Weight, defaultTypeface.Stretch ), defaultRunProperties.FontRenderingEmSize, defaultRunProperties.FontHintingEmSize, defaultRunProperties.TextDecorations, defaultRunProperties.ForegroundBrush, defaultRunProperties.BackgroundBrush, defaultRunProperties.BaselineAlignment, CultureMapper.GetSpecificCulture(defaultRunProperties.CultureInfo), null // default number substitution for culture ); } else if(IsKnownIndexMarkerStyle(markerStyle)) { // Internal client code should have already validated this. Debug.Assert(autoNumberingIndex > 0); _textRunProperties = defaultRunProperties; int counter = autoNumberingIndex; switch(markerStyle) { case TextMarkerStyle.Decimal: _characterArray = ConvertNumberToString(counter, false, DecimalNumerics); break; case TextMarkerStyle.LowerLatin: _characterArray = ConvertNumberToString(counter, true, LowerLatinNumerics); break; case TextMarkerStyle.UpperLatin: _characterArray = ConvertNumberToString(counter, true, UpperLatinNumerics); break; case TextMarkerStyle.LowerRoman: symbolString = ConvertNumberToRomanString(counter, false); break; case TextMarkerStyle.UpperRoman: symbolString = ConvertNumberToRomanString(counter, true); break; } } else { Debug.Assert(false, "Invalid marker style"); } if(symbolString != null) { _characterArray = symbolString.ToCharArray(); } Debug.Assert(_characterArray != null); } #region TextSource implementation ////// TextFormatter to get a text run started at specified text source position /// public override TextRun GetTextRun( int textSourceCharacterIndex ) { if (textSourceCharacterIndex < _characterArray.Length) { return new TextCharacters( _characterArray, textSourceCharacterIndex, _characterArray.Length - textSourceCharacterIndex, _textRunProperties ); } // Because LS ignores the character for TextEndOfLine characters in marker, // We must return TextEndOfParagraph to termine fetching. return new TextEndOfParagraph(1); } ////// TextFormatter to get text immediately before specified text source position. /// public override TextSpanGetPrecedingText( int textSourceCharacterIndexLimit ) { CharacterBufferRange charString = CharacterBufferRange.Empty; if (textSourceCharacterIndexLimit > 0) { charString = new CharacterBufferRange( new CharacterBufferReference(_characterArray, 0), Math.Min(_characterArray.Length, textSourceCharacterIndexLimit) ); } return new TextSpan ( textSourceCharacterIndexLimit, new CultureSpecificCharacterBufferRange(CultureMapper.GetSpecificCulture(_textRunProperties.CultureInfo), charString) ); } /// /// TextFormatter to map a text source character index to a text effect character index /// /// text source character index ///the text effect index corresponding to the text effect character index public override int GetTextEffectCharacterIndexFromTextSourceCharacterIndex( int textSourceCharacterIndex ) { throw new NotSupportedException(); } #endregion ////// Convert a number to string, consisting of digits followed by the NumberSuffix character. /// /// Number to convert. /// True if there is no zero digit (e.g., alpha numbering). /// Set of digits (e.g., 0-9 or a-z). ///Returns the number string as an array of characters. private static char[] ConvertNumberToString(int number, bool oneBased, string numericSymbols) { // Whether zero-based or one-based numbering is used affects how we // count and how we determine the maximum number of values for a // given number of digits. // // The following table illustrates how counting differs. In both // cases we're using base-2 numbering (i.e., two distinct digits), // but with 1-based counting each of those two digits can be a // significant leading digit. // // 0-based 1-based // ---------------------------- // 0 0 -- // 1 1 a // 2 10 b // 3 11 aa // 4 100 ab // 5 101 ba // 6 110 bb // 7 111 aaa // 8 1000 aab // 9 1001 aba // 10 1010 abb // 11 1011 baa // 12 1100 bab // 13 1101 bba // 14 1110 bbb // 15 1111 aaaa // 16 10000 aaab // // For zero-based counting, adding a leading zero does not change // the value of a number. Thus, the set of all N-digit numbers is // a proper subset of the set of (N+1)-digit numbers. Thus the set // of values that can be represented by N *or fewer* digits is the // same as the number of combinations of exactly N digits, i.e., // // b ^ N // // where b is the base of the numbering system. // // For one-based counting, there is no zero digit. Thus, the set // of N-digit numbers and the set of (N+1)-digit numbers are // disjoint sets. Thus, while the number of combinations of // *exactly* N digits is still b ^ N, the maximum value that // can be represented by N *or fewer* digits is: // // Max(N) // where N = 1 : b // where N > 1 : (b ^ N) + Max(N - 1) // if (oneBased) { // Subtract 1 from 1-based numbers so we can use zero-based // indexing. The formula for Max(N) given above should now be // thought of as a limit rather than a maximum. --number; } Debug.Assert(number >= 0); char[] result; int b = numericSymbols.Length; if (number < b) { // Optimize common case of single-digit numbers. result = new char[2]; // digit + suffix result[0] = numericSymbols[number]; result[1] = NumberSuffix; } else { // Disjoint is 1 if and only if the set of numbers with N // digits and the set of numbers with (N+1) digits are // disjoint (see comment above). Otherwise it is zero. int disjoint = oneBased ? 1 : 0; // Count digits. We stop when the limit (i.e., 1 + the max value // for the current number of digits) exceeds the specified number. int digits = 1; for (long limit = b, pow = b; (long)number >= limit; ++digits) { // Neither of the following calculations can overflow because // we know both pow and limit are <= number (which is an int) // and b is at most 26. pow *= b; limit = pow + (limit * disjoint); } // Build string in reverse order starting with suffix. result = new char[digits + 1]; // digits + suffix result[digits] = NumberSuffix; for (int i = digits - 1; i >= 0; --i) { result[i] = numericSymbols[number % b]; number = (number / b) - disjoint; } } return result; } ////// Convert 1-based number to a Roman numeric string /// followed by NumberSuffix character. /// ////// Roman number is 1-based. The Roman numeric string is a series of symbols. Following /// is the list of symbols and its value. /// /// Symbol Value /// I 1 /// V 5 /// X 10 /// L 50 /// C 100 /// D 500 /// M 1000 /// /// The rule of Roman number prohibits the use of more than 3 consecutive identical symbol /// but using subtraction of symbol standing for multiples of 10, so the value 4 is written /// as IV (5-1) rather than IIII. /// /// Due to the writing rule and the fact that the symbol represents not the numeral digit /// but the value of the number. Roman number system cannot represent value larger than 3999. /// /// See, http://www.ccsn.nevada.edu/math/ancient_systems.htm /// /// However, there exists a more relaxing use of Roman numbers to represent values 4000 and /// 4999 by using 4 consecutive M. The value 4999 is than written as 'MMMMCMXCIX'. Such use /// however is not widely accepted. /// /// See, http://www.guernsey.net/~sgibbs/roman.html /// /// For values larger than 3999, an overscore is used on the symbol to indicate 1000 multiplication. /// ___ /// So, value 7000 would be written as VII. This writing rule has a fair amount of disagreement /// since it is widely understood that it is not invented by the Romans and they rarely had a /// need for large numbers during their time. Furthermore, accepting this writing rule just /// for the sake of being able to write larger number would create a new limitation of the values /// greater than 3,999,999. Unicode 4.0 does not encode these overscore symbols. /// /// See, http://www.gwydir.demon.co.uk/jo/roman/number.htm /// http://www.novaroma.org/via_romana/numbers.html /// /// Implementation-wise, IE adopts a general limitation of 3999 and simply convert the value /// into a regular numeric form. /// /// We'll follow the mainstream and adopt the 3999 limit. The fallback would also do would IE does. /// /// private static string ConvertNumberToRomanString( int number, bool uppercase ) { if (number > 3999) { // Roman numeric string not supported return number.ToString(CultureInfo.InvariantCulture); } StringBuilder builder = new StringBuilder(); AddRomanNumeric(builder, number / 1000, RomanNumerics[uppercase ? 1 : 0][0]); number %= 1000; AddRomanNumeric(builder, number / 100, RomanNumerics[uppercase ? 1 : 0][1]); number %= 100; AddRomanNumeric(builder, number / 10, RomanNumerics[uppercase ? 1 : 0][2]); number %= 10; AddRomanNumeric(builder, number, RomanNumerics[uppercase ? 1 : 0][3]); builder.Append(NumberSuffix); return builder.ToString(); } ////// Convert number 0 - 9 into Roman numeric /// /// string builder /// number to convert /// Roman numeric char for one five and ten private static void AddRomanNumeric( StringBuilder builder, int number, string oneFiveTen ) { Debug.Assert(number >= 0 && number <= 9); if (number >= 1 && number <= 9) { if (number == 4 || number == 9) builder.Append(oneFiveTen[0]); if (number == 9) { builder.Append(oneFiveTen[2]); } else { if (number >= 4) builder.Append(oneFiveTen[1]); for (int i = number % 5; i > 0 && i < 4; i--) builder.Append(oneFiveTen[0]); } } } internal static bool IsKnownSymbolMarkerStyle(TextMarkerStyle markerStyle) { return ( markerStyle == TextMarkerStyle.Disc || markerStyle == TextMarkerStyle.Circle || markerStyle == TextMarkerStyle.Square || markerStyle == TextMarkerStyle.Box ); } internal static bool IsKnownIndexMarkerStyle(TextMarkerStyle markerStyle) { return ( markerStyle == TextMarkerStyle.Decimal || markerStyle == TextMarkerStyle.LowerLatin || markerStyle == TextMarkerStyle.UpperLatin || markerStyle == TextMarkerStyle.LowerRoman || markerStyle == TextMarkerStyle.UpperRoman ); } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved. //------------------------------------------------------------------------ // // Microsoft Windows Client Platform // Copyright (C) Microsoft Corporation, 2001 // // File: TextMarkerSource.cs // // Contents: Generated content for marker symbol // // Created: 3-10-2003 Worachai Chaoweeraprasit (wchao) // //----------------------------------------------------------------------- using System; using System.Diagnostics; using System.Windows.Threading; using System.Text; using System.Globalization; using System.Windows; using System.Windows.Media; using System.Windows.Media.TextFormatting; using MS.Internal; using SR=MS.Internal.PresentationCore.SR; using SRID=MS.Internal.PresentationCore.SRID; namespace MS.Internal.TextFormatting { ////// Implementation of TextSource for used by marker /// internal sealed class TextMarkerSource : TextSource { private char[] _characterArray; private TextRunProperties _textRunProperties; private TextParagraphProperties _textParagraphProperties; private const char NumberSuffix = '.'; private const string DecimalNumerics = "0123456789"; private const string LowerLatinNumerics = "abcdefghijklmnopqrstuvwxyz"; private const string UpperLatinNumerics = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; private static string[][] RomanNumerics = new string[][] { new string[] { "m??", "cdm", "xlc", "ivx" }, new string[] { "M??", "CDM", "XLC", "IVX" } }; internal TextMarkerSource( TextParagraphProperties textParagraphProperties, TextMarkerStyle markerStyle, int autoNumberingIndex ) { Debug.Assert(markerStyle != TextMarkerStyle.None); _textParagraphProperties = textParagraphProperties; TextRunProperties defaultRunProperties = _textParagraphProperties.DefaultTextRunProperties; string symbolString = null; if(IsKnownSymbolMarkerStyle(markerStyle)) { switch(markerStyle) { case TextMarkerStyle.Disc: symbolString = "\x9f"; break; case TextMarkerStyle.Circle: symbolString = "\xa1"; break; case TextMarkerStyle.Square: symbolString = "\x71"; break; case TextMarkerStyle.Box: symbolString = "\xa7"; break; } Typeface defaultTypeface = defaultRunProperties.Typeface; // recreate a new marker run properties based on symbol typeface e.g. Wingding _textRunProperties = new GenericTextRunProperties( new Typeface( new FontFamily("Wingdings"), defaultTypeface.Style, defaultTypeface.Weight, defaultTypeface.Stretch ), defaultRunProperties.FontRenderingEmSize, defaultRunProperties.FontHintingEmSize, defaultRunProperties.TextDecorations, defaultRunProperties.ForegroundBrush, defaultRunProperties.BackgroundBrush, defaultRunProperties.BaselineAlignment, CultureMapper.GetSpecificCulture(defaultRunProperties.CultureInfo), null // default number substitution for culture ); } else if(IsKnownIndexMarkerStyle(markerStyle)) { // Internal client code should have already validated this. Debug.Assert(autoNumberingIndex > 0); _textRunProperties = defaultRunProperties; int counter = autoNumberingIndex; switch(markerStyle) { case TextMarkerStyle.Decimal: _characterArray = ConvertNumberToString(counter, false, DecimalNumerics); break; case TextMarkerStyle.LowerLatin: _characterArray = ConvertNumberToString(counter, true, LowerLatinNumerics); break; case TextMarkerStyle.UpperLatin: _characterArray = ConvertNumberToString(counter, true, UpperLatinNumerics); break; case TextMarkerStyle.LowerRoman: symbolString = ConvertNumberToRomanString(counter, false); break; case TextMarkerStyle.UpperRoman: symbolString = ConvertNumberToRomanString(counter, true); break; } } else { Debug.Assert(false, "Invalid marker style"); } if(symbolString != null) { _characterArray = symbolString.ToCharArray(); } Debug.Assert(_characterArray != null); } #region TextSource implementation ////// TextFormatter to get a text run started at specified text source position /// public override TextRun GetTextRun( int textSourceCharacterIndex ) { if (textSourceCharacterIndex < _characterArray.Length) { return new TextCharacters( _characterArray, textSourceCharacterIndex, _characterArray.Length - textSourceCharacterIndex, _textRunProperties ); } // Because LS ignores the character for TextEndOfLine characters in marker, // We must return TextEndOfParagraph to termine fetching. return new TextEndOfParagraph(1); } ////// TextFormatter to get text immediately before specified text source position. /// public override TextSpanGetPrecedingText( int textSourceCharacterIndexLimit ) { CharacterBufferRange charString = CharacterBufferRange.Empty; if (textSourceCharacterIndexLimit > 0) { charString = new CharacterBufferRange( new CharacterBufferReference(_characterArray, 0), Math.Min(_characterArray.Length, textSourceCharacterIndexLimit) ); } return new TextSpan ( textSourceCharacterIndexLimit, new CultureSpecificCharacterBufferRange(CultureMapper.GetSpecificCulture(_textRunProperties.CultureInfo), charString) ); } /// /// TextFormatter to map a text source character index to a text effect character index /// /// text source character index ///the text effect index corresponding to the text effect character index public override int GetTextEffectCharacterIndexFromTextSourceCharacterIndex( int textSourceCharacterIndex ) { throw new NotSupportedException(); } #endregion ////// Convert a number to string, consisting of digits followed by the NumberSuffix character. /// /// Number to convert. /// True if there is no zero digit (e.g., alpha numbering). /// Set of digits (e.g., 0-9 or a-z). ///Returns the number string as an array of characters. private static char[] ConvertNumberToString(int number, bool oneBased, string numericSymbols) { // Whether zero-based or one-based numbering is used affects how we // count and how we determine the maximum number of values for a // given number of digits. // // The following table illustrates how counting differs. In both // cases we're using base-2 numbering (i.e., two distinct digits), // but with 1-based counting each of those two digits can be a // significant leading digit. // // 0-based 1-based // ---------------------------- // 0 0 -- // 1 1 a // 2 10 b // 3 11 aa // 4 100 ab // 5 101 ba // 6 110 bb // 7 111 aaa // 8 1000 aab // 9 1001 aba // 10 1010 abb // 11 1011 baa // 12 1100 bab // 13 1101 bba // 14 1110 bbb // 15 1111 aaaa // 16 10000 aaab // // For zero-based counting, adding a leading zero does not change // the value of a number. Thus, the set of all N-digit numbers is // a proper subset of the set of (N+1)-digit numbers. Thus the set // of values that can be represented by N *or fewer* digits is the // same as the number of combinations of exactly N digits, i.e., // // b ^ N // // where b is the base of the numbering system. // // For one-based counting, there is no zero digit. Thus, the set // of N-digit numbers and the set of (N+1)-digit numbers are // disjoint sets. Thus, while the number of combinations of // *exactly* N digits is still b ^ N, the maximum value that // can be represented by N *or fewer* digits is: // // Max(N) // where N = 1 : b // where N > 1 : (b ^ N) + Max(N - 1) // if (oneBased) { // Subtract 1 from 1-based numbers so we can use zero-based // indexing. The formula for Max(N) given above should now be // thought of as a limit rather than a maximum. --number; } Debug.Assert(number >= 0); char[] result; int b = numericSymbols.Length; if (number < b) { // Optimize common case of single-digit numbers. result = new char[2]; // digit + suffix result[0] = numericSymbols[number]; result[1] = NumberSuffix; } else { // Disjoint is 1 if and only if the set of numbers with N // digits and the set of numbers with (N+1) digits are // disjoint (see comment above). Otherwise it is zero. int disjoint = oneBased ? 1 : 0; // Count digits. We stop when the limit (i.e., 1 + the max value // for the current number of digits) exceeds the specified number. int digits = 1; for (long limit = b, pow = b; (long)number >= limit; ++digits) { // Neither of the following calculations can overflow because // we know both pow and limit are <= number (which is an int) // and b is at most 26. pow *= b; limit = pow + (limit * disjoint); } // Build string in reverse order starting with suffix. result = new char[digits + 1]; // digits + suffix result[digits] = NumberSuffix; for (int i = digits - 1; i >= 0; --i) { result[i] = numericSymbols[number % b]; number = (number / b) - disjoint; } } return result; } ////// Convert 1-based number to a Roman numeric string /// followed by NumberSuffix character. /// ////// Roman number is 1-based. The Roman numeric string is a series of symbols. Following /// is the list of symbols and its value. /// /// Symbol Value /// I 1 /// V 5 /// X 10 /// L 50 /// C 100 /// D 500 /// M 1000 /// /// The rule of Roman number prohibits the use of more than 3 consecutive identical symbol /// but using subtraction of symbol standing for multiples of 10, so the value 4 is written /// as IV (5-1) rather than IIII. /// /// Due to the writing rule and the fact that the symbol represents not the numeral digit /// but the value of the number. Roman number system cannot represent value larger than 3999. /// /// See, http://www.ccsn.nevada.edu/math/ancient_systems.htm /// /// However, there exists a more relaxing use of Roman numbers to represent values 4000 and /// 4999 by using 4 consecutive M. The value 4999 is than written as 'MMMMCMXCIX'. Such use /// however is not widely accepted. /// /// See, http://www.guernsey.net/~sgibbs/roman.html /// /// For values larger than 3999, an overscore is used on the symbol to indicate 1000 multiplication. /// ___ /// So, value 7000 would be written as VII. This writing rule has a fair amount of disagreement /// since it is widely understood that it is not invented by the Romans and they rarely had a /// need for large numbers during their time. Furthermore, accepting this writing rule just /// for the sake of being able to write larger number would create a new limitation of the values /// greater than 3,999,999. Unicode 4.0 does not encode these overscore symbols. /// /// See, http://www.gwydir.demon.co.uk/jo/roman/number.htm /// http://www.novaroma.org/via_romana/numbers.html /// /// Implementation-wise, IE adopts a general limitation of 3999 and simply convert the value /// into a regular numeric form. /// /// We'll follow the mainstream and adopt the 3999 limit. The fallback would also do would IE does. /// /// private static string ConvertNumberToRomanString( int number, bool uppercase ) { if (number > 3999) { // Roman numeric string not supported return number.ToString(CultureInfo.InvariantCulture); } StringBuilder builder = new StringBuilder(); AddRomanNumeric(builder, number / 1000, RomanNumerics[uppercase ? 1 : 0][0]); number %= 1000; AddRomanNumeric(builder, number / 100, RomanNumerics[uppercase ? 1 : 0][1]); number %= 100; AddRomanNumeric(builder, number / 10, RomanNumerics[uppercase ? 1 : 0][2]); number %= 10; AddRomanNumeric(builder, number, RomanNumerics[uppercase ? 1 : 0][3]); builder.Append(NumberSuffix); return builder.ToString(); } ////// Convert number 0 - 9 into Roman numeric /// /// string builder /// number to convert /// Roman numeric char for one five and ten private static void AddRomanNumeric( StringBuilder builder, int number, string oneFiveTen ) { Debug.Assert(number >= 0 && number <= 9); if (number >= 1 && number <= 9) { if (number == 4 || number == 9) builder.Append(oneFiveTen[0]); if (number == 9) { builder.Append(oneFiveTen[2]); } else { if (number >= 4) builder.Append(oneFiveTen[1]); for (int i = number % 5; i > 0 && i < 4; i--) builder.Append(oneFiveTen[0]); } } } internal static bool IsKnownSymbolMarkerStyle(TextMarkerStyle markerStyle) { return ( markerStyle == TextMarkerStyle.Disc || markerStyle == TextMarkerStyle.Circle || markerStyle == TextMarkerStyle.Square || markerStyle == TextMarkerStyle.Box ); } internal static bool IsKnownIndexMarkerStyle(TextMarkerStyle markerStyle) { return ( markerStyle == TextMarkerStyle.Decimal || markerStyle == TextMarkerStyle.LowerLatin || markerStyle == TextMarkerStyle.UpperLatin || markerStyle == TextMarkerStyle.LowerRoman || markerStyle == TextMarkerStyle.UpperRoman ); } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
![Network programming in C#, Network Programming in VB.NET, Network Programming in .NET](/images/book.jpg)
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- WebBrowserContainer.cs
- SqlDataSourceQuery.cs
- ListItemConverter.cs
- CompiledRegexRunner.cs
- VarInfo.cs
- CommentEmitter.cs
- ButtonChrome.cs
- BooleanStorage.cs
- Collection.cs
- RowSpanVector.cs
- PathGeometry.cs
- PolicyLevel.cs
- DocumentViewerConstants.cs
- TextTrailingWordEllipsis.cs
- SchemaObjectWriter.cs
- GenericWebPart.cs
- ImageBrush.cs
- WebPartsPersonalizationAuthorization.cs
- InvalidOleVariantTypeException.cs
- CharacterHit.cs
- XmlSchemaDatatype.cs
- QueueProcessor.cs
- Expression.cs
- PropertyItemInternal.cs
- DirectoryObjectSecurity.cs
- ColorConvertedBitmap.cs
- TableParaClient.cs
- RegistryPermission.cs
- DetailsViewUpdatedEventArgs.cs
- DataGridCell.cs
- ColorAnimation.cs
- TransformerConfigurationWizardBase.cs
- CancellationToken.cs
- AttributedMetaModel.cs
- EntitySqlQueryCacheEntry.cs
- MaskInputRejectedEventArgs.cs
- ClassValidator.cs
- TextTrailingCharacterEllipsis.cs
- DirtyTextRange.cs
- QueryGeneratorBase.cs
- BitmapVisualManager.cs
- mongolianshape.cs
- CommandID.cs
- MtomMessageEncodingBindingElement.cs
- MexTcpBindingCollectionElement.cs
- ModelMemberCollection.cs
- FamilyCollection.cs
- StandardMenuStripVerb.cs
- SlipBehavior.cs
- FormView.cs
- TextRenderer.cs
- XmlNamedNodeMap.cs
- HttpListenerException.cs
- HelpEvent.cs
- OracleBinary.cs
- LocatorPart.cs
- CatalogZone.cs
- Vector3D.cs
- XmlName.cs
- CustomAttributeSerializer.cs
- CommonDialog.cs
- JoinCqlBlock.cs
- EntityDataSourceWrapper.cs
- Misc.cs
- NamespaceInfo.cs
- RoutedEventArgs.cs
- VBCodeProvider.cs
- ReadOnlyDictionary.cs
- SerializationAttributes.cs
- ParseHttpDate.cs
- PeerToPeerException.cs
- TableItemStyle.cs
- SystemTcpConnection.cs
- ConfigurationStrings.cs
- SyndicationElementExtensionCollection.cs
- DesignerActionUI.cs
- DrawingContextDrawingContextWalker.cs
- BaseCodePageEncoding.cs
- TextBox.cs
- RepeatBehavior.cs
- AddressAlreadyInUseException.cs
- MiniConstructorInfo.cs
- TypeResolvingOptionsAttribute.cs
- SourceChangedEventArgs.cs
- PersonalizationProviderHelper.cs
- JournalEntryListConverter.cs
- SessionState.cs
- QualifiedCellIdBoolean.cs
- IconConverter.cs
- SQLDouble.cs
- XmlEncoding.cs
- CornerRadius.cs
- DateTimeParse.cs
- MenuItemBinding.cs
- OutKeywords.cs
- GridViewColumnHeaderAutomationPeer.cs
- DictionaryContent.cs
- MenuCommand.cs
- StructuralCache.cs
- HtmlLabelAdapter.cs