Code:
/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Core / System / Windows / Ink / DrawingAttributes.cs / 1 / DrawingAttributes.cs
//------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------
using MS.Utility;
using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Media;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.Collections;
using System.Diagnostics;
using MS.Internal;
using MS.Internal.Ink;
using MS.Internal.Ink.InkSerializedFormat;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
namespace System.Windows.Ink
{
///
/// DrawingAttributes is the list of attributes applied to an ink stroke
/// when it is drawn. The DrawingAttributes controls stroke color, width,
/// transparency, and more.
///
///
/// Note that when saving the DrawingAttributes, the V1 AntiAlias attribute
/// is always set, and on load the AntiAlias property is ignored.
///
public class DrawingAttributes : INotifyPropertyChanged
{
#region Constructors
///
/// Creates a DrawingAttributes with default values
///
public DrawingAttributes()
{
_extendedProperties = new ExtendedPropertyCollection();
Initialize();
}
///
/// Internal only constructor that initializes a DA with an EPC
///
///
internal DrawingAttributes(ExtendedPropertyCollection extendedProperties)
{
System.Diagnostics.Debug.Assert(extendedProperties != null);
_extendedProperties = extendedProperties;
Initialize();
}
///
/// Common constructor call, also called by Clone
///
private void Initialize()
{
System.Diagnostics.Debug.Assert(_extendedProperties != null);
_extendedProperties.Changed +=
new ExtendedPropertiesChangedEventHandler(this.ExtendedPropertiesChanged_EventForwarder);
}
#endregion Constructors
#region Public Properties
///
/// The color of the Stroke
///
public Color Color
{
get
{
//prevent boxing / unboxing if possible
if (!_extendedProperties.Contains(KnownIds.Color))
{
Debug.Assert(Colors.Black == (Color)GetDefaultDrawingAttributeValue(KnownIds.Color));
return Colors.Black;
}
return (Color)GetExtendedPropertyBackedProperty(KnownIds.Color);
}
set
{
//no need to raise change events, they will bubble up from the EPC
//underneath us
// Validation of value is done in EPC
SetExtendedPropertyBackedProperty(KnownIds.Color, value);
}
}
///
/// The StylusTip used to draw the stroke
///
public StylusTip StylusTip
{
get
{
//prevent boxing / unboxing if possible
if (!_extendedProperties.Contains(KnownIds.StylusTip))
{
Debug.Assert(StylusTip.Ellipse == (StylusTip)GetDefaultDrawingAttributeValue(KnownIds.StylusTip));
return StylusTip.Ellipse;
}
else
{
//if we ever add to StylusTip enumeration, we need to just return GetExtendedPropertyBackedProperty
Debug.Assert(StylusTip.Rectangle == (StylusTip)GetExtendedPropertyBackedProperty(KnownIds.StylusTip));
return StylusTip.Rectangle;
}
}
set
{
//no need to raise change events, they will bubble up from the EPC
//underneath us
// Validation of value is done in EPC
SetExtendedPropertyBackedProperty(KnownIds.StylusTip, value);
}
}
///
/// The StylusTip used to draw the stroke
///
public Matrix StylusTipTransform
{
get
{
//prevent boxing / unboxing if possible
if (!_extendedProperties.Contains(KnownIds.StylusTipTransform))
{
Debug.Assert(Matrix.Identity == (Matrix)GetDefaultDrawingAttributeValue(KnownIds.StylusTipTransform));
return Matrix.Identity;
}
return (Matrix)GetExtendedPropertyBackedProperty(KnownIds.StylusTipTransform);
}
set
{
Matrix m = (Matrix) value;
if (m.OffsetX != 0 || m.OffsetY != 0)
{
throw new ArgumentException(SR.Get(SRID.InvalidSttValue), "value");
}
//no need to raise change events, they will bubble up from the EPC
//underneath us
// Validation of value is done in EPC
SetExtendedPropertyBackedProperty(KnownIds.StylusTipTransform, value);
}
}
///
/// The height of the StylusTip
///
public double Height
{
get
{
//prevent boxing / unboxing if possible
if (!_extendedProperties.Contains(KnownIds.StylusHeight))
{
Debug.Assert(DrawingAttributes.DefaultHeight == (double)GetDefaultDrawingAttributeValue(KnownIds.StylusHeight));
return DrawingAttributes.DefaultHeight;
}
return (double)GetExtendedPropertyBackedProperty(KnownIds.StylusHeight);
}
set
{
if (double.IsNaN(value) || value < MinHeight || value > MaxHeight)
{
throw new ArgumentOutOfRangeException("Height", SR.Get(SRID.InvalidDrawingAttributesHeight));
}
//no need to raise change events, they will bubble up from the EPC
//underneath us
SetExtendedPropertyBackedProperty(KnownIds.StylusHeight, value);
}
}
///
/// The width of the StylusTip
///
public double Width
{
get
{
//prevent boxing / unboxing if possible
if (!_extendedProperties.Contains(KnownIds.StylusWidth))
{
Debug.Assert(DrawingAttributes.DefaultWidth == (double)GetDefaultDrawingAttributeValue(KnownIds.StylusWidth));
return DrawingAttributes.DefaultWidth;
}
return (double)GetExtendedPropertyBackedProperty(KnownIds.StylusWidth);
}
set
{
if (double.IsNaN(value) || value < MinWidth || value > MaxWidth)
{
throw new ArgumentOutOfRangeException("Width", SR.Get(SRID.InvalidDrawingAttributesWidth));
}
//no need to raise change events, they will bubble up from the EPC
//underneath us
SetExtendedPropertyBackedProperty(KnownIds.StylusWidth, value);
}
}
///
/// When true, ink will be rendered as a series of curves instead of as
/// lines between Stylus sample points. This is useful for smoothing the ink, especially
/// when the person writing the ink has jerky or shaky writing.
/// This value is TRUE by default in the Avalon implementation
///
public bool FitToCurve
{
get
{
DrawingFlags flags = (DrawingFlags)GetExtendedPropertyBackedProperty(KnownIds.DrawingFlags);
return (0 != (flags & DrawingFlags.FitToCurve));
}
set
{
//no need to raise change events, they will bubble up from the EPC
//underneath us
DrawingFlags flags = (DrawingFlags)GetExtendedPropertyBackedProperty(KnownIds.DrawingFlags);
if (value)
{
//turn on the bit
flags |= DrawingFlags.FitToCurve;
}
else
{
//turn off the bit
flags &= ~DrawingFlags.FitToCurve;
}
SetExtendedPropertyBackedProperty(KnownIds.DrawingFlags, flags);
}
}
///
/// When true, ink will be rendered with any available pressure information
/// taken into account
///
public bool IgnorePressure
{
get
{
DrawingFlags flags = (DrawingFlags)GetExtendedPropertyBackedProperty(KnownIds.DrawingFlags);
return (0 != (flags & DrawingFlags.IgnorePressure));
}
set
{
//no need to raise change events, they will bubble up from the EPC
//underneath us
DrawingFlags flags = (DrawingFlags)GetExtendedPropertyBackedProperty(KnownIds.DrawingFlags);
if (value)
{
//turn on the bit
flags |= DrawingFlags.IgnorePressure;
}
else
{
//turn off the bit
flags &= ~DrawingFlags.IgnorePressure;
}
SetExtendedPropertyBackedProperty(KnownIds.DrawingFlags, flags);
}
}
///
/// Determines if the stroke should be treated as a highlighter
///
public bool IsHighlighter
{
get
{
//prevent boxing / unboxing if possible
if (!_extendedProperties.Contains(KnownIds.IsHighlighter))
{
Debug.Assert(false == (bool)GetDefaultDrawingAttributeValue(KnownIds.IsHighlighter));
return false;
}
else
{
Debug.Assert(true == (bool)GetExtendedPropertyBackedProperty(KnownIds.IsHighlighter));
return true;
}
}
set
{
//no need to raise change events, they will bubble up from the EPC
//underneath us
SetExtendedPropertyBackedProperty(KnownIds.IsHighlighter, value);
//
// set RasterOp for V1 interop
//
if (value)
{
_v1RasterOperation = DrawingAttributeSerializer.RasterOperationMaskPen;
}
else
{
_v1RasterOperation = DrawingAttributeSerializer.RasterOperationDefaultV1;
}
}
}
#region Extended Properties
///
/// Allows addition of objects to the EPC
///
///
///
public void AddPropertyData(Guid propertyDataId, object propertyData)
{
DrawingAttributes.ValidateStylusTipTransform(propertyDataId, propertyData);
SetExtendedPropertyBackedProperty(propertyDataId, propertyData);
}
///
/// Allows removal of objects from the EPC
///
///
public void RemovePropertyData(Guid propertyDataId)
{
this.ExtendedProperties.Remove(propertyDataId);
}
///
/// Allows retrieval of objects from the EPC
///
///
public object GetPropertyData(Guid propertyDataId)
{
return GetExtendedPropertyBackedProperty(propertyDataId);
}
///
/// Allows retrieval of a Array of guids that are contained in the EPC
///
public Guid[] GetPropertyDataIds()
{
return this.ExtendedProperties.GetGuidArray();
}
///
/// Allows check of containment of objects to the EPC
///
///
public bool ContainsPropertyData(Guid propertyDataId)
{
return this.ExtendedProperties.Contains(propertyDataId);
}
///
/// ExtendedProperties
///
internal ExtendedPropertyCollection ExtendedProperties
{
get
{
return _extendedProperties;
}
}
///
/// Returns a copy of the EPC
///
internal ExtendedPropertyCollection CopyPropertyData()
{
return this.ExtendedProperties.Clone();
}
#endregion
#endregion
#region Internal Properties
///
/// StylusShape
///
internal StylusShape StylusShape
{
get
{
StylusShape s;
if (this.StylusTip == StylusTip.Rectangle)
{
s = new RectangleStylusShape(this.Width, this.Height);
}
else
{
s = new EllipseStylusShape(this.Width, this.Height);
}
s.Transform = StylusTipTransform;
return s;
}
}
///
/// Sets the Fitting error for this drawing attributes
///
internal int FittingError
{
get
{
if (!_extendedProperties.Contains(KnownIds.CurveFittingError))
{
return 0;
}
else
{
return (int)_extendedProperties[KnownIds.CurveFittingError];
}
}
set
{
_extendedProperties[KnownIds.CurveFittingError] = value;
}
}
///
/// Sets the Fitting error for this drawing attributes
///
internal DrawingFlags DrawingFlags
{
get
{
return (DrawingFlags)GetExtendedPropertyBackedProperty(KnownIds.DrawingFlags);
}
set
{
//no need to raise change events, they will bubble up from the EPC
//underneath us
SetExtendedPropertyBackedProperty(KnownIds.DrawingFlags, value);
}
}
///
/// we need to preserve this for round tripping
///
///
/// When we load ISF from V1 if width is set and height is not
/// and PenTip is Circle, we need to set height to the same as width
/// or else we'll render different as an Ellipse. We use this flag to
/// preserve state for round tripping.
///
internal bool HeightChangedForCompatabity
{
get { return _heightChangedForCompatabity; }
set { _heightChangedForCompatabity = value; }
}
#endregion
//-----------------------------------------------------
//
// INotifyPropertyChanged Interface
//
//-----------------------------------------------------
#region INotifyPropertyChanged Interface
///
/// INotifyPropertyChanged.PropertyChanged event
///
event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged
{
add { _propertyChanged += value; }
remove { _propertyChanged -= value; }
}
#endregion INotifyPropertyChanged Interface
#region Methods
#region Object overrides
//
public override int GetHashCode()
{
return base.GetHashCode();
}
/// Overload of the Equals method which determines if two DrawingAttributes
/// objects contain the same drawing attributes
public override bool Equals(object o)
{
if (o == null || o.GetType() != this.GetType())
{
return false;
}
//use as and check for null instead of casting to DA to make presharp happy
DrawingAttributes that = o as DrawingAttributes;
if (that == null)
{
return false;
}
return (this._extendedProperties == that._extendedProperties);
}
/// Overload of the equality operator which determines
/// if two DrawingAttributes are equal
public static bool operator ==(DrawingAttributes first, DrawingAttributes second)
{
// compare the GC ptrs for the obvious reference equality
if (((object)first == null && (object)second == null) ||
((object)first == (object)second))
{
return true;
}
// otherwise, if one of the ptrs are null, but not the other then return false
else if ((object)first == null || (object)second == null)
{
return false;
}
// finally use the full `blown value-style comparison against the collection contents
return first.Equals(second);
}
/// Overload of the not equals operator to determine if two
/// DrawingAttributes are different
public static bool operator !=(DrawingAttributes first, DrawingAttributes second)
{
return !(first == second);
}
#endregion
///
/// Copies the DrawingAttributes
///
/// Deep copy of the DrawingAttributes
///
/// Event fired whenever a DrawingAttribute is modified
///
public event PropertyDataChangedEventHandler AttributeChanged;
///
/// Method called when a change occurs to any DrawingAttribute
///
/// The change information for the DrawingAttribute that was modified
protected virtual void OnAttributeChanged(PropertyDataChangedEventArgs e)
{
if (null == e)
{
throw new ArgumentNullException("e", SR.Get(SRID.EventArgIsNull));
}
try
{
PrivateNotifyPropertyChanged(e);
}
finally
{
if ( this.AttributeChanged != null )
{
this.AttributeChanged(this, e);
}
}
}
///
/// Event fired whenever a DrawingAttribute is modified
///
public event PropertyDataChangedEventHandler PropertyDataChanged;
///
/// Method called when a change occurs to any PropertyData
///
/// The change information for the PropertyData that was modified
protected virtual void OnPropertyDataChanged(PropertyDataChangedEventArgs e)
{
if (null == e)
{
throw new ArgumentNullException("e", SR.Get(SRID.EventArgIsNull));
}
if (this.PropertyDataChanged != null)
{
this.PropertyDataChanged(this, e);
}
}
#endregion
#region Protected Methods
///
/// Method called when a property change occurs to DrawingAttribute
///
/// The EventArgs specifying the name of the changed property.
protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
{
if ( _propertyChanged != null )
{
_propertyChanged(this, e);
}
}
#endregion Protected Methods
#region Private Methods
///
/// Simple helper method used to determine if a guid
/// from an ExtendedProperty is used as the backing store
/// of a DrawingAttribute
///
///
///
/// Simple helper method used to determine if a guid
/// needs to be removed from the ExtendedPropertyCollection in ISF
/// before serializing
///
///
///
/// Returns true if two DrawingAttributes lead to the same PathGeometry.
///
internal static bool GeometricallyEqual(DrawingAttributes left, DrawingAttributes right)
{
// Optimization case:
// must correspond to the same path geometry if they refer to the same instance.
if (Object.ReferenceEquals(left, right))
{
return true;
}
if (left.StylusTip == right.StylusTip &&
left.StylusTipTransform == right.StylusTipTransform &&
DoubleUtil.AreClose(left.Width, right.Width) &&
DoubleUtil.AreClose(left.Height, right.Height) &&
left.DrawingFlags == right.DrawingFlags /*contains IgnorePressure / FitToCurve*/)
{
return true;
}
return false;
}
///
/// Returns true if the guid passed in has impact on geometry of the stroke
///
internal static bool IsGeometricalDaGuid(Guid guid)
{
// Assert it is a DA guid
System.Diagnostics.Debug.Assert(null != DrawingAttributes.GetDefaultDrawingAttributeValue(guid));
if (guid == KnownIds.StylusHeight || guid == KnownIds.StylusWidth ||
guid == KnownIds.StylusTipTransform || guid == KnownIds.StylusTip ||
guid == KnownIds.DrawingFlags)
{
return true;
}
return false;
}
///
/// Whenever the base class fires the generic ExtendedPropertiesChanged
/// event, we need to fire the DrawingAttributesChanged event also.
///
/// Should be 'this' object
/// The custom attributes that changed
private void ExtendedPropertiesChanged_EventForwarder(object sender, ExtendedPropertiesChangedEventArgs args)
{
System.Diagnostics.Debug.Assert(sender != null);
System.Diagnostics.Debug.Assert(args != null);
//see if the EP that changed is a drawingattribute
if (args.NewProperty == null)
{
//a property was removed, see if it is a drawing attribute property
object defaultValueIfDrawingAttribute
= DrawingAttributes.GetDefaultDrawingAttributeValue(args.OldProperty.Id);
if (defaultValueIfDrawingAttribute != null)
{
ExtendedProperty newProperty =
new ExtendedProperty( args.OldProperty.Id,
defaultValueIfDrawingAttribute);
//this is a da guid
PropertyDataChangedEventArgs dargs =
new PropertyDataChangedEventArgs( args.OldProperty.Id,
newProperty.Value, //the property
args.OldProperty.Value);//previous value
this.OnAttributeChanged(dargs);
}
else
{
PropertyDataChangedEventArgs dargs =
new PropertyDataChangedEventArgs( args.OldProperty.Id,
null, //the property
args.OldProperty.Value);//previous value
this.OnPropertyDataChanged(dargs);
}
}
else if (args.OldProperty == null)
{
//a property was added, see if it is a drawing attribute property
object defaultValueIfDrawingAttribute
= DrawingAttributes.GetDefaultDrawingAttributeValue(args.NewProperty.Id);
if (defaultValueIfDrawingAttribute != null)
{
if (!defaultValueIfDrawingAttribute.Equals(args.NewProperty.Value))
{
//this is a da guid
PropertyDataChangedEventArgs dargs =
new PropertyDataChangedEventArgs( args.NewProperty.Id,
args.NewProperty.Value, //the property
defaultValueIfDrawingAttribute); //previous value
this.OnAttributeChanged(dargs);
}
}
else
{
PropertyDataChangedEventArgs dargs =
new PropertyDataChangedEventArgs(args.NewProperty.Id,
args.NewProperty.Value, //the property
null); //previous value
this.OnPropertyDataChanged(dargs);
}
}
else
{
//something was modified, see if it is a drawing attribute property
object defaultValueIfDrawingAttribute
= DrawingAttributes.GetDefaultDrawingAttributeValue(args.NewProperty.Id);
if (defaultValueIfDrawingAttribute != null)
{
//
// we only raise DA changed when the value actually changes
//
if (!args.NewProperty.Value.Equals(args.OldProperty.Value))
{
//this is a da guid
PropertyDataChangedEventArgs dargs =
new PropertyDataChangedEventArgs( args.NewProperty.Id,
args.NewProperty.Value, //the da
args.OldProperty.Value);//old value
this.OnAttributeChanged(dargs);
}
}
else
{
if (!args.NewProperty.Value.Equals(args.OldProperty.Value))
{
PropertyDataChangedEventArgs dargs =
new PropertyDataChangedEventArgs( args.NewProperty.Id,
args.NewProperty.Value,
args.OldProperty.Value);//old value
this.OnPropertyDataChanged(dargs);
}
}
}
}
///
/// All DrawingAttributes are backed by an ExtendedProperty
/// this is a simple helper to set a property
///
/// id
/// value
private void SetExtendedPropertyBackedProperty(Guid id, object value)
{
if (_extendedProperties.Contains(id))
{
//
// check to see if we're setting the property back
// to a default value. If we are we should remove it from
// the EPC
//
object defaultValue = DrawingAttributes.GetDefaultDrawingAttributeValue(id);
if (defaultValue != null)
{
if (defaultValue.Equals(value))
{
_extendedProperties.Remove(id);
return;
}
}
//
// we're setting a non-default value on a EP that
// already exists, check for equality before we do
// so we don't raise unnecessary EPC changed events
//
object o = GetExtendedPropertyBackedProperty(id);
if (!o.Equals(value))
{
_extendedProperties[id] = value;
}
}
else
{
//
// make sure we're not setting a default value of the guid
// there is no need to do this
//
object defaultValue = DrawingAttributes.GetDefaultDrawingAttributeValue(id);
if (defaultValue == null || !defaultValue.Equals(value))
{
_extendedProperties[id] = value;
}
}
}
///
/// All DrawingAttributes are backed by an ExtendedProperty
/// this is a simple helper to set a property
///
/// id
///
/// A help method which fires INotifyPropertyChanged.PropertyChanged event
///
///
private void PrivateNotifyPropertyChanged(PropertyDataChangedEventArgs e)
{
if ( e.PropertyGuid == KnownIds.Color)
{
OnPropertyChanged("Color");
}
else if ( e.PropertyGuid == KnownIds.StylusTip)
{
OnPropertyChanged("StylusTip");
}
else if ( e.PropertyGuid == KnownIds.StylusTipTransform)
{
OnPropertyChanged("StylusTipTransform");
}
else if ( e.PropertyGuid == KnownIds.StylusHeight)
{
OnPropertyChanged("Height");
}
else if ( e.PropertyGuid == KnownIds.StylusWidth)
{
OnPropertyChanged("Width");
}
else if ( e.PropertyGuid == KnownIds.IsHighlighter)
{
OnPropertyChanged("IsHighlighter");
}
else if ( e.PropertyGuid == KnownIds.DrawingFlags )
{
DrawingFlags changedBits = ( ( (DrawingFlags)e.PreviousValue ) ^ ( (DrawingFlags)e.NewValue ) );
// NOTICE-2006/01/20-[....],
// If someone changes FitToCurve and IgnorePressure simultaneously via AddPropertyData/RemovePropertyData,
// we will fire both OnPropertyChangeds in advance the order of the values.
if ( (changedBits & DrawingFlags.FitToCurve) != 0 )
{
OnPropertyChanged("FitToCurve");
}
if ( (changedBits & DrawingFlags.IgnorePressure) != 0 )
{
OnPropertyChanged("IgnorePressure");
}
}
}
private void OnPropertyChanged(string propertyName)
{
OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
}
#endregion
#region Private Fields
// The private PropertyChanged event
private PropertyChangedEventHandler _propertyChanged;
private ExtendedPropertyCollection _extendedProperties;
private uint _v1RasterOperation = DrawingAttributeSerializer.RasterOperationDefaultV1;
private bool _heightChangedForCompatabity = false;
///
/// Statics
///
internal static readonly float StylusPrecision = 1000.0f;
internal static readonly double DefaultWidth = 2.0031496062992127;
internal static readonly double DefaultHeight = 2.0031496062992127;
#endregion
///
/// Mininum acceptable stylus tip height, corresponds to 0.001 in V1
///
/// corresponds to 0.001 in V1 (0.001 / (2540/96))
public static readonly double MinHeight = 0.00003779527559055120;
///
/// Minimum acceptable stylus tip width
///
/// corresponds to 0.001 in V1 (0.001 / (2540/96))
public static readonly double MinWidth = 0.00003779527559055120;
///
/// Maximum acceptable stylus tip height.
///
/// corresponds to 4294967 in V1 (4294967 / (2540/96))
public static readonly double MaxHeight = 162329.4614173230;
///
/// Maximum acceptable stylus tip width.
///
/// corresponds to 4294967 in V1 (4294967 / (2540/96))
public static readonly double MaxWidth = 162329.4614173230;
}
}
// 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
- EditorZoneBase.cs
- TransactionBridge.cs
- X509LogoTypeExtension.cs
- CommonProperties.cs
- WindowsPrincipal.cs
- Stopwatch.cs
- BufferedGraphics.cs
- InputChannelBinder.cs
- EmbossBitmapEffect.cs
- XmlAttributeProperties.cs
- MetadataHelper.cs
- SemaphoreSecurity.cs
- DataPagerFieldCommandEventArgs.cs
- DocumentsTrace.cs
- ListBoxItemWrapperAutomationPeer.cs
- XmlDataLoader.cs
- DbCommandDefinition.cs
- XmlCodeExporter.cs
- CacheVirtualItemsEvent.cs
- TypeBuilderInstantiation.cs
- WindowsMenu.cs
- ModuleBuilderData.cs
- DataGridViewColumnDesignTimeVisibleAttribute.cs
- ThicknessAnimationUsingKeyFrames.cs
- AttributeCollection.cs
- SplashScreen.cs
- DbException.cs
- EventLogTraceListener.cs
- DataError.cs
- SqlRewriteScalarSubqueries.cs
- TargetException.cs
- CommandHelper.cs
- TraceHwndHost.cs
- Exception.cs
- WebPartHeaderCloseVerb.cs
- WebPartConnectionCollection.cs
- DataFormats.cs
- RichTextBoxConstants.cs
- MimeMultiPart.cs
- DataGridAutomationPeer.cs
- Config.cs
- Matrix.cs
- Merger.cs
- WebPartConnectVerb.cs
- XmlQueryCardinality.cs
- GridViewSortEventArgs.cs
- NameValueFileSectionHandler.cs
- Selection.cs
- MediaElementAutomationPeer.cs
- SessionEndedEventArgs.cs
- ProtocolViolationException.cs
- DocumentViewer.cs
- TextEndOfParagraph.cs
- WebEventCodes.cs
- PropertyValueChangedEvent.cs
- CompilerLocalReference.cs
- VisualStyleRenderer.cs
- PreservationFileWriter.cs
- PointCollectionValueSerializer.cs
- SafeBuffer.cs
- SQLGuid.cs
- XPathDocumentIterator.cs
- StaticSiteMapProvider.cs
- PrinterResolution.cs
- TaiwanCalendar.cs
- JsonClassDataContract.cs
- TransformGroup.cs
- ByteStorage.cs
- JsonEncodingStreamWrapper.cs
- TransactionFlowAttribute.cs
- HttpRuntime.cs
- StylusDownEventArgs.cs
- DurableOperationAttribute.cs
- WsdlBuildProvider.cs
- DayRenderEvent.cs
- ProtocolViolationException.cs
- XmlSchemaDatatype.cs
- MarkupCompilePass1.cs
- SafeArrayRankMismatchException.cs
- DataSourceXmlSubItemAttribute.cs
- ClientEventManager.cs
- CaretElement.cs
- RuleSetReference.cs
- DataStorage.cs
- UnicodeEncoding.cs
- DocumentEventArgs.cs
- _SpnDictionary.cs
- Thickness.cs
- DropDownButton.cs
- ToolStripOverflowButton.cs
- WinCategoryAttribute.cs
- DetailsViewDesigner.cs
- LinearGradientBrush.cs
- SiteMapHierarchicalDataSourceView.cs
- BitmapEffectvisualstate.cs
- RuntimeHelpers.cs
- DataError.cs
- TransmissionStrategy.cs
- PartialCachingAttribute.cs
- XsltConvert.cs