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

		w->wndproc(w, &e);

    52

    53

		if (w->desc_flags & WDF_STD_BTN) {

    54

			if (e.click.widget == 0) {

    55

				DeleteWindow(w);

    56

			} else {

    57

				if (e.click.widget == 1) {

    58

					StartWindowDrag(w);

    59

				}

    60

			}

    61

		}

    62

    63

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

    64

			StartWindowSizing(w);

    65

		}

    66

    67

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

    68

			w->click_state ^= (1 << e.click.widget);

    69

			w->flags4 ^= WF_STICKY;

    70

			InvalidateWidget(w, e.click.widget);

    71

		}

    72

	} else {

    73

		w->wndproc(w, &e);

    74

	}

    75

}

    76

    77

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

    78

	WindowEvent e;

    79

    80

	/* default tooltips handler? */

    81

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

    82

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

    83

		if (e.click.widget < 0)

    84

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

    85

    86

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

    87

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

    88

			return;

    89

		}

    90

	}

    91

    92

	e.event = WE_RCLICK;

    93

	e.click.pt.x = x;

    94

	e.click.pt.y = y;

    95

	w->wndproc(w, &e);

    96

}

    97

    98

    99

void DispatchMouseWheelEvent(Window *w, int wheel)

   100

{

   101

	if (w->vscroll.count > w->vscroll.cap) {

   102

		int pos = clamp(w->vscroll.pos + wheel, 0, w->vscroll.count - w->vscroll.cap);

   103

		if (pos != w->vscroll.pos) {

   104

			w->vscroll.pos = pos;

   105

			SetWindowDirty(w);

   106

		}

   107

	}

   108

}

   109

   110

   111

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

   112

{

   113

	Window *w;

   114

	DrawPixelInfo bk;

   115

	_cur_dpi = &bk;

   116

   117

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

   118

		if (right > w->left &&

   119

				bottom > w->top &&

   120

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

   121

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

   122

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

   123

			}

   124

	}

   125

}

   126

   127

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

   128

{

   129

	Window *v = w;

   130

	int x;

   131

   132

	while (++v != _last_window) {

   133

		if (right > v->left &&

   134

		 		bottom > v->top &&

   135

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

   136

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

   137

   138

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

   139

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

   140

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

   141

				return;

   142

			}

   143

   144

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

   145

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

   146

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

   147

				return;

   148

			}

   149

   150

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

   151

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

   152

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

   153

				return;

   154

			}

   155

   156

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

   157

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

   158

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

   159

				return;

   160

			}

   161

   162

			return;

   163

		}

   164

	}

   165

   166

	{

   167

		DrawPixelInfo *dp = _cur_dpi;

   168

		dp->width = right - left;

   169

		dp->height = bottom - top;

   170

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

   171

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

   172

		dp->pitch = _screen.pitch;

   173

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

   174

		dp->zoom = 0;

   175

		CallWindowEventNP(w, WE_PAINT);

   176

	}

   177

}

   178

   179

void CallWindowEventNP(Window *w, int event)

   180

{

   181

	WindowEvent e;

   182

   183

	e.event = event;

   184

	w->wndproc(w, &e);

   185

}

   186

   187

void SetWindowDirty(Window *w)

   188

{

   189

	if (w == NULL)

   190

		return;

   191

   192

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

   193

}

   194

   195

void DeleteWindow(Window *w)

   196

{

   197

	WindowClass wc;

   198

	WindowNumber wn;

   199

	ViewPort *vp;

   200

	Window *v;

   201

	int count;

   202

   203

	if (w == NULL)

   204

		return;

   205

   206

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

   207

		ResetObjectToPlace();

   208

	}

   209

   210

	wc = w->window_class;

   211

	wn = w->window_number;

   212

   213

	CallWindowEventNP(w, WE_DESTROY);

   214

   215

	w = FindWindowById(wc, wn);

   216

   217

	vp = w->viewport;

   218

	w->viewport = NULL;

   219

	if (vp != NULL) {

   220

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

   221

		vp->width = 0;

   222

	}

   223

   224

	SetWindowDirty(w);

   225

   226

	free(w->widget);

   227

   228

	v = --_last_window;

   229

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

   230

	memcpy(w, w + 1, count);

   231

}

   232

   233

Window *FindWindowById(WindowClass cls, WindowNumber number)

   234

{

   235

	Window *w;

   236

   237

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

   238

		if (w->window_class == cls &&

   239

			  w->window_number == number) {

   240

			return w;

   241

		}

   242

	}

   243

   244

	return NULL;

   245

}

   246

   247

void DeleteWindowById(WindowClass cls, WindowNumber number)

   248

{

   249

	DeleteWindow(FindWindowById(cls, number));

   250

}

   251

   252

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   253

{

   254

	Window *w = FindWindowById(cls, number);

   255

   256

	if (w != NULL) {

   257

		w->flags4 |= WF_WHITE_BORDER_MASK;

   258

		SetWindowDirty(w);

   259

		w = BringWindowToFront(w);

   260

	}

   261

   262

	return w;

   263

}

   264

   265

Window *BringWindowToFront(Window *w)

   266

{

   267

	Window *v;

   268

	Window temp;

   269

   270

	v = _last_window;

   271

	do {

   272

		if (--v < _windows)

   273

			return w;

   274

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

   275

   276

	if (w == v)

   277

		return w;

   278

   279

	assert(w < v);

   280

   281

	temp = *w;

   282

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

   283

	*v = temp;

   284

   285

	SetWindowDirty(v);

   286

   287

	return v;

   288

}

   289

   290

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

   291

 * Keep all important windows intact */

   292

static Window *FindDeletableWindow(void)

   293

{

   294

	Window *w;

   295

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

   296

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

   297

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

   298

				!(w->flags4 & WF_STICKY) )

   299

				return w;

   300

	}

   301

	return NULL;

   302

}

   303

   304

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

   305

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

   306

static Window *ForceFindDeletableWindow(void)

   307

{

   308

	Window *w;

   309

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

   310

		assert(w < _last_window);

   311

   312

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

   313

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

   314

				return w;

   315

	}

   316

}

   317

   318

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

   319

{

   320

	return (w->original_widget == widget);

   321

}

   322

   323

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

   324

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

   325

{

   326

	w->original_widget = widget;

   327

   328

	if (widget != NULL) {

   329

		const Widget *wi = widget;

   330

		uint index = 1;

   331

		while (wi->type != WWT_LAST) {

   332

			wi++;

   333

			index++;

   334

		}

   335

   336

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

   337

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

   338

	} else {

   339

		w->widget = NULL;

   340

	}

   341

}

   342

   343

Window *AllocateWindow(

   344

							int x,

   345

							int y,

   346

							int width,

   347

							int height,

   348

							WindowProc *proc,

   349

							WindowClass cls,

   350

							const Widget *widget)

   351

{

   352

	Window *w;

   353

   354

	w = _last_window;

   355

   356

	if (w >= endof(_windows)) {

   357

		w = FindDeletableWindow();

   358

   359

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

   360

			w = ForceFindDeletableWindow();

   361

   362

		DeleteWindow(w);

   363

		w = _last_window;

   364

	}

   365

   366

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

   367

		Window *v;

   368

   369

		v = FindWindowById(WC_MAIN_TOOLBAR, 0);

   370

		if (v) {

   371

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

   372

			w = v;

   373

		}

   374

   375

		v = FindWindowById(WC_STATUS_BAR, 0);

   376

		if (v) {

   377

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

   378

			w = v;

   379

		}

   380

	}

   381

   382

	/* XXX: some more code here */

   383

	w->window_class = cls;

   384

	w->flags4 = WF_WHITE_BORDER_MASK;

   385

	w->caption_color = 0xFF;

   386

	w->window_number = 0;

   387

	w->left = x;

   388

	w->top = y;

   389

	w->width = width;

   390

	w->height = height;

   391

	w->viewport = NULL;

   392

	w->desc_flags = 0;

   393

//	w->landscape_assoc = 0xFFFF;

   394

	w->wndproc = proc;

   395

	w->click_state = 0;

   396

	w->disabled_state = 0;

   397

	w->hidden_state = 0;

   398

//	w->unk22 = 0xFFFF;

   399

	w->vscroll.pos = 0;

   400

	w->vscroll.count = 0;

   401

	w->hscroll.pos = 0;

   402

	w->hscroll.count = 0;

   403

	AssignWidgetToWindow(w, widget);

   404

	w->resize.width = width;

   405

	w->resize.height = height;

   406

	w->resize.step_width = 1;

   407

	w->resize.step_height = 1;

   408

   409

	{

   410

		int i;

   411

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

   412

			w->custom[i] = 0;

   413

	}

   414

   415

	_last_window++;

   416

   417

	SetWindowDirty(w);

   418

   419

	CallWindowEventNP(w, WE_CREATE);

   420

   421

	return w;

   422

}

   423

   424

Window *AllocateWindowAutoPlace2(

   425

	WindowClass exist_class,

   426

	WindowNumber exist_num,

   427

	int width,

   428

	int height,

   429

	WindowProc *proc,

   430

	WindowClass cls,

   431

	const Widget *widget)

   432

{

   433

	Window *w;

   434

	int x;

   435

   436

	w = FindWindowById(exist_class, exist_num);

   437

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

   438

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

   439

	}

   440

   441

	x = w->left;

   442

	if (x > _screen.width - width)

   443

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

   444

   445

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

   446

}

   447

   448

   449

typedef struct SizeRect {

   450

	int left,top,width,height;

   451

} SizeRect;

   452

   453

   454

static SizeRect _awap_r;

   455

   456

static bool IsGoodAutoPlace1(int left, int top)

   457

{

   458

	int right,bottom;

   459

	Window *w;

   460

   461

	_awap_r.left= left;

   462

	_awap_r.top = top;

   463

	right = _awap_r.width + left;

   464

	bottom = _awap_r.height + top;

   465

   466

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

   467

		return false;

   468

   469

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

   470

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

   471

		if (w->window_class == WC_MAIN_WINDOW)

   472

			continue;

   473

   474

		if (right > w->left &&

   475

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

   476

				bottom > w->top &&

   477

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

   478

					return false;

   479

	}

   480

   481

	return true;

   482

}

   483

   484

static bool IsGoodAutoPlace2(int left, int top)

   485

{

   486

	int width,height;

   487

	Window *w;

   488

   489

	_awap_r.left= left;

   490

	_awap_r.top = top;

   491

	width = _awap_r.width;

   492

	height = _awap_r.height;

   493

   494

	if (left < -(width>>2) || left > _screen.width - (width>>1))

   495

		return false;

   496

	if (top < 22 || top > _screen.height - (height>>2))

   497

		return false;

   498

   499

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

   500

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

   501

		if (w->window_class == WC_MAIN_WINDOW)

   502

			continue;

   503

   504

		if (left + width > w->left &&

   505

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

   506

				top + height > w->top &&

   507

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

   508

					return false;

   509

	}

   510

   511

	return true;

   512

}

   513

   514

Point GetAutoPlacePosition(int width, int height) {