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

bool _popup_menu_active;

    48

    49

byte _special_mouse_mode;

    50

    51

    52

/**

    53

 * Call the window event handler for handling event \a e

    54

 * @param e Window event to handle

    55

 */

    56

void Window::HandleWindowEvent(WindowEvent *e)

    57

{

    58

	if (wndproc != NULL) wndproc(this, e);

    59

}

    60

    61

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

    62

{

    63

	va_list wdg_list;

    64

    65

	va_start(wdg_list, widgets);

    66

    67

	while (widgets != WIDGET_LIST_END) {

    68

		SetWidgetDisabledState(widgets, disab_stat);

    69

		widgets = va_arg(wdg_list, int);

    70

	}

    71

    72

	va_end(wdg_list);

    73

}

    74

    75

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

    76

{

    77

	va_list wdg_list;

    78

    79

	va_start(wdg_list, widgets);

    80

    81

	while (widgets != WIDGET_LIST_END) {

    82

		SetWidgetHiddenState(widgets, hidden_stat);

    83

		widgets = va_arg(wdg_list, int);

    84

	}

    85

    86

	va_end(wdg_list);

    87

}

    88

    89

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

    90

{

    91

	va_list wdg_list;

    92

    93

	va_start(wdg_list, widgets);

    94

    95

	while (widgets != WIDGET_LIST_END) {

    96

		SetWidgetLoweredState(widgets, lowered_stat);

    97

		widgets = va_arg(wdg_list, int);

    98

	}

    99

   100

	va_end(wdg_list);

   101

}

   102

   103

void Window::RaiseButtons()

   104

{

   105

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

   106

		if (this->IsWidgetLowered(i)) {

   107

			this->RaiseWidget(i);

   108

			this->InvalidateWidget(i);

   109

		}

   110

	}

   111

}

   112

   113

void Window::InvalidateWidget(byte widget_index) const

   114

{

   115

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

   116

   117

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

   118

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

   119

   120

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

   121

}

   122

   123

void Window::HandleButtonClick(byte widget)

   124

{

   125

	this->LowerWidget(widget);

   126

	this->flags4 |= 5 << WF_TIMEOUT_SHL;

   127

	this->InvalidateWidget(widget);

   128

}

   129

   130

static void StartWindowDrag(Window *w);

   131

static void StartWindowSizing(Window *w);

   132

   133

/**

   134

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

   135

 * @param w Window to dispatch event in

   136

 * @param x X coordinate of the click

   137

 * @param y Y coordinate of the click

   138

 * @param double_click Was it a double click?

   139

 */

   140

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

   141

{

   142

	WindowEvent e;

   143

	e.we.click.pt.x = x;

   144

	e.we.click.pt.y = y;

   145

	e.event = double_click ? WE_DOUBLE_CLICK : WE_CLICK;

   146

   147

	if (w->desc_flags & WDF_DEF_WIDGET) {

   148

		e.we.click.widget = GetWidgetFromPos(w, x, y);

   149

		if (e.we.click.widget < 0) return; // exit if clicked outside of widgets

   150

   151

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

   152

		if (w->IsWidgetDisabled(e.we.click.widget)) return;

   153

   154

		const Widget *wi = &w->widget[e.we.click.widget];

   155

   156

		if (wi->type & WWB_MASK) {

   157

			/* special widget handling for buttons*/

   158

			switch (wi->type) {

   159

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   160

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   161

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   162

					w->HandleButtonClick(e.we.click.widget);

   163

					break;

   164

			}

   165

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

   166

			ScrollbarClickHandler(w, wi, e.we.click.pt.x, e.we.click.pt.y);

   167

		}

   168

   169

		if (w->desc_flags & WDF_STD_BTN) {

   170

			if (e.we.click.widget == 0) { /* 'X' */

   171

				delete w;

   172

				return;

   173

			}

   174

   175

			if (e.we.click.widget == 1) { /* 'Title bar' */

   176

				StartWindowDrag(w);

   177

				return;

   178

			}

   179

		}

   180

   181

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

   182

			StartWindowSizing(w);

   183

			w->InvalidateWidget(e.we.click.widget);

   184

			return;

   185

		}

   186

   187

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

   188

			w->flags4 ^= WF_STICKY;

   189

			w->InvalidateWidget(e.we.click.widget);

   190

			return;

   191

		}

   192

	}

   193

   194

	w->HandleWindowEvent(&e);

   195

}

   196

   197

/**

   198

 * Dispatch right mouse-button click in window.

   199

 * @param w Window to dispatch event in

   200

 * @param x X coordinate of the click

   201

 * @param y Y coordinate of the click

   202

 */

   203

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

   204

{

   205

	WindowEvent e;

   206

   207

	/* default tooltips handler? */

   208

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   209

		e.we.click.widget = GetWidgetFromPos(w, x, y);

   210

		if (e.we.click.widget < 0) return; // exit if clicked outside of widgets

   211

   212

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

   213

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

   214

			return;

   215

		}

   216

	}

   217

   218

	e.event = WE_RCLICK;

   219

	e.we.click.pt.x = x;

   220

	e.we.click.pt.y = y;

   221

	w->HandleWindowEvent(&e);

   222

}

   223

   224

/**

   225

 * Dispatch the mousewheel-action to the window.

   226

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

   227

 * @param w Window

   228

 * @param widget the widget where the scrollwheel was used

   229

 * @param wheel scroll up or down

   230

 */

   231

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

   232

{

   233

	if (widget < 0) return;

   234

   235

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

   236

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

   237

   238

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

   239

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

   240

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

   241

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

   242

	Scrollbar *sb;

   243

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

   244

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

   245

   246

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

   247

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

   248

			if (pos != sb->pos) {

   249

				sb->pos = pos;

   250

				w->SetDirty();

   251

			}

   252

		}

   253

	}

   254

}

   255

   256

/**

   257

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

   258

 *

   259

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

   260

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

   261

 *

   262

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

   263

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

   264

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

   265

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

   266

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

   267

 */

   268

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

   269

{

   270

	Window* const *vz = wz;

   271

   272

	while (++vz != _last_z_window) {

   273

		const Window *v = *vz;

   274

   275

		if (right > v->left &&

   276

				bottom > v->top &&

   277

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

   278

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

   279

			/* v and rectangle intersect with eeach other */

   280

			int x;

   281

   282

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

   283

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

   284

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

   285

				return;

   286

			}

   287

   288

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

   289

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

   290

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

   291

				return;

   292

			}

   293

   294

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

   295

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

   296

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

   297

				return;

   298

			}

   299

   300

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

   301

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

   302

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

   303

				return;

   304

			}

   305

   306

			return;

   307

		}

   308

	}

   309

   310

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

   311

	DrawPixelInfo *dp = _cur_dpi;

   312

	dp->width = right - left;

   313

	dp->height = bottom - top;

   314

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

   315

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

   316

	dp->pitch = _screen.pitch;

   317

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

   318

	dp->zoom = ZOOM_LVL_NORMAL;

   319

	CallWindowEventNP(*wz, WE_PAINT);

   320

}

   321

   322

/**

   323

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

   324

 * These windows should be re-painted.

   325

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

   326

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

   327

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

   328

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

   329

 */

   330

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

   331

{

   332

	Window* const *wz;

   333

	DrawPixelInfo bk;

   334

	_cur_dpi = &bk;

   335

   336

	FOR_ALL_WINDOWS(wz) {

   337

		const Window *w = *wz;

   338

		if (right > w->left &&

   339

				bottom > w->top &&

   340

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

   341

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

   342

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

   343

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

   344

		}

   345

	}

   346

}

   347

   348

/**

   349

 * Dispatch an event to a possibly non-existing window.

   350

 * If the window pointer w is \c NULL, the event is not dispatched

   351

 * @param w Window to dispatch the event to, may be \c NULL

   352

 * @param event Event to dispatch

   353

 */

   354

void CallWindowEventNP(Window *w, int event)

   355

{

   356

	WindowEvent e;

   357

   358

	e.event = event;

   359

	w->HandleWindowEvent(&e);

   360

}

   361

   362

/**

   363

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

   364

 * @param w Window to redraw

   365

 * @ingroup dirty

   366

 */

   367

void Window::SetDirty() const

   368

{

   369

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

   370

}

   371

   372

/**

   373

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

   374

 * @param w Window to redraw

   375

 * @ingroup dirty

   376

 */

   377

void SetWindowDirty(const Window *w)

   378

{

   379

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

   380

}

   381

   382

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

   383

 * @param w parent Window to find child of

   384

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

   385

static Window *FindChildWindow(const Window *w)

   386

{

   387

	Window* const *wz;

   388

   389

	FOR_ALL_WINDOWS(wz) {

   390

		Window *v = *wz;

   391

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

   392

	}

   393

   394

	return NULL;

   395

}

   396

   397

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

   398

 * or the behaviour is undefined but function should never fail

   399

 * @param w window to query Z Position

   400

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

   401

 */

   402

Window **FindWindowZPosition(const Window *w)

   403

{

   404

	Window **wz;

   405

   406

	FOR_ALL_WINDOWS(wz) {

   407

		if (*wz == w) return wz;

   408

	}

   409

   410

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

   411

		w->window_class, w->window_number);

   412

	return NULL;

   413

}

   414

   415

/**

   416

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

   417

 */

   418

Window::~Window()

   419

{

   420

	if (_thd.place_mode != VHM_NONE &&

   421

			_thd.window_class == this->window_class &&

   422

			_thd.window_number == this->window_number) {

   423

		ResetObjectToPlace();

   424

	}

   425

   426

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

   427

	if (_mouseover_last_w == this) _mouseover_last_w = NULL;

   428

   429

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

   430

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

   431

	 * done before removing the child so we cannot cause recursion

   432

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

   433

	Window **wz = FindWindowZPosition(this);

   434

	if (wz == NULL) return;

   435

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

   436

	_last_z_window--;

   437

   438

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

   439

	delete FindChildWindow(this);

   440

   441

	CallWindowEventNP(this, WE_DESTROY);

   442

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

   443

   444

	this->SetDirty();

   445

	free(this->widget);

   446

}

   447

   448

/**

   449

 * Find a window by its class and window number

   450

 * @param cls Window class

   451

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

   452

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

   453

 */

   454

Window *FindWindowById(WindowClass cls, WindowNumber number)

   455

{

   456

	Window* const *wz;

   457

   458

	FOR_ALL_WINDOWS(wz) {

   459

		Window *w = *wz;

   460

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

   461

	}

   462

   463

	return NULL;

   464

}

   465

   466

/**

   467

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

   468

 * @param cls Window class

   469

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

   470

 */

   471

void DeleteWindowById(WindowClass cls, WindowNumber number)

   472

{

   473

	delete FindWindowById(cls, number);

   474

}

   475

   476

/**

   477

 * Delete all windows of a given class

   478

 * @param cls Window class of windows to delete

   479

 */

   480

void DeleteWindowByClass(WindowClass cls)

   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) {

   489