1

/* $Id$ */

     2

     3

/** @file graph_gui.cpp GUI that shows performance graphs. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "gui.h"

     8

#include "window_gui.h"

     9

#include "player_base.h"

    10

#include "player_gui.h"

    11

#include "economy_func.h"

    12

#include "variables.h"

    13

#include "cargotype.h"

    14

#include "strings_func.h"

    15

#include "core/alloc_func.hpp"

    16

#include "window_func.h"

    17

#include "date_func.h"

    18

#include "gfx_func.h"

    19

#include "sortlist_type.h"

    20

    21

#include "table/strings.h"

    22

#include "table/sprites.h"

    23

    24

/* Bitmasks of player and cargo indices that shouldn't be drawn. */

    25

static uint _legend_excluded_players;

    26

static uint _legend_excluded_cargo;

    27

    28

/* Apparently these don't play well with enums. */

    29

static const OverflowSafeInt64 INVALID_DATAPOINT(INT64_MAX); // Value used for a datapoint that shouldn't be drawn.

    30

static const uint INVALID_DATAPOINT_POS = UINT_MAX;  // Used to determine if the previous point was drawn.

    31

    32

/****************/

    33

/* GRAPH LEGEND */

    34

/****************/

    35

    36

struct GraphLegendWindow : Window {

    37

	GraphLegendWindow(const WindowDesc *desc, WindowNumber window_number) : Window(desc, window_number)

    38

	{

    39

		for (uint i = 3; i < this->widget_count; i++) {

    40

			if (!HasBit(_legend_excluded_players, i - 3)) this->LowerWidget(i);

    41

		}

    42

    43

		this->FindWindowPlacementAndResize(desc);

    44

	}

    45

    46

	virtual void OnPaint()

    47

	{

    48

		for (PlayerID p = PLAYER_FIRST; p < MAX_PLAYERS; p++) {

    49

			if (IsValidPlayerID(p)) continue;

    50

    51

			SetBit(_legend_excluded_players, p);

    52

			this->RaiseWidget(p + 3);

    53

		}

    54

    55

		this->DrawWidgets();

    56

    57

		const Player *p;

    58

		FOR_ALL_PLAYERS(p) {

    59

			DrawPlayerIcon(p->index, 4, 18 + p->index * 12);

    60

    61

			SetDParam(0, p->index);

    62

			SetDParam(1, p->index);

    63

			DrawString(21, 17 + p->index * 12, STR_7021, HasBit(_legend_excluded_players, p->index) ? TC_BLACK : TC_WHITE);

    64

		}

    65

	}

    66

    67

	virtual void OnClick(Point pt, int widget)

    68

	{

    69

		if (!IsInsideMM(widget, 3, 11)) return;

    70

    71

		ToggleBit(_legend_excluded_players, widget - 3);

    72

		this->ToggleWidgetLoweredState(widget);

    73

		this->SetDirty();

    74

		InvalidateWindow(WC_INCOME_GRAPH, 0);

    75

		InvalidateWindow(WC_OPERATING_PROFIT, 0);

    76

		InvalidateWindow(WC_DELIVERED_CARGO, 0);

    77

		InvalidateWindow(WC_PERFORMANCE_HISTORY, 0);

    78

		InvalidateWindow(WC_COMPANY_VALUE, 0);

    79

	}

    80

};

    81

    82

static const Widget _graph_legend_widgets[] = {

    83

{   WWT_CLOSEBOX,   RESIZE_NONE,  COLOUR_GREY,     0,    10,     0,    13, STR_00C5,                       STR_018B_CLOSE_WINDOW},

    84

{    WWT_CAPTION,   RESIZE_NONE,  COLOUR_GREY,    11,   249,     0,    13, STR_704E_KEY_TO_COMPANY_GRAPHS, STR_018C_WINDOW_TITLE_DRAG_THIS},

    85

{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,     0,   249,    14,   113, 0x0,                            STR_NULL},

    86

{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,     2,   247,    16,    27, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

    87

{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,     2,   247,    28,    39, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

    88

{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,     2,   247,    40,    51, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

    89

{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,     2,   247,    52,    63, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

    90

{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,     2,   247,    64,    75, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

    91

{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,     2,   247,    76,    87, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

    92

{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,     2,   247,    88,    99, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

    93

{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,     2,   247,   100,   111, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

    94

{   WIDGETS_END},

    95

};

    96

    97

static const WindowDesc _graph_legend_desc = {

    98

	WDP_AUTO, WDP_AUTO, 250, 114, 250, 114,

    99

	WC_GRAPH_LEGEND, WC_NONE,

   100

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   101

	_graph_legend_widgets,

   102

};

   103

   104

static void ShowGraphLegend()

   105

{

   106

	AllocateWindowDescFront<GraphLegendWindow>(&_graph_legend_desc, 0);

   107

}

   108

   109

/******************/

   110

/* BASE OF GRAPHS */

   111

/*****************/

   112

   113

struct BaseGraphWindow : Window {

   114

protected:

   115

	enum {

   116

		GRAPH_MAX_DATASETS = 32,

   117

		GRAPH_AXIS_LINE_COLOUR  = 215,

   118

   119

		GRAPH_X_POSITION_BEGINNING  = 44,  ///< Start the graph 44 pixels from gd_left

   120

		GRAPH_X_POSITION_SEPARATION = 22,  ///< There are 22 pixels between each X value

   121

   122

		GRAPH_NUM_LINES_Y = 9, ///< How many horizontal lines to draw.

   123

		/* 9 is convenient as that means the distance between them is the gd_height of the graph / 8,

   124

		* which is the same

   125

		* as height >> 3. */

   126

	};

   127

   128

	uint excluded_data; ///< bitmask of the datasets that shouldn't be displayed.

   129

	byte num_dataset;

   130

	byte num_on_x_axis;

   131

	bool has_negative_values;

   132

	byte num_vert_lines;

   133

	static const TextColour graph_axis_label_colour = TC_BLACK; ///< colour of the graph axis label.

   134

   135

	/* The starting month and year that values are plotted against. If month is

   136

	 * 0xFF, use x_values_start and x_values_increment below instead. */

   137

	byte month;

   138

	Year year;

   139

   140

	/* These values are used if the graph is being plotted against values

   141

	 * rather than the dates specified by month and year. */

   142

	uint16 x_values_start;

   143

	uint16 x_values_increment;

   144

   145

	int gd_left, gd_top;  ///< Where to start drawing the graph, in pixels.

   146

	uint gd_height;    ///< The height of the graph in pixels.

   147

	StringID format_str_y_axis;

   148

	byte colors[GRAPH_MAX_DATASETS];

   149

	OverflowSafeInt64 cost[GRAPH_MAX_DATASETS][24]; ///< last 2 years

   150

   151

	void DrawGraph() const

   152

	{

   153

		uint x, y;                       ///< Reused whenever x and y coordinates are needed.

   154

		OverflowSafeInt64 highest_value; ///< Highest value to be drawn.

   155

		int x_axis_offset;               ///< Distance from the top of the graph to the x axis.

   156

   157

		/* the colors and cost array of GraphDrawer must accomodate

   158

		* both values for cargo and players. So if any are higher, quit */

   159

		assert(GRAPH_MAX_DATASETS >= (int)NUM_CARGO && GRAPH_MAX_DATASETS >= (int)MAX_PLAYERS);

   160

		assert(this->num_vert_lines > 0);

   161

   162

		byte grid_colour = _colour_gradient[COLOUR_GREY][4];

   163

   164

		/* The coordinates of the opposite edges of the graph. */

   165

		int bottom = this->gd_top + this->gd_height - 1;

   166

		int right  = this->gd_left + GRAPH_X_POSITION_BEGINNING + this->num_vert_lines * GRAPH_X_POSITION_SEPARATION - 1;

   167

   168

		/* Draw the vertical grid lines. */

   169

   170

		/* Don't draw the first line, as that's where the axis will be. */

   171

		x = this->gd_left + GRAPH_X_POSITION_BEGINNING + GRAPH_X_POSITION_SEPARATION;

   172

   173

		for (int i = 0; i < this->num_vert_lines; i++) {

   174

			GfxFillRect(x, this->gd_top, x, bottom, grid_colour);

   175

			x += GRAPH_X_POSITION_SEPARATION;

   176

		}

   177

   178

		/* Draw the horizontal grid lines. */

   179

		x = this->gd_left + GRAPH_X_POSITION_BEGINNING;

   180

		y = this->gd_height + this->gd_top;

   181

   182

		for (int i = 0; i < GRAPH_NUM_LINES_Y; i++) {

   183

			GfxFillRect(x, y, right, y, grid_colour);

   184

			y -= (this->gd_height / (GRAPH_NUM_LINES_Y - 1));

   185

		}

   186

   187

		/* Draw the y axis. */

   188

		GfxFillRect(x, this->gd_top, x, bottom, GRAPH_AXIS_LINE_COLOUR);

   189

   190

		/* Find the distance from the gd_top of the graph to the x axis. */

   191

		x_axis_offset = this->gd_height;

   192

   193

		/* The graph is currently symmetrical about the x axis. */

   194

		if (this->has_negative_values) x_axis_offset /= 2;

   195

   196

		/* Draw the x axis. */

   197

		y = x_axis_offset + this->gd_top;

   198

		GfxFillRect(x, y, right, y, GRAPH_AXIS_LINE_COLOUR);

   199

   200

		/* Find the largest value that will be drawn. */

   201

		if (this->num_on_x_axis == 0)

   202

			return;

   203

   204

		assert(this->num_on_x_axis > 0);

   205

		assert(this->num_dataset > 0);

   206

   207

		/* Start of with a value of twice the gd_height of the graph in pixels. It's a

   208

		* bit arbitrary, but it makes the cargo payment graph look a little nicer,

   209

		* and prevents division by zero when calculating where the datapoint

   210

		* should be drawn. */

   211

		highest_value = x_axis_offset * 2;

   212

   213

		for (int i = 0; i < this->num_dataset; i++) {

   214

			if (!HasBit(this->excluded_data, i)) {

   215

				for (int j = 0; j < this->num_on_x_axis; j++) {

   216

					OverflowSafeInt64 datapoint = this->cost[i][j];

   217

   218

					if (datapoint != INVALID_DATAPOINT) {

   219

						/* For now, if the graph has negative values the scaling is

   220

						* symmetrical about the x axis, so take the absolute value

   221

						* of each data point. */

   222

						highest_value = max(highest_value, abs(datapoint));

   223

					}

   224

				}

   225

			}

   226

		}

   227

   228

		/* Round up highest_value so that it will divide cleanly into the number of

   229

		* axis labels used. */

   230

		int round_val = highest_value % (GRAPH_NUM_LINES_Y - 1);

   231

		if (round_val != 0) highest_value += (GRAPH_NUM_LINES_Y - 1 - round_val);

   232

   233

		/* draw text strings on the y axis */

   234

		int64 y_label = highest_value;

   235

		int64 y_label_separation = highest_value / (GRAPH_NUM_LINES_Y - 1);

   236

   237

		/* If there are negative values, the graph goes from highest_value to

   238

		* -highest_value, not highest_value to 0. */

   239

		if (this->has_negative_values) y_label_separation *= 2;

   240

   241

		x = this->gd_left + GRAPH_X_POSITION_BEGINNING + 1;

   242

		y = this->gd_top - 3;

   243

   244

		for (int i = 0; i < GRAPH_NUM_LINES_Y; i++) {

   245

			SetDParam(0, this->format_str_y_axis);

   246

			SetDParam(1, y_label);

   247

			DrawStringRightAligned(x, y, STR_0170, graph_axis_label_colour);

   248

   249

			y_label -= y_label_separation;

   250

			y += (this->gd_height / (GRAPH_NUM_LINES_Y - 1));

   251

		}

   252

   253

		/* draw strings on the x axis */

   254

		if (this->month != 0xFF) {

   255

			x = this->gd_left + GRAPH_X_POSITION_BEGINNING;

   256

			y = this->gd_top + this->gd_height + 1;

   257

			byte month = this->month;

   258

			Year year  = this->year;

   259

			for (int i = 0; i < this->num_on_x_axis; i++) {

   260

				SetDParam(0, month + STR_0162_JAN);

   261

				SetDParam(1, month + STR_0162_JAN + 2);

   262

				SetDParam(2, year);

   263

				DrawString(x, y, month == 0 ? STR_016F : STR_016E, graph_axis_label_colour);

   264

   265

				month += 3;

   266

				if (month >= 12) {

   267

					month = 0;

   268

					year++;

   269

				}

   270

				x += GRAPH_X_POSITION_SEPARATION;

   271

			}

   272

		} else {

   273

			/* Draw the label under the data point rather than on the grid line. */

   274

			x = this->gd_left + GRAPH_X_POSITION_BEGINNING + (GRAPH_X_POSITION_SEPARATION / 2) + 1;

   275

			y = this->gd_top + this->gd_height + 1;

   276

			uint16 label = this->x_values_start;

   277

   278

			for (int i = 0; i < this->num_on_x_axis; i++) {

   279

				SetDParam(0, label);

   280

				DrawStringCentered(x, y, STR_01CB, graph_axis_label_colour);

   281

   282

				label += this->x_values_increment;

   283

				x += GRAPH_X_POSITION_SEPARATION;

   284

			}

   285

		}

   286

   287

		/* draw lines and dots */

   288

		for (int i = 0; i < this->num_dataset; i++) {

   289

			if (!HasBit(this->excluded_data, i)) {

   290

				/* Centre the dot between the grid lines. */

   291

				x = this->gd_left + GRAPH_X_POSITION_BEGINNING + (GRAPH_X_POSITION_SEPARATION / 2);

   292

   293

				byte color  = this->colors[i];

   294

				uint prev_x = INVALID_DATAPOINT_POS;

   295

				uint prev_y = INVALID_DATAPOINT_POS;

   296

   297

				for (int j = 0; j < this->num_on_x_axis; j++) {

   298

					OverflowSafeInt64 datapoint = this->cost[i][j];

   299

   300

					if (datapoint != INVALID_DATAPOINT) {

   301

						/*

   302

						* Check whether we need to reduce the 'accuracy' of the

   303

						* datapoint value and the highest value to splut overflows.

   304

						* And when 'drawing' 'one million' or 'one million and one'

   305

						* there is no significant difference, so the least

   306

						* significant bits can just be removed.

   307

						*

   308

						* If there are more bits needed than would fit in a 32 bits

   309

						* integer, so at about 31 bits because of the sign bit, the

   310

						* least significant bits are removed.

   311

						*/

   312

						int mult_range = FindLastBit(x_axis_offset) + FindLastBit(abs(datapoint));

   313

						int reduce_range = max(mult_range - 31, 0);

   314

   315

						/* Handle negative values differently (don't shift sign) */

   316

						if (datapoint < 0) {

   317

							datapoint = -(abs(datapoint) >> reduce_range);

   318

						} else {

   319

							datapoint >>= reduce_range;

   320

						}

   321

   322

						y = this->gd_top + x_axis_offset - (x_axis_offset * datapoint) / (highest_value >> reduce_range);

   323

   324

						/* Draw the point. */

   325

						GfxFillRect(x - 1, y - 1, x + 1, y + 1, color);

   326

   327

						/* Draw the line connected to the previous point. */

   328

						if (prev_x != INVALID_DATAPOINT_POS) GfxDrawLine(prev_x, prev_y, x, y, color);

   329

   330

						prev_x = x;

   331

						prev_y = y;

   332

					} else {

   333

						prev_x = INVALID_DATAPOINT_POS;

   334

						prev_y = INVALID_DATAPOINT_POS;

   335

					}

   336

   337

					x += GRAPH_X_POSITION_SEPARATION;

   338

				}

   339

			}

   340

		}

   341

	}

   342

   343

   344

	BaseGraphWindow(const WindowDesc *desc, WindowNumber window_number, int left,

   345

									int top, int height, bool has_negative_values, StringID format_str_y_axis) :

   346

			Window(desc, window_number), has_negative_values(has_negative_values),

   347

			gd_left(left), gd_top(top), gd_height(height), format_str_y_axis(format_str_y_axis)

   348

	{

   349

		InvalidateWindow(WC_GRAPH_LEGEND, 0);

   350

	}

   351

   352

public:

   353

	virtual void OnPaint()

   354

	{

   355

		this->DrawWidgets();

   356

   357

		uint excluded_players = _legend_excluded_players;

   358

   359

		/* Exclude the players which aren't valid */

   360

		for (PlayerID p = PLAYER_FIRST; p < MAX_PLAYERS; p++) {

   361

			if (!IsValidPlayerID(p)) SetBit(excluded_players, p);

   362

		}

   363

		this->excluded_data = excluded_players;

   364

		this->num_vert_lines = 24;

   365

   366

		byte nums = 0;

   367

		const Player *p;

   368

		FOR_ALL_PLAYERS(p) {

   369

			nums = max(nums, p->num_valid_stat_ent);

   370

		}

   371

		this->num_on_x_axis = min(nums, 24);

   372

   373

		int mo = (_cur_month / 3 - nums) * 3;

   374

		int yr = _cur_year;

   375

		while (mo < 0) {

   376

			yr--;

   377

			mo += 12;

   378

		}

   379

   380

		this->year = yr;

   381

		this->month = mo;

   382

   383

		int numd = 0;

   384

		for (PlayerID k = PLAYER_FIRST; k < MAX_PLAYERS; k++) {

   385

			if (IsValidPlayerID(k)) {

   386

				p = GetPlayer(k);

   387

				this->colors[numd] = _colour_gradient[p->player_color][6];

   388

				for (int j = this->num_on_x_axis, i = 0; --j >= 0;) {

   389

					this->cost[numd][i] = (j >= p->num_valid_stat_ent) ? INVALID_DATAPOINT : GetGraphData(p, j);

   390

					i++;

   391

				}

   392

			}

   393

			numd++;

   394

		}

   395

   396

		this->num_dataset = numd;

   397

   398

		this->DrawGraph();

   399

	}

   400

   401

	virtual OverflowSafeInt64 GetGraphData(const Player *p, int j)

   402

	{

   403

		return INVALID_DATAPOINT;

   404

	}

   405

   406

	virtual void OnClick(Point pt, int widget)

   407

	{

   408

		/* Clicked on legend? */

   409

		if (widget == 2) ShowGraphLegend();

   410

	}

   411

};

   412

   413

/********************/

   414

/* OPERATING PROFIT */

   415

/********************/

   416

   417

struct OperatingProfitGraphWindow : BaseGraphWindow {

   418

	OperatingProfitGraphWindow(const WindowDesc *desc, WindowNumber window_number) :

   419

			BaseGraphWindow(desc, window_number, 2, 18, 136, true, STR_CURRCOMPACT)

   420

	{

   421

		this->FindWindowPlacementAndResize(desc);

   422

	}

   423

   424

	virtual OverflowSafeInt64 GetGraphData(const Player *p, int j)

   425

	{

   426

		return p->old_economy[j].income + p->old_economy[j].expenses;

   427

	}

   428

};

   429

   430

static const Widget _operating_profit_widgets[] = {

   431

{   WWT_CLOSEBOX,   RESIZE_NONE,  COLOUR_GREY,     0,    10,     0,    13, STR_00C5,                        STR_018B_CLOSE_WINDOW},

   432

{    WWT_CAPTION,   RESIZE_NONE,  COLOUR_GREY,    11,   525,     0,    13, STR_7025_OPERATING_PROFIT_GRAPH, STR_018C_WINDOW_TITLE_DRAG_THIS},

   433

{ WWT_PUSHTXTBTN,   RESIZE_NONE,  COLOUR_GREY,   526,   575,     0,    13, STR_704C_KEY,                    STR_704D_SHOW_KEY_TO_GRAPHS},

   434

{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,     0,   575,    14,   173, 0x0,                             STR_NULL},

   435

{   WIDGETS_END},

   436

};

   437

   438

static const WindowDesc _operating_profit_desc = {

   439

	WDP_AUTO, WDP_AUTO, 576, 174, 576, 174,

   440

	WC_OPERATING_PROFIT, WC_NONE,

   441

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   442

	_operating_profit_widgets,

   443

};

   444

   445

   446

void ShowOperatingProfitGraph()

   447

{

   448

	AllocateWindowDescFront<OperatingProfitGraphWindow>(&_operating_profit_desc, 0);

   449

}

   450

   451

   452

/****************/

   453

/* INCOME GRAPH */

   454

/****************/

   455

   456

struct IncomeGraphWindow : BaseGraphWindow {

   457

	IncomeGraphWindow(const WindowDesc *desc, WindowNumber window_number) :

   458

			BaseGraphWindow(desc, window_number, 2, 18, 104, false, STR_CURRCOMPACT)

   459

	{

   460

		this->FindWindowPlacementAndResize(desc);

   461

	}

   462

   463

	virtual OverflowSafeInt64 GetGraphData(const Player *p, int j)

   464

	{

   465

		return p->old_economy[j].income;

   466

	}

   467

};

   468

   469

static const Widget _income_graph_widgets[] = {

   470

{   WWT_CLOSEBOX,   RESIZE_NONE,  COLOUR_GREY,     0,    10,     0,    13, STR_00C5,              STR_018B_CLOSE_WINDOW},

   471

{    WWT_CAPTION,   RESIZE_NONE,  COLOUR_GREY,    11,   525,     0,    13, STR_7022_INCOME_GRAPH, STR_018C_WINDOW_TITLE_DRAG_THIS},

   472

{ WWT_PUSHTXTBTN,   RESIZE_NONE,  COLOUR_GREY,   526,   575,     0,    13, STR_704C_KEY,          STR_704D_SHOW_KEY_TO_GRAPHS},

   473

{      WWT_PANEL,   RESIZE_NONE,  COLOUR_GREY,     0,   575,    14,   141, 0x0,                   STR_NULL},

   474

{   WIDGETS_END},

   475

};

   476

   477

static const WindowDesc _income_graph_desc = {

   478

	WDP_AUTO, WDP_AUTO, 576, 142, 576, 142,

   479

	WC_INCOME_GRAPH, WC_NONE,

   480

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   481

	_income_graph_widgets,

   482

};

   483

   484

void ShowIncomeGraph()

   485

{

   486

	AllocateWindowDescFront<IncomeGraphWindow>(&_income_graph_desc, 0);

   487

}

   488

   489

/*******************/

   490

/* DELIVERED CARGO */

   491

/*******************/

   492

   493

struct DeliveredCargoGraphWindow : BaseGraphWindow {

   494

	DeliveredCargoGraphWindow(const WindowDesc *desc, WindowNumber window_number) :