1

#ifndef WINDOW_H

     2

#define WINDOW_H

     3

     4

#include "vehicle_gui.h"

     5

     6

typedef union WindowEvent WindowEvent;

     7

     8

//typedef void WindowProc(Window *w, int event, int wparam, long lparam);

     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

	uint16 tooltips;

    62

} Widget;

    63

    64

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

    65

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

    66

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

    67

 * rewrite after 0.4.0 */

    68

union WindowEvent {

    69

	byte event;

    70

	struct {

    71

		byte event;

    72

		Point pt;

    73

		int widget;

    74

	} click;

    75

    76

	struct {

    77

		byte event;

    78

		Point pt;

    79

		uint tile;

    80

		uint starttile;

    81

		int userdata;

    82

	} place;

    83

    84

	struct {

    85

		byte event;

    86

		Point pt;

    87

		int widget;

    88

	} dragdrop;

    89

    90

	struct {

    91

		byte event;

    92

		Point size;

    93

		Point diff;

    94

	} sizing;

    95

    96

	struct {

    97

		byte event;

    98

		char *str;

    99

	} edittext;

   100

   101

	struct {

   102

		byte event;

   103

		Point pt;

   104

	} popupmenu;

   105

   106

	struct {

   107

		byte event;

   108

		int button;

   109

		int index;

   110

	} dropdown;

   111

   112

	struct {

   113

		byte event;

   114

		Point pt;

   115

		int widget;

   116

	} mouseover;

   117

   118

	struct {

   119

		byte event;

   120

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

   121

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

   122

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

   123

	} keypress;

   124

   125

	struct {

   126

		byte event;

   127

		uint msg;    // message to be sent

   128

		uint wparam; // additional message-specific information

   129

		uint lparam; // additional message-specific information

   130

	} message;

   131

};

   132

   133

enum WindowKeyCodes {

   134

	WKC_SHIFT = 0x8000,

   135

	WKC_CTRL  = 0x4000,

   136

	WKC_ALT   = 0x2000,

   137

	WKC_META  = 0x1000,

   138

   139

	// Special ones

   140

	WKC_NONE = 0,

   141

	WKC_ESC=1,

   142

	WKC_BACKSPACE = 2,

   143

	WKC_INSERT = 3,

   144

	WKC_DELETE = 4,

   145

   146

	WKC_PAGEUP = 5,

   147

	WKC_PAGEDOWN = 6,

   148

	WKC_END = 7,

   149

	WKC_HOME = 8,

   150

   151

	// Arrow keys

   152

	WKC_LEFT = 9,

   153

	WKC_UP = 10,

   154

	WKC_RIGHT = 11,

   155

	WKC_DOWN = 12,

   156

   157

	// Return & tab

   158

	WKC_RETURN = 13,

   159

	WKC_TAB = 14,

   160

   161

	// Numerical keyboard

   162

	WKC_NUM_0 = 16,

   163

	WKC_NUM_1 = 17,

   164

	WKC_NUM_2 = 18,

   165

	WKC_NUM_3 = 19,

   166

	WKC_NUM_4 = 20,

   167

	WKC_NUM_5 = 21,

   168

	WKC_NUM_6 = 22,

   169

	WKC_NUM_7 = 23,

   170

	WKC_NUM_8 = 24,

   171

	WKC_NUM_9 = 25,

   172

	WKC_NUM_DIV = 26,

   173

	WKC_NUM_MUL = 27,

   174

	WKC_NUM_MINUS = 28,

   175

	WKC_NUM_PLUS = 29,

   176

	WKC_NUM_ENTER = 30,

   177

	WKC_NUM_DECIMAL = 31,

   178

   179

	// Space

   180

	WKC_SPACE = 32,

   181

   182

	// Function keys

   183

	WKC_F1 = 33,

   184

	WKC_F2 = 34,

   185

	WKC_F3 = 35,

   186

	WKC_F4 = 36,

   187

	WKC_F5 = 37,

   188

	WKC_F6 = 38,

   189

	WKC_F7 = 39,

   190

	WKC_F8 = 40,

   191

	WKC_F9 = 41,

   192

	WKC_F10 = 42,

   193

	WKC_F11 = 43,

   194

	WKC_F12 = 44,

   195

   196

	// backquote is the key left of "1"

   197

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

   198

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

   199

	WKC_BACKQUOTE = 45,

   200

	WKC_PAUSE     = 46,

   201

   202

	// 0-9 are mapped to 48-57

   203

	// A-Z are mapped to 65-90

   204

	// a-z are mapped to 97-122

   205

   206

   207

	//WKC_UNKNOWN = 0xFF,

   208

   209

};

   210

   211

typedef struct WindowDesc {

   212

	int16 left, top, width, height;

   213

	byte cls;

   214

	byte parent_cls;

   215

	uint32 flags;

   216

	const Widget *widgets;

   217

	WindowProc *proc;

   218

} WindowDesc;

   219

   220

enum {

   221

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

   222

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

   223

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

   224

	WDF_RESTORE_DPARAM = 8, /* when drawing widgets, restore the dparam so all widgets recieve the same set of them */

   225

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

   226

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

   227

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

   228

};

   229

   230

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

   231

enum {

   232

	WDP_AUTO = -1,

   233

	WDP_CENTER = -2,

   234

};

   235

   236

typedef struct Textbuf {

   237

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

   238

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

   239

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

   240

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

   241

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

   242

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

   243

} Textbuf;

   244

   245

typedef struct {

   246

	StringID caption;

   247

	WindowClass wnd_class;

   248

	WindowNumber wnd_num;

   249

	Textbuf text;

   250

	const char* orig;

   251

} querystr_d;

   252

   253

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

   254

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

   255

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

   256

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

   257

//  instead of a hardcoded number.

   258

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

   259

#define WINDOW_CUSTOM_SIZE sizeof(querystr_d)

   260

   261

typedef struct {

   262

	uint16 count, cap, pos;

   263

} Scrollbar;

   264

   265

typedef struct {

   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 {

   274

		int msg;

   275

		int wparam;

   276

		int lparam;

   277

} Message;

   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

	//const WindowDesc *desc;

   298

	uint32 desc_flags;

   299

   300

	Message message;

   301

	byte custom[WINDOW_CUSTOM_SIZE];

   302

};

   303

   304

typedef struct {

   305

	byte item_count; /* follow_vehicle */

   306

	byte sel_index;		/* scrollpos_x */

   307

	byte main_button; /* scrollpos_y */

   308

	byte action_id;

   309

	StringID string_id; /* unk30 */

   310

	uint16 checked_items; /* unk32 */

   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; /* scrollpos_y */

   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; /* follow_vehicle */

   329

	uint16 count;/* scrollpos_x */

   330

} tree_d;

   331

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   332

   333

typedef struct {

   334

	byte refresh_counter; /* follow_vehicle */

   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

	int16 sel_engine;

   347

	int16 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

	int16 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

	uint16 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,

   433

	VL_RESORT  = 0x02,

   434

	VL_REBUILD = 0x04

   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 message_d {

   447

	int msg;

   448

	int wparam;

   449

	int lparam;

   450

} message_d;

   451

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   452

   453

enum WindowEvents {

   454

	WE_CLICK = 0,

   455

	WE_PAINT = 1,

   456

	WE_MOUSELOOP = 2,

   457

	WE_TICK = 3,

   458

	WE_4 = 4,

   459

	WE_TIMEOUT = 5,

   460

	WE_PLACE_OBJ = 6,

   461

	WE_ABORT_PLACE_OBJ = 7,

   462

	WE_DESTROY = 8,

   463

	WE_ON_EDIT_TEXT = 9,

   464

	WE_POPUPMENU_SELECT = 10,

   465

	WE_POPUPMENU_OVER = 11,

   466

	WE_DRAGDROP = 12,

   467

	WE_PLACE_DRAG = 13,

   468

	WE_PLACE_MOUSEUP = 14,

   469

	WE_PLACE_PRESIZE = 15,

   470

	WE_DROPDOWN_SELECT = 16,

   471

	WE_RCLICK = 17,

   472

	WE_KEYPRESS = 18,

   473

	WE_CREATE = 19,

   474

	WE_MOUSEOVER = 20,

   475

	WE_ON_EDIT_TEXT_CANCEL = 21,

   476

	WE_RESIZE = 22,

   477

	WE_MESSAGE = 23

   478

};

   479

   480

   481

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

   482

enum WindowWidgetBehaviours {

   483

	WWB_PUSHBUTTON = 1 << 5,

   484

	WWB_NODISBUTTON = 2 << 5,

   485

};

   486

   487

   488

enum WindowWidgetTypes {

   489

	WWT_EMPTY = 0,

   490

   491

	WWT_IMGBTN = 1,						/* button with image */

   492

	WWT_PANEL = WWT_IMGBTN,

   493

	WWT_PANEL_2 = 2,					/* button with diff image when clicked */

   494

   495

	WWT_TEXTBTN = 3,					/* button with text */

   496

	WWT_CLOSEBOX = WWT_TEXTBTN,

   497

	WWT_4 = 4,								/* button with diff text when clicked */

   498

	WWT_5 = 5,								/* label */

   499

	WWT_6 = 6,								/* combo box text area */

   500

	WWT_MATRIX = 7,

   501

	WWT_SCROLLBAR = 8,

   502

	WWT_FRAME = 9,						/* frame */

   503

	WWT_CAPTION = 10,

   504

   505

	WWT_HSCROLLBAR = 11,

   506

	WWT_STICKYBOX = 12,