public abstract void Sync(HierarchicalBaseWrapper aother, HierarchicalWrapper_Folder[] parents);
        public override void Sync(HierarchicalBaseWrapper aother, HierarchicalWrapper_Folder[] parents)
        {
            var other = (HierarchicalWrapper_AllNotes)aother;

            AllSubNotes.SynchronizeCollectionSafe(other.AllSubNotes);
        }
        public override void Sync(HierarchicalBaseWrapper aother, HierarchicalWrapper_Folder[] parents)
        {
            var other = (HierarchicalWrapper_Folder)aother;

            Debug.Assert(this.Header.ToLower() == other.Header.ToLower());
            Debug.Assert(this._isRoot == other._isRoot);

            _path           = other._path;
            _directSubNotes = other._directSubNotes;
            AllSubNotes.SynchronizeCollectionSafe(other.AllSubNotes);

            var me = this;

            bool FCompare(HierarchicalWrapper_Folder a, HierarchicalWrapper_Folder b)
            {
                return(a.Header.ToLower() == b.Header.ToLower());
            }

            HierarchicalWrapper_Folder FCopy(HierarchicalWrapper_Folder src)
            {
                if (src.GetType() == typeof(HierarchicalWrapper_Folder) && src.IsSpecialNode_RootFolder)
                {
                    return me.RootFolderViewWrapper = new HierarchicalWrapper_Folder(src.Header, _config, src._path, src._isRoot, src.Permanent)
                    {
                               IsExpanded  = src.IsExpanded,
                               CustomOrder = src.CustomOrder,
                    }
                }
                ;

                if (src.GetType() == typeof(HierarchicalWrapper_Folder))
                {
                    return new HierarchicalWrapper_Folder(src.Header, _config, src._path, src._isRoot, src.Permanent)
                           {
                               IsExpanded  = src.IsExpanded,
                               CustomOrder = src.CustomOrder,
                           }
                }
                ;

                if (src.GetType() == typeof(HierarchicalWrapper_UnsortedNotes))
                {
                    return me.EmptyPathViewWrapper = new HierarchicalWrapper_UnsortedNotes(me, _config)
                    {
                               IsExpanded  = src.IsExpanded,
                               CustomOrder = src.CustomOrder,
                    }
                }
                ;

                if (src.GetType() == typeof(HierarchicalWrapper_AllNotes))
                {
                    return me.AllNotesViewWrapper = new HierarchicalWrapper_AllNotes(me, _config)
                    {
                               IsExpanded  = src.IsExpanded,
                               CustomOrder = src.CustomOrder,
                    }
                }
                ;

                throw new NotSupportedException(src.GetType().ToString());
            }

            SubFolder.SynchronizeCollection(other.SubFolder, FCompare, FCopy);
            Debug.Assert(SubFolder.Count == other.SubFolder.Count);

            for (int i = 0; i < SubFolder.Count; i++)
            {
                SubFolder[i].Sync(other.SubFolder[i], parents.Concat(new [] { this }).ToArray());
            }
        }