|
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.Activities.Presentation
{
using System.Activities.Presentation.Model;
using System.Activities.Presentation.View;
using System.Activities.Presentation.Hosting;
using System.Runtime;
using System.Collections;
using System.Collections.ObjectModel;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Linq;
using System.Globalization;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Threading;
using System.Reflection;
internal sealed partial class DynamicArgumentDesigner : UserControl
{
public static readonly DependencyProperty ContextProperty =
DependencyProperty.Register("Context",
typeof(EditingContext),
typeof(DynamicArgumentDesigner));
public static readonly DependencyProperty OwnerActivityProperty =
DependencyProperty.Register("OwnerActivity",
typeof(ModelItem),
typeof(DynamicArgumentDesigner));
public static readonly DependencyProperty IsDirectionReadOnlyProperty =
DependencyProperty.Register("IsDirectionReadOnly",
typeof(bool),
typeof(DynamicArgumentDesigner),
new UIPropertyMetadata(true, OnIsDirectionReadOnlyChanged));
public static readonly DependencyProperty DynamicArgumentsProperty =
DependencyProperty.Register("DynamicArguments",
typeof(ObservableCollection<DynamicArgumentWrapperObject>),
typeof(DynamicArgumentDesigner),
new PropertyMetadata(new ObservableCollection<DynamicArgumentWrapperObject>()));
public static readonly DependencyProperty IsDictionaryProperty =
DependencyProperty.Register("IsDictionary",
typeof(bool?),
typeof(DynamicArgumentDesigner),
new PropertyMetadata(false));
public static readonly DependencyProperty UnderlyingArgumentTypeProperty =
DependencyProperty.Register("UnderlyingArgumentType",
typeof(Type),
typeof(DynamicArgumentDesigner),
new PropertyMetadata(typeof(Argument)));
public static readonly RoutedCommand CreateDynamicArgumentCommand = new RoutedCommand("CreateDynamicArgumentCommand", typeof(DynamicArgumentDesigner));
public static readonly RoutedCommand MoveUpArgumentCommand = new RoutedCommand("MoveUpArgumentCommand", typeof(DynamicArgumentDesigner));
public static readonly RoutedCommand MoveDownArgumentCommand = new RoutedCommand("MoveDownArgumentCommand", typeof(DynamicArgumentDesigner));
public static readonly RoutedCommand DeleteArgumentCommand = new RoutedCommand("DeleteArgumentCommand", typeof(DynamicArgumentDesigner));
public const string DefaultArgumentPrefix = "Argument";
SubscribeContextCallback<ReadOnlyState> onReadOnlyStateChangedCallback;
static readonly Type InArgumentType = typeof(InArgument);
static readonly Type OutArgumentType = typeof(OutArgument);
static readonly Type InOutArgumentType = typeof(InOutArgument);
static readonly Type ArgumentType = typeof(Argument);
const int NameColumn = 0;
const int DirectionColumn = 1;
const int ArgumentTypeColumn = 2;
const int ExpressionColumn = 3;
bool isReadOnly;
bool hideDirection;
string argumentPrefix = DefaultArgumentPrefix;
string hintText;
DataGridHelper dgHelper;
ContextItemManager contextItemManager;
public DynamicArgumentDesigner()
{
InitializeComponent();
this.dgHelper = new DataGridHelper(this.WPF_DataGrid, this);
this.dgHelper.AddNewRowCommand = DynamicArgumentDesigner.CreateDynamicArgumentCommand;
this.HintText = null;
this.WPF_DataGrid.LoadingRow += this.DataGrid_Standard_LoadingRow;
this.Loaded += (sender, e) =>
{
OnReadOnlyStateChanged(new ReadOnlyState());
this.ContextItemManager.Subscribe<ReadOnlyState>(this.OnReadOnlyStateChangedCallback);
this.OnDynamicArgumentsLoaded();
this.OnUnderlyingArgumentTypeChanged();
};
this.Unloaded += (sender, e) =>
{
this.ContextItemManager.Unsubscribe<ReadOnlyState>(this.OnReadOnlyStateChangedCallback);
};
DynamicArgumentWrapperObject.Editor = this;
}
ContextItemManager ContextItemManager
{
get
{
if (this.contextItemManager == null)
{
this.contextItemManager = this.OwnerActivity.GetEditingContext().Items;
}
return this.contextItemManager;
}
}
void OnReadOnlyStateChanged(ReadOnlyState state)
{
UpdateChildrenElementStatus();
}
void UpdateChildrenElementStatus()
{
this.isReadOnly = this.ContextItemManager.GetValue<ReadOnlyState>().IsReadOnly || this.DynamicArguments == null;
if (this.isReadOnly)
{
this.WPF_DataGrid.IsReadOnly = true;
this.ButtonMovDown.IsEnabled = false;
this.ButtonMovUp.IsEnabled = false;
this.ButtonDelete.IsEnabled = false;
}
}
void OnDataGridSelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (this.isReadOnly
|| this.WPF_DataGrid.SelectedItems == null
|| this.WPF_DataGrid.SelectedItems.Count == 0)
{
this.ButtonMovUp.IsEnabled = false;
this.ButtonMovDown.IsEnabled = false;
this.ButtonDelete.IsEnabled = false;
return;
}
// delete button
this.ButtonDelete.IsEnabled = true;
// up/down button.
if (this.WPF_DataGrid.SelectedItems.Count == 1)
{
bool upHadFocus = ButtonMovUp.IsFocused;
bool downHadFocus = ButtonMovDown.IsFocused;
this.ButtonMovUp.IsEnabled = this.WPF_DataGrid.SelectedIndex > 0;
this.ButtonMovDown.IsEnabled = this.WPF_DataGrid.SelectedIndex < this.DynamicArguments.Count - 1;
if (!this.ButtonMovDown.IsEnabled && downHadFocus)
{
this.ButtonMovUp.Focus();
}
if (!this.ButtonMovUp.IsEnabled && upHadFocus)
{
this.ButtonMovDown.Focus();
}
}
else
{
this.ButtonMovUp.IsEnabled = this.ButtonMovDown.IsEnabled = false;
}
}
// The DataGrid does not bubble up KeyDown event and we expect the upper window to be closed when ESC key is down.
// Thus we added an event handler in DataGrid to handle ESC key and closes the uppper window.
void OnDataGridRowKeyDown(object sender, KeyEventArgs args)
{
DataGridRow row = (DataGridRow)sender;
if (args.Key == Key.Escape && !row.IsEditing && this.ParentDialog != null)
{
this.ParentDialog.CloseDialog(false);
}
}
protected override void OnInitialized(EventArgs e)
{
base.OnInitialized(e);
this.Unloaded += this.OnDynamicArgumentDesignerUnloaded;
}
SubscribeContextCallback<ReadOnlyState> OnReadOnlyStateChangedCallback
{
get
{
if (onReadOnlyStateChangedCallback == null)
{
onReadOnlyStateChangedCallback = new SubscribeContextCallback<ReadOnlyState>(OnReadOnlyStateChanged);
}
return onReadOnlyStateChangedCallback;
}
}
void OnDynamicArgumentDesignerUnloaded(object sender, RoutedEventArgs e)
{
this.WPF_DataGrid.LoadingRow -= this.DataGrid_Standard_LoadingRow;
this.Unloaded -= this.OnDynamicArgumentDesignerUnloaded;
}
public ObservableCollection<DynamicArgumentWrapperObject> DynamicArguments
{
get
{
return (ObservableCollection<DynamicArgumentWrapperObject>)GetValue(DynamicArgumentsProperty);
}
set
{
SetValue(DynamicArgumentsProperty, value);
if (value != null)
{
this.WPF_DataGrid.ItemsSource = value;
}
}
}
[Fx.Tag.KnownXamlExternal]
public ModelItem OwnerActivity
{
get { return (ModelItem)GetValue(OwnerActivityProperty); }
set { SetValue(OwnerActivityProperty, value); }
}
[Fx.Tag.KnownXamlExternal]
public EditingContext Context
{
get { return (EditingContext)GetValue(ContextProperty); }
set { SetValue(ContextProperty, value); }
}
public bool IsDirectionReadOnly
{
get { return (bool)GetValue(IsDirectionReadOnlyProperty); }
set { SetValue(IsDirectionReadOnlyProperty, value); }
}
public bool HideDirection
{
get
{
return this.hideDirection;
}
set
{
this.hideDirection = value;
if (this.hideDirection)
{
this.WPF_DataGrid.Columns[DynamicArgumentDesigner.DirectionColumn].Visibility = Visibility.Hidden;
}
else
{
this.WPF_DataGrid.Columns[DynamicArgumentDesigner.DirectionColumn].Visibility = Visibility.Visible;
}
}
}
public string ArgumentPrefix
{
get
{
return this.argumentPrefix;
}
set
{
this.argumentPrefix = value;
}
}
public string HintText
{
get
{
if (this.hintText != null)
{
return this.hintText;
}
else
{
return (string)this.FindResource("addDynamicArgumentNewRowLabel");
}
}
set
{
this.hintText = value;
if (hintText == null)
{
dgHelper.AddNewRowContent = (string)this.FindResource("addDynamicArgumentNewRowLabel");
}
else
{
dgHelper.AddNewRowContent = hintText;
}
}
}
public WorkflowElementDialog ParentDialog
{
get;
set;
}
static void OnIsDirectionReadOnlyChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
{
((DynamicArgumentDesigner)dependencyObject).OnIsDirectionReadOnlyChanged();
}
void OnIsDirectionReadOnlyChanged()
{
if (!this.IsDirectionReadOnly)
{
DataGridTemplateColumn directionCol = this.WPF_DataGrid.Columns[1] as DataGridTemplateColumn;
directionCol.CellEditingTemplate = (DataTemplate)this.WPF_DataGrid.FindResource("argumentDirectionEditingTemplate");
}
}
internal Type UnderlyingArgumentType
{
get
{
return (Type)GetValue(UnderlyingArgumentTypeProperty);
}
set
{
if (!typeof(Argument).IsAssignableFrom(value))
{
ErrorReporting.ShowErrorMessage(SR.NonSupportedDynamicArgumentType);
}
else
{
SetValue(UnderlyingArgumentTypeProperty, value);
OnUnderlyingArgumentTypeChanged();
}
}
}
void OnUnderlyingArgumentTypeChanged()
{
Type currentArgumentType = this.UnderlyingArgumentType;
if (currentArgumentType != null && (OutArgumentType.IsAssignableFrom(currentArgumentType) || InOutArgumentType.IsAssignableFrom(currentArgumentType)))
{
this.WPF_DataGrid.Columns[DynamicArgumentDesigner.ExpressionColumn].Header = (string)this.FindResource("assignToHeader");
}
else
{
this.WPF_DataGrid.Columns[DynamicArgumentDesigner.ExpressionColumn].Header = (string)this.FindResource("valueHeader");
}
}
internal bool? IsDictionary
{
get
{
return (bool?)GetValue(IsDictionaryProperty);
}
set
{
SetValue(IsDictionaryProperty, value);
}
}
internal static ObservableCollection<DynamicArgumentWrapperObject> ModelItemToWrapperCollection(ModelItem model, out bool isDictionary, out Type underlyingArgumentType)
{
string errorMessage = string.Empty;
underlyingArgumentType = null;
isDictionary = false;
if (model is ModelItemCollection)
{
underlyingArgumentType = model.GetCurrentValue().GetType().GetGenericArguments()[0];
if (!typeof(Argument).IsAssignableFrom(underlyingArgumentType))
{
errorMessage = SR.NonSupportedDynamicArgumentType;
}
}
else if (model is ModelItemDictionary)
{
Type underlyingKeyType = model.GetCurrentValue().GetType().GetGenericArguments()[0];
underlyingArgumentType = model.GetCurrentValue().GetType().GetGenericArguments()[1];
if (!typeof(Argument).IsAssignableFrom(underlyingArgumentType))
{
errorMessage = SR.NonSupportedDynamicArgumentType;
}
if (underlyingKeyType != typeof(string))
{
errorMessage += SR.NonSupportedDynamicArgumentKeyType;
}
isDictionary = true;
}
else
{
errorMessage = SR.NonSupportedModelItemCollectionOrDictionary;
}
if (!string.IsNullOrEmpty(errorMessage))
{
ErrorReporting.ShowErrorMessage(SR.NonSupportedModelItemCollectionOrDictionary);
return null;
}
if (isDictionary)
{
ObservableCollection<DynamicArgumentWrapperObject> wrappers = new ObservableCollection<DynamicArgumentWrapperObject>();
foreach (ModelItem item in GetArgumentCollection(model))
{
wrappers.Add(new DynamicArgumentWrapperObject(item.Properties["Key"].ComputedValue as string, item.Properties["Value"].Value));
}
return wrappers;
}
else
{
ObservableCollection<DynamicArgumentWrapperObject> wrappers = new ObservableCollection<DynamicArgumentWrapperObject>();
foreach (ModelItem item in GetArgumentCollection(model))
{
wrappers.Add(new DynamicArgumentWrapperObject(null, item));
}
return wrappers;
}
}
internal static void WrapperCollectionToModelItem(ObservableCollection<DynamicArgumentWrapperObject> wrappers, ModelItem data, bool isDictionary, Type underlyingArgumentType)
{
ModelItemCollection collection = GetArgumentCollection(data);
using (ModelEditingScope change = collection.BeginEdit(SR.UpdateDynamicArgumentsDescription))
{
if (isDictionary)
{
collection.Clear();
Type dictionaryEntryType = typeof(ModelItemKeyValuePair<,>).MakeGenericType(new Type[] { typeof(string), underlyingArgumentType });
foreach (DynamicArgumentWrapperObject wrapper in wrappers)
{
Argument argument = Argument.Create(wrapper.Type, wrapper.Direction);
object mutableKVPair = Activator.CreateInstance(dictionaryEntryType, new object[] { wrapper.Name, argument });
ModelItem argumentKVPair = collection.Add(mutableKVPair);
if (wrapper.Expression != null)
{
argumentKVPair.Properties["Value"].Value.Properties["Expression"].SetValue(wrapper.Expression.GetCurrentValue());
}
}
}
else
{
collection.Clear();
foreach (DynamicArgumentWrapperObject wrapper in wrappers)
{
Argument argument = Argument.Create(wrapper.Type, wrapper.Direction);
ModelItem argumentItem = collection.Add(argument);
if (wrapper.Expression != null)
{
argumentItem.Properties["Expression"].SetValue(wrapper.Expression.GetCurrentValue());
}
}
}
change.Complete();
}
}
static ModelItemCollection GetArgumentCollection(ModelItem data)
{
if (data is ModelItemCollection)
{
return (data as ModelItemCollection);
}
else if (data is ModelItemDictionary)
{
return (data as ModelItemDictionary).Properties["ItemsCollection"].Collection;
}
else
{
ErrorReporting.ShowErrorMessage(SR.NonSupportedModelItemCollectionOrDictionary);
return null;
}
}
void OnDynamicArgumentsLoaded()
{
Fx.Assert(this.Context != null, "EditingContext cannot be null");
Fx.Assert(this.IsDictionary != null, "IsDictionary is not set");
Fx.Assert(this.UnderlyingArgumentType != null, "UnderlyingArgumentType is not set");
if (!(this.IsDictionary.Value))
{
this.WPF_DataGrid.Columns[DynamicArgumentDesigner.NameColumn].Visibility = Visibility.Hidden;
}
if (null != this.DynamicArguments)
{
if (this.UnderlyingArgumentType == ArgumentType)
{
this.IsDirectionReadOnly = false;
}
if (this.UnderlyingArgumentType.IsGenericType)
{
Type[] innerArgumentTypes = this.UnderlyingArgumentType.GetGenericArguments();
if (innerArgumentTypes.Length > 0)
{
Type innerArgumentType = innerArgumentTypes[0];
this.WPF_DataGrid.Columns[DynamicArgumentDesigner.ArgumentTypeColumn].IsReadOnly = !innerArgumentType.IsGenericParameter;
}
}
}
this.WPF_DataGrid.ItemsSource = this.DynamicArguments;
UpdateChildrenElementStatus();
}
internal void ValidateEntry(DynamicArgumentWrapperObject entry, DependencyPropertyChangedEventArgs e)
{
if (e.Property == DynamicArgumentWrapperObject.NameProperty)
{
if (this.IsDictionary.Value)
{
DataGridRow row = entry.Row;
string newName = e.NewValue as string;
bool duplicates =
this.DynamicArguments.Any<DynamicArgumentWrapperObject>(
p => string.Equals(p.Name, newName) && p != entry);
if (duplicates || string.IsNullOrEmpty(newName))
{
entry.Name = e.OldValue as string;
if (duplicates)
{
ErrorReporting.ShowErrorMessage(string.Format(CultureInfo.CurrentCulture, SR.DuplicateArgumentName, newName));
}
else
{
ErrorReporting.ShowErrorMessage(string.Format(CultureInfo.CurrentCulture, SR.EmptyArgumentName));
}
}
entry.IsValidating = false;
}
}
else
{
if (e.Property == DynamicArgumentWrapperObject.DirectionProperty)
{
entry.UseLocationExpression = (entry.Direction != ArgumentDirection.In);
}
if ((e.Property != DynamicArgumentWrapperObject.ExpressionProperty) && (entry.Expression != null))
{
ActivityWithResult expression = entry.Expression.GetCurrentValue() as ActivityWithResult;
if (expression != null)
{
ActivityWithResult newExpression;
if (ExpressionHelper.TryMorphExpression(expression, entry.UseLocationExpression, entry.Type, this.Context, out newExpression))
{
entry.Expression = (this.OwnerActivity as IModelTreeItem).ModelTreeManager.WrapAsModelItem(newExpression);
}
else
{
//Microsoft
entry.Expression = null;
}
}
}
entry.IsValidating = false;
}
}
internal string GetDefaultName()
{
if (!this.IsDictionary.Value)
{
return string.Empty;
}
else
{
var defaultNames = this.DynamicArguments
.Select<DynamicArgumentWrapperObject, string>(p => (string)p.Name)
.Where<string>(p => 0 == string.Compare(p, 0, this.ArgumentPrefix, 0, this.ArgumentPrefix.Length, StringComparison.Ordinal))
.Select(p => p.Substring(this.ArgumentPrefix.Length));
int maxNum = 1;
foreach (string numberPart in defaultNames)
{
int current;
if (int.TryParse(numberPart, out current))
{
if (current >= maxNum)
{
maxNum = current + 1;
}
}
}
return string.Format(CultureInfo.InvariantCulture, "{0}{1}", this.ArgumentPrefix, maxNum);
}
}
internal Type GetDefaultType()
{
Type[] genericArguments = this.UnderlyingArgumentType.GetGenericArguments();
if (genericArguments.Length == 0)
{
return typeof(string);
}
else
{
return genericArguments[0];
}
}
internal ArgumentDirection GetDefaultDirection()
{
if (this.UnderlyingArgumentType == ArgumentType)
{
return ArgumentDirection.In;
}
if (InArgumentType.IsAssignableFrom(this.UnderlyingArgumentType))
{
return ArgumentDirection.In;
}
if (OutArgumentType.IsAssignableFrom(this.UnderlyingArgumentType))
{
return ArgumentDirection.Out;
}
Fx.Assert(InOutArgumentType.IsAssignableFrom(this.UnderlyingArgumentType), "UnderlyingArgumentType should be of type OutArgumentType");
return ArgumentDirection.InOut;
}
//Hook LoadingRow event to set different row template (<Click here to add new item>) for new place holder
void DataGrid_Standard_LoadingRow(object sender, DataGridRowEventArgs e)
{
if (e.Row.Item != CollectionView.NewItemPlaceholder)
{
DynamicArgumentWrapperObject wrapper = e.Row.Item as DynamicArgumentWrapperObject;
wrapper.Row = e.Row;
}
}
void OnCreateDynamicArgumentExecute(object sender, ExecutedRoutedEventArgs e)
{
DynamicArgumentWrapperObject wrapper = new DynamicArgumentWrapperObject();
this.DynamicArguments.Add(wrapper);
this.dgHelper.BeginRowEdit(wrapper);
}
void OnMoveUpArgumentExecute(object sender, RoutedEventArgs e)
{
if (null != this.WPF_DataGrid.SelectedItem)
{
int selectedArgumentIndex = this.WPF_DataGrid.SelectedIndex;
if (selectedArgumentIndex > 0)
{
this.DynamicArguments.Move(selectedArgumentIndex, selectedArgumentIndex - 1);
}
this.OnDataGridSelectionChanged(this, null);
}
}
void OnMoveDownArgumentExecute(object sender, RoutedEventArgs e)
{
if (null != this.WPF_DataGrid.SelectedItem)
{
int selectedArgumentIndex = this.WPF_DataGrid.SelectedIndex;
if (selectedArgumentIndex < this.DynamicArguments.Count - 1)
{
this.DynamicArguments.Move(selectedArgumentIndex, selectedArgumentIndex + 1);
}
this.OnDataGridSelectionChanged(this, null);
}
}
void OnDeleteArgumentExecute(object sender, RoutedEventArgs e)
{
DataGridHelper.OnDeleteSelectedItems(this.WPF_DataGrid);
}
void OnExpressionTextBoxLoaded(object sender, RoutedEventArgs args)
{
ExpressionTextBox etb = (ExpressionTextBox)sender;
etb.IsIndependentExpression = true;
if (!etb.IsReadOnly)
{
DataGridHelper.OnEditingControlLoaded(sender, args);
}
}
void OnExpressionTextBoxUnloaded(object sender, RoutedEventArgs args)
{
ExpressionTextBox etb = (ExpressionTextBox)sender;
if (!etb.IsReadOnly)
{
DataGridHelper.OnEditingControlUnloaded(sender, args);
}
}
void OnEditingControlLoaded(object sender, RoutedEventArgs args)
{
DataGridHelper.OnEditingControlLoaded(sender, args);
}
void OnEditingControlUnloaded(object sender, RoutedEventArgs args)
{
DataGridHelper.OnEditingControlUnloaded(sender, args);
}
}
sealed class DynamicArgumentWrapperObject : DependencyObject
{
public static readonly DependencyProperty ModelItemProperty = DependencyProperty.Register(
"ModelItem",
typeof(ModelItem),
typeof(DynamicArgumentWrapperObject),
new UIPropertyMetadata(null));
public static readonly DependencyProperty NameProperty = DependencyProperty.Register(
"Name",
typeof(string),
typeof(DynamicArgumentWrapperObject),
new UIPropertyMetadata(string.Empty, OnArgumentPropertyChanged));
public static readonly DependencyProperty ArgumentTypeProperty = DependencyProperty.Register(
"Type",
typeof(Type),
typeof(DynamicArgumentWrapperObject),
new UIPropertyMetadata(typeof(string), OnArgumentPropertyChanged));
public static readonly DependencyProperty DirectionProperty = DependencyProperty.Register(
"Direction",
typeof(ArgumentDirection),
typeof(DynamicArgumentWrapperObject),
new UIPropertyMetadata(ArgumentDirection.In, OnArgumentPropertyChanged));
public static readonly DependencyProperty ExpressionProperty =
DependencyProperty.Register(
"Expression",
typeof(ModelItem),
typeof(DynamicArgumentWrapperObject),
new UIPropertyMetadata(OnArgumentPropertyChanged));
public static readonly DependencyProperty UseLocationExpressionProperty =
DependencyProperty.Register(
"UseLocationExpression",
typeof(bool),
typeof(DynamicArgumentWrapperObject));
public event PropertyChangedEventHandler PropertyChanged;
bool isInitializing;
const string ExpressionPropertyName = "Expression";
public string Name
{
get { return (string)GetValue(NameProperty); }
set { SetValue(NameProperty, value); }
}
public Type Type
{
get { return (Type)GetValue(ArgumentTypeProperty); }
set { SetValue(ArgumentTypeProperty, value); }
}
public ArgumentDirection Direction
{
get { return (ArgumentDirection)GetValue(DirectionProperty); }
set { SetValue(DirectionProperty, value); }
}
public ModelItem Expression
{
get { return (ModelItem)GetValue(ExpressionProperty); }
set { SetValue(ExpressionProperty, value); }
}
public bool UseLocationExpression
{
get { return (bool)GetValue(UseLocationExpressionProperty); }
set { SetValue(UseLocationExpressionProperty, value); }
}
internal bool IsValidating
{
get;
set;
}
internal DataGridRow Row
{
get;
set;
}
public static DynamicArgumentDesigner Editor
{
get;
set;
}
public DynamicArgumentWrapperObject()
{
this.isInitializing = true;
this.IsValidating = false;
this.Name = DynamicArgumentWrapperObject.Editor.GetDefaultName();
this.Type = DynamicArgumentWrapperObject.Editor.GetDefaultType();
this.Direction = DynamicArgumentWrapperObject.Editor.GetDefaultDirection();
this.UseLocationExpression = (this.Direction != ArgumentDirection.In);
this.isInitializing = false;
}
public DynamicArgumentWrapperObject(string argumentName, ModelItem argumentItem)
{
Fx.Assert(argumentItem != null, "argumentItem canot be null");
this.isInitializing = true;
this.IsValidating = false;
Argument argument = (Argument)argumentItem.GetCurrentValue();
this.Name = argumentName;
this.Direction = argument.Direction;
this.UseLocationExpression = (this.Direction != ArgumentDirection.In);
this.Type = argument.ArgumentType;
this.Expression = argumentItem.Properties[ExpressionPropertyName].Value;
this.isInitializing = false;
}
static void OnArgumentPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
DynamicArgumentWrapperObject wrapper = (DynamicArgumentWrapperObject)sender;
if (!wrapper.IsValidating && !wrapper.isInitializing)
{
wrapper.OnArgumentPropertyChanged(e);
}
}
void OnArgumentPropertyChanged(DependencyPropertyChangedEventArgs e)
{
Fx.Assert(DynamicArgumentWrapperObject.Editor != null, "collection editor is null!");
this.IsValidating = true;
DynamicArgumentWrapperObject.Editor.ValidateEntry(this, e);
if (this.PropertyChanged != null)
{
this.PropertyChanged(this, new PropertyChangedEventArgs(e.Property.Name));
}
}
// For screen reader to read the DataGrid row.
public override string ToString()
{
return string.IsNullOrEmpty(this.Name) ? "Parameter" : this.Name;
}
}
}
|