Gwen/Controls/Base.h

/*
	GWEN
	Copyright (c) 2010 Facepunch Studios
	See license in Gwen.h
*/

#pragma once
#ifndef GWEN_CONTROLS_BASE_H
#define GWEN_CONTROLS_BASE_H

#include "Gwen/Exports.h"
#include "Gwen/Structures.h"
#include "Gwen/BaseRender.h"
#include "Gwen/Events.h"
#include <list>
#include <map>

#define GWEN_DECLARE_CAST(T)                        \
	virtual class T* DynamicCast##T() { return 0; } \
	virtual const class T* DynamicCast##T() const { return 0; }

#define GWEN_IMPLEMENT_CAST(T)                             \
	virtual class T* DynamicCast##T() { return (T*)this; } \
	virtual const class T* DynamicCast##T() const { return (T*)this; }

namespace Gwen
{
namespace ControlsInternal
{
class ColorDisplay;
class Resizer;

};  // namespace ControlsInternal

namespace Pos
{
enum
{
	None = 0,
	Left = (1 << 1),
	Right = (1 << 2),
	Top = (1 << 3),
	Bottom = (1 << 4),
	CenterV = (1 << 5),
	CenterH = (1 << 6),
	Fill = (1 << 7),
	Center = CenterV | CenterH,
};
}

namespace Skin
{
class Base;
}

namespace Controls
{
class Canvas;

namespace Layout
{
class TableRow;
};

class GWEN_EXPORT Base : public Event::Handler
{
public:
	GWEN_DECLARE_CAST(TabButton)
	GWEN_DECLARE_CAST(DockedTabControl)
	virtual class Layout::TableRow* DynamicCastLayoutTableRow() { return 0; }
	virtual const class Layout::TableRow* DynamicCastLayoutTableRow() const { return 0; }

	GWEN_DECLARE_CAST(TextBoxNumeric)
	GWEN_DECLARE_CAST(HorizontalSlider)
	GWEN_DECLARE_CAST(DockBase)
	GWEN_DECLARE_CAST(MenuItem)
	GWEN_DECLARE_CAST(PropertyRow)
	GWEN_DECLARE_CAST(WindowControl)

	GWEN_DECLARE_CAST(TreeControl)
	GWEN_DECLARE_CAST(TreeNode)
	GWEN_DECLARE_CAST(HSVColorPicker)
	GWEN_DECLARE_CAST(TabControl)

	GWEN_DECLARE_CAST(TabControlInner)
	GWEN_DECLARE_CAST(GroupBox)
	GWEN_DECLARE_CAST(Properties)
	GWEN_DECLARE_CAST(RadioButton)
	GWEN_DECLARE_CAST(LabeledRadioButton)

	virtual class ::Gwen::ControlsInternal::Resizer* DynamicCastResizer() { return 0; }
	virtual const class ::Gwen::ControlsInternal::Resizer* DynamicCastResizer() const { return 0; }

	virtual class ::Gwen::ControlsInternal::ColorDisplay* DynamicCastColorDisplay() { return 0; }
	virtual const class ::Gwen::ControlsInternal::ColorDisplay* DynamicCastColorDisplay() const { return 0; }

	typedef std::list<Base*> List;

	typedef std::map<Gwen::UnicodeString, Gwen::Event::Caller*> AccelMap;

	Base(Base* pParent);
	virtual ~Base();

	virtual void DelayedDelete();

	virtual void SetParent(Controls::Base* pParent);
	virtual Controls::Base* GetParent() const { return m_Parent; }
	virtual Controls::Canvas* GetCanvas();

	virtual Base::List& GetChildren()
	{
		if (m_InnerPanel) return m_InnerPanel->GetChildren();
		return Children;
	}
	virtual bool IsChild(Controls::Base* pChild);
	virtual int NumChildren();
	virtual bool SizeToChildren(bool w = true, bool h = true);
	virtual Gwen::Point ChildrenSize();
	virtual Controls::Base* FindChildByName(const Gwen::String& name, bool bRecursive = false);

	virtual void SetName(Gwen::String name) { m_Name = name; }
	virtual const Gwen::String& GetName() { return m_Name; }

	virtual void Think() {}
	virtual void ExpandAll() {}
	virtual void SizeToContents() {}
	virtual bool IsActive() { return false; }

	virtual void AddChild(Controls::Base* pChild);

	virtual void RemoveChild(Controls::Base* pParent);

protected:
	virtual void OnChildAdded(Controls::Base* pChild);
	virtual void OnChildRemoved(Controls::Base* pChild);

public:
	virtual void RemoveAllChildren();

	virtual void SendToBack(void);
	virtual void BringToFront(void);
	virtual void BringNextToControl(Controls::Base* pChild, bool bBehind);

	virtual Gwen::Point LocalPosToCanvas(const Gwen::Point& in);
	virtual Gwen::Point CanvasPosToLocal(const Gwen::Point& in);

	virtual void Dock(int iDock);
	virtual int GetDock();

	virtual void RestrictToParent(bool restrict) { m_bRestrictToParent = restrict; }
	virtual bool ShouldRestrictToParent() { return m_bRestrictToParent; }

	virtual int X() const
	{
		return m_Bounds.x;
	}
	virtual int Y() const
	{
		return m_Bounds.y;
	}
	virtual int Width() const
	{
		return m_Bounds.w;
	}
	virtual int Height() const
	{
		return m_Bounds.h;
	}
	virtual int Bottom() const
	{
		return m_Bounds.y + m_Bounds.h + m_Margin.bottom;
	}
	virtual int Right() const
	{
		return m_Bounds.x + m_Bounds.w + m_Margin.right;
	}

	virtual const Margin& GetMargin() const { return m_Margin; }
	virtual const Padding& GetPadding() const { return m_Padding; }

	virtual void SetPos(int x, int y);
	virtual void SetWidth(int w)
	{
		SetSize(w, Height());
	}
	virtual void SetHeight(int h)
	{
		SetSize(Width(), h);
	}
	virtual bool SetSize(int w, int h);
	virtual bool SetBounds(int x, int y, int w, int h);
	virtual bool SetBounds(const Gwen::Rect& bounds);

	virtual void SetPadding(const Padding& padding);
	virtual void SetMargin(const Margin& margin);

	// MoveTo is identical to SetPos except it uses ShouldRestrictToParent()
	virtual void MoveTo(int x, int y);
	virtual void MoveBy(int x, int y);

	virtual const Gwen::Rect& GetBounds() const
	{
		return m_Bounds;
	}

	virtual Controls::Base* GetControlAt(int x, int y);

protected:
	virtual void OnBoundsChanged(Gwen::Rect oldBounds);
	virtual void OnChildBoundsChanged(Gwen::Rect oldChildBounds, Base* pChild);

	virtual void OnScaleChanged();

public:
	// Innerbounds is the area inside the control that
	// doesn't have child controls docked to it.
	virtual const Gwen::Rect& GetInnerBounds() const { return m_InnerBounds; }

protected:
	Gwen::Rect m_InnerBounds;

public:
	virtual const Gwen::Rect& GetRenderBounds() const { return m_RenderBounds; }

protected:
	virtual void UpdateRenderBounds();

public:
	virtual void DoRender(Gwen::Skin::Base* skin);
	virtual void DoCacheRender(Gwen::Skin::Base* skin, Gwen::Controls::Base* pMaster);

protected:
	virtual void Render(Gwen::Skin::Base* skin);
	virtual void RenderUnder(Gwen::Skin::Base* /*skin*/){};
	virtual void RenderOver(Gwen::Skin::Base* /*skin*/){};
	virtual void RenderFocus(Gwen::Skin::Base* /*skin*/);

public:
	virtual void SetHidden(bool hidden)
	{
		if (m_bHidden == hidden)
			return;
		m_bHidden = hidden;
		Invalidate();
	}
	virtual bool Hidden() const;   // Returns true only if this control is hidden
	virtual bool Visible() const;  // Returns false if this control or its parents are hidden
	virtual void Hide() { SetHidden(true); }
	virtual void Show() { SetHidden(false); }

	//Skin
	virtual void SetSkin(Skin::Base* skin, bool doChildren = false);
	virtual Gwen::Skin::Base* GetSkin(void);

	// Background drawing
	virtual bool ShouldDrawBackground() { return m_bDrawBackground; }
	virtual void SetShouldDrawBackground(bool b) { m_bDrawBackground = b; }

protected:
	virtual void OnSkinChanged(Gwen::Skin::Base* newSkin);

public:
	virtual void OnMouseMoved(int x, int y, int deltaX, int deltaY);
	virtual bool OnMouseWheeled(int iDelta);
	virtual void OnMouseClickLeft(int /*x*/, int /*y*/, bool /*bDown*/){};
	virtual void OnMouseClickRight(int /*x*/, int /*y*/, bool /*bDown*/) {}
	virtual void OnMouseDoubleClickLeft(int x, int y) { OnMouseClickLeft(x, y, true); };
	virtual void OnMouseDoubleClickRight(int x, int y) { OnMouseClickRight(x, y, true); };
	virtual void OnLostKeyboardFocus() {}
	virtual void OnKeyboardFocus() {}

	virtual void SetMouseInputEnabled(bool b) { m_bMouseInputEnabled = b; }
	virtual bool GetMouseInputEnabled() { return m_bMouseInputEnabled; }

	virtual void SetKeyboardInputEnabled(bool b) { m_bKeyboardInputEnabled = b; }
	virtual bool GetKeyboardInputEnabled() const { return m_bKeyboardInputEnabled; }
	virtual bool NeedsInputChars() { return false; }

	virtual bool OnChar(Gwen::UnicodeChar /*c*/) { return false; }

	virtual bool OnKeyPress(int iKey, bool bPress = true);
	virtual bool OnKeyRelease(int iKey);

	virtual void OnPaste(Controls::Base* /*pFrom*/) {}
	virtual void OnCopy(Controls::Base* /*pFrom*/) {}
	virtual void OnCut(Controls::Base* /*pFrom*/) {}
	virtual void OnSelectAll(Controls::Base* /*pFrom*/) {}

	virtual bool OnKeyTab(bool bDown);
	virtual bool OnKeySpace(bool /*bDown*/) { return false; }
	virtual bool OnKeyReturn(bool /*bDown*/) { return false; }
	virtual bool OnKeyBackspace(bool /*bDown*/) { return false; }
	virtual bool OnKeyDelete(bool /*bDown*/) { return false; }
	virtual bool OnKeyRight(bool /*bDown*/) { return false; }
	virtual bool OnKeyLeft(bool /*bDown*/) { return false; }
	virtual bool OnKeyHome(bool /*bDown*/) { return false; }
	virtual bool OnKeyEnd(bool /*bDown*/) { return false; }
	virtual bool OnKeyUp(bool /*bDown*/) { return false; }
	virtual bool OnKeyDown(bool /*bDown*/) { return false; }
	virtual bool OnKeyEscape(bool /*bDown*/) { return false; }

	virtual void OnMouseEnter();
	virtual void OnMouseLeave();
	virtual bool IsHovered();
	virtual bool ShouldDrawHover();

	virtual void Touch();
	virtual void OnChildTouched(Controls::Base* pChild);

	virtual bool IsOnTop();

	virtual bool HasFocus();
	virtual void Focus();
	virtual void Blur();

	//Other
	virtual void SetDisabled(bool active) { m_bDisabled = active; }
	virtual bool IsDisabled() { return m_bDisabled; }

	virtual void Redraw()
	{
		m_bCacheTextureDirty = true;
		if (m_Parent) m_Parent->Redraw();
	}
	virtual void SetCacheToTexture() { m_bCacheToTexture = true; }
	virtual bool ShouldCacheToTexture() { return m_bCacheToTexture; }

	virtual void SetCursor(unsigned char c) { m_Cursor = c; }
	virtual void UpdateCursor();

	virtual Gwen::Point GetMinimumSize() { return Gwen::Point(1, 1); }
	virtual Gwen::Point GetMaximumSize() { return Gwen::Point(4096, 4096); }

	virtual void SetToolTip(const String& strText);
	virtual void SetToolTip(const UnicodeString& strText);
	virtual void SetToolTip(Base* tooltip)
	{
		m_ToolTip = tooltip;
		if (m_ToolTip)
		{
			m_ToolTip->SetParent(this);
			m_ToolTip->SetHidden(true);
		}
	}
	virtual Base* GetToolTip() { return m_ToolTip; }

	virtual bool IsMenuComponent();
	virtual void CloseMenus();

	virtual bool IsTabable() { return m_Tabable; }
	virtual void SetTabable(bool isTabable) { m_Tabable = isTabable; }

	//Accelerator functionality
	void DefaultAccel(Gwen::Controls::Base* /*pCtrl*/) { AcceleratePressed(); }
	virtual void AcceleratePressed(){};
	virtual bool AccelOnlyFocus() { return false; }
	virtual bool HandleAccelerator(Gwen::UnicodeString& accelerator);

	template <typename T>
	void AddAccelerator(Gwen::UnicodeString accelerator, T func, Gwen::Event::Handler* handler = NULL)
	{
		if (handler == NULL)
			handler = this;
		Gwen::Event::Caller* caller = new Gwen::Event::Caller();
		caller->Add(handler, func);
		m_Accelerators[accelerator] = caller;
	}

	void AddAccelerator(Gwen::UnicodeString accelerator)
	{
		AddAccelerator(accelerator, &Base::DefaultAccel, this);
	}

	AccelMap m_Accelerators;

	// Default Events

	Gwen::Event::Caller onHoverEnter;
	Gwen::Event::Caller onHoverLeave;

	// Childrens List

	Base::List Children;

protected:
	// The logical parent
	// It's usually what you expect, the control you've parented it to.
	Base* m_Parent;

	// If the innerpanel exists our children will automatically
	//  become children of that instead of us - allowing us to move
	//  them all around by moving that panel (useful for scrolling etc)
	Base* m_InnerPanel;

	// This is the panel's actual parent - most likely the logical
	//  parent's InnerPanel (if it has one). You should rarely need this.
	Base* m_ActualParent;

	Base* m_ToolTip;

	Skin::Base* m_Skin;

	Gwen::Rect m_Bounds;
	Gwen::Rect m_RenderBounds;
	Padding m_Padding;
	Margin m_Margin;

	Gwen::String m_Name;

	bool m_bRestrictToParent;
	bool m_bDisabled;
	bool m_bHidden;
	bool m_bMouseInputEnabled;
	bool m_bKeyboardInputEnabled;
	bool m_bDrawBackground;

	int m_iDock;

	unsigned char m_Cursor;

	bool m_Tabable;

public:
	bool NeedsLayout() { return m_bNeedsLayout; }
	void Invalidate();
	void InvalidateParent()
	{
		if (m_Parent)
		{
			m_Parent->Invalidate();
		}
	}
	void InvalidateChildren(bool bRecursive = false);
	void Position(int pos, int xpadding = 0, int ypadding = 0);

protected:
	virtual void RecurseLayout(Skin::Base* skin);
	virtual void Layout(Skin::Base* skin);
	virtual void PostLayout(Skin::Base* /*skin*/){};

	bool m_bNeedsLayout;
	bool m_bCacheTextureDirty;
	bool m_bCacheToTexture;

	//
	// Drag + Drop
public:
	// Giver

	virtual void DragAndDrop_SetPackage(bool bDraggable, const String& strName = "", void* pUserData = NULL);
	virtual bool DragAndDrop_Draggable();
	virtual bool DragAndDrop_ShouldStartDrag() { return true; }
	virtual void DragAndDrop_StartDragging(Gwen::DragAndDrop::Package* pPackage, int x, int y);
	virtual Gwen::DragAndDrop::Package* DragAndDrop_GetPackage(int x, int y);
	virtual void DragAndDrop_EndDragging(bool /*bSuccess*/, int /*x*/, int /*y*/){};

protected:
	DragAndDrop::Package* m_DragAndDrop_Package;

public:
	// Receiver
	virtual void DragAndDrop_HoverEnter(Gwen::DragAndDrop::Package* /*pPackage*/, int /*x*/, int /*y*/) {}
	virtual void DragAndDrop_HoverLeave(Gwen::DragAndDrop::Package* /*pPackage*/) {}
	virtual void DragAndDrop_Hover(Gwen::DragAndDrop::Package* /*pPackage*/, int /*x*/, int /*y*/){};
	virtual bool DragAndDrop_HandleDrop(Gwen::DragAndDrop::Package* pPackage, int x, int y);
	virtual bool DragAndDrop_CanAcceptPackage(Gwen::DragAndDrop::Package* /*pPackage*/) { return false; }

	//
	// This is to be used by the client implementation
	// NOT HOOKS ETC.
	//
public:
	void* GetUserData() { return m_pUserData; }
	void SetUserData(void* pData) { m_pUserData = pData; }

private:
	void* m_pUserData;

	//
	// Useful anim shortcuts
	//
public:
#ifndef GWEN_NO_ANIMATION

	virtual void Anim_WidthIn(float fLength, float fDelay = 0.0f, float fEase = 1.0f);
	virtual void Anim_HeightIn(float fLength, float fDelay = 0.0f, float fEase = 1.0f);
	virtual void Anim_WidthOut(float fLength, bool bHide = true, float fDelay = 0.0f, float fEase = 1.0f);
	virtual void Anim_HeightOut(float fLength, bool bHide = true, float fDelay = 0.0f, float fEase = 1.0f);

#endif
};

}  // namespace Controls
}  // namespace Gwen

// To be placed in the controls .h definition.
#define GWEN_CONTROL(ThisName, BaseName) \
public:                                  \
	typedef BaseName BaseClass;          \
	typedef ThisName ThisClass;          \
	GWEN_IMPLEMENT_CAST(ThisName);       \
	ThisName(Gwen::Controls::Base* pParent)

#define GWEN_CONTROL_INLINE(ThisName, BaseName) \
	GWEN_CONTROL(ThisName, BaseName) : BaseClass(pParent)

#define GWEN_CONTROL_CONSTRUCTOR(ThisName) \
	ThisName::ThisName(Gwen::Controls::Base* pParent) : BaseClass(pParent)

#endif