Code:
/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Framework / System / Windows / Controls / ContentPresenter.cs / 4 / ContentPresenter.cs
//----------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
// Description: ContentPresenter class
//
// Specs: [....]/connecteddata/M5%20General%20Docs/Data%20Styling.mht
//
//---------------------------------------------------------------------------
using System;
using System.Diagnostics;
using System.ComponentModel;
using System.Windows.Threading;
using System.Windows.Shapes;
using System.Windows.Media;
using System.Windows.Data;
using System.Windows.Markup;
using MS.Internal;
using MS.Internal.Data;
using MS.Internal.KnownBoxes;
using System.Windows.Documents;
using MS.Utility;
using MS.Internal.PresentationFramework;
namespace System.Windows.Controls
{
///
/// ContentPresenter is used within the template of a content control to denote the
/// place in the control's visual tree (control template) where the content
/// is to be added.
///
[Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
public class ContentPresenter : FrameworkElement
{
//-----------------------------------------------------
//
// Constructors
//
//-----------------------------------------------------
static ContentPresenter()
{
DataTemplate template;
FrameworkElementFactory text;
Binding binding;
// Default template for strings when hosted in ContentPresener with RecognizesAccessKey=true
template = new DataTemplate();
text = CreateAccessTextFactory();
text.SetValue(AccessText.TextProperty, new TemplateBindingExtension(ContentProperty));
template.VisualTree = text;
template.Seal();
s_AccessTextTemplate = template;
// Default template for strings
template = new DataTemplate();
text = CreateTextBlockFactory();
text.SetValue(TextBlock.TextProperty, new TemplateBindingExtension(ContentProperty));
template.VisualTree = text;
template.Seal();
s_StringTemplate = template;
// Default template for XmlNodes
template = new DataTemplate();
text = CreateTextBlockFactory();
binding = new Binding();
binding.XPath = ".";
text.SetBinding(TextBlock.TextProperty, binding);
template.VisualTree = text;
template.Seal();
s_XmlNodeTemplate = template;
// Default template for UIElements
template = new UseContentTemplate();
template.Seal();
s_UIElementTemplate = template;
// Default template for everything else
template = new DefaultTemplate();
template.Seal();
s_DefaultTemplate = template;
// Default template selector
s_DefaultTemplateSelector = new DefaultSelector();
}
///
/// Default constructor
///
///
/// Automatic determination of current Dispatcher. Use alternative constructor
/// that accepts a Dispatcher for best performance.
///
public ContentPresenter() : base()
{
Initialize();
}
void Initialize()
{
// Initialize the _templateCache to the default value for TemplateProperty.
// If the default value is non-null then wire it to the current instance.
PropertyMetadata metadata = TemplateProperty.GetMetadata(DependencyObjectType);
DataTemplate defaultValue = (DataTemplate) metadata.DefaultValue;
if (defaultValue != null)
{
OnTemplateChanged(this, new DependencyPropertyChangedEventArgs(TemplateProperty, metadata, null, defaultValue));
}
DataContext = null; // this presents a uniform view: CP always has local DC
}
//------------------------------------------------------
//
// Public Properties
//
//-----------------------------------------------------
///
/// The DependencyProperty for the RecognizesAccessKey property.
/// Flags: None
/// Default Value: false
///
[CommonDependencyProperty]
public static readonly DependencyProperty RecognizesAccessKeyProperty =
DependencyProperty.Register(
"RecognizesAccessKey",
typeof(bool),
typeof(ContentPresenter),
new FrameworkPropertyMetadata(BooleanBoxes.FalseBox));
///
/// Determine if ContentPresenter should use AccessText in its style
///
public bool RecognizesAccessKey
{
get { return (bool) GetValue(RecognizesAccessKeyProperty); }
set { SetValue(RecognizesAccessKeyProperty, BooleanBoxes.Box(value)); }
}
///
/// The DependencyProperty for the Content property.
/// Flags: None
/// Default Value: null
///
// Any change in Content properties affectes layout measurement since
// a new template may be used. On measurement,
// ApplyTemplate will be invoked leading to possible application
// of a new template.
[CommonDependencyProperty]
public static readonly DependencyProperty ContentProperty =
ContentControl.ContentProperty.AddOwner(
typeof(ContentPresenter),
new FrameworkPropertyMetadata(
(object)null,
FrameworkPropertyMetadataOptions.AffectsMeasure,
new PropertyChangedCallback(OnContentChanged)));
///
/// Content is the data used to generate the child elements of this control.
///
public object Content
{
get { return GetValue(ContentControl.ContentProperty); }
set { SetValue(ContentControl.ContentProperty, value); }
}
///
/// Called when ContentProperty is invalidated on "d."
///
private static void OnContentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ContentPresenter ctrl = (ContentPresenter)d;
bool mismatch;
if (ctrl.ContentTemplate != null)
{
mismatch = false; // explicit template - matches by fiat
}
else if (ctrl.ContentTemplateSelector != null)
{
mismatch = true; // template selector - always re-select
}
else if (ctrl.Template == UIElementContentTemplate ||
ctrl.Template == DefaultContentTemplate)
{
mismatch = true; // direct template - always re-apply
}
else
{
// type-based template - matches if types agree
Type oldType = (e.OldValue != null) ? e.OldValue.GetType() : null;
Type newType = (e.NewValue != null) ? e.NewValue.GetType() : null;
mismatch = (oldType != newType);
}
// if the content and (old) template don't match, get rid of the template
if (mismatch)
{
ctrl._templateIsCurrent = false;
ctrl.Template = null;
}
// keep the DataContext in sync with Content
if (ctrl._templateIsCurrent && ctrl.Template != UIElementContentTemplate)
{
ctrl.DataContext = e.NewValue;
}
}
///
/// The DependencyProperty for the ContentTemplate property.
/// Flags: None
/// Default Value: null
///
[CommonDependencyProperty]
public static readonly DependencyProperty ContentTemplateProperty =
ContentControl.ContentTemplateProperty.AddOwner(
typeof(ContentPresenter),
new FrameworkPropertyMetadata(
(DataTemplate)null,
FrameworkPropertyMetadataOptions.AffectsMeasure,
new PropertyChangedCallback(OnContentTemplateChanged)));
///
/// ContentTemplate is the template used to display the content of the control.
///
public DataTemplate ContentTemplate
{
get { return (DataTemplate) GetValue(ContentControl.ContentTemplateProperty); }
set { SetValue(ContentControl.ContentTemplateProperty, value); }
}
///
/// Called when ContentTemplateProperty is invalidated on "d."
///
private static void OnContentTemplateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ContentPresenter ctrl = (ContentPresenter)d;
ctrl._templateIsCurrent = false;
ctrl.OnContentTemplateChanged((DataTemplate) e.OldValue, (DataTemplate) e.NewValue);
}
///
/// This method is invoked when the ContentTemplate property changes.
///
/// The old value of the ContentTemplate property.
/// The new value of the ContentTemplate property.
protected virtual void OnContentTemplateChanged(DataTemplate oldContentTemplate, DataTemplate newContentTemplate)
{
Helper.CheckTemplateAndTemplateSelector("Content", ContentTemplateProperty, ContentTemplateSelectorProperty, this);
// if ContentTemplate is really changing, remove the old template
this.Template = null;
}
///
/// The DependencyProperty for the ContentTemplateSelector property.
/// Flags: None
/// Default Value: null
///
[CommonDependencyProperty]
public static readonly DependencyProperty ContentTemplateSelectorProperty =
ContentControl.ContentTemplateSelectorProperty.AddOwner(
typeof(ContentPresenter),
new FrameworkPropertyMetadata(
(DataTemplateSelector)null,
FrameworkPropertyMetadataOptions.AffectsMeasure,
new PropertyChangedCallback(OnContentTemplateSelectorChanged)));
///
/// ContentTemplateSelector allows the application writer to provide custom logic
/// for choosing the template used to display the content of the control.
///
///
/// This property is ignored if
public DataTemplateSelector ContentTemplateSelector
{
get { return (DataTemplateSelector) GetValue(ContentControl.ContentTemplateSelectorProperty); }
set { SetValue(ContentControl.ContentTemplateSelectorProperty, value); }
}
///
/// This method is used by TypeDescriptor to determine if this property should
/// be serialized.
///
[EditorBrowsable(EditorBrowsableState.Never)]
public bool ShouldSerializeContentTemplateSelector()
{
return false;
}
///
/// Called when ContentTemplateSelectorProperty is invalidated on "d."
///
private static void OnContentTemplateSelectorChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ContentPresenter ctrl = (ContentPresenter) d;
ctrl._templateIsCurrent = false;
ctrl.OnContentTemplateSelectorChanged((DataTemplateSelector) e.OldValue, (DataTemplateSelector) e.NewValue);
}
///
/// This method is invoked when the ContentTemplateSelector property changes.
///
/// The old value of the ContentTemplateSelector property.
/// The new value of the ContentTemplateSelector property.
protected virtual void OnContentTemplateSelectorChanged(DataTemplateSelector oldContentTemplateSelector, DataTemplateSelector newContentTemplateSelector)
{
Helper.CheckTemplateAndTemplateSelector("Content", ContentTemplateProperty, ContentTemplateSelectorProperty, this);
// if ContentTemplateSelector is really changing (and in use), remove the old template
this.Template = null;
}
///
/// The DependencyProperty for the ContentSource property.
/// Flags: None
/// Default Value: Content
///
[CommonDependencyProperty]
public static readonly DependencyProperty ContentSourceProperty =
DependencyProperty.Register(
"ContentSource",
typeof(string),
typeof(ContentPresenter),
new FrameworkPropertyMetadata("Content"));
///
/// ContentSource is the base name to use during automatic aliasing.
/// When a template contains a ContentPresenter with ContentSource="Abc",
/// its Content, ContentTemplate, and ContentTemplateSelector properties are
/// automatically aliased to Abc, AbcTemplate, and AbcTemplateSelector,
/// respectively. The two most useful values for ContentSource are
/// "Content" and "Header"; the default is "Content".
///
///
/// This property only makes sense in a template. It should not be set on
/// an actual ContentPresenter; there will be no effect.
///
public string ContentSource
{
get { return GetValue(ContentSourceProperty) as string; }
set { SetValue(ContentSourceProperty, value); }
}
//------------------------------------------------------
//
// Protected Methods
//
//------------------------------------------------------
///
/// Called when the Template's tree is about to be generated
///
internal override void OnPreApplyTemplate()
{
base.OnPreApplyTemplate();
// If we're inflating our visual tree but our TemplatedParent is null,
// we might have been removed from the visual tree but not have had
// our ContentProperty invalidated. This would mean that when we go
// to reparent our content, we'll be looking at a stale cache. Make
// sure to invalidate the Content property in this case.
if (TemplatedParent == null)
{
// call GetValueCore to get this value from its TemplatedParent
InvalidateProperty(ContentProperty);
}
if (!_templateIsCurrent)
{
EnsureTemplate();
_templateIsCurrent = true;
}
}
///
/// Updates DesiredSize of the ContentPresenter. Called by parent UIElement. This is the first pass of layout.
///
///
/// ContentPresenter determines a desired size it needs from the child's sizing properties, margin, and requested size.
///
/// Constraint size is an "upper limit" that the return value should not exceed.
/// The ContentPresenter's desired size.
protected override Size MeasureOverride(Size constraint)
{
return Helper.MeasureElementWithSingleChild(this, constraint);
}
///
/// ContentPresenter computes the position of its single child inside child's Margin and calls Arrange
/// on the child.
///
/// Size the ContentPresenter will assume.
protected override Size ArrangeOverride(Size arrangeSize)
{
return Helper.ArrangeElementWithSingleChild(this, arrangeSize);
}
///
/// Return the template to use. This may depend on the Content, or
/// other properties.
///
///
/// The base class implements the following rules:
/// (a) If ContentTemplate is set, use it.
/// (b) If ContentTemplateSelector is set, call its
/// SelectTemplate method. If the result is not null, use it.
/// (c) Look for a DataTemplate whose DataType matches the
/// Content among the resources known to the ContentPresenter
/// (including application, theme, and system resources).
/// If one is found, use it.
/// (d) If the type of Content is "common", use a standard template.
/// The common types are String, XmlNode, UIElement.
/// (e) Otherwise, use a default template that essentially converts
/// Content to a string and displays it in a TextBlock.
/// Derived classes can override these rules and implement their own.
///
protected virtual DataTemplate ChooseTemplate()
{
DataTemplate template = null;
object content = Content;
// ContentTemplate has first stab
template = ContentTemplate;
// no ContentTemplate set, try ContentTemplateSelector
if (template == null)
{
if (ContentTemplateSelector != null)
{
template = ContentTemplateSelector.SelectTemplate(content, this);
}
}
// if that failed, try the default TemplateSelector
if (template == null)
{
template = DefaultTemplateSelector.SelectTemplate(content, this);
}
return template;
}
//-----------------------------------------------------
//
// Internal properties
//
//------------------------------------------------------
internal static DataTemplate AccessTextContentTemplate
{
get { return s_AccessTextTemplate; }
}
internal static DataTemplate StringContentTemplate
{
get { return s_StringTemplate; }
}
// Internal Helper so the FrameworkElement could see this property
internal override FrameworkTemplate TemplateInternal
{
get { return Template; }
}
// Internal Helper so the FrameworkElement could see the template cache
internal override FrameworkTemplate TemplateCache
{
get { return _templateCache; }
set { _templateCache = (DataTemplate)value; }
}
internal bool TemplateIsCurrent
{
get { return _templateIsCurrent; }
}
//-----------------------------------------------------
//
// Internal methods
//
//-----------------------------------------------------
///
/// Prepare to display the item.
///
internal void PrepareContentPresenter(object item, DataTemplate itemTemplate, DataTemplateSelector itemTemplateSelector)
{
if (item != this)
{
// copy templates from parent ItemsControl
if (_contentIsItem || !HasNonDefaultValue(ContentProperty))
{
Content = item;
_contentIsItem = true;
}
if (itemTemplate != null)
SetValue(ContentTemplateProperty, itemTemplate);
if (itemTemplateSelector != null)
SetValue(ContentTemplateSelectorProperty, itemTemplateSelector);
}
}
//-----------------------------------------------------
//
// Private properties
//
//------------------------------------------------------
static DataTemplate XmlNodeContentTemplate
{
get { return s_XmlNodeTemplate; }
}
static DataTemplate UIElementContentTemplate
{
get { return s_UIElementTemplate; }
}
static DataTemplate DefaultContentTemplate
{
get { return s_DefaultTemplate; }
}
static DefaultSelector DefaultTemplateSelector
{
get { return s_DefaultTemplateSelector; }
}
///
/// TemplateProperty
///
internal static readonly DependencyProperty TemplateProperty =
DependencyProperty.Register(
"Template",
typeof(DataTemplate),
typeof(ContentPresenter),
new FrameworkPropertyMetadata(
(DataTemplate) null, // default value
FrameworkPropertyMetadataOptions.AffectsMeasure,
new PropertyChangedCallback(OnTemplateChanged)));
///
/// Template Property
///
private DataTemplate Template
{
get { return _templateCache; }
set { SetValue(TemplateProperty, value); }
}
// Internal helper so FrameworkElement could see call the template changed virtual
internal override void OnTemplateChangedInternal(FrameworkTemplate oldTemplate, FrameworkTemplate newTemplate)
{
OnTemplateChanged((DataTemplate)oldTemplate, (DataTemplate)newTemplate);
}
// Property invalidation callback invoked when TemplateProperty is invalidated
private static void OnTemplateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ContentPresenter c = (ContentPresenter) d;
StyleHelper.UpdateTemplateCache(c, (FrameworkTemplate) e.OldValue, (FrameworkTemplate) e.NewValue, TemplateProperty);
}
///
/// Template has changed
///
///
/// When a Template changes, the VisualTree is removed. The new Template's
/// VisualTree will be created when ApplyTemplate is called
///
/// The old Template
/// The new Template
protected virtual void OnTemplateChanged(DataTemplate oldTemplate, DataTemplate newTemplate)
{
}
//-----------------------------------------------------
//
// Private methods
//
//------------------------------------------------------
private void EnsureTemplate()
{
DataTemplate oldTemplate = Template;
DataTemplate newTemplate = null;
for (_templateIsCurrent = false; !_templateIsCurrent; )
{
// normally this loop will execute exactly once. The only exception
// is when setting the DataContext causes the ContentTemplate or
// ContentTemplateSelector to change, presumably because they are
// themselves data-bound (see bug 128119). In that case, we need
// to call ChooseTemplate again, to pick up the new template.
// We detect this case because _templateIsCurrent is reset to false
// in OnContentTemplate[Selector]Changed, causing a second iteration
// of the loop.
_templateIsCurrent = true;
newTemplate = ChooseTemplate();
// if the template is changing, it's important that the code that cleans
// up the old template runs while the CP's DataContext is still set to
// the old Content. The way to get this effect is:
// a. change the template to null
// b. change the data context
// c. change the template to the new value
if (oldTemplate != newTemplate)
{
Template = null;
}
if (newTemplate != UIElementContentTemplate)
{
// set data context to the content, so that the template can bind to
// properties of the content.
this.DataContext = Content;
}
else
{
// If we're using the content directly, clear the data context.
// The content expects to inherit.
this.ClearValue(DataContextProperty);
}
}
Template = newTemplate;
// if the template didn't change, we still need to force the content for the template to be regenerated;
// so call StyleHelper's DoTemplateInvalidations directly
if (oldTemplate == newTemplate)
{
StyleHelper.DoTemplateInvalidations(this, oldTemplate);
}
}
// ContentPresenter often has occasion to display text. The TextBlock it uses
// should get the values for various text-related properties (foreground, fonts,
// decoration, trimming) from the governing ContentControl. The following
// two methods accomplish this - first for the case where the TextBlock appears
// in a true template, then for the case where the TextBlock is created on
// demand via BuildVisualTree.
// Create a FEF for a AccessText, to be used in a default template
internal static FrameworkElementFactory CreateAccessTextFactory()
{
FrameworkElementFactory text = new FrameworkElementFactory(typeof(AccessText));
return text;
}
// Create a FEF for a TextBlock, to be used in a default template
internal static FrameworkElementFactory CreateTextBlockFactory()
{
FrameworkElementFactory text = new FrameworkElementFactory(typeof(TextBlock));
return text;
}
// Create a TextBlock, to be used in a default "template" (via BuildVisualTree)
static TextBlock CreateTextBlock(ContentPresenter container)
{
TextBlock text = new TextBlock();
return text;
}
//
// This property
// 1. Finds the correct initial size for the _effectiveValues store on the current DependencyObject
// 2. This is a performance optimization
//
internal override int EffectiveValuesInitialSize
{
get { return 28; }
}
//------------------------------------------------------
//
// Private nested classes
//
//-----------------------------------------------------
// Template for displaying UIElements - use the UIElement itself
private class UseContentTemplate : DataTemplate
{
public UseContentTemplate()
{
// We need to preserve the treeState cache on a container node
// even after all its logical children have been added. This is so the
// construction of the template visual tree nodes can consume the cache.
// This member helps us know whether we should retain the cache for
// special scenarios when the visual tree is being built via BuildVisualTree
CanBuildVisualTree = true;
}
internal override bool BuildVisualTree(FrameworkElement container)
{
UIElement e = ((ContentPresenter)container).Content as UIElement;
StyleHelper.AddCustomTemplateRoot( container, e );
return true;
}
}
// template for displaying content when all else fails
private class DefaultTemplate : DataTemplate
{
public DefaultTemplate()
{
// We need to preserve the treeState cache on a container node
// even after all its logical children have been added. This is so the
// construction of the template visual tree nodes can consume the cache.
// This member helps us know whether we should retain the cache for
// special scenarios when the visual tree is being built via BuildVisualTree
CanBuildVisualTree = true;
}
//[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647
internal override bool BuildVisualTree(FrameworkElement container)
{
bool tracingEnabled = EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.normal);
if (tracingEnabled)
{
EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.GENERICSTRINGGUID), MS.Utility.EventType.StartEvent, "ContentPresenter.BuildVisualTree");
}
ContentPresenter cp = (ContentPresenter)container;
Visual result = DefaultExpansion(cp.Content, cp);
if (tracingEnabled)
{
EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.GENERICSTRINGGUID),
MS.Utility.EventType.EndEvent,
String.Format(System.Globalization.CultureInfo.InvariantCulture, "ContentPresenter.BuildVisualTree for CP {0}", container.GetHashCode()));
}
return (result != null);
}
private UIElement DefaultExpansion(object content, ContentPresenter container)
{
if (content == null)
return null;
TextBlock textBlock = CreateTextBlock(container);
textBlock.IsContentPresenterContainer = true; // this is done so that the TextBlock does not steal away the logical child
if( container != null )
{
StyleHelper.AddCustomTemplateRoot(
container,
textBlock,
false, // Do not need to check for existing visual parent since we just created it
true); // set treeState cache on the Text instance created
}
DoDefaultExpansion(textBlock, content);
return textBlock;
}
private void DoDefaultExpansion(TextBlock textBlock, object content)
{
if (content is string)
{
textBlock.Text = (string)content;
}
else if (content is Inline)
{
textBlock.Inlines.Add((Inline)content);
}
else if (content is UIElement)
{
textBlock.Inlines.Add(new InlineUIContainer((UIElement)content));
}
else
{
Type t = content.GetType();
TypeConverter tc = TypeDescriptor.GetConverter(t);
if (tc != null)
{
if (tc.CanConvertTo(typeof(UIElement)))
{
UIElement e = (UIElement)tc.ConvertTo(content, typeof(UIElement));
textBlock.Inlines.Add(new InlineUIContainer(e));
}
else if (tc.CanConvertTo(typeof(string)))
{
textBlock.Text = (string)tc.ConvertTo(content, typeof(string));
}
}
else
{
textBlock.Text = content.ToString();
}
}
}
}
private class DefaultSelector : DataTemplateSelector
{
///
/// Override this method to return an app specific
/// The data content
/// The container in which the content is to be displayed
/// a app specific template to apply.
public override DataTemplate SelectTemplate(object item, DependencyObject container)
{
DataTemplate template = null;
// Lookup template for typeof(Content) in resource dictionaries.
if (item != null)
{
template = (DataTemplate)FrameworkElement.FindTemplateResourceInternal(container, item, typeof(DataTemplate));
}
// default templates for well known types:
if (template == null)
{
if (item is string)
{
ContentPresenter cp = container as ContentPresenter;
if (cp != null && cp.RecognizesAccessKey && (item as string).IndexOf(AccessText.AccessKeyMarker) > -1)
template = AccessTextContentTemplate;
else
template = StringContentTemplate;
}
else if (item is UIElement)
template = UIElementContentTemplate;
else if (XmlHelper.IsXmlNode(item))
template = XmlNodeContentTemplate;
else
template = DefaultContentTemplate;
}
return template;
}
}
//------------------------------------------------------
//
// Private Fields
//
//-----------------------------------------------------
private DataTemplate _templateCache;
private bool _templateIsCurrent;
private bool _contentIsItem;
private static DataTemplate s_AccessTextTemplate;
private static DataTemplate s_StringTemplate;
private static DataTemplate s_XmlNodeTemplate;
private static DataTemplate s_UIElementTemplate;
private static DataTemplate s_DefaultTemplate;
private static DefaultSelector s_DefaultTemplateSelector;
}
}
// 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
- InputDevice.cs
- KeyValuePairs.cs
- ClientApiGenerator.cs
- LinkButton.cs
- nulltextnavigator.cs
- BindingNavigator.cs
- MaskInputRejectedEventArgs.cs
- RoutedEvent.cs
- Point3DConverter.cs
- Identity.cs
- SID.cs
- CDSCollectionETWBCLProvider.cs
- RequiredFieldValidator.cs
- TreeViewHitTestInfo.cs
- ListSortDescriptionCollection.cs
- DeviceFilterEditorDialog.cs
- UnsignedPublishLicense.cs
- CollectionChangeEventArgs.cs
- HostedHttpContext.cs
- SHA384Managed.cs
- HttpFileCollection.cs
- RoutedEventValueSerializer.cs
- XmlMapping.cs
- MethodBuilderInstantiation.cs
- BamlTreeMap.cs
- sitestring.cs
- ReaderContextStackData.cs
- TemplateParser.cs
- CngKeyBlobFormat.cs
- _ReceiveMessageOverlappedAsyncResult.cs
- ConsumerConnectionPoint.cs
- SmtpNegotiateAuthenticationModule.cs
- NavigationCommands.cs
- EntityContainerEmitter.cs
- EntityContainerEntitySet.cs
- ToolStripContainerDesigner.cs
- QueryResponse.cs
- CryptoConfig.cs
- ObjectSecurityT.cs
- FunctionDescription.cs
- VirtualPath.cs
- PackageRelationshipCollection.cs
- SQLByte.cs
- UIElementParaClient.cs
- CodeThrowExceptionStatement.cs
- FocusTracker.cs
- BitStream.cs
- UrlMappingsModule.cs
- WSSecureConversationFeb2005.cs
- GetPolicyDetailsRequest.cs
- Point.cs
- DataError.cs
- PeerEndPoint.cs
- TraceRecords.cs
- Directory.cs
- MailHeaderInfo.cs
- XmlEnumAttribute.cs
- CodeValidator.cs
- Vector3DAnimationBase.cs
- TableLayoutCellPaintEventArgs.cs
- NonVisualControlAttribute.cs
- SmtpSpecifiedPickupDirectoryElement.cs
- AnnotationHelper.cs
- RoleServiceManager.cs
- RuntimeResourceSet.cs
- ApplicationInfo.cs
- AdapterUtil.cs
- FontResourceCache.cs
- URL.cs
- XmlQuerySequence.cs
- OleDbConnection.cs
- SQLStringStorage.cs
- MergeFailedEvent.cs
- WebPartEditorCancelVerb.cs
- LogWriteRestartAreaState.cs
- SrgsDocument.cs
- Internal.cs
- DependencyPropertyAttribute.cs
- HttpCacheParams.cs
- EpmCustomContentDeSerializer.cs
- DetailsViewDeleteEventArgs.cs
- ActivityTypeDesigner.xaml.cs
- XmlAutoDetectWriter.cs
- PropertySourceInfo.cs
- FormatVersion.cs
- HttpModuleAction.cs
- HtmlInputReset.cs
- BlurBitmapEffect.cs
- SafeMILHandle.cs
- DataTableReaderListener.cs
- GetPageNumberCompletedEventArgs.cs
- TypeForwardedToAttribute.cs
- SqlCharStream.cs
- AdRotator.cs
- WebServiceMethodData.cs
- InlineUIContainer.cs
- XmlSchemaAttribute.cs
- Site.cs
- XmlUrlResolver.cs
- ReadOnlyDataSource.cs