1

/* $Id$ */

     2

     3

#ifndef WINDOW_H

     4

#define WINDOW_H

     5

     6

#include <list>

     7

#include "macros.h"

     8

#include "string.h"

     9

#include "order.h"

    10

#include "rail.h"

    11

#include "airport.h"

    12

#include "misc/countedptr.hpp"

    13

    14

typedef struct WindowEvent WindowEvent;

    15

    16

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

    17

    18

/* How the resize system works:

    19

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

    20

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

    21

     to resize itself.

    22

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

    23

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

    24

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

    25

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

    26

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

    27

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

    28

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

    29

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

    30

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

    31

     widgets moves downwards without resizing, and appears to be clamped

    32

     to the bottom. Nice aint it?

    33

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

    34

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

    35

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

    36

    after making the window, like this:

    37

      w->resize.step_height = 10;

    38

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

    39

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

    40

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

    41

    AFTER window-creation, with:

    42

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

    43

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

    44

    45

typedef enum ResizeFlags {

    46

	RESIZE_NONE   = 0,

    47

    48

	RESIZE_LEFT   = 1,

    49

	RESIZE_RIGHT  = 2,

    50

	RESIZE_TOP    = 4,

    51

	RESIZE_BOTTOM = 8,

    52

    53

	RESIZE_LR     = RESIZE_LEFT  | RESIZE_RIGHT,

    54

	RESIZE_RB     = RESIZE_RIGHT | RESIZE_BOTTOM,

    55

	RESIZE_TB     = RESIZE_TOP   | RESIZE_BOTTOM,

    56

	RESIZE_LRB    = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_BOTTOM,

    57

	RESIZE_LRTB   = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_TOP | RESIZE_BOTTOM,

    58

	RESIZE_RTB    = RESIZE_RIGHT | RESIZE_TOP    | RESIZE_BOTTOM,

    59

    60

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

    61

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

    62

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

    63

	 * Enabled, visible or unclicked widgets*/

    64

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

    65

	WIDG_HIDDEN   = 5,  // widget is made invisible

    66

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

    67

} ResizeFlag;

    68

    69

enum WindowFlags {

    70

	//WF_TIMEOUT_SHL       = 0,

    71

	//WF_TIMEOUT_MASK      = 7,

    72

	WF_DRAGGING          = 1 <<  3,

    73

	WF_SCROLL_UP         = 1 <<  4,

    74

	WF_SCROLL_DOWN       = 1 <<  5,

    75

	WF_SCROLL_MIDDLE     = 1 <<  6,

    76

	WF_HSCROLL           = 1 <<  7,

    77

	WF_SIZING            = 1 <<  8,

    78

	WF_STICKY            = 1 <<  9,

    79

    80

	WF_DISABLE_VP_SCROLL = 1 << 10,

    81

    82

	//WF_WHITE_BORDER_ONE  = 1 << 11,

    83

	//WF_WHITE_BORDER_MASK = 1 << 12 | WF_WHITE_BORDER_ONE,

    84

	WF_SCROLL2           = 1 << 13,

    85

};

    86

    87

DECLARE_ENUM_AS_BIT_SET(WindowFlags);

    88

    89

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

    90

enum {

    91

	WIDGET_LIST_END = -1,

    92

};

    93

    94

typedef struct Widget {

    95

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

    96

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

    97

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

    98

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

    99

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

   100

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

   101

} Widget;

   102

   103

typedef enum FrameFlags {

   104

	FR_NONE         = 0x00,

   105

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

   106

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

   107

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

   108

	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)

   109

} FrameFlags;

   110

   111

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

   112

   113

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

   114

   115

enum WindowEventCodes {

   116

	WE_CREATE,

   117

	WE_DESTROY,

   118

	WE_PAINT,

   119

	WE_KEYPRESS,

   120

	WE_CLICK,

   121

	WE_RCLICK,

   122

	WE_MOUSEOVER,

   123

	WE_MOUSELOOP,

   124

	WE_MOUSEWHEEL,

   125

	WE_TICK,

   126

	WE_4,

   127

	WE_TIMEOUT,

   128

	WE_PLACE_OBJ,

   129

	WE_ABORT_PLACE_OBJ,

   130

	WE_ON_EDIT_TEXT,

   131

	WE_ON_EDIT_TEXT_CANCEL,

   132

	WE_POPUPMENU_SELECT,

   133

	WE_POPUPMENU_OVER,

   134

	WE_DRAGDROP,

   135

	WE_PLACE_DRAG,

   136

	WE_PLACE_MOUSEUP,

   137

	WE_PLACE_PRESIZE,

   138

	WE_DROPDOWN_SELECT,

   139

	WE_RESIZE,

   140

	WE_MESSAGE,

   141

	WE_SCROLL,

   142

	WE_INVALIDATE_DATA,

   143

};

   144

   145

struct WindowEvent {

   146

	byte event;

   147

	union {

   148

		struct{

   149

			Point pt;

   150

			int widget;

   151

		} click;

   152

   153

		struct {

   154

			Point pt;

   155

			TileIndex tile;

   156

			TileIndex starttile;

   157

			int userdata;

   158

		} place;

   159

   160

		struct {

   161

			Point pt;

   162

			int widget;

   163

		} dragdrop;

   164

   165

		struct {

   166

			Point size;

   167

			Point diff;

   168

		} sizing;

   169

   170

		struct {

   171

			char *str;

   172

		} edittext;

   173

   174

		struct {

   175

			Point pt;

   176

		} popupmenu;

   177

   178

		struct {

   179

			int button;

   180

			int index;

   181

		} dropdown;

   182

   183

		struct {

   184

			Point pt;

   185

			int widget;

   186

		} mouseover;

   187

   188

		struct {

   189

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

   190

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

   191

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

   192

		} keypress;

   193

   194

		struct {

   195

			int msg;      // message to be sent

   196

			int wparam;   // additional message-specific information

   197

			int lparam;   // additional message-specific information

   198

		} message;

   199

   200

		struct {

   201

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

   202

		} scroll;

   203

   204

		struct {

   205

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

   206

		} wheel;

   207

	} we;

   208

};

   209

   210

typedef struct WindowDesc {

   211

	int16 left, top, width, height;

   212

	WindowClass cls;

   213

	WindowClass parent_cls;

   214

	uint32 flags;

   215

	const Widget *widgets;

   216

	WindowProc *proc;

   217

} WindowDesc;

   218

   219

enum WindowDefaultFlag {

   220

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

   221

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

   222

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

   223

   224

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

   225

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

   226

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

   227

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

   228

};

   229

   230

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

   231

enum WindowDefaultPosition {

   232

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

   233

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

   234

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

   235

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

   236

};

   237

   238

typedef struct Textbuf {

   239

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

   240

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

   241

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

   242

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

   243

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

   244

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

   245

} Textbuf;

   246

   247

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

   248

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

   249

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

   250

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

   251

#define WINDOW_CUSTOM_SIZE 96

   252

   253

typedef struct Scrollbar {

   254

	uint16 count, cap, pos;

   255

} Scrollbar;

   256

   257

typedef struct ResizeInfo {

   258

	uint width; /* Minimum width and height */

   259

	uint height;

   260

   261

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

   262

	uint step_height;

   263

} ResizeInfo;

   264

   265

typedef struct WindowMessage {

   266

		int msg;

   267

		int wparam;

   268

		int lparam;

   269

} WindowMessage;

   270

   271

struct CountedObject {

   272

	int32 m_ref_cnt;

   273

   274

	CountedObject()

   275

		: m_ref_cnt(0)

   276

	{}

   277

   278

	virtual ~CountedObject()

   279

	{};

   280

   281

	virtual int32 AddRef();

   282

	virtual int32 Release();

   283

	virtual void FinalRelease() {};

   284

};

   285

   286

struct Window;

   287

typedef CCountedPtr<Window> WindowPtr;

   288

   289

struct WindowList {

   290

	struct Item {

   291

		WindowPtr w;

   292

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

   293

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

   294

		~Item()

   295

		{}

   296

	};

   297

	typedef std::list<Item> List;

   298

	typedef List::iterator Iterator;

   299

	typedef List::reverse_iterator ReverseIterator;

   300

   301

	List m_list;

   302

   303

	void Add(Window *w);

   304

	void Remove(Window *w);

   305

	Iterator Find(Window *w);

   306

	Iterator FindFirstVitalWindow();

   307

	Iterator FindByClass(WindowClass cls);

   308

	Iterator FindById(WindowClass cls, WindowNumber num);

   309

   310

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

   311

	{

   312

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

   313

			if (enum_proc(it)) return it;

   314

		}

   315

		return m_list.end();

   316

	}

   317

   318

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

   319

	{

   320

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

   321

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

   322

		}

   323

		return m_list.end();

   324

	}

   325

   326

	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)

   327

	{

   328

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

   329

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

   330

		}

   331

		return m_list.end();

   332

	}

   333

   334

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

   335

	{

   336

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

   337

			--it;

   338

			if (enum_proc(it)) return it;

   339

		}

   340

		return m_list.end();

   341

	}

   342

   343

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

   344

	{

   345

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

   346

			--it;

   347

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

   348

		}

   349

		return m_list.end();

   350

	}

   351

};

   352

   354

public:

   355

	static WindowList s_list;

   356

   357

	WindowFlags flags4;

   358

	WindowClass window_class;

   359

	WindowNumber window_number;

   360

   361

	int left, top;

   362

	int width, height;

   363

   364

	Scrollbar hscroll, vscroll, vscroll2;

   365

	ResizeInfo resize;

   366

   367

	byte caption_color;

   368

	byte autorepeat_timeout; ///< timer for scroll (spin) click autorepeat

   369

	byte flash_timeout;      ///< timer for flashing white border

   370

   371

	WindowProc *wndproc;

   372

	ViewPort *viewport;

   373

	const Widget *original_widget;

   374

	Widget *widget;

   375

	uint widget_count;

   376

	uint32 desc_flags;

   377

   378

	WindowMessage message;

   379

	Window *parent;

   380

	byte custom[WINDOW_CUSTOM_SIZE];

   381

   382

	Window(int x, int y, int w, int h, WindowProc *proc, WindowClass cls, const Widget *widget, int wnd_number);

   383

   384

	void ZeroInit()

   385

	{

   386

		memset(&flags4, 0, sizeof(*this) - cpp_offsetof(Window, flags4));

   387

	}

   388

   389

	Window* FindChild() const;

   390

	void SetDirty() const;

   391

	void CDECL SetWidgetsDisabledState(bool disab_stat, int widgets, ...);

   392

	void CDECL SetWidgetsHiddenState(bool hidden_stat, int widgets, ...);

   393

	void CDECL SetWidgetsLoweredState(bool lowered_stat, int widgets, ...);

   394

	void RaiseButtons();

   395

	void HandleButtonClick(byte widget);

   396

	void BringToFront();

   397

	static Window* BringToFrontById(WindowClass cls, WindowNumber number);

   398

	void StartDrag();

   399

	bool ContinueDrag();

   400

	void StartSizing();

   401

	bool ContinueSizing();

   402

	static bool HandleWindowDragging(void);

   403

	void DispatchLeftClickEvent(int x, int y);

   404

	void DispatchRightClickEvent(int x, int y);

   405

	void DispatchMouseWheelEvent(int widget, int wheel);

   406

   407

	/*virtual*/ void FinalRelease();

   408

	virtual void Close();

   409

	virtual bool IsVital();

   410

   411

	static Window* Allocate(int x, int y, int width, int height, WindowProc *proc, WindowClass cls, const Widget *widget);

   412

	static Window* Get(WindowList::Iterator it);

   413

	static Window* FindById(WindowClass cls, WindowNumber num);

   414

	static void SetDirtyById(WindowClass cls, WindowNumber num);

   415

   416

	bool IsOfPrototype(const Widget *widgets) const;

   417

	int GetMenuItemIndex(int x, int y) const;

   418

	void Resize(int x, int y);

   419

   420

	void CallEventNP(int event);

   421

   422

	void AssignWidget(const Widget *widget);

   423

   424

	void InvalidateData();

   425

	void InvalidateWidget(byte widget_index) const;

   426

   427

	/* viewport.cpp */

   428

	void DrawViewport() const;

   429

   430

	/* widget.cpp */

   431

	int GetWidgetFromPos(int x, int y) const;

   432

	void DrawWidgets() const;

   433

	void ShowDropDownMenu(const StringID *strings, int selected, int button, uint32 disabled_mask, uint32 hidden_mask);

   434

	void ResizeButtons(byte left, byte right);

   435

   436

private:

   437

	void ScrollbarClickHandler(const Widget *wi, int x, int y);

   438

public:

   439

   442

	//int32 AddRef()

   443

	//{

   444

	//	const char *name = NULL;

   445

	//	switch (window_class)

   446

	//	{

   447

	//		case WC_MAIN_WINDOW:      name = "mw"; break;

   448

	//		case WC_SELECT_GAME:      name = "sg"; break;

   449

	//		case WC_INDUSTRY_VIEW:    name = "iw"; break;

   450

	//		default: break;

   451

	//	}

   452

	//	if (name != NULL) printf("%s+\n", name);

   453

	//	return CountedObject::AddRef();

   454

	//}

   455

   456

	//int32 Release()

   457

	//{

   458

	//	const char *name = NULL;

   459

	//	switch (window_class)

   460

	//	{

   461

	//		case WC_MAIN_WINDOW:      name = "mw"; break;

   462

	//		case WC_SELECT_GAME:      name = "sg"; break;

   463

	//		case WC_INDUSTRY_VIEW:    name = "iw"; break;

   464

	//		default: break;

   465

	//	}

   466

	//	if (name != NULL) printf("%s-\n", name);

   467

	//	return CountedObject::Release();

   468

	//}

   469

   470

	template <class Tmatch> struct EnumMatch {

   471

		Tmatch &m_match;

   472

		EnumMatch(Tmatch &m)

   473

			: m_match(m)

   474

		{}

   475

		bool EnumProc(WindowList::Iterator it)

   476

		{

   477

			return m_match->EnumProc((*it).w);

   478

		}

   479

	};

   480

   481

	//template <class Tmatch> Window* EnumT(Tmatch m)

   482

	//{

   483

	//	WindowList::Iterator it = Window::s_list.EnumT(EnumMatch<Tmatch>(m));

   484

	//	return (it == Window::s_list.m_list.end()) ? NULL : (*it).w;

   485

	//}

   486

   487

	//template <class Tmatch> Window* ReverseEnumT(Tmatch m)

   488

	//{

   489

	//	WindowList::Iterator it = Window::s_list.ReverseEnumT(EnumMatch<Tmatch>(m));

   490

	//	return (it == Window::s_list.m_list.end()) ? NULL : (*it).w;

   491

	//}