Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / wpf / src / Framework / MS / Internal / AppModel / IconHelper.cs / 1 / IconHelper.cs
//----------------------------------------------------------------------------
//
// File: IconHelper.cs
//
// Description: Static internal class implements utility functions for icon
// implementation for the Window class.
//
// Created: 07/27/05
//
// Copyright (C) 2001 by Microsoft Corporation. All rights reserved.
//
//---------------------------------------------------------------------------
using System;
using System.Security;
using System.Security.Permissions;
using System.Diagnostics;
using System.Collections.ObjectModel;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Windows;
using System.Windows.Interop;
using System.Windows.Media.Imaging;
using System.Windows.Media;
using MS.Internal;
using MS.Internal.PresentationFramework; // SecurityHelper
using MS.Win32;
namespace MS.Internal.AppModel
{
internal static class IconHelper
{
///
/// Critical: This code elevates to unmanaged Code permission
/// TreatAsSafe: There is a demand here
///
///
/// Critical: Since it calls CreateIconHandleFromBitmapFrame
/// TAS: Since it creates icons with known h/w i.e. IconWidth/Height or SmallIconWidth/Height
///
///
/// Critical: Since it calls CreateIconCursor which is SecurityCritical. CreateIconCursor is SecurityCritical b/c
/// it creates bitmaps with the input w/h etc. That width/height is passed by this method using
/// sourceBitmapFrame.Pixel[Width/Height] and is not guarded.
///
///
/// Critical: Critical as this code create a DIB section and writes data to it
///
[SecurityCritical]
internal static NativeMethods.IconHandle CreateIconCursor(
byte[] colorArray,
int width,
int height,
int xHotspot,
int yHotspot,
bool isIcon)
{
NativeMethods.IconHandle returnHandle = new NativeMethods.IconHandle();
// 1. We are going to generate a WIN32 color bitmap which represents the color cursor.
// 2. Then we need to create a monochrome bitmap which is used as the cursor mask.
// 3. At last we create a WIN32 HICON from the above two bitmaps
NativeMethods.BitmapHandle colorBitmap = null;
NativeMethods.BitmapHandle maskBitmap = null;
try
{
// 1) Create the color bitmap using colorArray
// Fill in the header information
NativeMethods.BITMAPINFO bi = new NativeMethods.BITMAPINFO(
width, // width
-height, // A negative value indicates the bitmap is top-down DIB
32 // biBitCount
);
bi.bmiHeader_biCompression = NativeMethods.BI_RGB;
IntPtr bits = IntPtr.Zero;
colorBitmap = MS.Win32.UnsafeNativeMethods.CreateDIBSection(
new HandleRef(null, IntPtr.Zero), // A device context. Pass null in if no DIB_PAL_COLORS is used.
ref bi, // A BITMAPINFO structure which specifies the dimensions and colors.
NativeMethods.DIB_RGB_COLORS, // Specifies the type of data contained in the bmiColors array member of the BITMAPINFO structure
ref bits, // An out Pointer to a variable that receives a pointer to the location of the DIB bit values
IntPtr.Zero, // Handle to a file-mapping object that the function will use to create the DIB. This parameter can be null.
0 // dwOffset. This value is ignored if hSection is NULL
);
if ( colorBitmap.IsInvalid || bits == IntPtr.Zero)
{
// Note we will release the GDI resources in the finally block.
return new NativeMethods.IconHandle(IntPtr.Zero);
}
// Copy the color bits to the win32 bitmap
Marshal.Copy(colorArray, 0, bits, colorArray.Length);
// 2) Now create the mask bitmap which is monochrome
byte[] maskArray = GenerateMaskArray(width, height, colorArray);
Invariant.Assert(maskArray != null);
maskBitmap = UnsafeNativeMethods.CreateBitmap(width, height, 1, 1, maskArray);
if ( maskBitmap.IsInvalid )
{
// Note we will release the GDI resources in the finally block.
return new NativeMethods.IconHandle(IntPtr.Zero);
}
// Now create HICON from two bitmaps.
NativeMethods.ICONINFO iconInfo = new NativeMethods.ICONINFO();
iconInfo.fIcon = isIcon; // fIcon == ture means creating an Icon, otherwise Cursor
iconInfo.xHotspot = xHotspot;
iconInfo.yHotspot = yHotspot;
iconInfo.hbmMask = maskBitmap;
iconInfo.hbmColor = colorBitmap;
returnHandle = UnsafeNativeMethods.CreateIconIndirect(iconInfo);
if ( returnHandle.IsInvalid )
{
// Note we will release the GDI resources in the finally block.
return new NativeMethods.IconHandle(IntPtr.Zero);
}
}
finally
{
if (colorBitmap != null)
{
colorBitmap.Dispose();
colorBitmap = null;
}
if (maskBitmap != null)
{
maskBitmap.Dispose();
maskBitmap = null;
}
}
return returnHandle;
}
// generates the mask array for the input colorArray.
// The mask array is 1 bpp
private static byte[] GenerateMaskArray(int width, int height, byte[] colorArray)
{
int nCount = width * height;
// NOTICE-2005/04/26-WAYNEZEN,
// Check out the notes in CreateBitmap in MSDN. The scan line has to be aliged to WORD.
int bytesPerScanLine = AlignToBytes(width, 2) / 8;
byte[] bitsMask = new byte[bytesPerScanLine * height];
// We are scaning all pixels in color bitmap.
// If the alpha value is 0, we should set the corresponding mask bit to 1. So the pixel will show
// the screen pixel. Otherwise, we should set the mask bit to 0 which causes the cursor to display
// the color bitmap pixel.
for ( int i = 0; i < nCount; i++ )
{
// Get the i-th pixel position (hPos, vPos)
int hPos = i % width;
int vPos = i / width;
// For each byte in 2-bit color bitmap, the lowest the bit represents the right-most display pixel.
// For example the bollow mask -
// 1 1 1 0 0 0 0 1
// ^ ^
// offsetBit = 0x80 offsetBit = 0x01
int byteIndex = hPos / 8;
byte offsetBit = (byte)( 0x80 >> ( hPos % 8 ) );
// Now we turn the mask on or off accordingly.
if ( colorArray[i * 4 + 3] /* Alpha value since it's in Args32 Format */ == 0x00 )
{
// Set the mask bit to 1.
bitsMask[byteIndex + bytesPerScanLine * vPos] |= (byte)offsetBit;
}
else
{
// Reset the mask bit to 0
bitsMask[byteIndex + bytesPerScanLine * vPos] &= (byte)( ~offsetBit );
}
// Since the scan line of the mask bitmap has to be aligned to word. We have set all padding bits to 1.
// So the extra pixel can be seen through.
if ( hPos == width - 1 && width == 8 )
{
bitsMask[1 + bytesPerScanLine * vPos] = 0xff;
}
}
return bitsMask;
}
///
/// Calculate the bits count aligned to N-Byte based on the input count
///
/// The original value
/// N-Byte
/// the nearest bit count which is aligned to N-Byte
internal static int AlignToBytes(double original, int nBytesCount)
{
Debug.Assert(nBytesCount > 0, "The N-Byte has to be greater than 0!");
int nBitsCount = 8 << (nBytesCount - 1);
return (((int)Math.Ceiling(original) + (nBitsCount - 1)) / nBitsCount) * nBitsCount;
}
// returns the current system bit depth -- incdicates the # of
// colors that can be shown.
//
// Code taken from WinForms implementation of selecting
// which icon frame to use
///
/// Critical: Calls GetDC, ReleaseDC and GetDeviceCaps that are marked SecurityCritical
/// TreatAsSafe: It is okay to return the current system bit depth
///
[SecurityCritical, SecurityTreatAsSafe]
private static int GetSystemBitDepth(object callerObj)
{
int sysBitDepth = 0;
HandleRef handleRefDC;
HandleRef handleRefZero = new HandleRef(callerObj, IntPtr.Zero);
IntPtr dc = UnsafeNativeMethods.GetDC(handleRefZero);
handleRefDC = new HandleRef(callerObj, dc);
sysBitDepth = UnsafeNativeMethods.GetDeviceCaps(handleRefDC, NativeMethods.BITSPIXEL);
sysBitDepth *= UnsafeNativeMethods.GetDeviceCaps(handleRefDC, NativeMethods.PLANES);
UnsafeNativeMethods.ReleaseDC(handleRefZero, handleRefDC);
return sysBitDepth;
}
// returns the index of the frame that best matches the given width, height and the current
// system bit depth.
//
// This code is taken from Winforms implementation of choosing the correct frame based on the
// requirements.
//
// Windows rules for specifing an icon:
//
// 1. The icon with the closest size match.
// 2. For matching sizes, the image with the closest bit depth.
// 3. If there is no color depth match, the icon with the closest color depth that does not exceed the display.
// 4. If all icon color depth > display, lowest color depth is chosen.
// 5. color depth of > 8bpp are all equal.
// 6. Never choose an 8bpp icon on an 8bpp system.
//
///
/// Critical: Calls LinkDemand property BitsPerPixel
/// TreatAsSafe: The bits per pixel info is not revealed/returned
///
[SecurityCritical, SecurityTreatAsSafe]
private static int GetBestMatch(ReadOnlyCollection frames, int sysBitDepth, int width, int height)
{
Invariant.Assert(width != 0, "input param width should not be zero");
Invariant.Assert(height != 0, "input param height should not be zero");
// If the _sysBitDepth is 8, make it 4. Why? Because windows does not
// choose a 256 color icon if the display is running in 256 color mode
// because of palette flicker.
//
if (sysBitDepth == 8)
{
sysBitDepth = 4;
}
int bestWidth = 0;
int bestHeight = 0;
int bestBitDepth = 0;
int bestIndex = 0;
int bestDelta = 0;
bool isBitmapIconDecoder = frames.Count > 0 && frames[0].Decoder is IconBitmapDecoder;
// iterate each frame to see if this one is a better match than the
// previous best match
for (int i = 0; i < frames.Count; i++)
{
bool updateBestFit = false;
int currentWidth = frames[i].PixelWidth;
int currentHeight = frames[i].PixelHeight;
int currentIconBitDepth = 0;
// determine the bit-depth (# of colors) in the
// current frame
//
// if the icon is palettized, Format.BitsPerPixel gives
// the # of bits required to index into the palette (thus,
// the # of colors in the palette). If it is a true
// color icon, it gives the # of bits required to support
// true colors.
// For icons, get the Format from the Thumbnail rather than from the
// BitmapFrame directly because the unmanaged icon decoder
// converts every icon to 32-bit. Thumbnail.Format.BitsPerPixel
// will give us the original bit depth.
currentIconBitDepth = isBitmapIconDecoder ? frames[i].Thumbnail.Format.BitsPerPixel : frames[i].Format.BitsPerPixel;
// it looks like if nothing is specified at this point, bpp is 8...
// straight from WinForm and Win32
if (currentIconBitDepth == 0)
{
currentIconBitDepth = 8;
}
// Windows rules for specifing an icon:
//
// 1. The icon with the closest size match.
// 2. For matching sizes, the image with the closest bit depth.
// 3. If there is no color depth match, the icon with the closest color depth that does not exceed the display.
// 4. If all icon color depth > display, lowest color depth is chosen.
// 5. color depth of > 8bpp are all equal.
// 6. Never choose an 8bpp icon on an 8bpp system.
//
// for the first index, don't have anything to compare against so pick it
if (i == 0)
{
updateBestFit = true;
}
else
{
int thisDelta = Math.Abs(currentWidth - width) + Math.Abs(currentHeight - height);
if ((thisDelta < bestDelta) ||
(thisDelta == bestDelta && (currentIconBitDepth <= sysBitDepth && currentIconBitDepth > bestBitDepth || bestBitDepth > sysBitDepth && currentIconBitDepth < bestBitDepth)))
{
updateBestFit = true;
}
}
if (updateBestFit)
{
bestWidth = currentWidth;
bestHeight = currentHeight;
bestBitDepth = currentIconBitDepth;
bestIndex = i;
bestDelta = Math.Abs(currentWidth - width) + Math.Abs(currentHeight - height);
}
}
return bestIndex;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
//
// File: IconHelper.cs
//
// Description: Static internal class implements utility functions for icon
// implementation for the Window class.
//
// Created: 07/27/05
//
// Copyright (C) 2001 by Microsoft Corporation. All rights reserved.
//
//---------------------------------------------------------------------------
using System;
using System.Security;
using System.Security.Permissions;
using System.Diagnostics;
using System.Collections.ObjectModel;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Windows;
using System.Windows.Interop;
using System.Windows.Media.Imaging;
using System.Windows.Media;
using MS.Internal;
using MS.Internal.PresentationFramework; // SecurityHelper
using MS.Win32;
namespace MS.Internal.AppModel
{
internal static class IconHelper
{
///
/// Critical: This code elevates to unmanaged Code permission
/// TreatAsSafe: There is a demand here
///
///
/// Critical: Since it calls CreateIconHandleFromBitmapFrame
/// TAS: Since it creates icons with known h/w i.e. IconWidth/Height or SmallIconWidth/Height
///
///
/// Critical: Since it calls CreateIconCursor which is SecurityCritical. CreateIconCursor is SecurityCritical b/c
/// it creates bitmaps with the input w/h etc. That width/height is passed by this method using
/// sourceBitmapFrame.Pixel[Width/Height] and is not guarded.
///
///
/// Critical: Critical as this code create a DIB section and writes data to it
///
[SecurityCritical]
internal static NativeMethods.IconHandle CreateIconCursor(
byte[] colorArray,
int width,
int height,
int xHotspot,
int yHotspot,
bool isIcon)
{
NativeMethods.IconHandle returnHandle = new NativeMethods.IconHandle();
// 1. We are going to generate a WIN32 color bitmap which represents the color cursor.
// 2. Then we need to create a monochrome bitmap which is used as the cursor mask.
// 3. At last we create a WIN32 HICON from the above two bitmaps
NativeMethods.BitmapHandle colorBitmap = null;
NativeMethods.BitmapHandle maskBitmap = null;
try
{
// 1) Create the color bitmap using colorArray
// Fill in the header information
NativeMethods.BITMAPINFO bi = new NativeMethods.BITMAPINFO(
width, // width
-height, // A negative value indicates the bitmap is top-down DIB
32 // biBitCount
);
bi.bmiHeader_biCompression = NativeMethods.BI_RGB;
IntPtr bits = IntPtr.Zero;
colorBitmap = MS.Win32.UnsafeNativeMethods.CreateDIBSection(
new HandleRef(null, IntPtr.Zero), // A device context. Pass null in if no DIB_PAL_COLORS is used.
ref bi, // A BITMAPINFO structure which specifies the dimensions and colors.
NativeMethods.DIB_RGB_COLORS, // Specifies the type of data contained in the bmiColors array member of the BITMAPINFO structure
ref bits, // An out Pointer to a variable that receives a pointer to the location of the DIB bit values
IntPtr.Zero, // Handle to a file-mapping object that the function will use to create the DIB. This parameter can be null.
0 // dwOffset. This value is ignored if hSection is NULL
);
if ( colorBitmap.IsInvalid || bits == IntPtr.Zero)
{
// Note we will release the GDI resources in the finally block.
return new NativeMethods.IconHandle(IntPtr.Zero);
}
// Copy the color bits to the win32 bitmap
Marshal.Copy(colorArray, 0, bits, colorArray.Length);
// 2) Now create the mask bitmap which is monochrome
byte[] maskArray = GenerateMaskArray(width, height, colorArray);
Invariant.Assert(maskArray != null);
maskBitmap = UnsafeNativeMethods.CreateBitmap(width, height, 1, 1, maskArray);
if ( maskBitmap.IsInvalid )
{
// Note we will release the GDI resources in the finally block.
return new NativeMethods.IconHandle(IntPtr.Zero);
}
// Now create HICON from two bitmaps.
NativeMethods.ICONINFO iconInfo = new NativeMethods.ICONINFO();
iconInfo.fIcon = isIcon; // fIcon == ture means creating an Icon, otherwise Cursor
iconInfo.xHotspot = xHotspot;
iconInfo.yHotspot = yHotspot;
iconInfo.hbmMask = maskBitmap;
iconInfo.hbmColor = colorBitmap;
returnHandle = UnsafeNativeMethods.CreateIconIndirect(iconInfo);
if ( returnHandle.IsInvalid )
{
// Note we will release the GDI resources in the finally block.
return new NativeMethods.IconHandle(IntPtr.Zero);
}
}
finally
{
if (colorBitmap != null)
{
colorBitmap.Dispose();
colorBitmap = null;
}
if (maskBitmap != null)
{
maskBitmap.Dispose();
maskBitmap = null;
}
}
return returnHandle;
}
// generates the mask array for the input colorArray.
// The mask array is 1 bpp
private static byte[] GenerateMaskArray(int width, int height, byte[] colorArray)
{
int nCount = width * height;
// NOTICE-2005/04/26-WAYNEZEN,
// Check out the notes in CreateBitmap in MSDN. The scan line has to be aliged to WORD.
int bytesPerScanLine = AlignToBytes(width, 2) / 8;
byte[] bitsMask = new byte[bytesPerScanLine * height];
// We are scaning all pixels in color bitmap.
// If the alpha value is 0, we should set the corresponding mask bit to 1. So the pixel will show
// the screen pixel. Otherwise, we should set the mask bit to 0 which causes the cursor to display
// the color bitmap pixel.
for ( int i = 0; i < nCount; i++ )
{
// Get the i-th pixel position (hPos, vPos)
int hPos = i % width;
int vPos = i / width;
// For each byte in 2-bit color bitmap, the lowest the bit represents the right-most display pixel.
// For example the bollow mask -
// 1 1 1 0 0 0 0 1
// ^ ^
// offsetBit = 0x80 offsetBit = 0x01
int byteIndex = hPos / 8;
byte offsetBit = (byte)( 0x80 >> ( hPos % 8 ) );
// Now we turn the mask on or off accordingly.
if ( colorArray[i * 4 + 3] /* Alpha value since it's in Args32 Format */ == 0x00 )
{
// Set the mask bit to 1.
bitsMask[byteIndex + bytesPerScanLine * vPos] |= (byte)offsetBit;
}
else
{
// Reset the mask bit to 0
bitsMask[byteIndex + bytesPerScanLine * vPos] &= (byte)( ~offsetBit );
}
// Since the scan line of the mask bitmap has to be aligned to word. We have set all padding bits to 1.
// So the extra pixel can be seen through.
if ( hPos == width - 1 && width == 8 )
{
bitsMask[1 + bytesPerScanLine * vPos] = 0xff;
}
}
return bitsMask;
}
///
/// Calculate the bits count aligned to N-Byte based on the input count
///
/// The original value
/// N-Byte
/// the nearest bit count which is aligned to N-Byte
internal static int AlignToBytes(double original, int nBytesCount)
{
Debug.Assert(nBytesCount > 0, "The N-Byte has to be greater than 0!");
int nBitsCount = 8 << (nBytesCount - 1);
return (((int)Math.Ceiling(original) + (nBitsCount - 1)) / nBitsCount) * nBitsCount;
}
// returns the current system bit depth -- incdicates the # of
// colors that can be shown.
//
// Code taken from WinForms implementation of selecting
// which icon frame to use
///
/// Critical: Calls GetDC, ReleaseDC and GetDeviceCaps that are marked SecurityCritical
/// TreatAsSafe: It is okay to return the current system bit depth
///
[SecurityCritical, SecurityTreatAsSafe]
private static int GetSystemBitDepth(object callerObj)
{
int sysBitDepth = 0;
HandleRef handleRefDC;
HandleRef handleRefZero = new HandleRef(callerObj, IntPtr.Zero);
IntPtr dc = UnsafeNativeMethods.GetDC(handleRefZero);
handleRefDC = new HandleRef(callerObj, dc);
sysBitDepth = UnsafeNativeMethods.GetDeviceCaps(handleRefDC, NativeMethods.BITSPIXEL);
sysBitDepth *= UnsafeNativeMethods.GetDeviceCaps(handleRefDC, NativeMethods.PLANES);
UnsafeNativeMethods.ReleaseDC(handleRefZero, handleRefDC);
return sysBitDepth;
}
// returns the index of the frame that best matches the given width, height and the current
// system bit depth.
//
// This code is taken from Winforms implementation of choosing the correct frame based on the
// requirements.
//
// Windows rules for specifing an icon:
//
// 1. The icon with the closest size match.
// 2. For matching sizes, the image with the closest bit depth.
// 3. If there is no color depth match, the icon with the closest color depth that does not exceed the display.
// 4. If all icon color depth > display, lowest color depth is chosen.
// 5. color depth of > 8bpp are all equal.
// 6. Never choose an 8bpp icon on an 8bpp system.
//
///
/// Critical: Calls LinkDemand property BitsPerPixel
/// TreatAsSafe: The bits per pixel info is not revealed/returned
///
[SecurityCritical, SecurityTreatAsSafe]
private static int GetBestMatch(ReadOnlyCollection frames, int sysBitDepth, int width, int height)
{
Invariant.Assert(width != 0, "input param width should not be zero");
Invariant.Assert(height != 0, "input param height should not be zero");
// If the _sysBitDepth is 8, make it 4. Why? Because windows does not
// choose a 256 color icon if the display is running in 256 color mode
// because of palette flicker.
//
if (sysBitDepth == 8)
{
sysBitDepth = 4;
}
int bestWidth = 0;
int bestHeight = 0;
int bestBitDepth = 0;
int bestIndex = 0;
int bestDelta = 0;
bool isBitmapIconDecoder = frames.Count > 0 && frames[0].Decoder is IconBitmapDecoder;
// iterate each frame to see if this one is a better match than the
// previous best match
for (int i = 0; i < frames.Count; i++)
{
bool updateBestFit = false;
int currentWidth = frames[i].PixelWidth;
int currentHeight = frames[i].PixelHeight;
int currentIconBitDepth = 0;
// determine the bit-depth (# of colors) in the
// current frame
//
// if the icon is palettized, Format.BitsPerPixel gives
// the # of bits required to index into the palette (thus,
// the # of colors in the palette). If it is a true
// color icon, it gives the # of bits required to support
// true colors.
// For icons, get the Format from the Thumbnail rather than from the
// BitmapFrame directly because the unmanaged icon decoder
// converts every icon to 32-bit. Thumbnail.Format.BitsPerPixel
// will give us the original bit depth.
currentIconBitDepth = isBitmapIconDecoder ? frames[i].Thumbnail.Format.BitsPerPixel : frames[i].Format.BitsPerPixel;
// it looks like if nothing is specified at this point, bpp is 8...
// straight from WinForm and Win32
if (currentIconBitDepth == 0)
{
currentIconBitDepth = 8;
}
// Windows rules for specifing an icon:
//
// 1. The icon with the closest size match.
// 2. For matching sizes, the image with the closest bit depth.
// 3. If there is no color depth match, the icon with the closest color depth that does not exceed the display.
// 4. If all icon color depth > display, lowest color depth is chosen.
// 5. color depth of > 8bpp are all equal.
// 6. Never choose an 8bpp icon on an 8bpp system.
//
// for the first index, don't have anything to compare against so pick it
if (i == 0)
{
updateBestFit = true;
}
else
{
int thisDelta = Math.Abs(currentWidth - width) + Math.Abs(currentHeight - height);
if ((thisDelta < bestDelta) ||
(thisDelta == bestDelta && (currentIconBitDepth <= sysBitDepth && currentIconBitDepth > bestBitDepth || bestBitDepth > sysBitDepth && currentIconBitDepth < bestBitDepth)))
{
updateBestFit = true;
}
}
if (updateBestFit)
{
bestWidth = currentWidth;
bestHeight = currentHeight;
bestBitDepth = currentIconBitDepth;
bestIndex = i;
bestDelta = Math.Abs(currentWidth - width) + Math.Abs(currentHeight - height);
}
}
return bestIndex;
}
}
}
// 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
- HostingEnvironment.cs
- EntityObject.cs
- ISO2022Encoding.cs
- AccessDataSource.cs
- BamlLocalizableResourceKey.cs
- pingexception.cs
- CompilerScopeManager.cs
- FunctionImportMapping.cs
- SqlCacheDependencyDatabase.cs
- FormattedText.cs
- TextEmbeddedObject.cs
- DecodeHelper.cs
- AnnotationMap.cs
- Rfc2898DeriveBytes.cs
- TextContainerChangedEventArgs.cs
- BufferedMessageWriter.cs
- ContextProperty.cs
- DocumentXmlWriter.cs
- SerializationException.cs
- NamespaceDecl.cs
- PlatformNotSupportedException.cs
- JpegBitmapEncoder.cs
- SmtpNetworkElement.cs
- IntellisenseTextBox.cs
- ScriptResourceMapping.cs
- UIElementHelper.cs
- MonthChangedEventArgs.cs
- ComponentEditorPage.cs
- OracleParameterCollection.cs
- SqlMethodCallConverter.cs
- ProxySimple.cs
- XmlBindingWorker.cs
- ClockGroup.cs
- WindowsEditBox.cs
- SyndicationDeserializer.cs
- UrlAuthorizationModule.cs
- ISAPIApplicationHost.cs
- NullableDoubleSumAggregationOperator.cs
- DbParameterCollectionHelper.cs
- InkCollectionBehavior.cs
- OpenFileDialog.cs
- ACL.cs
- PreviewControlDesigner.cs
- PropertyDescriptorGridEntry.cs
- ErrorHandler.cs
- WsdlInspector.cs
- FloaterBaseParaClient.cs
- XPathAncestorIterator.cs
- DataService.cs
- WebPartRestoreVerb.cs
- DesignerActionList.cs
- ScrollBar.cs
- StatusBarPanelClickEvent.cs
- UriParserTemplates.cs
- FileLevelControlBuilderAttribute.cs
- WaitHandleCannotBeOpenedException.cs
- TickBar.cs
- GlobalEventManager.cs
- TransformedBitmap.cs
- ErrorWrapper.cs
- DbParameterHelper.cs
- ExpressionBuilder.cs
- ThaiBuddhistCalendar.cs
- HttpModuleAction.cs
- SchemaComplexType.cs
- MenuItem.cs
- DocumentAutomationPeer.cs
- CommandCollectionEditor.cs
- ConfigurationManagerHelper.cs
- VersionConverter.cs
- HttpWriter.cs
- ApplicationBuildProvider.cs
- UnauthorizedAccessException.cs
- GB18030Encoding.cs
- ProcessHostFactoryHelper.cs
- View.cs
- IdentityHolder.cs
- WebPartPersonalization.cs
- SafeSecurityHandles.cs
- SyndicationFeed.cs
- XamlTreeBuilderBamlRecordWriter.cs
- DrawingContextDrawingContextWalker.cs
- XmlSiteMapProvider.cs
- SQLUtility.cs
- TemplateLookupAction.cs
- AtomMaterializerLog.cs
- MembershipPasswordException.cs
- ListDictionaryInternal.cs
- HttpFileCollection.cs
- ComponentTray.cs
- PriorityBindingExpression.cs
- DataGridViewColumn.cs
- XmlSchemaDatatype.cs
- ExpressionPrefixAttribute.cs
- ObjectResult.cs
- ExcCanonicalXml.cs
- XamlStream.cs
- XmlAtomicValue.cs
- PenThreadWorker.cs
- MultiPartWriter.cs