1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "map.h"

     5

#include "window.h"

     6

#include "gfx.h"

     7

#include "viewport.h"

     8

#include "console.h"

     9

    10

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

    11

static Point _drag_delta;

    12

    13

void HandleButtonClick(Window *w, byte widget)

    14

{

    15

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

    16

	w->flags4 |= 5 << WF_TIMEOUT_SHL;

    17

	InvalidateWidget(w, widget);

    18

}

    19

    20

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

    21

	WindowEvent e;

    22

	const Widget *wi;

    23

    24

	e.click.pt.x = x;

    25

	e.click.pt.y = y;

    26

	e.event = WE_CLICK;

    27

    28

	if (w->desc_flags & WDF_DEF_WIDGET) {

    29

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

    30

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

    31

    32

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

    33

    34

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

    35

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

    36

			return;

    37

    38

		if (wi->type & 0xE0) {

    39

			/* special widget handling for buttons*/

    40

			switch(wi->type) {

    41

			case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

    42

			case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

    43

				HandleButtonClick(w, e.click.widget);

    44

				break;

    45

			case WWT_NODISTXTBTN:

    46

				break;

    47

			}

    48

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

    49

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

    50

		}

    51

    52

		if (w->desc_flags & WDF_STD_BTN) {

    53

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

    54

				DeleteWindow(w);

    55

				return;

    56

			}

    57

    58

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

    59

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

    60

				return;

    61

			}

    62

		}

    63

    64

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

    65

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

    66

			return;

    67

		}

    68

    69

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

    70

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

    71

			w->flags4 ^= WF_STICKY;

    72

			InvalidateWidget(w, e.click.widget);

    73

			return;

    74

		}

    75

	}

    76

    77

	w->wndproc(w, &e);

    78

}

    79

    80

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

    81

	WindowEvent e;

    82

    83

	/* default tooltips handler? */

    84

	if (w->desc_flags & WDF_STD_TOOLTIPS) {

    85

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

    86

		if (e.click.widget < 0)

    87

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

    88

    89

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

    90

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

    91

			return;

    92

		}

    93

	}

    94

    95

	e.event = WE_RCLICK;

    96

	e.click.pt.x = x;

    97

	e.click.pt.y = y;

    98

	w->wndproc(w, &e);

    99

}

   100

   101

   102

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

   103

{

   104

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

   105

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

   106

	Scrollbar *sb;

   107

   108

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

   109

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

   110

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

   111

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

   112

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

   113

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

   114

   115

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

   116

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

   117

			if (pos != sb->pos) {

   118

				sb->pos = pos;

   119

				SetWindowDirty(w);

   120

			}

   121

		}

   122

	}

   123

}

   124

   125

   126

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

   127

{

   128

	Window *w;

   129

	DrawPixelInfo bk;

   130

	_cur_dpi = &bk;

   131

   132

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

   133

		if (right > w->left &&

   134

				bottom > w->top &&

   135

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

   136

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

   137

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

   138

			}

   139

	}

   140

}

   141

   142

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

   143

{

   144

	Window *v = w;

   145

	int x;

   146

   147

	while (++v != _last_window) {

   148

		if (right > v->left &&

   149

		 		bottom > v->top &&

   150

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

   151

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

   152

   153

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

   154

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

   155

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

   156

				return;

   157

			}

   158

   159

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

   160

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

   161

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

   162

				return;

   163

			}

   164

   165

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

   166

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

   167

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

   168

				return;

   169

			}

   170

   171

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

   172

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

   173

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

   174

				return;

   175

			}

   176

   177

			return;

   178

		}

   179

	}

   180

   181

	{

   182

		DrawPixelInfo *dp = _cur_dpi;

   183

		dp->width = right - left;

   184

		dp->height = bottom - top;

   185

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

   186

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

   187

		dp->pitch = _screen.pitch;

   188

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

   189

		dp->zoom = 0;

   190

		CallWindowEventNP(w, WE_PAINT);

   191

	}

   192

}

   193

   194

void CallWindowEventNP(Window *w, int event)

   195

{

   196

	WindowEvent e;

   197

   198

	e.event = event;

   199

	w->wndproc(w, &e);

   200

}

   201

   202

void SetWindowDirty(Window *w)

   203

{

   204

	if (w == NULL)

   205

		return;

   206

   207

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

   208

}

   209

   210

void DeleteWindow(Window *w)

   211

{

   212

	WindowClass wc;

   213

	WindowNumber wn;

   214

	ViewPort *vp;

   215

	Window *v;

   216

	int count;

   217

   218

	if (w == NULL)

   219

		return;

   220

   221

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

   222

		ResetObjectToPlace();

   223

	}

   224

   225

	wc = w->window_class;

   226

	wn = w->window_number;

   227

   228

	CallWindowEventNP(w, WE_DESTROY);

   229

   230

	w = FindWindowById(wc, wn);

   231

   232

	vp = w->viewport;

   233

	w->viewport = NULL;

   234

	if (vp != NULL) {

   235

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

   236

		vp->width = 0;

   237

	}

   238

   239

	SetWindowDirty(w);

   240

   241

	free(w->widget);

   242

   243

	v = --_last_window;

   244

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

   245

	memmove(w, w + 1, count);

   246

}

   247

   248

Window *FindWindowById(WindowClass cls, WindowNumber number)

   249

{

   250

	Window *w;

   251

   252

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

   253

		if (w->window_class == cls &&

   254

			  w->window_number == number) {

   255

			return w;

   256

		}

   257

	}

   258

   259

	return NULL;

   260

}

   261

   262

void DeleteWindowById(WindowClass cls, WindowNumber number)

   263

{

   264

	DeleteWindow(FindWindowById(cls, number));

   265

}

   266

   267

void DeleteWindowByClass(WindowClass cls)

   268

{

   269

	Window *w;

   270

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

   271

		if (w->window_class == cls) {

   272

			DeleteWindow(w);

   273

			w = _windows;

   274

		} else

   275

			w++;

   276

	}

   277

}

   278

   279

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   280

{

   281

	Window *w = FindWindowById(cls, number);

   282

   283

	if (w != NULL) {

   284

		w->flags4 |= WF_WHITE_BORDER_MASK;

   285

		SetWindowDirty(w);

   286

		w = BringWindowToFront(w);

   287

	}

   288

   289

	return w;

   290

}

   291

   292

Window *BringWindowToFront(Window *w)

   293

{

   294

	Window *v;

   295

	Window temp;

   296

   297

	v = _last_window;

   298

	do {

   299

		if (--v < _windows)

   300

			return w;

   301

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

   302

   303

	if (w == v)

   304

		return w;

   305

   306

	assert(w < v);

   307

   308

	temp = *w;

   309

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

   310

	*v = temp;

   311

   312

	SetWindowDirty(v);

   313

   314

	return v;

   315

}

   316

   317

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

   318

 * Keep all important windows intact */

   319

static Window *FindDeletableWindow(void)

   320

{

   321

	Window *w;

   322

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

   323

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

   324

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

   325

				!(w->flags4 & WF_STICKY) )

   326

				return w;

   327

	}

   328

	return NULL;

   329

}

   330

   331

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

   332

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

   333

static Window *ForceFindDeletableWindow(void)

   334

{

   335

	Window *w;

   336

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

   337

		assert(w < _last_window);

   338

   339

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

   340

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

   341

				return w;

   342

	}

   343

}

   344

   345

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

   346

{

   347

	return (w->original_widget == widget);

   348

}

   349

   350

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

   351

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

   352

{

   353

	w->original_widget = widget;

   354

   355

	if (widget != NULL) {

   356

		const Widget *wi = widget;

   357

		uint index = 1;

   358

		while (wi->type != WWT_LAST) {

   359

			wi++;

   360

			index++;

   361

		}

   362

   363

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

   364

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

   365

	} else {

   366

		w->widget = NULL;

   367

	}

   368

}

   369

   370

Window *AllocateWindow(

   371

							int x,

   372

							int y,

   373

							int width,

   374

							int height,

   375

							WindowProc *proc,

   376

							WindowClass cls,

   377

							const Widget *widget)

   378

{

   379

	Window *w;

   380

   381

	w = _last_window;

   382

   383

	if (w >= endof(_windows)) {

   384

		w = FindDeletableWindow();

   385

   386

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

   387

			w = ForceFindDeletableWindow();

   388

   389

		DeleteWindow(w);

   390

		w = _last_window;

   391

	}

   392

   393

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

   394

		Window *v;

   395

   396

		v = FindWindowById(WC_MAIN_TOOLBAR, 0);

   397

		if (v) {

   398

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

   399

			w = v;

   400

		}

   401

   402

		v = FindWindowById(WC_STATUS_BAR, 0);

   403

		if (v) {

   404

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

   405

			w = v;

   406

		}

   407

	}

   408

   409

	/* XXX: some more code here */

   410

	w->window_class = cls;

   411

	w->flags4 = WF_WHITE_BORDER_MASK;

   412

	w->caption_color = 0xFF;

   413

	w->window_number = 0;

   414

	w->left = x;

   415

	w->top = y;

   416

	w->width = width;

   417

	w->height = height;

   418

	w->viewport = NULL;

   419

	w->desc_flags = 0;

   420

//	w->landscape_assoc = 0xFFFF;

   421

	w->wndproc = proc;

   422

	w->click_state = 0;

   423

	w->disabled_state = 0;

   424

	w->hidden_state = 0;

   425

//	w->unk22 = 0xFFFF;

   426

	w->vscroll.pos = 0;

   427

	w->vscroll.count = 0;

   428

	w->hscroll.pos = 0;

   429

	w->hscroll.count = 0;

   430

	AssignWidgetToWindow(w, widget);

   431

	w->resize.width = width;

   432

	w->resize.height = height;

   433

	w->resize.step_width = 1;

   434

	w->resize.step_height = 1;

   435

   436

	{

   437

		uint i;

   438

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

   439

			w->custom[i] = 0;

   440

	}

   441

   442

	_last_window++;

   443

   444

	SetWindowDirty(w);

   445

   446

	CallWindowEventNP(w, WE_CREATE);

   447

   448

	return w;

   449

}

   450

   451

Window *AllocateWindowAutoPlace2(

   452

	WindowClass exist_class,

   453

	WindowNumber exist_num,

   454

	int width,

   455

	int height,

   456

	WindowProc *proc,

   457

	WindowClass cls,

   458

	const Widget *widget)

   459

{

   460

	Window *w;

   461

	int x;

   462

   463

	w = FindWindowById(exist_class, exist_num);

   464

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

   465

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

   466

	}

   467

   468

	x = w->left;

   469

	if (x > _screen.width - width)

   470

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

   471

   472

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

   473

}

   474

   475

   476

typedef struct SizeRect {

   477

	int left,top,width,height;

   478

} SizeRect;

   479

   480

   481

static SizeRect _awap_r;

   482

   483

static bool IsGoodAutoPlace1(int left, int top)

   484

{

   485

	int right,bottom;

   486

	Window *w;

   487

   488

	_awap_r.left= left;

   489

	_awap_r.top = top;

   490

	right = _awap_r.width + left;

   491

	bottom = _awap_r.height + top;

   492

   493

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

   494

		return false;

   495

   496

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

   497

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

   498

		if (w->window_class == WC_MAIN_WINDOW)

   499

			continue;

   500

   501

		if (right > w->left &&

   502

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

   503

				bottom > w->top &&

   504

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

   505

					return false;

   506

	}

   507

   508

	return true;

   509

}

   510

   511