public async Task OpenGraphItFile(InputFileChangeEventArgs e, bool overwrite)
{
Overwrite = overwrite;
try
{
byte[] temp;
Options newOptions = new Options();
using (var streamReader = new MemoryStream())
{
await e.File.OpenReadStream().CopyToAsync(streamReader);
temp = streamReader.ToArray();
}
OpenPreference = false;
string graph = DecodeAndInflate(temp);
XmlDocument xmlData = new XmlDocument();
xmlData.LoadXml(graph);
if (Overwrite)
{
Graph = new Graph();
}
Traverse(xmlData, NodeService.NextId(Graph.Nodes), EdgeService.NextId(Graph.Edges));
await GraphChanged.InvokeAsync(Graph);
if (Overwrite)
{
await OptionsChanged.InvokeAsync(Options);
}
}
catch (ObjectDisposedException)
{
ErrorOpening = true;
}
}
public async Task Save()
{
Graph.Nodes.Clear();
Graph.Edges.Clear();
for (int i = PlayAlgorithm.Count - 1; i >= 0; i--)
{
foreach (GraphObject obj in PlayAlgorithm[i])
{
if (obj is Node)
{
Node newNode = new Node(obj as Node);
if (!Graph.Nodes.Contains(newNode))
{
Graph.Nodes.Add(newNode);
}
}
else
{
Edge newEdge = new Edge(obj as Edge);
if (!Graph.Edges.Contains(newEdge))
{
Graph.Edges.Add(newEdge);
}
}
}
}
foreach (Edge edge in Graph.Edges)
{
edge.Head = Graph.Nodes.First(n => edge.Head == n);
edge.Tail = Graph.Nodes.First(n => edge.Tail == n);
}
await GraphChanged.InvokeAsync(Graph);
await Reset();
}
private void OnGraphChanged(string propertyName)
{
var _ignoredProperties = new[] { nameof(MousePosition), nameof(FilePath), nameof(LastMouseDownPosition), nameof(MouseDownPort), nameof(LinkingLink), nameof(MouseUpPort) };
if (_ignoredProperties.Contains(propertyName))
{
return;
}
GraphChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
private void OnLayoutTypeChanged(ISceneNode node, Type newLayoutType)
{
if (node != rootComponent.Node)
{
throw new NotImplementedException();
}
var layout = layoutsByType[newLayoutType];
layouts[node] = layout;
RootLayoutInstance = layout.ArrangeAndDecorate(GlobalGraph);
GraphChanged?.Invoke();
}
public void AddEdge(int from, int to)
{
rootComponent.Edges.Add(new Pair <int>(from, to));
if (InsideTransaction)
{
return;
}
GlobalGraph = new StoryGraph(rootComponent.Node, GetEdges(), false);
RootLayoutInstance = layouts.Values.Single().ArrangeAndDecorate(GlobalGraph);
editSceneComponent.OnEdgeAdded(new Pair <int>(from, to), GlobalGraph);
GraphChanged?.Invoke();
}
public async Task CreateGraph()
{
Loading = true;
switch (WantedGraph)
{
case CommonGraph.Complete:
CreateComplete();
break;
case CommonGraph.CBipartite:
CreateCBipartite();
break;
case CommonGraph.Star:
CreateStar();
break;
case CommonGraph.Cyclic:
if (numNodes > 2)
{
CreateCyclic();
}
else
{
ErrorCreatingGraph = "For a cyclic graph you need at least 3 nodes (assuming simple graph)";
}
break;
case CommonGraph.RBipartite:
if (numNodes % 2 == 0 && KValue <= numNodes / 2)
{
CreateRBipartite();
}
else
{
ErrorCreatingGraph = "k-Regular Bipartite graph must satisfy: Even number of nodes AND K is at most half the number of nodes";
}
break;
case CommonGraph.Tree:
CreateTree();
break;
}
WantedGraph = null;
Loading = false;
await GraphChanged.InvokeAsync(Graph);
}
public async Task Paste()
{
int nextNodeId = NodeService.NextId(Graph.Nodes);
PasteOffset += 5 * SVGControl.Scale;
ActiveGraph = new Graph();
foreach (Node node in CopiedGraph.Nodes)
{
ActiveGraph.Nodes.Add(NodeService.AddNode(Graph.Nodes, node, nextNodeId, PasteOffset));
}
foreach (Edge edge in CopiedGraph.Edges)
{
ActiveGraph.Edges.Add(EdgeService.AddEdge(Graph, edge, nextNodeId));
}
await GraphChanged.InvokeAsync(Graph);
await ActiveGraphChanged.InvokeAsync(ActiveGraph);
}
private void OnStoryNodeAdded(ISceneNode parent, ISceneNode newNode)
{
var layoutRoot = SearchLayoutRoot(newNode);
if (layoutRoot == newNode)
{
throw new NotImplementedException();
//var layoutType = newNode.GetAspect<IStoryAspect>().StartLayoutType;
//var layout = layoutsByType[layoutType];
//layouts[newNode] = layout;
//var sg = new StoryGraph(newNode, );
//layout.ArrangeAndDecorate();
}
GlobalGraph = new StoryGraph(rootComponent.Node, GetEdges(), false);
editSceneComponent.OnStoryNodeAdded(parent, newNode, GlobalGraph);
RootLayoutInstance = layouts[rootComponent.Node].ArrangeAndDecorate(GlobalGraph);
GraphChanged?.Invoke();
}
private void OnStoryNodeRemoved(ISceneNode parent, ISceneNode removedNode)
{
var layoutRoot = SearchLayoutRoot(removedNode);
if (layoutRoot == removedNode)
{
throw new NotImplementedException();
//var layoutType = newNode.GetAspect<IStoryAspect>().StartLayoutType;
//var layout = layoutsByType[layoutType];
//layouts[newNode] = layout;
//var sg = new StoryGraph(newNode, );
//layout.ArrangeAndDecorate();
}
var removedIds = removedNode.GetComponent <IStoryComponent>().EnumerateStoryAspectsDeep(false).Select(x => x.Node.Id).ToArray();
rootComponent.Edges.RemoveWhere(x => removedIds.Contains(x.First) || removedIds.Contains(x.Second));
GlobalGraph = new StoryGraph(rootComponent.Node, GetEdges(), false);
editSceneComponent.OnStoryNodeRemoved(parent, removedNode, GlobalGraph);
RootLayoutInstance = layouts[rootComponent.Node].ArrangeAndDecorate(GlobalGraph);
GraphChanged?.Invoke();
}
public async Task OnChangeText(ChangeEventArgs e)
{
string input = e.Value.ToString();
double[,] weights = ParseInput(input);
if (ValidInput)
{
int difference = weights.GetLength(0) - Graph.Nodes.Count;
if (difference > 0)
{
for (int i = 1; i <= difference; i++)
{
NodeService.AddNode(Graph.Nodes, DefaultOptions, GetRandom(true), GetRandom(false));
}
}
else if (difference < 0)
{
for (int i = difference; i < 0; i++)
{
Graph.Nodes.RemoveAt(Graph.Nodes.Count + i);
}
}
Graph.Edges.Clear();
for (int i = 0; i < weights.GetLength(0); i++)
{
for (int j = 0; j < weights.GetLength(1); j++)
{
if (weights[i, j] != 0)
{
EdgeService.AddEdge(Graph.Edges, DefaultOptions, Graph.Nodes[j], Graph.Nodes[i], weights[i, j]);
}
}
}
await GraphChanged.InvokeAsync(Graph);
ShowText = GetText();
}
}
public async Task OnChangeTable(ChangeEventArgs e, Node tail, Node head)
{
double weight = Math.Round(double.Parse(e.Value.ToString()), 2);
if (weight > 0)
{
RemoveEdge(tail, head);
EdgeService.AddEdge(Graph.Edges, DefaultOptions, head, tail, weight);
}
else if (weight == 0)
{
foreach (Edge edge in Graph.Edges)
{
if ((edge.Head == head && edge.Tail == tail) ||
(edge.Head == tail && edge.Tail == head && !Graph.Directed))
{
Graph.Edges.Remove(edge);
break;
}
}
}
await GraphChanged.InvokeAsync(Graph);
}
private void OnWorldRootChanged(ISceneNode newRoot)
{
rootComponent = newRoot.SearchComponent <StoryServiceRootComponent>();
if (rootComponent == null)
{
rootComponent = AmFactory.Create <StoryServiceRootComponent>();
newRoot.Components.Add(rootComponent);
}
var rootNode = newRoot;
rootComponent = rootNode.SearchComponent <StoryServiceRootComponent>();
if (rootComponent == null)
{
rootComponent = AmFactory.Create <StoryServiceRootComponent>();
rootNode.Components.Add(rootComponent);
}
GlobalGraph = new StoryGraph(rootNode, GetEdges(), false);
layouts.Clear();
var aStory = rootNode.SearchComponent <IStoryComponent>();
if (aStory?.StartLayoutType == null)
{
throw new InvalidOperationException("Root SceneNode is expected to have a StoryAspect and be a LayoutRoot.");
}
var layout = layoutsByType[aStory.StartLayoutType];
layouts.Add(rootNode, layout);
// todo: sub-layouts
editSceneComponent.OnWorldRootChanged(newRoot, GlobalGraph);
var rootSg = new StoryGraph(newRoot, (IReadOnlyList <Pair <int> >)rootComponent.Edges, true);
RootLayoutInstance = layout.ArrangeAndDecorate(rootSg);
GraphChanged?.Invoke();
}
public async Task Select(MenuEventArgs <MenuItem> e)
{
switch (e.Item.Text)
{
case "Copy":
Copy();
break;
case "Paste":
await Paste();
break;
case "Left":
case "Center":
case "Right":
case "Top":
case "Middle":
case "Bottom":
NodeService.Align(ActiveGraph.Nodes, e.Item.Text);
break;
case "Delete":
await DeleteActive.InvokeAsync("all");
break;
case "Edit":
case "Nodes":
case "Edges":
await ChangeMenu.InvokeAsync(NavChoice.Design);
break;
case "All Nodes":
await Activate("nodes");
break;
case "All Edges":
await Activate("edges");
break;
case "Everything":
await Activate("all");
break;
case "Insert Edge":
await InsertEdge();
break;
case "Insert Node":
NodeService.AddNode(Graph.Nodes, Options.Default, origin[0] * SVGControl.Scale + SVGControl.Xaxis, origin[1] * SVGControl.Scale + SVGControl.Yaxis);
await GraphChanged.InvokeAsync(Graph);
break;
case "Stop Algorithm":
if (StartAlgorithm.Done)
{
StartAlgorithm.Clear = true;
}
else
{
await Reset();
}
break;
case "Zoom In":
if (ZoomService.ZoomIn(SVGControl))
{
await SVGControlChanged.InvokeAsync(SVGControl);
}
break;
case "Zoom Out":
if (ZoomService.ZoomOut(SVGControl))
{
await SVGControlChanged.InvokeAsync(SVGControl);
}
break;
}
}
protected virtual void OnGraphChanged(IEnumerable <HistoryPrice> prices)
{
GraphChanged?.Invoke(prices);
}
protected void InvokeChanged(IReadOnlyList <TNode> addedNodes = null, IReadOnlyList <TNode> removedNodes = null, IReadOnlyList <TConnection> addedConnections = null, IReadOnlyList <TConnection> removedConnections = null)
{
GraphChanged?.Invoke(addedNodes ?? _emptyNodes, removedNodes ?? _emptyNodes, addedConnections ?? _emptyConnections, removedConnections ?? _emptyConnections);
}
public async Task OnTableDelete(Node node)
{
NodeService.DeleteNode(Graph, node);
await GraphChanged.InvokeAsync(Graph);
}
protected void OnGraphChanged() => GraphChanged?.Invoke();
