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_RCLICK,

   103

	WE_MOUSEOVER,

   104

	WE_MOUSELOOP,

   105

	WE_MOUSEWHEEL,

   106

	WE_TICK,

   107

	WE_4,

   108

	WE_TIMEOUT,

   109

	WE_PLACE_OBJ,

   110

	WE_ABORT_PLACE_OBJ,

   111

	WE_ON_EDIT_TEXT,

   112

	WE_ON_EDIT_TEXT_CANCEL,

   113

	WE_POPUPMENU_SELECT,

   114

	WE_POPUPMENU_OVER,

   115

	WE_DRAGDROP,

   116

	WE_PLACE_DRAG,

   117

	WE_PLACE_MOUSEUP,

   118

	WE_PLACE_PRESIZE,

   119

	WE_DROPDOWN_SELECT,

   120

	WE_RESIZE,

   121

	WE_MESSAGE,

   122

	WE_SCROLL,

   123

	WE_INVALIDATE_DATA,

   124

};

   125

   126

struct WindowEvent {

   127

	byte event;

   128

	union {

   129

		struct{

   130

			Point pt;

   131

			int widget;

   132

		} click;

   133

   134

		struct {

   135

			Point pt;

   136

			TileIndex tile;

   137

			TileIndex starttile;

   138

			byte select_method;

   139

			byte select_proc;

   140

		} place;

   141

   142

		struct {

   143

			Point pt;

   144

			int widget;

   145

		} dragdrop;

   146

   147

		struct {

   148

			Point size;

   149

			Point diff;

   150

		} sizing;

   151

   152

		struct {

   153

			char *str;

   154

		} edittext;

   155

   156

		struct {

   157

			Point pt;

   158

		} popupmenu;

   159

   160

		struct {

   161

			int button;

   162

			int index;

   163

		} dropdown;

   164

   165

		struct {

   166

			Point pt;

   167

			int widget;

   168

		} mouseover;

   169

   170

		struct {

   171

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

   172

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

   173

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

   174

		} keypress;

   175

   176

		struct {

   177

			int msg;      ///< message to be sent

   178

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

   179

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

   180

		} message;

   181

   182

		struct {

   183

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

   184

		} scroll;

   185

   186

		struct {

   187

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

   188

		} wheel;

   189

	} we;

   190

};

   191

   192

struct WindowDesc {

   193

	int16 left, top, width, height;

   194

	WindowClass cls;

   195

	WindowClass parent_cls;

   196

	uint32 flags;

   197

	const Widget *widgets;

   198

	WindowProc *proc;

   199

};

   200

   201

enum WindowDefaultFlag {

   202

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

   203

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

   204

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

   205

   206

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

   207

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

   208

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

   209

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

   210

};

   211

   212

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

   213

enum WindowDefaultPosition {

   214

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

   215

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

   216

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

   217

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

   218

};

   219

   220

struct Textbuf {

   221

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

   222

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

   223

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

   224

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

   225

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

   226

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

   227

};

   228

   229

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

   230

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

   231

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

   232

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

   233

#define WINDOW_CUSTOM_SIZE 96

   234

   235

struct Scrollbar {

   236

	uint16 count, cap, pos;

   237

};

   238

   239

struct ResizeInfo {

   240

	uint width; ///< Minimum width and height

   241

	uint height;

   242

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

   243

	uint step_height;

   244

};

   245

   246

struct WindowMessage {

   247

	int msg;

   248

	int wparam;

   249

	int lparam;

   250

};

   251

   252

struct Window {

   253

	uint16 flags4;

   254

	WindowClass window_class;

   255

	WindowNumber window_number;

   256

   257

	int left, top;

   258

	int width, height;

   259

   260

	Scrollbar hscroll, vscroll, vscroll2;

   261

	ResizeInfo resize;

   262

   263

	byte caption_color;

   264

   265

	WindowProc *wndproc;

   266

	ViewPort *viewport;

   267

	const Widget *original_widget;

   268

	Widget *widget;

   269

	uint widget_count;

   270

	uint32 desc_flags;

   271

   272

	WindowMessage message;

   273

	Window *parent;

   274

	byte custom[WINDOW_CUSTOM_SIZE];

   275

};

   276

   277

struct querystr_d {

   278

	StringID caption;

   279

	Textbuf text;

   280

	const char *orig;

   281

	CharSetFilter afilter;

   282

	bool handled;

   283

};

   284

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d));

   285

   286

struct chatquerystr_d : public querystr_d {

   287

	int dest;

   288

};

   289

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(chatquerystr_d));

   290

   291

struct menu_d {

   292

	byte item_count;      ///< follow_vehicle

   293

	byte sel_index;       ///< scrollpos_x

   294

	byte main_button;     ///< scrollpos_y

   295

	byte action_id;

   296

	StringID string_id;   ///< unk30

   297

	uint16 checked_items; ///< unk32

   298

	byte disabled_items;

   299

};

   300

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   301

   302

struct def_d {

   303

	int16 data_1, data_2, data_3;

   304

	int16 data_4, data_5;

   305

	bool close;

   306

	byte byte_1;

   307

};

   308

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   309

   310

struct void_d {

   311

	void *data;

   312

};

   313

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   314

   315

struct tree_d {

   316

	uint16 base;

   317

	uint16 count;

   318

};

   319

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   320

   321

struct tooltips_d {

   322

	StringID string_id;

   323

	byte paramcount;

   324

	uint32 params[5];

   325

};

   326

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   327

   328

struct buildvehicle_d {

   329

	VehicleType vehicle_type;

   330

	union {

   331

		RailTypeByte railtype;

   332

		AirportFTAClass::Flags flags;

   333

		RoadTypes roadtypes;

   334

	} filter;

   335

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

   336

	bool descending_sort_order;

   337

	byte sort_criteria;

   338

	bool regenerate_list;

   339

	EngineID sel_engine;

   340

	EngineID rename_engine;

   341

	EngineList eng_list;

   342

};

   343

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildvehicle_d));

   344

   345

struct replaceveh_d {

   346

	byte sel_index[2];

   347

	EngineID sel_engine[2];

   348

	uint16 count[2];

   349

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

   350

	EngineList list[2];

   351

	bool update_left;

   352

	bool update_right;

   353

	bool init_lists;

   354

	GroupID sel_group;

   355

};

   356

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   357

   358

struct depot_d {

   359

	VehicleID sel;

   360

	VehicleType type;

   361

	bool generate_list;

   362

	uint16 engine_list_length;

   363

	uint16 wagon_list_length;

   364

	uint16 engine_count;

   365

	uint16 wagon_count;

   366

	Vehicle **vehicle_list;

   367

	Vehicle **wagon_list;

   368

};

   369

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   370

   371

struct order_d {

   372

	int sel;

   373

};

   374

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   375

   376

struct traindetails_d {

   377

	byte tab;

   378

};

   379

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   380

   381

struct smallmap_d {

   382

	int32 scroll_x;

   383

	int32 scroll_y;

   384

	int32 subscroll;

   385

};

   386

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   387

   388

struct facesel_d {

   389

	uint32 face;

   390

	byte gender;

   391

};

   392

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   393

   394

struct refit_d {

   395

	int sel;

   396

	struct RefitOption *cargo;

   397

	struct RefitList *list;

   398

	uint length;

   399

	VehicleOrderID order;

   400

};

   401

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   402

   403

struct vp_d {

   404

	VehicleID follow_vehicle;

   405

	int32 scrollpos_x;

   406

	int32 scrollpos_y;

   409

};

   410

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   411

   412

/* vp2_d is the same as vp_d, except for the data_# values.. */

   413

struct vp2_d {

   414

	VehicleID follow_vehicle;

   415

	int32 scrollpos_x;

   416

	int32 scrollpos_y;

   419

	byte data_1;

   420

	byte data_2;

   421

	byte data_3;

   422

};

   423

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp2_d));

   424

   425

struct news_d {

   426

	uint16 follow_vehicle;

   427

	int32 scrollpos_x;

   428

	int32 scrollpos_y;

   431

	NewsItem *ni;

   432

};

   433

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   434

   435

struct highscore_d {

   436

	uint32 background_img;

   437

	int8 rank;

   438

};

   439

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   440

   441

struct scroller_d {

   442

	int height;

   443

	uint16 counter;

   444

};

   445

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   446

   447

enum SortListFlags {

   448

	VL_NONE    = 0x00,  ///< no sort

   449

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

   450

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

   451

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

   452

	VL_END     = 0x08

   453

};

   454

   455

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   456

   457

struct Listing {

   458

	bool order;    ///< Ascending/descending

   459

	byte criteria; ///< Sorting criteria

   460

};

   461

   462

struct list_d {

   463

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

   464

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

   465

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

   466

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

   467

};

   468

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   469

   470

struct message_d {

   471

	int msg;

   472

	int wparam;

   473

	int lparam;

   474

};

   475

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   476

   477

struct dropdown_d {

   478

	uint32 disabled_state;

   479

	uint32 hidden_state;

   480

	WindowClass parent_wnd_class;

   481

	WindowNumber parent_wnd_num;

   482

	byte parent_button;

   483

	byte num_items;

   484

	byte selected_index;