Implemented WebRtcTransportAdapter.

Implemented FileSystem via WebRTC.
Improved FileSystemControl keyboard control.
Implemented FileSystemControl context menu.
Improved Transported custom request handler registration.
Implemented FS copy/move/delete.
Implemented InputBox.

1 files changed, 372 insertions, 8 deletions

diff --git a/Software/Visual_Studio/Tango.FileSystem/FileExplorerControl.cs b/Software/Visual_Studio/Tango.FileSystem/FileExplorerControl.cs
index 23cac7733..60061780b 100644
--- a/Software/Visual_Studio/Tango.FileSystem/FileExplorerControl.cs
+++ b/Software/Visual_Studio/Tango.FileSystem/FileExplorerControl.cs
@@ -16,6 +16,7 @@ using System.Windows.Media;
 using System.Windows.Media.Imaging;
 using System.Windows.Navigation;
 using System.Windows.Shapes;
+using Tango.Core.Commands;
 using Tango.Core.IO;
 
 namespace Tango.FileSystem
@@ -28,6 +29,41 @@ namespace Tango.FileSystem
         private Point _dragOutStartPoint;
         private bool _isMouseDown;
         private List<FileSystemItem> _selectedItemsBeforeDrag;
+        private List<FileSystemItem> _copyItems;
+        private bool _isCut;
+        private bool _isAfterContextMenu;
+
+        #region IsCut Attached Property
+
+        /// <summary>
+        /// Determines whether the draggable element is currently being dragged.
+        /// </summary>
+        public static readonly DependencyProperty IsCutProperty =
+            DependencyProperty.RegisterAttached("IsCut",
+            typeof(bool), typeof(FileExplorerControl),
+            new FrameworkPropertyMetadata(false));
+
+        /// <summary>
+        /// Sets the IsCut attached property.
+        /// </summary>
+        /// <param name="element">The element.</param>
+        /// <param name="value">if set to <c>true</c> [value].</param>
+        public static void SetIsCut(FrameworkElement element, bool value)
+        {
+            element.SetValue(IsCutProperty, value);
+        }
+
+        /// <summary>
+        /// Gets the is dragging attached property.
+        /// </summary>
+        /// <param name="element">The element.</param>
+        /// <returns></returns>
+        public static bool GetIsCut(FrameworkElement element)
+        {
+            return (bool)element.GetValue(IsCutProperty);
+        }
+
+        #endregion
 
         public IFileSystemContainer CurrentItem
         {
@@ -35,7 +71,7 @@ namespace Tango.FileSystem
             set { SetValue(CurrentItemProperty, value); }
         }
         public static readonly DependencyProperty CurrentItemProperty =
-            DependencyProperty.Register("CurrentItem", typeof(IFileSystemContainer), typeof(FileExplorerControl), new PropertyMetadata(null));
+            DependencyProperty.Register("CurrentItem", typeof(IFileSystemContainer), typeof(FileExplorerControl), new PropertyMetadata(null, (d, e) => (d as FileExplorerControl).OnCurrentItemChanged()));
 
         public FileSystemItem SelectedItem
         {
@@ -61,6 +97,14 @@ namespace Tango.FileSystem
         public static readonly DependencyProperty DeleteCommandProperty =
             DependencyProperty.Register("DeleteCommand", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
 
+        public ICommand DeleteCommandInternal
+        {
+            get { return (ICommand)GetValue(DeleteCommandInternalProperty); }
+            set { SetValue(DeleteCommandInternalProperty, value); }
+        }
+        public static readonly DependencyProperty DeleteCommandInternalProperty =
+            DependencyProperty.Register("DeleteCommandInternal", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
+
         public ICommand DropCommand
         {
             get { return (ICommand)GetValue(DropCommandProperty); }
@@ -77,6 +121,110 @@ namespace Tango.FileSystem
         public static readonly DependencyProperty DragCommandProperty =
             DependencyProperty.Register("DragCommand", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
 
+        public ICommand CopyCommand
+        {
+            get { return (ICommand)GetValue(CopyCommandProperty); }
+            set { SetValue(CopyCommandProperty, value); }
+        }
+        public static readonly DependencyProperty CopyCommandProperty =
+            DependencyProperty.Register("CopyCommand", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
+
+        public ICommand CutCommand
+        {
+            get { return (ICommand)GetValue(CutCommandProperty); }
+            set { SetValue(CutCommandProperty, value); }
+        }
+        public static readonly DependencyProperty CutCommandProperty =
+            DependencyProperty.Register("CutCommand", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
+
+        public ICommand CopyPasteCommand
+        {
+            get { return (ICommand)GetValue(CopyPasteCommandProperty); }
+            set { SetValue(CopyPasteCommandProperty, value); }
+        }
+        public static readonly DependencyProperty CopyPasteCommandProperty =
+            DependencyProperty.Register("CopyPasteCommand", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
+
+        public ICommand CutPasteCommand
+        {
+            get { return (ICommand)GetValue(CutPasteCommandProperty); }
+            set { SetValue(CutPasteCommandProperty, value); }
+        }
+        public static readonly DependencyProperty CutPasteCommandProperty =
+            DependencyProperty.Register("CutPasteCommand", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
+
+        public ICommand PasteCommandInternal
+        {
+            get { return (ICommand)GetValue(PasteCommandInternalProperty); }
+            set { SetValue(PasteCommandInternalProperty, value); }
+        }
+        public static readonly DependencyProperty PasteCommandInternalProperty =
+            DependencyProperty.Register("PasteCommandInternal", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
+
+        public ICommand SelectAllCommand
+        {
+            get { return (ICommand)GetValue(SelectAllCommandProperty); }
+            set { SetValue(SelectAllCommandProperty, value); }
+        }
+        public static readonly DependencyProperty SelectAllCommandProperty =
+            DependencyProperty.Register("SelectAllCommand", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
+
+        public ICommand DownloadCommandInternal
+        {
+            get { return (ICommand)GetValue(DownloadCommandInternalProperty); }
+            set { SetValue(DownloadCommandInternalProperty, value); }
+        }
+        public static readonly DependencyProperty DownloadCommandInternalProperty =
+            DependencyProperty.Register("DownloadCommandInternal", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
+
+        public ICommand DownloadCommand
+        {
+            get { return (ICommand)GetValue(DownloadCommandProperty); }
+            set { SetValue(DownloadCommandProperty, value); }
+        }
+        public static readonly DependencyProperty DownloadCommandProperty =
+            DependencyProperty.Register("DownloadCommand", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
+
+        public ICommand OpenCommand
+        {
+            get { return (ICommand)GetValue(OpenCommandProperty); }
+            set { SetValue(OpenCommandProperty, value); }
+        }
+        public static readonly DependencyProperty OpenCommandProperty =
+            DependencyProperty.Register("OpenCommand", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
+
+        public ICommand BackCommand
+        {
+            get { return (ICommand)GetValue(BackCommandProperty); }
+            set { SetValue(BackCommandProperty, value); }
+        }
+        public static readonly DependencyProperty BackCommandProperty =
+            DependencyProperty.Register("BackCommand", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
+
+        public ICommand RenameCommand
+        {
+            get { return (ICommand)GetValue(RenameCommandProperty); }
+            set { SetValue(RenameCommandProperty, value); }
+        }
+        public static readonly DependencyProperty RenameCommandProperty =
+            DependencyProperty.Register("RenameCommand", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
+
+        public ICommand RenameCommandInternal
+        {
+            get { return (ICommand)GetValue(RenameCommandInternalProperty); }
+            set { SetValue(RenameCommandInternalProperty, value); }
+        }
+        public static readonly DependencyProperty RenameCommandInternalProperty =
+            DependencyProperty.Register("RenameCommandInternal", typeof(ICommand), typeof(FileExplorerControl), new PropertyMetadata(null));
+
+        public bool IsContextMenuOpened
+        {
+            get { return (bool)GetValue(IsContextMenuOpenedProperty); }
+            set { SetValue(IsContextMenuOpenedProperty, value); }
+        }
+        public static readonly DependencyProperty IsContextMenuOpenedProperty =
+            DependencyProperty.Register("IsContextMenuOpened", typeof(bool), typeof(FileExplorerControl), new PropertyMetadata(false, (d, e) => (d as FileExplorerControl).OnIsContextMenuOpenedChanged()));
+
         public ImageSource DriveIcon
         {
             get { return (ImageSource)GetValue(DriveIconProperty); }
@@ -124,7 +272,138 @@ namespace Tango.FileSystem
 
         public FileExplorerControl()
         {
+            Focusable = true;
+
+            _copyItems = new List<FileSystemItem>();
             _selectedItemsBeforeDrag = new List<FileSystemItem>();
+
+            CopyCommand = new RelayCommand(() =>
+            {
+                ResetItemsCut();
+                _copyItems.Clear();
+                _copyItems.AddRange(SelectedItems.ToList());
+                _isCut = false;
+            }, () => SelectedItems != null && SelectedItems.Count > 0);
+
+            CutCommand = new RelayCommand(() =>
+            {
+                _copyItems.Clear();
+                _copyItems.AddRange(SelectedItems.ToList());
+                CutSelectedItems();
+                _isCut = true;
+
+            }, () => SelectedItems != null && SelectedItems.Count > 0);
+
+            PasteCommandInternal = new RelayCommand(() =>
+            {
+                if (_isCut)
+                {
+                    CutPasteCommand?.Execute(_copyItems.ToList());
+                }
+                else
+                {
+                    CopyPasteCommand?.Execute(_copyItems.ToList());
+                }
+
+                ResetItemsCut();
+                _copyItems.Clear();
+            }, () => _copyItems.Count > 0);
+
+            SelectAllCommand = new RelayCommand(() =>
+            {
+                ResetItemsCut();
+                _copyItems.Clear();
+                SelectedItems.Clear();
+
+                if (CurrentItem != null)
+                {
+                    foreach (var item in CurrentItem.Items)
+                    {
+                        SelectedItems.Add(item);
+                    }
+                }
+            });
+
+            DownloadCommandInternal = new RelayCommand(() =>
+            {
+
+                DownloadCommand?.Execute(SelectedItems.ToList());
+
+            }, () => SelectedItems != null && SelectedItems.Count > 0 && SelectedItems.All(x => x.Type != FileSystemItemType.Drive));
+
+            OpenCommand = new RelayCommand(() =>
+            {
+                ItemDoubleClickedCommand?.Execute(SelectedItems.FirstOrDefault());
+            }, () => SelectedItems != null && SelectedItems.Count == 1);
+
+            DeleteCommandInternal = new RelayCommand(() =>
+            {
+
+                DeleteCommand?.Execute(SelectedItems.ToList());
+
+            }, () => SelectedItems != null && SelectedItems.Count > 1 && SelectedItems.All(x => x.Type != FileSystemItemType.Drive));
+
+            RenameCommandInternal = new RelayCommand(() => 
+            {
+
+                RenameCommand?.Execute(SelectedItems.FirstOrDefault());
+
+            }, () => SelectedItems != null && SelectedItems.Count == 1 && SelectedItems.All(x => x.Type != FileSystemItemType.Drive));
+        }
+
+        private void OnIsContextMenuOpenedChanged()
+        {
+            _isMouseDown = false;
+            (PasteCommandInternal as RelayCommand)?.RaiseCanExecuteChanged();
+            (CutCommand as RelayCommand)?.RaiseCanExecuteChanged();
+            (CopyCommand as RelayCommand)?.RaiseCanExecuteChanged();
+            (DownloadCommandInternal as RelayCommand)?.RaiseCanExecuteChanged();
+            (OpenCommand as RelayCommand)?.RaiseCanExecuteChanged();
+            (DeleteCommandInternal as RelayCommand)?.RaiseCanExecuteChanged();
+            (RenameCommandInternal as RelayCommand)?.RaiseCanExecuteChanged();
+
+            if (IsContextMenuOpened)
+            {
+                _isAfterContextMenu = true;
+            }
+        }
+
+        private void ResetItemsCut()
+        {
+            foreach (var item in _listBox.Items)
+            {
+                var element = _listBox.ItemContainerGenerator.ContainerFromItem(item) as FrameworkElement;
+                if (element != null)
+                {
+                    SetIsCut(element, false);
+                }
+
+                element = _datagrid.ItemContainerGenerator.ContainerFromItem(item) as FrameworkElement;
+                if (element != null)
+                {
+                    SetIsCut(element, false);
+                }
+            }
+        }
+
+        private void CutSelectedItems()
+        {
+            ResetItemsCut();
+
+            foreach (var item in SelectedItems.ToList())
+            {
+                var element = _listBox.ItemContainerGenerator.ContainerFromItem(item) as FrameworkElement;
+                if (element != null)
+                {
+                    SetIsCut(element, true);
+                }
+
+                element = _datagrid.ItemContainerGenerator.ContainerFromItem(item) as FrameworkElement;
+                if (element != null)
+                {
+                    SetIsCut(element, true);
+                }
+            }
         }
 
         public override void OnApplyTemplate()
@@ -138,17 +417,77 @@ namespace Tango.FileSystem
             _datagrid.SelectionChanged += _datagrid_SelectionChanged;
         }
 
-        protected override void OnPreviewKeyUp(KeyEventArgs e)
+        protected override void OnPreviewKeyDown(KeyEventArgs e)
         {
-            base.OnPreviewKeyUp(e);
+            base.OnPreviewKeyDown(e);
 
             if (e.Key == Key.Delete)
             {
-                if (SelectedItems != null && SelectedItems.Count > 0)
+                if (DeleteCommandInternal != null && DeleteCommandInternal.CanExecute(null))
+                {
+                    DeleteCommandInternal?.Execute(null);
+                }
+            }
+            else if (e.Key == Key.Return)
+            {
+                if (OpenCommand != null && OpenCommand.CanExecute(null))
                 {
-                    DeleteCommand?.Execute(SelectedItems);
+                    OpenCommand?.Execute(null);
                 }
             }
+            else if (e.Key == Key.C && Keyboard.IsKeyDown(Key.LeftCtrl))
+            {
+                if (CopyCommand != null && CopyCommand.CanExecute(null))
+                {
+                    CopyCommand.Execute(null);
+                }
+            }
+            else if (e.Key == Key.X && Keyboard.IsKeyDown(Key.LeftCtrl))
+            {
+                if (CutCommand != null && CutCommand.CanExecute(null))
+                {
+                    CutCommand.Execute(null);
+                }
+            }
+            else if (e.Key == Key.V && Keyboard.IsKeyDown(Key.LeftCtrl))
+            {
+                if (PasteCommandInternal != null && PasteCommandInternal.CanExecute(null))
+                {
+                    PasteCommandInternal.Execute(null);
+                }
+            }
+            else if (e.Key == Key.A && Keyboard.IsKeyDown(Key.LeftCtrl))
+            {
+                if (SelectAllCommand != null && SelectAllCommand.CanExecute(null))
+                {
+                    SelectAllCommand.Execute(null);
+                }
+            }
+            else if (e.Key == Key.D && Keyboard.IsKeyDown(Key.LeftCtrl))
+            {
+                if (DownloadCommandInternal != null && DownloadCommandInternal.CanExecute(null))
+                {
+                    DownloadCommandInternal.Execute(null);
+                }
+            }
+            else if (e.Key == Key.F2)
+            {
+                if (RenameCommandInternal != null && RenameCommandInternal.CanExecute(null))
+                {
+                    RenameCommandInternal.Execute(null);
+                }
+            }
+            else if (e.Key == Key.Down)
+            {
+                if (SelectedItems != null && SelectedItems.Count == 0 && CurrentItem != null && CurrentItem.Items.Count > 0)
+                {
+                    SelectedItems.Add(CurrentItem.Items.FirstOrDefault());
+                }
+            }
+            else if (e.Key == Key.Back)
+            {
+                BackCommand?.Execute(null);
+            }
         }
 
         private void _datagrid_SelectionChanged(object sender, SelectionChangedEventArgs e)
@@ -279,6 +618,12 @@ namespace Tango.FileSystem
         {
             base.OnPreviewMouseLeftButtonDown(e);
 
+            if (_isAfterContextMenu)
+            {
+                _isAfterContextMenu = false;
+                return;
+            }
+
             if (!AllowDrag) return;
 
             if (e.OriginalSource is FrameworkElement)
@@ -309,7 +654,7 @@ namespace Tango.FileSystem
         {
             base.OnPreviewMouseMove(e);
 
-            if (_isMouseDown)
+            if (_isMouseDown && !IsContextMenuOpened)
             {
                 Point mpos = e.GetPosition(null);
                 Vector diff = this._dragOutStartPoint - mpos;
@@ -375,7 +720,7 @@ namespace Tango.FileSystem
                                         }
 
                                         //Notify to user with all items!
-                                        Dispatcher.BeginInvoke(new Action(() => 
+                                        Dispatcher.BeginInvoke(new Action(() =>
                                         {
                                             DragCommand?.Execute(notifyItems);
                                         }));
@@ -400,7 +745,16 @@ namespace Tango.FileSystem
                     }
 
                     string[] files = dropItems.Select(x => x.Item2.Path).ToArray();
-                    var ef = DragDrop.DoDragDrop(this, new DataObject(DataFormats.FileDrop, files, false), DragDropEffects.Copy);
+
+                    try
+                    {
+                        var ef = DragDrop.DoDragDrop(this, new DataObject(DataFormats.FileDrop, files, false), DragDropEffects.Copy);
+                    }
+                    catch (Exception ex)
+                    {
+                        Debug.WriteLine(ex);
+                        Debugger.Break();
+                    }
 
                     await Task.Delay(3000);
 
@@ -419,5 +773,15 @@ namespace Tango.FileSystem
                 }
             }
         }
+
+        private async void OnCurrentItemChanged()
+        {
+            if (IsVisible)
+            {
+                await Task.Delay(100);
+                this.Focus();
+                Keyboard.Focus(this);
+            }
+        }
     }
 }