internal static string GetRootEditorSetting(ModelTreeManager modelTreeManager, FrameworkName targetFramework)
{
Debug.Assert(modelTreeManager != null, "modelTreeManager is null.");
Debug.Assert(targetFramework != null, "targetFramework is null.");
string globalEditorSetting = null;
if (Is45OrHigher(targetFramework))
{
if (modelTreeManager != null)
{
ModelItem rootItem = modelTreeManager.Root;
if (rootItem != null)
{
object root = rootItem.GetCurrentValue();
globalEditorSetting = ExpressionActivityEditor.GetExpressionActivityEditor(root);
if (string.IsNullOrEmpty(globalEditorSetting))
{
globalEditorSetting = VBExpressionLanguageName;
}
}
}
}
else
{
// When the target framework is less than 4.5, the root setting is ignored and always return VB
globalEditorSetting = VBExpressionLanguageName;
}
return(globalEditorSetting);
}
internal void InitializeEditor(ExpressionActivityEditor editor, ExpressionTextBox expressionTextBox)
{
if (editor != null)
{
expressionTextBox.InitializeHintText(editor.HintText);
expressionTextBox.InternalHintText = expressionTextBox.HintText;
SetBinding("InternalHintText", ExpressionActivityEditor.HintTextProperty, editor, expressionTextBox, BindingMode.TwoWay);
SetBinding("IsSupportedExpression", ExpressionActivityEditor.IsSupportedExpressionProperty, editor, expressionTextBox, BindingMode.OneWayToSource, null);
SetBinding("HorizontalScrollBarVisibility", ExpressionActivityEditor.HorizontalScrollBarVisibilityProperty, editor, expressionTextBox);
SetBinding("VerticalScrollBarVisibility", ExpressionActivityEditor.VerticalScrollBarVisibilityProperty, editor, expressionTextBox);
SetBinding("AcceptsReturn", ExpressionActivityEditor.AcceptsReturnProperty, editor, expressionTextBox);
SetBinding("AcceptsTab", ExpressionActivityEditor.AcceptsTabProperty, editor, expressionTextBox);
SetBinding("Expression", ExpressionActivityEditor.ExpressionProperty, editor, expressionTextBox, BindingMode.TwoWay, new Collection <ValidationRule> {
new ExpressionValidationRule(expressionTextBox)
});
SetBinding("ExpressionType", ExpressionActivityEditor.ExpressionTypeProperty, editor, expressionTextBox);
SetBinding("OwnerActivity", ExpressionActivityEditor.OwnerActivityProperty, editor, expressionTextBox);
SetBinding("UseLocationExpression", ExpressionActivityEditor.UseLocationExpressionProperty, editor, expressionTextBox);
SetBinding("PathToArgument", ExpressionActivityEditor.PathToArgumentProperty, editor, expressionTextBox);
SetBinding("IsReadOnly", ExpressionActivityEditor.IsReadOnlyProperty, editor, expressionTextBox);
SetBinding("ExplicitCommit", ExpressionActivityEditor.ExplicitCommitProperty, editor, expressionTextBox);
SetBinding("ClipToBounds", ExpressionActivityEditor.ClipToBoundsProperty, editor, expressionTextBox);
TextualExpressionEditor textEditor = editor as TextualExpressionEditor;
if (textEditor != null)
{
SetBinding("MaxLines", TextualExpressionEditor.MaxLinesProperty, textEditor, expressionTextBox);
SetBinding("MinLines", TextualExpressionEditor.MinLinesProperty, textEditor, expressionTextBox);
SetBinding("DefaultValue", TextualExpressionEditor.DefaultValueProperty, textEditor, expressionTextBox);
}
SetBinding("IsIndependentExpression", ExpressionActivityEditor.IsIndependentExpressionProperty, editor, expressionTextBox);
}
}
internal IExpressionEditorService GetExpressionService(ExpressionActivityEditor editor)
{
TextualExpressionEditor textualEditor = editor as TextualExpressionEditor;
if (textualEditor != null)
{
return(textualEditor.ExpressionEditorService);
}
else
{
return(null);
}
}
internal static bool TryMorphExpression(ActivityWithResult originalExpression, bool isLocation, Type targetType,
EditingContext context, out ActivityWithResult morphedExpression)
{
bool succeeded = false;
morphedExpression = null;
if (originalExpression != null)
{
Type resultType = originalExpression.ResultType;
if ((isLocation) && (ExpressionHelper.IsGenericLocationExpressionType(originalExpression) && (targetType == resultType.GetGenericArguments()[0])) ||
(!isLocation) && (resultType == targetType))
{
//no need to morph
succeeded = true;
morphedExpression = originalExpression;
}
else
{
Type expressionType = originalExpression.GetType();
if (expressionType.IsGenericType)
{
expressionType = expressionType.GetGenericTypeDefinition();
}
ExpressionMorphHelperAttribute morphHelperAttribute = ExtensibilityAccessor.GetAttribute <ExpressionMorphHelperAttribute>(expressionType);
if (morphHelperAttribute != null)
{
ExpressionMorphHelper morphHelper = Activator.CreateInstance(morphHelperAttribute.ExpressionMorphHelperType) as ExpressionMorphHelper;
if (morphHelper != null)
{
succeeded = morphHelper.TryMorphExpression(originalExpression, isLocation, targetType, context, out morphedExpression);
if (succeeded && morphedExpression != null)
{
string editorName = ExpressionActivityEditor.GetExpressionActivityEditor(originalExpression);
if (!string.IsNullOrWhiteSpace(editorName))
{
ExpressionActivityEditor.SetExpressionActivityEditor(morphedExpression, editorName);
}
}
}
}
}
}
else
{
succeeded = true;
}
return(succeeded);
}
internal bool TryCreateEditor(string expressionEditorName, out ExpressionActivityEditor editorInstance)
{
editorInstance = null;
if (expressionEditorName == null)
{
throw FxTrace.Exception.AsError(new ArgumentNullException(expressionEditorName));
}
if (!ExpressionEditorTypeTable.Keys.Contains(expressionEditorName))
{
return(false);
}
Type expressionEditorType = ExpressionEditorTypeTable[expressionEditorName];
editorInstance = Activator.CreateInstance(expressionEditorType) as ExpressionActivityEditor;
return(true);
}
void LoadInnerControl(string editorName)
{
if (editorName != this.currentEditorName)
{
ExpressionActivityEditor newEditor;
if (this.ViewModel.TryCreateEditor(editorName, out newEditor))
{
if ((this.IsInlinePropertyEditor) && !(newEditor is TextualExpressionEditor))
{
InitializeHintText(null);
this.editor = null;
this.currentEditorName = null;
this.Content = null;
this.ContentTemplate = this.FindResource("disabledInlineEditingTemplate") as DataTemplate;
}
else
{
this.currentEditorName = editorName;
this.editor = newEditor;
this.Content = this.editor;
this.ContentTemplate = null;
if (this.IsLoaded)
{
this.InitializeChildEditor();
}
}
}
else
{
this.UnsupportedEditorMessage = string.Format(CultureInfo.CurrentUICulture, SR.NonRegisteredExpressionEditor, editorName);
InitializeHintText(null);
this.editor = null;
this.currentEditorName = null;
this.Content = null;
this.ContentTemplate = this.FindResource("unsupportedEditorTemplate") as DataTemplate;
}
}
}
private static string GetLanguage(ModelItem modelItem)
{
return(ExpressionActivityEditor.GetExpressionActivityEditor(modelItem.Root.GetCurrentValue()));
}
