1

/* $Id$ */

     2

     3

#ifndef WINDOW_H

     4

#define WINDOW_H

     5

     6

#include <list>

     7

#include <map>

     8

#include "macros.h"

     9

#include "string.h"

    10

#include "order.h"

    11

#include "rail.h"

    12

#include "airport.h"

    13

#include "misc/rect.hpp"

    14

#include "misc/countedptr.hpp"

    15

    16

typedef struct WindowEvent WindowEvent;

    17

    18

typedef void WindowProc(BaseWindow *w, WindowEvent *e);

    19

    20

/* How the resize system works:

    21

    First, you need to add a WWT_RESIZEBOX to the widgets, and you need

    22

     to add the flag WDF_RESIZABLE to the window. Now the window is ready

    23

     to resize itself.

    24

    As you may have noticed, all widgets have a RESIZE_XXX in their line.

    25

     This lines controls how the widgets behave on resize. RESIZE_NONE means

    26

     it doesn't do anything. Any other option let's one of the borders

    27

     move with the changed width/height. So if a widget has

    28

     RESIZE_RIGHT, and the window is made 5 pixels wider by the user,

    29

     the right of the window will also be made 5 pixels wider.

    30

    Now, what if you want to clamp a widget to the bottom? Give it the flag

    31

     RESIZE_TB. This is RESIZE_TOP + RESIZE_BOTTOM. Now if the window gets

    32

     5 pixels bigger, both the top and bottom gets 5 bigger, so the whole

    33

     widgets moves downwards without resizing, and appears to be clamped

    34

     to the bottom. Nice aint it?

    35

   You should know one more thing about this system. Most windows can't

    36

    handle an increase of 1 pixel. So there is a step function, which

    37

    let the windowsize only be changed by X pixels. You configure this

    38

    after making the window, like this:

    39

      w->resize.step_height = 10;

    40

    Now the window will only change in height in steps of 10.

    41

   You can also give a minimum width and height. The default value is

    42

    the default height/width of the window itself. You can change this

    43

    AFTER window-creation, with:

    44

     w->resize.width or w->resize.height.

    45

   That was all.. good luck, and enjoy :) -- TrueLight */

    46

    47

enum ResizeFlag {

    48

	RESIZE_NONE   = 0,

    49

    50

	RESIZE_LEFT   = 1,

    51

	RESIZE_RIGHT  = 2,

    52

	RESIZE_TOP    = 4,

    53

	RESIZE_BOTTOM = 8,

    54

    55

	RESIZE_LR     = RESIZE_LEFT  | RESIZE_RIGHT,

    56

	RESIZE_RB     = RESIZE_RIGHT | RESIZE_BOTTOM,

    57

	RESIZE_TB     = RESIZE_TOP   | RESIZE_BOTTOM,

    58

	RESIZE_LRB    = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_BOTTOM,

    59

	RESIZE_LRTB   = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_TOP | RESIZE_BOTTOM,

    60

	RESIZE_RTB    = RESIZE_RIGHT | RESIZE_TOP    | RESIZE_BOTTOM,

    61

    62

	/* The following flags are used by the system to specify what is disabled, hidden, or clicked

    63

	 * They are used in the same place as the above RESIZE_x flags, Widget visual_flags.

    64

	 * These states are used in exceptions. If nothing is specified, they will indicate

    65

	 * Enabled, visible or unclicked widgets*/

    66

	WIDG_DISABLED = 4,  // widget is greyed out, not available

    67

	WIDG_HIDDEN   = 5,  // widget is made invisible

    68

	WIDG_LOWERED  = 6,  // widget is paint lowered, a pressed button in fact

    69

};

    70

    71

DECLARE_ENUM_AS_BIT_SET(ResizeFlag);

    72

    73

enum WindowFlags {

    74

	//WF_TIMEOUT_SHL       = 0,

    75

	//WF_TIMEOUT_MASK      = 7,

    76

	WF_DRAGGING          = 1 <<  3,

    77

	WF_SCROLL_UP         = 1 <<  4,

    78

	WF_SCROLL_DOWN       = 1 <<  5,

    79

	WF_SCROLL_MIDDLE     = 1 <<  6,

    80

	WF_HSCROLL           = 1 <<  7,

    81

	WF_SIZING            = 1 <<  8,

    82

	WF_STICKY            = 1 <<  9,

    83

    84

	WF_DISABLE_VP_SCROLL = 1 << 10,

    85

    86

	//WF_WHITE_BORDER_ONE  = 1 << 11,

    87

	//WF_WHITE_BORDER_MASK = 1 << 12 | WF_WHITE_BORDER_ONE,

    88

	WF_SCROLL2           = 1 << 13,

    89

};

    90

    91

DECLARE_ENUM_AS_BIT_SET(WindowFlags);

    92

    93

/* used to indicate the end of widgets' list for vararg functions */

    94

enum {

    95

	WIDGET_LIST_END = -1,

    96

};

    97

    98

/****************** THESE ARE NOT WIDGET TYPES!!!!! *******************/

    99

enum WindowWidgetBehaviours {

   100

	WWB_PUSHBUTTON  = 1 << 5,

   101

   102

	WWB_MASK        = 0xE0,

   103

};

   104

   105

   106

enum WindowWidgetTypes {

   107

	WWT_EMPTY,

   108

   109

	WWT_PANEL,      /* simple depressed panel */

   110

	WWT_INSET,      /* pressed (inset) panel, most commonly used as combo box _text_ area */

   111

	WWT_IMGBTN,     /* button with image */

   112

	WWT_IMGBTN_2,   /* button with diff image when clicked */

   113

   114

	WWT_TEXTBTN,    /* button with text */

   115

	WWT_TEXTBTN_2,  /* button with diff text when clicked */

   116

	WWT_LABEL,      /* centered label */

   117

	WWT_MATRIX,

   118

	WWT_SCROLLBAR,

   119

	WWT_FRAME,      /* frame */

   120

	WWT_CAPTION,

   121

   122

	WWT_HSCROLLBAR,

   123

	WWT_STICKYBOX,

   124

	WWT_SCROLL2BAR, /* 2nd vertical scrollbar*/

   125

	WWT_RESIZEBOX,

   126

	WWT_CLOSEBOX,

   127

	WWT_LAST,       /* Last Item. use WIDGETS_END to fill up padding!! */

   128

   129

	WWT_MASK = 0x1F,

   130

   131

	WWT_PUSHBTN     = WWT_PANEL   | WWB_PUSHBUTTON,

   132

	WWT_PUSHTXTBTN  = WWT_TEXTBTN | WWB_PUSHBUTTON,

   133

	WWT_PUSHIMGBTN  = WWT_IMGBTN  | WWB_PUSHBUTTON,

   134

};

   135

   136

#define WIDGETS_END WWT_LAST,   RESIZE_NONE,     0,     0,     0,     0,     0, 0, STR_NULL

   137

   138

   139

   140

   141

struct Widget;

   142

typedef CCountedPtr<Widget> WidgetPtr;

   143

   144

struct CompositeWidget;

   145

typedef CCountedPtr<CompositeWidget> CompositeWidgetPtr;

   146

   147

typedef int32 WidgetId;

   148

   149

typedef enum FrameFlags {

   150

	FR_NONE         = 0x00,

   151

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

   152

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

   153

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

   154

	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)

   155

} FrameFlags;

   156

   157

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

   158

   159

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

   160

   161

enum WindowEventCodes {

   162

	WE_CREATE,

   163

	WE_DESTROY,

   164

	WE_PAINT,

   165

	WE_KEYPRESS,

   166

	WE_CLICK,

   167

	WE_RCLICK,

   168

	WE_MOUSEOVER,

   169

	WE_MOUSELOOP,

   170

	WE_MOUSEWHEEL,

   171

	WE_TICK,

   172

	WE_4,

   173

	WE_TIMEOUT,

   174

	WE_PLACE_OBJ,

   175

	WE_ABORT_PLACE_OBJ,

   176

	WE_ON_EDIT_TEXT,

   177

	WE_ON_EDIT_TEXT_CANCEL,

   178

	WE_POPUPMENU_SELECT,

   179

	WE_POPUPMENU_OVER,

   180

	WE_DRAGDROP,

   181

	WE_PLACE_DRAG,

   182

	WE_PLACE_MOUSEUP,

   183

	WE_PLACE_PRESIZE,

   184

	WE_DROPDOWN_SELECT,

   185

	WE_RESIZE,

   186

	WE_MESSAGE,

   187

	WE_SCROLL,

   188

	WE_INVALIDATE_DATA,

   189

};

   190

   191

struct WindowEvent {

   192

	byte event;

   193

	union {

   194

		struct{

   195

			PointRaw pt;

   196

			int widget;

   197

		} click;

   198

   199

		struct {

   200

			PointRaw pt;

   201

			TileIndex tile;

   202

			TileIndex starttile;

   203

			int userdata;

   204

		} place;

   205

   206

		struct {

   207

			PointRaw pt;

   208

			int widget;

   209

		} dragdrop;

   210

   211

		struct {

   212

			PointRaw size;

   213

			PointRaw diff;

   214

		} sizing;

   215

   216

		struct {

   217

			char *str;

   218

		} edittext;

   219

   220

		struct {

   221

			PointRaw pt;

   222

		} popupmenu;

   223

   224

		struct {

   225

			int button;

   226

			int index;

   227

		} dropdown;

   228

   229

		struct {

   230

			PointRaw pt;

   231

			int widget;

   232

		} mouseover;

   233

   234

		struct {

   235

			bool cont;     // continue the search? (default true)

   236

			uint16 key;    // 16-bit Unicode value of the key

   237

			uint16 keycode;// untranslated key (including shift-state)

   238

		} keypress;

   239

   240

		struct {

   241

			int msg;      // message to be sent

   242

			int wparam;   // additional message-specific information

   243

			int lparam;   // additional message-specific information

   244

		} message;

   245

   246

		struct {

   247

			PointRaw delta;   // delta position against position of last call

   248

		} scroll;

   249

   250

		struct {

   251

			int wheel;     // how much was 'wheel'd'

   252

		} wheel;

   253

	} we;

   254

};

   255

   256

struct OldWidget;

   257

   258

typedef struct WindowDesc {

   259

	int16 left, top, width, height;

   260

	WindowClass cls;

   261

	WindowClass parent_cls;

   262

	uint32 flags;

   263

	const OldWidget *widgets;

   264

	WindowProc *proc;

   265

} WindowDesc;

   266

   267

enum WindowDefaultFlag {

   268

	WDF_STD_TOOLTIPS    =   1, /* use standard routine when displaying tooltips */

   269

	WDF_DEF_WIDGET      =   2, /* default widget control for some widgets in the on click event */

   270

	WDF_STD_BTN         =   4, /* default handling for close and drag widgets (widget no 0 and 1) */

   271

   272

	WDF_UNCLICK_BUTTONS =  16, /* Unclick buttons when the window event times out */

   273

	WDF_STICKY_BUTTON   =  32, /* Set window to sticky mode; they are not closed unless closed with 'X' (widget 2) */

   274

	WDF_RESIZABLE       =  64, /* A window can be resized */

   275

	WDF_MODAL           = 128, /* The window is a modal child of some other window, meaning the parent is 'inactive' */

   276

};

   277

   278

/* can be used as x or y coordinates to cause a specific placement */

   279

enum WindowDefaultPosition {

   280

	WDP_AUTO      = -1, ///< Find a place automatically

   281

	WDP_CENTER    = -2, ///< Center the window (left/right or top/bottom)

   282

	WDP_ALIGN_TBR = -3, ///< Align the right side of the window with the right side of the main toolbar

   283

	WDP_ALIGN_TBL = -4, ///< Align the left side of the window with the left side of the main toolbar

   284

};

   285

   286

typedef struct Textbuf {

   287

	char *buf;                  /* buffer in which text is saved */

   288

	uint16 maxlength, maxwidth; /* the maximum size of the buffer. Maxwidth specifies screensize in pixels, maxlength is in bytes */

   289

	uint16 length, width;       /* the current size of the string. Width specifies screensize in pixels, length is in bytes */

   290

	bool caret;                 /* is the caret ("_") visible or not */

   291

	uint16 caretpos;            /* the current position of the caret in the buffer, in bytes */

   292

	uint16 caretxoffs;          /* the current position of the caret in pixels */

   293

} Textbuf;

   294

   295

#define WP(ptr,str) (*(str*)(ptr)->custom)

   296

/* You cannot 100% reliably calculate the biggest custom struct as

   297

 * the number of pointers in it and alignment will have a huge impact.

   298

 * 96 is the largest window-size for 64-bit machines currently */

   299

#define WINDOW_CUSTOM_SIZE 96

   300

   301

typedef struct Scrollbar {

   302

	uint16 count, cap, pos;

   303

} Scrollbar;

   304

   305

typedef struct ResizeInfo {

   306

	uint width; /* Minimum width and height */

   307

	uint height;

   308

   309

	uint step_width; /* In how big steps the width and height go */

   310

	uint step_height;

   311

} ResizeInfo;

   312

   313

typedef struct WindowMessage {

   314

		int msg;

   315

		int wparam;

   316

		int lparam;

   317

} WindowMessage;

   318

   319

struct OldWidget {

   320

	WindowWidgetTypes type;           ///< OldWidget type, see @WindowWidgetTypes

   321

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

   322

	byte color;                       ///< OldWidget colour, see docs/ottd-colourtext-palette.png

   323

	int16 left, right, top, bottom;   ///< The position offsets inside the window

   324

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

   325

	StringID tooltips;                ///< Tooltips that are shown when rightclicking on a widget

   326

};

   327

   328

   329

struct Widget : public SimpleCountedObject {

   330

	//	byte type;                        ///< Widget type, see @WindowWidgetTypes

   331

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

   332

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

   333

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

   334

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

   335

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

   336

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

   337

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

   338

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

   339

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

   340

   346

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

   347

		: m_container(container)

   348

		, m_id(id)

   349

		, m_rect(rect)

   350

		, m_data(0)

   351

		, m_display_flags(display_flags)

   352

		, m_color(color)

   353

		, m_is_closing(false)

   354

		, m_dont_clip(false)

   355

		, m_tooltips(tooltips)

   356

	{}

   357

   358

	int16 Left() const;

   359

	int16 Top() const;

   360

	int16 Right() const;

   361

	int16 Bottom() const;

   362

	int16 Width() const;

   363

	int16 Height() const;

   364

	const Point16& TopLeft() const;

   365

	const Point16& BottomRight() const;

   366

	const Rect16& GetRect() const;

   367

   368

	void SetLeft(int16 val);

   369

	void SetTop(int16 val);

   370

	void SetRight(int16 val);

   371

	void SetBottom(int16 val);

   372

	void SetWidth(int16 val);

   373

	void SetHeight(int16 val);

   374

	void SetTopLeft(const Point16 &pt);

   375

	void SetBottomRight(const Point16 &pt);

   376

	void SetRect(const Rect16 &rect);

   377

   378

	WidgetId GetId() const;

   379

   380

	virtual Widget* WidgetFromPt(const Point16 &pt);

   381

   382

	virtual void Close();

   383

	virtual bool OnLeftClick(WindowEvent *ev) = 0;

   384

};

   385

   386

struct CompositeWidget : public Widget {

   387

	typedef Widget super;

   388

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

   389

	typedef Widgets::iterator WidgetIterator;

   390

	typedef Widgets::reverse_iterator WidgetReverseIterator;

   391

   392

protected:

   393

	Widgets m_widgets;

   394

   395

public:

   400

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

   401

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

   402

	{}

   403

   404

	void AddWidget(Widget *wd);

   405

	Widget* GetWidget(WidgetId id);

   406

	Widget* RemoveWidget(WidgetId id);

   407

   408

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

   409

   410

	virtual void Close();

   413

};

   414

   415

   416

struct BaseWindow;

   417

typedef CCountedPtr<BaseWindow> WindowPtr;

   418

   419

struct WindowList {

   420

	struct Item {

   421

		WindowPtr w;

   422

		Item(BaseWindow *v = NULL) : w(v) {}

   423

		Item(const Item &src) : w(src.w) {}

   424

		~Item()

   425

		{}

   426

	};

   427

	typedef std::list<Item> List;

   428

	typedef List::iterator Iterator;

   429

	typedef List::reverse_iterator ReverseIterator;

   430

   431

	List m_list;

   432

   433

	void Add(BaseWindow *w);

   434

	void Remove(BaseWindow *w);

   435

	Iterator Find(BaseWindow *w);

   436

	Iterator FindFirstVitalWindow();

   437

	Iterator FindByClass(WindowClass cls);

   438

	Iterator FindById(WindowClass cls, WindowNumber num);

   439

	Iterator FindFromPt(int x, int y);

   440

   441

	Iterator EnumT(bool (*enum_proc)(Iterator))

   442

	{

   443

		for (Iterator it = m_list.begin(); it != m_list.end(); ++it) {

   444

			if (enum_proc(it)) return it;

   445

		}

   446

		return m_list.end();

   447

	}

   448

   449

	template <class Tmatch_1> Iterator EnumT(bool (*enum_proc)(Iterator, Tmatch_1), Tmatch_1 match)

   450

	{

   451

		for (Iterator it = m_list.begin(); it != m_list.end(); ++it) {

   452

			if (enum_proc(it, match)) return it;

   453

		}

   454

		return m_list.end();

   455

	}

   456

   457

	template <class Tmatch_1, class Tmatch_2> Iterator EnumT(bool (*enum_proc)(Iterator, Tmatch_1, Tmatch_2), Tmatch_1 match_1, Tmatch_2 match_2)

   458

	{

   459

		for (Iterator it = m_list.begin(); it != m_list.end(); ++it) {

   460

			if (enum_proc(it, match_1, match_2)) return it;

   461

		}

   462

		return m_list.end();

   463

	}

   464

   465

	Iterator ReverseEnumT(bool (*enum_proc)(Iterator))

   466

	{

   467

		for (Iterator it = m_list.end(); it != m_list.begin(); ) {

   468

			--it;

   469

			if (enum_proc(it)) return it;

   470

		}

   471

		return m_list.end();

   472

	}

   473

   474

	template <class Tmatch_1> Iterator ReverseEnumT(bool (*enum_proc)(Iterator, Tmatch_1), Tmatch_1 match)

   475

	{

   476

		for (Iterator it = m_list.end(); it != m_list.begin(); ) {

   477

			--it;

   478

			if (enum_proc(it, match)) return it;

   479

		}

   480

		return m_list.end();

   481

	}

   482

   483

	template <class Tmatch_1, class Tmatch_2> Iterator ReverseEnumT(bool (*enum_proc)(Iterator, Tmatch_1, Tmatch_2), Tmatch_1 match_1, Tmatch_2 match_2)

   484

	{

   485

		for (Iterator it = m_list.end(); it != m_list.begin(); ) {

   486

			--it;

   487

			if (enum_proc(it, match_1, match_2)) return it;

   488

		}

   489

		return m_list.end();

   490

	}