TreeNode.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using Waher.Content.Markdown;
using Waher.Events;
using Waher.Networking.Sniffers;
using Waher.Networking.XMPP.DataForms;
using Waher.Networking.XMPP.Sensor;
using Waher.Things.DisplayableParameters;
using Waher.Networking;
 
namespace Waher.Client.WPF.Model
{
    public abstract class TreeNode : SelectableItem, IDisposable
    {
        private readonly TreeNode parent;
        protected DisplayableParameters parameters = null;
        protected SortedDictionary<string, TreeNode> children = null;
        private object tag = null;
        private bool expanded = false;
 
        public TreeNode(TreeNode Parent)
        {
            this.parent = Parent;
        }
 
        public abstract string Key
        {
            get;
        }
 
        public bool? HasChildren
        {
            get
            {
                if (this.children is null)
                    return null;
                else
                {
                    lock (this.children)
                    {
                        return this.children.Count > 0;
                    }
                }
            }
        }
 
        public TreeNode[] Children
        {
            get
            {
                if (this.children is null)
                    return null;
 
                TreeNode[] Children;
 
                lock (this.children)
                {
                    Children = new TreeNode[this.children.Count];
                    this.children.Values.CopyTo(Children, 0);
                }
 
                return Children;
            }
        }
 
        public bool TryGetChild(string ChildKey, out TreeNode Child)
        {
            lock (this.children)
            {
                return this.children.TryGetValue(ChildKey, out Child);
            }
        }
 
        public TreeNode Parent => this.parent;
 
        public object Tag
        {
            get => this.tag;
            set => this.tag = value;
        }
 
        public abstract string Header
        {
            get;
        }
 
        public virtual void Dispose()
        {
        }
 
        public abstract void Write(XmlWriter Output);
 
        public abstract ImageSource ImageResource
        {
            get;
        }
 
        public virtual Visibility ImageResourceVisibility
        {
            get { return Visibility.Visible; }
        }
 
        public virtual ImageSource ImageResource2
        {
            get { return null; }
        }
 
        public virtual Visibility ImageResource2Visibility
        {
            get { return Visibility.Hidden; }
        }
 
        public abstract string ToolTip
        {
            get;
        }
 
        public abstract string TypeName
        {
            get;
        }
 
        public virtual string this[string DisplayableParameter]
        {
            get
            {
                if (!(this.parameters is null))
                    return this.parameters[DisplayableParameter];
                else
                    return string.Empty;
            }
        }
 
        public virtual void Add(params Parameter[] Parameters)
        {
            if (this.parameters is null)
                this.parameters = new DisplayableParameters(Parameters);
            else
                this.parameters.AddRange(Parameters);
        }
 
        public virtual DisplayableParameters DisplayableParameters => this.parameters;
 
        public event EventHandler Updated = null;
 
        public virtual void OnUpdated()
        {
            this.Raise(this.Updated);
        }
 
        public bool IsExpanded
        {
            get => this.expanded;
            set
            {
                if (this.expanded != value)
                {
                    this.expanded = value;
 
                    if (this.expanded)
                        this.OnExpanded();
                    else
                        this.OnCollapsed();
                }
            }
        }
 
        public event EventHandler Expanded = null;
 
        public event EventHandler Collapsed = null;
 
        protected virtual void OnExpanded()
        {
            this.LoadChildren();
            this.Raise(this.Expanded);
        }
 
        protected override void OnSelected()
        {
            this.LoadChildren();
            base.OnSelected();
        }
 
        protected virtual bool IsLoaded
        {
            get
            {
                if (this.children is null)
                    return true;
 
                lock (this.children)
                {
                    return this.children.Count != 1 || !this.children.ContainsKey(string.Empty);
                }
            }
        }
 
        protected virtual void LoadChildren()
        {
            // Do nothing by default.
        }
 
        protected virtual void UnloadChildren()
        {
            // Do nothing by default.
        }
 
        protected virtual void UnloadGrandchildren()
        {
            if (!(this.children is null))
            {
                foreach (TreeNode Node in this.children.Values)
                    Node.UnloadChildren();
            }
        }
 
        protected virtual void LoadSiblings()
        {
            this.parent?.LoadChildren();
        }
 
        protected virtual void OnCollapsed()
        {
            this.UnloadGrandchildren();
            this.Raise(this.Collapsed);
        }
 
        public abstract bool CanAddChildren
        {
            get;
        }
 
        public virtual void Add()
        {
            throw new NotSupportedException();
        }
 
        public abstract bool CanDelete
        {
            get;
        }
 
        public virtual bool CustomDeleteQuestion => false;
 
        public virtual Task Delete(TreeNode Parent, EventHandler OnDeleted)
        {
            Parent?.RemoveChild(this);
            OnDeleted.Raise(this, EventArgs.Empty);
            return Task.CompletedTask;
        }
 
        public abstract bool CanEdit
        {
            get;
        }
 
        public virtual void Edit()
        {
            throw new NotSupportedException();
        }
 
        public virtual bool CanCopy
        {
            get => false;
        }
 
        public virtual void Copy()
        {
            throw new NotSupportedException();
        }
 
        public virtual bool CanPaste
        {
            get => false;
        }
 
        public virtual void Paste()
        {
            throw new NotSupportedException();
        }
 
        public abstract bool CanRecycle
        {
            get;
        }
 
        public virtual Task Recycle(MainWindow Window)
        {
            throw new NotSupportedException();
        }
 
        public virtual bool RemoveChild(TreeNode Node)
        {
            if (!(this.children is null))
            {
                lock (this.children)
                {
                    return this.children.Remove(Node.Key);
                }
            }
            else
                return false;
        }
 
        internal void RenameChild(string OldKey, string NewKey, TreeNode Node)
        {
            if (!(this.children is null))
            {
                lock (this.children)
                {
                    this.children.Remove(OldKey);
                    this.children[NewKey] = Node;
                }
            }
        }
 
        public virtual bool IsSniffable
        {
            get { return false; }
        }
 
        public virtual void AddSniffer(ISniffer Sniffer)
        {
            throw new NotSupportedException();
        }
 
        public virtual Task<bool> RemoveSniffer(ISniffer Sniffer)
        {
            throw new NotSupportedException();
        }
 
        public virtual bool CanChat => false;
 
        public virtual Task SendChatMessage(string Message, string ThreadId, MarkdownDocument Markdown)
        {
            MainWindow.ErrorBox("You are not allowed to chat with this entity.");
            return Task.CompletedTask;
        }
 
        public virtual void Added(MainWindow Window)
        {
        }
 
        public virtual void Removed(MainWindow Window)
        {
        }
 
        public virtual bool CanReadSensorData => false;
 
        public virtual bool CanSubscribeToSensorData => false;
 
        public virtual Task<SensorDataClientRequest> StartSensorDataMomentaryReadout()
        {
            throw new NotSupportedException();
        }
 
        public virtual Task<SensorDataClientRequest> StartSensorDataFullReadout()
        {
            throw new NotSupportedException();
        }
 
        public virtual Task<SensorDataSubscriptionRequest> SubscribeSensorDataMomentaryReadout(FieldSubscriptionRule[] Rules)
        {
            throw new NotSupportedException();
        }
 
        public virtual bool CanConfigure => false;
 
        public virtual void Configure()
        {
            Mouse.OverrideCursor = Cursors.Wait;
            this.GetConfigurationForm((Sender, e2) =>
            {
                if (e2.Ok && !(e2.Form is null))
                    MainWindow.UpdateGui(MainWindow.currentInstance.ShowForm, e2.Form);
                else
                    MainWindow.UpdateGui(MainWindow.currentInstance.ShowError, e2);
 
                return Task.CompletedTask;
            }, null);
        }
 
        public virtual Task GetConfigurationForm(EventHandlerAsync<DataFormEventArgs> Callback, object State)
        {
            throw new NotSupportedException();
        }
 
        public virtual bool CanSearch
        {
            get { return false; }
        }
 
        public virtual void Search()
        {
            throw new NotSupportedException();
        }
 
        public virtual void AddContexMenuItems(ref string CurrentGroup, ContextMenu Menu)
        {
            if (this.CanAddChildren)
            {
                CurrentGroup = "Edit";
                Menu.Items.Add(new MenuItem()
                {
                    Header = "_Add...",
                    IsEnabled = true,
                    Command = MainWindow.Add,
                    Icon = new Image()
                    {
                        Source = new BitmapImage(new Uri("../Graphics/Add.png", UriKind.Relative)),
                        Width = 16,
                        Height = 16
                    }
                });
            }
 
            if (!(this.Parent is null) && this.Parent.CanDelete)
            {
                CurrentGroup = "Edit";
                Menu.Items.Add(new MenuItem()
                {
                    Header = "_Delete...",
                    IsEnabled = true,
                    Command = MainWindow.Delete,
                    Icon = new Image()
                    {
                        Source = new BitmapImage(new Uri("../Graphics/delete_32_h.png", UriKind.Relative)),
                        Width = 16,
                        Height = 16
                    }
                });
            }
 
            if (this.CanCopy)
            {
                CurrentGroup = "Edit";
                Menu.Items.Add(new MenuItem()
                {
                    Header = "_Copy",
                    IsEnabled = true,
                    Command = MainWindow.Copy,
                    Icon = new Image()
                    {
                        Source = new BitmapImage(new Uri("../Graphics/Amitjakhu-Drip-Copy.16.png", UriKind.Relative)),
                        Width = 16,
                        Height = 16
                    }
                });
            }
            if (this.CanPaste)
            {
                CurrentGroup = "Edit";
                Menu.Items.Add(new MenuItem()
                {
                    Header = "_Paste",
                    IsEnabled = true,
                    Command = MainWindow.Paste,
                    Icon = new Image()
                    {
                        Source = new BitmapImage(new Uri("../Graphics/Amitjakhu-Drip-Clipboard.16.png", UriKind.Relative)),
                        Width = 16,
                        Height = 16
                    }
                });
            }
 
            if (this.CanRecycle)
            {
                this.GroupSeparator(ref CurrentGroup, "Connection", Menu);
                Menu.Items.Add(new MenuItem()
                {
                    Header = "_Refresh",
                    IsEnabled = true,
                    Command = MainWindow.Refresh,
                    Icon = new Image()
                    {
                        Source = new BitmapImage(new Uri("../Graphics/refresh_document_16_h.png", UriKind.Relative)),
                        Width = 16,
                        Height = 16
                    }
                });
            }
 
            if (this.IsSniffable)
            {
                this.GroupSeparator(ref CurrentGroup, "Connection", Menu);
                Menu.Items.Add(new MenuItem()
                {
                    Header = "_Sniff...",
                    IsEnabled = true,
                    Command = MainWindow.Sniff,
                    Icon = new Image()
                    {
                        Source = new BitmapImage(new Uri("../Graphics/Spy-icon.png", UriKind.Relative)),
                        Width = 16,
                        Height = 16
                    }
                });
            }
 
            if (this.CanChat)
            {
                this.GroupSeparator(ref CurrentGroup, "Communication", Menu);
                Menu.Items.Add(new MenuItem()
                {
                    Header = "C_hat...",
                    IsEnabled = true,
                    Command = MainWindow.Chat,
                    Icon = new Image()
                    {
                        Source = XmppAccountNode.chatBubble,
                        Width = 16,
                        Height = 16
                    }
                });
            }
 
            if (this.CanReadSensorData)
            {
                this.GroupSeparator(ref CurrentGroup, "Communication", Menu);
                Menu.Items.Add(new MenuItem()
                {
                    Header = "Read _Momentary Values...",
                    IsEnabled = true,
                    Command = MainWindow.ReadMomentary,
                    Icon = new Image()
                    {
                        Source = new BitmapImage(new Uri("../Graphics/history_16_h.png", UriKind.Relative)),
                        Width = 16,
                        Height = 16
                    }
                });
 
                Menu.Items.Add(new MenuItem()
                {
                    Header = "Read _Detailed Values...",
                    IsEnabled = true,
                    Command = MainWindow.ReadDetailed,
                    Icon = new Image()
                    {
                        Source = new BitmapImage(new Uri("../Graphics/print_preview_lined_16_h.png", UriKind.Relative)),
                        Width = 16,
                        Height = 16
                    }
                });
            }
 
            if (this.CanSubscribeToSensorData)
            {
                this.GroupSeparator(ref CurrentGroup, "Communication", Menu);
                Menu.Items.Add(new MenuItem()
                {
                    Header = "Su_bscribe to Momentary Values...",
                    IsEnabled = true,
                    Command = MainWindow.SubscribeToMomentary,
                    Icon = new Image()
                    {
                        Source = new BitmapImage(new Uri("../Graphics/rss-feed-icon_16.png", UriKind.Relative)),
                        Width = 16,
                        Height = 16
                    }
                });
            }
 
            if (this.CanConfigure)
            {
                this.GroupSeparator(ref CurrentGroup, "Communication", Menu);
                Menu.Items.Add(new MenuItem()
                {
                    Header = "Configure _Parameters...",
                    IsEnabled = true,
                    Command = MainWindow.Configure,
                    Icon = new Image()
                    {
                        Source = new BitmapImage(new Uri("../Graphics/Settings-icon_16.png", UriKind.Relative)),
                        Width = 16,
                        Height = 16
                    }
                });
            }
 
            if (this.CanSearch)
            {
                this.GroupSeparator(ref CurrentGroup, "Database", Menu);
                Menu.Items.Add(new MenuItem()
                {
                    Header = "_Search",
                    IsEnabled = true,
                    Command = MainWindow.Search,
                    Icon = new Image()
                    {
                        Source = new BitmapImage(new Uri("../Graphics/search_16_h.png", UriKind.Relative)),
                        Width = 16,
                        Height = 16
                    }
                });
            }
 
            TreeNode Loop = this;
            while (!(Loop is null))
            {
                if (Loop is IMenuAggregator MenuAggregator)
                    MenuAggregator.AddContexMenuItems(this, ref CurrentGroup, Menu);
 
                Loop = Loop.parent;
            }
        }
 
        protected void GroupSeparator(ref string CurrentGroup, string Group, ContextMenu Menu)
        {
            if (CurrentGroup != Group)
            {
                if (!string.IsNullOrEmpty(CurrentGroup))
                    Menu.Items.Add(new MenuItem());
 
                CurrentGroup = Group;
            }
        }
 
        public virtual void SelectionChanged()
        {
            // Do nothing by default.
        }
 
        public virtual void ViewClosed()
        {
            // Do nothing by default.
        }
 
    }
}