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

    24

#include "table/sprites.h"

    25

    26

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

    27

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

    28

    29

/**

    30

 * List of windows opened at the screen.

    31

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

    32

 * bottom window is at _z_windows[0]

    33

 */

    34

Window *_z_windows[MAX_NUMBER_OF_WINDOWS];

    35

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

    36

    37

Point _cursorpos_drag_start;

    38

    39

int _scrollbar_start_pos;

    40

int _scrollbar_size;

    41

byte _scroller_click_timeout;

    42

    43

bool _scrolling_scrollbar;

    44

bool _scrolling_viewport;

    45

bool _popup_menu_active;

    46

    47

byte _special_mouse_mode;

    48

    49

    50

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

    51

{

    52

	va_list wdg_list;

    53

    54

	va_start(wdg_list, widgets);

    55

    56

	while (widgets != WIDGET_LIST_END) {

    57

		SetWidgetDisabledState(widgets, disab_stat);

    58

		widgets = va_arg(wdg_list, int);

    59

	}

    60

    61

	va_end(wdg_list);

    62

}

    63

    64

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

    65

{

    66

	va_list wdg_list;

    67

    68

	va_start(wdg_list, widgets);

    69

    70

	while (widgets != WIDGET_LIST_END) {

    71

		SetWidgetHiddenState(widgets, hidden_stat);

    72

		widgets = va_arg(wdg_list, int);

    73

	}

    74

    75

	va_end(wdg_list);

    76

}

    77

    78

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

    79

{

    80

	va_list wdg_list;

    81

    82

	va_start(wdg_list, widgets);

    83

    84

	while (widgets != WIDGET_LIST_END) {

    85

		SetWidgetLoweredState(widgets, lowered_stat);

    86

		widgets = va_arg(wdg_list, int);

    87

	}

    88

    89

	va_end(wdg_list);

    90

}

    91

    92

void Window::RaiseButtons()

    93

{

    94

	uint i;

    95

    96

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

    97

		if (this->IsWidgetLowered(i)) {

    98

			this->RaiseWidget(i);

    99

			this->InvalidateWidget(i);

   100

		}

   101

	}

   102

}

   103

   104

void Window::InvalidateWidget(byte widget_index) const

   105

{

   106

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

   107

   108

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

   109

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

   110

   111

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

   112

}

   113

   114

void Window::HandleButtonClick(byte widget)

   115

{

   116

	this->LowerWidget(widget);

   117

	this->flags4 |= 5 << WF_TIMEOUT_SHL;

   118

	this->InvalidateWidget(widget);

   119

}

   120

   121

static void StartWindowDrag(Window *w);

   122

static void StartWindowSizing(Window *w);

   123

   124

/**

   125

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

   126

 * @param w Window to dispatch event in

   127

 * @param x X coordinate of the click

   128

 * @param y Y coordinate of the click

   129

 * @param double_click Was it a double click?

   130

 */

   131

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

   132

{

   133

	WindowEvent e;

   134

	const Widget *wi;

   135

   136

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

   137

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

   138

	e.event = double_click ? WE_DOUBLE_CLICK : WE_CLICK;

   139

   140

	if (w->desc_flags & WDF_DEF_WIDGET) {

   141

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

   142

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

   143

   144

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

   145

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

   146

   147

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

   148

   149

		if (wi->type & WWB_MASK) {

   150

			/* special widget handling for buttons*/

   151

			switch (wi->type) {

   152

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   153

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   154

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   155

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

   156

					break;

   157

			}

   158

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

   159

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

   160

		}

   161

   162

		if (w->desc_flags & WDF_STD_BTN) {

   163

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

   164

				DeleteWindow(w);

   165

				return;

   166

			}

   167

   168

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

   169

				StartWindowDrag(w);

   170

				return;

   171

			}

   172

		}

   173

   174

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

   175

			StartWindowSizing(w);

   176

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

   177

			return;

   178

		}

   179

   180

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

   181

			w->flags4 ^= WF_STICKY;

   182

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

   183

			return;

   184

		}

   185

	}

   186

   187

	w->wndproc(w, &e);

   188

}

   189

   190

/**

   191

 * Dispatch right mouse-button click in window.

   192

 * @param w Window to dispatch event in

   193

 * @param x X coordinate of the click

   194

 * @param y Y coordinate of the click

   195

 */

   196

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

   197

{

   198

	WindowEvent e;

   199

   200

	/* default tooltips handler? */

   201

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   202

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

   203

		if (e.we.click.widget < 0)

   204

			return; // exit if clicked outside of widgets

   205

   206

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

   207

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

   208

			return;

   209

		}

   210

	}

   211

   212

	e.event = WE_RCLICK;

   213

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

   214

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

   215

	w->wndproc(w, &e);

   216

}

   217

   218

/**

   219

 * Dispatch the mousewheel-action to the window.

   220

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

   221

 * @param w Window

   222

 * @param widget the widget where the scrollwheel was used

   223

 * @param wheel scroll up or down

   224

 */

   225

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

   226

{

   227

	const Widget *wi1, *wi2;

   228

	Scrollbar *sb;

   229

   230

	if (widget < 0) return;

   231

   232

	wi1 = &w->widget[widget];

   233

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

   234

   235

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

   236

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

   237

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

   238

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

   239

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

   240

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

   241

   242

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

   243

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

   244

			if (pos != sb->pos) {

   245

				sb->pos = pos;

   246

				SetWindowDirty(w);

   247

			}

   248

		}

   249

	}

   250

}

   251

   252

/**

   253

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

   254

 *

   255

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

   256

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

   257

 *

   258

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

   259

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

   260

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

   261

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

   262

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

   263

 */

   264

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

   265

{

   266

	Window* const *vz = wz;

   267

   268

	while (++vz != _last_z_window) {

   269

		const Window *v = *vz;

   270

   271

		if (right > v->left &&

   272

				bottom > v->top &&

   273

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

   274

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

   275

			/* v and rectangle intersect with eeach other */

   276

			int x;

   277

   278

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

   279

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

   280

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

   281

				return;

   282

			}

   283

   284

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

   285

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

   286

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

   287

				return;

   288

			}

   289

   290

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

   291

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

   292

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

   293

				return;

   294

			}

   295

   296

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

   297

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

   298

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

   299

				return;

   300

			}

   301

   302

			return;

   303

		}

   304

	}

   305

   306

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

   307

	DrawPixelInfo *dp = _cur_dpi;

   308

	dp->width = right - left;

   309

	dp->height = bottom - top;

   310

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

   311

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

   312

	dp->pitch = _screen.pitch;

   313

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

   314

	dp->zoom = ZOOM_LVL_NORMAL;

   315

	CallWindowEventNP(*wz, WE_PAINT);

   316

}

   317

   318

/**

   319

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

   320

 * These windows should be re-painted.

   321

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

   322

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

   323

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

   324

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

   325

 */

   326

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

   327

{

   328

	Window* const *wz;

   329

	DrawPixelInfo bk;

   330

	_cur_dpi = &bk;

   331

   332

	FOR_ALL_WINDOWS(wz) {

   333

		const Window *w = *wz;

   334

		if (right > w->left &&

   335

				bottom > w->top &&

   336

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

   337

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

   338

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

   339

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

   340

		}

   341

	}

   342

}

   343

   344

/**

   345

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

   346

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

   347

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

   348

 * @param event Event to dispatch

   349

 */

   350

void CallWindowEventNP(Window *w, int event)

   351

{

   352

	WindowEvent e;

   353

   354

	e.event = event;

   355

	w->wndproc(w, &e);

   356

}

   357

   358

/**

   359

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

   360

 * @param w Window to redraw

   361

 * @ingroup dirty

   362

 */

   363

void SetWindowDirty(const Window *w)

   364

{

   365

	if (w == NULL) return;

   366

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

   367

}

   368

   369

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

   370

 * @param w parent Window to find child of

   371

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

   372

static Window *FindChildWindow(const Window *w)

   373

{

   374

	Window* const *wz;

   375

   376

	FOR_ALL_WINDOWS(wz) {

   377

		Window *v = *wz;

   378

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

   379

	}

   380

   381

	return NULL;

   382

}

   383

   384

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

   385

 * or the behaviour is undefined but function should never fail

   386

 * @param w window to query Z Position

   387

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

   388

 */

   389

Window **FindWindowZPosition(const Window *w)

   390

{

   391

	Window **wz;

   392

   393

	FOR_ALL_WINDOWS(wz) {

   394

		if (*wz == w) return wz;

   395

	}

   396

   397

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

   398

		w->window_class, w->window_number);

   399

	return NULL;

   400

}

   401

   402

/**

   403

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

   404

 * @param w Window to delete

   405

 */

   406

void DeleteWindow(Window *w)

   407

{

   408

	if (w == NULL) return;

   409

   410

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

   411

	Window *v = FindChildWindow(w);

   412

	if (v != NULL) DeleteWindow(v);

   413

   414

	if (_thd.place_mode != VHM_NONE &&

   415

			_thd.window_class == w->window_class &&

   416

			_thd.window_number == w->window_number) {

   417

		ResetObjectToPlace();

   418

	}

   419

   420

	CallWindowEventNP(w, WE_DESTROY);

   421

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

   422

   423

	SetWindowDirty(w);

   424

	free(w->widget);

   425

	w->widget = NULL;

   426

	w->widget_count = 0;

   427

	w->parent = NULL;

   428

   429

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

   430

	if (_mouseover_last_w == w) _mouseover_last_w = NULL;

   431

   432

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

   433

	 * by moving all windows after it one to the left */

   434

	Window **wz = FindWindowZPosition(w);

   435

	if (wz == NULL) return;

   436

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

   437

	_last_z_window--;

   438

   439

	delete w;

   440

}

   441

   442

/**

   443

 * Find a window by its class and window number

   444

 * @param cls Window class

   445

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

   446

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

   447

 */

   448

Window *FindWindowById(WindowClass cls, WindowNumber number)

   449

{

   450

	Window* const *wz;

   451

   452

	FOR_ALL_WINDOWS(wz) {

   453

		Window *w = *wz;

   454

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

   455

	}

   456

   457

	return NULL;

   458

}

   459

   460

/**

   461

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

   462

 * @param cls Window class

   463

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

   464

 */

   465

void DeleteWindowById(WindowClass cls, WindowNumber number)

   466

{

   467

	DeleteWindow(FindWindowById(cls, number));

   468

}

   469

   470

/**

   471

 * Delete all windows of a given class

   472

 * @param cls Window class of windows to delete

   473

 */

   474

void DeleteWindowByClass(WindowClass cls)

   475

{

   476

	Window* const *wz;

   477

   478

restart_search:

   479

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

   480

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

   481

	 * anywhere in the z-array */

   482

	FOR_ALL_WINDOWS(wz) {

   483

		Window *w = *wz;

   484

		if (w->window_class == cls) {

   485

			DeleteWindow(w);

   486

			goto restart_search;

   487

		}

   488

	}

   489

}