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

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

    22

{

    23

	va_list wdg_list;

    24

    25

	va_start(wdg_list, widgets);

    26

    27

	while (widgets != WIDGET_LIST_END) {

    28

		SetWindowWidgetDisabledState(w, widgets, disab_stat);

    29

		widgets = va_arg(wdg_list, int);

    30

	}

    31

    32

	va_end(wdg_list);

    33

}

    34

    35

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

    36

{

    37

	va_list wdg_list;

    38

    39

	va_start(wdg_list, widgets);

    40

    41

	while (widgets != WIDGET_LIST_END) {

    42

		SetWindowWidgetHiddenState(w, widgets, hidden_stat);

    43

		widgets = va_arg(wdg_list, int);

    44

	}

    45

    46

	va_end(wdg_list);

    47

}

    48

    49

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

    50

{

    51

	va_list wdg_list;

    52

    53

	va_start(wdg_list, widgets);

    54

    55

	while (widgets != WIDGET_LIST_END) {

    56

		SetWindowWidgetLoweredState(w, widgets, lowered_stat);

    57

		widgets = va_arg(wdg_list, int);

    58

	}

    59

    60

	va_end(wdg_list);

    61

}

    62

    63

void RaiseWindowButtons(Window *w)

    64

{

    65

	const Widget *wi = w->widget;

    66

	uint i = 0;

    67

    68

	for (i = 0; wi->type != WWT_LAST; i++, wi++) {

    69

		if (IsWindowWidgetLowered(w, i)) {

    70

			RaiseWindowWidget(w, i);

    71

			InvalidateWidget(w, i);

    72

		}

    73

	}

    74

}

    75

    76

void HandleButtonClick(Window *w, byte widget)

    77

{

    78

	LowerWindowWidget(w, widget);

    79

	w->flags4 |= 5 << WF_TIMEOUT_SHL;

    80

	InvalidateWidget(w, widget);

    81

}

    82

    83

    84

static Window *StartWindowDrag(Window *w);

    85

static Window *StartWindowSizing(Window *w);

    86

    87

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

    88

{

    89

	WindowEvent e;

    90

	const Widget *wi;

    91

    92

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

    93

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

    94

	e.event = WE_CLICK;

    95

    96

	if (w->desc_flags & WDF_DEF_WIDGET) {

    97

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

    98

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

    99

   100

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

   101

   102

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

   103

		if (IsWidgetDisabled(wi)) return;

   104

   105

		if (wi->type & WWB_MASK) {

   106

			/* special widget handling for buttons*/

   107

			switch (wi->type) {

   108

				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   109

				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   110

				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   111

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

   112

					break;

   113

			}

   114

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

   115

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

   116

		}

   117

   118

		if (w->desc_flags & WDF_STD_BTN) {

   119

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

   120

				DeleteWindow(w);

   121

				return;

   122

			}

   123

   124

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

   125

				StartWindowDrag(w); // if not return then w = StartWindowDrag(w); to get correct pointer

   126

				return;

   127

			}

   128

		}

   129

   130

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

   131

			StartWindowSizing(w); // if not return then w = StartWindowSizing(w); to get correct pointer

   132

			return;

   133

		}

   134

   135

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

   136

			w->flags4 ^= WF_STICKY;

   137

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

   138

			return;

   139

		}

   140

	}

   141

   142

	w->wndproc(w, &e);

   143

}

   144

   145

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

   146

{

   147

	WindowEvent e;

   148

   149

	/* default tooltips handler? */

   150

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   151

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

   152

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

   153

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

   154

   155

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

   156

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

   157

			return;

   158

		}

   159

	}

   160

   161

	e.event = WE_RCLICK;

   162

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

   163

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

   164

	w->wndproc(w, &e);

   165

}

   166

   167

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

   168

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

   169

 * @param *w Window

   170

 * @param widget the widget where the scrollwheel was used

   171

 * @param wheel scroll up or down

   172

 */

   173

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

   174

{

   175

	const Widget *wi1, *wi2;

   176

	Scrollbar *sb;

   177

   178

	if (widget < 0) return;

   179

   180

	wi1 = &w->widget[widget];

   181

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

   182

   183

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

   184

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

   185

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

   186

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

   187

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

   188

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

   189

   190

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

   191

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

   192

			if (pos != sb->pos) {

   193

				sb->pos = pos;

   194

				SetWindowDirty(w);

   195

			}

   196

		}

   197

	}

   198

}

   199

   200

   201

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

   202

   203

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

   204

{

   205

	Window *w;

   206

	DrawPixelInfo bk;

   207

	_cur_dpi = &bk;

   208

   209

	for (w = _windows; w != _last_window; w++) {

   210

		if (right > w->left &&

   211

				bottom > w->top &&

   212

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

   213

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

   214

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

   215

		}

   216

	}

   217

}

   218

   219

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

   220

{

   221

	const Window *v = w;

   222

	int x;

   223

   224

	while (++v != _last_window) {

   225

		if (right > v->left &&

   226

				bottom > v->top &&

   227

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

   228

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

   229

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

   230

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

   231

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

   232

				return;

   233

			}

   234

   235

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

   236

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

   237

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

   238

				return;

   239

			}

   240

   241

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

   242

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

   243

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

   244

				return;

   245

			}

   246

   247

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

   248

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

   249

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

   250

				return;

   251

			}

   252

   253

			return;

   254

		}

   255

	}

   256

   257

	{

   258

		DrawPixelInfo *dp = _cur_dpi;

   259

		dp->width = right - left;

   260

		dp->height = bottom - top;

   261

		dp->left = left - w->left;

   262

		dp->top = top - w->top;

   263

		dp->pitch = _screen.pitch;

   264

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

   265

		dp->zoom = 0;

   266

		CallWindowEventNP(w, WE_PAINT);

   267

	}

   268

}

   269

   270

void CallWindowEventNP(Window *w, int event)

   271

{

   272

	WindowEvent e;

   273

   274

	e.event = event;

   275

	w->wndproc(w, &e);

   276

}

   277

   278

void SetWindowDirty(const Window *w)

   279

{

   280

	if (w == NULL) return;

   281

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

   282

}

   283

   284

void DeleteWindow(Window *w)

   285

{

   286

	WindowClass wc;

   287

	WindowNumber wn;

   288

	Window *v;

   289

	int count;

   290

   291

	if (w == NULL) return;

   292

   293

	if (_thd.place_mode != VHM_NONE &&

   294

			_thd.window_class == w->window_class &&

   295

			_thd.window_number == w->window_number) {

   296

		ResetObjectToPlace();

   297

	}

   298

   299

	wc = w->window_class;

   300

	wn = w->window_number;

   301

   302

	CallWindowEventNP(w, WE_DESTROY);

   303

   304

	w = FindWindowById(wc, wn);

   305

   306

	if (w->viewport != NULL) {

   307

		CLRBIT(_active_viewports, w->viewport - _viewports);

   308

		w->viewport->width = 0;

   309

		w->viewport = NULL;

   310

	}

   311

   312

	SetWindowDirty(w);

   313

   314

	free(w->widget);

   315

   316

	v = --_last_window;

   317

	count = (byte*)v - (byte*)w;

   318

	memmove(w, w + 1, count);

   319

}

   320

   321

Window *FindWindowById(WindowClass cls, WindowNumber number)

   322

{

   323

	Window *w;

   324

   325

	for (w = _windows; w != _last_window; w++) {

   326

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

   327

	}

   328

   329

	return NULL;

   330

}

   331

   332

void DeleteWindowById(WindowClass cls, WindowNumber number)

   333

{

   334

	DeleteWindow(FindWindowById(cls, number));

   335

}

   336

   337

void DeleteWindowByClass(WindowClass cls)

   338

{

   339

	Window *w;

   340

   341

	for (w = _windows; w != _last_window;) {

   342

		if (w->window_class == cls) {

   343

			DeleteWindow(w);

   344

			w = _windows;

   345

		} else {

   346

			w++;

   347

		}

   348

	}

   349

}

   350

   351

   352

static Window *BringWindowToFront(Window *w);

   353

   354

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   355

{

   356

	Window *w = FindWindowById(cls, number);

   357

   358

	if (w != NULL) {

   359

		w->flags4 |= WF_WHITE_BORDER_MASK;

   360

		SetWindowDirty(w);

   361

		w = BringWindowToFront(w);

   362

	}

   363

   364

	return w;

   365

}

   366

   367

static inline bool IsVitalWindow(const Window *w)

   368

{

   369

	WindowClass wc = w->window_class;

   370

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

   371

}

   372

   373

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

   374

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

   375

 * - Toolbar, Statusbar (always on)

   376

 * - New window, Chatbar (only if open)

   377

 * @param w window that is put into the foreground

   378

 */

   379

static Window *BringWindowToFront(Window *w)

   380

{

   381

	Window *v;

   382

	Window temp;

   383

   384

	v = _last_window;

   385

	do {

   386

		if (--v < _windows) return w;

   387

	} while (IsVitalWindow(v));

   388

   389

	if (w == v) return w;

   390

   391

	assert(w < v);

   392

   393

	temp = *w;

   394

	memmove(w, w + 1, (v - w) * sizeof(Window));

   395

	*v = temp;

   396

   397

	SetWindowDirty(v);

   398

   399

	return v;

   400

}

   401

   402

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

   403

 * Keep all important windows intact. These are

   404

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

   405

 * - News window, Chatbar (when on)

   406

 * - Any sticked windows since we wanted to keep these

   407

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

   408

 */

   409

static Window *FindDeletableWindow(void)

   410

{

   411

	Window *w;

   412

   413

	for (w = _windows; w < endof(_windows); w++) {

   414

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

   415

			return w;

   416

		}

   417

	}

   418

	return NULL;

   419

}

   420

   421

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

   422

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

   423

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

   424

 * @see FindDeletableWindow()

   425

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

   426

 */

   427

static Window *ForceFindDeletableWindow(void)

   428

{

   429

	Window *w;

   430

   431

	for (w = _windows;; w++) {

   432

		assert(w < _last_window);

   433

		if (w->window_class != WC_MAIN_WINDOW && !IsVitalWindow(w)) return w;

   434

	}

   435

}

   436

   437

bool IsWindowOfPrototype(const Window *w, const Widget *widget)

   438

{

   439

	return (w->original_widget == widget);

   440

}

   441

   442

/* Copies 'widget' to 'w->widget' to allow for resizable windows */

   443

void AssignWidgetToWindow(Window *w, const Widget *widget)

   444

{

   445

	w->original_widget = widget;

   446

   447

	if (widget != NULL) {

   448

		uint index = 1;

   449

		const Widget *wi;

   450

   451

		for (wi = widget; wi->type != WWT_LAST; wi++) index++;

   452

   453

		w->widget = realloc(w->widget, sizeof(*w->widget) * index);

   454

		memcpy(w->widget, widget, sizeof(*w->widget) * index);

   455

	} else {

   456

		w->widget = NULL;

   457

	}

   458

}

   459

   460

/* Open a new window.

   461

 * This function is called from AllocateWindow() or AllocateWindowDesc()

   462

 * See descriptions for those functions for usage

   463

 * See AllocateWindow() for description of arguments.

   464

 * Only addition here is window_number, which is the window_number being assigned to the new window

   465

 */

   466

static Window *LocalAllocateWindow(

   467

							int x, int y, int width, int height,

   468

							WindowProc *proc, WindowClass cls, const Widget *widget, int window_number)

   469

{

   470

	Window *w = _last_window; // last window keeps track of the highest open window

   471

   472

	// We have run out of windows, close one and use that as the place for our new one

   473

	if (w >= endof(_windows)) {

   474

		w = FindDeletableWindow();

   475

   476

		if (w == NULL) w = ForceFindDeletableWindow();

   477

   478

		DeleteWindow(w);

   479

		w = _last_window;

   480

	}

   481

   482

	/* XXX - This very strange construction makes sure that the chatbar is always

   483

	 * on top of other windows. Why? It is created as last_window (so, on top).

   484

	 * Any other window will go below toolbar/statusbar/news window, which implicitely

   485

	 * also means it is below the chatbar. Very likely needs heavy improvement

   486

	 * to de-braindeadize */

   487

	if (w != _windows && cls != WC_SEND_NETWORK_MSG) {

   488

		Window *v;

   489

   490

		/* XXX - if not this order (toolbar/statusbar and then news), game would

   491

		 * crash because it will try to copy a negative size for the news-window.

   492

		 * Eg. window was already moved BELOW news (which is below toolbar/statusbar)

   493

		 * and now needs to move below those too. That is a negative move. */

   494

		v = FindWindowById(WC_MAIN_TOOLBAR, 0);

   495

		if (v != NULL) {

   496

			memmove(v+1, v, (byte*)w - (byte*)v);