private void AddGroupNodes(GroupTreeNode groupNode)
        {
            IEnumerable <IGroup> childGroups = this.GetChildGroups(groupNode.Group);
            var nodes = new TreeListNodes(groupNode.Nodes, this.toolTipBuilder, this.favoriteIcons);

            nodes.InsertGroupNodes(childGroups);
        }
 internal void LoadGroupNodesRecursive(TreeListNodes nodes)
 {
     foreach (var groupNode in nodes.GroupNodes)
     {
         this.LoadGroupNode(groupNode);
         var childNodes = new TreeListNodes(groupNode.Nodes);
         this.LoadGroupNodesRecursive(childNodes);
     }
 }
 private static void InsertRecordedNode(GroupTreeNode todayGroup, HistoryRecordedEventArgs args)
 {
     IFavorite favorite = args.Favorite;
     if (favorite != null) // shouldnt happen, because the favorite was actualy processed
     {
         var nodes = new TreeListNodes(todayGroup.Nodes);
         nodes.InsertFavorite(favorite);
     }
 }
 internal void CheckChildNodesRecursive(bool checkState)
 {
     foreach (TreeNode node in this.nodes)
     {
         node.Checked = checkState;
         var childNodes = new TreeListNodes(node.Nodes);
         childNodes.CheckChildNodesRecursive(checkState);
     }
 }
 private void LoadGroupNodesRecursive(TreeListNodes nodes)
 {
     foreach (var groupNode in nodes.GroupNodes)
     {
         this.LoadGroupNode(groupNode);
         var childNodes = new TreeListNodes(groupNode.Nodes, this.toolTipBuilder, this.favoriteIcons);
         this.LoadGroupNodesRecursive(childNodes);
     }
 }
        public ExportForm(IPersistence persistence)
        {
            this.persistence = persistence;
            this.InitializeComponent();

            this.treeLoader = new FavoriteTreeListLoader(this.favsTree, this.persistence);
            this.treeLoader.LoadRootNodes();
            this.saveFileDialog.Filter = Integrations.Exporters.GetProvidersDialogFilter();
            this.rootNodes = new TreeListNodes(this.favsTree.Nodes);
        }
Exemple #7
0
        private void InsertRecordedNode(GroupTreeNode todayGroup, HistoryRecordedEventArgs args)
        {
            var favorite = args.Favorite;

            if (favorite != null) // shouldnt happen, because the favorite was actualy processed
            {
                var nodes = new TreeListNodes(todayGroup.Nodes, this.toolTipBuilder, this.favoriteIcons);
                nodes.InsertFavorite(favorite);
            }
        }
Exemple #8
0
        private static FavoriteTreeNode FindFavoriteNodeByName(TreeNode groupNode, IFavorite favorite)
        {
            if (groupNode == null)
            {
                return(null);
            }

            List <FavoriteTreeNode> favoriteNodes = TreeListNodes.FilterFavoriteNodes(groupNode.Nodes);

            return(favoriteNodes.FirstOrDefault(favoriteNode => favoriteNode.Favorite.StoreIdEquals(favorite)));
        }
        internal void LoadRootNodes()
        {
            if (persistedGroups == null) // because of designer
                return;

            var nodes = new TreeListNodes(this.RootNodes);
            // dont load everything, it is done by lazy loading after expand
            IOrderedEnumerable<IGroup> rootGroups = GetSortedRootGroups();
            nodes.InsertGroupNodes(rootGroups);
            List<IFavorite> untaggedFavorites = GetUntaggedFavorites(this.favorites);
            nodes.AddFavoriteNodes(untaggedFavorites);
        }
        private void LoadGroupNode(GroupTreeNode groupNode)
        {
            if (!groupNode.NotLoadedYet)
            {
                return;
            }

            groupNode.Nodes.Clear();
            this.AddGroupNodes(groupNode);
            var nodes = new TreeListNodes(groupNode.Nodes, this.toolTipBuilder, this.favoriteIcons);

            nodes.AddFavoriteNodes(groupNode.Favorites);
        }
        public void LoadRecursiveLoadsCompleateSubtree()
        {
            var treeView = new TestTreeView();
            var treeLoader = new FavoriteTreeListLoader(treeView, this.Persistence);
            treeLoader.LoadRootNodes(); // now we have 7 including Dummy nodes
            var rootNodes = new TreeListNodes(treeView.Nodes);

            treeLoader.LoadGroupNodesRecursive(rootNodes);
            int allLoadedCount = treeView.GetNodeCount(true);
            // or assert: treeView.Nodes[1].Nodes[0].Nodes[0].Name = "FavoriteA"
            // Dummy are replaced, and also Favorite nodes are included
            Assert.AreEqual(8, allLoadedCount, "Loading recursive subtree should load all nodes without expanding them");

            treeView.Dispose();
        }
        internal void LoadRootNodes()
        {
            if (persistedGroups == null) // because of designer
            {
                return;
            }

            var nodes = new TreeListNodes(this.RootNodes, this.toolTipBuilder, this.favoriteIcons);
            // dont load everything, it is done by lazy loading after expand
            IOrderedEnumerable <IGroup> rootGroups = GetSortedRootGroups();

            nodes.InsertGroupNodes(rootGroups);
            List <IFavorite> untaggedFavorites = GetUntaggedFavorites(this.favorites);

            nodes.AddFavoriteNodes(untaggedFavorites);
        }
 internal bool ContainsFavoriteNode(IFavorite favorite)
 {
     var nodes = new TreeListNodes(this.Nodes);
     return nodes.ContainsFavoriteNode(favorite);
 }
 /// <summary>
 /// Set the same check state to all childeren like this node has.
 /// </summary>
 internal void CheckChildsByParent()
 {
     var childNodes = new TreeListNodes(this.Nodes);
     childNodes.CheckChildNodesRecursive(this.Checked);
 }
Exemple #15
0
 /// <summary>
 /// Set the same check state to all childeren like this node has.
 /// </summary>
 internal void CheckChildsByParent()
 {
     TreeListNodes.CheckChildNodesRecursive(this.Nodes, this.Checked);
 }
Exemple #16
0
 internal bool ContainsFavoriteNode(IFavorite favorite)
 {
     return(TreeListNodes.ContainsFavoriteNode(this.Nodes, favorite));
 }
        private void LoadGroupNode(GroupTreeNode groupNode)
        {
            if (!groupNode.NotLoadedYet)
                return;

            groupNode.Nodes.Clear();
            this.AddGroupNodes(groupNode);
            var nodes = new TreeListNodes(groupNode.Nodes);
            nodes.AddFavoriteNodes(groupNode.Favorites);
        }
        private void FindAllCheckedFavorites(List<IFavorite> favorites)
        {
            var candidates = this.FindCheckedFavorites();
            favorites.AddRange(candidates);

            foreach (GroupTreeNode groupNode in this.GroupNodes)
            {
                // dont expect only Favorite nodes, because of group nodes on the same level
                groupNode.ExpandCheckedGroupNode();
                var childNodes = new TreeListNodes(groupNode.Nodes);
                childNodes.FindAllCheckedFavorites(favorites);
            }
        }
        private static FavoriteTreeNode FindFavoriteNodeByName(TreeNode groupNode, IFavorite favorite)
        {
            if (groupNode == null)
                return null;

            var nodes = new TreeListNodes(groupNode.Nodes);
            return nodes.FavoriteNodes.FirstOrDefault(favoriteNode => favoriteNode.Favorite.StoreIdEquals(favorite));
        }
        internal void LoadGroupNodesRecursive()
        {
            var rootNodes = new TreeListNodes(this.RootNodes, this.toolTipBuilder, this.favoriteIcons);

            this.LoadGroupNodesRecursive(rootNodes);
        }
 private void AddGroupNodes(GroupTreeNode groupNode)
 {
     IEnumerable<IGroup> childGroups = this.GetChildGroups(groupNode.Group);
     var nodes = new TreeListNodes(groupNode.Nodes);
     nodes.InsertGroupNodes(childGroups);
 }