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 {

    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

};

    54

    55

typedef struct Widget {

    56

	byte type;

    57

	byte resize_flag;

    58

	byte color;

    59

	uint16 left, right, top, bottom;

    60

	uint16 unkA;

    61

	StringID tooltips;

    62

} Widget;

    63

    64

enum FrameFlags {

    65

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

    66

	FR_NOBORDER     = 0x08,  ///< Hide border (draws just a solid box)

    67

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

    68

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

    69

	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)

    70

};

    71

    72

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

    73

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

    74

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

    75

 * rewrite after 0.4.0 */

    76

union WindowEvent {

    77

	byte event;

    78

	struct {

    79

		byte event;

    80

		Point pt;

    81

		int widget;

    82

	} click;

    83

    84

	struct {

    85

		byte event;

    86

		Point pt;

    87

		TileIndex tile;

    88

		TileIndex starttile;

    89

		int userdata;

    90

	} place;

    91

    92

	struct {

    93

		byte event;

    94

		Point pt;

    95

		int widget;

    96

	} dragdrop;

    97

    98

	struct {

    99

		byte event;

   100

		Point size;

   101

		Point diff;

   102

	} sizing;

   103

   104

	struct {

   105

		byte event;

   106

		char *str;

   107

	} edittext;

   108

   109

	struct {

   110

		byte event;

   111

		Point pt;

   112

	} popupmenu;

   113

   114

	struct {

   115

		byte event;

   116

		int button;

   117

		int index;

   118

	} dropdown;

   119

   120

	struct {

   121

		byte event;

   122

		Point pt;

   123

		int widget;

   124

	} mouseover;

   125

   126

	struct {

   127

		byte event;

   128

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

   129

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

   130

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

   131

	} keypress;

   132

   133

	struct {

   134

		byte event;

   135

		uint msg;    // message to be sent

   136

		uint wparam; // additional message-specific information

   137

		uint lparam; // additional message-specific information

   138

	} message;

   139

   140

	struct {

   141

		byte event;

   142

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

   143

	} scroll;

   144

   145

	struct {

   146

		byte event;

   147

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

   148

	} wheel;

   149

};

   150

   151

enum WindowKeyCodes {

   152

	WKC_SHIFT = 0x8000,

   153

	WKC_CTRL  = 0x4000,

   154

	WKC_ALT   = 0x2000,

   155

	WKC_META  = 0x1000,

   156

   157

	// Special ones

   158

	WKC_NONE        =  0,

   159

	WKC_ESC         =  1,

   160

	WKC_BACKSPACE   =  2,

   161

	WKC_INSERT      =  3,

   162

	WKC_DELETE      =  4,

   163

   164

	WKC_PAGEUP      =  5,

   165

	WKC_PAGEDOWN    =  6,

   166

	WKC_END         =  7,

   167

	WKC_HOME        =  8,

   168

   169

	// Arrow keys

   170

	WKC_LEFT        =  9,

   171

	WKC_UP          = 10,

   172

	WKC_RIGHT       = 11,

   173

	WKC_DOWN        = 12,

   174

   175

	// Return & tab

   176

	WKC_RETURN      = 13,

   177

	WKC_TAB         = 14,

   178

   179

	// Numerical keyboard

   180

	WKC_NUM_0       = 16,

   181

	WKC_NUM_1       = 17,

   182

	WKC_NUM_2       = 18,

   183

	WKC_NUM_3       = 19,

   184

	WKC_NUM_4       = 20,

   185

	WKC_NUM_5       = 21,

   186

	WKC_NUM_6       = 22,

   187

	WKC_NUM_7       = 23,

   188

	WKC_NUM_8       = 24,

   189

	WKC_NUM_9       = 25,

   190

	WKC_NUM_DIV     = 26,

   191

	WKC_NUM_MUL     = 27,

   192

	WKC_NUM_MINUS   = 28,

   193

	WKC_NUM_PLUS    = 29,

   194

	WKC_NUM_ENTER   = 30,

   195

	WKC_NUM_DECIMAL = 31,

   196

   197

	// Space

   198

	WKC_SPACE       = 32,

   199

   200

	// Function keys

   201

	WKC_F1          = 33,

   202

	WKC_F2          = 34,

   203

	WKC_F3          = 35,

   204

	WKC_F4          = 36,

   205

	WKC_F5          = 37,

   206

	WKC_F6          = 38,

   207

	WKC_F7          = 39,

   208

	WKC_F8          = 40,

   209

	WKC_F9          = 41,

   210

	WKC_F10         = 42,

   211

	WKC_F11         = 43,

   212

	WKC_F12         = 44,

   213

   214

	// backquote is the key left of "1"

   215

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

   216

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

   217

	WKC_BACKQUOTE   = 45,

   218

	WKC_PAUSE       = 46,

   219

   220

	// 0-9 are mapped to 48-57

   221

	// A-Z are mapped to 65-90

   222

	// a-z are mapped to 97-122

   223

};

   224

   225

typedef struct WindowDesc {

   226

	int16 left, top, width, height;

   227

	WindowClass cls;

   228

	WindowClass parent_cls;

   229

	uint32 flags;

   230

	const Widget *widgets;

   231

	WindowProc *proc;

   232

} WindowDesc;

   233

   234

enum {

   235

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

   236

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

   237

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

   238

   239

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

   240

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

   241

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

   242

};

   243

   244

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

   245

enum {

   246

	WDP_AUTO   = -1,

   247

	WDP_CENTER = -2,

   248

};

   249

   250

typedef struct Textbuf {

   251

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

   252

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

   253

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

   254

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

   255

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

   256

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

   257

} Textbuf;

   258

   259

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

   260

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

   261

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

   262

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

   263

#define WINDOW_CUSTOM_SIZE 96

   264

   265

typedef struct Scrollbar {

   266

	uint16 count, cap, pos;

   267

} Scrollbar;

   268

   269

typedef struct ResizeInfo {

   270

	uint width; /* Minimum width and height */

   271

	uint height;

   272

   273

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

   274

	uint step_height;

   275

} ResizeInfo;

   276

   277

typedef struct WindowMessage {

   278

		int msg;

   279

		int wparam;

   280

		int lparam;

   281

} WindowMessage;

   282

   283

struct Window {

   284

	uint16 flags4;

   285

	WindowClass window_class;

   286

	WindowNumber window_number;

   287

   288

	int left, top;

   289

	int width, height;

   290

   291

	Scrollbar hscroll, vscroll, vscroll2;

   292

	ResizeInfo resize;

   293

   294

	byte caption_color;

   295

   296

	uint32 click_state, disabled_state, hidden_state;

   297

	WindowProc *wndproc;

   298

	ViewPort *viewport;

   299

	const Widget *original_widget;

   300

	Widget *widget;

   301

	uint32 desc_flags;

   302

   303

	WindowMessage message;

   304

	byte custom[WINDOW_CUSTOM_SIZE];

   305

};

   306

   307

typedef struct querystr_d {

   308

	StringID caption;

   309

	WindowClass wnd_class;

   310

	WindowNumber wnd_num;

   311

	Textbuf text;

   312

	const char *orig;

   313

	CharSetFilter afilter;

   314

} querystr_d;

   315

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d));

   316

   317

typedef struct query_d {

   318

	StringID caption;

   319

	StringID message;

   320

	WindowClass wnd_class;

   321

	WindowNumber wnd_num;

   322

	void (*ok_cancel_callback)(bool ok_clicked);

   323

	bool calledback;

   324

} query_d;

   325

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(query_d));

   326

   327

typedef struct {

   328

	byte item_count;      /* follow_vehicle */

   329

	byte sel_index;       /* scrollpos_x */

   330

	byte main_button;     /* scrollpos_y */

   331

	byte action_id;

   332

	StringID string_id;   /* unk30 */

   333

	uint16 checked_items; /* unk32 */

   334

	byte disabled_items;

   335

} menu_d;

   336

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   337

   338

typedef struct {

   339

	int16 data_1, data_2, data_3;

   340

	int16 data_4, data_5;

   341

	bool close;

   342

	byte byte_1;

   343

} def_d;

   344

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   345

   346

typedef struct {

   347

	void *data;

   348

} void_d;

   349

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   350

   351

typedef struct {

   352

	uint16 base;

   353

	uint16 count;

   354

} tree_d;

   355

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   356

   357

typedef struct {

   358

	StringID string_id;

   359

} tooltips_d;

   360

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   361

   362

typedef struct {

   363

	byte railtype;

   364

	byte sel_index;

   365

	EngineID sel_engine;

   366

	EngineID rename_engine;

   367

} buildtrain_d;

   368

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildtrain_d));

   369

   370

typedef struct {

   371

	byte vehicletype;

   372

	byte sel_index[2];

   373

	EngineID sel_engine[2];

   374

	uint16 count[2];

   375

	bool wagon_btnstate;	// true means engine is selected

   376

} replaceveh_d;

   377

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   378

   379

typedef struct {

   380

	VehicleID sel;

   381

} traindepot_d;

   382

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindepot_d));

   383

   384

typedef struct {

   385

	int sel;

   386

} order_d;

   387

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   388

   389

typedef struct {

   390

	byte tab;

   391

} traindetails_d;

   392

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   393

   394

typedef struct {

   395

	int32 scroll_x;

   396

	int32 scroll_y;

   397

	int32 subscroll;

   398

} smallmap_d;

   399

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   400

   401

typedef struct {

   402

	uint32 face;

   403

	byte gender;

   404

} facesel_d;

   405

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   406

   407

typedef struct {

   408

	int sel;

   409

	CargoID cargo;

   410

} refit_d;

   411

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   412

   413

typedef struct {

   414

	VehicleID follow_vehicle;

   415

	int32 scrollpos_x;

   416

	int32 scrollpos_y;

   417

} vp_d;

   418

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

   419

   420

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

   421

typedef struct {

   422

	uint16 follow_vehicle;

   423

	int32 scrollpos_x;

   424

	int32 scrollpos_y;

   425

	byte data_1;

   426

	byte data_2;

   427

	byte data_3;

   428

} vp2_d;

   429

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp2_d));

   430

   431

typedef struct {

   432

	uint16 follow_vehicle;

   433

	int32 scrollpos_x;

   434

	int32 scrollpos_y;

   435

	NewsItem *ni;

   436

} news_d;

   437

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   438

   439

typedef struct {

   440

	uint32 background_img;

   441

	int8 rank;

   442

} highscore_d;

   443

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   444

   445

typedef struct {

   446

	int height;

   447

	uint16 counter;

   448

} scroller_d;

   449

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   450

   451

typedef enum VehicleListFlags {

   452

	VL_DESC    = 0x01,  // sort descending or ascending

   453

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

   454

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

   455

} VehicleListFlags;

   456

   457

typedef struct vehiclelist_d {

   458

	const Vehicle** sort_list;

   459

	uint16 list_length;

   460

	byte sort_type;

   461

	VehicleListFlags flags;

   462

	uint16 resort_timer;

   463

} vehiclelist_d;

   464

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehiclelist_d));

   465

   466

typedef struct list_d {

   467

	uint16 list_length;    // length of the list being sorted

   468

	byte sort_type;        // what criteria to sort on

   469

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

   470

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

   471

} list_d;

   472

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   473

   474

typedef struct message_d {

   475

	int msg;

   476

	int wparam;

   477

	int lparam;

   478

} message_d;

   479

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   480

   481

typedef struct dropdown_d {

   482

	uint32 disabled_state;

   483

	uint32 hidden_state;

   484

	WindowClass parent_wnd_class;

   485

	WindowNumber parent_wnd_num;

   486

	byte parent_button;

   487

	byte num_items;

   488

	byte selected_index;

   489

	const StringID *items;

   490

	byte click_delay;

   491

	bool drag_mode;

   492

} dropdown_d;

   493

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(dropdown_d));

   494

   495

enum WindowEvents {

   496

	WE_CLICK               =  0,

   497

	WE_PAINT               =  1,