Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / wpf / src / Framework / System / Windows / ResourceReferenceExpression.cs / 2 / ResourceReferenceExpression.cs
//---------------------------------------------------------------------------- // // File: ResourceReferenceExpression.cs // // Description: // Expression to evaluate a ResourceReference. // // Copyright (C) 2003 by Microsoft Corporation. All rights reserved. // //--------------------------------------------------------------------------- using System; using System.ComponentModel; using System.Diagnostics; using System.Windows.Markup; using MS.Internal; namespace System.Windows { ////// Expression to evaluate a ResourceReference /// [TypeConverter(typeof(ResourceReferenceExpressionConverter))] internal class ResourceReferenceExpression : Expression { ////// Constructor for ResourceReferenceExpression /// /// /// Name of the resource being referenced /// public ResourceReferenceExpression(object resourceKey) { _resourceKey = resourceKey; } ////// List of sources of the ResourceReferenceExpression /// ///Sources list internal override DependencySource[] GetSources() { return null; } ////// Called to evaluate the ResourceReferenceExpression value /// /// DependencyObject being queried /// Property being queried ///Computed value. Unset if unavailable. internal override object GetValue(DependencyObject d, DependencyProperty dp) { if (d == null) { throw new ArgumentNullException("d"); } if (dp == null) { throw new ArgumentNullException("dp"); } // If the cached value is valid then return it if (ReadInternalState(InternalState.HasCachedResourceValue) == true) return _cachedResourceValue; object source; return GetRawValue(d, out source, dp); } // Clone a copy of this expression (this is used by Freezable.Copy) internal override Expression Copy( DependencyObject targetObject, DependencyProperty targetDP ) { return new ResourceReferenceExpression( ResourceKey ); } ////// Called to evaluate the ResourceReferenceExpression value /// /// DependencyObject being queried /// Source object that the resource is found on /// DependencyProperty ///Computed value. Unset if unavailable. ////// This routine has been separated from the above GetValue call because it is /// invoked by the ResourceReferenceExpressionConverter during serialization. /// internal object GetRawValue(DependencyObject d, out object source, DependencyProperty dp) { // Find the mentor node to invoke FindResource on. For example // /// Allows ResourceReferenceExpression to store set values /// /// DependencyObject being set /// Property being set /// Value being set ///true if ResourceReferenceExpression handled storing of the value internal override bool SetValue(DependencyObject d, DependencyProperty dp, object value) { return false; } ////// Notification that the ResourceReferenceExpression has been set as a property's value /// /// DependencyObject being set /// Property being set internal override void OnAttach(DependencyObject d, DependencyProperty dp) { _targetObject = d; _targetProperty = dp; FrameworkObject fo = new FrameworkObject(_targetObject); fo.HasResourceReference = true; if (!fo.IsValid) { // Listen for the InheritanceContextChanged event on the target node, // so that if this context hierarchy changes we can re-evaluate this expression. _targetObject.InheritanceContextChanged += new EventHandler(InvalidateExpressionValue); } } ////// Notification that the ResourceReferenceExpression has been removed as a property's value /// /// DependencyObject being cleared /// Property being cleared internal override void OnDetach(DependencyObject d, DependencyProperty dp) { // Invalidate all the caches InvalidateMentorCache(); if (!(_targetObject is FrameworkElement) && !(_targetObject is FrameworkContentElement)) { // Stop listening for the InheritanceContextChanged event on the target node _targetObject.InheritanceContextChanged -= new EventHandler(InvalidateExpressionValue); } _targetObject = null; _targetProperty = null; } ////// Key used to lookup the resource /// public object ResourceKey { get { return _resourceKey; } } ////// This method is called when the cached value of the resource has /// been invalidated. E.g. after a new Resources property is set somewhere /// in the ancestory. /// private void InvalidateCacheValue() { object resource = _cachedResourceValue; // If the old value was a DeferredResourceReference, it should be // removed from its Dictionary's list to avoid a leak (bug 1624666). DeferredResourceReference deferredResourceReference = _cachedResourceValue as DeferredResourceReference; if (deferredResourceReference != null) { if (deferredResourceReference.IsInflated) { // use the inflated value for the Freezable test below resource = deferredResourceReference.Value; } else { // stop listening for the Inflated event if (ReadInternalState(InternalState.IsListeningForInflated)) { deferredResourceReference.RemoveInflatedListener(this); WriteInternalState(InternalState.IsListeningForInflated, false); } } deferredResourceReference.RemoveFromDictionary(); } StopListeningForFreezableChanges(resource); _cachedResourceValue = null; WriteInternalState(InternalState.HasCachedResourceValue, false); } ////// This method is called to invalidate all the cached values held in /// this expression. This is called under the following 3 scenarios /// 1. InheritanceContext changes /// 2. Logical tree changes /// 3. ResourceDictionary changes /// This call is more pervasive than the InvalidateCacheValue method /// private void InvalidateMentorCache() { if (ReadInternalState(InternalState.IsMentorCacheValid) == true) { if (_mentorCache != null) { if (_mentorCache != _targetObject) { FrameworkElement mentorFE; FrameworkContentElement mentorFCE; Helper.DowncastToFEorFCE(_mentorCache, out mentorFE, out mentorFCE, true); // Your mentor is about to change, make sure you detach handlers for // the events that you were listening on the old mentor if (mentorFE != null) { mentorFE.ResourcesChanged -= new EventHandler(InvalidateExpressionValue); } else { mentorFCE.ResourcesChanged -= new EventHandler(InvalidateExpressionValue); } } // Drop the mentor cache _mentorCache = null; } // Mark the cache invalid WriteInternalState(InternalState.IsMentorCacheValid, false); } // Invalidate the cached value of the expression InvalidateCacheValue(); } ////// This event handler is called to invalidate the cached value held in /// this expression. This is called under the following 3 scenarios /// 1. InheritanceContext changes /// 2. Logical tree changes /// 3. ResourceDictionary changes /// internal void InvalidateExpressionValue(object sender, EventArgs e) { ResourcesChangedEventArgs args = e as ResourcesChangedEventArgs; if (args != null) { ResourcesChangeInfo info = args.Info; if (!info.IsTreeChange) { // This will happen when // 1. Theme changes // 2. Entire ResourceDictionary in the ancestry changes // 3. Single entry in a ResourceDictionary in the ancestry is changed // In all of the above cases it is sufficient to re-evaluate the cache // value alone. The mentor relation ships stay the same. InvalidateCacheValue(); } else { // This is the case of a logical tree change and hence we need to // re-evaluate both the mentor and the cached value. InvalidateMentorCache(); } } else { // There is no information provided by the EventArgs. Hence we // pessimistically invalidate both the mentor and the cached value. // This code path will execute when the InheritanceContext changes. InvalidateMentorCache(); } InvalidateTargetProperty(sender, e); } private void InvalidateTargetProperty(object sender, EventArgs e) { _targetObject.InvalidateProperty(_targetProperty); } private void InvalidateTargetSubProperty(object sender, EventArgs e) { _targetObject.NotifySubPropertyChange(_targetProperty); } private void ListenForFreezableChanges(object resource) { if (!ReadInternalState(InternalState.IsListeningForFreezableChanges)) { // If this value is an unfrozen Freezable object, we need // to listen to its changed event in order to properly update // the cache. Freezable resourceAsFreezable = resource as Freezable; if( resourceAsFreezable != null && !resourceAsFreezable.IsFrozen ) { resourceAsFreezable.Changed += new EventHandler(InvalidateTargetSubProperty); WriteInternalState(InternalState.IsListeningForFreezableChanges, true); } } } private void StopListeningForFreezableChanges(object resource) { if (ReadInternalState(InternalState.IsListeningForFreezableChanges)) { // If the old value was an unfrozen Freezable object, we need // to stop listening to its changed event. If the old value wasn't // frozen (hence we attached an listener) but has been frozen // since then, the change handler we had attached was already // discarded during the freeze so we don't care here. Freezable resourceAsFreezable = resource as Freezable; if( resourceAsFreezable != null && !resourceAsFreezable.IsFrozen ) { resourceAsFreezable.Changed -= new EventHandler(InvalidateTargetSubProperty); } // It is possible that a freezable was unfrozen during the call to ListForFreezableChanges // but was frozen before the call to StopListeningForFreezableChanges WriteInternalState(InternalState.IsListeningForFreezableChanges, false); } } // when a deferred resource reference is inflated, the value may need extra // work internal void OnDeferredResourceInflated(DeferredResourceReference deferredResourceReference) { // once the value is inflated, stop listening for the event deferredResourceReference.RemoveInflatedListener(this); WriteInternalState(InternalState.IsListeningForInflated, false); ListenForFreezableChanges(deferredResourceReference.Value); } // Extracts the required flag and returns // bool to indicate if it is set or unset private bool ReadInternalState(InternalState reqFlag) { return (_state & reqFlag) != 0; } // Sets or Unsets the required flag based on // the bool argument private void WriteInternalState(InternalState reqFlag, bool set) { if (set) { _state |= reqFlag; } else { _state &= (~reqFlag); } } private object _resourceKey; // Name of the resource being referenced by this expression // Cached value and a dirty bit. See GetValue. private object _cachedResourceValue; // Used to find the value for this expression when it is set on a non-FE/FCE. // The mentor is the FE/FCE that the FindResource method is invoked on. private DependencyObject _mentorCache; // Used by the change listener to fire invalidation. private DependencyObject _targetObject; private DependencyProperty _targetProperty; // Bit Fields used to store boolean flags private InternalState _state = InternalState.Default; // this is a byte (see def'n) ////// This enum represents the internal state of the RRE. /// Additional bools should be coalesced into this enum. /// [Flags] private enum InternalState : byte { Default = 0x00, HasCachedResourceValue = 0x01, IsMentorCacheValid = 0x02, DisableThrowOnResourceFailure = 0x04, IsListeningForFreezableChanges= 0x08, IsListeningForInflated = 0x10, } } ////// These EventArgs are used to pass additional /// information during a ResourcesChanged event /// internal class ResourcesChangedEventArgs : EventArgs { internal ResourcesChangedEventArgs(ResourcesChangeInfo info) { _info = info; } internal ResourcesChangeInfo Info { get { return _info; } } private ResourcesChangeInfo _info; } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved. //---------------------------------------------------------------------------- // // File: ResourceReferenceExpression.cs // // Description: // Expression to evaluate a ResourceReference. // // Copyright (C) 2003 by Microsoft Corporation. All rights reserved. // //--------------------------------------------------------------------------- using System; using System.ComponentModel; using System.Diagnostics; using System.Windows.Markup; using MS.Internal; namespace System.Windows { ////// Expression to evaluate a ResourceReference /// [TypeConverter(typeof(ResourceReferenceExpressionConverter))] internal class ResourceReferenceExpression : Expression { ////// Constructor for ResourceReferenceExpression /// /// /// Name of the resource being referenced /// public ResourceReferenceExpression(object resourceKey) { _resourceKey = resourceKey; } ////// List of sources of the ResourceReferenceExpression /// ///Sources list internal override DependencySource[] GetSources() { return null; } ////// Called to evaluate the ResourceReferenceExpression value /// /// DependencyObject being queried /// Property being queried ///Computed value. Unset if unavailable. internal override object GetValue(DependencyObject d, DependencyProperty dp) { if (d == null) { throw new ArgumentNullException("d"); } if (dp == null) { throw new ArgumentNullException("dp"); } // If the cached value is valid then return it if (ReadInternalState(InternalState.HasCachedResourceValue) == true) return _cachedResourceValue; object source; return GetRawValue(d, out source, dp); } // Clone a copy of this expression (this is used by Freezable.Copy) internal override Expression Copy( DependencyObject targetObject, DependencyProperty targetDP ) { return new ResourceReferenceExpression( ResourceKey ); } ////// Called to evaluate the ResourceReferenceExpression value /// /// DependencyObject being queried /// Source object that the resource is found on /// DependencyProperty ///Computed value. Unset if unavailable. ////// This routine has been separated from the above GetValue call because it is /// invoked by the ResourceReferenceExpressionConverter during serialization. /// internal object GetRawValue(DependencyObject d, out object source, DependencyProperty dp) { // Find the mentor node to invoke FindResource on. For example // /// Allows ResourceReferenceExpression to store set values /// /// DependencyObject being set /// Property being set /// Value being set ///true if ResourceReferenceExpression handled storing of the value internal override bool SetValue(DependencyObject d, DependencyProperty dp, object value) { return false; } ////// Notification that the ResourceReferenceExpression has been set as a property's value /// /// DependencyObject being set /// Property being set internal override void OnAttach(DependencyObject d, DependencyProperty dp) { _targetObject = d; _targetProperty = dp; FrameworkObject fo = new FrameworkObject(_targetObject); fo.HasResourceReference = true; if (!fo.IsValid) { // Listen for the InheritanceContextChanged event on the target node, // so that if this context hierarchy changes we can re-evaluate this expression. _targetObject.InheritanceContextChanged += new EventHandler(InvalidateExpressionValue); } } ////// Notification that the ResourceReferenceExpression has been removed as a property's value /// /// DependencyObject being cleared /// Property being cleared internal override void OnDetach(DependencyObject d, DependencyProperty dp) { // Invalidate all the caches InvalidateMentorCache(); if (!(_targetObject is FrameworkElement) && !(_targetObject is FrameworkContentElement)) { // Stop listening for the InheritanceContextChanged event on the target node _targetObject.InheritanceContextChanged -= new EventHandler(InvalidateExpressionValue); } _targetObject = null; _targetProperty = null; } ////// Key used to lookup the resource /// public object ResourceKey { get { return _resourceKey; } } ////// This method is called when the cached value of the resource has /// been invalidated. E.g. after a new Resources property is set somewhere /// in the ancestory. /// private void InvalidateCacheValue() { object resource = _cachedResourceValue; // If the old value was a DeferredResourceReference, it should be // removed from its Dictionary's list to avoid a leak (bug 1624666). DeferredResourceReference deferredResourceReference = _cachedResourceValue as DeferredResourceReference; if (deferredResourceReference != null) { if (deferredResourceReference.IsInflated) { // use the inflated value for the Freezable test below resource = deferredResourceReference.Value; } else { // stop listening for the Inflated event if (ReadInternalState(InternalState.IsListeningForInflated)) { deferredResourceReference.RemoveInflatedListener(this); WriteInternalState(InternalState.IsListeningForInflated, false); } } deferredResourceReference.RemoveFromDictionary(); } StopListeningForFreezableChanges(resource); _cachedResourceValue = null; WriteInternalState(InternalState.HasCachedResourceValue, false); } ////// This method is called to invalidate all the cached values held in /// this expression. This is called under the following 3 scenarios /// 1. InheritanceContext changes /// 2. Logical tree changes /// 3. ResourceDictionary changes /// This call is more pervasive than the InvalidateCacheValue method /// private void InvalidateMentorCache() { if (ReadInternalState(InternalState.IsMentorCacheValid) == true) { if (_mentorCache != null) { if (_mentorCache != _targetObject) { FrameworkElement mentorFE; FrameworkContentElement mentorFCE; Helper.DowncastToFEorFCE(_mentorCache, out mentorFE, out mentorFCE, true); // Your mentor is about to change, make sure you detach handlers for // the events that you were listening on the old mentor if (mentorFE != null) { mentorFE.ResourcesChanged -= new EventHandler(InvalidateExpressionValue); } else { mentorFCE.ResourcesChanged -= new EventHandler(InvalidateExpressionValue); } } // Drop the mentor cache _mentorCache = null; } // Mark the cache invalid WriteInternalState(InternalState.IsMentorCacheValid, false); } // Invalidate the cached value of the expression InvalidateCacheValue(); } ////// This event handler is called to invalidate the cached value held in /// this expression. This is called under the following 3 scenarios /// 1. InheritanceContext changes /// 2. Logical tree changes /// 3. ResourceDictionary changes /// internal void InvalidateExpressionValue(object sender, EventArgs e) { ResourcesChangedEventArgs args = e as ResourcesChangedEventArgs; if (args != null) { ResourcesChangeInfo info = args.Info; if (!info.IsTreeChange) { // This will happen when // 1. Theme changes // 2. Entire ResourceDictionary in the ancestry changes // 3. Single entry in a ResourceDictionary in the ancestry is changed // In all of the above cases it is sufficient to re-evaluate the cache // value alone. The mentor relation ships stay the same. InvalidateCacheValue(); } else { // This is the case of a logical tree change and hence we need to // re-evaluate both the mentor and the cached value. InvalidateMentorCache(); } } else { // There is no information provided by the EventArgs. Hence we // pessimistically invalidate both the mentor and the cached value. // This code path will execute when the InheritanceContext changes. InvalidateMentorCache(); } InvalidateTargetProperty(sender, e); } private void InvalidateTargetProperty(object sender, EventArgs e) { _targetObject.InvalidateProperty(_targetProperty); } private void InvalidateTargetSubProperty(object sender, EventArgs e) { _targetObject.NotifySubPropertyChange(_targetProperty); } private void ListenForFreezableChanges(object resource) { if (!ReadInternalState(InternalState.IsListeningForFreezableChanges)) { // If this value is an unfrozen Freezable object, we need // to listen to its changed event in order to properly update // the cache. Freezable resourceAsFreezable = resource as Freezable; if( resourceAsFreezable != null && !resourceAsFreezable.IsFrozen ) { resourceAsFreezable.Changed += new EventHandler(InvalidateTargetSubProperty); WriteInternalState(InternalState.IsListeningForFreezableChanges, true); } } } private void StopListeningForFreezableChanges(object resource) { if (ReadInternalState(InternalState.IsListeningForFreezableChanges)) { // If the old value was an unfrozen Freezable object, we need // to stop listening to its changed event. If the old value wasn't // frozen (hence we attached an listener) but has been frozen // since then, the change handler we had attached was already // discarded during the freeze so we don't care here. Freezable resourceAsFreezable = resource as Freezable; if( resourceAsFreezable != null && !resourceAsFreezable.IsFrozen ) { resourceAsFreezable.Changed -= new EventHandler(InvalidateTargetSubProperty); } // It is possible that a freezable was unfrozen during the call to ListForFreezableChanges // but was frozen before the call to StopListeningForFreezableChanges WriteInternalState(InternalState.IsListeningForFreezableChanges, false); } } // when a deferred resource reference is inflated, the value may need extra // work internal void OnDeferredResourceInflated(DeferredResourceReference deferredResourceReference) { // once the value is inflated, stop listening for the event deferredResourceReference.RemoveInflatedListener(this); WriteInternalState(InternalState.IsListeningForInflated, false); ListenForFreezableChanges(deferredResourceReference.Value); } // Extracts the required flag and returns // bool to indicate if it is set or unset private bool ReadInternalState(InternalState reqFlag) { return (_state & reqFlag) != 0; } // Sets or Unsets the required flag based on // the bool argument private void WriteInternalState(InternalState reqFlag, bool set) { if (set) { _state |= reqFlag; } else { _state &= (~reqFlag); } } private object _resourceKey; // Name of the resource being referenced by this expression // Cached value and a dirty bit. See GetValue. private object _cachedResourceValue; // Used to find the value for this expression when it is set on a non-FE/FCE. // The mentor is the FE/FCE that the FindResource method is invoked on. private DependencyObject _mentorCache; // Used by the change listener to fire invalidation. private DependencyObject _targetObject; private DependencyProperty _targetProperty; // Bit Fields used to store boolean flags private InternalState _state = InternalState.Default; // this is a byte (see def'n) ////// This enum represents the internal state of the RRE. /// Additional bools should be coalesced into this enum. /// [Flags] private enum InternalState : byte { Default = 0x00, HasCachedResourceValue = 0x01, IsMentorCacheValid = 0x02, DisableThrowOnResourceFailure = 0x04, IsListeningForFreezableChanges= 0x08, IsListeningForInflated = 0x10, } } ////// These EventArgs are used to pass additional /// information during a ResourcesChanged event /// internal class ResourcesChangedEventArgs : EventArgs { internal ResourcesChangedEventArgs(ResourcesChangeInfo info) { _info = info; } internal ResourcesChangeInfo Info { get { return _info; } } private ResourcesChangeInfo _info; } } // 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
- BindingSource.cs
- MapPathBasedVirtualPathProvider.cs
- oledbconnectionstring.cs
- SpeechUI.cs
- MetadataCache.cs
- ItemDragEvent.cs
- SocketManager.cs
- DbMetaDataCollectionNames.cs
- ListViewEditEventArgs.cs
- DateTimeValueSerializer.cs
- WebPartTransformerAttribute.cs
- Point3DCollectionConverter.cs
- ErrorEventArgs.cs
- SimpleFileLog.cs
- TextRangeSerialization.cs
- Soap.cs
- PolyQuadraticBezierSegmentFigureLogic.cs
- BezierSegment.cs
- CacheMemory.cs
- ConsoleTraceListener.cs
- WebServiceHandlerFactory.cs
- PartManifestEntry.cs
- Parallel.cs
- WorkflowServiceNamespace.cs
- MemberMaps.cs
- ReadOnlyDataSource.cs
- OutOfMemoryException.cs
- CheckBox.cs
- ServiceOperationDetailViewControl.cs
- BatchWriter.cs
- MeasureData.cs
- ImmutablePropertyDescriptorGridEntry.cs
- QueryPageSettingsEventArgs.cs
- OdbcError.cs
- DrawingImage.cs
- FillBehavior.cs
- DataBindingExpressionBuilder.cs
- ErrorHandler.cs
- CodeNamespaceCollection.cs
- SetterBase.cs
- PersonalizableAttribute.cs
- StringAttributeCollection.cs
- ObjectViewListener.cs
- Msec.cs
- XPathBinder.cs
- ProtectedConfigurationProviderCollection.cs
- KnownTypesProvider.cs
- Stroke.cs
- HttpRequestWrapper.cs
- ServiceOperation.cs
- SoapIgnoreAttribute.cs
- EdmFunction.cs
- DesignerContextDescriptor.cs
- WindowVisualStateTracker.cs
- ToolstripProfessionalRenderer.cs
- IntellisenseTextBox.designer.cs
- MetadataArtifactLoaderCompositeFile.cs
- ComboBox.cs
- ImageMapEventArgs.cs
- InfiniteTimeSpanConverter.cs
- XsltQilFactory.cs
- CharKeyFrameCollection.cs
- CFGGrammar.cs
- CodeLabeledStatement.cs
- Triplet.cs
- FirstMatchCodeGroup.cs
- RegexGroup.cs
- NodeFunctions.cs
- ClientRoleProvider.cs
- GetResponse.cs
- LicenseManager.cs
- MemberJoinTreeNode.cs
- DefaultTraceListener.cs
- WorkflowView.cs
- MemberDomainMap.cs
- SettingsPropertyCollection.cs
- ConfigXmlText.cs
- Literal.cs
- UdpDiscoveryEndpointProvider.cs
- RtfToXamlReader.cs
- Metafile.cs
- PriorityBinding.cs
- XmlToDatasetMap.cs
- UserControl.cs
- BitmapMetadataBlob.cs
- ToolStripPanel.cs
- XmlDigitalSignatureProcessor.cs
- HashHelper.cs
- XmlSchemaResource.cs
- ConvertEvent.cs
- ServiceMetadataContractBehavior.cs
- XPathSingletonIterator.cs
- ValidationResult.cs
- PagePropertiesChangingEventArgs.cs
- SvcMapFileSerializer.cs
- ObjectTag.cs
- WebReferencesBuildProvider.cs
- ClientFormsIdentity.cs
- ProtocolProfile.cs
- ToolBarButton.cs