menu_drawer.cs

破解的飞信源代码

namespace Imps.Client.Pc.BizControls
{
    using System;
    using System.Drawing;
    using System.Drawing.Drawing2D;
    using System.Drawing.Text;
    using System.Windows.Forms;

    public class menu_drawer : menu_drawer_base
    {
        public static menu_drawer instance = new menu_drawer();
        private bool m_can_select_disableditem;
        private Color m_clr_background = Color.Snow;
        private Color m_clr_disabled_selected_text = Color.Gray;
        private Color m_clr_disabled_text = Color.Gray;
        private Color m_clr_frame = Color.Gray;
        private Color m_clr_selected = Color.FromKnownColor(KnownColor.Silver);
        private Color m_clr_selected_text = Color.Snow;
        private Color m_clr_separator = Color.Gray;
        private Color m_clr_text = Color.Black;

        protected menu_drawer()
        {
        }

        public override void draw(menu_widget menu, PaintEventArgs args)
        {
            if ((menu != null) && (args != null))
            {
                Rectangle rect = menu.ClientRectangle;
                if ((rect.Width > 0) && (rect.Height > 0))
                {
                    using (Bitmap image = new Bitmap(rect.Width, rect.Height))
                    {
                        using (Graphics g = Graphics.FromImage(image))
                        {
                            using (Brush brush = new SolidBrush(this.m_clr_background))
                            {
                                using (Pen pen = new Pen(this.m_clr_frame))
                                {
                                    g.FillRectangle(brush, 0, 0, image.Width, image.Height);
                                    if (menu.get_OwnerItem() != null)
                                    {
                                        Point location = menu.Bounds.Location;
                                        int num = menu.get_OwnerItem().get_Owner().PointToScreen(menu.get_OwnerItem().get_Bounds().Location).X - location.X;
                                        Point[] points = new Point[] { new Point(0, 0), new Point(0, image.Height - 1), new Point(image.Width - 1, image.Height - 1), new Point(image.Width - 1, 0) };
                                        g.DrawLines(pen, points);
                                        g.DrawLine(pen, 0, 0, num, 0);
                                        g.DrawLine(pen, (num + menu.get_OwnerItem().get_Size().Width) - 1, 0, image.Width - 1, 0);
                                    }
                                    else
                                    {
                                        g.DrawRectangle(pen, 0, 0, image.Width - 1, image.Height - 1);
                                    }
                                }
                            }
                            foreach (ToolStripItem item in menu.get_Items())
                            {
                                this.draw_item(menu, g, item);
                            }
                        }
                        args.Graphics.DrawImage(image, rect);
                    }
                }
            }
        }

        public override void draw_background(menu_widget menu, PaintEventArgs args)
        {
            this.draw(menu, args);
        }

        protected virtual void draw_item(menu_widget menu, Graphics g, ToolStripItem item)
        {
            if (item.get_Visible())
            {
                Rectangle clientRectangle = menu.ClientRectangle;
                Rectangle rcRawItem = item.get_Bounds();
                rcRawItem.Offset(-clientRectangle.Left, -clientRectangle.Top);
                if (item is ToolStripMenuItem)
                {
                    this.draw_menuitem(menu, g, (ToolStripMenuItem) item, rcRawItem);
                }
                else if (item is ToolStripSeparator)
                {
                    this.draw_separator(menu, g, (ToolStripSeparator) item, rcRawItem);
                }
            }
        }

        protected virtual void draw_menuitem(menu_widget menu, Graphics g, ToolStripMenuItem item, Rectangle rcRawItem)
        {
            Rectangle rect = Rectangle.FromLTRB(rcRawItem.Left + 1, rcRawItem.Top, rcRawItem.Right, rcRawItem.Bottom);
            if ((rect.Left < rect.Right) && (rect.Top < rect.Bottom))
            {
                Rectangle layoutRectangle = Rectangle.FromLTRB(rect.Left + menu.get_Padding().get_Left(), rect.Top, rect.Right - menu.get_Padding().get_Right(), rect.Bottom);
                if ((layoutRectangle.Left < layoutRectangle.Right) && (layoutRectangle.Top < layoutRectangle.Bottom))
                {
                    Color color;
                    if (item.get_Selected())
                    {
                        color = item.get_Enabled() ? this.m_clr_selected_text : this.m_clr_disabled_selected_text;
                        if (this.m_can_select_disableditem || item.get_Enabled())
                        {
                            g.FillRectangle(new SolidBrush(this.m_clr_selected), rect);
                        }
                    }
                    else
                    {
                        color = item.get_Enabled() ? this.m_clr_text : this.m_clr_disabled_text;
                    }
                    FontStyle newStyle = item.get_Font().Style;
                    using (Font font = new Font(SystemFonts.get_MenuFont(), newStyle))
                    {
                        using (Brush brush = new SolidBrush(color))
                        {
                            StringFormat format = new StringFormat();
                            format.Alignment = StringAlignment.Near;
                            format.LineAlignment = StringAlignment.Center;
                            format.HotkeyPrefix = menu.UseMnemonic ? HotkeyPrefix.Show : HotkeyPrefix.None;
                            g.DrawString(item.get_Text(), font, brush, layoutRectangle, format);
                            int y = rect.Top + ((rect.Height - 0x10) / 2);
                            if (item.get_Image() != null)
                            {
                                Rectangle rectangle3 = new Rectangle(layoutRectangle.Left - 0x11, y, 0x10, 0x10);
                                g.DrawImage(item.get_Image(), rectangle3);
                            }
                            if (((item.get_DropDown() != null) && (0 < item.get_DropDown().get_Items().get_Count())) || ((item.get_DropDownItems() != null) && (0 < item.get_DropDownItems().get_Count())))
                            {
                                draw_tools.draw_simple_arrow(g, (rect.Right - item.get_Padding().get_Right()) - 8, rect.Top + ((rect.Height - 6) / 2), 7, color, draw_tools.arrow_type.right);
                            }
                            else
                            {
                                Rectangle rectangle4 = new Rectangle(rect.Left, y, 0x10, 0x10);
                                if (item is menu_radioitem)
                                {
                                    if (((menu_radioitem) item).Radioed)
                                    {
                                        draw_tools.draw_radio_flag(g, rectangle4, color);
                                    }
                                }
                                else if (item.get_Checked() && (item.get_CheckState() != CheckState.Unchecked))
                                {
                                    draw_tools.draw_check_flag(g, rectangle4, color);
                                }
                                if (item.get_ShortcutKeys() != Keys.None)
                                {
                                    if ((item.get_ShortcutKeyDisplayString() != null) && (0 < item.get_ShortcutKeyDisplayString().Length))
                                    {
                                        StringFormat format2 = new StringFormat();
                                        format2.Alignment = StringAlignment.Far;
                                        format2.LineAlignment = StringAlignment.Center;
                                        format2.HotkeyPrefix = HotkeyPrefix.None;
                                        g.DrawString(item.get_ShortcutKeyDisplayString(), font, new SolidBrush(color), layoutRectangle, format2);
                                    }
                                    else
                                    {
                                        string s = string.Empty;
                                        if (Keys.Control == (item.get_ShortcutKeys() & Keys.Control))
                                        {
                                            s = s + "Ctrl+" + (item.get_ShortcutKeys() & ~Keys.Control);
                                        }
                                        else if (Keys.Alt == (item.get_ShortcutKeys() & Keys.Alt))
                                        {
                                            s = s + "Alt+" + (item.get_ShortcutKeys() & ~Keys.Alt);
                                        }
                                        else if (Keys.Shift == (item.get_ShortcutKeys() & Keys.Shift))
                                        {
                                            s = s + "Shift+" + (item.get_ShortcutKeys() & ~Keys.Shift);
                                        }
                                        else
                                        {
                                            s = s + item.get_ShortcutKeys().ToString();
                                        }
                                        StringFormat format3 = new StringFormat();
                                        format3.Alignment = StringAlignment.Far;
                                        format3.LineAlignment = StringAlignment.Center;
                                        format3.HotkeyPrefix = HotkeyPrefix.None;
                                        g.DrawString(s, font, new SolidBrush(color), layoutRectangle, format3);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        protected virtual void draw_separator(menu_widget menu, Graphics g, ToolStripSeparator item, Rectangle rcRawItem)
        {
            int left = rcRawItem.Left + 2;
            int top = rcRawItem.Top + (rcRawItem.Height / 2);
            int right = rcRawItem.Right - 3;
            Rectangle rect = Rectangle.FromLTRB(left, top, right, top + 1);
            LinearGradientBrush brush = new LinearGradientBrush(rect, this.m_clr_separator, this.m_clr_background, LinearGradientMode.Horizontal);
            g.FillRectangle(brush, rect);
        }

        public Color background_color
        {
            get
            {
                return this.m_clr_background;
            }
            set
            {
                this.m_clr_background = value;
            }
        }

        public bool can_select_disableditem
        {
            get
            {
                return this.m_can_select_disableditem;
            }
            set
            {
                this.m_can_select_disableditem = value;
            }
        }

        public Color disabled_selectedtext_color
        {
            get
            {
                return this.m_clr_disabled_selected_text;
            }
            set
            {
                this.m_clr_disabled_selected_text = value;
            }
        }

        public Color disabledtext_color
        {
            get
            {
                return this.m_clr_disabled_text;
            }
            set
            {
                this.m_clr_disabled_text = value;
            }
        }

        public Color frame_color
        {
            get
            {
                return this.m_clr_frame;
            }
            set
            {
                this.m_clr_frame = value;
            }
        }

        public Color highlight_color
        {
            get
            {
                return this.m_clr_selected;
            }
            set
            {
                this.m_clr_selected = value;
            }
        }

        public Color selectedtext_color
        {
            get
            {
                return this.m_clr_selected_text;
            }
            set
            {
                this.m_clr_selected_text = value;
            }
        }

        public Color separator_color
        {
            get
            {
                return this.m_clr_separator;
            }
            set
            {
                this.m_clr_separator = value;
            }
        }

        public Color text_color
        {
            get
            {
                return this.m_clr_text;
            }
            set
            {
                this.m_clr_text = value;
            }
        }
    }
}