public TreeViewItemViewModel(TreeViewItemViewModel parent, bool lazyLoadChildren)
        {
            _parent = parent;

            _children = new ObservableCollection <TreeViewItemViewModel>();

            if (lazyLoadChildren)
            {
                _children.Add(DummyChild);
            }
        }
 /// <summary>
 /// Dice al parent , che è stato selezionato
 /// </summary>
 public void OnSelected(TreeViewItemViewModel caller)
 {
     if (Parent != null)
     {
         Parent.OnSelected(caller);
     }
     else
     {
         RequestOnSelected(caller);
     }
 }
        private TreeViewItemViewModel GetPrev(TreeViewItemViewModel child)
        {
            if (Children.Contains(child))
            {
                var index = Children.IndexOf(child);

                index--;

                return(Children.ElementAtOrDefault(index));
            }

            return(null);
        }
        internal TreeViewItemViewModel GetPrevOrDefault(TreeViewItemViewModel selectedScreen)
        {
            if (selectedScreen == this)
            {
                if (Parent == null) // ovvero se è oggetto radice
                {
                    return(null);
                }
                else
                {
                    // chiedo al parent di darmi il successivo di quest'elemento
                    var prevScreen = Parent.GetPrev(this);

                    // se non c'è nessuno prevScreen ritorno il parent
                    return(prevScreen ?? Parent);
                }
            }

            // controllo fra i children ( parte ricorsiva)

            foreach (var variable in Children)
            {
                //if (variable == selectedScreen)
                //{
                //    var indexOf = variable.Children.IndexOf(selectedScreen);

                //    indexOf--;

                //    if (indexOf == Children.Count)
                //        break;

                //    return variable.Children.ElementAtOrDefault(indexOf);
                //}

                var prev = variable.GetPrevOrDefault(selectedScreen);
                if (prev != null)
                {
                    return(prev);
                }
            }

            // se arrivo qui, significa che non è stato trovato niente dall'oggetto radice.
            // fino all'ultimo del ramo,
            // sara poi dovere dell'oggetto chiamante cercare nella  radice precedente.
            return(null);
        }
        /// <summary>
        /// Metodo che ritorna il prossimo elemento nell'albero del TreeView
        /// </summary>
        /// <param name="selectedScreen"></param>
        /// <returns></returns>
        internal TreeViewItemViewModel GetNextOrDefault(TreeViewItemViewModel selectedScreen)
        {
            if (selectedScreen == this)
            {
                if (Parent == null)                    // ovvero se è oggetto radice
                {
                    return(Children.FirstOrDefault()); // ritorna il primo dei children
                }
                else
                {
                    // chiedo al parent di darmi il successivo di quest'elemento
                    var nextScreen = Parent.GetNext(this);
                    if (nextScreen != null)
                    {
                        return(nextScreen);
                    }
                }
            }

            // prima devo vedere se selectedScreen è questo
            // il problema è che controllo solamente i children.

            foreach (var variable in Children)
            {
                var nextOrDefault = variable.GetNextOrDefault(selectedScreen);
                if (nextOrDefault != null)
                {
                    return(nextOrDefault);
                }
            }



            // se arrivo qui, significa che non è stato trovato niente dall'oggetto radice.
            // fino all'ultimo del ramo,
            // sara poi dovere dell'oggetto chiamante cercare nella prossima radice.
            return(null);
        }