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

    71

bool Window::OnKeyPress(uint16 key, uint16 keycode)

    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

    80

	return e.we.keypress.cont;

    81

}

    82

    83

bool Window::OnCTRLStateChange()

    84

{

    85

	WindowEvent e;

    86

	e.event = WE_CTRL_CHANGED;

    87

	e.we.ctrl.cont = true;

    88

	this->HandleWindowEvent(&e);

    89

    90

	return e.we.ctrl.cont;

    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::OnDoubleClick(Point pt, int widget)

   103

{

   104

	WindowEvent e;

   105

	e.event = WE_DOUBLE_CLICK;

   106

	e.we.click.pt     = pt;

   107

	e.we.click.widget = widget;

   108

	this->HandleWindowEvent(&e);

   109

}

   110

   111

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

   112

{

   113

	WindowEvent e;

   114

	e.event = WE_RCLICK;

   115

	e.we.click.pt     = pt;

   116

	e.we.click.widget = widget;

   117

	this->HandleWindowEvent(&e);

   118

}

   119

   120

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

   121

{

   122

	WindowEvent e;

   123

	e.event = WE_DRAGDROP;

   124

	e.we.click.pt     = pt;

   125

	e.we.click.widget = widget;

   126

	this->HandleWindowEvent(&e);

   127

}

   128

   129

void Window::OnScroll(Point delta)

   130

{

   131

	WindowEvent e;

   132

	e.event = WE_SCROLL;

   133

	e.we.scroll.delta = delta;

   134

	this->HandleWindowEvent(&e);

   135

}

   136

   137

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

   138

{

   139

	WindowEvent e;

   140

	e.event = WE_MOUSEOVER;

   141

	e.we.click.pt     = pt;

   142

	e.we.click.widget = widget;

   143

	this->HandleWindowEvent(&e);

   144

}

   145

   146

void Window::OnMouseWheel(int wheel)

   147

{

   148

	WindowEvent e;

   149

	e.event = WE_MOUSEWHEEL;

   150

	e.we.wheel.wheel = wheel;

   151

	this->HandleWindowEvent(&e);

   152

}

   153

   154

void Window::OnMouseLoop()

   155

{

   156

	WindowEvent e;

   157

	e.event = WE_MOUSELOOP;

   158

	this->HandleWindowEvent(&e);

   159

}

   160

   161

void Window::OnTick()

   162

{

   163

	WindowEvent e;

   164

	e.event = WE_TICK;

   165

	this->HandleWindowEvent(&e);

   166

}

   167

   168

void Window::OnHundredthTick()

   169

{

   170

	WindowEvent e;

   171

	e.event = WE_100_TICKS;

   172

	this->HandleWindowEvent(&e);

   173

}

   174

   175

void Window::OnTimeout()

   176

{

   177

	WindowEvent e;

   178

	e.event = WE_TIMEOUT;

   179

	this->HandleWindowEvent(&e);

   180

}

   181

   182

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

   183

{

   184

	WindowEvent e;

   185

	e.event = WE_RESIZE;

   186

	e.we.sizing.size = new_size;

   187

	e.we.sizing.diff = delta;

   188

	this->HandleWindowEvent(&e);

   189

}

   190

   191

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

   192

{

   193

	WindowEvent e;

   194

	e.event = WE_DROPDOWN_SELECT;

   195

	e.we.dropdown.button = widget;

   196

	e.we.dropdown.index  = index;

   197

	this->HandleWindowEvent(&e);

   198

}

   199

   200

void Window::OnQueryTextFinished(char *str)

   201

{

   202

	WindowEvent e;

   203

	e.event = WE_ON_EDIT_TEXT;

   204

	e.we.edittext.str = str;

   205

	this->HandleWindowEvent(&e);

   206

}

   207

   208

void Window::OnInvalidateData(int data)

   209

{

   210

	WindowEvent e;

   211

	e.event = WE_INVALIDATE_DATA;

   212

	e.we.invalidate.data = data;

   213

	this->HandleWindowEvent(&e);

   214

}

   215

   216

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

   217

{

   218

	WindowEvent e;

   219

	e.event = WE_PLACE_OBJ;

   220

	e.we.place.pt   = pt;

   221

	e.we.place.tile = tile;

   222

	this->HandleWindowEvent(&e);

   223

}

   224

   225

void Window::OnPlaceObjectAbort()

   226

{

   227

	WindowEvent e;

   228

	e.event = WE_ABORT_PLACE_OBJ;

   229

	this->HandleWindowEvent(&e);

   230

}

   231

   232

   233

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

   234

{

   235

	WindowEvent e;

   236

	e.event = WE_PLACE_DRAG;

   237

	e.we.place.select_method = select_method;

   238

	e.we.place.select_proc   = select_proc;

   239

	e.we.place.pt            = pt;

   240

	this->HandleWindowEvent(&e);

   241

}

   242

   243

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

   244

{

   245

	WindowEvent e;

   246

	e.event = WE_PLACE_MOUSEUP;

   247

	e.we.place.select_method = select_method;

   248

	e.we.place.select_proc   = select_proc;

   249

	e.we.place.pt            = pt;

   250

	e.we.place.tile          = end_tile;

   251

	e.we.place.starttile     = start_tile;

   252

	this->HandleWindowEvent(&e);

   253

}

   254

   255

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

   256

{

   257

	WindowEvent e;

   258

	e.event = WE_PLACE_PRESIZE;

   259

	e.we.place.pt   = pt;

   260

	e.we.place.tile = tile;

   261

	this->HandleWindowEvent(&e);

   262

}

   263

   264

   265

   266

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

   267

{

   268

	va_list wdg_list;

   269

   270

	va_start(wdg_list, widgets);

   271

   272

	while (widgets != WIDGET_LIST_END) {

   273

		SetWidgetDisabledState(widgets, disab_stat);

   274

		widgets = va_arg(wdg_list, int);

   275

	}

   276

   277

	va_end(wdg_list);

   278

}

   279

   280

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

   281

{

   282

	va_list wdg_list;

   283

   284

	va_start(wdg_list, widgets);

   285

   286

	while (widgets != WIDGET_LIST_END) {

   287

		SetWidgetHiddenState(widgets, hidden_stat);

   288

		widgets = va_arg(wdg_list, int);

   289

	}

   290

   291

	va_end(wdg_list);

   292

}

   293

   294

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

   295

{

   296

	va_list wdg_list;

   297

   298

	va_start(wdg_list, widgets);

   299

   300

	while (widgets != WIDGET_LIST_END) {

   301

		SetWidgetLoweredState(widgets, lowered_stat);

   302

		widgets = va_arg(wdg_list, int);

   303

	}

   304

   305

	va_end(wdg_list);

   306

}

   307

   308

void Window::RaiseButtons()

   309

{

   310

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

   311

		if (this->IsWidgetLowered(i)) {

   312

			this->RaiseWidget(i);

   313

			this->InvalidateWidget(i);

   314

		}

   315

	}

   316

}

   317

   318

void Window::InvalidateWidget(byte widget_index) const

   319

{

   320

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

   321

   322

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

   323

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

   324

   325

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

   326

}

   327

   328

void Window::HandleButtonClick(byte widget)

   329

{

   330

	this->LowerWidget(widget);

   331

	this->flags4 |= 5 << WF_TIMEOUT_SHL;

   332

	this->InvalidateWidget(widget);

   333

}

   334

   335

static void StartWindowDrag(Window *w);

   336

static void StartWindowSizing(Window *w);

   337

   338

/**

   339

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

   340

 * @param w Window to dispatch event in

   341

 * @param x X coordinate of the click

   342

 * @param y Y coordinate of the click

   343

 * @param double_click Was it a double click?

   344

 */

   345

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

   346

{

   347

	int widget = 0;

   348

	if (w->desc_flags & WDF_DEF_WIDGET) {

   349

		widget = GetWidgetFromPos(w, x, y);

   350

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

   351

   352

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

   353

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

   354

   355

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

   356

   357

		if (wi->type & WWB_MASK) {

   358

			/* special widget handling for buttons*/

   359

			switch (wi->type) {

   360

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   361

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   362

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   363

					w->HandleButtonClick(widget);

   364

					break;

   365

			}

   366

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

   367

			ScrollbarClickHandler(w, wi, x, y);

   368

		}

   369

   370

		if (w->desc_flags & WDF_STD_BTN) {

   371

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

   372

				delete w;

   373

				return;

   374

			}

   375

   376

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

   377

				StartWindowDrag(w);

   378

				return;

   379

			}

   380

		}

   381

   382

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

   383

			StartWindowSizing(w);

   384

			w->InvalidateWidget(widget);

   385

			return;

   386

		}

   387

   388

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

   389

			w->flags4 ^= WF_STICKY;

   390

			w->InvalidateWidget(widget);

   391

			return;

   392

		}

   393

	}

   394

   395

	Point pt = { x, y };

   396

   397

	if (double_click) {

   398

		w->OnDoubleClick(pt, widget);

   399

	} else {

   400

		w->OnClick(pt, widget);

   401

	}

   402

}

   403

   404

/**

   405

 * Dispatch right mouse-button click in window.

   406

 * @param w Window to dispatch event in

   407

 * @param x X coordinate of the click

   408

 * @param y Y coordinate of the click

   409

 */

   410

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

   411

{

   412

	int widget = 0;

   413

   414

	/* default tooltips handler? */

   415

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   416

		widget = GetWidgetFromPos(w, x, y);

   417

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

   418

   419

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

   420

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

   421

			return;

   422

		}

   423

	}

   424

   425

	Point pt = { x, y };

   426

	w->OnRightClick(pt, widget);

   427

}

   428

   429

/**

   430

 * Dispatch the mousewheel-action to the window.

   431

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

   432

 * @param w Window

   433

 * @param widget the widget where the scrollwheel was used

   434

 * @param wheel scroll up or down

   435

 */

   436

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

   437

{

   438

	if (widget < 0) return;

   439

   440

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

   441

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

   442

   443

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

   444

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

   445

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

   446

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

   447

	Scrollbar *sb;

   448

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

   449

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

   450

   451

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

   452

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

   453

			if (pos != sb->pos) {

   454

				sb->pos = pos;

   455

				w->SetDirty();

   456

			}

   457

		}

   458

	}

   459

}

   460

   461

/**

   462

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

   463

 *

   464

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

   465

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

   466

 *

   467

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

   468

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

   469

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

   470

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

   471

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

   472

 */

   473

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

   474

{

   475

	Window* const *vz = wz;

   476

   477

	while (++vz != _last_z_window) {

   478

		const Window *v = *vz;

   479

   480

		if (right > v->left &&

   481

				bottom > v->top &&

   482

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

   483

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

   484

			/* v and rectangle intersect with eeach other */

   485

			int x;

   486

   487

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

   488

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

   489

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

   490

				return;