public virtual void Resume(IConceptUsecase usecase)
{
if (XmlUsecase == null || usecase.FavoriteManager == null)
{
return;
}
ComposeContentViewers();
Mesh.ClearDisplays();
var backHandler = Mesh.BackHandler <IThing, ILink>();
var backGraphs = backHandler.BackGraphs.ToArray();
var ser = new UsecaseXmlSerializer();
ser.Read(XmlUsecase, usecase);
var graphChanged = backGraphs.Distinct().Any();
// close others
foreach (var g in backHandler.BackGraphs
//.Where(g=>backGraphs.Contains(g)
.Select(g => new { iori = ThingMeshHelper.GetIori(g), graph = g })
.Where(g => g.iori == null || !ser.FileNames.Contains(g.iori.ToString()))
.Select(j => j.graph)
.ToArray())
{
backHandler.UnregisterBackGraph(g);
usecase.GraphSceneUiManager.SetContent(ThingMeshHelper.GetContent(g));
usecase.GraphSceneUiManager.Close();
}
if (graphChanged)
{
usecase.FavoriteManager.Clear();
usecase.SceneManager.Clear();
usecase.VisualsDisplayHistory.Clear();
foreach (var d in Mesh.Displays)
{
if (d.Info.Id != usecase.FavoriteManager.HomeId)
{
usecase.VisualsDisplayHistory.Store(d, usecase.SceneManager);
}
}
}
var thingGraph = backHandler.BackGraphs.FirstOrDefault() as IThingGraph;
if (thingGraph != null)
{
usecase.GraphSceneUiManager.SetContent(ThingMeshHelper.GetContent(thingGraph));
}
var focused = usecase.SplitView.Display1.Data.Focused;
usecase.SplitView.Display1.Data.FocusChanged?.Invoke(usecase.SplitView.Display1.Data, focused);
usecase.SplitView.Display1.OnSceneFocusChanged();
}
public virtual XElement Write(IConceptUsecase usecase)
{
var result = new XElement(NodeNames.Usecase);
result.Add(new MeshXmlSerializer().Write(Mesh));
var splitView = new XElement(NodeNames.SplitView);
var displays = new XElement(NodeNames.Displays);
Action <IGraphSceneDisplay <IVisual, IVisualEdge>, string> writeSplitDisplays = (d, n) => {
BeforeSave?.Invoke(d, n);
var display = new XElement(GraphSceneDisplayXmlSerializer.NodeNames.Display);
display.Add(Write(NodeNames.Name, n));
display.Add(Write(SceneInfoXmlSerializer.NodeNames.Id, d.DataId.ToString("X")));
displays.Add(display);
};
writeSplitDisplays(usecase.SplitView.Display1, NodeNames.SplitViewDisplay1);
writeSplitDisplays(usecase.SplitView.Display2, NodeNames.SplitViewDisplay2);
splitView.Add(displays);
result.Add(splitView);
var favorites = new XElement(NodeNames.Favorites);
favorites.Add(Write(NodeNames.HomeId, usecase.FavoriteManager.HomeId.ToString("X")));
result.Add(favorites);
return(result);
}
public void Save(IConceptUsecase usecase)
{
if (usecase.SplitView == null || usecase.GraphSceneUiManager == null)
{
return;
}
HomeId = usecase.FavoriteManager.HomeId;
var displays = Mesh.Displays;
usecase.VisualsDisplayHistory.SaveChanges(displays, usecase.SceneManager, false);
usecase.FavoriteManager.SaveChanges(displays);
usecase.GraphSceneUiManager.Save();
Save("SplitView.Display1", usecase.SplitView.Display1);
Save("SplitView.Display2", usecase.SplitView.Display2);
ClearContentViewers();
}
public virtual void Save(IConceptUsecase usecase)
{
if (usecase.SplitView == null || usecase.GraphSceneUiManager == null)
{
return;
}
var displays = Mesh.Displays;
usecase.VisualsDisplayHistory.SaveChanges(displays, usecase.SceneManager, false);
usecase.FavoriteManager.SaveChanges(displays);
usecase.GraphSceneUiManager.Save();
usecase.SplitView.ContentViewManager.SaveContentOfViewers();
XmlUsecase = new UsecaseXmlSerializer()
.Write(usecase);
StoreContentViewerTypes();
}
public void Resume(IConceptUsecase usecase)
{
if (SavedDisps == null || usecase.FavoriteManager == null)
{
return;
}
// there could be a resume without compose (only called in start)
if (Registry.Pooled <ContentViewerProvider> ().Viewers.Count() == 0)
{
ComposeContentViewers();
}
if (SavedDisps.Count > 0)
{
Restore("SplitView.Display1", usecase.SplitView.Display1);
Restore("SplitView.Display2", usecase.SplitView.Display2);
if (usecase.SplitView.CurrentDisplay != null && usecase.SplitView.CurrentDisplay.Data.Focused != null)
{
usecase.SplitView.CurrentDisplay.OnSceneFocusChanged();
}
}
usecase.FavoriteManager.HomeId = HomeId;
}
public virtual void Read(XElement node, IConceptUsecase usecase)
{
var ms = new MeshXmlSerializer();
ms.Read(node, Mesh);
FileNames = ms.FileNames;
var backHandler = Mesh.BackHandler <IThing, ILink> ();
var filesOpen = backHandler
.BackGraphs
.Select(g => new {
Iori = ThingMeshHelper.GetIori(g),
Graph = g
})
.Where(i => i.Iori != null)
.ToDictionary(k => k.Iori.ToString(), e => e.Graph);
foreach (var file in ms.FileNames)
{
var io = Registry.Pooled <ThingGraphIoPool> ().Find(Path.GetExtension(file), Limaki.Contents.IO.IoMode.Read)
as ThingGraphIo;
if (!filesOpen.ContainsKey(file))
{
try {
var content = io.Open(Iori.FromFileName(file));
var g = backHandler.WrapGraph(content.Data);
backHandler.RegisterBackGraph(g);
} catch (Exception e) {
}
}
}
var displays = ReadElement(ReadElement(node, NodeNames.SplitView), NodeNames.Displays);
foreach (var display in ReadElements(displays, GraphSceneDisplayXmlSerializer.NodeNames.Display))
{
var name = Read <string> (display, NodeNames.Name);
var id = Read <long> (display, SceneInfoXmlSerializer.NodeNames.Id);
var d = Mesh.Displays.Where(disp => disp.DataId == id).FirstOrDefault();
if (d == null)
{
var dm = ms.Displays.Where(disp => disp.Info.Id == id).FirstOrDefault();
if (name == NodeNames.SplitViewDisplay1 && dm != null)
{
dm.Restore(usecase.SplitView.Display1);
AfterRestore?.Invoke(d, name);
}
if (name == NodeNames.SplitViewDisplay2 && dm != null)
{
dm.Restore(usecase.SplitView.Display2);
AfterRestore?.Invoke(d, name);
}
}
}
var homeId = Read <long> (ReadElement(node, NodeNames.Favorites), NodeNames.HomeId);
usecase.FavoriteManager.HomeId = homeId;
}
