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

    13

#include "gfx.h"

    14

#include "viewport.h"

    15

#include "console.h"

    16

#include "variables.h"

    17

#include "table/sprites.h"

    18

#include "genworld.h"

    19

#include "helpers.hpp"

    20

    21

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

    22

static Point _drag_delta;

    23

    24

static Window _windows[25];

    25

Window *_z_windows[lengthof(_windows)];

    26

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

    27

    28

void CDECL SetWindowWidgetsDisabledState(Window *w, bool disab_stat, int widgets, ...)

    29

{

    30

	va_list wdg_list;

    31

    32

	va_start(wdg_list, widgets);

    33

    34

	while (widgets != WIDGET_LIST_END) {

    35

		SetWindowWidgetDisabledState(w, widgets, disab_stat);

    36

		widgets = va_arg(wdg_list, int);

    37

	}

    38

    39

	va_end(wdg_list);

    40

}

    41

    42

void CDECL SetWindowWidgetsHiddenState(Window *w, bool hidden_stat, int widgets, ...)

    43

{

    44

	va_list wdg_list;

    45

    46

	va_start(wdg_list, widgets);

    47

    48

	while (widgets != WIDGET_LIST_END) {

    49

		SetWindowWidgetHiddenState(w, widgets, hidden_stat);

    50

		widgets = va_arg(wdg_list, int);

    51

	}

    52

    53

	va_end(wdg_list);

    54

}

    55

    56

void CDECL SetWindowWidgetsLoweredState(Window *w, bool lowered_stat, int widgets, ...)

    57

{

    58

	va_list wdg_list;

    59

    60

	va_start(wdg_list, widgets);

    61

    62

	while (widgets != WIDGET_LIST_END) {

    63

		SetWindowWidgetLoweredState(w, widgets, lowered_stat);

    64

		widgets = va_arg(wdg_list, int);

    65

	}

    66

    67

	va_end(wdg_list);

    68

}

    69

    70

void RaiseWindowButtons(Window *w)

    71

{

    72

	uint i;

    73

    74

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

    75

		if (IsWindowWidgetLowered(w, i)) {

    76

			RaiseWindowWidget(w, i);

    77

			InvalidateWidget(w, i);

    78

		}

    79

	}

    80

}

    81

    82

void HandleButtonClick(Window *w, byte widget)

    83

{

    84

	LowerWindowWidget(w, widget);

    85

	w->flags4 |= 5 << WF_TIMEOUT_SHL;

    86

	InvalidateWidget(w, widget);

    87

}

    88

    89

    90

static void StartWindowDrag(Window *w);

    91

static void StartWindowSizing(Window *w);

    92

    93

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

    94

{

    95

	WindowEvent e;

    96

	const Widget *wi;

    97

    98

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

    99

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

   100

	e.event = WE_CLICK;

   101

   102

	if (w->desc_flags & WDF_DEF_WIDGET) {

   103

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

   104

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

   105

   106

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

   107

		if (IsWindowWidgetDisabled(w, e.we.click.widget)) return;

   108

   109

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

   110

   111

		if (wi->type & WWB_MASK) {

   112

			/* special widget handling for buttons*/

   113

			switch (wi->type) {

   114

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   115

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   116

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   117

					HandleButtonClick(w, e.we.click.widget);

   118

					break;

   119

			}

   120

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

   121

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

   122

		}

   123

   124

		if (w->desc_flags & WDF_STD_BTN) {

   125

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

   126

				DeleteWindow(w);

   127

				return;

   128

			}

   129

   130

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

   131

				StartWindowDrag(w);

   132

				return;

   133

			}

   134

		}

   135

   136

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

   137

			StartWindowSizing(w);

   138

			InvalidateWidget(w, e.we.click.widget);

   139

			return;

   140

		}

   141

   142

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

   143

			w->flags4 ^= WF_STICKY;

   144

			InvalidateWidget(w, e.we.click.widget);

   145

			return;

   146

		}

   147

	}

   148

   149

	w->wndproc(w, &e);

   150

}

   151

   152

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

   153

{

   154

	WindowEvent e;

   155

   156

	/* default tooltips handler? */

   157

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   158

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

   159

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

   160

			return; /* exit if clicked outside of widgets */

   161

   162

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

   163

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

   164

			return;

   165

		}

   166

	}

   167

   168

	e.event = WE_RCLICK;

   169

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

   170

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

   171

	w->wndproc(w, &e);

   172

}

   173

   174

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

   175

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

   176

 * @param *w Window

   177

 * @param widget the widget where the scrollwheel was used

   178

 * @param wheel scroll up or down

   179

 */

   180

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

   181

{

   182

	const Widget *wi1, *wi2;

   183

	Scrollbar *sb;

   184

   185

	if (widget < 0) return;

   186

   187

	wi1 = &w->widget[widget];

   188

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

   189

   190

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

   191

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

   192

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

   193

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

   194

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

   195

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

   196

   197

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

   198

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

   199

			if (pos != sb->pos) {

   200

				sb->pos = pos;

   201

				SetWindowDirty(w);

   202

			}

   203

		}

   204

	}

   205

}

   206

   207

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

   208

   209

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

   210

{

   211

	Window* const *wz;

   212

	DrawPixelInfo bk;

   213

	_cur_dpi = &bk;

   214

   215

	FOR_ALL_WINDOWS(wz) {

   216

		const Window *w = *wz;

   217

		if (right > w->left &&

   218

				bottom > w->top &&

   219

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

   220

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

   221

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

   222

		}

   223

	}

   224

}

   225

   226

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

   227

{

   228

	Window* const *vz = wz;

   229

	int x;

   230

   231

	while (++vz != _last_z_window) {

   232

		const Window *v = *vz;

   233

   234

		if (right > v->left &&

   235

				bottom > v->top &&

   236

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

   237

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

   238

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

   239

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

   240

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

   241

				return;

   242

			}

   243

   244

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

   245

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

   246

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

   247

				return;

   248

			}

   249

   250

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

   251

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

   252

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

   253

				return;

   254

			}

   255

   256

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

   257

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

   258

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

   259

				return;

   260

			}

   261

   262

			return;

   263

		}

   264

	}

   265

   266

	{

   267

		DrawPixelInfo *dp = _cur_dpi;

   268

		dp->width = right - left;

   269

		dp->height = bottom - top;

   270

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

   271

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

   272

		dp->pitch = _screen.pitch;

   273

		dp->dst_ptr = _screen.dst_ptr + top * _screen.pitch + left;

   274

		dp->zoom = 0;

   275

		CallWindowEventNP(*wz, WE_PAINT);

   276

	}

   277

}

   278

   279

void CallWindowEventNP(Window *w, int event)

   280

{

   281

	WindowEvent e;

   282

   283

	e.event = event;

   284

	w->wndproc(w, &e);

   285

}

   286

   287

void SetWindowDirty(const Window *w)

   288

{

   289

	if (w == NULL) return;

   290

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

   291

}

   292

   293

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

   294

 * @parent w Window to find child of

   295

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

   296

static Window *FindChildWindow(const Window *w)

   297

{

   298

	Window* const *wz;

   299

   300

	FOR_ALL_WINDOWS(wz) {

   301

		Window *v = *wz;

   302

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

   303

	}

   304

   305

	return NULL;

   306

}

   307

   308

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

   309

 * or the behaviour is undefined but function should never fail */

   310

Window **FindWindowZPosition(const Window *w)

   311

{

   312

	Window **wz;

   313

   314

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

   315

		if (*wz == w) return wz;

   316

	}

   317

   318

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

   319

		w->window_class, w->window_number);

   320

	return NULL;

   321

}

   322

   323

void DeleteWindow(Window *w)

   324

{

   325

	Window *v;

   326

	Window **wz;

   327

	if (w == NULL) return;

   328

   329

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

   330

	v = FindChildWindow(w);

   331

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

   332

   333

	if (_thd.place_mode != VHM_NONE &&

   334

			_thd.window_class == w->window_class &&

   335

			_thd.window_number == w->window_number) {

   336

		ResetObjectToPlace();

   337

	}

   338

   339

	CallWindowEventNP(w, WE_DESTROY);

   340

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

   341

   342

	SetWindowDirty(w);

   343

	free(w->widget);

   344

	w->widget = NULL;

   345

	w->widget_count = 0;

   346

	w->parent = NULL;

   347

   348

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

   349

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

   350

	wz = FindWindowZPosition(w);

   351

	if (wz == NULL) return;

   352

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

   353

	_last_z_window--;

   354

}

   355

   356

Window *FindWindowById(WindowClass cls, WindowNumber number)

   357

{

   358

	Window* const *wz;

   359

   360

	FOR_ALL_WINDOWS(wz) {

   361

		Window *w = *wz;

   362

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

   363

	}

   364

   365

	return NULL;

   366

}

   367

   368

void DeleteWindowById(WindowClass cls, WindowNumber number)

   369

{

   370

	DeleteWindow(FindWindowById(cls, number));

   371

}

   372

   373

void DeleteWindowByClass(WindowClass cls)

   374

{

   375

	Window* const *wz;

   376

   377

restart_search:

   378

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

   379

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

   380

	 * anywhere in the z-array */

   381

	FOR_ALL_WINDOWS(wz) {

   382

		Window *w = *wz;

   383

		if (w->window_class == cls) {

   384

			DeleteWindow(w);

   385

			goto restart_search;

   386

		}

   387

	}

   388

}

   389

   390

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

   391

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

   392

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

   393

 * @param id PlayerID player identifier */

   394

void DeletePlayerWindows(PlayerID id)

   395

{

   396

	Window* const *wz;

   397

   398

restart_search:

   399

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

   400

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

   401

	 * anywhere in the z-array */

   402

	FOR_ALL_WINDOWS(wz) {

   403

		Window *w = *wz;

   404

		if (w->caption_color == id) {

   405

			DeleteWindow(w);

   406

			goto restart_search;

   407

		}

   408

	}

   409

   410

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

   411

	DeleteWindowById(WC_BUY_COMPANY, id);

   412

}

   413

   414

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

   415

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

   416

 * that need to be deleted once takeover is complete

   417

 * @param old_player PlayerID of original owner of the window

   418

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

   419

void ChangeWindowOwner(PlayerID old_player, PlayerID new_player)

   420

{

   421

	Window* const *wz;

   422

   423

	FOR_ALL_WINDOWS(wz) {

   424

		Window *w = *wz;

   425

   426

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

   427

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

   428

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

   429

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

   430

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

   431

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

   432

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

   433

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

   434

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

   435

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

   436

   437

		w->caption_color = new_player;

   438

	}

   439

}

   440

   441

static void BringWindowToFront(const Window *w);

   442

   443

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

   444

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

   445

 * "activation"

   446

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

   447

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   448

{

   449

	Window *w = FindWindowById(cls, number);

   450

   451

	if (w != NULL) {

   452

		w->flags4 |= WF_WHITE_BORDER_MASK;

   453

		BringWindowToFront(w);

   454

		SetWindowDirty(w);

   455

	}

   456

   457

	return w;

   458

}

   459

   460

static inline bool IsVitalWindow(const Window *w)

   461

{

   462

	WindowClass wc = w->window_class;

   463

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

   464

}

   465

   466

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

   467

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

   468

 * - Toolbar, Statusbar (always on)

   469

 * - New window, Chatbar (only if open)

   470

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

   471

 * @param w window that is put into the foreground

   472

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

   473

 */

   474

static void BringWindowToFront(const Window *w)

   475

{

   476

	Window *tempz;

   477

	Window **wz = FindWindowZPosition(w);

   478

	Window **vz = _last_z_window;

   479

   480

	/* Bring the window just below the vital windows */

   481

	do {

   482

		if (--vz < _z_windows) return;

   483

	} while (IsVitalWindow(*vz));

   484

   485

	if (wz == vz) return; // window is already in the right position

   486

	assert(wz < vz);

   487

   488

	tempz = *wz;

   489

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

   490

	*vz = tempz;

   491