Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / wpf / src / Core / CSharp / MS / Internal / Shaping / latinshape.cs / 1 / latinshape.cs
//+------------------------------------------------------------------------
//
// Microsoft Windows Client Platform
// Copyright (C) Microsoft Corporation, 2001
//
// File: LatinShape.cs
//
// Contents: Combining marks/ Latin OT shaping engine
//
// Contact: nbeal
//
// Created: 10-21-2003
//
//-----------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using MS.Internal;
using MS.Internal.FontCache;
using System.Security;
using System.Security.Permissions;
using System.Windows.Media;
using System.Windows.Media.TextFormatting;
namespace MS.Internal.Shaping
{
///
/// The Latin/Cyrillic/Greek Shaping Engine - (shapes Latin text)
///
///
/// The IShaper and IShapingEngine interfaces are implemented to
/// provide the shaping methods for Latin/Cyrillic/Greek Scripts.
/// This engine incorporates combining marks shaping, which is
/// not dependent on the font being OpenType.
///
internal class LatinShape : BaseShape
{
#region Data members
//
// See static LatinShape() constructor for notes and initialization.
//
// Two-dimensional array [_combiningCharsIndexesTableLength][_combiningCharsIndexesTableSegmentLength]
///
/// Critical - Holds a pointer object
///
[SecurityCritical]
private unsafe static readonly ushort* _combiningCharsIndexes;
private static readonly int _combiningCharsIndexesTableLength;
private static readonly int _combiningCharsIndexesTableSegmentLength;
///
/// Critical - Holds a pointer object
///
[SecurityCritical]
private unsafe static readonly ushort* _combiningMarkIndexes;
private static readonly int _combiningMarkIndexesTableLength;
///
/// Critical - Holds a pointer object
///
[SecurityCritical]
private unsafe static readonly char* _combiningChars;
private static readonly int _combiningCharsBaseCount;
private static readonly int _combiningCharsMarkCount;
private static readonly ScriptTags[] _supportedScripts;
const char InvalidCombinationChar = '\u0000';
const ushort InvalidBaseIndex = 0;
const ushort InvalidMarkIndex = 0xffff;
#endregion
//--------------------------------------
//
// Constructors
//
//--------------------------------------
#region Constructors
///
/// Critical -This code calls into unsafe code and stores pointers
/// Safe - This constructor doesn't expose any of the unsafe pointers.
///
[SecurityCritical, SecurityTreatAsSafe]
unsafe static LatinShape()
{
Classification.CombiningMarksClassificationData classification;
Classification.GetCombiningMarksClassificationData(out classification);
_combiningCharsIndexes = (ushort*)classification.CombiningCharsIndexes;
_combiningCharsIndexesTableLength = classification.CombiningCharsIndexesTableLength;
_combiningCharsIndexesTableSegmentLength = classification.CombiningCharsIndexesTableSegmentLength;
_combiningMarkIndexes = (ushort*)classification.CombiningMarkIndexes;
_combiningMarkIndexesTableLength = classification.CombiningMarkIndexesTableLength;
_combiningChars = (char*)classification.CombinationChars;
_combiningCharsBaseCount = classification.CombinationCharsBaseCount;
_combiningCharsMarkCount = classification.CombinationCharsMarkCount;
_supportedScripts = new ScriptTags[]
{
ScriptTags.Armenian,
ScriptTags.Bopomofo,
ScriptTags.Braille,
ScriptTags.Buhid, // *
ScriptTags.CanadianSyllabics,
ScriptTags.Cherokee,
ScriptTags.CJKIdeographic,
ScriptTags.Coptic,
ScriptTags.Cyrillic,
ScriptTags.Ethiopic,
ScriptTags.Georgian,
ScriptTags.Glagolitic,
ScriptTags.Greek,
ScriptTags.Hanunoo, // *
ScriptTags.Hiragana,
// ScriptTags.Katakana, // this is here for reference only - tag has same value as "Hiragana"
ScriptTags.Latin,
ScriptTags.Ogham,
ScriptTags.Runic,
ScriptTags.Tagalog, // *
ScriptTags.Tagbanwa, // *
ScriptTags.TaiLe,
ScriptTags.Tifinagh,
ScriptTags.Yi
// * For V2 Philippine scripts will require separate engine
// to handle combining marks in case of incorrect input
};
}
///
/// Constructor for the Latin Open Type Shaping Engine.
///
internal LatinShape()
{
}
#endregion
//--------------------------------------
//
// Internal Methods
//
//--------------------------------------
#region Internal methods
///
/// HebrewShape.SupportedScripts -
/// IShapingEngine member override
///
/// Our supported scripts (Hebrew, Thaana).
public override ScriptTags[] SupportedScripts
{
get { return _supportedScripts; }
}
///
/// LatinShape.OnLoadFont - IShapingEngine method override.
///
///
/// We override the base implementation because this shaper
/// has work to do even if the font doesn't support our
/// script. (Combining marks support is not OpenType feature
/// dependent)
///
/// Script of interest.
/// Font face being loaded
/// font specific info for the shaper
/// True if font supports script.
///
/// Critical - This method reads into raw font table bits.
/// Safe - This method doesn't expose any critical data.
///
[SecurityCritical, SecurityTreatAsSafe]
public override bool OnLoadFont(
ScriptTags scriptTag,
GlyphTypeface fontFace,
out object shapeFontFaceInfo
)
{
// Create a font client for this script. (LatinShape doesn't have
// its own CharClassifier and will support fonts that have no OpenType
// script support, so use the "no OT support" constructor...
ShaperFontClient fontClient = new ShaperFontClient(fontFace);
// Now check if script support does exist in font
if (OpenTypeLayout.FindScript(fontClient,(uint)scriptTag) != TagInfoFlags.None)
{
fontClient.IsScriptSupportedByFont = true;
}
// we don't care if script support is in font cause we support
// combining marks even if the font doesn't support our script,
// so we always return "true"
shapeFontFaceInfo = fontClient;
return true;
}
///
/// LatinShape.GetGlyphs - Latin implementation of the GetGlyphs() helper function.
///
/// shaping currentRun
/// Text item
/// number of glyphs
///
/// Critical - calls critical code, unsafe code
///
[SecurityCritical]
unsafe protected override int GetGlyphs ( ref ShapingWorkspace currentRun, Item item )
{
// no pre-substitution shaping, just cmap lookup.
ushort currGlyph;
CharShapeInfo currShape;
ushort marksCount;
while ( GetNextGlyph (ref currentRun, out currGlyph, out currShape, out marksCount) )
{
if (marksCount < 2)
{
currentRun.SetGlyphPropertiesUsingGlyph(currShape, currGlyph);
}
else
{
// we need to replace the base glyph (already added) with
// this new composite glyph
currentRun.PreviousGlyph = currGlyph;
currentRun.AddLigatureChars(-1,marksCount);
}
}
return currentRun.GlyphsCount;
}
#endregion
//--------------------------------------
//
// Private Methods
//
//--------------------------------------
#region Combining mark methods
///
/// Index of the mark char in the combination lookup table
///
///
/// Critical - Dereferences a pointer which is stored without any validation
/// Safe - This method returns classification data which is safe.
///
[SecurityCritical, SecurityTreatAsSafe]
private unsafe ushort GetMarkIndex(char markChar)
{
int markCharCode = markChar-0x300;
if (markCharCode<0 || markCharCode>=_combiningMarkIndexesTableLength) return InvalidMarkIndex;
return _combiningMarkIndexes[markCharCode];
}
///
/// Critical - Dereferences a pointer which is stored without any validation
/// Safe - This method returns classification data which is safe.
///
[SecurityCritical, SecurityTreatAsSafe]
private unsafe ushort GetBaseIndex(char baseChar)
{
ushort baseCharCode = (ushort)baseChar;
ushort secondLevelIndex = _combiningCharsIndexes[ //0 * _combiningCharsIndexesTableLength + :first segment
baseCharCode/_combiningCharsIndexesTableSegmentLength];
Invariant.Assert(secondLevelIndex < _combiningCharsIndexesTableLength);
return _combiningCharsIndexes[secondLevelIndex*_combiningCharsIndexesTableSegmentLength +
baseCharCode%_combiningCharsIndexesTableSegmentLength];
}
///
/// Get combination character from combination lookup table
///
///
/// Critical - Dereferences a pointer which is stored without any validation
/// Safe - This method returns classification data which is safe.
///
[SecurityCritical, SecurityTreatAsSafe]
private unsafe char GetCombinationChar(ushort baseCharCode, ushort markCharCode)
{
Invariant.Assert(baseCharCode < _combiningCharsBaseCount && markCharCode < _combiningCharsMarkCount);
return _combiningChars[baseCharCode*_combiningCharsMarkCount + markCharCode];
}
///
/// Critical - Uses unsafe accessors/functions
///
[SecurityCritical]
private unsafe bool GetNextGlyph( ref ShapingWorkspace currentRun,
out ushort currGlyph,
out CharShapeInfo currShape,
out ushort marksCount )
{
// assume this isn't a combining mark (good assumption)
marksCount = 0;
char currChar;
bool isNextValid = currentRun.GetNextCharProperties (out currChar, out currGlyph, out currShape);
if ( isNextValid )
{
ushort markIndex = GetMarkIndex( currChar );
if ( markIndex != InvalidMarkIndex && (currShape & CharShapeInfo.IsUnicodeLayoutControl) == 0)
{
marksCount=1; // this is a valid mark (it may form a combination)
currShape = CharShapeInfo.NoFlagsSet; // this is a combining mark
ushort baseIndex = GetBaseIndex(currentRun.PreviousChar);
if (baseIndex != InvalidBaseIndex)
{
// base is a base, so check for combination char
char baseAndMarkOneChar=GetCombinationChar(baseIndex,markIndex);
ushort baseAndMarkOneGlyph = currentRun.CharConverter.ToGlyph(baseAndMarkOneChar);
if ( baseAndMarkOneGlyph != 0 )
{
// base + mark form a combination char. Let's see if we're
// lucky (can we use the next char(s) to form a combination
// char?)
ushort markTwoIndex = GetMarkIndex(currentRun.GetChar((ushort)(currentRun.CurrentCharIx + 1)));
if (markTwoIndex == InvalidMarkIndex)
{
// nope, the next char isn't a mark, so we're done (we found a
// glyph for this combination char)
marksCount = 2;
currShape |= CharShapeInfo.IsStartOfCluster;
currGlyph = baseAndMarkOneGlyph;
}
else
{
// next char is a mark, does it form a combination?
ushort baseAndMarkOneIndex = GetBaseIndex(baseAndMarkOneChar);
char baseAndBothMarksChar = GetCombinationChar(baseAndMarkOneIndex, markTwoIndex);
if (baseAndBothMarksChar != InvalidCombinationChar)
{
// base + both marks does form a combination char. Does
// font have the right glyph?
ushort baseAndBothMarksGlyph = currentRun.CharConverter.ToGlyph(baseAndBothMarksChar);
if (baseAndBothMarksGlyph != 0)
{
// we have a winner! ("base + 2 marks" has a glyph) If there's not yet
// another mark in the character stream, send the combo glyph back. If
// there is another mark, don't send combo glyph.
ushort markThreeIndex = GetMarkIndex(currentRun.GetChar((ushort)(currentRun.CurrentCharIx + 2)));
if (markThreeIndex == InvalidMarkIndex)
{
marksCount = 3;
currShape |= CharShapeInfo.IsStartOfCluster;
currGlyph = baseAndBothMarksGlyph;
}
}
}
}
}
}
}
}
return isNextValid;
}
#endregion
}
}
// 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: LatinShape.cs
//
// Contents: Combining marks/ Latin OT shaping engine
//
// Contact: nbeal
//
// Created: 10-21-2003
//
//-----------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using MS.Internal;
using MS.Internal.FontCache;
using System.Security;
using System.Security.Permissions;
using System.Windows.Media;
using System.Windows.Media.TextFormatting;
namespace MS.Internal.Shaping
{
///
/// The Latin/Cyrillic/Greek Shaping Engine - (shapes Latin text)
///
///
/// The IShaper and IShapingEngine interfaces are implemented to
/// provide the shaping methods for Latin/Cyrillic/Greek Scripts.
/// This engine incorporates combining marks shaping, which is
/// not dependent on the font being OpenType.
///
internal class LatinShape : BaseShape
{
#region Data members
//
// See static LatinShape() constructor for notes and initialization.
//
// Two-dimensional array [_combiningCharsIndexesTableLength][_combiningCharsIndexesTableSegmentLength]
///
/// Critical - Holds a pointer object
///
[SecurityCritical]
private unsafe static readonly ushort* _combiningCharsIndexes;
private static readonly int _combiningCharsIndexesTableLength;
private static readonly int _combiningCharsIndexesTableSegmentLength;
///
/// Critical - Holds a pointer object
///
[SecurityCritical]
private unsafe static readonly ushort* _combiningMarkIndexes;
private static readonly int _combiningMarkIndexesTableLength;
///
/// Critical - Holds a pointer object
///
[SecurityCritical]
private unsafe static readonly char* _combiningChars;
private static readonly int _combiningCharsBaseCount;
private static readonly int _combiningCharsMarkCount;
private static readonly ScriptTags[] _supportedScripts;
const char InvalidCombinationChar = '\u0000';
const ushort InvalidBaseIndex = 0;
const ushort InvalidMarkIndex = 0xffff;
#endregion
//--------------------------------------
//
// Constructors
//
//--------------------------------------
#region Constructors
///
/// Critical -This code calls into unsafe code and stores pointers
/// Safe - This constructor doesn't expose any of the unsafe pointers.
///
[SecurityCritical, SecurityTreatAsSafe]
unsafe static LatinShape()
{
Classification.CombiningMarksClassificationData classification;
Classification.GetCombiningMarksClassificationData(out classification);
_combiningCharsIndexes = (ushort*)classification.CombiningCharsIndexes;
_combiningCharsIndexesTableLength = classification.CombiningCharsIndexesTableLength;
_combiningCharsIndexesTableSegmentLength = classification.CombiningCharsIndexesTableSegmentLength;
_combiningMarkIndexes = (ushort*)classification.CombiningMarkIndexes;
_combiningMarkIndexesTableLength = classification.CombiningMarkIndexesTableLength;
_combiningChars = (char*)classification.CombinationChars;
_combiningCharsBaseCount = classification.CombinationCharsBaseCount;
_combiningCharsMarkCount = classification.CombinationCharsMarkCount;
_supportedScripts = new ScriptTags[]
{
ScriptTags.Armenian,
ScriptTags.Bopomofo,
ScriptTags.Braille,
ScriptTags.Buhid, // *
ScriptTags.CanadianSyllabics,
ScriptTags.Cherokee,
ScriptTags.CJKIdeographic,
ScriptTags.Coptic,
ScriptTags.Cyrillic,
ScriptTags.Ethiopic,
ScriptTags.Georgian,
ScriptTags.Glagolitic,
ScriptTags.Greek,
ScriptTags.Hanunoo, // *
ScriptTags.Hiragana,
// ScriptTags.Katakana, // this is here for reference only - tag has same value as "Hiragana"
ScriptTags.Latin,
ScriptTags.Ogham,
ScriptTags.Runic,
ScriptTags.Tagalog, // *
ScriptTags.Tagbanwa, // *
ScriptTags.TaiLe,
ScriptTags.Tifinagh,
ScriptTags.Yi
// * For V2 Philippine scripts will require separate engine
// to handle combining marks in case of incorrect input
};
}
///
/// Constructor for the Latin Open Type Shaping Engine.
///
internal LatinShape()
{
}
#endregion
//--------------------------------------
//
// Internal Methods
//
//--------------------------------------
#region Internal methods
///
/// HebrewShape.SupportedScripts -
/// IShapingEngine member override
///
/// Our supported scripts (Hebrew, Thaana).
public override ScriptTags[] SupportedScripts
{
get { return _supportedScripts; }
}
///
/// LatinShape.OnLoadFont - IShapingEngine method override.
///
///
/// We override the base implementation because this shaper
/// has work to do even if the font doesn't support our
/// script. (Combining marks support is not OpenType feature
/// dependent)
///
/// Script of interest.
/// Font face being loaded
/// font specific info for the shaper
/// True if font supports script.
///
/// Critical - This method reads into raw font table bits.
/// Safe - This method doesn't expose any critical data.
///
[SecurityCritical, SecurityTreatAsSafe]
public override bool OnLoadFont(
ScriptTags scriptTag,
GlyphTypeface fontFace,
out object shapeFontFaceInfo
)
{
// Create a font client for this script. (LatinShape doesn't have
// its own CharClassifier and will support fonts that have no OpenType
// script support, so use the "no OT support" constructor...
ShaperFontClient fontClient = new ShaperFontClient(fontFace);
// Now check if script support does exist in font
if (OpenTypeLayout.FindScript(fontClient,(uint)scriptTag) != TagInfoFlags.None)
{
fontClient.IsScriptSupportedByFont = true;
}
// we don't care if script support is in font cause we support
// combining marks even if the font doesn't support our script,
// so we always return "true"
shapeFontFaceInfo = fontClient;
return true;
}
///
/// LatinShape.GetGlyphs - Latin implementation of the GetGlyphs() helper function.
///
/// shaping currentRun
/// Text item
/// number of glyphs
///
/// Critical - calls critical code, unsafe code
///
[SecurityCritical]
unsafe protected override int GetGlyphs ( ref ShapingWorkspace currentRun, Item item )
{
// no pre-substitution shaping, just cmap lookup.
ushort currGlyph;
CharShapeInfo currShape;
ushort marksCount;
while ( GetNextGlyph (ref currentRun, out currGlyph, out currShape, out marksCount) )
{
if (marksCount < 2)
{
currentRun.SetGlyphPropertiesUsingGlyph(currShape, currGlyph);
}
else
{
// we need to replace the base glyph (already added) with
// this new composite glyph
currentRun.PreviousGlyph = currGlyph;
currentRun.AddLigatureChars(-1,marksCount);
}
}
return currentRun.GlyphsCount;
}
#endregion
//--------------------------------------
//
// Private Methods
//
//--------------------------------------
#region Combining mark methods
///
/// Index of the mark char in the combination lookup table
///
///
/// Critical - Dereferences a pointer which is stored without any validation
/// Safe - This method returns classification data which is safe.
///
[SecurityCritical, SecurityTreatAsSafe]
private unsafe ushort GetMarkIndex(char markChar)
{
int markCharCode = markChar-0x300;
if (markCharCode<0 || markCharCode>=_combiningMarkIndexesTableLength) return InvalidMarkIndex;
return _combiningMarkIndexes[markCharCode];
}
///
/// Critical - Dereferences a pointer which is stored without any validation
/// Safe - This method returns classification data which is safe.
///
[SecurityCritical, SecurityTreatAsSafe]
private unsafe ushort GetBaseIndex(char baseChar)
{
ushort baseCharCode = (ushort)baseChar;
ushort secondLevelIndex = _combiningCharsIndexes[ //0 * _combiningCharsIndexesTableLength + :first segment
baseCharCode/_combiningCharsIndexesTableSegmentLength];
Invariant.Assert(secondLevelIndex < _combiningCharsIndexesTableLength);
return _combiningCharsIndexes[secondLevelIndex*_combiningCharsIndexesTableSegmentLength +
baseCharCode%_combiningCharsIndexesTableSegmentLength];
}
///
/// Get combination character from combination lookup table
///
///
/// Critical - Dereferences a pointer which is stored without any validation
/// Safe - This method returns classification data which is safe.
///
[SecurityCritical, SecurityTreatAsSafe]
private unsafe char GetCombinationChar(ushort baseCharCode, ushort markCharCode)
{
Invariant.Assert(baseCharCode < _combiningCharsBaseCount && markCharCode < _combiningCharsMarkCount);
return _combiningChars[baseCharCode*_combiningCharsMarkCount + markCharCode];
}
///
/// Critical - Uses unsafe accessors/functions
///
[SecurityCritical]
private unsafe bool GetNextGlyph( ref ShapingWorkspace currentRun,
out ushort currGlyph,
out CharShapeInfo currShape,
out ushort marksCount )
{
// assume this isn't a combining mark (good assumption)
marksCount = 0;
char currChar;
bool isNextValid = currentRun.GetNextCharProperties (out currChar, out currGlyph, out currShape);
if ( isNextValid )
{
ushort markIndex = GetMarkIndex( currChar );
if ( markIndex != InvalidMarkIndex && (currShape & CharShapeInfo.IsUnicodeLayoutControl) == 0)
{
marksCount=1; // this is a valid mark (it may form a combination)
currShape = CharShapeInfo.NoFlagsSet; // this is a combining mark
ushort baseIndex = GetBaseIndex(currentRun.PreviousChar);
if (baseIndex != InvalidBaseIndex)
{
// base is a base, so check for combination char
char baseAndMarkOneChar=GetCombinationChar(baseIndex,markIndex);
ushort baseAndMarkOneGlyph = currentRun.CharConverter.ToGlyph(baseAndMarkOneChar);
if ( baseAndMarkOneGlyph != 0 )
{
// base + mark form a combination char. Let's see if we're
// lucky (can we use the next char(s) to form a combination
// char?)
ushort markTwoIndex = GetMarkIndex(currentRun.GetChar((ushort)(currentRun.CurrentCharIx + 1)));
if (markTwoIndex == InvalidMarkIndex)
{
// nope, the next char isn't a mark, so we're done (we found a
// glyph for this combination char)
marksCount = 2;
currShape |= CharShapeInfo.IsStartOfCluster;
currGlyph = baseAndMarkOneGlyph;
}
else
{
// next char is a mark, does it form a combination?
ushort baseAndMarkOneIndex = GetBaseIndex(baseAndMarkOneChar);
char baseAndBothMarksChar = GetCombinationChar(baseAndMarkOneIndex, markTwoIndex);
if (baseAndBothMarksChar != InvalidCombinationChar)
{
// base + both marks does form a combination char. Does
// font have the right glyph?
ushort baseAndBothMarksGlyph = currentRun.CharConverter.ToGlyph(baseAndBothMarksChar);
if (baseAndBothMarksGlyph != 0)
{
// we have a winner! ("base + 2 marks" has a glyph) If there's not yet
// another mark in the character stream, send the combo glyph back. If
// there is another mark, don't send combo glyph.
ushort markThreeIndex = GetMarkIndex(currentRun.GetChar((ushort)(currentRun.CurrentCharIx + 2)));
if (markThreeIndex == InvalidMarkIndex)
{
marksCount = 3;
currShape |= CharShapeInfo.IsStartOfCluster;
currGlyph = baseAndBothMarksGlyph;
}
}
}
}
}
}
}
}
return isNextValid;
}
#endregion
}
}
// 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
- RealizedColumnsBlock.cs
- SchemaInfo.cs
- SerializationInfoEnumerator.cs
- TableRow.cs
- AspNetSynchronizationContext.cs
- CompressionTransform.cs
- HttpCachePolicyElement.cs
- TransformerInfoCollection.cs
- Number.cs
- TabControlCancelEvent.cs
- unitconverter.cs
- PropertyBuilder.cs
- CodeAttachEventStatement.cs
- XmlSchemaNotation.cs
- TabRenderer.cs
- Classification.cs
- AnnotationStore.cs
- XmlUtf8RawTextWriter.cs
- ZoneLinkButton.cs
- UriWriter.cs
- SqlDataSourceView.cs
- BaseCAMarshaler.cs
- ProfileModule.cs
- Lock.cs
- HideDisabledControlAdapter.cs
- Assert.cs
- SqlRemoveConstantOrderBy.cs
- MediaElementAutomationPeer.cs
- SqlCommandSet.cs
- StringReader.cs
- CursorConverter.cs
- ReflectionUtil.cs
- DbInsertCommandTree.cs
- IteratorFilter.cs
- COM2ColorConverter.cs
- RunInstallerAttribute.cs
- FixUp.cs
- HyperLinkColumn.cs
- EventItfInfo.cs
- ListItemsCollectionEditor.cs
- SimpleBitVector32.cs
- DbDataRecord.cs
- TrackingStringDictionary.cs
- CapabilitiesUse.cs
- PropVariant.cs
- OnOperation.cs
- DbProviderManifest.cs
- LocalizableAttribute.cs
- QilLoop.cs
- XmlIlGenerator.cs
- MailBnfHelper.cs
- WindowsComboBox.cs
- UserPreferenceChangingEventArgs.cs
- LazyTextWriterCreator.cs
- HMAC.cs
- CrossContextChannel.cs
- Variant.cs
- ReadWriteSpinLock.cs
- HandleCollector.cs
- CodeParameterDeclarationExpression.cs
- CombinedGeometry.cs
- KeyInstance.cs
- TableStyle.cs
- DataBoundControlAdapter.cs
- MetadataArtifactLoaderCompositeFile.cs
- CircleHotSpot.cs
- TextAdaptor.cs
- ObjectDataSource.cs
- StringHandle.cs
- SoapIncludeAttribute.cs
- BinaryVersion.cs
- ReachIDocumentPaginatorSerializer.cs
- CompilerResults.cs
- CookieParameter.cs
- xmlfixedPageInfo.cs
- CompilerInfo.cs
- WindowsPen.cs
- Assert.cs
- FieldBuilder.cs
- HMACSHA512.cs
- ScaleTransform3D.cs
- XmlDocumentSerializer.cs
- MouseActionValueSerializer.cs
- ExecutedRoutedEventArgs.cs
- NavigateEvent.cs
- Int32.cs
- ContentFilePart.cs
- RelationshipConstraintValidator.cs
- documentsequencetextview.cs
- EncryptedPackageFilter.cs
- RequestSecurityToken.cs
- Int32AnimationBase.cs
- XmlDataSource.cs
- Line.cs
- IdentityHolder.cs
- ManifestResourceInfo.cs
- DiscoveryMessageSequenceCD1.cs
- DBConnectionString.cs
- StylusPoint.cs
- _PooledStream.cs