protected void VisualGraphChange(object sender, GraphChangeArgs <TItem, TEdge> args)
{
var visitor = CreateVisitor(args.Graph, args.Item);
var sceneEvents = CreateSceneEvents();
visitor.GraphChangedVisit(sceneEvents.GraphChanged, sender, args);
}
public void GraphChangedVisit(Action <
object,
GraphChangeArgs <TSinkItem, TSinkEdge>,
TSinkItem, IGraphScene <TSinkItem, TSinkEdge>,
IGraphSceneDisplay <TSinkItem, TSinkEdge>
> visit, object sender, GraphChangeArgs <TSinkItem, TSinkEdge> args)
{
var eventType = args.EventType;
foreach (var sinkScene in SinkScenes)
{
var sinkGraph = sinkScene.Graph;
if (ContainsSinkOf(sinkGraph.RootSource(), BackItem) || eventType == GraphEventType.Add)
{
var sinkItem = SinkOf(sinkGraph, BackItem);
if (sinkItem == null)
{
continue;
}
var sinkDisplay = Mesh.Displays.FirstOrDefault(d => d != SourceDisplay && d.Data == sinkScene);
visit(sender, args, sinkItem, sinkScene, sinkDisplay);
}
}
}
public override void OnGraphChange(object sender, GraphChangeArgs <TItem, TEdge> args)
{
base.OnGraphChange(sender, args);
if (args.EventType == GraphEventType.Update)
{
this.Add(args.Item);
}
}
public void GraphChanged(
object sender,
GraphChangeArgs <IVisual, IVisualEdge> args,
IVisual sinkItem, IGraphScene <IVisual, IVisualEdge> sinkScene,
IGraphSceneDisplay <IVisual, IVisualEdge> sinkDisplay)
{
// everything is done in MeshBackHandler
return;
}
public override void OnGraphChange(object sender, GraphChangeArgs <IThing, ILink> args)
{
if (args.EventType == GraphEventType.Update)
{
var link = args.Item as ILink;
if (link != null)
{
AddMarker(link.Marker);
}
}
base.OnGraphChange(sender, args);
}
protected virtual void BackGraphChange(object sender, GraphChangeArgs <TSourceItem, TSourceEdge> args)
{
var graph = args.Graph;
var backItem = args.Item;
var eventType = args.EventType;
if (backItem == null)
{
return;
}
var change = Tuple.Create(graph, backItem, eventType);
if (graphChanging.Contains(change))
{
return;
}
try {
graphChanging.Add(change);
var displays = new HashSet <IGraphSceneDisplay <TSinkItem, TSinkEdge> > ();
var removeDependencies = false;
var senderAsSink = (sender as IGraph <TSinkItem, TSinkEdge>).RootSink();
var scenes = ScenesOfBackGraph(graph)
// leave alone the sender:
.Where(s => s.Graph.RootSink() != senderAsSink)
.ToArray();
Action <TSourceItem> visit = sourceItem => {
foreach (var scene in scenes)
{
var graphPair = scene.Graph.Source <TSinkItem, TSinkEdge, TSourceItem, TSourceEdge> ();
var sinkItem = default(TSinkItem);
if (eventType == GraphEventType.Add)
{
sinkItem = graphPair.Get(sourceItem);
if (sinkItem is TSinkEdge)
{
SceneEdgeAdd(scene, (TSinkEdge)sinkItem);
displays.Add(DisplayOf(scene));
}
continue;
}
if (graphPair.Count == 0 || !graphPair.Source2Sink.TryGetValue(sourceItem, out sinkItem))
{
continue;
}
var visible = scene.Contains(sinkItem);
if (eventType == GraphEventType.Remove)
{
if (removeDependencies)
{
if (visible &&
!scene.Requests
.OfType <DeleteCommand <TSinkItem, TSinkEdge> > ()
.Any(r => sinkItem.Equals(r.Subject)))
{
scene.RequestDelete(sinkItem, null);
}
if (visible)
{
displays.Add(DisplayOf(scene));
}
}
else
{
if (visible)
{
if (scene.Focused != null && scene.Focused.Equals(sinkItem))
{
scene.Focused = default(TSinkItem);
}
scene.Selected.Remove(sinkItem);
scene.Requests.Add(new RemoveBoundsCommand <TSinkItem, TSinkEdge> (sinkItem, scene));
scene.Graph.Twig(sinkItem).ForEach(e =>
scene.Requests.Add(new RemoveBoundsCommand <TSinkItem, TSinkEdge> (e, scene)));
displays.Add(DisplayOf(scene));
}
}
}
if (eventType == GraphEventType.Update)
{
if (backItem is TSourceEdge && sinkItem is TSinkEdge)
{
SceneEdgeChanged(graph, (TSourceEdge)backItem, scene, (TSinkEdge)sinkItem);
if (visible)
{
displays.Add(DisplayOf(scene));
}
}
else
{
graphPair.UpdateSink(sinkItem);
if (visible)
{
scene.Requests.Add(new LayoutCommand <TSinkItem> (sinkItem, LayoutActionType.Justify));
displays.Add(DisplayOf(scene));
}
}
}
}
};
if (eventType == GraphEventType.Remove)
{
try {
var dependencies = Registry.Pooled <GraphDepencencies <TSourceItem, TSourceEdge> > ();
removeDependencies = true;
dependencies.VisitItems(GraphCursor.Create(graph, backItem), visit, eventType);
} catch (Exception ex) {
Trace.TraceError(ex.Message);
} finally {
removeDependencies = false;
}
}
visit(backItem);
displays.Where(display => display != null)
.ForEach(display => {
display.Perform();
Xwt.Application.MainLoop.QueueExitAction(() => display.QueueDraw());
});
Action <TSourceItem> visitAfter = sourceItem => {
foreach (var scene in scenes)
{
var graphPair = scene.Graph.Source <TSinkItem, TSinkEdge, TSourceItem, TSourceEdge> ();
var sinkItem = default(TSinkItem);
if (graphPair.Count == 0 || !graphPair.Source2Sink.TryGetValue(sourceItem, out sinkItem))
{
continue;
}
var visible = scene.Contains(sinkItem);
if (eventType == GraphEventType.Remove)
{
SceneItemRemoveAfterDisplayUpdate(scene, sinkItem);
}
}
};
visitAfter(backItem);
Xwt.Application.MainLoop.DispatchPendingEvents();
} catch (Exception ex) {
Trace.TraceError(ex.Message);
} finally {
graphChanging.Remove(change);
}
}
