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"

    11

#include "player_type.h"

    12

#include "strings_type.h"

    13

    14

/**

    15

 * The maximum number of windows that can be opened.

    16

 */

    17

static const int MAX_NUMBER_OF_WINDOWS = 25;

    18

    19

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

    20

    21

/* How the resize system works:

    22

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

    23

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

    24

     to resize itself.

    25

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

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

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

    34

     widgets moves downwards without resizing, and appears to be clamped

    35

     to the bottom. Nice aint it?

    36

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

    37

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

    38

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

    39

    after making the window, like this:

    40

      w->resize.step_height = 10;

    41

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

    42

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

    43

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

    44

    AFTER window-creation, with:

    45

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

    46

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

    47

    48

enum ResizeFlag {

    49

	RESIZE_NONE   = 0,  ///< no resize required

    50

    51

	RESIZE_LEFT   = 1,  ///< left resize flag

    52

	RESIZE_RIGHT  = 2,  ///< rigth resize flag

    53

	RESIZE_TOP    = 4,  ///< top resize flag

    54

	RESIZE_BOTTOM = 8,  ///< bottom resize flag

    55

    56

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

    57

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

    58

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

    59

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

    60

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

    61

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

    62

    63

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

    64

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

    65

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

    66

	 * Enabled, visible or unclicked widgets*/

    67

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

    68

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

    69

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

    70

};

    71

    72

enum {

    73

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

    74

};

    75

    79

struct Widget {

    80

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

    81

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

    82

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

    83

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

    84

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

    85

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

    86

};

    87

    91

enum FrameFlags {

    92

	FR_NONE         =  0,

    93

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

    94

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

    95

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

    96

	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)

    97

};

    98

    99

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

   100

   102

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

   103

   107

enum WindowEventCodes {

   115

	WE_MOUSEOVER,

   116

	WE_MOUSELOOP,

   117

	WE_MOUSEWHEEL,

   120

	WE_TIMEOUT,

   121

	WE_PLACE_OBJ,

   122

	WE_ABORT_PLACE_OBJ,

   123

	WE_ON_EDIT_TEXT,

   124

	WE_ON_EDIT_TEXT_CANCEL,

   125

	WE_POPUPMENU_SELECT,

   126

	WE_POPUPMENU_OVER,

   127

	WE_DRAGDROP,

   128

	WE_PLACE_DRAG,

   129

	WE_PLACE_MOUSEUP,

   130

	WE_PLACE_PRESIZE,

   131

	WE_DROPDOWN_SELECT,

   134

	WE_SCROLL,

   137

};

   138

   143

struct WindowEvent {

   144

	byte event;

   145

	union {

   146

		struct {

   147

			void *data;

   148

		} create;

   149

   150

		struct {

   151

			Point pt;

   152

			int widget;

   153

		} click;

   154

   155

		struct {

   156

			Point pt;

   157

			TileIndex tile;

   158

			TileIndex starttile;

   159

			ViewportPlaceMethod select_method;

   160

			byte select_proc;

   161

		} place;

   162

   163

		struct {

   164

			Point pt;

   165

			int widget;

   166

		} dragdrop;

   167

   168

		struct {

   169

			Point size;

   170

			Point diff;

   171

		} sizing;

   172

   173

		struct {

   174

			char *str;

   175

		} edittext;

   176

   177

		struct {

   178

			Point pt;

   179

		} popupmenu;

   180

   181

		struct {

   182

			int button;

   183

			int index;

   184

		} dropdown;

   185

   186

		struct {

   187

			Point pt;

   188

			int widget;

   189

		} mouseover;

   190

   191

		struct {

   192

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

   193

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

   194

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

   195

		} keypress;

   196

   197

		struct {

   198

			int msg;      ///< message to be sent

   199

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

   200

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

   201

		} message;

   202

   203

		struct {

   204

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

   205

		} scroll;

   206

   207

		struct {

   208

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

   209

		} wheel;

   210

   211

		struct {

   212

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

   213

		} ctrl;

   214

	} we;

   215

};

   216

   220

struct WindowDesc {

   232

};

   233

   237

enum WindowDefaultFlag {

   238

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

   241

   243

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

   245

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

   246

};

   247

   251

enum WindowDefaultPosition {

   252

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

   253

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

   254

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

   255

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

   256

};

   257

   258

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

   259

   263

struct Scrollbar {

   267

};

   268

   272

struct ResizeInfo {

   277

};

   278

   283

struct WindowMessage {

   284

	int msg;

   285

	int wparam;

   286

	int lparam;

   287

};

   288

   292

struct Window {

   296

   301

   306

   319

   320

	void HandleButtonClick(byte widget);

   321

   322

	void SetWidgetDisabledState(byte widget_index, bool disab_stat);

   323

	void DisableWidget(byte widget_index);

   324

	void EnableWidget(byte widget_index);

   325

	bool IsWidgetDisabled(byte widget_index) const;

   326

	void SetWidgetHiddenState(byte widget_index, bool hidden_stat);

   327

	void HideWidget(byte widget_index);

   328

	void ShowWidget(byte widget_index);

   329

	bool IsWidgetHidden(byte widget_index) const;

   330

	void SetWidgetLoweredState(byte widget_index, bool lowered_stat);

   331

	void ToggleWidgetLoweredState(byte widget_index);

   332

	void LowerWidget(byte widget_index);

   333

	void RaiseWidget(byte widget_index);

   334

	bool IsWidgetLowered(byte widget_index) const;

   335

   336

	void RaiseButtons();

   337

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

   338

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

   339

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

   340

	void InvalidateWidget(byte widget_index) const;

   341

};

   342

   343

struct menu_d {

   344

	byte item_count;      ///< follow_vehicle

   345

	byte sel_index;       ///< scrollpos_x

   346

	byte main_button;     ///< scrollpos_y

   347

	byte action_id;

   348

	StringID string_id;   ///< unk30

   349

	uint16 checked_items; ///< unk32

   350

	byte disabled_items;

   351

};

   352

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   353

   354

struct def_d {

   355

	int16 data_1, data_2, data_3;

   356

	int16 data_4, data_5;

   357

	bool close;

   358

	byte byte_1;

   359

};

   360

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   361

   362

struct void_d {

   363

	void *data;

   364

};

   365

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   366

   367

struct tree_d {

   368

	uint16 base;

   369

	uint16 count;

   370

};

   371

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   372

   373

struct tooltips_d {

   374

	StringID string_id;

   375

	byte paramcount;

   376

	uint64 params[5];

   377

};

   378

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   379

   380

struct depot_d {

   381

	VehicleID sel;

   382

	VehicleType type;

   383

	bool generate_list;

   384

	uint16 engine_list_length;

   385

	uint16 wagon_list_length;

   386

	uint16 engine_count;

   387

	uint16 wagon_count;

   388

	Vehicle **vehicle_list;

   389

	Vehicle **wagon_list;

   390

};

   391

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   392

   393

struct order_d {

   394

	int sel;

   395

};

   396

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   397

   398

struct vehicledetails_d {

   399

	byte tab;

   400

};

   401

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehicledetails_d));

   402

   403

struct smallmap_d {

   404

	int32 scroll_x;

   405

	int32 scroll_y;

   406

	int32 subscroll;

   407

};

   408

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   409

   410

struct vp_d {

   411

	VehicleID follow_vehicle;

   412

	int32 scrollpos_x;

   413

	int32 scrollpos_y;

   414

	int32 dest_scrollpos_x;

   415

	int32 dest_scrollpos_y;

   416

};

   417

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   418

   419

struct highscore_d {

   420

	uint32 background_img;

   421

	int8 rank;

   422

};

   423

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   424

   425

struct scroller_d {

   426

	int height;

   427

	uint16 counter;

   428

};

   429

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   430

   431

enum SortListFlags {

   432

	VL_NONE    = 0,      ///< no sort

   433

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

   434

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

   435

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

   436

	VL_END     = 1 << 3,

   437

};

   438

   439

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   440

   441

struct Listing {

   442

	bool order;    ///< Ascending/descending

   443

	byte criteria; ///< Sorting criteria

   444

};

   445

   446

struct list_d {

   447

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

   448

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

   449

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

   450

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

   451

};

   452

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   453

   454

struct message_d {

   455

	int msg;

   456

	int wparam;

   457

	int lparam;

   458

};

   459

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   460

   461

struct vehiclelist_d {

   462

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

   463

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

   464

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

   465

	VehicleType vehicle_type;   // The vehicle type that is sorted

   466

	list_d l;                   // General list struct

   467

};

   468

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehiclelist_d));

   469

   470

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

   471

enum WindowWidgetBehaviours {

   472

	WWB_PUSHBUTTON  = 1 << 5,

   473

   474

	WWB_MASK        = 0xE0,

   475

};

   476

   477

   481

enum WindowWidgetTypes {

   483