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

    10

#include "vehicle_type.h"

    11

#include "viewport_type.h"

    12

#include "player_type.h"

    13

#include "strings_type.h"

    14

#include "core/alloc_type.hpp"

    15

#include "window_type.h"

    16

#include "tile_type.h"

    17

    18

/**

    19

 * The maximum number of windows that can be opened.

    20

 */

    21

static const int MAX_NUMBER_OF_WINDOWS = 25;

    22

    23

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

    24

    25

/* How the resize system works:

    26

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

    27

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

    28

     to resize itself.

    29

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

    30

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

    31

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

    32

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

    33

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

    34

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

    35

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

    36

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

    37

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

    38

     widgets moves downwards without resizing, and appears to be clamped

    39

     to the bottom. Nice aint it?

    40

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

    41

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

    42

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

    43

    after making the window, like this:

    44

      w->resize.step_height = 10;

    45

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

    46

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

    47

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

    48

    AFTER window - creation, with:

    49

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

    50

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

    51

    52

enum ResizeFlag {

    53

	RESIZE_NONE   = 0,  ///< no resize required

    54

    55

	RESIZE_LEFT   = 1,  ///< left resize flag

    56

	RESIZE_RIGHT  = 2,  ///< rigth resize flag

    57

	RESIZE_TOP    = 4,  ///< top resize flag

    58

	RESIZE_BOTTOM = 8,  ///< bottom resize flag

    59

    60

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

    61

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

    62

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

    63

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

    64

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

    65

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

    66

    67

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

    68

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

    69

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

    70

	 * Enabled, visible or unclicked widgets*/

    71

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

    72

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

    73

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

    74

};

    75

    76

enum {

    77

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

    78

};

    79

    80

/**

    81

 * Window widget data structure

    82

 */

    83

struct Widget {

    84

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

    85

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

    86

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

    87

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

    88

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

    89

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

    90

};

    91

    92

/**

    93

 * Flags to describe the look of the frame

    94

 */

    95

enum FrameFlags {

    96

	FR_NONE         =  0,

    97

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

    98

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

    99

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

   100

	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)

   101

};

   102

   103

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

   104

   105

/* wiget.cpp */

   106

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

   107

   108

/**

   109

 * Available window events

   110

 */

   111

enum WindowEventCodes {

   112

	WE_CREATE,       ///< Initialize the Window

   113

	WE_DESTROY,      ///< Prepare for deletion of the window

   114

	WE_PAINT,        ///< Repaint the window contents

   115

	WE_KEYPRESS,     ///< Key pressed

   116

	WE_CLICK,        ///< Left mouse button click

   117

	WE_DOUBLE_CLICK, ///< Left mouse button double click

   118

	WE_RCLICK,       ///< Right mouse button click

   119

	WE_MOUSEOVER,

   120

	WE_MOUSEWHEEL,

   121

	WE_MOUSELOOP,    ///< Event for each mouse event in the game (at least once every game tick)

   122

	WE_TICK,         ///< Regularly occurring event (every game tick)

   123

	WE_100_TICKS,    ///< Regularly occurring event (every 100 game ticks, approximatelly 3 seconds)

   124

	WE_TIMEOUT,

   125

	WE_PLACE_OBJ,

   126

	WE_ABORT_PLACE_OBJ,

   127

	WE_ON_EDIT_TEXT,

   128

	WE_DRAGDROP,

   129

	WE_PLACE_DRAG,

   130

	WE_PLACE_MOUSEUP,

   131

	WE_PLACE_PRESIZE,

   132

	WE_DROPDOWN_SELECT,

   133

	WE_RESIZE,          ///< Request to resize the window, @see WindowEvent.we.resize

   134

	WE_SCROLL,

   135

	WE_INVALIDATE_DATA, ///< Notification that data displayed by the window is obsolete

   136

	WE_CTRL_CHANGED,    ///< CTRL key has changed state

   137

};

   138

   139

/**

   140

 * Data structures for additional data associated with a window event

   141

 * @see WindowEventCodes

   142

 */

   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

			int button;

   179

			int index;

   180

		} dropdown;

   181

   182

		struct {

   183

			Point pt;

   184

			int widget;

   185

		} mouseover;

   186

   187

		struct {

   188

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

   189

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

   190

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

   191

		} keypress;

   192

   193

		struct {

   196

   197

		struct {

   198

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

   199

		} scroll;

   200

   201

		struct {

   202

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

   203

		} wheel;

   204

   205

		struct {

   206

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

   207

		} ctrl;

   208

	} we;

   209

};

   210

   211

/**

   212

 * High level window description

   213

 */

   214

struct WindowDesc {

   215

	int16 left;             ///< Prefered x position of left edge of the window, @see WindowDefaultPosition()

   216

	int16 top;              ///< Prefered y position of the top of the window, @see WindowDefaultPosition()

   217

	int16 minimum_width;    ///< Minimal width of the window

   218

	int16 minimum_height;   ///< Minimal height of the window

   219

	int16 default_width;    ///< Prefered initial width of the window

   220

	int16 default_height;   ///< Prefered initial height of the window

   221

	WindowClass cls;        ///< Class of the window, @see WindowClass

   222

	WindowClass parent_cls; ///< Class of the parent window, @see WindowClass

   223

	uint32 flags;           ///< Flags, @see WindowDefaultFlags

   224

	const Widget *widgets;  ///< List of widgets with their position and size for the window

   225

	WindowProc *proc;       ///< Window event handler function for the window

   226

};

   227

   228

/**

   229

 * Window default widget/window handling flags

   230

 */

   231

enum WindowDefaultFlag {

   232

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

   233

	WDF_DEF_WIDGET      =   1 << 1, ///< Default widget control for some widgets in the on click event, @see DispatchLeftClickEvent()

   234

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

   235

   236

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

   237

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

   238

	WDF_RESIZABLE       =   1 << 6, ///< Window can be resized

   239

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

   240

};

   241

   242

/**

   243

 * Special values for 'left' and 'top' to cause a specific placement

   244

 */

   245

enum WindowDefaultPosition {

   246

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

   247

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

   248

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

   249

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

   250

};

   251

   252

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

   253

   254

/**

   255

 * Scrollbar data structure

   256

 */

   257

struct Scrollbar {

   258

	uint16 count;  ///< Number of elements in the list

   259

	uint16 cap;    ///< Number of visible elements of the scroll bar

   260

	uint16 pos;

   261

};

   262

   263

/**

   264

 * Data structure for resizing a window

   265

 */

   266

struct ResizeInfo {

   267

	uint width;       ///< Minimum allowed width of the window

   268

	uint height;      ///< Minimum allowed height of the window

   269

	uint step_width;  ///< Step-size of width resize changes

   270

	uint step_height; ///< Step-size of height resize changes

   271

};

   272

   273

/**

   274

 * Data structure for an opened window

   275

 */

   276

struct Window : ZeroedMemoryAllocator {

   277

private:

   278

	WindowProc *wndproc;   ///< Event handler function for the window. Do not use directly, call HandleWindowEvent() instead.

   279

   280

protected:

   281

	void Initialize(int x, int y, int min_width, int min_height, int def_width, int def_height,

   282

			WindowProc *proc, WindowClass cls, const Widget *widget, int window_number, void *data);

   283

   284

public:

   285

	Window(int x, int y, int width, int height, WindowProc *proc, WindowClass cls, const Widget *widget, void *data = NULL);

   286

	Window(const WindowDesc *desc, void *data = NULL, WindowNumber number = 0);

   287

   288

	virtual ~Window();

   289

   290

	uint16 flags4;              ///< Window flags, @see WindowFlags

   291

	WindowClass window_class;   ///< Window class

   292

	WindowNumber window_number; ///< Window number within the window class

   293

   294

	int left;   ///< x position of left edge of the window

   295

	int top;    ///< y position of top edge of the window

   296

	int width;  ///< width of the window (number of pixels to the right in x direction)

   297

	int height; ///< Height of the window (number of pixels down in y direction)

   298

   299

	Scrollbar hscroll;  ///< Horizontal scroll bar

   300

	Scrollbar vscroll;  ///< First vertical scroll bar

   301

	Scrollbar vscroll2; ///< Second vertical scroll bar

   302

	ResizeInfo resize;  ///< Resize information

   303

   304

	byte caption_color; ///< Background color of the window caption, contains PlayerID

   305

   306

	ViewPort *viewport;    ///< Pointer to viewport, if present

   307

	const Widget *original_widget; ///< Original widget layout, copied from WindowDesc

   308

	Widget *widget;        ///< Widgets of the window

   309

	uint widget_count;     ///< Number of widgets of the window

   310

	uint32 desc_flags;     ///< Window/widgets default flags setting, @see WindowDefaultFlag

   311

   312

	Window *parent;        ///< Parent window

   313

	byte custom[WINDOW_CUSTOM_SIZE]; ///< Additional data depending on window type

   314

   315

	void HandleButtonClick(byte widget);

   316

   317

	void SetWidgetDisabledState(byte widget_index, bool disab_stat);

   318

	void DisableWidget(byte widget_index);

   319

	void EnableWidget(byte widget_index);

   320

	bool IsWidgetDisabled(byte widget_index) const;

   321

	void SetWidgetHiddenState(byte widget_index, bool hidden_stat);

   322

	void HideWidget(byte widget_index);

   323

	void ShowWidget(byte widget_index);

   324

	bool IsWidgetHidden(byte widget_index) const;

   325

	void SetWidgetLoweredState(byte widget_index, bool lowered_stat);

   326

	void ToggleWidgetLoweredState(byte widget_index);

   327

	void LowerWidget(byte widget_index);

   328

	void RaiseWidget(byte widget_index);

   329

	bool IsWidgetLowered(byte widget_index) const;

   330

   331

	void RaiseButtons();

   332

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

   333

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

   334

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

   335

	void InvalidateWidget(byte widget_index) const;

   336

   337

	void SetDirty() const;

   338

   339

	virtual void HandleWindowEvent(WindowEvent *e);

   340

};

   341

   342

struct menu_d {

   343

	byte item_count;      ///< follow_vehicle

   344

	byte sel_index;       ///< scrollpos_x

   345

	byte main_button;     ///< scrollpos_y

   346

	byte action_id;

   347

	StringID string_id;   ///< unk30

   348

	uint16 checked_items; ///< unk32

   349

	byte disabled_items;

   350

};

   351

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   352

   353

struct def_d {

   354

	int16 data_1, data_2, data_3;

   355

	int16 data_4, data_5;

   356

	bool close;

   357

	byte byte_1;

   358

};

   359

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_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 vp_d {

   375

	VehicleID follow_vehicle;

   376

	int32 scrollpos_x;

   377

	int32 scrollpos_y;

   378

	int32 dest_scrollpos_x;

   379

	int32 dest_scrollpos_y;

   380

	ViewPort vp_data;          ///< Screen position and zoom of the viewport

   381

};

   382

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   383

   384

enum SortListFlags {

   385

	VL_NONE    = 0,      ///< no sort

   386

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

   387

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

   388

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

   389

	VL_END     = 1 << 3,

   390

};

   391

   392

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   393

   394

struct Listing {

   395

	bool order;    ///< Ascending/descending

   396

	byte criteria; ///< Sorting criteria

   397

};

   398

   399

struct list_d {

   400

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

   401

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

   402

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

   403

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

   404

};

   405

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   406

   407

struct vehiclelist_d {

   408

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

   409

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

   410

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

   411

	VehicleType vehicle_type;   // The vehicle type that is sorted

   412

	list_d l;                   // General list struct

   413

};

   414

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehiclelist_d));

   415

   416

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

   417

enum WindowWidgetBehaviours {

   418

	WWB_PUSHBUTTON  = 1 << 5,

   419

   420

	WWB_MASK        = 0xE0,

   421

};

   422

   423

   424

/**

   425

 * Window widget types

   426

 */

   427

enum WindowWidgetTypes {

   428

	WWT_EMPTY,      ///< Empty widget, place holder to reserve space in widget array

   429

   430

	WWT_PANEL,      ///< Simple depressed panel

   431

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

   432

	WWT_IMGBTN,     ///< Button with image

   433

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

   434

   435

	WWT_TEXTBTN,    ///< Button with text

   436

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

   437

	WWT_LABEL,      ///< Centered label

   438

	WWT_TEXT,       ///< Pure simple text

   439

	WWT_MATRIX,     ///< List of items underneath each other

   440

	WWT_SCROLLBAR,  ///< Vertical scrollbar

   441

	WWT_FRAME,      ///< Frame

   442

	WWT_CAPTION,    ///< Window caption (window title between closebox and stickybox)

   443

   444

	WWT_HSCROLLBAR, ///< Horizontal scrollbar

   445

	WWT_STICKYBOX,  ///< Sticky box (normally at top-right of a window)

   446

	WWT_SCROLL2BAR, ///< 2nd vertical scrollbar

   447

	WWT_RESIZEBOX,  ///< Resize box (normally at bottom-right of a window)

   448

	WWT_CLOSEBOX,   ///< Close box (at top-left of a window)

   449

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

   450

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

   451

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

   452

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

   453

   454

	WWT_MASK = 0x1F,

   455

   456

	WWT_PUSHBTN     = WWT_PANEL   | WWB_PUSHBUTTON,

   457

	WWT_PUSHTXTBTN  = WWT_TEXTBTN | WWB_PUSHBUTTON,

   458

	WWT_PUSHIMGBTN  = WWT_IMGBTN  | WWB_PUSHBUTTON,

   459

};

   460

   461

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

   462

   463

/**

   464

 * Window flags

   465

 */

   466

enum WindowFlags {

   467

	WF_TIMEOUT_SHL       = 0,       ///< Window timeout counter shift

   468

	WF_TIMEOUT_MASK      = 7,       ///< Window timeout counter bit mask (3 bits), @see WF_TIMEOUT_SHL

   469

	WF_DRAGGING          = 1 <<  3, ///< Window is being dragged

   470

	WF_SCROLL_UP         = 1 <<  4, ///< Upper scroll button has been pressed, @see ScrollbarClickHandler()

   471

	WF_SCROLL_DOWN       = 1 <<  5, ///< Lower scroll button has been pressed, @see ScrollbarClickHandler()

   472

	WF_SCROLL_MIDDLE     = 1 <<  6, ///< Scrollbar scrolling, @see ScrollbarClickHandler()

   473

	WF_HSCROLL           = 1 <<  7,

   474

	WF_SIZING            = 1 <<  8,

   475

	WF_STICKY            = 1 <<  9, ///< Window is made sticky by user

   476

   477

	WF_DISABLE_VP_SCROLL = 1 << 10, ///< Window does not do autoscroll, @see HandleAutoscroll()

   478

   479

	WF_WHITE_BORDER_ONE  = 1 << 11,

   480

	WF_WHITE_BORDER_MASK = 1 << 12 | WF_WHITE_BORDER_ONE,

   481

	WF_SCROLL2           = 1 << 13,

   482

};

   483

   484

/* window.cpp */

   485