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

		feature_flags |= gui::FF_SAME_HEIGHT | gui::FF_MAX_WIDTH;

   279

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

   280

		AddWidget(capt_bar, gui::Panel::TOP);

   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, gui::Panel::CENTER);

   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::OnCreate(gui::EvtCreate &ev)

   296

{

   297

	super::OnCreate(ev);

   298

	QuerySizes();

   299

	DoLayout();

   300

}

   301

   302

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

   303

{

   304

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

   305

	if (!ctx.IsEmpty()) super::OnPaint(ev);

   306

}

   307

   308

/*virtual*/ void BaseWindow::OnResize(gui::EvtResize &ev)

   309

{

   310

	if (ev.m_change == Point16(0, 0)) return;

   311

	super::OnResize(ev);

   312

	QuerySizes();

   313

	DoLayout();

   314

}

   315

   316

/**

   317

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

   318

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

   319

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

   320

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

   321

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

   322

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

   323

* @param width width in pixels of the window

   324

* @param height height in pixels of the window

   325

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

   326

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

   327

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

   328

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

   329

*/

   330

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

   331

{

   332

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

   333

	return new BaseWindow(&desc, 0);

   334

}

   335

   336

/**

   337

* Open a new window.

   338

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

   339

* @param window_number the window number of the new window

   340

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

   341

*/

   342

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

   343

{

   344

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

   345

	BaseWindow *w = Allocate(desc, window_number);

   346

	return w;

   347

}

   348

   349

static Point GetAutoPlacePosition(int width, int height);

   350

   351

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

   352

{

   353

	Point pt;

   354

	BaseWindow *w;

   355

   356

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

   357

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

   358

	 * it to an automatic place */

   359

	if (desc->parent_cls != WC_MAIN_WINDOW &&

   360

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

   361

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

   362

   363

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

   364

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

   365

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

   366

			}

   367

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

   368

	} else {

   369

		switch (desc->left) {

   370

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

   371

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

   372

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

   373

													}	break;

   374

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

   375

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

   376

				break;

   377

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

   378

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

   379

				goto allocate_window;

   380

			case WDP_CENTER: /* Centre the window horizontally */

   381

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

   382

				break;

   383

			default:

   384

				pt.x = desc->left;

   385

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

   386

		}

   387

   388

		switch (desc->top) {

   389

			case WDP_CENTER: /* Centre the window vertically */

   390

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

   391

				break;

   392

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

   393

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

   394

			case WDP_AUTO:

   395

				NOT_REACHED();

   396

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

   397

				/* fallthrough */

   398

			default:

   399

				pt.y = desc->top;

   400

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

   401

				break;

   402

		}

   403

	}

   404

   405

allocate_window:

   406

	WindowDesc d2 = *desc;

   407

	d2.left = pt.x;

   408

	d2.top  = pt.y;

   409

	w = new BaseWindow(&d2, window_number);

   410

	return w;

   411

}

   412

   413

   414

/* Open a new window.

   415

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

   416

* See descriptions for those functions for usage

   417

* See AllocateWindow() for description of arguments.

   418

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

   419

*/

   420

//BaseWindow::BaseWindow(

   421

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

   422

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

   423

//{

   424

//	ZeroInit();

   425

//

   426

//	window_class = cls;

   427

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

   428

//	caption_color = 0xFF;

   429

//	left = x;

   430

//	top = y;

   431

//	width = w;

   432

//	height = h;

   433

//	wndproc = proc;

   434

//	this->AssignWidget(widget);

   435

//	resize.width = width;

   436

//	resize.height = height;

   437

//	resize.step_width = 1;

   438

//	resize.step_height = 1;

   439

//	window_number = wnd_number;

   440

//

   441

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

   442

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

   443

//

   444

//	SetDirty();

   445

//	CallEventNP(WE_CREATE);

   446

//}

   447

   448

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

   449

{

   450

	return this;

   451

}

   452

   453

   454

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

   455

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

   456

BaseWindow* BaseWindow::FindChild() const

   457

{

   458

	BaseWindow *v;

   459

	FOR_ALL_WINDOWS(v) {

   460

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

   461

	}

   462

   463

	return NULL;

   464

}

   465

   466

void BaseWindow::SetDirty() const

   467

{

   468

	if (this == NULL) return;

   469

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

   470

}

   471

   472

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

   473

{

   474

	assert(m_is_closing); // should be closed already

   475

   476

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

   477

	BaseWindow *v = FindChild();

   478

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

   479

   480

	if (_thd.place_mode != VHM_NONE &&

   481

		_thd.window_class == window_class &&

   482

		_thd.window_number == window_number) {

   483

			ResetObjectToPlace();

   484

	}

   485

   486

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

   487

   488

	SetDirty();

   489

	free(widget);

   490