1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "map.h"

     8

#include "player.h"

     9

#include "window.h"

    10

#include "gfx.h"

    11

#include "viewport.h"

    12

#include "console.h"

    13

#include "variables.h"

    14

#include "table/sprites.h"

    15

    16

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

    17

static Point _drag_delta;

    18

    19

void HandleButtonClick(Window *w, byte widget)

    20

{

    21

	w->click_state |= (1 << widget);

    22

	w->flags4 |= 5 << WF_TIMEOUT_SHL;

    23

	InvalidateWidget(w, widget);

    24

}

    25

    26

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

    27

{

    28

	WindowEvent e;

    29

	const Widget *wi;

    30

    31

	e.click.pt.x = x;

    32

	e.click.pt.y = y;

    33

	e.event = WE_CLICK;

    34

    35

	if (w->desc_flags & WDF_DEF_WIDGET) {

    36

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

    37

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

    38

    39

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

    40

    41

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

    42

		if (HASBIT(w->disabled_state, e.click.widget))

    43

			return;

    44

    45

		if (wi->type & 0xE0) {

    46

			/* special widget handling for buttons*/

    47

			switch(wi->type) {

    48

			case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

    49

			case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

    50

				HandleButtonClick(w, e.click.widget);

    51

				break;

    52

			case WWT_NODISTXTBTN:

    53

				break;

    54

			}

    55

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

    56

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

    57

		}

    58

    59

		if (w->desc_flags & WDF_STD_BTN) {

    60

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

    61

				DeleteWindow(w);

    62

				return;

    63

			}

    64

    65

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

    66

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

    67

				return;

    68

			}

    69

		}

    70

    71

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

    72

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

    73

			return;

    74

		}

    75

    76

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

    77

			TOGGLEBIT(w->click_state, e.click.widget);

    78

			w->flags4 ^= WF_STICKY;

    79

			InvalidateWidget(w, e.click.widget);

    80

			return;

    81

		}

    82

	}

    83

    84

	w->wndproc(w, &e);

    85

}

    86

    87

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

    88

{

    89

	WindowEvent e;

    90

    91

	/* default tooltips handler? */

    92

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

    93

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

    94

		if (e.click.widget < 0)

    95

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

    96

    97

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

    98

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

    99

			return;

   100

		}

   101

	}

   102

   103

	e.event = WE_RCLICK;

   104

	e.click.pt.x = x;

   105

	e.click.pt.y = y;

   106

	w->wndproc(w, &e);

   107

}

   108

   109

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

   110

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

   111

 * @param *w Window

   112

 * @param widget the widget where the scrollwheel was used

   113

 * @param wheel scroll up or down

   114

 */

   115

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

   116

{

   117

	const Widget *wi1, *wi2;

   118

	Scrollbar *sb;

   119

   120

	if (widget < 0) return;

   121

   122

	wi1 = &w->widget[widget];

   123

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

   124

   125

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

   126

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

   127

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

   128

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

   129

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

   130

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

   131

   132

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

   133

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

   134

			if (pos != sb->pos) {

   135

				sb->pos = pos;

   136

				SetWindowDirty(w);

   137

			}

   138

		}

   139

	}

   140

}

   141

   142

   143

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

   144

{

   145

	Window *w;

   146

	DrawPixelInfo bk;

   147

	_cur_dpi = &bk;

   148

   149

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

   150

		if (right > w->left &&

   151

				bottom > w->top &&

   152

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

   153

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

   154

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

   155

			}

   156

	}

   157

}

   158

   159

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

   160

{

   162

	int x;

   163

   164

	while (++v != _last_window) {

   165

		if (right > v->left &&

   166

				bottom > v->top &&

   167

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

   168

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

   169

   170

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

   171

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

   172

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

   173

				return;

   174

			}

   175

   176

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

   177

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

   178

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

   179

				return;

   180

			}

   181

   182

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

   183

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

   184

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

   185

				return;

   186

			}

   187

   188

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

   189

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

   190

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

   191

				return;

   192

			}

   193

   194

			return;

   195

		}

   196

	}

   197

   198

	{

   199

		DrawPixelInfo *dp = _cur_dpi;

   200

		dp->width = right - left;

   201

		dp->height = bottom - top;

   202

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

   203

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

   204

		dp->pitch = _screen.pitch;

   205

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

   206

		dp->zoom = 0;

   207

		CallWindowEventNP(w, WE_PAINT);

   208

	}

   209

}

   210

   211

void CallWindowEventNP(Window *w, int event)

   212

{

   213

	WindowEvent e;

   214

   215

	e.event = event;

   216

	w->wndproc(w, &e);

   217

}

   218

   219

void SetWindowDirty(const Window* w)

   220

{

   221

	if (w == NULL) return;

   222

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

   223

}

   224

   225

void DeleteWindow(Window *w)

   226

{

   227

	WindowClass wc;

   228

	WindowNumber wn;

   229

	ViewPort *vp;

   230

	Window *v;

   231

	int count;

   232

   233

	if (w == NULL)

   234

		return;

   235

   236

	if (_thd.place_mode != 0 && _thd.window_class == w->window_class && _thd.window_number == w->window_number) {

   237

		ResetObjectToPlace();

   238

	}

   239

   240

	wc = w->window_class;

   241

	wn = w->window_number;

   242

   243

	CallWindowEventNP(w, WE_DESTROY);

   244

   245

	w = FindWindowById(wc, wn);

   246

   247

	vp = w->viewport;

   248

	w->viewport = NULL;

   249

	if (vp != NULL) {

   250

		_active_viewports &= ~(1 << (vp - _viewports));

   251

		vp->width = 0;

   252

	}

   253

   254

	SetWindowDirty(w);

   255

   256

	free(w->widget);

   257

   258

	v = --_last_window;

   259

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

   260

	memmove(w, w + 1, count);

   261

}

   262

   263

Window *FindWindowById(WindowClass cls, WindowNumber number)

   264

{

   265

	Window *w;

   266

   267

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

   268

		if (w->window_class == cls &&

   269

			  w->window_number == number) {

   270

			return w;

   271

		}

   272

	}

   273

   274

	return NULL;

   275

}

   276

   277

void DeleteWindowById(WindowClass cls, WindowNumber number)

   278

{

   279

	DeleteWindow(FindWindowById(cls, number));

   280

}

   281

   282

void DeleteWindowByClass(WindowClass cls)

   283

{

   284

	Window *w;

   285

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

   286

		if (w->window_class == cls) {

   287

			DeleteWindow(w);

   288

			w = _windows;

   289

		} else

   290

			w++;

   291

	}

   292

}

   293

   294

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   295

{

   296

	Window *w = FindWindowById(cls, number);

   297

   298

	if (w != NULL) {

   299

		w->flags4 |= WF_WHITE_BORDER_MASK;

   300

		SetWindowDirty(w);

   301

		w = BringWindowToFront(w);

   302

	}

   303

   304

	return w;

   305

}

   306

   307

static inline bool IsVitalWindow(const Window *w)

   308

{

   309

	WindowClass wc = w->window_class;

   310

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

   311

}

   312

   313

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

   314

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

   315

 * - Toolbar, Statusbar (always on)

   316

 * - New window, Chatbar (only if open)

   317

 * @param w window that is put into the foreground

   318

 */

   319

Window *BringWindowToFront(Window *w)

   320

{

   321

	Window *v;

   322

	Window temp;

   323

   324

	v = _last_window;

   325

	do {

   326

		if (--v < _windows)

   327

			return w;

   328

	} while (IsVitalWindow(v));

   329

   330

	if (w == v)

   331

		return w;

   332

   333

	assert(w < v);

   334

   335

	temp = *w;

   336

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

   337

	*v = temp;

   338

   339

	SetWindowDirty(v);

   340

   341

	return v;

   342

}

   343

   344

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

   345

 * Keep all important windows intact. These are

   346

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

   347

 * - News window, Chatbar (when on)

   348

 * - Any sticked windows since we wanted to keep these

   349

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

   350

 */

   351

static Window *FindDeletableWindow(void)

   352

{

   353

	Window *w;

   354

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

   355

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

   356

				return w;

   357

	}

   358

	return NULL;

   359

}

   360

   361

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

   362

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

   363

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

   364

 * @see FindDeletableWindow()

   365

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

   366

 */

   367

static Window *ForceFindDeletableWindow(void)

   368

{

   369

	Window *w;

   370

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

   371

		assert(w < _last_window);

   372

   373

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

   374

				return w;

   375

	}

   376

}

   377

   378

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

   379

{

   380

	return (w->original_widget == widget);

   381

}

   382

   383

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

   384

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

   385

{

   386

	w->original_widget = widget;

   387

   388

	if (widget != NULL) {

   389

		const Widget *wi = widget;

   390

		uint index = 1;

   391

		while (wi->type != WWT_LAST) {

   392

			wi++;

   393

			index++;

   394

		}

   395

   396

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

   397

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

   398

	} else

   399

		w->widget = NULL;

   400

}

   401

   402

/** Open a new window. If there is no space for a new window, close an open

   403

 * window. Try to avoid stickied windows, but if there is no else, close one of

   404

 * those as well. Then make sure all created windows are below some always-on-top

   405

 * ones. Finally set all variables and call the WE_CREATE event

   406

 * @param x offset in pixels from the left of the screen

   407

 * @param y offset in pixels from the top of the screen

   408

 * @param width width in pixels of the window

   409

 * @param height height in pixels of the window

   410

 * @param *proc @see WindowProc function to call when any messages/updates happen to the window

   411

 * @param cls @see WindowClass class of the window, used for identification and grouping

   412

 * @param *widget @see Widget pointer to the window layout and various elements

   413

 * @return @see Window pointer of the newly created window

   414

 */

   415

Window *AllocateWindow(

   416

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

   417

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

   418

{

   419

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

   420

   421

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

   422

	if (w >= endof(_windows)) {

   423

		w = FindDeletableWindow();

   424

   425

		if (w == NULL) // no window found, force it!

   426

			w = ForceFindDeletableWindow();

   427

   428

		DeleteWindow(w);

   429

		w = _last_window;

   430

	}

   431

   432

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

   433

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

   434

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

   435

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

   436

	 * to de-braindeadize */

   437

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

   438

		Window *v;

   439

   440

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

   441

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

   442

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

   443

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

   444

		v = FindWindowById(WC_MAIN_TOOLBAR, 0);

   445

		if (v != NULL) {

   446

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

   447

			w = v;

   448

		}

   449

   450

		v = FindWindowById(WC_STATUS_BAR, 0);

   451

		if (v != NULL) {

   452

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

   453

			w = v;

   454

		}

   455

   456

		v = FindWindowById(WC_NEWS_WINDOW, 0);

   457

		if (v != NULL) {

   458

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

   459

			w = v;

   460

		}

   461

	}

   462

   463

	// Set up window properties

   464

	memset(w, 0, sizeof(Window));

   465

	w->window_class = cls;

   466

	w->flags4 = WF_WHITE_BORDER_MASK; // just opened windows have a white border

   467

	w->caption_color = 0xFF;

   468

	w->left = x;

   469

	w->top = y;

   470

	w->width = width;

   471

	w->height = height;

   472

	w->wndproc = proc;

   473

	AssignWidgetToWindow(w, widget);

   474

	w->resize.width = width;

   475

	w->resize.height = height;

   476

	w->resize.step_width = 1;

   477

	w->resize.step_height = 1;

   478

   479

	_last_window++;

   480

   481

	SetWindowDirty(w);

   482

   483

	CallWindowEventNP(w, WE_CREATE);

   484

   485

	return w;

   486

}

   487

   488

Window *AllocateWindowAutoPlace2(

   489

	WindowClass exist_class,

   490

	WindowNumber exist_num,

   491

	int width,

   492

	int height,

   493

	WindowProc *proc,

   494

	WindowClass cls,

   495

	const Widget *widget)

   496

{

   497

	Window *w;

   498

	int x;

   499

   500

	w = FindWindowById(exist_class, exist_num);

   501

	if (w == NULL || w->left >= (_screen.width-20) || w->left <= -60 || w->top >= (_screen.height-20)) {

   502

		return AllocateWindowAutoPlace(width,height,proc,cls,widget);

   503

	}