1

/* $Id$ */

     2

     3

/** @file graph_gui.cpp */

     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

    20

#include "table/strings.h"

    21

#include "table/sprites.h"

    22

    23

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

    24

static uint _legend_excluded_players;

    25

static uint _legend_excluded_cargo;

    26

    27

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

    28

/* GENERIC GRAPH DRAWER */

    29

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

    30

    31

enum {

    32

	GRAPH_MAX_DATASETS = 32,

    33

	GRAPH_AXIS_LABEL_COLOUR = TC_BLACK,

    34

	GRAPH_AXIS_LINE_COLOUR  = 215,

    35

    36

	GRAPH_X_POSITION_BEGINNING  = 44,  ///< Start the graph 44 pixels from gw->left

    37

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

    38

    39

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

    40

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

    41

	 * which is the same

    42

	 * as height >> 3. */

    43

};

    44

    45

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

    46

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

    47

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

    48

    49

struct GraphDrawer {

    50

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

    51

	byte num_dataset;

    52

	byte num_on_x_axis;

    53

	bool has_negative_values;

    54

	byte num_vert_lines;

    55

    56

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

    57

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

    58

	byte month;

    59

	Year year;

    60

    61

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

    62

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

    63

	uint16 x_values_start;

    64

	uint16 x_values_increment;

    65

    66

	int left, top;  ///< Where to start drawing the graph, in pixels.

    67

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

    68

	StringID format_str_y_axis;

    69

	byte colors[GRAPH_MAX_DATASETS];

    70

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

    71

};

    72

    73

static void DrawGraph(const GraphDrawer *gw)

    74

{

    75

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

    76

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

    77

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

    78

    79

	/* the colors and cost array of GraphDrawer must accomodate

    80

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

    81

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

    82

	assert(gw->num_vert_lines > 0);

    83

    84

	byte grid_colour = _colour_gradient[14][4];

    85

    86

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

    87

	int bottom = gw->top + gw->height - 1;

    88

	int right  = gw->left + GRAPH_X_POSITION_BEGINNING + gw->num_vert_lines * GRAPH_X_POSITION_SEPARATION - 1;

    89

    90

	/* Draw the vertical grid lines. */

    91

    92

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

    93

	x = gw->left + GRAPH_X_POSITION_BEGINNING + GRAPH_X_POSITION_SEPARATION;

    94

    95

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

    96

		GfxFillRect(x, gw->top, x, bottom, grid_colour);

    97

		x += GRAPH_X_POSITION_SEPARATION;

    98

	}

    99

   100

	/* Draw the horizontal grid lines. */

   101

	x = gw->left + GRAPH_X_POSITION_BEGINNING;

   102

	y = gw->height + gw->top;

   103

   104

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

   105

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

   106

		y -= (gw->height / (GRAPH_NUM_LINES_Y - 1));

   107

	}

   108

   109

	/* Draw the y axis. */

   110

	GfxFillRect(x, gw->top, x, bottom, GRAPH_AXIS_LINE_COLOUR);

   111

   112

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

   113

	x_axis_offset = gw->height;

   114

   115

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

   116

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

   117

   118

	/* Draw the x axis. */

   119

	y = x_axis_offset + gw->top;

   120

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

   121

   122

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

   123

	if (gw->num_on_x_axis == 0)

   124

		return;

   125

   126

	assert(gw->num_on_x_axis > 0);

   127

	assert(gw->num_dataset > 0);

   128

   129

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

   130

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

   131

	 * and prevents division by zero when calculating where the datapoint

   132

	 * should be drawn. */

   133

	highest_value = x_axis_offset * 2;

   134

   135

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

   136

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

   137

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

   138

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

   139

   140

				if (datapoint != INVALID_DATAPOINT) {

   141

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

   142

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

   143

					 * of each data point. */

   144

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

   145

				}

   146

			}

   147

		}

   148

	}

   149

   150

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

   151

	 * axis labels used. */

   152

	int round_val = highest_value % (GRAPH_NUM_LINES_Y - 1);

   153

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

   154

   155

	/* draw text strings on the y axis */

   156

	int64 y_label = highest_value;

   157

	int64 y_label_separation = highest_value / (GRAPH_NUM_LINES_Y - 1);

   158

   159

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

   160

	 * -highest_value, not highest_value to 0. */

   161

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

   162

   163

	x = gw->left + GRAPH_X_POSITION_BEGINNING + 1;

   164

	y = gw->top - 3;

   165

   166

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

   167

		SetDParam(0, gw->format_str_y_axis);

   168

		SetDParam(1, y_label);

   169

		DrawStringRightAligned(x, y, STR_0170, GRAPH_AXIS_LABEL_COLOUR);

   170

   171

		y_label -= y_label_separation;

   172

		y += (gw->height / (GRAPH_NUM_LINES_Y - 1));

   173

	}

   174

   175

	/* draw strings on the x axis */

   176

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

   177

		x = gw->left + GRAPH_X_POSITION_BEGINNING;

   178

		y = gw->top + gw->height + 1;

   179

		byte month = gw->month;

   180

		Year year  = gw->year;

   181

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

   182

			SetDParam(0, month + STR_0162_JAN);

   183

			SetDParam(1, month + STR_0162_JAN + 2);

   184

			SetDParam(2, year);

   185

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

   186

   187

			month += 3;

   188

			if (month >= 12) {

   189

				month = 0;

   190

				year++;

   191

			}

   192

			x += GRAPH_X_POSITION_SEPARATION;

   193

		}

   194

	} else {

   195

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

   196

		x = gw->left + GRAPH_X_POSITION_BEGINNING + (GRAPH_X_POSITION_SEPARATION / 2) + 1;

   197

		y = gw->top + gw->height + 1;

   198

		uint16 label = gw->x_values_start;

   199

   200

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

   201

			SetDParam(0, label);

   202

			DrawStringCentered(x, y, STR_01CB, GRAPH_AXIS_LABEL_COLOUR);

   203

   204

			label += gw->x_values_increment;

   205

			x += GRAPH_X_POSITION_SEPARATION;

   206

		}

   207

	}

   208

   209

	/* draw lines and dots */

   210

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

   211

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

   212

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

   213

			x = gw->left + GRAPH_X_POSITION_BEGINNING + (GRAPH_X_POSITION_SEPARATION / 2);

   214

   215

			byte color  = gw->colors[i];

   216

			uint prev_x = INVALID_DATAPOINT_POS;

   217

			uint prev_y = INVALID_DATAPOINT_POS;

   218

   219

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

   220

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

   221

   222

				if (datapoint != INVALID_DATAPOINT) {

   223

					/*

   224

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

   225

					 * datapoint value and the highest value to splut overflows.

   226

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

   227

					 * there is no significant difference, so the least

   228

					 * significant bits can just be removed.

   229

					 *

   230

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

   231

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

   232

					 * least significant bits are removed.

   233

					 */

   234

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

   235

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

   236

   237

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

   238

					if (datapoint < 0) {

   239

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

   240

					} else {

   241

						datapoint >>= reduce_range;

   242

					}

   243

   244

					y = gw->top + x_axis_offset - (x_axis_offset * datapoint) / (highest_value >> reduce_range);

   245

   246

					/* Draw the point. */

   247

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

   248

   249

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

   250

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

   251

   252

					prev_x = x;

   253

					prev_y = y;

   254

				} else {

   255

					prev_x = INVALID_DATAPOINT_POS;

   256

					prev_y = INVALID_DATAPOINT_POS;

   257

				}

   258

   259

				x += GRAPH_X_POSITION_SEPARATION;

   260

			}

   261

		}

   262

	}

   263

}

   264

   265

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

   266

/* GRAPH LEGEND */

   267

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

   268

   269

static void GraphLegendWndProc(Window *w, WindowEvent *e)

   270

{

   271

	switch (e->event) {

   272

		case WE_CREATE:

   273

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

   274

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

   275

			}

   276

			break;

   277

   278

		case WE_PAINT: {

   279

			const Player *p;

   280

   281

			FOR_ALL_PLAYERS(p) {

   282

				if (p->is_active) continue;

   283

   284

				SetBit(_legend_excluded_players, p->index);

   285

				w->RaiseWidget(p->index + 3);

   286

			}

   287

   288

			DrawWindowWidgets(w);

   289

   290

			FOR_ALL_PLAYERS(p) {

   291

				if (!p->is_active) continue;

   292

   293

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

   294

   295

				SetDParam(0, p->index);

   296

				SetDParam(1, p->index);

   297

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

   298

			}

   299

			break;

   300

		}

   301

   302

		case WE_CLICK:

   303

			if (!IsInsideMM(e->we.click.widget, 3, 11)) return;

   304

   305

			ToggleBit(_legend_excluded_players, e->we.click.widget - 3);

   306

			w->ToggleWidgetLoweredState(e->we.click.widget);

   307

			SetWindowDirty(w);

   308

			InvalidateWindow(WC_INCOME_GRAPH, 0);

   309

			InvalidateWindow(WC_OPERATING_PROFIT, 0);

   310

			InvalidateWindow(WC_DELIVERED_CARGO, 0);

   311

			InvalidateWindow(WC_PERFORMANCE_HISTORY, 0);

   312

			InvalidateWindow(WC_COMPANY_VALUE, 0);

   313

			break;

   314

	}

   315

}

   316

   317

static const Widget _graph_legend_widgets[] = {

   318

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

   319

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

   320

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

   321

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

   322

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

   323

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

   324

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

   325

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

   326

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

   327

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

   328

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

   329

{   WIDGETS_END},

   330

};

   331

   332

static const WindowDesc _graph_legend_desc = {

   333

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

   334

	WC_GRAPH_LEGEND, WC_NONE,

   335

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   336

	_graph_legend_widgets,

   337

	GraphLegendWndProc

   338

};

   339

   340

static void ShowGraphLegend()

   341

{

   342

	AllocateWindowDescFront(&_graph_legend_desc, 0);

   343

}

   344

   345

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

   346

/* OPERATING PROFIT */

   347

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

   348

   349

static void SetupGraphDrawerForPlayers(GraphDrawer *gd)

   350

{

   351

	const Player* p;

   352

	uint excluded_players = _legend_excluded_players;

   353

	byte nums;

   354

	int mo, yr;

   355

   356

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

   357

	FOR_ALL_PLAYERS(p) {

   358

		if (!p->is_active) SetBit(excluded_players, p->index);

   359

	}

   360

	gd->excluded_data = excluded_players;

   361

	gd->num_vert_lines = 24;

   362

   363

	nums = 0;

   364

	FOR_ALL_PLAYERS(p) {

   365

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

   366

	}

   367

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

   368

   369

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

   370

	yr = _cur_year;

   371

	while (mo < 0) {

   372

		yr--;

   373

		mo += 12;

   374

	}

   375

   376

	gd->year = yr;

   377

	gd->month = mo;

   378

}

   379

   380

static void OperatingProfitWndProc(Window *w, WindowEvent *e)

   381

{

   382

	switch (e->event) {

   383

		case WE_PAINT: {

   384

			GraphDrawer gd;

   385

			const Player* p;

   386

   387

			DrawWindowWidgets(w);

   388

   389

			gd.left = 2;

   390

			gd.top = 18;

   391

			gd.height = 136;

   392

			gd.has_negative_values = true;

   393

			gd.format_str_y_axis = STR_CURRCOMPACT;

   394

   395

			SetupGraphDrawerForPlayers(&gd);

   396

   397

			int numd = 0;

   398

			FOR_ALL_PLAYERS(p) {

   399

				if (p->is_active) {

   400

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

   401

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

   402

						gd.cost[numd][i] = (j >= p->num_valid_stat_ent) ? INVALID_DATAPOINT : (p->old_economy[j].income + p->old_economy[j].expenses);

   403

						i++;

   404

					}

   405

				}

   406

				numd++;

   407

			}

   408

   409

			gd.num_dataset = numd;

   410

   411

			DrawGraph(&gd);

   412

			break;

   413

		}

   414

   415

		case WE_CLICK:

   416

			/* Clicked on legend? */

   417

			if (e->we.click.widget == 2) ShowGraphLegend();

   418

			break;

   419

	}

   420

}

   421

   422

static const Widget _operating_profit_widgets[] = {

   423

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

   424

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

   425

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

   426

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

   427

{   WIDGETS_END},

   428

};

   429

   430

static const WindowDesc _operating_profit_desc = {

   431

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

   432

	WC_OPERATING_PROFIT, WC_NONE,

   433

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   434

	_operating_profit_widgets,

   435

	OperatingProfitWndProc

   436

};

   437

   438

   439

void ShowOperatingProfitGraph()

   440

{

   441

	if (AllocateWindowDescFront(&_operating_profit_desc, 0)) {

   442

		InvalidateWindow(WC_GRAPH_LEGEND, 0);

   443

	}

   444

}

   445

   446

   447

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

   448

/* INCOME GRAPH */

   449

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

   450

   451

static void IncomeGraphWndProc(Window *w, WindowEvent *e)

   452

{

   453

	switch (e->event) {

   454

		case WE_PAINT: {

   455

			GraphDrawer gd;

   456

			const Player* p;

   457

   458

			DrawWindowWidgets(w);

   459

   460

			gd.left = 2;

   461

			gd.top = 18;

   462

			gd.height = 104;

   463

			gd.has_negative_values = false;

   464

			gd.format_str_y_axis = STR_CURRCOMPACT;

   465

			SetupGraphDrawerForPlayers(&gd);

   466

   467

			int numd = 0;

   468

			FOR_ALL_PLAYERS(p) {

   469

				if (p->is_active) {

   470

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

   471

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

   472

						gd.cost[numd][i] = (j >= p->num_valid_stat_ent) ? INVALID_DATAPOINT : p->old_economy[j].income;

   473

						i++;

   474

					}

   475

				}

   476

				numd++;

   477

			}

   478

   479

			gd.num_dataset = numd;

   480

   481

			DrawGraph(&gd);

   482

			break;

   483

		}

   484

   485

		case WE_CLICK:

   486

			if (e->we.click.widget == 2) ShowGraphLegend();

   487

			break;

   488

	}

   489

}