Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / NetFx40 / Tools / System.Activities.Presentation / System / Activities / Presentation / View / ActivityTypeResolver.xaml.cs / 1560892 / ActivityTypeResolver.xaml.cs
//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//---------------------------------------------------------------
namespace System.Activities.Presentation.View
{
using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Windows;
using System.Windows.Automation.Peers;
using System.Windows.Input;
using System.Windows.Controls;
using System.Windows.Media;
using System.Diagnostics.CodeAnalysis;
using System.Runtime;
using System.Runtime.InteropServices;
using System.Windows.Interop;
// This class is used to resolve generic type in case when a generic activity is
// dropped on design surface
internal partial class ActivityTypeResolver : DialogWindow
{
public static readonly DependencyProperty GenericTypeMappingProperty =
DependencyProperty.Register("GenericTypeMapping",
typeof(ObservableCollection < TypeKeyValue >),
typeof(ActivityTypeResolver));
public static readonly DependencyProperty EditedTypeProperty =
DependencyProperty.Register("EditedType",
typeof(Type),
typeof(ActivityTypeResolver),
new PropertyMetadata(new PropertyChangedCallback(OnEditedTypeChanged)));
static readonly DependencyPropertyKey IsTypeResolvedKey =
DependencyProperty.RegisterReadOnly("IsTypeResolved",
typeof(bool),
typeof(ActivityTypeResolver),
new PropertyMetadata(false));
public static readonly DependencyProperty IsTypeResolvedProperty = IsTypeResolvedKey.DependencyProperty;
public ActivityTypeResolver()
{
InitializeComponent();
this.HelpKeyword = HelpKeywords.ActivityTypeResolver;
}
protected override void OnInitialized(EventArgs e)
{
base.OnInitialized(e);
SetValue(GenericTypeMappingProperty, new ObservableCollection());
this.Title = SR.TypeResolverWindowTitle;
this.typeResolver.Focus();
}
public Type ConcreteType
{
get;
private set;
}
public Type EditedType
{
get { return (Type)GetValue(EditedTypeProperty); }
set { SetValue(EditedTypeProperty, value); }
}
public ObservableCollection < TypeKeyValue > GenericTypeMapping
{
get { return (ObservableCollection < TypeKeyValue >)GetValue(GenericTypeMappingProperty); }
set { SetValue(GenericTypeMappingProperty, value); }
}
public bool IsTypeResolved
{
get { return (bool)GetValue(IsTypeResolvedProperty); }
private set { SetValue(IsTypeResolvedKey, value); }
}
public TypeResolvingOptions Options
{
get;
set;
}
[SuppressMessage(FxCop.Category.Design, FxCop.Rule.DoNotCatchGeneralExceptionTypes,
Justification = "Catching all exceptions to avoid VS Crash")]
[SuppressMessage("Reliability", "Reliability108", Justification = "Catching all exceptions to avoid VS Crash")]
public void NotifyTypeChanged(TypeKeyValue sender)
{
this.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.ApplicationIdle,
new Action(() =>
{
try
{
IsTypeResolved = (null != ResolveType() ? true : false);
ClearError();
}
catch (Exception err)
{
SetError(err.Message);
IsTypeResolved = false;
}
}));
}
private void SetError(string message)
{
if (this.GenericTypeMapping != null)
{
foreach (TypeKeyValue tkv in this.GenericTypeMapping)
{
tkv.IsValid = false;
tkv.ErrorText = message;
}
}
}
private void ClearError()
{
if (this.GenericTypeMapping != null)
{
foreach (TypeKeyValue tkv in this.GenericTypeMapping)
{
tkv.IsValid = true;
tkv.ErrorText = null;
}
}
}
protected override System.Windows.Automation.Peers.AutomationPeer OnCreateAutomationPeer()
{
return new UIElementAutomationPeer(this);
}
static void OnEditedTypeChanged(DependencyObject sender, DependencyPropertyChangedEventArgs args)
{
ActivityTypeResolver resolver = (ActivityTypeResolver)sender;
resolver.OnEditTypeAssigned();
}
void OnCancelClick(object sender, RoutedEventArgs e)
{
DialogResult = false;
}
void OnEditTypeAssigned()
{
if (null != this.EditedType && this.EditedType.IsGenericTypeDefinition)
{
this.typeName.Text = TypeNameHelper.GetDisplayName(this.EditedType, false);
Type[] generics = this.EditedType.GetGenericArguments();
foreach (Type type in generics)
{
Type temp = type; // reference this temp variable instead of reference type in the anonymous delegate
TypeKeyValue tkv = new TypeKeyValue(type, new Action(NotifyTypeChanged))
{
IsSelected = false,
Filter = delegate(Type t)
{
foreach (Type constraint in temp.GetGenericParameterConstraints())
{
if (!constraint.IsAssignableFrom(t))
{
return false;
}
}
return this.Options == null
|| this.Options.Filter == null
|| this.Options.Filter(t);
},
MostRecentlyUsedTypes = this.Options != null? this.Options.MostRecentlyUsedTypes : null,
};
this.GenericTypeMapping.Add(tkv);
if (this.Options == null || !this.Options.BrowseTypeDirectly)
{
tkv.BrowseTypeDirectly = false;
//this has to happen after the tkv is added GenericTypeMapping because:
//when TargetType is set, TypeResolver will try to resolve the generic type with this TargetType as type argument,
//and when resolvig the type, TypeResolver needs to know all the mappings
tkv.TargetType = typeof(int);
}
}
}
}
void OnOkClick(object sender, RoutedEventArgs e)
{
try
{
Type type = ResolveType();
if (null != type)
{
this.ConcreteType = type;
DialogResult = true;
}
else
{
MessageBox.Show(SR.TypeResolverError, SR.TypeResolverErrorMessageTitle, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
catch (ArgumentException err)
{
MessageBox.Show(err.Message, err.GetType().Name, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
void TypeKeyDown(object sender, KeyEventArgs e)
{
if (TypePresenter.IsPreviewKey(e.Key))
{
ListViewItem typeView = (ListViewItem)sender;
//always focus on the type presenter so the presenter could handle keyboard events
TypePresenter typePresenter = FindChildElement(typeView);
if (typePresenter != null)
{
typePresenter.Preview();
}
e.Handled = true;
}
}
ChildType FindChildElement(DependencyObject tree) where ChildType : DependencyObject
{
//recursively traverse the visual tree and find the element of a given type
for (int i = 0; i < VisualTreeHelper.GetChildrenCount(tree); i++)
{
DependencyObject child = VisualTreeHelper.GetChild(tree, i);
if (child != null && child is ChildType)
{
return child as ChildType;
}
else
{
ChildType childInSubtree = FindChildElement(child);
if (childInSubtree != null)
{
return childInSubtree;
}
}
}
return null;
}
Type ResolveType()
{
Type result = null;
bool isValid = true;
//get number of generic parameters in edited type
Type[] arguments = new Type[this.GenericTypeMapping.Count];
//for each argument, get resolved type
for (int i = 0; i < this.GenericTypeMapping.Count && isValid; ++i)
{
arguments[i] = this.GenericTypeMapping[i].GetConcreteType();
isValid = isValid && (null != arguments[i]);
}
//if all parameters are resolved, create concrete type
if (isValid)
{
result = this.EditedType.MakeGenericType(arguments);
}
return result;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//---------------------------------------------------------------
namespace System.Activities.Presentation.View
{
using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Windows;
using System.Windows.Automation.Peers;
using System.Windows.Input;
using System.Windows.Controls;
using System.Windows.Media;
using System.Diagnostics.CodeAnalysis;
using System.Runtime;
using System.Runtime.InteropServices;
using System.Windows.Interop;
// This class is used to resolve generic type in case when a generic activity is
// dropped on design surface
internal partial class ActivityTypeResolver : DialogWindow
{
public static readonly DependencyProperty GenericTypeMappingProperty =
DependencyProperty.Register("GenericTypeMapping",
typeof(ObservableCollection < TypeKeyValue >),
typeof(ActivityTypeResolver));
public static readonly DependencyProperty EditedTypeProperty =
DependencyProperty.Register("EditedType",
typeof(Type),
typeof(ActivityTypeResolver),
new PropertyMetadata(new PropertyChangedCallback(OnEditedTypeChanged)));
static readonly DependencyPropertyKey IsTypeResolvedKey =
DependencyProperty.RegisterReadOnly("IsTypeResolved",
typeof(bool),
typeof(ActivityTypeResolver),
new PropertyMetadata(false));
public static readonly DependencyProperty IsTypeResolvedProperty = IsTypeResolvedKey.DependencyProperty;
public ActivityTypeResolver()
{
InitializeComponent();
this.HelpKeyword = HelpKeywords.ActivityTypeResolver;
}
protected override void OnInitialized(EventArgs e)
{
base.OnInitialized(e);
SetValue(GenericTypeMappingProperty, new ObservableCollection());
this.Title = SR.TypeResolverWindowTitle;
this.typeResolver.Focus();
}
public Type ConcreteType
{
get;
private set;
}
public Type EditedType
{
get { return (Type)GetValue(EditedTypeProperty); }
set { SetValue(EditedTypeProperty, value); }
}
public ObservableCollection < TypeKeyValue > GenericTypeMapping
{
get { return (ObservableCollection < TypeKeyValue >)GetValue(GenericTypeMappingProperty); }
set { SetValue(GenericTypeMappingProperty, value); }
}
public bool IsTypeResolved
{
get { return (bool)GetValue(IsTypeResolvedProperty); }
private set { SetValue(IsTypeResolvedKey, value); }
}
public TypeResolvingOptions Options
{
get;
set;
}
[SuppressMessage(FxCop.Category.Design, FxCop.Rule.DoNotCatchGeneralExceptionTypes,
Justification = "Catching all exceptions to avoid VS Crash")]
[SuppressMessage("Reliability", "Reliability108", Justification = "Catching all exceptions to avoid VS Crash")]
public void NotifyTypeChanged(TypeKeyValue sender)
{
this.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.ApplicationIdle,
new Action(() =>
{
try
{
IsTypeResolved = (null != ResolveType() ? true : false);
ClearError();
}
catch (Exception err)
{
SetError(err.Message);
IsTypeResolved = false;
}
}));
}
private void SetError(string message)
{
if (this.GenericTypeMapping != null)
{
foreach (TypeKeyValue tkv in this.GenericTypeMapping)
{
tkv.IsValid = false;
tkv.ErrorText = message;
}
}
}
private void ClearError()
{
if (this.GenericTypeMapping != null)
{
foreach (TypeKeyValue tkv in this.GenericTypeMapping)
{
tkv.IsValid = true;
tkv.ErrorText = null;
}
}
}
protected override System.Windows.Automation.Peers.AutomationPeer OnCreateAutomationPeer()
{
return new UIElementAutomationPeer(this);
}
static void OnEditedTypeChanged(DependencyObject sender, DependencyPropertyChangedEventArgs args)
{
ActivityTypeResolver resolver = (ActivityTypeResolver)sender;
resolver.OnEditTypeAssigned();
}
void OnCancelClick(object sender, RoutedEventArgs e)
{
DialogResult = false;
}
void OnEditTypeAssigned()
{
if (null != this.EditedType && this.EditedType.IsGenericTypeDefinition)
{
this.typeName.Text = TypeNameHelper.GetDisplayName(this.EditedType, false);
Type[] generics = this.EditedType.GetGenericArguments();
foreach (Type type in generics)
{
Type temp = type; // reference this temp variable instead of reference type in the anonymous delegate
TypeKeyValue tkv = new TypeKeyValue(type, new Action(NotifyTypeChanged))
{
IsSelected = false,
Filter = delegate(Type t)
{
foreach (Type constraint in temp.GetGenericParameterConstraints())
{
if (!constraint.IsAssignableFrom(t))
{
return false;
}
}
return this.Options == null
|| this.Options.Filter == null
|| this.Options.Filter(t);
},
MostRecentlyUsedTypes = this.Options != null? this.Options.MostRecentlyUsedTypes : null,
};
this.GenericTypeMapping.Add(tkv);
if (this.Options == null || !this.Options.BrowseTypeDirectly)
{
tkv.BrowseTypeDirectly = false;
//this has to happen after the tkv is added GenericTypeMapping because:
//when TargetType is set, TypeResolver will try to resolve the generic type with this TargetType as type argument,
//and when resolvig the type, TypeResolver needs to know all the mappings
tkv.TargetType = typeof(int);
}
}
}
}
void OnOkClick(object sender, RoutedEventArgs e)
{
try
{
Type type = ResolveType();
if (null != type)
{
this.ConcreteType = type;
DialogResult = true;
}
else
{
MessageBox.Show(SR.TypeResolverError, SR.TypeResolverErrorMessageTitle, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
catch (ArgumentException err)
{
MessageBox.Show(err.Message, err.GetType().Name, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
void TypeKeyDown(object sender, KeyEventArgs e)
{
if (TypePresenter.IsPreviewKey(e.Key))
{
ListViewItem typeView = (ListViewItem)sender;
//always focus on the type presenter so the presenter could handle keyboard events
TypePresenter typePresenter = FindChildElement(typeView);
if (typePresenter != null)
{
typePresenter.Preview();
}
e.Handled = true;
}
}
ChildType FindChildElement(DependencyObject tree) where ChildType : DependencyObject
{
//recursively traverse the visual tree and find the element of a given type
for (int i = 0; i < VisualTreeHelper.GetChildrenCount(tree); i++)
{
DependencyObject child = VisualTreeHelper.GetChild(tree, i);
if (child != null && child is ChildType)
{
return child as ChildType;
}
else
{
ChildType childInSubtree = FindChildElement(child);
if (childInSubtree != null)
{
return childInSubtree;
}
}
}
return null;
}
Type ResolveType()
{
Type result = null;
bool isValid = true;
//get number of generic parameters in edited type
Type[] arguments = new Type[this.GenericTypeMapping.Count];
//for each argument, get resolved type
for (int i = 0; i < this.GenericTypeMapping.Count && isValid; ++i)
{
arguments[i] = this.GenericTypeMapping[i].GetConcreteType();
isValid = isValid && (null != arguments[i]);
}
//if all parameters are resolved, create concrete type
if (isValid)
{
result = this.EditedType.MakeGenericType(arguments);
}
return result;
}
}
}
// 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
- HMACMD5.cs
- LicenseManager.cs
- DelegatingStream.cs
- DrawingServices.cs
- FacetChecker.cs
- MainMenu.cs
- TextDocumentView.cs
- MetadataArtifactLoader.cs
- Size.cs
- XmlWrappingWriter.cs
- WindowsButton.cs
- EdmComplexTypeAttribute.cs
- ReachDocumentReferenceCollectionSerializer.cs
- TextRunCacheImp.cs
- DbConnectionStringBuilder.cs
- QilFactory.cs
- DictionaryBase.cs
- MergeFilterQuery.cs
- coordinator.cs
- OutputCacheSettings.cs
- HwndSubclass.cs
- XmlUtf8RawTextWriter.cs
- DataSourceView.cs
- WindowExtensionMethods.cs
- Buffer.cs
- TextElementEnumerator.cs
- IUnknownConstantAttribute.cs
- CursorInteropHelper.cs
- ByteStorage.cs
- dataSvcMapFileLoader.cs
- PropertyDescriptor.cs
- SingleConverter.cs
- TypeConverterHelper.cs
- PtsHelper.cs
- WindowsFormsSectionHandler.cs
- DetailsView.cs
- DesignerDataStoredProcedure.cs
- IItemContainerGenerator.cs
- GeometryHitTestParameters.cs
- DataGridViewSortCompareEventArgs.cs
- NavigationService.cs
- WebScriptClientGenerator.cs
- ApplicationSettingsBase.cs
- DataViewManager.cs
- SoapIgnoreAttribute.cs
- TemplateControl.cs
- KeyInterop.cs
- BasicCommandTreeVisitor.cs
- XmlValidatingReaderImpl.cs
- DefaultWorkflowSchedulerService.cs
- Floater.cs
- DbXmlEnabledProviderManifest.cs
- FilteredDataSetHelper.cs
- DoWorkEventArgs.cs
- StreamGeometryContext.cs
- SmtpTransport.cs
- DataDocumentXPathNavigator.cs
- _StreamFramer.cs
- ProgressBar.cs
- FragmentNavigationEventArgs.cs
- AnnouncementDispatcherAsyncResult.cs
- HttpTransportManager.cs
- TextRangeBase.cs
- LinearKeyFrames.cs
- Animatable.cs
- BufferBuilder.cs
- WinEventTracker.cs
- InputQueueChannel.cs
- safemediahandle.cs
- HWStack.cs
- PolyQuadraticBezierSegmentFigureLogic.cs
- Page.cs
- SqlConnectionString.cs
- VisualState.cs
- LinqDataSourceContextEventArgs.cs
- FillRuleValidation.cs
- QuaternionValueSerializer.cs
- DrawingContextWalker.cs
- MatrixAnimationUsingKeyFrames.cs
- UriExt.cs
- StaticSiteMapProvider.cs
- MenuAutomationPeer.cs
- FileIOPermission.cs
- TcpActivation.cs
- StringUtil.cs
- BuildProvider.cs
- DnsPermission.cs
- ConversionContext.cs
- HScrollProperties.cs
- DSACryptoServiceProvider.cs
- CommandConverter.cs
- ResXBuildProvider.cs
- BaseHashHelper.cs
- DataGridViewColumnConverter.cs
- AutoFocusStyle.xaml.cs
- DataBindEngine.cs
- InternalControlCollection.cs
- GenericFlowSwitchHelper.cs
- AsyncDataRequest.cs
- ObjectQuery.cs