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

			Point pt;

   132

			int widget;

   133

		} click;

   134

   135

		struct {

   136

			Point pt;

   137

			TileIndex tile;

   138

			TileIndex starttile;

   139

			byte select_method;

   140

			byte select_proc;

   141

		} place;

   142

   143

		struct {

   144

			Point pt;

   145

			int widget;

   146

		} dragdrop;

   147

   148

		struct {

   149

			Point size;

   150

			Point diff;

   151

		} sizing;

   152

   153

		struct {

   154

			char *str;

   155

		} edittext;

   156

   157

		struct {

   158

			Point pt;

   159

		} popupmenu;

   160

   161

		struct {

   162

			int button;

   163

			int index;

   164

		} dropdown;

   165

   166

		struct {

   167

			Point pt;

   168

			int widget;

   169

		} mouseover;

   170

   171

		struct {

   172

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

   173

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

   174

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

   175

		} keypress;

   176

   177

		struct {

   178

			int msg;      ///< message to be sent

   179

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

   180

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

   181

		} message;

   182

   183

		struct {

   184

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

   185

		} scroll;

   186

   187

		struct {

   188

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

   189

		} wheel;

   190

	} we;

   191

};

   192

   193

struct WindowDesc {

   194

	int16 left, top, width, height;

   195

	WindowClass cls;

   196

	WindowClass parent_cls;

   197

	uint32 flags;

   198

	const Widget *widgets;

   199

	WindowProc *proc;

   200

};

   201

   202

enum WindowDefaultFlag {

   203

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

   204

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

   205

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

   206

   207

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

   208

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

   209

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

   210

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

   211

};

   212

   213

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

   214

enum WindowDefaultPosition {

   215

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

   216

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

   217

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

   218

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

   219

};

   220

   221

struct Textbuf {

   222

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

   223

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

   224

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

   225

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

   226

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

   227

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

   228

};

   229

   230

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

   231

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

   232

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

   233

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

   234

#define WINDOW_CUSTOM_SIZE 96

   235

   236

struct Scrollbar {

   237

	uint16 count, cap, pos;

   238

};

   239

   240

struct ResizeInfo {

   241

	uint width; ///< Minimum width and height

   242

	uint height;

   243

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

   244

	uint step_height;

   245

};

   246

   247

struct WindowMessage {

   248

	int msg;

   249

	int wparam;

   250

	int lparam;

   251

};

   252

   253

struct Window {

   254

	uint16 flags4;

   255

	WindowClass window_class;

   256

	WindowNumber window_number;

   257

   258

	int left, top;

   259

	int width, height;

   260

   261

	Scrollbar hscroll, vscroll, vscroll2;

   262

	ResizeInfo resize;

   263

   264

	byte caption_color;

   265

   266

	WindowProc *wndproc;

   267

	ViewPort *viewport;

   268

	const Widget *original_widget;

   269

	Widget *widget;

   270

	uint widget_count;

   271

	uint32 desc_flags;

   272

   273

	WindowMessage message;

   274

	Window *parent;

   275

	byte custom[WINDOW_CUSTOM_SIZE];

   276

};

   277

   278

struct querystr_d {

   279

	StringID caption;

   280

	Textbuf text;

   281

	const char *orig;

   282

	CharSetFilter afilter;

   283

	bool handled;

   284

};

   285

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d));

   286

   287

struct chatquerystr_d : public querystr_d {

   288

	int dest;

   289

};

   290

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(chatquerystr_d));

   291

   292

struct menu_d {

   293

	byte item_count;      ///< follow_vehicle

   294

	byte sel_index;       ///< scrollpos_x

   295

	byte main_button;     ///< scrollpos_y

   296

	byte action_id;

   297

	StringID string_id;   ///< unk30

   298

	uint16 checked_items; ///< unk32

   299

	byte disabled_items;

   300

};

   301

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   302

   303

struct def_d {

   304

	int16 data_1, data_2, data_3;

   305

	int16 data_4, data_5;

   306

	bool close;

   307

	byte byte_1;

   308

};

   309

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   310

   311

struct void_d {

   312

	void *data;

   313

};

   314

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   315

   316

struct tree_d {

   317

	uint16 base;

   318

	uint16 count;

   319

};

   320

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   321

   322

struct tooltips_d {

   323

	StringID string_id;

   324

	byte paramcount;

   325

	uint64 params[5];

   326

};

   327

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   328

   329

struct buildvehicle_d {

   330

	VehicleType vehicle_type;

   331

	union {

   332

		RailTypeByte railtype;

   333

		AirportFTAClass::Flags flags;

   334

		RoadTypes roadtypes;

   335

	} filter;

   336

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

   337

	bool descending_sort_order;

   338

	byte sort_criteria;

   339

	bool regenerate_list;

   340

	EngineID sel_engine;

   341

	EngineID rename_engine;

   342

	EngineList eng_list;

   343

};

   344

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildvehicle_d));

   345

   346

struct replaceveh_d {

   347

	byte sel_index[2];

   348

	EngineID sel_engine[2];

   349

	uint16 count[2];

   350

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

   351

	EngineList list[2];

   352

	bool update_left;

   353

	bool update_right;

   354

	bool init_lists;

   355

	GroupID sel_group;

   356

};

   357

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   358

   359

struct depot_d {

   360

	VehicleID sel;

   361

	VehicleType type;

   362

	bool generate_list;

   363

	uint16 engine_list_length;

   364

	uint16 wagon_list_length;

   365

	uint16 engine_count;

   366

	uint16 wagon_count;

   367

	Vehicle **vehicle_list;

   368

	Vehicle **wagon_list;

   369

};

   370

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   371

   372

struct order_d {

   373

	int sel;

   374

};

   375

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   376

   377

struct traindetails_d {

   378

	byte tab;

   379

};

   380

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   381

   382

struct smallmap_d {

   383

	int32 scroll_x;

   384

	int32 scroll_y;

   385

	int32 subscroll;

   386

};

   387

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   388

   389

struct facesel_d {

   390

	uint32 face;

   391

	byte gender;

   392

};

   393

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   394

   395

struct refit_d {

   396

	int sel;

   397

	struct RefitOption *cargo;

   398

	struct RefitList *list;

   399

	uint length;

   400

	VehicleOrderID order;

   401

};

   402

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   403

   404

struct vp_d {

   405

	VehicleID follow_vehicle;

   406

	int32 scrollpos_x;

   407

	int32 scrollpos_y;

   408

	int32 dest_scrollpos_x;

   409

	int32 dest_scrollpos_y;

   410

};

   411

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   412

   413

struct news_d {

   414

	uint16 follow_vehicle;

   415

	int32 scrollpos_x;

   416

	int32 scrollpos_y;

   417

	int32 dest_scrollpos_x;

   418

	int32 dest_scrollpos_y;

   419

	NewsItem *ni;

   420

};

   421

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   422

   423

struct highscore_d {

   424

	uint32 background_img;

   425

	int8 rank;

   426

};

   427

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   428

   429

struct scroller_d {

   430

	int height;

   431

	uint16 counter;

   432

};

   433

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   434

   435

enum SortListFlags {

   436

	VL_NONE    = 0x00,  ///< no sort

   437

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

   438

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

   439

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

   440

	VL_END     = 0x08

   441

};

   442

   443

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   444

   445

struct Listing {

   446

	bool order;    ///< Ascending/descending

   447

	byte criteria; ///< Sorting criteria

   448

};

   449

   450

struct list_d {

   451

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

   452

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

   453

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

   454

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

   455

};

   456

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   457

   458

struct message_d {

   459

	int msg;

   460

	int wparam;

   461

	int lparam;

   462

};

   463

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   464

   465

struct dropdown_d {

   466

	uint32 disabled_state;

   467

	uint32 hidden_state;

   468

	WindowClass parent_wnd_class;

   469

	WindowNumber parent_wnd_num;

   470

	byte parent_button;

   471

	byte num_items;

   472

	byte selected_index;

   473

	const StringID *items;

   474

	byte click_delay;

   475

	bool drag_mode;

   476

};

   477

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(dropdown_d));

   478

   479

struct vehiclelist_d {

   480

	const Vehicle** sort_list;  // List of vehicles (sorted)

   481

	Listing *_sorting;          // pointer to the appropiate subcategory of _sorting

   482

	uint16 length_of_sort_list; // Keeps track of how many vehicle pointers sort list got space for

   483

	VehicleType vehicle_type;   // The vehicle type that is sorted

   484

	list_d l;                   // General list struct