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

			Point pt;

   148

			int widget;

   149

		} click;

   150

   151

		struct {

   152

			Point pt;

   153

			TileIndex tile;

   154

			TileIndex starttile;

   155

			ViewportPlaceMethod select_method;

   156

			byte select_proc;

   157

		} place;

   158

   159

		struct {

   160

			Point pt;

   161

			int widget;

   162

		} dragdrop;

   163

   164

		struct {

   165

			Point size;

   166

			Point diff;

   167

		} sizing;

   168

   169

		struct {

   170

			char *str;

   171

		} edittext;

   172

   173

		struct {

   174

			int button;

   175

			int index;

   176

		} dropdown;

   177

   178

		struct {

   179

			Point pt;

   180

			int widget;

   181

		} mouseover;

   182

   183

		struct {

   184

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

   185

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

   186

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

   187

		} keypress;

   188

   189

		struct {

   190

			int data;

   191

		} invalidate;

   192

   193

		struct {

   194

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

   195

		} scroll;

   196

   197

		struct {

   198

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

   199

		} wheel;

   200

   201

		struct {

   202

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

   203

		} ctrl;

   204

	} we;

   205

};

   206

   207

/**

   208

 * High level window description

   209

 */

   210

struct WindowDesc {

   211

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

   212

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

   213

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

   214

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

   215

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

   216

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

   217

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

   218

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

   219

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

   220

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

   221

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

   222

};

   223

   224

/**

   225

 * Window default widget/window handling flags

   226

 */

   227

enum WindowDefaultFlag {

   228

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

   229

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

   230

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

   231

   232

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

   233

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

   234

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

   235

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

   236

};

   237

   238

/**

   239

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

   240

 */

   241

enum WindowDefaultPosition {

   242

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

   243

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

   244

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

   245

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

   246

};

   247

   248

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

   249

   250

/**

   251

 * Scrollbar data structure

   252

 */

   253

struct Scrollbar {

   254

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

   255

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

   256

	uint16 pos;

   257

};

   258

   259

/**

   260

 * Data structure for resizing a window

   261

 */

   262

struct ResizeInfo {

   263

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

   264

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

   265

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

   266

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

   267

};

   268

   269

/**

   270

 * Data structure for a window viewport

   271

 */

   272

struct ViewportData : ViewPort {

   273

	VehicleID follow_vehicle;

   274

	int32 scrollpos_x;

   275

	int32 scrollpos_y;

   276

	int32 dest_scrollpos_x;

   277

	int32 dest_scrollpos_y;

   278

};

   279

   280

	/**

   281

 * Data structure for an opened window

   282

 */

   283

struct Window : ZeroedMemoryAllocator {

   284

private:

   285

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

   286

	void HandleWindowEvent(WindowEvent *e);

   287

   288

protected:

   289

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

   290

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

   291

	void FindWindowPlacementAndResize(int def_width, int def_height);

   292

	void FindWindowPlacementAndResize(const WindowDesc *desc);

   293

   294

public:

   295

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

   296

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

   297

   298

	virtual ~Window();

   299

   300

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

   301

	WindowClass window_class;   ///< Window class

   302

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

   303

   304

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

   305

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

   306

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

   307

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

   308

   309

	Scrollbar hscroll;  ///< Horizontal scroll bar

   310

	Scrollbar vscroll;  ///< First vertical scroll bar

   311

	Scrollbar vscroll2; ///< Second vertical scroll bar

   312

	ResizeInfo resize;  ///< Resize information

   313

   314

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

   315

   316

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

   317

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

   318

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

   319

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

   320

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

   321

   322

	Window *parent;        ///< Parent window

   323

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

   324

   325

	void HandleButtonClick(byte widget);

   326

   327

	void SetWidgetDisabledState(byte widget_index, bool disab_stat);

   328

	void DisableWidget(byte widget_index);

   329

	void EnableWidget(byte widget_index);

   330

	bool IsWidgetDisabled(byte widget_index) const;

   331

	void SetWidgetHiddenState(byte widget_index, bool hidden_stat);

   332

	void HideWidget(byte widget_index);

   333

	void ShowWidget(byte widget_index);

   334

	bool IsWidgetHidden(byte widget_index) const;

   335

	void SetWidgetLoweredState(byte widget_index, bool lowered_stat);

   336

	void ToggleWidgetLoweredState(byte widget_index);

   337

	void LowerWidget(byte widget_index);

   338

	void RaiseWidget(byte widget_index);

   339

	bool IsWidgetLowered(byte widget_index) const;

   340

   341

	void RaiseButtons();

   342

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

   343

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

   344

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

   345

	void InvalidateWidget(byte widget_index) const;

   346

   347

	void SetDirty() const;

   348

   349

	/*** Event handling ***/

   350

   351

	/**

   352

	 * This window is currently being repainted.

   353

	 */

   354

	virtual void OnPaint();

   355

   356

   357

	/**

   358

	 * A key has been pressed.

   359

	 * @param key     the Unicode value of the key.

   360

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

   361

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

   362

	 *         window should receive the event.

   363

	 */

   364

	virtual bool OnKeyPress(uint16 key, uint16 keycode);

   365

   366

	/**

   367

	 * The state of the control key has changed

   368

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

   369

	 *         window should receive the event.

   370

	 */

   371

	virtual bool OnCTRLStateChange();

   372

   373

   374

	/**

   375

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

   376

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

   377

	 * @param widget the clicked widget.

   378

	 */

   379

	virtual void OnClick(Point pt, int widget);

   380

   381

	/**

   382

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

   383

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

   384

	 * @param widget the clicked widget.

   385

	 */

   386

	virtual void OnDoubleClick(Point pt, int widget);

   387

   388

	/**

   389

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

   390

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

   391

	 * @param widget the clicked widget.

   392

	 */

   393

	virtual void OnRightClick(Point pt, int widget);

   394

   395

	/**

   396

	 * A dragged 'object' has been released.

   397

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

   398

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

   399

	 */

   400

	virtual void OnDragDrop(Point pt, int widget);

   401

   402

	/**

   403

	 * Handle the request for (viewport) scrolling.

   404

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

   405

	 */

   406

	virtual void OnScroll(Point delta);

   407

   408

	/**

   409

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

   410

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

   411

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

   412

	 * @param widget the widget the mouse hovers over.

   413

	 */

   414

	virtual void OnMouseOver(Point pt, int widget);

   415

   416

	/**

   417

	 * The mouse wheel has been turned.

   418

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

   419

	 */

   420

	virtual void OnMouseWheel(int wheel);

   421

   422

   423

	/**

   424

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

   425

	 */

   426

	virtual void OnMouseLoop();

   427

   428

	/**

   429

	 * Called once per (game) tick.

   430

	 */

   431

	virtual void OnTick();

   432

   433

	/**

   434

	 * Called once every 100 (game) ticks.

   435

	 */

   436

	virtual void OnHundredthTick();

   437

   438

	/**

   439

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

   440

	 */

   441

	virtual void OnTimeout();

   442

   443

   444

	/**

   445

	 * Called when the window got resized.

   446

	 * @param new_size the new size of the window.

   447

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

   448

	 */

   449

	virtual void OnResize(Point new_size, Point delta);

   450

   451

	/**

   452

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

   453

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

   454

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

   455

	 */

   456

	virtual void OnDropdownSelect(int widget, int index);

   457

   458

	/**

   459

	 * The query window opened from this window has closed.

   460

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

   461

	 *            was cancelled.

   462

	 */

   463

	virtual void OnQueryTextFinished(char *str);

   464

   465

	/**

   466

	 * Some data on this window has become invalid.

   467

	 * @param data information about the changed data.

   468

	 */

   469

	virtual void OnInvalidateData(int data = 0);

   470

   471

   472

	/**

   473

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

   474

	 * has been set.

   475

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

   476

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

   477

	 */

   478

	virtual void OnPlaceObject(Point pt, TileIndex tile);

   479

   480

	/**

   481

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

   482

	 */

   483

	virtual void OnPlaceObjectAbort();

   484

   485

   486

	/**

   487

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

   488