public static AlignerOptions Options <TItem, TEdge> (this IGraphSceneLayout <TItem, TEdge> layout) where TEdge : IEdge <TItem>, TItem
{
var result = new AlignerOptions {
Dimension = layout.Dimension,
Distance = layout.Distance,
PointOrder = layout.Dimension == Dimension.X ? PointOrder.XY : PointOrder.YX,
};
if (layout.Dimension == Dimension.X)
{
result.AlignX = Alignment.Start;
result.AlignY = layout.Centered ? Alignment.Center : Alignment.Start;
}
else
{
result.AlignX = layout.Centered ? Alignment.Center : Alignment.Start;
result.AlignY = Alignment.Start;
}
if (layout.Dimension == Dimension.X)
{
result.PointOrderDelta = layout.StyleSheet.AutoSize.Width / 2;
}
else
{
result.PointOrderDelta = layout.StyleSheet.AutoSize.Height / 2;
}
return(result);
}
public void LoadSearch(IGraphScene <IVisual, IVisualEdge> scene, IGraphSceneLayout <IVisual, IVisualEdge> layout, object name)
{
var graph = scene.Graph.Source <IVisual, IVisualEdge, IThing, ILink>();
if (graph == null)
{
throw new ArgumentException("Search works only on ThingGraphs");
}
scene.CleanScene();
var visuals = scene.Graph.ThingGraph()
.Search(name, false)
.Select(t => graph.Get(t));
new GraphSceneFacade <IVisual, IVisualEdge>(() => scene, layout)
.Add(visuals, false, false);
var aligner = new Aligner <IVisual, IVisualEdge>(scene, layout);
aligner.FullLayout(null, new Point(layout.Border.Width, layout.Border.Height), layout.Options(), new VisualComparer());
aligner.Commit();
scene.ClearSpatialIndex();
}
protected SceneInfo SaveToThing(IGraphScene <IVisual, IVisualEdge> scene, IGraphSceneLayout <IVisual, IVisualEdge> layout, IThing thing, string name)
{
var result = default(SceneInfo);
if (thing is IStreamThing || thing == null)
{
var content = new Content <Stream> (
new MemoryStream(), CompressionType.bZip2, ContentTypes.LimadaSheet);
var serializer = new SheetSerializer();
serializer.Save(content.Data, scene.Graph, layout);
content.Data.Position = 0;
content.Description = name;
thing = new VisualThingsContentViz().AssignContent(scene.Graph, thing, content);
result = SheetStore.RegisterSceneInfo(thing.Id, name);
result.State.Hollow = false;
result.State.Clean = true;
result.State.CopyTo(scene.State);
}
else
{
throw new ArgumentException("thing must be a StreamThing");
}
return(result);
}
public ImageExporter(IGraphScene <IVisual, IVisualEdge> scene, IGraphSceneLayout <IVisual, IVisualEdge> layout)
: base()
{
this.Data = scene;
this.Layout = layout;
Compose();
}
public HedlessVisualsTextEditAction(Func <IGraphScene <IVisual, IVisualEdge> > func, Display <IGraphScene <IVisual, IVisualEdge> > display1, Drawing.ICamera camera, IGraphSceneLayout <IVisual, IVisualEdge> graphSceneLayout)
{
// TODO: Complete member initialization
this.func = func;
this.display1 = display1;
this.Camera = camera;
this.graphSceneLayout = graphSceneLayout;
}
public VisualsTextEditAction(
Func <IGraphScene <IVisual, IVisualEdge> > sceneHandler,
IDisplay display, ICamera camera,
IGraphSceneLayout <IVisual, IVisualEdge> layout)
: base(sceneHandler, display, camera, layout)
{
this.displayBackend = display.Backend as DisplayBackend;
}
public static IGraphSceneLayout <TItem, TEdge> CloneLayout <TItem, TEdge> (this IGraphScene <TItem, TEdge> scene, IGraphSceneLayout <TItem, TEdge> layout) where TEdge : TItem, IEdge <TItem>
{
IGraphSceneLayout <TItem, TEdge> result = null;
Func <IGraphScene <TItem, TEdge> > handler = () => scene;
result = Activator.CreateInstance(layout.GetType(), new object [] { handler, layout.StyleSheet }) as IGraphSceneLayout <TItem, TEdge>;
return(result);
}
protected override void SetEditorFromLayout(IGraphSceneLayout <IVisual, IVisualEdge> layout)
{
disableChanges = true;
this.Distance = layout.Distance;
this.Dimension = layout.Dimension;
this.Centered = layout.Centered;
this.LayoutBackColor = GdiConverter.ToGdi(layout.StyleSheet.BackColor);
disableChanges = false;
}
Stream SaveSheet(IGraphScene <IVisual, IVisualEdge> scene, IGraphSceneLayout <IVisual, IVisualEdge> layout)
{
var sheet = new SheetSerializer();
var s = new MemoryStream();
sheet.Save(s, scene.Graph, scene.CloneLayout(layout));
s.Position = 0;
return(s);
}
protected VisualsTextEditActionBase(
Func <IGraphScene <IVisual, IVisualEdge> > sceneHandler,
IDisplay display, ICamera camera,
IGraphSceneLayout <IVisual, IVisualEdge> layout) : this()
{
this.Display = display;
this.Camera = camera;
this._sceneHandler = sceneHandler;
this.Layout = layout;
}
public virtual void Save(Stream s, IGraph <IVisual, IVisualEdge> source, IGraphSceneLayout <IVisual, IVisualEdge> layout)
{
var graph = source.Source <IVisual, IVisualEdge, IThing, ILink> ();
if (graph != null)
{
var serializer = new VisualThingXmlSerializer {
VisualThingGraph = graph, Layout = layout, VisualsCollection = source
};
serializer.Write(s);
}
}
public bool SaveInStore(IGraphScene <IVisual, IVisualEdge> scene, IGraphSceneLayout <IVisual, IVisualEdge> layout, long id)
{
if (scene.Graph.Count > 0)
{
var stream = new MemoryStream();
new SheetSerializer().Save(stream, scene.Graph, layout);
stream.Position = 0;
SheetStore.Add(id, stream.GetBuffer((int)stream.Length));
return(true);
}
SheetStore.Remove(id);
return(false);
}
public override void Setup()
{
base.Setup();
if (Display != null)
{
oldlayout = Display.Layout;
Display.Layout = new EntityBenchmarkOneSceneFactory.LongtermPerformanceSceneLayout(
() => { return(Display.Data); }, Factory.styleSheet);
Display.StyleSheet = Factory.styleSheet;
}
Factory.Arrange(Display.Data);
Display.Data.ClearSpatialIndex();
Display.Reset();
IAction action = Display.ActionDispatcher.GetAction <IEditAction> ();
if (action != null)
{
editorEnabled = action.Enabled;
action.Enabled = false;
}
action = Display.ActionDispatcher.GetAction <GraphItemMoveResizeAction <IVisual, IVisualEdge> > ();
if (action != null)
{
action.Enabled = true;
}
action = Display.ActionDispatcher.GetAction <GraphEdgeChangeAction <IVisual, IVisualEdge> > ();
if (action != null)
{
action.Enabled = true;
}
// this is neccessary as the mouse cursor returns after a long time
// back to its position and activates VisualsTextEditor
action = Display.ActionDispatcher.GetAction <GraphItemAddAction <IVisual, IVisualEdge> > ();
action.Enabled = false;
action = Display.ActionDispatcher.GetAction <AddVisualEdgeAction> ();
action.Enabled = false;
Display.ActionDispatcher.Actions
.OfType <IDropAction> ()
.ForEach(a => a.Enabled = false);
}
void TestScene(IGraphScene <IVisual, IVisualEdge> scene, IGraphSceneLayout <IVisual, IVisualEdge> layout, Stream s)
{
scene.CleanScene();
var sheet = new SheetSerializer();
s.Position = 0;
sheet.Read(s, scene.Graph, scene.CloneLayout(layout));
var visualThingGraph = scene.Graph.Source <IVisual, IVisualEdge, IThing, ILink> ();
foreach (var visual in scene.Elements)
{
var thing = visualThingGraph.Get(visual);
Assert.IsNotNull(thing);
}
}
public void SaveInGraph(IGraphScene <IVisual, IVisualEdge> scene, IGraphSceneLayout <IVisual, IVisualEdge> layout, SceneInfo info)
{
var graph = GetThingGraph(scene);
var sheetThing = GetSheetThing(graph, info.Id);
var saved = SaveToThing(scene, layout, sheetThing, info.Name);
info.Id = saved.Id;
info.Name = saved.Name;
saved.State.CopyTo(info.State);
saved.State.CopyTo(scene.State);
var sheetVisual = scene.Graph.VisualOf(sheetThing);
if (sheetVisual != null)
{
//sheetVisual.Data = info.Name;
scene.Graph.DoChangeData(sheetVisual, info.Name);
scene.Graph.OnGraphChange(sheetVisual, GraphEventType.Update);
}
}
public static void SetOptions <TItem, TEdge> (this IGraphSceneLayout <TItem, TEdge> layout, AlignerOptions options) where TEdge : IEdge <TItem>, TItem
{
layout.Dimension = options.Dimension;
if (options.Distance.IsZero)
{
options.Distance = layout.Distance;
}
else
{
layout.Distance = options.Distance;
}
if (options.Dimension == Dimension.X)
{
layout.Centered = options.AlignX == Alignment.Center;
}
else
{
layout.Centered = options.AlignY == Alignment.Center;
}
}
public GraphSceneContextPainter(IGraphScene <TItem, TEdge> scene, IGraphSceneLayout <TItem, TEdge> layout)
: base()
{
this.Data = scene;
this.Layout = layout;
}
public ImageExporter(IGraphScene <IVisual, IVisualEdge> scene, IGraphSceneLayout <IVisual, IVisualEdge> layout)
{
this.Scene = scene;
this.Layout = layout;
}
internal PrintDocument CreatePrintDocument(IGraphScene <IVisual, IVisualEdge> graphScene,
IGraphSceneLayout <IVisual, IVisualEdge> graphSceneLayout)
{
throw new NotImplementedException();
}
public PrintDocument CreatePrintDocument(IGraphScene <IVisual, IVisualEdge> scene, IGraphSceneLayout <IVisual, IVisualEdge> layout)
{
this.painter = new ImageExporter(scene, layout);
painter.Viewport.ClipOrigin = scene.Shape.Location;
var doc = new PrintDocument();
doc.PrintPage += new PrintPageEventHandler(doc_PrintPage);
return(doc);
}
public virtual ICollection <IVisual> Read(Stream stream, IGraph <IVisual, IVisualEdge> source, IGraphSceneLayout <IVisual, IVisualEdge> layout)
{
var graph = source.Source <IVisual, IVisualEdge, IThing, ILink> ();
if (graph == null)
{
return(null);
}
var serializer = new VisualThingXmlSerializer {
VisualThingGraph = graph, Layout = layout
};
serializer.Read(stream);
return(serializer.VisualsCollection);
}
public static void AddVisual(this IGraphScene <IVisual, IVisualEdge> scene, IVisual visual, IGraphSceneLayout <IVisual, IVisualEdge> layout)
{
if (scene.Focused != null)
{
PlaceVisual(scene, scene.Focused, visual, layout);
}
else
{
AddItem(scene, visual, layout, scene.NoHit);
}
}
/// <summary>
/// adds a visual containing content to the scene
/// </summary>
/// <param name="scene"></param>
/// <param name="content"></param>
/// <param name="layout"></param>
public static void AddContent(this IGraphScene <IVisual, IVisualEdge> scene, Content <Stream> content, IGraphSceneLayout <IVisual, IVisualEdge> layout)
{
var visualOfContent = VisualContentViz.VisualOfContent(scene.Graph, content);
scene.AddVisual(visualOfContent, layout);
}
public VisualsDragDropAction(Func <IGraphScene <IVisual, IVisualEdge> > sceneHandler, IVidgetBackend backend, ICamera camera, IGraphSceneLayout <IVisual, IVisualEdge> layout)
: base(backend, camera)
{
this.SceneHandler = sceneHandler;
this.Layout = layout;
}
public GraphSceneContextPainter(IGraphScene <TItem, TEdge> scene, IGraphSceneLayout <TItem, TEdge> layout, IGraphItemRenderer <TItem, TEdge> itemRenderer)
: this(scene, layout)
{
this.GraphItemRenderer = itemRenderer;
Compose();
}
public static void CheckLayout <TItem, TEdge> (this IGraphScene <TItem, TEdge> scene, IGraphSceneLayout <TItem, TEdge> layout) where TEdge : TItem, IEdge <TItem>
{
if (scene != layout.Data)
{
throw new ArgumentException($"{nameof (layout)}.Data differs from {nameof (scene)}: {scene.GetHashCode ():X8} != {layout.Data.Graph.GetHashCode ():X8}");
}
}
public void EnsureShapes(IGraphSceneLayout <TSinkItem, TSinkEdge> layout)
{
Nodes.Where(n => n != null).ForEach(n => layout.Perform(n));
Edges.Where(n => n != null).ForEach(n => layout.Perform(n));
}
public static void AddItem(IGraphScene <IVisual, IVisualEdge> scene, IVisual item, IGraphSceneLayout <IVisual, IVisualEdge> layout, Point pt)
{
bool allowAdd = true;
if (scene == null)
{
return;
}
if (item is IVisualEdge)
{
var edge = (IVisualEdge)item;
allowAdd = scene.Contains(edge.Root) && scene.Contains(edge.Leaf);
}
if (allowAdd)
{
var facade = new GraphSceneFacade <IVisual, IVisualEdge>(() => scene, layout);
facade.Add(item, pt);
}
}
public VisualSceneContextPainter(IGraphScene <IVisual, IVisualEdge> scene, IGraphSceneLayout <IVisual, IVisualEdge> layout)
: base(scene, layout, new VisualsRenderer())
{
}
public static IVisual PlaceVisual(IGraphScene <IVisual, IVisualEdge> scene, IVisual root, IVisual visual, IGraphSceneLayout <IVisual, IVisualEdge> layout)
{
if (visual == null || scene == null)
{
return(visual);
}
var pt = (Point)layout.Border;
if (root != null)
{
pt = root.Shape [Anchor.LeftBottom];
}
AddItem(scene, visual, layout, pt);
CreateEdge(scene, root, visual);
return(visual);
}
