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

    10

#include "map.h"

    11

#include "player.h"

    12

#include "gfx.h"

    13

#include "viewport.h"

    14

#include "console.h"

    15

#include "variables.h"

    16

#include "table/sprites.h"

    17

#include "genworld.h"

    18

#include "helpers.hpp"

    19

#include "blitter/factory.hpp"

    20

#include "window_gui.h"

    21

    22

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

    23

static Point _drag_delta;

    24

    25

static Window _windows[MAX_NUMBER_OF_WINDOWS];

    26

Window *_z_windows[lengthof(_windows)];

    27

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

    28

    29

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

    30

{

    31

	va_list wdg_list;

    32

    33

	va_start(wdg_list, widgets);

    34

    35

	while (widgets != WIDGET_LIST_END) {

    36

		SetWidgetDisabledState(widgets, disab_stat);

    37

		widgets = va_arg(wdg_list, int);

    38

	}

    39

    40

	va_end(wdg_list);

    41

}

    42

    43

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

    44

{

    45

	va_list wdg_list;

    46

    47

	va_start(wdg_list, widgets);

    48

    49

	while (widgets != WIDGET_LIST_END) {

    50

		SetWidgetHiddenState(widgets, hidden_stat);

    51

		widgets = va_arg(wdg_list, int);

    52

	}

    53

    54

	va_end(wdg_list);

    55

}

    56

    57

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

    58

{

    59

	va_list wdg_list;

    60

    61

	va_start(wdg_list, widgets);

    62

    63

	while (widgets != WIDGET_LIST_END) {

    64

		SetWidgetLoweredState(widgets, lowered_stat);

    65

		widgets = va_arg(wdg_list, int);

    66

	}

    67

    68

	va_end(wdg_list);

    69

}

    70

    71

void Window::RaiseButtons()

    72

{

    73

	uint i;

    74

    75

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

    76

		if (this->IsWidgetLowered(i)) {

    77

			this->RaiseWidget(i);

    78

			this->InvalidateWidget(i);

    79

		}

    80

	}

    81

}

    82

    83

void Window::InvalidateWidget(byte widget_index) const

    84

{

    85

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

    86

    87

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

    88

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

    89

    90

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

    91

}

    92

    93

void Window::HandleButtonClick(byte widget)

    94

{

    95

	this->LowerWidget(widget);

    96

	this->flags4 |= 5 << WF_TIMEOUT_SHL;

    97

	this->InvalidateWidget(widget);

    98

}

    99

   100

static void StartWindowDrag(Window *w);

   101

static void StartWindowSizing(Window *w);

   102

   103

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

   104

{

   105

	WindowEvent e;

   106

	const Widget *wi;

   107

   108

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

   109

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

   110

	e.event = double_click ? WE_DOUBLE_CLICK : WE_CLICK;

   111

   112

	if (w->desc_flags & WDF_DEF_WIDGET) {

   113

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

   114

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

   115

   116

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

   117

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

   118

   119

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

   120

   121

		if (wi->type & WWB_MASK) {

   122

			/* special widget handling for buttons*/

   123

			switch (wi->type) {

   124

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   125

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   126

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   127

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

   128

					break;

   129

			}

   130

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

   131

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

   132

		}

   133

   134

		if (w->desc_flags & WDF_STD_BTN) {

   135

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

   136

				DeleteWindow(w);

   137

				return;

   138

			}

   139

   140

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

   141

				StartWindowDrag(w);

   142

				return;

   143

			}

   144

		}

   145

   146

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

   147

			StartWindowSizing(w);

   148

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

   149

			return;

   150

		}

   151

   152

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

   153

			w->flags4 ^= WF_STICKY;

   154

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

   155

			return;

   156

		}

   157

	}

   158

   159

	w->wndproc(w, &e);

   160

}

   161

   162

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

   163

{

   164

	WindowEvent e;

   165

   166

	/* default tooltips handler? */

   167

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   168

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

   169

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

   170

			return; // exit if clicked outside of widgets

   171

   172

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

   173

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

   174

			return;

   175

		}

   176

	}

   177

   178

	e.event = WE_RCLICK;

   179

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

   180

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

   181

	w->wndproc(w, &e);

   182

}

   183

   184

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

   185

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

   186

 * @param *w Window

   187

 * @param widget the widget where the scrollwheel was used

   188

 * @param wheel scroll up or down

   189

 */

   190

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

   191

{

   192

	const Widget *wi1, *wi2;

   193

	Scrollbar *sb;

   194

   195

	if (widget < 0) return;

   196

   197

	wi1 = &w->widget[widget];

   198

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

   199

   200

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

   201

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

   202

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

   203

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

   204

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

   205

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

   206

   207

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

   208

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

   209

			if (pos != sb->pos) {

   210

				sb->pos = pos;

   211

				SetWindowDirty(w);

   212

			}

   213

		}

   214

	}

   215

}

   216

   217

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

   218

   219

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

   220

{

   221

	Window* const *wz;

   222

	DrawPixelInfo bk;

   223

	_cur_dpi = &bk;

   224

   225

	FOR_ALL_WINDOWS(wz) {

   226

		const Window *w = *wz;

   227

		if (right > w->left &&

   228

				bottom > w->top &&

   229

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

   230

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

   231

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

   232

		}

   233

	}

   234

}

   235

   236

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

   237

{

   238

	Window* const *vz = wz;

   239

	int x;

   240

   241

	while (++vz != _last_z_window) {

   242

		const Window *v = *vz;

   243

   244

		if (right > v->left &&

   245

				bottom > v->top &&

   246

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

   247

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

   248

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

   249

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

   250

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

   251

				return;

   252

			}

   253

   254

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

   255

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

   256

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

   257

				return;

   258

			}

   259

   260

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

   261

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

   262

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

   263

				return;

   264

			}

   265

   266

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

   267

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

   268

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

   269

				return;

   270

			}

   271

   272

			return;

   273

		}

   274

	}

   275

   276

	{

   277

		DrawPixelInfo *dp = _cur_dpi;

   278

		dp->width = right - left;

   279

		dp->height = bottom - top;

   280

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

   281

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

   282

		dp->pitch = _screen.pitch;

   283

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

   284

		dp->zoom = ZOOM_LVL_NORMAL;

   285

		CallWindowEventNP(*wz, WE_PAINT);

   286

	}

   287

}

   288

   289

void CallWindowEventNP(Window *w, int event)

   290

{

   291

	WindowEvent e;

   292

   293

	e.event = event;

   294

	w->wndproc(w, &e);

   295

}

   296

   297

void SetWindowDirty(const Window *w)

   298

{

   299

	if (w == NULL) return;

   300

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

   301

}

   302

   303

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

   304

 * @param w parent Window to find child of

   305

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

   306

static Window *FindChildWindow(const Window *w)

   307

{

   308

	Window* const *wz;

   309

   310

	FOR_ALL_WINDOWS(wz) {

   311

		Window *v = *wz;

   312

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

   313

	}

   314

   315

	return NULL;

   316

}

   317

   318

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

   319

 * or the behaviour is undefined but function should never fail

   320

 * @param w window to query Z Position

   321

 * @return the window that matches it */

   322

Window **FindWindowZPosition(const Window *w)

   323

{

   324

	Window **wz;

   325

   326

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

   327

		if (*wz == w) return wz;

   328

	}

   329

   330

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

   331

		w->window_class, w->window_number);

   332

	return NULL;

   333

}

   334

   335

void DeleteWindow(Window *w)

   336

{

   337

	Window *v;

   338

	Window **wz;

   339

	if (w == NULL) return;

   340

   341

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

   342

	v = FindChildWindow(w);

   343

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

   344

   345

	if (_thd.place_mode != VHM_NONE &&

   346

			_thd.window_class == w->window_class &&

   347

			_thd.window_number == w->window_number) {

   348

		ResetObjectToPlace();

   349

	}

   350

   351

	CallWindowEventNP(w, WE_DESTROY);

   352

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

   353

   354

	SetWindowDirty(w);

   355

	free(w->widget);

   356

	w->widget = NULL;

   357

	w->widget_count = 0;

   358

	w->parent = NULL;

   359

   360

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

   361

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

   362

	wz = FindWindowZPosition(w);

   363

	if (wz == NULL) return;

   364

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

   365

	_last_z_window--;

   366

}

   367

   368

Window *FindWindowById(WindowClass cls, WindowNumber number)

   369

{

   370

	Window* const *wz;

   371

   372

	FOR_ALL_WINDOWS(wz) {

   373

		Window *w = *wz;

   374

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

   375

	}

   376

   377

	return NULL;

   378

}

   379

   380

void DeleteWindowById(WindowClass cls, WindowNumber number)

   381

{

   382

	DeleteWindow(FindWindowById(cls, number));

   383

}

   384

   385

void DeleteWindowByClass(WindowClass cls)

   386

{

   387

	Window* const *wz;

   388

   389

restart_search:

   390

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

   391

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

   392

	 * anywhere in the z-array */

   393

	FOR_ALL_WINDOWS(wz) {

   394

		Window *w = *wz;

   395

		if (w->window_class == cls) {

   396

			DeleteWindow(w);

   397

			goto restart_search;

   398

		}

   399

	}

   400

}

   401

   402

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

   403

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

   404

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

   405

 * @param id PlayerID player identifier */

   406

void DeletePlayerWindows(PlayerID id)

   407

{

   408

	Window* const *wz;

   409

   410

restart_search:

   411

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

   412

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

   413

	 * anywhere in the z-array */

   414

	FOR_ALL_WINDOWS(wz) {

   415

		Window *w = *wz;

   416

		if (w->caption_color == id) {

   417

			DeleteWindow(w);

   418

			goto restart_search;

   419

		}

   420

	}

   421

   422

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

   423

	DeleteWindowById(WC_BUY_COMPANY, id);

   424

}

   425

   426

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

   427

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

   428

 * that need to be deleted once takeover is complete

   429

 * @param old_player PlayerID of original owner of the window

   430

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

   431

void ChangeWindowOwner(PlayerID old_player, PlayerID new_player)

   432

{

   433

	Window* const *wz;

   434

   435

	FOR_ALL_WINDOWS(wz) {

   436

		Window *w = *wz;

   437

   438

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

   439

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

   440

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

   441

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

   442

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

   443

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

   444

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

   445

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

   446

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

   447

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

   448

   449

		w->caption_color = new_player;

   450

	}

   451

}

   452

   453

static void BringWindowToFront(const Window *w);

   454

   455

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

   456

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

   457

 * @param cls WindowClass of the window to activate

   458

 * @param number WindowNumber of the window to activate

   459

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

   460

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   461

{

   462

	Window *w = FindWindowById(cls, number);

   463

   464

	if (w != NULL) {

   465

		w->flags4 |= WF_WHITE_BORDER_MASK;

   466

		BringWindowToFront(w);

   467

		SetWindowDirty(w);

   468

	}

   469

   470

	return w;

   471

}

   472

   473

static inline bool IsVitalWindow(const Window *w)

   474

{

   475

	WindowClass wc = w->window_class;

   476

	return (wc == WC_MAIN_TOOLBAR || wc == WC_STATUS_BAR || wc == WC_NEWS_WINDOW || wc == WC_SEND_NETWORK_MSG);

   477

}

   478

   479

/** On clicking on a window, make it the frontmost window of all. However

   480

 * there are certain windows that always need to be on-top; these include

   481

 * - Toolbar, Statusbar (always on)

   482

 * - New window, Chatbar (only if open)

   483

 * The window is marked dirty for a repaint if the window is actually moved

   484

 * @param w window that is put into the foreground

   485

 * @return pointer to the window, the same as the input pointer

   486

 */

   487

static void BringWindowToFront(const Window *w)

   488

{

   489

	Window *tempz;

   490