1

/* $Id$ */

     2

     3

#ifndef WINDOW_H

     4

#define WINDOW_H

     5

     6

#include "macros.h"

     7

#include "string.h"

     8

#include "order.h"

     9

    10

typedef struct WindowEvent WindowEvent;

    11

    12

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

    13

    14

/* How the resize system works:

    15

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

    16

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

    17

     to resize itself.

    18

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

    19

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

    20

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

    21

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

    22

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

    23

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

    24

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

    25

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

    26

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

    27

     widgets moves downwards without resizing, and appears to be clamped

    28

     to the bottom. Nice aint it?

    29

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

    30

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

    31

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

    32

    after making the window, like this:

    33

      w->resize.step_height = 10;

    34

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

    35

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

    36

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

    37

    AFTER window-creation, with:

    38

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

    39

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

    40

    41

enum ResizeFlags {

    42

	RESIZE_NONE   = 0,

    43

    44

	RESIZE_LEFT   = 1,

    45

	RESIZE_RIGHT  = 2,

    46

	RESIZE_TOP    = 4,

    47

	RESIZE_BOTTOM = 8,

    48

    49

	RESIZE_LR     = RESIZE_LEFT  | RESIZE_RIGHT,

    50

	RESIZE_RB     = RESIZE_RIGHT | RESIZE_BOTTOM,

    51

	RESIZE_TB     = RESIZE_TOP   | RESIZE_BOTTOM,

    52

	RESIZE_LRB    = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_BOTTOM,

    53

	RESIZE_LRTB   = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_TOP | RESIZE_BOTTOM,

    54

	RESIZE_RTB    = RESIZE_RIGHT | RESIZE_TOP    | RESIZE_BOTTOM,

    55

} ResizeFlag;

    56

    57

typedef struct Widget {

    58

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

    59

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

    60

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

    61

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

    62

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

    63

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

    64

} Widget;

    65

    66

typedef enum FrameFlags {

    67

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

    68

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

    69

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

    70

	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)

    71

} FrameFlags;

    72

    73

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

    74

    75

enum WindowEventCodes {

    76

	WE_CLICK               =  0,

    77

	WE_PAINT               =  1,

    78

	WE_MOUSELOOP           =  2,

    79

	WE_TICK                =  3,

    80

	WE_4                   =  4,

    81

	WE_TIMEOUT             =  5,

    82

	WE_PLACE_OBJ           =  6,

    83

	WE_ABORT_PLACE_OBJ     =  7,

    84

	WE_DESTROY             =  8,

    85

	WE_ON_EDIT_TEXT        =  9,

    86

	WE_POPUPMENU_SELECT    = 10,

    87

	WE_POPUPMENU_OVER      = 11,

    88

	WE_DRAGDROP            = 12,

    89

	WE_PLACE_DRAG          = 13,

    90

	WE_PLACE_MOUSEUP       = 14,

    91

	WE_PLACE_PRESIZE       = 15,

    92

	WE_DROPDOWN_SELECT     = 16,

    93

	WE_RCLICK              = 17,

    94

	WE_KEYPRESS            = 18,

    95

	WE_CREATE              = 19,

    96

	WE_MOUSEOVER           = 20,

    97

	WE_ON_EDIT_TEXT_CANCEL = 21,

    98

	WE_RESIZE              = 22,

    99

	WE_MESSAGE             = 23,

   100

	WE_SCROLL              = 24,

   101

	WE_MOUSEWHEEL          = 25,

   102

};

   103

   104

struct WindowEvent {

   105

	byte event;

   106

	union {

   107

		struct{

   108

			Point pt;

   109

			int widget;

   110

		} click;

   111

   112

		struct {

   113

			Point pt;

   114

			TileIndex tile;

   115

			TileIndex starttile;

   116

			int userdata;

   117

		} place;

   118

   119

		struct {

   120

			Point pt;

   121

			int widget;

   122

		} dragdrop;

   123

   124

		struct {

   125

			Point size;

   126

			Point diff;

   127

		} sizing;

   128

   129

		struct {

   130

			char *str;

   131

		} edittext;

   132

   133

		struct {

   134

			Point pt;

   135

		} popupmenu;

   136

   137

		struct {

   138

			int button;

   139

			int index;

   140

		} dropdown;

   141

   142

		struct {

   143

			Point pt;

   144

			int widget;

   145

		} mouseover;

   146

   147

		struct {

   148

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

   149

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

   150

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

   151

		} keypress;

   152

   153

		struct {

   154

			uint msg;      // message to be sent

   155

			uint wparam;   // additional message-specific information

   156

			uint lparam;   // additional message-specific information

   157

		} message;

   158

   159

		struct {

   160

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

   161

		} scroll;

   162

   163

		struct {

   164

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

   165

		} wheel;

   166

	} we;

   167

};

   168

   169

enum WindowKeyCodes {

   170

	WKC_SHIFT = 0x8000,

   171

	WKC_CTRL  = 0x4000,

   172

	WKC_ALT   = 0x2000,

   173

	WKC_META  = 0x1000,

   174

   175

	// Special ones

   176

	WKC_NONE        =  0,

   177

	WKC_ESC         =  1,

   178

	WKC_BACKSPACE   =  2,

   179

	WKC_INSERT      =  3,

   180

	WKC_DELETE      =  4,

   181

   182

	WKC_PAGEUP      =  5,

   183

	WKC_PAGEDOWN    =  6,

   184

	WKC_END         =  7,

   185

	WKC_HOME        =  8,

   186

   187

	// Arrow keys

   188

	WKC_LEFT        =  9,

   189

	WKC_UP          = 10,

   190

	WKC_RIGHT       = 11,

   191

	WKC_DOWN        = 12,

   192

   193

	// Return & tab

   194

	WKC_RETURN      = 13,

   195

	WKC_TAB         = 14,

   196

   197

	// Numerical keyboard

   198

	WKC_NUM_0       = 16,

   199

	WKC_NUM_1       = 17,

   200

	WKC_NUM_2       = 18,

   201

	WKC_NUM_3       = 19,

   202

	WKC_NUM_4       = 20,

   203

	WKC_NUM_5       = 21,

   204

	WKC_NUM_6       = 22,

   205

	WKC_NUM_7       = 23,

   206

	WKC_NUM_8       = 24,

   207

	WKC_NUM_9       = 25,

   208

	WKC_NUM_DIV     = 26,

   209

	WKC_NUM_MUL     = 27,

   210

	WKC_NUM_MINUS   = 28,

   211

	WKC_NUM_PLUS    = 29,

   212

	WKC_NUM_ENTER   = 30,

   213

	WKC_NUM_DECIMAL = 31,

   214

   215

	// Space

   216

	WKC_SPACE       = 32,

   217

   218

	// Function keys

   219

	WKC_F1          = 33,

   220

	WKC_F2          = 34,

   221

	WKC_F3          = 35,

   222

	WKC_F4          = 36,

   223

	WKC_F5          = 37,

   224

	WKC_F6          = 38,

   225

	WKC_F7          = 39,

   226

	WKC_F8          = 40,

   227

	WKC_F9          = 41,

   228

	WKC_F10         = 42,

   229

	WKC_F11         = 43,

   230

	WKC_F12         = 44,

   231

   232

	// backquote is the key left of "1"

   233

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

   234

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

   235

	WKC_BACKQUOTE   = 45,

   236

	WKC_PAUSE       = 46,

   237

   238

	// 0-9 are mapped to 48-57

   239

	// A-Z are mapped to 65-90

   240

	// a-z are mapped to 97-122

   241

};

   242

   243

typedef struct WindowDesc {

   244

	int16 left, top, width, height;

   245

	WindowClass cls;

   246

	WindowClass parent_cls;

   247

	uint32 flags;

   248

	const Widget *widgets;

   249

	WindowProc *proc;

   250

} WindowDesc;

   251

   252

enum {

   253

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

   254

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

   255

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

   256

   257

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

   258

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

   259

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

   260

};

   261

   262

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

   263

enum {

   264

	WDP_AUTO   = -1,

   265

	WDP_CENTER = -2,

   266

};

   267

   268

typedef struct Textbuf {

   269

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

   270

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

   271

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

   272

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

   273

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

   274

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

   275

} Textbuf;

   276

   277

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

   278

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

   279

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

   280

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

   281

#define WINDOW_CUSTOM_SIZE 96

   282

   283

typedef struct Scrollbar {

   284

	uint16 count, cap, pos;

   285

} Scrollbar;

   286

   287

typedef struct ResizeInfo {

   288

	uint width; /* Minimum width and height */

   289

	uint height;

   290

   291

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

   292

	uint step_height;

   293

} ResizeInfo;

   294

   295

typedef struct WindowMessage {

   296

		int msg;

   297

		int wparam;

   298

		int lparam;

   299

} WindowMessage;

   300

   301

struct Window {

   302

	uint16 flags4;

   303

	WindowClass window_class;

   304

	WindowNumber window_number;

   305

   306

	int left, top;

   307

	int width, height;

   308

   309

	Scrollbar hscroll, vscroll, vscroll2;

   310

	ResizeInfo resize;

   311

   312

	byte caption_color;

   313

   314

	uint32 click_state, disabled_state, hidden_state;

   315

	WindowProc *wndproc;

   316

	ViewPort *viewport;

   317

	const Widget *original_widget;

   318

	Widget *widget;

   319

	uint32 desc_flags;

   320

   321

	WindowMessage message;

   322

	byte custom[WINDOW_CUSTOM_SIZE];

   323

};

   324

   325

typedef struct querystr_d {

   326

	StringID caption;

   327

	WindowClass wnd_class;

   328

	WindowNumber wnd_num;

   329

	Textbuf text;

   330

	const char *orig;

   331

	CharSetFilter afilter;

   332

} querystr_d;

   333

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d));

   334

   335

typedef struct query_d {

   336

	StringID caption;

   337

	StringID message;

   338

	WindowClass wnd_class;

   339

	WindowNumber wnd_num;

   340

	void (*ok_cancel_callback)(bool ok_clicked);

   341

	bool calledback;

   342

} query_d;

   343

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(query_d));

   344

   345

typedef struct {

   346

	byte item_count;      /* follow_vehicle */

   347

	byte sel_index;       /* scrollpos_x */

   348

	byte main_button;     /* scrollpos_y */

   349

	byte action_id;

   350

	StringID string_id;   /* unk30 */

   351

	uint16 checked_items; /* unk32 */

   352

	byte disabled_items;

   353

} menu_d;

   354

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   355

   356

typedef struct {

   357

	int16 data_1, data_2, data_3;

   358

	int16 data_4, data_5;

   359

	bool close;

   360

	byte byte_1;

   361

} def_d;

   362

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   363

   364

typedef struct {

   365

	void *data;

   366

} void_d;

   367

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   368

   369

typedef struct {

   370

	uint16 base;

   371

	uint16 count;

   372

} tree_d;

   373

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   374

   375

typedef struct {

   376

	StringID string_id;

   377

} tooltips_d;

   378

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   379

   380

typedef struct {

   381

	byte railtype;

   382

	byte sel_index;

   383

	EngineID sel_engine;

   384

	EngineID rename_engine;

   385

} buildtrain_d;

   386

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildtrain_d));

   387

   388

typedef struct {

   389

	byte vehicletype;

   390

	byte sel_index[2];

   391

	EngineID sel_engine[2];

   392

	uint16 count[2];

   393

	bool wagon_btnstate; // true means engine is selected

   394

} replaceveh_d;

   395

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   396

   397

typedef struct {

   398

	VehicleID sel;

   399

	byte type;

   400

	uint16 engine_list_length;

   401

	uint16 wagon_list_length;

   402

	uint16 engine_count;

   403

	uint16 wagon_count;

   404

	Vehicle **vehicle_list;

   405

	Vehicle **wagon_list;

   406

} depot_d;

   407

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   408

   409

typedef struct {

   410

	int sel;

   411

} order_d;

   412

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   413

   414

typedef struct {

   415

	byte tab;

   416

} traindetails_d;

   417

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   418

   419

typedef struct {

   420

	int32 scroll_x;

   421

	int32 scroll_y;

   422

	int32 subscroll;

   423

} smallmap_d;

   424

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   425

   426

typedef struct {

   427

	uint32 face;

   428

	byte gender;

   429

} facesel_d;

   430

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   431

   432

typedef struct {

   433

	int sel;

   434

	struct RefitOption *cargo;

   435

	struct RefitList *list;

   436

	uint length;

   437

	VehicleOrderID order;

   438

} refit_d;

   439

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   440

   441

typedef struct {

   442

	VehicleID follow_vehicle;

   443

	int32 scrollpos_x;

   444

	int32 scrollpos_y;

   445

} vp_d;

   446

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

   447

   448

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

   449

typedef struct {

   450

	uint16 follow_vehicle;

   451

	int32 scrollpos_x;

   452

	int32 scrollpos_y;

   453

	byte data_1;

   454

	byte data_2;

   455

	byte data_3;

   456

} vp2_d;

   457

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp2_d));

   458

   459

typedef struct {

   460

	uint16 follow_vehicle;

   461

	int32 scrollpos_x;

   462

	int32 scrollpos_y;

   463

	NewsItem *ni;

   464

} news_d;

   465

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   466

   467

typedef struct {

   468

	uint32 background_img;

   469

	int8 rank;

   470

} highscore_d;

   471

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   472

   473

typedef struct {

   474

	int height;

   475

	uint16 counter;

   476

} scroller_d;

   477

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   478

   479

typedef enum SortListFlags {

   480

	VL_DESC    = 0x01,  // sort descending or ascending

   481

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

   482

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

   483

} SortListFlags;

   484

   485

typedef struct Listing {

   486

	bool order;    // Ascending/descending

   487

	byte criteria; // Sorting criteria

   488

} Listing;

   489

   490

typedef struct list_d {

   491

	uint16 list_length;  // length of the list being sorted

   492

	byte sort_type;      // what criteria to sort on

   493

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

   494

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