/// <summary> /// returns the tooltiptext for the given element /// </summary> /// <param name="element">the element</param> /// <returns>the tooltip text</returns> private string getToolTipText(UML.UMLItem element) { //Getting some strange RPC_E_WRONG_THREAD error while getting the owner ElementWrapper. //Disablign the tooltiptext for now to avoid the error //Enabled again after installing all addins together return(element.fqn); }
void QuickSearchComboBoxSelectionChangeCommitted(object sender, EventArgs e) { if (this.quickSearchBox.SelectedIndex >= 0) { UML.UMLItem quickSearchSelectedItem = this.quickSearchBox.SelectedItem as UML.UMLItem; { if (quickSearchSelectedItem != null) { // if this element is to be selected in the project browser is will // automatically be set as the main element if (settings.quickSearchSelectProjectBrowser) { quickSearchSelectedItem.select(); } else { this.setElement(quickSearchSelectedItem); } // also add to diagram if needed if (settings.quickSearchAddToDiagram) { this.addToDiagram(quickSearchSelectedItem); } } } } }
/// <summary> /// event launched just before a node is expanded /// </summary> /// <param name="sender">sender</param> /// <param name="e">arguments</param> void NavigatorTreeBeforeExpand(object sender, TreeViewCancelEventArgs e) { foreach (TreeNode subNode in e.Node.Nodes) { if (this.isOwnerNode(subNode)) { UML.UMLItem owner = ((UML.UMLItem)e.Node.Tag).owner; if (owner != null) { this.addElementToTree(owner, e.Node, subNode); } } else if (this.isTypeNode(subNode)) { UML.Classes.Kernel.Property attribute = e.Node.Tag as UML.Classes.Kernel.Property; if (attribute != null && attribute.type != null) { this.addElementToTree(attribute.type, e.Node, subNode); } } } if (BeforeExpand != null) { BeforeExpand(sender, e); } }
private void selectFQN(string fqn) { UML.UMLItem item = null; item = this.model.getItemFromFQN(fqn); if (item != null) { item.select(); } else { string messageText; if (fqn.Length > 255) { messageText = fqn.Substring(0, 255); } else { messageText = fqn; } FQNInputForm fqnForm = new FQNInputForm("Could not find item with the string:" + Environment.NewLine + messageText, "Fill in the Fully Qualified Name", "FQN:"); if (fqnForm.ShowDialog() == DialogResult.OK && fqnForm.fqn.Length > 0) { this.selectFQN(fqnForm.fqn); } } }
/// <summary> /// set the main element to navigate /// </summary> /// <param name="newElement">the element to navigate</param> public void setElement(UML.UMLItem newElement) { if (!treeBackgroundWorker.IsBusy) { this.startThread(newElement); } else { //backgroundworker is still busy so we add the element to the workqueue instead TimeSpan runtime = (DateTime.Now - lastStartTime); if (runtime.TotalSeconds < 5) { this.workQueue.Insert(0, newElement); //make sure the queue doesn't get too large. if (this.workQueue.Count > 10) { this.workQueue.RemoveAt(this.workQueue.Count - 1); } } else { //for some reason sometimes the backgroundworker gets stuck. //This always seems to happen shortly after a right click (and thus a call to EA_GetMenuItems) when a lot of elements have been clicked in a short period of time. //when its stuck it is calling a method on the EA API that never returns (someting like EA.Element.Name) //I've tried everything to abort or cancel the thread, but nothing seems to work. //So the only solution that does seem to work is spawn a new thread and start using that one. //In the long rung this will ofcourse cause the a memory/thread leak, but from personal experience, this only seems to happen a few times a day, and only when dealing with a large (and thus slow) model. //current backgoundworker is stuck. Start a new one. this.resetTreeBackgroundWorker(); //process the element this.startThread(newElement); } } }
/// <summary> /// initialise based on named elements /// </summary> /// <param name="namedElements"></param> private void InitNamedElements(List <UML.UMLItem> namedElements) { InitializeComponent(); this.Text = "Select Elements"; this.ItemHeader.Text = "Element"; this.openButton.Text = "Select"; //fill the diagramList foreach (UML.UMLItem element in namedElements) { //add the element ListViewItem item = new ListViewItem(element.name); item.Tag = element; string ownerName = string.Empty; UML.UMLItem owner = element.owner as UML.UMLItem; if (null != owner) { ownerName = owner.name; } item.SubItems.Add(ownerName); if (ownerName == string.Empty) { item.ForeColor = SystemColors.GrayText; } item.UseItemStyleForSubItems = true; this.navigateListView.Items.Add(item); } }
/// <summary> /// returns all diagrams that show this item /// </summary> /// <param name="parentElement"></param> /// <returns></returns> private List <UML.UMLItem> getDepentDiagrams(UML.UMLItem parentElement) { var elementsToNavigate = new List <UML.UMLItem>(); elementsToNavigate.AddRange(parentElement.getDependentDiagrams()); return(elementsToNavigate); }
private bool SynchronizeUmlItemTags(UML.UMLItem umlItem, ref string TagName, ref string TagValue, ref string TagNotes) { inSyncUmlItem = true; try { if (umlItem is UML.Classes.Kernel.Class) { UML.Classes.Kernel.Class classItem = umlItem as UML.Classes.Kernel.Class; } else if (umlItem is UML.Classes.Interfaces.Interface) { return(SynchronizeUmlItemTags(umlItem as UML.Classes.Interfaces.Interface, ref TagName, ref TagValue, ref TagNotes)); } else if (umlItem is UML.Classes.Kernel.Operation) { return(SynchronizeUmlItemTags(umlItem as UML.Classes.Kernel.Operation, ref TagName, ref TagValue, ref TagNotes)); } } catch (Exception ex) { inSyncUmlItem = false; throw ex; } finally { inSyncUmlItem = false; } return(false); }
/// <summary> /// copies the GUID of the selected element to the clipboard /// </summary> void copyGUID() { UML.UMLItem selectedElement = this.NavigatorTree.SelectedNode.Tag as UML.UMLItem; if (selectedElement.uniqueID != null) { Clipboard.SetText(selectedElement.uniqueID); } }
private void addToDiagram(UML.UMLItem selectedElement) { if (selectedElement != null) { selectedElement.addToCurrentDiagram(); selectedElement.selectInCurrentDiagram(); } }
private void openProperties() { UML.UMLItem selectedElement = this.NavigatorTree.SelectedNode.Tag as UML.UMLItem; if (selectedElement != null) { selectedElement.openProperties(); } }
/// <summary> /// When a diagram is doubleclicked we need to set it a the main element /// </summary> /// <param name="sender">sender</param> /// <param name="e">parameters</param> void NavigatorTreeNodeDoubleClick(object sender, TreeNodeMouseClickEventArgs e) { UML.UMLItem selectedElement = e.Node.Tag as UML.UMLItem; if (selectedElement is UML.Diagrams.Diagram) { this.navigatorControl.setElement(selectedElement); } }
/// <summary> /// Opens the attributes of that use the selected element as type /// </summary> private List <UML.UMLItem> getAttributes(UML.UMLItem parentElement) { List <UML.UMLItem> elementsToNavigate = new List <UML.UMLItem>(); UML.Classes.Kernel.Type selectedType = parentElement as UML.Classes.Kernel.Type; // get the attributes that use the selected Type as type elementsToNavigate.AddRange(selectedType.getDependentTypedElements <UML.Classes.Kernel.Property>()); return(elementsToNavigate); }
/// <summary> /// Opens the parameters that use the selected element as type /// </summary> private List <UML.UMLItem> getParameters(UML.UMLItem parentElement) { List <UML.UMLItem> elementsToNavigate = new List <UML.UMLItem>(); UML.Classes.Kernel.Type selectedType = parentElement as UML.Classes.Kernel.Type; // get the parameters that use the selected classifier as type elementsToNavigate.AddRange(selectedType.getDependentTypedElements <UML.Classes.Kernel.Parameter>()); return(elementsToNavigate); }
/// <summary> /// catches the event that the backgroundworker has finished. /// in that case we should select the returned node /// </summary> /// <param name="sender">the backgroundworder</param> /// <param name="e">the parameters</param> private void treeBackgroundRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { if ((e.Cancelled == true)) { //nothing? } else if (!(e.Error == null)) { //nothing? } else { //do the visual work for the new treenode TreeNode elementNode = (TreeNode)e.Result; //remove duplicate if (this.removeRootNode((UML.UMLItem)elementNode.Tag)) { try { //no parentNode, add as new root node before any others //inserting a node sometimes causes an InvalidOperationException because its being called in the wrong thread //doing it using the invoke should help. invoker = new MethodDelegate(ThreadSaveInsertNode); this.NavigatorTree.Invoke(invoker, elementNode); //this.NavigatorTree.Nodes.Insert(0,elementNode); //remove the excess nodes this.removeExcessNodes(); //expand the node elementNode.Expand(); } catch (Exception exception) { MessageBox.Show(exception.Message + Environment.NewLine + exception.StackTrace, "An error occured" , MessageBoxButtons.OK, MessageBoxIcon.Error); } } else { //first node is already the one we need elementNode = this.NavigatorTree.Nodes[0]; } this.NavigatorTree.SelectedNode = (TreeNode)e.Result; //check if there's still something int the queue if (this.workQueue.Count > 0) { //get the last element in the queue UML.UMLItem nextElement = this.workQueue[this.workQueue.Count - 1]; //remove it this.workQueue.RemoveAt(this.workQueue.Count - 1); //process it this.setElement(nextElement); } } }
private void startThread(UML.UMLItem newElement) { if (!this.treeBackgroundWorker.IsBusy) { this.working = true; //start new tread here to create new element this.lastStartTime = DateTime.Now; this.treeBackgroundWorker.RunWorkerAsync(newElement); } }
internal static string getOwnerMenuName(UML.UMLItem element) { string ownerMenuname = ownerMenuPrefix; if (element.owner != null) { ownerMenuname += element.owner.name; } return(ownerMenuname); }
/// <summary> /// Opens the type of the attribute /// </summary> private List <UML.UMLItem> getClassifier(UML.UMLItem parentElement) { List <UML.UMLItem> elementsToNavigate = new List <UML.UMLItem>(); UML.Classes.Kernel.Property selectedAttribute = parentElement as UML.Classes.Kernel.Property; if (null != selectedAttribute) { elementsToNavigate.Add(selectedAttribute.type); } return(elementsToNavigate); }
/// <summary> /// Execute the actual functions /// </summary> /// <param name="Repository">the repository</param> /// <param name="Location">menu location</param> /// <param name="MenuName">menu name</param> /// <param name="ItemName">option clicked</param> public override void EA_MenuClick(global::EA.Repository Repository, String Location, String MenuName, String ItemName) { switch (ItemName) { case menuFQN: this.selectFQN(); break; case menuGUID: this.selectGUID(); break; case menuAbout: new AboutWindow().ShowDialog(); break; case menuSettings: new NavigatorSettingsForm(this.settings).ShowDialog(); //we need to set the toolbar in case that setting was changed if (this.navigatorControl != null) { this.navigatorControl.toolbarVisible = this.settings.toolbarVisible; } break; case menuOpenInNavigator: this.navigate(); break; default: UML.UMLItem selectedItem = this.model.selectedItem; if (selectedItem != null) { List <UML.UMLItem> elementsToNavigate = this.getElementsToNavigate(ItemName, selectedItem); if (elementsToNavigate.Count == 1) { elementsToNavigate[0].open(); } else if (elementsToNavigate.Count > 1) { NavigatorList dialog = new NavigatorList(elementsToNavigate, selectedItem); dialog.Show(); } else { string message = selectedItem.name + " does not have any " + ItemName.Replace("&", string.Empty); MessageBox.Show(message, "Nothing to navigate", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } break; } }
private void treeBackground_DoWork(object sender, DoWorkEventArgs e) { UML.UMLItem element = e.Argument as UML.UMLItem; BackgroundWorker worker = sender as BackgroundWorker; if (element != null) { //pass the new node to the runworkercompleted event e.Result = this.makeElementNode(element, null); } }
private List <UML.UMLItem> getCompositeElements(UML.UMLItem parentElement) { List <UML.UMLItem> elementsToNavigate = new List <UML.UMLItem>(); UML.Diagrams.Diagram compositeDiagram = parentElement as UML.Diagrams.Diagram; if (compositeDiagram != null) { elementsToNavigate = compositeDiagram.compositeElements.Cast <UML.UMLItem>().ToList(); } return(elementsToNavigate); }
/// <summary> /// opens the CallOperationActions that call te selected operation /// </summary> private List <UML.UMLItem> getActions(UML.UMLItem parentElement) { List <UML.UMLItem> elementsToNavigate = new List <UML.UMLItem>(); UML.Classes.Kernel.Operation selectedOperation = this.getSelectedOperation(parentElement); if (selectedOperation != null) { elementsToNavigate.AddRange(selectedOperation.getDependentCallOperationActions()); } return(elementsToNavigate); }
/// <summary> /// returns the owner of the parentElement /// </summary> /// <param name="parentElement">the selected element</param> /// <returns>the owner of the element</returns> private List <UML.UMLItem> getOwner(UML.UMLItem parentElement) { List <UML.UMLItem> elementsToNavigate = new List <UML.UMLItem>(); UML.UMLItem owner = parentElement.owner; if (owner != null) { elementsToNavigate.Add(owner); } return(elementsToNavigate); }
/// <summary> /// get all using diagrams for the given element /// currently only used for operations /// </summary> /// <param name="parentElement">the element</param> /// <returns>the diagrams using the given element</returns> private List <UML.UMLItem> getDiagrams(UML.UMLItem parentElement) { List <UML.UMLItem> elementsToNavigate = new List <UML.UMLItem>(); UML.Classes.Kernel.Operation selectedOperation = this.getSelectedOperation(parentElement); if (selectedOperation != null) { elementsToNavigate.AddRange(selectedOperation.getUsingDiagrams <UML.Diagrams.Diagram>()); } return(elementsToNavigate); }
internal static string getTypeMenuName(UML.UMLItem element) { string typeMenuname = typeMenuPrefix; UML.Classes.Kernel.Property attribute = element as UML.Classes.Kernel.Property; if (attribute != null && attribute.type != null) { typeMenuname += attribute.type.name; } return(typeMenuname); }
public override TSF.UmlToolingFramework.UML.UMLItem getItemFromRelativePath(List <string> relativePath) { UML.UMLItem item = null; if (ElementWrapper.filterName(relativePath, this.name)) { if (relativePath.Count == 1) { item = this; } } return(this); }
private void navigate(UML.UMLItem item) { if (fullyLoaded) { if (this.navigatorControl != null && this.model != null) { if (item != null) { this.navigatorControl.setElement(item); } } } }
/// <summary> /// gets the elements of a package right before expanding /// </summary> /// <param name="sender">sender</param> /// <param name="e">parameters</param> void NavigatorTreeBeforeExpand(object sender, TreeViewCancelEventArgs e) { if (e.Node.Tag == null) { UML.UMLItem parentElement = e.Node.Parent.Tag as UML.UMLItem; if (parentElement != null) { string option = "&" + e.Node.Text; List <UML.UMLItem> subElements = this.getElementsToNavigate(option, parentElement); this.navigatorControl.setSubNodes(e.Node, subElements); } } }
/// <summary> /// searches downward for the item with the given relative path /// This relative path includes the own name /// </summary> /// <param name="relativePath">list of names inlcuding the own name</param> /// <returns>the item matching the path</returns> public TSF.UmlToolingFramework.UML.UMLItem getItemFromRelativePath(List <string> relativePath) { UML.UMLItem item = null; List <string> filteredPath = new List <string>(relativePath); if (ElementWrapper.filterName(filteredPath, this.name)) { if (filteredPath.Count == 1) { item = this; } } return(item); }
/// <summary> /// The EA_GetMenuItems event enables the Add-In to provide the Enterprise Architect user interface with additional Add-In menu options in various context and main menus. When a user selects an Add-In menu option, an event is raised and passed back to the Add-In that originally defined that menu option. /// This event is raised just before Enterprise Architect has to show particular menu options to the user, and its use is described in the Define Menu Items topic. /// Also look at: /// - EA_MenuClick /// - EA_GetMenuState. /// </summary> /// <param name="Repository">An EA.Repository object representing the currently open Enterprise Architect model. /// Poll its members to retrieve model data and user interface status information.</param> /// <param name="MenuLocation">String representing the part of the user interface that brought up the menu. /// Can be TreeView, MainMenu or Diagram.</param> /// <param name="MenuName">The name of the parent menu for which sub-items are to be defined. In the case of the top-level menu it is an empty string.</param> /// <returns>One of the following types: /// - A string indicating the label for a single menu option. /// - An array of strings indicating a multiple menu options. /// - Empty (Visual Basic/VB.NET) or null (C#) to indicate that no menu should be displayed. /// In the case of the top-level menu it should be a single string or an array containing only one item, or Empty/null.</returns> public override object EA_GetMenuItems(EA.Repository Repository, string MenuLocation, string MenuName) { //check setting for context menus if (this.settings.contextmenuVisible || MenuLocation == "MainMenu" || !this.settings.trackSelectedElement) { switch (MenuName) { case "": //return top level menu option return(this.menuHeader); case menuName: List <string> menuOptionsList = new List <string>(); if (!this.settings.trackSelectedElement) { menuOptionsList.Add(menuOpenInNavigator); } //Context menu if (MenuLocation != "MainMenu" && this.settings.contextmenuVisible) { // get the selected element from the model UML.UMLItem selectedElement = this.model.selectedItem; menuOptionsList.AddRange(getMenuOptions(selectedElement)); } // Main menu else if (MenuLocation == "MainMenu") { // To FQN menuOptionsList.Add(menuFQN); // To GUID menuOptionsList.Add(menuGUID); // setting menuOptionsList.Add(menuSettings); //menu about menuOptionsList.Add(menuAbout); } // return submenu options return(menuOptionsList.ToArray()); default: return(string.Empty); } } //don't show menu; else { return(null); } }
/// <summary> /// createas a new navigatorList based on the given list of UML Items /// </summary> /// <param name="items">the items to show</param> public NavigatorList(List<UML.UMLItem> items, UML.UMLItem context):base() { if (items.Count > 0) { this.context = context; if (items[0] is UML.Diagrams.Diagram) { this.InitDiagrams(items.Cast<UML.Diagrams.Diagram>().ToList()); } else { this.InitNamedElements(items); } } }