Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Framework / System / Windows / TemplateContent.cs / 1599323 / TemplateContent.cs
using System.Xaml; using System.Xaml.Schema; using System.Xaml.Permissions; using System.Collections.Generic; using System.Windows.Controls; using System.Diagnostics; using System.Windows.Data; using System.Windows.Markup; using System.Globalization; using MS.Utility; using System.ComponentModel; using System.Collections; using System.Collections.Specialized; using System.Security; using MS.Internal.Xaml.Context; using System.Windows.Baml2006; namespace System.Windows { //TemplateContent is meant to hold any data that is needed during TemplateLoad and TemplateApply. // _templateLoadData holds all other data. [XamlDeferLoad(typeof(TemplateContentLoader), typeof(FrameworkElement))] public class TemplateContent { internal class Frame : XamlFrame { private FrugalObjectList_namespaces; private System.Xaml.XamlType _xamlType; public Frame() { } public XamlType Type { get { return _xamlType; } set { // can't change the type (except from null) Debug.Assert(_xamlType == null); _xamlType = value; } } public XamlMember Property { get; set; } public string Name { get; set; } public bool NameSet { get; set; } public bool IsInNameScope { get; set; } public bool IsInStyleOrTemplate { get; set; } public object Instance { get; set; } //ContentPresenter public bool ContentSet { get; set; } public bool ContentSourceSet { get; set; } public String ContentSource { get; set; } public bool ContentTemplateSet { get; set; } public bool ContentTemplateSelectorSet { get; set; } public bool ContentStringFormatSet { get; set; } //GridViewRowPresenter public bool ColumnsSet { get; set; } public override void Reset() { _xamlType = null; Property = null; Name = null; NameSet = false; IsInNameScope = false; Instance = null; ContentSet = false; ContentSourceSet = false; ContentSource = null; ContentTemplateSet = false; ContentTemplateSelectorSet = false; ContentStringFormatSet = false; IsInNameScope = false; if (HasNamespaces) { _namespaces = null; } } public FrugalObjectList Namespaces { get { if (_namespaces == null) { _namespaces = new FrugalObjectList (); } return _namespaces; } } public bool HasNamespaces { get { return _namespaces != null && _namespaces.Count > 0; } } public override string ToString() { string type = (this.Type == null) ? String.Empty : this.Type.Name; string prop = (this.Property == null) ? "-" : this.Property.Name; string inst = (Instance == null) ? "-" : "*"; string res = String.Format(CultureInfo.InvariantCulture, "{0}.{1} inst={2}", type, prop, inst); return res; } } internal class StackOfFrames : XamlContextStack { public StackOfFrames() : base(()=>new Frame()) { } public void Push(System.Xaml.XamlType xamlType, string name) { bool isInNameScope = false; bool isInStyleOrTemplate = false; if (Depth == 0 || CurrentFrame.Type != null) { if (Depth > 0) { isInNameScope = FrameworkTemplate.IsNameScope(CurrentFrame.Type) || CurrentFrame.IsInNameScope; isInStyleOrTemplate = CurrentFrame.IsInStyleOrTemplate || typeof(FrameworkTemplate).IsAssignableFrom(CurrentFrame.Type.UnderlyingType) || typeof(Style).IsAssignableFrom(CurrentFrame.Type.UnderlyingType); } base.PushScope(); } CurrentFrame.Type = xamlType; CurrentFrame.Name = name; CurrentFrame.IsInNameScope = isInNameScope; CurrentFrame.IsInStyleOrTemplate = isInStyleOrTemplate; } public void AddNamespace(System.Xaml.NamespaceDeclaration nsd) { bool isInNameScope = false; if (Depth == 0 || CurrentFrame.Type != null) { if (Depth > 0) { isInNameScope = FrameworkTemplate.IsNameScope(CurrentFrame.Type) || CurrentFrame.IsInNameScope; } base.PushScope(); } CurrentFrame.Namespaces.Add(nsd); CurrentFrame.IsInNameScope = isInNameScope; } public FrugalObjectList InScopeNamespaces { get { FrugalObjectList allNamespaces = null; Frame iteratorFrame = this.CurrentFrame; while (iteratorFrame != null) { if (iteratorFrame.HasNamespaces) { if (allNamespaces == null) // late allocation cause there is often nothing. { allNamespaces = new FrugalObjectList (); } for (int idx = 0; idx < iteratorFrame.Namespaces.Count; idx++) { allNamespaces.Add(iteratorFrame.Namespaces[idx]); } } iteratorFrame = (Frame)iteratorFrame.Previous; } return allNamespaces; } } } /// /// Critical: Sets critical property LoadPermission so we can assert the right permission /// when instantiating the template. /// Sets critical field _templateLoadData.Reader, which needs to be kept in [....] with LoadPermission. /// Safe: Demands the requested permission before setting the fields. Sets both fields together /// so they stay in [....]. /// [SecurityCritical, SecurityTreatAsSafe] internal TemplateContent(System.Xaml.XamlReader xamlReader, IXamlObjectWriterFactory factory, IServiceProvider context) { TemplateLoadData = new TemplateLoadData(); ObjectWriterFactory = factory; SchemaContext = xamlReader.SchemaContext; ObjectWriterParentSettings = factory.GetParentSettings(); XamlAccessLevel accessLevel = ObjectWriterParentSettings.AccessLevel; if (accessLevel != null) { XamlLoadPermission loadPermission = new XamlLoadPermission(accessLevel); loadPermission.Demand(); LoadPermission = loadPermission; } TemplateLoadData.Reader = xamlReader; Initialize(context); } private void Initialize(IServiceProvider context) { XamlObjectWriterSettings settings = System.Windows.Markup.XamlReader. CreateObjectWriterSettings(ObjectWriterParentSettings); settings.AfterBeginInitHandler = delegate(object sender, System.Xaml.XamlObjectEventArgs args) { //In several situations this even will happen with Stack == null. //If this event was on the XOW, perhaps we could stop listening in some circumstances? if (Stack != null && Stack.Depth > 0) { Stack.CurrentFrame.Instance = args.Instance; } }; settings.SkipProvideValueOnRoot = true; TemplateLoadData.ObjectWriter = ObjectWriterFactory.GetXamlObjectWriter(settings); TemplateLoadData.ServiceProviderWrapper = new ServiceProviderWrapper(context, SchemaContext); IRootObjectProvider irop = context.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider; if (irop != null) { TemplateLoadData.RootObject = irop.RootObject; } } // This needs to take the XamlReader passed in and sort it into things that // can be shared and can't be shared. Anything that can't be shared // needs to be stored away so that we can instantiate at template load time. // Shared values need to be stored into the shared value tables. internal void ParseXaml() { Debug.Assert(TemplateLoadData.Reader != null); StackOfFrames stack = new StackOfFrames(); TemplateLoadData.ServiceProviderWrapper.Frames = stack; OwnerTemplate.StyleConnector = TemplateLoadData.RootObject as IStyleConnector; TemplateLoadData.RootObject = null; ListsharedProperties = new List (); int nameNumber = 1; ParseTree(stack, sharedProperties, ref nameNumber); // Items panel templates have special rules if (OwnerTemplate is ItemsPanelTemplate) { PropertyValue pv = new PropertyValue(); pv.ValueType = PropertyValueType.Set; pv.ChildName = TemplateLoadData.RootName; pv.ValueInternal = true; pv.Property = Panel.IsItemsHostProperty; sharedProperties.Add(pv); } // Add all the shared properties to the special table for (int i = 0; i < sharedProperties.Count; i++) { PropertyValue value = sharedProperties[i]; if (value.ValueInternal is TemplateBindingExtension) // Use ValueInternal to avoid creating deferred resource references { value.ValueType = PropertyValueType.TemplateBinding; } else if (value.ValueInternal is DynamicResourceExtension) // Use ValueInternal to avoid creating deferred resource references { DynamicResourceExtension dynamicResource = value.Value as DynamicResourceExtension; value.ValueType = PropertyValueType.Resource; value.ValueInternal = dynamicResource.ResourceKey; } else { StyleHelper.SealIfSealable(value.ValueInternal); } StyleHelper.UpdateTables(ref value, ref OwnerTemplate.ChildRecordFromChildIndex, ref OwnerTemplate.TriggerSourceRecordFromChildIndex, ref OwnerTemplate.ResourceDependents, ref OwnerTemplate._dataTriggerRecordFromBinding, OwnerTemplate.ChildIndexFromChildName, ref OwnerTemplate._hasInstanceValues); } //We don't need to use this object writer anymore so let's clear it out. TemplateLoadData.ObjectWriter = null; } /// /// Critical: FrameworkTemplate relies on the integrity of this reader to assert LoadPermission. /// Accesses critical field _xamlNodeList. /// Safe: _xamlNodeList integrity is guarded by SecurityCritical. /// Doesn't leak _xamlNodeList.Writer, just provides a reader. /// [SecurityCritical, SecurityTreatAsSafe] internal System.Xaml.XamlReader PlayXaml() { return _xamlNodeList.GetReader(); } ////// Critical to write: Specifies the permission that can be asserted when loading the XAML /// from PlayXaml() or TemplateLoadData.Reader, to allow it to access non-public members. /// Critical to read: Can be mutated via FromXml method. /// internal XamlLoadPermission LoadPermission { [SecurityCritical] get; [SecurityCritical] set; } //Called by FrameworkTemplate.Seal() to let go of the data used for Template Load. ////// Critical: Resets _templateLoadData to null, which contains the critical Reader. /// Safe: It is ok to cause this object to be GCable, to preserve memory, as the data /// from Reader has been transferred to the critical _xamlNodeList. /// [SecurityCritical, SecurityTreatAsSafe] internal void ResetTemplateLoadData() { TemplateLoadData = null; } //+------------------------------------------------------------------------------------------ // // UpdateSharedList // // Update the last items on the shared DependencyProperty list with the // name of the current element. // //+----------------------------------------------------------------------------------------- private void UpdateSharedPropertyNames(string name, ListsharedProperties, XamlType type) { #if DEBUG int lastIndex = OwnerTemplate.LastChildIndex; #endif // Generate an index for this name int childIndex = StyleHelper.CreateChildIndexFromChildName(name, OwnerTemplate); OwnerTemplate.ChildNames.Add(name); OwnerTemplate.ChildTypeFromChildIndex.Add(childIndex, type.UnderlyingType); #if DEBUG Debug.Assert(childIndex == lastIndex); #endif // The tail of the _sharedProperties list has the properties for this element, // all with no name. Fill in the name now. for (int i = sharedProperties.Count - 1; i >= 0; i--) { PropertyValue sdp = sharedProperties[i]; if (sdp.ChildName == null) { sdp.ChildName = name; } else { break; } sharedProperties[i] = sdp; } } /// /// Critical: Asserts LoadPermission /// Safe: The node stream that we pass to the ObjectWriter (and copy into _xamlNodeList) /// comes from _reader, and we demanded LoadPermission when that was passed in /// (in the constructor). /// [SecurityCritical, SecurityTreatAsSafe] private void ParseTree( StackOfFrames stack, ListsharedProperties, ref int nameNumber) { if (LoadPermission != null) { LoadPermission.Assert(); try { ParseNodes(stack, sharedProperties, ref nameNumber); } finally { CodeAccessPermission.RevertAssert(); } } else { ParseNodes(stack, sharedProperties, ref nameNumber); } } /// /// Critical: Accesses critical TemplateLoadData.Reader and _xamlNodeList /// Safe: The node stream that we copy into critical _xamlNodeList comes from the critical Reader. /// At this point, it is ok to null out the reader, to release the memory. /// [SecurityCritical, SecurityTreatAsSafe] private void ParseNodes( StackOfFrames stack, ListsharedProperties, ref int nameNumber) { _xamlNodeList = new XamlNodeList(SchemaContext); System.Xaml.XamlWriter writer = _xamlNodeList.Writer; System.Xaml.XamlReader reader = TemplateLoadData.Reader; while (reader.Read()) { object newValue; bool reProcessOnApply = ParseNode(reader, stack, sharedProperties, ref nameNumber, out newValue); if (reProcessOnApply) { if (newValue == DependencyProperty.UnsetValue) { writer.WriteNode(reader); } else { writer.WriteValue(newValue); } } } writer.Close(); TemplateLoadData.Reader = null; } // Returns true if the node should be re-processed on template apply. If the value is // shareable, the node doesn't need to be reprocessed, so we return false. private bool ParseNode(System.Xaml.XamlReader xamlReader, StackOfFrames stack, List sharedProperties, ref int nameNumber, out object newValue) { newValue = DependencyProperty.UnsetValue; switch (xamlReader.NodeType) { case System.Xaml.XamlNodeType.StartObject: { // Process the load-time binding of StaticResources. // SR usage in RD's will be instance Values coming from the BAML reader. // SR in node list form are from inline templates. (or XML text) // V3 also hard codes type EQUALITY against StaticResourceExtension if (xamlReader.Type.UnderlyingType == typeof(StaticResourceExtension)) { // Use the shared XamlObjectWriter but clear the state first XamlObjectWriter writer = TemplateLoadData.ObjectWriter; writer.Clear(); WriteNamespaces(writer, stack.InScopeNamespaces, null); // newValue is an out parameter that will change the value in the processed node stream. newValue = LoadTimeBindUnshareableStaticResource(xamlReader, writer); return true; } // Check to see if the parent object needs to have the name set if (stack.Depth > 0 && stack.CurrentFrame.NameSet == false && stack.CurrentFrame.Type != null && !stack.CurrentFrame.IsInNameScope && !stack.CurrentFrame.IsInStyleOrTemplate) { // FEs and FCEs need to be added to the name to index map if (typeof(FrameworkElement).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType) || typeof(FrameworkContentElement).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType)) { // All FEs and FCEs must have a name. We assign a default if there was no name provided string name = nameNumber++.ToString(CultureInfo.InvariantCulture) + "_T"; UpdateSharedPropertyNames(name, sharedProperties, stack.CurrentFrame.Type); stack.CurrentFrame.Name = name; } stack.CurrentFrame.NameSet = true; } if (RootType == null) { RootType = xamlReader.Type; } stack.Push(xamlReader.Type, null); } break; case System.Xaml.XamlNodeType.GetObject: { // Check to see if the parent object needs to have the name set if (stack.Depth > 0 && stack.CurrentFrame.NameSet == false && stack.CurrentFrame.Type != null && !stack.CurrentFrame.IsInNameScope && !stack.CurrentFrame.IsInStyleOrTemplate) { // FEs and FCEs need to be added to the name to index map if (typeof(FrameworkElement).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType) || typeof(FrameworkContentElement).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType)) { // All FEs and FCEs must have a name. We assign a default if there was no name provided string name = nameNumber++.ToString(CultureInfo.InvariantCulture) + "_T"; UpdateSharedPropertyNames(name, sharedProperties, stack.CurrentFrame.Type); stack.CurrentFrame.Name = name; } stack.CurrentFrame.NameSet = true; } XamlType type = stack.CurrentFrame.Property.Type; if (RootType == null) { RootType = type; } stack.Push(type, null); } break; case System.Xaml.XamlNodeType.EndObject: if (!stack.CurrentFrame.IsInStyleOrTemplate) { if (stack.CurrentFrame.NameSet == false && !stack.CurrentFrame.IsInNameScope) { // FEs and FCEs need to be added to the name to index map if (typeof(FrameworkElement).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType) || typeof(FrameworkContentElement).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType)) { // All FEs and FCEs must have a name. We assign a default if there was no name provided string name = nameNumber++.ToString(CultureInfo.InvariantCulture) + "_T"; UpdateSharedPropertyNames(name, sharedProperties, stack.CurrentFrame.Type); stack.CurrentFrame.Name = name; } stack.CurrentFrame.NameSet = true; } if (TemplateLoadData.RootName == null && stack.Depth == 1) { TemplateLoadData.RootName = stack.CurrentFrame.Name; } // ContentPresenters have special rules for aliasing Content if (typeof(ContentPresenter).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType)) { AutoAliasContentPresenter( OwnerTemplate.TargetTypeInternal, stack.CurrentFrame.ContentSource, stack.CurrentFrame.Name, ref OwnerTemplate.ChildRecordFromChildIndex, ref OwnerTemplate.TriggerSourceRecordFromChildIndex, ref OwnerTemplate.ResourceDependents, ref OwnerTemplate._dataTriggerRecordFromBinding, ref OwnerTemplate._hasInstanceValues, OwnerTemplate.ChildIndexFromChildName, stack.CurrentFrame.ContentSet, stack.CurrentFrame.ContentSourceSet, stack.CurrentFrame.ContentTemplateSet, stack.CurrentFrame.ContentTemplateSelectorSet, stack.CurrentFrame.ContentStringFormatSet ); } // GridViewRowPresenters have special rules for aliasing Content if (typeof(GridViewRowPresenter).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType)) { AutoAliasGridViewRowPresenter( OwnerTemplate.TargetTypeInternal, stack.CurrentFrame.ContentSource, stack.CurrentFrame.Name, ref OwnerTemplate.ChildRecordFromChildIndex, ref OwnerTemplate.TriggerSourceRecordFromChildIndex, ref OwnerTemplate.ResourceDependents, ref OwnerTemplate._dataTriggerRecordFromBinding, ref OwnerTemplate._hasInstanceValues, OwnerTemplate.ChildIndexFromChildName, stack.CurrentFrame.ContentSet, stack.CurrentFrame.ColumnsSet ); } } stack.PopScope(); break; case System.Xaml.XamlNodeType.StartMember: stack.CurrentFrame.Property = xamlReader.Member; if (!stack.CurrentFrame.IsInStyleOrTemplate) { // Need to know if these properties are set for // autoaliasing. if (typeof(GridViewRowPresenter).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType)) { if (xamlReader.Member.Name == "Content") stack.CurrentFrame.ContentSet = true; else if (xamlReader.Member.Name == "Columns") stack.CurrentFrame.ColumnsSet = true; } else if (typeof(ContentPresenter).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType)) { if (xamlReader.Member.Name == "Content") stack.CurrentFrame.ContentSet = true; else if (xamlReader.Member.Name == "ContentTemplate") stack.CurrentFrame.ContentTemplateSet = true; else if (xamlReader.Member.Name == "ContentTemplateSelector") stack.CurrentFrame.ContentTemplateSelectorSet = true; else if (xamlReader.Member.Name == "ContentStringFormat") stack.CurrentFrame.ContentStringFormatSet = true; else if (xamlReader.Member.Name == "ContentSource") stack.CurrentFrame.ContentSourceSet = true; } if (!stack.CurrentFrame.IsInNameScope && xamlReader.Member.IsDirective == false) { // Try to see if the property is shareable PropertyValue? sharedValue; var iReader = xamlReader as IXamlIndexingReader; Debug.Assert(iReader != null, "Template's Reader is not a Indexing Reader"); bool sharable = false; int savedIdx = iReader.CurrentIndex; try { sharable = TrySharingProperty(xamlReader, stack.CurrentFrame.Type, stack.CurrentFrame.Name, stack.InScopeNamespaces, out sharedValue); } catch { sharable = false; sharedValue = null; } // Property is NOT shareable. // Back-up and add the unsharable section. if (!sharable) { iReader.CurrentIndex = savedIdx; break; } else { // Value can be shared. // Add it to the shared properties list Debug.Assert(sharedValue != null); sharedProperties.Add(sharedValue.Value); if (typeof(GridViewRowPresenter). IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType) || typeof(ContentPresenter). IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType)) { if (sharedValue.Value.Property.Name == "ContentSource") { stack.CurrentFrame.ContentSource = sharedValue.Value.ValueInternal as String; // if (!(sharedValue.Value.ValueInternal is String) && sharedValue.Value.ValueInternal != null) { stack.CurrentFrame.ContentSourceSet = false; } } } } return false; } } break; case System.Xaml.XamlNodeType.EndMember: stack.CurrentFrame.Property = null; break; case System.Xaml.XamlNodeType.Value: if (!stack.CurrentFrame.IsInStyleOrTemplate) { if (FrameworkTemplate.IsNameProperty(stack.CurrentFrame.Property, stack.CurrentFrame.Type)) { string name = xamlReader.Value as String; stack.CurrentFrame.Name = name; stack.CurrentFrame.NameSet = true; if (TemplateLoadData.RootName == null) { TemplateLoadData.RootName = name; } if (!stack.CurrentFrame.IsInNameScope) { // FEs and FCEs need to be added to the name to index map if (typeof(FrameworkElement).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType) || typeof(FrameworkContentElement).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType)) { TemplateLoadData.NamedTypes.Add(name, stack.CurrentFrame.Type); // All FEs and FCEs must have a name. We assign a default if there was no name provided UpdateSharedPropertyNames(name, sharedProperties, stack.CurrentFrame.Type); } } } if (typeof(ContentPresenter).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType) && stack.CurrentFrame.Property.Name == "ContentSource") { stack.CurrentFrame.ContentSource = xamlReader.Value as String; } } object value = xamlReader.Value; StaticResourceExtension staticResource = value as StaticResourceExtension; // Process the load-time binding of StaticResources. // If this is a simple inline template then the StaticResources will be StaticResourcesExtensions // [They also might be node-lists, see LoadTimeBindUnshareableStaticResource()] // and we do a full search for the location of the value and hold a deferred reference to it. // If the template was in a Resource Dictionary, the RD would have already replaced the // StaticResource with a StaticResourceHolder and we need to do a "live stack only" walk // to look for RD's that might be closer, for better values. if (staticResource != null) { object obj = null; // Inline Template case: if (staticResource.GetType() == typeof(StaticResourceExtension)) { obj = staticResource.TryProvideValueInternal(TemplateLoadData.ServiceProviderWrapper, true/*allowDeferredReference*/, true/*mustReturnDeferredResourceReference*/); } // Template in a Resource Dictionary entry case: else if (staticResource.GetType() == typeof(StaticResourceHolder)) { obj = staticResource.FindResourceInDeferredContent(TemplateLoadData.ServiceProviderWrapper, true/*allowDeferredReference*/, false/*mustReturnDeferredResourceReference*/); if (obj == DependencyProperty.UnsetValue) { obj = null; // value is only interesting if it improves the previous value. } } if (obj != null) { var deferredResourceReference = obj as DeferredResourceReference; // newValue is an out parameter that will change the value in the processed node stream. newValue = new StaticResourceHolder(staticResource.ResourceKey, deferredResourceReference); } } break; case System.Xaml.XamlNodeType.NamespaceDeclaration: // *** This code assumes that NamespaceDeclarations can only come before [Start|Get]Object. *** // This needs to be updated in the future to support it before properties & Values. if (!stack.CurrentFrame.IsInStyleOrTemplate) { // Check to see if the parent object needs to have the name set if (stack.Depth > 0 && stack.CurrentFrame.NameSet == false && stack.CurrentFrame.Type != null && !stack.CurrentFrame.IsInNameScope) { // FEs and FCEs need to be added to the name to index map if (typeof(FrameworkElement).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType) || typeof(FrameworkContentElement).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType)) { // All FEs and FCEs must have a name. We assign a default if there was no name provided string name = nameNumber++.ToString(CultureInfo.InvariantCulture) + "_T"; UpdateSharedPropertyNames(name, sharedProperties, stack.CurrentFrame.Type); stack.CurrentFrame.Name = name; } stack.CurrentFrame.NameSet = true; } } stack.AddNamespace(xamlReader.Namespace); break; case System.Xaml.XamlNodeType.None: break; } return true; } private StaticResourceExtension LoadTimeBindUnshareableStaticResource(Xaml.XamlReader xamlReader, XamlObjectWriter writer) { Debug.Assert(xamlReader.NodeType == Xaml.XamlNodeType.StartObject); Debug.Assert(xamlReader.Type.UnderlyingType == typeof(StaticResourceExtension)); // Loop through the nodes and create the StaticResource. Since objects could be nested inside the SRE, we need to keep // track of the number of start and end objects. int elementDepth = 0; do { writer.WriteNode(xamlReader); switch (xamlReader.NodeType) { case Xaml.XamlNodeType.StartObject: case Xaml.XamlNodeType.GetObject: elementDepth++; break; case Xaml.XamlNodeType.EndObject: elementDepth--; break; } } while (elementDepth > 0 && xamlReader.Read()); StaticResourceExtension resource = writer.Result as StaticResourceExtension; Debug.Assert(resource != null); // If the StaicResource was in NodeList form then it would not have been pre-resolved. // So do a full walk now, not a Live-Stack only. // Resolve the StaticResource value including lookup to the app and the theme DeferredResourceReference value = (DeferredResourceReference)resource.TryProvideValueInternal(TemplateLoadData.ServiceProviderWrapper, true/*allowDeferredReference*/, true/*mustReturnDeferredResourceReference*/); // Return the value that will be written out the unshareable node list; return new StaticResourceHolder(resource.ResourceKey, value); } // Tries to see if the property can be shared. Returns true property is shared. // Caller is responsible for bookmarking. // // Only property values can be shared. We try to share anything that is a Freezable, // ME, Style, Template. However, if the parent type is named, we can't share anything. // However, TemplateBindingExtension are ALWAYS shared private bool TrySharingProperty(System.Xaml.XamlReader xamlReader, XamlType parentType, string parentName, FrugalObjectList previousNamespaces, out PropertyValue? sharedValue) { Debug.Assert(xamlReader.NodeType == System.Xaml.XamlNodeType.StartMember); // All DependencyPropertys are wrapped in WpfXamlMembers. If it's not a WpfXamlMember, it's not a DependencyProperty WpfXamlMember xamlProperty = xamlReader.Member as WpfXamlMember; if (xamlProperty == null) { sharedValue = null; return false; } DependencyProperty property = xamlProperty.DependencyProperty; // We can only share DPs. Return the node pipe with just the SP in it if (property == null) { sharedValue = null; return false; } // Also, we cannot share the name property if (xamlReader.Member == parentType.GetAliasedProperty(XamlLanguage.Name)) { sharedValue = null; return false; } // We can only share properties on FEs and FCEs if (!typeof(FrameworkElement).IsAssignableFrom(parentType.UnderlyingType) && !typeof(FrameworkContentElement).IsAssignableFrom(parentType.UnderlyingType)) { sharedValue = null; return false; } // Check if the value is shareable. // We are in a StartMember so we assume there is another node to read. xamlReader.Read(); // Check if the value is shareable. if (xamlReader.NodeType == System.Xaml.XamlNodeType.Value) { Type typeofValue = xamlReader.Value.GetType(); if (!CheckSpecialCasesShareable(typeofValue, property)) { sharedValue = null; return false; } if (!(xamlReader.Value is String)) { return TrySharingValue(property, xamlReader.Value, parentName, xamlReader, true, out sharedValue); } else { object value = xamlReader.Value; TypeConverter converter = null; if (xamlProperty.TypeConverter != null) { converter = xamlProperty.TypeConverter.ConverterInstance; } else if (xamlProperty.Type.TypeConverter != null) { converter = xamlProperty.Type.TypeConverter.ConverterInstance; } if (converter != null) { value = converter.ConvertFrom(TemplateLoadData.ServiceProviderWrapper, CultureInfo.InvariantCulture, value); } return TrySharingValue(property, value, parentName, xamlReader, true, out sharedValue); } } else if (xamlReader.NodeType == System.Xaml.XamlNodeType.StartObject || xamlReader.NodeType == System.Xaml.XamlNodeType.NamespaceDeclaration) { FrugalObjectList localNamespaces = null; if (xamlReader.NodeType == System.Xaml.XamlNodeType.NamespaceDeclaration) { localNamespaces = new FrugalObjectList (); while (xamlReader.NodeType == System.Xaml.XamlNodeType.NamespaceDeclaration) { localNamespaces.Add(xamlReader.Namespace); xamlReader.Read(); } } Debug.Assert(xamlReader.NodeType == System.Xaml.XamlNodeType.StartObject); Type typeofValue = xamlReader.Type.UnderlyingType; if (!CheckSpecialCasesShareable(typeofValue, property)) { sharedValue = null; return false; } if (!IsTypeShareable(xamlReader.Type.UnderlyingType)) { sharedValue = null; return false; } else { // Keep track of the number of SOs and EOs // Perf note: This stack may be sharable if this gets hit multiple times per TemplateContent. StackOfFrames frames = new StackOfFrames(); frames.Push(xamlReader.Type, null); bool insideTemplate = false; bool insideStyle = false; // We don't care about named elements inside of Templates or Styles. We allow it to just work. if (typeof(FrameworkTemplate).IsAssignableFrom(xamlReader.Type.UnderlyingType)) { insideTemplate = true; Stack = frames; } else if (typeof(Style).IsAssignableFrom(xamlReader.Type.UnderlyingType)) { insideStyle = true; Stack = frames; } try { //Setup ObjectWriter to be able to create the right values XamlObjectWriter writer = TemplateLoadData.ObjectWriter; writer.Clear(); WriteNamespaces(writer, previousNamespaces, localNamespaces); writer.WriteNode(xamlReader); bool done = false; while (!done && xamlReader.Read()) { SkipFreeze(xamlReader); writer.WriteNode(xamlReader); switch (xamlReader.NodeType) { case System.Xaml.XamlNodeType.StartObject: if (typeof(StaticResourceExtension).IsAssignableFrom(xamlReader.Type.UnderlyingType)) { sharedValue = null; return false; } frames.Push(xamlReader.Type, null); break; case System.Xaml.XamlNodeType.GetObject: XamlType type = frames.CurrentFrame.Property.Type; frames.Push(type, null); break; case System.Xaml.XamlNodeType.EndObject: if (frames.Depth == 1) { return TrySharingValue(property, writer.Result, parentName, xamlReader, true, out sharedValue); } frames.PopScope(); break; case System.Xaml.XamlNodeType.StartMember: // Anything that is named cannot be shared if (!(insideStyle || insideTemplate) && FrameworkTemplate.IsNameProperty(xamlReader.Member, frames.CurrentFrame.Type)) { done = true; break; } frames.CurrentFrame.Property = xamlReader.Member; break; case System.Xaml.XamlNodeType.Value: if (typeof(StaticResourceExtension).IsAssignableFrom(xamlReader.Value.GetType())) { sharedValue = null; return false; } // We want to wire EventSetters for Styles but not wire // events inside of a FramewokrTemplate if (!insideTemplate && frames.CurrentFrame.Property == XamlLanguage.ConnectionId) { if (OwnerTemplate.StyleConnector != null) { OwnerTemplate.StyleConnector.Connect((int)xamlReader.Value, frames.CurrentFrame.Instance); } } break; } } // We've broken out of the while loop and haven't returned // The property is NOT shareable. sharedValue = null; return false; } finally { Stack = null; } } } else if (xamlReader.NodeType == System.Xaml.XamlNodeType.GetObject) { sharedValue = null; return false; } else { // Should never happen throw new System.Windows.Markup.XamlParseException(SR.Get(SRID.ParserUnexpectedEndEle)); } } private static bool CheckSpecialCasesShareable(Type typeofValue, DependencyProperty property) { if (typeofValue != typeof(DynamicResourceExtension) && typeofValue != typeof(TemplateBindingExtension) && typeofValue != typeof(TypeExtension) && typeofValue != typeof(StaticExtension)) { // Do not share in the case property type <: IList, Array, IDictionary to maintain compat with v3 // They wrapped with BamlCollectionHolder in these 3 cases so the value isn't shared. if (typeof(IList).IsAssignableFrom(property.PropertyType)) { return false; } if (property.PropertyType.IsArray) { return false; } if (typeof(IDictionary).IsAssignableFrom(property.PropertyType)) { return false; } } return true; } private static bool IsFreezableDirective(System.Xaml.XamlReader reader) { System.Xaml.XamlNodeType nodeType = reader.NodeType; if (nodeType == System.Xaml.XamlNodeType.StartMember) { System.Xaml.XamlMember member = reader.Member; return (member.IsUnknown && member.IsDirective && member.Name == "Freeze"); } return false; } private static void SkipFreeze(System.Xaml.XamlReader reader) { if (IsFreezableDirective(reader)) { reader.Read(); // V reader.Read(); // EM reader.Read(); // Next } } private bool TrySharingValue(DependencyProperty property, object value, string parentName, System.Xaml.XamlReader xamlReader, bool allowRecursive, out PropertyValue? sharedValue) { sharedValue = null; // Null is sharable. if (value != null && !IsTypeShareable(value.GetType())) { return false; } bool isValueShareable = true; if (value is Freezable) { // Check if it's a freezable and we can freeze it Freezable freezable = value as Freezable; if (freezable != null) { if (freezable.CanFreeze) { freezable.Freeze(); } else { // Object is not freezable, which means its // not shareable. isValueShareable = false; } } } else if (value is CollectionViewSource) { CollectionViewSource viewSource = value as CollectionViewSource; if (viewSource != null) { isValueShareable = viewSource.IsShareableInTemplate(); } } else if (value is MarkupExtension) { // Share the actual ME directly for these 3. if (value is BindingBase || value is TemplateBindingExtension || value is DynamicResourceExtension) { isValueShareable = true; } else if ((value is StaticResourceExtension) || (value is StaticResourceHolder)) { isValueShareable = false; } else { TemplateLoadData.ServiceProviderWrapper.SetData(_sharedDpInstance, property); value = (value as MarkupExtension).ProvideValue(TemplateLoadData.ServiceProviderWrapper); TemplateLoadData.ServiceProviderWrapper.Clear(); if (allowRecursive) { // Terminate recursive checking of provided value to prevent infinite loop return TrySharingValue(property, value, parentName, xamlReader, false, out sharedValue); } else { isValueShareable = true; } } } if (isValueShareable) { // If we're here, that means the property can be shared PropertyValue propertyValue = new PropertyValue(); propertyValue.Property = property; propertyValue.ChildName = parentName; propertyValue.ValueInternal = value; propertyValue.ValueType = PropertyValueType.Set; sharedValue = propertyValue; // Read the EndProperty so it's not going to be read by the outer reader xamlReader.Read(); Debug.Assert(xamlReader.NodeType == System.Xaml.XamlNodeType.EndMember); } return isValueShareable; } private bool IsTypeShareable(Type type) { if ( // We handle Freezables on an per-instance basis. typeof(Freezable).IsAssignableFrom(type) || // Well-known immutable CLR types type == typeof(string) || type == typeof(Uri) || type == typeof(Type) || // We assume MEs are shareable; the host object is responsible // for ensuring immutability. The exception is static resource // references, for which we have special support in templates. (typeof(MarkupExtension).IsAssignableFrom(type) && !typeof(StaticResourceExtension).IsAssignableFrom(type)) || // Styles & Templates are mostly shareable typeof(Style).IsAssignableFrom(type) || typeof(FrameworkTemplate).IsAssignableFrom(type) || // CVS might be shareable, wait for the instance check typeof(System.Windows.Data.CollectionViewSource).IsAssignableFrom(type) || // Value types are immutable by nature (type != null && type.IsValueType)) return true; return false; } private void WriteNamespaces(System.Xaml.XamlWriter writer, FrugalObjectList previousNamespaces, FrugalObjectList localNamespaces) { if (previousNamespaces != null) { for (int idx = 0; idx < previousNamespaces.Count; idx++) { writer.WriteNamespace(previousNamespaces[idx]); } } if (localNamespaces != null) { for (int idx = 0; idx < localNamespaces.Count; idx++) { writer.WriteNamespace(localNamespaces[idx]); } } } private static void AutoAliasContentPresenter( Type targetType, string contentSource, string templateChildName, ref FrugalStructList childRecordFromChildIndex, ref FrugalStructList > triggerSourceRecordFromChildIndex, ref FrugalStructList resourceDependents, ref HybridDictionary dataTriggerRecordFromBinding, ref bool hasInstanceValues, HybridDictionary childIndexFromChildName, bool isContentPropertyDefined, bool isContentSourceSet, bool isContentTemplatePropertyDefined, bool isContentTemplateSelectorPropertyDefined, bool isContentStringFormatPropertyDefined ) { if (String.IsNullOrEmpty(contentSource) && isContentSourceSet == false) contentSource = "Content"; if (!String.IsNullOrEmpty(contentSource) && !isContentPropertyDefined) { Debug.Assert(templateChildName != null); DependencyProperty dpContent = DependencyProperty.FromName(contentSource, targetType); DependencyProperty dpContentTemplate = DependencyProperty.FromName(contentSource + "Template", targetType); DependencyProperty dpContentTemplateSelector = DependencyProperty.FromName(contentSource + "TemplateSelector", targetType); DependencyProperty dpContentStringFormat = DependencyProperty.FromName(contentSource + "StringFormat", targetType); if (dpContent == null && isContentSourceSet) { throw new InvalidOperationException(SR.Get(SRID.MissingContentSource, contentSource, targetType)); } if (dpContent != null) { PropertyValue pv = new PropertyValue(); pv.ValueType = PropertyValueType.TemplateBinding; pv.ChildName = templateChildName; pv.ValueInternal = new TemplateBindingExtension(dpContent); pv.Property = ContentPresenter.ContentProperty; StyleHelper.UpdateTables(ref pv, ref childRecordFromChildIndex, ref triggerSourceRecordFromChildIndex, ref resourceDependents, ref dataTriggerRecordFromBinding, childIndexFromChildName, ref hasInstanceValues); } if (!isContentTemplatePropertyDefined && !isContentTemplateSelectorPropertyDefined && !isContentStringFormatPropertyDefined) { if (dpContentTemplate != null) { PropertyValue pv = new PropertyValue(); pv.ValueType = PropertyValueType.TemplateBinding; pv.ChildName = templateChildName; pv.ValueInternal = new TemplateBindingExtension(dpContentTemplate); pv.Property = ContentPresenter.ContentTemplateProperty; StyleHelper.UpdateTables(ref pv, ref childRecordFromChildIndex, ref triggerSourceRecordFromChildIndex, ref resourceDependents, ref dataTriggerRecordFromBinding, childIndexFromChildName, ref hasInstanceValues); } if (dpContentTemplateSelector != null) { PropertyValue pv = new PropertyValue(); pv.ValueType = PropertyValueType.TemplateBinding; pv.ChildName = templateChildName; pv.ValueInternal = new TemplateBindingExtension(dpContentTemplateSelector); pv.Property = ContentPresenter.ContentTemplateSelectorProperty; StyleHelper.UpdateTables(ref pv, ref childRecordFromChildIndex, ref triggerSourceRecordFromChildIndex, ref resourceDependents, ref dataTriggerRecordFromBinding, childIndexFromChildName, ref hasInstanceValues); } if (dpContentStringFormat != null) { PropertyValue pv = new PropertyValue(); pv.ValueType = PropertyValueType.TemplateBinding; pv.ChildName = templateChildName; pv.ValueInternal = new TemplateBindingExtension(dpContentStringFormat); pv.Property = ContentPresenter.ContentStringFormatProperty; StyleHelper.UpdateTables(ref pv, ref childRecordFromChildIndex, ref triggerSourceRecordFromChildIndex, ref resourceDependents, ref dataTriggerRecordFromBinding, childIndexFromChildName, ref hasInstanceValues); } } } } private static void AutoAliasGridViewRowPresenter( Type targetType, string contentSource, string childName, ref FrugalStructList childRecordFromChildIndex, ref FrugalStructList > triggerSourceRecordFromChildIndex, ref FrugalStructList resourceDependents, ref HybridDictionary dataTriggerRecordFromBinding, ref bool hasInstanceValues, HybridDictionary childIndexFromChildID, bool isContentPropertyDefined, bool isColumnsPropertyDefined ) { // if (!isContentPropertyDefined) { DependencyProperty dpContent = DependencyProperty.FromName("Content", targetType); if (dpContent != null) { PropertyValue propertyValue = new PropertyValue(); propertyValue.ValueType = PropertyValueType.TemplateBinding; propertyValue.ChildName = childName; propertyValue.ValueInternal = new TemplateBindingExtension(dpContent); propertyValue.Property = GridViewRowPresenter.ContentProperty; StyleHelper.UpdateTables(ref propertyValue, ref childRecordFromChildIndex, ref triggerSourceRecordFromChildIndex, ref resourceDependents, ref dataTriggerRecordFromBinding, childIndexFromChildID, ref hasInstanceValues); } } // if (!isColumnsPropertyDefined) { PropertyValue propertyValue = new PropertyValue(); propertyValue.ValueType = PropertyValueType.TemplateBinding; propertyValue.ChildName = childName; propertyValue.ValueInternal = new TemplateBindingExtension(GridView.ColumnCollectionProperty); propertyValue.Property = GridViewRowPresenter.ColumnsProperty; StyleHelper.UpdateTables(ref propertyValue, ref childRecordFromChildIndex, ref triggerSourceRecordFromChildIndex, ref resourceDependents, ref dataTriggerRecordFromBinding, childIndexFromChildID, ref hasInstanceValues); } } internal XamlType RootType { get; private set; } internal XamlType GetTypeForName(string name) { return TemplateLoadData.NamedTypes[name]; } internal FrameworkTemplate OwnerTemplate { get; set; } internal IXamlObjectWriterFactory ObjectWriterFactory { get; private set; } internal XamlObjectWriterSettings ObjectWriterParentSettings { get; private set; } internal XamlSchemaContext SchemaContext { get; private set; } /// /// Critical to write: The XAML in this field is loaded with the privilege specified in LoadPermission. /// Critical to read: Consumers can modify the contents of this object via its Writer property. /// //_xamlNodeList is the postProcessed list, not the original template nodes. TemplateContentConverter // and TemplateContent do that processing. [SecurityCritical] internal XamlNodeList _xamlNodeList = null; private static SharedDp _sharedDpInstance = new SharedDp(null, null, null); private StackOfFrames Stack { get { return TemplateLoadData.Stack; } set { TemplateLoadData.Stack = value; } } //This will be nulled out when the FrameworkTemplate is sealed. ////// Critical to write: The Reader in the TemplateLoadData stored on this object /// is security critical. /// internal TemplateLoadData TemplateLoadData { get; [SecurityCritical] set; } internal class ServiceProviderWrapper : ITypeDescriptorContext, IXamlTypeResolver, IXamlNamespaceResolver, IProvideValueTarget { private IServiceProvider _services; internal StackOfFrames Frames { get; set; } private XamlSchemaContext _schemaContext; private Object _targetObject; private Object _targetProperty; public ServiceProviderWrapper(IServiceProvider services, XamlSchemaContext schemaContext) { _services = services; _schemaContext = schemaContext; } #region IServiceProvider Members object IServiceProvider.GetService(Type serviceType) { if (serviceType == typeof(IXamlTypeResolver)) { return this; } else if (serviceType == typeof(IProvideValueTarget)) { return this; } else { return _services.GetService(serviceType); } } #endregion #region IXamlTypeResolver Members Type IXamlTypeResolver.Resolve(string qualifiedTypeName) { return _schemaContext.GetXamlType(XamlTypeName.Parse(qualifiedTypeName, this)).UnderlyingType; } #endregion #region IXamlNamespaceResolver Members string IXamlNamespaceResolver.GetNamespace(string prefix) { FrugalObjectListnamespaces = Frames.InScopeNamespaces; if (namespaces != null) { for (int idx = 0; idx < namespaces.Count; idx++) { if (namespaces[idx].Prefix == prefix) { return namespaces[idx].Namespace; } } } return ((IXamlNamespaceResolver)_services.GetService(typeof(IXamlNamespaceResolver))).GetNamespace(prefix); } IEnumerable IXamlNamespaceResolver.GetNamespacePrefixes() { throw new NotImplementedException(); } #endregion #region ITypeDescriptorContext Members IContainer ITypeDescriptorContext.Container { get { return null; } } object ITypeDescriptorContext.Instance { get { return null; } } void ITypeDescriptorContext.OnComponentChanged() { } bool ITypeDescriptorContext.OnComponentChanging() { return false; } PropertyDescriptor ITypeDescriptorContext.PropertyDescriptor { get { return null; } } #endregion public void SetData(Object targetObject, Object targetProperty) { _targetObject = targetObject; _targetProperty = targetProperty; } public void Clear() { _targetObject = null; _targetProperty = null; } Object IProvideValueTarget.TargetObject { get { return _targetObject; } } Object IProvideValueTarget.TargetProperty { get { return _targetProperty; } } } } //This class is meant to hold any data that a TemplateContent needs during TemplateLoad // that isn't needed by a FrameworkTemplate during TemplateApply. internal class TemplateLoadData { internal TemplateLoadData() { } internal TemplateContent.StackOfFrames Stack { get; set; } internal Dictionary _namedTypes; internal Dictionary NamedTypes { get { if (_namedTypes == null) _namedTypes = new Dictionary (); return _namedTypes; } } /// /// Critical to write: The XAML in this field is loaded with the privilege specified in LoadPermission. /// Safe to read: The object in itself carries no privilege. /// internal System.Xaml.XamlReader Reader { get; [SecurityCritical] set; } internal string RootName { get; set; } internal object RootObject { get; set; } internal TemplateContent.ServiceProviderWrapper ServiceProviderWrapper { get; set; } internal XamlObjectWriter ObjectWriter { get; set; } } } // 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
- HttpCookieCollection.cs
- StreamingContext.cs
- PointCollection.cs
- WebPartManagerInternals.cs
- processwaithandle.cs
- SoapExtension.cs
- WinFormsSecurity.cs
- RadialGradientBrush.cs
- FixedSOMTable.cs
- StorageMappingItemLoader.cs
- AttributeCollection.cs
- TriggerAction.cs
- _BasicClient.cs
- CorrelationManager.cs
- XomlDesignerLoader.cs
- WebServiceMethodData.cs
- TerminatorSinks.cs
- Image.cs
- UserPreferenceChangedEventArgs.cs
- BindingSource.cs
- InkCollectionBehavior.cs
- DynamicDiscoSearcher.cs
- ClientWindowsAuthenticationMembershipProvider.cs
- isolationinterop.cs
- DateBoldEvent.cs
- GridEntry.cs
- RetrieveVirtualItemEventArgs.cs
- RowToFieldTransformer.cs
- ParameterReplacerVisitor.cs
- ModelVisual3D.cs
- EventLogRecord.cs
- XsdBuildProvider.cs
- LowerCaseStringConverter.cs
- ContainerCodeDomSerializer.cs
- Table.cs
- DecoderBestFitFallback.cs
- AsyncResult.cs
- XpsPackagingException.cs
- TrustLevel.cs
- SqlProcedureAttribute.cs
- BinaryNode.cs
- Message.cs
- ScrollProviderWrapper.cs
- TableItemPatternIdentifiers.cs
- SwitchElementsCollection.cs
- WebServiceTypeData.cs
- shaperfactoryquerycacheentry.cs
- QueryConverter.cs
- DbDeleteCommandTree.cs
- HtmlListAdapter.cs
- SessionParameter.cs
- CompositeScriptReference.cs
- NavigationProperty.cs
- SlipBehavior.cs
- xdrvalidator.cs
- SymbolMethod.cs
- AmbientValueAttribute.cs
- MaskedTextBoxDesigner.cs
- FormsAuthentication.cs
- DataControlField.cs
- PrtTicket_Public.cs
- EventRoute.cs
- FileSystemInfo.cs
- Assert.cs
- DrawItemEvent.cs
- Directory.cs
- DisplayMemberTemplateSelector.cs
- DataObjectMethodAttribute.cs
- ResourceSetExpression.cs
- Button.cs
- Style.cs
- CodeDirectoryCompiler.cs
- _CommandStream.cs
- XmlLoader.cs
- SchemaNamespaceManager.cs
- SqlDataSourceCache.cs
- DelegatingConfigHost.cs
- WebPartConnectionsConfigureVerb.cs
- XslAstAnalyzer.cs
- SendActivityValidator.cs
- FlowLayoutPanel.cs
- Brushes.cs
- BrowserDefinitionCollection.cs
- XmlDataContract.cs
- InlineCollection.cs
- ToolStripOverflowButton.cs
- MatrixTransform.cs
- BitmapEffectInput.cs
- OpenFileDialog.cs
- NoneExcludedImageIndexConverter.cs
- QueryCreatedEventArgs.cs
- XmlSchemaAll.cs
- ScrollItemProviderWrapper.cs
- DataControlPagerLinkButton.cs
- DoubleConverter.cs
- AnnotationStore.cs
- DetailsViewCommandEventArgs.cs
- SubMenuStyleCollectionEditor.cs
- TypedTableBase.cs
- TextParentUndoUnit.cs