1

/* $Id$ */

     2

     3

/** @file window.cpp Windowing system, widgets and events */

     4

     5

#include "stdafx.h"

     6

#include <stdarg.h>

     7

#include "openttd.h"

     8

#include "debug.h"

     9

#include "player_func.h"

    10

#include "gfx_func.h"

    11

#include "console.h"

    12

#include "viewport_func.h"

    13

#include "variables.h"

    14

#include "genworld.h"

    15

#include "blitter/factory.hpp"

    16

#include "window_gui.h"

    17

#include "zoom_func.h"

    18

#include "core/alloc_func.hpp"

    19

#include "map_func.h"

    20

#include "vehicle_base.h"

    21

#include "settings_type.h"

    22

#include "cheat_func.h"

    23

#include "window_func.h"

    24

#include "tilehighlight_func.h"

    25

    26

#include "table/sprites.h"

    27

    28

static Point _drag_delta; ///< delta between mouse cursor and upper left corner of dragged window

    29

static Window *_mouseover_last_w = NULL; ///< Window of the last MOUSEOVER event

    30

    31

/**

    32

 * List of windows opened at the screen.

    33

 * Uppermost window is at  _z_windows[_last_z_window - 1],

    34

 * bottom window is at _z_windows[0]

    35

 */

    36

Window *_z_windows[MAX_NUMBER_OF_WINDOWS];

    37

Window **_last_z_window; ///< always points to the next free space in the z-array

    38

    39

Point _cursorpos_drag_start;

    40

    41

int _scrollbar_start_pos;

    42

int _scrollbar_size;

    43

byte _scroller_click_timeout;

    44

    45

bool _scrolling_scrollbar;

    46

bool _scrolling_viewport;

    47

    48

byte _special_mouse_mode;

    49

    50

    51

void CDECL Window::SetWidgetsDisabledState(bool disab_stat, int widgets, ...)

    52

{

    53

	va_list wdg_list;

    54

    55

	va_start(wdg_list, widgets);

    56

    57

	while (widgets != WIDGET_LIST_END) {

    58

		SetWidgetDisabledState(widgets, disab_stat);

    59

		widgets = va_arg(wdg_list, int);

    60

	}

    61

    62

	va_end(wdg_list);

    63

}

    64

    65

void CDECL Window::SetWidgetsHiddenState(bool hidden_stat, int widgets, ...)

    66

{

    67

	va_list wdg_list;

    68

    69

	va_start(wdg_list, widgets);

    70

    71

	while (widgets != WIDGET_LIST_END) {

    72

		SetWidgetHiddenState(widgets, hidden_stat);

    73

		widgets = va_arg(wdg_list, int);

    74

	}

    75

    76

	va_end(wdg_list);

    77

}

    78

    79

void CDECL Window::SetWidgetsLoweredState(bool lowered_stat, int widgets, ...)

    80

{

    81

	va_list wdg_list;

    82

    83

	va_start(wdg_list, widgets);

    84

    85

	while (widgets != WIDGET_LIST_END) {

    86

		SetWidgetLoweredState(widgets, lowered_stat);

    87

		widgets = va_arg(wdg_list, int);

    88

	}

    89

    90

	va_end(wdg_list);

    91

}

    92

    93

void Window::RaiseButtons()

    94

{

    95

	for (uint i = 0; i < this->widget_count; i++) {

    96

		if (this->IsWidgetLowered(i)) {

    97

			this->RaiseWidget(i);

    98

			this->InvalidateWidget(i);

    99

		}

   100

	}

   101

}

   102

   103

void Window::InvalidateWidget(byte widget_index) const

   104

{

   105

	const Widget *wi = &this->widget[widget_index];

   106

   107

	/* Don't redraw the window if the widget is invisible or of no-type */

   108

	if (wi->type == WWT_EMPTY || IsWidgetHidden(widget_index)) return;

   109

   110

	SetDirtyBlocks(this->left + wi->left, this->top + wi->top, this->left + wi->right + 1, this->top + wi->bottom + 1);

   111

}

   112

   113

void Window::HandleButtonClick(byte widget)

   114

{

   115

	this->LowerWidget(widget);

   116

	this->flags4 |= 5 << WF_TIMEOUT_SHL;

   117

	this->InvalidateWidget(widget);

   118

}

   119

   120

static void StartWindowDrag(Window *w);

   121

static void StartWindowSizing(Window *w);

   122

   123

/**

   124

 * Dispatch left mouse-button (possibly double) click in window.

   125

 * @param w Window to dispatch event in

   126

 * @param x X coordinate of the click

   127

 * @param y Y coordinate of the click

   128

 * @param double_click Was it a double click?

   129

 */

   130

static void DispatchLeftClickEvent(Window *w, int x, int y, bool double_click)

   131

{

   132

	int widget = 0;

   133

	if (w->desc_flags & WDF_DEF_WIDGET) {

   134

		widget = GetWidgetFromPos(w, x, y);

   135

		if (widget < 0) return; // exit if clicked outside of widgets

   136

   137

		/* don't allow any interaction if the button has been disabled */

   138

		if (w->IsWidgetDisabled(widget)) return;

   139

   140

		const Widget *wi = &w->widget[widget];

   141

   142

		if (wi->type & WWB_MASK) {

   143

			/* special widget handling for buttons*/

   144

			switch (wi->type) {

   145

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   146

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   147

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   148

					w->HandleButtonClick(widget);

   149

					break;

   150

			}

   151

		} else if (wi->type == WWT_SCROLLBAR || wi->type == WWT_SCROLL2BAR || wi->type == WWT_HSCROLLBAR) {

   152

			ScrollbarClickHandler(w, wi, x, y);

   153

		}

   154

   155

		if (w->desc_flags & WDF_STD_BTN) {

   156

			if (widget == 0) { /* 'X' */

   157

				delete w;

   158

				return;

   159

			}

   160

   161

			if (widget == 1) { /* 'Title bar' */

   162

				StartWindowDrag(w);

   163

				return;

   164

			}

   165

		}

   166

   167

		if (w->desc_flags & WDF_RESIZABLE && wi->type == WWT_RESIZEBOX) {

   168

			StartWindowSizing(w);

   169

			w->InvalidateWidget(widget);

   170

			return;

   171

		}

   172

   173

		if (w->desc_flags & WDF_STICKY_BUTTON && wi->type == WWT_STICKYBOX) {

   174

			w->flags4 ^= WF_STICKY;

   175

			w->InvalidateWidget(widget);

   176

			return;

   177

		}

   178

	}

   179

   180

	Point pt = { x, y };

   181

   182

	if (double_click) {

   183

		w->OnDoubleClick(pt, widget);

   184

	} else {

   185

		w->OnClick(pt, widget);

   186

	}

   187

}

   188

   189

/**

   190

 * Dispatch right mouse-button click in window.

   191

 * @param w Window to dispatch event in

   192

 * @param x X coordinate of the click

   193

 * @param y Y coordinate of the click

   194

 */

   195

static void DispatchRightClickEvent(Window *w, int x, int y)

   196

{

   197

	int widget = 0;

   198

   199

	/* default tooltips handler? */

   200

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   201

		widget = GetWidgetFromPos(w, x, y);

   202

		if (widget < 0) return; // exit if clicked outside of widgets

   203

   204

		if (w->widget[widget].tooltips != 0) {

   205

			GuiShowTooltips(w->widget[widget].tooltips);

   206

			return;

   207

		}

   208

	}

   209

   210

	Point pt = { x, y };

   211

	w->OnRightClick(pt, widget);

   212

}

   213

   214

/**

   215

 * Dispatch the mousewheel-action to the window.

   216

 * The window will scroll any compatible scrollbars if the mouse is pointed over the bar or its contents

   217

 * @param w Window

   218

 * @param widget the widget where the scrollwheel was used

   219

 * @param wheel scroll up or down

   220

 */

   221

static void DispatchMouseWheelEvent(Window *w, int widget, int wheel)

   222

{

   223

	if (widget < 0) return;

   224

   225

	const Widget *wi1 = &w->widget[widget];

   226

	const Widget *wi2 = &w->widget[widget + 1];

   227

   228

	/* The listbox can only scroll if scrolling was done on the scrollbar itself,

   229

	 * or on the listbox (and the next item is (must be) the scrollbar)

   230

	 * XXX - should be rewritten as a widget-dependent scroller but that's

   231

	 * not happening until someone rewrites the whole widget-code */

   232

	Scrollbar *sb;

   233

	if ((sb = &w->vscroll,  wi1->type == WWT_SCROLLBAR)  || (sb = &w->vscroll2, wi1->type == WWT_SCROLL2BAR)  ||

   234

			(sb = &w->vscroll2, wi2->type == WWT_SCROLL2BAR) || (sb = &w->vscroll, wi2->type == WWT_SCROLLBAR) ) {

   235

   236

		if (sb->count > sb->cap) {

   237

			int pos = Clamp(sb->pos + wheel, 0, sb->count - sb->cap);

   238

			if (pos != sb->pos) {

   239

				sb->pos = pos;

   240

				w->SetDirty();

   241

			}

   242

		}

   243

	}

   244

}

   245

   246

/**

   247

 * Generate repaint events for the visible part of window *wz within the rectangle.

   248

 *

   249

 * The function goes recursively upwards in the window stack, and splits the rectangle

   250

 * into multiple pieces at the window edges, so obscured parts are not redrawn.

   251

 *

   252

 * @param wz Pointer into window stack, pointing at the window that needs to be repainted

   253

 * @param left Left edge of the rectangle that should be repainted

   254

 * @param top Top edge of the rectangle that should be repainted

   255

 * @param right Right edge of the rectangle that should be repainted

   256

 * @param bottom Bottom edge of the rectangle that should be repainted

   257

 */

   258

static void DrawOverlappedWindow(Window* const *wz, int left, int top, int right, int bottom)

   259

{

   260

	Window* const *vz = wz;

   261

   262

	while (++vz != _last_z_window) {

   263

		const Window *v = *vz;

   264

   265

		if (right > v->left &&

   266

				bottom > v->top &&

   267

				left < v->left + v->width &&

   268

				top < v->top + v->height) {

   269

			/* v and rectangle intersect with eeach other */

   270

			int x;

   271

   272

			if (left < (x = v->left)) {

   273

				DrawOverlappedWindow(wz, left, top, x, bottom);

   274

				DrawOverlappedWindow(wz, x, top, right, bottom);

   275

				return;

   276

			}

   277

   278

			if (right > (x = v->left + v->width)) {

   279

				DrawOverlappedWindow(wz, left, top, x, bottom);

   280

				DrawOverlappedWindow(wz, x, top, right, bottom);

   281

				return;

   282

			}

   283

   284

			if (top < (x = v->top)) {

   285

				DrawOverlappedWindow(wz, left, top, right, x);

   286

				DrawOverlappedWindow(wz, left, x, right, bottom);

   287

				return;

   288

			}

   289

   290

			if (bottom > (x = v->top + v->height)) {

   291

				DrawOverlappedWindow(wz, left, top, right, x);

   292

				DrawOverlappedWindow(wz, left, x, right, bottom);

   293

				return;

   294

			}

   295

   296

			return;

   297

		}

   298

	}

   299

   300

	/* Setup blitter, and dispatch a repaint event to window *wz */

   301

	DrawPixelInfo *dp = _cur_dpi;

   302

	dp->width = right - left;

   303

	dp->height = bottom - top;

   304

	dp->left = left - (*wz)->left;

   305

	dp->top = top - (*wz)->top;

   306

	dp->pitch = _screen.pitch;

   307

	dp->dst_ptr = BlitterFactoryBase::GetCurrentBlitter()->MoveTo(_screen.dst_ptr, left, top);

   308

	dp->zoom = ZOOM_LVL_NORMAL;

   309

	(*wz)->OnPaint();

   310

}

   311

   312

/**

   313

 * From a rectangle that needs redrawing, find the windows that intersect with the rectangle.

   314

 * These windows should be re-painted.

   315

 * @param left Left edge of the rectangle that should be repainted

   316

 * @param top Top edge of the rectangle that should be repainted

   317

 * @param right Right edge of the rectangle that should be repainted

   318

 * @param bottom Bottom edge of the rectangle that should be repainted

   319

 */

   320

void DrawOverlappedWindowForAll(int left, int top, int right, int bottom)

   321

{

   322

	Window* const *wz;

   323

	DrawPixelInfo bk;

   324

	_cur_dpi = &bk;

   325

   326

	FOR_ALL_WINDOWS(wz) {

   327

		const Window *w = *wz;

   328

		if (right > w->left &&

   329

				bottom > w->top &&

   330

				left < w->left + w->width &&

   331

				top < w->top + w->height) {

   332

			/* Window w intersects with the rectangle => needs repaint */

   333

			DrawOverlappedWindow(wz, left, top, right, bottom);

   334

		}

   335

	}

   336

}

   337

   338

/**

   339

 * Mark entire window as dirty (in need of re-paint)

   340

 * @param w Window to redraw

   341

 * @ingroup dirty

   342

 */

   343

void Window::SetDirty() const

   344

{

   345

	SetDirtyBlocks(this->left, this->top, this->left + this->width, this->top + this->height);

   346

}

   347

   348

/**

   349

 * Mark entire window as dirty (in need of re-paint)

   350

 * @param w Window to redraw

   351

 * @ingroup dirty

   352

 */

   353

void SetWindowDirty(const Window *w)

   354

{

   355

	if (w != NULL) w->SetDirty();

   356

}

   357

   358

/** Find the Window whose parent pointer points to this window

   359

 * @param w parent Window to find child of

   360

 * @return a Window pointer that is the child of w, or NULL otherwise */

   361

static Window *FindChildWindow(const Window *w)

   362

{

   363

	Window* const *wz;

   364

   365

	FOR_ALL_WINDOWS(wz) {

   366

		Window *v = *wz;

   367

		if (v->parent == w) return v;

   368

	}

   369

   370

	return NULL;

   371

}

   372

   373

/** Find the z-value of a window. A window must already be open

   374

 * or the behaviour is undefined but function should never fail

   375

 * @param w window to query Z Position

   376

 * @return Pointer into the window-list at the position of \a w

   377

 */

   378

Window **FindWindowZPosition(const Window *w)

   379

{

   380

	Window **wz;

   381

   382

	FOR_ALL_WINDOWS(wz) {

   383

		if (*wz == w) return wz;

   384

	}

   385

   386

	DEBUG(misc, 3, "Window (cls %d, number %d) is not open, probably removed by recursive calls",

   387

		w->window_class, w->window_number);

   388

	return NULL;

   389

}

   390

   391

/**

   392

 * Remove window and all its child windows from the window stack.

   393

 */

   394

Window::~Window()

   395

{

   396

	if (_thd.place_mode != VHM_NONE &&

   397

			_thd.window_class == this->window_class &&

   398

			_thd.window_number == this->window_number) {

   399

		ResetObjectToPlace();

   400

	}

   401

   402

	/* Prevent Mouseover() from resetting mouse-over coordinates on a non-existing window */

   403

	if (_mouseover_last_w == this) _mouseover_last_w = NULL;

   404

   405

	/* Find the window in the z-array, and effectively remove it

   406

	 * by moving all windows after it one to the left. This must be

   407

	 * done before removing the child so we cannot cause recursion

   408

	 * between the deletion of the parent and the child. */

   409

	Window **wz = FindWindowZPosition(this);

   410

	if (wz == NULL) return;

   411

	memmove(wz, wz + 1, (byte*)_last_z_window - (byte*)wz);

   412

	_last_z_window--;

   413

   414

	/* Delete all children a window might have in a head-recursive manner */

   415

	Window *child = FindChildWindow(this);

   416

	while (child != NULL) {

   417

		delete child;

   418

		child = FindChildWindow(this);

   419

	}

   420

   421

	if (this->viewport != NULL) DeleteWindowViewport(this);

   422

   423

	this->SetDirty();

   424

	free(this->widget);

   425

}

   426

   427

/**

   428

 * Find a window by its class and window number

   429

 * @param cls Window class

   430

 * @param number Number of the window within the window class

   431

 * @return Pointer to the found window, or \c NULL if not available

   432

 */

   433

Window *FindWindowById(WindowClass cls, WindowNumber number)

   434

{

   435

	Window* const *wz;

   436

   437

	FOR_ALL_WINDOWS(wz) {

   438

		Window *w = *wz;

   439

		if (w->window_class == cls && w->window_number == number) return w;

   440

	}

   441

   442

	return NULL;

   443

}

   444

   445

/**

   446

 * Delete a window by its class and window number (if it is open).

   447

 * @param cls Window class

   448

 * @param number Number of the window within the window class

   449

 */

   450

void DeleteWindowById(WindowClass cls, WindowNumber number)

   451

{

   452

	delete FindWindowById(cls, number);

   453

}

   454

   455

/**

   456

 * Delete all windows of a given class

   457

 * @param cls Window class of windows to delete

   458

 */

   459

void DeleteWindowByClass(WindowClass cls)

   460

{

   461

	Window* const *wz;

   462

   463

restart_search:

   464

	/* When we find the window to delete, we need to restart the search

   465

	 * as deleting this window could cascade in deleting (many) others

   466

	 * anywhere in the z-array */

   467

	FOR_ALL_WINDOWS(wz) {

   468

		Window *w = *wz;

   469

		if (w->window_class == cls) {

   470

			delete w;

   471

			goto restart_search;

   472

		}

   473

	}

   474

}

   475

   476

/** Delete all windows of a player. We identify windows of a player

   477

 * by looking at the caption colour. If it is equal to the player ID

   478

 * then we say the window belongs to the player and should be deleted

   479

 * @param id PlayerID player identifier */

   480

void DeletePlayerWindows(PlayerID id)

   481

{

   482

	Window* const *wz;

   483

   484

restart_search:

   485

	/* When we find the window to delete, we need to restart the search

   486

	 * as deleting this window could cascade in deleting (many) others

   487

	 * anywhere in the z-array */

   488

	FOR_ALL_WINDOWS(wz) {