1

/* $Id$ */

     2

     3

/** @file window.h regroups declarations for all windowing system, as well as a few helper functions */

     4

     5

#ifndef WINDOW_H

     6

#define WINDOW_H

     7

     8

#include "widget/widget.h"

     9

    10

struct WindowEvent;

    11

    12

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

    13

    14

/* How the resize system works:

    15

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

    16

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

    17

     to resize itself.

    18

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

    19

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

    20

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

    21

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

    22

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

    23

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

    24

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

    25

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

    26

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

    27

     widgets moves downwards without resizing, and appears to be clamped

    28

     to the bottom. Nice aint it?

    29

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

    30

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

    31

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

    32

    after making the window, like this:

    33

      w->resize.step_height = 10;

    34

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

    35

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

    36

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

    37

    AFTER window-creation, with:

    38

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

    39

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

    40

    41

enum ResizeFlag {

    43

    48

    55

    56

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

    57

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

    58

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

    59

	 * Enabled, visible or unclicked widgets*/

    60

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

    61

	WIDG_HIDDEN   = 5,  ///< widget is made invisible

    62

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

    63

};

    64

    65

DECLARE_ENUM_AS_BIT_SET(ResizeFlag);

    66

    67

enum WindowFlags {

    68

	//WF_TIMEOUT_SHL       = 0,

    69

	//WF_TIMEOUT_MASK      = 7,

    70

	WF_DRAGGING          = 1 <<  3,

    71

	WF_SCROLL_UP         = 1 <<  4,

    72

	WF_SCROLL_DOWN       = 1 <<  5,

    73

	WF_SCROLL_MIDDLE     = 1 <<  6,

    74

	WF_HSCROLL           = 1 <<  7,

    75

	WF_SIZING            = 1 <<  8,

    76

	WF_STICKY            = 1 <<  9,

    77

    78

	WF_DISABLE_VP_SCROLL = 1 << 10,

    79

    80

	//WF_WHITE_BORDER_ONE  = 1 << 11,

    81

	//WF_WHITE_BORDER_MASK = 1 << 12 | WF_WHITE_BORDER_ONE,

    82

	WF_SCROLL2           = 1 << 13,

    83

};

    84

    85

DECLARE_ENUM_AS_BIT_SET(WindowFlags);

    86

    87

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

    88

enum {

    90

};

    91

    92

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

    93

enum WindowWidgetBehaviours {

    94

	WWB_PUSHBUTTON  = 1 << 5,

    95

	WWB_MASK        = 0xE0,

    96

};

    97

    98

    99

enum WindowWidgetTypes {

   100

	WWT_EMPTY,

   101

   102

	WWT_PANEL,      /* simple depressed panel */

   103

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

   104

	WWT_IMGBTN,     /* button with image */

   105

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

   106

   107

	WWT_TEXTBTN,    /* button with text */

   108

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

   109

	WWT_LABEL,      /* centered label */

   110

	WWT_MATRIX,

   111

	WWT_SCROLLBAR,

   112

	WWT_FRAME,      /* frame */

   113

	WWT_CAPTION,

   114

   115

	WWT_HSCROLLBAR,

   116

	WWT_STICKYBOX,

   117

	WWT_SCROLL2BAR, /* 2nd vertical scrollbar*/

   118

	WWT_RESIZEBOX,

   119

	WWT_CLOSEBOX,

   120

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

   121

   122

	WWT_MASK = 0x1F,

   123

   124

	WWT_PUSHBTN     = WWT_PANEL   | WWB_PUSHBUTTON,

   125

	WWT_PUSHTXTBTN  = WWT_TEXTBTN | WWB_PUSHBUTTON,

   126

	WWT_PUSHIMGBTN  = WWT_IMGBTN  | WWB_PUSHBUTTON,

   127

};

   128

   129

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

   130

   131

   132

   133

   134

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

   135

   136

enum WindowEventCodes {

   137

	WE_CREATE,

   138

	WE_DESTROY,

   139

	WE_PAINT,

   140

	WE_KEYPRESS,

   141

	WE_CLICK,

   142

	WE_RCLICK,

   143

	WE_MOUSEOVER,

   144

	WE_MOUSELOOP,

   145

	WE_MOUSEWHEEL,

   146

	WE_TICK,

   147

	WE_4,

   148

	WE_TIMEOUT,

   149

	WE_PLACE_OBJ,

   150

	WE_ABORT_PLACE_OBJ,

   151

	WE_ON_EDIT_TEXT,

   152

	WE_ON_EDIT_TEXT_CANCEL,

   153

	WE_POPUPMENU_SELECT,

   154

	WE_POPUPMENU_OVER,

   155

	WE_DRAGDROP,

   156

	WE_PLACE_DRAG,

   157

	WE_PLACE_MOUSEUP,

   158

	WE_PLACE_PRESIZE,

   159

	WE_DROPDOWN_SELECT,

   160

	WE_RESIZE,

   161

	WE_MESSAGE,

   162

	WE_SCROLL,

   163

	WE_INVALIDATE_DATA,

   164

};

   165

   166

struct WindowEvent {

   167

	byte event;

   168

	union {

   169

		struct{

   170

			PointRaw pt;

   171

			int widget;

   172

		} click;

   173

   174

		struct {

   175

			PointRaw pt;

   176

			TileIndex tile;

   177

			TileIndex starttile;

   178

			int userdata;

   179

		} place;

   180

   181

		struct {

   182

			PointRaw pt;

   183

			int widget;

   184

		} dragdrop;

   185

   186

		struct {

   187

			PointRaw size;

   188

			PointRaw diff;

   189

		} sizing;

   190

   191

		struct {

   192

			char *str;

   193

		} edittext;

   194

   195

		struct {

   196

			PointRaw pt;

   197

		} popupmenu;

   198

   199

		struct {

   200

			int button;

   201

			int index;

   202

		} dropdown;

   203

   204

		struct {

   205

			PointRaw pt;

   206

			int widget;

   207

		} mouseover;

   208

   209

		struct {

   210

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

   211

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

   212

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

   213

		} keypress;

   214

   215

		struct {

   216

			int msg;      ///< message to be sent

   217

			int wparam;   ///< additional message-specific information

   218

			int lparam;   ///< additional message-specific information

   219

		} message;

   220

   221

		struct {

   222

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

   223

		} scroll;

   224

   225

		struct {

   226

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

   227

		} wheel;

   228

	} we;

   229

};

   230

   231

struct OldWidget;

   232

   233

typedef struct WindowDesc {

   234

	int16 left, top, width, height;

   235

	WindowClass cls;

   236

	WindowClass parent_cls;

   237

	uint32 flags;

   238

	const OldWidget *widgets;

   239

	WindowProc *proc;

   240

} WindowDesc;

   241

   242

enum WindowDefaultFlag {

   243

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

   244

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

   245

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

   246

   247

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

   248

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

   249

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

   250

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

   251

};

   252

   253

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

   254

enum WindowDefaultPosition {

   255

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

   256

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

   257

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

   258

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

   259

};

   260

   261

typedef struct Textbuf {

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

} Textbuf;

   269

   270

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

   271

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

   272

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

   273

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

   274

#define WINDOW_CUSTOM_SIZE 96

   275

   276

typedef struct Scrollbar {

   277

	uint16 count, cap, pos;

   278

} Scrollbar;

   279

   280

typedef struct ResizeInfo {

   281

	uint width; ///< Minimum width and height

   282

	uint height;

   283

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

   284

	uint step_height;

   285

} ResizeInfo;

   286

   287

typedef struct WindowMessage {

   288

		int msg;

   289

		int wparam;

   290

		int lparam;

   291

} WindowMessage;

   292

   293

struct OldWidget {

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

};

   301

   302

   303

   304

struct BaseWindow;

   305

typedef CCountedPtr<BaseWindow> WindowPtr;

   306

   307

struct WindowList {

   308

	struct Item {

   309

		WindowPtr w;

   310

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

   311

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

   312

		~Item()

   313

		{}

   314

	};

   315

	typedef std::list<Item> List;

   316

	typedef List::iterator Iterator;

   317

	typedef List::reverse_iterator ReverseIterator;

   318

   319

	List m_list;

   320

   321

	void Add(BaseWindow *w);

   322

	void Remove(BaseWindow *w);

   323

	void CloseAll();

   324

	Iterator Find(BaseWindow *w);

   325

	Iterator FindFirstVitalWindow();

   326

	Iterator FindByClass(WindowClass cls);

   327

	Iterator FindById(WindowClass cls, WindowNumber num);

   328

	Iterator FindFromPt(int x, int y);

   329

   330

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

   331

	{

   332

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

   333

			if (enum_proc(it)) return it;

   334

		}

   335

		return m_list.end();

   336

	}

   337

   338

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

   339

	{

   340

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

   341

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

   342

		}

   343

		return m_list.end();

   344

	}

   345

   346

	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)

   347

	{

   348

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

   349

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

   350

		}

   351

		return m_list.end();

   352

	}

   353

   354

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

   355

	{

   356

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

   357

			--it;

   358

			if (enum_proc(it)) return it;

   359

		}

   360

		return m_list.end();

   361

	}

   362

   363

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

   364

	{

   365

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

   366

			--it;

   367

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

   368

		}

   369

		return m_list.end();

   370

	}

   371

   372

	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)

   373

	{

   374

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

   375

			--it;

   376

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

   377

		}

   378

		return m_list.end();

   379

	}

   380

   381

};

   382

   383

struct BaseWindow : public gui::CompositeWidget {

   384

public:

   385

	typedef gui::CompositeWidget super;

   386

   387

	static WindowList s_list;

   388

   389

	ZeroInitBegin m_zero_init_area; ///< following members get cleared by constructor

   390

   391

	WindowFlags flags4;

   392

	WindowClass window_class;

   393

	WindowNumber window_number;

   394

   395

protected:

   396

	Point16    m_wnd_pos;

   397

   398

public:

   399

	StringID   m_caption_text;

   400

   401

	Scrollbar hscroll, vscroll, vscroll2;

   402

	ResizeInfo resize;

   403

   404

	byte caption_color;

   405

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

   406

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

   407

   408

	WindowProc *wndproc;

   409

	ViewPort *viewport;

   410

	const OldWidget *original_widget;

   411

	OldWidget *widget;

   412

	uint widget_count;

   413

	uint32 desc_flags;

   414

   415

	WindowMessage message;

   416

	BaseWindow *parent;

   417

	byte custom[WINDOW_CUSTOM_SIZE];

   418

   419

	ZeroInitEnd m_zero_init_end; ///< end of zero initialization area

   420

   421

protected:

   422

	BaseWindow(WindowClass cls, StringID caption_text = 0, byte color = COLOUR_GREY, gui::FeatureFlags feature_flags = gui::FF_NONE)

   423

		: CompositeWidget(NULL, 0, feature_flags, color, Rect16(), 0)

   424

		, m_zero_init_area(m_zero_init_end)

   425

		, window_class(cls)

   426

		, m_caption_text(caption_text)

   427

	{}

   428

   429

public:

   430

	BaseWindow(const WindowDesc *desc, WindowNumber num = 0)

   431

		: m_zero_init_area(m_zero_init_end)

   432

	{

   433

		Create(desc, num);

   434

	}

   435

   436

	int16 Left() const;

   437

	int16 Top() const;

   438

	int16 Right() const;

   439

	int16 Bottom() const;

   440

	const Point16& TopLeft() const;

   441

	Point16 BottomRight() const;

   442

	Rect16 GetRect() const;

   443

   444

	void SetLeft(int16 val);

   445

	void SetTop(int16 val);

   446

	void SetRight(int16 val);

   447

	void SetBottom(int16 val);

   448

	void SetTopLeft(const Point16 &pt);

   449

	void SetBottomRight(const Point16 &pt);

   450

	void SetSize(const Point16 &pt);

   451

	void SetRect(const Rect16 &rect);

   452

   453

	virtual bool Create(WindowNumber num);

   454

	virtual bool Create(const WindowDesc *desc, WindowNumber num = 0);

   455

   456

	/*virtual*/ void CreateNcWidgets();

   457

	/*virtual*/ void CreateWidgets(); ///< @TODO remove it when old gui infrastructure will no longer be used

   458

   459

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

   460

	static BaseWindow* Allocate(const WindowDesc *desc, int window_number = 0);

   461

	static BaseWindow* AllocateFront(const WindowDesc *desc, int window_number = 0);

   462

   463

	/*virtual*/ BaseWindow* GetWindow();

   464

	BaseWindow* FindChild() const;

   465

	void SetDirty() const;

   466

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

   467

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

   468

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

   469

	void RaiseButtons();

   470

	void HandleButtonClick(byte widget);

   471

	void BringToFront();

   472

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

   473

	void StartDrag();

   474

	bool ContinueDrag();

   475

	void StartSizing();

   476

	bool ContinueSizing();

   477

	static bool HandleWindowDragging(void);

   478

	void DispatchLeftClickEvent(int x, int y);

   479

	void DispatchRightClickEvent(int x, int y);

   480

	void DispatchMouseWheelEvent(int widget, int wheel);

   481

   482

	/*virtual*/ void FinalRelease();

   483

	virtual void Close();

   484

	virtual bool IsVital();

   485

   486

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

   487

	static BaseWindow* FindFromPt(int x, int y);

   488

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