/** * extracts value from modelitem, returns null if there is no value */ public string Convert(ModelItem modelItem) { var currentValue = modelItem?.GetCurrentValue() as InArgument <string>; Literal <string> literal = currentValue?.Expression as Literal <string>; return(literal?.Value); }
public override object TranslatePropertyValue(ModelItem item, PropertyIdentifier identifier, object value) { MessageBox.Show($"name: {identifier.Name}\r\n" + $"value: {value}\r\n" + $"type: {value?.GetType()}\r\n" + $"item.View: {item.View}\r\n" + $"item.GetCurrentValue(): {item.GetCurrentValue()}"); if (identifier.DeclaringType == BackgroundPropertyIdentifier.DeclaringType) { using (var editingScope = item.BeginEdit()) { var button = item.GetCurrentValue() as Button; button?.SetValue(Control.BackgroundProperty, value); } return value; } return base.TranslatePropertyValue(item, identifier, value); }
public override void OnSelectionChanged(ModelItem oldItem, ModelItem newItem) { if (oldItem?.GetCurrentValue() is TDev2TOFn dto && dto.CanRemove()) { // old row is blank so remove var index = Collection.IndexOf(dto) + 1; RemoveDto(dto, index); } if (newItem != null) { CurrentModelItem = newItem; } }
/// <summary> /// Converts a value. /// </summary> /// <returns> /// A converted value. If the method returns null, the valid null value is used. /// </returns> /// <param name="value">The value that is produced by the binding target.</param><param name="targetType">The type to convert to.</param><param name="parameter">The converter parameter to use.</param><param name="culture">The culture to use in the converter.</param> public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { if (value != null) { ModelItem modelItem = value as ModelItem; if (modelItem != null) { Activity act = modelItem.GetCurrentValue() as Activity; return(act); } } return(null); }
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; }
protected override IEnumerable <IActionableErrorInfo> ValidateCollectionItem(ModelItem mi) { var dto = mi.GetCurrentValue() as GatherSystemInformationTO; if (dto == null) { yield break; } foreach (var error in dto.GetRuleSet("Result", _getDatalistString?.Invoke()).ValidateRules("", () => mi.SetProperty("IsResultFocused", true))) { yield return(error); } }
private void ActivityDesigner_Loaded(object sender, RoutedEventArgs e) { Azure.QueryBlobs modelItem = (Azure.QueryBlobs)ModelItem.GetCurrentValue(); AttributeCollection attributes = TypeDescriptor.GetProperties(modelItem)["ThrowOnError"].Attributes; DefaultValueAttribute defaultValueAttribute = (DefaultValueAttribute)attributes[typeof(DefaultValueAttribute)]; defaultValueAttribute = (DefaultValueAttribute)attributes[typeof(DefaultValueAttribute)]; if (modelItem.ThrowOnError == null && defaultValueAttribute != null) { chkThrowOnError.IsChecked = (bool)defaultValueAttribute.Value; } }
private void DeleteModelItem(ModelItem modelItem) { if (modelItem != null) { BreakpointTypes breakpointType; if (this.breakpoints.TryGetValue(modelItem, out breakpointType)) { this.transientBreakpoints[modelItem] = breakpointType; // cache it in case it's added later (move case). SetBreakpointType(modelItem, BreakpointTypes.None); // clear breakpoint } DeleteFromMapping(modelItem.GetCurrentValue()); } }
public static ImageSource GetImageSourceForTool(this ModelItem modelItem) { var computedValue = modelItem.GetCurrentValue(); if (computedValue is FlowStep && modelItem.Content?.Value != null) { computedValue = modelItem.Content.Value.GetCurrentValue(); } var type = computedValue.GetType(); var image = GetImageSourceForToolFromType(type); return(image); }
/// <summary> /// Handles the Loaded event of the ExecuteXamlWorkflowDesigner control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param> public void ExecuteXamlWorkflowDesigner_Loaded(object sender, RoutedEventArgs e) { this.ModelItem.PropertyChanged += new PropertyChangedEventHandler(this.ModelItem_PropertyChanged); ModelItem modelItem = this.ModelItem.Properties["ChildArguments"].Dictionary; if (modelItem == null) { argumentDictionary = new Dictionary <string, Argument>(); } else { argumentDictionary = (Dictionary <string, Argument>)modelItem.GetCurrentValue(); } }
private string GetExpressionEditorType() { object root = null; if (this.OwnerActivity != null) { ModelItem rootItem = this.Context.Services.GetService <ModelService>().Root; if (rootItem != null) { root = rootItem.GetCurrentValue(); } } return(this.ViewModel.GetExpressionEditorType(this.ExpressionActivityEditor, root, WorkflowDesigner.GetTargetFramework(this.Context))); }
private static string LiteralValueTranslateItem(ActivityTranslator translator, ModelItem item) { var temp = item.GetCurrentValue() as sae.Literal <DynamicValue>; if (null != temp) { DynamicValue id = temp.Value; DynamicValue validValue = GetValidValue(item, id); if (null != validValue.Value) { return(validValue.ToString()); } } return(translator.Translate(item.Properties[IMConstants.ValuePropertyName].Value)); }
/// <summary> /// Acquire a reference by the SourceLocation of the object. /// Notice this method will automatically register the object to listen to SourceLocationUpdated, if available. /// </summary> /// <param name="startLine">The start line of the object.</param> /// <param name="startColumn">The start column of the object.</param> /// <param name="endLine">The end line of the object.</param> /// <param name="endColumn">The end column of the object.</param> /// <returns>The object reference.</returns> public Guid AcquireObjectReference(int startLine, int startColumn, int endLine, int endColumn) { if (this.modelSearchService != null) { ModelItem modelItem = this.modelSearchService.FindModelItem(startLine, startColumn, endLine, endColumn); if (modelItem != null) { object searchObject = modelItem.GetCurrentValue(); Guid result = this.AcquireObjectReference(searchObject); this.SubscribedForSourceLocationChanges.Add(result); return(result); } } return(Guid.Empty); }
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { ModelItem modelItem = value as ModelItem; if (value != null) { InArgument <string> inArgument = modelItem.GetCurrentValue() as InArgument <string>; if (inArgument != null && inArgument.Expression as Literal <string> != null) { return((inArgument.Expression as Literal <string>).Value); } } return(string.Empty); }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { Type type = value as Type; if (type == null) { ModelItem modelItem = value as ModelItem; if (modelItem != null) { type = modelItem.GetCurrentValue() as Type; } } bool fullName = bool.Parse(parameter.ToString()); return(TypeNameHelper.GetDisplayName(type, fullName)); }
public object Convert(object[] values, Type targetType, object parameter, System.Globalization.CultureInfo culture) { int actualDisplayNameLength = MaxDisplayNameLength; // default to root item's typename string breadCrumbText = "<null>"; if (values[0] is ModelItem) { ModelItem boundModelItem = values[0] as ModelItem; breadCrumbText = boundModelItem.ItemType.Name; } else if (LocalAppContextSwitches.UseLegacyAccessibilityFeatures && values[0] is DesignerView.BreadCrumbObjectSeparator) { breadCrumbText = SR.BreadCrumbObjectSeparator; } // if there is a display name property on root use that as the file name. if (values[1] is ModelItem) { ModelItem displayNameProperty = (ModelItem)values[1]; if (typeof(string) == displayNameProperty.ItemType) { values[1] = displayNameProperty.GetCurrentValue(); } } if (values[1] is string) { string displayName = (string)values[1]; if (!displayName.Equals(string.Empty)) { breadCrumbText = displayName; } } if (values.Length == 3 && values[2] is double) { double actualControlWidth = (double)values[2]; actualDisplayNameLength = (int)Math.Max(MaxDisplayNameLength, actualControlWidth / pixelsPerChar); } if (breadCrumbText.Length > actualDisplayNameLength) { breadCrumbText = breadCrumbText.Substring(0, actualDisplayNameLength - 3) + "..."; } return(breadCrumbText); }
private void ActivityDesigner_Loaded(object sender, RoutedEventArgs e) { Activities.Vsdbcmd modelItem = (Activities.Vsdbcmd)ModelItem.GetCurrentValue(); bool?defaultValue = (bool?)DesignerHelper.GetDefaultValueAttributeValue(modelItem, "AlwaysCreateNewDatabase"); if (modelItem.AlwaysCreateNewDatabase == null && defaultValue != null) { chkAlwaysCreateNewDatabase.IsChecked = defaultValue.Value; } defaultValue = (bool?)DesignerHelper.GetDefaultValueAttributeValue(modelItem, "BackupBeforeDeploy"); if (modelItem.BackupBeforeDeploy == null && defaultValue != null) { chkBackupBeforeDeploy.IsChecked = defaultValue.Value; } }
protected override IEnumerable <IActionableErrorInfo> ValidateCollectionItem(ModelItem mi) { var dto = mi.GetCurrentValue() as ActivityDTO; if (dto == null) { yield break; } foreach (var error in dto.GetRuleSet("FieldName", GetDatalistString()).ValidateRules("'Variable'", () => mi.SetProperty("IsFieldNameFocused", true))) { yield return(error); } foreach (var error in dto.GetRuleSet("FieldValueAndCalculate", GetDatalistString()).ValidateRules("'New Value'", () => mi.SetProperty("IsFieldValueFocused", true))) { yield return(error); } }
protected override IEnumerable<IActionableErrorInfo> ValidateCollectionItem(ModelItem mi) { var dto = mi.GetCurrentValue() as JsonMappingTo; if(dto == null) { yield break; } foreach (var error in dto.GetRuleSet("SourceName", GetDatalistString()).ValidateRules("'Data'", () => mi.SetProperty("IsSourceNameFocused", true))) { yield return error; } foreach (var error in dto.GetRuleSet("DestinationName", GetDatalistString()).ValidateRules("'Name'", () => mi.SetProperty("IsDestinationNameFocused", true))) { yield return error; } }
protected override IEnumerable <IActionableErrorInfo> ValidateCollectionItem(ModelItem mi) { var dto = mi.GetCurrentValue() as XPathDTO; if (dto == null) { yield break; } foreach (var error in dto.GetRuleSet("OutputVariable", GetDatalistString()).ValidateRules("'Results'", () => mi.SetProperty("IsOutputVariableFocused", true))) { yield return(error); } foreach (var error in dto.GetRuleSet("XPath", GetDatalistString()).ValidateRules("'XPath'", () => mi.SetProperty("IsXpathVariableFocused", true))) { yield return(error); } }
private void ValidateNamespaceModelAndUpdateContextItem(ModelItem namespaceModel) { NamespaceData namespaceData = namespaceModel.GetCurrentValue() as NamespaceData; Fx.Assert(namespaceData != null, "added item has to be NamespaceData"); if (!this.availableNamespaces.ContainsKey(namespaceData.Namespace)) { namespaceModel.Properties[ErrorMessagePropertyName].SetValue(string.Format(CultureInfo.CurrentCulture, SR.CannotResolveNamespace, namespaceData.Namespace)); namespaceModel.Properties[IsInvalidPropertyName].SetValue(true); } else { namespaceModel.Properties[ErrorMessagePropertyName].SetValue(string.Empty); namespaceModel.Properties[IsInvalidPropertyName].SetValue(false); this.importedNamespacesItem.ImportedNamespaces.Add(namespaceData.Namespace); } }
private static List <ModelProperty> GetTypeConverterSubPropertiesHelper(ModelItem item, TypeConverter customConverter) { if (item == null) { return(null); } List <ModelProperty> subProperties = null; TypeConverter converter = customConverter; if (converter == null) { // See if there is a converter associated with the item type itself converter = ExtensibilityAccessor.GetTypeConverter(item); } if (converter != null) { PropertyDescriptorCollection subPropertyDescriptors = converter.GetProperties(item.GetCurrentValue()); if (subPropertyDescriptors != null && subPropertyDescriptors.Count > 0) { foreach (PropertyDescriptor subPropertyDescriptor in subPropertyDescriptors) { ModelProperty subProperty = item.Properties[subPropertyDescriptor.Name]; // We want to expose all properties through the model regardless of whether they // are browsable or not. That distinction should be made by the UI utilizing it if (subProperty != null) { if (subProperties == null) { subProperties = new List <ModelProperty>(); } subProperties.Add(subProperty); } } } } return(subProperties); }
void NavigateToError(object sourceDetail) { Fx.Assert(this.modelTreeManager != null, "ModelTreeManager is null."); ModelItem modelItem = this.modelTreeManager.GetModelItem(sourceDetail) ?? FindModelItem(this.modelTreeManager, sourceDetail); if (modelItem != null) { if (this.modelSearchService != null) { this.modelSearchService.NavigateTo(modelItem); } else { // For any Expression, need to focus to its parent instead. Activity activity = modelItem.GetCurrentValue() as Activity; if (activity != null && (activity.IsExpression())) { ModelItem parent = modelItem.Parent; while (parent != null) { bool hasDesignerAttribute = this.ViewService.GetDesignerType(parent.ItemType) != null; // ModelItemKeyValuePair type also has DesignerAttribute. // Since we do not want to put a focus on that type, special-casing it here. bool isModelItemKeyValuePair = parent.ItemType.IsGenericType && parent.ItemType.GetGenericTypeDefinition() == typeof(ModelItemKeyValuePair <,>); if (hasDesignerAttribute && !isModelItemKeyValuePair) { break; } parent = parent.Parent; } if (parent != null) { modelItem = parent; } } modelItem.Focus(); } } }
static void SetConnectorStartDotToolTip(FrameworkElement startDot, ModelItem connectorModelItem) { ModelItem triggerModelItem = connectorModelItem.Properties[TransitionDesigner.TriggerPropertyName].Value as ModelItem; string triggerName = null; if (triggerModelItem == null) { triggerName = "(null)"; } else { ModelItem displayNameModelItem = triggerModelItem.Properties["DisplayName"].Value; if (displayNameModelItem != null) { triggerName = displayNameModelItem.GetCurrentValue() as string; } } startDot.ToolTip = string.Format(CultureInfo.InvariantCulture, TriggerNameToolTip, triggerName) + Environment.NewLine + SR.SharedTriggerToolTip; }
void SetNext(ModelItem next, ModelItem source, bool delink = false) { if (next != null) { var nextStep = next.GetCurrentValue <FlowNode>(); if (nextStep != null) { SetNextFlowNode(next, source, nextStep, delink); } } else { var currentlyLinkedItem = GetNextItem(source); if (currentlyLinkedItem is null) { SetNextProperty(source, null); } } }
private void ElementCollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { // Only handle the event when single item is appended and it is not the first. if (e.NewItems != null && e.OldItems == null && e.NewItems.Count == 1 && e.NewStartingIndex > 0) { ModelItemCollection elements = ModelItem.Properties["Elements"].Collection; //NOXLATE // The insert position is always at the end when users add new item by clicking on hyperlike "<add text...>" // If the insert position is not the end, it must be 'Replace' operation. It is because ModelItemCollection // does not support 'Replace' operation, the operation is achieved by combination of 'remove' and 'add'. // Therefore you will receive an 'add' event when users are replacing an item. That is not the case we need to handle. if (e.NewStartingIndex == elements.Count - 1) { bool shouldAddSpacer = true; // Add space by default. int previousItemIndex = e.NewStartingIndex - 1; object previousValue = elements[previousItemIndex].GetCurrentValue(); string previousString = GetLiteralString(previousValue); if (previousString != null) { // If the previous item does not end with space, we should add a space. shouldAddSpacer = shouldAddSpacer && !previousString.EndsWith(Space); //NOXLATE } ModelItem modelItem = e.NewItems[0] as ModelItem; if (modelItem != null) { object theValue = modelItem.GetCurrentValue(); string theString = GetLiteralString(theValue); if (theString != null) { // If the newly-added string does start with space, we should add a space. shouldAddSpacer = shouldAddSpacer && !theString.StartsWith(Space); } } if (shouldAddSpacer) //NOXLATE { elements.Insert(e.NewStartingIndex, StringLiteral.CreateArgument(Space)); //NOXLATE } } } }
private ValidationRoot GetRootElement() { Activity rootElement = null; Fx.Assert(this.modelService != null, "ModelService is null."); // ModelService should not be null ModelItem rootItem = this.modelService.Root; object root = rootItem.GetCurrentValue(); // special case for WorkflowService - it will be returned directly WorkflowService workflowService = root as WorkflowService; if (workflowService != null) { return(new ValidationRoot(workflowService)); } //special case for ActivityBuilder - its will be converted to a DynamicActivity before validation. ActivityBuilder activityBuilder = root as ActivityBuilder; if (activityBuilder != null) { ActivityBuilderExtensions.ConvertActivityBuilderToDynamicActivity(activityBuilder, this.DynamicActivityWrapper); rootElement = this.DynamicActivityWrapper; } else { rootElement = rootItem.GetRootActivity(); } IList <AssemblyReference> references; IList <string> namespaces = NamespaceHelper.GetTextExpressionNamespaces(root, out references); NamespaceHelper.SetTextExpressionNamespaces(rootElement, namespaces, references); if (rootElement != null) { return(new ValidationRoot(rootElement)); } else { return(null); } }
public override void OnSelectionChanged(ModelItem oldItem, ModelItem newItem) { if (oldItem != null) { var dto = oldItem.GetCurrentValue() as TDev2TOFn; if (dto != null && dto.CanRemove()) { // old row is blank so remove if (ModelItemCollection != null) { var index = ModelItemCollection.IndexOf(oldItem) + 1; RemoveDto(dto, index); } } } if (newItem != null) { CurrentModelItem = newItem; } }
protected Variable <T> AddVariable <T>(ModelItemCollection variables, Variable <T> variable) { // Get variable. ModelItem modelItem = variables.FirstOrDefault( m => ((Variable)m.GetCurrentValue()).Name == variable.Name); // Add into variables collection if it does not exist. if (modelItem == null) { variables.Add(variable); } // Assign it if it was found. else { variable = modelItem.GetCurrentValue() as Variable <T>; } return(variable); }
private void ActivityDesigner_Loaded(object sender, RoutedEventArgs e) { Activities.CreateEventLog modelItem = (Activities.CreateEventLog)ModelItem.GetCurrentValue(); AttributeCollection attributes = TypeDescriptor.GetProperties(modelItem)["TreatExistAsSuccess"].Attributes; DefaultValueAttribute defaultValueAttribute = (DefaultValueAttribute)attributes[typeof(DefaultValueAttribute)]; if (modelItem.TreatExistAsSuccess == null && defaultValueAttribute != null) { chkTreatExistsAsSuccess.IsChecked = (bool)defaultValueAttribute.Value; } attributes = TypeDescriptor.GetProperties(modelItem)["ThrowOnError"].Attributes; defaultValueAttribute = (DefaultValueAttribute)attributes[typeof(DefaultValueAttribute)]; if (modelItem.ThrowOnError == null && defaultValueAttribute != null) { chkThrowOnError.IsChecked = (bool)defaultValueAttribute.Value; } }
protected override void OnModelItemChanged(object newItem) { base.OnModelItemChanged(newItem); Context.Items.Subscribe <Selection>(SelectionChanged); _convertCollection = newItem; _activity = newItem as ModelItem; if (_convertCollection.ConvertCollection == null || _convertCollection.ConvertCollection.Count <= 0) { _convertCollection.ConvertCollection.Add(new BaseConvertTO("", "Text", "Base 64", "", 1)); _convertCollection.ConvertCollection.Add(new BaseConvertTO("", "Text", "Base 64", "", 2)); } if (_activity != null) { var modelProperty = _activity.Properties["DisplayName"]; if (modelProperty != null) { modelProperty.SetValue(CreateDisplayName()); } ModelItem parent = _activity.Parent; while (parent != null) { if (parent.Properties["Argument"] != null) { break; } parent = parent.Parent; } } ICollectionActivity modelItemActivity = ModelItem.GetCurrentValue() as ICollectionActivity; QuickVariableInputModel model = new QuickVariableInputModel(ModelItem, modelItemActivity); ViewModel = new QuickVariableInputViewModel(model); }