1

/* $Id$ */

     2

     3

#ifndef WINDOW_H

     4

#define WINDOW_H

     5

     6

#include "string.h"

     7

     8

typedef struct WindowEvent WindowEvent;

     9

    10

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

    11

    12

/* How the resize system works:

    13

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

    14

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

    15

     to resize itself.

    16

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

    17

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

    18

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

    19

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

    20

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

    21

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

    22

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

    23

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

    24

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

    25

     widgets moves downwards without resizing, and appears to be clamped

    26

     to the bottom. Nice aint it?

    27

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

    28

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

    29

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

    30

    after making the window, like this:

    31

      w->resize.step_height = 10;

    32

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

    33

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

    34

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

    35

    AFTER window-creation, with:

    36

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

    37

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

    38

    39

enum ResizeFlags {

    40

	RESIZE_NONE   = 0,

    41

    42

	RESIZE_LEFT   = 1,

    43

	RESIZE_RIGHT  = 2,

    44

	RESIZE_TOP    = 4,

    45

	RESIZE_BOTTOM = 8,

    46

    47

	RESIZE_LR     = RESIZE_LEFT  | RESIZE_RIGHT,

    48

	RESIZE_RB     = RESIZE_RIGHT | RESIZE_BOTTOM,

    49

	RESIZE_TB     = RESIZE_TOP   | RESIZE_BOTTOM,

    50

	RESIZE_LRB    = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_BOTTOM,

    51

	RESIZE_LRTB   = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_TOP | RESIZE_BOTTOM,

    52

	RESIZE_RTB    = RESIZE_RIGHT | RESIZE_TOP    | RESIZE_BOTTOM,

    53

} ResizeFlag;

    54

    55

typedef struct Widget {

    56

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

    57

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

    58

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

    59

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

    60

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

    61

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

    62

} Widget;

    63

    64

typedef enum FrameFlags {

    65

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

    66

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

    67

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

    68

	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)

    69

} FrameFlags;

    70

    71

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

    72

    73

enum WindowEventCodes {

    74

	WE_CLICK               =  0,

    75

	WE_PAINT               =  1,

    76

	WE_MOUSELOOP           =  2,

    77

	WE_TICK                =  3,

    78

	WE_4                   =  4,

    79

	WE_TIMEOUT             =  5,

    80

	WE_PLACE_OBJ           =  6,

    81

	WE_ABORT_PLACE_OBJ     =  7,

    82

	WE_DESTROY             =  8,

    83

	WE_ON_EDIT_TEXT        =  9,

    84

	WE_POPUPMENU_SELECT    = 10,

    85

	WE_POPUPMENU_OVER      = 11,

    86

	WE_DRAGDROP            = 12,

    87

	WE_PLACE_DRAG          = 13,

    88

	WE_PLACE_MOUSEUP       = 14,

    89

	WE_PLACE_PRESIZE       = 15,

    90

	WE_DROPDOWN_SELECT     = 16,

    91

	WE_RCLICK              = 17,

    92

	WE_KEYPRESS            = 18,

    93

	WE_CREATE              = 19,

    94

	WE_MOUSEOVER           = 20,

    95

	WE_ON_EDIT_TEXT_CANCEL = 21,

    96

	WE_RESIZE              = 22,

    97

	WE_MESSAGE             = 23,

    98

	WE_SCROLL              = 24,

    99

	WE_MOUSEWHEEL          = 25,

   100

};

   101

   102

struct WindowEvent {

   103

	byte event;

   104

	union {

   105

		struct{

   106

			Point pt;

   107

			int widget;

   108

		} click;

   109

   110

		struct {

   111

			Point pt;

   112

			TileIndex tile;

   113

			TileIndex starttile;

   114

			int userdata;

   115

		} place;

   116

   117

		struct {

   118

			Point pt;

   119

			int widget;

   120

		} dragdrop;

   121

   122

		struct {

   123

			Point size;

   124

			Point diff;

   125

		} sizing;

   126

   127

		struct {

   128

			char *str;

   129

		} edittext;

   130

   131

		struct {

   132

			Point pt;

   133

		} popupmenu;

   134

   135

		struct {

   136

			int button;

   137

			int index;

   138

		} dropdown;

   139

   140

		struct {

   141

			Point pt;

   142

			int widget;

   143

		} mouseover;

   144

   145

		struct {

   146

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

   147

			byte ascii;    // 8-bit ASCII-value of the key

   148

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

   149

		} keypress;

   150

   151

		struct {

   152

			uint msg;      // message to be sent

   153

			uint wparam;   // additional message-specific information

   154

			uint lparam;   // additional message-specific information

   155

		} message;

   156

   157

		struct {

   158

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

   159

		} scroll;

   160

   161

		struct {

   162

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

   163

		} wheel;

   164

	} we;

   165

};

   166

   167

enum WindowKeyCodes {

   168

	WKC_SHIFT = 0x8000,

   169

	WKC_CTRL  = 0x4000,

   170

	WKC_ALT   = 0x2000,

   171

	WKC_META  = 0x1000,

   172

   173

	// Special ones

   174

	WKC_NONE        =  0,

   175

	WKC_ESC         =  1,

   176

	WKC_BACKSPACE   =  2,

   177

	WKC_INSERT      =  3,

   178

	WKC_DELETE      =  4,

   179

   180

	WKC_PAGEUP      =  5,

   181

	WKC_PAGEDOWN    =  6,

   182

	WKC_END         =  7,

   183

	WKC_HOME        =  8,

   184

   185

	// Arrow keys

   186

	WKC_LEFT        =  9,

   187

	WKC_UP          = 10,

   188

	WKC_RIGHT       = 11,

   189

	WKC_DOWN        = 12,

   190

   191

	// Return & tab

   192

	WKC_RETURN      = 13,

   193

	WKC_TAB         = 14,

   194

   195

	// Numerical keyboard

   196

	WKC_NUM_0       = 16,

   197

	WKC_NUM_1       = 17,

   198

	WKC_NUM_2       = 18,

   199

	WKC_NUM_3       = 19,

   200

	WKC_NUM_4       = 20,

   201

	WKC_NUM_5       = 21,

   202

	WKC_NUM_6       = 22,

   203

	WKC_NUM_7       = 23,

   204

	WKC_NUM_8       = 24,

   205

	WKC_NUM_9       = 25,

   206

	WKC_NUM_DIV     = 26,

   207

	WKC_NUM_MUL     = 27,

   208

	WKC_NUM_MINUS   = 28,

   209

	WKC_NUM_PLUS    = 29,

   210

	WKC_NUM_ENTER   = 30,

   211

	WKC_NUM_DECIMAL = 31,

   212

   213

	// Space

   214

	WKC_SPACE       = 32,

   215

   216

	// Function keys

   217

	WKC_F1          = 33,

   218

	WKC_F2          = 34,

   219

	WKC_F3          = 35,

   220

	WKC_F4          = 36,

   221

	WKC_F5          = 37,

   222

	WKC_F6          = 38,

   223

	WKC_F7          = 39,

   224

	WKC_F8          = 40,

   225

	WKC_F9          = 41,

   226

	WKC_F10         = 42,

   227

	WKC_F11         = 43,

   228

	WKC_F12         = 44,

   229

   230

	// backquote is the key left of "1"

   231

	// we only store this key here, no matter what character is really mapped to it

   232

	// on a particular keyboard. (US keyboard: ` and ~ ; German keyboard: ^ and °)

   233

	WKC_BACKQUOTE   = 45,

   234

	WKC_PAUSE       = 46,

   235

   236

	// 0-9 are mapped to 48-57

   237

	// A-Z are mapped to 65-90

   238

	// a-z are mapped to 97-122

   239

};

   240

   241

typedef struct WindowDesc {

   242

	int16 left, top, width, height;

   243

	WindowClass cls;

   244

	WindowClass parent_cls;

   245

	uint32 flags;

   246

	const Widget *widgets;

   247

	WindowProc *proc;

   248

} WindowDesc;

   249

   250

enum {

   251

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

   252

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

   253

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

   254

   255

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

   256

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

   257

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

   258

};

   259

   260

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

   261

enum {

   262

	WDP_AUTO   = -1,

   263

	WDP_CENTER = -2,

   264

};

   265

   266

typedef struct Textbuf {

   267

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

   268

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

   269

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

   270

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

   271

	uint16 caretpos;            /* the current position of the caret in the buffer */

   272

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

   273

} Textbuf;

   274

   275

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

   276

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

   277

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

   278

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

   279

#define WINDOW_CUSTOM_SIZE 96

   280

   281

typedef struct Scrollbar {

   282

	uint16 count, cap, pos;

   283

} Scrollbar;

   284

   285

typedef struct ResizeInfo {

   286

	uint width; /* Minimum width and height */

   287

	uint height;

   288

   289

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

   290

	uint step_height;

   291

} ResizeInfo;

   292

   293

typedef struct WindowMessage {

   294

		int msg;

   295

		int wparam;

   296

		int lparam;

   297

} WindowMessage;

   298

   299

struct Window {

   300

	uint16 flags4;

   301

	WindowClass window_class;

   302

	WindowNumber window_number;

   303

   304

	int left, top;

   305

	int width, height;

   306

   307

	Scrollbar hscroll, vscroll, vscroll2;

   308

	ResizeInfo resize;

   309

   310

	byte caption_color;

   311

   312

	uint32 click_state, disabled_state, hidden_state;

   313

	WindowProc *wndproc;

   314

	ViewPort *viewport;

   315

	const Widget *original_widget;

   316

	Widget *widget;

   317

	uint32 desc_flags;

   318

   319

	WindowMessage message;

   320

	byte custom[WINDOW_CUSTOM_SIZE];

   321

};

   322

   323

typedef struct querystr_d {

   324

	StringID caption;

   325

	WindowClass wnd_class;

   326

	WindowNumber wnd_num;

   327

	Textbuf text;

   328

	const char *orig;

   329

	CharSetFilter afilter;

   330

} querystr_d;

   331

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d));

   332

   333

typedef struct query_d {

   334

	StringID caption;

   335

	StringID message;

   336

	WindowClass wnd_class;

   337

	WindowNumber wnd_num;

   338

	void (*ok_cancel_callback)(bool ok_clicked);

   339

	bool calledback;

   340

} query_d;

   341

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(query_d));

   342

   343

typedef struct {

   344

	byte item_count;      /* follow_vehicle */

   345

	byte sel_index;       /* scrollpos_x */

   346

	byte main_button;     /* scrollpos_y */

   347

	byte action_id;

   348

	StringID string_id;   /* unk30 */

   349

	uint16 checked_items; /* unk32 */

   350

	byte disabled_items;

   351

} menu_d;

   352

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   353

   354

typedef struct {

   355

	int16 data_1, data_2, data_3;

   356

	int16 data_4, data_5;

   357

	bool close;

   358

	byte byte_1;

   359

} def_d;

   360

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   361

   362

typedef struct {

   363

	void *data;

   364

} void_d;

   365

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   366

   367

typedef struct {

   368

	uint16 base;

   369

	uint16 count;

   370

} tree_d;

   371

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   372

   373

typedef struct {

   374

	StringID string_id;

   375

} tooltips_d;

   376

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   377

   378

typedef struct {

   379

	byte railtype;

   380

	byte sel_index;

   381

	EngineID sel_engine;

   382

	EngineID rename_engine;

   383

} buildtrain_d;

   384

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildtrain_d));

   385

   386

typedef struct {

   387

	byte vehicletype;

   388

	byte sel_index[2];

   389

	EngineID sel_engine[2];

   390

	uint16 count[2];

   391

	bool wagon_btnstate; // true means engine is selected

   392

} replaceveh_d;

   393

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   394

   395

typedef struct {

   396

	VehicleID sel;

   397

	byte type;

   398

	uint16 engine_list_length;

   399

	uint16 wagon_list_length;

   400

	uint16 engine_count;

   401

	uint16 wagon_count;

   402

	Vehicle **vehicle_list;

   403

	Vehicle **wagon_list;

   404

} depot_d;

   405

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   406

   407

typedef struct {

   408

	int sel;

   409

} order_d;

   410

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   411

   412

typedef struct {

   413

	byte tab;

   414

} traindetails_d;

   415

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   416

   417

typedef struct {

   418

	int32 scroll_x;

   419

	int32 scroll_y;

   420

	int32 subscroll;

   421

} smallmap_d;

   422

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   423

   424

typedef struct {

   425

	uint32 face;

   426

	byte gender;

   427

} facesel_d;

   428

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   429

   430

typedef struct {

   431

	int sel;

   432

	CargoID cargo;

   433

} refit_d;

   434

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   435

   436

typedef struct {

   437

	VehicleID follow_vehicle;

   438

	int32 scrollpos_x;

   439

	int32 scrollpos_y;

   440

} vp_d;

   441

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d) + 3 * sizeof(byte)); // + 3 * byte is a hack from Miham

   442

   443

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

   444

typedef struct {

   445

	uint16 follow_vehicle;

   446

	int32 scrollpos_x;

   447

	int32 scrollpos_y;

   448

	byte data_1;

   449

	byte data_2;

   450

	byte data_3;

   451

} vp2_d;

   452

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp2_d));

   453

   454

typedef struct {

   455

	uint16 follow_vehicle;

   456

	int32 scrollpos_x;

   457

	int32 scrollpos_y;

   458

	NewsItem *ni;

   459

} news_d;

   460

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   461

   462

typedef struct {

   463

	uint32 background_img;

   464

	int8 rank;

   465

} highscore_d;

   466

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   467

   468

typedef struct {

   469

	int height;

   470

	uint16 counter;

   471

} scroller_d;

   472

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   473

   474

typedef enum SortListFlags {

   475

	VL_DESC    = 0x01,  // sort descending or ascending

   476

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

   477

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

   478

} SortListFlags;

   479

   480

typedef struct Listing {

   481

	bool order;    // Ascending/descending

   482

	byte criteria; // Sorting criteria

   483

} Listing;

   484

   485

typedef struct list_d {

   486

	uint16 list_length;  // length of the list being sorted

   487

	byte sort_type;      // what criteria to sort on

   488

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

   489

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

   490

} list_d;

   491

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   492

   493

typedef struct message_d {

   494

	int msg;