/********************************************************************************************
** Invoke View Change methods
********************************************************************************************/
internal static void InvokeViewChange(string elementGUID, EANativeType eANativeType)
{
if (eANativeType == EANativeType.Diagram)
{
IEAElement element = EAMain.Repository.GetElementByGUID(elementGUID);
IEADiagram[] diagrams = element.GetDiagrams();
if (diagrams.Length == 1)
{
IEADiagram diagram = diagrams[0];
diagram.OpenAndSelectElement(element);
}
else if (diagrams.Length >= 2)
{
var selectForm = new SelectDiagramDialog(diagrams);
if (selectForm.ShowDialog() == DialogResult.OK)
{
IEADiagram diagram = selectForm.GetSelectedDiagram();
diagram.OpenAndSelectElement(element);
}
}
}
else if (eANativeType == EANativeType.Element)
{
Instance.OnContextItemDoubleClicked(elementGUID, eANativeType);
}
}
/// <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);
}
}
}
public ChronologicalViewpointGenerator(List <IEAElement> decisions, IEAPackage historyPackage,
IEADiagram chronologicalViewpoint)
{
_chronologicalViewpoint = chronologicalViewpoint;
_historyPackage = historyPackage;
_decisions = decisions;
}
/// <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;
}
public static void Generate()
{
if (EANativeType.Package != EAMain.Repository.GetContextItemType())
{
return;
}
var eapackage = EAMain.Repository.GetContextObject <IEAPackage>();
if (null == eapackage)
{
return;
}
var view = new GenerateChronologyViewDialog();
if (DialogResult.OK == view.ShowDialog())
{
IEADiagram chronologicalView = CreateChronologyDiagram(eapackage, view.ViewName);
IEAPackage historyPackage =
eapackage.GetSubpackageByName("History data for " + chronologicalView.Name);
if (historyPackage != null)
{
historyPackage.ParentPackage.DeletePackage(historyPackage);
}
historyPackage = eapackage.CreatePackage("History data for " + chronologicalView.Name,
EAConstants.ChronologicalStereoType);
var generator = new ChronologicalViewpointGenerator(view.Decisions, historyPackage, chronologicalView);
generator.GenerateViewpoint();
}
}
/// <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);
}
}
private static MenuItem CreateTraceMenuItem(string uniqueName, IEAElement tracedElement)
{
var menuItem = new MenuItem(uniqueName);
menuItem.Value = tracedElement;
menuItem.ClickDelegate = delegate
{
IEADiagram[] diagrams = tracedElement.GetDiagrams();
if (diagrams.Count() == 1)
{
IEADiagram diagram = diagrams[0];
diagram.OpenAndSelectElement(tracedElement);
}
else if (diagrams.Count() >= 2)
{
var selectForm = new SelectDiagramDialog(diagrams);
if (selectForm.ShowDialog() == DialogResult.OK)
{
IEADiagram diagram = selectForm.GetSelectedDiagram();
diagram.OpenAndSelectElement(tracedElement);
}
}
tracedElement.ShowInProjectView();
};
return(menuItem);
}
private void GenerateDiagram(IEADiagram chronologicalViewpoint, IEnumerable <IEAElement> elements)
{
foreach (IEAElement element in elements)
{
chronologicalViewpoint.AddElement(element);
}
}
public void EA_WrapVolatileElement_diagramTest()
{
IEADiagram diagram = _e.GetDecisionForcesDiagram();
EventProperties properties = EAEventPropertiesHelper.GetInstance("", "", "", 0, 0, diagram.ID, 0, 0);
IEAVolatileElement e = EAMain.WrapVolatileElement(properties);
Assert.IsTrue(diagram.ID == e.Diagram.ID);
}
public void InsertDiagramImage(IEADiagram diagram)
{
ISlide imageSlide = new ImageSlide(_doc, _imageSlideTemplate, diagram);
imageSlide.Create();
imageSlide.FillContent();
imageSlide.Save();
imageSlide.Add();
}
public override void EA_OnPostOpenDiagram(Repository repository, int diagramId)
{
EAMain.UpdateRepository(repository);
IEADiagram diagram = EAMain.Repository.GetDiagramByID(diagramId);
foreach (IRepositoryListener l in _listeners)
{
l.OnPostOpenDiagram(diagram);
}
}
public IEADiagram GetDiagram()
{
IEADiagram diagram = null;
if (_native.DiagramID > 0)
{
diagram = EARepository.Instance.GetDiagramByID(_native.DiagramID);
}
return(diagram);
}
public override void OnPostOpenDiagram(IEADiagram diagram)
{
if (!diagram.IsRelationshipView())
{
return;
}
diagram.HideConnectors(new[]
{
EAConstants.RelationFollowedBy
});
}
public IEADiagramObject GetForcesDiagramObject()
{
IEADiagram diagram = GetDecisionForcesDiagram();
IEnumerable <IEADiagramObject> objects = diagram.GetElements();
Assert.IsNotNull(objects);
IEADiagramObject obj = objects.ElementAt(0);
Assert.IsNotNull(obj);
return(obj);
}
public override void OnPostOpenDiagram(IEADiagram diagram)
{
if (!diagram.IsForcesView())
{
return;
}
diagram.HideConnectors(new[]
{
EAConstants.RelationAlternativeFor, EAConstants.RelationCausedBy,
EAConstants.RelationDependsOn,
EAConstants.RelationExcludedBy, EAConstants.RelationReplaces, EAConstants.RelationFollowedBy
});
}
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 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 override void OnNotifyContextItemModified(string guid, EANativeType type)
{
if (EANativeType.Diagram.Equals(type))
{
IEADiagram diagram = EAMain.Repository.GetDiagramByGuid(guid);
if (!diagram.IsRelationshipView())
{
return;
}
diagram.HideConnectors(new[]
{
EAConstants.RelationFollowedBy
});
}
}
/// <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);
}
}
public void InsertDiagramImage(IEADiagram diagram)
{
if (diagram.IsRelationshipView())
{
Paragraph para = _body.AppendChild(new Paragraph());
Run run = para.AppendChild(new Run());
RunProperties runProperties = getHeading2(run);
run.AppendChild(new Text(++_diagmarCounter + ". Relationship View: " + diagram.Name));
//_body.AppendChild(new Paragraph(new Run(new Text(++_diagmarCounter + ". Relationship Viewpoint"))));
}
else if (diagram.IsStakeholderInvolvementView())
{
Paragraph para = _body.AppendChild(new Paragraph());
Run run = para.AppendChild(new Run());
RunProperties runProperties = getHeading2(run);
run.AppendChild(
new Text(++_diagmarCounter + ". Decision Stakeholder Involvement View: " + diagram.Name));
//_body.AppendChild(new Paragraph(new Run(new Text(++_diagmarCounter + ". Decision Stakeholder Involvement Viewpoint"))));
}
else if (diagram.IsChronologicalView())
{
Paragraph para = _body.AppendChild(new Paragraph());
Run run = para.AppendChild(new Run());
RunProperties runProperties = getHeading2(run);
run.AppendChild(new Text(++_diagmarCounter + ". Decision Chronological View: " + diagram.Name));
//_body.AppendChild(new Paragraph(new Run(new Text(++_diagmarCounter + ". Decision Chronological Viewpoint"))));
}
else
{
return;
}
_body.AppendChild(new Paragraph(new Run(new Text())));
ImagePart imagePart = _mainPart.AddImagePart(ImagePartType.Emf);
FileStream fs = diagram.DiagramToStream();
imagePart.FeedData(fs);
Image image = Image.FromFile(fs.Name);
AddImageToBody(_mainPart.GetIdOfPart(imagePart), Utils.GetImageSize(image));
//cleanup:
fs.Close();
image.Dispose();
File.Delete(fs.Name);
}
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);
}
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);
}
/// <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);
}
}
public void ShowInDiagrams()
{
IEADiagram[] diagrams = GetDiagrams();
if (diagrams.Length == 1)
{
IEADiagram diagram = diagrams[0];
diagram.OpenAndSelectElement(this);
}
else if (diagrams.Length >= 2)
{
var selectForm = new SelectDiagram(diagrams);
if (selectForm.ShowDialog() == DialogResult.OK)
{
IEADiagram diagram = selectForm.GetSelectedDiagram();
diagram.OpenAndSelectElement(this);
}
}
ShowInProjectView();
}
private IEADiagram GetDecisionStakeholderDiagram()
{
IEADiagram diagram = null;
IEAPackage package = GetDecisionPackage();
IEnumerable <IEADiagram> diagrams = package.GetAllDiagrams();
Assert.IsNotNull(diagrams);
// Find a forces viewpoint
foreach (IEADiagram d in diagrams)
{
if (d.IsStakeholderInvolvementView())
{
diagram = d;
break;
}
}
Assert.IsNotNull(diagram);
return(diagram);
}
private void OpenDecisionInDiagrams(IEAElement decision)
{
IEADiagram[] diagrams = decision.GetDiagrams();
if (diagrams.Count() == 1) // open the diagram with the decision if there is only one diagram
{
IEADiagram diagram = diagrams[0];
diagram.OpenAndSelectElement(decision);
}
else if (diagrams.Count() >= 2) // let the user decide which diagram to open
{
var selectForm = new SelectDiagram(diagrams);
if (selectForm.ShowDialog() == DialogResult.OK)
{
IEADiagram diagram = selectForm.GetSelectedDiagram();
diagram.OpenAndSelectElement(decision);
}
}
decision.ShowInProjectView();
}
private IEADiagram GetDecisionRelationshipDiagram()
{
IEADiagram diagram = null;
IEAPackage package = GetDecisionPackage();
IEnumerable <IEADiagram> diagrams = package.GetAllDiagrams();
Assert.IsNotNull(diagrams);
// Find a forces viewpoint
foreach (IEADiagram d in diagrams)
{
if (d.IsRelationshipView())
{
diagram = d;
break;
}
}
Assert.IsNotNull(diagram);
return(diagram);
}
public override void OnNotifyContextItemModified(string guid, EANativeType type)
{
switch (type)
{
case EANativeType.Diagram:
IEADiagram diagram = EAMain.Repository.GetDiagramByGuid(guid);
if (!diagram.IsChronologicalView())
{
break;
}
diagram.HideConnectors(new[]
{
EAConstants.RelationAlternativeFor, EAConstants.RelationCausedBy,
EAConstants.RelationDependsOn,
EAConstants.RelationExcludedBy, EAConstants.RelationReplaces
});
break;
}
}
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);
}
