/// <summary>
/// Tells the command which elements to delete. The method uses
/// interactive dialogs to specify the initial set of delted elements and
/// to ask whether to delete unused elements from the model.
/// </summary>
/// <param name="deletedElements">set of deleted elements</param>
/// <param name="selectionCallback">function that is called, when selected elements are specified in the dialog. Can be set to null.</param>
/// <returns><code>true</code> when user pressed OK, <code>false</code> when user pressed Cancel in the</returns>
public bool InitializeCommand(Action <IEnumerable <Element> > selectionCallback, IEnumerable <Element> deletedElements)
{
List <Element> _deleted = new List <Element>(deletedElements);
ElementDependencies dependencies = ElementDependencies.FindPSMDependencies(deletedElements);
DeleteDependentElementsDialog dialog = new DeleteDependentElementsDialog(dependencies);
if (dependencies.Count > 0 && selectionCallback != null)
{
IEnumerable <Element> res = dependencies.Keys;
foreach (var elements in dependencies.Values)
{
res = res.Union(elements);
}
selectionCallback(res);
}
if (dependencies.Count == 0 || ForceDelete || dialog.ShowDialog() == true)
{
if (dependencies.Count == 0 || ForceDelete)
{
dialog.Close();
}
// add all selected dependent elements, remove those that were not selected
foreach (KeyValuePair <Element, bool> _flag in dependencies.Flags)
{
if (!ForceDelete && _flag.Value == false)
{
_deleted.Remove(_flag.Key);
}
}
foreach (KeyValuePair <Element, bool> _flag in dependencies.Flags)
{
if (_flag.Value || ForceDelete)
{
foreach (Element element in dependencies[_flag.Key])
{
if (!_deleted.Contains(element))
{
_deleted.Add(element);
}
}
}
}
DeletedElements = _deleted;
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Tells the command which elements to delete. The method uses
/// interactive dialogs to specify the initial set of delted elements and
/// to ask whether to delete unused elements from the model.
/// </summary>
/// <param name="deletedElements">set of deleted elements</param>
public void InitializeCommand(IEnumerable <Element> deletedElements)
{
List <Element> _deleted = new List <Element>(deletedElements);
ElementDependencies dependencies = ElementDependencies.FindPSMDependencies(deletedElements);
DeleteDependentElementsDialog dialog = new DeleteDependentElementsDialog(dependencies);
if (dependencies.Count == 0 || dialog.ShowDialog() == true)
{
if (dependencies.Count == 0)
{
dialog.Close();
}
// add all selected dependent elements, remove those that were not selected
foreach (KeyValuePair <Element, bool> _flag in dependencies.Flags)
{
if (_flag.Value == false)
{
_deleted.Remove(_flag.Key);
}
}
foreach (KeyValuePair <Element, bool> _flag in dependencies.Flags)
{
if (_flag.Value)
{
foreach (Element element in dependencies[_flag.Key])
{
if (!_deleted.Contains(element))
{
_deleted.Add(element);
}
}
}
}
DeleteFromPSMDiagramCommand command = (DeleteFromPSMDiagramCommand)DeleteFromPSMDiagramCommandFactory.Factory().Create(Controller);
command.DeletedElements = _deleted;
Commands.Add(command);
}
}
/// <summary>
/// Tells the command which elements to delete. The method uses
/// interactive dialogs to specify the initial set of delted elements and
/// to ask whether to delete unused elements from the model.
/// </summary>
/// <param name="deletedElements">set of deleted elements</param>
public bool InitializeCommand(IEnumerable <Element> deletedElements)
{
List <Element> _deleted = new List <Element>(deletedElements);
ElementDependencies dependencies = ElementDependencies.FindElementDependenciesInDiagram(_deleted, Controller.Diagram);
DeleteDependentElementsDialog dialog = new DeleteDependentElementsDialog(dependencies);
if (dependencies.Count == 0 || dialog.ShowDialog() == true)
{
if (dependencies.Count == 0)
{
dialog.Close();
}
// add all selected dependent elements, remove those that were not selected
foreach (KeyValuePair <Element, bool> _flag in dependencies.Flags)
{
if (_flag.Value == false)
{
_deleted.Remove(_flag.Key);
}
}
foreach (KeyValuePair <Element, bool> _flag in dependencies.Flags)
{
if (_flag.Value)
{
foreach (Element element in dependencies[_flag.Key])
{
if (!_deleted.Contains(element))
{
_deleted.Add(element);
}
}
}
}
DeleteFromDiagramCommand command = (DeleteFromDiagramCommand)DeleteFromDiagramCommandFactory.Factory().Create(Controller);
command.DeletedElements = _deleted;
Commands.Add(command);
//
// Elements that are not used in any diagrams are offered to be
// deleted from model.
//
List <Element> deleteFromModelCandidates = new List <Element>();
ElementDependencies modelDependencies = ElementDependencies.FindElementDependenciesInModel(deleteFromModelCandidates);
foreach (Element element in _deleted)
{
if (!Controller.ModelController.IsElementUsedInDiagrams(element, Controller.Diagram) &&
(!modelDependencies.ContainsKey(element) || modelDependencies[element].All(dependentElement => !Controller.ModelController.IsElementUsedInDiagrams(dependentElement))))
{
deleteFromModelCandidates.Add(element);
if (!modelDependencies.ContainsKey(element))
{
modelDependencies[element] = new List <Element>();
}
}
}
if (deleteFromModelCandidates.Count > 0)
{
DeleteDependentElementsDialog modelDialog = new DeleteDependentElementsDialog(modelDependencies);
modelDialog.tbShort.Content = "Some elements remained unused in model";
modelDialog.tbLong.Text =
"Some elements were removed from diagram and it was their only usage. Select elements you wish to remove also from model from the following list.";
modelDialog.Title = "Delete from model";
modelDialog.bCancel.Content = "Cancel";
if (modelDialog.ShowDialog() == true) //User clicked on Delete
{
// add all selected dependent elements, remove those that were not selected
foreach (KeyValuePair <Element, bool> _flag in modelDependencies.Flags)
{
if (_flag.Value == false)
{
deleteFromModelCandidates.Remove(_flag.Key);
}
}
if (deleteFromModelCandidates.Count > 0)
{
DeleteFromModelCommand deleteFromModelCommand = (DeleteFromModelCommand)DeleteFromModelCommandFactory.Factory().Create(Controller.ModelController);
deleteFromModelCommand.DeletedElements = deleteFromModelCandidates;
deleteFromModelCommand.CallingDiagram = Controller.Diagram;
Commands.Add(deleteFromModelCommand);
}
// both dialog were closed with OK
return(true);
}
else
{
// user clicked Cancel in the second dialog
return(false);
}
}
else
{
// first dialog closed OK, second dialog was not shown
return(true);
}
}
else
{
// first dialog closed OK, but second closed Cancel
return(false);
}
}
public bool Set(IEnumerable <Element> deleted, DiagramController activeDiagramController)
{
ActiveDiagramController = activeDiagramController;
Deleted = new List <Element>(deleted.Count());
foreach (Element deletable in deleted)
{
Deleted.Add(deletable);
}
ElementDependencies dependencies = ElementDependencies.FindElementDependenciesInModel(Deleted);
DeleteDependentElementsDialog dialog = new DeleteDependentElementsDialog(dependencies);
dialog.DeleteLevel = DeleteDependentElementsDialog.EDeleteLevel.Model;
if (dependencies.Count == 0 || dialog.ShowDialog() == true)
{
if (dependencies.Count == 0)
{
dialog.Close();
}
// add all selected dependent elements, remove those that were not selected
foreach (KeyValuePair <Element, bool> _flag in dependencies.Flags)
{
if (_flag.Value == false)
{
Deleted.Remove(_flag.Key);
}
else
{
foreach (Element element in dependencies[_flag.Key])
{
if (!Deleted.Contains(element))
{
Deleted.Add(element);
}
}
}
}
// test whether elements are not used in other diagrams
ElementDiagramDependencies dependentDiagrams;
if (ActiveDiagramController != null)
{
dependentDiagrams = ElementDiagramDependencies.FindElementDiagramDependencies(Controller.Project, Deleted, ActiveDiagramController.Diagram);
}
else
{
dependentDiagrams = ElementDiagramDependencies.FindElementDiagramDependencies(Controller.Project, Deleted, null);
}
if (dependentDiagrams.Count > 0 &&
!(dependentDiagrams.Count == 1 &&
ActiveDiagramController != null &&
dependentDiagrams.Single().Value.Count == 1 &&
dependentDiagrams.Single().Value.Single() == ActiveDiagramController.Diagram
)
)
{
ReferencingDiagramsDialog referencingDiagramsDialog = new ReferencingDiagramsDialog(dependentDiagrams);
referencingDiagramsDialog.ShowDialog();
if (referencingDiagramsDialog.cbOpen.IsChecked == true)
{
foreach (KeyValuePair <Element, List <Diagram> > pair in dependentDiagrams)
{
foreach (Diagram diagram in pair.Value)
{
ActivateDiagramCommand c = ActivateDiagramCommandFactory.Factory().Create(Controller) as ActivateDiagramCommand;
c.Set(diagram);
c.Execute();
}
}
}
}
else
{
deleteFromModelCommand =
(DeleteFromModelCommand)DeleteFromModelCommandFactory.Factory().Create(Controller);
deleteFromModelCommand.DeletedElements = Deleted;
if (ActiveDiagramController != null)
{
deleteFromModelCommand.CallingDiagram = ActiveDiagramController.Diagram;
}
else
{
deleteFromModelCommand.CallingDiagram = null;
}
if (ActiveDiagramController != null && ActiveDiagramController.Diagram != null)
{
deleteFromDiagramCommand =
(DeleteFromDiagramCommand)DeleteFromDiagramCommandFactory.Factory().Create(ActiveDiagramController);
deleteFromDiagramCommand.DeletedElements = Deleted.Where(e => ActiveDiagramController.Diagram.IsElementPresent(e)).ToList();
Commands.Add(deleteFromDiagramCommand);
}
Commands.Add(deleteFromModelCommand);
return(true);
}
}
return(false);
}