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

    76

struct Widget {

    77

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

    78

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

    79

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

    80

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

    81

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

    82

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

    83

};

    84

    85

enum FrameFlags {

    86

	FR_NONE         =  0,

    87

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

    88

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

    89

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

    90

	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)

    91

};

    92

    93

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

    94

    95

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

    96

    97

enum WindowEventCodes {

    98

	WE_CREATE,

    99

	WE_DESTROY,

   100

	WE_PAINT,

   101

	WE_KEYPRESS,

   102

	WE_CLICK,

   103

	WE_DOUBLE_CLICK,

   104

	WE_RCLICK,

   105

	WE_MOUSEOVER,

   106

	WE_MOUSELOOP,

   107

	WE_MOUSEWHEEL,

   108

	WE_TICK,

   109

	WE_4,

   110

	WE_TIMEOUT,

   111

	WE_PLACE_OBJ,

   112

	WE_ABORT_PLACE_OBJ,

   113

	WE_ON_EDIT_TEXT,

   114

	WE_ON_EDIT_TEXT_CANCEL,

   115

	WE_POPUPMENU_SELECT,

   116

	WE_POPUPMENU_OVER,

   117

	WE_DRAGDROP,

   118

	WE_PLACE_DRAG,

   119

	WE_PLACE_MOUSEUP,

   120

	WE_PLACE_PRESIZE,

   121

	WE_DROPDOWN_SELECT,

   122

	WE_RESIZE,

   123

	WE_MESSAGE,

   124

	WE_SCROLL,

   125

	WE_INVALIDATE_DATA,

   126

	WE_CTRL_CHANGED,

   127

};

   128

   129

struct WindowEvent {

   130

	byte event;

   131

	union {

   132

		struct {

   133

			void *data;

   134

		} create;

   135

   136

		struct {

   137

			Point pt;

   138

			int widget;

   139

		} click;

   140

   141

		struct {

   142

			Point pt;

   143

			TileIndex tile;

   144

			TileIndex starttile;

   145

			ViewportPlaceMethod select_method;

   146

			byte select_proc;

   147

		} place;

   148

   149

		struct {

   150

			Point pt;

   151

			int widget;

   152

		} dragdrop;

   153

   154

		struct {

   155

			Point size;

   156

			Point diff;

   157

		} sizing;

   158

   159

		struct {

   160

			char *str;

   161

		} edittext;

   162

   163

		struct {

   164

			Point pt;

   165

		} popupmenu;

   166

   167

		struct {

   168

			int button;

   169

			int index;

   170

		} dropdown;

   171

   172

		struct {

   173

			Point pt;

   174

			int widget;

   175

		} mouseover;

   176

   177

		struct {

   178

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

   179

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

   180

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

   181

		} keypress;

   182

   183

		struct {

   184

			int msg;      ///< message to be sent

   185

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

   186

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

   187

		} message;

   188

   189

		struct {

   190

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

   191

		} scroll;

   192

   193

		struct {

   194

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

   195

		} wheel;

   196

   197

		struct {

   198

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

   199

		} ctrl;

   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

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

   232

   233

struct Scrollbar {

   234

	uint16 count, cap, pos;

   235

};

   236

   237

struct ResizeInfo {

   238

	uint width; ///< Minimum width and height

   239

	uint height;

   240

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

   241

	uint step_height;

   242

};

   243

   244

struct WindowMessage {

   245

	int msg;

   246

	int wparam;

   247

	int lparam;

   248

};

   249

   250

struct Window {

   251

	uint16 flags4;

   252

	WindowClass window_class;

   253

	WindowNumber window_number;

   254

   255

	int left, top;

   256

	int width, height;

   257

   258

	Scrollbar hscroll, vscroll, vscroll2;

   259

	ResizeInfo resize;

   260

   261

	byte caption_color;

   262

   263

	WindowProc *wndproc;

   264

	ViewPort *viewport;

   265

	const Widget *original_widget;

   266

	Widget *widget;

   267

	uint widget_count;

   268

	uint32 desc_flags;

   269

   270

	WindowMessage message;

   271

	Window *parent;

   272

	byte custom[WINDOW_CUSTOM_SIZE];

   273

   274

	void HandleButtonClick(byte widget);

   275

   276

	void SetWidgetDisabledState(byte widget_index, bool disab_stat);

   277

	void DisableWidget(byte widget_index);

   278

	void EnableWidget(byte widget_index);

   279

	bool IsWidgetDisabled(byte widget_index) const;

   280

	void SetWidgetHiddenState(byte widget_index, bool hidden_stat);

   281

	void HideWidget(byte widget_index);

   282

	void ShowWidget(byte widget_index);

   283

	bool IsWidgetHidden(byte widget_index) const;

   284

	void SetWidgetLoweredState(byte widget_index, bool lowered_stat);

   285

	void ToggleWidgetLoweredState(byte widget_index);

   286

	void LowerWidget(byte widget_index);

   287

	void RaiseWidget(byte widget_index);

   288

	bool IsWidgetLowered(byte widget_index) const;

   289

   290

	void RaiseButtons();

   291

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

   292

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

   293

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

   294

	void InvalidateWidget(byte widget_index) const;

   295

};

   296

   297

struct menu_d {

   298

	byte item_count;      ///< follow_vehicle

   299

	byte sel_index;       ///< scrollpos_x

   300

	byte main_button;     ///< scrollpos_y

   301

	byte action_id;

   302

	StringID string_id;   ///< unk30

   303

	uint16 checked_items; ///< unk32

   304

	byte disabled_items;

   305

};

   306

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   307

   308

struct def_d {

   309

	int16 data_1, data_2, data_3;

   310

	int16 data_4, data_5;

   311

	bool close;

   312

	byte byte_1;

   313

};

   314

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   315

   316

struct void_d {

   317

	void *data;

   318

};

   319

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   320

   321

struct tree_d {

   322

	uint16 base;

   323

	uint16 count;

   324

};

   325

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   326

   327

struct tooltips_d {

   328

	StringID string_id;

   329

	byte paramcount;

   330

	uint64 params[5];

   331

};

   332

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   333

   334

struct depot_d {

   335

	VehicleID sel;

   336

	VehicleType type;

   337

	bool generate_list;

   338

	uint16 engine_list_length;

   339

	uint16 wagon_list_length;

   340

	uint16 engine_count;

   341

	uint16 wagon_count;

   342

	Vehicle **vehicle_list;

   343

	Vehicle **wagon_list;

   344

};

   345

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   346

   347

struct order_d {

   348

	int sel;

   349

};

   350

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(order_d));

   351

   352

struct vehicledetails_d {

   353

	byte tab;

   354

};

   355

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehicledetails_d));

   356

   357

struct smallmap_d {

   358

	int32 scroll_x;

   359

	int32 scroll_y;

   360

	int32 subscroll;

   361

};

   362

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   363

   364

struct vp_d {

   365

	VehicleID follow_vehicle;

   366

	int32 scrollpos_x;

   367

	int32 scrollpos_y;

   368

	int32 dest_scrollpos_x;

   369

	int32 dest_scrollpos_y;

   370

};

   371

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   372

   373

struct highscore_d {

   374

	uint32 background_img;

   375

	int8 rank;

   376

};

   377

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   378

   379

struct scroller_d {

   380

	int height;

   381

	uint16 counter;

   382

};

   383

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   384

   385

enum SortListFlags {

   386

	VL_NONE    = 0,      ///< no sort

   387

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

   388

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

   389

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

   390

	VL_END     = 1 << 3,

   391

};

   392

   393

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   394

   395

struct Listing {

   396

	bool order;    ///< Ascending/descending

   397

	byte criteria; ///< Sorting criteria

   398

};

   399

   400

struct list_d {

   401

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

   402

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

   403

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

   404

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

   405

};

   406

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   407

   408

struct message_d {

   409

	int msg;

   410

	int wparam;

   411

	int lparam;

   412

};

   413

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   414

   415

struct vehiclelist_d {

   416

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

   417

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

   418

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

   419

	VehicleType vehicle_type;   // The vehicle type that is sorted

   420

	list_d l;                   // General list struct

   421

};

   422

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehiclelist_d));

   423

   424

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

   425

enum WindowWidgetBehaviours {

   426

	WWB_PUSHBUTTON  = 1 << 5,

   427

   428

	WWB_MASK        = 0xE0,

   429

};

   430

   431

   432

enum WindowWidgetTypes {

   433

	WWT_EMPTY,

   434

   435

	WWT_PANEL,      ///< simple depressed panel

   436

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

   437

	WWT_IMGBTN,     ///< button with image

   438

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

   439

   440

	WWT_TEXTBTN,    ///< button with text

   441

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

   442

	WWT_LABEL,      ///< centered label

   443

	WWT_TEXT,       ///< pure simple text

   444

	WWT_MATRIX,

   445

	WWT_SCROLLBAR,

   446

	WWT_FRAME,      ///< frame

   447

	WWT_CAPTION,

   448

   449

	WWT_HSCROLLBAR,

   450

	WWT_STICKYBOX,

   451

	WWT_SCROLL2BAR, ///< 2nd vertical scrollbar

   452

	WWT_RESIZEBOX,

   453

	WWT_CLOSEBOX,

   454

	WWT_DROPDOWN,   ///< Raised drop down list (regular)

   455

	WWT_DROPDOWNIN, ///< Inset drop down list (used on game options only)

   456

	WWT_EDITBOX,    ///< a textbox for typing (don't forget to call ShowOnScreenKeyboard() when clicked)

   457

	WWT_LAST,       ///< Last Item. use WIDGETS_END to fill up padding!!

   458

   459

	WWT_MASK = 0x1F,

   460

   461

	WWT_PUSHBTN     = WWT_PANEL   | WWB_PUSHBUTTON,

   462

	WWT_PUSHTXTBTN  = WWT_TEXTBTN | WWB_PUSHBUTTON,

   463

	WWT_PUSHIMGBTN  = WWT_IMGBTN  | WWB_PUSHBUTTON,

   464

};

   465

   466

#define WIDGETS_END WWT_LAST,   RESIZE_NONE,     0,     0,     0,     0,     0, 0, STR_NULL

   467

   468

enum WindowFlags {

   469

	WF_TIMEOUT_SHL       = 0,

   470

	WF_TIMEOUT_MASK      = 7,

   471

	WF_DRAGGING          = 1 <<  3,

   472

	WF_SCROLL_UP         = 1 <<  4,

   473

	WF_SCROLL_DOWN       = 1 <<  5,

   474

	WF_SCROLL_MIDDLE     = 1 <<  6,

   475

	WF_HSCROLL           = 1 <<  7,

   476

	WF_SIZING            = 1 <<  8,

   477

	WF_STICKY            = 1 <<  9,

   478

   479

	WF_DISABLE_VP_SCROLL = 1 << 10,

   480

   481

	WF_WHITE_BORDER_ONE  = 1 << 11,

   482

	WF_WHITE_BORDER_MASK = 1 << 12 | WF_WHITE_BORDER_ONE,

   483

	WF_SCROLL2           = 1 << 13,

   484

};

   485