1

/* $Id$ */

     2

     3

/** @file graph_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "table/strings.h"

     8

#include "strings.h"

     9

#include "table/sprites.h"

    10

#include "functions.h"

    11

#include "window.h"

    12

#include "gui.h"

    13

#include "gfx.h"

    14

#include "player.h"

    15

#include "economy.h"

    16

#include "variables.h"

    17

#include "date.h"

    18

#include "helpers.hpp"

    19

#include "cargotype.h"

    20

    21

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

    22

static uint _legend_excluded_players;

    23

static uint _legend_excluded_cargo;

    24

    25

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

    26

/* GENERIC GRAPH DRAWER */

    27

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

    28

    29

enum {

    30

	GRAPH_MAX_DATASETS = 32,

    31

	GRAPH_AXIS_LABEL_COLOUR = TC_BLACK,

    32

	GRAPH_AXIS_LINE_COLOUR  = 215,

    33

    34

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

    35

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

    36

    37

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

    38

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

    39

	 * which is the same

    40

	 * as height >> 3. */

    41

};

    42

    43

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

    44

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

    45

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

    46

    47

struct GraphDrawer {

    48

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

    49

	byte num_dataset;

    50

	byte num_on_x_axis;

    51

	bool has_negative_values;

    52

	byte num_vert_lines;

    53

    54

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

    55

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

    56

	byte month;

    57

	Year year;

    58

    59

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

    60

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

    61

	uint16 x_values_start;

    62

	uint16 x_values_increment;

    63

    64

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

    65

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

    66

	StringID format_str_y_axis;

    67

	byte colors[GRAPH_MAX_DATASETS];

    68

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

    69

};

    70

    71

static void DrawGraph(const GraphDrawer *gw)

    72

{

    73

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

    74

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

    75

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

    76

    77

	/* the colors and cost array of GraphDrawer must accomodate

    78

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

    79

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

    80

	assert(gw->num_vert_lines > 0);

    81

    82

	byte grid_colour = _colour_gradient[14][4];

    83

    84

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

    85

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

    86

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

    87

    88

	/* Draw the vertical grid lines. */

    89

    90

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

    91

	x = gw->left + GRAPH_X_POSITION_BEGINNING + GRAPH_X_POSITION_SEPARATION;

    92

    93

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

    94

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

    95

		x += GRAPH_X_POSITION_SEPARATION;

    96

	}

    97

    98

	/* Draw the horizontal grid lines. */

    99

	x = gw->left + GRAPH_X_POSITION_BEGINNING;

   100

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

   101

   102

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

   103

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

   104

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

   105

	}

   106

   107

	/* Draw the y axis. */

   108

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

   109

   110

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

   111

	x_axis_offset = gw->height;

   112

   113

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

   114

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

   115

   116

	/* Draw the x axis. */

   117

	y = x_axis_offset + gw->top;

   118

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

   119

   120

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

   121

	if (gw->num_on_x_axis == 0)

   122

		return;

   123

   124

	assert(gw->num_on_x_axis > 0);

   125

	assert(gw->num_dataset > 0);

   126

   127

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

   128

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

   129

	 * and prevents division by zero when calculating where the datapoint

   130

	 * should be drawn. */

   131

	highest_value = x_axis_offset * 2;

   132

   133

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

   134

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

   135

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

   136

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

   137

   138

				if (datapoint != INVALID_DATAPOINT) {

   139

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

   140

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

   141

					 * of each data point. */

   142

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

   143

				}

   144

			}

   145

		}

   146

	}

   147

   148

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

   149

	 * axis labels used. */

   150

	int round_val = highest_value % (GRAPH_NUM_LINES_Y - 1);

   151

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

   152

   153

	/* draw text strings on the y axis */

   154

	int64 y_label = highest_value;

   155

	int64 y_label_separation = highest_value / (GRAPH_NUM_LINES_Y - 1);

   156

   157

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

   158

	 * -highest_value, not highest_value to 0. */

   159

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

   160

   161

	x = gw->left + GRAPH_X_POSITION_BEGINNING + 1;

   162

	y = gw->top - 3;

   163

   164

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

   165

		SetDParam(0, gw->format_str_y_axis);

   166

		SetDParam(1, y_label);

   167

		DrawStringRightAligned(x, y, STR_0170, GRAPH_AXIS_LABEL_COLOUR);

   168

   169

		y_label -= y_label_separation;

   170

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

   171

	}

   172

   173

	/* draw strings on the x axis */

   174

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

   175

		x = gw->left + GRAPH_X_POSITION_BEGINNING;

   176

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

   177

		byte month = gw->month;

   178

		Year year  = gw->year;

   179

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

   180

			SetDParam(0, month + STR_0162_JAN);

   181

			SetDParam(1, month + STR_0162_JAN + 2);

   182

			SetDParam(2, year);

   183

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

   184

   185

			month += 3;

   186

			if (month >= 12) {

   187

				month = 0;

   188

				year++;

   189

			}

   190

			x += GRAPH_X_POSITION_SEPARATION;

   191

		}

   192

	} else {

   193

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

   194

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

   195

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

   196

		uint16 label = gw->x_values_start;

   197

   198

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

   199

			SetDParam(0, label);

   200

			DrawStringCentered(x, y, STR_01CB, GRAPH_AXIS_LABEL_COLOUR);

   201

   202

			label += gw->x_values_increment;

   203

			x += GRAPH_X_POSITION_SEPARATION;

   204

		}

   205

	}

   206

   207

	/* draw lines and dots */

   208

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

   209

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

   210

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

   211

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

   212

   213

			byte color  = gw->colors[i];

   214

			uint prev_x = INVALID_DATAPOINT_POS;

   215

			uint prev_y = INVALID_DATAPOINT_POS;

   216

   217

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

   218

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

   219

   220

				if (datapoint != INVALID_DATAPOINT) {

   221

					/* XXX: This can overflow if x_axis_offset * datapoint is

   222

					 * too big to fit in an int64. */

   223

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

   224

   225

					/* Draw the point. */

   226

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

   227

   228

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

   229

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

   230

   231

					prev_x = x;

   232

					prev_y = y;

   233

				} else {

   234

					prev_x = INVALID_DATAPOINT_POS;

   235

					prev_y = INVALID_DATAPOINT_POS;

   236

				}

   237

   238

				x += GRAPH_X_POSITION_SEPARATION;

   239

			}

   240

		}

   241

	}

   242

}

   243

   244

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

   245

/* GRAPH LEGEND */

   246

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

   247

   248

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

   249

{

   250

	switch (e->event) {

   251

		case WE_CREATE:

   252

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

   253

				if (!HASBIT(_legend_excluded_players, i - 3)) LowerWindowWidget(w, i);

   254

			}

   255

			break;

   256

   257

		case WE_PAINT: {

   258

			const Player *p;

   259

   260

			FOR_ALL_PLAYERS(p) {

   261

				if (p->is_active) continue;

   262

   263

				SETBIT(_legend_excluded_players, p->index);

   264

				RaiseWindowWidget(w, p->index + 3);

   265

			}

   266

   267

			DrawWindowWidgets(w);

   268

   269

			FOR_ALL_PLAYERS(p) {

   270

				if (!p->is_active) continue;

   271

   272

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

   273

   274

				SetDParam(0, p->index);

   275

				SetDParam(1, p->index);

   276

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

   277

			}

   278

			break;

   279

		}

   280

   281

		case WE_CLICK:

   282

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

   283

   284

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

   285

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

   286

			SetWindowDirty(w);

   287

			InvalidateWindow(WC_INCOME_GRAPH, 0);

   288

			InvalidateWindow(WC_OPERATING_PROFIT, 0);

   289

			InvalidateWindow(WC_DELIVERED_CARGO, 0);

   290

			InvalidateWindow(WC_PERFORMANCE_HISTORY, 0);

   291

			InvalidateWindow(WC_COMPANY_VALUE, 0);

   292

			break;

   293

	}

   294

}

   295

   296

static const Widget _graph_legend_widgets[] = {

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

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

   305

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

   306

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

   307

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

   308

{   WIDGETS_END},

   309

};

   310

   311

static const WindowDesc _graph_legend_desc = {

   312

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

   313

	WC_GRAPH_LEGEND, WC_NONE,

   314

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   315

	_graph_legend_widgets,

   316

	GraphLegendWndProc

   317

};

   318

   319

static void ShowGraphLegend()

   320

{

   321

	AllocateWindowDescFront(&_graph_legend_desc, 0);

   322

}

   323

   324

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

   325

/* OPERATING PROFIT */

   326

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

   327

   328

static void SetupGraphDrawerForPlayers(GraphDrawer *gd)

   329

{

   330

	const Player* p;

   331

	uint excluded_players = _legend_excluded_players;

   332

	byte nums;

   333

	int mo, yr;

   334

   335

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

   336

	FOR_ALL_PLAYERS(p) {

   337

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

   338

	}

   339

	gd->excluded_data = excluded_players;

   340

	gd->num_vert_lines = 24;

   341

   342

	nums = 0;

   343

	FOR_ALL_PLAYERS(p) {

   344

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

   345

	}

   346

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

   347

   348

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

   349

	yr = _cur_year;

   350

	while (mo < 0) {

   351

		yr--;

   352

		mo += 12;

   353

	}

   354

   355

	gd->year = yr;

   356

	gd->month = mo;

   357

}

   358

   359

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

   360

{

   361

	switch (e->event) {

   362

		case WE_PAINT: {

   363

			GraphDrawer gd;

   364

			const Player* p;

   365

   366

			DrawWindowWidgets(w);

   367

   368

			gd.left = 2;

   369

			gd.top = 18;

   370

			gd.height = 136;

   371

			gd.has_negative_values = true;

   372

			gd.format_str_y_axis = STR_CURRCOMPACT;

   373

   374

			SetupGraphDrawerForPlayers(&gd);

   375

   376

			int numd = 0;

   377

			FOR_ALL_PLAYERS(p) {

   378

				if (p->is_active) {

   379

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

   380

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

   381

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

   382

						i++;

   383

					}

   384

				}

   385

				numd++;

   386

			}

   387

   388

			gd.num_dataset = numd;

   389

   390

			DrawGraph(&gd);

   391

			break;

   392

		}

   393

   394

		case WE_CLICK:

   395

			/* Clicked on legend? */

   396

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

   397

			break;

   398

	}

   399

}

   400

   401

static const Widget _operating_profit_widgets[] = {

   402

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

   403

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

   404

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

   405

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

   406

{   WIDGETS_END},

   407

};

   408

   409

static const WindowDesc _operating_profit_desc = {

   410

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

   411

	WC_OPERATING_PROFIT, WC_NONE,

   412

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   413

	_operating_profit_widgets,

   414

	OperatingProfitWndProc

   415

};

   416

   417

   418

void ShowOperatingProfitGraph()

   419

{

   420

	if (AllocateWindowDescFront(&_operating_profit_desc, 0)) {

   421

		InvalidateWindow(WC_GRAPH_LEGEND, 0);

   422

	}

   423

}

   424

   425

   426

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

   427

/* INCOME GRAPH */

   428

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

   429

   430

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

   431

{

   432

	switch (e->event) {

   433

		case WE_PAINT: {

   434

			GraphDrawer gd;

   435

			const Player* p;

   436

   437

			DrawWindowWidgets(w);

   438

   439

			gd.left = 2;

   440

			gd.top = 18;

   441

			gd.height = 104;

   442

			gd.has_negative_values = false;

   443

			gd.format_str_y_axis = STR_CURRCOMPACT;

   444

			SetupGraphDrawerForPlayers(&gd);

   445

   446

			int numd = 0;

   447

			FOR_ALL_PLAYERS(p) {

   448

				if (p->is_active) {

   449

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

   450

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

   451

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

   452

						i++;

   453

					}

   454

				}

   455

				numd++;

   456

			}

   457

   458

			gd.num_dataset = numd;

   459

   460

			DrawGraph(&gd);

   461

			break;

   462

		}

   463

   464

		case WE_CLICK:

   465

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

   466

			break;

   467

	}

   468

}

   469

   470

static const Widget _income_graph_widgets[] = {

   471

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

   472

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

   473

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

   474

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

   475

{   WIDGETS_END},

   476

};

   477

   478

static const WindowDesc _income_graph_desc = {

   479

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

   480

	WC_INCOME_GRAPH, WC_NONE,

   481

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   482

	_income_graph_widgets,

   483

	IncomeGraphWndProc

   484

};

   485

   486

void ShowIncomeGraph()

   487

{

   488

	if (AllocateWindowDescFront(&_income_graph_desc, 0)) {

   489

		InvalidateWindow(WC_GRAPH_LEGEND, 0);

   490

	}