Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Framework / MS / Internal / PtsHost / ListMarkerSourceInfo.cs / 1305600 / ListMarkerSourceInfo.cs
//----------------------------------------------------------------------------
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
// File: ListMarkerSourceInfo.cs
//
// Information about list markers for different types of list.
// NOTE: This logic depends on the logic used in MS.Internal.TextFormatting.TextMarkerSource.cs
// This file must always be kept up to date with changes in TextMarkerSource
//
//---------------------------------------------------------------------------
using System;
using System.Diagnostics;
using System.Windows;
using System.Windows.Documents; // List
using MS.Internal.Text;
using System.Windows.Media; // FormattedText and Brush
using MS.Internal.TextFormatting; // TextMarkerSource
using System.Text; // StringBuilder
namespace MS.Internal.PtsHost
{
///
/// ListMarkerSourceInfo contains information about list markers for different types of lists
///
internal sealed class ListMarkerSourceInfo
{
///
/// Private constructor to prevent the compiler from generating a default constructor.
///
private ListMarkerSourceInfo()
{
}
///
/// Calculate padding for a list
///
///
/// Specified List element
///
///
/// Line height for list element
///
internal static Thickness CalculatePadding(List list, double lineHeight)
{
FormattedText formattedMarker = GetFormattedMarker(list);
double leftPadding = formattedMarker.Width + 1.5 * lineHeight;
leftPadding = (double)((int)(leftPadding / lineHeight) + 1) * lineHeight;
return new Thickness(leftPadding, 0, 0, 0);
}
///
/// Returns FormattedText for the largets marker in a list
///
///
/// List element for which formatted marker is to be calculated
///
private static FormattedText GetFormattedMarker(List list)
{
string markerString = "";
FormattedText formattedMarker;
if (IsKnownSymbolMarkerStyle(list.MarkerStyle))
{
switch (list.MarkerStyle)
{
case TextMarkerStyle.Disc:
markerString = "\x9f";
break;
case TextMarkerStyle.Circle:
markerString = "\xa1";
break;
case TextMarkerStyle.Square:
markerString = "\x71";
break;
case TextMarkerStyle.Box:
markerString = "\xa7";
break;
}
// Create new formatted text with typeface using a symbol font, e.g. Wingdings
Typeface typeface = DynamicPropertyReader.GetModifiedTypeface(list, new FontFamily("Wingdings"));
formattedMarker = new FormattedText(markerString, DynamicPropertyReader.GetCultureInfo(list), list.FlowDirection,
typeface, list.FontSize, list.Foreground);
}
else if (IsKnownIndexMarkerStyle(list.MarkerStyle))
{
// Assume at least one element will be added and format accordingly
int startIndex = list.StartIndex;
Invariant.Assert(startIndex > 0);
int size = list.ListItems.Count;
int highestIndex;
if (int.MaxValue - size < startIndex)
{
// Highest index will exceed max value of int. Clamp to int.MaxValue
highestIndex = int.MaxValue;
}
else
{
highestIndex = (size == 0) ? startIndex : startIndex + size - 1;
}
switch (list.MarkerStyle)
{
case TextMarkerStyle.Decimal:
markerString = ConvertNumberToString(highestIndex, false, DecimalNumerics);
break;
case TextMarkerStyle.LowerLatin:
markerString = ConvertNumberToString(highestIndex, true, LowerLatinNumerics);
break;
case TextMarkerStyle.UpperLatin:
markerString = ConvertNumberToString(highestIndex, true, UpperLatinNumerics);
break;
case TextMarkerStyle.LowerRoman:
markerString = GetStringForLargestRomanMarker(startIndex, highestIndex, false);
break;
case TextMarkerStyle.UpperRoman:
markerString = GetStringForLargestRomanMarker(startIndex, highestIndex, true);
break;
}
// Create new formatted text using List defaulls
formattedMarker = new FormattedText(markerString, DynamicPropertyReader.GetCultureInfo(list), list.FlowDirection,
DynamicPropertyReader.GetTypeface(list), list.FontSize, list.Foreground);
}
else
{
// Assume a disc
markerString = "\x9f";
// Create new formatted text with typeface using a symbol font, e.g. Wingdings
Typeface typeface = DynamicPropertyReader.GetModifiedTypeface(list, new FontFamily("Wingdings"));
formattedMarker = new FormattedText(markerString, DynamicPropertyReader.GetCultureInfo(list), list.FlowDirection,
typeface, list.FontSize, list.Foreground);
}
return formattedMarker;
}
///
/// Convert a number to string, consisting of digits followed by the NumberSuffix character.
/// From TextMarkerSource, uses same conversion
///
/// 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 string ConvertNumberToString(int number, bool oneBased, string numericSymbols)
{
if (oneBased)
{
// Subtract 1 from 1-based numbers so we can use zero-based indexing
--number;
}
Invariant.Assert(number >= 0);
char[] result;
int b = numericSymbols.Length;
if (number < b)
{
// Optimize common case of single-digit numbers.
// 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.
// 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 new string(result);
}
///
/// Returns string for the largest roman marker in a list with Roman numbering style
///
///
/// Start index of list
///
///
/// Number of elements in the list
///
///
/// True if list uses uppercase mode
///
private static string GetStringForLargestRomanMarker(int startIndex, int highestIndex, bool uppercase)
{
int largestMarkerIndex = 0;
if (highestIndex > 3999)
{
// Roman numerals are 1-based and there is no accepted convention
// for writing numbers larger than 3999. For anything larger than this,
// we assume the largest value under 3999, which is 3888 or
// MMMDCCCLXXXVIII. TextSourceMarker willnot support larger values anyway.
return uppercase ? LargestRomanMarkerUpper : LargestRomanMarkerLower;
}
else
{
largestMarkerIndex = GetIndexForLargestRomanMarker(startIndex, highestIndex);
}
return ConvertNumberToRomanString(largestMarkerIndex, uppercase);
}
///
/// Returns the index of the roman marker that will have largest width, i.e. most letters
///
///
/// Start index of the list
///
///
/// Highest-numbered index in the list
///
private static int GetIndexForLargestRomanMarker(int startIndex, int highestIndex)
{
int largestIndex = 0;
if (startIndex == 1)
{
// Do quick search by looking only at size increments
int thousands = highestIndex / 1000;
highestIndex = highestIndex % 1000;
for (int i = 0; i < RomanNumericSizeIncrements.Length; i++)
{
Invariant.Assert(highestIndex >= RomanNumericSizeIncrements[i]);
if (highestIndex == RomanNumericSizeIncrements[i])
{
// This is the largest index.
largestIndex = highestIndex;
break;
}
else
{
Invariant.Assert(highestIndex > RomanNumericSizeIncrements[i]);
if (i < RomanNumericSizeIncrements.Length - 1)
{
if (highestIndex >= RomanNumericSizeIncrements[i + 1])
{
// Size does not lie within this increment range. Keep searching
continue;
}
}
// Size is either larger than the largest increment value,
// or lies between two increment values in which case we
// take the lower one
largestIndex = RomanNumericSizeIncrements[i];
break;
}
}
if (thousands > 0)
{
// M's will be added to largest index for extra thousands
largestIndex = thousands * 1000 + largestIndex;
}
}
else
{
// Quick search will not work. Look at each index
int largestIndexSize = 0;
for (int i = startIndex; i <= highestIndex; i++)
{
// Format as roman string. It does not matter if we use upper or lowercase formatting here since
// we are only counting number of letters in each string. This is not strictly correct -
// III might be smaller than XX in some fonts - but we cannot format text each time.
string romanString = ConvertNumberToRomanString(i, true);
if (romanString.Length > largestIndexSize)
{
largestIndex = i;
largestIndexSize = romanString.Length;
}
}
}
Invariant.Assert(largestIndex > 0);
return largestIndex;
}
///
/// Convert 1-based number to a Roman numeric string
/// followed by NumberSuffix character.
///
private static string ConvertNumberToRomanString(
int number,
bool uppercase)
{
Invariant.Assert(number <= 3999);
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. From TextMarkerSource
///
/// 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]);
}
}
}
private static bool IsKnownSymbolMarkerStyle(TextMarkerStyle markerStyle)
{
return (
markerStyle == TextMarkerStyle.Disc
|| markerStyle == TextMarkerStyle.Circle
|| markerStyle == TextMarkerStyle.Square
|| markerStyle == TextMarkerStyle.Box
);
}
private static bool IsKnownIndexMarkerStyle(TextMarkerStyle markerStyle)
{
return (
markerStyle == TextMarkerStyle.Decimal
|| markerStyle == TextMarkerStyle.LowerLatin
|| markerStyle == TextMarkerStyle.UpperLatin
|| markerStyle == TextMarkerStyle.LowerRoman
|| markerStyle == TextMarkerStyle.UpperRoman
);
}
// Const values for marker conversion
private static char NumberSuffix = '.';
private static string DecimalNumerics = "0123456789";
private static string LowerLatinNumerics = "abcdefghijklmnopqrstuvwxyz";
private static string UpperLatinNumerics = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
private static string LargestRomanMarkerUpper = "MMMDCCCLXXXVIII";
private static string LargestRomanMarkerLower = "mmmdccclxxxviii";
private static string[][] RomanNumerics = new string[][]
{
new string[] { "m??", "cdm", "xlc", "ivx" },
new string[] { "M??", "CDM", "XLC", "IVX" }
};
private static int[] RomanNumericSizeIncrements =
new int[] { 1, 2, 3, 8, 18, 28, 38, 88, 188, 288, 388, 888 };
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
// File: ListMarkerSourceInfo.cs
//
// Information about list markers for different types of list.
// NOTE: This logic depends on the logic used in MS.Internal.TextFormatting.TextMarkerSource.cs
// This file must always be kept up to date with changes in TextMarkerSource
//
//---------------------------------------------------------------------------
using System;
using System.Diagnostics;
using System.Windows;
using System.Windows.Documents; // List
using MS.Internal.Text;
using System.Windows.Media; // FormattedText and Brush
using MS.Internal.TextFormatting; // TextMarkerSource
using System.Text; // StringBuilder
namespace MS.Internal.PtsHost
{
///
/// ListMarkerSourceInfo contains information about list markers for different types of lists
///
internal sealed class ListMarkerSourceInfo
{
///
/// Private constructor to prevent the compiler from generating a default constructor.
///
private ListMarkerSourceInfo()
{
}
///
/// Calculate padding for a list
///
///
/// Specified List element
///
///
/// Line height for list element
///
internal static Thickness CalculatePadding(List list, double lineHeight)
{
FormattedText formattedMarker = GetFormattedMarker(list);
double leftPadding = formattedMarker.Width + 1.5 * lineHeight;
leftPadding = (double)((int)(leftPadding / lineHeight) + 1) * lineHeight;
return new Thickness(leftPadding, 0, 0, 0);
}
///
/// Returns FormattedText for the largets marker in a list
///
///
/// List element for which formatted marker is to be calculated
///
private static FormattedText GetFormattedMarker(List list)
{
string markerString = "";
FormattedText formattedMarker;
if (IsKnownSymbolMarkerStyle(list.MarkerStyle))
{
switch (list.MarkerStyle)
{
case TextMarkerStyle.Disc:
markerString = "\x9f";
break;
case TextMarkerStyle.Circle:
markerString = "\xa1";
break;
case TextMarkerStyle.Square:
markerString = "\x71";
break;
case TextMarkerStyle.Box:
markerString = "\xa7";
break;
}
// Create new formatted text with typeface using a symbol font, e.g. Wingdings
Typeface typeface = DynamicPropertyReader.GetModifiedTypeface(list, new FontFamily("Wingdings"));
formattedMarker = new FormattedText(markerString, DynamicPropertyReader.GetCultureInfo(list), list.FlowDirection,
typeface, list.FontSize, list.Foreground);
}
else if (IsKnownIndexMarkerStyle(list.MarkerStyle))
{
// Assume at least one element will be added and format accordingly
int startIndex = list.StartIndex;
Invariant.Assert(startIndex > 0);
int size = list.ListItems.Count;
int highestIndex;
if (int.MaxValue - size < startIndex)
{
// Highest index will exceed max value of int. Clamp to int.MaxValue
highestIndex = int.MaxValue;
}
else
{
highestIndex = (size == 0) ? startIndex : startIndex + size - 1;
}
switch (list.MarkerStyle)
{
case TextMarkerStyle.Decimal:
markerString = ConvertNumberToString(highestIndex, false, DecimalNumerics);
break;
case TextMarkerStyle.LowerLatin:
markerString = ConvertNumberToString(highestIndex, true, LowerLatinNumerics);
break;
case TextMarkerStyle.UpperLatin:
markerString = ConvertNumberToString(highestIndex, true, UpperLatinNumerics);
break;
case TextMarkerStyle.LowerRoman:
markerString = GetStringForLargestRomanMarker(startIndex, highestIndex, false);
break;
case TextMarkerStyle.UpperRoman:
markerString = GetStringForLargestRomanMarker(startIndex, highestIndex, true);
break;
}
// Create new formatted text using List defaulls
formattedMarker = new FormattedText(markerString, DynamicPropertyReader.GetCultureInfo(list), list.FlowDirection,
DynamicPropertyReader.GetTypeface(list), list.FontSize, list.Foreground);
}
else
{
// Assume a disc
markerString = "\x9f";
// Create new formatted text with typeface using a symbol font, e.g. Wingdings
Typeface typeface = DynamicPropertyReader.GetModifiedTypeface(list, new FontFamily("Wingdings"));
formattedMarker = new FormattedText(markerString, DynamicPropertyReader.GetCultureInfo(list), list.FlowDirection,
typeface, list.FontSize, list.Foreground);
}
return formattedMarker;
}
///
/// Convert a number to string, consisting of digits followed by the NumberSuffix character.
/// From TextMarkerSource, uses same conversion
///
/// 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 string ConvertNumberToString(int number, bool oneBased, string numericSymbols)
{
if (oneBased)
{
// Subtract 1 from 1-based numbers so we can use zero-based indexing
--number;
}
Invariant.Assert(number >= 0);
char[] result;
int b = numericSymbols.Length;
if (number < b)
{
// Optimize common case of single-digit numbers.
// 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.
// 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 new string(result);
}
///
/// Returns string for the largest roman marker in a list with Roman numbering style
///
///
/// Start index of list
///
///
/// Number of elements in the list
///
///
/// True if list uses uppercase mode
///
private static string GetStringForLargestRomanMarker(int startIndex, int highestIndex, bool uppercase)
{
int largestMarkerIndex = 0;
if (highestIndex > 3999)
{
// Roman numerals are 1-based and there is no accepted convention
// for writing numbers larger than 3999. For anything larger than this,
// we assume the largest value under 3999, which is 3888 or
// MMMDCCCLXXXVIII. TextSourceMarker willnot support larger values anyway.
return uppercase ? LargestRomanMarkerUpper : LargestRomanMarkerLower;
}
else
{
largestMarkerIndex = GetIndexForLargestRomanMarker(startIndex, highestIndex);
}
return ConvertNumberToRomanString(largestMarkerIndex, uppercase);
}
///
/// Returns the index of the roman marker that will have largest width, i.e. most letters
///
///
/// Start index of the list
///
///
/// Highest-numbered index in the list
///
private static int GetIndexForLargestRomanMarker(int startIndex, int highestIndex)
{
int largestIndex = 0;
if (startIndex == 1)
{
// Do quick search by looking only at size increments
int thousands = highestIndex / 1000;
highestIndex = highestIndex % 1000;
for (int i = 0; i < RomanNumericSizeIncrements.Length; i++)
{
Invariant.Assert(highestIndex >= RomanNumericSizeIncrements[i]);
if (highestIndex == RomanNumericSizeIncrements[i])
{
// This is the largest index.
largestIndex = highestIndex;
break;
}
else
{
Invariant.Assert(highestIndex > RomanNumericSizeIncrements[i]);
if (i < RomanNumericSizeIncrements.Length - 1)
{
if (highestIndex >= RomanNumericSizeIncrements[i + 1])
{
// Size does not lie within this increment range. Keep searching
continue;
}
}
// Size is either larger than the largest increment value,
// or lies between two increment values in which case we
// take the lower one
largestIndex = RomanNumericSizeIncrements[i];
break;
}
}
if (thousands > 0)
{
// M's will be added to largest index for extra thousands
largestIndex = thousands * 1000 + largestIndex;
}
}
else
{
// Quick search will not work. Look at each index
int largestIndexSize = 0;
for (int i = startIndex; i <= highestIndex; i++)
{
// Format as roman string. It does not matter if we use upper or lowercase formatting here since
// we are only counting number of letters in each string. This is not strictly correct -
// III might be smaller than XX in some fonts - but we cannot format text each time.
string romanString = ConvertNumberToRomanString(i, true);
if (romanString.Length > largestIndexSize)
{
largestIndex = i;
largestIndexSize = romanString.Length;
}
}
}
Invariant.Assert(largestIndex > 0);
return largestIndex;
}
///
/// Convert 1-based number to a Roman numeric string
/// followed by NumberSuffix character.
///
private static string ConvertNumberToRomanString(
int number,
bool uppercase)
{
Invariant.Assert(number <= 3999);
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. From TextMarkerSource
///
/// 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]);
}
}
}
private static bool IsKnownSymbolMarkerStyle(TextMarkerStyle markerStyle)
{
return (
markerStyle == TextMarkerStyle.Disc
|| markerStyle == TextMarkerStyle.Circle
|| markerStyle == TextMarkerStyle.Square
|| markerStyle == TextMarkerStyle.Box
);
}
private static bool IsKnownIndexMarkerStyle(TextMarkerStyle markerStyle)
{
return (
markerStyle == TextMarkerStyle.Decimal
|| markerStyle == TextMarkerStyle.LowerLatin
|| markerStyle == TextMarkerStyle.UpperLatin
|| markerStyle == TextMarkerStyle.LowerRoman
|| markerStyle == TextMarkerStyle.UpperRoman
);
}
// Const values for marker conversion
private static char NumberSuffix = '.';
private static string DecimalNumerics = "0123456789";
private static string LowerLatinNumerics = "abcdefghijklmnopqrstuvwxyz";
private static string UpperLatinNumerics = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
private static string LargestRomanMarkerUpper = "MMMDCCCLXXXVIII";
private static string LargestRomanMarkerLower = "mmmdccclxxxviii";
private static string[][] RomanNumerics = new string[][]
{
new string[] { "m??", "cdm", "xlc", "ivx" },
new string[] { "M??", "CDM", "XLC", "IVX" }
};
private static int[] RomanNumericSizeIncrements =
new int[] { 1, 2, 3, 8, 18, 28, 38, 88, 188, 288, 388, 888 };
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- Composition.cs
- ConnectionInterfaceCollection.cs
- XmlSchemaElement.cs
- FloaterParaClient.cs
- AppDomainInstanceProvider.cs
- PathFigure.cs
- ListControl.cs
- ListItemDetailViewAttribute.cs
- TypeUsageBuilder.cs
- Scene3D.cs
- Line.cs
- RequestQueryProcessor.cs
- SimpleBitVector32.cs
- Pkcs9Attribute.cs
- TextWriterTraceListener.cs
- ActivityDesigner.cs
- WebServiceReceive.cs
- AppDomainInstanceProvider.cs
- SchemaExporter.cs
- ResourceManager.cs
- HttpApplicationFactory.cs
- ExtenderProviderService.cs
- MappingSource.cs
- SetMemberBinder.cs
- SurrogateSelector.cs
- MetaModel.cs
- PermissionSetTriple.cs
- MarshalByRefObject.cs
- FileUtil.cs
- CollectionContainer.cs
- ComboBoxDesigner.cs
- SelectionList.cs
- UICuesEvent.cs
- ResourceManager.cs
- CompiledQueryCacheEntry.cs
- QilScopedVisitor.cs
- DataGridViewTextBoxCell.cs
- TextBlock.cs
- PreservationFileWriter.cs
- XPathSingletonIterator.cs
- TextFormatterHost.cs
- SafeThemeHandle.cs
- Style.cs
- VisemeEventArgs.cs
- PageParser.cs
- HashCodeCombiner.cs
- HttpDebugHandler.cs
- CompositeFontFamily.cs
- WebPartTransformerAttribute.cs
- BaseParagraph.cs
- ButtonField.cs
- Decimal.cs
- GridLength.cs
- TreeNode.cs
- ProbeMatchesMessageCD1.cs
- ISCIIEncoding.cs
- WebPartsPersonalizationAuthorization.cs
- Int16AnimationUsingKeyFrames.cs
- PageThemeParser.cs
- DataGridViewColumnHeaderCell.cs
- SeekableReadStream.cs
- Point4D.cs
- GridView.cs
- PropertyInfoSet.cs
- DependentTransaction.cs
- UnSafeCharBuffer.cs
- XmlElementCollection.cs
- LinqDataSourceDisposeEventArgs.cs
- nulltextnavigator.cs
- DataGridViewCellStateChangedEventArgs.cs
- CommandConverter.cs
- followingquery.cs
- BulletChrome.cs
- PtsHelper.cs
- SystemResources.cs
- GridPattern.cs
- SystemEvents.cs
- DataPager.cs
- BamlLocalizabilityResolver.cs
- HttpAsyncResult.cs
- CustomTypeDescriptor.cs
- DbInsertCommandTree.cs
- TypeBuilderInstantiation.cs
- MemoryRecordBuffer.cs
- wgx_exports.cs
- BindingList.cs
- XPathMultyIterator.cs
- DataSysAttribute.cs
- MsmqTransportSecurity.cs
- Empty.cs
- TypeUtil.cs
- SafeTimerHandle.cs
- Bitmap.cs
- JulianCalendar.cs
- ActivityCodeDomSerializationManager.cs
- EntityDataSourceContextDisposingEventArgs.cs
- StructuredCompositeActivityDesigner.cs
- DesignerTransactionCloseEvent.cs
- ClassicBorderDecorator.cs
- SHA384.cs