/// <summary>
/// set the main element to navigate
/// </summary>
/// <param name="newElement">the element to navigate</param>
public void setElement(UML.Extended.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>
/// returns the tooltiptext for the given element
/// </summary>
/// <param name="element">the element</param>
/// <returns>the tooltip text</returns>
private string getToolTipText(UML.Extended.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);
}
/// <summary>
/// initialise based on named elements
/// </summary>
/// <param name="namedElements"></param>
private void InitNamedElements(List <UML.Extended.UMLItem> namedElements)
{
InitializeComponent();
this.Text = "Select Elements";
this.ItemHeader.Text = "Element";
this.openButton.Text = "Select";
//fill the diagramList
foreach (UML.Extended.UMLItem element in namedElements)
{
//add the element
ListViewItem item = new ListViewItem(element.name);
item.Tag = element;
string ownerName = string.Empty;
UML.Extended.UMLItem owner = element.owner as UML.Extended.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>
/// 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.Extended.UMLItem owner = ((UML.Extended.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 static Mapping getMapping(UML.Extended.UMLItem mappingItem, Element mappingTarget, MappingNode startNode, List <string> sourceMappingPath, List <string> targetMappingPath, MappingNode targetRootNode)
{
//do nothing if mappign target is null
if (mappingTarget == null)
{
return(null);
}
//check if the mappingPath of the source corresponds with the path of the node
var startNodeMappingPath = startNode.mappingPath;
//source is OK if mapping corresponds, or no mappingPath found and it is not virtual
var sourceOK = sourceMappingPath.SequenceEqual(startNodeMappingPath) || (!sourceMappingPath.Any() && !startNode.isVirtual);
// if no targetMapping found then we try to build a Mapping up to the target root node source element
if (!targetMappingPath.Any())
{
targetMappingPath = getMappingPath(mappingTarget, targetRootNode);
}
//target is OK if the first item of the targetMappignPath corresponds to the targetRootNode
var targetOK = targetMappingPath.FirstOrDefault() == targetRootNode.source?.uniqueID;
//if target or source is not OK then we return null
if (!sourceOK || !targetOK)
{
return(null);
}
//first create the targetMappingNode
var targetMappingNode = targetRootNode.createMappingNode(targetMappingPath);
//return the actual mapping
return(createMapping(mappingItem, startNode, targetMappingNode));
}
void QuickSearchComboBoxSelectionChangeCommitted(object sender, EventArgs e)
{
if (this.quickSearchBox.SelectedIndex >= 0)
{
UML.Extended.UMLItem quickSearchSelectedItem = this.quickSearchBox.SelectedItem as UML.Extended.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>
/// adds an elementNode to the tree
/// </summary>
/// <param name="element">the source element</param>
/// <param name="parentNode">the parentNode. If null is passed then the node will be added as root node</param>
/// <param name="nodeToReplace">the node to replace with new data</param>
private void addElementToTree(UML.Extended.UMLItem element, TreeNode parentNode, TreeNode nodeToReplace = null)
{
TreeNode elementNode = this.makeElementNode(element, parentNode, nodeToReplace);
this.enableDisableContexMenu(element);
// select the node
//NavigatorTree.SelectedNode = elementNode;
}
private void openProperties()
{
UML.Extended.UMLItem selectedElement = this.NavigatorTree.SelectedNode.Tag as UML.Extended.UMLItem;
if (selectedElement != null)
{
selectedElement.openProperties();
}
}
private void addToDiagram(UML.Extended.UMLItem selectedElement)
{
if (selectedElement != null)
{
selectedElement.addToCurrentDiagram();
selectedElement.selectInCurrentDiagram();
}
}
/// <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.Extended.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.Extended.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.Extended.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);
}
}
private void treeBackground_DoWork(object sender, DoWorkEventArgs e)
{
UML.Extended.UMLItem element = e.Argument as UML.Extended.UMLItem;
BackgroundWorker worker = sender as BackgroundWorker;
if (element != null)
{
//pass the new node to the runworkercompleted event
e.Result = this.makeElementNode(element, null);
}
}
/// <summary>
/// copies the GUID of the selected element to the clipboard
/// </summary>
void copyGUID()
{
if (this.NavigatorTree.SelectedNode != null)
{
UML.Extended.UMLItem selectedElement = this.NavigatorTree.SelectedNode.Tag as UML.Extended.UMLItem;
if (selectedElement.uniqueID != null)
{
Clipboard.SetText(selectedElement.uniqueID);
}
}
}
public override TSF.UmlToolingFramework.UML.Extended.UMLItem getItemFromRelativePath(List <string> relativePath)
{
UML.Extended.UMLItem item = null;
if (ElementWrapper.filterName(relativePath, this.name))
{
if (relativePath.Count == 1)
{
item = this;
}
}
return(this);
}
/// <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.Extended.UMLItem getItemFromRelativePath(List <string> relativePath)
{
UML.Extended.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>
/// 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.Extended.UMLItem> items, UML.Extended.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);
}
}
}
private void openSelectedElements()
{
foreach (ListViewItem item in this.navigateListView.SelectedItems)
{
UML.Extended.UMLItem element = item.Tag as UML.Extended.UMLItem;
if (null != element)
{
element.open();
}
//if the element is a diagram then also select the context
if (element is UML.Diagrams.Diagram)
{
((UML.Diagrams.Diagram)element).selectItem(context);
}
}
}
public static Mapping createMapping(UML.Extended.UMLItem mappingItem, MappingNode startNode, MappingNode targetNode)
{
var connector = mappingItem as ConnectorWrapper;
if (connector != null)
{
return(new ConnectorMapping(connector, startNode, targetNode));
}
var taggedValue = mappingItem as TaggedValue;
if (taggedValue != null)
{
return(new TaggedValueMapping(taggedValue, startNode, targetNode));
}
throw new ArgumentException("MappingItem should be Connector or TaggedValue");
}
public UML_SM.StateMachine getContainingStateMachine(UML.Extended.UMLItem umlItem)
{
if (umlItem != null)
{
if (umlItem.owner is UML_SM.StateMachine)
{
return(umlItem.owner as UML_SM.StateMachine);
}
else
{
return(getContainingStateMachine(umlItem.owner));
}
}
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.Extended.UMLItem> items, UML.Extended.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);
}
}
}
private UML.Extended.UMLItem getLinkedFeature(bool start)
{
string styleEx = this.wrappedConnector.StyleEx;
string key;
UML.Extended.UMLItem linkedFeature = null;
//determine start or end keyword
key = start ? "LFSP=" : "LFEP=";
int guidStart = styleEx.IndexOf(key) + key.Length;
if (guidStart >= key.Length)
{
string featureGUID = styleEx.Substring(guidStart, this.WrappedConnector.ConnectorGUID.Length);
linkedFeature = this.model.getItemFromGUID(featureGUID);
}
return(linkedFeature);
}
void NavigatorTreeNodeMouseClick(object sender, System.Windows.Forms.TreeNodeMouseClickEventArgs e)
{
//set the selected node also with right mouse click
if (e.Button == MouseButtons.Right)
{
this.NavigatorTree.SelectedNode = e.Node;
}
//show context menu
UML.Extended.UMLItem selectedElement = this.NavigatorTree.SelectedNode.Tag as UML.Extended.UMLItem;
if (e.Button == MouseButtons.Right &&
selectedElement != null)
{
//set enabled status
this.enableDisableContexMenu(selectedElement);
//then actually show the menu
this.navigatorContextMenu.Show(this.NavigatorTree, e.Location);
}
}
void NavigatorTreeNodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e)
{
UML.Extended.UMLItem selectedElement = e.Node.Tag as UML.Extended.UMLItem;
if (selectedElement != null)
{
if (this.settings.projectBrowserDefaultAction)
{
this.selectInProjectBrowser();
}
else
{
this.openProperties();
}
}
// if (NodeDoubleClick != null)
// {
// NodeDoubleClick(sender,e);
// }
}
private UML.Extended.UMLItem getLinkedFeature(bool isSource)
{
UML.Extended.UMLItem linkedFeature = null;
//determine start or end keyword
string key = isSource ? "LFSP" : "LFEP";
string featureGUID = KeyValuePairsHelper.getValueForKey(key, this.wrappedConnector.StyleEx);
if (!string.IsNullOrEmpty(featureGUID))
{
if (featureGUID.EndsWith("}R") ||
featureGUID.EndsWith("}L"))
{
//remove the last "R" or "L"
featureGUID = featureGUID.Substring(0, featureGUID.Length - 1);
}
//get the linked feature
linkedFeature = this.model.getItemFromGUID(featureGUID);
}
return(linkedFeature);
}
/// <summary>
/// returns the name to show as node name for this element
/// </summary>
/// <param name="element"></param>
public string getNodeName(UML.Extended.UMLItem element)
{
string name = string.Empty;
if (element != null)
{
name = this.getStereotypeString(element);
name += element.name;
}
if (element is UML.Classes.Kernel.Parameter)
{
UML.Classes.Kernel.Parameter parameter = (UML.Classes.Kernel.Parameter)element;
if (parameter.direction != UML.Classes.Kernel.ParameterDirectionKind._return)
{
name = parameter.name + " (" + this.getNodeName(parameter.operation) + ")";
}
}
else if (element is UML.Classes.Kernel.Feature)
{
UML.Classes.Kernel.Feature feature = (UML.Classes.Kernel.Feature)element;
UML.Classes.Kernel.Element owner = feature.owner;
if (owner != null)
{
name = owner.name;
}
else
{
name = "[owner missing]";
}
name += "." + this.getStereotypeString(element) + feature.name;
}
else if (element is UML.Profiles.TaggedValue)
{
UML.Profiles.TaggedValue taggedValue = (UML.Profiles.TaggedValue)element;
if (taggedValue.owner.name.Length > 0)
{
name = taggedValue.owner.name + "." + taggedValue.name;
}
}
return(name);
}
/// <summary>
/// removes the rootnode representig the given element
/// unless it this node is the first rootnode.
/// In that case it simply returns false
/// </summary>
/// <param name="sourceElement">the element</param>
private bool removeRootNode(UML.Extended.UMLItem sourceElement)
{
for (int i = this.NavigatorTree.Nodes.Count - 1; i >= 0; i--)
{
TreeNode node = this.NavigatorTree.Nodes[i];
if (node.Tag.Equals(sourceElement))
{
if (i > 0)
{
node.Remove();
return(true);
}
else
{
//if the node is the first root node then don't remove it but return false
return(false);
}
}
}
return(true);
}
/// <summary>
/// gets the item from the given relative path.
/// </summary>
/// <param name="relativePath">the "." separated path</param>
/// <returns>the item with the given path</returns>
public override UML.Extended.UMLItem getItemFromRelativePath(List <string> relativePath)
{
UML.Extended.UMLItem item = null;
List <string> filteredPath = new List <string>(relativePath);
if (filterName(filteredPath, this.name))
{
if (filteredPath.Count > 1)
{
//remove first item from filteredPath
filteredPath.RemoveAt(0);
//search deeper
foreach (UML.Classes.Kernel.Element element in this.ownedElements)
{
item = element.getItemFromRelativePath(filteredPath);
if (item != null)
{
return(item);
}
}
//still not found, now search diagram
foreach (UML.Diagrams.Diagram diagram in this.ownedDiagrams)
{
item = diagram.getItemFromRelativePath(filteredPath);
if (item != null)
{
return(item);
}
}
}
else
{
item = this;
}
}
return(item);
}
/// <summary>
/// removes the rootnode representig the given element
/// unless it this node is the first rootnode.
/// In that case it simply returns false
/// </summary>
/// <param name="sourceElement">the element</param>
private bool removeRootNode(UML.Extended.UMLItem sourceElement)
{
if (sourceElement != null)
{
for (int i = this.NavigatorTree.Nodes.Count - 1; i >= 0; i--)
{
TreeNode node = this.NavigatorTree.Nodes[i];
if (node != null)
{
if (sourceElement.Equals(node.Tag))
{
if (i > 0)
{
try
{
node.Remove();
}
catch (NullReferenceException)
{
//sometimes we get a nullpointer exception here for unknown reasons.
//just ignore it and return true
return(true);
}
return(true);
}
else
{
//if the node is the first root node then don't remove it but return false
return(false);
}
}
}
}
}
return(true);
}
private void selectInProjectBrowser()
{
UML.Extended.UMLItem selectedElement = this.NavigatorTree.SelectedNode.Tag as UML.Extended.UMLItem;
if (selectedElement != null)
{
//select the context before opening the element (and changing the selected node)
UML.Extended.UMLItem context = null;
if (selectedElement is UML.Diagrams.Diagram)
{
context = this.findContext(this.NavigatorTree.SelectedNode);
}
//actually open element
selectedElement.open();
if (selectedElement is UML.Classes.Kernel.Relationship)
{
this.setElement(selectedElement);
}
//select the context if the selected element was a diagram
if (context != null)
{
((UML.Diagrams.Diagram)selectedElement).selectItem(context);
}
}
}
/// <summary>
/// returns a string represenation of the stereotypes
/// </summary>
/// <param name="element">the element containing the stereotype</param>
/// <returns>a string containing the stereotype «stereo1,ste..»</returns>
private string getStereotypeString(UML.Extended.UMLItem element)
{
string stereotypeString = string.Empty;
int maxLength = 20;
if (element.stereotypes.Count > 0)
{
stereotypeString = "«";
foreach (UML.Profiles.Stereotype stereotype in element.stereotypes)
{
if (stereotypeString.Length > 1)
{
stereotypeString += ", ";
}
stereotypeString += stereotype.name;
if (stereotypeString.Length > maxLength)
{
stereotypeString = stereotypeString.Substring(0, maxLength - 2) + "..";
}
}
stereotypeString += "» ";
}
return(stereotypeString);
}
/// <summary>
/// enables or disabled the context menu items based on the type of the selected element
/// </summary>
/// <param name="selectedElement">the selected element</param>
private void enableDisableContexMenu(UML.Extended.UMLItem selectedElement)
{
//both options should be disabled for connectors,
if (selectedElement is UML.Classes.Kernel.Relationship)
{
this.selectBrowserMenuItem.Enabled = false;
this.projectBrowserButton.Enabled = false;
this.openPropertiesMenuItem.Enabled = false;
this.propertiesButton.Enabled = false;
}
//or for tagged values on connectors because we can't open their properties dialog anyway.
else if (selectedElement is UML.Profiles.TaggedValue &&
((UML.Profiles.TaggedValue)selectedElement).owner is UML.Classes.Kernel.Relationship)
{
this.selectBrowserMenuItem.Enabled = false;
this.projectBrowserButton.Enabled = false;
this.openPropertiesMenuItem.Enabled = false;
this.propertiesButton.Enabled = false;
}
else if (selectedElement == null)
{
this.selectBrowserMenuItem.Enabled = false;
this.openPropertiesMenuItem.Enabled = false;
this.addToDiagramButton.Enabled = false;
this.propertiesButton.Enabled = false;
this.projectBrowserButton.Enabled = false;
}
//standard should be enabled.
else
{
this.setContextMenuItemsEnabled(true);
this.propertiesButton.Enabled = true;
this.projectBrowserButton.Enabled = true;
this.addToDiagramButton.Enabled = true;
}
}
