1

/* $Id$ */

     2

     3

/** @file window_gui.h Functions, definitions and such used only by the GUI. */

     4

     5

#ifndef WINDOW_GUI_H

     6

#define WINDOW_GUI_H

     7

     8

#include "string.h"

     9

#include "order.h"

    10

#include "rail_type.h"

    11

#include "road_type.h"

    12

#include "airport.h"

    13

#include "vehicle_type.h"

    14

#include "viewport.h"

    15

    16

/**

    17

 * The maximum number of windows that can be opened.

    18

 */

    19

static const int MAX_NUMBER_OF_WINDOWS = 25;

    20

    21

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

    22

    23

/* How the resize system works:

    24

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

    25

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

    26

     to resize itself.

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

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

    34

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

    35

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

    36

     widgets moves downwards without resizing, and appears to be clamped

    37

     to the bottom. Nice aint it?

    38

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

    39

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

    40

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

    41

    after making the window, like this:

    42

      w->resize.step_height = 10;

    43

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

    44

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

    45

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

    46

    AFTER window-creation, with:

    47

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

    48

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

    49

    50

enum ResizeFlag {

    51

	RESIZE_NONE   = 0,  ///< no resize required

    52

    53

	RESIZE_LEFT   = 1,  ///< left resize flag

    54

	RESIZE_RIGHT  = 2,  ///< rigth resize flag

    55

	RESIZE_TOP    = 4,  ///< top resize flag

    56

	RESIZE_BOTTOM = 8,  ///< bottom resize flag

    57

    58

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

    59

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

    60

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

    61

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

    62

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

    63

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

    64

    65

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

    66

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

    67

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

    68

	 * Enabled, visible or unclicked widgets*/

    69

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

    70

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

    71

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

    72

};

    73

    74

enum {

    75

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

    76

};

    77

    78

struct Widget {

    79

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

    80

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

    81

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

    82

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

    83

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

    84

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

    85

};

    86

    87

enum FrameFlags {

    88

	FR_NONE         =  0,

    89

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

    90

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

    91

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

    92

	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)

    93

};

    94

    95

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

    96

    97

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

    98

    99

enum WindowEventCodes {

   100

	WE_CREATE,

   101

	WE_DESTROY,

   102

	WE_PAINT,

   103

	WE_KEYPRESS,

   104

	WE_CLICK,

   105

	WE_DOUBLE_CLICK,

   106

	WE_RCLICK,

   107

	WE_MOUSEOVER,

   108

	WE_MOUSELOOP,

   109

	WE_MOUSEWHEEL,

   110

	WE_TICK,

   111

	WE_4,

   112

	WE_TIMEOUT,

   113

	WE_PLACE_OBJ,

   114

	WE_ABORT_PLACE_OBJ,

   115

	WE_ON_EDIT_TEXT,

   116

	WE_ON_EDIT_TEXT_CANCEL,

   117

	WE_POPUPMENU_SELECT,

   118

	WE_POPUPMENU_OVER,

   119

	WE_DRAGDROP,

   120

	WE_PLACE_DRAG,

   121

	WE_PLACE_MOUSEUP,

   122

	WE_PLACE_PRESIZE,

   123

	WE_DROPDOWN_SELECT,

   124

	WE_RESIZE,

   125

	WE_MESSAGE,

   126

	WE_SCROLL,

   127

	WE_INVALIDATE_DATA,

   128

};

   129

   130

struct WindowEvent {

   131

	byte event;

   132

	union {

   133

		struct {

   134

			void *data;

   135

		} create;

   136

   137

		struct {

   138

			Point pt;

   139

			int widget;

   140

		} click;

   141

   142

		struct {

   143

			Point pt;

   144

			TileIndex tile;

   145

			TileIndex starttile;

   146

			ViewportPlaceMethod select_method;

   147

			byte select_proc;

   148

		} place;

   149

   150

		struct {

   151

			Point pt;

   152

			int widget;

   153

		} dragdrop;

   154

   155

		struct {

   156

			Point size;

   157

			Point diff;

   158

		} sizing;

   159

   160

		struct {

   161

			char *str;

   162

		} edittext;

   163

   164

		struct {

   165

			Point pt;

   166

		} popupmenu;

   167

   168

		struct {

   169

			int button;

   170

			int index;

   171

		} dropdown;

   172

   173

		struct {

   174

			Point pt;

   175

			int widget;

   176

		} mouseover;

   177

   178

		struct {

   179

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

   180

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

   181

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

   182

		} keypress;

   183

   184

		struct {

   185

			int msg;      ///< message to be sent

   186

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

   187

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

   188

		} message;

   189

   190

		struct {

   191

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

   192

		} scroll;

   193

   194

		struct {

   195

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

   196

		} wheel;

   197

	} we;

   198

};

   199

   200

struct WindowDesc {

   201

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

   202

	WindowClass cls;

   203

	WindowClass parent_cls;

   204

	uint32 flags;

   205

	const Widget *widgets;

   206

	WindowProc *proc;

   207

};

   208

   209

enum WindowDefaultFlag {

   210

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

   211

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

   212

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

   213

   214

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

   215

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

   216

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

   217

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

   218

};

   219

   220

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

   221

enum WindowDefaultPosition {

   222

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

   223

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

   224

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

   225

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

   226

};

   227

   228

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

   229

   230

struct Scrollbar {

   231

	uint16 count, cap, pos;

   232

};

   233

   234

struct ResizeInfo {

   235

	uint width; ///< Minimum width and height

   236

	uint height;

   237

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

   238

	uint step_height;

   239

};

   240

   241

struct WindowMessage {

   242

	int msg;

   243

	int wparam;

   244

	int lparam;

   245

};

   246

   247

struct Window {

   248

	uint16 flags4;

   249

	WindowClass window_class;

   250

	WindowNumber window_number;

   251

   252

	int left, top;

   253

	int width, height;

   254

   255

	Scrollbar hscroll, vscroll, vscroll2;

   256

	ResizeInfo resize;

   257

   258

	byte caption_color;

   259

   260

	WindowProc *wndproc;

   261

	ViewPort *viewport;

   262

	const Widget *original_widget;

   263

	Widget *widget;

   264

	uint widget_count;

   265

	uint32 desc_flags;

   266

   267

	WindowMessage message;

   268

	Window *parent;

   269

	byte custom[WINDOW_CUSTOM_SIZE];

   270

   271

	void HandleButtonClick(byte widget);

   272

   273

	void SetWidgetDisabledState(byte widget_index, bool disab_stat);

   274

	void DisableWidget(byte widget_index);

   275

	void EnableWidget(byte widget_index);

   276

	bool IsWidgetDisabled(byte widget_index) const;

   277

	void SetWidgetHiddenState(byte widget_index, bool hidden_stat);

   278

	void HideWidget(byte widget_index);

   279

	void ShowWidget(byte widget_index);

   280

	bool IsWidgetHidden(byte widget_index) const;

   281

	void SetWidgetLoweredState(byte widget_index, bool lowered_stat);

   282

	void ToggleWidgetLoweredState(byte widget_index);

   283

	void LowerWidget(byte widget_index);

   284

	void RaiseWidget(byte widget_index);

   285

	bool IsWidgetLowered(byte widget_index) const;

   286

   287

	void RaiseButtons();

   288

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

   289

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

   290

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

   291

	void InvalidateWidget(byte widget_index) const;

   292

};

   293

   294

struct menu_d {

   295

	byte item_count;      ///< follow_vehicle

   296

	byte sel_index;       ///< scrollpos_x

   297

	byte main_button;     ///< scrollpos_y

   298

	byte action_id;

   299

	StringID string_id;   ///< unk30

   300

	uint16 checked_items; ///< unk32

   301

	byte disabled_items;

   302

};

   303

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   304

   305

struct def_d {

   306

	int16 data_1, data_2, data_3;

   307

	int16 data_4, data_5;

   308

	bool close;

   309

	byte byte_1;

   310

};

   311

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   312

   313

struct void_d {

   314

	void *data;

   315

};

   316

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   317

   318

struct tree_d {

   319

	uint16 base;

   320

	uint16 count;

   321

};

   322

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   323

   324

struct tooltips_d {

   325

	StringID string_id;

   326

	byte paramcount;

   327

	uint64 params[5];

   328

};

   329

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   330

   331

struct buildvehicle_d {

   332

	VehicleType vehicle_type;

   333

	union {

   334

		RailTypeByte railtype;

   335

		AirportFTAClass::Flags flags;

   336

		RoadTypes roadtypes;

   337

	} filter;

   338

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

   339

	bool descending_sort_order;

   340

	byte sort_criteria;

   341

	bool regenerate_list;

   342

	EngineID sel_engine;

   343

	EngineID rename_engine;

   344

	EngineList eng_list;

   345

};

   346

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildvehicle_d));

   347

   348

struct replaceveh_d {

   349

	byte sel_index[2];

   350

	EngineID sel_engine[2];

   351

	uint16 count[2];

   352

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

   353

	EngineList list[2];

   354

	bool update_left;

   355

	bool update_right;

   356

	bool init_lists;

   357

	GroupID sel_group;

   358

};

   359

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   360

   361

struct depot_d {

   362

	VehicleID sel;

   363

	VehicleType type;

   364

	bool generate_list;

   365

	uint16 engine_list_length;

   366

	uint16 wagon_list_length;

   367

	uint16 engine_count;

   368

	uint16 wagon_count;

   369

	Vehicle **vehicle_list;

   370

	Vehicle **wagon_list;

   371

};

   372

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   373

   374

struct order_d {

   375

	int sel;

   376

};

   377

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   378

   379

struct vehicledetails_d {

   380

	byte tab;

   381

};

   382

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehicledetails_d));

   383

   384

struct smallmap_d {

   385

	int32 scroll_x;

   386

	int32 scroll_y;

   387

	int32 subscroll;

   388

};

   389

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   390

   391

/* player face selection window */

   392

struct facesel_d {

   393

	PlayerFace face; // player face bits

   394

	bool advanced;   // advance player face selection window

   395

};

   396

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(facesel_d));

   397

   398

struct refit_d {

   399

	int sel;

   400

	struct RefitOption *cargo;

   401

	struct RefitList *list;

   402

	uint length;

   403

	VehicleOrderID order;

   404

};

   405

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   406

   407

struct vp_d {

   408

	VehicleID follow_vehicle;

   409

	int32 scrollpos_x;

   410

	int32 scrollpos_y;

   411

	int32 dest_scrollpos_x;

   412

	int32 dest_scrollpos_y;

   413

};

   414

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   415

   416

struct news_d {

   417

	uint16 follow_vehicle;

   418

	int32 scrollpos_x;

   419

	int32 scrollpos_y;

   420

	int32 dest_scrollpos_x;

   421

	int32 dest_scrollpos_y;

   422

	NewsItem *ni;

   423

};

   424

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   425

   426

struct highscore_d {

   427

	uint32 background_img;

   428

	int8 rank;

   429

};

   430

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   431

   432

struct scroller_d {

   433

	int height;

   434

	uint16 counter;

   435

};

   436

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   437

   438

enum SortListFlags {

   439

	VL_NONE    = 0,      ///< no sort

   440

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

   441

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

   442

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

   443

	VL_END     = 1 << 3,

   444

};

   445

   446

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   447

   448

struct Listing {

   449

	bool order;    ///< Ascending/descending

   450

	byte criteria; ///< Sorting criteria

   451

};

   452

   453

struct list_d {

   454

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

   455

	byte sort_type;      ///< what criteria to sort on

   456

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

   457

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

   458

};

   459

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   460

   461

struct message_d {

   462

	int msg;

   463

	int wparam;

   464

	int lparam;

   465

};

   466

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   467

   468

struct dropdown_d {

   469

	uint32 disabled_state;

   470

	uint32 hidden_state;

   471

	WindowClass parent_wnd_class;

   472

	WindowNumber parent_wnd_num;

   473

	byte parent_button;

   474

	byte num_items;

   475

	byte selected_index;

   476

	const StringID *items;

   477

	byte click_delay;

   478

	bool drag_mode;

   479

};

   480

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(dropdown_d));

   481

   482

struct vehiclelist_d {

   483

	const Vehicle** sort_list;  // List of vehicles (sorted)