1

/* $Id$ */

     2

     3

#ifndef WINDOW_H

     4

#define WINDOW_H

     5

     6

#include "string.h"

     7

     8

typedef union 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

/* XXX - outside "byte event" so you can set event directly without going into

    74

 * the union elements at first. Because of this every first element of the union

    75

 * MUST BE 'byte event'. Whoever did this must get shot! Scheduled for immediate

    76

 * rewrite after 0.4.0 */

    77

union WindowEvent {

    78

	byte event;

    79

	struct {

    80

		byte event;

    81

		Point pt;

    82

		int widget;

    83

	} click;

    84

    85

	struct {

    86

		byte event;

    87

		Point pt;

    88

		TileIndex tile;

    89

		TileIndex starttile;

    90

		int userdata;

    91

	} place;

    92

    93

	struct {

    94

		byte event;

    95

		Point pt;

    96

		int widget;

    97

	} dragdrop;

    98

    99

	struct {

   100

		byte event;

   101

		Point size;

   102

		Point diff;

   103

	} sizing;

   104

   105

	struct {

   106

		byte event;

   107

		char *str;

   108

	} edittext;

   109

   110

	struct {

   111

		byte event;

   112

		Point pt;

   113

	} popupmenu;

   114

   115

	struct {

   116

		byte event;

   117

		int button;

   118

		int index;

   119

	} dropdown;

   120

   121

	struct {

   122

		byte event;

   123

		Point pt;

   124

		int widget;

   125

	} mouseover;

   126

   127

	struct {

   128

		byte event;

   129

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

   130

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

   131

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

   132

	} keypress;

   133

   134

	struct {

   135

		byte event;

   136

		uint msg;    // message to be sent

   137

		uint wparam; // additional message-specific information

   138

		uint lparam; // additional message-specific information

   139

	} message;

   140

   141

	struct {

   142

		byte event;

   143

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

   144

	} scroll;

   145

   146

	struct {

   147

		byte event;

   148

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

   149

	} wheel;

   150

};

   151

   152

enum WindowKeyCodes {

   153

	WKC_SHIFT = 0x8000,

   154

	WKC_CTRL  = 0x4000,

   155

	WKC_ALT   = 0x2000,

   156

	WKC_META  = 0x1000,

   157

   158

	// Special ones

   159

	WKC_NONE        =  0,

   160

	WKC_ESC         =  1,

   161

	WKC_BACKSPACE   =  2,

   162

	WKC_INSERT      =  3,

   163

	WKC_DELETE      =  4,

   164

   165

	WKC_PAGEUP      =  5,

   166

	WKC_PAGEDOWN    =  6,

   167

	WKC_END         =  7,

   168

	WKC_HOME        =  8,

   169

   170

	// Arrow keys

   171

	WKC_LEFT        =  9,

   172

	WKC_UP          = 10,

   173

	WKC_RIGHT       = 11,

   174

	WKC_DOWN        = 12,

   175

   176

	// Return & tab

   177

	WKC_RETURN      = 13,

   178

	WKC_TAB         = 14,

   179

   180

	// Numerical keyboard

   181

	WKC_NUM_0       = 16,

   182

	WKC_NUM_1       = 17,

   183

	WKC_NUM_2       = 18,

   184

	WKC_NUM_3       = 19,

   185

	WKC_NUM_4       = 20,

   186

	WKC_NUM_5       = 21,

   187

	WKC_NUM_6       = 22,

   188

	WKC_NUM_7       = 23,

   189

	WKC_NUM_8       = 24,

   190

	WKC_NUM_9       = 25,

   191

	WKC_NUM_DIV     = 26,

   192

	WKC_NUM_MUL     = 27,

   193

	WKC_NUM_MINUS   = 28,

   194

	WKC_NUM_PLUS    = 29,

   195

	WKC_NUM_ENTER   = 30,

   196

	WKC_NUM_DECIMAL = 31,

   197

   198

	// Space

   199

	WKC_SPACE       = 32,

   200

   201

	// Function keys

   202

	WKC_F1          = 33,

   203

	WKC_F2          = 34,

   204

	WKC_F3          = 35,

   205

	WKC_F4          = 36,

   206

	WKC_F5          = 37,

   207

	WKC_F6          = 38,

   208

	WKC_F7          = 39,

   209

	WKC_F8          = 40,

   210

	WKC_F9          = 41,

   211

	WKC_F10         = 42,

   212

	WKC_F11         = 43,

   213

	WKC_F12         = 44,

   214

   215

	// backquote is the key left of "1"

   216

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

   217

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

   218

	WKC_BACKQUOTE   = 45,

   219

	WKC_PAUSE       = 46,

   220

   221

	// 0-9 are mapped to 48-57

   222

	// A-Z are mapped to 65-90

   223

	// a-z are mapped to 97-122

   224

};

   225

   226

typedef struct WindowDesc {

   227

	int16 left, top, width, height;

   228

	WindowClass cls;

   229

	WindowClass parent_cls;

   230

	uint32 flags;

   231

	const Widget *widgets;

   232

	WindowProc *proc;

   233

} WindowDesc;

   234

   235

enum {

   236

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

   237

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

   238

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

   239

   240

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

   241

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

   242

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

   243

};

   244

   245

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

   246

enum {

   247

	WDP_AUTO   = -1,

   248

	WDP_CENTER = -2,

   249

};

   250

   251

typedef struct Textbuf {

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

} Textbuf;

   259

   260

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

   261

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

   262

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

   263

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

   264

#define WINDOW_CUSTOM_SIZE 96

   265

   266

typedef struct Scrollbar {

   267

	uint16 count, cap, pos;

   268

} Scrollbar;

   269

   270

typedef struct ResizeInfo {

   271

	uint width; /* Minimum width and height */

   272

	uint height;

   273

   274

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

   275

	uint step_height;

   276

} ResizeInfo;

   277

   278

typedef struct WindowMessage {

   279

		int msg;

   280

		int wparam;

   281

		int lparam;

   282

} WindowMessage;

   283

   284

struct Window {

   285

	uint16 flags4;

   286

	WindowClass window_class;

   287

	WindowNumber window_number;

   288

   289

	int left, top;

   290

	int width, height;

   291

   292

	Scrollbar hscroll, vscroll, vscroll2;

   293

	ResizeInfo resize;

   294

   295

	byte caption_color;

   296

   297

	uint32 click_state, disabled_state, hidden_state;

   298

	WindowProc *wndproc;

   299

	ViewPort *viewport;

   300

	const Widget *original_widget;

   301

	Widget *widget;

   302

	uint32 desc_flags;

   303

   304

	WindowMessage message;

   305

	byte custom[WINDOW_CUSTOM_SIZE];

   306

};

   307

   308

typedef struct querystr_d {

   309

	StringID caption;

   310

	WindowClass wnd_class;

   311

	WindowNumber wnd_num;

   312

	Textbuf text;

   313

	const char *orig;

   314

	CharSetFilter afilter;

   315

} querystr_d;

   316

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d));

   317

   318

typedef struct query_d {

   319

	StringID caption;

   320

	StringID message;

   321

	WindowClass wnd_class;

   322

	WindowNumber wnd_num;

   323

	void (*ok_cancel_callback)(bool ok_clicked);

   324

	bool calledback;

   325

} query_d;

   326

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(query_d));

   327

   328

typedef struct {

   329

	byte item_count;      /* follow_vehicle */

   330

	byte sel_index;       /* scrollpos_x */

   331

	byte main_button;     /* scrollpos_y */

   332

	byte action_id;

   333

	StringID string_id;   /* unk30 */

   334

	uint16 checked_items; /* unk32 */

   335

	byte disabled_items;

   336

} menu_d;

   337

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   338

   339

typedef struct {

   340

	int16 data_1, data_2, data_3;

   341

	int16 data_4, data_5;

   342

	bool close;

   343

	byte byte_1;

   344

} def_d;

   345

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   346

   347

typedef struct {

   348

	void *data;

   349

} void_d;

   350

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   351

   352

typedef struct {

   353

	uint16 base;

   354

	uint16 count;

   355

} tree_d;

   356

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   357

   358

typedef struct {

   359

	StringID string_id;

   360

} tooltips_d;

   361

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   362

   363

typedef struct {

   364

	byte railtype;

   365

	byte sel_index;

   366

	EngineID sel_engine;

   367

	EngineID rename_engine;

   368

} buildtrain_d;

   369

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildtrain_d));

   370

   371

typedef struct {

   372

	byte vehicletype;

   373

	byte sel_index[2];

   374

	EngineID sel_engine[2];

   375

	uint16 count[2];

   376

	bool wagon_btnstate; // true means engine is selected

   377

} replaceveh_d;

   378

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   379

   380

typedef struct {

   381

	VehicleID sel;

   382

} traindepot_d;

   383

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindepot_d));

   384

   385

typedef struct {

   386

	int sel;

   387

} order_d;

   388

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   389

   390

typedef struct {

   391

	byte tab;

   392

} traindetails_d;

   393

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   394

   395

typedef struct {

   396

	int32 scroll_x;

   397

	int32 scroll_y;

   398

	int32 subscroll;

   399

} smallmap_d;

   400

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   401

   402

typedef struct {

   403

	uint32 face;

   404

	byte gender;

   405

} facesel_d;

   406

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   407

   408

typedef struct {

   409

	int sel;

   410

	CargoID cargo;

   411

} refit_d;

   412

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   413

   414

typedef struct {

   415

	VehicleID follow_vehicle;

   416

	int32 scrollpos_x;

   417

	int32 scrollpos_y;

   418

} vp_d;

   419

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

   420

   421

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

   422

typedef struct {

   423

	uint16 follow_vehicle;

   424

	int32 scrollpos_x;

   425

	int32 scrollpos_y;

   426

	byte data_1;

   427

	byte data_2;

   428

	byte data_3;

   429

} vp2_d;

   430

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp2_d));

   431

   432

typedef struct {

   433

	uint16 follow_vehicle;

   434

	int32 scrollpos_x;

   435

	int32 scrollpos_y;

   436

	NewsItem *ni;

   437

} news_d;

   438

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   439

   440

typedef struct {

   441

	uint32 background_img;

   442

	int8 rank;

   443

} highscore_d;

   444

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   445

   446

typedef struct {

   447

	int height;

   448

	uint16 counter;

   449

} scroller_d;

   450

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   451

   452

typedef enum SortListFlags {

   453

	VL_DESC    = 0x01,  // sort descending or ascending

   454

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

   455

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

   456

} SortListFlags;

   457

   458

typedef struct Listing {

   459

	bool order;    // Ascending/descending

   460

	byte criteria; // Sorting criteria

   461

} Listing;

   462

   463

typedef struct list_d {

   464

	uint16 list_length;  // length of the list being sorted

   465

	byte sort_type;      // what criteria to sort on

   466

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

   467

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

   468

} list_d;

   469

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   470

   471

typedef struct message_d {

   472

	int msg;

   473

	int wparam;

   474

	int lparam;

   475

} message_d;

   476

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   477

   478

typedef struct dropdown_d {

   479

	uint32 disabled_state;

   480

	uint32 hidden_state;

   481

	WindowClass parent_wnd_class;

   482

	WindowNumber parent_wnd_num;

   483

	byte parent_button;

   484

	byte num_items;

   485

	byte selected_index;

   486

	const StringID *items;

   487

	byte click_delay;

   488

	bool drag_mode;

   489

} dropdown_d;

   490

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(dropdown_d));

   491

   492

enum WindowEvents {

   493

	WE_CLICK               =  0,

   494

	WE_PAINT               =  1,

   495

	WE_MOUSELOOP           =  2,

   496

	WE_TICK                =  3,

   497

	WE_4                   =  4,