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

#include "blitter/factory.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

		w->SetWidgetDisabledState(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

		w->SetWidgetHiddenState(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

		w->SetWidgetLoweredState(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 (w->IsWidgetLowered(i)) {

    77

			w->RaiseWidget(i);

    78

			InvalidateWidget(w, i);

    79

		}

    80

	}

    81

}

    82

    83

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

    84

{

    85

	va_list wdg_list;

    86

    87

	va_start(wdg_list, widgets);

    88

    89

	while (widgets != WIDGET_LIST_END) {

    90

		SetWidgetDisabledState(widgets, disab_stat);

    91

		widgets = va_arg(wdg_list, int);

    92

	}

    93

    94

	va_end(wdg_list);

    95

}

    96

    97

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

    98

{

    99

	va_list wdg_list;

   100

   101

	va_start(wdg_list, widgets);

   102

   103

	while (widgets != WIDGET_LIST_END) {

   104

		SetWidgetHiddenState(widgets, hidden_stat);

   105

		widgets = va_arg(wdg_list, int);

   106

	}

   107

   108

	va_end(wdg_list);

   109

}

   110

   111

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

   112

{

   113

	va_list wdg_list;

   114

   115

	va_start(wdg_list, widgets);

   116

   117

	while (widgets != WIDGET_LIST_END) {

   118

		SetWidgetLoweredState(widgets, lowered_stat);

   119

		widgets = va_arg(wdg_list, int);

   120

	}

   121

   122

	va_end(wdg_list);

   123

}

   124

   125

void Window::RaiseButtons()

   126

{

   127

	uint i;

   128

   129

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

   130

		if (IsWidgetLowered(i)) {

   131

			RaiseWidget(i);

   132

			InvalidateWidget(i);

   133

		}

   134

	}

   135

}

   136

   137

void Window::InvalidateWidget(byte widget_index)

   138

{

   139

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

   140

   141

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

   142

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

   143

   144

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

   145

}

   146

   147

void HandleButtonClick(Window *w, byte widget)

   148

{

   149

	w->LowerWidget(widget);

   150

	w->flags4 |= 5 << WF_TIMEOUT_SHL;

   151

	InvalidateWidget(w, widget);

   152

}

   153

   154

   155

static void StartWindowDrag(Window *w);

   156

static void StartWindowSizing(Window *w);

   157

   158

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

   159

{

   160

	WindowEvent e;

   161

	const Widget *wi;

   162

   163

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

   164

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

   165

	e.event = double_click ? WE_DOUBLE_CLICK : WE_CLICK;

   166

   167

	if (w->desc_flags & WDF_DEF_WIDGET) {

   168

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

   169

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

   170

   171

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

   172

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

   173

   174

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

   175

   176

		if (wi->type & WWB_MASK) {

   177

			/* special widget handling for buttons*/

   178

			switch (wi->type) {

   179

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   180

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   181

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   182

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

   183

					break;

   184

			}

   185

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

   186

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

   187

		}

   188

   189

		if (w->desc_flags & WDF_STD_BTN) {

   190

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

   191

				DeleteWindow(w);

   192

				return;

   193

			}

   194

   195

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

   196

				StartWindowDrag(w);

   197

				return;

   198

			}

   199

		}

   200

   201

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

   202

			StartWindowSizing(w);

   203

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

   204

			return;

   205

		}

   206

   207

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

   208

			w->flags4 ^= WF_STICKY;

   209

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

   210

			return;

   211

		}

   212

	}

   213

   214

	w->wndproc(w, &e);

   215

}

   216

   217

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

   218

{

   219

	WindowEvent e;

   220

   221

	/* default tooltips handler? */

   222

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   223

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

   224

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

   225

			return; // exit if clicked outside of widgets

   226

   227

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

   228

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

   229

			return;

   230

		}

   231

	}

   232

   233

	e.event = WE_RCLICK;

   234

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

   235

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

   236

	w->wndproc(w, &e);

   237

}

   238

   239

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

   240

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

   241

 * @param *w Window

   242

 * @param widget the widget where the scrollwheel was used

   243

 * @param wheel scroll up or down

   244

 */

   245

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

   246

{

   247

	const Widget *wi1, *wi2;

   248

	Scrollbar *sb;

   249

   250

	if (widget < 0) return;

   251

   252

	wi1 = &w->widget[widget];

   253

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

   254

   255

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

   256

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

   257

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

   258

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

   259

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

   260

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

   261

   262

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

   263

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

   264

			if (pos != sb->pos) {

   265

				sb->pos = pos;

   266

				SetWindowDirty(w);

   267

			}

   268

		}

   269

	}

   270

}

   271

   272

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

   273

   274

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

   275

{

   276

	Window* const *wz;

   277

	DrawPixelInfo bk;

   278

	_cur_dpi = &bk;

   279

   280

	FOR_ALL_WINDOWS(wz) {

   281

		const Window *w = *wz;

   282

		if (right > w->left &&

   283

				bottom > w->top &&

   284

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

   285

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

   286

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

   287

		}

   288

	}

   289

}

   290

   291

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

   292

{

   293

	Window* const *vz = wz;

   294

	int x;

   295

   296

	while (++vz != _last_z_window) {

   297

		const Window *v = *vz;

   298

   299

		if (right > v->left &&

   300

				bottom > v->top &&

   301

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

   302

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

   303

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

   304

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

   305

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

   306

				return;

   307

			}

   308

   309

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

   310

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

   311

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

   312

				return;

   313

			}

   314

   315

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

   316

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

   317

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

   318

				return;

   319

			}

   320

   321

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

   322

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

   323

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

   324

				return;

   325

			}

   326

   327

			return;

   328

		}

   329

	}

   330

   331

	{

   332

		DrawPixelInfo *dp = _cur_dpi;

   333

		dp->width = right - left;

   334

		dp->height = bottom - top;

   335

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

   336

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

   337

		dp->pitch = _screen.pitch;

   338

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

   339

		dp->zoom = ZOOM_LVL_NORMAL;

   340

		CallWindowEventNP(*wz, WE_PAINT);

   341

	}

   342

}

   343

   344

void CallWindowEventNP(Window *w, int event)

   345

{

   346

	WindowEvent e;

   347

   348

	e.event = event;

   349

	w->wndproc(w, &e);

   350

}

   351

   352

void SetWindowDirty(const Window *w)

   353

{

   354

	if (w == NULL) return;

   355

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

   356

}

   357

   358

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

   359

 * @param w parent Window to find child of

   360

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

   361

static Window *FindChildWindow(const Window *w)

   362

{

   363

	Window* const *wz;

   364

   365

	FOR_ALL_WINDOWS(wz) {

   366

		Window *v = *wz;

   367

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

   368

	}

   369

   370

	return NULL;

   371

}

   372

   373

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

   374

 * or the behaviour is undefined but function should never fail

   375

 * @param w window to query Z Position

   376

 * @return the window that matches it */

   377

Window **FindWindowZPosition(const Window *w)

   378

{

   379

	Window **wz;

   380

   381

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

   382

		if (*wz == w) return wz;

   383

	}

   384

   385

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

   386

		w->window_class, w->window_number);

   387

	return NULL;

   388

}

   389

   390

void DeleteWindow(Window *w)

   391

{

   392

	Window *v;

   393

	Window **wz;

   394

	if (w == NULL) return;

   395

   396

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

   397

	v = FindChildWindow(w);

   398

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

   399

   400

	if (_thd.place_mode != VHM_NONE &&

   401

			_thd.window_class == w->window_class &&

   402

			_thd.window_number == w->window_number) {

   403

		ResetObjectToPlace();

   404

	}

   405

   406

	CallWindowEventNP(w, WE_DESTROY);

   407

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

   408

   409

	SetWindowDirty(w);

   410

	free(w->widget);

   411

	w->widget = NULL;

   412

	w->widget_count = 0;

   413

	w->parent = NULL;

   414

   415

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

   416

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

   417

	wz = FindWindowZPosition(w);

   418

	if (wz == NULL) return;

   419

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

   420

	_last_z_window--;

   421

}

   422

   423

Window *FindWindowById(WindowClass cls, WindowNumber number)

   424

{

   425

	Window* const *wz;

   426

   427

	FOR_ALL_WINDOWS(wz) {

   428

		Window *w = *wz;

   429

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

   430

	}

   431

   432

	return NULL;

   433

}

   434

   435

void DeleteWindowById(WindowClass cls, WindowNumber number)

   436

{

   437

	DeleteWindow(FindWindowById(cls, number));

   438

}

   439

   440

void DeleteWindowByClass(WindowClass cls)

   441

{

   442

	Window* const *wz;

   443

   444

restart_search:

   445

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

   446

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

   447

	 * anywhere in the z-array */

   448

	FOR_ALL_WINDOWS(wz) {

   449

		Window *w = *wz;

   450

		if (w->window_class == cls) {

   451

			DeleteWindow(w);

   452

			goto restart_search;

   453

		}

   454

	}

   455

}

   456

   457

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

   458

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

   459

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

   460

 * @param id PlayerID player identifier */

   461

void DeletePlayerWindows(PlayerID id)

   462

{

   463

	Window* const *wz;

   464

   465

restart_search:

   466

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

   467

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

   468

	 * anywhere in the z-array */

   469

	FOR_ALL_WINDOWS(wz) {

   470

		Window *w = *wz;

   471

		if (w->caption_color == id) {

   472

			DeleteWindow(w);

   473

			goto restart_search;

   474

		}

   475

	}

   476

   477

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

   478

	DeleteWindowById(WC_BUY_COMPANY, id);

   479

}

   480

   481

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

   482

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

   483

 * that need to be deleted once takeover is complete

   484

 * @param old_player PlayerID of original owner of the window

   485

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

   486

void ChangeWindowOwner(PlayerID old_player, PlayerID new_player)

   487

{

   488

	Window* const *wz;

   489

   490

	FOR_ALL_WINDOWS(wz) {