~ubuntu-branches/ubuntu/saucy/monodevelop/saucy-proposed

//
// DockToolbar.cs
//
// Author:
//   Lluis Sanchez Gual
//
// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
//
// 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.
//

using System;
using System.Collections.Generic;
using Gtk;
using Gdk;

namespace MonoDevelop.Components.DockToolbars
{
	public class DockToolbar: Toolbar, IDockToolbar
	{
		DockGrip grip;
		DockToolbarFrame parentFrame;
		bool dragging;
		FloatingDock floatingDock;
		string id;
		string title;
		
		int row;
		int offset;
		int shiftOffset = -1;
		
		// Offset requested by the user. It is used to know where the
		// toolbar is expected to move when the window is expanded.
		int anchorOffset;	
		
		Animation animation;
		DockToolbarPosition lastPosition;
		DockToolbarStatus defaultStatus;
		
		int defaultSize;
		int defaultHeight;
		bool gotSize = false;
		bool gettingSize;
		Dictionary<Gtk.Widget,int> calculatedSizes = new Dictionary<Gtk.Widget, int> ();
		
		public DockToolbar (string id, string title)
		{
			grip = new DockGrip ();
			Add (grip);
			grip.Hide ();
			this.id = id;
			this.title = title;
			ShowArrow = false;
		}
		
		internal void SetParentFrame (DockToolbarFrame frame)
		{
			parentFrame = frame;
			grip.Show ();
		}
		
		public string Id {
			get { return id; }
		}
		
		public string Title {
			get { return title; }
		}
		
		public bool Floating {
			get { return floatingDock != null; }
		}
		
		bool IDockToolbar.Visible {
			get { return Parent != null; }
			set {
				if (value == ((IDockToolbar)this).Visible)
					return;
					
				if (value) {
					if (lastPosition != null)
						lastPosition.RestorePosition (parentFrame, this);
					else
						defaultStatus.Position.RestorePosition (parentFrame, this);
				} else {
					lastPosition = DockToolbarPosition.Create (this);
					if (Floating) {
						FloatingDock win = FloatingDock;
						win.Detach ();
						win.Destroy ();
					}
					else
						DockPanel.RemoveBar (this);
				}
			}
		}
		
		internal DockToolbarPosition Position {
			get {
				if (((IDockToolbar)this).Visible) return DockToolbarPosition.Create (this);
				else if (lastPosition != null) return lastPosition;
				else return defaultStatus.Position;
			}
		}
		
		internal DockToolbarStatus Status {
			get {
				return new DockToolbarStatus (id, ((IDockToolbar)this).Visible, Position);
			}
			set {
				if (value.Visible) {
					((IDockToolbar)this).Visible = false;
					lastPosition = value.Position;
					((IDockToolbar)this).Visible = true;
				} else {
					((IDockToolbar)this).Visible = false;
					lastPosition = value.Position;
				}
			}
			
		}
		
		internal DockToolbarStatus DefaultStatus {
			get { return defaultStatus; }
			set { defaultStatus = value; }
		}
		
		internal int DockRow {
			get { return row; }
			set { row = value; }
		}
		
		/// <summary>
		/// The current offset of the toolbar
		/// </summary>
		internal int DockOffset {
			get { return offset; }
			set { offset = value; }
		}
		
		internal int DockShiftOffset {
			get { return shiftOffset; }
			set { shiftOffset = value; }
		}
		
		/// <summary>
		/// The ideal offset of the toolbar. It may not be the real offset if the
		/// toolbar has been forced to move to make room for other toolbars
		/// </summary>
		internal int AnchorOffset {
			get { return anchorOffset; }
			set { anchorOffset = value; }
		}
		
		internal int DefaultSize {
			get {
				if (!gotSize) CalcSizes ();
				return defaultSize;
			}
		}
		
		public int DefaultHeight {
			get {
				if (!gotSize) CalcSizes ();
				return defaultHeight;
			}
		}
		
		internal void CalcSizes ()
		{
			// Calculates the real size of the toolbar. ShowArrow=false is
			// needed, since SizeRequest reports 0 size requested if not.
			
			gettingSize = true;
			bool olda = ShowArrow;
			int oldw = WidthRequest;
			int oldh = HeightRequest;
			WidthRequest = -1;
			HeightRequest = -1;
			
			ShowArrow = false;
			Requisition r = SizeRequest ();
			if (Orientation == Orientation.Horizontal) {
				defaultSize = r.Width;
				defaultHeight = r.Height;
			}
			else {
				defaultSize = r.Height;
				defaultHeight = r.Width;
			}
		
			calculatedSizes.Clear ();
			foreach (Widget w in Children) {
				if (!w.Visible)
					continue;
				if (Orientation == Orientation.Horizontal)
					calculatedSizes [w] = w.Allocation.Width;
				else
					calculatedSizes [w] = w.Allocation.Height;
			}
			
			WidthRequest = oldw;
			HeightRequest = oldh;
			ShowArrow = olda;
			gotSize = true;
			gettingSize = false;
		}
		
		internal bool CanDockTo (DockToolbarPanel panel)
		{
			return true;
		}
		
		internal FloatingDock FloatingDock {
			get { return floatingDock; }
			set { floatingDock = value; }
		}
		
		internal DockToolbarPanel DockPanel {
			get { return Parent as DockToolbarPanel; }
		}
		
		internal Animation Animation {
			get { return animation; }
			set { animation = value; }
		}
		
		protected override bool OnButtonPressEvent (EventButton e)
		{
			if (parentFrame != null && e.Button == 1) {
				if (Orientation == Orientation.Horizontal && e.X <= 10) {
					dragging = true;
					parentFrame.StartDragBar (this, (int)e.X, (int)e.Y, e.Time);
					return true;
				}
				else if (Orientation == Orientation.Vertical && e.Y <= 10) {
					dragging = true;
					parentFrame.StartDragBar (this, (int)e.X, (int)e.Y, e.Time);
					return true;
				}
			}
			return base.OnButtonPressEvent (e);
		}
		
		protected override bool OnButtonReleaseEvent (EventButton e)
		{
			if (e.Button == 1 && dragging) {
				dragging = false;
				parentFrame.EndDragBar (this, e.Time);
			}
			return base.OnButtonReleaseEvent (e);
		}
		
/*		protected override bool OnExposeEvent (EventExpose evnt)
		{
			//use the base class to paint the background like a toolbar, which may be a gradient
			// but only if horizontal, else the gradient usually looks really ugly
			if (this.Orientation == Orientation.Horizontal){
				//the WIMP theme engine's rendering is a bit off, need to force it to render wider
				int widen = MonoDevelop.Core.PropertyService.IsWindows? 1 : 0;
				
				var shadowType = (ShadowType)StyleGetProperty ("shadow-type");
				Style.PaintBox (Style, evnt.Window, State, shadowType, evnt.Area, this, "toolbar", 
				                Allocation.X - widen, Allocation.Y, Allocation.Width + widen + widen, Allocation.Height);
			} else {
				//else we paint a plain flat background to make everything even - see DockToolbarPanel.OnExposeEvent
				GdkWindow.DrawRectangle (Style.BackgroundGC (State), true, Allocation);
			}
            
            foreach (Widget child in Children) {
                PropagateExpose (child, evnt);
            }
		
		    return true;
		}*/
		
		bool firstRealized;
		protected override void OnRealized ()
		{
			base.OnRealized ();
			if (!firstRealized) {
				OnItemChange (null, null);
				firstRealized = true;
			}
		}


		internal void ResetSize ()
		{
			WidthRequest = -1;
			HeightRequest = -1;
			ShowArrow = false;
		}
		
		public int Size {
			set {
				if (Orientation == Orientation.Horizontal) {
					if (value >= DefaultSize)
						WidthRequest = -1;
					else
						WidthRequest = value;
				}
				else {
					if (value >= DefaultSize)
						HeightRequest = -1;
					else
						HeightRequest = value;
					HeightRequest = value;
				}
			}
			get {
				if (Orientation == Orientation.Horizontal)
					return SizeRequest ().Width;
				else
					return SizeRequest ().Height;
			}
		}
		
		public new Orientation Orientation {
			get {
				return base.Orientation;
			}
			set {
				if (value == base.Orientation)
					return;
				
				if (FloatingDock != null) {
					// I create a new dock window because resizing the
					// current one has lots of issues (mainly synchronization
					// problems between the size change of the window and
					// the toolbar).
					
					int x,y;
					FloatingDock w = FloatingDock;
					w.GetPosition (out x, out y);
					w.Detach ();
					
					base.Orientation = value;
					
					FloatingDock fdock = new FloatingDock (parentFrame);
					fdock.Move (x, y);
					fdock.Attach (this);
					w.Destroy ();
				} else
					base.Orientation = value;
				gotSize = false;
			}
		}
		
		protected override void OnAdded (Widget w)
		{
			base.OnAdded (w);
			gotSize = false;
			if (DefaultSizeChanged != null)
				DefaultSizeChanged (this, EventArgs.Empty);
			w.Shown += OnItemChange;
			w.Hidden += OnItemChange;
			w.SizeAllocated += OnItemSizeChange;
		}

		protected override void OnRemoved (Widget w)
		{
			base.OnRemoved (w);
			gotSize = false;
			if (DefaultSizeChanged != null)
				DefaultSizeChanged (this, EventArgs.Empty);
			w.Shown -= OnItemChange;
			w.Hidden -= OnItemChange;
			w.SizeAllocated -= OnItemSizeChange;
		}
		
		void OnItemSizeChange (object o, SizeAllocatedArgs args)
		{
			if (gettingSize || !gotSize)
				return;
			int os;
			if (calculatedSizes.TryGetValue ((Gtk.Widget) o, out os)) {
				int ns = (Orientation == Orientation.Horizontal ? args.Allocation.Width : args.Allocation.Height);
				if (os != ns) {
					Gtk.Application.Invoke (delegate {
						OnItemChange (null, null);
					});
				}
			}
		}
		
		void OnItemChange (object o, EventArgs args)
		{
			// This notifies changes in the size of the toolbar
			gotSize = false;
			if (DefaultSizeChanged != null)
				DefaultSizeChanged (this, EventArgs.Empty);
		}
		
		internal event EventHandler DefaultSizeChanged;
	}
}