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

    13

    14

struct WindowEvent;

    15

    16

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

    17

    18

/* How the resize system works:

    19

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

    20

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

    21

     to resize itself.

    22

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

    23

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

    24

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

    25

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

    26

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

    27

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

    28

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

    29

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

    30

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

    31

     widgets moves downwards without resizing, and appears to be clamped

    32

     to the bottom. Nice aint it?

    33

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

    34

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

    35

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

    36

    after making the window, like this:

    37

      w->resize.step_height = 10;

    38

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

    39

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

    40

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

    41

    AFTER window-creation, with:

    42

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

    43

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

    44

    45

enum ResizeFlag {

    46

	RESIZE_NONE   = 0,  ///< no resize required

    47

    48

	RESIZE_LEFT   = 1,  ///< left resize flag

    49

	RESIZE_RIGHT  = 2,  ///< rigth resize flag

    50

	RESIZE_TOP    = 4,  ///< top resize flag

    51

	RESIZE_BOTTOM = 8,  ///< bottom resize flag

    52

    53

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

    54

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

    55

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

    56

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

    57

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

    58

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

    59

    60

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

    61

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

    62

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

    63

	 * Enabled, visible or unclicked widgets*/

    64

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

    65

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

    66

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

    67

};

    68

    69

enum {

    70

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

    71

};

    72

    73

struct Widget {

    74

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

    75

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

    76

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

    77

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

    78

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

    79

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

    80

};

    81

    82

enum FrameFlags {

    83

	FR_NONE         = 0x00,

    84

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

    85

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

    86

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

    87

	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)

    88

};

    89

    90

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

    91

    92

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

    93

    94

enum WindowEventCodes {

    95

	WE_CREATE,

    96

	WE_DESTROY,

    97

	WE_PAINT,

    98

	WE_KEYPRESS,

    99

	WE_CLICK,

   100

	WE_RCLICK,

   101

	WE_MOUSEOVER,

   102

	WE_MOUSELOOP,

   103

	WE_MOUSEWHEEL,

   104

	WE_TICK,

   105

	WE_4,

   106

	WE_TIMEOUT,

   107

	WE_PLACE_OBJ,

   108

	WE_ABORT_PLACE_OBJ,

   109

	WE_ON_EDIT_TEXT,

   110

	WE_ON_EDIT_TEXT_CANCEL,

   111

	WE_POPUPMENU_SELECT,

   112

	WE_POPUPMENU_OVER,

   113

	WE_DRAGDROP,

   114

	WE_PLACE_DRAG,

   115

	WE_PLACE_MOUSEUP,

   116

	WE_PLACE_PRESIZE,

   117

	WE_DROPDOWN_SELECT,

   118

	WE_RESIZE,

   119

	WE_MESSAGE,

   120

	WE_SCROLL,

   121

	WE_INVALIDATE_DATA,

   122

};

   123

   124

struct WindowEvent {

   125

	byte event;

   126

	union {

   127

		struct{

   128

			Point pt;

   129

			int widget;

   130

		} click;

   131

   132

		struct {

   133

			Point pt;

   134

			TileIndex tile;

   135

			TileIndex starttile;

   136

			int userdata;

   137

		} place;

   138

   139

		struct {

   140

			Point pt;

   141

			int widget;

   142

		} dragdrop;

   143

   144

		struct {

   145

			Point size;

   146

			Point diff;

   147

		} sizing;

   148

   149

		struct {

   150

			char *str;

   151

		} edittext;

   152

   153

		struct {

   154

			Point pt;

   155

		} popupmenu;

   156

   157

		struct {

   158

			int button;

   159

			int index;

   160

		} dropdown;

   161

   162

		struct {

   163

			Point pt;

   164

			int widget;

   165

		} mouseover;

   166

   167

		struct {

   168

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

   169

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

   170

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

   171

		} keypress;

   172

   173

		struct {

   174

			int msg;      ///< message to be sent

   175

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

   176

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

   177

		} message;

   178

   179

		struct {

   180

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

   181

		} scroll;

   182

   183

		struct {

   184

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

   185

		} wheel;

   186

	} we;

   187

};

   188

   189

struct WindowDesc {

   190

	int16 left, top, width, height;

   191

	WindowClass cls;

   192

	WindowClass parent_cls;

   193

	uint32 flags;

   194

	const Widget *widgets;

   195

	WindowProc *proc;

   196

};

   197

   198

enum WindowDefaultFlag {

   199

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

   200

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

   201

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

   202

   203

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

   204

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

   205

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

   206

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

   207

};

   208

   209

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

   210

enum WindowDefaultPosition {

   211

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

   212

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

   213

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

   214

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

   215

};

   216

   217

struct Textbuf {

   218

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

   219

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

   220

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

   221

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

   222

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

   223

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

   224

};

   225

   226

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

   227

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

   228

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

   229

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

   230

#define WINDOW_CUSTOM_SIZE 96

   231

   232

struct Scrollbar {

   233

	uint16 count, cap, pos;

   234

};

   235

   236

struct ResizeInfo {

   237

	uint width; ///< Minimum width and height

   238

	uint height;

   239

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

   240

	uint step_height;

   241

};

   242

   243

struct WindowMessage {

   244

	int msg;

   245

	int wparam;

   246

	int lparam;

   247

};

   248

   249

struct Window {

   250

	uint16 flags4;

   251

	WindowClass window_class;

   252

	WindowNumber window_number;

   253

   254

	int left, top;

   255

	int width, height;

   256

   257

	Scrollbar hscroll, vscroll, vscroll2;

   258

	ResizeInfo resize;

   259

   260

	byte caption_color;

   261

   262

	WindowProc *wndproc;

   263

	ViewPort *viewport;

   264

	const Widget *original_widget;

   265

	Widget *widget;

   266

	uint widget_count;

   267

	uint32 desc_flags;

   268

   269

	WindowMessage message;

   270

	Window *parent;

   271

	byte custom[WINDOW_CUSTOM_SIZE];

   272

};

   273

   274

struct querystr_d {

   275

	StringID caption;

   276

	Textbuf text;

   277

	const char *orig;

   278

	CharSetFilter afilter;

   279

	bool handled;

   280

};

   281

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d));

   282

   283

struct menu_d {

   284

	byte item_count;      ///< follow_vehicle

   285

	byte sel_index;       ///< scrollpos_x

   286

	byte main_button;     ///< scrollpos_y

   287

	byte action_id;

   288

	StringID string_id;   ///< unk30

   289

	uint16 checked_items; ///< unk32

   290

	byte disabled_items;

   291

};

   292

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   293

   294

struct def_d {

   295

	int16 data_1, data_2, data_3;

   296

	int16 data_4, data_5;

   297

	bool close;

   298

	byte byte_1;

   299

};

   300

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   301

   302

struct void_d {

   303

	void *data;

   304

};

   305

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   306

   307

struct tree_d {

   308

	uint16 base;

   309

	uint16 count;

   310

};

   311

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   312

   313

struct tooltips_d {

   314

	StringID string_id;

   315

	byte paramcount;

   316

	uint32 params[5];

   317

};

   318

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   319

   320

struct buildvehicle_d {

   321

	byte vehicle_type;

   322

	union {

   323

		RailTypeByte railtype;

   324

		AirportFTAClass::Flags flags;

   325

	} filter;

   326

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

   327

	bool descending_sort_order;

   328

	byte sort_criteria;

   329

	bool regenerate_list;

   330

	EngineID sel_engine;

   331

	EngineID rename_engine;

   332

	EngineList eng_list;

   333

};

   334

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildvehicle_d));

   335

   336

struct replaceveh_d {

   337

	byte sel_index[2];

   338

	EngineID sel_engine[2];

   339

	uint16 count[2];

   340

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

   341

	EngineList list[2];

   342

	bool update_left;

   343

	bool update_right;

   344

	bool init_lists;

   345

};

   346

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   347

   348

struct depot_d {

   349

	VehicleID sel;

   350

	byte type;

   351

	bool generate_list;

   352

	uint16 engine_list_length;

   353

	uint16 wagon_list_length;

   354

	uint16 engine_count;

   355

	uint16 wagon_count;

   356

	Vehicle **vehicle_list;

   357

	Vehicle **wagon_list;

   358

};

   359

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   360

   361

struct order_d {

   362

	int sel;

   363

};

   364

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   365

   366

struct traindetails_d {

   367

	byte tab;

   368

};

   369

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   370

   371

struct smallmap_d {

   372

	int32 scroll_x;

   373

	int32 scroll_y;

   374

	int32 subscroll;

   375

};

   376

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   377

   378

struct facesel_d {

   379

	uint32 face;

   380

	byte gender;

   381

};

   382

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   383

   384

struct refit_d {

   385

	int sel;

   386

	struct RefitOption *cargo;

   387

	struct RefitList *list;

   388

	uint length;

   389

	VehicleOrderID order;

   390

};

   391

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   392

   393

struct vp_d {

   394

	VehicleID follow_vehicle;

   395

	int32 scrollpos_x;

   396

	int32 scrollpos_y;

   397

};

   398

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   399

   400

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

   401

struct vp2_d {

   402

	VehicleID follow_vehicle;

   403

	int32 scrollpos_x;

   404

	int32 scrollpos_y;

   405

	byte data_1;

   406

	byte data_2;

   407

	byte data_3;

   408

};

   409

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp2_d));

   410

   411

struct news_d {

   412

	uint16 follow_vehicle;

   413

	int32 scrollpos_x;

   414

	int32 scrollpos_y;

   415

	NewsItem *ni;

   416

};

   417

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   418

   419

struct highscore_d {

   420

	uint32 background_img;

   421

	int8 rank;

   422

};

   423

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   424

   425

struct scroller_d {

   426

	int height;

   427

	uint16 counter;

   428

};

   429

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   430

   431

enum SortListFlags {

   432

	VL_NONE    = 0x00,  ///< no sort

   433

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

   434

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

   435

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

   436

	VL_END     = 0x08

   437

};

   438

   439

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   440

   441

struct Listing {

   442

	bool order;    ///< Ascending/descending

   443

	byte criteria; ///< Sorting criteria

   444

};

   445

   446

struct list_d {

   447

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

   448

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

   449

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

   450

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

   451

};

   452

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   453

   454

struct message_d {

   455

	int msg;

   456

	int wparam;

   457

	int lparam;

   458

};

   459

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   460

   461

struct dropdown_d {

   462

	uint32 disabled_state;

   463

	uint32 hidden_state;

   464

	WindowClass parent_wnd_class;

   465

	WindowNumber parent_wnd_num;

   466

	byte parent_button;

   467

	byte num_items;

   468

	byte selected_index;

   469

	const StringID *items;

   470

	byte click_delay;

   471

	bool drag_mode;

   472

};

   473

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(dropdown_d));

   474

   475

   476

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

   477

enum WindowWidgetBehaviours {

   478

	WWB_PUSHBUTTON  = 1 << 5,

   479

   480

	WWB_MASK        = 0xE0,

   481

};

   482

   483

   484

enum WindowWidgetTypes {