Synnefo » Pithos MS Client

#region

/* -----------------------------------------------------------------------

 * <copyright file="PreferencesViewModel.cs" company="GRNet">

 * 

 * Copyright 2011-2012 GRNET S.A. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or

 * without modification, are permitted provided that the following

 * conditions are met:

 *

 *   1. Redistributions of source code must retain the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer.

 *

 *   2. Redistributions in binary form must reproduce the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer in the documentation and/or other materials

 *      provided with the distribution.

 *

 *

 * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 *

 * The views and conclusions contained in the software and

 * documentation are those of the authors and should not be

 * interpreted as representing official policies, either expressed

 * or implied, of GRNET S.A.

 * </copyright>

 * -----------------------------------------------------------------------

 */

#endregion

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Collections.Specialized;

using System.ComponentModel.Composition;

using System.Diagnostics;

using System.IO;

using System.Net;

using System.Reflection;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Forms;

using Caliburn.Micro;

using Pithos.Client.WPF.Configuration;

using Pithos.Client.WPF.Properties;

using Pithos.Client.WPF.SelectiveSynch;

using Pithos.Client.WPF.Utils;

using Pithos.Core;

using Pithos.Core.Agents;

using Pithos.Interfaces;

using System;

using System.Linq;

using Pithos.Network;

using MessageBox = System.Windows.MessageBox;

using Screen = Caliburn.Micro.Screen;

namespace Pithos.Client.WPF.Preferences

{

    /// <summary>

    /// The preferences screen displays user and account settings and updates the PithosMonitor

    /// classes when account settings change.

    /// </summary>

    /// <remarks>

    /// The class is a single ViewModel for all Preferences tabs. It can be broken in separate

    /// ViewModels, one for each tab.

    /// </remarks>

    [Export, PartCreationPolicy(CreationPolicy.Shared)]

    public class PreferencesViewModel : Screen

    {

        private readonly IEventAggregator _events;

        //Logging in the Pithos client is provided by log4net

        private static readonly log4net.ILog Log =

            log4net.LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

        private PithosSettings _settings;

        public PithosSettings Settings

        {

            get { return _settings; }

            set

            {

                _settings = value;

                NotifyOfPropertyChange(() => Settings);

            }

        }

        private ObservableConcurrentCollection<AccountViewModel> _accounts;

        public ObservableConcurrentCollection<AccountViewModel> Accounts

        {

            get { return _accounts; }

            set

            {

                _accounts = value;

                NotifyOfPropertyChange(() => Accounts);

            }

        }

        public bool IsBusy

        {

            get { return _isBusy; }

            set

            {

                if (value.Equals(_isBusy)) return;

                _isBusy = value;

                NotifyOfPropertyChange(() => IsBusy);

            }

        }

        public bool StartOnSystemStartup { get; set; }

        public ShellViewModel Shell { get; set; }

        //ShellExtensionController _extensionController=new ShellExtensionController();

        [ImportingConstructor]

        public PreferencesViewModel(IWindowManager windowManager, IEventAggregator events, ShellViewModel shell,

                                    PithosSettings settings)

        {

            this.DisplayName = "Pithos+ Preferences";

            // ReSharper disable DoNotCallOverridableMethodsInConstructor

            //Caliburn.Micro uses DisplayName for the view's title

            DisplayName = "Pithos+ Preferences";

            // ReSharper restore DoNotCallOverridableMethodsInConstructor

            _windowManager = windowManager;

            _events = events;

            Shell = shell;

            Settings = settings;

            Accounts = new ObservableConcurrentCollection<AccountViewModel>();

            var startupPath = Environment.GetFolderPath(Environment.SpecialFolder.Startup);

            _shortcutPath = Path.Combine(startupPath, "Pithos.lnk");

            StartOnSystemStartup = File.Exists(_shortcutPath);

            //SelectedTab = currentTab;

        }

        protected override void OnViewLoaded(object view)

        {

            base.OnViewLoaded(view);

            Settings.Reload();

            Accounts.Clear();

            if (Settings.Accounts == null)

            {

                Settings.Accounts = new AccountsCollection();

                Settings.Save();

            }

            var accountVMs = from account in Settings.Accounts

                             select new AccountViewModel(account);

            Accounts.AddFromEnumerable(accountVMs);

            if (Accounts.Count > 0)

                CurrentAccount = Accounts.First();

        }

        private string _selectedTab = "General";

        public string SelectedTab

        {

            get { return _selectedTab; }

            set

            {

                _selectedTab = value ?? "GeneralTab";

                NotifyOfPropertyChange(() => SelectedTab);

                NotifyOfPropertyChange(() => AccountTabSelected);

            }

        }

        public bool AccountTabSelected

        {

            get { return _selectedTab == "AccountTab"; }

        }

        #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

        public int StartupDelay

        {

            get { return (int) Settings.StartupDelay.TotalMinutes; }

            set

            {

                if (value < 0)

                    throw new ArgumentOutOfRangeException("value",

                                                          Resources.

                                                              PreferencesViewModel_StartupDelay_Greater_or_equal_to_0);

                Settings.StartupDelay = TimeSpan.FromMinutes(value);

                NotifyOfPropertyChange(() => StartupDelay);

            }

        }

        #region Commands

        public bool CanSelectiveSyncFolders

        {

            get { return CurrentAccount != null && CurrentAccount.SelectiveSyncEnabled; }

        }

        public void SelectiveSyncFolders()

        {

            //var monitor = Shell.Monitors[CurrentAccount.AccountKey];

            var model = new SelectiveSynchViewModel(_events, CurrentAccount.Account, CurrentAccount.ApiKey, false);

            if (_windowManager.ShowDialog(model) == true)

            {

            }

        }

        /* private bool _networkTracing;

        public bool NetworkTracing

        {

            get { return _networkTracing; }

            set

            {

                _networkTracing = value;

            }

        }*/

        private DisposeGuard GetBusyGuard()

        {

            return new DisposeGuard(()=>IsBusy=true,()=>IsBusy=false);

        }

        public async Task RefreshApiKey()

        {

            //_events.Publish(new Notification { Title = "Authorization failed", Message = "Your API Key has probably expired. You will be directed to a page where you can renew it", Level = TraceLevel.Error });

            if (CurrentAccount == null)

                return;

            using (GetBusyGuard())

            {

                try

                {

                    var name = CurrentAccount.AccountName;

                    var loginUri = PithosAccount.GetLoginUri(CurrentAccount.ServerUrl);

                    var credentials = PithosAccount.RetrieveCredentials(loginUri.ToString(), name);

                    if (credentials == null)

                        return;

                    //The server will return credentials for a different account, not just the current account

                    //We need to find the correct account first

                    AccountViewModel account = null;

                    Guid token;

                    if (Guid.TryParse(name, out token))

                    {

                        account =

                            Accounts.First(

                                act =>

                                act.AccountName == credentials.UserName && act.ServerUrl == CurrentAccount.ServerUrl);

                    }

                    else

                    {

                        account =

                            Accounts.First(

                                act => act.AccountName == name && act.ServerUrl == CurrentAccount.ServerUrl);

                        account.AccountName = credentials.UserName;

                        account.DisplayName = name;

                        Shell.RemoveMonitor(account.ServerUrl, name);

                        CurrentAccount.AccountName = credentials.UserName;

                        CurrentAccount.DisplayName = name;

                        await Shell.MonitorAccount(account.Account);

                    }

                    account.ApiKey = credentials.Password;

                    account.IsExpired = false;

                    Settings.Save();

                    TaskEx.Delay(10000).ContinueWith(_ => Shell.MonitorAccount(account.Account));

                    NotifyOfPropertyChange(() => Accounts);

                }

                catch (AggregateException exc)

                {

                    string message = String.Format("API Key retrieval failed");

                    Log.Error(message, exc.InnerException);

                    _events.Publish(new Notification

                        {Title = "Authorization failed", Message = message, Level = TraceLevel.Error});

                }

                catch (Exception exc)

                {

                    string message = String.Format("API Key retrieval failed");

                    Log.Error(message, exc);

                    _events.Publish(new Notification

                        {Title = "Authorization failed", Message = message, Level = TraceLevel.Error});

                }

            }

        }

        public bool CanWipeAccount

        {

            get { return CurrentAccount != null 

                && Shell.Monitors.ContainsKey(CurrentAccount.AccountKey)

                && Shell.Monitors[CurrentAccount.AccountKey].CloudClient!=null;

            }

        }

        public async Task WipeAccount()

        {

            PithosMonitor aMonitor;

            if (Shell.Monitors.TryGetValue(CurrentAccount.AccountKey, out aMonitor))

            {

                if (aMonitor.CloudClient == null)

                {

                    Log.ErrorFormat("Tried to wipe account [{0}] before authenticating",CurrentAccount.AccountKey);

                    return;

                }

                var message = String.Format("You are about to wipe all data in the {0} account at {1}. Are you sure?",

                                            CurrentAccount.AccountName, CurrentAccount.ServerUrl);

                if (MessageBoxResult.Yes !=

                    MessageBox.Show(message, "Warning! Account data will be wiped", MessageBoxButton.YesNo,

                                    MessageBoxImage.Hand, MessageBoxResult.No))

                    return;

                using(GetBusyGuard())

                {

                   await aMonitor.CloudClient.WipeContainer("", new Uri("pithos", UriKind.Relative));

                    aMonitor.Stop();

                    await aMonitor.Start();

                    MessageBox.Show("Account wiped");

                }

            }

        }

        public void OpenLogPath()

        {

            Shell.OpenLogPath();

        }

        public void OpenLogConsole()

        {

            var logView = IoC.Get<LogConsole.LogConsoleViewModel>();

            _windowManager.ShowWindow(logView);

        }

        public async Task SaveChanges()

        {

            using (GetBusyGuard())

            {

                await DoSave();

                TryClose( /*true*/);

            }

        }

        public void RejectChanges()

        {

            Settings.Reload();

            TryClose( /*false*/);

        }

        public async Task ApplyChanges()

        {

            using (GetBusyGuard())

            {

                await DoSave();

            }

        }

        private async Task DoSave()

        {

            //SetStartupMode();            

            //Ensure we save the settings changes first

            foreach (var account in _accountsToRemove)

            {

                Settings.Accounts.Remove(account);

            }

            foreach (var account in _accountsToAdd)

            {

                Settings.Accounts.Add(account);

            }

            Settings.Save();

            try

            {

                foreach (var account in _accountsToRemove)

                {

                    Shell.RemoveMonitor(account.ServerUrl, account.AccountName);

                    Shell.RemoveAccountFromDatabase(account);

                }

                foreach (var account in Settings.Accounts)

                {

                    await Shell.MonitorAccount(account);

                }

                var poller = IoC.Get<PollAgent>();

                poller.SynchNow();

            }

            finally

            {

                _accountsToRemove.Clear();

                _accountsToAdd.Clear();

            }

            NotifyOfPropertyChange(() => Settings);

            if (IgnoreCertificateErrors)

                ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true;

            else

            {

                ServicePointManager.ServerCertificateValidationCallback = null;

            }

        }

        /*   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;

                var accountName = CurrentAccount.AccountName;

                var monitor = Shell.Monitors[accountName];

                monitor.Stop();

                Shell.Monitors.Remove(accountName);

                Directory.Move(Settings.PithosPath, newPath);

                Settings.PithosPath = newPath;

                Settings.Save();

                Shell.MonitorAccount(CurrentAccount);

                NotifyOfPropertyChange(() => Settings);                

            }

        }

*/

        private readonly List<AccountSettings> _accountsToAdd = new List<AccountSettings>();

        public async Task AddAccount()

        {

            var wizard = new AddAccountViewModel();

            if (_windowManager.ShowDialog(wizard) == true)

            {

                try

                {

                    string selectedPath = wizard.AccountPath;

                    var initialRootPath = wizard.ShouldCreateOkeanosFolder

                                              ? Path.Combine(selectedPath, "okeanos")

                                              : selectedPath;

                    var actualRootPath = initialRootPath;

                    if (wizard.ShouldCreateOkeanosFolder)

                    {

                        int attempt = 1;

                        while (Directory.Exists(actualRootPath) || File.Exists(actualRootPath))

                        {

                            actualRootPath = String.Format("{0} {1}", initialRootPath, attempt++);

                        }

                        Directory.CreateDirectory(actualRootPath);

                    }

                    var account =

                        Accounts.FirstOrDefault(

                            act => act.AccountName == wizard.AccountName && act.ServerUrl == wizard.CurrentServer);

                    if (account != null)

                    {

                        if (

                            MessageBox.Show("The account you specified already exists. Do you want to update it?",

                                            "The account exists") == MessageBoxResult.Yes)

                        {

                            account.ApiKey = wizard.Token;

                            account.IsExpired = false;

                            CurrentAccount = account;

                        }

                    }

                    else

                    {

                        var newAccount = new AccountSettings

                                             {

                                                 AccountName = wizard.AccountName,

                                                 ServerUrl = wizard.CurrentServer,

                                                 ApiKey = wizard.Token,

                                                 RootPath = actualRootPath,

                                                 IsActive = wizard.IsAccountActive,

                                             };

                        var client = new CloudFilesClient(newAccount.AccountName, newAccount.ApiKey)

                                         {

                                             AuthenticationUrl = newAccount.ServerUrl,

                                             UsePithos = true

                                         };

                        await client.Authenticate().ConfigureAwait(false);

                        Guid token;

                        if (Guid.TryParse(wizard.AccountName, out token))

                        {

                            newAccount.AccountToken = token;

                            newAccount.DisplayName = await client.ResolveName(token).ConfigureAwait(false);    

                        }

                        await InitializeSelectiveFolders(newAccount, client);

                        //TODO:Add the "pithos" container as a default selection                   

                        _accountsToAdd.Add(newAccount);

                        var accountVm = new AccountViewModel(newAccount);

                        (Accounts as IProducerConsumerCollection<AccountViewModel>).TryAdd(accountVm);

                        CurrentAccount = accountVm;

                    }

                    NotifyOfPropertyChange(() => Accounts);

                    NotifyOfPropertyChange(() => Settings);

                }

                catch (WebException exc)

                {

                    Log.ErrorFormat("[Add Account] Connectivity Error: {0}", exc);

                    MessageBox.Show("Unable to connect to Pithos. Please try again later", "Connectivity Error",

                                    MessageBoxButton.OK, MessageBoxImage.Exclamation);

                }

            }

        }

        private async Task InitializeSelectiveFolders(AccountSettings newAccount, CloudFilesClient client,

                                                      int retries = 3)

        {

            while (true)

            {

                try

                {

                    var containers = await client.ListContainers(newAccount.AccountName).ConfigureAwait(false);

                    var containerUris = from container in containers

                                        select String.Format(@"{0}/v1/{1}/{2}",

                                                             newAccount.ServerUrl, newAccount.AccountName,

                                                             container.Name);

                    lock (newAccount.SelectiveFolders)

                    {

                        newAccount.SelectiveFolders.AddRange(containerUris.ToArray());

                    }

                    var objectInfos = (from container in containers

                                       from dir in client.ListObjects(newAccount.AccountName, container.Name)

                                       where container.Name.ToString() != "trash"

                                       select dir).ToList();

                    var tree = objectInfos.ToTree();

                    var selected = (from root in tree

                                    from child in root

                                    select child.Uri.ToString()).ToArray();

                    lock (newAccount.SelectiveFolders)

                    {

                        newAccount.SelectiveFolders.AddRange(selected);

                    }

                    return;

                }

                catch (WebException)

                {

                    if (retries > 0)

                        retries--;

                    else

                        throw;

                }

            }

        }

/*

        public void AddPithosAccount()

       {

            var credentials=PithosAccount.RetrieveCredentials(null);

            if (credentials == null)

                return;

            var account = Settings.Accounts.FirstOrDefault(act => act.AccountName == credentials.UserName);

            var accountVM = new AccountViewModel(account);

            if (account == null)

            {

                account=new AccountSettings{

                    AccountName=credentials.UserName,

                    ApiKey=credentials.Password

                };

                Settings.Accounts.Add(account);

                accountVM = new AccountViewModel(account);

                (Accounts as IProducerConsumerCollection<AccountViewModel>).TryAdd(accountVM);

            }

            else

            {

                account.ApiKey=credentials.Password;

            }

            //SelectedAccountIndex= Settings.Accounts.IndexOf(account);

            CurrentAccount = accountVM;

            NotifyOfPropertyChange(() => Accounts);

            NotifyOfPropertyChange(()=>Settings);                       

       }

*/

        private readonly List<AccountSettings> _accountsToRemove = new List<AccountSettings>();

        public void RemoveAccount()

        {

            Accounts.TryRemove(CurrentAccount);

            _accountsToRemove.Add(CurrentAccount.Account);

            CurrentAccount = null;

            NotifyOfPropertyChange(() => Accounts);

            //NotifyOfPropertyChange("Settings.Accounts");

        }

        public bool CanRemoveAccount

        {

            get { return (CurrentAccount != null); }

        }

        public bool CanClearAccountCache

        {

            get { return (CurrentAccount != null); }

        }

        public void ClearAccountCache()

        {

            if (MessageBoxResult.Yes ==

                MessageBox.Show("You are about to delete all partially downloaded files from the account's cache.\n" +

                                " You will have to download all partially downloaded data again\n" +

                                "This change can not be undone\n\n" +

                                "Do you wish to delete all partially downloaded data?",

                                "Warning! Clearing account cache",

                                MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No))

            {

                var cachePath = Path.Combine(CurrentAccount.RootPath, FolderConstants.CacheFolder);

                var dir = new DirectoryInfo(cachePath);

                //The file may not exist if we just created the account

                if (!dir.Exists)

                    return;

                dir.EnumerateFiles().Apply(file => file.Delete());

                dir.EnumerateDirectories().Apply(folder => folder.Delete(true));

            }

        }

        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 bool DebugLoggingEnabled

        {

            get { return Settings.DebugLoggingEnabled; }

            set

            {

                Settings.DebugLoggingEnabled = value;

                NotifyOfPropertyChange(() => DebugLoggingEnabled);

            }

        }

        public bool IgnoreCertificateErrors

        {

            get { return Settings.IgnoreCertificateErrors; }

            set

            {

                Settings.IgnoreCertificateErrors = value;

                NotifyOfPropertyChange(() => IgnoreCertificateErrors);

            }

        }

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

                _selectedAccountIndex = value;

                NotifyOfPropertyChange(() => CurrentAccount);

                NotifyOfPropertyChange(() => CanRemoveAccount);

                NotifyOfPropertyChange(()=>SelectedAccountIndex);

            }

        }*/

        private AccountViewModel _currentAccount;

        private readonly IWindowManager _windowManager;

        private readonly string _shortcutPath;

        private bool _isBusy;

        public AccountViewModel CurrentAccount

        {

            get { return _currentAccount; }

            set

            {

                _currentAccount = value;

                if (_currentAccount != null)

                    _currentAccount.PropertyChanged += (o, e) => NotifyOfPropertyChange(() => CanSelectiveSyncFolders);

                NotifyOfPropertyChange(() => CurrentAccount);

                NotifyOfPropertyChange(() => CanRemoveAccount);

                NotifyOfPropertyChange(() => CanSelectiveSyncFolders);

                NotifyOfPropertyChange(() => CanMoveAccountFolder);

                NotifyOfPropertyChange(() => CanClearAccountCache);

                NotifyOfPropertyChange(() => CanWipeAccount);

            }

        }

/*

        public AccountSettings CurrentAccount

        {

            get {

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

                    return Settings.Accounts[SelectedAccountIndex];

                return null;

            }

        }

*/

        public bool CanMoveAccountFolder

        {

            get { return CurrentAccount != null; }

        }

        public async Task MoveAccountFolder()

        {

            using (var dlg = new FolderBrowserDialog())

            {

                var currentFolder = CurrentAccount.RootPath;

                dlg.SelectedPath = currentFolder;

                //Ask the user to select a folder

                //Note: We need a parent window here, which we retrieve with GetView            

                var view = (Window) GetView();

                if (DialogResult.OK != dlg.ShowDialog(new Wpf32Window(view)))

                    return;

                var newPath = dlg.SelectedPath;

                //Find the account's monitor and stop it

                PithosMonitor monitor;

                if (Shell.Monitors.TryGetValue(CurrentAccount.AccountKey, out monitor))

                {

                    //Problem: Doesn't stop the poll agent

                    monitor.Stop();

                    monitor.MoveRootFolder(newPath);

                }

                //Replace the old rootpath with the new

                CurrentAccount.RootPath = newPath;

                //TODO: This will save all settings changes. Too coarse grained, need to fix at a later date

                Settings.Save();

                //And start the monitor on the new RootPath            

                if (monitor != null)

                {

                    monitor.RootPath = newPath;

                    if (CurrentAccount.IsActive)

                        await Shell.StartMonitor(monitor);

                }

                else

                    await Shell.MonitorAccount(CurrentAccount.Account);

                //Finally, notify that the Settings, CurrentAccount have changed

                NotifyOfPropertyChange(() => CurrentAccount);

                NotifyOfPropertyChange(() => Settings);

            }

        }

    }

    public class DisposeGuard : IDisposable

    {

        private readonly System.Action _disposeCall;

        public DisposeGuard(System.Action start, System.Action dispose)

        {

            _disposeCall = dispose;

            start();

        }

        public void Dispose()

        {

            _disposeCall();

            GC.SuppressFinalize(this);

        }       

    }

}