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

/**

    52

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

    53

 * This is a temporary helper functions that will be removed

    54

 * once all windows that still rely on WindowEvent and

    55

 * WindowEventCodes have been rewritten to use the 'OnXXX'

    56

 * event handlers.

    57

 * @param e Window event to handle

    58

 */

    59

void Window::HandleWindowEvent(WindowEvent *e)

    60

{

    61

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

    62

}

    63

    64

void Window::OnPaint()

    65

{

    66

	WindowEvent e;

    67

	e.event = WE_PAINT;

    68

	this->HandleWindowEvent(&e);

    69

}

    70

    72

{

    73

	WindowEvent e;

    74

	e.event = WE_KEYPRESS;

    75

	e.we.keypress.key     = key;

    76

	e.we.keypress.keycode = keycode;

    77

	e.we.keypress.cont    = true;

    78

	this->HandleWindowEvent(&e);

    79

    81

}

    82

    84

{

    85

	WindowEvent e;

    86

	e.event = WE_CTRL_CHANGED;

    87

	e.we.ctrl.cont = true;

    88

	this->HandleWindowEvent(&e);

    89

    91

}

    92

    93

void Window::OnClick(Point pt, int widget)

    94

{

    95

	WindowEvent e;

    96

	e.event = WE_CLICK;

    97

	e.we.click.pt     = pt;

    98

	e.we.click.widget = widget;

    99

	this->HandleWindowEvent(&e);

   100

}

   101

   102

void Window::OnMouseLoop()

   103

{

   104

	WindowEvent e;

   105

	e.event = WE_MOUSELOOP;

   106

	this->HandleWindowEvent(&e);

   107

}

   108

   109

void Window::OnTick()

   110

{

   111

	WindowEvent e;

   112

	e.event = WE_TICK;

   113

	this->HandleWindowEvent(&e);

   114

}

   115

   116

void Window::OnHundredthTick()

   117

{

   118

	WindowEvent e;

   119

	e.event = WE_100_TICKS;

   120

	this->HandleWindowEvent(&e);

   121

}

   122

   123

void Window::OnTimeout()

   124

{

   125

	WindowEvent e;

   126

	e.event = WE_TIMEOUT;

   127

	this->HandleWindowEvent(&e);

   128

}

   129

   130

void Window::OnResize(Point new_size, Point delta)

   131

{

   132

	WindowEvent e;

   133

	e.event = WE_RESIZE;

   134

	e.we.sizing.size = new_size;

   135

	e.we.sizing.diff = delta;

   136

	this->HandleWindowEvent(&e);

   137

}

   138

   139

void Window::OnDropdownSelect(int widget, int index)

   140

{

   141

	WindowEvent e;

   142

	e.event = WE_DROPDOWN_SELECT;

   143

	e.we.dropdown.button = widget;

   144

	e.we.dropdown.index  = index;

   145

	this->HandleWindowEvent(&e);

   146

}

   147

   148

void Window::OnQueryTextFinished(char *str)

   149

{

   150

	WindowEvent e;

   151

	e.event = WE_ON_EDIT_TEXT;

   152

	e.we.edittext.str = str;

   153

	this->HandleWindowEvent(&e);

   154

}

   155

   156

void Window::OnInvalidateData(int data)

   157

{

   158

	WindowEvent e;

   159

	e.event = WE_INVALIDATE_DATA;

   160

	e.we.invalidate.data = data;

   161

	this->HandleWindowEvent(&e);

   162

}

   163

   164

void Window::OnPlaceObject(Point pt, TileIndex tile)

   165

{

   166

	WindowEvent e;

   167

	e.event = WE_PLACE_OBJ;

   168

	e.we.place.pt   = pt;

   169

	e.we.place.tile = tile;

   170

	this->HandleWindowEvent(&e);

   171

}

   172

   173

void Window::OnPlaceObjectAbort()

   174

{

   175

	WindowEvent e;

   176

	e.event = WE_ABORT_PLACE_OBJ;

   177

	this->HandleWindowEvent(&e);

   178

}

   179

   180

   181

void Window::OnPlaceDrag(ViewportPlaceMethod select_method, byte select_proc, Point pt)

   182

{

   183

	WindowEvent e;

   184

	e.event = WE_PLACE_DRAG;

   185

	e.we.place.select_method = select_method;

   186

	e.we.place.select_proc   = select_proc;

   187

	e.we.place.pt            = pt;

   188

	this->HandleWindowEvent(&e);

   189

}

   190

   191

void Window::OnPlaceMouseUp(ViewportPlaceMethod select_method, byte select_proc, Point pt, TileIndex start_tile, TileIndex end_tile)

   192

{

   193

	WindowEvent e;

   194

	e.event = WE_PLACE_MOUSEUP;

   195

	e.we.place.select_method = select_method;

   196

	e.we.place.select_proc   = select_proc;

   197

	e.we.place.pt            = pt;

   198

	e.we.place.tile          = end_tile;

   199

	e.we.place.starttile     = start_tile;

   200

	this->HandleWindowEvent(&e);

   201

}

   202

   203

void Window::OnPlacePresize(Point pt, TileIndex tile)

   204

{

   205

	WindowEvent e;

   206

	e.event = WE_PLACE_PRESIZE;

   207

	e.we.place.pt   = pt;

   208

	e.we.place.tile = tile;

   209

	this->HandleWindowEvent(&e);

   210

}

   211

   212

   213

   214

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

   215

{

   216

	va_list wdg_list;

   217

   218

	va_start(wdg_list, widgets);

   219

   220

	while (widgets != WIDGET_LIST_END) {

   221

		SetWidgetDisabledState(widgets, disab_stat);

   222

		widgets = va_arg(wdg_list, int);

   223

	}

   224

   225

	va_end(wdg_list);

   226

}

   227

   228

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

   229

{

   230

	va_list wdg_list;

   231

   232

	va_start(wdg_list, widgets);

   233

   234

	while (widgets != WIDGET_LIST_END) {

   235

		SetWidgetHiddenState(widgets, hidden_stat);

   236

		widgets = va_arg(wdg_list, int);

   237

	}

   238

   239

	va_end(wdg_list);

   240

}

   241

   242

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

   243

{

   244

	va_list wdg_list;

   245

   246

	va_start(wdg_list, widgets);

   247

   248

	while (widgets != WIDGET_LIST_END) {

   249

		SetWidgetLoweredState(widgets, lowered_stat);

   250

		widgets = va_arg(wdg_list, int);

   251

	}

   252

   253

	va_end(wdg_list);

   254

}

   255

   256

void Window::RaiseButtons()

   257

{

   258

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

   259

		if (this->IsWidgetLowered(i)) {

   260

			this->RaiseWidget(i);

   261

			this->InvalidateWidget(i);

   262

		}

   263

	}

   264

}

   265

   266

void Window::InvalidateWidget(byte widget_index) const

   267

{

   268

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

   269

   270

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

   271

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

   272

   273

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

   274

}

   275

   276

void Window::HandleButtonClick(byte widget)

   277

{

   278

	this->LowerWidget(widget);

   279

	this->flags4 |= 5 << WF_TIMEOUT_SHL;

   280

	this->InvalidateWidget(widget);

   281

}

   282

   283

static void StartWindowDrag(Window *w);

   284

static void StartWindowSizing(Window *w);

   285

   286

/**

   287

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

   288

 * @param w Window to dispatch event in

   289

 * @param x X coordinate of the click

   290

 * @param y Y coordinate of the click

   291

 * @param double_click Was it a double click?

   292

 */

   293

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

   294

{

   295

	int widget = 0;

   296

	if (w->desc_flags & WDF_DEF_WIDGET) {

   297

		widget = GetWidgetFromPos(w, x, y);

   298

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

   299

   300

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

   301

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

   302

   303

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

   304

   305

		if (wi->type & WWB_MASK) {

   306

			/* special widget handling for buttons*/

   307

			switch (wi->type) {

   308

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   309

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   310

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   311

					w->HandleButtonClick(widget);

   312

					break;

   313

			}

   314

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

   315

			ScrollbarClickHandler(w, wi, x, y);

   316

		}

   317

   318

		if (w->desc_flags & WDF_STD_BTN) {

   319

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

   320

				delete w;

   321

				return;

   322

			}

   323

   324

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

   325

				StartWindowDrag(w);

   326

				return;

   327

			}

   328

		}

   329

   330

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

   331

			StartWindowSizing(w);

   332

			w->InvalidateWidget(widget);

   333

			return;

   334

		}

   335

   336

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

   337

			w->flags4 ^= WF_STICKY;

   338

			w->InvalidateWidget(widget);

   339

			return;

   340

		}

   341

	}

   342

   343

	Point pt = { x, y };

   344

   345

	if (double_click) {

   346

		w->OnDoubleClick(pt, widget);

   347

	} else {

   348

		w->OnClick(pt, widget);

   349

	}

   350

}

   351

   352

/**

   353

 * Dispatch right mouse-button click in window.

   354

 * @param w Window to dispatch event in

   355

 * @param x X coordinate of the click

   356

 * @param y Y coordinate of the click

   357

 */

   358

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

   359

{

   360

	int widget = 0;

   361

   362

	/* default tooltips handler? */

   363

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   364

		widget = GetWidgetFromPos(w, x, y);

   365

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

   366

   367

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

   368

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

   369

			return;

   370

		}

   371

	}

   372

   373

	Point pt = { x, y };

   374

	w->OnRightClick(pt, widget);

   375

}

   376

   377

/**

   378

 * Dispatch the mousewheel-action to the window.

   379

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

   380

 * @param w Window

   381

 * @param widget the widget where the scrollwheel was used

   382

 * @param wheel scroll up or down

   383

 */

   384

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

   385

{

   386

	if (widget < 0) return;

   387

   388

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

   389

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

   390

   391

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

   392

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

   393

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

   394

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

   395

	Scrollbar *sb;

   396

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

   397

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

   398

   399

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

   400

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

   401

			if (pos != sb->pos) {

   402

				sb->pos = pos;

   403

				w->SetDirty();

   404

			}

   405

		}

   406

	}

   407

}

   408

   409

/**

   410

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

   411

 *

   412

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

   413

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

   414

 *

   415

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

   416

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

   417

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

   418

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

   419

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

   420

 */

   421

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

   422

{

   423

	Window* const *vz = wz;

   424

   425

	while (++vz != _last_z_window) {

   426

		const Window *v = *vz;

   427

   428

		if (right > v->left &&

   429

				bottom > v->top &&

   430

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

   431

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

   432

			/* v and rectangle intersect with eeach other */

   433

			int x;

   434

   435

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

   436

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

   437

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

   438

				return;

   439

			}

   440

   441

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

   442

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

   443

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

   444

				return;

   445

			}

   446

   447

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

   448

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

   449

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

   450

				return;

   451

			}

   452

   453

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

   454

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

   455

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

   456

				return;

   457

			}

   458

   459

			return;

   460

		}

   461

	}

   462

   463

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

   464

	DrawPixelInfo *dp = _cur_dpi;

   465

	dp->width = right - left;

   466

	dp->height = bottom - top;

   467

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

   468

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

   469

	dp->pitch = _screen.pitch;

   470

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

   471

	dp->zoom = ZOOM_LVL_NORMAL;

   472

	(*wz)->OnPaint();

   473

}

   474

   475

/**

   476

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

   477

 * These windows should be re-painted.

   478

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

   479

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

   480

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

   481

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

   482

 */

   483

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

   484

{

   485

	Window* const *wz;

   486

	DrawPixelInfo bk;

   487

	_cur_dpi = &bk;

   488

   489

	FOR_ALL_WINDOWS(wz) {

   490

		const Window *w = *wz;