Files
spark/src/client/spark/view/Shell/Workspaces/WorkspacesModel.cs
T

282 lines
11 KiB
C#

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.ComponentModel.Composition;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using mbts.config;
using mbts.ui.native;
using mbts.ui.settings;
using mbts.utils;
using ProtoBuf;
using mbts.persist;
namespace mbts.ui.shell
{
[Export]
public class WorkspacesModel : ViewModelBaseWithValidation
{
internal const string WORKSPACE_NAMESPACE = "workspace";
internal const string ACTIVE_WORKSPACE_PREFIX = "Where I left off on ";
public static string ACTIVE_WORKSPACE_NAME { get { return ACTIVE_WORKSPACE_PREFIX + Environment.MachineName; } }
private ISettingsCollector _settings_collector;
private ISavedWindowFactory _window_restore;
private IWindowManager _wm;
private IPersist _public;
private IPersist _private;
private ObservableCollection<IShellModule> _modules;
private bool _closing = false;
private ILauncher _launcher;
private IUndoActions _undo;
readonly IBookmarks _bookmarks;
[ImportingConstructor]
public WorkspacesModel(ISettingsCollector settings, ISavedWindowFactory window_restore,
IWindowManager windows, ObservableCollection<IShellModule> modules, IPersist persist, IBookmarks bm,
IUserPersist user_persist, ILauncher launcher, IUndoActions undo, [Import("workspace")]string initial_workspace) {
_settings_collector = settings;
_window_restore = window_restore;
_public = persist;
_private = user_persist;
_wm = windows;
_modules = modules;
_launcher = launcher;
_undo = undo;
_bookmarks = bm;
_launcher.closing += _launcher_closing;
Workspaces = new ObservableCollection<WorkspaceViewModel>();
init(initial_workspace).ignore();
}
public async Task init(string initial_workspace) {
// Load the named workspace if it exists
// If the named workspace is ACTIVE_WORKSPACE_NAME
// check the local disk before loading from the network in case there was an error saving
var my_workspaces = await _private.query<WorkspaceDefinition>(WORKSPACE_NAMESPACE, ".*");
my_workspaces = my_workspaces.Concat(await _public.query<WorkspaceDefinition>(WORKSPACE_NAMESPACE, ".*"));
Workspaces.AddRange(my_workspaces.Where(x => !x.key.StartsWith(ACTIVE_WORKSPACE_PREFIX)).Select(x => new WorkspaceViewModel(this, x.key, x.value)));
save_workspace_periodically();
var to_load = my_workspaces.SingleOrDefault(r => r.key == initial_workspace);
if (initial_workspace == ACTIVE_WORKSPACE_NAME) {
var localws = load_local_workspace();
if (localws != null) {
Logger.log(bts.log.Level.Info, bts.log.Subsystem.Ui, "Loading workspace from disk");
await load_workspace(localws, position_shell: true);
return;
}
}
if (to_load != null) {
Logger.log(bts.log.Level.Info, bts.log.Subsystem.Ui, "Loading initial workspace '{0}'".fmt(to_load.key));
// Only load the launcher position if this is a private workspace
await load_workspace(to_load.value, to_load.key, undo:false, position_shell: !to_load.value.is_shared);
}
else {
// Show launcher at default position
Logger.log(bts.log.Level.Info, bts.log.Subsystem.Ui, "Showing launcher without loading initial workspace.");
_launcher.set_position(null);
}
}
public async void save_workspace_periodically() {
TimeSpan interval = TimeSpan.FromSeconds(Configuration.get<bts.config.ShellSettingsConfig>().save_timer);
await Task.Delay(interval);
while (!_closing) {
var workspace = await get_workspace_async();
await _private.set(WORKSPACE_NAMESPACE, ACTIVE_WORKSPACE_NAME, workspace);
await Task.Delay(interval);
}
}
void _launcher_closing(CancelEventArgs obj) {
_closing = true;
var workspace = get_workspace();
var task = _private.set(WORKSPACE_NAMESPACE, ACTIVE_WORKSPACE_NAME, workspace);
_wm.clear();
task.Wait(TimeSpan.FromSeconds(90));
if (!task.IsCompleted) {
Logger.log(bts.log.Level.Error, bts.log.Subsystem.Ui, "Failed to save workspace during UI shutdown");
// The server is gone! Save the state to the local disk.
save_workspace_locally(workspace);
}
}
#region Static local save methods
private static string local_workspace_path() {
var system = Configuration.get<bts.config.System>();
return @"{0}/{1}/{2}".fmt(system.data_path, WORKSPACE_NAMESPACE, "recover_workspace");
}
private static void save_workspace_locally(WorkspaceDefinition workspace) {
string path = local_workspace_path();
try {
string directory = Path.GetDirectoryName(path);
Directory.CreateDirectory(directory);
using (var file = File.OpenWrite(path)) {
ProtoBuf.Serializer.SerializeWithLengthPrefix(file, workspace, PrefixStyle.Fixed32);
}
}
catch {
Logger.log(bts.log.Level.Error, bts.log.Subsystem.Ui, "The settings server is gone and I can't write to disk either. Shell is not having a good day.");
}
}
private static WorkspaceDefinition load_local_workspace() {
string path = local_workspace_path();
if (File.Exists(path)) {
WorkspaceDefinition def = null;
using (var file = File.OpenRead(path)) {
def = ProtoBuf.Serializer.DeserializeWithLengthPrefix<WorkspaceDefinition>(file, PrefixStyle.Fixed32);
}
File.Delete(path);
return def;
}
return null;
}
#endregion
// Collection of saved workspaces
public ObservableCollection<WorkspaceViewModel> Workspaces { get; private set; }
public event Action<string> WorkspaceLoaded;
WorkspaceDefinition get_workspace() {
WorkspaceDefinition workspace = new WorkspaceDefinition();
workspace.windows = _settings_collector.get_window_state().ToList();
workspace.modules = _settings_collector.get_module_state().ToList();
workspace.launcher_state = _settings_collector.get_launcher_state();
workspace.named_windows = _bookmarks.bookmarks.ToList();
return workspace;
}
async Task<WorkspaceDefinition> get_workspace_async() {
WorkspaceDefinition workspace = new WorkspaceDefinition();
workspace.windows = new List<WindowState>();
foreach (var w in _settings_collector.get_window_state()) {
workspace.windows.Add(w);
await Task.Yield();
}
workspace.modules = new List<ModuleState>();
foreach (var m in _settings_collector.get_module_state()) {
workspace.modules.Add(m);
await Task.Yield();
}
workspace.launcher_state = _settings_collector.get_launcher_state();
workspace.named_windows = _bookmarks.bookmarks.ToList();
return workspace;
}
public void save_workspace(string name, bool persist=true, bool ispublic=false) {
WorkspaceDefinition workspace = get_workspace();
workspace.is_shared = ispublic;
if (ispublic) { name += " (shared)"; }
// Remove the old one if a workspace by this name exists already
var old = Workspaces.SingleOrDefault(w => w.Name == name && ispublic == w.IsShared);
if (old != null) {
Workspaces.Remove(old);
}
Workspaces.Add(new WorkspaceViewModel(this, name, workspace));
if (persist) {
(ispublic ? _public : _private).set(WORKSPACE_NAMESPACE, name, workspace);
}
}
public async Task load_workspace(WorkspaceDefinition def, string name="", bool undo=true, bool position_shell=false) {
Logger.assert(def != null);
if (undo && !string.IsNullOrEmpty(name)) {
var current_workspace = await get_workspace_async();
_undo.push("Undo Load workspace '{0}'".fmt(name), async () => {
await load_workspace(current_workspace);
});
}
// Close all windows
_wm.clear();
if (position_shell) {
_launcher.set_position(def.launcher_state);
}
// Load the new workspace
if (def.modules != null) {
foreach (var settings in def.modules) {
if (settings.app_data.Length > 0) {
var module = _modules.OfType<IPersistShellModule>().SingleOrDefault(m => m.key() == settings.name);
if (module != null) {
module.load_state(new MemoryStream(settings.app_data));
}
}
}
}
if (def.windows != null) {
foreach (var window in def.windows) {
var new_shell_window = await _window_restore.restore(window);
// user can close the launcher from the taskbar while a workspace is loading
if (_closing) {
return;
} else if (new_shell_window != null) {
await _wm.add(new_shell_window);
}
}
}
_bookmarks.clear();
if (def.named_windows != null) {
foreach (var window in def.named_windows) {
_bookmarks.save_bookmark(window);
}
}
// Notify workspace changed
WorkspaceLoaded?.Invoke(name);
}
public Task delete_workspace(string name, WorkspaceDefinition def) {
var to_remove = Workspaces.SingleOrDefault(x => x.Name == name && x.IsShared == def.is_shared);
if (to_remove != null) {
Logger.assert_d(def == null || to_remove.Definition == def);
Workspaces.Remove(to_remove);
_undo.push("Restore workspace: '{0}'".fmt(name), () => {
Workspaces.Add(new WorkspaceViewModel(this, name, def));
(def.is_shared ? _public : _private).set(WORKSPACE_NAMESPACE, name, def);
});
}
return (def.is_shared ? _public : _private).clear(WORKSPACE_NAMESPACE, name);
}
}
// The serialized data for the Workspace
[ProtoContract(Name = "WorkspaceDefinition")]
public class WorkspaceDefinition
{
[ProtoMember(2, IsRequired = false)]
public List<WindowState> windows { get; set; }
// named windows which are not currently open
[ProtoMember(3)]
public List<WindowState> named_windows { get; set; }
[ProtoMember(9, IsRequired = false)]
public List<ModuleState> modules { get; set; }
[ProtoMember(8, IsRequired = false)]
public WindowPosition launcher_state { get; set; }
[ProtoMember(10, IsRequired = false)]
public bool is_shared { get; set; }
}
}