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

    10

#include "player.h"

    11

#include "viewport.h"

    12

#include "console.h"

    13

#include "variables.h"

    14

#include "table/sprites.h"

    15

#include "genworld.h"

    16

#include "blitter/factory.hpp"

    17

#include "window_gui.h"

    18

#include "zoom_func.h"

    19

#include "core/alloc_func.hpp"

    20

    21

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

    22

static Point _drag_delta;

    23

    24

static Window _windows[MAX_NUMBER_OF_WINDOWS];

    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 Window::SetWidgetsDisabledState(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

		SetWidgetDisabledState(widgets, disab_stat);

    36

		widgets = va_arg(wdg_list, int);

    37

	}

    38

    39

	va_end(wdg_list);

    40

}

    41

    42

void CDECL Window::SetWidgetsHiddenState(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

		SetWidgetHiddenState(widgets, hidden_stat);

    50

		widgets = va_arg(wdg_list, int);

    51

	}

    52

    53

	va_end(wdg_list);

    54

}

    55

    56

void CDECL Window::SetWidgetsLoweredState(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

		SetWidgetLoweredState(widgets, lowered_stat);

    64

		widgets = va_arg(wdg_list, int);

    65

	}

    66

    67

	va_end(wdg_list);

    68

}

    69

    70

void Window::RaiseButtons()

    71

{

    72

	uint i;

    73

    74

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

    75

		if (this->IsWidgetLowered(i)) {

    76

			this->RaiseWidget(i);

    77

			this->InvalidateWidget(i);

    78

		}

    79

	}

    80

}

    81

    82

void Window::InvalidateWidget(byte widget_index) const

    83

{

    84

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

    85

    86

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

    87

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

    88

    89

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

    90

}

    91

    92

void Window::HandleButtonClick(byte widget)

    93

{

    94

	this->LowerWidget(widget);

    95

	this->flags4 |= 5 << WF_TIMEOUT_SHL;

    96

	this->InvalidateWidget(widget);

    97

}

    98

    99

static void StartWindowDrag(Window *w);

   100

static void StartWindowSizing(Window *w);

   101

   102

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

   103

{

   104

	WindowEvent e;

   105

	const Widget *wi;

   106

   107

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

   108

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

   109

	e.event = double_click ? WE_DOUBLE_CLICK : WE_CLICK;

   110

   111

	if (w->desc_flags & WDF_DEF_WIDGET) {

   112

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

   113

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

   114

   115

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

   116

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

   117

   118

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

   119

   120

		if (wi->type & WWB_MASK) {

   121

			/* special widget handling for buttons*/

   122

			switch (wi->type) {

   123

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   124

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   125

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   126

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

   127

					break;

   128

			}

   129

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

   130

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

   131

		}

   132

   133

		if (w->desc_flags & WDF_STD_BTN) {

   134

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

   135

				DeleteWindow(w);

   136

				return;

   137

			}

   138

   139

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

   140

				StartWindowDrag(w);

   141

				return;

   142

			}

   143

		}

   144

   145

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

   146

			StartWindowSizing(w);

   147

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

   148

			return;

   149

		}

   150

   151

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

   152

			w->flags4 ^= WF_STICKY;

   153

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

   154

			return;

   155

		}

   156

	}

   157

   158

	w->wndproc(w, &e);

   159

}

   160

   161

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

   162

{

   163

	WindowEvent e;

   164

   165

	/* default tooltips handler? */

   166

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   167

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

   168

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

   169

			return; // exit if clicked outside of widgets

   170

   171

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

   172

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

   173

			return;

   174

		}

   175

	}

   176

   177

	e.event = WE_RCLICK;

   178

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

   179

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

   180

	w->wndproc(w, &e);

   181

}

   182

   183

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

   184

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

   185

 * @param *w Window

   186

 * @param widget the widget where the scrollwheel was used

   187

 * @param wheel scroll up or down

   188

 */

   189

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

   190

{

   191

	const Widget *wi1, *wi2;

   192

	Scrollbar *sb;

   193

   194

	if (widget < 0) return;

   195

   196

	wi1 = &w->widget[widget];

   197

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

   198

   199

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

   200

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

   201

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

   202

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

   203

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

   204

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

   205

   206

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

   207

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

   208

			if (pos != sb->pos) {

   209

				sb->pos = pos;

   210

				SetWindowDirty(w);

   211

			}

   212

		}

   213

	}

   214

}

   215

   216

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

   217

   218

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

   219

{

   220

	Window* const *wz;

   221

	DrawPixelInfo bk;

   222

	_cur_dpi = &bk;

   223

   224

	FOR_ALL_WINDOWS(wz) {

   225

		const Window *w = *wz;

   226

		if (right > w->left &&

   227

				bottom > w->top &&

   228

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

   229

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

   230

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

   231

		}

   232

	}

   233

}

   234

   235

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

   236

{

   237

	Window* const *vz = wz;

   238

	int x;

   239

   240

	while (++vz != _last_z_window) {

   241

		const Window *v = *vz;

   242

   243

		if (right > v->left &&

   244

				bottom > v->top &&

   245

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

   246

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

   247

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

   248

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

   249

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

   250

				return;

   251

			}

   252

   253

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

   254

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

   255

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

   256

				return;

   257

			}

   258

   259

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

   260

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

   261

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

   262

				return;

   263

			}

   264

   265

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

   266

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

   267

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

   268

				return;

   269

			}

   270

   271

			return;

   272

		}

   273

	}

   274

   275

	{

   276

		DrawPixelInfo *dp = _cur_dpi;

   277

		dp->width = right - left;

   278

		dp->height = bottom - top;

   279

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

   280

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

   281

		dp->pitch = _screen.pitch;

   282

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

   283

		dp->zoom = ZOOM_LVL_NORMAL;

   284

		CallWindowEventNP(*wz, WE_PAINT);

   285

	}

   286

}

   287

   288

void CallWindowEventNP(Window *w, int event)

   289

{

   290

	WindowEvent e;

   291

   292

	e.event = event;

   293

	w->wndproc(w, &e);

   294

}

   295

   296

void SetWindowDirty(const Window *w)

   297

{

   298

	if (w == NULL) return;

   299

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

   300

}

   301

   302

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

   303

 * @param w parent Window to find child of

   304

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

   305

static Window *FindChildWindow(const Window *w)

   306

{

   307

	Window* const *wz;

   308

   309

	FOR_ALL_WINDOWS(wz) {

   310

		Window *v = *wz;

   311

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

   312

	}

   313

   314

	return NULL;

   315

}

   316

   317

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

   318

 * or the behaviour is undefined but function should never fail

   319

 * @param w window to query Z Position

   320

 * @return the window that matches it */

   321

Window **FindWindowZPosition(const Window *w)

   322

{

   323

	Window **wz;

   324

   325

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

   326

		if (*wz == w) return wz;

   327

	}

   328

   329

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

   330

		w->window_class, w->window_number);

   331

	return NULL;

   332

}

   333

   334

void DeleteWindow(Window *w)

   335

{

   336

	Window *v;

   337

	Window **wz;

   338

	if (w == NULL) return;

   339

   340

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

   341

	v = FindChildWindow(w);

   342

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

   343

   344

	if (_thd.place_mode != VHM_NONE &&

   345

			_thd.window_class == w->window_class &&

   346

			_thd.window_number == w->window_number) {

   347

		ResetObjectToPlace();

   348

	}

   349

   350

	CallWindowEventNP(w, WE_DESTROY);

   351

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

   352

   353

	SetWindowDirty(w);

   354

	free(w->widget);

   355

	w->widget = NULL;

   356

	w->widget_count = 0;

   357

	w->parent = NULL;

   358

   359

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

   360

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

   361

	wz = FindWindowZPosition(w);

   362

	if (wz == NULL) return;

   363

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

   364

	_last_z_window--;

   365

}

   366

   367

Window *FindWindowById(WindowClass cls, WindowNumber number)

   368

{

   369

	Window* const *wz;

   370

   371

	FOR_ALL_WINDOWS(wz) {

   372

		Window *w = *wz;

   373

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

   374

	}

   375

   376

	return NULL;

   377

}

   378

   379

void DeleteWindowById(WindowClass cls, WindowNumber number)

   380

{

   381

	DeleteWindow(FindWindowById(cls, number));

   382

}

   383

   384

void DeleteWindowByClass(WindowClass cls)

   385

{

   386

	Window* const *wz;

   387

   388

restart_search:

   389

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

   390

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

   391

	 * anywhere in the z-array */

   392

	FOR_ALL_WINDOWS(wz) {

   393

		Window *w = *wz;

   394

		if (w->window_class == cls) {

   395

			DeleteWindow(w);

   396

			goto restart_search;

   397

		}

   398

	}

   399

}

   400

   401

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

   402

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

   403

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

   404

 * @param id PlayerID player identifier */

   405

void DeletePlayerWindows(PlayerID id)

   406

{

   407

	Window* const *wz;

   408

   409

restart_search:

   410

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

   411

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

   412

	 * anywhere in the z-array */

   413

	FOR_ALL_WINDOWS(wz) {

   414

		Window *w = *wz;

   415

		if (w->caption_color == id) {

   416

			DeleteWindow(w);

   417

			goto restart_search;

   418

		}

   419

	}

   420

   421

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

   422

	DeleteWindowById(WC_BUY_COMPANY, id);

   423

}

   424

   425

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

   426

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

   427

 * that need to be deleted once takeover is complete

   428

 * @param old_player PlayerID of original owner of the window

   429

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

   430

void ChangeWindowOwner(PlayerID old_player, PlayerID new_player)

   431

{

   432

	Window* const *wz;

   433

   434

	FOR_ALL_WINDOWS(wz) {

   435

		Window *w = *wz;

   436

   437

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

   438

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

   439

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

   440

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

   441

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

   442

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

   443

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

   444

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

   445

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

   446

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

   447

   448

		w->caption_color = new_player;

   449

	}

   450

}

   451

   452

static void BringWindowToFront(const Window *w);

   453

   454

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

   455

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

   456

 * @param cls WindowClass of the window to activate

   457

 * @param number WindowNumber of the window to activate

   458

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

   459

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   460

{

   461

	Window *w = FindWindowById(cls, number);

   462

   463

	if (w != NULL) {

   464

		w->flags4 |= WF_WHITE_BORDER_MASK;

   465

		BringWindowToFront(w);

   466

		SetWindowDirty(w);

   467

	}

   468

   469

	return w;

   470

}

   471

   472

static inline bool IsVitalWindow(const Window *w)

   473

{

   474

	WindowClass wc = w->window_class;

   475

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

   476

}

   477

   478

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

   479

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

   480

 * - Toolbar, Statusbar (always on)

   481

 * - New window, Chatbar (only if open)

   482

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

   483

 * @param w window that is put into the foreground

   484

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

   485

 */

   486

static void BringWindowToFront(const Window *w)

   487

{

   488

	Window *tempz;

   489

	Window **wz = FindWindowZPosition(w);

   490