bookmark-manager/Windows/Forms/BookmarkTreeView.cs

using bzit.bomg;
using bzit.bomg.Models;
using System;
using System.ComponentModel;
using System.Drawing;
using System.IO;
using System.Windows.Forms;
using Resources = bzit.bomg.Properties.Resources;

namespace RyzStudio.Windows.Forms
{
    public class BookmarkTreeView : System.Windows.Forms.TreeView
    {
        public enum IconSet
        {
            Root = 0,
            Folder1,
            Folder2,
            Default
        }

        public enum NodeType
        {
            None = 0,
            Root,
            Folder,
            Page
        }

        public BookmarkTreeViewSNode SNode { get; set; }

        protected IconDatabase iconDatabase = null;


        public delegate void NodeCountUpdated(ulong v);

        public EventHandler OnChanged = null;
        public NodeCountUpdated OnNodeCountUpdate = null;

        protected const char pathSeparator = '|';

        protected TreeNode draggingNode = null;
        //protected bool allowBeginEdit = false;
        protected ulong nodeCount = 0;
        protected bool hasChanged = false;

        public BookmarkTreeView() : base()
        {
            this.SNode = new BookmarkTreeViewSNode(this);

            if (this.ImageList == null)
            {
                this.ImageList = new ImageList();
            }

            this.ImageList.ColorDepth = ColorDepth.Depth16Bit;
            this.ImageList.ImageSize = new Size(16, 16);
            this.ImageList.TransparentColor = Color.Transparent;

            this.ImageList.Images.Clear();
            this.ImageList.Images.Add(Resources.transmit_blue);
            this.ImageList.Images.Add(Resources.folder);
            this.ImageList.Images.Add(Resources.folder_explore);
            this.ImageList.Images.Add(Resources.page_white_world_bw);
        }

        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public new ImageList ImageList { get => base.ImageList; set => base.ImageList = value; }

        [Browsable(false)]
        public TreeNode[] NodeList
        {
            get
            {
                TreeNode[] rv = new TreeNode[0];
                if (this.Nodes.Count <= 0)
                {
                    return rv;
                }

                foreach (TreeNode tn in this.Nodes)
                {
                    traverseNodeList(ref rv, tn);
                }

                return rv;
            }
        }

        [Browsable(false)]
        public ulong NodeCount
        {
            get
            {
                return nodeCount;
            }
        }

        [Browsable(false)]
        public ulong NodeCountCalc
        {
            get
            {
                ulong rv = 0;
                if (this.Nodes.Count <= 0)
                {
                    return rv;
                }

                foreach (TreeNode tn in this.Nodes)
                {
                    traverseNodeCount(ref rv, tn);
                }

                return rv;
            }
        }

        [Browsable(false)]
        public bool HasChanged
        {
            get { return hasChanged; }
            set
            {
                hasChanged = value;

                OnChanged?.Invoke(null, null);
            }
        }


        #region public methods

        public bool InitialiseIconDatabase(out string message, string filename)
        {
            message = string.Empty;

            if (string.IsNullOrWhiteSpace(filename))
            {
                return false;
            }

            if (iconDatabase == null)
            {
                iconDatabase = new IconDatabase();
            }

            bool rv = false;
            if (File.Exists(filename))
            {
                rv = iconDatabase.LoadFile(filename);
                if (!rv)
                {
                    rv = iconDatabase.Create(filename, true, null, true);
                    if (!rv)
                    {
                        message = iconDatabase.LastError;
                        return false;
                    }
                }
            }
            else
            {
                rv = iconDatabase.Create(filename, true, null, true);
                if (!rv)
                {
                    message = iconDatabase.LastError;
                    return false;
                }
            }

            return true;
        }

        public void AddItem(BookmarkItemViewModel viewModel)
        {
            int iconIndex = addIcon(viewModel);

            TreeNode tn = new TreeNode(viewModel.SiteName, iconIndex, iconIndex);
            tn.Tag = viewModel;
            tn.ToolTipText = viewModel.ToString();

            TreeNode tn2 = addFolderPath(viewModel.TreeviewPath);

            tn2.Nodes.Add(tn);
        }

        public void AddOrUpdateItem_OnSelectedNode(BookmarkItemViewModel viewModel)
        {
            switch (this.SNode.GetNodeType())
            {
                case NodeType.Root:
                case NodeType.Folder:
                    addItem_OnSelectedNode(viewModel);
                    break;
                case NodeType.Page:
                    updateItem_OnSelectedNode(viewModel);
                    break;
                default:
                    break;
            }
        }

        public NodeType GetNodeType(TreeNode node)
        {
            if (node.Tag == null)
            {
                if (node.Equals(this.Nodes[0]))
                {
                    return NodeType.Root;
                }
                else
                {
                    return NodeType.Folder;
                }
            }
            else
            {
                if (node.Tag is BookmarkItemViewModel)
                {
                    return NodeType.Page;
                }
                else
                {
                    return NodeType.None;
                }
            }
        }


        //public void EditNode()
        //{
        //    this.SNode.

        //    //this.HasChanged = true;

        //    //if (this.SelectedNode == null)
        //    //{
        //    //    return;
        //    //}

        //    //if (!this.SelectedNode.IsEditing)
        //    //{
        //    //    allowBeginEdit = true;
        //    //    this.SelectedNode.BeginEdit();
        //    //}
        //}

        public string GetNodeFullPath(TreeNode node)
        {
            string rv = PathEncode(node.Text);

            TreeNode tn = node;
            while (true)
            {
                tn = tn.Parent;

                if (tn == null)
                {
                    break;
                }

                if (tn.Level == 0)
                {
                    break;
                }

                rv = PathEncode(tn.Text) + pathSeparator.ToString() + rv;
            }

            return rv;
        }

        public bool FindTextNode(TreeNode node, string term)
        {
            if (node == null)
            {
                return false;
            }

            if (this.Nodes.Count <= 0)
            {
                return false;
            }

            bool rt = false;
            bool inclusive = false;
            TreeNode tn = node;
            while (true)
            {
                if (tn == null)
                {
                    break;
                }

                if (inclusive)
                {
                    if (tn.Text.ToLower().Contains(term.ToLower()))
                    {
                        this.SelectedNode = tn;
                        this.SelectedNode.EnsureVisible();
                        rt = true;
                        break;
                    }
                }

                if (tn.Nodes.Count > 0)
                {
                    tn = tn.Nodes[0];
                    inclusive = true;
                }
                else
                {
                    if (tn.NextNode != null)
                    {
                        tn = tn.NextNode;
                        inclusive = true;
                    }
                    else
                    {
                        while (true)
                        {
                            tn = tn.Parent;
                            if (tn == null)
                            {
                                break;
                            }

                            if (tn.NextNode != null)
                            {
                                tn = tn.NextNode;
                                break;
                            }
                        }

                        inclusive = true;
                    }
                }
            }

            return rt;
        }

        public void Clear()
        {
            nodeCount = 0;
            NodeCountUpdate(nodeCount);
            this.Nodes.Clear();

            this.HasChanged = true;
        }

        #endregion

        #region integrated behaviour

        protected override void OnItemDrag(ItemDragEventArgs e)
        {
            base.OnItemDrag(e);

            draggingNode = (TreeNode)e.Item;
            DoDragDrop(e.Item, DragDropEffects.Move);
        }

        protected override void OnDragDrop(DragEventArgs e)
        {
            base.OnDragDrop(e);

            if (draggingNode.Level <= 0)
            {
                return;
            }

            TreeNode en = this.GetNodeAt(this.PointToClient(new Point(e.X, e.Y)));
            if (en == null)
            {
                return;
            }

            if (isNodeChild(draggingNode, en))
            {
                return;
            }

            TreeNode dn = draggingNode;
            if (en.Tag == null)
            {
                dn.Parent.Nodes.Remove(dn);
                en.Nodes.Insert(0, dn);
            }
            else
            {
                en.Parent.Nodes.Remove(dn);
                en.Parent.Nodes.Insert(en.Index + 1, dn);
            }

            this.HasChanged = true;
        }

        protected override void OnDragEnter(DragEventArgs e)
        {
            base.OnDragEnter(e);

            e.Effect = DragDropEffects.Move;
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);

            this.SelectedNode = this.GetNodeAt(e.Location);
        }

        protected override void OnDragOver(DragEventArgs e)
        {
            base.OnDragOver(e);

            this.SelectedNode = this.GetNodeAt(this.PointToClient(new Point(e.X, e.Y)));
        }

        protected override void OnBeforeLabelEdit(NodeLabelEditEventArgs e)
        {
            //if (!allowBeginEdit)
            //{
            //    e.CancelEdit = true;
            //    return;
            //}

            //this.HasChanged = true;

            //base.OnBeforeLabelEdit(e);

            //if (e.Node == null)
            //{
            //    e.CancelEdit = true;
            //}
            //else
            //{
            //    if (e.Node.Tag == null)
            //    {
            //        // do it
            //    }
            //    else
            //    {
            //        e.CancelEdit = true;
            //    }
            //}
        }

        protected override void OnAfterLabelEdit(NodeLabelEditEventArgs e)
        {
            base.OnAfterLabelEdit(e);

            //if (e.Node.Tag == null)
            //{
            //    if (e.Label == null)
            //    {
            //        e.CancelEdit = true;
            //    }
            //    else
            //    {
            //        if (e.Label.Trim().Length <= 0)
            //        {
            //            e.CancelEdit = true;
            //        }
            //    }
            //}
            //else
            //{
            //    e.CancelEdit = true;
            //}

            //allowBeginEdit = false;
        }

        protected override void OnPreviewKeyDown(PreviewKeyDownEventArgs e)
        {
            TreeNode tn = this.SelectedNode;
            if (tn == null)
            {
                return;
            }

            switch (e.KeyCode)
            {
                case Keys.Insert:
                    if (e.Modifiers == Keys.Shift)
                    {
                        this.SelectedNode = this.SNode.AddFolder();
                    }
                    else
                    {
                        //##AddBookmarkPage();
                    }

                    break;
                case Keys.Delete:
                    if (!tn.IsEditing)
                    {
                        this.SNode.Delete();
                    }

                    break;
                case Keys.F2:
                    this.SNode.Edit();
                    break;
                case Keys.Up:
                    if (e.Modifiers == Keys.Control)
                    {
                        this.SNode.MoveUp();
                    }

                    break;
                case Keys.Down:
                    if (e.Modifiers == Keys.Control)
                    {
                        this.SNode.MoveDown();
                    }

                    break;
                default: break;
            }

            //base.OnPreviewKeyDown(e);
        }

        protected virtual void NodeCountUpdate(ulong v)
        {
            this.OnNodeCountUpdate?.Invoke(v);
        }

        #endregion


        protected int addIcon(BookmarkItemViewModel viewModel) => addIcon(viewModel.ToModel());

        protected int addIcon(BookmarkItemModel model)
        {
            if (this.ImageList.Images.ContainsKey(model.SiteAddress))
            {
                return this.ImageList.Images.IndexOfKey(model.SiteAddress);
            }

            if (iconDatabase.HasIcon(model.SiteAddress))
            {
                Image rs = iconDatabase.GetIcon(model.SiteAddress);
                if (rs == null)
                {
                    return (int)IconSet.Default;
                }
                else
                {
                    this.ImageList.Images.Add(model.SiteAddress, rs);

                    return this.ImageList.Images.IndexOfKey(model.SiteAddress);
                }
            }

            Bitmap bmp = model.RetrieveFavicon();
            if (bmp == null)
            {
                return (int)IconSet.Default;
            }

            this.ImageList.Images.Add(model.SiteAddress, bmp);

            return this.ImageList.Images.IndexOfKey(model.SiteAddress);
        }

        protected TreeNode addFolderPath(string path)
        {
            TreeNode tn = this.Nodes[0];
            if (tn == null)
            {
                return tn;
            }

            if (string.IsNullOrWhiteSpace(path))
            {
                return tn;
            }

            if (string.IsNullOrWhiteSpace(path.Trim('\\')))
            {
                return tn;
            }

            string[] folderList = path.Trim('\\').Split('\\');
            if (folderList.Length <= 0)
            {
                return tn;
            }

            foreach (string item in folderList)
            {
                if (tn.Nodes.ContainsKey(item))
                {
                    // do nothing
                }
                else
                {
                    tn.Nodes.Add(item, item, (int)IconSet.Folder1, (int)IconSet.Folder2);
                }

                tn = tn.Nodes[item];
            }

            return tn;
        }

        protected void addItem_OnSelectedNode(BookmarkItemViewModel viewModel)
        {
            if (this.SelectedNode == null)
            {
                return;
            }

            int iconIndex = addIcon(viewModel);

            TreeNode tn = new TreeNode(viewModel.SiteName, iconIndex, iconIndex);
            tn.Tag = viewModel;
            tn.ToolTipText = viewModel.ToString();

            int n = this.SelectedNode.Nodes.Add(tn);

            this.SelectedNode = this.SelectedNode.Nodes[n];
        }

        protected void updateItem_OnSelectedNode(BookmarkItemViewModel viewModel)
        {
            if (this.SelectedNode == null)
            {
                return;
            }

            int iconIndex = addIcon(viewModel);

            this.SelectedNode.Text = viewModel.SiteName;
            this.SelectedNode.ImageIndex = iconIndex;
            this.SelectedNode.SelectedImageIndex = iconIndex;
            this.SelectedNode.Tag = viewModel;
            this.SelectedNode.ToolTipText = viewModel.ToString();
        }

        protected bool isNodeChild(TreeNode drag_node, TreeNode drop_node)
        {
            TreeNode tn = drop_node;
            while (true)
            {
                if (tn.Parent == null)
                {
                    break;
                }

                if (tn.Equals(drag_node))
                {
                    return true;
                }

                tn = tn.Parent;
            }

            return false;
        }

        protected void traverseNodeList(ref TreeNode[] results, TreeNode node)
        {
            foreach (TreeNode tn in node.Nodes)
            {
                if (tn.Tag == null)
                {
                    traverseNodeList(ref results, tn);
                }
                else
                {
                    Array.Resize(ref results, (results.Length + 1));
                    results[(results.Length - 1)] = tn;
                }
            }
        }

        protected void traverseNodeCount(ref ulong results, TreeNode node)
        {
            foreach (TreeNode tn in node.Nodes)
            {
                if (tn.Tag == null)
                {
                    traverseNodeCount(ref results, tn);
                }
                else
                {
                    results++;
                }
            }
        }







        protected virtual void OnAddFolderNode(TreeNode node) { }

        protected virtual void OnAddItemNode(TreeNode node) { }


        ////protected string PathEncode(string text) { return RyzStudio.String.EncodeTo64(text); }
        //protected string PathDecode(string text) { return RyzStudio.String.DecodeFrom64(text); }
        protected string PathEncode(string text) { return System.Web.HttpUtility.UrlEncode(text); }
        protected string PathDecode(string text) { return System.Web.HttpUtility.UrlDecode(text); }





    }
}