Statistics
| Branch: | Revision:

root / trunk / Pithos.Client.WPF / Shell / ShellViewModel.cs @ 6aa29f4f

History | View | Annotate | Download (26.5 kB)

1
´╗┐using System.Collections.Concurrent;
2
using System.ComponentModel;
3
using System.ComponentModel.Composition;
4
using System.Diagnostics;
5
using System.Diagnostics.Contracts;
6
using System.IO;
7
using System.Net;
8
using System.Reflection;
9
using System.Runtime.InteropServices;
10
using System.ServiceModel;
11
using System.ServiceModel.Description;
12
using System.Threading.Tasks;
13
using System.Windows;
14
using Caliburn.Micro;
15
using Hardcodet.Wpf.TaskbarNotification;
16
using Pithos.Client.WPF.Configuration;
17
using Pithos.Client.WPF.FileProperties;
18
using Pithos.Client.WPF.Properties;
19
using Pithos.Client.WPF.SelectiveSynch;
20
using Pithos.Client.WPF.Services;
21
using Pithos.Client.WPF.Shell;
22
using Pithos.Core;
23
using Pithos.Interfaces;
24
using System;
25
using System.Collections.Generic;
26
using System.Linq;
27
using System.Text;
28
using Pithos.Network;
29
using StatusService = Pithos.Client.WPF.Services.StatusService;
30

    
31
namespace Pithos.Client.WPF {
32
    using System.ComponentModel.Composition;
33

    
34
    
35
	///<summary>
36
	/// The "shell" of the Pithos application displays the taskbar  icon, menu and notifications.
37
	/// The shell also hosts the status service called by shell extensions to retrieve file info
38
	///</summary>
39
	///<remarks>
40
	/// It is a strange "shell" as its main visible element is an icon instead of a window
41
	/// The shell subscribes to the following events:
42
	/// * Notification:  Raised by components that want to notify the user. Usually displayed in a balloon
43
	/// * SelectiveSynchChanges: Notifies that the user made changes to the selective synch folders for an account. Raised by the Selective Synch dialog. Located here because the monitors are here
44
	/// * ShowFilePropertiesEvent: Raised when a shell command requests the display of the file/container properties dialog
45
	///</remarks>		
46
	//TODO: CODE SMELL Why does the shell handle the SelectiveSynchChanges?
47
    [Export(typeof(IShell))]
48
    public class ShellViewModel : Screen, IStatusNotification, IShell,
49
        IHandle<Notification>, IHandle<SelectiveSynchChanges>, IHandle<ShowFilePropertiesEvent>
50
    {
51
		//The Status Checker provides the current synch state
52
		//TODO: Could we remove the status checker and use events in its place?
53
        private IStatusChecker _statusChecker;
54
        private IEventAggregator _events;
55

    
56
        public PithosSettings Settings { get; private set; }        
57

    
58
		
59
        private Dictionary<string, PithosMonitor> _monitors = new Dictionary<string, PithosMonitor>();
60
		///<summary>
61
		/// Dictionary of account monitors, keyed by account
62
		///</summary>
63
		///<remarks>
64
		/// One monitor class is created for each account. The Shell needs access to the monitors to execute start/stop/pause commands,
65
		/// retrieve account and boject info		
66
		///</remarks>
67
		// TODO: Does the Shell REALLY need access to the monitors? Could we achieve the same results with a better design?
68
		// TODO: The monitors should be internal to Pithos.Core, even though exposing them makes coding of the Object and Container windows easier
69
        public Dictionary<string, PithosMonitor> Monitors
70
        {
71
            get { return _monitors; }
72
        }
73

    
74

    
75
		///<summary>
76
		/// The status service is used by Shell extensions to retrieve file status information
77
		///</summary>
78
		//TODO: CODE SMELL! This is the shell! While hosting in the shell makes executing start/stop commands easier, it is still a smell
79
        private ServiceHost _statusService { get; set; }
80

    
81
		//Logging in the Pithos client is provided by log4net
82
        private static readonly log4net.ILog Log = log4net.LogManager.GetLogger("Pithos");
83

    
84
		///<summary>
85
		/// The Shell depends on MEF to provide implementations for windowManager, events, the status checker service and the settings
86
		///</summary>
87
		///<remarks>
88
		/// The PithosSettings class encapsulates the app's settings to abstract their storage mechanism (App settings, a database or registry)
89
		///</remarks>
90
        [ImportingConstructor]		
91
        public ShellViewModel(IWindowManager windowManager, IEventAggregator events, IStatusChecker statusChecker, PithosSettings settings)
92
        {
93
            try
94
            {
95

    
96
                _windowManager = windowManager;
97
				//CHECK: Caliburn doesn't need explicit command construction
98
                //OpenPithosFolderCommand = new PithosCommand(OpenPithosFolder);
99
                _statusChecker = statusChecker;
100
				//The event subst
101
                _events = events;
102
                _events.Subscribe(this);
103

    
104
                Settings = settings;
105

    
106
                StatusMessage = "In Synch";
107

    
108
                _accounts.CollectionChanged += (sender, e) =>
109
                                                   {
110
                                                       NotifyOfPropertyChange(() => OpenFolderCaption);
111
                                                       NotifyOfPropertyChange(() => HasAccounts);
112
                                                   };
113

    
114
            }
115
            catch (Exception exc)
116
            {
117
                Log.Error("Error while starting the ShellViewModel",exc);
118
                throw;
119
            }
120
        }
121

    
122

    
123
        protected override void OnActivate()
124
        {
125
            base.OnActivate();
126

    
127
            StartMonitoring();                    
128
        }
129

    
130

    
131
        private async Task StartMonitoring()
132
        {
133
            try
134
            {                
135
                foreach (var account in Settings.Accounts)
136
                {
137
                    await MonitorAccount(account);
138
                }
139
                _statusService = StatusService.Start();
140
            }
141
            catch (AggregateException exc)
142
            {
143
                exc.Handle(e =>
144
                {
145
                    Log.Error("Error while starting monitoring", e);
146
                    return true;
147
                });
148
                throw;
149
            }
150
        }
151

    
152
        protected override void OnDeactivate(bool close)
153
        {
154
            base.OnDeactivate(close);
155
            if (close)
156
            {
157
                StatusService.Stop(_statusService);
158
                _statusService = null;
159
            }
160
        }
161

    
162
        public Task MonitorAccount(AccountSettings account)
163
        {
164
            return Task.Factory.StartNew(() =>
165
            {                                                
166
                PithosMonitor monitor = null;
167
                var accountName = account.AccountName;
168

    
169
                if (_monitors.TryGetValue(accountName, out monitor))
170
                {
171
                    //If the account is active
172
                    if (account.IsActive)
173
                        //Start the monitor. It's OK to start an already started monitor,
174
                        //it will just ignore the call
175
                        monitor.Start();
176
                    else
177
                    {
178
                        //If the account is inactive
179
                        //Stop and remove the monitor
180
                        RemoveMonitor(accountName);
181
                    }
182
                    return;
183
                }
184

    
185
                //Create a new monitor/ Can't use MEF here, it would return a single instance for all monitors
186
                monitor = new PithosMonitor
187
                              {
188
                                  UserName = accountName,
189
                                  ApiKey = account.ApiKey,
190
                                  UsePithos = account.UsePithos,
191
                                  StatusNotification = this,
192
                                  RootPath = account.RootPath
193
                              };
194
                //PithosMonitor uses MEF so we need to resolve it
195
                IoC.BuildUp(monitor);
196

    
197
                var appSettings = Properties.Settings.Default;
198
                monitor.AuthenticationUrl = account.UsePithos
199
                                                ? appSettings.PithosAuthenticationUrl
200
                                                : appSettings.CloudfilesAuthenticationUrl;
201

    
202
                _monitors[accountName] = monitor;
203

    
204
                if (account.IsActive)
205
                {
206
                    //Don't start a monitor if it doesn't have an account and ApiKey
207
                    if (String.IsNullOrWhiteSpace(monitor.UserName) ||
208
                        String.IsNullOrWhiteSpace(monitor.ApiKey))
209
                        return;
210
                    StartMonitor(monitor);
211
                }
212
            });
213
        }
214

    
215

    
216
        protected override void OnViewLoaded(object view)
217
        {
218
            UpdateStatus();
219
            var window = (Window)view;            
220
            TaskEx.Delay(1000).ContinueWith(t => Execute.OnUIThread(window.Hide));
221
            base.OnViewLoaded(view);
222
        }
223

    
224

    
225
        #region Status Properties
226

    
227
        private string _statusMessage;
228
        public string StatusMessage
229
        {
230
            get { return _statusMessage; }
231
            set
232
            {
233
                _statusMessage = value;
234
                NotifyOfPropertyChange(() => StatusMessage);
235
            }
236
        }
237

    
238
        private readonly ObservableConcurrentCollection<AccountInfo> _accounts = new ObservableConcurrentCollection<AccountInfo>();
239
        public ObservableConcurrentCollection<AccountInfo> Accounts
240
        {
241
            get { return _accounts; }
242
        }
243

    
244
	    public bool HasAccounts
245
	    {
246
            get { return _accounts.Count > 0; }
247
	    }
248

    
249

    
250
        public string OpenFolderCaption
251
        {
252
            get
253
            {
254
                return (_accounts.Count == 0)
255
                        ? "No Accounts Defined"
256
                        : "Open Pithos Folder";
257
            }
258
        }
259

    
260
        private string _pauseSyncCaption="Pause Synching";
261
        public string PauseSyncCaption
262
        {
263
            get { return _pauseSyncCaption; }
264
            set
265
            {
266
                _pauseSyncCaption = value;
267
                NotifyOfPropertyChange(() => PauseSyncCaption);
268
            }
269
        }
270

    
271
        private readonly ObservableConcurrentCollection<FileEntry> _recentFiles = new ObservableConcurrentCollection<FileEntry>();
272
        public ObservableConcurrentCollection<FileEntry> RecentFiles
273
        {
274
            get { return _recentFiles; }
275
        }
276

    
277

    
278
        private string _statusIcon="../Images/Pithos.ico";
279
        public string StatusIcon
280
        {
281
            get { return _statusIcon; }
282
            set
283
            {
284
                //_statusIcon = value;
285
                NotifyOfPropertyChange(() => StatusIcon);
286
            }
287
        }
288

    
289
        #endregion
290

    
291
        #region Commands
292

    
293
        public void ShowPreferences()
294
        {
295
            Settings.Reload();
296
            var preferences = new PreferencesViewModel(_windowManager,_events, this,Settings);            
297
            _windowManager.ShowDialog(preferences);
298
            
299
        }
300

    
301
        public void AboutPithos()
302
        {
303
            var about = new AboutViewModel();
304
            _windowManager.ShowWindow(about);
305
        }
306

    
307
        public void SendFeedback()
308
        {
309
            var feedBack =  IoC.Get<FeedbackViewModel>();
310
            _windowManager.ShowWindow(feedBack);
311
        }
312

    
313
        //public PithosCommand OpenPithosFolderCommand { get; private set; }
314

    
315
        public void OpenPithosFolder()
316
        {
317
            var account = Settings.Accounts.FirstOrDefault(acc => acc.IsActive);
318
            if (account == null)
319
                return;
320
            Process.Start(account.RootPath);
321
        }
322

    
323
        public void OpenPithosFolder(AccountInfo account)
324
        {
325
            Process.Start(account.AccountPath);
326
        }
327

    
328
        
329
        public void GoToSite()
330
        {            
331
            var site = Properties.Settings.Default.PithosSite;
332
            Process.Start(site);            
333
        }
334

    
335
        public void GoToSite(AccountInfo account)
336
        {
337
            var site = String.Format("{0}/ui/?token={1}&user={2}",
338
                Properties.Settings.Default.PithosSite,account.Token,
339
                account.UserName);
340
            Process.Start(site);
341
        }
342

    
343
        public void ShowFileProperties()
344
        {
345
            var account = Settings.Accounts.First(acc => acc.IsActive);            
346
            var dir = new DirectoryInfo(account.RootPath + @"\pithos");
347
            var files=dir.GetFiles();
348
            var r=new Random();
349
            var idx=r.Next(0, files.Length);
350
            ShowFileProperties(files[idx].FullName);            
351
        }
352

    
353
        public void ShowFileProperties(string filePath)
354
        {
355
            if (String.IsNullOrWhiteSpace(filePath))
356
                throw new ArgumentNullException("filePath");
357
            if (!File.Exists(filePath))
358
                throw new ArgumentException(String.Format("Non existent file {0}",filePath),"filePath");
359
            Contract.EndContractBlock();
360

    
361
            var pair=(from monitor in  Monitors
362
                               where filePath.StartsWith(monitor.Value.RootPath, StringComparison.InvariantCultureIgnoreCase)
363
                                   select monitor).FirstOrDefault();
364
            var account = pair.Key;
365
            var accountMonitor = pair.Value;
366

    
367
            if (accountMonitor == null)
368
                return;
369

    
370
            var infoTask=Task.Factory.StartNew(()=>accountMonitor.GetObjectInfo(filePath));
371

    
372
            
373

    
374
            var fileProperties = new FilePropertiesViewModel(this, infoTask,filePath);
375
            _windowManager.ShowWindow(fileProperties);
376
        } 
377
        
378
        public void ShowContainerProperties()
379
        {
380
            var account = Settings.Accounts.First(acc => acc.IsActive);            
381
            var dir = new DirectoryInfo(account.RootPath);
382
            var fullName = (from folder in dir.EnumerateDirectories()
383
                            where (folder.Attributes & FileAttributes.Hidden) == 0
384
                            select folder.FullName).First();
385
            ShowContainerProperties(fullName);            
386
        }
387

    
388
        public void ShowContainerProperties(string filePath)
389
        {
390
            if (String.IsNullOrWhiteSpace(filePath))
391
                throw new ArgumentNullException("filePath");
392
            if (!Directory.Exists(filePath))
393
                throw new ArgumentException(String.Format("Non existent file {0}",filePath),"filePath");
394
            Contract.EndContractBlock();
395

    
396
            var pair=(from monitor in  Monitors
397
                               where filePath.StartsWith(monitor.Value.RootPath, StringComparison.InvariantCultureIgnoreCase)
398
                                   select monitor).FirstOrDefault();
399
            var account = pair.Key;
400
            var accountMonitor = pair.Value;            
401
            var info = accountMonitor.GetContainerInfo(filePath);
402

    
403
            
404

    
405
            var containerProperties = new ContainerPropertiesViewModel(this, info,filePath);
406
            _windowManager.ShowWindow(containerProperties);
407
        }
408

    
409
        public ObjectInfo RefreshObjectInfo(ObjectInfo currentInfo)
410
        {
411
            if (currentInfo==null)
412
                throw new ArgumentNullException("currentInfo");
413
            Contract.EndContractBlock();
414

    
415
            var monitor = Monitors[currentInfo.Account];
416
            var newInfo=monitor.CloudClient.GetObjectInfo(currentInfo.Account, currentInfo.Container, currentInfo.Name);
417
            return newInfo;
418
        }
419

    
420
        public ContainerInfo RefreshContainerInfo(ContainerInfo container)
421
        {
422
            if (container == null)
423
                throw new ArgumentNullException("container");
424
            Contract.EndContractBlock();
425

    
426
            var monitor = Monitors[container.Account];
427
            var newInfo = monitor.CloudClient.GetContainerInfo(container.Account, container.Name);
428
            return newInfo;
429
        }
430

    
431

    
432
        public void ToggleSynching()
433
        {
434
            bool isPaused=false;
435
            foreach (var pair in Monitors)
436
            {
437
                var monitor = pair.Value;
438
                monitor.Pause = !monitor.Pause;
439
                isPaused = monitor.Pause;
440
            }
441

    
442
            PauseSyncCaption = isPaused ? "Resume syncing" : "Pause syncing";
443
            var iconKey = isPaused? "TraySyncPaused" : "TrayInSynch";
444
            StatusIcon = String.Format(@"../Images/{0}.ico", iconKey);
445
        }
446

    
447
        public void ExitPithos()
448
        {
449
            foreach (var pair in Monitors)
450
            {
451
                var monitor = pair.Value;
452
                monitor.Stop();
453
            }
454

    
455
            ((Window)GetView()).Close();
456
        }
457
        #endregion
458

    
459

    
460
        private Dictionary<PithosStatus, StatusInfo> iconNames = new List<StatusInfo>
461
            {
462
                new StatusInfo(PithosStatus.InSynch, "All files up to date", "TrayInSynch"),
463
                new StatusInfo(PithosStatus.Syncing, "Syncing Files", "TraySynching"),
464
                new StatusInfo(PithosStatus.SyncPaused, "Sync Paused", "TraySyncPaused")
465
            }.ToDictionary(s => s.Status);
466

    
467
        readonly IWindowManager _windowManager;
468

    
469

    
470
		///<summary>
471
		/// Updates the visual status indicators of the application depending on status changes, e.g. icon, stat		
472
		///</summary>
473
        public void UpdateStatus()
474
        {
475
            var pithosStatus = _statusChecker.GetPithosStatus();
476

    
477
            if (iconNames.ContainsKey(pithosStatus))
478
            {
479
                var info = iconNames[pithosStatus];
480
                StatusIcon = String.Format(@"../Images/{0}.ico", info.IconName);
481

    
482
                Assembly assembly = Assembly.GetExecutingAssembly();                               
483
                var fileVersion = FileVersionInfo.GetVersionInfo(assembly.Location);
484

    
485

    
486
                StatusMessage = String.Format("Pithos {0}\r\n{1}", fileVersion.FileVersion,info.StatusText);
487
            }
488
            
489
            _events.Publish(new Notification { Title = "Start", Message = "Start Monitoring", Level = TraceLevel.Info});
490
        }
491

    
492

    
493
       
494
        private Task StartMonitor(PithosMonitor monitor,int retries=0)
495
        {
496
            return Task.Factory.StartNew(() =>
497
            {
498
                using (log4net.ThreadContext.Stacks["Monitor"].Push("Start"))
499
                {
500
                    try
501
                    {
502
                        Log.InfoFormat("Start Monitoring {0}", monitor.UserName);
503

    
504
                        monitor.Start();
505
                    }
506
                    catch (WebException exc)
507
                    {
508
                        if (AbandonRetry(monitor, retries))
509
                            return;
510

    
511
                        if (IsUnauthorized(exc))
512
                        {
513
                            var message = String.Format("API Key Expired for {0}. Starting Renewal",monitor.UserName);                            
514
                            Log.Error(message,exc);
515
                            TryAuthorize(monitor,retries).Wait();
516
                        }
517
                        else
518
                        {
519
                            TryLater(monitor, exc,retries);
520
                        }
521
                    }
522
                    catch (Exception exc)
523
                    {
524
                        if (AbandonRetry(monitor, retries)) 
525
                            return;
526

    
527
                        TryLater(monitor,exc,retries);
528
                    }
529
                }
530
            });
531
        }
532

    
533
        private bool AbandonRetry(PithosMonitor monitor, int retries)
534
        {
535
            if (retries > 1)
536
            {
537
                var message = String.Format("Monitoring of account {0} has failed too many times. Will not retry",
538
                                            monitor.UserName);
539
                _events.Publish(new Notification
540
                                    {Title = "Account monitoring failed", Message = message, Level = TraceLevel.Error});
541
                return true;
542
            }
543
            return false;
544
        }
545

    
546

    
547
        private async Task TryAuthorize(PithosMonitor monitor,int retries)
548
        {
549
            _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 });
550

    
551
            try
552
            {
553

    
554
                var credentials = await PithosAccount.RetrieveCredentials(Settings.PithosLoginUrl);
555

    
556
                var account = Settings.Accounts.FirstOrDefault(act => act.AccountName == credentials.UserName);
557
                account.ApiKey = credentials.Password;
558
                monitor.ApiKey = credentials.Password;
559
                Settings.Save();
560
                await TaskEx.Delay(10000);
561
                StartMonitor(monitor, retries + 1);
562
                NotifyOfPropertyChange(()=>Accounts);
563
            }
564
            catch (AggregateException exc)
565
            {
566
                string message = String.Format("API Key retrieval for {0} failed", monitor.UserName);
567
                Log.Error(message, exc.InnerException);
568
                _events.Publish(new Notification { Title = "Authorization failed", Message = message, Level = TraceLevel.Error });
569
                return;
570
            }
571
            catch (Exception exc)
572
            {
573
                string message = String.Format("API Key retrieval for {0} failed", monitor.UserName);
574
                Log.Error(message, exc);
575
                _events.Publish(new Notification { Title = "Authorization failed", Message = message, Level = TraceLevel.Error });
576
                return;
577
                
578
            }
579

    
580
        }
581

    
582
        private static bool IsUnauthorized(WebException exc)
583
        {
584
            if (exc==null)
585
                throw new ArgumentNullException("exc");
586
            Contract.EndContractBlock();
587

    
588
            var response = exc.Response as HttpWebResponse;
589
            if (response == null)
590
                return false;
591
            return (response.StatusCode == HttpStatusCode.Unauthorized);
592
        }
593

    
594
        private void TryLater(PithosMonitor monitor, Exception exc,int retries)
595
        {
596
            var message = String.Format("An exception occured. Can't start monitoring\nWill retry in 10 seconds");
597
            Task.Factory.StartNewDelayed(10000, () => StartMonitor(monitor,retries+1));
598
            _events.Publish(new Notification
599
                                {Title = "Error", Message = message, Level = TraceLevel.Error});
600
            Log.Error(message, exc);
601
        }
602

    
603

    
604
        public void NotifyChange(string status, TraceLevel level=TraceLevel.Info)
605
        {
606
            this.StatusMessage = status;
607
            
608
            _events.Publish(new Notification { Title = "Pithos", Message = status, Level = level });
609
        }
610

    
611
        public void NotifyChangedFile(string filePath)
612
        {
613
            var entry = new FileEntry {FullPath=filePath};
614
            IProducerConsumerCollection<FileEntry> files=this.RecentFiles;
615
            FileEntry popped;
616
            while (files.Count > 5)
617
                files.TryTake(out popped);
618
            files.TryAdd(entry);
619
        }
620

    
621
        public void NotifyAccount(AccountInfo account)
622
        {
623
            if (account== null)
624
                return;
625

    
626
            account.SiteUri= String.Format("{0}/ui/?token={1}&user={2}",
627
                Properties.Settings.Default.PithosSite, account.Token,
628
                account.UserName);
629

    
630
            IProducerConsumerCollection<AccountInfo> accounts = Accounts;
631
            for (var i = 0; i < _accounts.Count; i++)
632
            {
633
                AccountInfo item;
634
                if (accounts.TryTake(out item))
635
                {
636
                    if (item.UserName!=account.UserName)
637
                    {
638
                        accounts.TryAdd(item);
639
                    }
640
                }
641
            }
642

    
643
            accounts.TryAdd(account);
644
        }
645

    
646

    
647
        public void RemoveMonitor(string accountName)
648
        {
649
            if (String.IsNullOrWhiteSpace(accountName))
650
                return;
651

    
652
            var accountInfo=_accounts.FirstOrDefault(account => account.UserName == accountName);
653
            _accounts.TryRemove(accountInfo);
654

    
655
            PithosMonitor monitor;
656
            if (Monitors.TryGetValue(accountName, out monitor))
657
            {
658
                Monitors.Remove(accountName);
659
                monitor.Stop();
660
            }
661
        }
662

    
663
        public void RefreshOverlays()
664
        {
665
            foreach (var pair in Monitors)
666
            {
667
                var monitor = pair.Value;
668

    
669
                var path = monitor.RootPath;
670

    
671
                if (String.IsNullOrWhiteSpace(path))
672
                    continue;
673

    
674
                if (!Directory.Exists(path) && !File.Exists(path))
675
                    continue;
676

    
677
                IntPtr pathPointer = Marshal.StringToCoTaskMemAuto(path);
678

    
679
                try
680
                {
681
                    NativeMethods.SHChangeNotify(HChangeNotifyEventID.SHCNE_UPDATEITEM,
682
                                                 HChangeNotifyFlags.SHCNF_PATHW | HChangeNotifyFlags.SHCNF_FLUSHNOWAIT,
683
                                                 pathPointer, IntPtr.Zero);
684
                }
685
                finally
686
                {
687
                    Marshal.FreeHGlobal(pathPointer);
688
                }
689
            }
690
        }
691

    
692
        #region Event Handlers
693
        
694
        public void Handle(SelectiveSynchChanges message)
695
        {
696
            var accountName = message.Account.AccountName;
697
            PithosMonitor monitor;
698
            if (_monitors.TryGetValue(accountName, out monitor))
699
            {
700
                monitor.AddSelectivePaths(message.Added);
701
                monitor.RemoveSelectivePaths(message.Removed);
702

    
703
            }
704
            
705
        }
706

    
707

    
708
        public void Handle(Notification notification)
709
        {
710
            if (!Settings.ShowDesktopNotifications)
711
                return;
712
            BalloonIcon icon = BalloonIcon.None;
713
            switch (notification.Level)
714
            {
715
                case TraceLevel.Error:
716
                    icon = BalloonIcon.Error;
717
                    break;
718
                case TraceLevel.Info:
719
                case TraceLevel.Verbose:
720
                    icon = BalloonIcon.Info;
721
                    break;
722
                case TraceLevel.Warning:
723
                    icon = BalloonIcon.Warning;
724
                    break;
725
                default:
726
                    icon = BalloonIcon.None;
727
                    break;
728
            }
729

    
730
            if (Settings.ShowDesktopNotifications)
731
            {
732
                var tv = (ShellView) this.GetView();
733
                tv.TaskbarView.ShowBalloonTip(notification.Title, notification.Message, icon);
734
            }
735
        }
736
        #endregion
737

    
738
        public void Handle(ShowFilePropertiesEvent message)
739
        {
740
            if (message == null)
741
                throw new ArgumentNullException("message");
742
            if (String.IsNullOrWhiteSpace(message.FileName) )
743
                throw new ArgumentException("message");
744
            Contract.EndContractBlock();
745

    
746
            var fileName = message.FileName;
747

    
748
            if (File.Exists(fileName))
749
                this.ShowFileProperties(fileName);
750
            else if (Directory.Exists(fileName))
751
                this.ShowContainerProperties(fileName);
752
        }
753
    }
754
}