Synnefo » Pithos MS Client

// -----------------------------------------------------------------------

// <copyright file="PreferencesViewModel.cs" company="Microsoft">

// TODO: Update copyright text.

// </copyright>

// -----------------------------------------------------------------------

using System.Collections;

using System.ComponentModel.Composition;

using System.Diagnostics;

using System.IO;

using System.IO.IsolatedStorage;

using System.Runtime.Serialization;

using System.Windows;

using System.Windows.Forms;

using Caliburn.Micro;

using Pithos.Client.WPF.Configuration;

using Pithos.Core;

using Pithos.Interfaces;

using Pithos.ShellExtensions;

using Screen = Caliburn.Micro.Screen;

namespace Pithos.Client.WPF

{

    using System;

    using System.Collections.Generic;

    using System.Linq;

    using System.Text;

    /// <summary>

    /// TODO: Update summary.

    /// </summary>

    [Export(typeof(IShell))]

    public class PreferencesViewModel : Screen, IShell

    {

        private IStatusChecker _statusChecker;

        public IPithosSettings Settings { get; set; }

        public PithosMonitor Monitor { get; private set; }

        ShellExtensionController _extensionController=new ShellExtensionController();

        [ImportingConstructor]

        public PreferencesViewModel(IStatusChecker statusChecker, IPithosSettings settings, PithosMonitor monitor)

        {

            DisplayName = "Pithos Preferences";

            _statusChecker = statusChecker;

            Settings=settings;

            Monitor=monitor;

            OpenPithosFolderCommand=new PithosCommand(OpenPithosFolder);

            UsageMessage = "Using 15% of 50 GB";

            RecentFiles.AddRange(new[]

                                     {

                                      new FileEntry{FileName="Moo",FullPath=@"e:\Pithos\moo"}   ,

                                      new FileEntry{FileName="Mee",FullPath=@"e:\Pithos\mee"}   

                                     });

            StatusMessage = "In Synch";

            UpdateStatus();

        }

        protected override void OnViewAttached(object view, object context)

        {

            var window = (Window)view;

            window.WindowStartupLocation = WindowStartupLocation.CenterScreen;

            window.ShowInTaskbar = false;

            base.OnViewAttached(view, context);

        }

        protected override void OnViewLoaded(object view)

        {

            var window = (Window)view;

            window.Hide();

            base.OnViewLoaded(view);

        }

        #region Status Properties

        private string _statusMessage;

        public string StatusMessage

        {

            get { return _statusMessage; }

            set

            {

                _statusMessage = value;

                NotifyOfPropertyChange(() => StatusMessage);

            }

        }

        private string _usageMessage;

        public string UsageMessage

        {

            get { return _usageMessage; }

            set

            {

                _usageMessage = value;

                NotifyOfPropertyChange(() => UsageMessage);

            }

        }

        private readonly IObservableCollection<FileEntry> _recentFiles = new BindableCollection<FileEntry>();

        public IObservableCollection<FileEntry> RecentFiles

        {

            get { return _recentFiles; }

        }

        private string _statusIcon;

        public string StatusIcon

        {

            get { return _statusIcon; }

            set

            {

                _statusIcon = value;

                NotifyOfPropertyChange(()=>StatusIcon);

            }

        }

        #endregion

        //public PithosSettings Settings { get; set; }

        #region Commands

        public void ShowPreferences()

        {

            Settings.Reload();

            var window = (Window)this.GetView();

            window.Show();

        }

        public PithosCommand OpenPithosFolderCommand { get; private set; }

        public void OpenPithosFolder()

        {

            Process.Start(Settings.PithosPath);

        }

        public void GoToSite()

        {

        }

        public void ToggleSynching()

        {

        }

        public void SaveChanges()

        {

            DoSave();

            /*var window = (Window)GetView();

            window.Hide();*/

        }

        public void RejectChanges()

        {

            Settings.Reload();

           /* var window = (Window)GetView();

            window.Hide();*/

        }

        public void ApplyChanges()

        {

            DoSave();

        }

        private void DoSave()

        {

            Settings.Save();

            Monitor.Start();

        }

        public void ChangePithosFolder()

        {

            var browser = new FolderBrowserDialog();

            browser.SelectedPath = Settings.PithosPath;

            var result = browser.ShowDialog((IWin32Window)GetView());

            if (result == DialogResult.OK)

            {

                var newPath = browser.SelectedPath;

                Directory.Move(Settings.PithosPath, newPath);

                Settings.PithosPath = newPath;

                Settings.Save();

                NotifyOfPropertyChange(() => Settings);

            }

        }

        public void ExitPithos()

        {

            Monitor.Stop();

            this.TryClose();            

        }

        #endregion

        private AccountSettings _currentAccount;

        public AccountSettings CurrentAccount

        {

            get { return _currentAccount; }

            set

            {

                _currentAccount = value;

                NotifyOfPropertyChange(()=>CurrentAccount);

            }

        }

        private Dictionary<PithosStatus, StatusInfo> iconNames = new List<StatusInfo>

            {

                new StatusInfo(PithosStatus.InSynch, "All files up to date", "TrayInSynch"),

                new StatusInfo(PithosStatus.Synching, "Synching Files", "TraySynching")

            }.ToDictionary(s => s.Status);

        public void UpdateStatus()

        {

            var pithosStatus = _statusChecker.GetPithosStatus();

            if (iconNames.ContainsKey(pithosStatus))

            {

                var info = iconNames[pithosStatus];

                StatusIcon = String.Format(@"Images/{0}.ico",info.IconName);

                StatusMessage= String.Format("Pithos 1.0\r\n{0}", info.StatusText);                

            }

            if (!String.IsNullOrWhiteSpace(Settings.UserName) &&

                !String.IsNullOrWhiteSpace(Settings.ApiKey))

                Monitor.Start();

        }

        public bool ExtensionsActivated

        {

            get { return Settings.ExtensionsActivated; }

            set

            {

                if (Settings.ExtensionsActivated == value)

                    return;                

                Settings.ExtensionsActivated = value;

                if(value)

                    _extensionController.RegisterExtensions();

                else

                {

                    _extensionController.UnregisterExtensions();

                }

                NotifyOfPropertyChange(()=>ExtensionsActivated);

            }

        }

        /* private void UnregisterExtensions()

        {

            using (var installer = new ProjectInstaller())

            {

                IDictionary state = ShellExtensionController.LoadState();

                installer.Uninstall(state);

            }

        }

        private void RegisterExtensions()

        {

            using (var installer = new ProjectInstaller())

            {

                IDictionary state = new Dictionary<object, object>();

                installer.Install(state);

                ShellExtensionController.SaveState(state);

            }

        }*/

    }

}