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

    10

#include "gfx_func.h"

    11

#include "console_func.h"

    12

#include "console_gui.h"

    13

#include "viewport_func.h"

    14

#include "variables.h"

    15

#include "genworld.h"

    16

#include "blitter/factory.hpp"

    17

#include "window_gui.h"

    18

#include "zoom_func.h"

    19

#include "core/alloc_func.hpp"

    20

#include "map_func.h"

    21

#include "vehicle_base.h"

    22

#include "settings_type.h"

    23

#include "cheat_func.h"

    24

#include "window_func.h"

    25

#include "tilehighlight_func.h"

    26

#include "network/network.h"

    27

    28

#include "table/sprites.h"

    29

    30

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

    31

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

    32

    33

/**

    34

 * List of windows opened at the screen.

    35

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

    36

 * bottom window is at _z_windows[0]

    37

 */

    38

Window *_z_windows[MAX_NUMBER_OF_WINDOWS];

    39

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

    40

    41

byte _no_scroll;

    42

Point _cursorpos_drag_start;

    43

    44

int _scrollbar_start_pos;

    45

int _scrollbar_size;

    46

byte _scroller_click_timeout;

    47

    48

bool _scrolling_scrollbar;

    49

bool _scrolling_viewport;

    50

    51

byte _special_mouse_mode;

    52

    53

    54

/**

    55

 * Sets the enabled/disabled status of a list of widgets.

    56

 * By default, widgets are enabled.

    57

 * On certain conditions, they have to be disabled.

    58

 * @param disab_stat status to use ie: disabled = true, enabled = false

    59

 * @param widgets list of widgets ended by WIDGET_LIST_END

    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

/**

    76

 * Sets the hidden/shown status of a list of widgets.

    77

 * By default, widgets are visible.

    78

 * On certain conditions, they have to be hidden.

    79

 * @param hidden_stat status to use ie. hidden = true, visible = false

    80

 * @param widgets list of widgets ended by WIDGET_LIST_END

    81

 */

    82

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

    83

{

    84

	va_list wdg_list;

    85

    86

	va_start(wdg_list, widgets);

    87

    88

	while (widgets != WIDGET_LIST_END) {

    89

		SetWidgetHiddenState(widgets, hidden_stat);

    90

		widgets = va_arg(wdg_list, int);

    91

	}

    92

    93

	va_end(wdg_list);

    94

}

    95

    96

/**

    97

 * Sets the lowered/raised status of a list of widgets.

    98

 * @param lowered_stat status to use ie: lowered = true, raised = false

    99

 * @param widgets list of widgets ended by WIDGET_LIST_END

   100

 */

   101

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

   102

{

   103

	va_list wdg_list;

   104

   105

	va_start(wdg_list, widgets);

   106

   107

	while (widgets != WIDGET_LIST_END) {

   108

		SetWidgetLoweredState(widgets, lowered_stat);

   109

		widgets = va_arg(wdg_list, int);

   110

	}

   111

   112

	va_end(wdg_list);

   113

}

   114

   115

/**

   116

 * Raise all buttons of the window

   117

 */

   118

void Window::RaiseButtons()

   119

{

   120

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

   121

		if (this->IsWidgetLowered(i)) {

   122

			this->RaiseWidget(i);

   123

			this->InvalidateWidget(i);

   124

		}

   125

	}

   126

}

   127

   128

/**

   129

 * Invalidate a widget, i.e. mark it as being changed and in need of redraw.

   130

 * @param widget_index the widget to redraw.

   131

 */

   132

void Window::InvalidateWidget(byte widget_index) const

   133

{

   134

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

   135

   136

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

   137

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

   138

   139

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

   140

}

   141

   142

/**

   143

 * Do all things to make a button look clicked and mark it to be

   144

 * unclicked in a few ticks.

   145

 * @param widget the widget to "click"

   146

 */

   147

void Window::HandleButtonClick(byte widget)

   148

{

   149

	this->LowerWidget(widget);

   150

	this->flags4 |= WF_TIMEOUT_BEGIN;

   151

	this->InvalidateWidget(widget);

   152

}

   153

   154

static void StartWindowDrag(Window *w);

   155

static void StartWindowSizing(Window *w);

   156

   157

/**

   158

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

   159

 * @param w Window to dispatch event in

   160

 * @param x X coordinate of the click

   161

 * @param y Y coordinate of the click

   162

 * @param double_click Was it a double click?

   163

 */

   164

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

   165

{

   166

	int widget = 0;

   167

	if (w->desc_flags & WDF_DEF_WIDGET) {

   168

		widget = GetWidgetFromPos(w, x, y);

   169

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

   170

   171

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

   172

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

   173

   174

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

   175

   176

		if (wi->type & WWB_MASK) {

   177

			/* special widget handling for buttons*/

   178

			switch (wi->type) {

   179

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   180

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   181

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   182

					w->HandleButtonClick(widget);

   183

					break;

   184

			}

   185

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

   186

			ScrollbarClickHandler(w, wi, x, y);

   187

		}

   188

   189

		if (w->desc_flags & WDF_STD_BTN) {

   190

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

   191

				delete w;

   192

				return;

   193

			}

   194

   195

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

   196

				StartWindowDrag(w);

   197

				return;

   198

			}

   199

		}

   200

   201

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

   202

			StartWindowSizing(w);

   203

			w->InvalidateWidget(widget);

   204

			return;

   205

		}

   206

   207

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

   208

			w->flags4 ^= WF_STICKY;

   209

			w->InvalidateWidget(widget);

   210

			return;

   211

		}

   212

	}

   213

   214

	Point pt = { x, y };

   215

   216

	if (double_click) {

   217

		w->OnDoubleClick(pt, widget);

   218

	} else {

   219

		w->OnClick(pt, widget);

   220

	}

   221

}

   222

   223

/**

   224

 * Dispatch right mouse-button click in window.

   225

 * @param w Window to dispatch event in

   226

 * @param x X coordinate of the click

   227

 * @param y Y coordinate of the click

   228

 */

   229

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

   230

{

   231

	int widget = 0;

   232

   233

	/* default tooltips handler? */

   234

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   235

		widget = GetWidgetFromPos(w, x, y);

   236

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

   237

   238

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

   239

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

   240

			return;

   241

		}

   242

	}

   243

   244

	Point pt = { x, y };

   245

	w->OnRightClick(pt, widget);

   246

}

   247

   248

/**

   249

 * Dispatch the mousewheel-action to the window.

   250

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

   251

 * @param w Window

   252

 * @param widget the widget where the scrollwheel was used

   253

 * @param wheel scroll up or down

   254

 */

   255

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

   256

{

   257

	if (widget < 0) return;

   258

   259

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

   260

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

   261

   262

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

   263

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

   264

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

   265

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

   266

	Scrollbar *sb;

   267

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

   268

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

   269

   270

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

   271

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

   272

			if (pos != sb->pos) {

   273

				sb->pos = pos;

   274

				w->SetDirty();

   275

			}

   276

		}

   277

	}

   278

}

   279

   280

/**

   281

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

   282

 *

   283

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

   284

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

   285

 *

   286

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

   287

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

   288

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

   289

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

   290

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

   291

 */

   292

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

   293

{

   294

	Window* const *vz = wz;

   295

   296

	while (++vz != _last_z_window) {

   297

		const Window *v = *vz;

   298

   299

		if (right > v->left &&

   300

				bottom > v->top &&

   301

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

   302

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

   303

			/* v and rectangle intersect with eeach other */

   304

			int x;

   305

   306

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

   307

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

   308

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

   309

				return;

   310

			}

   311

   312

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

   313

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

   314

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

   315

				return;

   316

			}

   317

   318

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

   319

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

   320

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

   321

				return;

   322

			}

   323

   324

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

   325

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

   326

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

   327

				return;

   328

			}

   329

   330

			return;

   331

		}

   332

	}

   333

   334

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

   335

	DrawPixelInfo *dp = _cur_dpi;

   336

	dp->width = right - left;

   337

	dp->height = bottom - top;

   338

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

   339

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

   340

	dp->pitch = _screen.pitch;

   341

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

   342

	dp->zoom = ZOOM_LVL_NORMAL;

   343

	(*wz)->OnPaint();

   344

}

   345

   346

/**

   347

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

   348

 * These windows should be re-painted.

   349

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

   350

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

   351

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

   352

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

   353

 */

   354

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

   355

{

   356

	Window* const *wz;

   357

	DrawPixelInfo bk;

   358

	_cur_dpi = &bk;

   359

   360

	FOR_ALL_WINDOWS(wz) {

   361

		const Window *w = *wz;

   362

		if (right > w->left &&

   363

				bottom > w->top &&

   364

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

   365

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

   366

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

   367

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

   368

		}

   369

	}

   370

}

   371

   372

/**

   373

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

   374

 * @ingroup dirty

   375

 */

   376

void Window::SetDirty() const

   377

{

   378

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

   379

}

   380

   381

/**

   382

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

   383

 * @param w Window to redraw

   384

 * @ingroup dirty

   385

 */

   386

void SetWindowDirty(const Window *w)

   387

{

   388

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

   389

}

   390

   391

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

   392

 * @param w parent Window to find child of

   393

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

   394

static Window *FindChildWindow(const Window *w)

   395

{

   396

	Window* const *wz;

   397

   398

	FOR_ALL_WINDOWS(wz) {

   399

		Window *v = *wz;

   400

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

   401

	}

   402

   403

	return NULL;

   404

}

   405

   406

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

   407

 * or the behaviour is undefined but function should never fail

   408

 * @param w window to query Z Position

   409

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

   410

 */

   411

Window **FindWindowZPosition(const Window *w)

   412

{

   413

	Window **wz;

   414

   415

	FOR_ALL_WINDOWS(wz) {

   416

		if (*wz == w) return wz;

   417

	}

   418

   419

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

   420

		w->window_class, w->window_number);

   421

	return NULL;

   422

}

   423

   424

/**

   425

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

   426

 */

   427

void Window::DeleteChildWindows() const

   428

{

   429

	Window *child = FindChildWindow(this);

   430

	while (child != NULL) {

   431

		delete child;

   432

		child = FindChildWindow(this);

   433

	}

   434

}

   435

   436

/**

   437

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

   438

 */

   439

Window::~Window()

   440

{

   441

	if (_thd.place_mode != VHM_NONE &&

   442

			_thd.window_class == this->window_class &&

   443

			_thd.window_number == this->window_number) {

   444

		ResetObjectToPlace();

   445

	}

   446

   447

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

   448

	if (_mouseover_last_w == this) _mouseover_last_w = NULL;

   449

   450

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

   451

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

   452

	 * done before removing the child so we cannot cause recursion

   453

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

   454

	Window **wz = FindWindowZPosition(this);

   455

	if (wz == NULL) return;

   456

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

   457

	_last_z_window--;

   458

   459

	this->DeleteChildWindows();

   460

   461

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

   462

   463

	this->SetDirty();

   464

	free(this->widget);

   465

}

   466

   467

/**

   468

 * Find a window by its class and window number

   469

 * @param cls Window class

   470

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

   471

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

   472

 */

   473

Window *FindWindowById(WindowClass cls, WindowNumber number)

   474

{

   475

	Window* const *wz;

   476

   477

	FOR_ALL_WINDOWS(wz) {

   478

		Window *w = *wz;

   479

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

   480

	}

   481

   482

	return NULL;

   483

}

   484

   485

/**

   486

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

   487

 * @param cls Window class

   488

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