treeviewfunc.cs

是一款式CSDN阅读器,可以方便CSDN用户阅读自己感兴趣的内容！

using System;
using System.Collections.Generic;
using System.Text;


using System.Windows.Forms;
using feiyun0112.cnblogs.com.CSDNReader.Controls;
using feiyun0112.cnblogs.com.CSDNReader.Model;

namespace feiyun0112.cnblogs.com.CSDNReader.Functions
{
    class TreeviewFunc
    {
        private TreeViewEx _treeRoom;
        public TreeViewEx TreeRoom
        {
            get { return _treeRoom; }
            set { _treeRoom = value; }
        }

        public TreeviewFunc(TreeViewEx tree)
        {
            TreeRoom=tree ;
        }

        public void  AddRoom(Room r)
        {
            RoomDBFunc db = new RoomDBFunc();
            if (!db.AddRoom(r))
                return;

            AddTreeNode(r);
        }

        private void AddTreeNode(Room r)
        {
            TreeNode nodeRoot = null;
            TreeRoom.BeginUpdate();
            try
            {
                if (TreeRoom.Nodes.Count == 0)
                {
                    nodeRoot = new TreeNode();
                    nodeRoot.Text = "CSDN";
                    nodeRoot.ImageIndex = 0;
                    nodeRoot.SelectedImageIndex = 0;
                    TreeRoom.Nodes.Add(nodeRoot);
                }

                if (r.GroupID != 0)
                {
                    nodeRoot = FindNode(TreeRoom.Nodes[0], r.GroupID);
                }
                if (nodeRoot == null)
                {
                    nodeRoot = TreeRoom.Nodes[0];
                }

                TreeNode node1 = new TreeNode();
                node1.Tag = r;
                node1.Text = r.Name;
                if (r.IsGroup)
                {
                    node1.ImageKey = "folder";
                    node1.SelectedImageKey = "folder";
                }
                else
                {
                    node1.ImageIndex = 1;
                    node1.SelectedImageIndex = 1;
                }
                if (r.GroupID > 0)
                {
                    Room rGroup = nodeRoot.Tag  as Room;
                    rGroup.ChildRooms.Add(r);
                }
                r.Tag = node1;
                nodeRoot.Nodes.Add(node1);


                TreeRoom.SelectedNode = node1;

            }
            finally
            {
                TreeRoom.EndUpdate();
                if (nodeRoot != null)
                {
                    nodeRoot.Expand();
                }
            }
        }

        public void EditRoom(Room oldr,Room r)
        {
            RoomDBFunc db = new RoomDBFunc();
            if (!db.EditRoom(oldr,r))
                return;

            EditTreeNode(oldr, r);
        }

        private void EditTreeNode(Room oldr, Room r)
        {
            TreeRoom.BeginUpdate();
            try
            {
                TreeNode nodeRoot = null;
                if (TreeRoom.Nodes.Count != 0)
                {
                    if (oldr.IsGroup == r.IsGroup && oldr.GroupID == r.GroupID)
                    {
                        nodeRoot = TreeRoom.Nodes[0];
                        TreeNode node1 = FindNode(nodeRoot, oldr.ID);
                        if (node1 != null)
                        {
                            node1.Tag = r;
                            node1.Text = r.Name;
                            r.Tag = node1;

                            return;
                        }
                    }
                    else
                    {
                        DelTreeNode(oldr);
                        AddTreeNode(r);
                    }
                }

            }
            finally
            {
                TreeRoom.EndUpdate();
                //TreeRoom.Nodes[0].Expand();
            }
        }

        public void DelRoom(Room room)
        {
            RoomDBFunc db = new RoomDBFunc();
            if (!db.DelRoom(room))
                return;

            DelTreeNode(room);
        }

        private void DelTreeNode(Room room)
        {
            TreeRoom.BeginUpdate();
            try
            {
                TreeNode nodeRoot = null;
                if (TreeRoom.Nodes.Count != 0)
                {
                    nodeRoot = TreeRoom.Nodes[0];
                    TreeNode node1 = FindNode(nodeRoot, room.ID);
                    if (node1 != null)
                    {
                        nodeRoot.Nodes.Remove(node1);

                        return;
                    }
                }

            }
            finally
            {
                TreeRoom.EndUpdate();
                //TreeRoom.Nodes[0].Expand();
            }
        }

        public TreeNode FindNode(TreeNode nodeRoot, int intRoomID)
        {
            foreach (TreeNode node1 in nodeRoot.Nodes)
            {
                Room tmpr = node1.Tag as Room;
                if (tmpr != null)
                {
                    if (tmpr.ID == intRoomID)
                    {
                        return node1;
                    }
                    else if (tmpr.IsGroup)
                    {
                        TreeNode node2 = FindNode(node1, intRoomID);
                        if (node2 != null)
                        {
                            return node2;
                        }
                    }
                }
                else
                {
                    TreeNode node2 = FindNode(node1, intRoomID);
                    if (node2 != null)
                    {
                        return node2;
                    }
                }
            }
            return null;
        }

        
        public void FillNode()
        {
            TreeRoom.BeginUpdate();
            
            TreeRoom.Nodes.Clear();
            TreeNode nodeRoot = new TreeNode();
            nodeRoot.Text = "CSDN";
            nodeRoot.ImageIndex = 0;
            nodeRoot.SelectedImageIndex = 0;
            TreeRoom.Nodes.Add(nodeRoot);

            try
            {
                RoomDBFunc db = new RoomDBFunc();                

                foreach (Room r in db.GetRooms())
                {
                    TreeNode node1 = new TreeNode();
                    node1.Tag = r;
                    node1.Text = r.Name;
                    if (r.IsGroup)
                    {
                        node1.ImageKey = "folder";
                        node1.SelectedImageKey = "folder";
                    }
                    else
                    {
                        node1.ImageIndex = 1;
                        node1.SelectedImageIndex = 1;
                    }
                    r.Tag = node1;
                    nodeRoot.Nodes.Add(node1);

                    if (r.IsGroup)
                    {
                        FillChildNodes(db, r, node1);
                    }
                }

            }
            finally
            {
                TreeRoom.EndUpdate();
                nodeRoot.Expand();                
            }
        }

        private static void FillChildNodes(RoomDBFunc db, Room r, TreeNode node1)
        {
            foreach (Room rChild in db.GetChildRooms(r.ID))
            {
                TreeNode node2 = new TreeNode();
                node2.Tag = rChild;
                node2.Text = rChild.Name;
                if (rChild.IsGroup)
                {
                    node2.ImageKey = "folder";
                    node2.SelectedImageKey = "folder";
                }
                else
                {
                    node2.ImageIndex = 1;
                    node2.SelectedImageIndex = 1;
                }
                rChild.Tag = node2;

                r.ChildRooms.Add(rChild);

                node1.Nodes.Add(node2);

                if (rChild.IsGroup)
                {
                    FillChildNodes(db, rChild, node2);
                }
            }
        }

        public void RefreshTreeview(TreeNodeCollection nodeRoot, int intRoomID, bool blnNoRead, bool blnCountChanged)
        {
 
            foreach (TreeNode n1 in nodeRoot )
            {
                Room r = n1.Tag as Room;
                if (r != null)
                {
                    if (r.ID  == intRoomID)
                    {
                        if (blnNoRead && r.UnreadItems != 0)
                        {
                            n1.NodeFont = Setting.Fonts.NoRead;                            
                        }
                        else if(r.UnreadItems==0)
                        {
                            n1.NodeFont = Setting.Fonts.Normal;
                        }

                         
                        n1.Text = n1.Text;
                         

                        RefreshGroup(r, blnNoRead,blnCountChanged);
                    }
                }    
                RefreshTreeview(n1.Nodes, intRoomID,   blnNoRead,   blnCountChanged);
            }        
        }

        private void RefreshGroup(Room r,  bool blnNoRead, bool blnCountChanged)
        {
            if (r.GroupID > 0)
            {
                TreeNode nodeGroup = FindNode(TreeRoom.Nodes[0], r.GroupID);
                if (nodeGroup != null)
                {
                    Room rGroup = nodeGroup.Tag as Room;
                    if (rGroup != null)
                    {
                        if (blnNoRead && rGroup.UnreadItems != 0)
                         {
                            nodeGroup.NodeFont = Setting.Fonts.NoRead;
                         }
                         else if (rGroup.UnreadItems == 0)
                         {
                             nodeGroup.NodeFont = Setting.Fonts.Normal;
                         }
                         
                            nodeGroup.Text = nodeGroup.Text;
                                              
                     
                    
                        RefreshGroup(rGroup, blnNoRead,blnCountChanged);
                    }
                }
            }
        }


        public void MarkRoomReaded(TreeNodeCollection nodeRoot, int intRoomID)
        {

            foreach (TreeNode n1 in nodeRoot)
            {
                Room rx = n1.Tag as Room;
                if (rx != null)
                {
                    if (rx.ID == intRoomID && !rx.IsGroup)
                    {
                        
                            n1.NodeFont = Setting.Fonts.Normal;
                            n1.Text = n1.Text;

                             
                             MarkGroupReaded(rx);
                             
                        
                    }
                }


                MarkRoomReaded(n1.Nodes, intRoomID);
            }
            
        }
        private void MarkChildReaded(TreeNode nodeRoot)
        {
            foreach (TreeNode n1 in nodeRoot.Nodes )
            {
                Room rx = n1.Tag as Room;
                if (rx != null)
                {
                    
                        
                            n1.NodeFont = Setting.Fonts.Normal;
                            n1.Text = n1.Text;

                            if (rx.IsGroup)
                            {
                                MarkChildReaded(n1);
                            }
                            else
                            {
                                 
                            }
                        
                     
                }

 
            }
        }


        private void MarkGroupReaded(Room rx)
        {
            if (rx.GroupID > 0)
            {
                TreeNode nodeGroup = FindNode(TreeRoom.Nodes[0], rx.GroupID);
                if (nodeGroup != null)
                {
                     
                        nodeGroup.NodeFont = Setting.Fonts.Normal;
                        nodeGroup.Text = nodeGroup.Text;
                     
                    Room rGroup = nodeGroup.Tag as Room;
                    if (rGroup != null)
                    {
                        MarkGroupReaded(rGroup);
                    } 
                }
            }
        }

        public void RefreRooms(TreeNodeCollection nodeRoot)
        {
            foreach (TreeNode n1 in nodeRoot)
            {

                Room r1 = (Room)n1.Tag;
                if (r1 != null)
                {
                    RoomFunc rFunc = new RoomFunc(r1);
                    r1.ManuleRefresh = false;
                    rFunc.RefreshRoom();

                }
                RefreRooms(n1.Nodes);
            }            
        }


        public TreeNode FindChildNode(TreeNode nodeRoot, bool blnAll)
        {
            foreach (TreeNode node in nodeRoot.Nodes)
            {
                if (blnAll)
                {
                    return node;
                }
                else
                {
                    Room r = node.Tag as Room;
                    if (r!=null && r.UnreadItems>0)
                    {
                        return node;
                    }
                }
            }
            return null;
        }

        public TreeNode FindChildNode(TreeNode node)
        {
            return FindChildNode(node, false);
        }

        public TreeNode SelectNode(TreeNode node)
        {
            Room r = node.Tag as Room;
            if (r != null)
            {
                if (r.IsGroup)
                {

                    TreeNode nodeChild = FindChildNode(node);
                    if (nodeChild == null)
                    {
                        nodeChild = FindChildNode(node, true);
                    }
                    return nodeChild;
                }
                else
                {
                    return node;
                }                
            }
            return null;
        }
    }
}