tree_widget.cs

破解的飞信源代码

namespace Imps.Client.Pc.BizControls
{
    using Imps.Client.Pc;
    using Imps.Client.Utils;
    using std;
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Drawing;
    using System.Drawing.Drawing2D;
    using System.Drawing.Text;
    using System.Runtime.CompilerServices;
    using System.Windows.Forms;

    public class tree_widget : Control
    {
        private TreeDisplayMode _displayMode;
        private bool _f2Edit = true;
        private bool _handledMouseClick;
        private const int BlockBorder = 3;
        private const int BlockMargin = 3;
        private const int BlockSpace = 2;
        private IContainer components;
        public const string dragging_formats = "{66FFF7D8-C9A4-4a5d-9707-82D22DF3633F}";
        protected int item_edit_control_MaxLength = 0x40;
        private Image m_collapse_img;
        private Image m_expand_img;
        private bool m_fDragging;
        private bool m_fEditable;
        private bool m_fEditStartup;
        private bool m_fHCanScroll;
        private bool m_fHScrollable;
        private tree<item_type>.iterator m_first_visible_item = new tree<item_type>.iterator(true);
        private bool m_fIsScrolling;
        private crystal_band_colors m_focus_band_colors = new crystal_band_colors();
        private tree<item_type>.iterator m_focus_item = new tree<item_type>.iterator(true);
        private bool m_fToggling;
        private bool m_fVCanScroll;
        private bool m_fVScrollable = true;
        private crystal_band_colors m_hover_band_colors = new crystal_band_colors();
        private tree<item_type>.iterator m_hover_item = new tree<item_type>.iterator(true);
        private int m_indent = 0x10;
        protected item_edit_control m_item_edit;
        protected PictureBox m_item_edit_backGround;
        protected tree<item_type> m_items;
        private MouseEventArgs m_lastButtonDown = new MouseEventArgs(MouseButtons.Left, 0, -1, -1, 0);
        private System.Windows.Forms.Message m_lastLButtonDownMsg;
        private bool m_multi_select;
        private Cursor m_NormalCursor = Cursors.Default;
        private root_item_type m_root_item;
        private crystal_band_colors m_select_band_colors = new crystal_band_colors();
        private List<tree<item_type>.iterator> m_selected_items = new List<tree<item_type>.iterator>();
        protected const int WM_DOPAINT = 0x40a;
        protected const int WM_UPDATE_DRAGGING_IMG = 0x40b;

        public event tree_widget_item_handler ItemDoubleClick;

        public event OnFocusedItemChangedHandler OnFocusedItemChanged;

        public event OnHoverItemChangedHandler OnHoverItemChanged;

        public event OnSelectedItemsChangedHandler OnSelectedItemsChanged;

        public event PreAddSelectedItemHandler PreAddSelectedItem;

        public event PreFocusedItemChangingHandler PreFocusedItemChanging;

        public event PreHoverItemChangingHandler PreHoverItemChanging;

        public event PreSelectItemsHandler PreSelectItems;

        public tree_widget()
        {
            this.PreInitializeComponent();
            this.InitializeComponent();
            this.PostInitializeComponent();
        }

        private void add_selected_item(tree<item_type>.iterator item, bool fRepaint)
        {
            if ((item != null) && !tree<item_type>.iterator.is_equal(this.end, item))
            {
                if (!this.m_selected_items.Contains(item))
                {
                    if (this.PreAddSelectedItem != null)
                    {
                        cancel_event_args_t<tree<item_type>.iterator> args = new cancel_event_args_t<tree<item_type>.iterator>(false, item);
                        this.PreAddSelectedItem(this, args);
                        if (!args.Cancel)
                        {
                            this.m_selected_items.Add(item.clone);
                            if (this.OnSelectedItemsChanged != null)
                            {
                                this.OnSelectedItemsChanged(this);
                            }
                        }
                    }
                    else
                    {
                        this.m_selected_items.Add(item.clone);
                        if (this.OnSelectedItemsChanged != null)
                        {
                            this.OnSelectedItemsChanged(this);
                        }
                    }
                }
                if (fRepaint)
                {
                    this.draw_item(item);
                }
            }
        }

        private tree<item_type>.iterator browse_items(browse_item_handler handler, object context)
        {
            browse_item_helper_arg arg;
            tree<item_type>.iterator end = this.m_items.end;
            for (tree<item_type>.iterator item = this.first_item; item != this.m_items.end; item = arg.next_visible_item)
            {
                arg = new browse_item_helper_arg();
                arg.context = context;
                arg.item = item;
                arg.next_visible_item = this.next_visible_item(item);
                handler(arg);
                if (arg.hitted)
                {
                    end = item.clone;
                }
                if (arg.cancel)
                {
                    return end;
                }
            }
            return end;
        }

        private Rectangle CalcItemRect(browse_item_helper_arg arg)
        {
            int left;
            int right;
            Rectangle rectangle3;
            tree<item_type>.iterator item = arg.item;
            tree<item_type>.iterator iterator2 = arg.next_visible_item;
            paint_context context = (paint_context) arg.context;
            Rectangle canvas = context.canvas;
            int hoffset = context.hoffset;
            int voffset = context.voffset;
            int width = item.data.width;
            int height = item.data.height;
            tree<item_type>.iterator iterator3 = this.parent(item);
            bool flag = (iterator3 != null) && !iterator3.is_end;
            if ((hoffset == 0) && flag)
            {
                left = iterator3.data.bounds.Left + 1;
                if (this.DisplayMode == TreeDisplayMode.Line)
                {
                    left += this.m_indent;
                }
            }
            else
            {
                left = canvas.Left + hoffset;
            }
            if (flag)
            {
                right = iterator3.data.bounds.Right - 1;
            }
            else
            {
                right = canvas.Right;
            }
            if ((width > 0) && ((left + width) < right))
            {
                right = left + width;
            }
            int top = canvas.Top + voffset;
            int bottom = top + height;
            Rectangle rectangle2 = Rectangle.FromLTRB(left, top, right, bottom);
            if (item.data.ColoredBlock)
            {
                int num9;
                if (width > 0)
                {
                    num9 = rectangle2.Width;
                    rectangle2.Width += 6;
                }
                else
                {
                    num9 = rectangle2.Width - 6;
                }
                rectangle3 = new Rectangle(rectangle2.Left + 3, rectangle2.Top + 3, num9, rectangle2.Height);
                item.data.bounds = rectangle3;
                rectangle2.Height += 6;
                if (item.data.expand && item.has_children)
                {
                    int num10 = item.children_count;
                    int num11 = iterator2.data.width;
                    if (num11 > 0)
                    {
                        int num12 = (rectangle3.Width - 2) / (num11 + 1);
                        if (num12 < 1)
                        {
                            num12 = 1;
                        }
                        num10 = (int) Math.Ceiling((double) (((float) num10) / ((float) num12)));
                    }
                    rectangle2.Height += num10 * (iterator2.data.height + 1);
                }
                context.voffset += 3;
                context.items_height += 8;
            }
            else
            {
                if ((width <= 0) && !iterator3.is_end)
                {
                    rectangle3 = new Rectangle(iterator3.data.bounds.Left + 1, rectangle2.Top, iterator3.data.bounds.Width - 2, rectangle2.Height);
                }
                else
                {
                    rectangle3 = rectangle2;
                }
                item.data.bounds = rectangle2;
            }
            arg.item_rect = rectangle2;
            if (!iterator2.is_end)
            {
                int num13 = rectangle2.Right + 1;
                int num14 = iterator2.data.width;
                if (flag)
                {
                    right = iterator3.data.bounds.Right - 1;
                }
                else
                {
                    right = canvas.Right;
                }
                if ((num14 > 0) && ((num13 + num14) < right))
                {
                    context.hoffset = num13 - canvas.Left;
                    return rectangle3;
                }
                context.hoffset = 0;
                context.voffset += ++height;
                context.items_height += height;
                if (iterator2.data.ColoredBlock)
                {
                    context.voffset += 5;
                }
                return rectangle3;
            }
            context.items_height += ++height;
            return rectangle3;
        }

        protected void change_focus_item(tree<item_type>.iterator item, bool fRepaint)
        {
            if (!tree<item_type>.iterator.is_equal(item, this.m_focus_item))
            {
                if (this.PreFocusedItemChanging != null)
                {
                    cancel_event_args_t<tree<item_type>.iterator> args = new cancel_event_args_t<tree<item_type>.iterator>(false, item);
                    this.PreFocusedItemChanging(this, args);
                    if (!args.Cancel)
                    {
                        tree<item_type>.iterator clone = this.m_focus_item.clone;
                        this.m_focus_item.copy(item);
                        if (fRepaint)
                        {
                            this.draw_item(clone);
                            this.draw_item(this.m_focus_item);
                        }
                        if (this.OnFocusedItemChanged != null)
                        {
                            this.OnFocusedItemChanged(this);
                        }
                    }
                }
                else
                {
                    tree<item_type>.iterator iterator2 = this.m_focus_item.clone;
                    this.m_focus_item.copy(item);
                    if (fRepaint)
                    {
                        this.draw_item(iterator2);
                        this.draw_item(this.m_focus_item);
                    }
                    if (this.OnFocusedItemChanged != null)
                    {
                        this.OnFocusedItemChanged(this);
                    }
                }
            }
        }

        private void change_hover_item(tree<item_type>.iterator item, bool fRepaint)
        {
            if (!tree<item_type>.iterator.is_equal(this.m_hover_item, item))
            {
                if (this.PreHoverItemChanging != null)
                {
                    cancel_event_args_t<tree<item_type>.iterator> args = new cancel_event_args_t<tree<item_type>.iterator>(false, item);
                    this.PreHoverItemChanging(this, args);
                    if (!args.Cancel)
                    {
                        tree<item_type>.iterator clone = this.m_hover_item.clone;
                        this.m_hover_item.copy(item);
                        if (fRepaint)
                        {
                            this.draw_item(clone);
                            this.draw_item(this.m_hover_item);
                        }
                        if (this.OnHoverItemChanged != null)
                        {
                            this.OnHoverItemChanged(this);
                        }
                    }
                }
                else
                {
                    tree<item_type>.iterator iterator2 = this.m_hover_item.clone;
                    this.m_hover_item.copy(item);
                    if (fRepaint)
                    {
                        this.draw_item(iterator2);