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 "../strings.h"

    16

#include "../table/sprites.h"

    17

#include "../genworld.h"

    18

#include "../helpers.hpp"

    19

#include "window_events.hpp"

    20

    21

namespace gui {

    22

    23

int16 Widget::Left() const

    24

{

    25

	return m_rect.Left();

    26

}

    27

    28

int16 Widget::Top() const

    29

{

    30

	return m_rect.Top();

    31

}

    32

    33

int16 Widget::Right() const

    34

{

    35

	return m_rect.Right();

    36

}

    37

    38

int16 Widget::Bottom() const

    39

{

    40

	return m_rect.Bottom();

    41

}

    42

    43

int16 Widget::Width() const

    44

{

    45

	return m_rect.Width();

    46

}

    47

    48

int16 Widget::Height() const

    49

{

    50

	return m_rect.Height();

    51

}

    52

    53

const Point16& Widget::TopLeft() const

    54

{

    55

	return m_rect.TopLeft();

    56

}

    57

    58

const Point16& Widget::BottomRight() const

    59

{

    60

	return m_rect.BottomRight();

    61

}

    62

    63

Size16 Widget::GetSize() const

    64

{

    65

	return m_rect.Size();

    66

}

    67

    68

Point16 Widget::CenterPt() const

    69

{

    70

	return m_rect.CenterPt();

    71

}

    72

    73

const Rect16& Widget::GetRect() const

    74

{

    75

	return m_rect;

    76

}

    77

    78

Rect16 Widget::GetLocalRect() const

    79

{

    80

	return Rect16(Point16(0, 0), BottomRight() - TopLeft());

    81

}

    82

    83

Point16 Widget::GetTopLeftInWindow() const

    84

{

    85

	Point16 pt = TopLeft();

    86

	if (m_container != NULL) pt += m_container->GetTopLeftInWindow();

    87

	return pt;

    88

}

    89

    90

void Widget::SetLeft(int16 val)

    91

{

    92

	m_rect.SetRight(Right() + val - Left());

    93

	m_rect.SetLeft(val);

    94

}

    95

    96

void Widget::SetTop(int16 val)

    97

{

    98

	m_rect.SetBottom(Bottom() + val - Top());

    99

	m_rect.SetTop(val);

   100

}

   101

   102

void Widget::SetRight(int16 val)

   103

{

   104

	EvtResize evt_resize(Point16(val - Right(), 0));

   105

	m_rect.SetRight(val);

   106

	OnResize(evt_resize);

   107

}

   108

   109

void Widget::SetBottom(int16 val)

   110

{

   111

	EvtResize evt_resize(Point16(0, val - Bottom()));

   112

	m_rect.SetBottom(val);

   113

	OnResize(evt_resize);

   114

}

   115

   116

void Widget::SetWidth(int16 val)

   117

{

   118

	EvtResize evt_resize(Point16(val - Width(), 0));

   119

	m_rect.SetWidth(val);

   120

	OnResize(evt_resize);

   121

}

   122

   123

void Widget::SetHeight(int16 val)

   124

{

   125

	EvtResize evt_resize(Point16(0, val - Height()));

   126

	m_rect.SetHeight(val);

   127

	OnResize(evt_resize);

   128

}

   129

   130

void Widget::SetTopLeft(const Point16 &pt)

   131

{

   132

	m_rect.SetBottomRight(BottomRight() + pt - TopLeft());

   133

	m_rect.SetTopLeft(pt);

   134

}

   135

   136

void Widget::SetBottomRight(const Point16 &pt)

   137

{

   138

	EvtResize evt_resize(pt - BottomRight());

   139

	m_rect.SetBottomRight(pt);

   140

	OnResize(evt_resize);

   141

}

   142

   143

void Widget::SetSize(const Point16 &pt)

   144

{

   145

	EvtResize evt_resize(pt - GetSize());

   146

	m_rect.SetSize(pt);

   147

	OnResize(evt_resize);

   148

}

   149

   150

void Widget::SetRect(const Rect16 &rect)

   151

{

   152

	EvtResize evt_resize(rect.Size() - GetSize());

   153

	m_rect = rect;

   154

	OnResize(evt_resize);

   155

}

   156

   157

void Widget::SetSlotRect(const Rect16 &rc_slot)

   158

{

   159

	Rect16 rc = rc_slot;

   160

	if ((m_feature_flags & FF_MIN_WIDTH) != FF_NONE) {

   161

		switch (m_feature_flags & (FF_ALIGN_LEFT | FF_ALIGN_RIGHT)) {

   162

			case FF_ALIGN_HCENTER:

   163

				rc.DoMove((rc.Width() - m_min_size.x) / 2, 0);

   164

				break;

   165

			case FF_ALIGN_RIGHT:

   166

				rc.DoMove(rc.Width() - m_min_size.x, 0);

   167

				/* fall down to FF_ALIGN_LEFT */

   168

			case FF_ALIGN_LEFT:

   169

			default:

   170

				break;

   171

		}

   172

		rc.SetWidth(m_min_size.x);

   173

	}

   174

	if ((m_feature_flags & FF_MIN_HEIGHT) != FF_NONE) {

   175

		switch (m_feature_flags & (FF_ALIGN_TOP | FF_ALIGN_BOTTOM)) {

   176

			case FF_ALIGN_VCENTER:

   177

				rc.DoMove(0, (rc.Height() - m_min_size.y) / 2);

   178

				break;

   179

			case FF_ALIGN_BOTTOM:

   180

				rc.DoMove(0, rc.Height() - m_min_size.y);

   181

				/* fall down to FF_ALIGN_TOP */

   182

			case FF_ALIGN_TOP:

   183

			default:

   184

				break;

   185

		}

   186

		rc.SetHeight(m_min_size.y);

   187

	}

   188

	SetRect(rc);

   189

}

   190

   191

/** Check widget size against minimal size and resize if needed. Return true if resized. */

   192

bool Widget::CheckMinSize()

   193

{

   194

	Size16 size = GetSize();

   195

	Size16 new_size(max(size.x, m_min_size.x), max(size.y, m_min_size.y));

   196

	if (new_size != size) {

   197

		/* The current size if smaller then minimal size. */

   198

		SetSize(new_size);

   199

		return true;

   200

	}

   201

	return false;

   202

}

   203

   204

uint16 Widget::GetColor() const

   205

{

   206

	return m_color;

   207

}

   208

   209

byte Widget::GetBkColor() const

   210

{

   211

	if (m_color == COLOUR_PARENT || m_color == COLOUR_TRANSPARENT) {

   212

		if (m_container == NULL) return 0;

   213

		return m_container->GetBkColor();

   214

	}

   215

	return (byte)m_color;

   216

}

   217

   218

void Widget::SetColor(uint16 val)

   219

{

   220

	m_color = val;

   221

}

   222

   223

void Widget::SetAnchors(Anchors a)

   224

{

   225

	m_anchors = a;

   226

}

   227

   228

WidgetId Widget::GetId() const

   229

{

   230

	return m_id;

   231

}

   232

   233

void Widget::AddHandler(EventHandlerDelegate *d)

   234

{

   235

	m_handlers.push_back(Handler(d));

   236

}

   237

   238

void Widget::CallHandlers(EventBase &e)

   239

{

   240

	BaseWindow *w = GetWindow();

   241

	if (w == NULL) return;

   242

	for (Handlers::iterator it = m_handlers.begin(); it != m_handlers.end(); ++it) {

   243

		EventHandlerDelegatePtr d = (*it);

   244

		if (d->m_code != e.GetCode()) continue;

   245

		d->HandleEvent(w, e);

   246

	}

   247

}

   248

   249

/*static*/ Size16 Widget::GetStringSize(StringID id)

   250

{

   251

	if (id != 0) {

   252

		char str[512];

   253

		GetString(str, id, lastof(str));

   254

		if (str[0] != 0) {

   255

			BoundingRect br = GetStringBoundingBox(str);

   256

			return Size(br.width, br.height);

   257

		}

   258

	}

   259

	return Size16(0, 0);

   260

}

   261

   262

/*static*/ void Widget::DrawFrameRect(int left, int top, int right, int bottom, int ctab, FrameFlags flags)

   263

{

   264

	uint dark         = _colour_gradient[ctab][3];

   265

	uint medium_dark  = _colour_gradient[ctab][5];

   266

	uint medium_light = _colour_gradient[ctab][6];

   267

	uint light        = _colour_gradient[ctab][7];

   268

   269

	if (flags & FR_TRANSPARENT) {

   270

		GfxFillRect(left, top, right, bottom, PALETTE_TO_TRANSPARENT | (1 << USE_COLORTABLE));

   271

	} else if (flags & FR_BG_ONLY) {

   272

		GfxFillRect(left, top, right, bottom, medium_dark);

   273

	} else {

   274

		uint interior;

   275

   276

		if (flags & FR_LOWERED) {

   277

			GfxFillRect(left,     top,     left,  bottom,     dark);

   278

			GfxFillRect(left + 1, top,     right, top,        dark);

   279

			GfxFillRect(right,    top + 1, right, bottom - 1, light);

   280

			GfxFillRect(left + 1, bottom,  right, bottom,     light);

   281

			interior = (flags & FR_DARKENED ? medium_dark : medium_light);

   282

		} else {

   283

			GfxFillRect(left,     top,    left,      bottom - 1, light);

   284

			GfxFillRect(left + 1, top,    right - 1, top,        light);

   285

			GfxFillRect(right,    top,    right,     bottom - 1, dark);

   286

			GfxFillRect(left,     bottom, right,     bottom,     dark);

   287

			interior = medium_dark;

   288

		}

   289

		if (!(flags & FR_BORDERONLY)) {

   290

			GfxFillRect(left + 1, top + 1, right - 1, bottom - 1, interior);

   291

		}

   292

	}

   293

}

   294

   295

void Widget::DrawFrameRect(int ctab, FrameFlags flags)

   296

{

   297

	DrawFrameRect(0, 0, Width() - 1, Height() - 1, ctab, flags);

   298

}

   299

   300

void Widget::DrawSprite(SpriteID img, SpriteID pal, const Point16 &local_pos)

   301

{

   302

	::DrawSprite(img, pal, local_pos.x, local_pos.y);

   303

}

   304

   305

   306

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

   307

{

   308

	if (m_container != NULL) {

   309

		return m_container->GetWindow();

   310

	}

   311

	return NULL;

   312

}

   313

   314

/*virtual*/ Widget* Widget::WidgetFromPt(const Point16 &pt)

   315

{

   316

	if (GetLocalRect().PtInRect(pt)) return this;

   317

	return NULL;

   318

}

   319

   320

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

   321

{

   322

	m_is_closing = true;

   323

}

   324

   325

/*virtual*/ void Widget::OnLeftClick(EvtLeftClick &ev)

   326

{

   327

	CallHandlers(ev);

   328

}

   329

   330

/*virtual*/ void Widget::OnRightButtonDown(EvtRightButtonDown &ev)

   331

{

   332

	if (m_tooltips != 0) {

   333

		GuiShowTooltips(m_tooltips);

   334

		ev.SetHandled();

   335

		return;

   336

	}

   337

}

   338

   339

/*virtual*/ void Widget::OnResizeParent(EvtResizeParent &ev)

   340

{

   341

	Rect16 rc = GetRect();

   342

	if ((m_anchors & PIN_RIGHT) != PIN_NONE) {

   343

		rc.SetRight(rc.Right() + ev.m_change.x);

   344

		if ((m_anchors & PIN_LEFT) == PIN_NONE) {

   345

			rc.SetLeft(rc.Left() + ev.m_change.x);

   346

		}

   347

	}

   348

	if ((m_anchors & PIN_BOTTOM) != PIN_NONE) {

   349

		rc.SetBottom(rc.Bottom() + ev.m_change.y);

   350

		if ((m_anchors & PIN_TOP) == PIN_NONE) {

   351

			rc.SetTop(rc.Top() + ev.m_change.y);

   352

		}

   353

	}

   354

	SetRect(rc);

   355

}

   356

   357

/*virtual*/ void Widget::DrawBackground(EvtPaint &ev)

   358

{

   359

	bool draw_frame = (m_feature_flags & FF_NO_FRAME) == FF_NONE;

   360

	DrawFrameRect(GetBkColor(), draw_frame ? FR_NONE : FR_BG_ONLY);

   361

}

   362

   363

/*virtual*/ void Widget::DispatchEvent(EventBase &ev)

   364

{

   365

	if (ev.m_widget.IsNull()) ev.m_widget = this;

   366

	ev.Dispatch();

   367

}

   368

   369

}; // namespace gui