// 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.
//
// Copyright (c) 2005-2008 Novell, Inc. (http://www.novell.com)
//
// Authors:
//	Peter Dennis Bartok	(pbartok@novell.com)
//      Ivan N. Zlatev          (contact i-nz.net)
//
//

// COMPLETE

#undef Debug

using System;
using System.ComponentModel;
using System.Drawing;
using System.Reflection;
using System.Runtime.InteropServices;

namespace System.Windows.Forms {
	[ComVisible (true)]
	[ClassInterface (ClassInterfaceType.AutoDispatch)]
	[DefaultEvent("SplitterMoved")]
	[Designer("System.Windows.Forms.Design.SplitterDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
	[DefaultProperty("Dock")]
	public class Splitter : Control
	{
		#region Local Variables
		static private Cursor		splitter_ns;
		static private Cursor		splitter_we;
		// XXX this "new" shouldn't be here.  Control shouldn't define border_style as internal.
		new private BorderStyle		border_style;
		private int			min_extra;
		private int			min_size;
		private int                     max_size;
		private int			splitter_size;		// Size (width or height) of our splitter control
		private bool			horizontal;		// true if we've got a horizontal splitter
		private Control			affected;		// The control that the splitter resizes
		private int			split_requested;	// If the user requests a position before we have ever laid out the doc
		private int 			splitter_prev_move;
		private Rectangle 		splitter_rectangle_moving;
		private int			moving_offset;
		#endregion	// Local Variables

		#region Constructors
		static Splitter() {
			splitter_ns = Cursors.HSplit;
			splitter_we = Cursors.VSplit;
		}

		public Splitter() {

			min_extra = 25;
			min_size = 25;
			split_requested = -1;
			splitter_size = 3;
			horizontal = false;

			SetStyle(ControlStyles.Selectable, false);
			Anchor = AnchorStyles.None;
			Dock = DockStyle.Left;

			Layout += new LayoutEventHandler(LayoutSplitter);
			this.ParentChanged += new EventHandler(ReparentSplitter);
			Cursor = splitter_we;
		}
		#endregion	// Constructors

		#region Public Instance Properties
		[Browsable(false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public override bool AllowDrop {
			get {
				return base.AllowDrop;
			}

			set {
				base.AllowDrop = value;
			}
		}

		[Browsable(false)]
		[DefaultValue(AnchorStyles.None)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public override AnchorStyles Anchor {
			get {
				return AnchorStyles.None;
			}

			set {
				;	// MS doesn't set it
			}
		}

		[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; }
		}

		[DispId(-504)]
		[DefaultValue (BorderStyle.None)]
		[MWFDescription("Sets the border style for the splitter")]
		[MWFCategory("Appearance")]
		public BorderStyle BorderStyle {
			get {
				return border_style;
			}

			set {
				border_style = value;

				switch(value) {
				case BorderStyle.FixedSingle:
					splitter_size = 4;	// We don't get motion events for 1px wide windows on X11. sigh.
					break;

				case BorderStyle.Fixed3D:
					value = BorderStyle.None;
					splitter_size = 3;
					break;

				case BorderStyle.None:
					splitter_size = 3;
					break;

				default:
					throw new InvalidEnumArgumentException (string.Format("Enum argument value '{0}' is not valid for BorderStyle", value));
				}

				base.InternalBorderStyle = value;
			}
		}

		[DefaultValue(DockStyle.Left)]
		[Localizable(true)]
		public override DockStyle Dock {
			get {
				return base.Dock;
			}

			set {
				if (!Enum.IsDefined (typeof (DockStyle), value) || (value == DockStyle.None) || (value == DockStyle.Fill)) {
					throw new ArgumentException("Splitter must be docked left, top, bottom or right");
				}

				if ((value == DockStyle.Top) || (value == DockStyle.Bottom)) {
					horizontal = true;
					Cursor = splitter_ns;
				} else {
					horizontal = false;
					Cursor = splitter_we;
				}
				base.Dock = value;
			}
		}

		[Browsable(false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public override Font Font {
			get {
				return base.Font;
			}

			set {
				base.Font = value;
			}
		}

		[Browsable(false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public override Color ForeColor {
			get {
				return base.ForeColor;
			}

			set {
				base.ForeColor = value;
			}
		}

		[Browsable(false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public new ImeMode ImeMode {
			get {
				return base.ImeMode;
			}

			set {
				base.ImeMode = value;
			}
		}

		[DefaultValue(25)]
		[Localizable(true)]
		[MWFDescription("Sets minimum size of undocked window")]
		[MWFCategory("Behaviour")]
		public int MinExtra {
			get {
				return min_extra;
			}

			set {
				min_extra = value;
			}
		}

		[DefaultValue(25)]
		[Localizable(true)]
		[MWFDescription("Sets minimum size of the resized control")]
		[MWFCategory("Behaviour")]
		public int MinSize {
			get {
				return min_size;
			}

			set {
				min_size = value;
			}
		}

		internal int MaxSize {
			get {
				if (this.Parent == null)
					return 0;

				if (affected == null)
					affected = AffectedControl;

				int widths = 0;
				int heights = 0;
				int vert_offset = 0;
				int horiz_offset = 0;
				foreach (Control c in this.Parent.Controls) {
					if (c != affected) {
						switch (c.Dock) {
						case DockStyle.Left:
						case DockStyle.Right:
							widths += c.Width;

							if (c.Location.X < this.Location.X)
								vert_offset += c.Width;
							break;
						case DockStyle.Top:
						case DockStyle.Bottom:
							heights += c.Height;

							if (c.Location.Y < this.Location.Y)
								horiz_offset += c.Height;
							break;
						}
					}
				}

				if (horizontal) {
					moving_offset = horiz_offset;

					return Parent.ClientSize.Height - heights - MinExtra;
				} else {
					moving_offset = vert_offset;

					return Parent.ClientSize.Width - widths - MinExtra;
				}
			}
		}
		
		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		[MWFDescription("Current splitter position")]
		[MWFCategory("Layout")]
		public int SplitPosition {
			get {
				affected = AffectedControl;
				if (affected == null) {
					return -1;
				}

				if (Capture) {
					return CalculateSplitPosition();
				}

				if (horizontal) {
					return affected.Height;
				} else {
					return affected.Width;
				}
			}

			set {
				if (value > MaxSize)
					value = MaxSize;
				if (value < MinSize)
					value = MinSize;

				affected = AffectedControl;
				if (affected == null)
					split_requested = value;
				else {
					if (horizontal)
						affected.Height = value;
					else
						affected.Width = value;
					OnSplitterMoved (new SplitterEventArgs (Left, Top, value, value));
				}
			}
		}

		[Browsable(false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		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 {
				base.Text = value;
			}
		}

		#endregion	// Public Instance Properties

		#region Protected Instance Properties
		protected override CreateParams CreateParams {
			get {
				return base.CreateParams;
			}
		}

		protected override Cursor DefaultCursor {
			get { return base.DefaultCursor; }
		}

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

		protected override Size DefaultSize {
			get {
				return new Size (3, 3);
			}
		}
		#endregion	// Protected Instance Properties

		#region Public Instance Methods
		public override string ToString() {
			return base.ToString () + String.Format(", MinExtra: {0}, MinSize: {1}", min_extra, min_size);
		}
		#endregion	// Public Instance Methods

		#region Protected Instance Methods
		protected override void OnKeyDown(KeyEventArgs e) {
			base.OnKeyDown (e);
			if (Capture && (e.KeyCode == Keys.Escape)) {
				Capture = false;
				SplitterEndMove (Point.Empty, true);
			}
		}

		protected override void OnMouseDown(MouseEventArgs e) {
			base.OnMouseDown (e);

			// Only allow if we are set up properly
			if (affected == null)
				affected = AffectedControl;
			max_size = MaxSize;

			if (affected == null || e.Button != MouseButtons.Left)
				return;

			Capture = true;
			SplitterBeginMove (Parent.PointToClient (PointToScreen (new Point (e.X, e.Y))));
		}

		protected override void OnMouseMove (MouseEventArgs e)
		{
			base.OnMouseMove (e);

			if (!Capture  || e.Button != MouseButtons.Left || affected == null)
				return;

			// We need our mouse coordinates relative to our parent
			SplitterMove (Parent.PointToClient (PointToScreen (e.Location)));
		}

		protected override void OnMouseUp (MouseEventArgs e)
		{
			base.OnMouseUp (e);
			if (!Capture || e.Button != MouseButtons.Left || affected == null) 
				return;

			SplitterEndMove (Parent.PointToClient (PointToScreen (e.Location)), false);
			Capture = false;
		}

		private void SplitterBeginMove (Point location)
		{
			splitter_rectangle_moving = new Rectangle (Bounds.X, Bounds.Y,
								   Width, Height);
			splitter_prev_move = horizontal ? location.Y : location.X;
		}

		private void SplitterMove (Point location)
		{
			int currentMove = horizontal ? location.Y : location.X;
			int delta = currentMove - splitter_prev_move;
			Rectangle prev_location = splitter_rectangle_moving;
			bool moved = false;
			int min = this.MinSize + moving_offset;
			int max = max_size + moving_offset;

			if (horizontal) {
				if (splitter_rectangle_moving.Y + delta > min && splitter_rectangle_moving.Y + delta < max) {
					splitter_rectangle_moving.Y += delta;
					moved = true;
				} else {
					// Ensure that the splitter is set to minimum or maximum position, 
					// even if the mouse "skips".
					//
					if (splitter_rectangle_moving.Y + delta <= min && splitter_rectangle_moving.Y != min) {
						splitter_rectangle_moving.Y = min;
						moved = true;
					} else if (splitter_rectangle_moving.Y + delta >= max && splitter_rectangle_moving.Y != max) {
						splitter_rectangle_moving.Y = max;
						moved = true;
					}
				}
			} else {
				if (splitter_rectangle_moving.X + delta > min && splitter_rectangle_moving.X + delta < max) {
					splitter_rectangle_moving.X += delta;
					moved = true;
				} else {
					// Ensure that the splitter is set to minimum or maximum position, 
					// even if the mouse "skips".
					//
					if (splitter_rectangle_moving.X + delta <= min && splitter_rectangle_moving.X != min) {
						splitter_rectangle_moving.X = min;
						moved = true;
					} else if (splitter_rectangle_moving.X + delta >= max && splitter_rectangle_moving.X != max) {
						splitter_rectangle_moving.X = max;
						moved = true;
					}
				}
			}

			if (moved) {
				splitter_prev_move = currentMove;
				OnSplitterMoving (new SplitterEventArgs (location.X, location.Y, 
									 splitter_rectangle_moving.X, 
									 splitter_rectangle_moving.Y));
				XplatUI.DrawReversibleRectangle (this.Parent.Handle, prev_location, 1);
				XplatUI.DrawReversibleRectangle (this.Parent.Handle, splitter_rectangle_moving, 1);
			}
		}

		private void SplitterEndMove (Point location, bool cancel)
		{
			if (!cancel) {
				// Resize the affected window
				if (horizontal)
					affected.Height = CalculateSplitPosition();
				else
					affected.Width = CalculateSplitPosition();
			}

			this.Parent.Refresh (); // to clean up the drag handle artifacts from all controls
			SplitterEventArgs args = new SplitterEventArgs (location.X, location.Y, 
									splitter_rectangle_moving.X, 
									splitter_rectangle_moving.Y);
			OnSplitterMoved (args);
		}

		protected virtual void OnSplitterMoved(SplitterEventArgs sevent) {
			SplitterEventHandler eh = (SplitterEventHandler)(Events [SplitterMovedEvent]);
			if (eh != null)
				eh (this, sevent);
		}

		protected virtual void OnSplitterMoving(SplitterEventArgs sevent) {
			SplitterEventHandler eh = (SplitterEventHandler)(Events [SplitterMovingEvent]);
			if (eh != null)
				eh (this, sevent);
		}

		protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) {
			// enforce our width / height
			if (horizontal) {
				splitter_size = height;
				if (splitter_size < 1) {
					splitter_size = 3;
				}
				base.SetBoundsCore (x, y, width, splitter_size, specified);
			} else {
				splitter_size = width;
				if (splitter_size < 1) {
					splitter_size = 3;
				}
				base.SetBoundsCore (x, y, splitter_size, height, specified);
			}
		}
		#endregion	// Protected Instance Methods

		#region Private Properties and Methods
		private Control AffectedControl {
			get {
				if (Parent == null)
					return null;

				// Doc says the first control preceeding us in the zorder 
				for (int i = Parent.Controls.GetChildIndex(this) + 1; i < Parent.Controls.Count; i++) {
					switch (Dock) {
					case DockStyle.Top:
						if (Top == Parent.Controls[i].Bottom)
							return Parent.Controls[i];
						break;
					case DockStyle.Bottom:
						if (Bottom == Parent.Controls[i].Top)
							return Parent.Controls[i];
						break;
					case DockStyle.Left:
						if (Left == Parent.Controls[i].Right)
							return Parent.Controls[i];
						break;
					case DockStyle.Right:
						if (Right == Parent.Controls[i].Left)
							return Parent.Controls[i];
						break;
					}
				}
				return null;
			}
		}

		private int CalculateSplitPosition() {
			if (horizontal) {
				if (Dock == DockStyle.Top)
					return splitter_rectangle_moving.Y - affected.Top;
				else
					return affected.Bottom - splitter_rectangle_moving.Y - splitter_size;
			} else {
				if (Dock == DockStyle.Left)
					return splitter_rectangle_moving.X - affected.Left;
				else
					return affected.Right - splitter_rectangle_moving.X - splitter_size;
			}
		}

		internal override void OnPaintInternal (PaintEventArgs e) {
			e.Graphics.FillRectangle(ThemeEngine.Current.ResPool.GetSolidBrush(this.BackColor), e.ClipRectangle);
		}

		private void LayoutSplitter(object sender, LayoutEventArgs e) {
			affected = AffectedControl;
			if (split_requested != -1) {
				SplitPosition = split_requested;
				split_requested = -1;
			}
		}

		private void ReparentSplitter(object sender, EventArgs e) {
			affected = null;
		}

		#endregion	// Private Properties and Methods

		#region Events
		[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; }
		}

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

		[Browsable(false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public new event EventHandler FontChanged {
			add { base.FontChanged += value; }
			remove { base.FontChanged -= 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 KeyEventHandler KeyDown {
			add { base.KeyDown += value; }
			remove { base.KeyDown -= value; }
		}

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

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

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

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

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

		static object SplitterMovedEvent = new object ();
		static object SplitterMovingEvent = new object ();

		public event SplitterEventHandler SplitterMoved {
			add { Events.AddHandler (SplitterMovedEvent, value); }
			remove { Events.RemoveHandler (SplitterMovedEvent, value); }
		}

		public event SplitterEventHandler SplitterMoving {
			add { Events.AddHandler (SplitterMovingEvent, value); }
			remove { Events.RemoveHandler (SplitterMovingEvent, value); }
		}
		#endregion	// Events
	}
}