/*
 * OpenClonk, http://www.openclonk.org
 *
 * Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
 * Copyright (c) 2009-2016, The OpenClonk Team and contributors
 *
 * Distributed under the terms of the ISC license; see accompanying file
 * "COPYING" for details.
 *
 * "Clonk" is a registered trademark of Matthes Bender, used with permission.
 * See accompanying file "TRADEMARK" for details.
 *
 * To redistribute this file separately, substitute the full license texts
 * for the above references.
 */
// generic user interface
// grouping elements and control base classes

#include "C4Include.h"
#include "gui/C4Gui.h"

#include "graphics/C4Draw.h"
#include "graphics/C4GraphicsResource.h"
#include "gui/C4MouseControl.h"

namespace C4GUI
{

// --------------------------------------------------
// Container

	void Container::Draw(C4TargetFacet &cgo)
	{
		// self visible?
		if (!IsVisible()) return;
		// then draw all visible child elements
		for (Element *pEl = pFirst; pEl; pEl = pEl->pNext)
			if (pEl->fVisible)
			{
				// skip viewport dialogs
				if (!pEl->IsExternalDrawDialog())
				{
					if (pEl->GetDialogWindow())
						pEl->GetDialogWindow()->RequestUpdate();
					else
						pEl->Draw(cgo);
				}
			}
	}

	Container::Container() : Element()
	{
		// zero fields
		pFirst = pLast = nullptr;
	}

	Container::~Container()
	{
		// empty
		Clear();
	}

	void Container::Clear()
	{
		ClearChildren();
	}

	void Container::ClearChildren()
	{
		// delete all items; dtor will update list
		while (pFirst)
		{
			if (pFirst->IsOwnPtrElement())
			{
				// unlink from list
				Element *pANext = pFirst->pNext;
				pFirst->pPrev = pFirst->pNext = nullptr;
				pFirst->pParent = nullptr;
				if ((pFirst = pANext))
					pFirst->pPrev = nullptr;
				else
					pLast = nullptr;
			}
			else
				delete pFirst;
		}
	}

	void Container::RemoveElement(Element *pChild)
	{
		// safety
		if (!pChild) return;
		// inherited
		Element::RemoveElement(pChild);
		// must be from same container
		if (pChild->pParent != this) return;
		// unlink from list
		if (pChild->pPrev) pChild->pPrev->pNext = pChild->pNext; else pFirst = pChild->pNext;
		if (pChild->pNext) pChild->pNext->pPrev = pChild->pPrev; else pLast = pChild->pPrev;
		// unset parent; invalidates pPrev/pNext
		pChild->pParent = nullptr;
		// element has been removed
		AfterElementRemoval();
	}

	void Container::MakeLastElement(Element *pChild)
	{
		// must be from same container
		if (pChild->pParent != this) return;
		// unlink from list
		if (pChild->pPrev) pChild->pPrev->pNext = pChild->pNext; else pFirst = pChild->pNext;
		if (pChild->pNext) pChild->pNext->pPrev = pChild->pPrev; else pLast = pChild->pPrev;
		// readd to front of list
		if (pLast) pLast->pNext = pChild; else pFirst = pChild;
		pChild->pPrev = pLast; pChild->pNext = nullptr; pLast = pChild;
	}

	void Container::AddElement(Element *pChild)
	{
		// safety
		if (!pChild) return;
		// remove from any previous container
		if (pChild->pParent) pChild->pParent->RemoveElement(pChild);
		// add to end of list
		if (pLast) pLast->pNext = pChild; else pFirst = pChild;
		pChild->pPrev = pLast; pChild->pNext = nullptr; pLast = pChild;
		pChild->pParent = this;

		assert(pChild->pNext != pChild);
		assert(pChild->pPrev != pChild);
		assert(pChild->pParent != pChild);
	}

	void Container::ReaddElement(Element *pChild)
	{
		// safety
		if (!pChild || pChild->pParent != this) return;
		// remove from any previous container
		if (pChild->pPrev) pChild->pPrev->pNext = pChild->pNext; else pFirst = pChild->pNext;
		if (pChild->pNext) pChild->pNext->pPrev = pChild->pPrev; else pLast = pChild->pPrev;
		// add to end of list
		if (pLast) pLast->pNext = pChild; else pFirst = pChild;
		pChild->pPrev = pLast; pChild->pNext = nullptr; pLast = pChild;

		assert(pChild->pNext != pChild);
		assert(pChild->pPrev != pChild);
		assert(pChild->pParent != pChild);
	}

	void Container::InsertElement(Element *pChild, Element *pInsertBefore)
	{
		// add?
		if (!pInsertBefore) { AddElement(pChild); return; }
		// safety
		if (!pChild || pInsertBefore->pParent != this) return;
		// remove from any previous container
		if (pChild->pParent) pChild->pParent->RemoveElement(pChild);
		// add before given element
		if ((pChild->pPrev = pInsertBefore->pPrev))
			pInsertBefore->pPrev->pNext = pChild;
		else
			pFirst = pChild;
		pChild->pNext = pInsertBefore; pInsertBefore->pPrev = pChild;
		pChild->pParent = this;

		assert(pChild->pNext != pChild);
		assert(pChild->pPrev != pChild);
		assert(pChild->pParent != pChild);
	}

	Element *Container::GetNextNestedElement(Element *pPrevElement, bool fBackwards)
	{
		if (fBackwards)
		{
			// this is last
			if (pPrevElement == this) return nullptr;
			// no previous given?
			if (!pPrevElement)
				// then use last nested for backwards search
				return GetFirstNestedElement(true);
			// get nested, previous element if present
			if (pPrevElement->pPrev) return pPrevElement->pPrev->GetFirstNestedElement(true);
			// if not, return parent (could be this)
			return pPrevElement->pParent;
		}
		else
		{
			// forward search: first element is this
			if (!pPrevElement) return this;
			// check next nested
			Element *pEl;
			if ((pEl = pPrevElement->GetFirstContained())) return pEl;
			// check next in list, going upwards until this container is reached
			while (pPrevElement && pPrevElement != this)
			{
				if ((pEl = pPrevElement->pNext)) return pEl;
				pPrevElement = pPrevElement->pParent;
			}
			// nothing found
		}
		return nullptr;
	}

	Element *Container::GetFirstNestedElement(bool fBackwards)
	{
		// get first/last in own list
		if (pFirst) return (fBackwards ? pLast : pFirst)->GetFirstNestedElement(fBackwards);
		// no own list: return this one
		return this;
	}

	bool Container::OnHotkey(uint32_t cHotkey)
	{
		if (!IsVisible()) return false;
		// check all nested elements
		for (Element *pEl = pFirst; pEl; pEl=pEl->pNext)
			if (pEl->fVisible)
				if (pEl->OnHotkey(cHotkey)) return true;
		// no match found
		return false;
	}

	Element *Container::GetElementByIndex(int32_t i)
	{
		// get next until end of list or queried index is reached
		// if i is negative or equal or larger than childcount, the loop will never break and nullptr returned
		Element *pEl;
		for (pEl = pFirst; i-- && pEl; pEl=pEl->pNext) {}
		return pEl;
	}

	int32_t Container::GetElementCount()
	{
		int32_t cnt=0;
		for (Element *pEl = pFirst; pEl; pEl=pEl->pNext) ++cnt;
		return cnt;
	}

	bool Container::IsParentOf(Element *pEl)
	{
		// return whether this is the parent container (directly or recursively) of the passed element
		for (Container *pC = pEl->GetParent(); pC; pC = pC->GetParent())
			if (pC == this) return true;
		return false;
	}

	void Container::SetVisibility(bool fToValue)
	{
		// inherited
		Element::SetVisibility(fToValue);
		// remove focus from contained elements
		if (!fToValue)
		{
			Dialog *pDlg = GetDlg();
			if (pDlg)
			{
				Control *pFocus = pDlg->GetFocus();
				if (pFocus)
				{
					if (IsParentOf(pFocus))
					{
						pDlg->SetFocus(nullptr, false);
					}
				}
			}
		}
	}


// --------------------------------------------------
// Window

	void Window::MouseInput(CMouse &rMouse, int32_t iButton, int32_t iX, int32_t iY, DWORD dwKeyParam)
	{
		// invisible?
		if (!IsVisible()) return;
		// inherited
		Container::MouseInput(rMouse, iButton, iX, iY, dwKeyParam);
		// get client pos
		C4Rect &rcClientRect = GetClientRect(), &rcBounds = GetBounds();
		iX -= rcClientRect.x - rcBounds.x; iY -= rcClientRect.y - rcBounds.y;
		// forward to topmost child element
		for (Element *pChild = pLast; pChild; pChild = pChild->GetPrev())
			if (pChild->fVisible && pChild->GetBounds().Contains(iX, iY))
			{
				// forward
				pChild->MouseInput(rMouse, iButton, iX - pChild->GetBounds().x, iY - pChild->GetBounds().y, dwKeyParam);
				// forward to one control only
				break;
			}
	}

	void Window::Draw(C4TargetFacet &cgo)
	{
		// invisible?
		if (!IsVisible()) return;
		// draw window itself
		DrawElement(cgo);
		// get target area
		C4Rect &rcClientRect = GetClientRect();
		C4Rect &rcClipArea = (IsComponentOutsideClientArea() ? GetBounds() : GetClientRect());
		// clip to window area
		int clx1, cly1, clx2, cly2;
		pDraw->GetPrimaryClipper(clx1, cly1, clx2, cly2);
		float nclx1 = cgo.TargetX+rcClipArea.x, ncly1 = cgo.TargetY+rcClipArea.y, nclx2 = cgo.TargetX+rcClipArea.x+rcClipArea.Wdt-1, ncly2 = cgo.TargetY+rcClipArea.y+rcClipArea.Hgt-1;
		pDraw->ApplyZoom(nclx1, ncly1);
		pDraw->ApplyZoom(nclx2, ncly2);
		pDraw->SubPrimaryClipper(nclx1, ncly1, nclx2, ncly2);
		// update target area
		cgo.TargetX += rcClientRect.x; cgo.TargetY += rcClientRect.y;
		// draw contents
		Container::Draw(cgo);
		// reset target area
		cgo.TargetX -= rcClientRect.x; cgo.TargetY -= rcClientRect.y;
		// reset clipper
		pDraw->SetPrimaryClipper(clx1, cly1, clx2, cly2);
	}

	Window::Window() : Container()
	{
		UpdateOwnPos();
	}

	void Window::UpdateOwnPos()
	{
		Container::UpdateOwnPos();
		// set client rect
		int32_t iMarginL=GetMarginLeft(), iMarginT=GetMarginTop();
		rcClientRect.Set(rcBounds.x + iMarginL, rcBounds.y + iMarginT, std::max<int32_t>(rcBounds.Wdt - iMarginL - GetMarginRight(), 0), std::max<int32_t>(rcBounds.Hgt - iMarginT - GetMarginBottom(), 0));
	}


// --------------------------------------------------
// ScrollBar

	ScrollBar::ScrollBar(C4Rect &rcBounds, ScrollWindow *pWin) : fAutoHide(false), fHorizontal(false), iCBMaxRange(100), pScrollCallback(nullptr), pCustomGfx(nullptr)
	{
		// set bounds
		this->rcBounds = rcBounds;
		// set initial values
		pScrollWindow = pWin;
		fScrolling = false;
		iScrollThumbSize = C4GUI_ScrollThumbHgt; // vertical
		iScrollPos = 0;
		fTopDown = fBottomDown = false;
		// update scroll bar pos
		Update();
	}

	ScrollBar::ScrollBar(C4Rect &rcBounds, bool fHorizontal, BaseParCallbackHandler<int32_t> *pCB, int32_t iCBMaxRange) : fAutoHide(false), fHorizontal(fHorizontal), iCBMaxRange(iCBMaxRange), pScrollWindow(nullptr), pCustomGfx(nullptr)
	{
		// set bounds
		this->rcBounds = rcBounds;
		// set initial values
		if ((pScrollCallback = pCB)) pScrollCallback->Ref();
		fScrolling = true;
		iScrollThumbSize = fHorizontal ? C4GUI_ScrollThumbWdt : C4GUI_ScrollThumbHgt;
		iScrollPos = 0;
		fTopDown = fBottomDown = false;
	}

	ScrollBar::~ScrollBar()
	{
		if (pScrollWindow) { pScrollWindow->pScrollBar = nullptr; }
		if (pScrollCallback) pScrollCallback->DeRef();
	}

	void ScrollBar::Update()
	{
		// check associated control
		if (pScrollWindow)
		{
			int32_t iVisHgt = pScrollWindow->GetBounds().Hgt;
			int32_t iClientHgt = pScrollWindow->GetClientRect().Hgt;
			if ((fScrolling = (iVisHgt < iClientHgt)))
			{
				// scrolling necessary
				// get vertical scroll pos
				int32_t iMaxWinScroll = iClientHgt - iVisHgt;
				int32_t iMaxBarScroll = GetBounds().Hgt - 2*C4GUI_ScrollArrowHgt - iScrollThumbSize;
				int32_t iWinScroll = pScrollWindow->iScrollY;
				// scroll thumb height is currently hardcoded
				// calc scroll pos
				iScrollPos = Clamp<int32_t>(iMaxBarScroll * iWinScroll / iMaxWinScroll, 0, iMaxBarScroll);
			}
		}
		else fScrolling = !!pScrollCallback;
		// reset buttons
		if (!fScrolling)
			fTopDown = fBottomDown = false;
		// set visibility by scroll status
		if (fAutoHide) SetVisibility(fScrolling);
	}

	void ScrollBar::OnPosChanged()
	{
		int32_t iMaxBarScroll = GetMaxScroll();
		if (!iMaxBarScroll) iMaxBarScroll=1;
		// CB - passes scroll pos
		if (pScrollCallback) pScrollCallback->DoCall(Clamp<int32_t>(iScrollPos * (iCBMaxRange-1) / iMaxBarScroll, 0, (iCBMaxRange-1)));
		// safety
		if (!pScrollWindow || !fScrolling) return;
		// get scrolling values
		assert(!fHorizontal); // nyi
		int32_t iVisHgt = pScrollWindow->GetBounds().Hgt;
		int32_t iClientHgt = pScrollWindow->GetClientRect().Hgt;
		int32_t iMaxWinScroll = iClientHgt - iVisHgt;
		int32_t iWinScroll = pScrollWindow->iScrollY;
		// calc new window scrolling
		int32_t iNewWinScroll = Clamp<int32_t>(iMaxWinScroll * iScrollPos / iMaxBarScroll, 0, iMaxWinScroll);
		// apply it, if it is different
		if (iWinScroll != iNewWinScroll)
			pScrollWindow->SetScroll(iNewWinScroll);
	}

	void ScrollBar::MouseInput(CMouse &rMouse, int32_t iButton, int32_t iX, int32_t iY, DWORD dwKeyParam)
	{
		// inherited
		Element::MouseInput(rMouse, iButton, iX, iY, dwKeyParam);
		// not if scrolling is disabled
		if (!fScrolling) return;
		// reset arrow states
		bool fPrevDown = fTopDown || fBottomDown;
		fTopDown = fBottomDown = false;
		// not if dragging
		if (rMouse.pDragElement) return;
		// left mouse button down?
		if (rMouse.IsLDown())
			// non-scroll-direction area check
			if (fHorizontal ? Inside<int32_t>(iY, 0, C4GUI_ScrollBarHgt) : Inside<int32_t>(iX, 0, C4GUI_ScrollBarWdt))
			{
				// scroll-direction area check: up/left arrow
				if (fHorizontal ? Inside<int32_t>(iX, 0, C4GUI_ScrollArrowWdt-1) : Inside<int32_t>(iY, 0, C4GUI_ScrollArrowHgt-1))
					fTopDown = true;
				// check down arrow
				else if (fHorizontal ? Inside<int32_t>(iX, GetBounds().Wdt-C4GUI_ScrollArrowWdt, GetBounds().Wdt-1)
				         : Inside<int32_t>(iY, GetBounds().Hgt-C4GUI_ScrollArrowHgt, GetBounds().Hgt-1))
					fBottomDown = true;
				else if (HasPin() && (fHorizontal ? Inside<int32_t>(iX, C4GUI_ScrollArrowWdt, GetBounds().Wdt-C4GUI_ScrollArrowWdt-1)
				                      : Inside<int32_t>(iY, C4GUI_ScrollArrowHgt, GetBounds().Hgt-C4GUI_ScrollArrowHgt-1)))
				{
					// move thumb here
					iScrollPos = GetScrollByPos(iX, iY);
					// reflect movement in associated window or do CB
					OnPosChanged();
					// start dragging
					rMouse.pDragElement = this;
					GUISound("UI::Select");
				}
			}
		// sound effekt when buttons are pressed
		if ((fTopDown || fBottomDown) != fPrevDown) GUISound("UI::Tick");
	}

	void ScrollBar::DoDragging(CMouse &rMouse, int32_t iX, int32_t iY, DWORD dwKeyParam)
	{
		// move thumb
		iScrollPos = GetScrollByPos(iX, iY);
		// reflect movement in associated window
		OnPosChanged();
	}

	void ScrollBar::MouseLeave(CMouse &rMouse)
	{
		// inherited
		Element::MouseLeave(rMouse);
		// reset button states
		fTopDown = fBottomDown = false;
	}

	void ScrollBar::DrawElement(C4TargetFacet &cgo)
	{
		// do scrolling
		// not quite perfect; but there's no OnIdle, and it's be a bit of overkill starting a timer
		if (fTopDown && fScrolling && iScrollPos>0)
			{ --iScrollPos; OnPosChanged(); }
		if (fBottomDown && fScrolling)
		{
			if (iScrollPos < GetMaxScroll()) { ++iScrollPos; OnPosChanged(); }
		}
		// draw bar
		ScrollBarFacets &rUseGfx = pCustomGfx ? *pCustomGfx : ::GraphicsResource.sfctScroll;
		DynBarFacet bar = rUseGfx.barScroll;
		if (fTopDown) bar.fctBegin = rUseGfx.fctScrollDTop;
		if (fBottomDown) bar.fctEnd = rUseGfx.fctScrollDBottom;
		if (fHorizontal)
			DrawHBarByVGfx(cgo, bar);
		else
			DrawVBar(cgo, bar);
		// draw scroll pin
		if (fScrolling && HasPin())
		{
			if (fHorizontal)
				rUseGfx.fctScrollPin.Draw(cgo.Surface, cgo.TargetX+rcBounds.x+C4GUI_ScrollArrowWdt+iScrollPos, cgo.TargetY+rcBounds.y);
			else
				rUseGfx.fctScrollPin.Draw(cgo.Surface, cgo.TargetX+rcBounds.x, cgo.TargetY+rcBounds.y+C4GUI_ScrollArrowHgt+iScrollPos);
		}
	}


// --------------------------------------------------
// ScrollWindow

	ScrollWindow::ScrollWindow(Window *pParentWindow)
			: Window(), pScrollBar(nullptr), iScrollY(0), iClientHeight(0), fHasBar(true), iFrozen(0)
	{
		// place within client rect
		C4Rect rtBounds = pParentWindow->GetClientRect();
		rtBounds.x = rtBounds.y = 0;
		rtBounds.Wdt -= C4GUI_ScrollBarWdt;
		SetBounds(rtBounds);
		// create scroll bar
		rtBounds.x += rtBounds.Wdt; rtBounds.Wdt = C4GUI_ScrollBarWdt;
		pScrollBar = new ScrollBar(rtBounds, this);
		// add self and scroll bar to window
		if (pParentWindow != this)
		{
			pParentWindow->AddElement(this);
			pParentWindow->AddElement(pScrollBar);
		}
	}

	void ScrollWindow::Update()
	{
		// not if window is being refilled
		if (iFrozen) return;
		// do not scroll outside range
		iScrollY = Clamp<int32_t>(iScrollY, 0, std::max<int32_t>(iClientHeight - GetBounds().Hgt, 0));
		// update client rect
		rcClientRect.x = 0;
		rcClientRect.y = -iScrollY;
		rcClientRect.Wdt = rcBounds.Wdt;
		rcClientRect.Hgt = iClientHeight;
		// update scroll bar
		if (pScrollBar) pScrollBar->Update();
	}

	void ScrollWindow::SetScroll(int32_t iToScroll)
	{
		// set values
		rcClientRect.y = -(iScrollY = iToScroll);
	}

	void ScrollWindow::ScrollToBottom()
	{
		int32_t iVisHgt = GetBounds().Hgt;
		int32_t iClientHgt = GetClientRect().Hgt;
		int32_t iMaxScroll = iClientHgt - iVisHgt;
		if (iScrollY < iMaxScroll)
		{
			// scrolling possible: do it
			iScrollY = iMaxScroll;
			// update (self + bar)
			Update();
		}
	}

	void ScrollWindow::ScrollPages(int iPageCount)
	{
		int32_t iVisHgt = GetBounds().Hgt;
		ScrollBy(iPageCount * iVisHgt);
	}

	void ScrollWindow::ScrollBy(int iAmount)
	{
		int32_t iVisHgt = GetBounds().Hgt;
		int32_t iClientHgt = GetClientRect().Hgt;
		int32_t iMaxScroll = iClientHgt - iVisHgt;
		int iNewScrollY = Clamp<int>(iScrollY + iAmount, 0, iMaxScroll);
		if (iScrollY != iNewScrollY)
		{
			// scrolling possible: do it
			iScrollY = iNewScrollY;
			// update (self + bar)
			Update();
		}
	}

	void ScrollWindow::ScrollRangeInView(int32_t iY, int32_t iHgt)
	{
		// safety bounds
		if (iY<0) iY=0;
		int32_t iClientHgt = GetClientRect().Hgt;
		if (iY+iHgt > iClientHgt) { ScrollToBottom(); return; }
		// check top
		if (iScrollY > iY)
		{
			iScrollY = iY;
			Update(); // update (self+bar)
		}
		else
		{
			// check bottom
			int32_t iVisHgt = GetBounds().Hgt;
			// if no height is given, scroll given Y-pos to top
			if (!iHgt) iHgt = iVisHgt;
			if (iScrollY + iVisHgt < iY + iHgt)
			{
				iScrollY = iY + iHgt - iVisHgt;
				Update(); // update (self+bar)
			}
		}
	}

	bool ScrollWindow::IsRangeInView(int32_t iY, int32_t iHgt)
	{
		// returns whether scrolling range is in view
		// check top
		if (iScrollY > iY) return false;
		// check height
		return iScrollY + GetBounds().Hgt >= iY+iHgt;
	}

	void ScrollWindow::UpdateOwnPos()
	{
		if (!GetParent()) { Update(); return; }
		// place within client rect
		C4Rect rtBounds = GetParent()->GetContainedClientRect();
		rtBounds.x = rtBounds.y = 0;
		if (fHasBar) rtBounds.Wdt -= C4GUI_ScrollBarWdt;
		if (GetBounds() != rtBounds)
		{
			SetBounds(rtBounds);
			// scroll bar
			if (fHasBar)
			{
				rtBounds.x += rtBounds.Wdt; rtBounds.Wdt = C4GUI_ScrollBarWdt;
				pScrollBar->SetBounds(rtBounds);
			}
		}
		// standard updates
		Update();
	}

	void ScrollWindow::SetScrollBarEnabled(bool fToVal, bool noAutomaticPositioning)
	{
		if (fHasBar == fToVal) return;
		pScrollBar->SetVisibility(fHasBar = fToVal);
		// in some cases the windows will already care for the correct positioning themselves (see C4ScriptGuiWindow)
		if (!noAutomaticPositioning)
			UpdateOwnPos();
	}

	void ScrollWindow::MouseInput(CMouse &rMouse, int32_t iButton, int32_t iX, int32_t iY, DWORD dwKeyParam)
	{
		// process wheel: Scroll
		if (iButton == C4MC_Button_Wheel)
		{
			short iDelta = (short)(dwKeyParam >> 16);
			ScrollBy(-iDelta);
			return;
		}
		// other mouse input: inherited (forward to children)
		Window::MouseInput(rMouse, iButton, iX, iY, dwKeyParam);
	}


// --------------------------------------------------
// GroupBox

	CStdFont *GroupBox::GetTitleFont() const
	{
		// get font; fallback to GUI caption font
		return pFont ? pFont : &(::GraphicsResource.CaptionFont);
	}

	void GroupBox::DrawElement(C4TargetFacet &cgo)
	{
		// draw background
		if (dwBackClr != 0xffffffff)
		{
			pDraw->DrawBoxDw(cgo.Surface, cgo.TargetX+rcBounds.x, cgo.TargetY+rcBounds.y, cgo.TargetX+rcBounds.x+rcBounds.Wdt-1, cgo.TargetY+rcBounds.y+rcBounds.Hgt-1, dwBackClr);
		}
		// draw title label
		int32_t iBorderYOff = 0;
		int32_t iTitleGapX = 0;
		int32_t iTitleGapWdt = 0;
		if (HasTitle())
		{
			CStdFont *pTitleFont = GetTitleFont();
			iBorderYOff = pTitleFont->GetLineHeight()/2;
			pTitleFont->GetTextExtent(sTitle.getData(), iTitleGapWdt, iTitleGapX, true);
			iTitleGapX = 7; iTitleGapWdt += 4;
			pDraw->TextOut(sTitle.getData(), *pTitleFont, 1.0f, cgo.Surface, cgo.TargetX+rcBounds.x+iTitleGapX+2, cgo.TargetY+rcBounds.y, dwTitleClr);
		}
		// draw frame
		if (dwFrameClr)
		{
			int32_t x1=cgo.TargetX+rcBounds.x,y1=cgo.TargetY+rcBounds.y+iBorderYOff,x2=x1+rcBounds.Wdt,y2=y1+rcBounds.Hgt-iBorderYOff;
			if (iTitleGapWdt)
			{
				for (int i=0; i<2; ++i)
				{
					pDraw->DrawLineDw(cgo.Surface, (float) x1+i, (float)y1, (float)(x1+i), (float)(y2-1), dwFrameClr); // left
					pDraw->DrawLineDw(cgo.Surface, (float) (x1+2), (float)(y1+i), (float)(x1+iTitleGapX), (float)(y1+i), dwFrameClr); // top - left side
					pDraw->DrawLineDw(cgo.Surface, (float) (x1+iTitleGapX+iTitleGapWdt), (float)(y1+i), (float)(x2-3), (float)(y1+i), dwFrameClr); // top - right side
					pDraw->DrawLineDw(cgo.Surface, (float) (x2-1-i), (float)y1, (float)(x2-1-i), (float)(y2-1), dwFrameClr); // right
					pDraw->DrawLineDw(cgo.Surface, (float) (x1+2), (float)(y2-1-i), (float)(x2-3), (float)(y2-1-i), dwFrameClr); // bottom
				}
			}
			else
			{
				pDraw->DrawFrameDw(cgo.Surface, x1, y1, x2, (y2-1), dwFrameClr);
				pDraw->DrawFrameDw(cgo.Surface, (x1+1), (y1+1), (x2-1), (y2-2), dwFrameClr);
			}
		}
		else
			// default frame color
			// 2do: Make this work with titled group boxes
			Draw3DFrame(cgo);
	}


// --------------------------------------------------
// Control

	Control::Control(const C4Rect &rtBounds) : Window()
	{
		// set bounds
		SetBounds(rtBounds);
		// context menu key binding
		pKeyContext = new C4KeyBinding(C4KeyCodeEx(K_MENU), "GUIContext", KEYSCOPE_Gui,
		                               new ControlKeyCB<Control>(*this, &Control::KeyContext), C4CustomKey::PRIO_Ctrl);
	}

	Control::~Control()
	{
		delete pKeyContext;
	}

	void Control::MouseInput(CMouse &rMouse, int32_t iButton, int32_t iX, int32_t iY, DWORD dwKeyParam)
	{
		if (!IsVisible()) return;
		// left down on click=focus-components?
		if (IsFocusOnClick() && IsFocusElement()) if (iButton == C4MC_Button_LeftDown && !HasFocus())
			{
				// then set focus
				Dialog *pParentDlg = GetDlg();
				if (pParentDlg)
				{
					// but do not set focus to this if a child control has it already
					Control *pActiveCtrl = pParentDlg->GetFocus();
					if (!pActiveCtrl || !IsParentOf(pActiveCtrl))
						pParentDlg->SetFocus(this, true);
				}
			}
		// inherited - processing child elements
		Window::MouseInput(rMouse, iButton, iX, iY, dwKeyParam);
	}

	bool Control::HasDrawFocus()
	{
		// has focus at all?
		if (!HasFocus()) return false;
		// is screen ready and not in context?
		if (GetScreen() && GetScreen()->HasContext()) return false;
		// get dlg
		Dialog *pDlg=GetDlg();
		// dlg-less control has focus, OK (shouldn't happen)
		if (!pDlg) return true;
		// check if dlg is active
		return pDlg->IsActive(true);
	}

	void Control::DisableFocus()
	{
		// has it any focus at all?
		if (!HasFocus()) return;
		// then de-focus it
		Dialog *pDlg=GetDlg();
		if (!pDlg) return;
		pDlg->AdvanceFocus(true);
	}

} // end of namespace