/// <summary> /// AddTab menu item action. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Event arguments.</param> private void AddTabMenuAction_Execute(object sender, MenuActionEventArgs e) { ModelItem primarySelection = e.Selection.PrimarySelection; ModelItem tabControl = null; if (primarySelection.IsItemOfType(MyPlatformTypes.TabControl.TypeId)) { tabControl = e.Selection.PrimarySelection; } else if (primarySelection.IsItemOfType(MyPlatformTypes.TabItem.TypeId)) { ModelItem parent = e.Selection.PrimarySelection.Parent; if (parent != null && parent.IsItemOfType(MyPlatformTypes.TabControl.TypeId)) { tabControl = parent; } } if (tabControl != null) { using (ModelEditingScope changes = tabControl.BeginEdit(Properties.Resources.TabControl_AddTabMenuItem)) { ModelItem newTabItem = ModelFactory.CreateItem(e.Context, MyPlatformTypes.TabItem.TypeId, CreateOptions.InitializeDefaults); tabControl.Content.Collection.Add(newTabItem); // change selection to newly created TabItem. Selection sel = new Selection(newTabItem); e.Context.Items.SetValue(sel); changes.Complete(); } } }
public override void ShowDialog(PropertyValue propertyValue, IInputElement commandSource) { ModelPropertyEntryToOwnerActivityConverter ownerActivityConverter = new ModelPropertyEntryToOwnerActivityConverter(); ModelItem activityItem = ownerActivityConverter.Convert(propertyValue.ParentProperty, typeof(ModelItem), false, null) as ModelItem; EditingContext context = activityItem.GetEditingContext(); ModelItem parentModelItem = ownerActivityConverter.Convert(propertyValue.ParentProperty, typeof(ModelItem), true, null) as ModelItem; ModelItemDictionary arguments = parentModelItem.Properties[propertyValue.ParentProperty.PropertyName].Dictionary; DynamicArgumentDesignerOptions options = new DynamicArgumentDesignerOptions { Title = propertyValue.ParentProperty.DisplayName }; using (ModelEditingScope change = arguments.BeginEdit("PowerShellParameterEditing")) { if (DynamicArgumentDialog.ShowDialog(activityItem, arguments, context, activityItem.View, options)) { change.Complete(); } else { change.Revert(); } } }
public override void ShowDialog(PropertyValue propertyValue, System.Windows.IInputElement commandSource) { EventActionWin wn = new EventActionWin(); EventActionDefine action = propertyValue.Value as EventActionDefine; wn.action_url = action.url; wn.action_params = action.action_params; wn.event_linkParams = action.event_params; if (wn.ShowDialog().Equals(true)) { var ownerActivityConverter = new ModelPropertyEntryToOwnerActivityConverter(); ModelItem activityItem = ownerActivityConverter.Convert(propertyValue.ParentProperty, typeof(ModelItem), false, null) as ModelItem; using (ModelEditingScope editingScope = activityItem.BeginEdit()) { EventActionDefine newValue = new EventActionDefine(); newValue.url = wn.action_url; newValue.action_params = wn.action_params; newValue.event_params = wn.event_linkParams; propertyValue.Value = newValue; editingScope.Complete(); var control = commandSource as Control; var oldData = control.DataContext; control.DataContext = null; control.DataContext = oldData; } } }
public Variable <T> GetVariableOf <T>(string Name) { if (selectedActivity == null) { throw new Exception("Cannot get variable when no activity has been selected"); } var seq = GetVariableScope(selectedActivity); if (seq == null) { throw new Exception("Cannot add variables to root activity!"); } Variable <T> result = null; result = GetVariableModel <T>(Name, selectedActivity); if (result == null) { ModelService modelService = wfDesigner.Context.Services.GetService <ModelService>(); using (ModelEditingScope editingScope = modelService.Root.BeginEdit("Implementation")) { var Variables = seq.Properties["Variables"].Collection; result = new Variable <T>() { Name = Name }; Variables.Add(result); editingScope.Complete(); } } return(result); }
public void ShowDialog(ModelItem ownerActivity) { using (ModelEditingScope modelEditingScope = ownerActivity.BeginEdit()) { var dlg = new VBNetCodeEditorDialog(ownerActivity); if (!string.IsNullOrEmpty(Title)) { dlg.Title = Title; } if (!string.IsNullOrEmpty(ContentTitle)) { dlg.lblContentTitle.Content = ContentTitle; } if (dlg.ShowOkCancel()) { modelEditingScope.Complete(); } else { modelEditingScope.Revert(); } } }
// return true if really something is dropped, otherwise, false. bool DoAutoWrapDrop(InsertionPosition insertionPos, IEnumerable <object> droppedObjects) { List <Activity> activityList = ObjectList2ActivityList(droppedObjects); if (activityList.Count == 0) { return(false); } AutoWrapEventArgs args = new AutoWrapEventArgs() { InsertionPosition = insertionPos, ExistingActivity = this.MyActivity, ActivitiesToBeInserted = activityList }; using (ModelEditingScope scope = this.Context.Services.GetService <ModelService>().Root.BeginEdit(SR.WrapInSequenceDescription)) { ModelItem sequenceActivity = WorkflowItemPresenter.AutoWrapInSequenceHandler(this.Context, args); if (this.UpdateItem(sequenceActivity, true)) { scope.Complete(); return(true); } else { scope.Revert(); return(false); } } }
private static void UpdateTypeArgument(ModelItem modelItem, Int32 argumentIndex, Type newGenericType) { Type itemType = modelItem.ItemType; Type[] genericTypes = itemType.GetGenericArguments(); // Replace the type being changed genericTypes[argumentIndex] = newGenericType; Type newType = itemType.GetGenericTypeDefinition().MakeGenericType(genericTypes); EditingContext editingContext = modelItem.GetEditingContext(); Object instanceOfNewType = Activator.CreateInstance(newType); ModelItem newModelItem = ModelFactory.CreateItem(editingContext, instanceOfNewType); using (ModelEditingScope editingScope = newModelItem.BeginEdit("Change type argument")) { MorphHelper.MorphObject(modelItem, newModelItem); MorphHelper.MorphProperties(modelItem, newModelItem); if (itemType.IsSubclassOf(typeof(Activity)) && newType.IsSubclassOf(typeof(Activity))) { if (DisplayNameRequiresUpdate(modelItem)) { // Update to the new display name String newDisplayName = GetActivityDefaultName(newType); newModelItem.Properties[DisplayName].SetValue(newDisplayName); } } DesignerUpdater.UpdateModelItem(modelItem, newModelItem); editingScope.Complete(); } }
void OnCreateSendReplyExecute(object sender, ExecutedRoutedEventArgs e) { ModelItem container; ModelItem flowStepContainer; using (ModelEditingScope scope = this.ModelItem.BeginEdit((string)this.FindResource("createSendReplyDescription"))) { //special case handling for Sequence if (this.ModelItem.IsItemInSequence(out container)) { //get activities collection ModelItemCollection activities = container.Properties["Activities"].Collection; //get index of Send within collection and increment by one int index = activities.IndexOf(this.ModelItem) + 1; //insert created reply just after the Receive activities.Insert(index, ReceiveDesigner.CreateSendReply(container, this.ModelItem)); } //special case handling for Flowchart else if (this.ModelItem.IsItemInFlowchart(out container, out flowStepContainer)) { Activity replyActivity = ReceiveDesigner.CreateSendReply(container, this.ModelItem); FlowchartDesigner.DropActivityBelow(this.ViewStateService, this.ModelItem, replyActivity, 30); } else { ErrorReporting.ShowAlertMessage(string.Format(CultureInfo.CurrentUICulture, System.Activities.Core.Presentation.SR.CannotPasteSendReplyOrReceiveReply, typeof(SendReply).Name)); } scope.Complete(); } //always copy reply to clipboard Func <ModelItem, object, object> callback = CreateSendReply; CutCopyPasteHelper.PutCallbackOnClipBoard(callback, typeof(SendReply), this.ModelItem); e.Handled = true; }
public void BeginEdit() { try { _scope = _modelItem.BeginEdit(); _session = new UaSession { EndpointUrl = Session.EndpointUrl }; if (_session != null) { try { NamespaceItems.Clear(); var root = new ReferenceDescriptionViewModel(new ReferenceDescription { DisplayName = "Objects", NodeId = new NodeId(Objects.ObjectsFolder, 0) }, null, LoadChildren); NamespaceItems.Add(root); root.IsExpanded = true; } catch (Exception ex) { Debug.WriteLine(ex.Message); } } } catch (Exception ex) { Debug.WriteLine(ex.Message); } }
public override void ShowDialog(PropertyValue propertyValue, IInputElement commandSource) { string propertyName = propertyValue.ParentProperty.PropertyName; var ownerActivity = (new ModelPropertyEntryToOwnerActivityConverter()).Convert( propertyValue.ParentProperty, typeof(ModelItem), false, null) as ModelItem; DynamicArgumentDesignerOptions options = new DynamicArgumentDesignerOptions() { Title = propertyName }; ModelItem modelItem = ownerActivity.Properties[propertyName].Dictionary; using (ModelEditingScope change = modelItem.BeginEdit(propertyName + "Editing")) { if (DynamicArgumentDialog.ShowDialog(ownerActivity, modelItem, ownerActivity.GetEditingContext(), ownerActivity.View, options)) { change.Complete(); } else { change.Revert(); } } }
private void EditColumn() { DataGridColumnModel columnModel = datagridColumnsListBox.SelectedItem as DataGridColumnModel; if (columnModel == null) { return; } using (ModelEditingScope scope = columnModel.Column.BeginEdit(columnModel.Column.Name + " Changed")) { EditDataGridColumnsUserInterface ui = new EditDataGridColumnsUserInterface(_context, columnModel, _dataSourceProperties); // Use Windows Forms to show the design time because Windows Forms knows about the VS message pump System.Windows.Forms.DialogResult result = DesignerDialog.ShowDesignerDialog("Edit Column", ui, 360, 470); if (result == System.Windows.Forms.DialogResult.OK) { scope.Complete(); _dataSourcePropertiesCVS.View.Refresh(); } else { scope.Revert(); } } }
public static void OnAddAnnotationCommandExecuted(ExecutedRoutedEventArgs e, ModelItem modelItem) { ModelProperty property = modelItem.Properties.Find(Annotation.AnnotationTextPropertyName); if (property != null) { using (ModelEditingScope editingScope = modelItem.BeginEdit(SR.AddAnnotationDescription)) { property.SetValue(string.Empty); ViewStateService viewStateService = modelItem.GetEditingContext().Services.GetService <ViewStateService>(); viewStateService.StoreViewStateWithUndo(modelItem, Annotation.IsAnnotationDockedViewStateName, false); editingScope.Complete(); } if (modelItem.View != null) { WorkflowViewElement element = modelItem.View as WorkflowViewElement; if (element != null) { element.OnEditAnnotation(); } } } e.Handled = true; }
// <summary> // Basic ctor // </summary> // <param name="property">Property to display</param> // <param name="valueDialogTemplate">Template to use</param> public PropertyValueDialogControl(PropertyEntry property, DataTemplate valueDialogTemplate) { Fx.Assert(property != null, "property parameter is null"); Fx.Assert(valueDialogTemplate != null, "valueDialogTemplate parameter is null"); ModelPropertyEntry modelPropertyValue = property as ModelPropertyEntry; if (modelPropertyValue != null) { _rootTransaction = modelPropertyValue.FirstModelProperty.Value.BeginEdit(); } InitializeComponent(); // Make sure we use PI-specific resources within this control this.Resources.MergedDictionaries.Add(PropertyInspectorResources.GetResources()); // Hook into an opening of nested dialogs. PropertyInspector class takes care of this for us. // However, we are using Blend's collection editor which doesn't do the same thing, so // we need to reproduce that behavior manually. PropertyValueDialogHost.AttachOpenDialogHandlers(this); // Hook into the standard set of Commands _defaultCommandHandler = new PropertyValueEditorCommandHandler(this); _OKButton.Click += new RoutedEventHandler(OnOkButtonClicked); _cancelButton.Click += new RoutedEventHandler(OnCancelButtonClicked); _contentControl.Content = property.PropertyValue; _contentControl.ContentTemplate = valueDialogTemplate; //Handle the commit and cancel keys within the property inspector, that is hosted in the collection editor ValueEditorUtils.SetHandlesCommitKeys(this, true); }
public override void ShowDialog(PropertyValue propertyValue, System.Windows.IInputElement commandSource) { TimeoutWin wn = new TimeoutWin(); Dictionary <string, object> action = propertyValue.Value as Dictionary <string, object>; wn.time_start = action.ContainsKey("start") ? (action["start"] as string) : ""; wn.time_offset = action.ContainsKey("offset") ? (action["offset"] as TimeSpan?) : null; wn.time_exact = action.ContainsKey("exact") ? (action["exact"] as DateTime?) : null; wn.time_callback = action.ContainsKey("callback") ? (action["callback"] as string) : ""; wn.time_action = action.ContainsKey("action") ? (action["action"] as string) : ""; if (wn.ShowDialog().Equals(true)) { var ownerActivityConverter = new ModelPropertyEntryToOwnerActivityConverter(); ModelItem activityItem = ownerActivityConverter.Convert(propertyValue.ParentProperty, typeof(ModelItem), false, null) as ModelItem; using (ModelEditingScope editingScope = activityItem.BeginEdit()) { Dictionary <string, object> newValue = new Dictionary <string, object>(); newValue["start"] = wn.time_start; newValue["offset"] = wn.time_offset; newValue["exact"] = wn.time_exact; newValue["action"] = wn.time_action; newValue["callback"] = wn.time_callback; propertyValue.Value = newValue; editingScope.Complete(); var control = commandSource as Control; var oldData = control.DataContext; control.DataContext = null; control.DataContext = oldData; } } }
/// <summary> /// Handles the Click event of the DefineArgsButton control to launch a DynamicArgumentDialog instance for argument editing. /// </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> private void DefineArgsButton_Click(object sender, RoutedEventArgs e) { DynamicArgumentDesignerOptions options = new DynamicArgumentDesignerOptions() { Title = Bot.Activity.ActivityLibrary.Properties.Resources.DynamicArgumentDialogTitle }; this.InitImportDynamicArgumentDialog(); this.ModelItem.Properties["ChildArguments"].SetValue(argumentDictionary); ModelItem modelItem = this.ModelItem.Properties["ChildArguments"].Dictionary; using (ModelEditingScope change = modelItem.BeginEdit("ChildArgumentEditing")) { ThreadInvoker.Instance.RunByUiThread(() => { if (DynamicArgumentDialog.ShowDialog(this.ModelItem, modelItem, Context, this.ModelItem.View, options)) { change.Complete(); } else { change.Revert(); } }); } }
/// <summary> /// Add Columns based on the datasource /// </summary> private void AddColumns(ModelItem selectedDataGrid, EditingContext context) { using (ModelEditingScope scope = selectedDataGrid.BeginEdit("Generate Columns")) { // Set databinding related properties DataGridHelper.SparseSetValue(selectedDataGrid.Properties[DataGrid.AutoGenerateColumnsProperty], false); // Get the datasource object dataSource = selectedDataGrid.Properties[ItemsControl.ItemsSourceProperty].ComputedValue; if (dataSource != null) { // Does WPF expose something like ListBindingHelper? PropertyDescriptorCollection dataSourceProperties = System.Windows.Forms.ListBindingHelper.GetListItemProperties(dataSource); foreach (PropertyDescriptor pd in dataSourceProperties) { ModelItem dataGridColumn = null; dataGridColumn = DataGridHelper.CreateDefaultDataGridColumn(context, pd); if (dataGridColumn != null) { selectedDataGrid.Properties["Columns"].Collection.Add(dataGridColumn); } } } scope.Complete(); } }
bool UpdateItem(object newItem, bool allowReplaceExistingActivity) { bool updateSucceeded = false; ModelItem newModelItem = newItem as ModelItem; if (this.Item == null || allowReplaceExistingActivity) { if (newModelItem == null && newItem != null) { // try to wrap the droppedObject in a ModelItem. ModelServiceImpl modelService = (ModelServiceImpl)this.Context.Services.GetService <ModelService>(); newModelItem = modelService.WrapAsModelItem(newItem); } if (this.CanUpdateItem(newModelItem)) { // In order to allow for model updates that happens during the model item is drop, this is all done in an atomic unit. using (ModelEditingScope editingScope = this.Context.Services.GetService <ModelService>().Root.BeginEdit(SR.PropertyChangeEditingScopeDescription)) { this.Item = newModelItem; editingScope.Complete(); } updateSucceeded = true; this.isItemPastedOrDropped = true; } } return(updateSucceeded); }
private void Button_Click(object sender, RoutedEventArgs e) { var options = new DynamicArgumentDesignerOptions { Title = string.Format("Параметры метода {0}", _methodInfo.Name) }; var modelParameters = GetParametersProperty(); foreach (var p in _methodParameters) { if (modelParameters.ContainsKey(p.Name ?? ResultParamName)) { continue; } var direction = (p.IsOut || p.IsRetval || string.IsNullOrEmpty(p.Name)) ? ArgumentDirection.Out : ArgumentDirection.In; modelParameters.Add(p.Name ?? ResultParamName, ActivityHelpers.CreateDefaultValue(p.ParameterType, direction)); } using (ModelEditingScope change = modelParameters.BeginEdit("ObjectEditing")) { if (DynamicArgumentDialog.ShowDialog(ModelItem, modelParameters, Context, ModelItem.View, options)) { change.Complete(); } else { change.Revert(); } } }
public void Complete() { if (this._activeTool == null) { throw new InvalidOperationException(Resources.Error_ObjectNotActive); } ModelEditingScope modelEditingScope = this._editingScope; try { this.OnCompleted(EventArgs.Empty); if (modelEditingScope == null) { return; } if (this.Description.Length > 0) { modelEditingScope.Description = this.Description; } modelEditingScope.Complete(); modelEditingScope = (ModelEditingScope)null; } finally { this._activeTool.ClearFocusedTask(); this._activeTool = (Tool)null; this._editingScope = (ModelEditingScope)null; if (modelEditingScope != null) { modelEditingScope.Revert(); } this.OnFocusDeactivated(EventArgs.Empty); } }
// These methods are not used, but they are very useful when developing the Design experience #if Development /// <summary> /// Adds a default column for each property in the data source /// </summary> public static void GenerateColumns(ModelItem dataGridModelItem, EditingContext context) { using (ModelEditingScope scope = dataGridModelItem.BeginEdit(Properties.Resources.Generate_Columns)) { // Set databinding related properties DataGridDesignHelper.SparseSetValue(dataGridModelItem.Properties[MyPlatformTypes.DataGrid.AutoGenerateColumnsProperty], false); // Get the datasource object dataSource = dataGridModelItem.Properties[MyPlatformTypes.DataGrid.ItemsSourceProperty].ComputedValue; if (dataSource != null) { foreach (ColumnInfo columnGenerationInfo in DataGridDesignHelper.GetColumnGenerationInfos(dataSource)) { ModelItem dataGridColumn = null; dataGridColumn = DataGridDesignHelper.CreateDefaultDataGridColumn(context, columnGenerationInfo); if (dataGridColumn != null) { dataGridModelItem.Properties[MyPlatformTypes.DataGrid.ColumnsProperty].Collection.Add(dataGridColumn); } } } scope.Complete(); } }
private void Button_Click_2(object sender, RoutedEventArgs e) { ModelItemDictionary dictionary = base.ModelItem.Properties["Arguments"].Dictionary; try { string form = ModelItem.GetValue <string>("Form"); var definition = Forge.Forms.FormBuilding.FormBuilder.Default.GetDefinition(form, freeze: false); foreach (DataFormField f in definition.GetElements().Where(x => x is DataFormField)) { bool exists = false; foreach (var key in dictionary.Keys) { if (key.ToString() == f.Key) { exists = true; } if (key.GetValue <string>("AnnotationText") == f.Key) { exists = true; } if (key.GetValue <string>("Name") == f.Key) { exists = true; } } if (!exists) { Type t = f.PropertyType; Type atype = typeof(VisualBasicValue <>); Type constructed = atype.MakeGenericType(t); object o = Activator.CreateInstance(constructed, f.Key); Argument a = null; a = Argument.Create(t, ArgumentDirection.InOut); dictionary.Add(f.Key, a); } } } catch (Exception) { } var options = new System.Activities.Presentation.DynamicArgumentDesignerOptions() { Title = "Map Arguments" }; using (ModelEditingScope modelEditingScope = dictionary.BeginEdit()) { if (System.Activities.Presentation.DynamicArgumentDialog.ShowDialog(base.ModelItem, dictionary, base.Context, base.ModelItem.View, options)) { modelEditingScope.Complete(); } else { modelEditingScope.Revert(); } } }
/// <summary> /// Removes all columns from the DataGrid /// </summary> public static void RemoveColumns(ModelItem dataGridModelItem, EditingContext editingContext) { using (ModelEditingScope scope = dataGridModelItem.BeginEdit(Properties.Resources.Remove_Columns)) { dataGridModelItem.Properties[MyPlatformTypes.DataGrid.ColumnsProperty].Collection.Clear(); scope.Complete(); } }
internal static void GoToFirstPage(ModelItem wizard) { using (ModelEditingScope changes = wizard.BeginEdit(Resources.FirstPageText)) { SetCurrentPageIndex(wizard, 0); changes.Complete(); } }
private void GenerateExpression() { //TODO: Enhance the type infering logic if (ExpressionType == null) { // Get the variables in scope List <ModelItem> declaredVariables = CSharpExpressionHelper.GetVariablesInScope(OwnerActivity); if (declaredVariables.Count > 0) { InferredType = ((LocationReference)declaredVariables[0].GetCurrentValue()).Type; } } Type resultType = ExpressionType != null ? ExpressionType : InferredType; ////This could happen when: ////1) No ExpressionType is specified and ////2) The expression is invalid so that the inferred type equals to null if (resultType == null) { resultType = typeof(object); } // If the text is null we don't need to bother generating the expression (this would be the case the // first time you enter an ETB. We still need to generate the expression when it is EMPTY however - otherwise // the case where you had an expression (valid or invalid), then deleted the whole thing will not be evaluated. if (Text != null) { using (ModelEditingScope scope = OwnerActivity.BeginEdit("Property Change")) if (OwnerActivity != null) { EditingState = EditingState.Validating; // we set the expression to null // a) when the expressionText is empty AND it's a reference expression or // b) when the expressionText is empty AND the DefaultValue property is null if (Text.Length == 0 && (UseLocationExpression || DefaultValue == null)) { Expression = null; } else { if (Text.Length == 0) { Text = DefaultValue; } ModelTreeManager modelTreeManager = Context.Services.GetService <ModelTreeManager>(); ActivityWithResult newExpression = CSharpExpressionHelper.CreateExpressionFromString(Text, UseLocationExpression, resultType); ModelItem expressionItem = modelTreeManager.CreateModelItem(null, newExpression); Expression = expressionItem; } scope.Complete(); } } }
internal static void GoToNextPage(ModelItem wizard) { using (ModelEditingScope changes = wizard.BeginEdit(Resources.NextPageText)) { var pageIndex = GetCurrentPageIndex(wizard); SetCurrentPageIndex(wizard, pageIndex + 1); changes.Complete(); } }
internal static void GoToLastPage(ModelItem wizard) { using (ModelEditingScope changes = wizard.BeginEdit(Resources.LastPageText)) { int pageCount = wizard.Content.Collection.Count; SetCurrentPageIndex(wizard, pageCount - 1); changes.Complete(); } }
public ModelItem addActivity(Activity a) { ModelItem newItem = null; ModelService modelService = wfDesigner.Context.Services.GetService <ModelService>(); using (ModelEditingScope editingScope = modelService.Root.BeginEdit("Implementation")) { var lastSequence = GetSequence(selectedActivity); if (lastSequence == null && selectedActivity != null) { lastSequence = GetActivitiesScope(selectedActivity.Parent); } if (lastSequence != null) { ModelItemCollection Activities = null; if (lastSequence.Properties["Activities"] != null) { Activities = lastSequence.Properties["Activities"].Collection; } else { Activities = lastSequence.Properties["Nodes"].Collection; } var insertAt = Activities.Count; for (var i = 0; i < Activities.Count; i++) { if (Activities[i].Equals(selectedActivity)) { insertAt = (i + 1); } } if (lastSequence.Properties["Activities"] != null) { newItem = Activities.Insert(insertAt, a); } else { FlowStep step = new FlowStep(); step.Action = a; newItem = Activities.Insert(insertAt, step); } //Selection.Select(wfDesigner.Context, selectedActivity); //ModelItemExtensions.Focus(selectedActivity); } editingScope.Complete(); //WorkflowInspectionServices.CacheMetadata(a); } if (newItem != null) { selectedActivity = newItem; newItem.Focus(20); Selection.SelectOnly(wfDesigner.Context, newItem); } return(newItem); }
void OnModelItemPropertyChanged(object sender, PropertyChangedEventArgs e) { if (e.PropertyName == "Expression") { Update(); } else if (e.PropertyName == "DefaultCaseDisplayName") { // To fix 218600 without losing PropertyGrid focus (Bug 210326), the only workaround is to // update the connector label manually, because FlowSwitchLink.ModelItem["DefaultCaseDisplayName"] // is a FakeModelPropertyImpl, and would not generate a Undo unit // (FakeModelNotifyPropertyChange.GetInverse() returns null). // However, there is a known issue with PropertyGrid bound to a fake ModelItem. The workaround is // to shift the focus to the FlowchartDesigner IF the keyboard focus is on the connector when the user // calls Undo/Redo, to avoid the problem of PropertyGrid not refreshable. FlowchartDesigner flowchartDesigner = VisualTreeUtils.FindVisualAncestor <FlowchartDesigner>(this); Fx.Assert(null != flowchartDesigner, "flowchart designer cannot be null because FlowswitchDesigner must exist within the same visual tree ofthe parent Flowchart."); if (null != flowchartDesigner && null != this.ModelItem.Properties["Default"].Value && this.Context.Services.GetService <UndoEngine>().IsUndoRedoInProgress) { // the designer is available Connector connector = flowchartDesigner.GetLinkOnCanvas(this.ModelItem, this.ModelItem.Properties["Default"].Value, "Default"); Fx.Assert(null != connector, "Connector should not be null."); ModelItem linkModelItem = FlowchartDesigner.GetLinkModelItem(connector); Fx.Assert(linkModelItem is FakeModelItemImpl, "ModelItem of FlowSwitch link is fake."); IFlowSwitchDefaultLink link = (IFlowSwitchDefaultLink)linkModelItem.GetCurrentValue(); string defaultDisplayName = (string)this.ModelItem.Properties[FlowSwitchLabelFeature.DefaultCaseDisplayNamePropertyName].Value.GetCurrentValue(); if (link.DefaultCaseDisplayName != defaultDisplayName) { // the purpose of re-setting the link value during Undo/Redo is to update the FlowSwitch label using (ModelEditingScope scope = this.ModelItem.BeginEdit(SR.FlowSwitchDefaultCaseDisplayNameEditingScopeDesc)) { linkModelItem.Properties[FlowSwitchLabelFeature.DefaultCaseDisplayNamePropertyName].SetValue(defaultDisplayName); link.DefaultCaseDisplayName = defaultDisplayName; scope.Complete(); } if (Selection.IsSelection(linkModelItem)) { // cause the connector to lose focus, because the PropertyGrid would not have focus. // this scenario only happens if the user explicitly selects the FlowSwitch link after // editing the DefaultDisplayName. This behavior is only a workaround due to the fact // that PropertyGrid does not receive update from change in a FakeModelPropertyImpl // (i.e. FlowSwitchLink). Keyboard.ClearFocus(); Selection.SelectOnly(this.Context, this.ModelItem); linkModelItem.Highlight(); } } } } }
private void AbortRootTransaction() { if (_rootTransaction == null) { return; } _rootTransaction.Revert(); _rootTransaction = null; }
/// <summary> /// Remove columns /// </summary> private void RemoveColumnsMenuAction_Execute(object sender, MenuActionEventArgs e) { ModelItem selectedDataGrid = e.Selection.PrimarySelection; using (ModelEditingScope scope = selectedDataGrid.BeginEdit("Delete Grid Columns")) { selectedDataGrid.Properties["Columns"].Collection.Clear(); scope.Complete(); } }
// The following method handles the MouseLeftButtonDown event. // It calls the BeginEdit method on the ModelItem which represents // the adorned control. void slider_MouseLeftButtonDown( object sender, System.Windows.Input.MouseButtonEventArgs e) { batchedChange = adornedControlModel.BeginEdit(); }
// The following method handles the MouseLeftButtonUp event. // It commits any changes made to the ModelItem which represents the // the adorned control. void slider_MouseLeftButtonUp( object sender, System.Windows.Input.MouseButtonEventArgs e) { if (batchedChange != null) { batchedChange.Complete(); batchedChange.Dispose(); batchedChange = null; } }