Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / ndp / fx / src / WinForms / Managed / System / WinForms / Screen.cs / 1 / Screen.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
namespace System.Windows.Forms {
using System.Threading;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System;
using System.Drawing;
using System.Windows.Forms;
using System.Collections;
using Microsoft.Win32;
///
///
/// Represents a display device or
/// multiple display devices on a single system.
///
///
public class Screen {
readonly IntPtr hmonitor;
///
/// Bounds of the screen
///
readonly Rectangle bounds;
///
/// Available working area on the screen. This excludes taskbars and other
/// docked windows.
///
private Rectangle workingArea = Rectangle.Empty;
///
/// Set to true if this screen is the primary monitor
///
readonly bool primary;
///
/// Device name associated with this monitor
///
readonly string deviceName;
readonly int bitDepth;
private static object syncLock = new object();//used to lock this class before [....]'ing to SystemEvents
private static int desktopChangedCount = -1;//static counter of desktop size changes
private int currentDesktopChangedCount = -1;//instance-based counter used to invalidate WorkingArea
// This identifier is just for us, so that we don't try to call the multimon
// functions if we just need the primary monitor... this is safer for
// non-multimon OSes.
//
private const int PRIMARY_MONITOR = unchecked((int)0xBAADF00D);
private const int MONITOR_DEFAULTTONULL = 0x00000000;
private const int MONITOR_DEFAULTTOPRIMARY = 0x00000001;
private const int MONITOR_DEFAULTTONEAREST = 0x00000002;
private const int MONITORINFOF_PRIMARY = 0x00000001;
private static bool multiMonitorSupport = (UnsafeNativeMethods.GetSystemMetrics(NativeMethods.SM_CMONITORS) != 0);
private static Screen[] screens;
internal Screen(IntPtr monitor) : this(monitor, IntPtr.Zero) {
}
internal Screen(IntPtr monitor, IntPtr hdc) {
IntPtr screenDC = hdc;
if (!multiMonitorSupport || monitor == (IntPtr)PRIMARY_MONITOR) {
// Single monitor system
//
bounds = SystemInformation.VirtualScreen;
primary = true;
deviceName = "DISPLAY";
}
else {
// MultiMonitor System
// We call the 'A' version of GetMonitorInfoA() because
// the 'W' version just never fills out the struct properly on Win2K.
//
NativeMethods.MONITORINFOEX info = new NativeMethods.MONITORINFOEX();
SafeNativeMethods.GetMonitorInfo(new HandleRef(null, monitor), info);
bounds = Rectangle.FromLTRB(info.rcMonitor.left, info.rcMonitor.top, info.rcMonitor.right, info.rcMonitor.bottom);
primary = ((info.dwFlags & MONITORINFOF_PRIMARY) != 0);
int count = info.szDevice.Length;
while (count > 0 && info.szDevice[count - 1] == (char)0) {
count--;
}
deviceName = new string(info.szDevice);
deviceName = deviceName.TrimEnd((char)0);
if (hdc == IntPtr.Zero) {
screenDC = UnsafeNativeMethods.CreateDC(deviceName);
}
}
hmonitor = monitor;
this.bitDepth = UnsafeNativeMethods.GetDeviceCaps(new HandleRef(null, screenDC), NativeMethods.BITSPIXEL);
this.bitDepth *= UnsafeNativeMethods.GetDeviceCaps(new HandleRef(null, screenDC), NativeMethods.PLANES);
if (hdc != screenDC) {
UnsafeNativeMethods.DeleteDC(new HandleRef(null, screenDC));
}
}
///
///
/// Gets an array of all of the displays on the system.
///
///
public static Screen[] AllScreens {
get {
if (screens == null) {
if (multiMonitorSupport) {
MonitorEnumCallback closure = new MonitorEnumCallback();
NativeMethods.MonitorEnumProc proc = new NativeMethods.MonitorEnumProc(closure.Callback);
IntPtr hdc = UnsafeNativeMethods.GetDC(NativeMethods.NullHandleRef);
try {
SafeNativeMethods.EnumDisplayMonitors(new HandleRef(null, hdc), null, proc, IntPtr.Zero);
}
finally {
UnsafeNativeMethods.ReleaseDC(NativeMethods.NullHandleRef, new HandleRef(null, hdc));
}
if (closure.screens.Count > 0) {
Screen[] temp = new Screen[closure.screens.Count];
closure.screens.CopyTo(temp, 0);
screens = temp;
}
else {
screens = new Screen[] {new Screen((IntPtr)PRIMARY_MONITOR)};
}
}
else {
screens = new Screen[] {PrimaryScreen};
}
// Now that we have our screens, attach a display setting changed
// event so that we know when to invalidate them.
//
SystemEvents.DisplaySettingsChanging += new EventHandler(OnDisplaySettingsChanging);
}
return screens;
}
}
///
///
/// Gets Bits per Pixel value.
///
///
public int BitsPerPixel {
get {
return bitDepth;
}
}
///
///
/// Gets the bounds of the display.
///
///
public Rectangle Bounds {
get {
return bounds;
}
}
///
///
/// Gets the device name associated with a display.
///
///
public string DeviceName {
get {
return deviceName;
}
}
///
///
/// Gets a value indicating whether a particular display is
/// the primary device.
///
///
public bool Primary {
get {
return primary;
}
}
///
///
/// Gets the
/// primary display.
///
///
public static Screen PrimaryScreen {
get {
if (multiMonitorSupport) {
Screen[] screens = AllScreens;
for (int i=0; i
///
/// Gets the working area of the screen.
///
///
public Rectangle WorkingArea {
get {
//if the static Screen class has a different desktop change count
//than this instance then update the count and recalculate our working area
if (currentDesktopChangedCount != Screen.DesktopChangedCount) {
Interlocked.Exchange(ref currentDesktopChangedCount, Screen.DesktopChangedCount);
if (!multiMonitorSupport ||hmonitor == (IntPtr)PRIMARY_MONITOR) {
// Single monitor system
//
workingArea = SystemInformation.WorkingArea;
}
else {
// MultiMonitor System
// We call the 'A' version of GetMonitorInfoA() because
// the 'W' version just never fills out the struct properly on Win2K.
//
NativeMethods.MONITORINFOEX info = new NativeMethods.MONITORINFOEX();
SafeNativeMethods.GetMonitorInfo(new HandleRef(null, hmonitor), info);
workingArea = Rectangle.FromLTRB(info.rcWork.left, info.rcWork.top, info.rcWork.right, info.rcWork.bottom);
}
}
return workingArea;
}
}
///
/// Screen instances call this property to determine
/// if their WorkingArea cache needs to be invalidated.
///
private static int DesktopChangedCount {
get {
if (desktopChangedCount == -1) {
lock (syncLock) {
//now that we have a lock, verify (again) our changecount...
if (desktopChangedCount == -1) {
//[....] the UserPreference.Desktop change event. We'll keep count
//of desktop changes so that the WorkingArea property on Screen
//instances know when to invalidate their cache.
SystemEvents.UserPreferenceChanged += new UserPreferenceChangedEventHandler(OnUserPreferenceChanged);
desktopChangedCount = 0;
}
}
}
return desktopChangedCount;
}
}
///
///
/// Specifies a value that indicates whether the specified object is equal to
/// this one.
///
///
public override bool Equals(object obj) {
if (obj is Screen) {
Screen comp = (Screen)obj;
if (hmonitor == comp.hmonitor) {
return true;
}
}
return false;
}
///
///
/// Retrieves a
///
public static Screen FromPoint(Point point) {
if (multiMonitorSupport) {
NativeMethods.POINTSTRUCT pt = new NativeMethods.POINTSTRUCT(point.X, point.Y);
return new Screen(SafeNativeMethods.MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST));
}
else {
return new Screen((IntPtr)PRIMARY_MONITOR);
}
}
///
///
/// Retrieves a
///
public static Screen FromRectangle(Rectangle rect) {
if (multiMonitorSupport) {
NativeMethods.RECT rc = NativeMethods.RECT.FromXYWH(rect.X, rect.Y, rect.Width, rect.Height);
return new Screen(SafeNativeMethods.MonitorFromRect(ref rc, MONITOR_DEFAULTTONEAREST));
}
else {
return new Screen((IntPtr)PRIMARY_MONITOR, IntPtr.Zero);
}
}
///
///
/// Retrieves a
///
public static Screen FromControl(Control control) {
return FromHandleInternal(control.Handle);
}
///
///
/// Retrieves a
///
public static Screen FromHandle(IntPtr hwnd) {
Debug.WriteLineIf(IntSecurity.SecurityDemand.TraceVerbose, "ObjectFromWin32Handle Demanded");
IntSecurity.ObjectFromWin32Handle.Demand();
return FromHandleInternal(hwnd);
}
internal static Screen FromHandleInternal(IntPtr hwnd) {
if (multiMonitorSupport) {
return new Screen(SafeNativeMethods.MonitorFromWindow(new HandleRef(null, hwnd), MONITOR_DEFAULTTONEAREST));
}
else {
return new Screen((IntPtr)PRIMARY_MONITOR, IntPtr.Zero);
}
}
///
///
/// Retrieves the working area for the monitor that is closest to the
/// specified point.
///
///
///
public static Rectangle GetWorkingArea(Point pt) {
return Screen.FromPoint(pt).WorkingArea;
}
///
///
/// Retrieves the working area for the monitor that contains the largest region
/// of the specified rectangle.
///
///
///
public static Rectangle GetWorkingArea(Rectangle rect) {
return Screen.FromRectangle(rect).WorkingArea;
}
///
///
/// Retrieves the working area for the monitor that contains the largest
/// region of the specified control.
///
///
///
public static Rectangle GetWorkingArea(Control ctl) {
return Screen.FromControl(ctl).WorkingArea;
}
///
///
/// Retrieves the bounds of the monitor that is closest to the specified
/// point.
///
///
public static Rectangle GetBounds(Point pt) {
return Screen.FromPoint(pt).Bounds;
}
///
///
/// Retrieves the bounds of the monitor that contains the largest region of the
/// specified rectangle.
///
///
public static Rectangle GetBounds(Rectangle rect) {
return Screen.FromRectangle(rect).Bounds;
}
///
///
/// Retrieves the bounds of the monitor
/// that contains the largest region of the specified control.
///
///
public static Rectangle GetBounds(Control ctl) {
return Screen.FromControl(ctl).Bounds;
}
///
///
/// Computes and retrieves a hash code for an object.
///
///
public override int GetHashCode() {
return(int)hmonitor;
}
///
/// Called by the SystemEvents class when our display settings are
/// changing. We cache screen information and at this point we must
/// invalidate our cache.
///
private static void OnDisplaySettingsChanging(object sender, EventArgs e) {
// Now that we've responded to this event, we don't need it again until
// someone re-queries. We will re-add the event at that time.
//
SystemEvents.DisplaySettingsChanging -= new EventHandler(OnDisplaySettingsChanging);
// Display settings changed, so the set of screens we have is invalid.
//
screens = null;
}
///
/// Called by the SystemEvents class when our display settings have
/// changed. Here, we increment a static counter that Screen instances
/// can check against to invalidate their cache.
///
private static void OnUserPreferenceChanged(object sender, UserPreferenceChangedEventArgs e) {
if (e.Category == UserPreferenceCategory.Desktop) {
Interlocked.Increment(ref desktopChangedCount);
}
}
///
///
/// Retrieves a string representing this object.
///
///
public override string ToString() {
return GetType().Name + "[Bounds=" + bounds.ToString() + " WorkingArea=" + WorkingArea.ToString() + " Primary=" + primary.ToString() + " DeviceName=" + deviceName;
}
///
///
private class MonitorEnumCallback {
public ArrayList screens = new ArrayList();
public virtual bool Callback(IntPtr monitor, IntPtr hdc, IntPtr lprcMonitor, IntPtr lparam) {
screens.Add(new Screen(monitor, hdc));
return true;
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
namespace System.Windows.Forms {
using System.Threading;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System;
using System.Drawing;
using System.Windows.Forms;
using System.Collections;
using Microsoft.Win32;
///
///
/// Represents a display device or
/// multiple display devices on a single system.
///
///
public class Screen {
readonly IntPtr hmonitor;
///
/// Bounds of the screen
///
readonly Rectangle bounds;
///
/// Available working area on the screen. This excludes taskbars and other
/// docked windows.
///
private Rectangle workingArea = Rectangle.Empty;
///
/// Set to true if this screen is the primary monitor
///
readonly bool primary;
///
/// Device name associated with this monitor
///
readonly string deviceName;
readonly int bitDepth;
private static object syncLock = new object();//used to lock this class before [....]'ing to SystemEvents
private static int desktopChangedCount = -1;//static counter of desktop size changes
private int currentDesktopChangedCount = -1;//instance-based counter used to invalidate WorkingArea
// This identifier is just for us, so that we don't try to call the multimon
// functions if we just need the primary monitor... this is safer for
// non-multimon OSes.
//
private const int PRIMARY_MONITOR = unchecked((int)0xBAADF00D);
private const int MONITOR_DEFAULTTONULL = 0x00000000;
private const int MONITOR_DEFAULTTOPRIMARY = 0x00000001;
private const int MONITOR_DEFAULTTONEAREST = 0x00000002;
private const int MONITORINFOF_PRIMARY = 0x00000001;
private static bool multiMonitorSupport = (UnsafeNativeMethods.GetSystemMetrics(NativeMethods.SM_CMONITORS) != 0);
private static Screen[] screens;
internal Screen(IntPtr monitor) : this(monitor, IntPtr.Zero) {
}
internal Screen(IntPtr monitor, IntPtr hdc) {
IntPtr screenDC = hdc;
if (!multiMonitorSupport || monitor == (IntPtr)PRIMARY_MONITOR) {
// Single monitor system
//
bounds = SystemInformation.VirtualScreen;
primary = true;
deviceName = "DISPLAY";
}
else {
// MultiMonitor System
// We call the 'A' version of GetMonitorInfoA() because
// the 'W' version just never fills out the struct properly on Win2K.
//
NativeMethods.MONITORINFOEX info = new NativeMethods.MONITORINFOEX();
SafeNativeMethods.GetMonitorInfo(new HandleRef(null, monitor), info);
bounds = Rectangle.FromLTRB(info.rcMonitor.left, info.rcMonitor.top, info.rcMonitor.right, info.rcMonitor.bottom);
primary = ((info.dwFlags & MONITORINFOF_PRIMARY) != 0);
int count = info.szDevice.Length;
while (count > 0 && info.szDevice[count - 1] == (char)0) {
count--;
}
deviceName = new string(info.szDevice);
deviceName = deviceName.TrimEnd((char)0);
if (hdc == IntPtr.Zero) {
screenDC = UnsafeNativeMethods.CreateDC(deviceName);
}
}
hmonitor = monitor;
this.bitDepth = UnsafeNativeMethods.GetDeviceCaps(new HandleRef(null, screenDC), NativeMethods.BITSPIXEL);
this.bitDepth *= UnsafeNativeMethods.GetDeviceCaps(new HandleRef(null, screenDC), NativeMethods.PLANES);
if (hdc != screenDC) {
UnsafeNativeMethods.DeleteDC(new HandleRef(null, screenDC));
}
}
///
///
/// Gets an array of all of the displays on the system.
///
///
public static Screen[] AllScreens {
get {
if (screens == null) {
if (multiMonitorSupport) {
MonitorEnumCallback closure = new MonitorEnumCallback();
NativeMethods.MonitorEnumProc proc = new NativeMethods.MonitorEnumProc(closure.Callback);
IntPtr hdc = UnsafeNativeMethods.GetDC(NativeMethods.NullHandleRef);
try {
SafeNativeMethods.EnumDisplayMonitors(new HandleRef(null, hdc), null, proc, IntPtr.Zero);
}
finally {
UnsafeNativeMethods.ReleaseDC(NativeMethods.NullHandleRef, new HandleRef(null, hdc));
}
if (closure.screens.Count > 0) {
Screen[] temp = new Screen[closure.screens.Count];
closure.screens.CopyTo(temp, 0);
screens = temp;
}
else {
screens = new Screen[] {new Screen((IntPtr)PRIMARY_MONITOR)};
}
}
else {
screens = new Screen[] {PrimaryScreen};
}
// Now that we have our screens, attach a display setting changed
// event so that we know when to invalidate them.
//
SystemEvents.DisplaySettingsChanging += new EventHandler(OnDisplaySettingsChanging);
}
return screens;
}
}
///
///
/// Gets Bits per Pixel value.
///
///
public int BitsPerPixel {
get {
return bitDepth;
}
}
///
///
/// Gets the bounds of the display.
///
///
public Rectangle Bounds {
get {
return bounds;
}
}
///
///
/// Gets the device name associated with a display.
///
///
public string DeviceName {
get {
return deviceName;
}
}
///
///
/// Gets a value indicating whether a particular display is
/// the primary device.
///
///
public bool Primary {
get {
return primary;
}
}
///
///
/// Gets the
/// primary display.
///
///
public static Screen PrimaryScreen {
get {
if (multiMonitorSupport) {
Screen[] screens = AllScreens;
for (int i=0; i
///
/// Gets the working area of the screen.
///
///
public Rectangle WorkingArea {
get {
//if the static Screen class has a different desktop change count
//than this instance then update the count and recalculate our working area
if (currentDesktopChangedCount != Screen.DesktopChangedCount) {
Interlocked.Exchange(ref currentDesktopChangedCount, Screen.DesktopChangedCount);
if (!multiMonitorSupport ||hmonitor == (IntPtr)PRIMARY_MONITOR) {
// Single monitor system
//
workingArea = SystemInformation.WorkingArea;
}
else {
// MultiMonitor System
// We call the 'A' version of GetMonitorInfoA() because
// the 'W' version just never fills out the struct properly on Win2K.
//
NativeMethods.MONITORINFOEX info = new NativeMethods.MONITORINFOEX();
SafeNativeMethods.GetMonitorInfo(new HandleRef(null, hmonitor), info);
workingArea = Rectangle.FromLTRB(info.rcWork.left, info.rcWork.top, info.rcWork.right, info.rcWork.bottom);
}
}
return workingArea;
}
}
///
/// Screen instances call this property to determine
/// if their WorkingArea cache needs to be invalidated.
///
private static int DesktopChangedCount {
get {
if (desktopChangedCount == -1) {
lock (syncLock) {
//now that we have a lock, verify (again) our changecount...
if (desktopChangedCount == -1) {
//[....] the UserPreference.Desktop change event. We'll keep count
//of desktop changes so that the WorkingArea property on Screen
//instances know when to invalidate their cache.
SystemEvents.UserPreferenceChanged += new UserPreferenceChangedEventHandler(OnUserPreferenceChanged);
desktopChangedCount = 0;
}
}
}
return desktopChangedCount;
}
}
///
///
/// Specifies a value that indicates whether the specified object is equal to
/// this one.
///
///
public override bool Equals(object obj) {
if (obj is Screen) {
Screen comp = (Screen)obj;
if (hmonitor == comp.hmonitor) {
return true;
}
}
return false;
}
///
///
/// Retrieves a
///
public static Screen FromPoint(Point point) {
if (multiMonitorSupport) {
NativeMethods.POINTSTRUCT pt = new NativeMethods.POINTSTRUCT(point.X, point.Y);
return new Screen(SafeNativeMethods.MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST));
}
else {
return new Screen((IntPtr)PRIMARY_MONITOR);
}
}
///
///
/// Retrieves a
///
public static Screen FromRectangle(Rectangle rect) {
if (multiMonitorSupport) {
NativeMethods.RECT rc = NativeMethods.RECT.FromXYWH(rect.X, rect.Y, rect.Width, rect.Height);
return new Screen(SafeNativeMethods.MonitorFromRect(ref rc, MONITOR_DEFAULTTONEAREST));
}
else {
return new Screen((IntPtr)PRIMARY_MONITOR, IntPtr.Zero);
}
}
///
///
/// Retrieves a
///
public static Screen FromControl(Control control) {
return FromHandleInternal(control.Handle);
}
///
///
/// Retrieves a
///
public static Screen FromHandle(IntPtr hwnd) {
Debug.WriteLineIf(IntSecurity.SecurityDemand.TraceVerbose, "ObjectFromWin32Handle Demanded");
IntSecurity.ObjectFromWin32Handle.Demand();
return FromHandleInternal(hwnd);
}
internal static Screen FromHandleInternal(IntPtr hwnd) {
if (multiMonitorSupport) {
return new Screen(SafeNativeMethods.MonitorFromWindow(new HandleRef(null, hwnd), MONITOR_DEFAULTTONEAREST));
}
else {
return new Screen((IntPtr)PRIMARY_MONITOR, IntPtr.Zero);
}
}
///
///
/// Retrieves the working area for the monitor that is closest to the
/// specified point.
///
///
///
public static Rectangle GetWorkingArea(Point pt) {
return Screen.FromPoint(pt).WorkingArea;
}
///
///
/// Retrieves the working area for the monitor that contains the largest region
/// of the specified rectangle.
///
///
///
public static Rectangle GetWorkingArea(Rectangle rect) {
return Screen.FromRectangle(rect).WorkingArea;
}
///
///
/// Retrieves the working area for the monitor that contains the largest
/// region of the specified control.
///
///
///
public static Rectangle GetWorkingArea(Control ctl) {
return Screen.FromControl(ctl).WorkingArea;
}
///
///
/// Retrieves the bounds of the monitor that is closest to the specified
/// point.
///
///
public static Rectangle GetBounds(Point pt) {
return Screen.FromPoint(pt).Bounds;
}
///
///
/// Retrieves the bounds of the monitor that contains the largest region of the
/// specified rectangle.
///
///
public static Rectangle GetBounds(Rectangle rect) {
return Screen.FromRectangle(rect).Bounds;
}
///
///
/// Retrieves the bounds of the monitor
/// that contains the largest region of the specified control.
///
///
public static Rectangle GetBounds(Control ctl) {
return Screen.FromControl(ctl).Bounds;
}
///
///
/// Computes and retrieves a hash code for an object.
///
///
public override int GetHashCode() {
return(int)hmonitor;
}
///
/// Called by the SystemEvents class when our display settings are
/// changing. We cache screen information and at this point we must
/// invalidate our cache.
///
private static void OnDisplaySettingsChanging(object sender, EventArgs e) {
// Now that we've responded to this event, we don't need it again until
// someone re-queries. We will re-add the event at that time.
//
SystemEvents.DisplaySettingsChanging -= new EventHandler(OnDisplaySettingsChanging);
// Display settings changed, so the set of screens we have is invalid.
//
screens = null;
}
///
/// Called by the SystemEvents class when our display settings have
/// changed. Here, we increment a static counter that Screen instances
/// can check against to invalidate their cache.
///
private static void OnUserPreferenceChanged(object sender, UserPreferenceChangedEventArgs e) {
if (e.Category == UserPreferenceCategory.Desktop) {
Interlocked.Increment(ref desktopChangedCount);
}
}
///
///
/// Retrieves a string representing this object.
///
///
public override string ToString() {
return GetType().Name + "[Bounds=" + bounds.ToString() + " WorkingArea=" + WorkingArea.ToString() + " Primary=" + primary.ToString() + " DeviceName=" + deviceName;
}
///
///
private class MonitorEnumCallback {
public ArrayList screens = new ArrayList();
public virtual bool Callback(IntPtr monitor, IntPtr hdc, IntPtr lprcMonitor, IntPtr lparam) {
screens.Add(new Screen(monitor, hdc));
return true;
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- MetadataCollection.cs
- DataGridViewSelectedRowCollection.cs
- EntitySetBaseCollection.cs
- PreservationFileWriter.cs
- ColumnWidthChangingEvent.cs
- MimeMultiPart.cs
- TraceListeners.cs
- filewebrequest.cs
- ModulesEntry.cs
- PathFigureCollection.cs
- Int32Rect.cs
- DataFormats.cs
- StorageConditionPropertyMapping.cs
- TransactionFlowBindingElement.cs
- DesignerProperties.cs
- RenderDataDrawingContext.cs
- XPathEmptyIterator.cs
- DbExpressionVisitor_TResultType.cs
- TrackingMemoryStreamFactory.cs
- Bidi.cs
- XmlElementAttribute.cs
- ConstNode.cs
- HyperLinkDesigner.cs
- DependencyObject.cs
- ExeConfigurationFileMap.cs
- ShaperBuffers.cs
- GridViewRowEventArgs.cs
- BinaryFormatterWriter.cs
- GregorianCalendar.cs
- QuaternionRotation3D.cs
- Tag.cs
- WebPartsPersonalization.cs
- NGCSerializer.cs
- FlowLayoutSettings.cs
- CodeDOMUtility.cs
- StringCollection.cs
- VirtualizingStackPanel.cs
- PathNode.cs
- XmlSerializationReader.cs
- COM2ColorConverter.cs
- FacetValues.cs
- PageCodeDomTreeGenerator.cs
- MimeFormatter.cs
- TileBrush.cs
- PageTheme.cs
- ZipQueryOperator.cs
- ArraySet.cs
- SimpleLine.cs
- FrameworkContentElementAutomationPeer.cs
- StateBag.cs
- OutgoingWebResponseContext.cs
- FileIOPermission.cs
- TabControlCancelEvent.cs
- DropTarget.cs
- ValidationResult.cs
- DataTemplateKey.cs
- SslStreamSecurityBindingElement.cs
- SelectionItemPattern.cs
- Button.cs
- DetailsViewUpdatedEventArgs.cs
- PiiTraceSource.cs
- ControlBuilder.cs
- BezierSegment.cs
- SrgsElement.cs
- ErrorItem.cs
- ParsedAttributeCollection.cs
- LabelLiteral.cs
- ProfileInfo.cs
- WebControl.cs
- DataListAutoFormat.cs
- HttpAsyncResult.cs
- StringPropertyBuilder.cs
- MobileControlsSection.cs
- RtfToXamlReader.cs
- ObjectDataProvider.cs
- DelegatingTypeDescriptionProvider.cs
- WizardDesigner.cs
- DataGridViewEditingControlShowingEventArgs.cs
- DataGridViewSortCompareEventArgs.cs
- WebPartUserCapability.cs
- XmlStreamStore.cs
- NullableDecimalAverageAggregationOperator.cs
- DisposableCollectionWrapper.cs
- GlobalizationAssembly.cs
- Typeface.cs
- OleDbParameter.cs
- DateTimeConverter.cs
- dbenumerator.cs
- MarshalByRefObject.cs
- DataGridTable.cs
- Registry.cs
- ConstructorExpr.cs
- NgenServicingAttributes.cs
- HttpRequestBase.cs
- TextRangeEditLists.cs
- MultipleViewPatternIdentifiers.cs
- ProtectedConfigurationProviderCollection.cs
- CleanUpVirtualizedItemEventArgs.cs
- ExceptionUtil.cs
- DataStreamFromComStream.cs