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

   100

{

   118

		}

   119

	}

   120

}

   121

   122

   123

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

   124

{

   125

	Window *w;

   126

	DrawPixelInfo bk;

   127

	_cur_dpi = &bk;

   128

   129

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

   130

		if (right > w->left &&

   131

				bottom > w->top &&

   132

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

   133

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

   134

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

   135

			}

   136

	}

   137

}

   138

   139

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

   140

{

   141

	Window *v = w;

   142

	int x;

   143

   144

	while (++v != _last_window) {

   145

		if (right > v->left &&

   146

		 		bottom > v->top &&

   147

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

   148

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

   149

   150

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

   151

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

   152

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

   153

				return;

   154

			}

   155

   156

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

   157

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

   158

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

   159

				return;

   160

			}

   161

   162

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

   163

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

   164

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

   165

				return;

   166

			}

   167

   168

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

   169

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

   170

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

   171

				return;

   172

			}

   173

   174

			return;

   175

		}

   176

	}

   177

   178

	{

   179

		DrawPixelInfo *dp = _cur_dpi;

   180

		dp->width = right - left;

   181

		dp->height = bottom - top;

   182

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

   183

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

   184

		dp->pitch = _screen.pitch;

   185

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

   186

		dp->zoom = 0;

   187

		CallWindowEventNP(w, WE_PAINT);

   188

	}

   189

}

   190

   191

void CallWindowEventNP(Window *w, int event)

   192

{

   193

	WindowEvent e;

   194

   195

	e.event = event;

   196

	w->wndproc(w, &e);

   197

}

   198

   199

void SetWindowDirty(Window *w)

   200

{

   201

	if (w == NULL)

   202

		return;

   203

   204

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

   205

}

   206

   207

void DeleteWindow(Window *w)

   208

{

   209

	WindowClass wc;

   210

	WindowNumber wn;

   211

	ViewPort *vp;

   212

	Window *v;

   213

	int count;

   214

   215

	if (w == NULL)

   216

		return;

   217

   218

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

   219

		ResetObjectToPlace();

   220

	}

   221

   222

	wc = w->window_class;

   223

	wn = w->window_number;

   224

   225

	CallWindowEventNP(w, WE_DESTROY);

   226

   227

	w = FindWindowById(wc, wn);

   228

   229

	vp = w->viewport;

   230

	w->viewport = NULL;

   231

	if (vp != NULL) {

   232

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

   233

		vp->width = 0;

   234

	}

   235

   236

	SetWindowDirty(w);

   237

   238

	free(w->widget);

   239

   240

	v = --_last_window;

   241

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

   242

	memcpy(w, w + 1, count);

   243

}

   244

   245

Window *FindWindowById(WindowClass cls, WindowNumber number)

   246

{

   247

	Window *w;

   248

   249

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

   250

		if (w->window_class == cls &&

   251

			  w->window_number == number) {

   252

			return w;

   253

		}

   254

	}

   255

   256

	return NULL;

   257

}

   258

   259

void DeleteWindowById(WindowClass cls, WindowNumber number)

   260

{

   261

	DeleteWindow(FindWindowById(cls, number));

   262

}

   263

   264

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   265

{

   266

	Window *w = FindWindowById(cls, number);

   267

   268

	if (w != NULL) {

   269

		w->flags4 |= WF_WHITE_BORDER_MASK;

   270

		SetWindowDirty(w);

   271

		w = BringWindowToFront(w);

   272

	}

   273

   274

	return w;

   275

}

   276

   277

Window *BringWindowToFront(Window *w)

   278

{

   279

	Window *v;

   280

	Window temp;

   281

   282

	v = _last_window;

   283

	do {

   284

		if (--v < _windows)

   285

			return w;

   286

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

   287

   288

	if (w == v)

   289

		return w;

   290

   291

	assert(w < v);

   292

   293

	temp = *w;

   294

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

   295

	*v = temp;

   296

   297

	SetWindowDirty(v);

   298

   299

	return v;

   300

}

   301

   302

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

   303

 * Keep all important windows intact */

   304

static Window *FindDeletableWindow(void)

   305

{

   306

	Window *w;

   307

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

   308

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

   309

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

   310

				!(w->flags4 & WF_STICKY) )

   311

				return w;

   312

	}

   313

	return NULL;

   314

}

   315

   316

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

   317

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

   318

static Window *ForceFindDeletableWindow(void)

   319

{

   320

	Window *w;

   321

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

   322

		assert(w < _last_window);

   323

   324

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

   325

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

   326

				return w;

   327

	}

   328

}

   329

   330

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

   331

{

   332

	return (w->original_widget == widget);

   333

}

   334

   335

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

   336

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

   337

{

   338

	w->original_widget = widget;

   339

   340

	if (widget != NULL) {

   341

		const Widget *wi = widget;

   342

		uint index = 1;

   343

		while (wi->type != WWT_LAST) {

   344

			wi++;

   345

			index++;

   346

		}

   347

   348

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

   349

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

   350

	} else {

   351

		w->widget = NULL;

   352

	}

   353

}

   354

   355

Window *AllocateWindow(

   356

							int x,

   357

							int y,

   358

							int width,

   359

							int height,

   360

							WindowProc *proc,

   361

							WindowClass cls,

   362

							const Widget *widget)

   363

{

   364

	Window *w;

   365

   366

	w = _last_window;

   367

   368

	if (w >= endof(_windows)) {

   369

		w = FindDeletableWindow();

   370

   371

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

   372

			w = ForceFindDeletableWindow();

   373

   374

		DeleteWindow(w);

   375

		w = _last_window;

   376

	}

   377

   378

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

   379

		Window *v;

   380

   381

		v = FindWindowById(WC_MAIN_TOOLBAR, 0);

   382

		if (v) {

   383

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

   384

			w = v;

   385

		}

   386

   387

		v = FindWindowById(WC_STATUS_BAR, 0);

   388

		if (v) {

   389

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

   390

			w = v;

   391

		}

   392

	}

   393

   394

	/* XXX: some more code here */

   395

	w->window_class = cls;

   396

	w->flags4 = WF_WHITE_BORDER_MASK;

   397

	w->caption_color = 0xFF;

   398

	w->window_number = 0;

   399

	w->left = x;

   400

	w->top = y;

   401

	w->width = width;

   402

	w->height = height;

   403

	w->viewport = NULL;

   404

	w->desc_flags = 0;

   405

//	w->landscape_assoc = 0xFFFF;

   406

	w->wndproc = proc;

   407

	w->click_state = 0;

   408

	w->disabled_state = 0;

   409

	w->hidden_state = 0;

   410

//	w->unk22 = 0xFFFF;

   411

	w->vscroll.pos = 0;

   412

	w->vscroll.count = 0;

   413

	w->hscroll.pos = 0;

   414

	w->hscroll.count = 0;

   415

	AssignWidgetToWindow(w, widget);

   416

	w->resize.width = width;

   417

	w->resize.height = height;

   418

	w->resize.step_width = 1;

   419

	w->resize.step_height = 1;

   420

   421

	{

   422

		uint i;

   423

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

   424

			w->custom[i] = 0;

   425

	}

   426

   427

	_last_window++;

   428

   429

	SetWindowDirty(w);

   430

   431

	CallWindowEventNP(w, WE_CREATE);

   432

   433

	return w;

   434

}

   435

   436

Window *AllocateWindowAutoPlace2(

   437

	WindowClass exist_class,

   438

	WindowNumber exist_num,

   439

	int width,

   440

	int height,

   441

	WindowProc *proc,

   442

	WindowClass cls,

   443

	const Widget *widget)

   444

{

   445

	Window *w;

   446

	int x;

   447

   448

	w = FindWindowById(exist_class, exist_num);

   449

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

   450

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

   451

	}

   452

   453

	x = w->left;

   454

	if (x > _screen.width - width)

   455

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

   456

   457

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

   458

}

   459

   460

   461

typedef struct SizeRect {

   462

	int left,top,width,height;

   463

} SizeRect;

   464

   465

   466

static SizeRect _awap_r;

   467

   468

static bool IsGoodAutoPlace1(int left, int top)

   469

{

   470

	int right,bottom;

   471

	Window *w;

   472

   473

	_awap_r.left= left;

   474

	_awap_r.top = top;

   475

	right = _awap_r.width + left;

   476

	bottom = _awap_r.height + top;

   477

   478

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

   479

		return false;

   480

   481

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

   482

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

   483

		if (w->window_class == WC_MAIN_WINDOW)

   484

			continue;

   485

   486

		if (right > w->left &&

   487

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

   488

				bottom > w->top &&

   489

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

   490

					return false;

   491

	}

   492

   493

	return true;

   494

}

   495

   496

static bool IsGoodAutoPlace2(int left, int top)

   497

{

   498

	int width,height;

   499

	Window *w;

   500

   501

	_awap_r.left= left;

   502

	_awap_r.top = top;

   503

	width = _awap_r.width;

   504

	height = _awap_r.height;

   505

   506

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

   507

		return false;

   508

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

   509

		return false;

   510

   511

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

   512

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

   513

		if (w->window_class == WC_MAIN_WINDOW)