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

    78

void Widget::SetLeft(int16 val)

    79

{

    80

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

    81

	m_rect.SetLeft(val);

    82

}

    83

    84

void Widget::SetTop(int16 val)

    85

{

    86

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

    87

	m_rect.SetTop(val);

    88

}

    89

    90

void Widget::SetRight(int16 val)

    91

{

    92

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

    93

	m_rect.SetRight(val);

    94

	OnResize(evt_resize);

    95

}

    96

    97

void Widget::SetBottom(int16 val)

    98

{

    99

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

   100

	m_rect.SetBottom(val);

   101

	OnResize(evt_resize);

   102

}

   103

   104

void Widget::SetWidth(int16 val)

   105

{

   106

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

   107

	m_rect.SetWidth(val);

   108

	OnResize(evt_resize);

   109

}

   110

   111

void Widget::SetHeight(int16 val)

   112

{

   113

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

   114

	m_rect.SetHeight(val);

   115

	OnResize(evt_resize);

   116

}

   117

   118

void Widget::SetTopLeft(const Point16 &pt)

   119

{

   120

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

   121

	m_rect.SetTopLeft(pt);

   122

}

   123

   124

void Widget::SetBottomRight(const Point16 &pt)

   125

{

   126

	EvtResize evt_resize(pt - BottomRight());

   127

	m_rect.SetBottomRight(pt);

   128

	OnResize(evt_resize);

   129

}

   130

   131

void Widget::SetSize(const Point16 &pt)

   132

{

   133

	EvtResize evt_resize(pt - Size());

   134

	m_rect.SetSize(pt);

   135

	OnResize(evt_resize);

   136

}

   137

   138

void Widget::SetRect(const Rect16 &rect)

   139

{

   140

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

   141

	m_rect = rect;

   142

	OnResize(evt_resize);

   143

}

   144

   145

void Widget::SetAnchors(Anchors a)

   146

{

   147

	m_anchors = a;

   148

}

   149

   150

WidgetId Widget::GetId() const

   151

{

   152

	return m_id;

   153

}

   154

   155

void Widget::AddHandler(EventHandlerDelegate *d)

   156

{

   157

	m_handlers.push_back(Handler(d));

   158

}

   159

   160

void Widget::CallHandlers(EventBase &e)

   161

{

   162

	BaseWindow *w = GetWindow();

   163

	if (w == NULL) return;

   164

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

   165

		EventHandlerDelegatePtr d = (*it);

   166

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

   167

		d->HandleEvent(w, e);

   168

	}

   169

}

   170

   171

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

   172

{

   173

	uint dark         = _colour_gradient[ctab][3];

   174

	uint medium_dark  = _colour_gradient[ctab][5];

   175

	uint medium_light = _colour_gradient[ctab][6];

   176

	uint light        = _colour_gradient[ctab][7];

   177

   178

	if (flags & FR_TRANSPARENT) {

   179

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

   180

	} else {

   181

		uint interior;

   182

   183

		if (flags & FR_LOWERED) {

   184

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

   185

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

   186

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

   187

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

   188

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

   189

		} else {

   190

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

   191

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

   192

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

   193

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

   194

			interior = medium_dark;

   195

		}

   196

		if (!(flags & FR_BORDERONLY)) {

   197

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

   198

		}

   199

	}

   200

}

   201

   202

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

   203

{

   204

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

   205

}

   206

   207

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

   208

{

   209

	if (m_container != NULL) {

   210

		return m_container->GetWindow();

   211

	}

   212

	return NULL;

   213

}

   214

   215

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

   216

{

   217

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

   218

	return NULL;

   219

}

   220

   221

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

   222

{

   223

	m_is_closing = true;

   224

}

   225

   227

{

   229

}

   230

   232

{

   233

	if (m_tooltips != 0) {

   234

		GuiShowTooltips(m_tooltips);

   235

		ev.SetHandled();

   236

		return;

   237

	}

   238

}

   239

   240

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

   241

{

   242

	Rect16 rc = GetRect();

   243

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

   244

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

   245

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

   246

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

   247

		}

   248

	}

   249

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

   250

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

   251

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

   252

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

   253

		}

   254

	}

   255

	SetRect(rc);

   256

}

   257

   258

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

   259

{

   260

	DrawFrameRect(m_color, FR_NONE);

   261

}

   262

   263

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

   264

{

   265

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

   266

	ev.Dispatch();

   267

}

   268

   269

}; // namespace gui