1

/* $Id$ */

     2

     3

/** @file window.cpp windowing system, widgets and events */

     4

     5

#include "stdafx.h"

     6

#include <stdarg.h>

     7

#include "openttd.h"

     8

#include "debug.h"

     9

#include "functions.h"

    10

#include "map.h"

    11

#include "player.h"

    12

#include "window.h"

    13

#include "gfx.h"

    14

#include "viewport.h"

    15

#include "console.h"

    16

#include "variables.h"

    17

#include "table/sprites.h"

    18

#include "genworld.h"

    19

#include "helpers.hpp"

    20

#include "widget/window_events.hpp"

    21

#include "widget/widget_types.h"

    22

    23

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

    24

static Point _drag_delta;

    25

    26

/*static*/ WindowList BaseWindow::s_list;

    27

    28

//static BaseWindow _windows[25];

    29

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

    30

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

    31

    32

void WindowList::Add(BaseWindow *w)

    33

{

    34

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

    35

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

    36

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

    37

	m_list.insert(it, w);

    38

}

    39

    40

void WindowList::Remove(BaseWindow *w)

    41

{

    42

	Iterator it = Find(w);

    43

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

    44

		assert(it != m_list.end());

    45

		Item &item = (*it);

    46

		assert(item.w == w);

    47

//		w->Close();

    48

		m_list.erase(it);

    49

	}

    50

}

    51

    52

void WindowList::CloseAll()

    53

{

    54

	BaseWindow *w_prev = NULL;

    55

	while (!m_list.empty()) {

    56

		Iterator it = m_list.begin();

    57

		Item &item = (*it);

    58

		BaseWindow *w = item.w;

    59

		assert(w != w_prev);

    60

		w_prev = w;

    61

		w->Close();

    62

	}

    63

}

    64

    65

static bool MatchWindow(WindowList::Iterator it, BaseWindow *w)

    66

{

    67

	return (*it).w == w;

    68

}

    69

    70

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

    71

{

    72

	Iterator it = EnumT(&MatchWindow, w);

    73

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

    74

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

    75

			w->window_class, w->window_number);

    76

	}

    77

	return it;

    78

}

    79

    80

static bool MatchNonVitalWindow(WindowList::Iterator it)

    81

{

    82

	return !(*it).w->IsVital();

    83

}

    84

    85

WindowList::Iterator WindowList::FindFirstVitalWindow()

    86

{

    87

	Iterator it = ReverseEnumT(&MatchNonVitalWindow);

    88

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

    89

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

    90

	return it;

    91

}

    92

    93

static bool MatchClass(WindowList::Iterator it, WindowClass cls)

    94

{

    95

	return (*it).w->window_class == cls;

    96

}

    97

    98

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

    99

{

   100

	return EnumT(&MatchClass, cls);

   101

}

   102

   103

static bool MatchClassAndId(WindowList::Iterator it, WindowClass cls, WindowNumber num)

   104

{

   105

	return (*it).w->window_class == cls && (*it).w->window_number == num;

   106

}

   107

   108

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

   109

{

   110

	return EnumT(&MatchClassAndId, cls, num);

   111

}

   112

   113

static bool MatchXY(WindowList::Iterator it, int x, int y)

   114

{

   115

	BaseWindow *w = (*it).w;

   116

	return IS_INSIDE_1D(x, w->Left(), w->Width()) && IS_INSIDE_1D(y, w->Top(), w->Height());

   117

}

   118

   119

/** Do a search for a window at specific coordinates. For this we start

   120

* at the topmost window, obviously and work our way down to the bottom

   121

* @return a pointer to the found window if any, NULL otherwise */

   122

WindowList::Iterator WindowList::FindFromPt(int x, int y)

   123

{

   124

	return ReverseEnumT(&MatchXY, x, y);

   125

}

   126

   127

   128

   129

   130

int16 BaseWindow::Left() const

   131

{

   132

	assert(super::TopLeft() == Point16(0, 0));

   133

	return m_wnd_pos.x;

   134

}

   135

   136

int16 BaseWindow::Top() const

   137

{

   138

	assert(super::TopLeft() == Point16(0, 0));

   139

	return m_wnd_pos.y;

   140

}

   141

   142

int16 BaseWindow::Right() const

   143

{

   144

	assert(super::TopLeft() == Point16(0, 0));

   145

	return m_wnd_pos.x + super::Right();

   146

}

   147

   148

int16 BaseWindow::Bottom() const

   149

{

   150

	assert(super::TopLeft() == Point16(0, 0));

   151

	return m_wnd_pos.y + super::Bottom();

   152

}

   153

   154

const Point16& BaseWindow::TopLeft() const

   155

{

   156

	assert(super::TopLeft() == Point16(0, 0));

   157

	return m_wnd_pos;

   158

}

   159

   160

Point16 BaseWindow::BottomRight() const

   161

{

   162

	assert(super::TopLeft() == Point16(0, 0));

   163

	return m_wnd_pos + super::BottomRight();

   164

}

   165

   166

Rect16 BaseWindow::GetRect() const

   167

{

   168

	assert(super::TopLeft() == Point16(0, 0));

   169

	return super::GetRect() + m_wnd_pos;

   170

}

   171

   172

   173

void BaseWindow::SetLeft(int16 val)

   174

{

   175

	assert(super::TopLeft() == Point16(0, 0));

   176

	m_wnd_pos.x = val;

   177

}

   178

   179

void BaseWindow::SetTop(int16 val)

   180

{

   181

	assert(super::TopLeft() == Point16(0, 0));

   182

	m_wnd_pos.y = val;

   183

}

   184

   185

void BaseWindow::SetRight(int16 val)

   186

{

   187

	assert(super::TopLeft() == Point16(0, 0));

   188

	assert(val >= m_wnd_pos.x);

   189

	super::SetRight(val - m_wnd_pos.x);

   190

}

   191

   192

void BaseWindow::SetBottom(int16 val)

   193

{

   194

	assert(super::TopLeft() == Point16(0, 0));

   195

	assert(val >= m_wnd_pos.y);

   196

	super::SetBottom(val - m_wnd_pos.y);

   197

}

   198

   199

void BaseWindow::SetTopLeft(const Point16 &pt)

   200

{

   201

	assert(super::TopLeft() == Point16(0, 0));

   202

	m_wnd_pos = pt;

   203

}

   204

   205

void BaseWindow::SetBottomRight(const Point16 &pt)

   206

{

   207

	assert(super::TopLeft() == Point16(0, 0));

   208

	super::SetBottomRight(pt - m_wnd_pos);

   209

}

   210

   211

void BaseWindow::SetSize(const Point16 &pt)

   212

{

   213

	assert(super::TopLeft() == Point16(0, 0));

   214

	super::SetSize(pt);

   215

}

   216

   217

void BaseWindow::SetRect(const Rect16 &rect)

   218

{

   219

	assert(super::TopLeft() == Point16(0, 0));

   220

	m_wnd_pos = rect.top_left;

   221

	super::SetBottomRight(rect.Size());

   222

}

   223

   224

   225

/*virtual*/ bool BaseWindow::Create(WindowNumber num)

   226

{

   227

	window_number = num;

   228

	flash_timeout = 3; // just opened windows have a white border

   229

	caption_color = 0xFF;

   230

	wndproc = &BaseWindow::DefaultWndProc;

   231

   232

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

   233

	BaseWindow::s_list.Add(this);

   234

   235

	/* Finalize the creation process */

   236

	CallEventNP(WE_CREATE);

   237

   238

	/* window should have some widgets now */

   239

	assert(widget != NULL || m_widgets.size() > 0);

   240

   241

	SetDirty();

   242

	return true;

   243

}

   244

   245

/*virtual*/ bool BaseWindow::Create(const WindowDesc *desc, WindowNumber num)

   246

{

   247

	window_class = desc->cls;

   248

	flash_timeout = 3; // just opened windows have a white border

   249

	caption_color = 0xFF;

   250

	SetTopLeft(Point16(desc->left, desc->top));

   251

	SetSize(Point16(desc->width, desc->height));

   252

   253

	wndproc = desc->proc != NULL ? desc->proc : &BaseWindow::DefaultWndProc;

   254

	desc_flags = desc->flags;

   255

	AssignWidget(desc->widgets);

   256

	resize.width = Width();

   257

	resize.height = Height();

   258

	resize.step_width = 1;

   259

	resize.step_height = 1;

   260

	window_number = num;

   261

   262

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

   263

	BaseWindow::s_list.Add(this);

   264

   265

	/* Finalize the creation process */

   266

	CallEventNP(WE_CREATE);

   267

   268

	SetDirty();

   269

	return true;

   270

}

   271

   272

/*virtual*/ void BaseWindow::CreateNcWidgets()

   273

{

   274

	super::CreateNcWidgets();

   275

	if ((m_feature_flags & gui::FF_NO_CAPTION_BAR) == gui::FF_NONE) {

   276

		/* add caption bar */

   277

		gui::FeatureFlags feature_flags = m_feature_flags & (gui::FF_NO_CLOSE_BOX | gui::FF_NO_STICKY_BOX);

   278

		gui::CaptionBar *capt_bar = new gui::CaptionBar(this, -100, feature_flags, m_color);

   279

		capt_bar->SetAnchors(PIN_LEFT | PIN_TOP | PIN_RIGHT);

   280

		AddWidget(capt_bar);

   281

	}

   282

	if ((m_feature_flags & gui::FF_NO_RESIZE_BOX) == gui::FF_NONE) {

   283

		/* add resize box */

   284

		gui::ResizeBox *resize_box = new gui::ResizeBox(this);

   285

		AddWidget(resize_box);

   286

	}

   287

}

   288

   289

/*virtual*/ void BaseWindow::CreateWidgets()

   290

{

   291

	/* only old windows are allowed to use this fake 'CreateWidgets()' method << new gui must have its own */

   292

	assert(widget != NULL);

   293

}

   294

   295

/*virtual*/ void BaseWindow::OnPaint(gui::EvtPaint &ev)

   296

{

   297

	ClipDrawContext ctx(0, 0, Width(), Height());

   298

	super::OnPaint(ev);

   299

}

   300

   301

/**

   302

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

   303

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

   304

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

   305

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

   306

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

   307

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

   308

* @param width width in pixels of the window

   309

* @param height height in pixels of the window

   310

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

   311

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

   312

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

   313

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

   314

*/

   315

/*static*/ BaseWindow* BaseWindow::Allocate(int x, int y, int width, int height, WindowProc *proc, WindowClass cls, const OldWidget *widget)

   316

{

   317

	WindowDesc desc = {x, y, width, height, cls, WC_NONE, 0, widget, proc};

   318

	return new BaseWindow(&desc, 0);

   319

}

   320

   321

/**

   322

* Open a new window.

   323

* @param *desc The pointer to the WindowDesc to be created

   324

* @param window_number the window number of the new window

   325

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

   326

*/

   327

BaseWindow *BaseWindow::AllocateFront(const WindowDesc *desc, int window_number)

   328

{

   329

	if (BaseWindow::BringToFrontById(desc->cls, window_number) != NULL) return NULL;

   330

	BaseWindow *w = Allocate(desc, window_number);

   331

	return w;

   332

}

   333

   334

static Point GetAutoPlacePosition(int width, int height);

   335

   336

/*static*/ BaseWindow* BaseWindow::Allocate(const WindowDesc *desc, int window_number)

   337

{

   338

	Point pt;

   339

	BaseWindow *w;

   340

   341

	/* By default position a child window at an offset of 10/10 of its parent.

   342

	* However if it falls too extremely outside window positions, reposition

   343

	* it to an automatic place */

   344

	if (desc->parent_cls != WC_MAIN_WINDOW &&

   345

		(w = BaseWindow::FindById(desc->parent_cls, window_number)) != NULL &&

   346

		w->Left() < _screen.width - 20 && w->Left() > -60 && w->Top() < _screen.height - 20) {

   347

   348

			pt.x = w->Left() + 10;

   349

			if (pt.x > _screen.width + 10 - desc->width) {

   350

				pt.x = (_screen.width + 10 - desc->width) - 20;

   351

			}

   352

			pt.y = w->Top() + 10;

   353

	} else {

   354

		switch (desc->left) {

   355

			case WDP_ALIGN_TBR: { /* Align the right side with the top toolbar */

   356

				w = BaseWindow::FindById(WC_MAIN_TOOLBAR, 0);

   357

				pt.x = (w->Left() + w->Width()) - desc->width;

   358

													}	break;

   359

			case WDP_ALIGN_TBL: /* Align the left side with the top toolbar */

   360

				pt.x = BaseWindow::FindById(WC_MAIN_TOOLBAR, 0)->Left();

   361

				break;

   362

			case WDP_AUTO: /* Find a good automatic position for the window */

   363

				pt = GetAutoPlacePosition(desc->width, desc->height);

   364

				goto allocate_window;

   365

			case WDP_CENTER: /* Centre the window horizontally */

   366

				pt.x = (_screen.width - desc->width) / 2;

   367

				break;

   368

			default:

   369

				pt.x = desc->left;

   370

				if (pt.x < 0) pt.x += _screen.width; // negative is from right of the screen

   371

		}

   372

   373

		switch (desc->top) {

   374

			case WDP_CENTER: /* Centre the window vertically */

   375

				pt.y = (_screen.height - desc->height) / 2;

   376

				break;

   377

				/* WDP_AUTO sets the position at once and is controlled by desc->left.

   378

				* Both left and top must be set to WDP_AUTO */

   379

			case WDP_AUTO:

   380

				NOT_REACHED();

   381

				assert(desc->left == WDP_AUTO && desc->top != WDP_AUTO);

   382

				/* fallthrough */

   383

			default:

   384

				pt.y = desc->top;

   385

				if (pt.y < 0) pt.y += _screen.height; // negative is from bottom of the screen

   386

				break;

   387

		}

   388

	}

   389

   390

allocate_window:

   391

	WindowDesc d2 = *desc;

   392

	d2.left = pt.x;

   393

	d2.top  = pt.y;

   394

	w = new BaseWindow(&d2, window_number);

   395

	return w;

   396

}

   397

   398

   399

/* Open a new window.

   400

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

   401

* See descriptions for those functions for usage

   402

* See AllocateWindow() for description of arguments.

   403

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

   404

*/

   405

//BaseWindow::BaseWindow(

   406

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

   407

//							 WindowProc *proc, WindowClass cls, const OldWidget *widget, int wnd_number)

   408

//{

   409

//	ZeroInit();

   410

//

   411

//	window_class = cls;

   412

//	flash_timeout = 3; // just opened windows have a white border

   413

//	caption_color = 0xFF;

   414

//	left = x;

   415

//	top = y;

   416

//	width = w;

   417

//	height = h;

   418

//	wndproc = proc;

   419

//	this->AssignWidget(widget);

   420

//	resize.width = width;

   421

//	resize.height = height;

   422

//	resize.step_width = 1;

   423

//	resize.step_height = 1;

   424

//	window_number = wnd_number;

   425

//

   426

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

   427

//	BaseWindow::s_list.Add(this);

   428

//

   429

//	SetDirty();

   430

//	CallEventNP(WE_CREATE);

   431

//}

   432

   433

/*virtual*/ BaseWindow* BaseWindow::GetWindow()

   434

{

   435

	return this;

   436

}

   437

   438

   439

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

   440

* @parent w BaseWindow to find child of

   441

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

   442

BaseWindow* BaseWindow::FindChild() const

   443

{

   444

	BaseWindow *v;

   445

	FOR_ALL_WINDOWS(v) {

   446

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

   447

	}

   448

   449

	return NULL;

   450

}

   451

   452

void BaseWindow::SetDirty() const

   453

{

   454

	if (this == NULL) return;

   455

	SetDirtyBlocks(Left(), Top(), Left() + Width(), Top() + Height());

   456

}

   457

   458

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

   459

{

   460

	assert(m_is_closing); // should be closed already

   461

   462

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

   463

	BaseWindow *v = FindChild();

   464

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

   465

   466

	if (_thd.place_mode != VHM_NONE &&

   467

		_thd.window_class == window_class &&

   468

		_thd.window_number == window_number) {

   469

			ResetObjectToPlace();

   470

	}

   471

   472

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

   473

   474

	SetDirty();

   475

	free(widget);

   476

	widget = NULL;

   477

	widget_count = 0;

   478

	parent = NULL;

   479

}

   480

   481

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

   482

{

   483

	super::Close();

   484

	CallEventNP(WE_DESTROY);

   485

	s_list.Remove(this);

   486

}

   487

   488

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

   489

{

   490