private void DeleteFocus(FocusModel Model)
{
//Kill the set that might have this focus as parent
foreach (FocusModel focus in FociList)
{
foreach (PrerequisitesSetModel set in focus.Prerequisite.ToList())
{
if (set.FociList.Contains(Model))
{
set.DeleteSetRelations();
}
}
foreach (MutuallyExclusiveSetModel set in focus.MutualyExclusive.ToList())
{
if (set.Focus2 == Model || set.Focus1 == Model)
{
set.DeleteSetRelations();
}
}
}
//Remove the focus
FociList.Remove(Model);
UndoService.Current[GetUndoRoot()].EndChangeSetBatch();
EditGridDefinition();
DrawOnCanvas();
}
public void addFocusToList(Focus FocusToAdd)
{
FociList.Add(FocusToAdd);
RowCount = FocusToAdd.Y >= RowCount ? FocusToAdd.Y + 1 : RowCount;
ColumnCount = FocusToAdd.X >= ColumnCount ? FocusToAdd.X + 1 : ColumnCount;
DrawOnCanvas();
}
public void addFocusToList(FocusModel FocusToAdd)
{
FociList.Add(FocusToAdd);
UndoService.Current[GetUndoRoot()].EndChangeSetBatch();
RowCount = FocusToAdd.Y >= RowCount ? FocusToAdd.Y + 1 : RowCount;
ColumnCount = FocusToAdd.X >= ColumnCount ? FocusToAdd.X + 1 : ColumnCount;
DrawOnCanvas();
}
public void EditGridDefinition()
{
if (!FociList.Any())
{
return;
}
Focus biggestY = FociList.Aggregate((i1, i2) => i1.Y > i2.Y ? i1 : i2);
Focus biggestX = FociList.Aggregate((i1, i2) => i1.X > i2.X ? i1 : i2);
RowCount = biggestY.Y >= RowCount ? biggestY.Y + 1 : RowCount;
ColumnCount = biggestX.X >= ColumnCount ? biggestX.X + 1 : ColumnCount;
}
public void EditGridDefinition()
{
if (!FociList.Any())
{
return;
}
FocusModel biggestY = FociList.Aggregate((i1, i2) => i1.DisplayY >
i2.DisplayY ? i1 : i2);
FocusModel biggestX = FociList.Aggregate((i1, i2) => i1.DisplayX >
i2.DisplayX ? i1 : i2);
RowCount = biggestY.DisplayY >= RowCount ? biggestY.DisplayY + 1 : RowCount;
ColumnCount = biggestX.DisplayX >= ColumnCount ? biggestX.DisplayX + 1 : ColumnCount;
}
internal void updateRelatives(FocusModel RelativeTo)
{
if (FociList.All(f => f.CoordinatesRelativeTo != RelativeTo))
{
return;
}
//Select all focuses that are relative to this parent, but not currently in movement
foreach (FocusModel relative in
FociList.Where(f => f.CoordinatesRelativeTo == RelativeTo &&
!SelectedFocuses.Contains(f)))
{
relative.RaisePropertyChanged(() => relative.DisplayX);
relative.RaisePropertyChanged(() => relative.DisplayY);
updateRelatives(relative);
}
}
public FocusGridModel(FocusGridModel model)
{
SetupCommons();
//Transfer data
UniqueID = Guid.NewGuid();
visibleName = model.visibleName;
tag = model.tag;
additionnalMods = model.additionnalMods;
foreach (FocusModel focus in model.FociList)
{
FociList.Add(new FocusModel(focus));
}
//Rerun to create sets
foreach (FocusModel focus in FociList)
{
focus.RepairSets(model.FociList.FirstOrDefault(f => f.UniqueName == focus.UniqueName),
FociList.ToList());
}
//Create the remaining stuff
FociList.CollectionChanged += FociList_CollectionChanged;
//Min Row & column Count
EditGridDefinition();
}
public FocusGridModel(FociGridContainer container)
{
SetupCommons();
//Transfer data
UniqueID = container.IdentifierID;
visibleName = container.ContainerID;
tag = container.TAG;
additionnalMods = container.AdditionnalMods;
foreach (Focus focus in container.FociList)
{
FociList.Add(new FocusModel(focus));
}
//Rerun to create sets
foreach (FocusModel model in FociList)
{
model.RepairSets(
container.FociList.FirstOrDefault(f => f.UniqueName == model.UniqueName),
FociList.ToList());
}
//Create the remaining stuff
FociList.CollectionChanged += FociList_CollectionChanged;
//Min Row & column Count
EditGridDefinition();
}
private void NotificationMessageReceived(NotificationMessage msg)
{
//If this is not the intended target
if (msg.Target != null && msg.Target != this)
{
return;
}
//If this is a dead tab waiting to be destroyed
if (VisibleName == null)
{
return;
}
FocusModel Model = msg.Sender as FocusModel;
switch (msg.Notification)
{
case "CloseEditFocus":
switch (ModeType)
{
case RelationMode.Add:
ManageFocusViewModel viewModel = msg.Sender as ManageFocusViewModel;
if (viewModel != null)
{
addFocusToList(viewModel.Focus);
}
DrawOnCanvas();
break;
case RelationMode.Edit:
EditGridDefinition();
DrawOnCanvas();
break;
}
ModeType = RelationMode.None;
break;
case "DeleteFocus":
if (Model == null)
{
return;
}
//Check if model is in the selected foci
if (Model.IsSelected && SelectedFocuses.Contains(Model))
{
//Delete everyone
foreach (FocusModel item in SelectedFocuses)
{
DeleteFocus(item);
}
break;
}
//Otherwise, kill the current focus
DeleteFocus(Model);
break;
case "AddFocusMutually":
ModeType = RelationMode.MutuallyExclusive;
if (Model != null)
{
ChosenFocusForLink = Model;
Model.IsWaiting = true;
}
break;
case "FinishAddFocusMutually":
if (ChosenFocusForLink != null && ChosenFocusForLink != Model &&
FociList.Any(f => f == Model))
{
UndoService.Current[GetUndoRoot()]
.BeginChangeSetBatch("AddMutuallyExclusive", false);
ModeType = RelationMode.None;
ChosenFocusForLink.IsWaiting = false;
MutuallyExclusiveSetModel tempo =
new MutuallyExclusiveSetModel(ChosenFocusForLink, Model);
ChosenFocusForLink.MutualyExclusive.Add(tempo);
Model?.MutualyExclusive.Add(tempo);
ChosenFocusForLink = null;
Messenger.Default.Send(new NotificationMessage(this,
new ViewModelLocator().StatusBar, "Clear_message"));
UndoService.Current[GetUndoRoot()].EndChangeSetBatch();
RaisePropertyChanged(() => FociList);
DrawOnCanvas();
}
break;
case "AddFocusPrerequisite":
ModeType = RelationMode.Prerequisite;
if (Model != null)
{
ChosenFocusForLink = Model;
Model.IsWaiting = true;
}
break;
case "FinishAddFocusPrerequisite":
if (ChosenFocusForLink != null && ChosenFocusForLink != Model &&
FociList.Any(f => f == Model))
{
UndoService.Current[GetUndoRoot()]
.BeginChangeSetBatch("AddPrerequisite", false);
ModeType = RelationMode.None;
if (ModeParam == RelationModeParam.Required)
{
//Create new set
PrerequisitesSetModel set = new PrerequisitesSetModel(ChosenFocusForLink);
set.FociList.Add(Model);
ChosenFocusForLink.Prerequisite.Add(set);
}
else if (ModeParam == RelationModeParam.Optional)
{
//Create new set if no exist
if (!ChosenFocusForLink.Prerequisite.Any())
{
PrerequisitesSetModel set = new PrerequisitesSetModel(ChosenFocusForLink);
ChosenFocusForLink.Prerequisite.Add(set);
}
//Add Model to last Set
ChosenFocusForLink.Prerequisite.Last().FociList.Add(Model);
}
ChosenFocusForLink.IsWaiting = false;
ChosenFocusForLink = null;
Messenger.Default.Send(new NotificationMessage(this,
new ViewModelLocator().StatusBar, "Clear_message"));
UndoService.Current[GetUndoRoot()].EndChangeSetBatch();
RaisePropertyChanged(() => FociList);
DrawOnCanvas();
}
break;
case "MakeRelativeTo":
ModeType = RelationMode.RelativeTo;
if (Model != null)
{
ChosenFocusForLink = Model;
Model.IsWaiting = true;
}
break;
case "FinishMakeRelativeTo":
if (ChosenFocusForLink != null && ChosenFocusForLink != Model &&
FociList.Any(f => f == Model))
{
if (Model != null)
{
UndoService.Current[GetUndoRoot()]
.BeginChangeSetBatch("MakeRelativeTo", false);
ModeType = RelationMode.None;
ChosenFocusForLink.IsWaiting = false;
ChosenFocusForLink.X = ChosenFocusForLink.DisplayX - Model.DisplayX;
ChosenFocusForLink.Y = ChosenFocusForLink.DisplayY - Model.DisplayY;
ChosenFocusForLink.CoordinatesRelativeTo = Model;
ChosenFocusForLink = null;
Messenger.Default.Send(new NotificationMessage(this,
new ViewModelLocator().StatusBar, "Clear_message"));
UndoService.Current[GetUndoRoot()].EndChangeSetBatch();
RaisePropertyChanged(() => FociList);
DrawOnCanvas();
}
}
break;
case "PositionChanged":
if (Model != null)
{
foreach (FocusModel focus in FociList.Where(f => f.CoordinatesRelativeTo == Model))
{
focus.RaisePropertyChanged(() => focus.DisplayX);
focus.RaisePropertyChanged(() => focus.DisplayY);
}
DrawOnCanvas();
}
UndoService.Current[GetUndoRoot()].EndChangeSetBatch();
break;
}
if (msg.Target == this)
{
//Resend to the tutorial View model if this was the target
Messenger.Default.Send(new NotificationMessage(msg.Sender,
new ViewModelLocator().Tutorial, msg.Notification));
}
}
private void Paste(object sender)
{
if (!CanPaste(sender))
{
return;
}
UndoService.Current[GetUndoRoot()]
.BeginChangeSetBatch("PasteMultiple", false);
Point mousePos = Mouse.GetPosition((IInputElement)sender);
if (!CopyTempMemory.Any())
{
return;
}
int XChange = 0;
int YChange = 0;
if (sender != null)
{
FocusModel First = CopyTempMemory.FirstOrDefault();
if (First == null)
{
return;
}
XChange = (int)Math.Floor(mousePos.X / 89 - 0.4) - First.DisplayX;
YChange = (int)Math.Floor(mousePos.Y / 140) - First.DisplayY;
}
List <FocusModel> newSelected = CopyTempMemory.Select(selected =>
selected.Copy(XChange, YChange)).ToList();
for (int index = 0; index < CopyTempMemory.Count; index++)
{
FocusModel selected = CopyTempMemory[index];
FocusModel currentFocus = newSelected[index];
//Repair relative to
if (selected.CoordinatesRelativeTo != null)
{
//If the relative to can be found in the current new list
if (newSelected.Any(f => selected.CoordinatesRelativeTo.UniqueName == f.UniqueName))
{
currentFocus.CoordinatesRelativeTo = newSelected.FirstOrDefault(f =>
selected.CoordinatesRelativeTo.UniqueName == f.UniqueName);
}
else
{
//Otherwise, keep the same
currentFocus.CoordinatesRelativeTo = selected.CoordinatesRelativeTo;
}
}
//Repair prerequisites
foreach (PrerequisitesSetModel set in selected.Prerequisite)
{
PrerequisitesSetModel newset = new PrerequisitesSetModel(currentFocus);
foreach (FocusModel child in set.FociList)
{
//If the focus to can be found in the current new list
if (newSelected.Any(f => child.UniqueName == f.UniqueName))
{
newset.FociList.Add(newSelected.FirstOrDefault(f => child.UniqueName
== f.UniqueName));
}
else
{
//Otherwise, keep the same
newset.FociList.Add(child);
}
}
currentFocus.Prerequisite.Add(newset);
}
//Repair mutually exclusives
foreach (MutuallyExclusiveSetModel set in selected.MutualyExclusive)
{
FocusModel toFind;
FocusModel focus1;
FocusModel focus2;
if (set.Focus1.UniqueName == currentFocus.UniqueName)
{
toFind = set.Focus2;
focus1 = set.Focus1;
}
else if (set.Focus2.UniqueName == currentFocus.UniqueName)
{
toFind = set.Focus1;
focus1 = set.Focus2;
}
else
{
//Cannot be found, cancel
continue;
}
//If the focus to can be found in the current new list
if (newSelected.Any(f => toFind.UniqueName == f.UniqueName))
{
focus2 = newSelected.FirstOrDefault(f => toFind.UniqueName
== f.UniqueName);
}
else
{
//Otherwise, keep the same
focus2 = toFind;
}
currentFocus.MutualyExclusive.Add(new MutuallyExclusiveSetModel(focus1, focus2));
}
currentFocus.IsSelected = true;
FociList.Add(currentFocus);
}
//Unselect all the selected foci
foreach (FocusModel selected in SelectedFocuses)
{
selected.IsSelected = false;
}
//Change all copied name to append _Copy
foreach (FocusModel currentFocus in newSelected)
{
currentFocus.UniqueName += "_Copy";
}
SelectedFocuses = newSelected;
UndoService.Current[GetUndoRoot()].EndChangeSetBatch();
}
private void NotificationMessageReceived(NotificationMessage msg)
{
if (!this.isShown || this.Filename == null)
{
//is not shown, do not manage
return;
}
if (msg.Notification == "HideAddFocus")
{
System.Windows.Application.Current.Properties["Mode"] = null;
AddFocusViewModel viewModel = msg.Sender as AddFocusViewModel;
addFocusToList(viewModel.Focus);
RaisePropertyChanged(() => FociList);
DrawOnCanvas();
}
if (msg.Notification == "HideEditFocus")
{
System.Windows.Application.Current.Properties["Mode"] = null;
EditGridDefinition();
DrawOnCanvas();
}
if (msg.Notification == "DeleteFocus")
{
Focus Model = (Focus)msg.Sender;
//Kill the set that might have this focus as parent
foreach (Focus focus in FociList)
{
foreach (PrerequisitesSet set in focus.Prerequisite.ToList())
{
if (set.FociList.Contains(Model))
{
set.DeleteSetRelations();
}
}
}
FociList.Remove(Model);
RaisePropertyChanged(() => FociList);
EditGridDefinition();
DrawOnCanvas();
}
if (msg.Notification == "AddFocusMutually")
{
System.Windows.Application.Current.Properties["Mode"] = "Mutually";
Focus Model = (Focus)msg.Sender;
selectedFocus = Model;
Model.IsSelected = true;
}
if (msg.Notification == "FinishAddFocusMutually")
{
Focus Model = (Focus)msg.Sender;
if (selectedFocus != null && selectedFocus != Model &&
FociList.Where((f) => f == Model).Any())
{
System.Windows.Application.Current.Properties["Mode"] = null;
selectedFocus.IsSelected = false;
var tempo = new MutuallyExclusiveSet(selectedFocus, Model);
selectedFocus.MutualyExclusive.Add(tempo);
Model.MutualyExclusive.Add(tempo);
DrawOnCanvas();
}
}
if (msg.Notification == "AddFocusPrerequisite")
{
System.Windows.Application.Current.Properties["Mode"] = "Prerequisite";
Focus Model = (Focus)msg.Sender;
selectedFocus = Model;
Model.IsSelected = true;
}
if (msg.Notification == "FinishAddFocusPrerequisite")
{
Focus Model = (Focus)msg.Sender;
if (selectedFocus != null && selectedFocus != Model &&
FociList.Where((f) => f == Model).Any())
{
System.Windows.Application.Current.Properties["Mode"] = null;
string Type = (string)System.Windows.Application.Current.Properties["ModeParam"];
System.Windows.Application.Current.Properties["ModeParam"] = null;
selectedFocus.IsSelected = false;
if (Type == "Required")
{
//Create new set
PrerequisitesSet set = new PrerequisitesSet(selectedFocus);
set.FociList.Add(Model);
selectedFocus.Prerequisite.Add(set);
}
else
{
//Create new set if no exist
if (!selectedFocus.Prerequisite.Any())
{
PrerequisitesSet set = new PrerequisitesSet(selectedFocus);
selectedFocus.Prerequisite.Add(set);
}
//Add Model to first Set
selectedFocus.Prerequisite.First().FociList.Add(Model);
}
RaisePropertyChanged(() => FociList);
DrawOnCanvas();
}
}
if (msg.Notification == "ContainerRenamed")
{
RaisePropertyChanged(() => Filename);
}
}
