public static void CreateAndTraceTopic()
{
IEARepository repository = EAMain.Repository;
if (repository.GetContextItemType() == EANativeType.Element)
{
var eaelement = repository.GetContextObject <IEAElement>();
if (eaelement != null && !EAMain.IsDecision(eaelement) && !EAMain.IsTopic(eaelement))
{
string nameSuggestion = string.Format(Messages.NameSuggestionTopic, eaelement.Name);
var createTopicView = new CreateTopicDialog(nameSuggestion);
if (createTopicView.ShowDialog() == DialogResult.OK)
{
IEAPackage dvPackage = createTopicView.GetDecisionViewPackage();
IEAElement topic = dvPackage.CreateElement(createTopicView.GetName(),
EAConstants.TopicStereoType,
EAConstants.ActivityMetaType);
topic.MetaType = EAConstants.TopicMetaType;
topic.AddTaggedValue(EATaggedValueKeys.DecisionStateModifiedDate,
DateTime.Now.ToString(CultureInfo.InvariantCulture));
eaelement.ConnectTo(topic, EAConstants.AbstractionMetaType, EAConstants.RelationTrace);
topic.Update();
dvPackage.RefreshElements();
repository.RefreshModelView(dvPackage.ID);
topic.ShowInProjectView();
}
}
}
}
/// <summary>
/// Implements IForcesModel.GetDecisions()
/// </summary>
/// <returns></returns>
public IEAElement[] GetDecisions()
{
IEARepository repository = EAMain.Repository;
IEAElement[] topicsElements = (from diagramObject in _diagram.GetElements()
select repository.GetElementByID(diagramObject.ElementID)
into element
where
EAMain.IsTopic(element) &&
!element.TaggedValueExists(EATaggedValueKeys.IsForceElement, _diagram.GUID)
select element).ToArray();
ITopic[] topics = (from element in topicsElements select Topic.Load(element)).ToArray();
IEnumerable <IEAElement> decisionsFromTopic =
(from ITopic topic in topics select topic.GetDecisionsForTopic()).SelectMany(x => x);
IEnumerable <IEAElement> decisionsDirectlyFromDiagram = (from diagramObject in _diagram.GetElements()
select
repository.GetElementByID(
diagramObject.ElementID)
into element
where
element.TaggedValueExists(
EATaggedValueKeys.IsDecisionElement,
_diagram.GUID)
select element);
return(decisionsFromTopic.Union(decisionsDirectlyFromDiagram).ToArray());
}
private void SaveStakeholders(IEAElement element)
{
IEARepository repository = EAMain.Repository;
IEnumerable <string> deleted =
element.GetConnectors().Where(connector => connector.IsAction() && connector.ClientId != element.ID)
.Select(c => c.GUID)
.Except(Stakeholders.Select(a => a.ConnectorGUID));
foreach (string connector in deleted)
{
element.RemoveConnector(repository.GetConnectorByGUID(connector));
}
foreach (IStakeholderAction connector in Stakeholders)
{
if ("".Equals(connector.ConnectorGUID) || null == connector.ConnectorGUID && !connector.DoDelete)
{
var client = repository.GetElementByGUID(GUID);
var supplier = repository.GetElementByGUID(connector.Stakeholder.GUID);
supplier.ConnectTo(client, EAConstants.ActionMetaType, connector.Action);
}
else if (connector.ConnectorGUID != null && connector.DoDelete)
{
var supplier = repository.GetElementByGUID(connector.Stakeholder.GUID);
var temp = EAMain.Repository.GetConnectorByGUID(connector.ConnectorGUID);
supplier.RemoveConnector(temp);
}
}
}
private void SaveRelations(IEAElement element)
{
IEARepository repository = EAMain.Repository;
IEnumerable <string> deleted =
element.FindConnectors(EAConstants.RelationMetaType, EAConstants.RelationDependsOn,
EAConstants.RelationExcludedBy, EAConstants.RelationCausedBy,
EAConstants.RelationReplaces)
.Select(c => c.GUID)
.Except(RelatedDecisions.Select(a => a.RelationGUID));
foreach (string connector in deleted)
{
element.RemoveConnector(repository.GetConnectorByGUID(connector));
}
foreach (IDecisionRelation connector in RelatedDecisions)
{
if ("".Equals(connector.RelationGUID) || null == connector.RelationGUID)
{
IEAElement client = repository.GetElementByGUID(connector.Decision.GUID);
IEAElement supplier = repository.GetElementByGUID(connector.RelatedDecision.GUID);
client.ConnectTo(supplier, EAConstants.RelationMetaType, connector.Type);
}
}
}
/// <summary>
/// Add a new force for each concern if the combination not exists already
/// </summary>
/// <param name="force"></param>
private void AddForceConcerns(IEAElement force)
{
IEARepository repository = EAFacade.EA.Repository;
string diagramGuid = _controller.Model.DiagramGUID;
IEADiagram diagram = repository.GetDiagramByGuid(diagramGuid);
//Add the force for each selected concern
foreach (var item in _lbConcern.SelectedItems)
{
var selectedItem = (KeyValuePair <string, string>)item;
IEAElement concern = repository.GetElementByGUID(selectedItem.Key);
diagram.AddElement(concern);
IEAConnector connector = force.ConnectTo(concern, EAConstants.ForcesConnectorType, EAConstants.RelationClassifiedBy);
if (!connector.TaggedValueExists(EATaggedValueKeys.IsForceConnector, diagramGuid))
{
// Add TaggedValue for new force and concern (having multiple TaggedValues of the same name/data is possible).
// The amount of TaggedValues with the same name and data is the amount of forces/concerns in the table.
force.AddTaggedValue(EATaggedValueKeys.IsForceElement, diagramGuid);
concern.AddTaggedValue(EATaggedValueKeys.IsConcernElement, diagramGuid);
// Add the diagramGuid as a TaggedValue (ConnectorTag) to the connector
connector.AddTaggedValue(EATaggedValueKeys.IsForceConnector, diagramGuid);
_closeWindow = true;
}
else //Force concern combination (connector) already exists
{
MessageBox.Show(string.Format(Messages.ForcesViewForceExists, force.Name, concern.Name),
"Force already exists", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
}
/// <summary>
/// Adds the forces and concerns that are selected in the TreeView and ListBox to the forces diagram
/// </summary>
public void AddForceToForcesDiagram()
{
TreeNode selectedNode = _tvForce.SelectedNode;
// Cannot add force if no force or concern is selected
if (selectedNode == null || _lbConcern.SelectedItems.Count < 1)
{
return;
}
IEARepository repository = EAFacade.EA.Repository;
string diagramGuid = _controller.Model.DiagramGUID;
IEADiagram diagram = repository.GetDiagramByGuid(diagramGuid);
IEAElement force = repository.GetElementByGUID(selectedNode.ImageKey);
// if (force.Type.Equals("Package")) return; // User cannot add packages as a force
diagram.AddElement(force); //Will not be added if already exists
AddForceConcerns(force);
//Window does not have to be closed and no update needed
if (!_closeWindow)
{
return;
}
_controller.SetDiagramModel(repository.GetDiagramByGuid(_controller.Model.DiagramGUID));
DialogResult = DialogResult.OK;
}
/// <summary>
/// Remove the decision from the ForcesView
/// </summary>
/// <param name="element"></param>
public void RemoveDecision(IEAElement element)
{
RemoveDecisionFromDiagram(element);
IEARepository repository = EAFacade.EA.Repository;
_controller.SetDiagramModel(repository.GetDiagramByGuid(_controller.Model.DiagramGUID));
}
public override string[] GetSubItems()
{
Clear();
IEARepository repository = EAMain.Repository;
if (repository.GetContextItemType() == EANativeType.Element)
{
var element = repository.GetContextObject <IEAElement>();
if (element != null)
{
var menuItemNames = new List <string>();
foreach (IEAElement tracedElement in element.GetTracedElements())
{
string name = tracedElement.GetProjectPath() + "/" + tracedElement.Name;
if (!"".Equals(tracedElement.Stereotype))
{
name += " �" + tracedElement.Stereotype + "�";
}
string uniqueName = GetUniqueName(name, menuItemNames);
MenuItem menuItem = CreateTraceMenuItem(uniqueName, tracedElement);
menuItemNames.Add(uniqueName);
Add(menuItem);
}
menuItemNames.Sort();
return(menuItemNames.ToArray());
}
}
return(new string[0]);
}
/// <summary>
/// Add deicsion to the diagram and TaggedValue to the decision if it doesn't exist already
/// </summary>
/// <param name="element"></param>
private void AddDecisionToDiagram(IEAElement element)
{
if (_listener != null)
{
_listener.OnDecisionSelected(element);
return;
}
IEARepository repository = EAMain.Repository;
string diagramGuid = _controller.Model.DiagramGUID;
IEADiagram diagram = repository.GetDiagramByGuid(diagramGuid);
diagram.AddElement(element);
// Only add the TaggedValue once, because the element is already a decision
if (!element.TaggedValueExists(EATaggedValueKeys.IsDecisionElement, diagramGuid))
{
element.AddTaggedValue(EATaggedValueKeys.IsDecisionElement, diagramGuid);
_closeWindow = true;
}
else
{
MessageBox.Show(string.Format(Messages.ForcesViewDecisionExists, element.Name),
Messages.ForcesViewDecisionExistsTitle,
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
public override bool ValidateElement(IEAElement element)
{
IEARepository repository = EAMain.Repository;
return(!(from IEAElement e in repository.GetAllElements()
where EAConstants.States.Contains(e.Stereotype)
where (!e.GUID.Equals(element.GUID))
where element.Name.Equals(e.Name)
select e).Any());
}
/// <summary>
/// Implements IForcesModel.GetForces()
/// </summary>
/// <returns></returns>
public IEnumerable <IEAElement> GetForces()
{
IEARepository repository = EAMain.Repository;
return((from diagramObject in _diagram.GetElements()
select repository.GetElementByID(diagramObject.ElementID)
into element
where element.TaggedValueExists(EATaggedValueKeys.IsForceElement, _diagram.GUID)
select element).ToArray());
}
/// <summary>
/// Removes all decisions from the table and diagram
/// </summary>
private void RemoveAllDecisionsFromDiagram()
{
IEARepository repository = EAFacade.EA.Repository;
string diagramGuid = _controller.Model.DiagramGUID;
IEADiagram diagram = repository.GetDiagramByGuid(diagramGuid);
for (int i = ForcesTableContext.DecisionColumnIndex; i < _forcesTable.Columns.Count; i++)
{
string decisionGuid = _forcesTable.Rows[_forcesTable.Rows.Count - 1].Cells[i].Value.ToString();
IEAElement decision = EAFacade.EA.Repository.GetElementByGUID(decisionGuid);
RemoveDecisionFromDiagram(decision);
}
_controller.SetDiagramModel(diagram);
}
public void Configure()
{
IEARepository repository = EAMain.Repository;
try
{
IEADiagram diagram = repository.GetDiagramByGuid(_model.DiagramGUID);
repository.OpenDiagram(diagram.ID);
}
catch (Exception)
{
MessageBox.Show(Messages.ForcesController_Configure_no_diagram);
}
}
/// <summary>
/// Removes a decision from the table and diagram
/// </summary>
/// <param name="decision">The element to be removed</param>
private void RemoveDecisionFromDiagram(IEAElement decision)
{
IEARepository repository = EAFacade.EA.Repository;
string diagramGuid = _controller.Model.DiagramGUID;
IEADiagram diagram = repository.GetDiagramByGuid(diagramGuid);
//Remove the TaggedValue of the decision
decision.RemoveTaggedValue(EATaggedValueKeys.IsDecisionElement, diagramGuid);
//Delete the element if it is not used in the diagram/table anymore
if (!ElementExistsInDiagram(decision, diagramGuid))
{
diagram.RemoveElement(decision);
}
}
private void RemoveAllForcesFromDiagram()
{
for (int i = _forcesTable.Rows.Count - 1; i >= 0; i--)
{
if (_forcesTable.Rows[i].Cells[ForcesTableContext.ForceGUIDColumnIndex].Value.Equals(ForcesTableContext.EmptyCellValue))
{
continue;
}
RemoveForceFromDiagram(i);
}
IEARepository repository = EAFacade.EA.Repository;
_controller.SetDiagramModel(repository.GetDiagramByGuid(_controller.Model.DiagramGUID));
}
public IEAElement GetChronologyTopicElement()
{
IEADiagram diagram = GetDecisionChronologicalDiagram();
IEARepository repository = EAMain.Repository;
IEAElement[] elements = (from diagramObject in diagram.GetElements()
select repository.GetElementByID(diagramObject.ElementID)
into elem
where EAConstants.TopicMetaType == elem.MetaType
select elem).ToArray();
Assert.IsNotNull(elements);
IEAElement element = elements.ElementAt(0);
Assert.IsNotNull(element);
return(element);
}
public void CloseDecisionDetailView(IDecision decision)
{
if (!_tabMap.ContainsKey(decision.GUID))
{
return;
}
string tabName = _tabMap[decision.GUID];
IEARepository repository = EAMain.Repository;
if (repository.IsTabOpen(tabName) > 0)
{
repository.RemoveTab(tabName);
_tabMap.Remove(decision.GUID);
}
}
private IEAElement GetStakeholderActorElement()
{
IEADiagram diagram = GetDecisionStakeholderDiagram();
IEARepository repository = EAMain.Repository;
IEAElement[] elements = (from diagramObject in diagram.GetElements()
select repository.GetElementByID(diagramObject.ElementID)
into elem
where EAConstants.StakeholderMetaType == elem.MetaType
select elem).ToArray();
Assert.IsNotNull(elements);
IEAElement element = elements.ElementAt(0);
Assert.IsNotNull(element);
return(element);
}
public IEADiagram[] GetDiagrams()
{
string sql =
@"Select t_diagramobjects.Diagram_ID FROM t_diagramobjects WHERE t_diagramobjects.Object_ID = " + ID +
";";
IEARepository repository = EARepository.Instance;
var document = new XmlDocument();
document.LoadXml(repository.Query(sql));
XmlNodeList diagramIDs = document.GetElementsByTagName(@"Diagram_ID");
return((from XmlNode diagramId in diagramIDs
select EAUtilities.ParseToInt32(diagramId.InnerText, -1)
into id
where id > 0
select repository.GetDiagramByID(id)).ToArray());
}
/// <summary>
/// Removes a force/concern from the table and diagram (if necessary). Diagram should be update afterwards
/// </summary>
/// <param name="rowIndex">The element to be removed</param>
private void RemoveForceFromDiagram(int rowIndex)
{
//Get the GUIDs from the diagram, force and concern
string diagramGuid = _controller.Model.DiagramGUID;
string forceGuid =
_forcesTable.Rows[rowIndex].Cells[ForcesTableContext.ForceGUIDColumnIndex].Value.ToString();
string concernGuid =
_forcesTable.Rows[rowIndex].Cells[ForcesTableContext.ConcernGUIDColumnIndex].Value.ToString();
//Get the diagram, force and concern objects
IEARepository repository = EAMain.Repository;
IEADiagram diagram = repository.GetDiagramByGuid(diagramGuid);
IEAElement force = repository.GetElementByGUID(forceGuid);
IEAElement concern = repository.GetElementByGUID(concernGuid);
foreach (
IEAConnector connector in
force.FindConnectors(concern, EAConstants.RelationClassifiedBy, EAConstants.ForcesConnectorType))
{
if (connector.TaggedValueExists(EATaggedValueKeys.IsForceConnector, diagramGuid))
{
connector.RemoveTaggedValue(EATaggedValueKeys.IsForceConnector, diagramGuid);
if (!connector.TaggedValueExists(EATaggedValueKeys.IsForceConnector))
{
force.RemoveConnector(connector);
concern.RemoveConnector(connector);
}
break;
}
}
//Remove the TaggedValue of the force and concern
force.RemoveTaggedValue(EATaggedValueKeys.IsForceElement, diagramGuid);
concern.RemoveTaggedValue(EATaggedValueKeys.IsConcernElement, diagramGuid);
//Delete the element if it is not used in the diagram/table anymore
if (!ElementExistsInDiagram(force, diagramGuid))
{
diagram.RemoveElement(force);
}
if (!ElementExistsInDiagram(concern, diagramGuid))
{
diagram.RemoveElement(concern);
}
}
/// <summary>
/// Populates the listbox with the concerns from the repository
/// </summary>
private void PopulateConcerns()
{
IEARepository repository = EAFacade.EA.Repository;
var concerns =
repository.GetAllElements()
.Where(element => element != null && element.IsConcern())
.ToDictionary(element => element.GUID, element => element.Name + " (" + element.ParentPackage.Name + ")");
if (concerns.Count <= 0) //No concerns found
{
_btnAddForce.Enabled = false;
return;
}
_lbConcern.DataSource = new BindingSource(concerns, null);
_lbConcern.DisplayMember = "Value";
_lbConcern.ValueMember = "Key";
}
/// <summary>
/// Colours the header of a row according to the state of the element in the row if it is a decision
/// </summary>
/// <param name="i"></param>
private void ColourForceHeader(int i)
{
DataGridViewRow row = _forcesTable.Rows[i];
string guid = row.Cells[ForcesTableContext.ForceGUIDColumnIndex].Value.ToString();
if (guid.Equals(ForcesTableContext.EmptyCellValue))
{
return;
}
IEARepository repository = EAFacade.EA.Repository;
IEAElement element = repository.GetElementByGUID(guid);
if (element == null || row.HeaderCell == null || !element.IsDecision())
{
return;
}
row.HeaderCell.Style.BackColor = RetrieveColorByState(element.Stereotype);
}
/// <summary>
/// Colours the header of a decision column according to the state of the decision
/// </summary>
/// <param name="i"></param>
private void ColourDecisionHeader(int i)
{
if (i < ForcesTableContext.DecisionColumnIndex)
{
return;
}
string decisionGuid = _forcesTable.Rows[_forcesTable.Rows.Count - 1].Cells[i].Value.ToString();
DataGridViewColumn column = _forcesTable.Columns[i];
if (column.HeaderCell == null)
{
return;
}
IEARepository repository = EAFacade.EA.Repository;
column.HeaderCell.Style.BackColor =
RetrieveColorByState(repository.GetElementByGUID(decisionGuid).Stereotype);
}
/// <summary>
/// Add all elements that do not contain children
/// </summary>
/// <param name="node"></param>
private void AddFromNode(TreeNode node)
{
if (node.Nodes.Count > 0)
{
foreach (TreeNode n in node.Nodes)
{
AddFromNode(n);
}
}
else
{
IEARepository repository = EAFacade.EA.Repository;
IEAElement element = repository.GetElementByGUID(node.ImageKey);
if (element.IsDecision())
{
AddDecisionToDiagram(element);
}
}
}
public void DiscardChanges()
{
if ("".Equals(TaggedValueGUID))
{
//no changes have been saved to the repository, its a fresh history entry
}
else
{
IEARepository repository = EAMain.Repository;
//should not happen, need to know where the History Entry should be loaded from.
if (null == Decision)
{
throw new Exception();
}
IEAElement element = repository.GetElementByGUID(Decision.GUID);
IEATaggedValue taggedValue = element.GetTaggedValueByGUID(TaggedValueGUID);
Deserialize(taggedValue.Value);
}
}
/// <summary>
/// Defines MenuItems for a right click on a column's header
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void _forcesTable_ColumnHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e)
{
//Only for decisions
if (e.ColumnIndex < ForcesTableContext.DecisionColumnIndex)
{
return;
}
string elementGuid =
_forcesTable.Rows[_forcesTable.Rows.Count - 1].Cells[e.ColumnIndex].Value.ToString();
IEAElement decision = EAFacade.EA.Repository.GetElementByGUID(elementGuid);
if (e.Button == MouseButtons.Right)
{
var menu = new ContextMenu();
// Menuitem for opening a decision in its diagram
menu.MenuItems.Add(Messages.ForcesViewOpenDecisionInDiagrams,
(o, args) => OpenDecisionInDiagrams(decision));
// Menuitem for opening the detailviewpoint of a decision
menu.MenuItems.Add(Messages.ForcesViewOpenDecisionInDetailView,
(sender1, e1) => OpenInDetailView(new Decision(decision)));
// Menuitem for a separator
menu.MenuItems.Add("-");
// Menuitem for removing a decision
menu.MenuItems.Add(Messages.ForcesViewRemoveDecision, (sender1, e1) =>
{
RemoveDecisionFromDiagram(decision);
IEARepository repository = EAFacade.EA.Repository;
_controller.SetDiagramModel(repository.GetDiagramByGuid(_controller.Model.DiagramGUID));
});
// Meneitem for removing all decision
menu.MenuItems.Add(Messages.ForcesViewRemoveAllDecisions,
(sender1, e1) => RemoveAllDecisionsFromDiagram());
Point relativeMousePosition = PointToClient(Cursor.Position);
menu.Show(this, relativeMousePosition);
}
}
public override bool OnPreDeleteDiagram(IEAVolatileDiagram volatileDiagram)
{
IEARepository repository = EAMain.Repository;
IEADiagram diagram = repository.GetDiagramByID(volatileDiagram.DiagramID);
if (!diagram.IsForcesView())
{
return(true);
}
if (_controllers.ContainsKey(diagram.GUID))
{
if (repository.IsTabOpen(ForcesModel.CreateForcesTabName(diagram.Name)) > 0)
{
repository.RemoveTab(ForcesModel.CreateForcesTabName(diagram.Name));
}
_controllers.Remove(diagram.GUID);
}
return(true);
}
public override bool OnContextItemDoubleClicked(string guid, EANativeType type)
{
if (EANativeType.Diagram != type)
{
return(false);
}
IEARepository repository = EAMain.Repository;
IEADiagram diagram = repository.GetDiagramByGuid(guid);
if (!diagram.IsForcesView())
{
return(false);
}
var forcesDiagramModel = new ForcesModel(diagram);
if (repository.IsTabOpen(forcesDiagramModel.Name) > 0)
{
// naming is not optimal as tabs can have same names... need to find a solution that we can
// distinguish tabs more optimal
repository.ActivateTab(forcesDiagramModel.Name);
return(true);
}
IForcesView forcesView = repository.AddTab(forcesDiagramModel.Name,
"DecisionViewpoints.Forces");
IForcesController forcesController;
if (!_controllers.ContainsKey(forcesDiagramModel.DiagramGUID))
{
forcesController = new ForcesController(forcesView, forcesDiagramModel);
_controllers.Add(forcesDiagramModel.DiagramGUID, forcesController);
}
else
{
forcesController = _controllers[forcesDiagramModel.DiagramGUID];
forcesController.View = forcesView;
forcesController.Model = forcesDiagramModel;
}
forcesController.Update();
return(true);
}
public override bool OnPreDeleteElement(IEAElement element)
{
if (!element.TaggedValueExists(EATaggedValueKeys.IsDecisionElement) &&
!element.TaggedValueExists(EATaggedValueKeys.IsConcernElement) &&
!element.TaggedValueExists(EATaggedValueKeys.IsForceElement))
{
return(true);
}
var diagrams = new List <IEADiagram>();
diagrams.AddRange(element.GetDiagrams().Where(eaDiagram => eaDiagram.IsForcesView()));
if (diagrams.Count == 0)
{
return(true);
}
IEARepository repository = EAMain.Repository;
foreach (
IForcesController forcesController in
from diagram in diagrams
where repository.IsTabOpen(ForcesModel.CreateForcesTabName(diagram.Name)) > 0
select _controllers[diagram.GUID])
{
string diagramGuid = forcesController.Model.DiagramGUID;
// we cannot update the view with a new diagram model here, as the diagram changes are applied
// after the deletion event is successful
if (element.TaggedValueExists(EATaggedValueKeys.IsDecisionElement, diagramGuid))
{
forcesController.RemoveDecision(element);
}
if (element.TaggedValueExists(EATaggedValueKeys.IsConcernElement, diagramGuid))
{
forcesController.RemoveConcern(element);
}
if (element.TaggedValueExists(EATaggedValueKeys.IsForceElement, diagramGuid))
{
forcesController.RemoveForce(element);
}
}
return(true);
}
/// <summary>
/// Defines MenuItems for right clicking on a row's header
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void _forcesTable_RowHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
var menu = new ContextMenu();
// Menuitem for removing a force
menu.MenuItems.Add(Messages.ForcesViewRemoveForce, (sender1, e1) =>
{
RemoveForceFromDiagram(e.RowIndex);
IEARepository repository = EAFacade.EA.Repository;
_controller.SetDiagramModel(repository.GetDiagramByGuid(_controller.Model.DiagramGUID));
});
// Menuitem for removing all forces
menu.MenuItems.Add(Messages.ForcesViewRemoveAllForces, (sender1, e1) => RemoveAllForcesFromDiagram());
Point relativeMousePosition = PointToClient(Cursor.Position);
menu.Show(this, relativeMousePosition);
}
}
