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 "core/bitmath_func.hpp"

     9

#include "vehicle_type.h"

    10

#include "viewport_type.h"

    12

    13

/**

    14

 * The maximum number of windows that can be opened.

    15

 */

    16

static const int MAX_NUMBER_OF_WINDOWS = 25;

    17

    18

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

    19

    20

/* How the resize system works:

    21

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

    22

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

    23

     to resize itself.

    24

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

    25

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

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

     widgets moves downwards without resizing, and appears to be clamped

    34

     to the bottom. Nice aint it?

    35

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

    36

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

    37

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

    38

    after making the window, like this:

    39

      w->resize.step_height = 10;

    40

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

    41

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

    42

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

    43

    AFTER window-creation, with:

    44

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

    45

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

    46

    47

enum ResizeFlag {

    48

	RESIZE_NONE   = 0,  ///< no resize required

    49

    50

	RESIZE_LEFT   = 1,  ///< left resize flag

    51

	RESIZE_RIGHT  = 2,  ///< rigth resize flag

    52

	RESIZE_TOP    = 4,  ///< top resize flag

    53

	RESIZE_BOTTOM = 8,  ///< bottom resize flag

    54

    55

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

    56

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

    57

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

    58

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

    59

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

    60

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

    61

    62

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

    63

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

    64

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

    65

	 * Enabled, visible or unclicked widgets*/

    66

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

    67

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

    68

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

    69

};

    70

    71

enum {

    72

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

    73

};

    74

    75

struct Widget {

    76

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

    77

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

    78

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

    79

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

    80

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

    81

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

    82

};

    83

    84

enum FrameFlags {

    85

	FR_NONE         =  0,

    86

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

    87

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

    88

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

    89

	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)

    90

};

    91

    92

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

    93

    94

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

    95

    96

enum WindowEventCodes {

    97

	WE_CREATE,

    98

	WE_DESTROY,

    99

	WE_PAINT,

   100

	WE_KEYPRESS,

   101

	WE_CLICK,

   102

	WE_DOUBLE_CLICK,

   103

	WE_RCLICK,

   104

	WE_MOUSEOVER,

   105

	WE_MOUSELOOP,

   106

	WE_MOUSEWHEEL,

   107

	WE_TICK,

   108

	WE_4,

   109

	WE_TIMEOUT,

   110

	WE_PLACE_OBJ,

   111

	WE_ABORT_PLACE_OBJ,

   112

	WE_ON_EDIT_TEXT,

   113

	WE_ON_EDIT_TEXT_CANCEL,

   114

	WE_POPUPMENU_SELECT,

   115

	WE_POPUPMENU_OVER,

   116

	WE_DRAGDROP,

   117

	WE_PLACE_DRAG,

   118

	WE_PLACE_MOUSEUP,

   119

	WE_PLACE_PRESIZE,

   120

	WE_DROPDOWN_SELECT,

   121

	WE_RESIZE,

   122

	WE_MESSAGE,

   123

	WE_SCROLL,

   124

	WE_INVALIDATE_DATA,

   125

};

   126

   127

struct WindowEvent {

   128

	byte event;

   129

	union {

   130

		struct {

   131

			void *data;

   132

		} create;

   133

   134

		struct {

   135

			Point pt;

   136

			int widget;

   137

		} click;

   138

   139

		struct {

   140

			Point pt;

   141

			TileIndex tile;

   142

			TileIndex starttile;

   143

			ViewportPlaceMethod select_method;

   144

			byte select_proc;

   145

		} place;

   146

   147

		struct {

   148

			Point pt;

   149

			int widget;

   150

		} dragdrop;

   151

   152

		struct {

   153

			Point size;

   154

			Point diff;

   155

		} sizing;

   156

   157

		struct {

   158

			char *str;

   159

		} edittext;

   160

   161

		struct {

   162

			Point pt;

   163

		} popupmenu;

   164

   165

		struct {

   166

			int button;

   167

			int index;

   168

		} dropdown;

   169

   170

		struct {

   171

			Point pt;

   172

			int widget;

   173

		} mouseover;

   174

   175

		struct {

   176

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

   177

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

   178

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

   179

		} keypress;

   180

   181

		struct {

   182

			int msg;      ///< message to be sent

   183

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

   184

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

   185

		} message;

   186

   187

		struct {

   188

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

   189

		} scroll;

   190

   191

		struct {

   192

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

   193

		} wheel;

   194

	} we;

   195

};

   196

   197

struct WindowDesc {

   198

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

   199

	WindowClass cls;

   200

	WindowClass parent_cls;

   201

	uint32 flags;

   202

	const Widget *widgets;

   203

	WindowProc *proc;

   204

};

   205

   206

enum WindowDefaultFlag {

   207

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

   208

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

   209

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

   210

   211

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

   212

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

   213

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

   214

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

   215

};

   216

   217

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

   218

enum WindowDefaultPosition {

   219

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

   220

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

   221

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

   222

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

   223

};

   224

   225

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

   226

   227

struct Scrollbar {

   228

	uint16 count, cap, pos;

   229

};

   230

   231

struct ResizeInfo {

   232

	uint width; ///< Minimum width and height

   233

	uint height;

   234

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

   235

	uint step_height;

   236

};

   237

   238

struct WindowMessage {

   239

	int msg;

   240

	int wparam;

   241

	int lparam;

   242

};

   243

   244

struct Window {

   245

	uint16 flags4;

   246

	WindowClass window_class;

   247

	WindowNumber window_number;

   248

   249

	int left, top;

   250

	int width, height;

   251

   252

	Scrollbar hscroll, vscroll, vscroll2;

   253

	ResizeInfo resize;

   254

   255

	byte caption_color;

   256

   257

	WindowProc *wndproc;

   258

	ViewPort *viewport;

   259

	const Widget *original_widget;

   260

	Widget *widget;

   261

	uint widget_count;

   262

	uint32 desc_flags;

   263

   264

	WindowMessage message;

   265

	Window *parent;

   266

	byte custom[WINDOW_CUSTOM_SIZE];

   267

   268

	void HandleButtonClick(byte widget);

   269

   270

	void SetWidgetDisabledState(byte widget_index, bool disab_stat);

   271

	void DisableWidget(byte widget_index);

   272

	void EnableWidget(byte widget_index);

   273

	bool IsWidgetDisabled(byte widget_index) const;

   274

	void SetWidgetHiddenState(byte widget_index, bool hidden_stat);

   275

	void HideWidget(byte widget_index);

   276

	void ShowWidget(byte widget_index);

   277

	bool IsWidgetHidden(byte widget_index) const;

   278

	void SetWidgetLoweredState(byte widget_index, bool lowered_stat);

   279

	void ToggleWidgetLoweredState(byte widget_index);

   280

	void LowerWidget(byte widget_index);

   281

	void RaiseWidget(byte widget_index);

   282

	bool IsWidgetLowered(byte widget_index) const;

   283

   284

	void RaiseButtons();

   285

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

   286

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

   287

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

   288

	void InvalidateWidget(byte widget_index) const;

   289

};

   290

   291

struct menu_d {

   292

	byte item_count;      ///< follow_vehicle

   293

	byte sel_index;       ///< scrollpos_x

   294

	byte main_button;     ///< scrollpos_y

   295

	byte action_id;

   296

	StringID string_id;   ///< unk30

   297

	uint16 checked_items; ///< unk32

   298

	byte disabled_items;

   299

};

   300

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   301

   302

struct def_d {

   303

	int16 data_1, data_2, data_3;

   304

	int16 data_4, data_5;

   305

	bool close;

   306

	byte byte_1;

   307

};

   308

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   309

   310

struct void_d {

   311

	void *data;

   312

};

   313

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   314

   315

struct tree_d {

   316

	uint16 base;

   317

	uint16 count;

   318

};

   319

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   320

   321

struct tooltips_d {

   322

	StringID string_id;

   323

	byte paramcount;

   324

	uint64 params[5];

   325

};

   326

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   327

   328

struct replaceveh_d {

   329

	byte sel_index[2];

   330

	EngineID sel_engine[2];

   331

	uint16 count[2];

   332

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

   333

	EngineList list[2];

   334

	bool update_left;

   335

	bool update_right;

   336

	bool init_lists;

   337

	GroupID sel_group;

   338

};

   339

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(replaceveh_d));

   340

   341

struct depot_d {

   342

	VehicleID sel;

   343

	VehicleType type;

   344

	bool generate_list;

   345

	uint16 engine_list_length;

   346

	uint16 wagon_list_length;

   347

	uint16 engine_count;

   348

	uint16 wagon_count;

   349

	Vehicle **vehicle_list;

   350

	Vehicle **wagon_list;

   351

};

   352

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   353

   354

struct order_d {

   355

	int sel;

   356

};

   357

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   358

   359

struct vehicledetails_d {

   360

	byte tab;

   361

};

   362

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehicledetails_d));

   363

   364

struct smallmap_d {

   365

	int32 scroll_x;

   366

	int32 scroll_y;

   367

	int32 subscroll;

   368

};

   369

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   370

   371

struct refit_d {

   372

	int sel;

   373

	struct RefitOption *cargo;

   374

	struct RefitList *list;

   375

	uint length;

   376

	VehicleOrderID order;

   377

};

   378

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

   379

   380

struct vp_d {

   381

	VehicleID follow_vehicle;

   382

	int32 scrollpos_x;

   383

	int32 scrollpos_y;

   384

	int32 dest_scrollpos_x;

   385

	int32 dest_scrollpos_y;

   386

};

   387

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   388

   389

struct news_d {

   390

	uint16 follow_vehicle;

   391

	int32 scrollpos_x;

   392

	int32 scrollpos_y;

   393

	int32 dest_scrollpos_x;

   394

	int32 dest_scrollpos_y;

   395

	NewsItem *ni;

   396

};

   397

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(news_d));

   398

   399

struct highscore_d {

   400

	uint32 background_img;

   401

	int8 rank;

   402

};

   403

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   404

   405

struct scroller_d {

   406

	int height;

   407

	uint16 counter;

   408

};

   409

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   410

   411

enum SortListFlags {

   412

	VL_NONE    = 0,      ///< no sort

   413

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

   414

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

   415

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

   416

	VL_END     = 1 << 3,

   417

};

   418

   419

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   420

   421

struct Listing {

   422

	bool order;    ///< Ascending/descending

   423

	byte criteria; ///< Sorting criteria

   424

};

   425

   426

struct list_d {

   427

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

   428

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

   429

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

   430

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

   431

};

   432

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   433

   434

struct message_d {

   435

	int msg;

   436

	int wparam;

   437

	int lparam;

   438

};

   439

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   440

   441

struct dropdown_d {

   442

	uint32 disabled_state;

   443

	uint32 hidden_state;

   444

	WindowClass parent_wnd_class;

   445

	WindowNumber parent_wnd_num;

   446

	byte parent_button;

   447

	byte num_items;

   448

	byte selected_index;

   449

	const StringID *items;

   450

	byte click_delay;

   451

	bool drag_mode;

   452

};

   453

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(dropdown_d));

   454

   455

struct vehiclelist_d {

   456

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

   457

	Listing *_sorting;          // pointer to the appropiate subcategory of _sorting

   458

	uint16 length_of_sort_list; // Keeps track of how many vehicle pointers sort list got space for

   459

	VehicleType vehicle_type;   // The vehicle type that is sorted

   460

	list_d l;                   // General list struct

   461

};

   462

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehiclelist_d));

   463

   464

struct grouplist_d {

   465

	const Group **sort_list;

   466

	list_d l;                   // General list struct

   467

};

   468

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(grouplist_d));

   469

   470

struct groupveh_d : vehiclelist_d {

   471

	GroupID group_sel;

   472

	VehicleID vehicle_sel;

   473

   474

	grouplist_d gl;

   475

};

   476

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(groupveh_d));

   477

   478

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

   479

enum WindowWidgetBehaviours {

   480

	WWB_PUSHBUTTON  = 1 << 5,

   481

   482

	WWB_MASK        = 0xE0,

   483

};

   484

   485