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

    10

#include "gfx_func.h"

    11

#include "console.h"

    12

#include "viewport_func.h"

    13

#include "variables.h"

    14

#include "genworld.h"

    15

#include "blitter/factory.hpp"

    16

#include "window_gui.h"

    17

#include "zoom_func.h"

    18

#include "core/alloc_func.hpp"

    19

#include "map_func.h"

    20

#include "vehicle_base.h"

    21

#include "settings_type.h"

    22

    23

#include "table/sprites.h"

    24

    26

static Point _drag_delta;

    27

    28

static Window _windows[MAX_NUMBER_OF_WINDOWS];

    35

Window *_z_windows[lengthof(_windows)];

    36

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

    37

    38

Point _cursorpos_drag_start;

    39

    40

int _scrollbar_start_pos;

    41

int _scrollbar_size;

    42

byte _scroller_click_timeout;

    43

    44

bool _scrolling_scrollbar;

    45

bool _scrolling_viewport;

    46

bool _popup_menu_active;

    47

    48

byte _special_mouse_mode;

    49

    50

    51

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

    52

{

    53

	va_list wdg_list;

    54

    55

	va_start(wdg_list, widgets);

    56

    57

	while (widgets != WIDGET_LIST_END) {

    58

		SetWidgetDisabledState(widgets, disab_stat);

    59

		widgets = va_arg(wdg_list, int);

    60

	}

    61

    62

	va_end(wdg_list);

    63

}

    64

    65

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

    66

{

    67

	va_list wdg_list;

    68

    69

	va_start(wdg_list, widgets);

    70

    71

	while (widgets != WIDGET_LIST_END) {

    72

		SetWidgetHiddenState(widgets, hidden_stat);

    73

		widgets = va_arg(wdg_list, int);

    74

	}

    75

    76

	va_end(wdg_list);

    77

}

    78

    79

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

    80

{

    81

	va_list wdg_list;

    82

    83

	va_start(wdg_list, widgets);

    84

    85

	while (widgets != WIDGET_LIST_END) {

    86

		SetWidgetLoweredState(widgets, lowered_stat);

    87

		widgets = va_arg(wdg_list, int);

    88

	}

    89

    90

	va_end(wdg_list);

    91

}

    92

    93

void Window::RaiseButtons()

    94

{

    95

	uint i;

    96

    97

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

    98

		if (this->IsWidgetLowered(i)) {

    99

			this->RaiseWidget(i);

   100

			this->InvalidateWidget(i);

   101

		}

   102

	}

   103

}

   104

   105

void Window::InvalidateWidget(byte widget_index) const

   106

{

   107

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

   108

   109

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

   110

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

   111

   112

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

   113

}

   114

   115

void Window::HandleButtonClick(byte widget)

   116

{

   117

	this->LowerWidget(widget);

   118

	this->flags4 |= 5 << WF_TIMEOUT_SHL;

   119

	this->InvalidateWidget(widget);

   120

}

   121

   122

static void StartWindowDrag(Window *w);

   123

static void StartWindowSizing(Window *w);

   124

   132

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

   133

{

   134

	WindowEvent e;

   135

	const Widget *wi;

   136

   137

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

   138

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

   139

	e.event = double_click ? WE_DOUBLE_CLICK : WE_CLICK;

   140

   141

	if (w->desc_flags & WDF_DEF_WIDGET) {

   142

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

   143

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

   144

   145

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

   146

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

   147

   148

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

   149

   150

		if (wi->type & WWB_MASK) {

   151

			/* special widget handling for buttons*/

   152

			switch (wi->type) {

   153

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   154

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   155

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   156

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

   157

					break;

   158

			}

   159

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

   160

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

   161

		}

   162

   163

		if (w->desc_flags & WDF_STD_BTN) {

   164

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

   165

				DeleteWindow(w);

   166

				return;

   167

			}

   168

   169

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

   170

				StartWindowDrag(w);

   171

				return;

   172

			}

   173

		}

   174

   175

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

   176

			StartWindowSizing(w);

   177

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

   178

			return;

   179

		}

   180

   181

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

   182

			w->flags4 ^= WF_STICKY;

   183

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

   184

			return;

   185

		}

   186

	}

   187

   188

	w->wndproc(w, &e);

   189

}

   190

   197

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

   198

{

   199

	WindowEvent e;

   200

   201

	/* default tooltips handler? */

   202

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   203

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

   204

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

   205

			return; // exit if clicked outside of widgets

   206

   207

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

   208

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

   209

			return;

   210

		}

   211

	}

   212

   213

	e.event = WE_RCLICK;

   214

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

   215

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

   216

	w->wndproc(w, &e);

   217

}

   218

   223

 * @param widget the widget where the scrollwheel was used

   224

 * @param wheel scroll up or down

   225

 */

   226

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

   227

{

   228

	const Widget *wi1, *wi2;

   229

	Scrollbar *sb;

   230

   231

	if (widget < 0) return;

   232

   233

	wi1 = &w->widget[widget];

   234

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

   235

   236

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

   237

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

   238

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

   239

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

   240

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

   241

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

   242

   243

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

   244

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

   245

			if (pos != sb->pos) {

   246

				sb->pos = pos;

   247

				SetWindowDirty(w);

   248

			}

   249

		}

   250

	}

   251

}

   252

   253

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

   254

   263

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

   264

{

   265

	Window* const *wz;

   266

	DrawPixelInfo bk;

   267

	_cur_dpi = &bk;

   268

   269

	FOR_ALL_WINDOWS(wz) {

   270

		const Window *w = *wz;

   271

		if (right > w->left &&

   272

				bottom > w->top &&

   273

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

   274

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

   275

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

   276

		}

   277

	}

   278

}

   279

   294

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

   295

{

   296

	Window* const *vz = wz;

   297

   298

	while (++vz != _last_z_window) {

   299

		const Window *v = *vz;

   300

   301

		if (right > v->left &&

   302

				bottom > v->top &&

   303

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

   304

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

   308

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

   309

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

   310

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

   311

				return;

   312

			}

   313

   314

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

   315

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

   316

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

   317

				return;

   318

			}

   319

   320

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

   321

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

   322

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

   323

				return;

   324

			}

   325

   326

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

   327

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

   328

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

   329

				return;

   330

			}

   331

   332

			return;

   333

		}

   334

	}

   335

   336

	{

   337

		DrawPixelInfo *dp = _cur_dpi;

   338

		dp->width = right - left;

   339

		dp->height = bottom - top;

   340

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

   341

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

   342

		dp->pitch = _screen.pitch;

   343

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

   344

		dp->zoom = ZOOM_LVL_NORMAL;

   345

		CallWindowEventNP(*wz, WE_PAINT);

   346

	}

   347

}

   348

   355

void CallWindowEventNP(Window *w, int event)

   356

{

   357

	WindowEvent e;

   358

   359

	e.event = event;

   360

	w->wndproc(w, &e);

   361

}

   362

   368

void SetWindowDirty(const Window *w)

   369

{

   370

	if (w == NULL) return;

   371

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

   372

}

   373

   374

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

   375

 * @param w parent Window to find child of

   376

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

   377

static Window *FindChildWindow(const Window *w)

   378

{

   379

	Window* const *wz;

   380

   381

	FOR_ALL_WINDOWS(wz) {

   382

		Window *v = *wz;

   383

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

   384

	}

   385

   386

	return NULL;

   387

}

   388

   389

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

   390

 * or the behaviour is undefined but function should never fail

   391

 * @param w window to query Z Position

   394

Window **FindWindowZPosition(const Window *w)

   395

{

   396

	Window **wz;

   397

   399

		if (*wz == w) return wz;

   400

	}

   401

   402

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

   403

		w->window_class, w->window_number);

   404

	return NULL;

   405

}

   406

   410

void DeleteWindow(Window *w)

   411

{

   412

	if (w == NULL) return;

   413

   414

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

   416

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

   417

   418

	if (_thd.place_mode != VHM_NONE &&

   419

			_thd.window_class == w->window_class &&

   420

			_thd.window_number == w->window_number) {

   421

		ResetObjectToPlace();

   422

	}

   423

   424

	CallWindowEventNP(w, WE_DESTROY);

   425

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

   426

   427

	SetWindowDirty(w);

   428

	free(w->widget);

   429

	w->widget = NULL;

   430

	w->widget_count = 0;

   431

	w->parent = NULL;

   432

   433

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

   434

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

   436

	if (wz == NULL) return;

   437

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

   438

	_last_z_window--;

   439

}

   440

   447

Window *FindWindowById(WindowClass cls, WindowNumber number)

   448

{

   449

	Window* const *wz;

   450

   451

	FOR_ALL_WINDOWS(wz) {

   452

		Window *w = *wz;

   453

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

   454

	}

   455

   456

	return NULL;

   457

}

   458

   464

void DeleteWindowById(WindowClass cls, WindowNumber number)

   465

{

   466

	DeleteWindow(FindWindowById(cls, number));

   467

}

   468

   473

void DeleteWindowByClass(WindowClass cls)

   474

{

   475

	Window* const *wz;

   476

   477

restart_search:

   478

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

   479

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

   480

	 * anywhere in the z-array */

   481

	FOR_ALL_WINDOWS(wz) {

   482

		Window *w = *wz;

   483

		if (w->window_class == cls) {

   484

			DeleteWindow(w);

   485

			goto restart_search;

   486

		}

   487

	}

   488

}

   489