1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include <stdarg.h>

     5

#include "openttd.h"

     6

#include "debug.h"

     7

#include "functions.h"

     8

#include "map.h"

     9

#include "player.h"

    10

#include "window.h"

    11

#include "gfx.h"

    12

#include "viewport.h"

    13

#include "console.h"

    14

#include "variables.h"

    15

#include "table/sprites.h"

    16

#include "genworld.h"

    17

    18

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

    19

static Point _drag_delta;

    20

    21

static Window _windows[25];

    22

Window *_z_windows[lengthof(_windows)];

    23

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

    24

    25

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

    26

{

    27

	va_list wdg_list;

    28

    29

	va_start(wdg_list, widgets);

    30

    31

	while (widgets != WIDGET_LIST_END) {

    32

		SetWindowWidgetDisabledState(w, widgets, disab_stat);

    33

		widgets = va_arg(wdg_list, int);

    34

	}

    35

    36

	va_end(wdg_list);

    37

}

    38

    39

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

    40

{

    41

	va_list wdg_list;

    42

    43

	va_start(wdg_list, widgets);

    44

    45

	while (widgets != WIDGET_LIST_END) {

    46

		SetWindowWidgetHiddenState(w, widgets, hidden_stat);

    47

		widgets = va_arg(wdg_list, int);

    48

	}

    49

    50

	va_end(wdg_list);

    51

}

    52

    53

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

    54

{

    55

	va_list wdg_list;

    56

    57

	va_start(wdg_list, widgets);

    58

    59

	while (widgets != WIDGET_LIST_END) {

    60

		SetWindowWidgetLoweredState(w, widgets, lowered_stat);

    61

		widgets = va_arg(wdg_list, int);

    62

	}

    63

    64

	va_end(wdg_list);

    65

}

    66

    67

void RaiseWindowButtons(Window *w)

    68

{

    69

	uint i;

    70

    71

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

    72

		if (IsWindowWidgetLowered(w, i)) {

    73

			RaiseWindowWidget(w, i);

    74

			InvalidateWidget(w, i);

    75

		}

    76

	}

    77

}

    78

    79

void HandleButtonClick(Window *w, byte widget)

    80

{

    81

	LowerWindowWidget(w, widget);

    82

	w->flags4 |= 5 << WF_TIMEOUT_SHL;

    83

	InvalidateWidget(w, widget);

    84

}

    85

    86

    87

static void StartWindowDrag(Window *w);

    88

static void StartWindowSizing(Window *w);

    89

    90

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

    91

{

    92

	WindowEvent e;

    93

	const Widget *wi;

    94

    95

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

    96

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

    97

	e.event = WE_CLICK;

    98

    99

	if (w->desc_flags & WDF_DEF_WIDGET) {

   100

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

   101

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

   102

   103

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

   104

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

   105

   106

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

   107

   108

		if (wi->type & WWB_MASK) {

   109

			/* special widget handling for buttons*/

   110

			switch (wi->type) {

   111

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   112

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   113

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   114

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

   115

					break;

   116

			}

   117

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

   118

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

   119

		}

   120

   121

		if (w->desc_flags & WDF_STD_BTN) {

   122

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

   123

				DeleteWindow(w);

   124

				return;

   125

			}

   126

   127

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

   128

				StartWindowDrag(w);

   129

				return;

   130

			}

   131

		}

   132

   133

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

   134

			StartWindowSizing(w);

   135

			return;

   136

		}

   137

   138

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

   139

			w->flags4 ^= WF_STICKY;

   140

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

   141

			return;

   142

		}

   143

	}

   144

   145

	w->wndproc(w, &e);

   146

}

   147

   148

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

   149

{

   150

	WindowEvent e;

   151

   152

	/* default tooltips handler? */

   153

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   154

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

   155

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

   156

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

   157

   158

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

   159

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

   160

			return;

   161

		}

   162

	}

   163

   164

	e.event = WE_RCLICK;

   165

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

   166

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

   167

	w->wndproc(w, &e);

   168

}

   169

   170

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

   171

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

   172

 * @param *w Window

   173

 * @param widget the widget where the scrollwheel was used

   174

 * @param wheel scroll up or down

   175

 */

   176

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

   177

{

   178

	const Widget *wi1, *wi2;

   179

	Scrollbar *sb;

   180

   181

	if (widget < 0) return;

   182

   183

	wi1 = &w->widget[widget];

   184

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

   185

   186

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

   187

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

   188

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

   189

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

   190

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

   191

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

   192

   193

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

   194

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

   195

			if (pos != sb->pos) {

   196

				sb->pos = pos;

   197

				SetWindowDirty(w);

   198

			}

   199

		}

   200

	}

   201

}

   202

   203

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

   204

   205

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

   206

{

   207

	Window* const *wz;

   208

	DrawPixelInfo bk;

   209

	_cur_dpi = &bk;

   210

   211

	FOR_ALL_WINDOWS(wz) {

   212

		const Window *w = *wz;

   213

		if (right > w->left &&

   214

				bottom > w->top &&

   215

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

   216

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

   217

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

   218

		}

   219

	}

   220

}

   221

   222

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

   223

{

   224

	Window* const *vz = wz;

   225

	int x;

   226

   227

	while (++vz != _last_z_window) {

   228

		const Window *v = *vz;

   229

   230

		if (right > v->left &&

   231

				bottom > v->top &&

   232

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

   233

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

   234

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

   235

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

   236

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

   237

				return;

   238

			}

   239

   240

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

   241

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

   242

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

   243

				return;

   244

			}

   245

   246

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

   247

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

   248

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

   249

				return;

   250

			}

   251

   252

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

   253

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

   254

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

   255

				return;

   256

			}

   257

   258

			return;

   259

		}

   260

	}

   261

   262

	{

   263

		DrawPixelInfo *dp = _cur_dpi;

   264

		dp->width = right - left;

   265

		dp->height = bottom - top;

   266

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

   267

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

   268

		dp->pitch = _screen.pitch;

   269

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

   270

		dp->zoom = 0;

   271

		CallWindowEventNP(*wz, WE_PAINT);

   272

	}

   273

}

   274

   275

void CallWindowEventNP(Window *w, int event)

   276

{

   277

	WindowEvent e;

   278

   279

	e.event = event;

   280

	w->wndproc(w, &e);

   281

}

   282

   283

void SetWindowDirty(const Window *w)

   284

{

   285

	if (w == NULL) return;

   286

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

   287

}

   288

   289

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

   290

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

   291

Window **FindWindowZPosition(const Window *w)

   292

{

   293

	Window **wz;

   294

   295

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

   296

		assert(wz < _last_z_window);

   297

		if (*wz == w) return wz;

   298

	}

   299

}

   300

   301

void DeleteWindow(Window *w)

   302

{

   303

	Window **wz;

   304

	if (w == NULL) return;

   305

   306

	if (_thd.place_mode != VHM_NONE &&

   307

			_thd.window_class == w->window_class &&

   308

			_thd.window_number == w->window_number) {

   309

		ResetObjectToPlace();

   310

	}

   311

   312

	CallWindowEventNP(w, WE_DESTROY);

   313

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

   314

   315

	SetWindowDirty(w);

   316

	free(w->widget);

   317

	w->widget = NULL;

   318

	w->widget_count = 0;

   319

   320

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

   321

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

   322

	wz = FindWindowZPosition(w);

   323

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

   324

	_last_z_window--;

   325

}

   326

   327

Window *FindWindowById(WindowClass cls, WindowNumber number)

   328

{

   329

	Window* const *wz;

   330

   331

	FOR_ALL_WINDOWS(wz) {

   332

		Window *w = *wz;

   333

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

   334

	}

   335

   336

	return NULL;

   337

}

   338

   339

void DeleteWindowById(WindowClass cls, WindowNumber number)

   340

{

   341

	DeleteWindow(FindWindowById(cls, number));

   342

}

   343

   344

void DeleteWindowByClass(WindowClass cls)

   345

{

   346

	Window* const *wz;

   347

   348

restart_search:

   349

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

   350

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

   351

	 * anywhere in the z-array */

   352

	FOR_ALL_WINDOWS(wz) {

   353

		Window *w = *wz;

   354

		if (w->window_class == cls) {

   355

			DeleteWindow(w);

   356

			goto restart_search;

   357

		}

   358

	}

   359

}

   360

   361

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

   362

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

   363

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

   364

 * @param id PlayerID player identifier */

   365

void DeletePlayerWindows(PlayerID id)

   366

{

   367

	Window* const *wz;

   368

   369

restart_search:

   370

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

   371

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

   372

	 * anywhere in the z-array */

   373

	FOR_ALL_WINDOWS(wz) {

   374

		Window *w = *wz;

   375

		if (w->caption_color == id) {

   376

			DeleteWindow(w);

   377

			goto restart_search;

   378

		}

   379

	}

   380

   381

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

   382

	DeleteWindowById(WC_BUY_COMPANY, id);

   383

}

   384

   385

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

   386

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

   387

 * that need to be deleted once takeover is complete

   388

 * @param old_player PlayerID of original owner of the window

   389

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

   390

void ChangeWindowOwner(PlayerID old_player, PlayerID new_player)

   391

{

   392

	Window* const *wz;

   393

   394

	FOR_ALL_WINDOWS(wz) {

   395

		Window *w = *wz;

   396

   397

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

   398

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

   399

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

   400

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

   401

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

   402

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

   403

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

   404

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

   405

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

   406

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

   407

   408

		w->caption_color = new_player;

   409

	}

   410

}

   411

   412

static void BringWindowToFront(const Window *w);

   413

   414

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

   415

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

   416

 * "activation"

   417

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

   418

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   419

{

   420

	Window *w = FindWindowById(cls, number);

   421

   422

	if (w != NULL) {

   423

		w->flags4 |= WF_WHITE_BORDER_MASK;

   424

		BringWindowToFront(w);

   425

		SetWindowDirty(w);

   426

	}

   427

   428

	return w;

   429

}

   430

   431

static inline bool IsVitalWindow(const Window *w)

   432

{

   433

	WindowClass wc = w->window_class;

   434

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

   435

}

   436

   437

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

   438

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

   439

 * - Toolbar, Statusbar (always on)

   440

 * - New window, Chatbar (only if open)

   441

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

   442

 * @param w window that is put into the foreground

   443

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

   444

 */

   445

static void BringWindowToFront(const Window *w)

   446

{

   447

	Window *tempz;

   448

	Window **wz = FindWindowZPosition(w);

   449

	Window **vz = _last_z_window;

   450

   451

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

   452

	do {

   453

		if (--vz < _z_windows) return;

   454

	} while (IsVitalWindow(*vz));

   455

   456

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

   457

	assert(wz < vz);

   458

   459

	tempz = *wz;

   460

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

   461

	*vz = tempz;

   462

   463

	SetWindowDirty(w);

   464

}

   465

   466

/** We have run out of windows, so find a suitable candidate for replacement.

   467

 * Keep all important windows intact. These are

   468

 * - Main window (gamefield), Toolbar, Statusbar (always on)

   469

 * - News window, Chatbar (when on)

   470

 * - Any sticked windows since we wanted to keep these

   471

 * @return w pointer to the window that is going to be deleted

   472

 */

   473

static Window *FindDeletableWindow(void)

   474

{

   475

	Window* const *wz;

   476

   477

	FOR_ALL_WINDOWS(wz) {

   478

		Window *w = *wz;

   479

		if (w->window_class != WC_MAIN_WINDOW && !IsVitalWindow(w) && !(w->flags4 & WF_STICKY)) {

   480

			return w;

   481

		}

   482

	}

   483

	return NULL;

   484

}

   485

   486

/** A window must be freed, and all are marked as important windows. Ease the

   487

 * restriction a bit by allowing to delete sticky windows. Keep important/vital

   488

 * windows intact (Main window, Toolbar, Statusbar, News Window, Chatbar)

   489

 * Start finding an appropiate candidate from the lowest z-values (bottom)

   490

 * @see FindDeletableWindow()

   491

 * @return w Pointer to the window that is being deleted

   492