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 "macros.h"

     9

#include "string.h"

    10

#include "order.h"

    11

#include "rail.h"

    12

#include "road.h"

    13

#include "airport.h"

    14

#include "vehicle.h"

    15

#include "viewport.h"

    16

    17

struct WindowEvent;

    18

    19

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

    20

    21

/* How the resize system works:

    22

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

    23

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

    24

     to resize itself.

    25

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

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

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

    34

     widgets moves downwards without resizing, and appears to be clamped

    35

     to the bottom. Nice aint it?

    36

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

    37

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

    38

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

    39

    after making the window, like this:

    40

      w->resize.step_height = 10;

    41

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

    42

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

    43

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

    44

    AFTER window-creation, with:

    45

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

    46

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

    47

    48

enum ResizeFlag {

    49

	RESIZE_NONE   = 0,  ///< no resize required

    50

    51

	RESIZE_LEFT   = 1,  ///< left resize flag

    52

	RESIZE_RIGHT  = 2,  ///< rigth resize flag

    53

	RESIZE_TOP    = 4,  ///< top resize flag

    54

	RESIZE_BOTTOM = 8,  ///< bottom resize flag

    55

    56

	RESIZE_LR     = RESIZE_LEFT  | RESIZE_RIGHT,   ///<  combination of left and right resize flags

    57

	RESIZE_RB     = RESIZE_RIGHT | RESIZE_BOTTOM,  ///<  combination of right and bottom resize flags

    58

	RESIZE_TB     = RESIZE_TOP   | RESIZE_BOTTOM,  ///<  combination of top and bottom resize flags

    59

	RESIZE_LRB    = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_BOTTOM, ///< combination of left, right and bottom resize flags

    60

	RESIZE_LRTB   = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_TOP | RESIZE_BOTTOM,  ///<  combination of all resize flags

    61

	RESIZE_RTB    = RESIZE_RIGHT | RESIZE_TOP    | RESIZE_BOTTOM, ///<  combination of right, top and bottom resize flag

    62

    63

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

    64

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

    65

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

    66

	 * Enabled, visible or unclicked widgets*/

    67

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

    68

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

    69

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

    70

};

    71

    72

enum {

    73

	WIDGET_LIST_END = -1, ///< indicate the end of widgets' list for vararg functions

    74

};

    75

    76

struct Widget {

    77

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

    78

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

    79

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

    80

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

    81

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

    82

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

    83

};

    84

    85

enum FrameFlags {

    86

	FR_NONE         =  0,

    87

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

    88

	FR_BORDERONLY   =  1 << 4,  ///< Draw border only, no background

    89

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

    90

	FR_DARKENED     =  1 << 6,  ///< If set the background is darker, allows for lowered frames with normal background color when used with FR_LOWERED (ie. dropdown boxes)

    91

};

    92

    93

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

    94

    95

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

    96

    97

enum WindowEventCodes {

    98

	WE_CREATE,

    99

	WE_DESTROY,

   100

	WE_PAINT,

   101

	WE_KEYPRESS,

   102

	WE_CLICK,

   103

	WE_DOUBLE_CLICK,

   104

	WE_RCLICK,

   105

	WE_MOUSEOVER,

   106

	WE_MOUSELOOP,

   107

	WE_MOUSEWHEEL,

   108

	WE_TICK,

   109

	WE_4,

   110

	WE_TIMEOUT,

   111

	WE_PLACE_OBJ,

   112

	WE_ABORT_PLACE_OBJ,

   113

	WE_ON_EDIT_TEXT,

   114

	WE_ON_EDIT_TEXT_CANCEL,

   115

	WE_POPUPMENU_SELECT,

   116

	WE_POPUPMENU_OVER,

   117

	WE_DRAGDROP,

   118

	WE_PLACE_DRAG,

   119

	WE_PLACE_MOUSEUP,

   120

	WE_PLACE_PRESIZE,

   121

	WE_DROPDOWN_SELECT,

   122

	WE_RESIZE,

   123

	WE_MESSAGE,

   124

	WE_SCROLL,

   125

	WE_INVALIDATE_DATA,

   126

};

   127

   128

struct WindowEvent {

   129

	byte event;

   130

	union {

   131

		struct {

   132

			void *data;

   133

		} create;

   134

   135

		struct {

   136

			Point pt;

   137

			int widget;

   138

		} click;

   139

   140

		struct {

   141

			Point pt;

   142

			TileIndex tile;

   143

			TileIndex starttile;

   144

			ViewportPlaceMethod select_method;

   145

			byte select_proc;

   146

		} place;

   147

   148

		struct {

   149

			Point pt;

   150

			int widget;

   151

		} dragdrop;

   152

   153

		struct {

   154

			Point size;

   155

			Point diff;

   156

		} sizing;

   157

   158

		struct {

   159

			char *str;

   160

		} edittext;

   161

   162

		struct {

   163

			Point pt;

   164

		} popupmenu;

   165

   166

		struct {

   167

			int button;

   168

			int index;

   169

		} dropdown;

   170

   171

		struct {

   172

			Point pt;

   173

			int widget;

   174

		} mouseover;

   175

   176

		struct {

   177

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

   178

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

   179

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

   180

		} keypress;

   181

   182

		struct {

   183

			int msg;      ///< message to be sent

   184

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

   185

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

   186

		} message;

   187

   188

		struct {

   189

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

   190

		} scroll;

   191

   192

		struct {

   193

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

   194

		} wheel;

   195

	} we;

   196

};

   197

   198

struct WindowDesc {

   199

	int16 left, top, minimum_width, minimum_height, default_width, default_height;

   200

	WindowClass cls;

   201

	WindowClass parent_cls;

   202

	uint32 flags;

   203

	const Widget *widgets;

   204

	WindowProc *proc;

   205

};

   206

   207

enum WindowDefaultFlag {

   208

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

   209

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

   210

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

   211

   212

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

   213

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

   214

	WDF_RESIZABLE       =   1 << 6, ///< A window can be resized

   215

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

   216

};

   217

   218

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

   219

enum WindowDefaultPosition {

   220

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

   221

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

   222

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

   223

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

   224

};

   225

   226

struct Textbuf {

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

};

   234

   235

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

   236

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

   237

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

   238

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

   239

#define WINDOW_CUSTOM_SIZE 96

   240

   241

struct Scrollbar {

   242

	uint16 count, cap, pos;

   243

};

   244

   245

struct ResizeInfo {

   246

	uint width; ///< Minimum width and height

   247

	uint height;

   248

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

   249

	uint step_height;

   250

};

   251

   252

struct WindowMessage {

   253

	int msg;

   254

	int wparam;

   255

	int lparam;

   256

};

   257

   258

struct Window {

   259

	uint16 flags4;

   260

	WindowClass window_class;

   261

	WindowNumber window_number;

   262

   263

	int left, top;

   264

	int width, height;

   265

   266

	Scrollbar hscroll, vscroll, vscroll2;

   267

	ResizeInfo resize;

   268

   269

	byte caption_color;

   270

   271

	WindowProc *wndproc;

   272

	ViewPort *viewport;

   273

	const Widget *original_widget;

   274

	Widget *widget;

   275

	uint widget_count;

   276

	uint32 desc_flags;

   277

   278

	WindowMessage message;

   279

	Window *parent;

   280

	byte custom[WINDOW_CUSTOM_SIZE];

   281

   282

	void SetWidgetDisabledState(byte widget_index, bool disab_stat);

   283

	void DisableWidget(byte widget_index);

   284

	void EnableWidget(byte widget_index);

   285

	bool IsWidgetDisabled(byte widget_index) const;

   286

	void SetWidgetHiddenState(byte widget_index, bool hidden_stat);

   287

	void HideWidget(byte widget_index);

   288

	void ShowWidget(byte widget_index);

   289

	bool IsWidgetHidden(byte widget_index) const;

   290

	void SetWidgetLoweredState(byte widget_index, bool lowered_stat);

   291

	void ToggleWidgetLoweredState(byte widget_index);

   292

	void LowerWidget(byte widget_index);

   293

	void RaiseWidget(byte widget_index);

   294

	bool IsWidgetLowered(byte widget_index) const;

   295

   296

	void RaiseButtons();

   297

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

   298

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

   299

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

   300

	void InvalidateWidget(byte widget_index);

   301

};

   302

   303

struct querystr_d {

   304

	StringID caption;

   305

	Textbuf text;

   306

	const char *orig;

   307

	CharSetFilter afilter;

   308

	bool handled;

   309

};

   310

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d));

   311

   312

struct chatquerystr_d : public querystr_d {

   313

	int dest;

   314

};

   315

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(chatquerystr_d));

   316

   317

struct menu_d {

   318

	byte item_count;      ///< follow_vehicle

   319

	byte sel_index;       ///< scrollpos_x

   320

	byte main_button;     ///< scrollpos_y

   321

	byte action_id;

   322

	StringID string_id;   ///< unk30

   323

	uint16 checked_items; ///< unk32

   324

	byte disabled_items;

   325

};

   326

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   327

   328

struct def_d {

   329

	int16 data_1, data_2, data_3;

   330

	int16 data_4, data_5;

   331

	bool close;

   332

	byte byte_1;

   333

};

   334

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   335

   336

struct void_d {

   337

	void *data;

   338

};

   339

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   340

   341

struct tree_d {

   342

	uint16 base;

   343

	uint16 count;

   344

};

   345

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   346

   347

struct tooltips_d {

   348

	StringID string_id;

   349

	byte paramcount;

   350

	uint64 params[5];

   351

};

   352

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   353

   354

struct buildvehicle_d {

   355

	VehicleType vehicle_type;

   356

	union {

   357

		RailTypeByte railtype;

   358

		AirportFTAClass::Flags flags;

   359

		RoadTypes roadtypes;

   360

	} filter;

   361

	byte sel_index;  ///< deprecated value, used for 'unified' ship and road

   362

	bool descending_sort_order;

   363

	byte sort_criteria;

   364

	bool regenerate_list;

   365

	EngineID sel_engine;

   366

	EngineID rename_engine;

   367

	EngineList eng_list;

   368

};

   369

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildvehicle_d));

   370

   371

struct replaceveh_d {

   372

	byte sel_index[2];

   373

	EngineID sel_engine[2];

   374

	uint16 count[2];

   375

	bool wagon_btnstate; ///< true means engine is selected

   376

	EngineList list[2];

   377

	bool update_left;

   378

	bool update_right;

   379

	bool init_lists;

   380

	GroupID sel_group;

   381

};

   382

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   383

   384

struct depot_d {

   385

	VehicleID sel;

   386

	VehicleType type;

   387

	bool generate_list;

   388

	uint16 engine_list_length;

   389

	uint16 wagon_list_length;

   390

	uint16 engine_count;

   391

	uint16 wagon_count;

   392

	Vehicle **vehicle_list;

   393

	Vehicle **wagon_list;

   394

};

   395

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   396

   397

struct order_d {

   398

	int sel;

   399

};

   400

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   401

   402

struct vehicledetails_d {

   403

	byte tab;

   404

};

   405

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehicledetails_d));

   406

   407

struct smallmap_d {

   408

	int32 scroll_x;

   409

	int32 scroll_y;

   410

	int32 subscroll;

   411

};

   412

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   413

   414

/* player face selection window */

   415

struct facesel_d {

   416

	PlayerFace face; // player face bits

   417

	bool advanced;   // advance player face selection window

   418

};

   419

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   420

   421

struct refit_d {

   422

	int sel;

   423

	struct RefitOption *cargo;

   424

	struct RefitList *list;

   425

	uint length;

   426

	VehicleOrderID order;

   427

};

   428

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   429

   430

struct vp_d {

   431

	VehicleID follow_vehicle;

   432

	int32 scrollpos_x;

   433

	int32 scrollpos_y;

   434

	int32 dest_scrollpos_x;

   435

	int32 dest_scrollpos_y;

   436

};

   437

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   438

   439

struct news_d {

   440

	uint16 follow_vehicle;

   441

	int32 scrollpos_x;

   442

	int32 scrollpos_y;

   443

	int32 dest_scrollpos_x;

   444

	int32 dest_scrollpos_y;

   445

	NewsItem *ni;

   446

};

   447

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   448

   449

struct highscore_d {

   450

	uint32 background_img;

   451

	int8 rank;

   452

};

   453

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   454

   455

struct scroller_d {

   456

	int height;

   457

	uint16 counter;

   458

};

   459

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   460

   461

enum SortListFlags {

   462

	VL_NONE    = 0,      ///< no sort

   463

	VL_DESC    = 1 << 0, ///< sort descending or ascending

   464

	VL_RESORT  = 1 << 1, ///< instruct the code to resort the list in the next loop

   465

	VL_REBUILD = 1 << 2, ///< create sort-listing to use for qsort and friends

   466

	VL_END     = 1 << 3,

   467

};

   468

   469

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   470

   471

struct Listing {

   472

	bool order;    ///< Ascending/descending

   473

	byte criteria; ///< Sorting criteria

   474

};

   475

   476

struct list_d {

   477

	uint16 list_length;  ///< length of the list being sorted

   478

	byte sort_type;      ///< what criteria to sort on

   479

	SortListFlags flags; ///< used to control sorting/resorting/etc.

   480

	uint16 resort_timer; ///< resort list after a given amount of ticks if set

   481

};

   482

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   483

   484