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

#include "window_events.hpp"

    19

    20

namespace gui {

    21

    22

int16 Widget::Left() const

    23

{

    24

	return m_rect.Left();

    25

}

    26

    27

int16 Widget::Top() const

    28

{

    29

	return m_rect.Top();

    30

}

    31

    32

int16 Widget::Right() const

    33

{

    34

	return m_rect.Right();

    35

}

    36

    37

int16 Widget::Bottom() const

    38

{

    39

	return m_rect.Bottom();

    40

}

    41

    42

int16 Widget::Width() const

    43

{

    44

	return m_rect.Width();

    45

}

    46

    47

int16 Widget::Height() const

    48

{

    49

	return m_rect.Height();

    50

}

    51

    52

const Point16& Widget::TopLeft() const

    53

{

    54

	return m_rect.TopLeft();

    55

}

    56

    57

const Point16& Widget::BottomRight() const

    58

{

    59

	return m_rect.BottomRight();

    60

}

    61

    62

Point16 Widget::Size() const

    63

{

    64

	return m_rect.Size();

    65

}

    66

    67

Point16 Widget::CenterPt() const

    68

{

    69

	return m_rect.CenterPt();

    70

}

    71

    72

const Rect16& Widget::GetRect() const

    73

{

    74

	return m_rect;

    75

}

    76

    77

void Widget::SetLeft(int16 val)

    78

{

    79

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

    80

	m_rect.SetLeft(val);

    81

}

    82

    83

void Widget::SetTop(int16 val)

    84

{

    85

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

    86

	m_rect.SetTop(val);

    87

}

    88

    89

void Widget::SetRight(int16 val)

    90

{

    91

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

    92

	m_rect.SetRight(val);

    93

	OnResize(evt_resize);

    94

}

    95

    96

void Widget::SetBottom(int16 val)

    97

{

    98

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

    99

	m_rect.SetBottom(val);

   100

	OnResize(evt_resize);

   101

}

   102

   103

void Widget::SetWidth(int16 val)

   104

{

   105

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

   106

	m_rect.SetWidth(val);

   107

	OnResize(evt_resize);

   108

}

   109

   110

void Widget::SetHeight(int16 val)

   111

{

   112

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

   113

	m_rect.SetHeight(val);

   114

	OnResize(evt_resize);

   115

}

   116

   117

void Widget::SetTopLeft(const Point16 &pt)

   118

{

   119

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

   120

	m_rect.SetTopLeft(pt);

   121

}

   122

   123

void Widget::SetBottomRight(const Point16 &pt)

   124

{

   125

	EvtResize evt_resize(pt - BottomRight());

   126

	m_rect.SetBottomRight(pt);

   127

	OnResize(evt_resize);

   128

}

   129

   130

void Widget::SetSize(const Point16 &pt)

   131

{

   132

	EvtResize evt_resize(pt - Size());

   133

	m_rect.SetSize(pt);

   134

	OnResize(evt_resize);

   135

}

   136

   137

void Widget::SetRect(const Rect16 &rect)

   138

{

   139

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

   140

	m_rect = rect;

   141

	OnResize(evt_resize);

   142

}

   143

   154

void Widget::SetAnchors(Anchors a)

   155

{

   156

	m_anchors = a;

   157

}

   158

   159

WidgetId Widget::GetId() const

   160

{

   161

	return m_id;

   162

}

   163

   164

void Widget::AddHandler(EventHandlerDelegate *d)

   165

{

   166

	m_handlers.push_back(Handler(d));

   167

}

   168

   169

void Widget::CallHandlers(EventBase &e)

   170

{

   171

	BaseWindow *w = GetWindow();

   172

	if (w == NULL) return;

   173

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

   174

		EventHandlerDelegatePtr d = (*it);

   175

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

   176

		d->HandleEvent(w, e);

   177

	}

   178

}

   179

   180

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

   181

{

   182

	uint dark         = _colour_gradient[ctab][3];

   183

	uint medium_dark  = _colour_gradient[ctab][5];

   184

	uint medium_light = _colour_gradient[ctab][6];

   185

	uint light        = _colour_gradient[ctab][7];

   186

   187

	if (flags & FR_TRANSPARENT) {

   188

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

   191

	} else {

   192

		uint interior;

   193

   194

		if (flags & FR_LOWERED) {

   195

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

   196

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

   197

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

   198

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

   199

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

   200

		} else {

   201

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

   202

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

   203

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

   204

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

   205

			interior = medium_dark;

   206

		}

   207

		if (!(flags & FR_BORDERONLY)) {

   208

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

   209

		}

   210

	}

   211

}

   212

   213

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

   214

{

   215

	DrawFrameRect(Left(), Top(), Right(), Bottom(), ctab, flags);

   216

}

   217

   218

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

   219

{

   220

	if (m_container != NULL) {

   221

		return m_container->GetWindow();

   222

	}

   223

	return NULL;

   224

}

   225

   226

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

   227

{

   228

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

   229

	return NULL;

   230

}

   231

   232

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

   233

{

   234

	m_is_closing = true;

   235

}

   236

   237

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

   238

{

   239

	CallHandlers(ev);

   240

}

   241

   242

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

   243

{

   244

	if (m_tooltips != 0) {

   245

		GuiShowTooltips(m_tooltips);

   246

		ev.SetHandled();

   247

		return;

   248

	}

   249

}

   250

   251

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

   252

{

   253

	Rect16 rc = GetRect();

   254

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

   255

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

   256

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

   257

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

   258

		}

   259

	}

   260

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

   261

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

   262

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

   263

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

   264

		}

   265

	}

   266

	SetRect(rc);

   267

}

   268

   269

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

   270

{

   271

	DrawFrameRect(m_color, FR_NONE);

   272

}

   273

   274

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

   275

{

   276

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

   277

	ev.Dispatch();

   278

}

   279

   280

}; // namespace gui