1

/* $Id$ */

     2

     3

/** @file window.h regroups declarations for all windowing system, as well as a few helper functions */

     4

     5

#ifndef WINDOW_H

     6

#define WINDOW_H

     7

     8

#include "macros.h"

     9

#include "string.h"

    10

#include "order.h"

    13

#include "airport.h"

    14

#include "vehicle.h"

    15

#include "viewport.h"

    16

    17

/**

    18

 * The maximum number of windows that can be opened.

    19

 */

    20

static const int MAX_NUMBER_OF_WINDOWS = 25;

    21

    22

struct WindowEvent;

    23

    24

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

    25

    26

/* How the resize system works:

    27

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

    28

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

    29

     to resize itself.

    30

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

    31

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

    32

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

    33

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

    34

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

    35

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

    36

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

    37

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

    38

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

    39

     widgets moves downwards without resizing, and appears to be clamped

    40

     to the bottom. Nice aint it?

    41

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

    42

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

    43

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

    44

    after making the window, like this:

    45

      w->resize.step_height = 10;

    46

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

    47

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

    48

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

    49

    AFTER window-creation, with:

    50

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

    51

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

    52

    53

enum ResizeFlag {

    54

	RESIZE_NONE   = 0,  ///< no resize required

    55

    56

	RESIZE_LEFT   = 1,  ///< left resize flag

    57

	RESIZE_RIGHT  = 2,  ///< rigth resize flag

    58

	RESIZE_TOP    = 4,  ///< top resize flag

    59

	RESIZE_BOTTOM = 8,  ///< bottom resize flag

    60

    61

	RESIZE_LR     = RESIZE_LEFT  | RESIZE_RIGHT,   ///<  combination of left and right resize flags

    62

	RESIZE_RB     = RESIZE_RIGHT | RESIZE_BOTTOM,  ///<  combination of right and bottom resize flags

    63

	RESIZE_TB     = RESIZE_TOP   | RESIZE_BOTTOM,  ///<  combination of top and bottom resize flags

    64

	RESIZE_LRB    = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_BOTTOM, ///< combination of left, right and bottom resize flags

    65

	RESIZE_LRTB   = RESIZE_LEFT  | RESIZE_RIGHT  | RESIZE_TOP | RESIZE_BOTTOM,  ///<  combination of all resize flags

    66

	RESIZE_RTB    = RESIZE_RIGHT | RESIZE_TOP    | RESIZE_BOTTOM, ///<  combination of right, top and bottom resize flag

    67

    68

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

    69

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

    70

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

    71

	 * Enabled, visible or unclicked widgets*/

    72

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

    73

	WIDG_HIDDEN   = 5,  ///< widget is made invisible

    74

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

    75

};

    76

    77

enum {

    78

	WIDGET_LIST_END = -1, ///< indicate the end of widgets' list for vararg functions

    79

};

    80

    81

struct Widget {

    82

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

    83

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

    84

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

    85

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

    86

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

    87

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

    88

};

    89

    90

enum FrameFlags {

    91

	FR_NONE         =  0,

    92

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

    93

	FR_BORDERONLY   =  1 << 4,  ///< Draw border only, no background

    94

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

    95

	FR_DARKENED     =  1 << 6,  ///< If set the background is darker, allows for lowered frames with normal background color when used with FR_LOWERED (ie. dropdown boxes)

    96

};

    97

    98

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

    99

   100

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

   101

   102

enum WindowEventCodes {

   103

	WE_CREATE,

   104

	WE_DESTROY,

   105

	WE_PAINT,

   106

	WE_KEYPRESS,

   107

	WE_CLICK,

   108

	WE_DOUBLE_CLICK,

   109

	WE_RCLICK,

   110

	WE_MOUSEOVER,

   111

	WE_MOUSELOOP,

   112

	WE_MOUSEWHEEL,

   113

	WE_TICK,

   114

	WE_4,

   115

	WE_TIMEOUT,

   116

	WE_PLACE_OBJ,

   117

	WE_ABORT_PLACE_OBJ,

   118

	WE_ON_EDIT_TEXT,

   119

	WE_ON_EDIT_TEXT_CANCEL,

   120

	WE_POPUPMENU_SELECT,

   121

	WE_POPUPMENU_OVER,

   122

	WE_DRAGDROP,

   123

	WE_PLACE_DRAG,

   124

	WE_PLACE_MOUSEUP,

   125

	WE_PLACE_PRESIZE,

   126

	WE_DROPDOWN_SELECT,

   127

	WE_RESIZE,

   128

	WE_MESSAGE,

   129

	WE_SCROLL,

   130

	WE_INVALIDATE_DATA,

   131

};

   132

   133

struct WindowEvent {

   134

	byte event;

   135

	union {

   136

		struct {

   137

			void *data;

   138

		} create;

   139

   140

		struct {

   141

			Point pt;

   142

			int widget;

   143

		} click;

   144

   145

		struct {

   146

			Point pt;

   147

			TileIndex tile;

   148

			TileIndex starttile;

   149

			ViewportPlaceMethod select_method;

   150

			byte select_proc;

   151

		} place;

   152

   153

		struct {

   154

			Point pt;

   155

			int widget;

   156

		} dragdrop;

   157

   158

		struct {

   159

			Point size;

   160

			Point diff;

   161

		} sizing;

   162

   163

		struct {

   164

			char *str;

   165

		} edittext;

   166

   167

		struct {

   168

			Point pt;

   169

		} popupmenu;

   170

   171

		struct {

   172

			int button;

   173

			int index;

   174

		} dropdown;

   175

   176

		struct {

   177

			Point pt;

   178

			int widget;

   179

		} mouseover;

   180

   181

		struct {

   182

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

   183

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

   184

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

   185

		} keypress;

   186

   187

		struct {

   188

			int msg;      ///< message to be sent

   189

			int wparam;   ///< additional message-specific information

   190

			int lparam;   ///< additional message-specific information

   191

		} message;

   192

   193

		struct {

   194

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

   195

		} scroll;

   196

   197

		struct {

   198

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

   199

		} wheel;

   200

	} we;

   201

};

   202

   203

struct WindowDesc {

   204

	int16 left, top, minimum_width, minimum_height, default_width, default_height;

   205

	WindowClass cls;

   206

	WindowClass parent_cls;

   207

	uint32 flags;

   208

	const Widget *widgets;

   209

	WindowProc *proc;

   210

};

   211

   212

enum WindowDefaultFlag {

   213

	WDF_STD_TOOLTIPS    =   1 << 0, ///< use standard routine when displaying tooltips

   214

	WDF_DEF_WIDGET      =   1 << 1, ///< default widget control for some widgets in the on click event

   215

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

   216

   217

	WDF_UNCLICK_BUTTONS =   1 << 4, ///< Unclick buttons when the window event times out */

   218

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

   219

	WDF_RESIZABLE       =   1 << 6, ///< A window can be resized

   220

	WDF_MODAL           =   1 << 7, ///< The window is a modal child of some other window, meaning the parent is 'inactive'

   221

};

   222

   223

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

   224

enum WindowDefaultPosition {

   225

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

   226

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

   227

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

   228

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

   229

};

   230

   231

struct Textbuf {

   232

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

   233

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

   234

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

   235

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

   236

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

   237

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

   238

};

   239

   240

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

   241

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

   242

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

   243

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

   244

#define WINDOW_CUSTOM_SIZE 96

   245

   246

struct Scrollbar {

   247

	uint16 count, cap, pos;

   248

};

   249

   250

struct ResizeInfo {

   251

	uint width; ///< Minimum width and height

   252

	uint height;

   253

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

   254

	uint step_height;

   255

};

   256

   257

struct WindowMessage {

   258

	int msg;

   259

	int wparam;

   260

	int lparam;

   261

};

   262

   263

struct Window {

   264

	uint16 flags4;

   265

	WindowClass window_class;

   266

	WindowNumber window_number;

   267

   268

	int left, top;

   269

	int width, height;

   270

   271

	Scrollbar hscroll, vscroll, vscroll2;

   272

	ResizeInfo resize;

   273

   274

	byte caption_color;

   275

   276

	WindowProc *wndproc;

   277

	ViewPort *viewport;

   278

	const Widget *original_widget;

   279

	Widget *widget;

   280

	uint widget_count;

   281

	uint32 desc_flags;

   282

   283

	WindowMessage message;

   284

	Window *parent;

   285

	byte custom[WINDOW_CUSTOM_SIZE];

   286

   287

	void HandleButtonClick(byte widget);

   288

   289

	void SetWidgetDisabledState(byte widget_index, bool disab_stat);

   290

	void DisableWidget(byte widget_index);

   291

	void EnableWidget(byte widget_index);

   292

	bool IsWidgetDisabled(byte widget_index) const;

   293

	void SetWidgetHiddenState(byte widget_index, bool hidden_stat);

   294

	void HideWidget(byte widget_index);

   295

	void ShowWidget(byte widget_index);

   296

	bool IsWidgetHidden(byte widget_index) const;

   297

	void SetWidgetLoweredState(byte widget_index, bool lowered_stat);

   298

	void ToggleWidgetLoweredState(byte widget_index);

   299

	void LowerWidget(byte widget_index);

   300

	void RaiseWidget(byte widget_index);

   301

	bool IsWidgetLowered(byte widget_index) const;

   302

   303

	void RaiseButtons();

   304

	void CDECL SetWidgetsDisabledState(bool disab_stat, int widgets, ...);

   305

	void CDECL SetWidgetsHiddenState(bool hidden_stat, int widgets, ...);

   306

	void CDECL SetWidgetsLoweredState(bool lowered_stat, int widgets, ...);

   307

	void InvalidateWidget(byte widget_index) const;

   308

};

   309

   310

struct querystr_d {

   311

	StringID caption;

   312

	Textbuf text;

   313

	const char *orig;

   314

	CharSetFilter afilter;

   315

	bool handled;

   316

};

   317

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d));

   318

   319

struct chatquerystr_d : public querystr_d {

   320

	int dest;

   321

};

   322

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(chatquerystr_d));

   323

   324

struct menu_d {

   325

	byte item_count;      ///< follow_vehicle

   326

	byte sel_index;       ///< scrollpos_x

   327

	byte main_button;     ///< scrollpos_y

   328

	byte action_id;

   329

	StringID string_id;   ///< unk30

   330

	uint16 checked_items; ///< unk32

   331

	byte disabled_items;

   332

};

   333

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   334

   335

struct def_d {

   336

	int16 data_1, data_2, data_3;

   337

	int16 data_4, data_5;

   338

	bool close;

   339

	byte byte_1;

   340

};

   341

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   342

   343

struct void_d {

   344

	void *data;

   345

};

   346

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   347

   348

struct tree_d {

   349

	uint16 base;

   350

	uint16 count;

   351

};

   352

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   353

   354

struct tooltips_d {

   355

	StringID string_id;

   356

	byte paramcount;

   357

	uint64 params[5];

   358

};

   359

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   360

   361

struct buildvehicle_d {

   362

	VehicleType vehicle_type;

   363

	union {

   364

		RailTypeByte railtype;

   365

		AirportFTAClass::Flags flags;

   366

		RoadTypes roadtypes;

   367

	} filter;

   368

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

   369

	bool descending_sort_order;

   370

	byte sort_criteria;

   371

	bool regenerate_list;

   372

	EngineID sel_engine;

   373

	EngineID rename_engine;

   374

	EngineList eng_list;

   375

};

   376

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildvehicle_d));

   377

   378

struct replaceveh_d {

   379

	byte sel_index[2];

   380

	EngineID sel_engine[2];

   381

	uint16 count[2];

   382

	bool wagon_btnstate; ///< true means engine is selected

   383

	EngineList list[2];

   384

	bool update_left;

   385

	bool update_right;

   386

	bool init_lists;

   387

	GroupID sel_group;

   388

};

   389

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   390

   391

struct depot_d {

   392

	VehicleID sel;

   393

	VehicleType type;

   394

	bool generate_list;

   395

	uint16 engine_list_length;

   396

	uint16 wagon_list_length;

   397

	uint16 engine_count;

   398

	uint16 wagon_count;

   399

	Vehicle **vehicle_list;

   400

	Vehicle **wagon_list;

   401

};

   402

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   403

   404

struct order_d {

   405

	int sel;

   406

};

   407

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   408

   409

struct vehicledetails_d {

   410

	byte tab;

   411

};

   412

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehicledetails_d));

   413

   414

struct smallmap_d {

   415

	int32 scroll_x;

   416

	int32 scroll_y;

   417

	int32 subscroll;

   418

};

   419

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   420

   421

/* player face selection window */

   422

struct facesel_d {

   423

	PlayerFace face; // player face bits

   424

	bool advanced;   // advance player face selection window

   425

};

   426

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   427

   428

struct refit_d {

   429

	int sel;

   430

	struct RefitOption *cargo;

   431

	struct RefitList *list;

   432

	uint length;

   433

	VehicleOrderID order;

   434

};

   435

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   436

   437

struct vp_d {

   438

	VehicleID follow_vehicle;

   439

	int32 scrollpos_x;

   440

	int32 scrollpos_y;

   441

	int32 dest_scrollpos_x;

   442

	int32 dest_scrollpos_y;

   443

};

   444

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   445

   446

struct news_d {

   447

	uint16 follow_vehicle;

   448

	int32 scrollpos_x;

   449

	int32 scrollpos_y;

   450

	int32 dest_scrollpos_x;

   451

	int32 dest_scrollpos_y;

   452

	NewsItem *ni;

   453

};

   454

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   455

   456

struct highscore_d {

   457

	uint32 background_img;

   458

	int8 rank;

   459

};

   460

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   461

   462

struct scroller_d {

   463

	int height;

   464

	uint16 counter;

   465

};

   466

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   467

   468

enum SortListFlags {

   469

	VL_NONE    = 0,      ///< no sort

   470

	VL_DESC    = 1 << 0, ///< sort descending or ascending

   471

	VL_RESORT  = 1 << 1, ///< instruct the code to resort the list in the next loop

   472

	VL_REBUILD = 1 << 2, ///< create sort-listing to use for qsort and friends

   473

	VL_END     = 1 << 3,

   474

};

   475

   476

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   477

   478

struct Listing {

   479

	bool order;    ///< Ascending/descending

   480

	byte criteria; ///< Sorting criteria

   481

};

   482

   483

struct list_d {

   484

	uint16 list_length;  ///< length of the list being sorted