1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "debug.h"

     4

#include "map.h"

     6

#include "window.h"

     7

#include "gfx.h"

     8

#include "viewport.h"

     9

#include "console.h"

    10

    11

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

    12

static Point _drag_delta;

    13

    14

void HandleButtonClick(Window *w, byte widget)

    15

{

    16

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

    17

	w->flags4 |= 5 << WF_TIMEOUT_SHL;

    18

	InvalidateWidget(w, widget);

    19

}

    20

    21

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

    22

	WindowEvent e;

    23

	const Widget *wi;

    24

    25

	e.click.pt.x = x;

    26

	e.click.pt.y = y;

    27

	e.event = WE_CLICK;

    28

    29

	if (w->desc_flags & WDF_DEF_WIDGET) {

    30

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

    31

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

    32

    33

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

    34

    35

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

    36

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

    37

			return;

    38

    39

		if (wi->type & 0xE0) {

    40

			/* special widget handling for buttons*/

    41

			switch(wi->type) {

    42

			case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

    43

			case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

    44

				HandleButtonClick(w, e.click.widget);

    45

				break;

    46

			case WWT_NODISTXTBTN:

    47

				break;

    48

			}

    49

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

    50

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

    51

		}

    52

    53

		if (w->desc_flags & WDF_STD_BTN) {

    54

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

    55

				DeleteWindow(w);

    56

				return;

    57

			}

    58

    59

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

    60

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

    61

				return;

    62

			}

    63

		}

    64

    65

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

    66

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

    67

			return;

    68

		}

    69

    70

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

    71

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

    72

			w->flags4 ^= WF_STICKY;

    73

			InvalidateWidget(w, e.click.widget);

    74

			return;

    75

		}

    76

	}

    77

    78

	w->wndproc(w, &e);

    79

}

    80

    81

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

    82

	WindowEvent e;

    83

    84

	/* default tooltips handler? */

    85

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

    86

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

    87

		if (e.click.widget < 0)

    88

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

    89

    90

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

    91

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

    92

			return;

    93

		}

    94

	}

    95

    96

	e.event = WE_RCLICK;

    97

	e.click.pt.x = x;

    98

	e.click.pt.y = y;

    99

	w->wndproc(w, &e);

   100

}

   101

   102

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

   103

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

   104

 * @param *w Window

   105

 * @param widget the widget where the scrollwheel was used

   106

 * @param wheel scroll up or down

   107

 */

   108

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

   109

{

   110

	const Widget *wi1, *wi2;

   111

	Scrollbar *sb;

   112

   113

	if (widget < 0) return;

   114

   115

	wi1 = &w->widget[widget];

   116

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

   117

   118

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

   119

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

   120

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

   121

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

   122

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

   123

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

   124

   125

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

   126

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

   127

			if (pos != sb->pos) {

   128

				sb->pos = pos;

   129

				SetWindowDirty(w);

   130

			}

   131

		}

   132

	}

   133

}

   134

   135

   136

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

   137

{

   138

	Window *w;

   139

	DrawPixelInfo bk;

   140

	_cur_dpi = &bk;

   141

   142

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

   143

		if (right > w->left &&

   144

				bottom > w->top &&

   145

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

   146

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

   147

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

   148

			}

   149

	}

   150

}

   151

   152

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

   153

{

   154

	Window *v = w;

   155

	int x;

   156

   157

	while (++v != _last_window) {

   158

		if (right > v->left &&

   159

				bottom > v->top &&

   160

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

   161

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

   162

   163

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

   164

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

   165

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

   166

				return;

   167

			}

   168

   169

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

   170

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

   171

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

   172

				return;

   173

			}

   174

   175

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

   176

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

   177

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

   178

				return;

   179

			}

   180

   181

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

   182

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

   183

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

   184

				return;

   185

			}

   186

   187

			return;

   188

		}

   189

	}

   190

   191

	{

   192

		DrawPixelInfo *dp = _cur_dpi;

   193

		dp->width = right - left;

   194

		dp->height = bottom - top;

   195

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

   196

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

   197

		dp->pitch = _screen.pitch;

   198

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

   199

		dp->zoom = 0;

   200

		CallWindowEventNP(w, WE_PAINT);

   201

	}

   202

}

   203

   204

void CallWindowEventNP(Window *w, int event)

   205

{

   206

	WindowEvent e;

   207

   208

	e.event = event;

   209

	w->wndproc(w, &e);

   210

}

   211

   212

void SetWindowDirty(Window *w)

   213

{

   214

	if (w == NULL)

   215

		return;

   216

   217

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

   218

}

   219

   220

void DeleteWindow(Window *w)

   221

{

   222

	WindowClass wc;

   223

	WindowNumber wn;

   224

	ViewPort *vp;

   225

	Window *v;

   226

	int count;

   227

   228

	if (w == NULL)

   229

		return;

   230

   231

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

   232

		ResetObjectToPlace();

   233

	}

   234

   235

	wc = w->window_class;

   236

	wn = w->window_number;

   237

   238

	CallWindowEventNP(w, WE_DESTROY);

   239

   240

	w = FindWindowById(wc, wn);

   241

   242

	vp = w->viewport;

   243

	w->viewport = NULL;

   244

	if (vp != NULL) {

   245

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

   246

		vp->width = 0;

   247

	}

   248

   249

	SetWindowDirty(w);

   250

   251

	free(w->widget);

   252

   253

	v = --_last_window;

   254

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

   255

	memmove(w, w + 1, count);

   256

}

   257

   258

Window *FindWindowById(WindowClass cls, WindowNumber number)

   259

{

   260

	Window *w;

   261

   262

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

   263

		if (w->window_class == cls &&

   264

			  w->window_number == number) {

   265

			return w;

   266

		}

   267

	}

   268

   269

	return NULL;

   270

}

   271

   272

void DeleteWindowById(WindowClass cls, WindowNumber number)

   273

{

   274

	DeleteWindow(FindWindowById(cls, number));

   275

}

   276

   277

void DeleteWindowByClass(WindowClass cls)

   278

{

   279

	Window *w;

   280

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

   281

		if (w->window_class == cls) {

   282

			DeleteWindow(w);

   283

			w = _windows;

   284

		} else

   285

			w++;

   286

	}

   287

}

   288

   289

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   290

{

   291

	Window *w = FindWindowById(cls, number);

   292

   293

	if (w != NULL) {

   294

		w->flags4 |= WF_WHITE_BORDER_MASK;

   295

		SetWindowDirty(w);

   296

		w = BringWindowToFront(w);

   297

	}

   298

   299

	return w;

   300

}

   301

   302

static inline bool IsVitalWindow(const Window *w)

   303

{

   304

	WindowClass wc = w->window_class;

   305

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

   306

}

   307

   308

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

   309

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

   310

 * - Toolbar, Statusbar (always on)

   311

 * - New window, Chatbar (only if open)

   312

 * @param w window that is put into the foreground

   313

 */

   314

Window *BringWindowToFront(Window *w)

   315

{

   316

	Window *v;

   317

	Window temp;

   318

   319

	v = _last_window;

   320

	do {

   321

		if (--v < _windows)

   322

			return w;

   323

	} while (IsVitalWindow(v));

   324

   325

	if (w == v)

   326

		return w;

   327

   328

	assert(w < v);

   329

   330

	temp = *w;

   331

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

   332

	*v = temp;

   333

   334

	SetWindowDirty(v);

   335

   336

	return v;

   337

}

   338

   339

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

   340

 * Keep all important windows intact. These are

   341

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

   342

 * - News window, Chatbar (when on)

   343

 * - Any sticked windows since we wanted to keep these

   344

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

   345

 */

   346

static Window *FindDeletableWindow(void)

   347

{

   348

	Window *w;

   349

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

   350

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

   351

				return w;

   352

	}

   353

	return NULL;

   354

}

   355

   356

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

   357

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

   358

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

   359

 * @see FindDeletableWindow()

   360

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

   361

 */

   362

static Window *ForceFindDeletableWindow(void)

   363

{

   364

	Window *w;

   365

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

   366

		assert(w < _last_window);

   367

   368

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

   369

				return w;

   370

	}

   371

}

   372

   373

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

   374

{

   375

	return (w->original_widget == widget);

   376

}

   377

   378

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

   379

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

   380

{

   381

	w->original_widget = widget;

   382

   383

	if (widget != NULL) {

   384

		const Widget *wi = widget;

   385

		uint index = 1;

   386

		while (wi->type != WWT_LAST) {

   387

			wi++;

   388

			index++;

   389

		}

   390

   391

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

   392

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

   393

	} else

   394

		w->widget = NULL;

   395

}

   396

   397

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

   398

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

   399

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

   400

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

   401

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

   402

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

   403

 * @param width width in pixels of the window

   404

 * @param height height in pixels of the window

   405

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

   406

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

   407

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

   408

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

   409

 */

   410

Window *AllocateWindow(

   411

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

   412

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

   413

{

   414

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

   415

   416

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

   417

	if (w >= endof(_windows)) {

   418

		w = FindDeletableWindow();

   419

   420

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

   421

			w = ForceFindDeletableWindow();

   422

   423

		DeleteWindow(w);

   424

		w = _last_window;

   425

	}

   426

   427

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

   428

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

   429

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

   430

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

   431

	 * to de-braindeadize */

   432

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

   433

		Window *v;

   434

   435

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

   436

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

   437

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

   438

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

   439

		v = FindWindowById(WC_MAIN_TOOLBAR, 0);

   440

		if (v != NULL) {

   441

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

   442

			w = v;

   443

		}

   444

   445

		v = FindWindowById(WC_STATUS_BAR, 0);

   446

		if (v != NULL) {

   447

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

   448

			w = v;

   449

		}

   450

   451

		v = FindWindowById(WC_NEWS_WINDOW, 0);

   452

		if (v != NULL) {

   453

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

   454

			w = v;

   455

		}

   456

	}

   457

   458

	// Set up window properties

   459

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

   460

	w->window_class = cls;

   461

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

   462

	w->caption_color = 0xFF;

   463

	w->left = x;

   464

	w->top = y;

   465

	w->width = width;

   466

	w->height = height;

   467

	w->wndproc = proc;

   468

	AssignWidgetToWindow(w, widget);

   469

	w->resize.width = width;

   470

	w->resize.height = height;

   471

	w->resize.step_width = 1;

   472

	w->resize.step_height = 1;

   473

   474

	_last_window++;

   475

   476

	SetWindowDirty(w);

   477

   478

	CallWindowEventNP(w, WE_CREATE);

   479

   480

	return w;

   481

}

   482

   483

Window *AllocateWindowAutoPlace2(

   484

	WindowClass exist_class,

   485

	WindowNumber exist_num,

   486

	int width,

   487

	int height,

   488

	WindowProc *proc,

   489

	WindowClass cls,

   490

	const Widget *widget)

   491

{

   492

	Window *w;

   493

	int x;

   494

   495

	w = FindWindowById(exist_class, exist_num);

   496

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

   497

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

   498

	}

   499

   500

	x = w->left;

   501

	if (x > _screen.width - width)

   502

		x = (_screen.width - width) - 20;

   503

   504

	return AllocateWindow(x+10,w->top+10,width,height,proc,cls,widget);