treeviewfunc.cs

定义社区节点

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 TreeviewFunc()
        {
        }
        public static   void  AddRoom(Room r)
        {
            //RoomDBFunc db = new RoomDBFunc();
            if (!RoomDBFunc.AddRoom(r))
                return;

            AddTreeNode(r);
        }

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

                if (r.GroupID != 0)
                {
                    nodeRoot = FindNode(Variant.MainForm.TreeRoom.Nodes[0], r.GroupID);
                }
                if (nodeRoot == null)
                {
                    nodeRoot = Variant.MainForm.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)
                {
                    
                }
 
                nodeRoot.Nodes.Add(node1);


                Variant.MainForm.TreeRoom.SelectedNode = node1;

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

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

            EditTreeNode(oldr, r);
        }

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

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

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

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

            DelTreeNode(room);
        }

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

                        return;
                    }
                }

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

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

        public static 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 static void FillNode()
        {
            Variant.MainForm.TreeRoom.BeginUpdate();
            
            Variant.MainForm.TreeRoom.Nodes.Clear();
            TreeNode nodeRoot = new TreeNode();
            nodeRoot.Text = "CSDN";
            nodeRoot.ImageIndex = 0;
            nodeRoot.SelectedImageIndex = 0;
            Variant.MainForm.TreeRoom.Nodes.Add(nodeRoot);

            try
            {
               
                foreach (Room r in RoomDBFunc.GetRooms())
                {
                    AddNode(nodeRoot, r);
                }

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

        private static void AddNode(TreeNode nodeRoot, Room r)
        {
            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;
            }
             
            nodeRoot.Nodes.Add(node1);

            if (r.IsGroup)
            {
                 
                foreach (Room r1 in RoomDBFunc.GetChildRooms(r.ID))
                {
                    AddNode(node1, r1);
                }

            }
        }

       
        public static void RefreshTreeview(TreeNodeCollection nodeRoot, int intRoomID, bool blnNoRead, bool blnCountChanged)
        {
            TreeNode n1 = FindNode(Variant.MainForm.TreeRoom.Nodes[0], intRoomID);

            Room r = n1.Tag as Room;
            if (r != null)
            {
                System.Drawing.Font newFont = n1.NodeFont;

                if (blnNoRead && r.UnreadItems != 0)
                {
                    newFont = Setting.Fonts.NoRead;
                }
                else if (r.UnreadItems == 0)
                {
                    newFont = Setting.Fonts.Normal;
                }

                if (newFont != n1.NodeFont)
                {
                    n1.NodeFont = newFont;
                    n1.Text = n1.Text;

                    RefreshGroup(n1.Parent, newFont);
                }
                else if (Variant.MainForm.TreeRoom.Visible && n1.IsVisible)
                {
                    Variant.MainForm.TreeRoom.Invalidate(n1.Bounds);
                }                
            }
        }

        private static void RefreshGroup(TreeNode n1, System.Drawing.Font newFont)
        {            
            if (n1 != null)
            {
                Room rGroup = n1.Tag as Room;
                if (rGroup != null  && rGroup.IsGroup)
                {                     
                    
                    if (newFont != n1.NodeFont)
                    {
                        n1.NodeFont = newFont;
                        n1.Text = n1.Text;
                    }
                    else if (Variant.MainForm.TreeRoom.Visible && n1.IsVisible)
                    {
                        Variant.MainForm.TreeRoom.Invalidate(n1.Bounds);
                    }

                    RefreshGroup(n1.Parent, newFont);
                }
            }
        }


        public static 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 static void MarkGroupReaded(Room rx)
        {
            if (rx.GroupID > 0)
            {
                TreeNode nodeGroup = FindNode(Variant.MainForm.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 static void RefreRooms(TreeNodeCollection nodeRoot)
        {
            foreach (TreeNode n1 in nodeRoot)
            {

                Room r1 = (Room)n1.Tag;
                if (r1 != null)
                {                    
                    r1.ManuleRefresh = false;
                    r1.RefreshRoom();
                }
                RefreRooms(n1.Nodes);
            }            
        }


        public static   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 static    TreeNode FindChildNode(TreeNode node)
        {
            return FindChildNode(node, false);
        }

        public static    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;
        }
    }
}