1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include <stdarg.h>

     5

#include "openttd.h"

     6

#include "debug.h"

     7

#include "functions.h"

     8

#include "map.h"

     9

#include "player.h"

    10

#include "window.h"

    11

#include "gfx.h"

    12

#include "viewport.h"

    13

#include "console.h"

    14

#include "variables.h"

    15

#include "table/sprites.h"

    16

#include "genworld.h"

    17

#include "helpers.hpp"

    18

    19

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

    20

static Point _drag_delta;

    21

    22

/*static*/ WindowList Window::s_list;

    23

    24

//static Window _windows[25];

    25

//Window *_z_windows[lengthof(_windows)];

    26

//Window **_last_z_window; ///< always points to the next free space in the z-array

    27

    28

int32 CountedObject::AddRef()

    29

{

    30

	return ++m_ref_cnt;

    31

}

    32

    33

int32 CountedObject::Release()

    34

{

    35

	int32 res = --m_ref_cnt;

    36

	assert(res >= 0);

    37

	if (res == 0) {

    38

		FinalRelease();

    39

		delete this;

    40

	}

    41

	return res;

    42

}

    43

    44

void WindowList::Add(Window *w)

    45

{

    46

	/* we will add the new window before first vital window or at the end */

    47

	Iterator it = w->IsVital() ? m_list.end() : FindFirstVitalWindow();

    48

	/* it should be now at the proper position where new window should be added */

    49

	m_list.insert(it, w);

    50

}

    51

    52

void WindowList::Remove(Window *w)

    53

{

    54

	Iterator it = Find(w);

    55

	if (it != m_list.end()) m_list.erase(it);

    56

}

    57

    63

WindowList::Iterator WindowList::Find(Window *w)

    64

{

    66

	if (it == m_list.end()) {

    67

		DEBUG(misc, 3, "Window (cls %d, number %d) is not open, probably removed by recursive calls",

    68

			w->window_class, w->window_number);

    69

	}

    70

	return it;

    71

}

    72

    78

WindowList::Iterator WindowList::FindFirstVitalWindow()

    79

{

    81

	/* we have stopped on last non-vital window. Move one step forward to locate first vital window. */

    82

	if (it != m_list.end()) ++it;

    83

	return it;

    84

}

    85

    91

WindowList::Iterator WindowList::FindByClass(WindowClass cls)

    92

{

    95

    99

}

   100

   101

WindowList::Iterator WindowList::FindById(WindowClass cls, WindowNumber num)

   102

{

   104

}

   105

   106

/* Open a new window.

   107

* This function is called from AllocateWindow() or AllocateWindowDesc()

   108

* See descriptions for those functions for usage

   109

* See AllocateWindow() for description of arguments.

   110

* Only addition here is window_number, which is the window_number being assigned to the new window

   111

*/

   112

Window::Window(

   113

							 int x, int y, int w, int h,

   114

							 WindowProc *proc, WindowClass cls, const Widget *widget, int wnd_number)

   115

{

   116

	//Window *w = FindFreeWindow();

   117

   118

	///* We have run out of windows, close one and use that as the place for our new one */

   119

	//if (w == NULL) {

   120

	//	w = FindDeletableWindow();

   121

	//	if (w == NULL) w = ForceFindDeletableWindow();

   122

	//	w->Close();

   123

	//}

   124

   125

	// Set up window properties

   126

	//memset(w, 0, sizeof(*w));

   127

	ZeroInit();

   128

   129

	window_class = cls;

   130

	flags4 = WF_WHITE_BORDER_MASK; // just opened windows have a white border

   131

	caption_color = 0xFF;

   132

	left = x;

   133

	top = y;

   134

	width = w;

   135

	height = h;

   136

	wndproc = proc;

   137

	AssignWidgetToWindow(this, widget);

   138

	resize.width = width;

   139

	resize.height = height;

   140

	resize.step_width = 1;

   141

	resize.step_height = 1;

   142

	window_number = wnd_number;

   143

   144

	//{

   145

	//	Window **wz = _last_z_window;

   146

   147

	//	/* Hacky way of specifying always-on-top windows. These windows are

   148

	//	 * always above other windows because they are moved below them.

   149

	//	 * status-bar is above news-window because it has been created earlier.

   150

	//	 * Also, as the chat-window is excluded from this, it will always be

   151

	//	 * the last window, thus always on top.

   152

	//	 * XXX - Yes, ugly, probably needs something like w->always_on_top flag

   153

	//	 * to implement correctly, but even then you need some kind of distinction

   154

	//	 * between on-top of chat/news and status windows, because these conflict */

   155

	//	if (wz != _z_windows && w->window_class != WC_SEND_NETWORK_MSG) {

   156

	//		if (FindWindowById(WC_MAIN_TOOLBAR, 0)     != NULL) wz--;

   157

	//		if (FindWindowById(WC_STATUS_BAR, 0)       != NULL) wz--;

   158

	//		if (FindWindowById(WC_NEWS_WINDOW, 0)      != NULL) wz--;

   159

	//		if (FindWindowById(WC_SEND_NETWORK_MSG, 0) != NULL) wz--;

   160

   161

	//		assert(wz >= _z_windows);

   162

	//		if (wz != _last_z_window) memmove(wz + 1, wz, (byte*)_last_z_window - (byte*)wz);

   163

	//	}

   164

   165

	//	*wz = w;

   166

	//	_last_z_window++;

   167

	//}

   168

   169

	/* add our new window into z-order list */

   170

	Window::s_list.Add(this);

   171

   172

	SetDirty();

   173

	CallWindowEventNP(this, WE_CREATE);

   174

   175

	//return w;

   176

}

   177

   178

/** Find the Window whose parent pointer points to this window

   179

* @parent w Window to find child of

   180

* @return return a Window pointer that is the child of w, or NULL otherwise */

   181

Window* Window::FindChild() const

   182

{

   183

	Window *v;

   184

	FOR_ALL_WINDOWS(v) {

   185

		if (v->parent == this) return v;

   186

	}

   187

   188

	return NULL;

   189

}

   190

   191

void Window::SetDirty() const

   192

{

   193

	if (this == NULL) return;

   194

	SetDirtyBlocks(left, top, left + width, top + height);

   195

}

   196

   197

/*virtual*/ void Window::FinalRelease()

   198

{

   199

	/* Delete any children a window might have in a head-recursive manner */

   200

	Window *v = FindChild();

   201

	if (v != NULL) v->Close();

   202

   203

	if (_thd.place_mode != VHM_NONE &&

   204

		_thd.window_class == window_class &&

   205

		_thd.window_number == window_number) {

   206

			ResetObjectToPlace();

   207

	}

   208

   209

	CallWindowEventNP(this, WE_DESTROY);

   210

	if (viewport != NULL) DeleteWindowViewport(this);

   211

   212

	SetDirty();

   213

	free(widget);

   214

	widget = NULL;

   215

	widget_count = 0;

   216

	parent = NULL;

   217

}

   218

   219

/*virtual*/ void Window::Close()

   220

{

   221

	s_list.Remove(this);

   222

}

   223

   224

/*virtual*/ bool Window::IsVital()

   225

{

   226

	WindowClass wc = window_class;

   227

	return (wc == WC_MAIN_TOOLBAR || wc == WC_STATUS_BAR || wc == WC_NEWS_WINDOW || wc == WC_SEND_NETWORK_MSG);

   228

}

   229

   230

/**

   231

* Open a new window. If there is no space for a new window, close an open

   232

* window. Try to avoid stickied windows, but if there is no else, close one of

   233

* those as well. Then make sure all created windows are below some always-on-top

   234

* ones. Finally set all variables and call the WE_CREATE event

   235

* @param x offset in pixels from the left of the screen

   236

* @param y offset in pixels from the top of the screen

   237

* @param width width in pixels of the window

   238

* @param height height in pixels of the window

   239

* @param *proc @see WindowProc function to call when any messages/updates happen to the window

   240

* @param cls @see WindowClass class of the window, used for identification and grouping

   241

* @param *widget @see Widget pointer to the window layout and various elements

   242

* @return @see Window pointer of the newly created window

   243

*/

   244

/*static*/ Window* Window::Allocate(

   245

																		int x, int y, int width, int height,

   246

																		WindowProc *proc, WindowClass cls, const Widget *widget)

   247

{

   248

	return new Window(x, y, width, height, proc, cls, widget, 0);

   249

}

   250

   251

/*static*/ Window* Window::Get(WindowList::Iterator it)

   252

{

   253

	return (it != s_list.m_list.end()) ? (*it).w : NULL;

   254

}

   255

   256

/*static*/ Window* Window::FindById(WindowClass cls, WindowNumber num)

   257

{

   258

	return Get(s_list.FindById(cls, num));

   259

}

   260

   261

/*static*/ void Window::SetDirtyById(WindowClass cls, WindowNumber num)

   262

{

   263

	Window *w = FindById(cls, num);

   264

	if (w != NULL) w->SetDirty();

   265

}

   266

   267

void CDECL Window::SetWidgetsDisabledState(bool disab_stat, int widgets, ...)

   268

{

   269

	va_list wdg_list;

   270

   271

	va_start(wdg_list, widgets);

   272

   273

	while (widgets != WIDGET_LIST_END) {

   274

		SetWindowWidgetDisabledState(this, widgets, disab_stat);

   275

		widgets = va_arg(wdg_list, int);

   276

	}

   277

   278

	va_end(wdg_list);

   279

}

   280

   281

void CDECL Window::SetWidgetsHiddenState(bool hidden_stat, int widgets, ...)

   282

{

   283

	va_list wdg_list;

   284

   285

	va_start(wdg_list, widgets);

   286

   287

	while (widgets != WIDGET_LIST_END) {

   288

		SetWindowWidgetHiddenState(this, widgets, hidden_stat);

   289

		widgets = va_arg(wdg_list, int);

   290

	}

   291

   292

	va_end(wdg_list);

   293

}

   294

   295

void CDECL Window::SetWidgetsLoweredState(bool lowered_stat, int widgets, ...)

   296

{

   297

	va_list wdg_list;

   298

   299

	va_start(wdg_list, widgets);

   300

   301

	while (widgets != WIDGET_LIST_END) {

   302

		SetWindowWidgetLoweredState(this, widgets, lowered_stat);

   303

		widgets = va_arg(wdg_list, int);

   304

	}

   305

   306

	va_end(wdg_list);

   307

}

   308

   309

void Window::RaiseButtons()

   310

{

   311

	uint i;

   312

   313

	for (i = 0; i < widget_count; i++) {

   314

		if (IsWindowWidgetLowered(this, i)) {

   315

			RaiseWindowWidget(this, i);

   316

			InvalidateWidget(this, i);

   317

		}

   318

	}

   319

}

   320

   321

void Window::HandleButtonClick(byte widget)

   322

{

   323

	LowerWindowWidget(this, widget);

   324

	this->flags4 |= 5 << WF_TIMEOUT_SHL;

   325

	InvalidateWidget(this, widget);

   326

}

   327

   328

/** On clicking on a window, make it the frontmost window of all. However

   329

* there are certain windows that always need to be on-top; these include

   330

* - Toolbar, Statusbar (always on)

   331

* - New window, Chatbar (only if open)

   332

* The window is marked dirty for a repaint if the window is actually moved

   333

* @param w window that is put into the foreground

   334

* @return pointer to the window, the same as the input pointer

   335

*/

   336

void Window::BringToFront()

   337

{

   338

	WindowPtr wp = this;

   339

	WindowList::Iterator it = Window::s_list.Find(this);

   340

	Window::s_list.Remove(this);

   341

	Window::s_list.Add(this);

   342

   343

	SetDirty();

   344

}

   345

   346

/** Find a window and make it the top-window on the screen. The window

   347

* gets a white border for a brief period of time to visualize its

   348

* "activation"

   349

* @return a pointer to the window thus activated */

   350

/*static*/ Window* Window::BringToFrontById(WindowClass cls, WindowNumber num)

   351

{

   352

	Window *w = FindById(cls, num);

   353

	if (w != NULL) {

   354

		w->flags4 |= WF_WHITE_BORDER_MASK;

   355

		w->BringToFront();

   356

	}

   357

	return w;

   358

}

   359

   360

static bool _dragging_window;

   361

   362

void Window::StartDrag()

   363

{

   364

	flags4 |= WF_DRAGGING;

   365

	_dragging_window = true;

   366

   367

	_drag_delta.x = left - _cursor.pos.x;

   368

	_drag_delta.y = top  - _cursor.pos.y;

   369

   370

	BringToFront();

   371

	DeleteWindowById(WC_DROPDOWN_MENU, 0);

   372

}

   373

   374

bool Window::ContinueDrag()

   375

{

   376

	const Widget *t = &widget[1]; // the title bar ... ugh

   377

	const Window *v;

   378

	int x;

   379

	int y;

   380

	int nx;

   381

	int ny;

   382

   383

	// Stop the dragging if the left mouse button was released

   384

	if (!_left_button_down) {

   385

		flags4 &= ~WF_DRAGGING;

   386

		_dragging_window = false;

   387

		return false;

   388

	}

   389

   390

	SetDirty();

   391

   392

	x = _cursor.pos.x + _drag_delta.x;

   393

	y = _cursor.pos.y + _drag_delta.y;

   394

	nx = x;

   395

	ny = y;

   396

   397

	if (_patches.window_snap_radius != 0) {

   398

		Window *v;

   399

   400

		int hsnap = _patches.window_snap_radius;

   401

		int vsnap = _patches.window_snap_radius;

   402

		int delta;

   403

   404

		FOR_ALL_WINDOWS(v) {

   405

			if (v == this) continue; // Don't snap at yourself

   406

   407

			if (y + height > v->top && y < v->top + v->height) {

   408

				// Your left border <-> other right border

   409

				delta = abs(v->left + v->width - x);

   410

				if (delta <= hsnap) {

   411

					nx = v->left + v->width;

   412

					hsnap = delta;

   413

				}

   414

   415

				// Your right border <-> other left border

   416

				delta = abs(v->left - x - width);

   417

				if (delta <= hsnap) {

   418

					nx = v->left - width;

   419

					hsnap = delta;

   420

				}

   421

			}

   422

   423

			if (top + height >= v->top && top <= v->top + v->height) {

   424

				// Your left border <-> other left border

   425

				delta = abs(v->left - x);

   426

				if (delta <= hsnap) {

   427

					nx = v->left;

   428

					hsnap = delta;

   429

				}

   430

   431

				// Your right border <-> other right border

   432

				delta = abs(v->left + v->width - x - width);

   433

				if (delta <= hsnap) {

   434

					nx = v->left + v->width - width;

   435

					hsnap = delta;

   436

				}

   437

			}

   438

   439

			if (x + width > v->left && x < v->left + v->width) {

   440

				// Your top border <-> other bottom border

   441

				delta = abs(v->top + v->height - y);

   442

				if (delta <= vsnap) {

   443

					ny = v->top + v->height;

   444

					vsnap = delta;

   445

				}

   446

   447

				// Your bottom border <-> other top border

   448

				delta = abs(v->top - y - height);

   449

				if (delta <= vsnap) {

   450

					ny = v->top - height;

   451

					vsnap = delta;

   452

				}

   453

			}

   454

   455

			if (left + width >= v->left && left <= v->left + v->width) {

   456

				// Your top border <-> other top border

   457

				delta = abs(v->top - y);

   458

				if (delta <= vsnap) {

   459

					ny = v->top;

   460

					vsnap = delta;

   461

				}

   462

   463

				// Your bottom border <-> other bottom border

   464

				delta = abs(v->top + v->height - y - height);

   465

				if (delta <= vsnap) {

   466

					ny = v->top + v->height - height;

   467

					vsnap = delta;

   468

				}

   469

			}

   470

		}

   471

	}

   472

   473

	// Make sure the window doesn't leave the screen

   474

	// 13 is the height of the title bar

   475

	nx = clamp(nx, 13 - t->right, _screen.width - 13 - t->left);

   476

	ny = clamp(ny, 0, _screen.height - 13);

   477

   478

	// Make sure the title bar isn't hidden by behind the main tool bar

   479

	v = Window::FindById(WC_MAIN_TOOLBAR, 0);

   480

	if (v != NULL) {

   481

		int v_bottom = v->top + v->height;

   482

		int v_right = v->left + v->width;

   483

		if (ny + t->top >= v->top && ny + t->top < v_bottom) {

   484

			if ((v->left < 13 && nx + t->left < v->left) ||

   485

				(v_right > _screen.width - 13 && nx + t->right > v_right)) {

   486

					ny = v_bottom;

   487

			} else {

   488

				if (nx + t->left > v->left - 13 &&

   489

					nx + t->right < v_right + 13) {

   490

						if (top >= v_bottom) {

   491

							ny = v_bottom;

   492

						} else if (left < nx) {

   493

							nx = v->left - 13 - t->left;