1

/* $Id$ */

     2

     3

#ifndef WINDOW_H

     4

#define WINDOW_H

     5

     6

typedef union WindowEvent WindowEvent;

     7

     8

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

     9

    10

/* How the resize system works:

    11

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

    12

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

    13

     to resize itself.

    14

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

    15

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

    16

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

    17

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

    18

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

    19

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

    20

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

    21

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

    22

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

    23

     widgets moves downwards without resizing, and appears to be clamped

    24

     to the bottom. Nice aint it?

    25

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

    26

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

    27

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

    28

    after making the window, like this:

    29

      w->resize.step_height = 10;

    30

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

    31

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

    32

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

    33

    AFTER window-creation, with:

    34

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

    35

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

    36

    37

enum {

    38

	RESIZE_NONE   = 0,

    39

    40

	RESIZE_LEFT   = 1,

    41

	RESIZE_RIGHT  = 2,

    42

	RESIZE_TOP    = 4,

    43

	RESIZE_BOTTOM = 8,

    44

    45

	RESIZE_LR     = RESIZE_LEFT  | RESIZE_RIGHT,

    46

	RESIZE_RB     = RESIZE_RIGHT | RESIZE_BOTTOM,

    47

	RESIZE_TB     = RESIZE_TOP   | RESIZE_BOTTOM,

    48

	RESIZE_LRB    = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_BOTTOM,

    49

	RESIZE_LRTB   = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_TOP | RESIZE_BOTTOM,

    50

	RESIZE_RTB    = RESIZE_RIGHT | RESIZE_TOP    | RESIZE_BOTTOM,

    51

};

    52

    53

typedef struct Widget {

    54

	byte type;

    55

	byte resize_flag;

    56

	byte color;

    57

	uint16 left, right, top, bottom;

    58

	uint16 unkA;

    59

	StringID tooltips;

    60

} Widget;

    61

    62

enum FrameFlags {

    63

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

    64

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

    65

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

    66

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

    67

	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)

    68

};

    69

    70

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

    71

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

    72

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

    73

 * rewrite after 0.4.0 */

    74

union WindowEvent {

    75

	byte event;

    76

	struct {

    77

		byte event;

    78

		Point pt;

    79

		int widget;

    80

	} click;

    81

    82

	struct {

    83

		byte event;

    84

		Point pt;

    85

		TileIndex tile;

    86

		TileIndex starttile;

    87

		int userdata;

    88

	} place;

    89

    90

	struct {

    91

		byte event;

    92

		Point pt;

    93

		int widget;

    94

	} dragdrop;

    95

    96

	struct {

    97

		byte event;

    98

		Point size;

    99

		Point diff;

   100

	} sizing;

   101

   102

	struct {

   103

		byte event;

   104

		char *str;

   105

	} edittext;

   106

   107

	struct {

   108

		byte event;

   109

		Point pt;

   110

	} popupmenu;

   111

   112

	struct {

   113

		byte event;

   114

		int button;

   115

		int index;

   116

	} dropdown;

   117

   118

	struct {

   119

		byte event;

   120

		Point pt;

   121

		int widget;

   122

	} mouseover;

   123

   124

	struct {

   125

		byte event;

   126

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

   127

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

   128

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

   129

	} keypress;

   130

   131

	struct {

   132

		byte event;

   133

		uint msg;    // message to be sent

   134

		uint wparam; // additional message-specific information

   135

		uint lparam; // additional message-specific information

   136

	} message;

   137

};

   138

   139

enum WindowKeyCodes {

   140

	WKC_SHIFT = 0x8000,

   141

	WKC_CTRL  = 0x4000,

   142

	WKC_ALT   = 0x2000,

   143

	WKC_META  = 0x1000,

   144

   145

	// Special ones

   146

	WKC_NONE = 0,

   147

	WKC_ESC=1,

   148

	WKC_BACKSPACE = 2,

   149

	WKC_INSERT = 3,

   150

	WKC_DELETE = 4,

   151

   152

	WKC_PAGEUP = 5,

   153

	WKC_PAGEDOWN = 6,

   154

	WKC_END = 7,

   155

	WKC_HOME = 8,

   156

   157

	// Arrow keys

   158

	WKC_LEFT = 9,

   159

	WKC_UP = 10,

   160

	WKC_RIGHT = 11,

   161

	WKC_DOWN = 12,

   162

   163

	// Return & tab

   164

	WKC_RETURN = 13,

   165

	WKC_TAB = 14,

   166

   167

	// Numerical keyboard

   168

	WKC_NUM_0 = 16,

   169

	WKC_NUM_1 = 17,

   170

	WKC_NUM_2 = 18,

   171

	WKC_NUM_3 = 19,

   172

	WKC_NUM_4 = 20,

   173

	WKC_NUM_5 = 21,

   174

	WKC_NUM_6 = 22,

   175

	WKC_NUM_7 = 23,

   176

	WKC_NUM_8 = 24,

   177

	WKC_NUM_9 = 25,

   178

	WKC_NUM_DIV = 26,

   179

	WKC_NUM_MUL = 27,

   180

	WKC_NUM_MINUS = 28,

   181

	WKC_NUM_PLUS = 29,

   182

	WKC_NUM_ENTER = 30,

   183

	WKC_NUM_DECIMAL = 31,

   184

   185

	// Space

   186

	WKC_SPACE = 32,

   187

   188

	// Function keys

   189

	WKC_F1 = 33,

   190

	WKC_F2 = 34,

   191

	WKC_F3 = 35,

   192

	WKC_F4 = 36,

   193

	WKC_F5 = 37,

   194

	WKC_F6 = 38,

   195

	WKC_F7 = 39,

   196

	WKC_F8 = 40,

   197

	WKC_F9 = 41,

   198

	WKC_F10 = 42,

   199

	WKC_F11 = 43,

   200

	WKC_F12 = 44,

   201

   202

	// backquote is the key left of "1"

   203

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

   204

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

   205

	WKC_BACKQUOTE = 45,

   206

	WKC_PAUSE     = 46,

   207

   208

	// 0-9 are mapped to 48-57

   209

	// A-Z are mapped to 65-90

   210

	// a-z are mapped to 97-122

   211

};

   212

   213

typedef struct WindowDesc {

   214

	int16 left, top, width, height;

   215

	WindowClass cls;

   216

	WindowClass parent_cls;

   217

	uint32 flags;

   218

	const Widget *widgets;

   219

	WindowProc *proc;

   220

} WindowDesc;

   221

   222

enum {

   223

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

   224

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

   225

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

   226

   227

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

   228

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

   229

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

   230

};

   231

   232

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

   233

enum {

   234

	WDP_AUTO = -1,

   235

	WDP_CENTER = -2,

   236

};

   237

   238

typedef struct Textbuf {

   239

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

   240

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

   241

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

   242

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

   243

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

   244

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

   245

} Textbuf;

   246

   247

typedef struct querystr_d {

   248

	StringID caption;

   249

	WindowClass wnd_class;

   250

	WindowNumber wnd_num;

   251

	Textbuf text;

   252

	const char* orig;

   253

} querystr_d;

   254

   255

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

   256

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

   257

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

   258

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

   259

#define WINDOW_CUSTOM_SIZE 88

   260

   261

typedef struct Scrollbar {

   262

	uint16 count, cap, pos;

   263

} Scrollbar;

   264

   265

typedef struct ResizeInfo {

   266

	uint width; /* Minimum width and height */

   267

	uint height;

   268

   269

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

   270

	uint step_height;

   271

} ResizeInfo;

   272

   273

typedef struct WindowMessage {

   274

		int msg;

   275

		int wparam;

   276

		int lparam;

   277

} WindowMessage;

   278

   279

struct Window {

   280

	uint16 flags4;

   281

	WindowClass window_class;

   282

	WindowNumber window_number;

   283

   284

	int left, top;

   285

	int width, height;

   286

   287

	Scrollbar hscroll, vscroll, vscroll2;

   288

	ResizeInfo resize;

   289

   290

	byte caption_color;

   291

   292

	uint32 click_state, disabled_state, hidden_state;

   293

	WindowProc *wndproc;

   294

	ViewPort *viewport;

   295

	const Widget *original_widget;

   296

 	Widget *widget;

   297

	uint32 desc_flags;

   298

   299

	WindowMessage message;

   300

	byte custom[WINDOW_CUSTOM_SIZE];

   301

};

   302

   303

typedef struct {

   304

	byte item_count; /* follow_vehicle */

   305

	byte sel_index;		/* scrollpos_x */

   306

	byte main_button; /* scrollpos_y */

   307

	byte action_id;

   308

	StringID string_id; /* unk30 */

   309

	uint16 checked_items; /* unk32 */

   310

	byte disabled_items;

   311

} menu_d;

   312

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   313

   314

typedef struct {

   315

	int16 data_1, data_2, data_3;

   316

	int16 data_4, data_5;

   317

	bool close;

   318

	byte byte_1;

   319

} def_d;

   320

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   321

   322

typedef struct {

   323

	void *data;

   324

} void_d;

   325

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   326

   327

typedef struct {

   328

	uint16 base;

   329

	uint16 count;

   330

} tree_d;

   331

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   332

   333

typedef struct {

   334

	byte refresh_counter;

   335

} plstations_d;

   336

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(plstations_d));

   337

   338

typedef struct {

   339

	StringID string_id;

   340

} tooltips_d;

   341

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   342

   343

typedef struct {

   344

	byte railtype;

   345

	byte sel_index;

   346

	EngineID sel_engine;

   347

	EngineID rename_engine;

   348

} buildtrain_d;

   349

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildtrain_d));

   350

   351

typedef struct {

   352

	byte vehicletype;

   353

	byte sel_index[2];

   354

	EngineID sel_engine[2];

   355

	uint16 count[2];

   357

} replaceveh_d;

   358

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   359

   360

typedef struct {

   361

	VehicleID sel;

   362

} traindepot_d;

   363

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindepot_d));

   364

   365

typedef struct {

   366

	int sel;

   367

} order_d;

   368

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   369

   370

typedef struct {

   371

	byte tab;

   372

} traindetails_d;

   373

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   374

   375

typedef struct {

   376

	int32 scroll_x;

   377

	int32 scroll_y;

   378

	int32 subscroll;

   379

} smallmap_d;

   380

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   381

   382

typedef struct {

   383

	uint32 face;

   384

	byte gender;

   385

} facesel_d;

   386

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   387

   388

typedef struct {

   389

	int sel;

   390

	byte cargo;

   391

} refit_d;

   392

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   393

   394

typedef struct {

   395

	VehicleID follow_vehicle;

   396

	int32 scrollpos_x;

   397

	int32 scrollpos_y;

   398

} vp_d;

   399

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

   400

   401

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

   402

typedef struct {

   403

	uint16 follow_vehicle;

   404

	int32 scrollpos_x;

   405

	int32 scrollpos_y;

   406

	byte data_1;

   407

	byte data_2;

   408

	byte data_3;

   409

} vp2_d;

   410

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp2_d));

   411

   412

typedef struct {

   413

	uint16 follow_vehicle;

   414

	int32 scrollpos_x;

   415

	int32 scrollpos_y;

   416

	NewsItem *ni;

   417

} news_d;

   418

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   419

   420

typedef struct {

   421

	uint32 background_img;

   422

	int8 rank;

   423

} highscore_d;

   424

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   425

   426

typedef struct {

   427

	int height;

   428

	uint16 counter;

   429

} scroller_d;

   430

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   431

   432

typedef enum VehicleListFlags {

   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

} VehicleListFlags;

   437

   438

typedef struct vehiclelist_d {

   439

	SortStruct *sort_list;

   440

	uint16 list_length;

   441

	byte sort_type;

   442

	VehicleListFlags flags;

   443

	uint16 resort_timer;

   444

} vehiclelist_d;

   445

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehiclelist_d));

   446

   447

typedef struct list_d {

   448

	uint16 list_length;    // length of the list being sorted

   449

	byte sort_type;        // what criteria to sort on

   450

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

   451

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

   452

} list_d;

   453

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   454

   455

typedef struct message_d {

   456

	int msg;

   457

	int wparam;

   458

	int lparam;

   459

} message_d;

   460

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   461

   462

typedef struct dropdown_d {

   463

	uint32 disabled_state;

   464

	uint32 hidden_state;

   465

	WindowClass parent_wnd_class;

   466

	WindowNumber parent_wnd_num;

   467

	byte parent_button;

   468

	byte num_items;

   469

	byte selected_index;

   470

	const StringID *items;

   471

	byte click_delay;

   472

	bool drag_mode;

   473

} dropdown_d;

   474

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(dropdown_d));

   475

   476

enum WindowEvents {

   477

	WE_CLICK = 0,

   478

	WE_PAINT = 1,

   479

	WE_MOUSELOOP = 2,

   480

	WE_TICK = 3,

   481

	WE_4 = 4,

   482

	WE_TIMEOUT = 5,

   483

	WE_PLACE_OBJ = 6,

   484

	WE_ABORT_PLACE_OBJ = 7,

   485

	WE_DESTROY = 8,

   486

	WE_ON_EDIT_TEXT = 9,

   487

	WE_POPUPMENU_SELECT = 10,

   488

	WE_POPUPMENU_OVER = 11,

   489

	WE_DRAGDROP = 12,

   490

	WE_PLACE_DRAG = 13,

   491

	WE_PLACE_MOUSEUP = 14,

   492

	WE_PLACE_PRESIZE = 15,

   493

	WE_DROPDOWN_SELECT = 16,

   494

	WE_RCLICK = 17,

   495

	WE_KEYPRESS = 18,

   496

	WE_CREATE = 19,

   497

	WE_MOUSEOVER = 20,

   498

	WE_ON_EDIT_TEXT_CANCEL = 21,

   499

	WE_RESIZE = 22,

   500

	WE_MESSAGE = 23

   501

};

   502

   503