1

/* $Id$ */

     2

     3

#ifndef WINDOW_H

     4

#define WINDOW_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

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

   141

enum WindowKeyCodes {

   142

	WKC_SHIFT = 0x8000,

   143

	WKC_CTRL  = 0x4000,

   144

	WKC_ALT   = 0x2000,

   145

	WKC_META  = 0x1000,

   146

   147

	// Special ones

   148

	WKC_NONE = 0,

   149

	WKC_ESC=1,

   150

	WKC_BACKSPACE = 2,

   151

	WKC_INSERT = 3,

   152

	WKC_DELETE = 4,

   153

   154

	WKC_PAGEUP = 5,

   155

	WKC_PAGEDOWN = 6,

   156

	WKC_END = 7,

   157

	WKC_HOME = 8,

   158

   159

	// Arrow keys

   160

	WKC_LEFT = 9,

   161

	WKC_UP = 10,

   162

	WKC_RIGHT = 11,

   163

	WKC_DOWN = 12,

   164

   165

	// Return & tab

   166

	WKC_RETURN = 13,

   167

	WKC_TAB = 14,

   168

   169

	// Numerical keyboard

   170

	WKC_NUM_0 = 16,

   171

	WKC_NUM_1 = 17,

   172

	WKC_NUM_2 = 18,

   173

	WKC_NUM_3 = 19,

   174

	WKC_NUM_4 = 20,

   175

	WKC_NUM_5 = 21,

   176

	WKC_NUM_6 = 22,

   177

	WKC_NUM_7 = 23,

   178

	WKC_NUM_8 = 24,

   179

	WKC_NUM_9 = 25,

   180

	WKC_NUM_DIV = 26,

   181

	WKC_NUM_MUL = 27,

   182

	WKC_NUM_MINUS = 28,

   183

	WKC_NUM_PLUS = 29,

   184

	WKC_NUM_ENTER = 30,

   185

	WKC_NUM_DECIMAL = 31,

   186

   187

	// Space

   188

	WKC_SPACE = 32,

   189

   190

	// Function keys

   191

	WKC_F1 = 33,

   192

	WKC_F2 = 34,

   193

	WKC_F3 = 35,

   194

	WKC_F4 = 36,

   195

	WKC_F5 = 37,

   196

	WKC_F6 = 38,

   197

	WKC_F7 = 39,

   198

	WKC_F8 = 40,

   199

	WKC_F9 = 41,

   200

	WKC_F10 = 42,

   201

	WKC_F11 = 43,

   202

	WKC_F12 = 44,

   203

   204

	// backquote is the key left of "1"

   205

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

   206

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

   207

	WKC_BACKQUOTE = 45,

   208

	WKC_PAUSE     = 46,

   209

   210

	// 0-9 are mapped to 48-57

   211

	// A-Z are mapped to 65-90

   212

	// a-z are mapped to 97-122

   213

   214

   215

	//WKC_UNKNOWN = 0xFF,

   216

   217

};

   218

   219

typedef struct WindowDesc {

   220

	int16 left, top, width, height;

   221

	byte cls;

   222

	byte parent_cls;

   223

	uint32 flags;

   224

	const Widget *widgets;

   225

	WindowProc *proc;

   226

} WindowDesc;

   227

   228

enum {

   229

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

   230

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

   231

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

   232

   233

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

   234

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

   235

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

   236

};

   237

   238

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

   239

enum {

   240

	WDP_AUTO = -1,

   241

	WDP_CENTER = -2,

   242

};

   243

   244

typedef struct Textbuf {

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

} Textbuf;

   252

   253

typedef struct {

   254

	StringID caption;

   255

	WindowClass wnd_class;

   256

	WindowNumber wnd_num;

   257

	Textbuf text;

   258

	const char* orig;

   259

} querystr_d;

   260

   261

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

   262

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

   263

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

   264

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

   265

//  instead of a hardcoded number.

   266

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

   267

#define WINDOW_CUSTOM_SIZE sizeof(querystr_d)

   268

   269

typedef struct {

   270

	uint16 count, cap, pos;

   271

} Scrollbar;

   272

   273

typedef struct {

   274

	uint width; /* Minimum width and height */

   275

	uint height;

   276

   277

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

   278

	uint step_height;

   279

} ResizeInfo;

   280

   281

typedef struct {

   282

		int msg;

   283

		int wparam;

   284

		int lparam;

   285

} Message;

   286

   287

struct Window {

   288

	uint16 flags4;

   289

	WindowClass window_class;

   290

	WindowNumber window_number;

   291

   292

	int left, top;

   293

	int width, height;

   294

   295

	Scrollbar hscroll, vscroll, vscroll2;

   296

	ResizeInfo resize;

   297

   298

	byte caption_color;

   299

   300

	uint32 click_state, disabled_state, hidden_state;

   301

	WindowProc *wndproc;

   302

	ViewPort *viewport;

   303

	const Widget *original_widget;

   304

 	Widget *widget;

   305

	//const WindowDesc *desc;

   306

	uint32 desc_flags;

   307

   308

	Message message;

   309

	byte custom[WINDOW_CUSTOM_SIZE];

   310

};

   311

   312

typedef struct {

   313

	byte item_count; /* follow_vehicle */

   314

	byte sel_index;		/* scrollpos_x */

   315

	byte main_button; /* scrollpos_y */

   316

	byte action_id;

   317

	StringID string_id; /* unk30 */

   318

	uint16 checked_items; /* unk32 */

   319

} menu_d;

   320

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   321

   322

typedef struct {

   323

	int16 data_1, data_2, data_3;

   324

	int16 data_4, data_5;

   325

	bool close; /* scrollpos_y */

   326

	byte byte_1;

   327

} def_d;

   328

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   329

   330

typedef struct {

   331

	void *data;

   332

} void_d;

   333

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   334

   335

typedef struct {

   336

	uint16 base; /* follow_vehicle */

   337

	uint16 count;/* scrollpos_x */

   338

} tree_d;

   339

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   340

   341

typedef struct {

   342

	byte refresh_counter; /* follow_vehicle */

   343

} plstations_d;

   344

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(plstations_d));

   345

   346

typedef struct {

   347

	StringID string_id;

   348

} tooltips_d;

   349

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   350

   351

typedef struct {

   352

	byte railtype;

   353

	byte sel_index;

   354

	int16 sel_engine;

   355

	int16 rename_engine;

   356

} buildtrain_d;

   357

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildtrain_d));

   358

   359

typedef struct {

   360

	byte vehicletype;

   361

	byte sel_index[2];

   362

	int16 sel_engine[2];

   363

	uint16 count[2];

   364

} replaceveh_d;

   365

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   366

   367

typedef struct {

   368

	VehicleID sel;

   369

} traindepot_d;

   370

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindepot_d));

   371

   372

typedef struct {

   373

	int sel;

   374

} order_d;

   375

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   376

   377

typedef struct {

   378

	byte tab;

   379

} traindetails_d;

   380

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   381

   382

typedef struct {

   383

	int32 scroll_x;

   384

	int32 scroll_y;

   385

	int32 subscroll;

   386

} smallmap_d;

   387

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   388

   389

typedef struct {

   390

	uint32 face;

   391

	byte gender;

   392

} facesel_d;

   393

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   394

   395

typedef struct {

   396

	int sel;

   397

	byte cargo;

   398

} refit_d;

   399

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   400

   401

typedef struct {

   402

	VehicleID follow_vehicle;

   403

	int32 scrollpos_x;

   404

	int32 scrollpos_y;

   405

} vp_d;

   406

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

   407

   408

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

   409

typedef struct {

   410

	uint16 follow_vehicle;

   411

	int32 scrollpos_x;

   412

	int32 scrollpos_y;

   413

	byte data_1;

   414

	byte data_2;

   415

	byte data_3;

   416

} vp2_d;

   417

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp2_d));

   418

   419

typedef struct {

   420

	uint16 follow_vehicle;

   421

	int32 scrollpos_x;

   422

	int32 scrollpos_y;

   423

	NewsItem *ni;

   424

} news_d;

   425

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   426

   427

typedef struct {

   428

	uint32 background_img;

   429

	int8 rank;

   430

} highscore_d;

   431

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   432

   433

typedef struct {

   434

	int height;

   435

	uint16 counter;

   436

} scroller_d;

   437

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   438

   439

typedef enum VehicleListFlags {

   440

	VL_DESC    = 0x01,

   441

	VL_RESORT  = 0x02,

   442

	VL_REBUILD = 0x04

   443

} VehicleListFlags;

   444

   445

typedef struct vehiclelist_d {

   446

	SortStruct *sort_list;

   447

	uint16 list_length;

   448

	byte sort_type;

   449

	VehicleListFlags flags;

   450

	uint16 resort_timer;

   451

} vehiclelist_d;

   452

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehiclelist_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

enum WindowEvents {

   462

	WE_CLICK = 0,

   463

	WE_PAINT = 1,

   464

	WE_MOUSELOOP = 2,

   465

	WE_TICK = 3,

   466

	WE_4 = 4,

   467

	WE_TIMEOUT = 5,

   468

	WE_PLACE_OBJ = 6,

   469

	WE_ABORT_PLACE_OBJ = 7,

   470

	WE_DESTROY = 8,

   471

	WE_ON_EDIT_TEXT = 9,

   472

	WE_POPUPMENU_SELECT = 10,

   473

	WE_POPUPMENU_OVER = 11,

   474

	WE_DRAGDROP = 12,

   475

	WE_PLACE_DRAG = 13,

   476

	WE_PLACE_MOUSEUP = 14,

   477

	WE_PLACE_PRESIZE = 15,

   478

	WE_DROPDOWN_SELECT = 16,

   479

	WE_RCLICK = 17,

   480

	WE_KEYPRESS = 18,

   481

	WE_CREATE = 19,

   482

	WE_MOUSEOVER = 20,

   483

	WE_ON_EDIT_TEXT_CANCEL = 21,

   484

	WE_RESIZE = 22,

   485

	WE_MESSAGE = 23

   486

};

   487

   488

   489

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

   490

enum WindowWidgetBehaviours {

   491

	WWB_PUSHBUTTON = 1 << 5,

   492

	WWB_NODISBUTTON = 2 << 5,

   493

};

   494

   495

   496

enum WindowWidgetTypes {

   497

	WWT_EMPTY = 0,

   498

   499

	WWT_IMGBTN = 1,						/* button with image */

   500

	WWT_PANEL = WWT_IMGBTN,

   501

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

   502

   503

	WWT_TEXTBTN = 3,					/* button with text */

   504

	WWT_CLOSEBOX = WWT_TEXTBTN,

   505

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

   506