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

	byte disabled_items;

   320

} menu_d;

   321

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   322

   323

typedef struct {

   324

	int16 data_1, data_2, data_3;

   325

	int16 data_4, data_5;

   326

	bool close; /* scrollpos_y */

   327

	byte byte_1;

   328

} def_d;

   329

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   330

   331

typedef struct {

   332

	void *data;

   333

} void_d;

   334

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   335

   336

typedef struct {

   337

	uint16 base; /* follow_vehicle */

   338

	uint16 count;/* scrollpos_x */

   339

} tree_d;

   340

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   341

   342

typedef struct {

   343

	byte refresh_counter; /* follow_vehicle */

   344

} plstations_d;

   345

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(plstations_d));

   346

   347

typedef struct {

   348

	StringID string_id;

   349

} tooltips_d;

   350

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   351

   352

typedef struct {

   353

	byte railtype;

   354

	byte sel_index;

   355

	EngineID sel_engine;

   356

	EngineID rename_engine;

   357

} buildtrain_d;

   358

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildtrain_d));

   359

   360

typedef struct {

   361

	byte vehicletype;

   362

	byte sel_index[2];

   363

	int16 sel_engine[2];

   364

	uint16 count[2];

   365

} replaceveh_d;

   366

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   367

   368

typedef struct {

   369

	VehicleID sel;

   370

} traindepot_d;

   371

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindepot_d));

   372

   373

typedef struct {

   374

	int sel;

   375

} order_d;

   376

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   377

   378

typedef struct {

   379

	byte tab;

   380

} traindetails_d;

   381

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   382

   383

typedef struct {

   384

	int32 scroll_x;

   385

	int32 scroll_y;

   386

	int32 subscroll;

   387

} smallmap_d;

   388

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   389

   390

typedef struct {

   391

	uint32 face;

   392

	byte gender;

   393

} facesel_d;

   394

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   395

   396

typedef struct {

   397

	int sel;

   398

	byte cargo;

   399

} refit_d;

   400

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   401

   402

typedef struct {

   403

	VehicleID follow_vehicle;

   404

	int32 scrollpos_x;

   405

	int32 scrollpos_y;

   406

} vp_d;

   407

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

   408

   409

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

   410

typedef struct {

   411

	uint16 follow_vehicle;

   412

	int32 scrollpos_x;

   413

	int32 scrollpos_y;

   414

	byte data_1;

   415

	byte data_2;

   416

	byte data_3;

   417

} vp2_d;

   418

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp2_d));

   419

   420

typedef struct {

   421

	uint16 follow_vehicle;

   422

	int32 scrollpos_x;

   423

	int32 scrollpos_y;

   424

	NewsItem *ni;

   425

} news_d;

   426

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   427

   428

typedef struct {

   429

	uint32 background_img;

   430

	int8 rank;

   431

} highscore_d;

   432

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   433

   434

typedef struct {

   435

	int height;

   436

	uint16 counter;

   437

} scroller_d;

   438

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   439

   440

typedef enum VehicleListFlags {

   441

	VL_DESC    = 0x01,

   442

	VL_RESORT  = 0x02,

   443

	VL_REBUILD = 0x04

   444

} VehicleListFlags;

   445

   446

typedef struct vehiclelist_d {

   447

	SortStruct *sort_list;

   448

	uint16 list_length;

   449

	byte sort_type;

   450

	VehicleListFlags flags;

   451

	uint16 resort_timer;

   452

} vehiclelist_d;

   453

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

enum WindowEvents {

   463

	WE_CLICK = 0,

   464

	WE_PAINT = 1,

   465

	WE_MOUSELOOP = 2,

   466

	WE_TICK = 3,

   467

	WE_4 = 4,

   468

	WE_TIMEOUT = 5,

   469

	WE_PLACE_OBJ = 6,

   470

	WE_ABORT_PLACE_OBJ = 7,

   471

	WE_DESTROY = 8,

   472

	WE_ON_EDIT_TEXT = 9,

   473

	WE_POPUPMENU_SELECT = 10,

   474

	WE_POPUPMENU_OVER = 11,

   475

	WE_DRAGDROP = 12,

   476

	WE_PLACE_DRAG = 13,

   477

	WE_PLACE_MOUSEUP = 14,

   478

	WE_PLACE_PRESIZE = 15,

   479

	WE_DROPDOWN_SELECT = 16,

   480

	WE_RCLICK = 17,

   481

	WE_KEYPRESS = 18,

   482

	WE_CREATE = 19,

   483

	WE_MOUSEOVER = 20,

   484

	WE_ON_EDIT_TEXT_CANCEL = 21,

   485

	WE_RESIZE = 22,

   486

	WE_MESSAGE = 23

   487

};

   488

   489

   490

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

   491

enum WindowWidgetBehaviours {

   492

	WWB_PUSHBUTTON = 1 << 5,

   493

	WWB_NODISBUTTON = 2 << 5,

   494

};

   495

   496

   497

enum WindowWidgetTypes {

   498

	WWT_EMPTY = 0,

   499

   500

	WWT_IMGBTN = 1,						/* button with image */

   501

	WWT_PANEL = WWT_IMGBTN,

   502

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

   503

   504

	WWT_TEXTBTN = 3,					/* button with text */

   505

	WWT_CLOSEBOX = WWT_TEXTBTN,

   506