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

#include "core/alloc_type.hpp"

    14

    15

/**

    16

 * The maximum number of windows that can be opened.

    17

 */

    18

static const int MAX_NUMBER_OF_WINDOWS = 25;

    19

    20

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

    21

    22

/* How the resize system works:

    23

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

    24

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

    25

     to resize itself.

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

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

    34

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

    35

     widgets moves downwards without resizing, and appears to be clamped

    36

     to the bottom. Nice aint it?

    37

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

    38

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

    39

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

    40

    after making the window, like this:

    41

      w->resize.step_height = 10;

    42

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

    43

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

    44

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

    45

    AFTER window - creation, with:

    46

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

    47

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

    48

    49

enum ResizeFlag {

    50

	RESIZE_NONE   = 0,  ///< no resize required

    51

    52

	RESIZE_LEFT   = 1,  ///< left resize flag

    53

	RESIZE_RIGHT  = 2,  ///< rigth resize flag

    54

	RESIZE_TOP    = 4,  ///< top resize flag

    55

	RESIZE_BOTTOM = 8,  ///< bottom resize flag

    56

    57

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

    58

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

    59

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

    60

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

    61

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

    62

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

    63

    64

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

    65

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

    66

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

    67

	 * Enabled, visible or unclicked widgets*/

    68

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

    69

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

    70

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

    71

};

    72

    73

enum {

    74

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

    75

};

    76

    77

/**

    78

 * Window widget data structure

    79

 */

    80

struct Widget {

    81

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

    82

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

    83

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

    84

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

    85

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

    86

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

    87

};

    88

    89

/**

    90

 * Flags to describe the look of the frame

    91

 */

    92

enum FrameFlags {

    93

	FR_NONE         =  0,

    94

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

    95

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

    96

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

    97

	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)

    98

};

    99

   100

DECLARE_ENUM_AS_BIT_SET(FrameFlags);

   101

   102

/* wiget.cpp */

   103

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

   104

   105

/**

   106

 * Available window events

   107

 */

   108

enum WindowEventCodes {

   109

	WE_CREATE,       ///< Initialize the Window

   110

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

   111

	WE_PAINT,        ///< Repaint the window contents

   112

	WE_KEYPRESS,     ///< Key pressed

   113

	WE_CLICK,        ///< Left mouse button click

   114

	WE_DOUBLE_CLICK, ///< Left mouse button double click

   115

	WE_RCLICK,       ///< Right mouse button click

   116

	WE_MOUSEOVER,

   117

	WE_MOUSELOOP,

   118

	WE_MOUSEWHEEL,

   119

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

   120

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

   121

	WE_TIMEOUT,

   122

	WE_PLACE_OBJ,

   123

	WE_ABORT_PLACE_OBJ,

   124

	WE_ON_EDIT_TEXT,

   125

	WE_ON_EDIT_TEXT_CANCEL,

   126

	WE_POPUPMENU_SELECT,

   127

	WE_POPUPMENU_OVER,

   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_MESSAGE,         ///< Receipt of a message from another window. @see WindowEvent.we.message, SendWindowMessage(), SendWindowMessageClass()

   135

	WE_SCROLL,

   136

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

   137

	WE_CTRL_CHANGED,    ///< CTRL key has changed state

   138

};

   139

   140

/**

   141

 * Data structures for additional data associated with a window event

   142

 * @see WindowEventCodes

   143

 */

   144

struct WindowEvent {

   145

	byte event;

   146

	union {

   147

		struct {

   148

			void *data;

   149

		} create;

   150

   151

		struct {

   152

			Point pt;

   153

			int widget;

   154

		} click;

   155

   156

		struct {

   157

			Point pt;

   158

			TileIndex tile;

   159

			TileIndex starttile;

   160

			ViewportPlaceMethod select_method;

   161

			byte select_proc;

   162

		} place;

   163

   164

		struct {

   165

			Point pt;

   166

			int widget;

   167

		} dragdrop;

   168

   169

		struct {

   170

			Point size;

   171

			Point diff;

   172

		} sizing;

   173

   174

		struct {

   175

			char *str;

   176

		} edittext;

   177

   178

		struct {

   179

			Point pt;

   180

		} popupmenu;

   181

   182

		struct {

   183

			int button;

   184

			int index;

   185

		} dropdown;

   186

   187

		struct {

   188

			Point pt;

   189

			int widget;

   190

		} mouseover;

   191

   192

		struct {

   193

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

   194

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

   195

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

   196

		} keypress;

   197

   198

		struct {

   199

			int msg;      ///< message to be sent

   200

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

   201

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

   202

		} message;

   203

   204

		struct {

   205

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

   206

		} scroll;

   207

   208

		struct {

   209

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

   210

		} wheel;

   211

   212

		struct {

   213

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

   214

		} ctrl;

   215

	} we;

   216

};

   217

   218

/**

   219

 * High level window description

   220

 */

   221

struct WindowDesc {

   222

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

   223

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

   224

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

   225

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

   226

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

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

};

   234

   235

/**

   236

 * Window default widget/window handling flags

   237

 */

   238

enum WindowDefaultFlag {

   239

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

   240

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

   241

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

   242

   243

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

   244

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

   245

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

   246

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

   247

};

   248

   249

/**

   250

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

   251

 */

   252

enum WindowDefaultPosition {

   253

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

   254

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

   255

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

   256

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

   257

};

   258

   259

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

   260

   261

/**

   262

 * Scrollbar data structure

   263

 */

   264

struct Scrollbar {

   265

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

   266

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

   267

	uint16 pos;

   268

};

   269

   270

/**

   271

 * Data structure for resizing a window

   272

 */

   273

struct ResizeInfo {

   274

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

   275

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

   276

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

   277

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

   278

};

   279

   280

/**

   281

 * Message data structure for messages sent between winodows

   282

 * @see SendWindowMessageW()

   283

 */

   284

struct WindowMessage {

   285

	int msg;

   286

	int wparam;

   287

	int lparam;

   288

};

   289

   290

/**

   291

 * Data structure for an opened window

   292

 */

   293

struct Window : ZeroedMemoryAllocator {

   294

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

   295

	WindowClass window_class;   ///< Window class

   296

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

   297

   298

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

   299

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

   300

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

   301

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

   302

   303

	Scrollbar hscroll;  ///< Horizontal scroll bar

   304

	Scrollbar vscroll;  ///< First vertical scroll bar

   305

	Scrollbar vscroll2; ///< Second vertical scroll bar

   306

	ResizeInfo resize;  ///< Resize information

   307

   308

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

   309

   310

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

   311

	ViewPort *viewport;    ///< Pointer to viewport, if present

   312

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

   313

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

   314

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

   315

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

   316

   317

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

   318

	Window *parent;        ///< Parent window

   319

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

   320

   321

	void HandleButtonClick(byte widget);

   322

   323

	void SetWidgetDisabledState(byte widget_index, bool disab_stat);

   324

	void DisableWidget(byte widget_index);

   325

	void EnableWidget(byte widget_index);

   326

	bool IsWidgetDisabled(byte widget_index) const;

   327

	void SetWidgetHiddenState(byte widget_index, bool hidden_stat);

   328

	void HideWidget(byte widget_index);

   329

	void ShowWidget(byte widget_index);

   330

	bool IsWidgetHidden(byte widget_index) const;

   331

	void SetWidgetLoweredState(byte widget_index, bool lowered_stat);

   332

	void ToggleWidgetLoweredState(byte widget_index);

   333

	void LowerWidget(byte widget_index);

   334

	void RaiseWidget(byte widget_index);

   335

	bool IsWidgetLowered(byte widget_index) const;

   336

   337

	void RaiseButtons();

   338

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

   339

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

   340

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

   341

	void InvalidateWidget(byte widget_index) const;

   342

};

   343

   344

struct menu_d {

   345

	byte item_count;      ///< follow_vehicle

   346

	byte sel_index;       ///< scrollpos_x

   347

	byte main_button;     ///< scrollpos_y

   348

	byte action_id;

   349

	StringID string_id;   ///< unk30

   350

	uint16 checked_items; ///< unk32

   351

	byte disabled_items;

   352

};

   353

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(menu_d));

   354

   355

struct def_d {

   356

	int16 data_1, data_2, data_3;

   357

	int16 data_4, data_5;

   358

	bool close;

   359

	byte byte_1;

   360

};

   361

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(def_d));

   362

   363

struct void_d {

   364

	void *data;

   365

};

   366

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(void_d));

   367

   368

struct tree_d {

   369

	uint16 base;

   370

	uint16 count;

   371

};

   372

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tree_d));

   373

   374

struct tooltips_d {

   375

	StringID string_id;

   376

	byte paramcount;

   377

	uint64 params[5];

   378

};

   379

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(tooltips_d));

   380

   381

struct depot_d {

   382

	VehicleID sel;

   383

	VehicleType type;

   384

	bool generate_list;

   385

	uint16 engine_list_length;

   386

	uint16 wagon_list_length;

   387

	uint16 engine_count;

   388

	uint16 wagon_count;

   389

	Vehicle **vehicle_list;

   390

	Vehicle **wagon_list;

   391

};

   392

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(depot_d));

   393

   394

struct vehicledetails_d {

   395

	byte tab;

   396

};

   397

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehicledetails_d));

   398

   399

struct smallmap_d {

   400

	int32 scroll_x;

   401

	int32 scroll_y;

   402

	int32 subscroll;

   403

};

   404

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(smallmap_d));

   405

   406

struct vp_d {

   407

	VehicleID follow_vehicle;

   408

	int32 scrollpos_x;

   409

	int32 scrollpos_y;

   410

	int32 dest_scrollpos_x;

   411

	int32 dest_scrollpos_y;

   412

	ViewPort vp_data;          ///< Screen position and zoom of the viewport

   413

};

   414

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vp_d));

   415

   416

struct highscore_d {

   417

	uint32 background_img;

   418

	int8 rank;

   419

};

   420

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(highscore_d));

   421

   422

struct scroller_d {

   423

	int height;

   424

	uint16 counter;

   425

};

   426

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(scroller_d));

   427

   428

enum SortListFlags {

   429

	VL_NONE    = 0,      ///< no sort

   430

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

   431

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

   432

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

   433

	VL_END     = 1 << 3,

   434

};

   435

   436

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

   437

   438

struct Listing {

   439

	bool order;    ///< Ascending/descending

   440

	byte criteria; ///< Sorting criteria

   441

};

   442

   443

struct list_d {

   444

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

   445

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

   446

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

   447

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

   448

};

   449

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(list_d));

   450

   451

struct message_d {

   452

	int msg;

   453

	int wparam;

   454

	int lparam;

   455

};

   456

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(message_d));

   457

   458

struct vehiclelist_d {

   459

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

   460

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

   461

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

   462

	VehicleType vehicle_type;   // The vehicle type that is sorted

   463

	list_d l;                   // General list struct

   464

};

   465

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(vehiclelist_d));

   466

   467

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

   468

enum WindowWidgetBehaviours {

   469

	WWB_PUSHBUTTON  = 1 << 5,

   470

   471

	WWB_MASK        = 0xE0,

   472

};

   473

   474

   475

/**

   476

 * Window widget types

   477

 */

   478

enum WindowWidgetTypes {

   479

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

   480

   481

	WWT_PANEL,      ///< Simple depressed panel

   482

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

   483

	WWT_IMGBTN,     ///< Button with image

   484

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