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];

   356

} replaceveh_d;

   357

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   358

   359

typedef struct {

   360

	VehicleID sel;

   361

} traindepot_d;

   362

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindepot_d));

   363

   364

typedef struct {

   365

	int sel;

   366

} order_d;

   367

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   368

   369

typedef struct {

   370

	byte tab;

   371

} traindetails_d;

   372

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   373

   374

typedef struct {

   375

	int32 scroll_x;

   376

	int32 scroll_y;

   377

	int32 subscroll;

   378

} smallmap_d;

   379

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   380

   381

typedef struct {

   382

	uint32 face;

   383

	byte gender;

   384

} facesel_d;

   385

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   386

   387

typedef struct {

   388

	int sel;

   389

	byte cargo;

   390

} refit_d;

   391

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   392

   393

typedef struct {

   394

	VehicleID follow_vehicle;

   395

	int32 scrollpos_x;

   396

	int32 scrollpos_y;

   397

} vp_d;

   398

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

   399

   400

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

   401

typedef struct {

   402

	uint16 follow_vehicle;

   403

	int32 scrollpos_x;

   404

	int32 scrollpos_y;

   405

	byte data_1;

   406

	byte data_2;

   407

	byte data_3;

   408

} vp2_d;

   409

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp2_d));

   410

   411

typedef struct {

   412

	uint16 follow_vehicle;

   413

	int32 scrollpos_x;

   414

	int32 scrollpos_y;

   415

	NewsItem *ni;

   416

} news_d;

   417

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   418

   419

typedef struct {

   420

	uint32 background_img;

   421

	int8 rank;

   422

} highscore_d;

   423

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   424

   425

typedef struct {

   426

	int height;

   427

	uint16 counter;

   428

} scroller_d;

   429

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   430

   431

typedef enum VehicleListFlags {

   432

	VL_DESC    = 0x01,  // sort descending or ascending

   433

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

   434

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

   435

} VehicleListFlags;

   436

   437

typedef struct vehiclelist_d {

   438

	SortStruct *sort_list;

   439

	uint16 list_length;

   440

	byte sort_type;

   441

	VehicleListFlags flags;

   442

	uint16 resort_timer;

   443

} vehiclelist_d;

   444

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehiclelist_d));

   445

   446

typedef struct list_d {

   447

	uint16 list_length;    // length of the list being sorted

   448

	byte sort_type;        // what criteria to sort on

   449

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

   450

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

   451

} list_d;

   452

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   453

   454

typedef struct message_d {

   455

	int msg;

   456

	int wparam;

   457

	int lparam;

   458

} message_d;

   459

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   460

   461

typedef struct dropdown_d {

   462

	uint32 disabled_state;

   463

	uint32 hidden_state;

   464

	WindowClass parent_wnd_class;

   465

	WindowNumber parent_wnd_num;

   466

	byte parent_button;

   467

	byte num_items;

   468

	byte selected_index;

   469

	const StringID *items;

   470

	byte click_delay;

   471

	bool drag_mode;

   472

} dropdown_d;

   473

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(dropdown_d));

   474

   475

enum WindowEvents {

   476

	WE_CLICK = 0,

   477

	WE_PAINT = 1,

   478

	WE_MOUSELOOP = 2,

   479

	WE_TICK = 3,

   480

	WE_4 = 4,

   481

	WE_TIMEOUT = 5,

   482

	WE_PLACE_OBJ = 6,

   483

	WE_ABORT_PLACE_OBJ = 7,

   484

	WE_DESTROY = 8,

   485

	WE_ON_EDIT_TEXT = 9,

   486

	WE_POPUPMENU_SELECT = 10,

   487

	WE_POPUPMENU_OVER = 11,

   488

	WE_DRAGDROP = 12,

   489

	WE_PLACE_DRAG = 13,

   490

	WE_PLACE_MOUSEUP = 14,

   491

	WE_PLACE_PRESIZE = 15,

   492

	WE_DROPDOWN_SELECT = 16,

   493

	WE_RCLICK = 17,

   494

	WE_KEYPRESS = 18,

   495

	WE_CREATE = 19,

   496

	WE_MOUSEOVER = 20,

   497

	WE_ON_EDIT_TEXT_CANCEL = 21,

   498

	WE_RESIZE = 22,

   499

	WE_MESSAGE = 23

   500

};

   501

   502

   503

/****************** THESE ARE NOT WIDGET TYPES!!!!! *******************/