source: branches/eraser6/Eraser/ToolBar.cs @ 492

Revision 492, 6.9 KB checked in by lowjoel, 6 years ago (diff)

This seems to be working already, remove the todo.

  • Property svn:keywords set to Id
Line 
1/*
2 * $Id$
3 * Copyright 2008 The Eraser Project
4 * Original Author: Joel Low <lowjoel@users.sourceforge.net>
5 * Modified By:
6 *
7 * This file is part of Eraser.
8 *
9 * Eraser is free software: you can redistribute it and/or modify it under the
10 * terms of the GNU General Public License as published by the Free Software
11 * Foundation, either version 3 of the License, or (at your option) any later
12 * version.
13 *
14 * Eraser is distributed in the hope that it will be useful, but WITHOUT ANY
15 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
16 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
17 *
18 * A copy of the GNU General Public License can be found at
19 * <http://www.gnu.org/licenses/>.
20 */
21
22using System;
23using System.Collections.Generic;
24using System.ComponentModel;
25using System.Data;
26using System.Drawing;
27using System.Text;
28using System.Windows.Forms;
29using System.Runtime.InteropServices;
30
31namespace Eraser
32{
33    public partial class ToolBar : Control
34    {
35        public ToolBar()
36        {
37            //Create the base component
38            InitializeComponent();
39
40            //Initialize the toolbar item list
41            items = new List<ToolBarItem>();
42
43            //Hook mouse move events to show the currently selected item
44            MouseMove += new MouseEventHandler(ToolBar_MouseMove);
45            MouseLeave += new EventHandler(ToolBar_MouseLeave);
46            MouseClick += new MouseEventHandler(ToolBar_MouseClick);
47        }
48
49        void ToolBar_MouseMove(object sender, MouseEventArgs e)
50        {
51            Redraw();
52        }
53
54        void ToolBar_MouseLeave(object sender, EventArgs e)
55        {
56            Redraw();
57        }
58
59        void ToolBar_MouseClick(object sender, MouseEventArgs e)
60        {
61            //See if the click was on any item's arrow.
62            Rectangle mouse_rect = new Rectangle(e.Location, new Size(1, 1));
63            foreach (ToolBarItem i in items)
64            {
65                if (i.Menu != null && mouse_rect.IntersectsWith(i.MenuRect))
66                {
67                    //Show the menu below the toolbar item.
68                    Point mouse_point = PointToScreen(i.Rectangle.Location);
69                    i.Menu.Show(mouse_point.X, mouse_point.Y + i.Rectangle.Height);
70                }
71                else if (mouse_rect.IntersectsWith(i.Rectangle))
72                {
73                    //Broadcast the item click event
74                    i.OnToolbarItemClicked(this);
75                }
76            }
77        }
78       
79        /// <summary>
80        /// Draws the Tool Bar on the given graphics object.
81        /// </summary>
82        /// <param name="dc">Graphics object to draw on.</param>
83        public void Draw(Graphics sdc)
84        {
85            //Create a backing bitmap buffer to prevent flicker
86            Bitmap back_bmp = new Bitmap(Width, Height);
87            Graphics dc = Graphics.FromImage(back_bmp);
88
89            //Draw the parent background image. This is not portable in that it will render
90            //this code unreusable, but for the lack of anything better this will have to suffice!
91            dc.DrawImage(Properties.Resources.BackgroundGradient, new Point(-Left, -Top));
92           
93            Point mouse_pos = PointToClient(MousePosition);
94            int x = 0;
95
96            foreach (ToolBarItem i in items)
97            {
98                {
99                    Point pos = i.Rectangle.Location;
100                    pos.X = x;
101                    pos.Y = 0;
102                    i.Rectangle.Location = pos;
103                }
104
105                if (i.Bitmap != null)
106                {
107                    i.BitmapRect = new Rectangle(x, 0, i.Bitmap.Width, i.Bitmap.Height);
108                    dc.DrawImage(i.Bitmap, i.BitmapRect);
109
110                    x += i.BitmapRect.Width + 4;
111                }
112
113                //Draw the toolbar item text
114                SizeF string_size = dc.MeasureString(i.Text, Font);
115                i.TextRect = new Rectangle(x, (int)(Height - string_size.Height) / 2,
116                    (int)string_size.Width, (int)string_size.Height);
117                dc.DrawString(i.Text, Font, Brushes.White, i.TextRect.Location);
118                x += i.TextRect.Width;
119               
120                //If there is a menu associated draw a drop-down glyph
121                if (i.Menu != null)
122                {
123                    Bitmap menu_arrow = Properties.Resources.ToolbarArrow;
124                    i.MenuRect = new Rectangle(x += 6, i.TextRect.Y,
125                        menu_arrow.Width, menu_arrow.Height);
126                    dc.DrawImage(menu_arrow, i.MenuRect);
127                    x += i.MenuRect.Width;
128                }
129
130                //Update the size of the item rectangle
131                {
132                    Size size = i.Rectangle.Size;
133                    size.Width = x - i.Rectangle.Location.X;
134                    size.Height = Height;
135                    i.Rectangle.Size = size;
136                }
137
138                //If the mouse cursor intersects with the item then draw an underline.
139                if (i.Rectangle.IntersectsWith(new Rectangle(mouse_pos, new Size(1, 1))))
140                    dc.DrawLine(Pens.White, new Point(i.TextRect.Left, i.TextRect.Bottom + 1),
141                        new Point(i.TextRect.Right, i.TextRect.Bottom + 1));
142
143                //Padding between items.
144                x += 16;
145            }
146
147            sdc.DrawImage(back_bmp, new Point(0, 0));
148        }
149
150        /// <summary>
151        /// Redraws the Tool Bar by creating a Graphics object.
152        /// </summary>
153        public void Redraw()
154        {
155            Draw(CreateGraphics());
156        }
157
158        /// <summary>
159        /// Paints the control.
160        /// </summary>
161        /// <param name="pe">Paint event object.</param>
162        protected override void OnPaint(PaintEventArgs pe)
163        {
164            Draw(pe.Graphics);
165
166            // Calling the base class OnPaint
167            base.OnPaint(pe);
168        }
169
170        /// <summary>
171        /// Stores the items in the Tool Bar.
172        /// </summary>
173        private List<ToolBarItem> items;
174
175        /// <summary>
176        /// Accesses or modifies the items in the tool bar.
177        /// </summary>
178        /// <param name="i">Index of item.</param>
179        /// <returns>ToolBarItem describing the item at index i.</returns>
180        public ToolBarItem this[int i]
181        {
182            get
183            {
184                return items[i];
185            }
186
187            set
188            {
189                items[i] = value;
190                Redraw();
191            }
192        }
193
194        public List<ToolBarItem> Items
195        {
196            get { return items; }
197            set { items = value; }
198        }
199    }
200
201    public class ToolBarItem
202    {
203        /// <summary>
204        /// Tool bar item text.
205        /// </summary>
206        [Description("Tool bar item text")]
207        public string Text
208        {
209            get { return text; }
210            set { text = value; }
211        }
212
213        /// <summary>
214        /// Item bitmap.
215        /// </summary>
216        [Description("Item Bitmap")]
217        public Bitmap Bitmap
218        {
219            get { return bitmap; }
220            set { bitmap = value; }
221        }
222
223        /// <summary>
224        /// Item drop-down menu
225        /// </summary>
226        public ContextMenuStrip Menu
227        {
228            get { return menu; }
229            set { menu = value; }
230        }
231
232        /// <summary>
233        /// Item click event handler
234        /// </summary>
235        public event ToolbarItemClickedEventFunction ToolbarItemClicked;
236        public delegate void ToolbarItemClickedEventFunction(object sender, EventArgs e);
237        internal void OnToolbarItemClicked(object sender)
238        {
239            if (ToolbarItemClicked != null)
240                ToolbarItemClicked(sender, new EventArgs());
241        }
242
243        private string text;
244        private Bitmap bitmap;
245        private ContextMenuStrip menu;
246
247        /// <summary>
248        /// Stores the rectangle of this item.
249        /// </summary>
250        internal Rectangle Rectangle = new Rectangle();
251
252        /// <summary>
253        /// Stores the rectangle of the bitmap.
254        /// </summary>
255        internal Rectangle BitmapRect;
256
257        /// <summary>
258        /// Stores the rectangle of the text.
259        /// </summary>
260        internal Rectangle TextRect;
261
262        /// <summary>
263        /// Stores the rectangle of the drop-down arrow.
264        /// </summary>
265        internal Rectangle MenuRect;
266    }
267}
Note: See TracBrowser for help on using the repository browser.