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

// querystr_d is the largest struct that comes in w->custom

   257

//  because 64-bit systems use 64-bit pointers, it is bigger on a 64-bit system

   258

//  than on a 32-bit system. Therefore, the size is calculated from querystr_d

   259

//  instead of a hardcoded number.

   260

// if any struct becomes bigger the querystr_d, it should be replaced.

   261

#define WINDOW_CUSTOM_SIZE sizeof(querystr_d)

   262

   263

typedef struct Scrollbar {

   264

	uint16 count, cap, pos;

   265

} Scrollbar;

   266

   267

typedef struct ResizeInfo {

   268

	uint width; /* Minimum width and height */

   269

	uint height;

   270

   271

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

   272

	uint step_height;

   273

} ResizeInfo;

   274

   275

typedef struct WindowMessage {

   276

		int msg;

   277

		int wparam;

   278

		int lparam;

   279

} WindowMessage;

   280

   281

struct Window {

   282

	uint16 flags4;

   283

	WindowClass window_class;

   284

	WindowNumber window_number;

   285

   286

	int left, top;

   287

	int width, height;

   288

   289

	Scrollbar hscroll, vscroll, vscroll2;

   290

	ResizeInfo resize;

   291

   292

	byte caption_color;

   293

   294

	uint32 click_state, disabled_state, hidden_state;

   295

	WindowProc *wndproc;

   296

	ViewPort *viewport;

   297

	const Widget *original_widget;

   298

 	Widget *widget;

   299

	uint32 desc_flags;

   300

   301

	WindowMessage message;

   302

	byte custom[WINDOW_CUSTOM_SIZE];

   303

};

   304

   305

typedef struct {

   306

	byte item_count; /* follow_vehicle */

   307

	byte sel_index;		/* scrollpos_x */

   308

	byte main_button; /* scrollpos_y */

   309

	byte action_id;

   310

	StringID string_id; /* unk30 */

   311

	uint16 checked_items; /* unk32 */

   312

	byte disabled_items;

   313

} menu_d;

   314

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   315

   316

typedef struct {

   317

	int16 data_1, data_2, data_3;

   318

	int16 data_4, data_5;

   319

	bool close;

   320

	byte byte_1;

   321

} def_d;

   322

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   323

   324

typedef struct {

   325

	void *data;

   326

} void_d;

   327

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   328

   329

typedef struct {

   330

	uint16 base;

   331

	uint16 count;

   332

} tree_d;

   333

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   334

   335

typedef struct {

   336

	byte refresh_counter;

   337

} plstations_d;

   338

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(plstations_d));

   339

   340

typedef struct {

   341

	StringID string_id;

   342

} tooltips_d;

   343

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   344

   345

typedef struct {

   346

	byte railtype;

   347

	byte sel_index;

   348

	EngineID sel_engine;

   349

	EngineID rename_engine;

   350

} buildtrain_d;

   351

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildtrain_d));

   352

   353

typedef struct {

   354

	byte vehicletype;

   355

	byte sel_index[2];

   356

	EngineID sel_engine[2];

   357

	uint16 count[2];

   358

} replaceveh_d;

   359

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   360

   361

typedef struct {

   362

	VehicleID sel;

   363

} traindepot_d;

   364

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindepot_d));

   365

   366

typedef struct {

   367

	int sel;

   368

} order_d;

   369

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   370

   371

typedef struct {

   372

	byte tab;

   373

} traindetails_d;

   374

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   375

   376

typedef struct {

   377

	int32 scroll_x;

   378

	int32 scroll_y;

   379

	int32 subscroll;

   380

} smallmap_d;

   381

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   382

   383

typedef struct {

   384

	uint32 face;

   385

	byte gender;

   386

} facesel_d;

   387

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   388

   389

typedef struct {

   390

	int sel;

   391

	byte cargo;

   392

} refit_d;

   393

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   394

   395

typedef struct {

   396

	VehicleID follow_vehicle;

   397

	int32 scrollpos_x;

   398

	int32 scrollpos_y;

   399

} vp_d;

   400

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

   401

   402

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

   403

typedef struct {

   404

	uint16 follow_vehicle;

   405

	int32 scrollpos_x;

   406

	int32 scrollpos_y;

   407

	byte data_1;

   408

	byte data_2;

   409

	byte data_3;

   410

} vp2_d;

   411

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp2_d));

   412

   413

typedef struct {

   414

	uint16 follow_vehicle;

   415

	int32 scrollpos_x;

   416

	int32 scrollpos_y;

   417

	NewsItem *ni;

   418

} news_d;

   419

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   420

   421

typedef struct {

   422

	uint32 background_img;

   423

	int8 rank;

   424

} highscore_d;

   425

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   426

   427

typedef struct {

   428

	int height;

   429

	uint16 counter;

   430

} scroller_d;

   431

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   432

   433

typedef enum VehicleListFlags {

   434

	VL_DESC    = 0x01,

   435

	VL_RESORT  = 0x02,

   436

	VL_REBUILD = 0x04

   437

} VehicleListFlags;

   438

   439

typedef struct vehiclelist_d {

   440

	SortStruct *sort_list;

   441

	uint16 list_length;

   442

	byte sort_type;

   443

	VehicleListFlags flags;

   444

	uint16 resort_timer;

   445

} vehiclelist_d;

   446

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehiclelist_d));

   447

   448

typedef struct message_d {

   449

	int msg;

   450

	int wparam;

   451

	int lparam;

   452

} message_d;

   453

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   454

   455

typedef struct dropdown_d {

   456

	uint32 disabled_state;

   457

	uint32 hidden_state;

   458

	WindowClass parent_wnd_class;

   459

	WindowNumber parent_wnd_num;

   460

	byte parent_button;

   461

	byte num_items;

   462

	byte selected_index;

   463

	const StringID *items;

   464

	byte click_delay;

   465

	bool drag_mode;

   466

} dropdown_d;

   467

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(dropdown_d));

   468

   469

enum WindowEvents {

   470

	WE_CLICK = 0,

   471

	WE_PAINT = 1,

   472

	WE_MOUSELOOP = 2,

   473

	WE_TICK = 3,

   474

	WE_4 = 4,

   475

	WE_TIMEOUT = 5,

   476

	WE_PLACE_OBJ = 6,

   477

	WE_ABORT_PLACE_OBJ = 7,

   478

	WE_DESTROY = 8,

   479

	WE_ON_EDIT_TEXT = 9,

   480

	WE_POPUPMENU_SELECT = 10,

   481

	WE_POPUPMENU_OVER = 11,

   482

	WE_DRAGDROP = 12,

   483

	WE_PLACE_DRAG = 13,

   484

	WE_PLACE_MOUSEUP = 14,

   485

	WE_PLACE_PRESIZE = 15,

   486

	WE_DROPDOWN_SELECT = 16,

   487

	WE_RCLICK = 17,

   488

	WE_KEYPRESS = 18,

   489

	WE_CREATE = 19,

   490

	WE_MOUSEOVER = 20,

   491

	WE_ON_EDIT_TEXT_CANCEL = 21,

   492

	WE_RESIZE = 22,

   493

	WE_MESSAGE = 23

   494

};

   495

   496

   497

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

   498

enum WindowWidgetBehaviours {

   499

	WWB_PUSHBUTTON = 1 << 5,

   500

	WWB_NODISBUTTON = 2 << 5,

   501

};

   502

   503

   504

enum WindowWidgetTypes {