// Written by Christopher E. Miller
// See the included license.txt for copyright and license details.


///
module dfl.splitter;

private import dfl.control, dfl.internal.winapi, dfl.base, dfl.drawing;
private import dfl.event;


///
class SplitterEventArgs: EventArgs
{
	///
	this(int x, int y, int splitX, int splitY)
	{
		_x = x;
		_y = y;
		_splitX = splitX;
		_splitY = splitY;
	}
	
	
	///
	final @property int x() // getter
	{
		return _x;
	}
	
	
	///
	final @property int y() // getter
	{
		return _y;
	}
	
	
	///
	final @property void splitX(int val) // setter
	{
		_splitX = val;
	}
	
	/// ditto
	final @property int splitX() // getter
	{
		return _splitX;
	}
	
	
	///
	final @property void splitY(int val) // setter
	{
		_splitY = val;
	}
	
	/// ditto
	final @property int splitY() // getter
	{
		return _splitY;
	}
	
	
	private:
	int _x, _y, _splitX, _splitY;
}


///
class Splitter: Control // docmain
{
	this()
	{
		// DMD 0.95: need 'this' to access member dock
		this.dock = DockStyle.LEFT;
		
		if(HBRUSH.init == hbrxor)
			inithbrxor();
	}
	
	
	/+
	override @property void anchor(AnchorStyles a) // setter
	{
		throw new DflException("Splitter cannot be anchored");
	}
	
	alias Control.anchor anchor; // Overload.
	+/
	
	
	override @property void dock(DockStyle ds) // setter
	{
		switch(ds)
		{
			case DockStyle.LEFT:
			case DockStyle.RIGHT:
				//cursor = new Cursor(LoadCursorA(null, IDC_SIZEWE), false);
				cursor = Cursors.vSplit;
				break;
			
			case DockStyle.TOP:
			case DockStyle.BOTTOM:
				//cursor = new Cursor(LoadCursorA(null, IDC_SIZENS), false);
				cursor = Cursors.hSplit;
				break;
			
			default:
				throw new DflException("Invalid splitter dock");
		}
		
		super.dock(ds);
	}
	
	alias Control.dock dock; // Overload.
	
	
	package void initsplit(int sx, int sy)
	{
		capture = true;
		
		downing = true;
		//downpos = Point(mea.x, mea.y);
		
		switch(dock)
		{
			case DockStyle.TOP:
			case DockStyle.BOTTOM:
				downpos = sy;
				lastpos = 0;
				drawxorClient(0, lastpos);
				break;
			
			default: // LEFT / RIGHT.
				downpos = sx;
				lastpos = 0;
				drawxorClient(lastpos, 0);
		}
	}
	
	
	final void resumeSplit(int sx, int sy) // package
	{
		if(Control.mouseButtons & MouseButtons.LEFT)
		{
			initsplit(sx, sy);
			
			if(cursor)
				Cursor.current = cursor;
		}
	}
	
	// /// ditto
	final void resumeSplit() // package
	{
		Point pt = pointToClient(Cursor.position);
		return resumeSplit(pt.x, pt.y);
	}
	
	
	///
	@property void movingGrip(bool byes) // setter
	{
		if(mgrip == byes)
			return;
		
		this.mgrip = byes;
		
		if(created)
		{
			invalidate();
		}
	}
	
	/// ditto
	@property bool movingGrip() // getter
	{
		return mgrip;
	}
	
	deprecated alias movingGrip moveingGrip;
	deprecated alias movingGrip moveGrip;
	deprecated alias movingGrip sizingGrip;
	
	
	protected override void onPaint(PaintEventArgs ea)
	{
		super.onPaint(ea);
		
		if(mgrip)
		{
			ea.graphics.drawMoveGrip(displayRectangle, DockStyle.LEFT == dock || DockStyle.RIGHT == dock);
		}
	}
	
	
	protected override void onResize(EventArgs ea)
	{
		if(mgrip)
		{
			invalidate();
		}
		
		resize(this, ea);
	}
	
	
	protected override void onMouseDown(MouseEventArgs mea)
	{
		super.onMouseDown(mea);
		
		if(mea.button == MouseButtons.LEFT && 1 == mea.clicks)
		{
			initsplit(mea.x, mea.y);
		}
	}
	
	
	protected override void onMouseMove(MouseEventArgs mea)
	{
		super.onMouseMove(mea);
		
		if(downing)
		{
			switch(dock)
			{
				case DockStyle.TOP:
				case DockStyle.BOTTOM:
					drawxorClient(0, mea.y - downpos, 0, lastpos);
					lastpos = mea.y - downpos;
					break;
				
				default: // LEFT / RIGHT.
					drawxorClient(mea.x - downpos, 0, lastpos, 0);
					lastpos = mea.x - downpos;
			}
			
			scope sea = new SplitterEventArgs(mea.x, mea.y, left, top);
			onSplitterMoving(sea);
		}
	}
	
	
	protected override void onMove(EventArgs ea)
	{
		super.onMove(ea);
		
		if(downing) // ?
		{
			Point curpos = Cursor.position;
			curpos = pointToClient(curpos);
			scope sea = new SplitterEventArgs(curpos.x, curpos.y, left, top);
			onSplitterMoved(sea);
		}
	}
	
	
	final Control getSplitControl() // package
	{
		Control splat; // Splitted.
		// DMD 0.95: need 'this' to access member dock
		//switch(dock())
		final switch(this.dock())
		{
			case DockStyle.LEFT:
				foreach(Control ctrl; parent.controls())
				{
					if(DockStyle.LEFT != ctrl.dock) //if(this.dock != ctrl.dock)
						continue;
					// DMD 0.95: overloads int(Object o) and int(Control ctrl) both match argument list for opEquals
					//if(ctrl == this)
					if(ctrl == cast(Control)this)
						return splat;
					splat = ctrl;
				}
				break;
			
			case DockStyle.RIGHT:
				foreach(Control ctrl; parent.controls())
				{
					if(DockStyle.RIGHT != ctrl.dock) //if(this.dock != ctrl.dock)
						continue;
					// DMD 0.95: overloads int(Object o) and int(Control ctrl) both match argument list for opEquals
					//if(ctrl == this)
					if(ctrl == cast(Control)this)
						return splat;
					splat = ctrl;
				}
				break;
			
			case DockStyle.TOP:
				foreach(Control ctrl; parent.controls())
				{
					if(DockStyle.TOP != ctrl.dock) //if(this.dock != ctrl.dock)
						continue;
					// DMD 0.95: overloads int(Object o) and int(Control ctrl) both match argument list for opEquals
					//if(ctrl == this)
					if(ctrl == cast(Control)this)
						return splat;
					splat = ctrl;
				}
				break;
			
			case DockStyle.BOTTOM:
				foreach(Control ctrl; parent.controls())
				{
					if(DockStyle.BOTTOM != ctrl.dock) //if(this.dock != ctrl.dock)
						continue;
					// DMD 0.95: overloads int(Object o) and int(Control ctrl) both match argument list for opEquals
					//if(ctrl == this)
					if(ctrl == cast(Control)this)
						return splat;
					splat = ctrl;
				}
				break;
			
			case DockStyle.FILL:
				assert("DockStyle.FILL is not allowed in Splitter");
				break;
			
			case DockStyle.NONE:
				assert("DockStyle.NONE is not allowed in Splitter");
				break;
		}
		return null;
	}
	
	
	protected override void onMouseUp(MouseEventArgs mea)
	{
		if(downing)
		{
			capture = false;
			
			downing = false;
			
			if(mea.button != MouseButtons.LEFT)
			{
				// Abort.
				switch(dock)
				{
					case DockStyle.TOP:
					case DockStyle.BOTTOM:
						drawxorClient(0, lastpos);
						break;
					
					default: // LEFT / RIGHT.
						drawxorClient(lastpos, 0);
				}
				super.onMouseUp(mea);
				return;
			}
			
			int adj, val, vx;
			auto splat = getSplitControl(); // Splitted.
			if(splat)
			{
				// DMD 0.95: need 'this' to access member dock
				//switch(dock())
				switch(this.dock())
				{
					case DockStyle.LEFT:
						drawxorClient(lastpos, 0);
						//val = left - splat.left + mea.x - downpos.x;
						val = left - splat.left + mea.x - downpos;
						if(val < msize)
							val = msize;
						splat.width = val;
						break;
					
					case DockStyle.RIGHT:
						drawxorClient(lastpos, 0);
						//adj = right - splat.left + mea.x - downpos.x;
						adj = right - splat.left + mea.x - downpos;
						val = splat.width - adj;
						vx = splat.left + adj;
						if(val < msize)
						{
							vx -= msize - val;
							val = msize;
						}
						splat.bounds = Rect(vx, splat.top, val, splat.height);
						break;
					
					case DockStyle.TOP:
						drawxorClient(0, lastpos);
						//val = top - splat.top + mea.y - downpos.y;
						val = top - splat.top + mea.y - downpos;
						if(val < msize)
							val = msize;
						splat.height = val;
						break;
					
					case DockStyle.BOTTOM:
						drawxorClient(0, lastpos);
						//adj = bottom - splat.top + mea.y - downpos.y;
						adj = bottom - splat.top + mea.y - downpos;
						val = splat.height - adj;
						vx = splat.top + adj;
						if(val < msize)
						{
							vx -= msize - val;
							val = msize;
						}
						splat.bounds = Rect(splat.left, vx, splat.width, val);
						break;
					
					default:
				}
			}
			
			// This is needed when the moved control first overlaps the splitter and the splitter
			// gets bumped over, causing a little area to not be updated correctly.
			// I'll fix it someday.
			parent.invalidate(true);
			
			// Event..
		}
		
		super.onMouseUp(mea);
	}
	
	
	/+
	// Not quite sure how to implement this yet.
	// Might need to scan all controls until one of:
	//    Control with opposite dock (right if left dock): stay -mextra- away from it,
	//    Control with fill dock: that control can't have less than -mextra- width,
	//    Reached end of child controls: stay -mextra- away from the edge.
	
	///
	final @property void minExtra(int min) // setter
	{
		mextra = min;
	}
	
	/// ditto
	final @property int minExtra() // getter
	{
		return mextra;
	}
	+/
	
	
	///
	final @property void minSize(int min) // setter
	{
		msize = min;
	}
	
	/// ditto
	final @property int minSize() // getter
	{
		return msize;
	}
	
	
	///
	final @property void splitPosition(int pos) // setter
	{
		auto splat = getSplitControl(); // Splitted.
		if(splat)
		{
			// DMD 0.95: need 'this' to access member dock
			//switch(dock())
			switch(this.dock())
			{
				case DockStyle.LEFT:
				case DockStyle.RIGHT:
					splat.width = pos;
					break;
				
				case DockStyle.TOP:
				case DockStyle.BOTTOM:
					splat.height = pos;
					break;
				
				default:
			}
		}
	}
	
	/// ditto
	// -1 if not docked to a control.
	final @property int splitPosition() // getter
	{
		auto splat = getSplitControl(); // Splitted.
		if(splat)
		{
			// DMD 0.95: need 'this' to access member dock
			//switch(dock())
			switch(this.dock())
			{
				case DockStyle.LEFT:
				case DockStyle.RIGHT:
					return splat.width;
				
				case DockStyle.TOP:
				case DockStyle.BOTTOM:
					return splat.height;
				
				default:
			}
		}
		return -1;
	}
	
	
	//SplitterEventHandler splitterMoved;
	Event!(Splitter, SplitterEventArgs) splitterMoved; ///
	//SplitterEventHandler splitterMoving;
	Event!(Splitter, SplitterEventArgs) splitterMoving; ///
	
	
	protected:
	
	override @property Size defaultSize() // getter
	{
		//return Size(GetSystemMetrics(SM_CXSIZEFRAME), GetSystemMetrics(SM_CYSIZEFRAME));
		int sx = GetSystemMetrics(SM_CXSIZEFRAME);
		int sy = GetSystemMetrics(SM_CYSIZEFRAME);
		// Need a bit extra room for the move-grips.
		if(sx < 5)
			sx = 5;
		if(sy < 5)
			sy = 5;
		return Size(sx, sy);
	}
	
	
	///
	void onSplitterMoving(SplitterEventArgs sea)
	{
		splitterMoving(this, sea);
	}
	
	
	///
	void onSplitterMoved(SplitterEventArgs sea)
	{
		splitterMoving(this, sea);
	}
	
	
	private:
	
	bool downing = false;
	bool mgrip = true;
	//Point downpos;
	int downpos;
	int lastpos;
	int msize = 25; // Min size of control that's being sized from the splitter.
	int mextra = 25; // Min size of the control on the opposite side.
	
	static HBRUSH hbrxor;
	
	
	static void inithbrxor()
	{
		static ubyte[] bmbits = [0xAA, 0, 0x55, 0, 0xAA, 0, 0x55, 0,
			0xAA, 0, 0x55, 0, 0xAA, 0, 0x55, 0, ];
		
		HBITMAP hbm;
		hbm = CreateBitmap(8, 8, 1, 1, bmbits.ptr);
		hbrxor = CreatePatternBrush(hbm);
		DeleteObject(hbm);
	}
	
	
	static void drawxor(HDC hdc, Rect r)
	{
		SetBrushOrgEx(hdc, r.x, r.y, null);
		HGDIOBJ hbrold = SelectObject(hdc, hbrxor);
		PatBlt(hdc, r.x, r.y, r.width, r.height, PATINVERT);
		SelectObject(hdc, hbrold);
	}
	
	
	void drawxorClient(HDC hdc, int x, int y)
	{
		POINT pt;
		pt.x = x;
		pt.y = y;
		//ClientToScreen(handle, &pt);
		MapWindowPoints(handle, parent.handle, &pt, 1);
		
		drawxor(hdc, Rect(pt.x, pt.y, width, height));
	}
	
	
	void drawxorClient(int x, int y, int xold = int.min, int yold = int.min)
	{
		HDC hdc;
		//hdc = GetWindowDC(null);
		hdc = GetDCEx(parent.handle, null, DCX_CACHE);
		
		if(xold != int.min)
			drawxorClient(hdc, xold, yold);
		
		drawxorClient(hdc, x, y);
		
		ReleaseDC(null, hdc);
	}
}