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

    16

struct WindowEvent;

    17

    18

typedef void WindowProc(Window *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,  ///< no resize required

    49

    50

	RESIZE_LEFT   = 1,  ///< left resize flag

    51

	RESIZE_RIGHT  = 2,  ///< rigth resize flag

    52

	RESIZE_TOP    = 4,  ///< top resize flag

    53

	RESIZE_BOTTOM = 8,  ///< bottom resize flag

    54

    55

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

    56

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

    57

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

    58

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

    59

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

    60

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

    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

enum {

    72

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

    73

};

    74

    75

struct Widget {

    76

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

    77

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

    78

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

    79

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

    80

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

    81

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

    82

};

    83

    84

enum FrameFlags {

    85

	FR_NONE         = 0x00,

    86

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

    87

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

    88

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

    89

	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)

    90

};

    91

    92

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

    93

    94

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

    95

    96

enum WindowEventCodes {

    97

	WE_CREATE,

    98

	WE_DESTROY,

    99

	WE_PAINT,

   100

	WE_KEYPRESS,

   101

	WE_CLICK,

   102

	WE_DOUBLE_CLICK,

   103

	WE_RCLICK,

   104

	WE_MOUSEOVER,

   105

	WE_MOUSELOOP,

   106

	WE_MOUSEWHEEL,

   107

	WE_TICK,

   108

	WE_4,

   109

	WE_TIMEOUT,

   110

	WE_PLACE_OBJ,

   111

	WE_ABORT_PLACE_OBJ,

   112

	WE_ON_EDIT_TEXT,

   113

	WE_ON_EDIT_TEXT_CANCEL,

   114

	WE_POPUPMENU_SELECT,

   115

	WE_POPUPMENU_OVER,

   116

	WE_DRAGDROP,

   117

	WE_PLACE_DRAG,

   118

	WE_PLACE_MOUSEUP,

   119

	WE_PLACE_PRESIZE,

   120

	WE_DROPDOWN_SELECT,

   121

	WE_RESIZE,

   122

	WE_MESSAGE,

   123

	WE_SCROLL,

   124

	WE_INVALIDATE_DATA,

   125

};

   126

   127

struct WindowEvent {

   128

	byte event;

   129

	union {

   130

		struct {

   131

			void *data;

   132

		} create;

   133

   134

		struct {

   135

			Point pt;

   136

			int widget;

   137

		} click;

   138

   139

		struct {

   140

			Point pt;

   141

			TileIndex tile;

   142

			TileIndex starttile;

   143

			byte select_method;

   144

			byte select_proc;

   145

		} place;

   146

   147

		struct {

   148

			Point pt;

   149

			int widget;

   150

		} dragdrop;

   151

   152

		struct {

   153

			Point size;

   154

			Point diff;

   155

		} sizing;

   156

   157

		struct {

   158

			char *str;

   159

		} edittext;

   160

   161

		struct {

   162

			Point pt;

   163

		} popupmenu;

   164

   165

		struct {

   166

			int button;

   167

			int index;

   168

		} dropdown;

   169

   170

		struct {

   171

			Point pt;

   172

			int widget;

   173

		} mouseover;

   174

   175

		struct {

   176

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

   177

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

   178

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

   179

		} keypress;

   180

   181

		struct {

   182

			int msg;      ///< message to be sent

   183

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

   184

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

   185

		} message;

   186

   187

		struct {

   188

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

   189

		} scroll;

   190

   191

		struct {

   192

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

   193

		} wheel;

   194

	} we;

   195

};

   196

   197

struct WindowDesc {

   198

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

   199

	WindowClass cls;

   200

	WindowClass parent_cls;

   201

	uint32 flags;

   202

	const Widget *widgets;

   203

	WindowProc *proc;

   204

};

   205

   206

enum WindowDefaultFlag {

   207

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

   208

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

   209

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

   210

   211

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

   212

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

   213

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

   214

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

   215

};

   216

   217

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

   218

enum WindowDefaultPosition {

   219

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

   220

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

   221

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

   222

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

   223

};

   224

   225

struct Textbuf {

   226

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

   227

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

   228

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

   229

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

   230

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

   231

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

   232

};

   233

   234

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

   235

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

   236

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

   237

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

   238

#define WINDOW_CUSTOM_SIZE 96

   239

   240

struct Scrollbar {

   241

	uint16 count, cap, pos;

   242

};

   243

   244

struct ResizeInfo {

   245

	uint width; ///< Minimum width and height

   246

	uint height;

   247

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

   248

	uint step_height;

   249

};

   250

   251

struct WindowMessage {

   252

	int msg;

   253

	int wparam;

   254

	int lparam;

   255

};

   256

   257

struct Window {

   258

	uint16 flags4;

   259

	WindowClass window_class;

   260

	WindowNumber window_number;

   261

   262

	int left, top;

   263

	int width, height;

   264

   265

	Scrollbar hscroll, vscroll, vscroll2;

   266

	ResizeInfo resize;

   267

   268

	byte caption_color;

   269

   270

	WindowProc *wndproc;

   271

	ViewPort *viewport;

   272

	const Widget *original_widget;

   273

	Widget *widget;

   274

	uint widget_count;

   275

	uint32 desc_flags;

   276

   277

	WindowMessage message;

   278

	Window *parent;

   279

	byte custom[WINDOW_CUSTOM_SIZE];

   280

};

   281

   282

struct querystr_d {

   283

	StringID caption;

   284

	Textbuf text;

   285

	const char *orig;

   286

	CharSetFilter afilter;

   287

	bool handled;

   288

};

   289

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d));

   290

   291

struct chatquerystr_d : public querystr_d {

   292

	int dest;

   293

};

   294

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(chatquerystr_d));

   295

   296

struct menu_d {

   297

	byte item_count;      ///< follow_vehicle

   298

	byte sel_index;       ///< scrollpos_x

   299

	byte main_button;     ///< scrollpos_y

   300

	byte action_id;

   301

	StringID string_id;   ///< unk30

   302

	uint16 checked_items; ///< unk32

   303

	byte disabled_items;

   304

};

   305

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   306

   307

struct def_d {

   308

	int16 data_1, data_2, data_3;

   309

	int16 data_4, data_5;

   310

	bool close;

   311

	byte byte_1;

   312

};

   313

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   314

   315

struct void_d {

   316

	void *data;

   317

};

   318

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   319

   320

struct tree_d {

   321

	uint16 base;

   322

	uint16 count;

   323

};

   324

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   325

   326

struct tooltips_d {

   327

	StringID string_id;

   328

	byte paramcount;

   329

	uint64 params[5];

   330

};

   331

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   332

   333

struct buildvehicle_d {

   334

	VehicleType vehicle_type;

   335

	union {

   336

		RailTypeByte railtype;

   337

		AirportFTAClass::Flags flags;

   338

		RoadTypes roadtypes;

   339

	} filter;

   340

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

   341

	bool descending_sort_order;

   342

	byte sort_criteria;

   343

	bool regenerate_list;

   344

	EngineID sel_engine;

   345

	EngineID rename_engine;

   346

	EngineList eng_list;

   347

};

   348

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildvehicle_d));

   349

   350

struct replaceveh_d {

   351

	byte sel_index[2];

   352

	EngineID sel_engine[2];

   353

	uint16 count[2];

   354

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

   355

	EngineList list[2];

   356

	bool update_left;

   357

	bool update_right;

   358

	bool init_lists;

   359

	GroupID sel_group;

   360

};

   361

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   362

   363

struct depot_d {

   364

	VehicleID sel;

   365

	VehicleType type;

   366

	bool generate_list;

   367

	uint16 engine_list_length;

   368

	uint16 wagon_list_length;

   369

	uint16 engine_count;

   370

	uint16 wagon_count;

   371

	Vehicle **vehicle_list;

   372

	Vehicle **wagon_list;

   373

};

   374

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   375

   376

struct order_d {

   377

	int sel;

   378

};

   379

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   380

   381

struct vehicledetails_d {

   382

	byte tab;

   383

};

   384

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehicledetails_d));

   385

   386

struct smallmap_d {

   387

	int32 scroll_x;

   388

	int32 scroll_y;

   389

	int32 subscroll;

   390

};

   391

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   392

   393

struct facesel_d {

   394

	uint32 face;

   395

	byte gender;

   396

};

   397

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   398

   399

struct refit_d {

   400

	int sel;

   401

	struct RefitOption *cargo;

   402

	struct RefitList *list;

   403

	uint length;

   404

	VehicleOrderID order;

   405

};

   406

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   407

   408

struct vp_d {

   409

	VehicleID follow_vehicle;

   410

	int32 scrollpos_x;

   411

	int32 scrollpos_y;

   412

	int32 dest_scrollpos_x;

   413

	int32 dest_scrollpos_y;

   414

};

   415

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   416

   417

struct news_d {

   418

	uint16 follow_vehicle;

   419

	int32 scrollpos_x;

   420

	int32 scrollpos_y;

   421

	int32 dest_scrollpos_x;

   422

	int32 dest_scrollpos_y;

   423

	NewsItem *ni;

   424

};

   425

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   426

   427

struct highscore_d {

   428

	uint32 background_img;

   429

	int8 rank;

   430

};

   431

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   432

   433

struct scroller_d {

   434

	int height;

   435

	uint16 counter;

   436

};

   437

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   438

   439

enum SortListFlags {

   440

	VL_NONE    = 0x00,  ///< no sort

   441

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

   442

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

   443

	VL_REBUILD = 0x04,  ///< create sort-listing to use for qsort and friends

   444

	VL_END     = 0x08

   445

};

   446

   447

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   448

   449

struct Listing {

   450

	bool order;    ///< Ascending/descending

   451

	byte criteria; ///< Sorting criteria

   452

};

   453

   454

struct list_d {

   455

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

   456

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

   457

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

   458

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

   459

};

   460

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   461

   462

struct message_d {

   463

	int msg;

   464

	int wparam;

   465

	int lparam;

   466

};

   467

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   468

   469

struct dropdown_d {

   470

	uint32 disabled_state;

   471

	uint32 hidden_state;

   472

	WindowClass parent_wnd_class;

   473

	WindowNumber parent_wnd_num;

   474

	byte parent_button;

   475

	byte num_items;

   476

	byte selected_index;

   477

	const StringID *items;

   478

	byte click_delay;

   479

	bool drag_mode;

   480

};

   481

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(dropdown_d));

   482

   483

struct vehiclelist_d {

   484