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

	bool regenerate_list;

   330

	EngineID sel_engine;

   331

	EngineID rename_engine;

   332

	EngineList eng_list;

   333

} buildvehicle_d;

   334

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildvehicle_d));

   335

   336

typedef struct {

   337

	byte vehicletype;

   338

	byte sel_index[2];

   339

	EngineID sel_engine[2];

   340

	uint16 count[2];

   341

	bool wagon_btnstate; // true means engine is selected

   342

} replaceveh_d;

   343

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   344

   345

typedef struct {

   346

	VehicleID sel;

   347

	byte type;

   348

	bool generate_list;

   349

	uint16 engine_list_length;

   350

	uint16 wagon_list_length;

   351

	uint16 engine_count;

   352

	uint16 wagon_count;

   353

	Vehicle **vehicle_list;

   354

	Vehicle **wagon_list;

   355

} depot_d;

   356

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   357

   358

typedef struct {

   359

	int sel;

   360

} order_d;

   361

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   362

   363

typedef struct {

   364

	byte tab;

   365

} traindetails_d;

   366

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(traindetails_d));

   367

   368

typedef struct {

   369

	int32 scroll_x;

   370

	int32 scroll_y;

   371

	int32 subscroll;

   372

} smallmap_d;

   373

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   374

   375

typedef struct {

   376

	uint32 face;

   377

	byte gender;

   378

} facesel_d;

   379

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   380

   381

typedef struct {

   382

	int sel;

   383

	struct RefitOption *cargo;

   384

	struct RefitList *list;

   385

	uint length;

   386

	VehicleOrderID order;

   387

} refit_d;

   388

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   389

   390

typedef struct {

   391

	VehicleID follow_vehicle;

   392

	int32 scrollpos_x;

   393

	int32 scrollpos_y;

   394

} vp_d;

   395

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   396

   397

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

   398

typedef struct {

   399

	VehicleID follow_vehicle;

   400

	int32 scrollpos_x;

   401

	int32 scrollpos_y;

   402

	byte data_1;

   403

	byte data_2;

   404

	byte data_3;

   405

} vp2_d;

   406

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp2_d));

   407

   408

typedef struct {

   409

	uint16 follow_vehicle;

   410

	int32 scrollpos_x;

   411

	int32 scrollpos_y;

   412

	NewsItem *ni;

   413

} news_d;

   414

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   415

   416

typedef struct {

   417

	uint32 background_img;

   418

	int8 rank;

   419

} highscore_d;

   420

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   421

   422

typedef struct {

   423

	int height;

   424

	uint16 counter;

   425

} scroller_d;

   426

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   427

   428

typedef enum SortListFlags {

   429

	VL_NONE    = 0x00,

   430

	VL_DESC    = 0x01,  // sort descending or ascending

   431

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

   432

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

   433

	VL_END     = 0x08

   434

} SortListFlags;

   435

   436

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   437

   438

typedef struct Listing {

   439

	bool order;    // Ascending/descending

   440

	byte criteria; // Sorting criteria

   441

} Listing;

   442

   443

typedef struct list_d {

   444

	uint16 list_length;  // length of the list being sorted

   445

	byte sort_type;      // what criteria to sort on

   446

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

   447

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

   448

} list_d;

   449

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   450

   451

typedef struct message_d {

   452

	int msg;

   453

	int wparam;

   454

	int lparam;

   455

} message_d;

   456

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   457

   458

typedef struct dropdown_d {

   459

	uint32 disabled_state;

   460

	uint32 hidden_state;

   461

	WindowClass parent_wnd_class;

   462

	WindowNumber parent_wnd_num;

   463

	byte parent_button;

   464

	byte num_items;

   465

	byte selected_index;

   466

	const StringID *items;

   467

	byte click_delay;

   468

	bool drag_mode;

   469

} dropdown_d;

   470

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(dropdown_d));

   471

   472

   473

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

   474

enum WindowWidgetBehaviours {

   475

	WWB_PUSHBUTTON  = 1 << 5,

   476

   477

	WWB_MASK        = 0xE0,

   478

};

   479

   480

   481

enum WindowWidgetTypes {

   482

	WWT_EMPTY,

   483

   484

	WWT_PANEL,      /* simple depressed panel */

   485

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

   486

	WWT_IMGBTN,     /* button with image */

   487

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

   488

   489

	WWT_TEXTBTN,    /* button with text */

   490

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

   491