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

 * Available window events

   108

 */

   109

enum WindowEventCodes {

   110

	WE_CREATE,       ///< Initialize the Window

   111

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

   112

	WE_PAINT,        ///< Repaint the window contents

   113

	WE_KEYPRESS,     ///< Key pressed

   114

	WE_CLICK,        ///< Left mouse button click

   115

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

   116

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

   117

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

   118

	WE_TIMEOUT,

   119

	WE_PLACE_OBJ,

   120

	WE_ABORT_PLACE_OBJ,

   121

	WE_ON_EDIT_TEXT,

   122

	WE_PLACE_DRAG,

   123

	WE_PLACE_MOUSEUP,

   124

	WE_PLACE_PRESIZE,

   125

	WE_DROPDOWN_SELECT,

   126

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

   127

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

   128

	WE_CTRL_CHANGED,    ///< CTRL key has changed state

   129

};

   130

   131

/**

   132

 * Data structures for additional data associated with a window event

   133

 * @see WindowEventCodes

   134

 */

   135

struct WindowEvent {

   136

	byte event;

   137

	union {

   138

		struct {

   139

			Point pt;

   140

			int widget;

   141

		} click;

   142

   143

		struct {

   144

			Point pt;

   145

			TileIndex tile;

   146

			TileIndex starttile;

   147

			ViewportPlaceMethod select_method;

   149

		} place;

   150

   151

		struct {

   152

			Point pt;

   153

			int widget;

   154

		} dragdrop;

   155

   156

		struct {

   157

			Point size;

   158

			Point diff;

   159

		} sizing;

   160

   161

		struct {

   162

			char *str;

   163

		} edittext;

   164

   165

		struct {

   166

			int button;

   167

			int index;

   168

		} dropdown;

   169

   170

		struct {

   171

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

   172

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

   173

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

   174

		} keypress;

   175

   176

		struct {

   177

			int data;

   178

		} invalidate;

   179

   180

		struct {

   181

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

   182

		} ctrl;

   183

	} we;

   184

};

   185

   188

/**

   189

 * High level window description

   190

 */

   191

struct WindowDesc {

   192

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

   193

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

   194

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

   195

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

   196

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

   197

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

   198

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

   199

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

   200

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

   201

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

   202

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

   203

};

   204

   205

/**

   206

 * Window default widget/window handling flags

   207

 */

   208

enum WindowDefaultFlag {

   209

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

   210

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

   211

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

   212

   213

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

   214

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

   215

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

   216

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

   217

};

   218

   219

/**

   220

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

   221

 */

   222

enum WindowDefaultPosition {

   223

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

   224

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

   225

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

   226

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

   227

};

   228

   229

/**

   230

 * Scrollbar data structure

   231

 */

   232

struct Scrollbar {

   233

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

   234

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

   235

	uint16 pos;

   236

};

   237

   238

/**

   239

 * Data structure for resizing a window

   240

 */

   241

struct ResizeInfo {

   242

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

   243

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

   244

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

   245

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

   246

};

   247

   248

enum SortButtonState {

   249

	SBS_OFF,

   250

	SBS_DOWN,

   251

	SBS_UP,

   252

};

   253

   254

/**

   255

 * Data structure for a window viewport

   256

 */

   257

struct ViewportData : ViewPort {

   258

	VehicleID follow_vehicle;

   259

	int32 scrollpos_x;

   260

	int32 scrollpos_y;

   261

	int32 dest_scrollpos_x;

   262

	int32 dest_scrollpos_y;

   263

};

   264

   265

/**

   266

 * Data structure for an opened window

   267

 */

   268

struct Window : ZeroedMemoryAllocator {

   269

	enum EventState {

   270

		ES_HANDLED,

   271

		ES_NOT_HANDLED,

   272

	};

   273

   274

private:

   275

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

   276

	void HandleWindowEvent(WindowEvent *e);

   277

   278

protected:

   279

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

   280

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

   281

	void FindWindowPlacementAndResize(int def_width, int def_height);

   282

	void FindWindowPlacementAndResize(const WindowDesc *desc);

   283

   284

public:

   285

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

   286

	Window(const WindowDesc *desc, 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

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

   307

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

   308

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

   309

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

   310

   311

	Window *parent;        ///< Parent window

   312

   313

	void HandleButtonClick(byte widget);

   314

   315

	void SetWidgetDisabledState(byte widget_index, bool disab_stat);

   316

	void DisableWidget(byte widget_index);

   317

	void EnableWidget(byte widget_index);

   318

	bool IsWidgetDisabled(byte widget_index) const;

   319

	void SetWidgetHiddenState(byte widget_index, bool hidden_stat);

   320

	void HideWidget(byte widget_index);

   321

	void ShowWidget(byte widget_index);

   322

	bool IsWidgetHidden(byte widget_index) const;

   323

	void SetWidgetLoweredState(byte widget_index, bool lowered_stat);

   324

	void ToggleWidgetLoweredState(byte widget_index);

   325

	void LowerWidget(byte widget_index);

   326

	void RaiseWidget(byte widget_index);

   327

	bool IsWidgetLowered(byte widget_index) const;

   328

   329

	void RaiseButtons();

   330

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

   331

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

   332

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

   333

	void InvalidateWidget(byte widget_index) const;

   334

   335

	void DrawWidgets() const;

   336

	void DrawViewport() const;

   337

	void DrawSortButtonState(int widget, SortButtonState state) const;

   338

   339

	void SetDirty() const;

   340

   341

	/*** Event handling ***/

   342

   343

	/**

   344

	 * This window is currently being repainted.

   345

	 */

   346

	virtual void OnPaint();

   347

   348

   349

	/**

   350

	 * A key has been pressed.

   351

	 * @param key     the Unicode value of the key.

   352

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

   353

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

   354

	 *         window should receive the event.

   355

	 */

   356

	virtual EventState OnKeyPress(uint16 key, uint16 keycode);

   357

   358

	/**

   359

	 * The state of the control key has changed

   360

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

   361

	 *         window should receive the event.

   362

	 */

   363

	virtual EventState OnCTRLStateChange();

   364

   365

   366

	/**

   367

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

   368

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

   369

	 * @param widget the clicked widget.

   370

	 */

   371

	virtual void OnClick(Point pt, int widget);

   372

   373

	/**

   374

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

   375

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

   376

	 * @param widget the clicked widget.

   377

	 */

   378

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

   379

   380

	/**

   381

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

   382

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

   383

	 * @param widget the clicked widget.

   384

	 */

   385

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

   386

   387

	/**

   388

	 * A dragged 'object' has been released.

   389

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

   390

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

   391

	 */

   392

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

   393

   394

	/**

   395

	 * Handle the request for (viewport) scrolling.

   396

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

   397

	 */

   398

	virtual void OnScroll(Point delta) {}

   399

   400

	/**

   401

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

   402

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

   403

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

   404

	 * @param widget the widget the mouse hovers over.

   405

	 */

   406

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

   407

   408

	/**

   409

	 * The mouse wheel has been turned.

   410

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

   411

	 */

   412

	virtual void OnMouseWheel(int wheel) {}

   413

   414

   415

	/**

   416

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

   417

	 */

   418

	virtual void OnMouseLoop();

   419

   420

	/**

   421

	 * Called once per (game) tick.

   422

	 */

   423

	virtual void OnTick();

   424

   425

	/**

   426

	 * Called once every 100 (game) ticks.

   427

	 */

   428

	virtual void OnHundredthTick();

   429

   430

	/**

   431

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

   432

	 */

   433

	virtual void OnTimeout();

   434

   435

   436

	/**

   437

	 * Called when the window got resized.

   438

	 * @param new_size the new size of the window.

   439

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

   440

	 */

   441

	virtual void OnResize(Point new_size, Point delta);

   442

   443

	/**

   444

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

   445

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

   446

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

   447

	 */

   448

	virtual void OnDropdownSelect(int widget, int index);

   449

   450

	/**

   451

	 * The query window opened from this window has closed.

   452

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

   453

	 *            was cancelled.

   454

	 */

   455

	virtual void OnQueryTextFinished(char *str);

   456

   457

	/**

   458

	 * Some data on this window has become invalid.

   459

	 * @param data information about the changed data.

   460

	 */

   461

	virtual void OnInvalidateData(int data = 0);

   462

   463

   464

	/**

   465

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

   466

	 * has been set.

   467

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

   468

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

   469

	 */

   470

	virtual void OnPlaceObject(Point pt, TileIndex tile);

   471

   472

	/**

   473

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

   474

	 */

   475

	virtual void OnPlaceObjectAbort();

   476

   477

   478

	/**

   479

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

   480

	 * has been set.

   481

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

   482

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

   483

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

   484

	 */

   486