1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "window.h"

     4

#include "gfx.h"

     5

#include "viewport.h"

     6

#include "console.h"

     7

     8

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

     9

static Point _drag_delta;

    10

    11

void HandleButtonClick(Window *w, byte widget)

    12

{

    13

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

    14

	w->flags4 |= 5 << WF_TIMEOUT_SHL;

    15

	InvalidateWidget(w, widget);

    16

}

    17

    18

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

    19

	WindowEvent e;

    20

	const Widget *wi;

    21

    22

	e.click.pt.x = x;

    23

	e.click.pt.y = y;

    24

	e.event = WE_CLICK;

    25

    26

	if (w->desc_flags & WDF_DEF_WIDGET) {

    27

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

    28

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

    29

    30

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

    31

    32

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

    33

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

    34

			return;

    35

    36

		if (wi->type & 0xE0) {

    37

			/* special widget handling for buttons*/

    38

			switch(wi->type) {

    39

			case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

    40

			case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

    41

				HandleButtonClick(w, e.click.widget);

    42

				break;

    43

			case WWT_NODISTXTBTN:

    44

				break;

    45

			}

    46

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

    47

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

    48

		}

    49

    50

		w->wndproc(w, &e);

    51

    52

		if (w->desc_flags & WDF_STD_BTN) {

    53

			if (e.click.widget == 0) DeleteWindow(w);

    54

			else {

    55

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

    56

					if (_ctrl_pressed)

    57

						StartWindowSizing(w);

    58

					else

    59

						StartWindowDrag(w);

    60

				}

    61

			}

    62

		}

    63

	} else {

    64

		w->wndproc(w, &e);

    65

	}

    66

}

    67

    68

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

    69

	WindowEvent e;

    70

    71

	/* default tooltips handler? */

    72

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

    73

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

    74

		if (e.click.widget < 0)

    75

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

    76

    77

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

    78

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

    79

			return;

    80

		}

    81

	}

    82

    83

	e.event = WE_RCLICK;

    84

	e.click.pt.x = x;

    85

	e.click.pt.y = y;

    86

	w->wndproc(w, &e);

    87

}

    88

    89

    90

void DispatchMouseWheelEvent(Window *w, int wheel)

    91

{

    92

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

    93

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

    94

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

    95

			w->vscroll.pos = pos;

    96

			SetWindowDirty(w);

    97

		}

    98

	}

    99

}

   100

   101

   102

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

   103

{

   104

	Window *w;

   105

	DrawPixelInfo bk;

   106

	_cur_dpi = &bk;

   107

   108

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

   109

		if (right > w->left &&

   110

				bottom > w->top &&

   111

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

   112

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

   113

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

   114

			}

   115

	}

   116

}

   117

   118

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

   119

{

   120

	Window *v = w;

   121

	int x;

   122

   123

	while (++v != _last_window) {

   124

		if (right > v->left &&

   125

		 		bottom > v->top &&

   126

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

   127

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

   128

   129

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

   130

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

   131

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

   132

				return;

   133

			}

   134

   135

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

   136

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

   137

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

   138

				return;

   139

			}

   140

   141

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

   142

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

   143

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

   144

				return;

   145

			}

   146

   147

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

   148

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

   149

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

   150

				return;

   151

			}

   152

   153

			return;

   154

		}

   155

	}

   156

   157

	{

   158

		DrawPixelInfo *dp = _cur_dpi;

   159

		dp->width = right - left;

   160

		dp->height = bottom - top;

   161

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

   162

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

   163

		dp->pitch = _screen.pitch;

   164

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

   165

		dp->zoom = 0;

   166

		CallWindowEventNP(w, WE_PAINT);

   167

	}

   168

}

   169

   170

void CallWindowEventNP(Window *w, int event)

   171

{

   172

	WindowEvent e;

   173

   174

	e.event = event;

   175

	w->wndproc(w, &e);

   176

}

   177

   178

void SetWindowDirty(Window *w)

   179

{

   180

	if (w == NULL)

   181

		return;

   182

   183

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

   184

}

   185

   186

void DeleteWindow(Window *w)

   187

{

   188

	WindowClass wc;

   189

	WindowNumber wn;

   190

	ViewPort *vp;

   191

	Window *v;

   192

	int count;

   193

   194

	if (w == NULL)

   195

		return;

   196

   197

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

   198

		ResetObjectToPlace();

   199

	}

   200

   201

	wc = w->window_class;

   202

	wn = w->window_number;

   203

   204

	CallWindowEventNP(w, WE_DESTROY);

   205

   206

	w = FindWindowById(wc, wn);

   207

   208

	vp = w->viewport;

   209

	w->viewport = NULL;

   210

	if (vp != NULL) {

   211

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

   212

		vp->width = 0;

   213

	}

   214

   215

	SetWindowDirty(w);

   216

   217

	v = --_last_window;

   218

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

   219

	memcpy(w, w + 1, count);

   220

}

   221

   222

Window *FindWindowById(WindowClass cls, WindowNumber number)

   223

{

   224

	Window *w;

   225

   226

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

   227

		if (w->window_class == cls &&

   228

			  w->window_number == number) {

   229

			return w;

   230

		}

   231

	}

   232

   233

	return NULL;

   234

}

   235

   236

void DeleteWindowById(WindowClass cls, WindowNumber number)

   237

{

   238

	DeleteWindow(FindWindowById(cls, number));

   239

}

   240

   241

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   242

{

   243

	Window *w = FindWindowById(cls, number);

   244

   245

	if (w != NULL) {

   246

		w->flags4 |= WF_WHITE_BORDER_MASK;

   247

		SetWindowDirty(w);

   248

		w = BringWindowToFront(w);

   249

	}

   250

   251

	return w;

   252

}

   253

   254

Window *BringWindowToFront(Window *w)

   255

{

   256

	Window *v;

   257

	Window temp;

   258

   259

	v = _last_window;

   260

	do {

   261

		if (--v < _windows)

   262

			return w;

   263

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

   264

   265

	if (w == v)

   266

		return w;

   267

   268

	assert(w < v);

   269

   270

	temp = *w;

   271

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

   272

	*v = temp;

   273

   274

	SetWindowDirty(v);

   275

   276

	return v;

   277

}

   278

   279

Window *AllocateWindow(

   280

							int x,

   281

							int y,

   282

							int width,

   283

							int height,

   284

							WindowProc *proc,

   285

							WindowClass cls,

   286

							const Widget *widget)

   287

{

   288

	Window *w;

   289

   290

restart:;

   291

	w = _last_window;

   292

   293

	if (w >= endof(_windows)) {

   294

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

   295

			assert(w < _last_window);

   296

   297

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

   298

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

   299

   300

					DeleteWindow(w);

   301

					goto restart;

   302

			}

   303

		}

   304

	}

   305

   306

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

   307

		Window *v;

   308

   309

		v = FindWindowById(WC_MAIN_TOOLBAR, 0);

   310

		if (v) {

   311

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

   312

			w = v;

   313

		}

   314

   315

		v = FindWindowById(WC_STATUS_BAR, 0);

   316

		if (v) {

   317

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

   318

			w = v;

   319

		}

   320

	}

   321

   322

	/* XXX: some more code here */

   323

	w->window_class = cls;

   324

	w->flags4 = WF_WHITE_BORDER_MASK;

   325

	w->caption_color = 0xFF;

   326

	w->window_number = 0;

   327

	w->left = x;

   328

	w->top = y;

   329

	w->width = width;

   330

	w->height = height;

   331

	w->viewport = NULL;

   332

	w->desc_flags = 0;

   333

//	w->landscape_assoc = 0xFFFF;

   334

	w->wndproc = proc;

   335

	w->click_state = 0;

   336

	w->disabled_state = 0;

   337

	w->hidden_state = 0;

   338

//	w->unk22 = 0xFFFF;

   339

	w->vscroll.pos = 0;

   340

	w->vscroll.count = 0;

   341

	w->hscroll.pos = 0;

   342

	w->hscroll.count = 0;

   343

	w->widget = widget;

   344

   345

	{

   346

		int i;

   347

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

   348

			w->custom[i] = 0;

   349

	}

   350

   351

	_last_window++;

   352

   353

	SetWindowDirty(w);

   354

   355

	CallWindowEventNP(w, WE_CREATE);

   356

   357

	return w;

   358

}

   359

   360

Window *AllocateWindowAutoPlace2(

   361

	WindowClass exist_class,

   362

	WindowNumber exist_num,

   363

	int width,

   364

	int height,

   365

	WindowProc *proc,

   366

	WindowClass cls,

   367

	const Widget *widget)

   368

{

   369

	Window *w;

   370

	int x;

   371

   372

	w = FindWindowById(exist_class, exist_num);

   373

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

   374

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

   375

	}

   376

   377

	x = w->left;

   378

	if (x > _screen.width - width)

   379

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

   380

   381

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

   382

}

   383

   384

   385

typedef struct SizeRect {

   386

	int left,top,width,height;

   387

} SizeRect;

   388

   389

   390

static SizeRect _awap_r;

   391

   392

static bool IsGoodAutoPlace1(int left, int top)

   393

{

   394

	int right,bottom;

   395

	Window *w;

   396

   397

	_awap_r.left= left;

   398

	_awap_r.top = top;

   399

	right = _awap_r.width + left;

   400

	bottom = _awap_r.height + top;

   401

   402

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

   403

		return false;

   404

   405

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

   406

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

   407

		if (w->window_class == WC_MAIN_WINDOW)

   408

			continue;

   409

   410

		if (right > w->left &&

   411

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

   412

				bottom > w->top &&

   413

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

   414

					return false;

   415

	}

   416

   417

	return true;

   418

}

   419

   420

static bool IsGoodAutoPlace2(int left, int top)

   421

{

   422

	int width,height;

   423

	Window *w;

   424

   425

	_awap_r.left= left;

   426

	_awap_r.top = top;

   427

	width = _awap_r.width;

   428

	height = _awap_r.height;

   429

   430

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

   431

		return false;

   432

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

   433

		return false;

   434

   435

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

   436

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

   437

		if (w->window_class == WC_MAIN_WINDOW)

   438

			continue;

   439

   440

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

   441

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

   442

				top + height > w->top &&

   443

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

   444

					return false;

   445

	}

   446

   447

	return true;

   448

}

   449

   450

Point GetAutoPlacePosition(int width, int height) {

   451

	Window *w;

   452

	Point pt;

   453

   454

	_awap_r.width = width;

   455

	_awap_r.height = height;

   456

   457

	if (IsGoodAutoPlace1(0, 24)) goto ok_pos;

   458

   459

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

   460

		if (w->window_class == WC_MAIN_WINDOW)

   461

			continue;

   462

   463

		if (IsGoodAutoPlace1(w->left+w->width+2,w->top)) goto ok_pos;

   464

		if (IsGoodAutoPlace1(w->left-   width-2,w->top)) goto ok_pos;

   465

		if (IsGoodAutoPlace1(w->left,w->top+w->height+2)) goto ok_pos;

   466

		if (IsGoodAutoPlace1(w->left,w->top-   height-2)) goto ok_pos;

   467

		if (IsGoodAutoPlace1(w->left+w->width+2,w->top+w->height-height)) goto ok_pos;

   468

		if (IsGoodAutoPlace1(w->left-   width-2,w->top+w->height-height)) goto ok_pos;

   469

		if (IsGoodAutoPlace1(w->left+w->width-width,w->top+w->height+2)) goto ok_pos;

   470

		if (IsGoodAutoPlace1(w->left+w->width-width,w->top-   height-2)) goto ok_pos;

   471

	}

   472

   473

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

   474

		if (w->window_class == WC_MAIN_WINDOW)

   475

			continue;

   476

   477

		if (IsGoodAutoPlace2(w->left+w->width+2,w->top)) goto ok_pos;

   478

		if (IsGoodAutoPlace2(w->left-   width-2,w->top)) goto ok_pos;

   479

		if (IsGoodAutoPlace2(w->left,w->top+w->height+2)) goto ok_pos;

   480

		if (IsGoodAutoPlace2(w->left,w->top-   height-2)) goto ok_pos;

   481

	}

   482

   483

	{

   484

		int left=0,top=24;

   485

   486

restart:;

   487

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

   488

			if (w->left == left && w->top == top) {

   489

				left += 5;

   490

				top += 5;

   491

				goto restart;

   492

			}

   493

		}

   494

   495

		pt.x = left;

   496

		pt.y = top;

   497

		return pt;

   498

	}

   499

   500

ok_pos:;

   501

	pt.x = _awap_r.left;

   502

	pt.y = _awap_r.top;

   503

	return pt;

   504

}

   505

   506

Window *AllocateWindowAutoPlace(

   507

	int width,

   508

	int height,

   509

	WindowProc *proc,

   510

	WindowClass cls,

   511

	const Widget *widget) {

   512

   513

	Point pt = GetAutoPlacePosition(width, height);

   514

	return AllocateWindow(pt.x, pt.y, width, height, proc, cls, widget);

   515

}

   516

   517

Window *AllocateWindowDescFront(const WindowDesc *desc, int value)

   518

{

   519

	Window *w;