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,

   124

	WE_TIMEOUT,

   125

	WE_PLACE_OBJ,

   126

	WE_ABORT_PLACE_OBJ,

   127

	WE_ON_EDIT_TEXT,

   128

	WE_ON_EDIT_TEXT_CANCEL,

   129

	WE_POPUPMENU_SELECT,

   130

	WE_POPUPMENU_OVER,

   131

	WE_DRAGDROP,

   132

	WE_PLACE_DRAG,

   133

	WE_PLACE_MOUSEUP,

   134

	WE_PLACE_PRESIZE,

   135

	WE_DROPDOWN_SELECT,

   136

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

   137

	WE_MESSAGE,         ///< Receipt of a message from another window. @see WindowEvent.we.message, SendWindowMessage(), SendWindowMessageClass()

   138

	WE_SCROLL,

   139

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

   140

	WE_CTRL_CHANGED,    ///< CTRL key has changed state

   141

};

   142

   143

/**

   144

 * Data structures for additional data associated with a window event

   145

 * @see WindowEventCodes

   146

 */

   147

struct WindowEvent {

   148

	byte event;

   149

	union {

   150

		struct {

   151

			void *data;

   152

		} create;

   153

   154

		struct {

   155

			Point pt;

   156

			int widget;

   157

		} click;

   158

   159

		struct {

   160

			Point pt;

   161

			TileIndex tile;

   162

			TileIndex starttile;

   163

			ViewportPlaceMethod select_method;

   164

			byte select_proc;

   165

		} place;

   166

   167

		struct {

   168

			Point pt;

   169

			int widget;

   170

		} dragdrop;

   171

   172

		struct {

   173

			Point size;

   174

			Point diff;

   175

		} sizing;

   176

   177

		struct {

   178

			char *str;

   179

		} edittext;

   180

   181

		struct {

   182

			Point pt;

   183

		} popupmenu;

   184

   185

		struct {

   186

			int button;

   187

			int index;

   188

		} dropdown;

   189

   190

		struct {

   191

			Point pt;

   192

			int widget;

   193

		} mouseover;

   194

   195

		struct {

   196

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

   197

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

   198

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

   199

		} keypress;

   200

   201

		struct {

   202

			int msg;      ///< message to be sent

   203

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

   204

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

   205

		} message;

   206

   207

		struct {

   208

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

   209

		} scroll;

   210

   211

		struct {

   212

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

   213

		} wheel;

   214

   215

		struct {

   216

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

   217

		} ctrl;

   218

	} we;

   219

};

   220

   221

/**

   222

 * High level window description

   223

 */

   224

struct WindowDesc {

   225

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

   226

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

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

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

   234

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

   235

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

   236

};

   237

   238

/**

   239

 * Window default widget/window handling flags

   240

 */

   241

enum WindowDefaultFlag {

   242

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

   243

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

   244

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

   245

   246

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

   247

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

   248

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

   249

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

   250

};

   251

   252

/**

   253

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

   254

 */

   255

enum WindowDefaultPosition {

   256

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

   257

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

   258

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

   259

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

   260

};

   261

   262

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

   263

   264

/**

   265

 * Scrollbar data structure

   266

 */

   267

struct Scrollbar {

   268

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

   269

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

   270

	uint16 pos;

   271

};

   272

   273

/**

   274

 * Data structure for resizing a window

   275

 */

   276

struct ResizeInfo {

   277

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

   278

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

   279

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

   280

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

   281

};

   282

   283

/**

   284

 * Message data structure for messages sent between winodows

   285

 * @see SendWindowMessageW()

   286

 */

   287

struct WindowMessage {

   288

	int msg;

   289

	int wparam;

   290

	int lparam;

   291

};

   292

   293

/**

   294

 * Data structure for an opened window

   295

 */

   296

struct Window : ZeroedMemoryAllocator {

   297

private:

   298

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

   299

   300

protected:

   301

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

   302

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

   303

   304

public:

   305

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

   306

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

   307

   308

	virtual ~Window();

   309

   310

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

   311

	WindowClass window_class;   ///< Window class

   312

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

   313

   314

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

   315

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

   316

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

   317

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

   318

   319

	Scrollbar hscroll;  ///< Horizontal scroll bar

   320

	Scrollbar vscroll;  ///< First vertical scroll bar

   321

	Scrollbar vscroll2; ///< Second vertical scroll bar

   322

	ResizeInfo resize;  ///< Resize information

   323

   324

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

   325

   326

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

   327

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

   328

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

   329

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

   330

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

   331

   332

	WindowMessage message; ///< Buffer for storing received messages (for communication between different window events)

   333

	Window *parent;        ///< Parent window

   334

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

   335

   336

	void HandleButtonClick(byte widget);

   337

   338

	void SetWidgetDisabledState(byte widget_index, bool disab_stat);

   339

	void DisableWidget(byte widget_index);

   340

	void EnableWidget(byte widget_index);

   341

	bool IsWidgetDisabled(byte widget_index) const;

   342

	void SetWidgetHiddenState(byte widget_index, bool hidden_stat);

   343

	void HideWidget(byte widget_index);

   344

	void ShowWidget(byte widget_index);

   345

	bool IsWidgetHidden(byte widget_index) const;

   346

	void SetWidgetLoweredState(byte widget_index, bool lowered_stat);

   347

	void ToggleWidgetLoweredState(byte widget_index);

   348

	void LowerWidget(byte widget_index);

   349

	void RaiseWidget(byte widget_index);

   350

	bool IsWidgetLowered(byte widget_index) const;

   351

   352

	void RaiseButtons();

   353

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

   354

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

   355

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

   356

	void InvalidateWidget(byte widget_index) const;

   357

   358

	void SetDirty() const;

   359

   360

	virtual void HandleWindowEvent(WindowEvent *e);

   361

};

   362

   363

struct menu_d {

   364

	byte item_count;      ///< follow_vehicle

   365

	byte sel_index;       ///< scrollpos_x

   366

	byte main_button;     ///< scrollpos_y

   367

	byte action_id;

   368

	StringID string_id;   ///< unk30

   369

	uint16 checked_items; ///< unk32

   370

	byte disabled_items;

   371

};

   372

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   373

   374

struct def_d {

   375

	int16 data_1, data_2, data_3;

   376

	int16 data_4, data_5;

   377

	bool close;

   378

	byte byte_1;

   379

};

   380

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   381

   382

struct depot_d {

   383

	VehicleID sel;

   384

	VehicleType type;

   385

	bool generate_list;

   386

	uint16 engine_list_length;

   387

	uint16 wagon_list_length;

   388

	uint16 engine_count;

   389

	uint16 wagon_count;

   390

	Vehicle **vehicle_list;

   391

	Vehicle **wagon_list;

   392

};

   393

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   394

   395

struct vp_d {

   396

	VehicleID follow_vehicle;

   397

	int32 scrollpos_x;

   398

	int32 scrollpos_y;

   399

	int32 dest_scrollpos_x;

   400

	int32 dest_scrollpos_y;

   401

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

   402

};

   403

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   404

   405

enum SortListFlags {

   406

	VL_NONE    = 0,      ///< no sort

   407

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

   408

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

   409

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

   410

	VL_END     = 1 << 3,

   411

};

   412

   413

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   414

   415

struct Listing {

   416

	bool order;    ///< Ascending/descending

   417

	byte criteria; ///< Sorting criteria

   418

};

   419

   420

struct list_d {

   421

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

   422

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

   423

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

   424

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

   425

};

   426

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   427

   428

struct vehiclelist_d {

   429

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

   430

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

   431

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

   432

	VehicleType vehicle_type;   // The vehicle type that is sorted

   433

	list_d l;                   // General list struct

   434

};

   435

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehiclelist_d));

   436

   437

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

   438

enum WindowWidgetBehaviours {

   439

	WWB_PUSHBUTTON  = 1 << 5,

   440

   441

	WWB_MASK        = 0xE0,

   442

};

   443

   444

   445

/**

   446

 * Window widget types

   447

 */

   448

enum WindowWidgetTypes {

   449

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

   450

   451

	WWT_PANEL,      ///< Simple depressed panel

   452

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

   453

	WWT_IMGBTN,     ///< Button with image

   454

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

   455

   456

	WWT_TEXTBTN,    ///< Button with text

   457

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

   458

	WWT_LABEL,      ///< Centered label

   459

	WWT_TEXT,       ///< Pure simple text

   460

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

   461

	WWT_SCROLLBAR,  ///< Vertical scrollbar

   462

	WWT_FRAME,      ///< Frame

   463

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

   464

   465

	WWT_HSCROLLBAR, ///< Horizontal scrollbar

   466

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

   467

	WWT_SCROLL2BAR, ///< 2nd vertical scrollbar

   468

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

   469

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

   470

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

   471

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

   472

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

   473

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

   474

   475

	WWT_MASK = 0x1F,

   476

   477

	WWT_PUSHBTN     = WWT_PANEL   | WWB_PUSHBUTTON,

   478

	WWT_PUSHTXTBTN  = WWT_TEXTBTN | WWB_PUSHBUTTON,

   479

	WWT_PUSHIMGBTN  = WWT_IMGBTN  | WWB_PUSHBUTTON,

   480

};

   481

   482

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

   483

   484

/**

   485

 * Window flags