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

    27

static Window *StartWindowDrag(Window *w);

    28

static Window *StartWindowSizing(Window *w);

    29

    30

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

    31

{

    32

	WindowEvent e;

    33

	const Widget *wi;

    34

    35

	e.click.pt.x = x;

    36

	e.click.pt.y = y;

    37

	e.event = WE_CLICK;

    38

    39

	if (w->desc_flags & WDF_DEF_WIDGET) {

    40

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

    41

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

    42

    43

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

    44

    45

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

    46

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

    47

    48

		if (wi->type & 0xE0) {

    49

			/* special widget handling for buttons*/

    50

			switch (wi->type) {

    51

			case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

    52

			case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

    53

				HandleButtonClick(w, e.click.widget);

    54

				break;

    55

			case WWT_NODISTXTBTN:

    56

				break;

    57

			}

    58

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

    59

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

    60

		}

    61

    62

		if (w->desc_flags & WDF_STD_BTN) {

    63

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

    64

				DeleteWindow(w);

    65

				return;

    66

			}

    67

    68

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

    69

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

    70

				return;

    71

			}

    72

		}

    73

    74

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

    75

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

    76

			return;

    77

		}

    78

    79

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

    80

			w->flags4 ^= WF_STICKY;

    81

			InvalidateWidget(w, e.click.widget);

    82

			return;

    83

		}

    84

	}

    85

    86

	w->wndproc(w, &e);

    87

}

    88

    89

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

    90

{

    91

	WindowEvent e;

    92

    93

	/* default tooltips handler? */

    94

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

    95

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

    96

		if (e.click.widget < 0)

    97

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

    98

    99

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

   100

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

   101

			return;

   102

		}

   103

	}

   104

   105

	e.event = WE_RCLICK;

   106

	e.click.pt.x = x;

   107

	e.click.pt.y = y;

   108

	w->wndproc(w, &e);

   109

}

   110

   111

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

   112

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

   113

 * @param *w Window

   114

 * @param widget the widget where the scrollwheel was used

   115

 * @param wheel scroll up or down

   116

 */

   117

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

   118

{

   119

	const Widget *wi1, *wi2;

   120

	Scrollbar *sb;

   121

   122

	if (widget < 0) return;

   123

   124

	wi1 = &w->widget[widget];

   125

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

   126

   127

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

   128

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

   129

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

   130

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

   131

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

   132

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

   133

   134

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

   135

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

   136

			if (pos != sb->pos) {

   137

				sb->pos = pos;

   138

				SetWindowDirty(w);

   139

			}

   140

		}

   141

	}

   142

}

   143

   144

   145

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

   146

   147

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

   148

{

   149

	Window *w;

   150

	DrawPixelInfo bk;

   151

	_cur_dpi = &bk;

   152

   153

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

   154

		if (right > w->left &&

   155

				bottom > w->top &&

   156

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

   157

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

   158

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

   159

		}

   160

	}

   161

}

   162

   163

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

   164

{

   165

	const Window *v = w;

   166

	int x;

   167

   168

	while (++v != _last_window) {

   169

		if (right > v->left &&

   170

				bottom > v->top &&

   171

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

   172

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

   173

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

   174

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

   175

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

   176

				return;

   177

			}

   178

   179

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

   180

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

   181

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

   182

				return;

   183

			}

   184

   185

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

   186

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

   187

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

   188

				return;

   189

			}

   190

   191

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

   192

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

   193

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

   194

				return;

   195

			}

   196

   197

			return;

   198

		}

   199

	}

   200

   201

	{

   202

		DrawPixelInfo *dp = _cur_dpi;

   203

		dp->width = right - left;

   204

		dp->height = bottom - top;

   205

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

   206

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

   207

		dp->pitch = _screen.pitch;

   208

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

   209

		dp->zoom = 0;

   210

		CallWindowEventNP(w, WE_PAINT);

   211

	}

   212

}

   213

   214

void CallWindowEventNP(Window *w, int event)

   215

{

   216

	WindowEvent e;

   217

   218

	e.event = event;

   219

	w->wndproc(w, &e);

   220

}

   221

   222

void SetWindowDirty(const Window *w)

   223

{

   224

	if (w == NULL) return;

   225

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

   226

}

   227

   228

void DeleteWindow(Window *w)

   229

{

   230

	WindowClass wc;

   231

	WindowNumber wn;

   232

	Window *v;

   233

	int count;

   234

   235

	if (w == NULL) return;

   236

   237

	if (_thd.place_mode != VHM_NONE &&

   238

			_thd.window_class == w->window_class &&

   239

			_thd.window_number == w->window_number) {

   240

		ResetObjectToPlace();

   241

	}

   242

   243

	wc = w->window_class;

   244

	wn = w->window_number;

   245

   246

	CallWindowEventNP(w, WE_DESTROY);

   247

   248

	w = FindWindowById(wc, wn);

   249

   250

	if (w->viewport != NULL) {

   251

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

   252

		w->viewport->width = 0;

   253

		w->viewport = NULL;

   254

	}

   255

   256

	SetWindowDirty(w);

   257

   258

	free(w->widget);

   259

   260

	v = --_last_window;

   261

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

   262

	memmove(w, w + 1, count);

   263

}

   264

   265

Window *FindWindowById(WindowClass cls, WindowNumber number)

   266

{

   267

	Window *w;

   268

   269

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

   270

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

   271

	}

   272

   273

	return NULL;

   274

}

   275

   276

void DeleteWindowById(WindowClass cls, WindowNumber number)

   277

{

   278

	DeleteWindow(FindWindowById(cls, number));

   279

}

   280

   281

void DeleteWindowByClass(WindowClass cls)

   282

{

   283

	Window *w;

   284

   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

   295

   296

static Window *BringWindowToFront(Window *w);

   297

   298

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   299

{

   300

	Window *w = FindWindowById(cls, number);

   301

   302

	if (w != NULL) {

   303

		w->flags4 |= WF_WHITE_BORDER_MASK;

   304

		SetWindowDirty(w);

   305

		w = BringWindowToFront(w);

   306

	}

   307

   308

	return w;

   309

}

   310

   311

static inline bool IsVitalWindow(const Window *w)

   312

{

   313

	WindowClass wc = w->window_class;

   314

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

   315

}

   316

   317

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

   318

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

   319

 * - Toolbar, Statusbar (always on)

   320

 * - New window, Chatbar (only if open)

   321

 * @param w window that is put into the foreground

   322

 */

   323

static Window *BringWindowToFront(Window *w)

   324

{

   325

	Window *v;

   326

	Window temp;

   327

   328

	v = _last_window;

   329

	do {

   330

		if (--v < _windows) return w;

   331

	} while (IsVitalWindow(v));

   332

   333

	if (w == v) return w;

   334

   335

	assert(w < v);

   336

   337

	temp = *w;

   338

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

   339

	*v = temp;

   340

   341

	SetWindowDirty(v);

   342

   343

	return v;

   344

}

   345

   346

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

   347

 * Keep all important windows intact. These are

   348

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

   349

 * - News window, Chatbar (when on)

   350

 * - Any sticked windows since we wanted to keep these

   351

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

   352

 */

   353

static Window *FindDeletableWindow(void)

   354

{

   355

	Window *w;

   356

   357

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

   358

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

   359

			return w;

   360

		}

   361

	}

   362

	return NULL;

   363

}

   364

   365

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

   366

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

   367

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

   368

 * @see FindDeletableWindow()

   369

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

   370

 */

   371

static Window *ForceFindDeletableWindow(void)

   372

{

   373

	Window *w;

   374

   375

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

   376

		assert(w < _last_window);

   377

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

   378

	}

   379

}

   380

   381

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

   382

{

   383

	return (w->original_widget == widget);

   384

}

   385

   386

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

   387

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

   388

{

   389

	w->original_widget = widget;

   390

   391

	if (widget != NULL) {

   392

		uint index = 1;

   393

		const Widget *wi;

   394

   395

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

   396

   397

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

   398

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

   399

	} else {

   400

		w->widget = NULL;

   401

	}

   402

}

   403

   404

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

   405

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

   406

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

   407

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

   408

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

   409

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

   410

 * @param width width in pixels of the window

   411

 * @param height height in pixels of the window

   412

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

   413

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

   414

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

   415

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

   416

 */

   417

Window *AllocateWindow(

   418

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

   419

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

   420

{

   421

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

   422

   423

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

   424

	if (w >= endof(_windows)) {

   425

		w = FindDeletableWindow();

   426

   427

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

   428

   429

		DeleteWindow(w);

   430

		w = _last_window;

   431

	}

   432

   433

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

   434

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

   435

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

   436

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

   437

	 * to de-braindeadize */

   438

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

   439

		Window *v;

   440

   441

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

   442

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

   443

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

   444

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

   445

		v = FindWindowById(WC_MAIN_TOOLBAR, 0);

   446

		if (v != NULL) {

   447

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

   448

			w = v;

   449

		}

   450

   451

		v = FindWindowById(WC_STATUS_BAR, 0);

   452

		if (v != NULL) {

   453

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

   454

			w = v;

   455

		}

   456

   457

		v = FindWindowById(WC_NEWS_WINDOW, 0);

   458

		if (v != NULL) {

   459

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

   460

			w = v;

   461

		}

   462

	}

   463

   464

	// Set up window properties

   465

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

   466

	w->window_class = cls;

   467

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

   468

	w->caption_color = 0xFF;

   469

	w->left = x;

   470

	w->top = y;

   471

	w->width = width;

   472

	w->height = height;

   473

	w->wndproc = proc;

   474

	AssignWidgetToWindow(w, widget);

   475

	w->resize.width = width;

   476

	w->resize.height = height;

   477

	w->resize.step_width = 1;

   478

	w->resize.step_height = 1;

   479

   480

	_last_window++;

   481

   482

	SetWindowDirty(w);

   483

   484

	CallWindowEventNP(w, WE_CREATE);

   485

   486

	return w;

   487

}

   488

   489

   490

typedef struct SizeRect {

   491

	int left,top,width,height;

   492

} SizeRect;

   493

   494

   495

static SizeRect _awap_r;

   496

   497

static bool IsGoodAutoPlace1(int left, int top)

   498

{

   499

	int right,bottom;

   500

	Window *w;