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 "vehicle_type.h"

    10

#include "viewport_type.h"

    11

#include "player_type.h"

    12

#include "strings_type.h"

    13

    14

/**

    15

 * The maximum number of windows that can be opened.

    16

 */

    17

static const int MAX_NUMBER_OF_WINDOWS = 25;

    18

    19

typedef void WindowProc(Window *w, WindowEvent *e);

    20

    21

/* How the resize system works:

    22

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

    23

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

    24

     to resize itself.

    25

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

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

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

    34

     widgets moves downwards without resizing, and appears to be clamped

    35

     to the bottom. Nice aint it?

    36

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

    37

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

    38

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

    39

    after making the window, like this:

    40

      w->resize.step_height = 10;

    41

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

    42

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

    43

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

    44

    AFTER window-creation, with:

    45

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

    46

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

    47

    48

enum ResizeFlag {

    49

	RESIZE_NONE   = 0,  ///< no resize required

    50

    51

	RESIZE_LEFT   = 1,  ///< left resize flag

    52

	RESIZE_RIGHT  = 2,  ///< rigth resize flag

    53

	RESIZE_TOP    = 4,  ///< top resize flag

    54

	RESIZE_BOTTOM = 8,  ///< bottom resize flag

    55

    56

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

    57

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

    58

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

    59

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

    60

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

    61

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

    62

    63

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

    64

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

    65

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

    66

	 * Enabled, visible or unclicked widgets*/

    67

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

    68

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

    69

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

    70

};

    71

    72

enum {

    73

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

    74

};

    75

    76

/**

    77

 * Window widget data structure

    78

 */

    79

struct Widget {

    80

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

    81

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

    82

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

    83

	int16 left, right, top, bottom;   ///< The position offsets inside the window

    84

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

    85

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

    86

};

    87

    88

/**

    89

 * Flags to describe the look of the frame

    90

 */

    91

enum FrameFlags {

    92

	FR_NONE         =  0,

    93

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

    94

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

    95

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

    96

	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)

    97

};

    98

    99

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

   100

   101

/* wiget.cpp */

   102

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

   103

   104

/**

   105

 * Available window events

   106

 */

   107

enum WindowEventCodes {

   108

	WE_CREATE,       ///< Initialize the Window

   109

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

   110

	WE_PAINT,        ///< Repaint the window contents

   111

	WE_KEYPRESS,     ///< Key pressed

   112

	WE_CLICK,        ///< Left mouse button click

   113

	WE_DOUBLE_CLICK, ///< Left mouse button double click

   114

	WE_RCLICK,       ///< Right mouse button click

   115

	WE_MOUSEOVER,

   116

	WE_MOUSELOOP,

   117

	WE_MOUSEWHEEL,

   118

	WE_TICK,         ///< Regularly occurring event (about once every 20 seconds orso, 10 days) for slowly changing content (typically list sorting)

   119

	WE_4,            ///< Regularly occurring event for updating continuously changing window content (other than view ports), or timer expiring

   120

	WE_TIMEOUT,

   121

	WE_PLACE_OBJ,

   122

	WE_ABORT_PLACE_OBJ,

   123

	WE_ON_EDIT_TEXT,

   124

	WE_ON_EDIT_TEXT_CANCEL,

   125

	WE_POPUPMENU_SELECT,

   126

	WE_POPUPMENU_OVER,

   127

	WE_DRAGDROP,

   128

	WE_PLACE_DRAG,

   129

	WE_PLACE_MOUSEUP,

   130

	WE_PLACE_PRESIZE,

   131

	WE_DROPDOWN_SELECT,

   132

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

   133

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

   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

			void *data;

   148

		} create;

   149

   150

		struct {

   151

			Point pt;

   152

			int widget;

   153

		} click;

   154

   155

		struct {

   156

			Point pt;

   157

			TileIndex tile;

   158

			TileIndex starttile;

   159

			ViewportPlaceMethod select_method;

   160

			byte select_proc;

   161

		} place;

   162

   163

		struct {

   164

			Point pt;

   165

			int widget;

   166

		} dragdrop;

   167

   168

		struct {

   169

			Point size;

   170

			Point diff;

   171

		} sizing;

   172

   173

		struct {

   174

			char *str;

   175

		} edittext;

   176

   177

		struct {

   178

			Point pt;

   179

		} popupmenu;

   180

   181

		struct {

   182

			int button;

   183

			int index;

   184

		} dropdown;

   185

   186

		struct {

   187

			Point pt;

   188

			int widget;

   189

		} mouseover;

   190

   191

		struct {

   192

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

   193

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

   194

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

   195

		} keypress;

   196

   197

		struct {

   198

			int msg;      ///< message to be sent

   199

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

   200

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

   201

		} message;

   202

   203

		struct {

   204

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

   205

		} scroll;

   206

   207

		struct {

   208

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

   209

		} wheel;

   210

   211

		struct {

   212

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

   213

		} ctrl;

   214

	} we;

   215

};

   216

   217

/**

   218

 * High level window description

   219

 */

   220

struct WindowDesc {

   221

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

   222

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

   223

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

   224

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

   225

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

   226

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

   227

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

   228

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

   229

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

   230

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

   231

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

   232

};

   233

   234

/**

   235

 * Window default widget/window handling flags

   236

 */

   237

enum WindowDefaultFlag {

   238

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

   239

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

   240

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

   241

   242

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

   243

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

   244

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

   245

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

   246

};

   247

   248

/**

   249

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

   250

 */

   251

enum WindowDefaultPosition {

   252

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

   253

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

   254

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

   255

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

   256

};

   257

   258

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

   259

   260

/**

   261

 * Scrollbar data structure

   262

 */

   263

struct Scrollbar {

   264

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

   265

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

   266

	uint16 pos;

   267

};

   268

   269

/**

   270

 * Data structure for resizing a window

   271

 */

   272

struct ResizeInfo {

   273

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

   274

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

   275

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

   276

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

   277

};

   278

   279

/**

   280

 * Message data structure for messages sent between winodows

   281

 * @see SendWindowMessageW()

   282

 */

   283

struct WindowMessage {

   284

	int msg;

   285

	int wparam;

   286

	int lparam;

   287

};

   288

   289

/**

   290

 * Data structure for an opened window

   291

 */

   292

struct Window {

   293

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

   294

	WindowClass window_class;   ///< Window class

   295

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

   296

   297

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

   298

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

   299

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

   300

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

   301

   302

	Scrollbar hscroll;  ///< Horizontal scroll bar

   303

	Scrollbar vscroll;  ///< First vertical scroll bar

   304

	Scrollbar vscroll2; ///< Second vertical scroll bar

   305

	ResizeInfo resize;  ///< Resize information

   306

   307

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

   308

   309

	WindowProc *wndproc;   ///< Event handler function for the window

   311

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

   312

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

   313

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

   314

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

   315

   316

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

   317

	Window *parent;        ///< Parent window

   318

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

   319

   320

	void HandleButtonClick(byte widget);

   321

   322

	void SetWidgetDisabledState(byte widget_index, bool disab_stat);

   323

	void DisableWidget(byte widget_index);

   324

	void EnableWidget(byte widget_index);

   325

	bool IsWidgetDisabled(byte widget_index) const;

   326

	void SetWidgetHiddenState(byte widget_index, bool hidden_stat);

   327

	void HideWidget(byte widget_index);

   328

	void ShowWidget(byte widget_index);

   329

	bool IsWidgetHidden(byte widget_index) const;

   330

	void SetWidgetLoweredState(byte widget_index, bool lowered_stat);

   331

	void ToggleWidgetLoweredState(byte widget_index);

   332

	void LowerWidget(byte widget_index);

   333

	void RaiseWidget(byte widget_index);

   334

	bool IsWidgetLowered(byte widget_index) const;

   335

   336

	void RaiseButtons();

   337

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

   338

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

   339

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

   340

	void InvalidateWidget(byte widget_index) const;

   341

};

   342

   343

struct menu_d {

   344

	byte item_count;      ///< follow_vehicle

   345

	byte sel_index;       ///< scrollpos_x

   346

	byte main_button;     ///< scrollpos_y

   347

	byte action_id;

   348

	StringID string_id;   ///< unk30

   349

	uint16 checked_items; ///< unk32

   350

	byte disabled_items;

   351

};

   352

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   353

   354

struct def_d {

   355

	int16 data_1, data_2, data_3;

   356

	int16 data_4, data_5;

   357

	bool close;

   358

	byte byte_1;

   359

};

   360

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   361

   362

struct void_d {

   363

	void *data;

   364

};

   365

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   366

   367

struct tree_d {

   368

	uint16 base;

   369

	uint16 count;

   370

};

   371

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   372

   373

struct tooltips_d {

   374

	StringID string_id;

   375

	byte paramcount;

   376

	uint64 params[5];

   377

};

   378

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   379

   380

struct depot_d {

   381

	VehicleID sel;

   382

	VehicleType type;

   383

	bool generate_list;

   384

	uint16 engine_list_length;

   385

	uint16 wagon_list_length;

   386

	uint16 engine_count;

   387

	uint16 wagon_count;

   388

	Vehicle **vehicle_list;

   389

	Vehicle **wagon_list;

   390

};

   391

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   392

   393

struct vehicledetails_d {

   394

	byte tab;

   395

};

   396

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehicledetails_d));

   397

   398

struct smallmap_d {

   399

	int32 scroll_x;

   400

	int32 scroll_y;

   401

	int32 subscroll;

   402

};

   403

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   404

   405

struct vp_d {

   406

	VehicleID follow_vehicle;

   407

	int32 scrollpos_x;

   408

	int32 scrollpos_y;

   409

	int32 dest_scrollpos_x;

   410

	int32 dest_scrollpos_y;

   411

};

   412

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   413

   414

struct highscore_d {

   415

	uint32 background_img;

   416

	int8 rank;

   417

};

   418

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   419

   420

struct scroller_d {

   421

	int height;

   422

	uint16 counter;

   423

};

   424

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   425

   426

enum SortListFlags {

   427

	VL_NONE    = 0,      ///< no sort

   428

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

   429

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

   430

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

   431

	VL_END     = 1 << 3,

   432

};

   433

   434

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   435

   436

struct Listing {

   437

	bool order;    ///< Ascending/descending

   438

	byte criteria; ///< Sorting criteria

   439

};

   440

   441

struct list_d {

   442

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

   443

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

   444

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

   445

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

   446

};

   447

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   448

   449

struct message_d {

   450

	int msg;

   451

	int wparam;

   452

	int lparam;

   453

};

   454

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   455

   456

struct vehiclelist_d {

   457

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

   458

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

   459

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

   460

	VehicleType vehicle_type;   // The vehicle type that is sorted

   461

	list_d l;                   // General list struct

   462

};

   463

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehiclelist_d));

   464

   465

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

   466

enum WindowWidgetBehaviours {

   467

	WWB_PUSHBUTTON  = 1 << 5,

   468

   469

	WWB_MASK        = 0xE0,

   470

};

   471

   472

   473

/**

   474

 * Window widget types

   475

 */

   476

enum WindowWidgetTypes {

   477

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

   478

   479

	WWT_PANEL,      ///< Simple depressed panel

   480

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

   481

	WWT_IMGBTN,     ///< Button with image

   482

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

   483

   484

	WWT_TEXTBTN,    ///< Button with text