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.Linq.Expressions;

using System.Net;

using System.Reflection;

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

    {

        public IPithosSettings Settings { get; set; }

        public PithosMonitor Monitor { get; private set; }

        public TaskbarViewModel Taskbar { get; set; }

        ShellExtensionController _extensionController=new ShellExtensionController();

        [ImportingConstructor]

        public PreferencesViewModel(TaskbarViewModel taskbar, IPithosSettings settings, PithosMonitor monitor)

        {

            DisplayName = "Pithos Preferences";

            Taskbar=taskbar;

            Taskbar.Parent = this;

            Settings=settings;

            Monitor=monitor;

            Taskbar.UsageMessage = "Using 15% of 50 GB";

            Taskbar.RecentFiles.AddRange(new[]

                                     {

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

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

                                     });

            Taskbar.StatusMessage = "In Synch";

            Taskbar.UpdateStatus();

        }

        protected override void OnViewAttached(object view, object context)

        {

            var window = (Window)view;

            base.OnViewAttached(view, context);

        }

        protected override void OnViewLoaded(object view)

        {

            var window = (Window)view;

            window.Hide();

            base.OnViewLoaded(view);

        }

        #region Preferences Properties

        private bool _noProxy;

        public bool NoProxy

        {

            get { return _noProxy; }

            set

            {

                _noProxy = value;

                NotifyOfPropertyChange(()=>NoProxy);

            }

        }

        private bool _defaultProxy;

        public bool DefaultProxy

        {

            get { return _defaultProxy; }

            set

            {

                _defaultProxy = value;

                NotifyOfPropertyChange(() => DefaultProxy);

            }

        }

        private bool _manualProxy;

        public bool ManualProxy

        {

            get { return _manualProxy; }

            set

            {

                _manualProxy = value;

                NotifyOfPropertyChange(() => ManualProxy);

            }

        }

        #endregion

        #region Commands

        public void SaveChanges()

        {

            DoSave();

        }

        public void RejectChanges()

        {

            Settings.Reload();

        }

        public void ApplyChanges()

        {

            DoSave();

        }

        private void DoSave()

        {

            Settings.Save();

            NotifyOfPropertyChange(()=>Settings);

            var activeAccount = Settings.Accounts.FirstOrDefault(account => account.IsActive);

            if (activeAccount == null)

                return;

            if (String.IsNullOrWhiteSpace(activeAccount.AccountName))

                return;

            Monitor.ApiKey = activeAccount.ApiKey;

            Monitor.UserName = activeAccount.AccountName;

            Monitor.UsePithos = activeAccount.UsePithos;

            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 AddAccount()

        {

            var newAccount = new AccountSettings();

            Settings.Accounts.Add(newAccount);

            SelectedAccountIndex= Settings.Accounts.Count-1;

            NotifyOfPropertyChange(()=>Settings);

        }

        public void RemoveAccount()

        {

            Settings.Accounts.RemoveAll(account => account.AccountName == CurrentAccount.AccountName);

            NotifyOfPropertyChange(()=>CurrentAccount);

            NotifyOfPropertyChange(()=>Settings);

            //NotifyOfPropertyChange("Settings.Accounts");

        }

        public bool CanRemoveAccount

        {

            get { return (CurrentAccount != null); }

        }

        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);

            }

        }

        public void RefreshOverlays()

        {

            this.Monitor.Workflow.RaiseChangeNotification(Settings.PithosPath);

        }

        #endregion

        private int _selectedAccountIndex;

        public int SelectedAccountIndex

        {

            get { return _selectedAccountIndex; }

            set

            {

                //var accountCount=Settings.Accounts.Count;

                //if (accountCount == 0)

                //    return;

                //if (0 <= value && value < accountCount)

                //    _selectedAccountIndex = value;

                //else

                //    _selectedAccountIndex = 0;

                NotifyOfPropertyChange(() => CurrentAccount);

                NotifyOfPropertyChange(() => CanRemoveAccount);

                NotifyOfPropertyChange(()=>SelectedAccountIndex);

            }

        }

        private AccountSettings _currentAccount;

        public AccountSettings CurrentAccount

        {

            get {

                if (0 <= SelectedAccountIndex && SelectedAccountIndex < Settings.Accounts.Count)                    

                    return Settings.Accounts[SelectedAccountIndex];

                return null;

            }

/*

            set

            {

                _currentAccount = value;

            }

*/

        }

    }

}