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 DetectPositionPoints()
{
DependencyObject parent = VisualTreeHelper.GetParent(this);
while (!(parent is Grid))
{
if (parent == null)
{
dispatcherTimer.Stop();
return;
}
parent = VisualTreeHelper.GetParent(parent);
}
Point position = TranslatePoint(new Point(1, 1), (FrameworkElement)parent);
//If the focus has not changed position
if (OldPoint == position)
{
return;
}
OldPoint = position;
FocusModel model = DataContext as FocusModel;
if (model == null)
{
return;
}
model.setPoints(new Point(position.X + (RenderSize.Width / 2), position.Y + 40),
new Point(position.X + (RenderSize.Width / 2), position.Y + (RenderSize.Height)),
new Point(position.X, position.Y + (RenderSize.Height / 2)),
new Point(position.X + (RenderSize.Width), position.Y + (RenderSize.Height / 2)));
((FocusGridModel)((FrameworkElement)parent).DataContext).UpdateFocus(model);
}
public FociGridContainer(FocusGridModel item)
{
IdentifierID = item.UniqueID;
ContainerID = item.VisibleName;
TAG = item.TAG;
AdditionnalMods = item.AdditionnalMods;
FileInfo = item.FileInfo;
FociList = new List <Focus>();
foreach (FocusModel model in item.FociList)
{
FociList.Add(new Focus
{
UniqueName = model.UniqueName,
Text = model.Text,
Image = model.Image,
X = model.X,
Y = model.Y,
Cost = model.Cost,
InternalScript = model.InternalScript,
Note = model.Note
});
}
//Repair sets and relative to
foreach (Focus focus in FociList)
{
FocusModel associatedModel =
item.FociList.FirstOrDefault(f => f.UniqueName == focus.UniqueName);
//If no model was found, continue the loop, the focus is broken
if (associatedModel == null)
{
continue;
}
//Relative to
if (associatedModel.CoordinatesRelativeTo != null)
{
focus.RelativeTo = FociList.FirstOrDefault(f => f.UniqueName ==
associatedModel.CoordinatesRelativeTo.UniqueName);
}
//Prerequisites
foreach (PrerequisitesSetModel set in associatedModel.Prerequisite)
{
PrerequisitesSet newset = new PrerequisitesSet(focus);
foreach (FocusModel model in set.FociList)
{
newset.FociList.Add(FociList.FirstOrDefault(f => f.UniqueName ==
model.UniqueName));
}
focus.Prerequisite.Add(newset);
}
//Mutually exclusives
foreach (MutuallyExclusiveSetModel set in associatedModel.MutualyExclusive)
{
MutuallyExclusiveSet newset = new MutuallyExclusiveSet(
FociList.FirstOrDefault(f => f.UniqueName == set.Focus1.UniqueName),
FociList.FirstOrDefault(f => f.UniqueName == set.Focus2.UniqueName));
focus.MutualyExclusive.Add(newset);
}
}
}
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 UpdateFocus(FocusModel sender)
{
if (new ViewModelLocator().Main.SelectedTab != this)
{
return;
}
EditGridDefinition();
DrawOnCanvas();
}
public void SelectFocus(Views.UserControls.Focus selected)
{
FocusModel model = selected.DataContext as FocusModel;
if (model == null)
{
return;
}
model.IsSelected = true;
SelectedFocuses.Add(model);
CopyCommand.RaiseCanExecuteChanged();
}
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;
}
public async Task GetFocusModelShouldBeSuccessful()
{
ClarifaiResponse <IModel <Focus> > response =
await Client.GetModel <Focus>(Client.PublicModels.FocusModel.ModelID)
.ExecuteAsync();
Assert.True(response.IsSuccessful);
Assert.AreEqual(10000, response.Status.StatusCode);
Assert.AreEqual(HttpStatusCode.OK, response.HttpCode);
Assert.NotNull(response.RawBody);
FocusModel focusModel = (FocusModel)response.Get();
Assert.NotNull(focusModel.ModelID);
}
private void Focus_OnMouseLeave(object sender, MouseEventArgs e)
{
Cursor = null;
FocusModel model = DataContext as FocusModel;
if (model == null)
{
return;
}
if (model.IsWaiting)
{
return;
}
FocusGrid.ClearValue(EffectProperty);
}
private void VisualFocus_Loaded(object sender, RoutedEventArgs e)
{
//Property change for blur effect
FocusModel model = DataContext as FocusModel;
if (model == null)
{
return;
}
model.PropertyChanged += Focus_PropertyChanged;
//Image loading async
StartImageDispatcher();
Messenger.Default.Send(new NotificationMessage(this,
new ViewModelLocator().Tutorial, "FocusLoaded"));
}
private void Focus_PreviewMouseMove(object sender, MouseEventArgs e)
{
FocusGridModel context = DataContext as FocusGridModel;
if (e.OriginalSource is TextBox || context == null)
{
return;
}
Focus element = sender as Focus;
if (element != null && IsDragging && e.LeftButton == MouseButtonState.Pressed &&
!DraggedElement.Any())
{
//Check if the dragged element is in the selected focus list
if (context.SelectedFocuses.Any(f => f == element.DataContext))
{
//Add all the selected
IEnumerable <Focus> selectedFoci = UiHelper.FindVisualChildren <Focus>(this)
.Where(f =>
{
FocusModel selectedContext = f.DataContext as FocusModel;
return(selectedContext != null &&
context.SelectedFocuses.Any(f2 => f2 == selectedContext));
});
DraggedElement.AddRange(selectedFoci);
}
else
{
//We don't want to have selected AND dragged
context.ClearSelected();
DraggedElement.Add(element);
}
Source = element;
Source.CaptureMouse();
}
if (!DraggedElement.Any() || Source == null || !Source.IsMouseCaptured)
{
return;
}
currentPoint = e.GetPosition(ListGrid);
transform.X += currentPoint.X - anchorPoint.X;
transform.Y += currentPoint.Y - anchorPoint.Y;
foreach (Focus focus in DraggedElement)
{
focus.RenderTransform = transform;
}
anchorPoint = currentPoint;
}
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);
}
}
internal void ChangePosition(object draggedElement, Point newPos)
{
FocusModel element = draggedElement as FocusModel;
if (element == null)
{
return;
}
UndoService.Current[GetUndoRoot()]
.BeginChangeSetBatch("ChangePosition", false);
//Move the focuses
element.DisplayX = (int)Math.Floor(newPos.X / 89);
element.DisplayY = (int)Math.Floor(newPos.Y / 140);
//Make all relative to focuses change their positions
updateRelatives(element);
EditGridDefinition();
UndoService.Current[GetUndoRoot()].EndChangeSetBatch();
}
private void StartImageDispatcher()
{
FocusModel model = DataContext as FocusModel;
if (model == null)
{
return;
}
Dispatcher.Invoke(() =>
{
Binding binding = new Binding
{
Path = new PropertyPath("Icon"),
Source = model
};
BindingOperations.SetBinding(FocusIcon, Image.SourceProperty, binding);
});
}
private void Focus_OnMouseEnter(object sender, MouseEventArgs e)
{
Cursor = ((TextBlock)Resources["CursorGrab"]).Cursor;
FocusModel model = DataContext as FocusModel;
if (model == null)
{
return;
}
if (model.IsWaiting)
{
return;
}
FocusGrid.Effect = new DropShadowEffect
{
Color = Colors.Yellow,
BlurRadius = 20,
Opacity = 1,
ShadowDepth = 0
};
}
private void Focus_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
FocusModel model = DataContext as FocusModel;
if (model == null)
{
return;
}
if (e.PropertyName == "IsWaiting")
{
FocusGrid.ClearValue(EffectProperty);
if (model.IsWaiting)
{
FocusGrid.Effect = new DropShadowEffect
{
Color = Colors.OrangeRed,
BlurRadius = 20,
Opacity = 1,
ShadowDepth = 0
};
}
}
}
public ManageFocusViewModel SetupFlyout(object sender, ModeType Mode)
{
if (Mode == ModeType.Create)
{
Point mousePos = Mouse.GetPosition((IInputElement)sender);
FocusModel localFocus = new FocusModel();
FocusGridModel firstOrDefault = new ViewModelLocator().Main.SelectedTab as FocusGridModel;
if (firstOrDefault != null)
{
localFocus.setDefaults(firstOrDefault
.FociList.Count);
Focus = localFocus;
//minus 0.4 because if you hit the border of a cell, it will add it to the next one... Annoying
Focus.X = (int)Math.Floor(mousePos.X / 89 - 0.4);
Focus.Y = (int)Math.Floor(mousePos.Y / 140);
}
}
else
{
Focus = (FocusModel)sender;
}
RaisePropertyChanged(() => Focus);
return(this);
}
public void DrawOnCanvas()
{
if (FociList == null)
{
return;
}
CanvasLines.Clear();
foreach (FocusModel focus in FociList)
{
//Draw relatives
if (DrawPositionLines && focus.CoordinatesRelativeTo != null)
{
CanvasLine newline = new CanvasLine(
focus.FocusTop.X,
focus.FocusTop.Y,
focus.CoordinatesRelativeTo.FocusBottom.X,
focus.CoordinatesRelativeTo.FocusBottom.Y,
System.Windows.Media.Brushes.Gold, false, null, focus);
CanvasLines.Add(newline);
}
//Draw Prerequisites
foreach (PrerequisitesSetModel set in focus.Prerequisite)
{
//Draw line from top of first Focus
CanvasLine newline = new CanvasLine(
set.Focus.FocusTop.X,
set.Focus.FocusTop.Y,
set.Focus.FocusTop.X,
set.Focus.FocusTop.Y - PRE_LINE_HEIGHT,
System.Windows.Media.Brushes.Teal, set.isRequired(), set);
CanvasLines.Add(newline);
foreach (FocusModel model in set.FociList)
{
FocusModel Prerequisite = model;
if (Prerequisite == null)
{
continue;
}
//Draw horizontal lines to prerequisite pos
newline = new CanvasLine(set.Focus.FocusTop.X,
set.Focus.FocusTop.Y - PRE_LINE_HEIGHT, Prerequisite.FocusBottom.X,
set.Focus.FocusTop.Y - PRE_LINE_HEIGHT, System.Windows.Media.Brushes.Teal,
set.isRequired(), set);
CanvasLines.Add(newline);
//Draw line to prerequisite bottom
newline = new CanvasLine(Prerequisite.FocusBottom.X,
set.Focus.FocusTop.Y - PRE_LINE_HEIGHT, Prerequisite.FocusBottom.X,
Prerequisite.FocusBottom.Y, System.Windows.Media.Brushes.Teal,
set.isRequired(), set);
CanvasLines.Add(newline);
}
}
//Draw Mutually exclusives
foreach (MutuallyExclusiveSetModel set in focus.MutualyExclusive)
{
CanvasLine newline = new CanvasLine(
set.Focus1.FocusRight.X,
set.Focus1.FocusRight.Y,
set.Focus2.FocusLeft.X,
set.Focus2.FocusLeft.Y,
System.Windows.Media.Brushes.Red, false, set);
if (!CanvasLines.Any(line => line.X1 == newline.X1 &&
line.X2 == newline.X2 &&
line.Y1 == newline.Y1 &&
line.Y2 == newline.Y2))
{
CanvasLines.Add(newline);
}
}
}
RaisePropertyChanged(() => CanvasLines);
Messenger.Default.Send(new NotificationMessage("DrawOnCanvas"));
}
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();
}
public static FocusGridModel CreateTreeFromScript(string fileName, Script script)
{
if (script.Logger.hasErrors())
{
return(null);
}
FocusGridModel container = new FocusGridModel(script.TryParse(script, "id"));
//Get content of Modifier block
Assignation modifier = script.FindAssignation("modifier");
container.TAG = script.TryParse(modifier, "tag", null, false);
if (container.TAG != null)
{
container.AdditionnalMods = modifier.GetContentAsScript(new[] { "add", "tag" })
.Parse(script.Comments, 0);
}
//Run through all foci
foreach (ICodeStruct codeStruct in script.FindAllValuesOfType <CodeBlock>("focus"))
{
CodeBlock block = (CodeBlock)codeStruct;
try
{
//Create the focus
FocusModel newFocus = new FocusModel
{
UniqueName = script.TryParse(block, "id"),
Text = script.TryParse(block, "text", null, false),
Image = script.TryParse(block, "icon").Replace("GFX_", ""),
X = int.Parse(script.TryParse(block, "x")),
Y = int.Parse(script.TryParse(block, "y")),
Cost = GetDouble(script.TryParse(block, "cost"), 10)
};
//Get all core scripting elements
Script InternalFocusScript = block.
GetContentAsScript(ALL_PARSED_ELEMENTS.ToArray(), script.Comments);
newFocus.InternalScript = InternalFocusScript;
if (script.Logger.hasErrors())
{
new ViewModelLocator().ErrorDawg.AddError(
string.Join("\n", script.Logger.getErrors()));
continue;
}
container.FociList.Add(newFocus);
}
catch (Exception)
{
//TODO: Add language support
new ViewModelLocator().ErrorDawg.AddError(script.Logger.ErrorsToString());
new ViewModelLocator().ErrorDawg.AddError("Invalid syntax for focus "
+ script.TryParse(block, "id") + ", please double-check the syntax.");
}
}
//Run through all foci again for mutually exclusives and prerequisites
foreach (ICodeStruct codeStruct in script.FindAllValuesOfType <CodeBlock>("focus"))
{
CodeBlock block = (CodeBlock)codeStruct;
string id = block.FindValue("id") != null?block.FindValue("id").Parse() : "";
FocusModel newFocus = container.FociList.FirstOrDefault(f => f.UniqueName == id);
if (newFocus == null)
{
//Check if we removed this focus because of a syntax error
continue;
}
//Try to find its relative to
string relativeToId = script.TryParse(block, "relative_position_id", null, false);
if (!string.IsNullOrEmpty(relativeToId))
{
newFocus.CoordinatesRelativeTo = container.FociList.FirstOrDefault(f =>
f.UniqueName == relativeToId);
}
//Recreate its mutually exclusives
foreach (ICodeStruct exclusives in block.FindAllValuesOfType <ICodeStruct>
("mutually_exclusive"))
{
foreach (ICodeStruct focuses in exclusives
.FindAllValuesOfType <ICodeStruct>("focus"))
{
//Check if focus exists in list
FocusModel found = container.FociList.FirstOrDefault(f =>
f.UniqueName == focuses.Parse());
//If we have found something
if (found == null)
{
continue;
}
MutuallyExclusiveSetModel set =
new MutuallyExclusiveSetModel(newFocus, found);
//Check if the set already exists in this focus
if (newFocus.MutualyExclusive.Contains(set) ||
found.MutualyExclusive.Contains(set))
{
continue;
}
newFocus.MutualyExclusive.Add(set);
found.MutualyExclusive.Add(set);
}
}
//Recreate its prerequisites
foreach (ICodeStruct prerequistes in block
.FindAllValuesOfType <ICodeStruct>("prerequisite"))
{
if (!prerequistes.FindAllValuesOfType <ICodeStruct>("focus").Any())
{
break;
}
PrerequisitesSetModel set = new PrerequisitesSetModel(newFocus);
foreach (ICodeStruct focuses in prerequistes.FindAllValuesOfType <ICodeStruct>
("focus"))
{
//Add the focus as a prerequisites in the current existing focuses
FocusModel search = container.FociList.FirstOrDefault((f) =>
f.UniqueName == focuses.Parse());
if (search != null)
{
set.FociList.Add(search);
}
}
//If any prerequisite was added (Poland has empty prerequisite blocks...)
if (set.FociList.Any())
{
newFocus.Prerequisite.Add(set);
}
}
}
return(container);
}
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));
}
}
