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

};

    26

    27

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

    28

    29

    30

namespace gui {

    31

    32

struct Widget;

    33

typedef CCountedPtr<Widget> WidgetPtr;

    34

    35

struct CompositeWidget;

    36

typedef CCountedPtr<CompositeWidget> CompositeWidgetPtr;

    37

    38

typedef int32 WidgetId;

    39

    40

struct Widget : public SimpleCountedObject {

    41

	typedef AdaptT<EventHandlerDelegatePtr> Handler;

    42

	typedef std::list<Handler> Handlers;

    43

    44

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

    45

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

    46

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

    47

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

    48

	byte            m_display_flags;    ///< Resize direction, alignment, etc. during resizing, see @ResizeFlags

    49

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

    50

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

    51

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

    52

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

    53

	Handlers        m_handlers;         ///< dynamically registered event handlers

    54

    55

	Widget()

    56

		: m_container(NULL), m_id(0), m_rect(), m_data(0), m_display_flags(0), m_color(0)

    57

		, m_is_closing(false), m_tooltips(0)

    58

	{}

    59

    60

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

    61

		: m_container(container)

    62

		, m_id(id)

    63

		, m_rect(rect)

    64

		, m_data(0)

    65

		, m_display_flags(display_flags)

    66

		, m_color(color)

    67

		, m_is_closing(false)

    68

		, m_dont_clip(false)

    69

		, m_tooltips(tooltips)

    70

	{}

    71

    72

	int16 Left() const;

    73

	int16 Top() const;

    74

	int16 Right() const;

    75

	int16 Bottom() const;

    76

	int16 Width() const;

    77

	int16 Height() const;

    78

	const Point16& TopLeft() const;

    79

	const Point16& BottomRight() const;

    80

	Point16 Size() const;

    81

	Point16 CenterPt() const;

    82

	const Rect16& GetRect() const;

    83

    84

	void SetLeft(int16 val);

    85

	void SetTop(int16 val);

    86

	void SetRight(int16 val);

    87

	void SetBottom(int16 val);

    88

	void SetWidth(int16 val);

    89

	void SetHeight(int16 val);

    90

	void SetTopLeft(const Point16 &pt);

    91

	void SetBottomRight(const Point16 &pt);

    92

	void SetSize(const Point16 &pt);

    93

	void SetRect(const Rect16 &rect);

    94

    95

	WidgetId GetId() const;

    96

    97

	void AddHandler(EventHandlerDelegate *d);

    98

	void CallHandlers(EventBase &e);

    99

   100

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

   101

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

   102

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

   103

	void DrawFrameRect(int ctab, FrameFlags flags);

   104

   105

	virtual BaseWindow* GetWindow();

   106

	virtual Widget* WidgetFromPt(const Point16 &pt);

   107

   108

	virtual void Close();

   109

   110

	virtual void DrawBackground(EvtPaint &ev);

   111

   112

	/**

   113

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

   114

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

   115

	 */

   116

	virtual void OnCreate(EvtCreate &ev) {};

   117

	virtual void OnDestroy(EvtDestroy &ev) {};

   118

	virtual void OnPaint(EvtPaint &ev) = 0;

   119

	virtual void OnKeyPress(EvtKeyPress &ev) {};

   120

	virtual void OnLeftClick(EvtClick &ev);

   121

	virtual void OnRightClick(EvtRightClick &ev);

   122

	virtual void OnMouseOver(EvtMouseOver &ev) {};

   123

   124

	/**

   125

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

   126

	 */

   127

	virtual void DispatchEvent(EventBase &ev);

   128

   129

	/**

   130

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

   131

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

   132

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

   133

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

   134

	 * like:

   135

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

   136

	 *       {

   137

	 *          ...

   138

	 *       }

   139

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

   140

	 * call:

   141

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

   142

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

   143

	 */

   144

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

   145

	{

   146

		typedef ReflectHandlerDelegateT<Twnd_cls, Tevt_code> Delegate;

   147

		AddHandler(new Delegate(handler));

   148

	}

   149

   150

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

   151

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

   152

	{

   153

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

   154

		return ticket;

   155

	}

   156

   157

};

   158

   159

struct CompositeWidget : public Widget {

   160

	typedef Widget super;

   161

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

   162

	typedef Widgets::iterator WidgetIterator;

   163

	typedef Widgets::reverse_iterator WidgetReverseIterator;

   164

   165

protected:

   166

	Widgets m_widgets;

   167

   168

public:

   169

	CompositeWidget()

   170

		: Widget()

   171

	{}

   172

   173

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

   174

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

   175

	{}

   176

   177

	void AddWidget(Widget *wd);

   178

	Widget* GetWidget(WidgetId id);

   179

	Widget* RemoveWidget(WidgetId id);

   180

   181

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

   182

   183

	virtual void Close();

   184

   185

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

   186

	/*virtual*/ void OnLeftClick(EvtClick &ev);

   187

	/*virtual*/ void OnRightClick(EvtRightClick &ev);

   188

};

   189

   190

struct Button : public Widget {

   191

	typedef Widget super;

   192

   193

protected:

   194

	bool m_pushed;

   195

	CaptureTicket m_ticket_pressed;

   196

   197

public:

   198

	Button()

   199

		: Widget()

   200

		, m_pushed(false)

   201

	{}

   202

   203

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

   204

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

   205

		, m_pushed(false)

   206

	{}

   207

   208

	void OnCapturePressed(EvtMouseOver &e);

   209

   210

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

   211

   212

	/*virtual*/ void OnLeftClick(EvtClick &ev);

   213

};

   214

   215

struct TextButton : public Button {

   216

	typedef Button super;

   217

   218

protected:

   219

	StringID m_text;

   220

   221

public:

   222

	TextButton()

   223

		: Button()

   224

	{}

   225

   226

	TextButton(CompositeWidget *container, WidgetId id, byte display_flags, byte color, const Rect16 &rect, StringID tooltips, StringID text)

   227

		: Button(container, id, display_flags, color, rect, tooltips)

   228

		, m_text(text)

   229

	{}

   230

   231

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

   232

};

   233

   234

struct CaptionBar : public CompositeWidget {

   235

	typedef CompositeWidget super;

   236

   237

	static const int16 DEFAULT_HEIGHT = 14;

   238

   239

protected:

   244

   245

public:

   246

	CaptionBar()

   247

		: CompositeWidget()

   248

		, m_text(0)

   249

		, m_text_color(0xFF)

   250

	{}

   251

   252

	CaptionBar(CompositeWidget *container, WidgetId id, byte display_flags, byte color, byte text_color, StringID tooltips, StringID text)

   253

		: CompositeWidget(container, id, display_flags, color, Rect16(0, 0, container->Width() - 1, DEFAULT_HEIGHT - 1), tooltips)

   254

		, m_text(text)

   255

		, m_text_color(text_color)

   256

	{}

   257

   258

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

   259

   260

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

   263

};

   264

   265

   266

   267

   268

   269

   270

   271

   272

   273

   274

   275

}; // namespace gui

   276

   277

   278

#endif /* WIDGET_H */