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

/* 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, right, top, bottom;   ///< The position offsets inside the window

    86

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

    87

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

    88

};

    89

    90

/**

    91

 * Flags to describe the look of the frame

    92

 */

    93

enum FrameFlags {

    94

	FR_NONE         =  0,

    95

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

    96

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

    97

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

    98

	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)

    99

};

   100

   101

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

   102

   103

/* wiget.cpp */

   104

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

   105

   106

/**

   107

 * High level window description

   108

 */

   109

struct WindowDesc {

   110

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

   111

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

   112

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

   113

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

   114

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

   115

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

   116

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

   117

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

   118

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

   119

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

   120

};

   121

   122

/**

   123

 * Window default widget/window handling flags

   124

 */

   125

enum WindowDefaultFlag {

   126

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

   127

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

   128

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

   129

   130

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

   131

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

   132

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

   133

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

   134

};

   135

   136

/**

   137

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

   138

 */

   139

enum WindowDefaultPosition {

   140

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

   141

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

   142

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

   143

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

   144

};

   145

   146

/**

   147

 * Scrollbar data structure

   148

 */

   149

struct Scrollbar {

   150

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

   151

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

   152

	uint16 pos;

   153

};

   154

   155

/**

   156

 * Data structure for resizing a window

   157

 */

   158

struct ResizeInfo {

   159

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

   160

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

   161

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

   162

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

   163

};

   164

   165

enum SortButtonState {

   166

	SBS_OFF,

   167

	SBS_DOWN,

   168

	SBS_UP,

   169

};

   170

   171

/**

   172

 * Data structure for a window viewport

   173

 */

   174

struct ViewportData : ViewPort {

   175

	VehicleID follow_vehicle;

   176

	int32 scrollpos_x;

   177

	int32 scrollpos_y;

   178

	int32 dest_scrollpos_x;

   179

	int32 dest_scrollpos_y;

   180

};

   181

   182

/**

   183

 * Data structure for an opened window

   184

 */

   185

struct Window : ZeroedMemoryAllocator {

   186

	enum EventState {

   187

		ES_HANDLED,

   188

		ES_NOT_HANDLED,

   189

	};

   190

   191

protected:

   192

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

   193

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

   194

	void FindWindowPlacementAndResize(int def_width, int def_height);

   195

	void FindWindowPlacementAndResize(const WindowDesc *desc);

   196

   197

public:

   198

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

   199

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

   200

   201

	virtual ~Window();

   202

   203

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

   204

	WindowClass window_class;   ///< Window class

   205

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

   206

   207

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

   208

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

   209

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

   210

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

   211

   212

	Scrollbar hscroll;  ///< Horizontal scroll bar

   213

	Scrollbar vscroll;  ///< First vertical scroll bar

   214

	Scrollbar vscroll2; ///< Second vertical scroll bar

   215

	ResizeInfo resize;  ///< Resize information

   216

   217

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

   218

   219

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

   220

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

   221

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

   222

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

   223

   224

	Window *parent;        ///< Parent window

   225

   226

	void HandleButtonClick(byte widget);

   227

   228

	void SetWidgetDisabledState(byte widget_index, bool disab_stat);

   229

	void DisableWidget(byte widget_index);

   230

	void EnableWidget(byte widget_index);

   231

	bool IsWidgetDisabled(byte widget_index) const;

   232

	void SetWidgetHiddenState(byte widget_index, bool hidden_stat);

   233

	void HideWidget(byte widget_index);

   234

	void ShowWidget(byte widget_index);

   235

	bool IsWidgetHidden(byte widget_index) const;

   236

	void SetWidgetLoweredState(byte widget_index, bool lowered_stat);

   237

	void ToggleWidgetLoweredState(byte widget_index);

   238

	void LowerWidget(byte widget_index);

   239

	void RaiseWidget(byte widget_index);

   240

	bool IsWidgetLowered(byte widget_index) const;

   241

   242

	void RaiseButtons();

   243

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

   244

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

   245

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

   246

	void InvalidateWidget(byte widget_index) const;

   247

   248

	void DrawWidgets() const;

   249

	void DrawViewport() const;

   250

	void DrawSortButtonState(int widget, SortButtonState state) const;

   251

   252

	void SetDirty() const;

   253

   254

	/*** Event handling ***/

   255

   256

	/**

   257

	 * This window is currently being repainted.

   258

	 */

   259

	virtual void OnPaint() {}

   260

   261

   262

	/**

   263

	 * A key has been pressed.

   264

	 * @param key     the Unicode value of the key.

   265

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

   266

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

   267

	 *         window should receive the event.

   268

	 */

   269

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

   270

   271

	/**

   272

	 * The state of the control key has changed

   273

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

   274

	 *         window should receive the event.

   275

	 */

   276

	virtual EventState OnCTRLStateChange() { return ES_NOT_HANDLED; }

   277

   278

   279

	/**

   280

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

   281

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

   282

	 * @param widget the clicked widget.

   283

	 */

   284

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

   285

   286

	/**

   287

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

   288

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

   289

	 * @param widget the clicked widget.

   290

	 */

   291

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

   292

   293

	/**

   294

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

   295

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

   296

	 * @param widget the clicked widget.

   297

	 */

   298

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

   299

   300

	/**

   301

	 * A dragged 'object' has been released.

   302

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

   303

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

   304

	 */

   305

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

   306

   307

	/**

   308

	 * Handle the request for (viewport) scrolling.

   309

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

   310

	 */

   311

	virtual void OnScroll(Point delta) {}

   312

   313

	/**

   314

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

   315

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

   316

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

   317

	 * @param widget the widget the mouse hovers over.

   318

	 */

   319

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

   320

   321

	/**

   322

	 * The mouse wheel has been turned.

   323

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

   324

	 */

   325

	virtual void OnMouseWheel(int wheel) {}

   326

   327

   328

	/**

   329

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

   330

	 */

   331

	virtual void OnMouseLoop() {}

   332

   333

	/**

   334

	 * Called once per (game) tick.

   335

	 */

   336

	virtual void OnTick() {}

   337

   338

	/**

   339

	 * Called once every 100 (game) ticks.

   340

	 */

   341

	virtual void OnHundredthTick() {}

   342

   343

	/**

   344

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

   345

	 */

   346

	virtual void OnTimeout() {}

   347

   348

   349

	/**

   350

	 * Called when the window got resized.

   351

	 * @param new_size the new size of the window.

   352

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

   353

	 */

   354

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

   355

   356

	/**

   357

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

   358

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

   359

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

   360

	 */

   361

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

   362

   363

	/**

   364

	 * The query window opened from this window has closed.

   365

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

   366

	 *            was cancelled.

   367

	 */

   368

	virtual void OnQueryTextFinished(char *str) {}

   369

   370

	/**

   371

	 * Some data on this window has become invalid.

   372

	 * @param data information about the changed data.

   373

	 */

   374

	virtual void OnInvalidateData(int data = 0) {}

   375

   376

   377

	/**

   378

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

   379

	 * has been set.

   380

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

   381

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

   382

	 */

   383

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

   384

   385

	/**

   386

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

   387

	 */

   388

	virtual void OnPlaceObjectAbort() {}

   389

   390

   391

	/**

   392

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

   393

	 * has been set.

   394

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

   395

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

   396

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

   397

	 */

   398

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

   399

   400

	/**

   401

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

   402

	 * has been set.

   403

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

   404

	 * @param select_proc   what should be created.

   405

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

   406

	 * @param start_tile    the begin tile of the drag.

   407

	 * @param end_tile      the end tile of the drag.

   408

	 */

   409

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

   410

   411

	/**

   412

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

   413

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

   414

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

   415

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

   416

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

   417

	 */

   418

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

   419

   420

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

   421

};

   422

   423

/**

   424

 * Data structure for a window opened from a toolbar

   425

 */

   426

class PickerWindowBase : public Window {

   427

   428

public:

   429

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

   430

	{

   431

		this->parent = parent;

   432

	};

   433

   434

	virtual ~PickerWindowBase();

   435

};

   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