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

#include "rail.h"

    10

#include "airport.h"

    11

    12

typedef struct WindowEvent WindowEvent;

    13

    14

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

    15

    16

/* How the resize system works:

    17

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

    18

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

    19

     to resize itself.

    20

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

    21

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

    22

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

    23

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

    24

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

    25

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

    26

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

    27

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

    28

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

    29

     widgets moves downwards without resizing, and appears to be clamped

    30

     to the bottom. Nice aint it?

    31

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

    32

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

    33

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

    34

    after making the window, like this:

    35

      w->resize.step_height = 10;

    36

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

    37

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

    38

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

    39

    AFTER window-creation, with:

    40

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

    41

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

    42

    43

typedef enum ResizeFlags {

    44

	RESIZE_NONE   = 0,

    45

    46

	RESIZE_LEFT   = 1,

    47

	RESIZE_RIGHT  = 2,

    48

	RESIZE_TOP    = 4,

    49

	RESIZE_BOTTOM = 8,

    50

    51

	RESIZE_LR     = RESIZE_LEFT  | RESIZE_RIGHT,

    52

	RESIZE_RB     = RESIZE_RIGHT | RESIZE_BOTTOM,

    53

	RESIZE_TB     = RESIZE_TOP   | RESIZE_BOTTOM,

    54

	RESIZE_LRB    = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_BOTTOM,

    55

	RESIZE_LRTB   = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_TOP | RESIZE_BOTTOM,

    56

	RESIZE_RTB    = RESIZE_RIGHT | RESIZE_TOP    | RESIZE_BOTTOM,

    57

    58

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

    59

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

    60

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

    61

	 * Enabled, visible or unclicked widgets*/

    62

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

    63

	WIDG_HIDDEN   = 5,  // widget is made invisible

    64

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

    65

} ResizeFlag;

    66

    67

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

    68

enum {

    69

	WIDGET_LIST_END = -1,

    70

};

    71

    72

typedef struct Widget {

    73

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

    74

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

    75

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

    76

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

    77

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

    78

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

    79

} Widget;

    80

    81

typedef enum FrameFlags {

    82

	FR_NONE         = 0x00,

    83

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

    84

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

    85

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

    86

	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)

    87

} FrameFlags;

    88

    89

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

    90

    91

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

    92

    93

enum WindowEventCodes {

    94

	WE_CREATE,

    95

	WE_DESTROY,

    96

	WE_PAINT,

    97

	WE_KEYPRESS,

    98

	WE_CLICK,

    99

	WE_RCLICK,

   100

	WE_MOUSEOVER,

   101

	WE_MOUSELOOP,

   102

	WE_MOUSEWHEEL,

   103

	WE_TICK,

   104

	WE_4,

   105

	WE_TIMEOUT,

   106

	WE_PLACE_OBJ,

   107

	WE_ABORT_PLACE_OBJ,

   108

	WE_ON_EDIT_TEXT,

   109

	WE_ON_EDIT_TEXT_CANCEL,

   110

	WE_POPUPMENU_SELECT,

   111

	WE_POPUPMENU_OVER,

   112

	WE_DRAGDROP,

   113

	WE_PLACE_DRAG,

   114

	WE_PLACE_MOUSEUP,

   115

	WE_PLACE_PRESIZE,

   116

	WE_DROPDOWN_SELECT,

   117

	WE_RESIZE,

   118

	WE_MESSAGE,

   119

	WE_SCROLL,

   120

	WE_INVALIDATE_DATA,

   121

};

   122

   123

struct WindowEvent {

   124

	byte event;

   125

	union {

   126

		struct{

   127

			Point pt;

   128

			int widget;

   129

		} click;

   130

   131

		struct {

   132

			Point pt;

   133

			TileIndex tile;

   134

			TileIndex starttile;

   135

			int userdata;

   136

		} place;

   137

   138

		struct {

   139

			Point pt;

   140

			int widget;

   141

		} dragdrop;

   142

   143

		struct {

   144

			Point size;

   145

			Point diff;

   146

		} sizing;

   147

   148

		struct {

   149

			char *str;

   150

		} edittext;

   151

   152

		struct {

   153

			Point pt;

   154

		} popupmenu;

   155

   156

		struct {

   157

			int button;

   158

			int index;

   159

		} dropdown;

   160

   161

		struct {

   162

			Point pt;

   163

			int widget;

   164

		} mouseover;

   165

   166

		struct {

   167

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

   168

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

   169

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

   170

		} keypress;

   171

   172

		struct {

   173

			int msg;      // message to be sent

   174

			int wparam;   // additional message-specific information

   175

			int lparam;   // additional message-specific information

   176

		} message;

   177

   178

		struct {

   179

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

   180

		} scroll;

   181

   182

		struct {

   183

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

   184

		} wheel;

   185

	} we;

   186

};

   187

   188

typedef struct WindowDesc {

   189

	int16 left, top, width, height;

   190

	WindowClass cls;

   191

	WindowClass parent_cls;

   192

	uint32 flags;

   193

	const Widget *widgets;

   194

	WindowProc *proc;

   195

} WindowDesc;

   196

   197

enum WindowDefaultFlag {

   198

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

   199

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

   200

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

   201

   202

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

   203

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

   204

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

   205

	WDF_MODAL           = 128, /* The window is a modal child of some other window, meaning the parent is 'inactive' */

   206

};

   207

   208

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

   209

enum WindowDefaultPosition {

   210

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

   211

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

   212

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

   213

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

   214

};

   215

   216

typedef struct Textbuf {

   217

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

   218

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

   219

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

   220

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

   221

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

   222

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

   223

} Textbuf;

   224

   225

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

   226

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

   227

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

   228

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

   229

#define WINDOW_CUSTOM_SIZE 96

   230

   231

typedef struct Scrollbar {

   232

	uint16 count, cap, pos;

   233

} Scrollbar;

   234

   235

typedef struct ResizeInfo {

   236

	uint width; /* Minimum width and height */

   237

	uint height;

   238

   239

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

   240

	uint step_height;

   241

} ResizeInfo;

   242

   243

typedef struct WindowMessage {

   244

		int msg;

   245

		int wparam;

   246

		int lparam;

   247

} WindowMessage;

   248

   249

struct Window {

   250

	uint16 flags4;

   251

	WindowClass window_class;

   252

	WindowNumber window_number;

   253

   254

	int left, top;

   255

	int width, height;

   256

   257

	Scrollbar hscroll, vscroll, vscroll2;

   258

	ResizeInfo resize;

   259

   260

	byte caption_color;

   261

   262

	WindowProc *wndproc;

   263

	ViewPort *viewport;

   264

	const Widget *original_widget;

   265

	Widget *widget;

   266

	uint widget_count;

   267

	uint32 desc_flags;

   268

   269

	WindowMessage message;

   270

	Window *parent;

   271

	byte custom[WINDOW_CUSTOM_SIZE];

   272

};

   273

   274

typedef struct querystr_d {

   275

	StringID caption;

   276

	Textbuf text;

   277

	const char *orig;

   278

	CharSetFilter afilter;

   279

	bool handled;

   280

} querystr_d;

   281

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d));

   282

   283

typedef struct {

   284

	byte item_count;      /* follow_vehicle */

   285

	byte sel_index;       /* scrollpos_x */

   286

	byte main_button;     /* scrollpos_y */

   287

	byte action_id;

   288

	StringID string_id;   /* unk30 */

   289

	uint16 checked_items; /* unk32 */

   290

	byte disabled_items;

   291

} menu_d;

   292

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   293

   294

typedef struct {

   295

	int16 data_1, data_2, data_3;

   296

	int16 data_4, data_5;

   297

	bool close;

   298

	byte byte_1;

   299

} def_d;

   300

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   301

   302

typedef struct {

   303

	void *data;

   304

} void_d;

   305

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   306

   307

typedef struct {

   308

	uint16 base;

   309

	uint16 count;

   310

} tree_d;

   311

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   312

   313

typedef struct {

   314

	StringID string_id;

   315

	byte paramcount;

   316

	uint32 params[5];

   317

} tooltips_d;

   318

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   319

   320

typedef struct {

   321

	byte vehicle_type;

   322

	union {

   323

		RailTypeByte railtype;

   324

		AcceptPlanesByte acc_planes; // AIRCRAFT_ONLY, ALL, HELICOPTERS_ONLY

   325

	} filter;

   326

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

   327

	bool descending_sort_order;

   328

	byte sort_criteria;

   329

	EngineID sel_engine;

   330

	EngineID rename_engine;

   331

	EngineList eng_list;

   332

} buildvehicle_d;

   333

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildvehicle_d));

   334

   335

typedef struct {

   336

	byte vehicletype;

   337

	byte sel_index[2];

   338

	EngineID sel_engine[2];

   339

	uint16 count[2];

   340

	bool wagon_btnstate; // true means engine is selected

   341

} replaceveh_d;

   342

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   343

   344

typedef struct {

   345

	VehicleID sel;

   346

	byte type;

   347

	bool generate_list;

   348

	uint16 engine_list_length;

   349

	uint16 wagon_list_length;

   350

	uint16 engine_count;

   351

	uint16 wagon_count;

   352

	Vehicle **vehicle_list;

   353

	Vehicle **wagon_list;

   354

} depot_d;

   355

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   356

   357

typedef struct {

   358

	int sel;

   359

} order_d;

   360

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   361

   362

typedef struct {

   363

	byte tab;

   364

} traindetails_d;

   365

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   366

   367

typedef struct {

   368

	int32 scroll_x;

   369

	int32 scroll_y;

   370

	int32 subscroll;

   371

} smallmap_d;

   372

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   373

   374

typedef struct {

   375

	uint32 face;

   376

	byte gender;

   377

} facesel_d;

   378

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   379

   380

typedef struct {

   381

	int sel;

   382

	struct RefitOption *cargo;

   383

	struct RefitList *list;

   384

	uint length;

   385

	VehicleOrderID order;

   386

} refit_d;

   387

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   388

   389

typedef struct {

   390

	VehicleID follow_vehicle;

   391

	int32 scrollpos_x;

   392

	int32 scrollpos_y;

   393

} vp_d;

   394

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   395

   396

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

   397

typedef struct {

   398

	VehicleID follow_vehicle;

   399

	int32 scrollpos_x;

   400

	int32 scrollpos_y;

   401

	byte data_1;

   402

	byte data_2;

   403

	byte data_3;

   404

} vp2_d;

   405

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp2_d));

   406

   407

typedef struct {

   408

	uint16 follow_vehicle;

   409

	int32 scrollpos_x;

   410

	int32 scrollpos_y;

   411

	NewsItem *ni;

   412

} news_d;

   413

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   414

   415

typedef struct {

   416

	uint32 background_img;

   417

	int8 rank;

   418

} highscore_d;

   419

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   420

   421

typedef struct {

   422

	int height;

   423

	uint16 counter;

   424

} scroller_d;

   425

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   426

   427

typedef enum SortListFlags {

   428

	VL_NONE    = 0x00,

   429

	VL_DESC    = 0x01,  // sort descending or ascending

   430

	VL_RESORT  = 0x02,  // instruct the code to resort the list in the next loop

   431

	VL_REBUILD = 0x04,  // create sort-listing to use for qsort and friends

   432

	VL_END     = 0x08

   433

} SortListFlags;

   434

   435

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   436

   437

typedef struct Listing {

   438

	bool order;    // Ascending/descending

   439

	byte criteria; // Sorting criteria

   440

} Listing;

   441

   442

typedef struct list_d {

   443

	uint16 list_length;  // length of the list being sorted

   444

	byte sort_type;      // what criteria to sort on

   445

	SortListFlags flags; // used to control sorting/resorting/etc.

   446

	uint16 resort_timer; // resort list after a given amount of ticks if set

   447

} list_d;

   448

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   449

   450

typedef struct message_d {

   451

	int msg;

   452

	int wparam;

   453

	int lparam;

   454

} message_d;

   455

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   456

   457

typedef struct dropdown_d {

   458

	uint32 disabled_state;

   459

	uint32 hidden_state;

   460

	WindowClass parent_wnd_class;

   461

	WindowNumber parent_wnd_num;

   462

	byte parent_button;

   463

	byte num_items;

   464

	byte selected_index;

   465

	const StringID *items;

   466

	byte click_delay;

   467

	bool drag_mode;

   468

} dropdown_d;

   469

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(dropdown_d));

   470

   471

   472

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

   473

enum WindowWidgetBehaviours {

   474

	WWB_PUSHBUTTON  = 1 << 5,

   475

   476

	WWB_MASK        = 0xE0,

   477

};

   478

   479

   480

enum WindowWidgetTypes {

   481

	WWT_EMPTY,

   482

   483

	WWT_PANEL,      /* simple depressed panel */

   484

	WWT_INSET,      /* pressed (inset) panel, most commonly used as combo box _text_ area */

   485

	WWT_IMGBTN,     /* button with image */

   486

	WWT_IMGBTN_2,   /* button with diff image when clicked */

   487

   488

	WWT_TEXTBTN,    /* button with text */

   489

	WWT_TEXTBTN_2,  /* button with diff text when clicked */

   490

	WWT_LABEL,      /* centered label */

   491

	WWT_MATRIX,