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 "company_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

/* How the resize system works:

    24

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

    25

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

    26

     to resize itself.

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

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

    34

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

    35

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

    36

     widgets moves downwards without resizing, and appears to be clamped

    37

     to the bottom. Nice aint it?

    38

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

    39

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

    40

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

    41

    after making the window, like this:

    42

      w->resize.step_height = 10;

    43

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

    44

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

    45

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

    46

    AFTER window - creation, with:

    47

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

    48

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

    49

    50

enum ResizeFlag {

    51

	RESIZE_NONE   = 0,  ///< no resize required

    52

    53

	RESIZE_LEFT   = 1,  ///< left resize flag

    54

	RESIZE_RIGHT  = 2,  ///< rigth resize flag

    55

	RESIZE_TOP    = 4,  ///< top resize flag

    56

	RESIZE_BOTTOM = 8,  ///< bottom resize flag

    57

    58

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

    59

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

    60

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

    61

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

    62

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

    63

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

    64

    65

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

    66

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

    67

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

    68

	 * Enabled, visible or unclicked widgets*/

    69

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

    70

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

    71

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

    72

};

    73

    74

enum {

    75

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

    76

};

    77

    78

/**

    79

 * Window widget data structure

    80

 */

    81

struct Widget {

    82

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

    83

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

    84

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

    85

	int16 left;                       ///< The left edge of the widget

    86

	int16 right;                      ///< The right edge of the widget

    87

	int16 top;                        ///< The top edge of the widget

    88

	int16 bottom;                     ///< The bottom edge of the widget

    89

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

    90

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

    91

};

    92

    93

/**

    94

 * Flags to describe the look of the frame

    95

 */

    96

enum FrameFlags {

    97

	FR_NONE         =  0,

    98

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

    99

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

   100

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

   101

	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)

   102

};

   103

   104

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

   105

   106

/* wiget.cpp */

   107

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

   108

   109

/**

   110

 * High level window description

   111

 */

   112

struct WindowDesc {

   113

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

   114

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

   115

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

   116

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

   117

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

   118

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

   119

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

   120

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

   121

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

   122

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

   123

};

   124

   125

/**

   126

 * Window default widget/window handling flags

   127

 */

   128

enum WindowDefaultFlag {

   129

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

   130

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

   131

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

   132

   133

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

   134

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

   135

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

   136

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

   137

};

   138

   139

/**

   140

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

   141

 */

   142

enum WindowDefaultPosition {

   143

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

   144

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

   145

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

   146

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

   147

};

   148

   149

/**

   150

 * Scrollbar data structure

   151

 */

   152

struct Scrollbar {

   153

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

   154

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

   155

	uint16 pos;    ///< Index of first visible item of the list

   156

};

   157

   158

/**

   159

 * Data structure for resizing a window

   160

 */

   161

struct ResizeInfo {

   162

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

   163

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

   164

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

   165

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

   166

};

   167

   168

enum SortButtonState {

   169

	SBS_OFF,

   170

	SBS_DOWN,

   171

	SBS_UP,

   172

};

   173

   174

/**

   175

 * Data structure for a window viewport

   176

 */

   177

struct ViewportData : ViewPort {

   178

	VehicleID follow_vehicle;

   179

	int32 scrollpos_x;

   180

	int32 scrollpos_y;

   181

	int32 dest_scrollpos_x;

   182

	int32 dest_scrollpos_y;

   183

};

   184

   185

/**

   186

 * Data structure for an opened window

   187

 */

   188

struct Window : ZeroedMemoryAllocator {

   189

	/** State whether an event is handled or not */

   190

	enum EventState {

   191

		ES_HANDLED,     ///< The passed event is handled

   192

		ES_NOT_HANDLED, ///< The passed event is not handled

   193

	};

   194

   195

protected:

   196

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

   197

			WindowClass cls, const Widget *widget, int window_number);

   198

	void FindWindowPlacementAndResize(int def_width, int def_height);

   199

	void FindWindowPlacementAndResize(const WindowDesc *desc);

   200

   201

public:

   202

	Window(int x, int y, int width, int height, WindowClass cls, const Widget *widget);

   203

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

   204

   205

	virtual ~Window();

   206

   207

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

   208

	WindowClass window_class;   ///< Window class

   209

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

   210

   211

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

   212

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

   213

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

   214

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

   215

   216

	Scrollbar hscroll;  ///< Horizontal scroll bar

   217

	Scrollbar vscroll;  ///< First vertical scroll bar

   218

	Scrollbar vscroll2; ///< Second vertical scroll bar

   219

	ResizeInfo resize;  ///< Resize information

   220

   221

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

   222

   223

	ViewportData *viewport;      ///< Pointer to viewport data, if present

   224

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

   225

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

   226

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

   227

   228

	Window *parent;        ///< Parent window

   229

   230

	void HandleButtonClick(byte widget);

   231

   232

	void SetWidgetDisabledState(byte widget_index, bool disab_stat);

   233

	void DisableWidget(byte widget_index);

   234

	void EnableWidget(byte widget_index);

   235

	bool IsWidgetDisabled(byte widget_index) const;

   236

	void SetWidgetHiddenState(byte widget_index, bool hidden_stat);

   237

	void HideWidget(byte widget_index);

   238

	void ShowWidget(byte widget_index);

   239

	bool IsWidgetHidden(byte widget_index) const;

   240

	void SetWidgetLoweredState(byte widget_index, bool lowered_stat);

   241

	void ToggleWidgetLoweredState(byte widget_index);

   242

	void LowerWidget(byte widget_index);

   243

	void RaiseWidget(byte widget_index);

   244

	bool IsWidgetLowered(byte widget_index) const;

   245

	void AlignWidgetRight(byte widget_index_a, byte widget_index_b);

   246

	int  GetWidgetWidth(byte widget_index) const;

   247

   248

	void RaiseButtons();

   249

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

   250

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

   251

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

   252

	void InvalidateWidget(byte widget_index) const;

   253

   254

	void DrawWidgets() const;

   255

	void DrawViewport() const;

   256

	void DrawSortButtonState(int widget, SortButtonState state) const;

   257

   258

	void DeleteChildWindows() const;

   259

   260

	void SetDirty() const;

   261

   262

	/*** Event handling ***/

   263

   264

	/**

   265

	 * This window is currently being repainted.

   266

	 */

   267

	virtual void OnPaint() {}

   268

   269

   270

	/**

   271

	 * A key has been pressed.

   272

	 * @param key     the Unicode value of the key.

   273

	 * @param keycode the untranslated key code including shift state.

   274

	 * @return ES_HANDLED if the key press has been handled and no other

   275

	 *         window should receive the event.

   276

	 */

   277

	virtual EventState OnKeyPress(uint16 key, uint16 keycode) { return ES_NOT_HANDLED; }

   278

   279

	/**

   280

	 * The state of the control key has changed

   281

	 * @return ES_HANDLED if the change has been handled and no other

   282

	 *         window should receive the event.

   283

	 */

   284

	virtual EventState OnCTRLStateChange() { return ES_NOT_HANDLED; }

   285

   286

   287

	/**

   288

	 * A click with the left mouse button has been made on the window.

   289

	 * @param pt     the point inside the window that has been clicked.

   290

	 * @param widget the clicked widget.

   291

	 */

   292

	virtual void OnClick(Point pt, int widget) {}

   293

   294

	/**

   295

	 * A double click with the left mouse button has been made on the window.

   296

	 * @param pt     the point inside the window that has been clicked.

   297

	 * @param widget the clicked widget.

   298

	 */

   299

	virtual void OnDoubleClick(Point pt, int widget) {}

   300

   301

	/**

   302

	 * A click with the right mouse button has been made on the window.

   303

	 * @param pt     the point inside the window that has been clicked.

   304

	 * @param widget the clicked widget.

   305

	 */

   306

	virtual void OnRightClick(Point pt, int widget) {}

   307

   308

	/**

   309

	 * A dragged 'object' has been released.

   310

	 * @param pt     the point inside the window where the release took place.

   311

	 * @param widget the widget where the release took place.

   312

	 */

   313

	virtual void OnDragDrop(Point pt, int widget) {}

   314

   315

	/**

   316

	 * Handle the request for (viewport) scrolling.

   317

	 * @param delta the amount the viewport must be scrolled.

   318

	 */

   319

	virtual void OnScroll(Point delta) {}

   320

   321

	/**

   322

	 * The mouse is currently moving over the window or has just moved outside

   323

	 * of the window. In the latter case pt is (-1, -1).

   324

	 * @param pt     the point inside the window that the mouse hovers over.

   325

	 * @param widget the widget the mouse hovers over.

   326

	 */

   327

	virtual void OnMouseOver(Point pt, int widget) {}

   328

   329

	/**

   330

	 * The mouse wheel has been turned.

   331

	 * @param wheel the amount of movement of the mouse wheel.

   332

	 */

   333

	virtual void OnMouseWheel(int wheel) {}

   334

   335

   336

	/**

   337

	 * Called for every mouse loop run, which is at least once per (game) tick.

   338

	 */

   339

	virtual void OnMouseLoop() {}

   340

   341

	/**

   342

	 * Called once per (game) tick.

   343

	 */

   344

	virtual void OnTick() {}

   345

   346

	/**

   347

	 * Called once every 100 (game) ticks.

   348

	 */

   349

	virtual void OnHundredthTick() {}

   350

   351

	/**

   352

	 * Called when this window's timeout has been reached.

   353

	 */

   354

	virtual void OnTimeout() {}

   355

   356

   357

	/**

   358

	 * Called when the window got resized.

   359

	 * @param new_size the new size of the window.

   360

	 * @param delta    the amount of which the window size changed.

   361

	 */

   362

	virtual void OnResize(Point new_size, Point delta) {}

   363

   364

	/**

   365

	 * A dropdown option associated to this window has been selected.

   366

	 * @param widget the widget (button) that the dropdown is associated with.

   367

	 * @param index  the element in the dropdown that is selected.

   368

	 */

   369

	virtual void OnDropdownSelect(int widget, int index) {}

   370

   371

	/**

   372

	 * The query window opened from this window has closed.

   373

	 * @param str the new value of the string or NULL if the window

   374

	 *            was cancelled.

   375

	 */

   376

	virtual void OnQueryTextFinished(char *str) {}

   377

   378

	/**

   379

	 * Some data on this window has become invalid.

   380

	 * @param data information about the changed data.

   381

	 */

   382

	virtual void OnInvalidateData(int data = 0) {}

   383

   384

   385

	/**

   386

	 * The user clicked some place on the map when a tile highlight mode

   387

	 * has been set.

   388

	 * @param pt   the exact point on the map that has been clicked.

   389

	 * @param tile the tile on the map that has been clicked.

   390

	 */

   391

	virtual void OnPlaceObject(Point pt, TileIndex tile) {}

   392

   393

	/**

   394

	 * The user cancelled a tile highlight mode that has been set.

   395

	 */

   396

	virtual void OnPlaceObjectAbort() {}

   397

   398

   399

	/**

   400

	 * The user is dragging over the map when the tile highlight mode

   401

	 * has been set.

   402

	 * @param select_method the method of selection (allowed directions)

   403

	 * @param select_proc   what will be created when the drag is over.

   404

	 * @param pt            the exact point on the map where the mouse is.

   405

	 */

   406

	virtual void OnPlaceDrag(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt) {}

   407

   408

	/**

   409

	 * The user has dragged over the map when the tile highlight mode

   410

	 * has been set.

   411

	 * @param select_method the method of selection (allowed directions)

   412

	 * @param select_proc   what should be created.

   413

	 * @param pt            the exact point on the map where the mouse was released.

   414

	 * @param start_tile    the begin tile of the drag.

   415

	 * @param end_tile      the end tile of the drag.

   416

	 */

   417

	virtual void OnPlaceMouseUp(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt, TileIndex start_tile, TileIndex end_tile) {}

   418

   419

	/**

   420

	 * The user moves over the map when a tile highlight mode has been set

   421

	 * when the special mouse mode has been set to 'PRESIZE' mode. An

   422

	 * example of this is the tile highlight for dock building.

   423

	 * @param pt   the exact point on the map where the mouse is.

   424

	 * @param tile the tile on the map where the mouse is.

   425

	 */

   426

	virtual void OnPlacePresize(Point pt, TileIndex tile) {}

   427

   428

	/*** End of the event handling ***/

   429

};

   430

   431

/**

   432

 * Data structure for a window opened from a toolbar

   433

 */

   434

class PickerWindowBase : public Window {

   435

   436

public:

   437

	PickerWindowBase(const WindowDesc *desc, Window *parent) : Window(desc)

   438

	{

   439

		this->parent = parent;

   440

	};

   441

   442

	virtual ~PickerWindowBase();

   443

};

   444

   445

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

   446

enum WindowWidgetBehaviours {

   447

	WWB_PUSHBUTTON  = 1 << 5,

   448

   449

	WWB_MASK        = 0xE0,

   450

};

   451

   452

   453

/**

   454

 * Window widget types

   455

 */

   456

enum WindowWidgetTypes {

   457

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

   458

   459

	WWT_PANEL,      ///< Simple depressed panel

   460

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

   461

	WWT_IMGBTN,     ///< Button with image

   462

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

   463

   464

	WWT_TEXTBTN,    ///< Button with text

   465

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

   466

	WWT_LABEL,      ///< Centered label

   467

	WWT_TEXT,       ///< Pure simple text

   468

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

   469

	WWT_SCROLLBAR,  ///< Vertical scrollbar

   470

	WWT_FRAME,      ///< Frame

   471

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

   472

   473

	WWT_HSCROLLBAR, ///< Horizontal scrollbar

   474

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

   475

	WWT_SCROLL2BAR, ///< 2nd vertical scrollbar

   476

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

   477

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

   478

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

   479

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

   480

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

   481

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

   482

   483

	WWT_MASK = 0x1F,

   484

   485

	WWT_PUSHBTN     = WWT_PANEL   | WWB_PUSHBUTTON,