private void TestParseAllTrees()
{
//Arrange
Script tester = new Script();
foreach (string file in Directory.EnumerateFiles("national_focus", "*.txt"))
{
string contents = File.ReadAllText(file);
//Act
FocusGridModel model = FocusTreeParser.CreateTreeFromScript(file, contents);
FociGridContainer container = new FociGridContainer(model);
List <FociGridContainer> list = new List <FociGridContainer> {
container
};
Dictionary <string, string> files = FocusTreeParser.ParseAllTrees(list);
string filecontent = files.FirstOrDefault().Value;
string fileName = files.FirstOrDefault().Key;
//Assert
Assert.IsNotNull(model);
Assert.IsTrue(model.FociList.Any());
Assert.IsNotNull(fileName);
Assert.IsNotNull(filecontent);
tester.Analyse(filecontent);
Assert.IsFalse(tester.Logger.hasErrors());
}
}
private void CopyElement(object obj)
{
UndoService.Current[GetUndoRoot()].BeginChangeSetBatch("CopyAnyFile", false);
FileManager dialog = new FileManager(ModeType.Edit);
if (obj is FocusGridModel)
{
FocusGridModel item = new FocusGridModel((FocusGridModel)obj);
item.VisibleName += "_copy";
Project.fociList.Add(item);
RaisePropertyChanged(() => Project.fociList);
}
else if (obj is LocalisationModel)
{
LocalisationModel item = new LocalisationModel((LocalisationModel)obj);
item.VisibleName += "_copy";
Project.localisationList.Add(item);
RaisePropertyChanged(() => Project.localisationList);
}
else if (obj is EventTabModel)
{
EventTabModel item = new EventTabModel((EventTabModel)obj);
item.VisibleName += "_copy";
Project.eventList.Add(item);
RaisePropertyChanged(() => Project.eventList);
}
else if (obj is ScriptModel)
{
ScriptModel item = new ScriptModel((ScriptModel)obj);
item.VisibleName += "_copy";
Project.scriptList.Add(item);
RaisePropertyChanged(() => Project.scriptList);
}
UndoService.Current[GetUndoRoot()].EndChangeSetBatch();
}
private void UIElement_OnMouseDown(object sender, MouseButtonEventArgs e)
{
//Always send the event to the data context
FocusGridModel dataContext = DataContext as FocusGridModel;
if (dataContext == null)
{
return;
}
dataContext.LeftClickCommand.Execute(ListGrid);
//Check if we are on the grid
if (!(e.OriginalSource is GriddedGrid))
{
return;
}
//Make sure we aren't dragging already
if (IsDragging)
{
return;
}
// Capture and track the mouse.
IsSelecting = true;
mouseDownPos = e.GetPosition(SelectionGrid);
SelectionGrid.CaptureMouse();
// Initial placement of the drag selection box.
Canvas.SetLeft(selectionBox, mouseDownPos.X);
Canvas.SetTop(selectionBox, mouseDownPos.Y);
selectionBox.Width = 0;
selectionBox.Height = 0;
// Make the drag selection box visible.
selectionBox.Visibility = Visibility.Visible;
FocusGridModel model = DataContext as FocusGridModel;
model?.ClearSelected();
}
public void TestFocusParser()
{
FocusGridModel model = TestScriptToTree();
TestTreeToScript(model);
TestParseAllTrees();
}
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 static string ParseTreeForCompare(FocusGridModel model)
{
FociGridContainer container = new FociGridContainer(model);
string focusTreeId = container.ContainerID.Replace(" ", "_");
return(Parse(container.FociList.ToList(), focusTreeId,
container.TAG, container.AdditionnalMods));
}
private void Focus_PreviewMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
FocusGridModel model = DataContext as FocusGridModel;
if (model == null)
{
return;
}
Focus element = sender as Focus;
//Check if the focus id not move at all and is not a double click
if (element != null && !element.IsMouseCaptured && model.ModeType == RelationMode.None &&
IsDragging)
{
//If not holding CTRL
if (Keyboard.Modifiers != ModifierKeys.Control)
{
//Clear all selected
model.ClearSelected();
}
//If it was just a click, add this focus to the selected
model.SelectFocus(element);
IsDragging = false;
Source = null;
DraggedElement.Clear();
}
//Otherwise, manage as a move
else if (model.ModeType == RelationMode.None && IsDragging)
{
if (Source == null)
{
return;
}
Source.ReleaseMouseCapture();
foreach (Focus focus in DraggedElement)
{
Image image = UiHelper.FindChildWithName(focus, "FocusIcon") as Image;
if (image == null)
{
return;
}
Point basepos = image.TranslatePoint(new Point(0, 0), ListGrid);
//Kill the transform
focus.RenderTransform = new TranslateTransform();
//Change the position after applying the transform
((FocusGridModel)DataContext).ChangePosition(focus.DataContext,
new Point(basepos.X + 45, basepos.Y));
}
IsDragging = false;
transform.X = 0;
transform.Y = 0;
Source.Cursor = null;
Source = null;
DraggedElement.Clear();
e.Handled = true;
}
}
private void NotificationMessageReceived(NotificationMessage msg)
{
if (msg.Target != null && msg.Target != this)
{
//Message not itended for here
return;
}
if (msg.Notification == "OpenFocusTree")
{
FociGridContainer container = msg.Sender as FociGridContainer;
if (TabsModelList.Where((t) => t is FocusGridModel &&
((FocusGridModel)t).UniqueID == container.IdentifierID).Any())
{
return;
}
FocusGridModel newModel = new FocusGridModel(container.IdentifierID);
TabsModelList.Add(newModel);
RaisePropertyChanged("TabsModelList");
}
if (msg.Notification == "OpenLocalisation")
{
LocalisationContainer container = msg.Sender as LocalisationContainer;
if (TabsModelList.Where((t) => t is LocalisationModel &&
((LocalisationModel)t).UniqueID == container.IdentifierID).Any())
{
return;
}
LocalisationModel newModel = new LocalisationModel(container.IdentifierID);
TabsModelList.Add(newModel);
RaisePropertyChanged("TabsModelList");
}
if (msg.Notification == "SaveProject")
{
saveProject();
}
if (msg.Notification == "RefreshProjectViewer")
{
TabsModelList.Clear();
RaisePropertyChanged("TabsModelList");
}
if (msg.Notification == "SendDeleteItemSignal")
{
ObservableObject Model = null;
if (msg.Sender is FociGridContainer)
{
Model = TabsModelList.FirstOrDefault((m) => m is FocusGridModel &&
((FocusGridModel)m).UniqueID == ((FociGridContainer)msg.Sender).IdentifierID);
}
else if (msg.Sender is LocalisationContainer)
{
Model = TabsModelList.FirstOrDefault((m) => m is LocalisationModel &&
((LocalisationModel)m).UniqueID == ((LocalisationContainer)msg.Sender).IdentifierID);
}
TabsModelList.Remove(Model);
RaisePropertyChanged("TabsModelList");
}
}
private void FocusGrid_OnKeyUp(object sender, KeyEventArgs e)
{
if ((!IsShown || e.SystemKey != Key.LeftAlt) && e.SystemKey != Key.RightAlt)
{
return;
}
IsShown = false;
FocusGridModel model = (FocusGridModel)DataContext;
model.ShowHidePositionLinesCommand.Execute(this);
}
private FocusGridModel TestScriptToTree()
{
//Act
FocusGridModel model = FocusTreeParser.CreateTreeFromScript("usa.txt", File.ReadAllText("usa.txt"));
//Assert
Assert.IsNotNull(model);
Assert.IsTrue(model.FociList.Any());
Assert.AreEqual(model.TAG, "USA");
Assert.AreEqual(model.VisibleName, "usa_focus");
return(model);
}
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;
}
private void AddElement()
{
FileManager dialog = new FileManager(ModeType.Create);
dialog.ShowDialog();
ObservableObject File = (new ViewModelLocator()).FileManager.File;
if (File == null)
{
return;
}
UndoService.Current[GetUndoRoot()].BeginChangeSetBatch("AddAnyFile", false);
FocusGridModel file = File as FocusGridModel;
if (file != null)
{
ProjectModel project = new ViewModelLocator().Main.Project;
project.fociList.Add(file);
RaisePropertyChanged(() => project.fociList);
}
else if (File is LocalisationModel)
{
ProjectModel project = new ViewModelLocator().Main.Project;
project.localisationList.Add((LocalisationModel)File);
//Check if first, if yes, set as default
if (project.DefaultLocale == null)
{
project.DefaultLocale = (LocalisationModel)File;
}
RaisePropertyChanged(() => project.localisationList);
}
else if (File is EventTabModel)
{
ProjectModel project = new ViewModelLocator().Main.Project;
project.eventList.Add((EventTabModel)File);
RaisePropertyChanged(() => project.eventList);
}
else if (File is ScriptModel)
{
ProjectModel project = new ViewModelLocator().Main.Project;
project.scriptList.Add((ScriptModel)File);
RaisePropertyChanged(() => project.scriptList);
}
UndoService.Current[GetUndoRoot()].EndChangeSetBatch();
}
protected override void OnRender(DrawingContext drawingContext)
{
Child.Children.Clear();
FocusGridModel DataContext = this.DataContext as FocusGridModel;
base.OnRender(drawingContext);
foreach (CanvasLine line in DataContext.CanvasLines)
{
Line newLine = new Line()
{
X1 = line.X1,
X2 = line.X2,
Y1 = line.Y1,
Y2 = line.Y2,
Visibility = System.Windows.Visibility.Visible,
StrokeThickness = 2,
Stroke = line.Color
};
if (line.Dashes)
{
newLine.StrokeDashArray = new DoubleCollection(new double[] { 2, 2 });
}
Child.Children.Add(newLine);
}
if (DataContext.selectedLine != null)
{
ResourceDictionary resourceLocalization = new ResourceDictionary();
resourceLocalization.Source = new Uri("/FocusTreeManager;component/Resources/Icons.xaml", UriKind.Relative);
Rectangle visualBoard = new Rectangle();
visualBoard.Width = 25;
visualBoard.Height = 25;
Canvas.SetLeft(visualBoard, Math.Min(DataContext.selectedLine.X1,
DataContext.selectedLine.X2) + (Math.Abs(DataContext.selectedLine.X2 -
DataContext.selectedLine.X1) / 2) - 12.5);
Canvas.SetTop(visualBoard, Math.Min(DataContext.selectedLine.Y1,
DataContext.selectedLine.Y2) + (Math.Abs(DataContext.selectedLine.Y2 -
DataContext.selectedLine.Y1) / 2) - 12.5);
VisualBrush vBrush = new VisualBrush();
vBrush.Visual = (Visual)resourceLocalization["appbar_scissor"];
visualBoard.Fill = vBrush;
Child.Children.Add(visualBoard);
}
}
private void FocusGrid_OnKeyDown(object sender, KeyEventArgs e)
{
if (!IsShown && (e.SystemKey == Key.LeftAlt || e.SystemKey == Key.RightAlt))
{
IsShown = true;
FocusGridModel model = (FocusGridModel)DataContext;
model.ShowHidePositionLinesCommand.Execute(this);
e.Handled = true;
}
else if (e.Key == Key.C && Keyboard.IsKeyDown(Key.LeftCtrl))
{
FocusGridModel model = (FocusGridModel)DataContext;
model.CopyCommand.Execute(null);
}
else if (e.Key == Key.V && Keyboard.IsKeyDown(Key.LeftCtrl))
{
FocusGridModel model = (FocusGridModel)DataContext;
model.PasteCommand.Execute(null);
}
}
private void TestTreeToScript(FocusGridModel model)
{
//Arrange
FociGridContainer container = new FociGridContainer(model);
List <FociGridContainer> list = new List <FociGridContainer> {
container
};
Script tester = new Script();
//Act
Dictionary <string, string> files = FocusTreeParser.ParseAllTrees(list);
string filecontent = files.FirstOrDefault().Value;
string fileName = files.FirstOrDefault().Key;
//Assert
Assert.IsNotNull(filecontent);
Assert.IsNotNull(fileName);
Assert.AreEqual(fileName, "usa_focus");
//Test if we can process the script
tester.Analyse(filecontent);
Assert.IsFalse(tester.Logger.hasErrors());
Assert.IsNotNull(tester.FindAssignation("tag"));
}
private void UIElement_OnMouseUp(object sender, MouseButtonEventArgs e)
{
if (!IsSelecting)
{
return;
}
// Release the mouse capture and stop tracking it.
IsSelecting = false;
SelectionGrid.ReleaseMouseCapture();
// Hide the drag selection box.
selectionBox.Visibility = Visibility.Collapsed;
Point mouseUpPos = e.GetPosition(SelectionGrid);
Rect selectedBoundaries = new Rect(mouseDownPos, mouseUpPos);
IEnumerable <Focus> selectedFoci = UiHelper.FindVisualChildren <Focus>(this)
.Where(f =>
{
Image firstOrDefault = UiHelper.FindChildWithName(f, "FocusIcon") as Image;
if (firstOrDefault == null)
{
return(false);
}
Point pos = firstOrDefault.TranslatePoint(new Point(0, 0), this);
return(selectedBoundaries
.Contains(new Point(pos.X + f.ActualWidth / 2,
pos.Y + f.ActualHeight / 2)));
});
FocusGridModel model = DataContext as FocusGridModel;
foreach (Focus focus in selectedFoci)
{
MouseEventArgs mouseLeaveEventArgs = new MouseEventArgs(Mouse.PrimaryDevice, 0)
{
RoutedEvent = Mouse.MouseLeaveEvent
};
focus.RaiseEvent(mouseLeaveEventArgs);
model?.SelectFocus(focus);
}
}
private void Focus_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
FocusGridModel model = DataContext as FocusGridModel;
if (model == null)
{
return;
}
if (e.ClickCount > 1 || model.ModeType != RelationMode.None)
{
return;
}
DraggedElement.Clear();
Focus element = sender as Focus;
if (element == null)
{
return;
}
anchorPoint = e.GetPosition(ListGrid);
IsDragging = true;
element.Cursor = ((TextBlock)Resources["CursorGrabbing"]).Cursor;
}
public void SetFileType(object param)
{
File = null;
ListViewItem item = param as ListViewItem;
if (item == null)
{
return;
}
switch (item.Tag as string)
{
case "FocusTreeItem":
File = new FocusGridModel("New file");
Messenger.Default.Send(new NotificationMessage(this,
new ViewModelLocator().Tutorial, "NewFocusTreeFile"));
break;
case "LocalisationItem":
File = new LocalisationModel("New file");
Messenger.Default.Send(new NotificationMessage(this,
new ViewModelLocator().Tutorial, "NewLocalizationFile"));
break;
case "EventItem":
File = new EventTabModel("New file");
Messenger.Default.Send(new NotificationMessage(this,
new ViewModelLocator().Tutorial, "NewEventFile"));
break;
case "GenericItem":
File = new ScriptModel("New file");
Messenger.Default.Send(new NotificationMessage(this,
new ViewModelLocator().Tutorial, "NewScriptFile"));
break;
}
}
protected override void OnRender(DrawingContext drawingContext)
{
Child.Children.Clear();
FocusGridModel context = DataContext as FocusGridModel;
base.OnRender(drawingContext);
if (context == null)
{
return;
}
foreach (CanvasLine line in context.CanvasLines)
{
Line newLine = new Line
{
X1 = line.X1,
X2 = line.X2,
Y1 = line.Y1,
Y2 = line.Y2,
Visibility = Visibility.Visible,
StrokeThickness = 2,
Stroke = line.Color
};
if (line.Dashes)
{
newLine.StrokeDashArray = new DoubleCollection(new double[] { 2, 2 });
}
Child.Children.Add(newLine);
}
if (context.selectedLine == null)
{
return;
}
ResourceDictionary resourceLocalization = new ResourceDictionary
{
Source = new Uri("/FocusTreeManager;component/Resources/Icons.xaml", UriKind.Relative)
};
Rectangle visualBoard = new Rectangle
{
Width = 25,
Height = 25
};
//Canvas.SetLeft(visualBoard, Math.Min(context.selectedLine.X1,
// context.selectedLine.X2) +
// Math.Abs(context.selectedLine.X2 -
// context.selectedLine.X1) / 2 - 12.5);
//Canvas.SetTop(visualBoard, Math.Min(context.selectedLine.Y1,
// context.selectedLine.Y2) +
// Math.Abs(context.selectedLine.Y2 -
// context.selectedLine.Y1) / 2 - 12.5);
Point Position = Mouse.GetPosition(this);
Canvas.SetTop(visualBoard, Position.Y);
Canvas.SetLeft(visualBoard, Position.X);
VisualBrush vBrush = new VisualBrush
{
Visual = (Visual)resourceLocalization["appbar_scissor"]
};
visualBoard.Fill = vBrush;
Child.Children.Add(visualBoard);
}
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 EditElement(object obj)
{
UndoService.Current[GetUndoRoot()].BeginChangeSetBatch("EditAnyFile", false);
FileManager dialog = new FileManager(ModeType.Edit);
if (obj is FocusGridModel)
{
FocusGridModel item = (FocusGridModel)obj;
new ViewModelLocator().FileManager.File = new FocusGridModel(item.VisibleName)
{
TAG = item.TAG,
AdditionnalMods = item.AdditionnalMods
};
dialog.ShowDialog();
if (new ViewModelLocator().FileManager.File == null)
{
return;
}
FocusGridModel newItem = new ViewModelLocator().FileManager.File as FocusGridModel;
if (newItem == null)
{
return;
}
item.VisibleName = newItem.VisibleName;
item.TAG = newItem.TAG;
item.AdditionnalMods = newItem.AdditionnalMods;
}
else if (obj is LocalisationModel)
{
LocalisationModel item = (LocalisationModel)obj;
new ViewModelLocator().FileManager.File = new LocalisationModel(item.VisibleName)
{
LanguageName = item.LanguageName
};
dialog.ShowDialog();
if (new ViewModelLocator().FileManager.File == null)
{
return;
}
LocalisationModel newItem = new ViewModelLocator().FileManager.File as LocalisationModel;
if (newItem == null)
{
return;
}
item.VisibleName = newItem.VisibleName;
item.LanguageName = newItem.LanguageName;
}
else if (obj is EventTabModel)
{
EventTabModel item = (EventTabModel)obj;
new ViewModelLocator().FileManager.File = new EventTabModel(item.VisibleName)
{
EventNamespace = item.EventNamespace
};
dialog.ShowDialog();
if (new ViewModelLocator().FileManager.File == null)
{
return;
}
EventTabModel newItem = (new ViewModelLocator()).FileManager.File as EventTabModel;
if (newItem == null)
{
return;
}
item.VisibleName = newItem.VisibleName;
item.EventNamespace = newItem.EventNamespace;
}
else if (obj is ScriptModel)
{
ScriptModel item = (ScriptModel)obj;
new ViewModelLocator().FileManager.File = new ScriptModel(item.VisibleName);
dialog.ShowDialog();
if (new ViewModelLocator().FileManager.File == null)
{
return;
}
ScriptModel newItem = new ViewModelLocator().FileManager.File as ScriptModel;
if (newItem != null)
{
item.VisibleName = newItem.VisibleName;
}
}
UndoService.Current[GetUndoRoot()].EndChangeSetBatch();
}
public LineAdorner(UIElement el, FocusGridModel DataContext) : base(el)
{
element = el as FrameworkElement;
this.DataContext = DataContext;
Children = new Canvas();
}
private void NotificationMessageReceived(NotificationMessage msg)
{
//If this is not the intended target
if (msg.Target != null && msg.Target != this)
{
return;
}
if (msg.Notification == "OpenFocusTree")
{
FocusGridModel container = msg.Sender as FocusGridModel;
if (TabsModelList.Contains(container))
{
return;
}
CheckForChanges(container);
TabsModelList.Add(container);
RaisePropertyChanged("TabsModelList");
}
if (msg.Notification == "OpenLocalisation")
{
LocalisationModel container = msg.Sender as LocalisationModel;
if (TabsModelList.Contains(container))
{
return;
}
CheckForChanges(container);
TabsModelList.Add(container);
RaisePropertyChanged("TabsModelList");
}
if (msg.Notification == "OpenEventList")
{
EventTabModel container = msg.Sender as EventTabModel;
if (TabsModelList.Contains(container))
{
return;
}
CheckForChanges(container);
TabsModelList.Add(container);
RaisePropertyChanged("TabsModelList");
}
if (msg.Notification == "OpenScriptList")
{
ScriptModel container = msg.Sender as ScriptModel;
if (TabsModelList.Contains(container))
{
return;
}
CheckForChanges(container);
TabsModelList.Add(container);
RaisePropertyChanged("TabsModelList");
}
if (msg.Notification == "SaveProject")
{
saveProject();
}
if (msg.Notification == "RefreshProjectViewer")
{
TabsModelList.Clear();
RaisePropertyChanged("TabsModelList");
}
if (msg.Notification == "SendDeleteItemSignal")
{
ObservableObject Model = null;
if (msg.Sender is FocusGridModel)
{
Model = TabsModelList.FirstOrDefault((m) => m is FocusGridModel &&
((FocusGridModel)m).UniqueID == ((FocusGridModel)msg.Sender).UniqueID);
}
else if (msg.Sender is LocalisationModel)
{
Model = TabsModelList.FirstOrDefault((m) => m is LocalisationModel &&
((LocalisationModel)m).UniqueID == ((LocalisationModel)msg.Sender).UniqueID);
}
else if (msg.Sender is EventTabModel)
{
Model = TabsModelList.FirstOrDefault((m) => m is EventTabModel &&
((EventTabModel)m).UniqueID == ((EventTabModel)msg.Sender).UniqueID);
}
else if (msg.Sender is ScriptModel)
{
Model = TabsModelList.FirstOrDefault((m) => m is ScriptModel &&
((ScriptModel)m).UniqueID == ((ScriptModel)msg.Sender).UniqueID);
}
TabsModelList.Remove(Model);
RaisePropertyChanged("TabsModelList");
}
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));
}
}
