Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / NetFx40 / Tools / System.Activities.Presentation / System / Activities / Presentation / Base / Core / ContextItemManager.cs / 1305376 / ContextItemManager.cs
//---------------------------------------------------------------- // Copyright (c) Microsoft Corporation. All rights reserved. //--------------------------------------------------------------- namespace System.Activities.Presentation { using System; using System.Collections; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Diagnostics.CodeAnalysis; using System.Activities.Presentation; using System.Runtime; //// The ContextItemManager class maintains a set of context items. A context // item represents a piece of transient state in a designer. // // ContextItems must define an empty constructor. This empty constructor // version of a context item represents its default value, and will be the // value returned from GetItem if the context item manager does not contain // a context item of the requested type. // // The ContextItemManager supports context layers. A context layer is a // separation in the set of context items and is useful when providing modal // functions. For example, when switching modes in the designer to show the // tab order layout it may be desirable to disable adding items from the // toolbox and change the user mouse and keyboard gestures to focus on setting // the tab order. Rather than grabbing and storing context items before // replacing them with new values, a developer can simply call CreateLayer. // Once the layer is created, all subsequent context changes go to that layer. // // When the developer is done with the layer, as would be the case when a user // switches out of tab order mode, she simply calls Remove on the layer. This // removes all context items that were added to the layer and restores the context // to its previous set of values before the layer was created. // [SuppressMessage(FxCop.Category.Naming, FxCop.Rule.IdentifiersShouldHaveCorrectSuffix)] public abstract class ContextItemManager : IEnumerable{ // // Creates a new ContextItemManager object. // protected ContextItemManager() { } //// Returns true if the item manager contains an item of the given type. // // The type of item to check. //True if the context contains an instance of this item type. //if itemType is null. public abstract bool Contains(Type itemType); //// Returns true if the item manager contains an item of the given type. // //The type of item to check. //True if the context contains an instance of this item type. [SuppressMessage(FxCop.Category.Design, FxCop.Rule.GenericMethodsShouldProvideTypeParameter)] public bool Contains() where TItemType : ContextItem { return Contains(typeof(TItemType)); } // // Enumerates the context items in the editing context. This enumeration // includes prior layers unless the enumerator hits an isolated layer. // Enumeration is typically not useful in most scenarios but it is provided so // that developers can search in the context and learn what is placed in it. // //An enumeration of context items. public abstract IEnumeratorGetEnumerator(); // // Returns an instance of the requested item type. If there is no context // item with the given type, an empty item will be created. // // The type of item to return. //A context item of the requested type. If there is no item in the context of this type a default one will be created. //if itemType is null. public abstract ContextItem GetValue(Type itemType); //// Returns an instance of the requested item type. If there is no context // item with the given type, an empty item will be created. // //The type of item to return. //A context item of the requested type. If there is no item in the context of this type a default one will be created. [SuppressMessage(FxCop.Category.Design, FxCop.Rule.GenericMethodsShouldProvideTypeParameter)] public TItemType GetValue() where TItemType : ContextItem { return (TItemType)GetValue(typeof(TItemType)); } // // This is a helper method that invokes the protected OnItemChanged // method on ContextItem. // // The editing context in use. // The new context item. // The previous context item. //if context, item or previousItem is null. protected static void NotifyItemChanged(EditingContext context, ContextItem item, ContextItem previousItem) { if (context == null) { throw FxTrace.Exception.ArgumentNull("context"); } if (item == null) { throw FxTrace.Exception.ArgumentNull("item"); } if (previousItem == null) { throw FxTrace.Exception.ArgumentNull("previousItem"); } item.InvokeOnItemChanged(context, previousItem); } //// This sets a context item to the given value. It is illegal to pass // null here. If you want to set a context item to its empty value create // an instance of the item using a default constructor. // // The value to set into the context item manager. public abstract void SetValue(ContextItem value); //// Adds an event callback that will be invoked with a context item of the given item type changes. // // The type of item you wish to subscribe to. // A callback that will be invoked when contextItemType changes. //if contextItemType or callback is null. public abstract void Subscribe(Type contextItemType, SubscribeContextCallback callback); //// Adds an event callback that will be invoked with a context item of the given item type changes. // //The type of item you wish to subscribe to. // A callback that will be invoked when contextItemType changes. //if callback is null. [SuppressMessage(FxCop.Category.Design, FxCop.Rule.GenericMethodsShouldProvideTypeParameter)] public void Subscribe(SubscribeContextCallback callback) where TContextItemType : ContextItem { if (callback == null) { throw FxTrace.Exception.ArgumentNull("callback"); } SubscribeProxy proxy = new SubscribeProxy (callback); Subscribe(typeof(TContextItemType), proxy.Callback); } // // Removes a subscription. // //The type of context item to remove the callback from. // The callback to remove. //if callback is null. [SuppressMessage(FxCop.Category.Design, FxCop.Rule.GenericMethodsShouldProvideTypeParameter)] public void Unsubscribe(SubscribeContextCallback callback) where TContextItemType : ContextItem { if (callback == null) { throw FxTrace.Exception.ArgumentNull("callback"); } SubscribeProxy proxy = new SubscribeProxy (callback); Unsubscribe(typeof(TContextItemType), proxy.Callback); } // // Removes a subscription. // // The type of context item to remove the callback from. // The callback to remove. //if contextItemType or callback is null. public abstract void Unsubscribe(Type contextItemType, SubscribeContextCallback callback); //// This is a helper method that returns the target object for a delegate. // If the delegate was created to proxy a generic delegate, this will correctly // return the original object, not the proxy. // // The callback whose target you want. //if callback is null. //The target object of the callback. protected static object GetTarget(Delegate callback) { if (callback == null) { throw FxTrace.Exception.ArgumentNull("callback"); } ICallbackProxy proxy = callback.Target as ICallbackProxy; if (proxy != null) { return proxy.OriginalTarget; } return callback.Target; } //// This is a helper method that performs a Delegate.Remove, but knows // how to unwrap delegates that are proxies to generic callbacks. Use // this in your Unsubscribe implementations. // // The existing delegate. // The delegate to be removed from existing. //The new delegate that should be assigned to existing. protected static Delegate RemoveCallback(Delegate existing, Delegate toRemove) { if (existing == null) { return null; } if (toRemove == null) { return existing; } ICallbackProxy toRemoveProxy = toRemove.Target as ICallbackProxy; if (toRemoveProxy == null) { // The item to be removed is a normal delegate. Just call // Delegate.Remove return Delegate.Remove(existing, toRemove); } toRemove = toRemoveProxy.OriginalDelegate; Delegate[] invocationList = existing.GetInvocationList(); bool removedItems = false; for (int idx = 0; idx < invocationList.Length; idx++) { Delegate item = invocationList[idx]; ICallbackProxy itemProxy = item.Target as ICallbackProxy; if (itemProxy != null) { item = itemProxy.OriginalDelegate; } if (item.Equals(toRemove)) { invocationList[idx] = null; removedItems = true; } } if (removedItems) { // We must create a new delegate containing the // invocation list that is is left existing = null; foreach (Delegate d in invocationList) { if (d != null) { if (existing == null) { existing = d; } else { existing = Delegate.Combine(existing, d); } } } } return existing; } //// Implementation of default IEnumerable. // IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } private interface ICallbackProxy { Delegate OriginalDelegate { get; } object OriginalTarget { get; } } //// This is a simple proxy that converts a non-generic subscribe callback to a generic // one. // //private class SubscribeProxy : ICallbackProxy where TContextItemType : ContextItem { private SubscribeContextCallback _genericCallback; internal SubscribeProxy(SubscribeContextCallback callback) { _genericCallback = callback; } internal SubscribeContextCallback Callback { get { return new SubscribeContextCallback(SubscribeContext); } } Delegate ICallbackProxy.OriginalDelegate { get { return _genericCallback; } } object ICallbackProxy.OriginalTarget { get { return _genericCallback.Target; } } private void SubscribeContext(ContextItem item) { if (item == null) { throw FxTrace.Exception.ArgumentNull("item"); } _genericCallback((TContextItemType)item); } } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- MenuItemBindingCollection.cs
- SmtpClient.cs
- ScalarConstant.cs
- LZCodec.cs
- DropDownList.cs
- CRYPTPROTECT_PROMPTSTRUCT.cs
- XmlDataSourceDesigner.cs
- figurelength.cs
- NonVisualControlAttribute.cs
- LogLogRecordHeader.cs
- PeerHelpers.cs
- CompiledQueryCacheKey.cs
- Repeater.cs
- Scalars.cs
- KeyManager.cs
- AttachedPropertyBrowsableWhenAttributePresentAttribute.cs
- NetworkAddressChange.cs
- View.cs
- SimpleRecyclingCache.cs
- SystemInfo.cs
- XmlCharacterData.cs
- MenuBindingsEditorForm.cs
- UIElement3DAutomationPeer.cs
- FileChangesMonitor.cs
- JournalEntry.cs
- RSACryptoServiceProvider.cs
- WebCategoryAttribute.cs
- ImageListUtils.cs
- ControlBindingsConverter.cs
- TableParagraph.cs
- UnitySerializationHolder.cs
- PropertyInfoSet.cs
- BlurBitmapEffect.cs
- DetailsViewCommandEventArgs.cs
- ReadOnlyObservableCollection.cs
- DoubleAnimation.cs
- SourceChangedEventArgs.cs
- EntityStoreSchemaGenerator.cs
- ContextMarshalException.cs
- AutomationPropertyInfo.cs
- SingleSelectRootGridEntry.cs
- TextBox.cs
- DotExpr.cs
- DataGridViewCellValueEventArgs.cs
- NavigationWindowAutomationPeer.cs
- ClientConvert.cs
- ExpressionNode.cs
- COMException.cs
- SymLanguageVendor.cs
- ToolStripInSituService.cs
- CheckBoxRenderer.cs
- Utils.cs
- NativeMethodsCLR.cs
- UTF7Encoding.cs
- RadioButton.cs
- tooltip.cs
- DBCommandBuilder.cs
- CoreSwitches.cs
- _AutoWebProxyScriptEngine.cs
- MachineSettingsSection.cs
- DataGridViewSelectedRowCollection.cs
- VirtualDirectoryMappingCollection.cs
- XmlSchemaObjectCollection.cs
- JavaScriptString.cs
- ObjectSet.cs
- DataKeyCollection.cs
- DtrList.cs
- WindowsGrip.cs
- ByteAnimation.cs
- WindowsAltTab.cs
- TrustManager.cs
- PageContentCollection.cs
- TriState.cs
- BufferedGraphics.cs
- SolidColorBrush.cs
- CheckBoxRenderer.cs
- LocatorManager.cs
- complextypematerializer.cs
- IResourceProvider.cs
- UIInitializationException.cs
- TabRenderer.cs
- SizeF.cs
- UnsafeNativeMethodsCLR.cs
- PersonalizationProviderCollection.cs
- TabItem.cs
- ModelPerspective.cs
- SqlParameter.cs
- DataRecord.cs
- WebPartAuthorizationEventArgs.cs
- StatusBarPanelClickEvent.cs
- ImageBrush.cs
- SelectionRangeConverter.cs
- DataGridViewRowStateChangedEventArgs.cs
- LocalizabilityAttribute.cs
- TaiwanLunisolarCalendar.cs
- XmlSchemaSet.cs
- returneventsaver.cs
- FixedPageProcessor.cs
- GridErrorDlg.cs
- DataGridViewCellValueEventArgs.cs