1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "map.h"

     4

#include "window.h"

     5

#include "gfx.h"

     6

#include "viewport.h"

     7

#include "console.h"

     8

     9

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

    10

static Point _drag_delta;

    11

    12

void HandleButtonClick(Window *w, byte widget)

    13

{

    14

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

    15

	w->flags4 |= 5 << WF_TIMEOUT_SHL;

    16

	InvalidateWidget(w, widget);

    17

}

    18

    19

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

    20

	WindowEvent e;

    21

	const Widget *wi;

    22

    23

	e.click.pt.x = x;

    24

	e.click.pt.y = y;

    25

	e.event = WE_CLICK;

    26

    27

	if (w->desc_flags & WDF_DEF_WIDGET) {

    28

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

    29

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

    30

    31

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

    32

    33

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

    34

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

    35

			return;

    36

    37

		if (wi->type & 0xE0) {

    38

			/* special widget handling for buttons*/

    39

			switch(wi->type) {

    40

			case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

    41

			case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

    42

				HandleButtonClick(w, e.click.widget);

    43

				break;

    44

			case WWT_NODISTXTBTN:

    45

				break;

    46

			}

    47

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

    48

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

    49

		}

    50

    51

		if (w->desc_flags & WDF_STD_BTN) {

    52

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

    53

				DeleteWindow(w);

    54

				return;

    57

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

    58

				StartWindowDrag(w);

    59

		}

    60

    61

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

    62

			w = StartWindowSizing(w);

    63

    64

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

    65

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

    66

			w->flags4 ^= WF_STICKY;

    67

			InvalidateWidget(w, e.click.widget);

    68

		}

    69

	}

    70

    71

	w->wndproc(w, &e);

    72

}

    73

    74

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

    75

	WindowEvent e;

    76

    77

	/* default tooltips handler? */

    78

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

    79

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

    80

		if (e.click.widget < 0)

    81

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

    82

    83

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

    84

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

    85

			return;

    86

		}

    87

	}

    88

    89

	e.event = WE_RCLICK;

    90

	e.click.pt.x = x;

    91

	e.click.pt.y = y;

    92

	w->wndproc(w, &e);

    93

}

    94

    95

    96

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

    97

{

    98

	const Widget *wi1 = &w->widget[widget];

    99

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

   100

	Scrollbar *sb;

   101

   102

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

   103

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

   104

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

   105

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

   106

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

   107

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

   108

   109

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

   110

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

   111

			if (pos != sb->pos) {

   112

				sb->pos = pos;

   113

				SetWindowDirty(w);

   114

			}

   115

		}

   116

	}

   117

}

   118

   119

   120

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

   121

{

   122

	Window *w;

   123

	DrawPixelInfo bk;

   124

	_cur_dpi = &bk;

   125

   126

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

   127

		if (right > w->left &&

   128

				bottom > w->top &&

   129

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

   130

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

   131

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

   132

			}

   133

	}

   134

}

   135

   136

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

   137

{

   138

	Window *v = w;

   139

	int x;

   140

   141

	while (++v != _last_window) {

   142

		if (right > v->left &&

   143

		 		bottom > v->top &&

   144

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

   145

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

   146

   147

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

   148

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

   149

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

   150

				return;

   151

			}

   152

   153

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

   154

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

   155

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

   156

				return;

   157

			}

   158

   159

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

   160

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

   161

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

   162

				return;

   163

			}

   164

   165

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

   166

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

   167

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

   168

				return;

   169

			}

   170

   171

			return;

   172

		}

   173

	}

   174

   175

	{

   176

		DrawPixelInfo *dp = _cur_dpi;

   177

		dp->width = right - left;

   178

		dp->height = bottom - top;

   179

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

   180

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

   181

		dp->pitch = _screen.pitch;

   182

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

   183

		dp->zoom = 0;

   184

		CallWindowEventNP(w, WE_PAINT);

   185

	}

   186

}

   187

   188

void CallWindowEventNP(Window *w, int event)

   189

{

   190

	WindowEvent e;

   191

   192

	e.event = event;

   193

	w->wndproc(w, &e);

   194

}

   195

   196

void SetWindowDirty(Window *w)

   197

{

   198

	if (w == NULL)

   199

		return;

   200

   201

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

   202

}

   203

   204

void DeleteWindow(Window *w)

   205

{

   206

	WindowClass wc;

   207

	WindowNumber wn;

   208

	ViewPort *vp;

   209

	Window *v;

   210

	int count;

   211

   212

	if (w == NULL)

   213

		return;

   214

   215

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

   216

		ResetObjectToPlace();

   217

	}

   218

   219

	wc = w->window_class;

   220

	wn = w->window_number;

   221

   222

	CallWindowEventNP(w, WE_DESTROY);

   223

   224

	w = FindWindowById(wc, wn);

   225

   226

	vp = w->viewport;

   227

	w->viewport = NULL;

   228

	if (vp != NULL) {

   229

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

   230

		vp->width = 0;

   231

	}

   232

   233

	SetWindowDirty(w);

   234

   235

	free(w->widget);

   236

   237

	v = --_last_window;

   238

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

   239

	memmove(w, w + 1, count);

   240

}

   241

   242

Window *FindWindowById(WindowClass cls, WindowNumber number)

   243

{

   244

	Window *w;

   245

   246

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

   247

		if (w->window_class == cls &&

   248

			  w->window_number == number) {

   249

			return w;

   250

		}

   251

	}

   252

   253

	return NULL;

   254

}

   255

   256

void DeleteWindowById(WindowClass cls, WindowNumber number)

   257

{

   258

	DeleteWindow(FindWindowById(cls, number));

   259

}

   260

   261

void DeleteWindowByClass(WindowClass cls)

   262

{

   263

	Window *w;

   264

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

   265

		if (w->window_class == cls) {

   266

			DeleteWindow(w);

   267

			w = _windows;

   268

		} else

   269

			w++;

   270

	}

   271

}

   272

   273

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   274

{

   275

	Window *w = FindWindowById(cls, number);

   276

   277

	if (w != NULL) {

   278

		w->flags4 |= WF_WHITE_BORDER_MASK;

   279

		SetWindowDirty(w);

   280

		w = BringWindowToFront(w);

   281

	}

   282

   283

	return w;

   284

}

   285

   286

Window *BringWindowToFront(Window *w)

   287

{

   288

	Window *v;

   289

	Window temp;

   290

   291

	v = _last_window;

   292

	do {

   293

		if (--v < _windows)

   294

			return w;

   295

	} while (v->window_class == WC_MAIN_TOOLBAR || v->window_class == WC_STATUS_BAR || v->window_class == WC_NEWS_WINDOW);

   296

   297

	if (w == v)

   298

		return w;

   299

   300

	assert(w < v);

   301

   302

	temp = *w;

   303

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

   304

	*v = temp;

   305

   306

	SetWindowDirty(v);

   307

   308

	return v;

   309

}

   310

   311

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

   312

 * Keep all important windows intact */

   313

static Window *FindDeletableWindow(void)

   314

{

   315

	Window *w;

   316

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

   317

		if (w->window_class != WC_MAIN_WINDOW && w->window_class != WC_MAIN_TOOLBAR &&

   318

			  w->window_class != WC_STATUS_BAR && w->window_class != WC_NEWS_WINDOW &&

   319

				!(w->flags4 & WF_STICKY) )

   320

				return w;

   321

	}

   322

	return NULL;

   323

}

   324

   325

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

   326

 * restriction a bit by allowing to delete sticky windows */

   327

static Window *ForceFindDeletableWindow(void)

   328

{

   329

	Window *w;

   330

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

   331

		assert(w < _last_window);

   332

   333

		if (w->window_class != WC_MAIN_WINDOW && w->window_class != WC_MAIN_TOOLBAR &&

   334

			  w->window_class != WC_STATUS_BAR && w->window_class != WC_NEWS_WINDOW)

   335

				return w;

   336

	}

   337

}

   338

   339

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

   340

{

   341

	return (w->original_widget == widget);

   342

}

   343

   344

/* Copies 'widget' to 'w->widget' */

   345

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

   346

{

   347

	w->original_widget = widget;

   348

   349

	if (widget != NULL) {

   350

		const Widget *wi = widget;

   351

		uint index = 1;

   352

		while (wi->type != WWT_LAST) {

   353

			wi++;

   354

			index++;

   355

		}

   356

   357

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

   358

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

   359

	} else {

   360

		w->widget = NULL;

   361

	}

   362

}

   363

   364

Window *AllocateWindow(

   365

							int x,

   366

							int y,

   367

							int width,

   368

							int height,

   369

							WindowProc *proc,

   370

							WindowClass cls,

   371

							const Widget *widget)

   372

{

   373

	Window *w;

   374

   375

	w = _last_window;

   376

   377

	if (w >= endof(_windows)) {

   378

		w = FindDeletableWindow();

   379

   380

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

   381

			w = ForceFindDeletableWindow();

   382

   383

		DeleteWindow(w);

   384

		w = _last_window;

   385

	}

   386

   387

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

   388

		Window *v;

   389

   390

		v = FindWindowById(WC_MAIN_TOOLBAR, 0);

   391

		if (v) {

   392

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

   393

			w = v;

   394

		}

   395

   396

		v = FindWindowById(WC_STATUS_BAR, 0);

   397

		if (v) {

   398

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

   399

			w = v;

   400

		}

   401

	}

   402

   403

	/* XXX: some more code here */

   404

	w->window_class = cls;

   405

	w->flags4 = WF_WHITE_BORDER_MASK;

   406

	w->caption_color = 0xFF;

   407

	w->window_number = 0;

   408

	w->left = x;

   409

	w->top = y;

   410

	w->width = width;

   411

	w->height = height;

   412

	w->viewport = NULL;

   413

	w->desc_flags = 0;

   414

//	w->landscape_assoc = 0xFFFF;

   415

	w->wndproc = proc;

   416

	w->click_state = 0;

   417

	w->disabled_state = 0;

   418

	w->hidden_state = 0;

   419

//	w->unk22 = 0xFFFF;

   420

	w->vscroll.pos = 0;

   421

	w->vscroll.count = 0;

   422

	w->hscroll.pos = 0;

   423

	w->hscroll.count = 0;

   424

	AssignWidgetToWindow(w, widget);

   425

	w->resize.width = width;

   426

	w->resize.height = height;

   427

	w->resize.step_width = 1;

   428

	w->resize.step_height = 1;

   429

   430

	{

   431

		uint i;

   432

		for (i=0;i<lengthof(w->custom);i++)

   433

			w->custom[i] = 0;

   434

	}

   435

   436

	_last_window++;

   437

   438

	SetWindowDirty(w);

   439

   440

	CallWindowEventNP(w, WE_CREATE);

   441

   442

	return w;

   443

}

   444

   445

Window *AllocateWindowAutoPlace2(

   446

	WindowClass exist_class,

   447

	WindowNumber exist_num,

   448

	int width,

   449

	int height,

   450

	WindowProc *proc,

   451

	WindowClass cls,

   452

	const Widget *widget)

   453

{

   454

	Window *w;

   455

	int x;

   456

   457

	w = FindWindowById(exist_class, exist_num);

   458

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

   459

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

   460

	}

   461

   462

	x = w->left;

   463

	if (x > _screen.width - width)

   464

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

   465

   466

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

   467

}

   468

   469

   470

typedef struct SizeRect {

   471

	int left,top,width,height;

   472

} SizeRect;

   473

   474

   475

static SizeRect _awap_r;

   476

   477

static bool IsGoodAutoPlace1(int left, int top)

   478

{

   479

	int right,bottom;

   480

	Window *w;

   481

   482

	_awap_r.left= left;

   483

	_awap_r.top = top;

   484

	right = _awap_r.width + left;

   485

	bottom = _awap_r.height + top;

   486

   487

	if (left < 0 || top < 22 || right > _screen.width || bottom > _screen.height)

   488

		return false;

   489

   490

	// Make sure it is not obscured by any window.

   491

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

   492

		if (w->window_class == WC_MAIN_WINDOW)

   493

			continue;

   494

   495

		if (right > w->left &&

   496

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

   497

				bottom > w->top &&

   498

				w->top + w->height > top)

   499

					return false;

   500

	}

   501

   502

	return true;

   503

}

   504

   505

static bool IsGoodAutoPlace2(int left, int top)

   506

{

   507

	int width,height;

   508

	Window *w;

   509

   510

	_awap_r.left= left;

   511

	_awap_r.top = top;