1

/* $Id$ */

     2

     3

#ifndef WINDOW_H

     4

#define WINDOW_H

     5

     6

#include "macros.h"

     7

#include "string.h"

     8

#include "order.h"

     9

    10

typedef struct WindowEvent WindowEvent;

    11

    12

typedef void WindowProc(Window *w, WindowEvent *e);

    13

    14

/* How the resize system works:

    15

    First, you need to add a WWT_RESIZEBOX to the widgets, and you need

    16

     to add the flag WDF_RESIZABLE to the window. Now the window is ready

    17

     to resize itself.

    18

    As you may have noticed, all widgets have a RESIZE_XXX in their line.

    19

     This lines controls how the widgets behave on resize. RESIZE_NONE means

    20

     it doesn't do anything. Any other option let's one of the borders

    21

     move with the changed width/height. So if a widget has

    22

     RESIZE_RIGHT, and the window is made 5 pixels wider by the user,

    23

     the right of the window will also be made 5 pixels wider.

    24

    Now, what if you want to clamp a widget to the bottom? Give it the flag

    25

     RESIZE_TB. This is RESIZE_TOP + RESIZE_BOTTOM. Now if the window gets

    26

     5 pixels bigger, both the top and bottom gets 5 bigger, so the whole

    27

     widgets moves downwards without resizing, and appears to be clamped

    28

     to the bottom. Nice aint it?

    29

   You should know one more thing about this system. Most windows can't

    30

    handle an increase of 1 pixel. So there is a step function, which

    31

    let the windowsize only be changed by X pixels. You configure this

    32

    after making the window, like this:

    33

      w->resize.step_height = 10;

    34

    Now the window will only change in height in steps of 10.

    35

   You can also give a minimum width and height. The default value is

    36

    the default height/width of the window itself. You can change this

    37

    AFTER window-creation, with:

    38

     w->resize.width or w->resize.height.

    39

   That was all.. good luck, and enjoy :) -- TrueLight */

    40

    41

enum ResizeFlags {

    42

	RESIZE_NONE   = 0,

    43

    44

	RESIZE_LEFT   = 1,

    45

	RESIZE_RIGHT  = 2,

    46

	RESIZE_TOP    = 4,

    47

	RESIZE_BOTTOM = 8,

    48

    49

	RESIZE_LR     = RESIZE_LEFT  | RESIZE_RIGHT,

    50

	RESIZE_RB     = RESIZE_RIGHT | RESIZE_BOTTOM,

    51

	RESIZE_TB     = RESIZE_TOP   | RESIZE_BOTTOM,

    52

	RESIZE_LRB    = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_BOTTOM,

    53

	RESIZE_LRTB   = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_TOP | RESIZE_BOTTOM,

    54

	RESIZE_RTB    = RESIZE_RIGHT | RESIZE_TOP    | RESIZE_BOTTOM,

    55

    56

	/* The following flags are used by the system to specify what is disabled, hidden, or clicked

    57

	 * They are used in the same place as the above RESIZE_x flags, Widget visual_flags.

    58

	 * These states are used in exceptions. If nothing is specified, they will indicate

    59

	 * Enabled, visible or unclicked widgets*/

    60

	WIDG_DISABLED = 4,  // widget is greyed out, not available

    61

	WIDG_HIDDEN   = 5,  // widget is made invisible

    62

	WIDG_LOWERED  = 6,  // widget is paint lowered, a pressed button in fact

    63

} ResizeFlag;

    64

    65

/* used to indicate the end of widgets' list for vararg functions */

    66

enum {

    67

	WIDGET_LIST_END = -1,

    68

};

    69

    70

typedef struct Widget {

    71

	byte type;                        ///< Widget type, see @WindowWidgetTypes

    72

	byte display_flags;               ///< Resize direction, alignment, etc. during resizing, see @ResizeFlags

    73

	byte color;                       ///< Widget colour, see docs/ottd-colourtext-palette.png

    74

	uint16 left, right, top, bottom;  ///< The position offsets inside the window

    75

	uint16 data;                      ///< The String/Image or special code (list-matrixes) of a widget

    76

	StringID tooltips;                ///< Tooltips that are shown when rightclicking on a widget

    77

} Widget;

    78

    79

typedef enum FrameFlags {

    80

	FR_TRANSPARENT  = 0x01,  ///< Makes the background transparent if set

    81

	FR_BORDERONLY   = 0x10,  ///< Draw border only, no background

    82

	FR_LOWERED      = 0x20,  ///< If set the frame is lowered and the background color brighter (ie. buttons when pressed)

    83

	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)

    84

} FrameFlags;

    85

    86

void DrawFrameRect(int left, int top, int right, int bottom, int color, FrameFlags flags);

    87

    88

enum WindowEventCodes {

    89

	WE_CLICK               =  0,

    90

	WE_PAINT               =  1,

    91

	WE_MOUSELOOP           =  2,

    92

	WE_TICK                =  3,

    93

	WE_4                   =  4,

    94

	WE_TIMEOUT             =  5,

    95

	WE_PLACE_OBJ           =  6,

    96

	WE_ABORT_PLACE_OBJ     =  7,

    97

	WE_DESTROY             =  8,

    98

	WE_ON_EDIT_TEXT        =  9,

    99

	WE_POPUPMENU_SELECT    = 10,

   100

	WE_POPUPMENU_OVER      = 11,

   101

	WE_DRAGDROP            = 12,

   102

	WE_PLACE_DRAG          = 13,

   103

	WE_PLACE_MOUSEUP       = 14,

   104

	WE_PLACE_PRESIZE       = 15,

   105

	WE_DROPDOWN_SELECT     = 16,

   106

	WE_RCLICK              = 17,

   107

	WE_KEYPRESS            = 18,

   108

	WE_CREATE              = 19,

   109

	WE_MOUSEOVER           = 20,

   110

	WE_ON_EDIT_TEXT_CANCEL = 21,

   111

	WE_RESIZE              = 22,

   112

	WE_MESSAGE             = 23,

   113

	WE_SCROLL              = 24,

   114

	WE_MOUSEWHEEL          = 25,

   115

	WE_INVALIDATE_DATA     = 26,

   116

};

   117

   118

struct WindowEvent {

   119

	byte event;

   120

	union {

   121

		struct{

   122

			Point pt;

   123

			int widget;

   124

		} click;

   125

   126

		struct {

   127

			Point pt;

   128

			TileIndex tile;

   129

			TileIndex starttile;

   130

			int userdata;

   131

		} place;

   132

   133

		struct {

   134

			Point pt;

   135

			int widget;

   136

		} dragdrop;

   137

   138

		struct {

   139

			Point size;

   140

			Point diff;

   141

		} sizing;

   142

   143

		struct {

   144

			char *str;

   145

		} edittext;

   146

   147

		struct {

   148

			Point pt;

   149

		} popupmenu;

   150

   151

		struct {

   152

			int button;

   153

			int index;

   154

		} dropdown;

   155

   156

		struct {

   157

			Point pt;

   158

			int widget;

   159

		} mouseover;

   160

   161

		struct {

   162

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

   163

			uint16 key;    // 16-bit Unicode value of the key

   164

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

   165

		} keypress;

   166

   167

		struct {

   168

			uint msg;      // message to be sent

   169

			uint wparam;   // additional message-specific information

   170

			uint lparam;   // additional message-specific information

   171

		} message;

   172

   173

		struct {

   174

			Point delta;   // delta position against position of last call

   175

		} scroll;

   176

   177

		struct {

   178

			int wheel;     // how much was 'wheel'd'

   179

		} wheel;

   180

	} we;

   181

};

   182

   183

enum WindowKeyCodes {

   184

	WKC_SHIFT = 0x8000,

   185

	WKC_CTRL  = 0x4000,

   186

	WKC_ALT   = 0x2000,

   187

	WKC_META  = 0x1000,

   188

   189

	// Special ones

   190

	WKC_NONE        =  0,

   191

	WKC_ESC         =  1,

   192

	WKC_BACKSPACE   =  2,

   193

	WKC_INSERT      =  3,

   194

	WKC_DELETE      =  4,

   195

   196

	WKC_PAGEUP      =  5,

   197

	WKC_PAGEDOWN    =  6,

   198

	WKC_END         =  7,

   199

	WKC_HOME        =  8,

   200

   201

	// Arrow keys

   202

	WKC_LEFT        =  9,

   203

	WKC_UP          = 10,

   204

	WKC_RIGHT       = 11,

   205

	WKC_DOWN        = 12,

   206

   207

	// Return & tab

   208

	WKC_RETURN      = 13,

   209

	WKC_TAB         = 14,

   210

   211

	// Numerical keyboard

   212

	WKC_NUM_0       = 16,

   213

	WKC_NUM_1       = 17,

   214

	WKC_NUM_2       = 18,

   215

	WKC_NUM_3       = 19,

   216

	WKC_NUM_4       = 20,

   217

	WKC_NUM_5       = 21,

   218

	WKC_NUM_6       = 22,

   219

	WKC_NUM_7       = 23,

   220

	WKC_NUM_8       = 24,

   221

	WKC_NUM_9       = 25,

   222

	WKC_NUM_DIV     = 26,

   223

	WKC_NUM_MUL     = 27,

   224

	WKC_NUM_MINUS   = 28,

   225

	WKC_NUM_PLUS    = 29,

   226

	WKC_NUM_ENTER   = 30,

   227

	WKC_NUM_DECIMAL = 31,

   228

   229

	// Space

   230

	WKC_SPACE       = 32,

   231

   232

	// Function keys

   233

	WKC_F1          = 33,

   234

	WKC_F2          = 34,

   235

	WKC_F3          = 35,

   236

	WKC_F4          = 36,

   237

	WKC_F5          = 37,

   238

	WKC_F6          = 38,

   239

	WKC_F7          = 39,

   240

	WKC_F8          = 40,

   241

	WKC_F9          = 41,

   242

	WKC_F10         = 42,

   243

	WKC_F11         = 43,

   244

	WKC_F12         = 44,

   245

   246

	// backquote is the key left of "1"

   247

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

   248

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

   249

	WKC_BACKQUOTE   = 45,

   250

	WKC_PAUSE       = 46,

   251

   252

	// 0-9 are mapped to 48-57

   253

	// A-Z are mapped to 65-90

   254

	// a-z are mapped to 97-122

   255

};

   256

   257

typedef struct WindowDesc {

   258

	int16 left, top, width, height;

   259

	WindowClass cls;

   260

	WindowClass parent_cls;

   261

	uint32 flags;

   262

	const Widget *widgets;

   263

	WindowProc *proc;

   264

} WindowDesc;

   265

   266

enum {

   267

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

   268

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

   269

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

   270

   271

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

   272

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

   273

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

   274

};

   275

   276

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

   277

enum {

   278

	WDP_AUTO      = -1, ///< Find a place automatically

   279

	WDP_CENTER    = -2, ///< Center the window (left/right or top/bottom)

   280

	WDP_ALIGN_TBR = -3, ///< Align the right side of the window with the right side of the main toolbar

   281

	WDP_ALIGN_TBL = -4, ///< Align the left side of the window with the left side of the main toolbar

   282

};

   283

   284

typedef struct Textbuf {

   285

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

   286

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

   287

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

   288

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

   289

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

   290

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

   291

} Textbuf;

   292

   293

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

   294

/* You cannot 100% reliably calculate the biggest custom struct as

   295

 * the number of pointers in it and alignment will have a huge impact.

   296

 * 96 is the largest window-size for 64-bit machines currently */

   297

#define WINDOW_CUSTOM_SIZE 96

   298

   299

typedef struct Scrollbar {

   300

	uint16 count, cap, pos;

   301

} Scrollbar;

   302

   303

typedef struct ResizeInfo {

   304

	uint width; /* Minimum width and height */

   305

	uint height;

   306

   307

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

   308

	uint step_height;

   309

} ResizeInfo;

   310

   311

typedef struct WindowMessage {

   312

		int msg;

   313

		int wparam;

   314

		int lparam;

   315

} WindowMessage;

   316

   317

struct Window {

   318

	uint16 flags4;

   319

	WindowClass window_class;

   320

	WindowNumber window_number;

   321

   322

	int left, top;

   323

	int width, height;

   324

   325

	Scrollbar hscroll, vscroll, vscroll2;

   326

	ResizeInfo resize;

   327

   328

	byte caption_color;

   329

   330

	WindowProc *wndproc;

   331

	ViewPort *viewport;

   332

	const Widget *original_widget;

   333

	Widget *widget;

   334

	uint widget_count;

   335

	uint32 desc_flags;

   336

   337

	WindowMessage message;

   338

	byte custom[WINDOW_CUSTOM_SIZE];

   339

};

   340

   341

typedef struct querystr_d {

   342

	StringID caption;

   343

	WindowClass wnd_class;

   344

	WindowNumber wnd_num;

   345

	Textbuf text;

   346

	const char *orig;

   347

	CharSetFilter afilter;

   348

} querystr_d;

   349

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d));

   350

   351

typedef struct chatquerystr_d {

   352

	StringID caption;

   353

	WindowClass wnd_class;

   354

	WindowNumber wnd_num;

   355

	Textbuf text;

   356

	const char *orig;

   357

	CharSetFilter afilter;

   358

	int dest;

   359

} chatquerystr_d;

   360

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(chatquerystr_d));

   361

   362

typedef struct query_d {

   363

	StringID caption;

   364

	StringID message;

   365

	WindowClass wnd_class;

   366

	WindowNumber wnd_num;

   367

	void (*ok_cancel_callback)(bool ok_clicked);

   368

	bool calledback;

   369

} query_d;

   370

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(query_d));

   371

   372

typedef struct {

   373

	byte item_count;      /* follow_vehicle */

   374

	byte sel_index;       /* scrollpos_x */

   375

	byte main_button;     /* scrollpos_y */

   376

	byte action_id;

   377

	StringID string_id;   /* unk30 */

   378

	uint16 checked_items; /* unk32 */

   379

	byte disabled_items;

   380

} menu_d;

   381

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   382

   383

typedef struct {

   384

	int16 data_1, data_2, data_3;

   385

	int16 data_4, data_5;

   386

	bool close;

   387

	byte byte_1;

   388

} def_d;

   389

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   390

   391

typedef struct {

   392

	void *data;

   393

} void_d;

   394

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   395

   396

typedef struct {

   397

	uint16 base;

   398

	uint16 count;

   399

} tree_d;

   400

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   401

   402

typedef struct {

   403

	StringID string_id;

   404

	byte paramcount;

   405

	uint32 params[5];

   406

} tooltips_d;

   407

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   408

   409

typedef struct {

   410

	byte vehicle_type;

   411

	union {

   412

		byte railtype;

   413

		byte acc_planes; // AIRCRAFT_ONLY, ALL, HELICOPTERS_ONLY

   414

	} filter;

   415

	byte sel_index;  // deprecated value, used for 'unified' ship and road

   416

	bool descending_sort_order;

   417

	byte sort_criteria;

   418

	EngineID sel_engine;

   419

	EngineID rename_engine;

   420

	EngineList eng_list;

   421

} buildvehicle_d;

   422

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildvehicle_d));

   423

   424

typedef struct {

   425

	byte vehicletype;

   426

	byte sel_index[2];

   427

	EngineID sel_engine[2];

   428

	uint16 count[2];

   429

	bool wagon_btnstate; // true means engine is selected

   430

} replaceveh_d;

   431

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   432

   433

typedef struct {

   434

	VehicleID sel;

   435

	byte type;

   436

	bool generate_list;

   437

	uint16 engine_list_length;

   438

	uint16 wagon_list_length;

   439

	uint16 engine_count;

   440

	uint16 wagon_count;

   441

	Vehicle **vehicle_list;

   442

	Vehicle **wagon_list;

   443

} depot_d;

   444

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   445

   446

typedef struct {

   447

	int sel;

   448

} order_d;

   449

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   450

   451

typedef struct {

   452

	byte tab;

   453

} traindetails_d;

   454

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   455

   456

typedef struct {

   457

	int32 scroll_x;

   458

	int32 scroll_y;

   459

	int32 subscroll;

   460

} smallmap_d;

   461

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   462

   463

typedef struct {

   464

	uint32 face;

   465

	byte gender;

   466

} facesel_d;

   467

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   468

   469

typedef struct {

   470

	int sel;

   471

	struct RefitOption *cargo;

   472

	struct RefitList *list;

   473

	uint length;

   474

	VehicleOrderID order;

   475

} refit_d;

   476

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   477

   478

typedef struct {

   479

	VehicleID follow_vehicle;

   480

	int32 scrollpos_x;

   481

	int32 scrollpos_y;

   482

} vp_d;

   483

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   484

   485

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

   486

typedef struct {

   487

	VehicleID follow_vehicle;

   488

	int32 scrollpos_x;

   489

	int32 scrollpos_y;

   490

	byte data_1;

   491

	byte data_2;

   492

	byte data_3;

   493

} vp2_d;