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

    23

#include "table/sprites.h"

    24

    25

/* delta between mouse cursor and upper left corner of dragged window */

    26

static Point _drag_delta;

    27

    28

static Window _windows[MAX_NUMBER_OF_WINDOWS];

    29

Window *_z_windows[lengthof(_windows)];

    30

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

    31

    32

Point _cursorpos_drag_start;

    33

    34

int _scrollbar_start_pos;

    35

int _scrollbar_size;

    36

byte _scroller_click_timeout;

    37

    38

bool _scrolling_scrollbar;

    39

bool _scrolling_viewport;

    40

bool _popup_menu_active;

    41

    42

byte _special_mouse_mode;

    43

    44

    45

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

    46

{

    47

	va_list wdg_list;

    48

    49

	va_start(wdg_list, widgets);

    50

    51

	while (widgets != WIDGET_LIST_END) {

    52

		SetWidgetDisabledState(widgets, disab_stat);

    53

		widgets = va_arg(wdg_list, int);

    54

	}

    55

    56

	va_end(wdg_list);

    57

}

    58

    59

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

    60

{

    61

	va_list wdg_list;

    62

    63

	va_start(wdg_list, widgets);

    64

    65

	while (widgets != WIDGET_LIST_END) {

    66

		SetWidgetHiddenState(widgets, hidden_stat);

    67

		widgets = va_arg(wdg_list, int);

    68

	}

    69

    70

	va_end(wdg_list);

    71

}

    72

    73

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

    74

{

    75

	va_list wdg_list;

    76

    77

	va_start(wdg_list, widgets);

    78

    79

	while (widgets != WIDGET_LIST_END) {

    80

		SetWidgetLoweredState(widgets, lowered_stat);

    81

		widgets = va_arg(wdg_list, int);

    82

	}

    83

    84

	va_end(wdg_list);

    85

}

    86

    87

void Window::RaiseButtons()

    88

{

    89

	uint i;

    90

    91

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

    92

		if (this->IsWidgetLowered(i)) {

    93

			this->RaiseWidget(i);

    94

			this->InvalidateWidget(i);

    95

		}

    96

	}

    97

}

    98

    99

void Window::InvalidateWidget(byte widget_index) const

   100

{

   101

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

   102

   103

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

   104

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

   105

   106

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

   107

}

   108

   109

void Window::HandleButtonClick(byte widget)

   110

{

   111

	this->LowerWidget(widget);

   112

	this->flags4 |= 5 << WF_TIMEOUT_SHL;

   113

	this->InvalidateWidget(widget);

   114

}

   115

   116

static void StartWindowDrag(Window *w);

   117

static void StartWindowSizing(Window *w);

   118

   119

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

   120

{

   121

	WindowEvent e;

   122

	const Widget *wi;

   123

   124

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

   125

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

   126

	e.event = double_click ? WE_DOUBLE_CLICK : WE_CLICK;

   127

   128

	if (w->desc_flags & WDF_DEF_WIDGET) {

   129

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

   130

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

   131

   132

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

   133

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

   134

   135

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

   136

   137

		if (wi->type & WWB_MASK) {

   138

			/* special widget handling for buttons*/

   139

			switch (wi->type) {

   140

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   141

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   142

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   143

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

   144

					break;

   145

			}

   146

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

   147

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

   148

		}

   149

   150

		if (w->desc_flags & WDF_STD_BTN) {

   151

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

   152

				DeleteWindow(w);

   153

				return;

   154

			}

   155

   156

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

   157

				StartWindowDrag(w);

   158

				return;

   159

			}

   160

		}

   161

   162

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

   163

			StartWindowSizing(w);

   164

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

   165

			return;

   166

		}

   167

   168

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

   169

			w->flags4 ^= WF_STICKY;

   170

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

   171

			return;

   172

		}

   173

	}

   174

   175

	w->wndproc(w, &e);

   176

}

   177

   178

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

   179

{

   180

	WindowEvent e;

   181

   182

	/* default tooltips handler? */

   183

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   184

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

   185

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

   186

			return; // exit if clicked outside of widgets

   187

   188

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

   189

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

   190

			return;

   191

		}

   192

	}

   193

   194

	e.event = WE_RCLICK;

   195

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

   196

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

   197

	w->wndproc(w, &e);

   198

}

   199

   200

/** Dispatch the mousewheel-action to the window which will scroll any

   201

 * compatible scrollbars if the mouse is pointed over the bar or its contents

   202

 * @param *w Window

   203

 * @param widget the widget where the scrollwheel was used

   204

 * @param wheel scroll up or down

   205

 */

   206

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

   207

{

   208

	const Widget *wi1, *wi2;

   209

	Scrollbar *sb;

   210

   211

	if (widget < 0) return;

   212

   213

	wi1 = &w->widget[widget];

   214

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

   215

   216

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

   217

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

   218

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

   219

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

   220

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

   221

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

   222

   223

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

   224

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

   225

			if (pos != sb->pos) {

   226

				sb->pos = pos;

   227

				SetWindowDirty(w);

   228

			}

   229

		}

   230

	}

   231

}

   232

   233

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

   234

   235

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

   236

{

   237

	Window* const *wz;

   238

	DrawPixelInfo bk;

   239

	_cur_dpi = &bk;

   240

   241

	FOR_ALL_WINDOWS(wz) {

   242

		const Window *w = *wz;

   243

		if (right > w->left &&

   244

				bottom > w->top &&

   245

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

   246

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

   247

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

   248

		}

   249

	}

   250

}

   251

   252

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

   253

{

   254

	Window* const *vz = wz;

   255

	int x;

   256

   257

	while (++vz != _last_z_window) {

   258

		const Window *v = *vz;

   259

   260

		if (right > v->left &&

   261

				bottom > v->top &&

   262

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

   263

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

   264

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

   265

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

   266

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

   267

				return;

   268

			}

   269

   270

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

   271

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

   272

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

   273

				return;

   274

			}

   275

   276

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

   277

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

   278

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

   279

				return;

   280

			}

   281

   282

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

   283

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

   284

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

   285

				return;

   286

			}

   287

   288

			return;

   289

		}

   290

	}

   291

   292

	{

   293

		DrawPixelInfo *dp = _cur_dpi;

   294

		dp->width = right - left;

   295

		dp->height = bottom - top;

   296

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

   297

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

   298

		dp->pitch = _screen.pitch;

   299

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

   300

		dp->zoom = ZOOM_LVL_NORMAL;

   301

		CallWindowEventNP(*wz, WE_PAINT);

   302

	}

   303

}

   304

   305

void CallWindowEventNP(Window *w, int event)

   306

{

   307

	WindowEvent e;

   308

   309

	e.event = event;

   310

	w->wndproc(w, &e);

   311

}

   312

   313

void SetWindowDirty(const Window *w)

   314

{

   315

	if (w == NULL) return;

   316

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

   317

}

   318

   319

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

   320

 * @param w parent Window to find child of

   321

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

   322

static Window *FindChildWindow(const Window *w)

   323

{

   324

	Window* const *wz;

   325

   326

	FOR_ALL_WINDOWS(wz) {

   327

		Window *v = *wz;

   328

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

   329

	}

   330

   331

	return NULL;

   332

}

   333

   334

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

   335

 * or the behaviour is undefined but function should never fail

   336

 * @param w window to query Z Position

   337

 * @return the window that matches it */

   338

Window **FindWindowZPosition(const Window *w)

   339

{

   340

	Window **wz;

   341

   342

	for (wz = _z_windows; wz != _last_z_window; wz++) {

   343

		if (*wz == w) return wz;

   344

	}

   345

   346

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

   347

		w->window_class, w->window_number);

   348

	return NULL;

   349

}

   350

   351

void DeleteWindow(Window *w)

   352

{

   353

	Window *v;

   354

	Window **wz;

   355

	if (w == NULL) return;

   356

   357

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

   358

	v = FindChildWindow(w);

   359

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

   360

   361

	if (_thd.place_mode != VHM_NONE &&

   362

			_thd.window_class == w->window_class &&

   363

			_thd.window_number == w->window_number) {

   364

		ResetObjectToPlace();

   365

	}

   366

   367

	CallWindowEventNP(w, WE_DESTROY);

   368

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

   369

   370

	SetWindowDirty(w);

   371

	free(w->widget);

   372

	w->widget = NULL;

   373

	w->widget_count = 0;

   374

	w->parent = NULL;

   375

   376

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

   377

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

   378

	wz = FindWindowZPosition(w);

   379

	if (wz == NULL) return;

   380

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

   381

	_last_z_window--;

   382

}

   383

   384

Window *FindWindowById(WindowClass cls, WindowNumber number)

   385

{

   386

	Window* const *wz;

   387

   388

	FOR_ALL_WINDOWS(wz) {

   389

		Window *w = *wz;

   390

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

   391

	}

   392

   393

	return NULL;

   394

}

   395

   396

void DeleteWindowById(WindowClass cls, WindowNumber number)

   397

{

   398

	DeleteWindow(FindWindowById(cls, number));

   399

}

   400

   401

void DeleteWindowByClass(WindowClass cls)

   402

{

   403

	Window* const *wz;

   404

   405

restart_search:

   406

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

   407

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

   408

	 * anywhere in the z-array */

   409

	FOR_ALL_WINDOWS(wz) {

   410

		Window *w = *wz;

   411

		if (w->window_class == cls) {

   412

			DeleteWindow(w);

   413

			goto restart_search;

   414

		}

   415

	}

   416

}

   417

   418

/** Delete all windows of a player. We identify windows of a player

   419

 * by looking at the caption colour. If it is equal to the player ID

   420

 * then we say the window belongs to the player and should be deleted

   421

 * @param id PlayerID player identifier */

   422

void DeletePlayerWindows(PlayerID id)

   423

{

   424

	Window* const *wz;

   425

   426

restart_search:

   427

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

   428

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

   429

	 * anywhere in the z-array */

   430

	FOR_ALL_WINDOWS(wz) {

   431

		Window *w = *wz;

   432

		if (w->caption_color == id) {

   433

			DeleteWindow(w);

   434

			goto restart_search;

   435

		}

   436

	}

   437

   438

	/* Also delete the player specific windows, that don't have a player-colour */

   439

	DeleteWindowById(WC_BUY_COMPANY, id);

   440

}

   441

   442

/** Change the owner of all the windows one player can take over from another

   443

 * player in the case of a company merger. Do not change ownership of windows

   444

 * that need to be deleted once takeover is complete

   445

 * @param old_player PlayerID of original owner of the window

   446

 * @param new_player PlayerID of the new owner of the window */

   447

void ChangeWindowOwner(PlayerID old_player, PlayerID new_player)

   448

{

   449

	Window* const *wz;

   450

   451

	FOR_ALL_WINDOWS(wz) {

   452

		Window *w = *wz;

   453

   454

		if (w->caption_color != old_player)      continue;

   455

		if (w->window_class == WC_PLAYER_COLOR)  continue;

   456

		if (w->window_class == WC_FINANCES)      continue;

   457

		if (w->window_class == WC_STATION_LIST)  continue;

   458

		if (w->window_class == WC_TRAINS_LIST)   continue;

   459

		if (w->window_class == WC_ROADVEH_LIST)  continue;

   460

		if (w->window_class == WC_SHIPS_LIST)    continue;

   461

		if (w->window_class == WC_AIRCRAFT_LIST) continue;

   462

		if (w->window_class == WC_BUY_COMPANY)   continue;

   463

		if (w->window_class == WC_COMPANY)       continue;

   464

   465

		w->caption_color = new_player;

   466

	}

   467

}

   468

   469

static void BringWindowToFront(const Window *w);

   470

   471

/** Find a window and make it the top-window on the screen. The window

   472

 * gets a white border for a brief period of time to visualize its "activation"

   473

 * @param cls WindowClass of the window to activate

   474

 * @param number WindowNumber of the window to activate

   475

 * @return a pointer to the window thus activated */

   476

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   477

{

   478

	Window *w = FindWindowById(cls, number);

   479

   480

	if (w != NULL) {

   481

		w->flags4 |= WF_WHITE_BORDER_MASK;

   482

		BringWindowToFront(w);

   483

		SetWindowDirty(w);

   484

	}

   485

   486

	return w;

   487

}

   488

   489

static inline bool IsVitalWindow(const Window *w)