void OnSelectionChanged(Selection selection) { if (selection.PrimarySelection != this.lastNavigatedItem) { this.isModelTreeChanged = true; } }
private static bool AreSelectionsEquivalent(View.Selection a, View.Selection b) { if (a == null && b == null) { return(true); } if (a == null || b == null) { return(false); } if (a.SelectionCount != b.SelectionCount) { return(false); } // POSSIBLE OPTIMIZATION: be smarter about same selection in a different order IEnumerator <ModelItem> ea = a.SelectedObjects.GetEnumerator(); IEnumerator <ModelItem> eb = b.SelectedObjects.GetEnumerator(); while (ea.MoveNext() && eb.MoveNext()) { if (!object.Equals(ea.Current, eb.Current)) { return(false); } } return(true); }
// IPropertyInspectorState internal void Dispose() { _disposed = true; DisassociateAllProperties(); UpdateSelectionPropertyChangedEventHooks(_displayedSelection, null); _displayedSelection = null; _defaultCommandHandler.Dispose(); _defaultCommandHandler = null; }
// Removes / adds a PropertyChanged listener from / to the previous / current selection private void UpdateSelectionPropertyChangedEventHooks(View.Selection previousSelection, View.Selection currentSelection) { if (previousSelection != null && previousSelection.PrimarySelection != null) { previousSelection.PrimarySelection.PropertyChanged -= OnSelectedItemPropertyChanged; } if (currentSelection != null && currentSelection.PrimarySelection != null) { currentSelection.PrimarySelection.PropertyChanged += OnSelectedItemPropertyChanged; } }
// Looks for common parent ModelItem among all the items in the selection private static ModelItem GetCommonParent(View.Selection selection) { if (selection == null || selection.SelectionCount < 1) { return(null); } ModelItem parent = null; foreach (ModelItem item in selection.SelectedObjects) { if (parent == null) { parent = item.Parent; } else if (parent != item.Parent) { return(null); } } return(parent); }
// Tries to figure out what property to select and selects is private void UpdateSelectedProperty(View.Selection selection) { // If we are not loaded, skip any and all selection magic if (!this.IsLoaded) { return; } if (selection != null) { // See what the view would like us to select if we run out of things // we can think of selecting // SelectionPath fallbackSelection = null; if (_propertyToolBar.CurrentViewManager != null) { fallbackSelection = _propertyToolBar.CurrentViewManager.GetDefaultSelectionPath(_categoryList); } // Select the first thing we request that exists, using the following // precedence order: // // * LastSelectionPath // * DefaultProperty // * Whatever the view wants to show (first category, first property, ...) // _categoryList.UpdateSelectedProperty( this.LastSelectionPath, ModelPropertyMerger.GetMergedDefaultProperty(selection.SelectedObjects), fallbackSelection); } if (DesignerPerfEventProvider != null) { DesignerPerfEventProvider.PropertyInspectorUpdatePropertyListEnd(); } }
/// <summary> /// Selection helper method. This sets itemToSelect into the selection. /// Any existing items are deselected. /// </summary> /// <param name="context">The editing context to apply this selection change to.</param> /// <param name="itemToSelect">The item to select.</param> /// <returns>A Selection object that contains the new selection.</returns> /// <exception cref="ArgumentNullException">If context or itemToSelect is null.</exception> public static Selection SelectOnly(EditingContext context, ModelItem itemToSelect) { if (context == null) throw FxTrace.Exception.ArgumentNull("context"); if (itemToSelect == null) throw FxTrace.Exception.ArgumentNull("itemToSelect"); // Check to see if only this object is selected. If so, bail. Selection existing = context.Items.GetValue<Selection>(); if (existing.PrimarySelection == itemToSelect) { IEnumerator<ModelItem> en = existing.SelectedObjects.GetEnumerator(); en.MoveNext(); if (!en.MoveNext()) { return existing; } } DesignerPerfEventProvider designerPerfEventProvider = context.Services.GetService<DesignerPerfEventProvider>(); if (designerPerfEventProvider != null) { designerPerfEventProvider.SelectionChangedStart(); } Selection selection = new Selection(itemToSelect); context.Items.SetValue(selection); return selection; }
/// <summary> /// Selection helper method. This takes the existing selection in the /// context and creates a new selection that contains the toggled /// state of the item. If the item is to be /// added to the selection, it is added as the primary selection. /// </summary> /// <param name="context">The editing context to apply this selection change to.</param> /// <param name="itemToToggle">The item to toggle selection for.</param> /// <returns>A Selection object that contains the new selection.</returns> /// <exception cref="ArgumentNullException">If context or itemToToggle is null.</exception> public static Selection Toggle(EditingContext context, ModelItem itemToToggle) { if (context == null) throw FxTrace.Exception.ArgumentNull("context"); if (itemToToggle == null) throw FxTrace.Exception.ArgumentNull("itemToToggle"); Selection existing = context.Items.GetValue<Selection>(); // Is the item already in the selection? If so, remove it. // If not, add it to the beginning. List<ModelItem> list = new List<ModelItem>(existing.SelectedObjects); if (list.Contains(itemToToggle)) { list.Remove(itemToToggle); } else { list.Insert(0, itemToToggle); } Selection selection = new Selection(list); context.Items.SetValue(selection); return selection; }
void SelectionChanged(Selection selection) { this.selectedModelItem = selection.PrimarySelection; }
/// <summary> /// Selection helper method. This takes the existing selection in the /// context and selects an item into it. If the item is already in the /// selection the selection is preserved and the item is promoted /// to the primary selection. /// </summary> /// <param name="context">The editing context to apply this selection change to.</param> /// <param name="itemToSelect">The item to select.</param> /// <returns>A Selection object that contains the new selection.</returns> /// <exception cref="ArgumentNullException">If context or itemToSelect is null.</exception> public static Selection Select(EditingContext context, ModelItem itemToSelect) { if (context == null) throw FxTrace.Exception.ArgumentNull("context"); if (itemToSelect == null) throw FxTrace.Exception.ArgumentNull("itemToSelect"); Selection existing = context.Items.GetValue<Selection>(); // short cut if we're already in the right state. if (existing.PrimarySelection == itemToSelect) { return existing; } Selection selection = null; foreach (ModelItem obj in existing.SelectedObjects) { if (obj == itemToSelect) { List<ModelItem> list = new List<ModelItem>(existing.SelectedObjects); list.Remove(itemToSelect); list.Insert(0, itemToSelect); selection = new Selection(list); } } if (selection == null) { selection = new Selection(itemToSelect); } context.Items.SetValue(selection); return selection; }
private void SelectionChanged(Selection selection) { var httpRequestSequenceFilesViewModel = ServiceLocator.Current.GetInstance<HttpRequestSequenceFilesViewModel>(); if (httpRequestSequenceFilesViewModel.IsLoadingSequence) { return; } eventAggregator.GetEvent<IsDirtyEvent>().Publish(new IsDirtyData(httpRequestSequenceViewModel, true)); var modelItem = selection.PrimarySelection; if (modelItem == null) { return; } if (modelItem.ItemType == typeof(HttpRequestIfElseActivityModel) || modelItem.ItemType == typeof(RetryUntilActivityModel)) { if (modelItem.Properties["Operators"].Collection.Count > 4) { for (var i = modelItem.Properties["Operators"].Collection.Count - 1; i >= 4; i--) { modelItem.Properties["Operators"].Collection.RemoveAt(i); } } if (modelItem.Properties["ResponseSections"].Collection.Count > 3) { for (var i = modelItem.Properties["ResponseSections"].Collection.Count - 1; i >= 3; i--) { modelItem.Properties["ResponseSections"].Collection.RemoveAt(i); } } } var httpRequests = modelItem.Properties["HttpRequests"]; if (modelItem.Properties["HttpRequests"] != null) { // remove deleted var deleted = httpRequests.Collection.Where(x => !Solution.Current.HttpRequestFiles.Any(s => s.Id == x.Properties["Id"].Value.ToString())); for (var i = httpRequests.Collection.Count - 1; i >= 0; i--) { var deletedItems = deleted as IList<ModelItem> ?? deleted.ToList(); if (deletedItems.Any(x => x.Properties["Id"].Value.ToString() == httpRequests.Collection[i].Properties["Id"].Value.ToString())) { httpRequests.Collection.RemoveAt(i); } } // add new foreach (var httpRequestFile in Solution.Current.HttpRequestFiles) { if (!httpRequests.Collection.Any(x => x.Properties["Id"].Value.ToString() == httpRequestFile.Id)) { httpRequests.Collection.Add(httpRequestFile); } } } }
private ModelItem GetTopmostSelectedArgument(Selection selection, ModelItemCollection arguments) { foreach (ModelItem argument in arguments) { foreach (ModelItem candidateArgument in selection.SelectedObjects) { if (candidateArgument.ItemType == typeof(DesignTimeArgument)) { // since for arguments, the selection is not the modelitem, it is the fakemodelitem, we cannot do a // simple reference comparing to find the selected argument. DesignTimeArgument designTimeArgument = candidateArgument.GetCurrentValue() as DesignTimeArgument; if (designTimeArgument.ReflectedObject == argument) { return argument; } } } } return null; }
void OnConnectorGotFocus(object sender, RoutedEventArgs e) { Connector connector = e.Source as Connector; if (this.panel.connectorEditor == null || !connector.Equals(this.panel.connectorEditor.Connector)) { this.panel.RemoveConnectorEditor(); this.panel.connectorEditor = new ConnectorEditor(this.panel, connector); } if (this.panel.Children.Contains(connector)) { this.updatingSelectedConnector = true; ModelItem connectorModelItem = StateContainerEditor.GetConnectorModelItem(connector); Selection newSelection = new Selection(); if (connectorModelItem != null && connectorModelItem.ItemType == typeof(Transition)) { newSelection = new Selection(connectorModelItem); } this.Context.Items.SetValue(newSelection); this.selectedConnector = connector; this.updatingSelectedConnector = false; if (connectorModelItem.ItemType == typeof(Transition)) { // Populate the source and destination States's View if it is still in Virtualized mode. ModelItem destinationState = connectorModelItem.Properties[TransitionDesigner.ToPropertyName].Value; PopulateVirtualizingContainer(destinationState); ModelItem sourceState = StateContainerEditor.GetParentStateModelItemForTransition(connectorModelItem); PopulateVirtualizingContainer(sourceState); // Assign its destination State's View on the connector model item for copy/paste function. ((IModelTreeItem)connectorModelItem).SetCurrentView(destinationState.View); } e.Handled = true; } }
void SelectionChanged(Selection item) { _workflowDesignerSelection = item; if(_workflowDesignerSelection != null) { if(_workflowDesignerSelection.PrimarySelection == ModelItem) { IsSelected = true; BringToFront(); ShowAllAdorners(); } else { IsSelected = false; HideAdorners(); } } }
// Selection Logic // SelectionPathStateContainer // <summary> // Called externally whenever selection changes // </summary> // <param name="selection">New selection</param> public void OnSelectionChanged(View.Selection selection) { _lastNotifiedSelection = selection; RefreshSelection(); }
/// <summary> /// Selection helper method. This takes the existing selection in the /// context and creates a new selection that contains the original /// selection and the itemToAdd. If itemToAdd is already in the /// original selection it is promoted to the primary selection. /// </summary> /// <param name="context">The editing context to apply this selection change to.</param> /// <param name="itemToAdd">The item to add to the selection.</param> /// <returns>A Selection object that contains the new selection.</returns> /// <exception cref="ArgumentNullException">If context or itemToAdd is null.</exception> public static Selection Union(EditingContext context, ModelItem itemToAdd) { if (context == null) throw FxTrace.Exception.ArgumentNull("context"); if (itemToAdd == null) throw FxTrace.Exception.ArgumentNull("itemToAdd"); Selection existing = context.Items.GetValue<Selection>(); // short cut if we're already in the right state. if (existing.PrimarySelection == itemToAdd) { return existing; } // Is the item already in the selection? If not, add it. List<ModelItem> list = new List<ModelItem>(existing.SelectedObjects); if (list.Contains(itemToAdd)) { list.Remove(itemToAdd); } list.Insert(0, itemToAdd); Selection selection = new Selection(list); context.Items.SetValue(selection); return selection; }
// The user can only specify the name for the selected objects iff exactly one // object is selected. private static bool CanSetSelectionName(View.Selection selection) { return(selection != null && selection.SelectionCount == 1); }
// Updates PI when the application becomes Idle (perf optimization) private void OnSelectionChangedIdle() { if (DesignerPerfEventProvider != null) { DesignerPerfEventProvider.PropertyInspectorUpdatePropertyListStart(); } if (AreSelectionsEquivalent(_lastNotifiedSelection, _displayedSelection)) { return; } if (!VisualTreeUtils.IsVisible(this)) { return; } // Change the SelectedControlFlowDirectionRTL resource property // This will allow the 3rd party editors to look at this property // and change to RTL for controls that support RTL. // We set the resource to the primary selections RTL property. FlowDirection commmonFD = this.FlowDirection; if (_lastNotifiedSelection != null && _lastNotifiedSelection.PrimarySelection != null) { FrameworkElement selectedElement = _lastNotifiedSelection.PrimarySelection.View as FrameworkElement; if (selectedElement != null) { commmonFD = selectedElement.FlowDirection; } // In case of mulitislection, // if the FlowDirection is different then always set it to LTR. // else set it to common FD. if (_lastNotifiedSelection.SelectionCount > 1) { foreach (ModelItem item in _lastNotifiedSelection.SelectedObjects) { FrameworkElement curElm = item.View as FrameworkElement; if (curElm != null && curElm.FlowDirection != commmonFD) { //reset to LTR (since the FD's are different within multiselect) commmonFD = FlowDirection.LeftToRight; break; } } } } PropertyInspectorResources.GetResources()["SelectedControlFlowDirectionRTL"] = commmonFD; RefreshPropertyList(false); UpdateSelectionPropertyChangedEventHooks(_displayedSelection, _lastNotifiedSelection); _displayedSelection = _lastNotifiedSelection; _lastParent = GetCommonParent(_lastNotifiedSelection); // Handle dangling transactions _defaultCommandHandler.CommitOpenTransactions(); OnPropertyChanged("IsInfoBarNameReadOnly"); OnPropertyChanged("SelectionName"); OnPropertyChanged("SelectionIcon"); OnPropertyChanged("SelectionTypeName"); }
// This is the work-horse that refreshes the list of properties and categories within a PropertyInspector // window, including refreshing of CategoryEditors, based on the specified selection private void UpdateCategories(View.Selection selection, bool attachedOnly) { // Optimization stolen from Sparkle: // re-rendering the categories is the number one perf issue. Clearing // the databound collection results in massive Avalon code execution, and // then re-adding everything causes another huge shuffle. What is more, // even when changing the selection between different objects, most properties // do not change. Therefore we are going to take the new list of properties // and we are going to merge them into the existing stuff, using an // approach I call Mark, Match, and Cull. // // First we mark all the properties in the current collection. Those which // are still marked at the end will be culled out foreach (ModelCategoryEntry category in _categoryList) { if (attachedOnly) { category.MarkAttachedPropertiesDisassociated(); } else { category.MarkAllPropertiesDisassociated(); } } // Second we try to match each property in the list of properties for the newly selected objects // against something that we already have. If we have a match, then we reset the existing // ModelPropertyEntry and clear the mark // foreach (IEnumerable <ModelProperty> propertySet in ModelPropertyMerger.GetMergedProperties( selection == null ? null : selection.SelectedObjects, selection == null ? 0 : selection.SelectionCount)) { string propertyName = GetPropertyName(propertySet); // Specifically filter out the Name property // PS 40699 - Name is not a special property for WF //if ("Name".Equals(propertyName)) //{ // continue; //} if (attachedOnly && propertyName.IndexOf('.') < 0) { continue; } ModelPropertyEntry wrappedProperty = _propertyToolBar.CurrentViewManager.AddProperty(propertySet, propertyName, _categoryList); // Make sure no valid properties get culled out wrappedProperty.Disassociated = false; } // Third, we walk the properties and categories, and we cull out all of the // marked properties. Empty categories are removed. // for (int i = _categoryList.Count - 1; i >= 0; i--) { ModelCategoryEntry category = (ModelCategoryEntry)_categoryList[i]; category.CullDisassociatedProperties(); if (category.IsEmpty) { _categoryList.RemoveAt(i); } } _categoryList.RefreshFilter(); }
// Helper method that adjusts the visible set of CategoryEditors based on the specified selection private void UpdateCategoryEditors(View.Selection selection) { // Figure out which category editors to show Dictionary <Type, object> newCategoryEditorTypes = _propertyToolBar.CurrentViewManager.GetCategoryEditors( FindCommonType(selection == null ? null : selection.SelectedObjects), _categoryList); // Figure out which CategoryEditors are no longer needed and remove them List <Type> editorTypesToRemove = null; foreach (KeyValuePair <Type, string> item in _activeCategoryEditors) { if (!newCategoryEditorTypes.ContainsKey(item.Key) || !IsCategoryShown(item.Key)) { // New selection does not include this existing category editor // or the category that contains this editor // so remove the editor. if (editorTypesToRemove == null) { editorTypesToRemove = new List <Type>(); } editorTypesToRemove.Add(item.Key); } else { // This category editor already exists, so don't re-add it newCategoryEditorTypes.Remove(item.Key); } } if (editorTypesToRemove != null) { foreach (Type editorTypeToRemove in editorTypesToRemove) { ModelCategoryEntry affectedCategory = _categoryList.FindCategory(_activeCategoryEditors[editorTypeToRemove]) as ModelCategoryEntry; if (affectedCategory != null) { affectedCategory.RemoveCategoryEditor(editorTypeToRemove); } _activeCategoryEditors.Remove(editorTypeToRemove); } } // Figure out which CategoryEditors are now required and add them foreach (Type editorTypeToAdd in newCategoryEditorTypes.Keys) { CategoryEditor editor = (CategoryEditor)ExtensibilityAccessor.SafeCreateInstance(editorTypeToAdd); if (editor == null) { continue; } ModelCategoryEntry affectedCategory = _categoryList.FindCategory(editor.TargetCategory) as ModelCategoryEntry; if (affectedCategory == null) { continue; } affectedCategory.AddCategoryEditor(editor); _activeCategoryEditors[editorTypeToAdd] = editor.TargetCategory; } }
private void OnSelectionChanged(Selection selection) { // If selection changed, remove ConnectorEditor if existed. // Only if the selection changed is caused by adding ConnectorEditor when OnConnectorGotFocus. if (!this.updatingSelectedConnector && this.panel != null && this.panel.connectorEditor != null) { this.panel.RemoveConnectorEditor(); } }
void AddEntriesForArguments(Selection selection, ref int startIndex) { ModelProperty argumentsProperty = this.modelService.Root.Properties["Properties"]; if (argumentsProperty == null) { return; } ModelItemCollection arguments = argumentsProperty.Collection; if (arguments != null) { ModelItem selectedArgument = this.GetTopmostSelectedArgument(selection, arguments); foreach (ModelItem argument in arguments) { // Do this check to make sure we start from the topmost selected item. if (startIndex == StartIndexUnchangeMark && argument == selectedArgument && argument != lastNavigatedItem) { startIndex = index; } entries.Add(CreateSearchableEntry(SearchableEntryOption.Argument, argument, null, TypeNameHelper.GetDisplayName(argument.Properties["Type"].ComputedValue as Type, false), null)); entries.Add(CreateSearchableEntry(SearchableEntryOption.Argument, argument, null, argument.Properties[DesignTimeArgument.ArgumentNameProperty].ComputedValue.ToString(), null)); IList<string> argumentValues = GetSearchableStrings(argument.Properties[DesignTimeArgument.ArgumentDefaultValueProperty].ComputedValue); if (argumentValues.Count == 1) { AddEntriesForPropertyValue(argumentValues[0], argument, null, SearchableEntryOption.Argument, null); } if (this.editingContext.Services.GetService<DesignerConfigurationService>().AnnotationEnabled) { string annotationText = (string)argument.Properties[Annotation.AnnotationTextPropertyName].ComputedValue; if (!string.IsNullOrEmpty(annotationText)) { entries.Add(CreateSearchableEntry(SearchableEntryOption.Argument, argument, null, annotationText, null)); } } } } }
private void OnItemSelected(Selection item) { ModelItem mi = item.PrimarySelection; if (mi != null) { if (flowchartCategory != null && wd.ContextMenu != null) { if (mi.ItemType == typeof(Flowchart)) { //add the flowchart-only activities foreach (var tool in flowchartActivities) { if (!flowchartCategory.Tools.Contains(tool)) { flowchartCategory.Tools.Add(tool); } } if (!wd.ContextMenu.Items.Contains(miAddFlowDecision)) { wd.ContextMenu.Items.Add(miAddFlowDecision); } } else { //remove the flowchart-only activities foreach (var tool in flowchartActivities) { flowchartCategory.Tools.Remove(tool); } wd.ContextMenu.Items.Remove(miAddFlowDecision); } } } }
void OnConnectorGotFocus(object sender, RoutedEventArgs e) { Connector connector = e.Source as Connector; if (this.panel.connectorEditor == null || !connector.Equals(this.panel.connectorEditor.Connector)) { this.panel.RemoveConnectorEditor(); this.panel.connectorEditor = new ConnectorEditor(this.panel, connector); } if (this.panel.Children.Contains(connector)) { ModelItem connectorModelItem = StateContainerEditor.GetConnectorModelItem(connector); Selection newSelection = new Selection(); if (connectorModelItem != null && connectorModelItem.ItemType == typeof(Transition)) { newSelection = new Selection(connectorModelItem); } this.Context.Items.SetValue(newSelection); this.selectedConnector = connector; e.Handled = true; } }