1

/* $Id$ */

     2

     3

#ifndef WIDGET_H

     4

#define WIDGET_H

     5

     6

     7

#include <list>

     8

#include <map>

     9

#include "../macros.h"

    10

#include "../string.h"

    11

#include "../order.h"

    12

#include "../rail.h"

    13

#include "../airport.h"

    14

#include "../misc/rect.hpp"

    15

#include "../misc/countedptr.hpp"

    16

    17

#include "window_event_base.h"

    18

    19

enum FrameFlags {

    20

	FR_NONE         = 0x00,

    21

	FR_TRANSPARENT  = 0x01,  ///< Makes the background transparent if set

    22

	FR_BORDERONLY   = 0x10,  ///< Draw border only, no background

    23

	FR_LOWERED      = 0x20,  ///< If set the frame is lowered and the background color brighter (ie. buttons when pressed)

    24

	FR_DARKENED     = 0x40,  ///< If set the background is darker, allows for lowered frames with normal background color when used with FR_LOWERED (ie. dropdown boxes)

    25

	FR_BG_ONLY      = 0x80,  ///< If set only the background is drawn without any frame (labels and such)

    26

};

    27

    28

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

    29

    30

enum Anchors {

    31

	PIN_NONE     = 0x00,

    32

	PIN_LEFT     = 0x01,

    33

	PIN_TOP      = 0x02,

    34

	PIN_RIGHT    = 0x04,

    35

	PIN_BOTTOM   = 0x08,

    36

};

    37

    38

DECLARE_ENUM_AS_BIT_SET(Anchors);

    39

    40

namespace gui {

    41

    42

enum FeatureFlags {

    43

	FF_NONE                = 0,

    44

	FF_NO_CAPTION_BAR      = (1 <<  0),

    45

	FF_NO_CLOSE_BOX        = (1 <<  1),

    46

	FF_NO_STICKY_BOX       = (1 <<  2),

    47

	FF_NO_RESIZE_BOX       = (1 <<  3),

    48

	FF_UNMOVABLE           = (1 <<  4),

    49

	FF_TRANSPARENT         = (1 <<  5),

    50

	FF_TOGGLE_BUTTON       = (1 <<  6),

    51

	FF_STICKED             = (1 <<  7),

    52

};

    53

    54

DECLARE_ENUM_AS_BIT_SET(FeatureFlags);

    55

    56

struct Widget;

    57

typedef CCountedPtr<Widget> WidgetPtr;

    58

    59

struct CompositeWidget;

    60

typedef CCountedPtr<CompositeWidget> CompositeWidgetPtr;

    61

    62

typedef int32 WidgetId;

    63

    64

struct Widget : public SimpleCountedObject {

    65

	typedef AdaptT<EventHandlerDelegatePtr> Handler;

    66

	typedef std::list<Handler> Handlers;

    67

    68

	CompositeWidget *m_container;       ///< widget container (can be any panel or window)

    69

	WidgetId        m_id;               ///< Widget id in its container

    70

	Rect16          m_rect;             ///< The position offsets relative to the container

    71

	uint16          m_data;             ///< The String/Image or special code (list-matrices) of a widget

    72

	FeatureFlags    m_feature_flags;    ///< @see FeatureFlags

    73

	byte            m_color;            ///< Widget color, see docs/ottd-colourtext-palette.png

    74

	bool            m_is_closing : 1;   ///< Widget was logically destroyed

    75

	bool            m_dont_clip : 1;    ///< should not be clipped by parent (container)

    76

	StringID        m_tooltips;         ///< Tooltips that are shown when right clicking on a widget

    77

	Anchors         m_anchors;          ///< Resize/move when container resizes?

    81

	Handlers        m_handlers;         ///< dynamically registered event handlers

    82

    83

	Widget()

    84

		: m_container(NULL), m_id(0), m_rect(), m_data(0), m_feature_flags(FF_NONE), m_color(0)

    85

		, m_is_closing(false), m_tooltips(0), m_anchors(PIN_NONE)

    87

	{}

    88

    89

	Widget(CompositeWidget *container, WidgetId id, FeatureFlags feature_flags, byte color, const Rect16 &rect, StringID tooltips)

    90

		: m_container(container)

    91

		, m_id(id)

    92

		, m_rect(rect)

    93

		, m_data(0)

    94

		, m_feature_flags(feature_flags)

    95

		, m_color(color)

    96

		, m_is_closing(false)

    97

		, m_dont_clip(false)

    98

		, m_tooltips(tooltips)

    99

		, m_anchors(PIN_NONE)

   102

	{}

   103

   104

	int16 Left() const;

   105

	int16 Top() const;

   106

	int16 Right() const;

   107

	int16 Bottom() const;

   108

	int16 Width() const;

   109

	int16 Height() const;

   110

	const Point16& TopLeft() const;

   111

	const Point16& BottomRight() const;

   112

	Point16 Size() const;

   113

	Point16 CenterPt() const;

   114

	const Rect16& GetRect() const;

   115

   116

	void SetLeft(int16 val);

   117

	void SetTop(int16 val);

   118

	void SetRight(int16 val);

   119

	void SetBottom(int16 val);

   120

	void SetWidth(int16 val);

   121

	void SetHeight(int16 val);

   122

	void SetTopLeft(const Point16 &pt);

   123

	void SetBottomRight(const Point16 &pt);

   124

	void SetSize(const Point16 &pt);

   125

	void SetRect(const Rect16 &rect);

   126

   127

	byte GetColor() const;

   128

	void SetColor(byte val);

   129

   130

	void SetAnchors(Anchors a);

   131

   132

	WidgetId GetId() const;

   133

   134

	void AddHandler(EventHandlerDelegate *d);

   135

	void CallHandlers(EventBase &e);

   136

   137

	void Invalidate() {}; ///< now we redraw gui all the time, so no processing is needed here

   138

	static /*static*/ void FillRect(const Rect16 &rc, int color);

   139

	static void DrawFrameRect(int left, int top, int right, int bottom, int ctab, FrameFlags flags);

   140

	void DrawFrameRect(int ctab, FrameFlags flags);

   141

	void DrawSprite(SpriteID img, SpriteID pal, const Point16 &local_pos);

   142

   143

	virtual BaseWindow* GetWindow();

   144

	virtual Widget* WidgetFromPt(const Point16 &pt);

   145

   146

	virtual void Close();

   147

   148

	virtual void DrawBackground(EvtPaint &ev);

   149

   150

	/**

   151

	 * OnCreate() handler called when window gets created. Override this method in your

   152

	 * Window subclass and place widgets into your window from there.

   153

	 */

   154

	virtual void OnCreate(EvtCreate &ev) {};

   155

	virtual void OnDestroy(EvtDestroy &ev) {};

   156

	virtual void OnPaint(EvtPaint &ev) = 0;

   157

	virtual void OnKeyPress(EvtKeyPress &ev) {};

   158

	virtual void OnLeftButtonDown(EvtLeftButtonDown &ev) {};

   159

	virtual void OnLeftClick(EvtLeftClick &ev);

   160

	virtual void OnRightButtonDown(EvtRightButtonDown &ev);

   161

	virtual void OnMouseOver(EvtMouseOver &ev) {};

   162

	virtual void OnResize(EvtResize &ev) {};

   163

	virtual void OnResizeParent(EvtResizeParent &ev);

   164

   165

	/**

   166

	 * Dispatch event by its type calling appropriate OnCreate(), OnDestroy(), etc.

   167

	 */

   168

	virtual void DispatchEvent(EventBase &ev);

   169

   170

	/**

   171

	 * @function AddReflectHandlerT Registers reflected event handler. Use it from

   172

	 * BaseWindow subclasses (Window implementations) to register custom event handler.

   173

	 * For example if you are implementing 'MyWindow' class and want to handle OnLeftClick()

   174

	 * event for your button 'MyButton', define your handler method inside 'MyWindow' class

   175

	 * like:

   176

	 *       void MyWindow::MyButtonClickHandler(gui::EvtLeftClick &e)

   177

	 *       {

   178

	 *          ...

   179

	 *       }

   180

	 * then from inside OnCreate() handler, create your button 'my_button' and

   181

	 * call:

   182

	 *       my_button->AddReflectHandlerT(&MyWindow::MyButtonClickHandler);

   183

	 * and your MyButtonClickHandler will be called on every click on my_button.

   184

	 */

   185

	template <class Twnd_cls, EventCode Tevt_code> void AddReflectHandlerT(void (Twnd_cls::*handler)(gui::EventT<Tevt_code>&))

   186

	{

   187

		typedef ReflectHandlerDelegateT<Twnd_cls, Tevt_code> Delegate;

   188

		AddHandler(new Delegate(handler));

   189

	}

   190

   191

	/** add capture handler using default delegate type (CaptureHandlerDelegateT<>) */

   192

	template <class Twd_cls, EventCode Tevt_code> CaptureTicket CaptureEventsT(Twd_cls *wd, void (Twd_cls::*handler)(EventT<Tevt_code>&))

   193

	{

   194

		CaptureTicket ticket = EventCaptureStack::AddHandler(new CaptureHandlerDelegateT<Twd_cls, Tevt_code>(wd, handler));

   195

		return ticket;

   196

	}

   197

   198

};

   199

   200

struct CompositeWidget : public Widget {

   201

	typedef Widget super;

   202

	typedef std::map<WidgetId, WidgetPtr> Widgets;

   203

	typedef Widgets::iterator WidgetIterator;

   204

	typedef Widgets::reverse_iterator WidgetReverseIterator;

   205

   206

protected:

   207

	Widgets m_widgets;

   208

   209

public:

   210

	CompositeWidget()

   211

		: Widget()

   212

	{}

   213

   214

	CompositeWidget(CompositeWidget *container, WidgetId id, FeatureFlags feature_flags, byte color, const Rect16 &rect, StringID tooltips)

   215

		: Widget(container, id, feature_flags, color, rect, tooltips)

   216

	{}

   217

   218

	void AddWidget(Widget *wd);

   219

	Widget* GetWidget(WidgetId id);

   220

	Widget* RemoveWidget(WidgetId id);

   221

   222

	/*virtual*/ Widget* WidgetFromPt(const Point16 &pt);

   223

   224

	virtual void CreateNcWidgets() {};

   225

	virtual void CreateWidgets() = 0;

   226

	virtual void Close();

   227

   228

	/*virtual*/ void OnCreate(EvtCreate &ev);

   229

	/*virtual*/ void OnPaint(EvtPaint &ev);

   230

	/*virtual*/ void OnLeftButtonDown(EvtLeftButtonDown &ev);

   231

	/*virtual*/ void OnRightButtonDown(EvtRightButtonDown &ev);

   232

	/*virtual*/ void OnResize(EvtResize &ev);

   233

};

   234

   235

   236

}; // namespace gui

   237

   238

#endif /* WIDGET_H */