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

};

    51

    52

DECLARE_ENUM_AS_BIT_SET(FeatureFlags);

    53

    54

struct Widget;

    55

typedef CCountedPtr<Widget> WidgetPtr;

    56

    57

struct CompositeWidget;

    58

typedef CCountedPtr<CompositeWidget> CompositeWidgetPtr;

    59

    60

typedef int32 WidgetId;

    61

    62

struct Widget : public SimpleCountedObject {

    63

	typedef AdaptT<EventHandlerDelegatePtr> Handler;

    64

	typedef std::list<Handler> Handlers;

    65

    66

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

    67

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

    68

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

    69

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

    70

	FeatureFlags    m_feature_flags;    ///< @see FeatureFlags

    71

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

    72

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

    73

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

    74

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

    75

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

    76

	Handlers        m_handlers;         ///< dynamically registered event handlers

    77

    78

	Widget()

    79

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

    80

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

    81

	{}

    82

    83

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

    84

		: m_container(container)

    85

		, m_id(id)

    86

		, m_rect(rect)

    87

		, m_data(0)

    88

		, m_feature_flags(feature_flags)

    89

		, m_color(color)

    90

		, m_is_closing(false)

    91

		, m_dont_clip(false)

    92

		, m_tooltips(tooltips)

    93

		, m_anchors(PIN_NONE)

    94

	{}

    95

    96

	int16 Left() const;

    97

	int16 Top() const;

    98

	int16 Right() const;

    99

	int16 Bottom() const;

   100

	int16 Width() const;

   101

	int16 Height() const;

   102

	const Point16& TopLeft() const;

   103

	const Point16& BottomRight() const;

   104

	Point16 Size() const;

   105

	Point16 CenterPt() const;

   106

	const Rect16& GetRect() const;

   107

   108

	void SetLeft(int16 val);

   109

	void SetTop(int16 val);

   110

	void SetRight(int16 val);

   111

	void SetBottom(int16 val);

   112

	void SetWidth(int16 val);

   113

	void SetHeight(int16 val);

   114

	void SetTopLeft(const Point16 &pt);

   115

	void SetBottomRight(const Point16 &pt);

   116

	void SetSize(const Point16 &pt);

   117

	void SetRect(const Rect16 &rect);

   118

   119

	byte GetColor() const;

   120

	void SetColor(byte val);

   121

   122

	void SetAnchors(Anchors a);

   123

   124

	WidgetId GetId() const;

   125

   126

	void AddHandler(EventHandlerDelegate *d);

   127

	void CallHandlers(EventBase &e);

   128

   129

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

   130

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

   131

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

   132

	void DrawFrameRect(int ctab, FrameFlags flags);

   133

   134

	virtual BaseWindow* GetWindow();

   135

	virtual Widget* WidgetFromPt(const Point16 &pt);

   136

   137

	virtual void Close();

   138

   139

	virtual void DrawBackground(EvtPaint &ev);

   140

   141

	/**

   142

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

   143

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

   144

	 */

   145

	virtual void OnCreate(EvtCreate &ev) {};

   146

	virtual void OnDestroy(EvtDestroy &ev) {};

   147

	virtual void OnPaint(EvtPaint &ev) = 0;

   148

	virtual void OnKeyPress(EvtKeyPress &ev) {};

   149

	virtual void OnLeftButtonDown(EvtLeftButtonDown &ev) {};

   150

	virtual void OnLeftClick(EvtLeftClick &ev);

   151

	virtual void OnRightButtonDown(EvtRightButtonDown &ev);

   152

	virtual void OnMouseOver(EvtMouseOver &ev) {};

   153

	virtual void OnResize(EvtResize &ev) {};

   154

	virtual void OnResizeParent(EvtResizeParent &ev);

   155

   156

	/**

   157

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

   158

	 */

   159

	virtual void DispatchEvent(EventBase &ev);

   160

   161

	/**

   162

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

   163

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

   164

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

   165

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

   166

	 * like:

   167

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

   168

	 *       {

   169

	 *          ...

   170

	 *       }

   171

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

   172

	 * call:

   173

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

   174

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

   175

	 */

   176

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

   177

	{

   178

		typedef ReflectHandlerDelegateT<Twnd_cls, Tevt_code> Delegate;

   179

		AddHandler(new Delegate(handler));

   180

	}

   181

   182

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

   183

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

   184

	{

   185

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

   186

		return ticket;

   187

	}

   188

   189

};

   190

   191

struct CompositeWidget : public Widget {

   192

	typedef Widget super;

   193

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

   194

	typedef Widgets::iterator WidgetIterator;

   195

	typedef Widgets::reverse_iterator WidgetReverseIterator;

   196

   197

protected:

   198

	Widgets m_widgets;

   199

   200

public:

   201

	CompositeWidget()

   202

		: Widget()

   203

	{}

   204

   205

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

   206

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

   207

	{}

   208

   209

	void AddWidget(Widget *wd);

   210

	Widget* GetWidget(WidgetId id);

   211

	Widget* RemoveWidget(WidgetId id);

   212

   213

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

   214

   215

	virtual void CreateNcWidgets() {};

   216

	virtual void CreateWidgets() = 0;

   217

	virtual void Close();

   218

   219

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

   220

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

   221

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

   222

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

   223

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

   224

};

   225

   226

struct Label : public Widget {

   227

	typedef Widget super;

   228

   229

protected:

   230

	StringID m_text;

   231

   232

public:

   233

	Label()

   234

		: Widget()

   235

	{}

   236

   237

	Label(CompositeWidget *container, WidgetId id, FeatureFlags feature_flags, const Rect16 &rect, StringID text, StringID tooltip = 0, int color = COLOUR_NONE)

   238

		: Widget(container, id, feature_flags, (byte)color, rect, tooltip)

   239

		, m_text(text)

   240

	{

   241

		/* make the label transparent (no background) if color not provided */

   242

		if (color == COLOUR_NONE) m_feature_flags |= FF_TRANSPARENT;

   243

	}

   244

   245

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

   246

   247

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

   248

};

   249

   250

struct Button : public Widget {

   251

	typedef Widget super;

   252

   253

protected:

   254

	bool m_pushed;

   255

	CaptureTicket m_ticket_pressed;

   256

   257

public:

   258

	Button()

   259

		: Widget()

   260

		, m_pushed(false)

   261

	{}

   262

   263

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

   264

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

   265

		, m_pushed(false)

   266

	{}

   267

   268

	void OnCapturePressed(EvtMouseOver &e);

   269

   270

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

   271

   272

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

   273

};

   274

   275

struct TextButton : public Button {

   276

	typedef Button super;

   277

   278

protected:

   279

	StringID m_text;

   280

   281

public:

   282

	TextButton()

   283

		: Button()

   284

	{}

   285

   286

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

   287

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

   288

		, m_text(text)

   289

	{}

   290

   291

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

   292

};

   293

   294

struct CloseBox : public Button {

   295

	typedef Button super;

   296

   297

	static const int16 DEFAULT_WIDTH  = 11;

   298

	static const int16 DEFAULT_HEIGHT = 14;

   299

   300

public:

   301

	CloseBox()

   302

		: Button()

   303

	{}

   304

   305

	CloseBox(CompositeWidget *container)

   306

		: Button(container, -102, FF_NONE, container->m_color, Rect16(), 0)

   307

	{}

   308

   309

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

   310

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

   311

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

   312

};

   313

   314

struct Caption : public Widget {

   315

	typedef Widget super;

   316

   317

protected:

   318

	Point16       m_moving_offset;

   319

	CaptureTicket m_ticket_moving;

   320

   321

public:

   322

	Caption()

   323

		: Widget()

   324

	{}

   325

   326

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

   327

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

   328

	{}

   329

   330

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

   331

   332

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

   333

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

   334

	void OnCaptureMoving(EvtMouseOver &e);

   335

};

   336

   337

struct CaptionBar : public CompositeWidget {

   338

	typedef CompositeWidget super;

   339

   340

	static const int16 DEFAULT_HEIGHT = 14;

   341

   342

public:

   343

	CaptionBar()

   344

		: CompositeWidget()

   345

	{}

   346

   347

	CaptionBar(CompositeWidget *container, WidgetId id, FeatureFlags feature_flags, byte color)

   348

		: CompositeWidget(container, id, feature_flags, color, Rect16(0, 0, container->Right(), DEFAULT_HEIGHT - 1), 0)

   349

	{}

   350

   351

	/*virtual*/ void CreateWidgets();

   352

};

   353

   354

   355

struct ResizeBox : public Widget {

   356

	typedef Widget super;

   357

   358

	static const int16 DEFAULT_WIDTH  = 11;

   359

	static const int16 DEFAULT_HEIGHT = 11;

   360

   361

protected:

   362

	Point16       m_sizing_offset;

   363

	CaptureTicket m_ticket_sizing;

   364

   365

public:

   366

	ResizeBox()

   367

		: Widget()

   368

	{}

   369

   370

	ResizeBox(CompositeWidget *container)

   371

		: Widget(container, -101, FF_NONE, container->m_color, Rect16(), 0)

   372

	{}

   373

   374

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

   375

	void OnCaptureSizing(EvtMouseOver &e);

   376

   377

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

   378

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

   379

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

   380

	/*virtual*/ void OnResizeParent(EvtResizeParent &ev);

   381

   382

};

   383

   384

}; // namespace gui

   385

   386

#endif /* WIDGET_H */