linux-packaging-mono/mcs/class/Managed.Windows.Forms/System.Windows.Forms/ToolBar.cs

// System.Windows.Forms.ToolBar.cs
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// Author:
//	Ravindra (rkumar@novell.com)
//	Mike Kestner <mkestner@novell.com>
//	Everaldo Canuto <ecanuto@novell.com>
//
// Copyright (C) 2004-2006  Novell, Inc. (http://www.novell.com)
//

using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Drawing;
using System.Drawing.Text;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;

namespace System.Windows.Forms
{
	[ComVisible (true)]
	[ClassInterface (ClassInterfaceType.AutoDispatch)]
	[DefaultEvent ("ButtonClick")]
	[DefaultProperty ("Buttons")]
	[Designer ("System.Windows.Forms.Design.ToolBarDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
	public class ToolBar : Control
	{
		#region Instance Variables
		private bool size_specified = false;
		private ToolBarItem current_item;
		internal ToolBarItem[] items;
		internal Size default_size;
		#endregion Instance Variables

		#region Events
		static object ButtonClickEvent = new object ();
		static object ButtonDropDownEvent = new object ();

		[Browsable (true)]
		[EditorBrowsable (EditorBrowsableState.Always)]
		public new event EventHandler AutoSizeChanged {
			add { base.AutoSizeChanged += value; }
			remove { base.AutoSizeChanged -= value; }
		}

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public new event EventHandler BackColorChanged {
			add { base.BackColorChanged += value; }
			remove { base.BackColorChanged -= value; }
		}

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public new event EventHandler BackgroundImageChanged {
			add { base.BackgroundImageChanged += value; }
			remove { base.BackgroundImageChanged -= value; }
		}

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public new event EventHandler BackgroundImageLayoutChanged {
			add { base.BackgroundImageLayoutChanged += value; }
			remove { base.BackgroundImageLayoutChanged -= value; }
		}

		public event ToolBarButtonClickEventHandler ButtonClick {
			add { Events.AddHandler (ButtonClickEvent, value); }
			remove {Events.RemoveHandler (ButtonClickEvent, value); }
		}

		public event ToolBarButtonClickEventHandler ButtonDropDown {
			add { Events.AddHandler (ButtonDropDownEvent, value); }
			remove {Events.RemoveHandler (ButtonDropDownEvent, value); }
		}

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public new event EventHandler ForeColorChanged {
			add { base.ForeColorChanged += value; }
			remove { base.ForeColorChanged -= value; }
		}

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public new event EventHandler ImeModeChanged {
			add { base.ImeModeChanged += value; }
			remove { base.ImeModeChanged -= value; }
		}

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public new event PaintEventHandler Paint {
			add { base.Paint += value; }
			remove { base.Paint -= value; }
		}

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public new event EventHandler RightToLeftChanged {
			add { base.RightToLeftChanged += value; }
			remove { base.RightToLeftChanged -= value; }
		}

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public new event EventHandler TextChanged {
			add { base.TextChanged += value; }
			remove { base.TextChanged -= value; }
		}
		#endregion Events

		#region Constructor
		public ToolBar ()
		{
			background_color = ThemeEngine.Current.DefaultControlBackColor;
			foreground_color = ThemeEngine.Current.DefaultControlForeColor;
			buttons = new ToolBarButtonCollection (this);
			Dock = DockStyle.Top;
			
			GotFocus += new EventHandler (FocusChanged);
			LostFocus += new EventHandler (FocusChanged);
			MouseDown += new MouseEventHandler (ToolBar_MouseDown);
			MouseHover += new EventHandler (ToolBar_MouseHover);
			MouseLeave += new EventHandler (ToolBar_MouseLeave);
			MouseMove += new MouseEventHandler (ToolBar_MouseMove);
			MouseUp += new MouseEventHandler (ToolBar_MouseUp);
			BackgroundImageChanged += new EventHandler (ToolBar_BackgroundImageChanged);

			TabStop = false;
			
			SetStyle (ControlStyles.UserPaint, false);
			SetStyle (ControlStyles.FixedHeight, true);
			SetStyle (ControlStyles.FixedWidth, false);
		}
		#endregion Constructor

		#region protected Properties
		protected override CreateParams CreateParams {
			get { 
				CreateParams create_params = base.CreateParams;
				
				if (appearance == ToolBarAppearance.Flat) {
					create_params.Style |= (int) ToolBarStyles.TBSTYLE_FLAT;
				}
				
				return create_params;
			}
		}

		protected override ImeMode DefaultImeMode {
			get { return ImeMode.Disable; }
		}

		protected override Size DefaultSize {
			get { return ThemeEngine.Current.ToolBarDefaultSize; }
		}

		[EditorBrowsable (EditorBrowsableState.Never)]
		protected override bool DoubleBuffered {
			get { return base.DoubleBuffered; }
			set { base.DoubleBuffered = value; }
		}
		#endregion

		ToolBarAppearance appearance = ToolBarAppearance.Normal;

		#region Public Properties
		[DefaultValue (ToolBarAppearance.Normal)]
		[Localizable (true)]
		public ToolBarAppearance Appearance {
			get { return appearance; }
			set {
				if (value == appearance)
					return;

				appearance = value;
				Redraw (true);
			}
		}

		bool autosize = true;

		[Browsable (true)]
		[DesignerSerializationVisibility (DesignerSerializationVisibility.Visible)]
		[EditorBrowsable (EditorBrowsableState.Always)]
		[DefaultValue (true)]
		[Localizable (true)]
		public override bool AutoSize {
			get { return autosize; }
			set {
				if (value == autosize)
					return;

				autosize = value;
				
				if (IsHandleCreated)
					Redraw (true);
			}
		}

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public override Color BackColor {
			get { return background_color; }
			set {
				if (value == background_color)
					return;

				background_color = value;
				OnBackColorChanged (EventArgs.Empty);
				Redraw (false);
			}
		}

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public override Image BackgroundImage {
			get { return base.BackgroundImage; }
			set { base.BackgroundImage = value; }
		}

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public override ImageLayout BackgroundImageLayout {
			get { return base.BackgroundImageLayout; }
			set { base.BackgroundImageLayout = value; }
		}

		[DefaultValue (BorderStyle.None)]
		[DispIdAttribute (-504)]
		public BorderStyle BorderStyle {
			get { return InternalBorderStyle; }
			set { InternalBorderStyle = value; }
		}

		ToolBarButtonCollection buttons;

		[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
		[Localizable (true)]
		[MergableProperty (false)]
		public ToolBarButtonCollection Buttons {
			get { return buttons; }
		}

		Size button_size;

		[Localizable (true)]
		[RefreshProperties (RefreshProperties.All)]
		public Size ButtonSize {
			get {
				if (!button_size.IsEmpty)
					return button_size; 
				
				if (buttons.Count == 0)
					return new Size (39, 36);
					
				Size result = CalcButtonSize ();
				if (result.IsEmpty)
					return new Size (24, 22);
				else
					return result;
			}
			set {
				size_specified = value != Size.Empty;
				if (button_size == value)
					return;

				button_size = value;
				Redraw (true);
			}
		}

		bool divider = true;

		[DefaultValue (true)]
		public bool Divider {
			get { return divider; }
			set {
				if (value == divider)
					return;

				divider = value;
				Redraw (false);
			}
		}

		[DefaultValue (DockStyle.Top)]
		[Localizable (true)]
		public override DockStyle Dock {
			get { return base.Dock; }
			set {
				if (base.Dock == value) {
					// Call base anyways so layout_type gets set correctly
					if (value != DockStyle.None)
						base.Dock = value;
					return;
				}
					
				if (Vertical) {
					SetStyle (ControlStyles.FixedWidth, AutoSize);
					SetStyle (ControlStyles.FixedHeight, false);
				} else {
					SetStyle (ControlStyles.FixedHeight, AutoSize);
					SetStyle (ControlStyles.FixedWidth, false);
				}
				
				LayoutToolBar ();
				
				base.Dock = value;
			}
		}

		bool drop_down_arrows = true;

		[DefaultValue (false)]
		[Localizable (true)]
		public bool DropDownArrows {
			get { return drop_down_arrows; }
			set {
				if (value == drop_down_arrows)
					return;

				drop_down_arrows = value;
				Redraw (true);
			}
		}

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public override Color ForeColor {
			get { return foreground_color; }
			set {
				if (value == foreground_color)
					return;

				foreground_color = value;
				OnForeColorChanged (EventArgs.Empty);
				Redraw (false);
			}
		}

		ImageList image_list;

		[DefaultValue (null)]
		public ImageList ImageList {
			get { return image_list; }
			set { 
				if (image_list == value)
					return;
				image_list = value;
				Redraw (true);
			}
		}

		[Browsable (false)]
		[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		public Size ImageSize {
			get {
				if (ImageList == null)
					return Size.Empty;

				return ImageList.ImageSize;
			}
		}

		// XXX this should probably go away and it should call
		// into Control.ImeMode instead.
		ImeMode ime_mode = ImeMode.Disable;

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public new ImeMode ImeMode {
			get { return ime_mode; }
			set {
				if (value == ime_mode)
					return;

				ime_mode = value;
				OnImeModeChanged (EventArgs.Empty);
			}
		}

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public override RightToLeft RightToLeft {
			get { return base.RightToLeft; }
			set {
				if (value == base.RightToLeft)
					return;

				base.RightToLeft = value;
				OnRightToLeftChanged (EventArgs.Empty);
			}
		}

		// Default value is "false" but after make a test in .NET we get "true" result as default.  
		bool show_tooltips = true;

		[DefaultValue (false)]
		[Localizable (true)]
		public bool ShowToolTips {
			get { return show_tooltips; }
			set { show_tooltips = value; }
		}

		[DefaultValue (false)]
		public new bool TabStop {
			get { return base.TabStop; }
			set { base.TabStop = value; }
		}

		[Bindable (false)]
		[Browsable (false)]
		[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public override string Text {
			get { return base.Text; } 
			set {
				if (value == base.Text)
					return;

				base.Text = value;
				Redraw (true);
			}
		}

		ToolBarTextAlign text_alignment = ToolBarTextAlign.Underneath;

		[DefaultValue (ToolBarTextAlign.Underneath)]
		[Localizable (true)]
		public ToolBarTextAlign TextAlign {
			get { return text_alignment; }
			set {
				if (value == text_alignment)
					return;

				text_alignment = value;
				Redraw (true);
			}
		}

		bool wrappable = true;

		[DefaultValue (true)]
		[Localizable (true)]
		public bool Wrappable {
			get { return wrappable; }
			set {
				if (value == wrappable)
					return;

				wrappable = value;
				Redraw (true);
			}
		}
		#endregion Public Properties

		#region Public Methods
		public override string ToString ()
		{
			int count = this.Buttons.Count;

			if (count == 0)
				return string.Format ("System.Windows.Forms.ToolBar, Buttons.Count: 0");
			else
				return string.Format ("System.Windows.Forms.ToolBar, Buttons.Count: {0}, Buttons[0]: {1}",
						      count, this.Buttons [0].ToString ());
		}
		#endregion Public Methods

		#region Protected Methods
		protected override void CreateHandle ()
		{
			base.CreateHandle ();
			default_size = CalcButtonSize ();
			
			// In win32 the recalculate size only happens for not flat style
			if (appearance != ToolBarAppearance.Flat)
				Redraw (true);
		}

		protected override void Dispose (bool disposing)
		{
			if (disposing)
				ImageList = null;

			base.Dispose (disposing);
		}

		private ToolBarButton button_for_focus = null;
		
		internal void UIAPerformClick (ToolBarButton button)
		{
			ToolBarItem previous_item = current_item;
			current_item = null;
			
			foreach (ToolBarItem item in items)
				if (item.Button == button) {
					current_item = item;
					break;
				}

			try {
				if (current_item == null)
					throw new ArgumentException ("button", "The button specified is not part of this toolbar");
				PerformButtonClick (new ToolBarButtonClickEventArgs (button));
			} finally {
				current_item = previous_item;
			}
		}
		
		void PerformButtonClick (ToolBarButtonClickEventArgs e)
		{
			// Only change pushed for ToogleButton
			if (e.Button.Style == ToolBarButtonStyle.ToggleButton) {
				if (! e.Button.Pushed)
					e.Button.Pushed = true;
				else
					e.Button.Pushed = false;
			}
			
			current_item.Pressed = false;
			current_item.Invalidate ();
			
			button_for_focus = current_item.Button;
			button_for_focus.UIAHasFocus = true;

			OnButtonClick (e);
		}

		protected virtual void OnButtonClick (ToolBarButtonClickEventArgs e)
		{			
			ToolBarButtonClickEventHandler eh = (ToolBarButtonClickEventHandler)(Events [ButtonClickEvent]);
			if (eh != null)
				eh (this, e);
		}

		protected virtual void OnButtonDropDown (ToolBarButtonClickEventArgs e) 
		{
			ToolBarButtonClickEventHandler eh = (ToolBarButtonClickEventHandler)(Events [ButtonDropDownEvent]);
			if (eh != null)
				eh (this, e);

			if (e.Button.DropDownMenu == null)
				return;

			ShowDropDownMenu (current_item);
		}

		internal void ShowDropDownMenu (ToolBarItem item)
		{
			Point loc = new Point (item.Rectangle.X + 1, item.Rectangle.Bottom + 1);
			((ContextMenu) item.Button.DropDownMenu).Show (this, loc);

			item.DDPressed = false;
			item.Hilight = false;
			item.Invalidate ();
		}

		protected override void OnFontChanged (EventArgs e)
		{
			base.OnFontChanged (e);
			Redraw (true);
		}

		protected override void OnHandleCreated (EventArgs e)
		{
			base.OnHandleCreated (e);
		}

		protected override void OnResize (EventArgs e)
		{
			base.OnResize (e);
			LayoutToolBar ();
		}

		protected override void ScaleControl (SizeF factor, BoundsSpecified specified)
		{
			specified &= ~BoundsSpecified.Height;
			
			base.ScaleControl (factor, specified);
		}

		[EditorBrowsable (EditorBrowsableState.Never)]
		protected override void ScaleCore (float dx, float dy)
		{
			dy = 1.0f;
			
			base.ScaleCore (dx, dy);
		}

		private int requested_size = -1;

		protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified)
		{
			if (Vertical) {
				if (!AutoSize && (requested_size != width) && ((specified & BoundsSpecified.Width) != BoundsSpecified.None)) 
					requested_size = width;
			} else {
				if (!AutoSize && (requested_size != height) && ((specified & BoundsSpecified.Height) != BoundsSpecified.None)) 
					requested_size = height;
			}
			
			base.SetBoundsCore (x, y, width, height, specified);
		}

		protected override void WndProc (ref Message m)
		{
			base.WndProc (ref m);
		}

		internal override bool InternalPreProcessMessage (ref Message msg)
		{
			if (msg.Msg == (int)Msg.WM_KEYDOWN) {
				Keys key_data = (Keys)msg.WParam.ToInt32();
				if (HandleKeyDown (ref msg, key_data))
					return true;
			} 
			return base.InternalPreProcessMessage (ref msg);
		}
			
		#endregion Protected Methods

		#region Private Methods
		internal int CurrentItem {
			get {
				return Array.IndexOf (items, current_item);
			}
			set {
				if (current_item != null)
					current_item.Hilight = false;

				current_item = value == -1 ? null : items [value];

				if (current_item != null)
					current_item.Hilight = true;
			}

		}

		private void FocusChanged (object sender, EventArgs args)
		{
			if (!Focused && button_for_focus != null)
				button_for_focus.UIAHasFocus = false;
			button_for_focus = null;
			
			if (Appearance != ToolBarAppearance.Flat || Buttons.Count == 0)
				return;

			ToolBarItem prelit = null;
			foreach (ToolBarItem item in items) {
				if (item.Hilight) {
					prelit = item;
					break;
				}
			}

			if (Focused && prelit == null) {
				foreach (ToolBarItem item in items) {
					if (item.Button.Enabled) {
						item.Hilight = true;
						break;
					}
				}
			} else if (prelit != null) {
				prelit.Hilight = false;
			}
		}

		private bool HandleKeyDown (ref Message msg, Keys key_data)
		{
			if (Appearance != ToolBarAppearance.Flat || Buttons.Count == 0)
				return false;

			// Handle the key as needed if the current item is a dropdownbutton.
			if (HandleKeyOnDropDown (ref msg, key_data))
				return true;

			switch (key_data) {
				case Keys.Left:
				case Keys.Up:
					HighlightButton (-1);
					return true;
				case Keys.Right:
				case Keys.Down:
					HighlightButton (1);
					return true;
				case Keys.Enter:
				case Keys.Space:
					if (current_item != null) {
						OnButtonClick (new ToolBarButtonClickEventArgs (current_item.Button));
						return true;
					}
					break;
			}

			return false;
		}

		bool HandleKeyOnDropDown (ref Message msg, Keys key_data)
		{
			if (current_item == null || current_item.Button.Style != ToolBarButtonStyle.DropDownButton ||
					current_item.Button.DropDownMenu == null)
				return false;

			Menu dropdown_menu = current_item.Button.DropDownMenu;

			if (dropdown_menu.Tracker.active) {
				dropdown_menu.ProcessCmdKey (ref msg, key_data);
				return true; // always true if the menu is active
			}

			if (key_data == Keys.Up || key_data == Keys.Down) {
				current_item.DDPressed = true;
				current_item.Invalidate ();
				OnButtonDropDown (new ToolBarButtonClickEventArgs (current_item.Button));
				return true;
			}

			return false;
		}

		void HighlightButton (int offset)
		{
			ArrayList enabled = new ArrayList ();
			int count = 0;
			int start = -1;
			ToolBarItem curr_item = null;
			foreach (ToolBarItem item in items) {
				if (item.Hilight) {
					start = count;
					curr_item = item;
				}

				if (item.Button.Enabled) {
					enabled.Add (item);
					count++;
				}
			}

			int next = (start + offset) % count;
			if (next < 0)
				next = count - 1;

			if (next == start)
				return;

			if (curr_item != null)
				curr_item.Hilight = false;

			current_item = enabled [next] as ToolBarItem;
			current_item.Hilight = true;
		}

		private void ToolBar_BackgroundImageChanged (object sender, EventArgs args)
		{
			Redraw (false, true);
		}

		private void ToolBar_MouseDown (object sender, MouseEventArgs me)
		{
			if ((!Enabled) || ((me.Button & MouseButtons.Left) == 0))
				return;

			Point loc = new Point (me.X, me.Y);

			if (ItemAtPoint (loc) == null)
				return;
			
			// Hide tooltip when left mouse button 
			if ((tip_window != null) && (tip_window.Visible) && ((me.Button & MouseButtons.Left) == MouseButtons.Left)) {
				TipDownTimer.Stop ();
				tip_window.Hide (this);
			}
			
			// draw the pushed button
			foreach (ToolBarItem item in items) {
				if (item.Button.Enabled && item.Rectangle.Contains (loc)) {
					// Mark the DropDown rect as pressed.
					// We don't redraw the dropdown rect.
					if (item.Button.Style == ToolBarButtonStyle.DropDownButton) {
						Rectangle rect = item.Rectangle;
						if (DropDownArrows) {
							rect.Width = ThemeEngine.Current.ToolBarDropDownWidth;
							rect.X = item.Rectangle.Right - rect.Width;
						}
						
						if (rect.Contains (loc)) {
							if (item.Button.DropDownMenu != null) {
								item.DDPressed = true;
								Invalidate (rect);
							}
							break;
						}
					}
					item.Pressed = true;
					item.Inside = true;
					item.Invalidate ();
					break;
				}
			}
		}

		private void ToolBar_MouseUp (object sender, MouseEventArgs me)
		{
			if ((!Enabled) || ((me.Button & MouseButtons.Left) == 0))
				return;

			Point loc = new Point (me.X, me.Y);

			// draw the normal button
			// Make a copy in case the list is modified during enumeration
			ArrayList items = new ArrayList (this.items);
			foreach (ToolBarItem item in items) {
				if (item.Button.Enabled && item.Rectangle.Contains (loc)) {
					if (item.Button.Style == ToolBarButtonStyle.DropDownButton) {
						Rectangle ddRect = item.Rectangle;
						ddRect.Width = ThemeEngine.Current.ToolBarDropDownWidth;
						ddRect.X = item.Rectangle.Right - ddRect.Width;
						if (ddRect.Contains (loc)) {
							current_item = item;
							if (item.DDPressed)
								OnButtonDropDown (new ToolBarButtonClickEventArgs (item.Button));
							continue;
						}
					}
					// Fire a ButtonClick
					current_item = item;
					if ((item.Pressed) && ((me.Button & MouseButtons.Left) == MouseButtons.Left))
						PerformButtonClick (new ToolBarButtonClickEventArgs (item.Button));
				} else if (item.Pressed) {
					item.Pressed = false;
					item.Invalidate ();
				}
			}
		}

		private ToolBarItem ItemAtPoint (Point pt)
		{
			foreach (ToolBarItem item in items)
				if (item.Rectangle.Contains (pt)) 
					return item;

			return null;
		}

		ToolTip tip_window = null;
		Timer tipdown_timer = null;

		private void PopDownTip (object o, EventArgs args)
		{
			tip_window.Hide (this);
		}

		private Timer TipDownTimer {
			get {
				if (tipdown_timer == null) {
					tipdown_timer = new Timer ();
					tipdown_timer.Enabled = false;
					tipdown_timer.Interval = 5000;
					tipdown_timer.Tick += new EventHandler (PopDownTip);
				}
				return tipdown_timer;
			}
		}

		private void ToolBar_MouseHover (object sender, EventArgs e)
		{
			if (Capture)
				return;

			if (tip_window == null)
				tip_window = new ToolTip ();

			ToolBarItem item = ItemAtPoint (PointToClient (Control.MousePosition));
			current_item = item;

			if (item == null || item.Button.ToolTipText.Length == 0)
				return;

			tip_window.Present (this, item.Button.ToolTipText);
			TipDownTimer.Start ();
		}

		private void ToolBar_MouseLeave (object sender, EventArgs e)
		{
			if (tipdown_timer != null)
				tipdown_timer.Dispose ();
			tipdown_timer = null;
			if (tip_window != null)
				tip_window.Dispose ();
			tip_window = null;

			if (!Enabled || current_item == null) 
				return;

			current_item.Hilight = false;
			current_item = null;
		}

		private void ToolBar_MouseMove (object sender, MouseEventArgs me)
		{
			if (!Enabled) 
				return;

			if (tip_window != null && tip_window.Visible) {
				TipDownTimer.Stop ();
				TipDownTimer.Start ();
			}

			Point loc = new Point (me.X, me.Y);

			if (Capture) {
				// If the button was pressed and we leave, release the 
				// button press and vice versa
				foreach (ToolBarItem item in items) {
					if (item.Pressed &&
					    (item.Inside != item.Rectangle.Contains (loc))) {
						item.Inside = item.Rectangle.Contains (loc);
						item.Hilight = false;
						break;
					}
				}
				return;
			} 

			if (current_item != null && current_item.Rectangle.Contains (loc)) {
				if (ThemeEngine.Current.ToolBarHasHotElementStyles (this)) {
					if (current_item.Hilight || (!ThemeEngine.Current.ToolBarHasHotCheckedElementStyles && current_item.Button.Pushed) || !current_item.Button.Enabled)
						return;
					current_item.Hilight = true;
				}
			} else {
				if (tip_window != null) {
					if (tip_window.Visible) {
						tip_window.Hide (this);
						TipDownTimer.Stop ();
					}
					current_item = ItemAtPoint (loc);
					if (current_item != null && current_item.Button.ToolTipText.Length > 0) {
						tip_window.Present (this, current_item.Button.ToolTipText);
						TipDownTimer.Start ();
					}
				}

				if (ThemeEngine.Current.ToolBarHasHotElementStyles (this)) {
					foreach (ToolBarItem item in items) {
						if (item.Rectangle.Contains (loc) && item.Button.Enabled) {
							current_item = item;
							if (current_item.Hilight || (!ThemeEngine.Current.ToolBarHasHotCheckedElementStyles && current_item.Button.Pushed))
								continue;
							current_item.Hilight = true;
						}
						else if (item.Hilight) {
							item.Hilight = false;
						}
					}
				}
			}
		}

		internal override void OnPaintInternal (PaintEventArgs pevent)
		{
			if (GetStyle (ControlStyles.UserPaint))
				return;
				
			ThemeEngine.Current.DrawToolBar (pevent.Graphics, pevent.ClipRectangle, this);
			
			// Toolbars do not raise OnPaint unless UserPaint is set
			pevent.Handled = true;
		}

		internal void Redraw (bool recalculate)
		{
			Redraw (recalculate, true);
		}

		internal void Redraw (bool recalculate, bool force)
		{
			bool invalidate = true;
			
			if (recalculate)
				invalidate = LayoutToolBar ();

			if (force || invalidate)
				Invalidate ();
		}

		internal bool SizeSpecified {
			get { return size_specified; }
		}
		
		internal bool Vertical {
			get { return (Dock == DockStyle.Left) || (Dock == DockStyle.Right); }
		}

		internal const int text_padding = 3;

		private Size CalcButtonSize ()
		{
			if (Buttons.Count == 0)
				return Size.Empty;

			string longest_text = Buttons [0].Text;
			for (int i = 1; i < Buttons.Count; i++) {
				if (Buttons[i].Text.Length > longest_text.Length)
					longest_text = Buttons[i].Text;
			}

			Size size = Size.Empty;
			if (longest_text != null && longest_text.Length > 0) {
				SizeF sz = TextRenderer.MeasureString (longest_text, Font);
				if (sz != SizeF.Empty)
					size = new Size ((int) Math.Ceiling (sz.Width) + 2 * text_padding, (int) Math.Ceiling (sz.Height));
			}

			Size img_size = ImageList == null ? new Size (16, 16) : ImageSize;

			Theme theme = ThemeEngine.Current;
			int imgWidth = img_size.Width + 2 * theme.ToolBarImageGripWidth; 
			int imgHeight = img_size.Height + 2 * theme.ToolBarImageGripWidth;

			if (text_alignment == ToolBarTextAlign.Right) {
				size.Width = imgWidth + size.Width;
				size.Height = (size.Height > imgHeight) ? size.Height : imgHeight;
			} else {
				size.Height = imgHeight + size.Height;
				size.Width = (size.Width > imgWidth) ? size.Width : imgWidth;
			}

			size.Width += theme.ToolBarImageGripWidth;
			size.Height += theme.ToolBarImageGripWidth;
			return size;
		}

		// Flat toolbars disregard specified sizes.  Normal toolbars grow the
		// button size to be at least large enough to show the image.
		private Size AdjustedButtonSize {
			get {
				Size size;

				if (default_size.IsEmpty || Appearance == ToolBarAppearance.Normal) 
					size = ButtonSize;
				else
					size = default_size;
				
				if (size_specified) {
					if (Appearance == ToolBarAppearance.Flat)
						size = CalcButtonSize ();
					else {
						int grip = ThemeEngine.Current.ToolBarImageGripWidth;
						if (size.Width < ImageSize.Width + 2 * grip )
							size.Width = ImageSize.Width + 2 * grip;
						if (size.Height < ImageSize.Height + 2 * grip)
							size.Height = ImageSize.Height + 2 * grip;
					}
				}
				return size;
			}
		}

		private bool LayoutToolBar ()
		{
			bool changed = false;
			Theme theme = ThemeEngine.Current;
			int x = theme.ToolBarGripWidth;
			int y = theme.ToolBarGripWidth;

			Size adjusted_size = AdjustedButtonSize;
			
			int calculated_size = (Vertical ? adjusted_size.Width : adjusted_size.Height) + theme.ToolBarGripWidth;
			
			int separator_index = -1;

			items = new ToolBarItem [buttons.Count];
			
			for (int i = 0; i < buttons.Count; i++) {
				ToolBarButton button = buttons [i];
				
				ToolBarItem item = new ToolBarItem (button);
				items [i] = item;

				if (!button.Visible)
					continue;

				if (size_specified && (button.Style != ToolBarButtonStyle.Separator))
					changed = item.Layout (adjusted_size);
				else
					changed = item.Layout (Vertical, calculated_size);
				
				bool is_separator = button.Style == ToolBarButtonStyle.Separator;
				
				if (Vertical) {
					if (y + item.Rectangle.Height < Height || is_separator || !Wrappable) {
						if (item.Location.X != x || item.Location.Y != y)
							changed = true;
						item.Location = new Point (x, y);
						y += item.Rectangle.Height;
						if (is_separator)
							separator_index = i;
					} else if (separator_index > 0) {
						i = separator_index;
						separator_index = -1;
						y = theme.ToolBarGripWidth;
						x += calculated_size; 
					} else {
						y = theme.ToolBarGripWidth;
						x += calculated_size; 
						if (item.Location.X != x || item.Location.Y != y)
							changed = true;
						item.Location = new Point (x, y);
						y += item.Rectangle.Height;
					}
				} else {
					if (x + item.Rectangle.Width < Width || is_separator || !Wrappable) {
						if (item.Location.X != x || item.Location.Y != y)
							changed = true;
						item.Location = new Point (x, y);
						x += item.Rectangle.Width;
						if (is_separator)
							separator_index = i;
					} else if (separator_index > 0) {
						i = separator_index;
						separator_index = -1;
						x = theme.ToolBarGripWidth;
						y += calculated_size; 
					} else {
						x = theme.ToolBarGripWidth;
						y += calculated_size; 
						if (item.Location.X != x || item.Location.Y != y)
							changed = true;
						item.Location = new Point (x, y);
						x += item.Rectangle.Width;
					}
				}
			}
			
			if (Parent == null)
				return changed;
			
			if (Wrappable)
				calculated_size += Vertical ? x : y;
			
			if (IsHandleCreated) {
				if (Vertical)
					Width = calculated_size;
				else
					Height = calculated_size; 
			}
			
			return changed;
		}
 		#endregion Private Methods

		#region subclass
		public class ToolBarButtonCollection : IList, ICollection, IEnumerable
		{
			#region instance variables
			private ArrayList list; // ToolBarButton list
			private ToolBar owner;  // ToolBar associated to Collection
			private bool redraw;    // Flag if needs to redraw after add/remove operations
			#endregion

			#region UIA Framework Events
			static object UIACollectionChangedEvent = new object ();
			
			internal event CollectionChangeEventHandler UIACollectionChanged {
				add { owner.Events.AddHandler (UIACollectionChangedEvent, value); }
				remove { owner.Events.RemoveHandler (UIACollectionChangedEvent, value); }
			}

			internal void OnUIACollectionChanged (CollectionChangeEventArgs e)
			{
				CollectionChangeEventHandler eh
					= (CollectionChangeEventHandler) owner.Events [UIACollectionChangedEvent];
				if (eh != null)
					eh (owner, e);
			}
			#endregion

			#region constructors
			public ToolBarButtonCollection (ToolBar owner)
			{
				this.list   = new ArrayList ();
				this.owner  = owner;
				this.redraw = true;
			}
			#endregion

			#region properties
			[Browsable (false)]
			public int Count {
				get { return list.Count; }
			}

			public bool IsReadOnly {
				get { return list.IsReadOnly; }
			}

			public virtual ToolBarButton this [int index] {
				get { return (ToolBarButton) list [index]; }
				set {
					// UIA Framework Event: Button Removed
					OnUIACollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Remove, index));

					value.SetParent (owner);
					list [index] = value;
					owner.Redraw (true);

				// UIA Framework Event: Button Added
				OnUIACollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Add, index));
				}
			}

			public virtual ToolBarButton this[string key] {
				get {
					if (string.IsNullOrEmpty (key))
						return null;
						
					foreach (ToolBarButton b in list)
						if (string.Compare (b.Name, key, true) == 0)
							return b;
							
					return null;
				}
			}

			bool ICollection.IsSynchronized {
				get { return list.IsSynchronized; }
			}

			object ICollection.SyncRoot {
				get { return list.SyncRoot; }
			}

			bool IList.IsFixedSize {
				get { return list.IsFixedSize; }
			}

			object IList.this [int index] {
				get { return this [index]; }
				set {
					if (! (value is ToolBarButton))
						throw new ArgumentException("Not of type ToolBarButton", "value");
					this [index] = (ToolBarButton) value;
				}
			}
			#endregion

			#region methods
			public int Add (string text)
			{
				ToolBarButton button = new ToolBarButton (text);
				return this.Add (button);
			}

			public int Add (ToolBarButton button)
			{
				int result;
				button.SetParent (owner);
				result = list.Add (button);
				if (redraw)
					owner.Redraw (true);

				// UIA Framework Event: Button Added
				OnUIACollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Add, result));

				return result;
			}

			public void AddRange (ToolBarButton [] buttons)
			{
				try {
					redraw = false;
					foreach (ToolBarButton button in buttons)
						Add (button);
				}
				finally {
					redraw = true;
					owner.Redraw (true);
				}
			}

			public void Clear ()
			{
				list.Clear ();
				owner.Redraw (false);

				// UIA Framework Event: Button Cleared
				OnUIACollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Refresh, -1));
			}

			public bool Contains (ToolBarButton button)
			{
				return list.Contains (button);
			}

			public virtual bool ContainsKey (string key)
			{
				return !(this[key] == null);
			}

			public IEnumerator GetEnumerator ()
			{
				return list.GetEnumerator ();
			}

			void ICollection.CopyTo (Array dest, int index)
			{
				list.CopyTo (dest, index);
			}

			int IList.Add (object button)
			{
				if (! (button is ToolBarButton)) {
					throw new ArgumentException("Not of type ToolBarButton", "button");
				}

				return this.Add ((ToolBarButton) button);
			}

			bool IList.Contains (object button)
			{
				if (! (button is ToolBarButton)) {
					throw new ArgumentException("Not of type ToolBarButton", "button");
				}

				return this.Contains ((ToolBarButton) button);
			}

			int IList.IndexOf (object button)
			{
				if (! (button is ToolBarButton)) {
					throw new ArgumentException("Not of type ToolBarButton", "button");
				}

				return this.IndexOf ((ToolBarButton) button);
			}

			void IList.Insert (int index, object button)
			{
				if (! (button is ToolBarButton)) {
					throw new ArgumentException("Not of type ToolBarButton", "button");
				}

				this.Insert (index, (ToolBarButton) button);
			}

			void IList.Remove (object button)
			{
				if (! (button is ToolBarButton)) {
					throw new ArgumentException("Not of type ToolBarButton", "button");
				}

				this.Remove ((ToolBarButton) button);
			}

			public int IndexOf (ToolBarButton button)
			{
				return list.IndexOf (button);
			}

			public virtual int IndexOfKey (string key)
			{
				return IndexOf (this[key]);
			}

			public void Insert (int index, ToolBarButton button)
			{
				list.Insert (index, button);
				owner.Redraw (true);

				// UIA Framework Event: Button Added
				OnUIACollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Add, index));
			}

			public void Remove (ToolBarButton button)
			{
				list.Remove (button);
				owner.Redraw (true);
			}

			public void RemoveAt (int index)
			{
				list.RemoveAt (index);
				owner.Redraw (true);

				// UIA Framework Event: Button Removed
				OnUIACollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Remove, index));
			}

			public virtual void RemoveByKey (string key)
			{
				Remove (this[key]);
			}
			#endregion methods
		}
		
		#endregion subclass
	}
	
	
	// Because same button can be added to toolbar multiple times, we need to maintain
	// a list of button information for each positions. 
	internal class ToolBarItem : Component
	{
		#region Instance variables
		
		private ToolBar       toolbar;    // Parent toolbar
		private ToolBarButton button;     // Associated toolBar button 
		private Rectangle     bounds;     // Toolbar button bounds
		private Rectangle     image_rect; // Image button bounds
		private Rectangle     text_rect;  // Text button bounds

		private bool dd_pressed = false;  // to check for a mouse down on dropdown rect
		private bool inside     = false;  // to handle the mouse move event with mouse pressed
		private bool hilight    = false;  // to hilight buttons in flat style
		private bool pressed    = false;  // this is to check for mouse down on a button
		
		#endregion
		
		#region Constructors
		
		public ToolBarItem (ToolBarButton button)
		{
			this.toolbar = button.Parent;
			this.button  = button;
		}
		
		#endregion Constructors
	
		#region Properties

		public ToolBarButton Button {
			get { return this.button; }
		}
		
		public Rectangle Rectangle {
			get { 
				if (!button.Visible || toolbar == null)
					return Rectangle.Empty;

				if (button.Style == ToolBarButtonStyle.DropDownButton && toolbar.DropDownArrows) {
					Rectangle result = bounds;
					result.Width += ThemeEngine.Current.ToolBarDropDownWidth;
					return result;
				}
				 
				return bounds;
			}
			set { this.bounds = value; }
		}

		public Point Location {
			get { return bounds.Location; }
			set { bounds.Location = value; }
		}

		public Rectangle ImageRectangle {
			get {
				Rectangle result = image_rect;
				result.X += bounds.X;
				result.Y += bounds.Y;
				return result; 
			}
		}
		
		public Rectangle TextRectangle {
			get { 
				Rectangle result = text_rect;
				result.X += bounds.X;
				result.Y += bounds.Y;
				return result; 
			}
		}

		private Size TextSize {
			get {
				StringFormat text_format = new StringFormat ();
				text_format.HotkeyPrefix = HotkeyPrefix.Hide;

				SizeF sz = TextRenderer.MeasureString (button.Text, toolbar.Font, SizeF.Empty, text_format);
				if (sz == SizeF.Empty)
					return Size.Empty;
				return new Size ((int) Math.Ceiling (sz.Width) + 2 * ToolBar.text_padding, (int) Math.Ceiling (sz.Height));
			}
		}
		
		public bool Pressed {
			get { return (pressed && inside); }
			set { pressed = value; }
		}

		public bool DDPressed {
			get { return dd_pressed; }
			set { dd_pressed = value; }
		}

		public bool Inside {
			get { return inside; }
			set { inside = value; }
		}

		public bool Hilight {
			get { return hilight; }
			set {
				if (hilight == value)
					return;

				hilight = value;
				Invalidate ();
			}
		}	
		
		#endregion Properties

		#region Methods
		
		public Size CalculateSize ()
		{
			Theme theme = ThemeEngine.Current;

			int ht = toolbar.ButtonSize.Height + 2 * theme.ToolBarGripWidth;

			if (button.Style == ToolBarButtonStyle.Separator)
				return new Size (theme.ToolBarSeparatorWidth, ht);

			Size size;
			if (TextSize.IsEmpty && (button.Image == null))
				size = toolbar.default_size;
			else
				size = TextSize;
			
			Size image_size = (toolbar.ImageSize == Size.Empty) ? new Size (16, 16) : toolbar.ImageSize;

			int image_width = image_size.Width + 2 * theme.ToolBarImageGripWidth; 
			int image_height = image_size.Height + 2 * theme.ToolBarImageGripWidth; 

			if (toolbar.TextAlign == ToolBarTextAlign.Right) {
				size.Width =  image_width + size.Width;
				size.Height = (size.Height > image_height) ? size.Height : image_height;
			} else {
				size.Height = image_height + size.Height;
				size.Width = (size.Width > image_width) ? size.Width : image_width;
			}

			size.Width += theme.ToolBarGripWidth;
			size.Height += theme.ToolBarGripWidth;
			return size;
		}

		
		public bool Layout (bool vertical, int calculated_size)
		{
			if (toolbar == null || !button.Visible)
				return false;

			Size psize = toolbar.ButtonSize;
			Size size = psize;
			if ((!toolbar.SizeSpecified) || (button.Style == ToolBarButtonStyle.Separator)) {
				size = CalculateSize ();

				if (size.Width == 0 || size.Height == 0)
					size = psize;

				if (vertical)
					size.Width = calculated_size;
				else
					size.Height = calculated_size;
			}
			return Layout (size);
		}

		public bool Layout (Size size)
		{
			if (toolbar == null || !button.Visible)
				return false;

			bounds.Size = size;

			Size image_size = (toolbar.ImageSize == Size.Empty) ? new Size (16, 16) : toolbar.ImageSize;
			int grip = ThemeEngine.Current.ToolBarImageGripWidth;

			Rectangle new_image_rect, new_text_rect;
			
			if (toolbar.TextAlign == ToolBarTextAlign.Underneath) {
				new_image_rect = new Rectangle ((bounds.Size.Width - image_size.Width) / 2 - grip, 0, image_size.Width + 2 + grip, image_size.Height + 2 * grip);
				new_text_rect = new Rectangle (0, new_image_rect.Height, bounds.Size.Width, bounds.Size.Height - new_image_rect.Height - 2 * grip);
			} else {
				new_image_rect = new Rectangle (0, 0, image_size.Width + 2 * grip, image_size.Height + 2 * grip);
				new_text_rect = new Rectangle (new_image_rect.Width, 0, bounds.Size.Width - new_image_rect.Width, bounds.Size.Height - 2 * grip);
			}

			bool changed = false;

			if (new_image_rect != image_rect || new_text_rect != text_rect)
				changed = true;

			image_rect = new_image_rect;
			text_rect = new_text_rect;
			
			return changed;
		}
		
		public void Invalidate ()
		{
			if (toolbar != null)
				toolbar.Invalidate (Rectangle);
		}

		#endregion Methods
	}
}