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"

    21

    22

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

    23

static Point _drag_delta;

    24

    25

static Window _windows[25];

    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 SetWindowWidgetsDisabledState(Window *w, 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

		SetWindowWidgetDisabledState(w, widgets, disab_stat);

    37

		widgets = va_arg(wdg_list, int);

    38

	}

    39

    40

	va_end(wdg_list);

    41

}

    42

    43

void CDECL SetWindowWidgetsHiddenState(Window *w, 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

		SetWindowWidgetHiddenState(w, widgets, hidden_stat);

    51

		widgets = va_arg(wdg_list, int);

    52

	}

    53

    54

	va_end(wdg_list);

    55

}

    56

    57

void CDECL SetWindowWidgetsLoweredState(Window *w, 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

		SetWindowWidgetLoweredState(w, widgets, lowered_stat);

    65

		widgets = va_arg(wdg_list, int);

    66

	}

    67

    68

	va_end(wdg_list);

    69

}

    70

    71

void RaiseWindowButtons(Window *w)

    72

{

    73

	uint i;

    74

    75

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

    76

		if (IsWindowWidgetLowered(w, i)) {

    77

			RaiseWindowWidget(w, i);

    78

			InvalidateWidget(w, i);

    79

		}

    80

	}

    81

}

    82

    83

void HandleButtonClick(Window *w, byte widget)

    84

{

    85

	LowerWindowWidget(w, widget);

    86

	w->flags4 |= 5 << WF_TIMEOUT_SHL;

    87

	InvalidateWidget(w, widget);

    88

}

    89

    90

    91

static void StartWindowDrag(Window *w);

    92

static void StartWindowSizing(Window *w);

    93

    94

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

    95

{

    96

	WindowEvent e;

    97

	const Widget *wi;

    98

    99

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

   100

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

   101

	e.event = WE_CLICK;

   102

   103

	if (w->desc_flags & WDF_DEF_WIDGET) {

   104

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

   105

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

   106

   107

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

   108

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

   109

   110

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

   111

   112

		if (wi->type & WWB_MASK) {

   113

			/* special widget handling for buttons*/

   114

			switch (wi->type) {

   115

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   116

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   117

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   118

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

   119

					break;

   120

			}

   121

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

   122

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

   123

		}

   124

   125

		if (w->desc_flags & WDF_STD_BTN) {

   126

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

   127

				DeleteWindow(w);

   128

				return;

   129

			}

   130

   131

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

   132

				StartWindowDrag(w);

   133

				return;

   134

			}

   135

		}

   136

   137

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

   138

			StartWindowSizing(w);

   139

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

   140

			return;

   141

		}

   142

   143

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

   144

			w->flags4 ^= WF_STICKY;

   145

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

   146

			return;

   147

		}

   148

	}

   149

   150

	w->wndproc(w, &e);

   151

}

   152

   153

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

   154

{

   155

	WindowEvent e;

   156

   157

	/* default tooltips handler? */

   158

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   159

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

   160

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

   161

			return; // exit if clicked outside of widgets

   162

   163

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

   164

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

   165

			return;

   166

		}

   167

	}

   168

   169

	e.event = WE_RCLICK;

   170

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

   171

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

   172

	w->wndproc(w, &e);

   173

}

   174

   175

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

   176

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

   177

 * @param *w Window

   178

 * @param widget the widget where the scrollwheel was used

   179

 * @param wheel scroll up or down

   180

 */

   181

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

   182

{

   183

	const Widget *wi1, *wi2;

   184

	Scrollbar *sb;

   185

   186

	if (widget < 0) return;

   187

   188

	wi1 = &w->widget[widget];

   189

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

   190

   191

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

   192

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

   193

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

   194

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

   195

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

   196

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

   197

   198

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

   199

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

   200

			if (pos != sb->pos) {

   201

				sb->pos = pos;

   202

				SetWindowDirty(w);

   203

			}

   204

		}

   205

	}

   206

}

   207

   208

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

   209

   210

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

   211

{

   212

	Window* const *wz;

   213

	DrawPixelInfo bk;

   214

	_cur_dpi = &bk;

   215

   216

	FOR_ALL_WINDOWS(wz) {

   217

		const Window *w = *wz;

   218

		if (right > w->left &&

   219

				bottom > w->top &&

   220

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

   221

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

   222

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

   223

		}

   224

	}

   225

}

   226

   227

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

   228

{

   229

	Window* const *vz = wz;

   230

	int x;

   231

   232

	while (++vz != _last_z_window) {

   233

		const Window *v = *vz;

   234

   235

		if (right > v->left &&

   236

				bottom > v->top &&

   237

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

   238

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

   239

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

   240

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

   241

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

   242

				return;

   243

			}

   244

   245

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

   246

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

   247

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

   248

				return;

   249

			}

   250

   251

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

   252

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

   253

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

   254

				return;

   255

			}

   256

   257

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

   258

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

   259

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

   260

				return;

   261

			}

   262

   263

			return;

   264

		}

   265

	}

   266

   267

	{

   268

		DrawPixelInfo *dp = _cur_dpi;

   269

		dp->width = right - left;

   270

		dp->height = bottom - top;

   271

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

   272

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

   273

		dp->pitch = _screen.pitch;

   275

		dp->zoom = ZOOM_LVL_NORMAL;

   276

		CallWindowEventNP(*wz, WE_PAINT);

   277

	}

   278

}

   279

   280

void CallWindowEventNP(Window *w, int event)

   281

{

   282

	WindowEvent e;

   283

   284

	e.event = event;

   285

	w->wndproc(w, &e);

   286

}

   287

   288

void SetWindowDirty(const Window *w)

   289

{

   290

	if (w == NULL) return;

   291

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

   292

}

   293

   294

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

   295

 * @param w parent Window to find child of

   296

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

   297

static Window *FindChildWindow(const Window *w)

   298

{

   299

	Window* const *wz;

   300

   301

	FOR_ALL_WINDOWS(wz) {

   302

		Window *v = *wz;

   303

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

   304

	}

   305

   306

	return NULL;

   307

}

   308

   309

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

   310

 * or the behaviour is undefined but function should never fail

   311

 * @param w window to query Z Position

   312

 * @return the window that matches it */

   313

Window **FindWindowZPosition(const Window *w)

   314

{

   315

	Window **wz;

   316

   317

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

   318

		if (*wz == w) return wz;

   319

	}

   320

   321

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

   322

		w->window_class, w->window_number);

   323

	return NULL;

   324

}

   325

   326

void DeleteWindow(Window *w)

   327

{

   328

	Window *v;

   329

	Window **wz;

   330

	if (w == NULL) return;

   331

   332

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

   333

	v = FindChildWindow(w);

   334

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

   335

   336

	if (_thd.place_mode != VHM_NONE &&

   337

			_thd.window_class == w->window_class &&

   338

			_thd.window_number == w->window_number) {

   339

		ResetObjectToPlace();

   340

	}

   341

   342

	CallWindowEventNP(w, WE_DESTROY);

   343

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

   344

   345

	SetWindowDirty(w);

   346

	free(w->widget);

   347

	w->widget = NULL;

   348

	w->widget_count = 0;

   349

	w->parent = NULL;

   350

   351

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

   352

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

   353

	wz = FindWindowZPosition(w);

   354

	if (wz == NULL) return;

   355

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

   356

	_last_z_window--;

   357

}

   358

   359

Window *FindWindowById(WindowClass cls, WindowNumber number)

   360

{

   361

	Window* const *wz;

   362

   363

	FOR_ALL_WINDOWS(wz) {

   364

		Window *w = *wz;

   365

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

   366

	}

   367

   368

	return NULL;

   369

}

   370

   371

void DeleteWindowById(WindowClass cls, WindowNumber number)

   372

{

   373

	DeleteWindow(FindWindowById(cls, number));

   374

}

   375

   376

void DeleteWindowByClass(WindowClass cls)

   377

{

   378

	Window* const *wz;

   379

   380

restart_search:

   381

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

   382

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

   383

	 * anywhere in the z-array */

   384

	FOR_ALL_WINDOWS(wz) {

   385

		Window *w = *wz;

   386

		if (w->window_class == cls) {

   387

			DeleteWindow(w);

   388

			goto restart_search;

   389

		}

   390

	}

   391

}

   392

   393

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

   394

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

   395

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

   396

 * @param id PlayerID player identifier */

   397

void DeletePlayerWindows(PlayerID id)

   398

{

   399

	Window* const *wz;

   400

   401

restart_search:

   402

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

   403

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

   404

	 * anywhere in the z-array */

   405

	FOR_ALL_WINDOWS(wz) {

   406

		Window *w = *wz;

   407

		if (w->caption_color == id) {

   408

			DeleteWindow(w);

   409

			goto restart_search;

   410

		}

   411

	}

   412

   413

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

   414

	DeleteWindowById(WC_BUY_COMPANY, id);

   415

}

   416

   417

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

   418

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

   419

 * that need to be deleted once takeover is complete

   420

 * @param old_player PlayerID of original owner of the window

   421

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

   422

void ChangeWindowOwner(PlayerID old_player, PlayerID new_player)

   423

{

   424

	Window* const *wz;

   425

   426

	FOR_ALL_WINDOWS(wz) {

   427

		Window *w = *wz;

   428

   429

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

   430

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

   431

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

   432

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

   433

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

   434

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

   435

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

   436

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

   437

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

   438

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

   439

   440

		w->caption_color = new_player;

   441

	}

   442

}

   443

   444

static void BringWindowToFront(const Window *w);

   445

   446

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

   447

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

   448

 * @param cls WindowClass of the window to activate

   449

 * @param number WindowNumber of the window to activate

   450

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

   451

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   452

{

   453

	Window *w = FindWindowById(cls, number);

   454

   455

	if (w != NULL) {

   456

		w->flags4 |= WF_WHITE_BORDER_MASK;

   457

		BringWindowToFront(w);

   458

		SetWindowDirty(w);

   459

	}

   460

   461

	return w;

   462

}

   463

   464

static inline bool IsVitalWindow(const Window *w)

   465

{

   466

	WindowClass wc = w->window_class;

   467

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

   468

}

   469

   470

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

   471

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

   472

 * - Toolbar, Statusbar (always on)

   473

 * - New window, Chatbar (only if open)

   474

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

   475

 * @param w window that is put into the foreground

   476

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

   477

 */

   478

static void BringWindowToFront(const Window *w)

   479

{

   480

	Window *tempz;

   481

	Window **wz = FindWindowZPosition(w);

   482

	Window **vz = _last_z_window;

   483

   484

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

   485

	do {

   486

		if (--vz < _z_windows) return;

   487

	} while (IsVitalWindow(*vz));

   488

   489

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

   490

	assert(wz < vz);