1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "table/strings.h"

     6

#include "table/sprites.h"

     7

#include "functions.h"

     8

#include "window.h"

     9

#include "gui.h"

    10

#include "gfx.h"

    11

#include "player.h"

    12

#include "economy.h"

    13

#include "variables.h"

    14

#include "date.h"

    15

#include "helpers.hpp"

    16

#include "cargotype.h"

    17

    18

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

    19

static uint _legend_excluded_players;

    20

static uint _legend_excluded_cargo;

    21

    22

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

    23

/* GENERIC GRAPH DRAWER */

    24

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

    25

    26

enum {

    27

	GRAPH_MAX_DATASETS = 16,

    28

	GRAPH_AXIS_LABEL_COLOUR = 16,

    29

	GRAPH_AXIS_LINE_COLOUR  = 215,

    30

    31

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

    32

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

    33

    34

	/* How many horizontal lines to draw. 9 is convenient as that means the

    35

	 * distance between them is the height of the graph / 8, which is the same

    36

	 * as height >> 3. */

    37

	GRAPH_NUM_LINES_Y = 9,

    38

};

    39

    40

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

    41

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

    42

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

    43

    44

typedef struct GraphDrawer {

    45

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

    46

	byte num_dataset;

    47

	byte num_on_x_axis;

    48

	bool has_negative_values;

    49

	byte num_vert_lines;

    50

    51

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

    52

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

    53

	byte month;

    54

	Year year;

    55

    56

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

    57

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

    58

	uint16 x_values_start;

    59

	uint16 x_values_increment;

    60

    61

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

    62

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

    63

	StringID format_str_y_axis;

    64

	byte colors[GRAPH_MAX_DATASETS];

    65

	int64 cost[GRAPH_MAX_DATASETS][24]; // last 2 years

    66

} GraphDrawer;

    67

    68

static void DrawGraph(const GraphDrawer *gw)

    69

{

    70

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

    71

	int64 highest_value;  // Highest value to be drawn.

    72

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

    73

    74

	/* the colors and cost array of GraphDrawer must accomodate

    75

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

    76

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

    77

	assert(gw->num_vert_lines > 0);

    78

    79

	byte grid_colour = _colour_gradient[14][4];

    80

    81

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

    82

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

    83

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

    84

    85

	/* Draw the vertical grid lines. */

    86

    87

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

    88

	x = gw->left + GRAPH_X_POSITION_BEGINNING + GRAPH_X_POSITION_SEPARATION;

    89

    90

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

    91

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

    92

		x += GRAPH_X_POSITION_SEPARATION;

    93

	}

    94

    95

	/* Draw the horizontal grid lines. */

    96

	x = gw->left + GRAPH_X_POSITION_BEGINNING;

    97

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

    98

    99

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

   100

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

   101

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

   102

	}

   103

   104

	/* Draw the y axis. */

   105

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

   106

   107

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

   108

	x_axis_offset = gw->height;

   109

   110

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

   111

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

   112

   113

	/* Draw the x axis. */

   114

	y = x_axis_offset + gw->top;

   115

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

   116

   117

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

   118

	if (gw->num_on_x_axis == 0)

   119

		return;

   120

   121

	assert(gw->num_on_x_axis > 0);

   122

	assert(gw->num_dataset > 0);

   123

   124

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

   125

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

   126

	 * and prevents division by zero when calculating where the datapoint

   127

	 * should be drawn. */

   128

	highest_value = x_axis_offset * 2;

   129

   130

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

   131

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

   132

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

   133

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

   134

   135

				if (datapoint != INVALID_DATAPOINT) {

   136

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

   137

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

   138

					 * of each data point. */

   139

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

   140

				}

   141

			}

   142

		}

   143

	}

   144

   145

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

   146

	 * axis labels used. */

   147

	int round_val = highest_value % (GRAPH_NUM_LINES_Y - 1);

   148

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

   149

   150

	/* draw text strings on the y axis */

   151

	int64 y_label = highest_value;

   152

	int64 y_label_separation = highest_value / (GRAPH_NUM_LINES_Y - 1);

   153

   154

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

   155

	 * -highest_value, not highest_value to 0. */

   156

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

   157

   158

	x = gw->left + GRAPH_X_POSITION_BEGINNING + 1;

   159

	y = gw->top - 3;

   160

   161

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

   162

		SetDParam(0, gw->format_str_y_axis);

   163

		SetDParam64(1, y_label);

   164

		DrawStringRightAligned(x, y, STR_0170, GRAPH_AXIS_LABEL_COLOUR);

   165

   166

		y_label -= y_label_separation;

   167

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

   168

	}

   169

   170

	/* draw strings on the x axis */

   171

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

   172

		x = gw->left + GRAPH_X_POSITION_BEGINNING;

   173

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

   174

		byte month = gw->month;

   175

		Year year  = gw->year;

   176

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

   177

			SetDParam(0, month + STR_0162_JAN);

   178

			SetDParam(1, month + STR_0162_JAN + 2);

   179

			SetDParam(2, year);

   180

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

   181

   182

			month += 3;

   183

			if (month >= 12) {

   184

				month = 0;

   185

				year++;

   186

			}

   187

			x += GRAPH_X_POSITION_SEPARATION;

   188

		}

   189

	} else {

   190

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

   191

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

   192

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

   193

		uint16 label = gw->x_values_start;

   194

   195

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

   196

			SetDParam(0, label);

   197

			DrawStringCentered(x, y, STR_01CB, GRAPH_AXIS_LABEL_COLOUR);

   198

   199

			label += gw->x_values_increment;

   200

			x += GRAPH_X_POSITION_SEPARATION;

   201

		}

   202

	}

   203

   204

	/* draw lines and dots */

   205

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

   206

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

   207

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

   208

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

   209

   210

			byte color  = gw->colors[i];

   211

			uint prev_x = INVALID_DATAPOINT_POS;

   212

			uint prev_y = INVALID_DATAPOINT_POS;

   213

   214

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

   215

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

   216

   217

				if (datapoint != INVALID_DATAPOINT) {

   218

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

   219

					 * too big to fit in an int64. */

   220

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

   221

   222

					/* Draw the point. */

   223

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

   224

   225

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

   226

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

   227

   228

					prev_x = x;

   229

					prev_y = y;

   230

				} else {

   231

					prev_x = INVALID_DATAPOINT_POS;

   232

					prev_y = INVALID_DATAPOINT_POS;

   233

				}

   234

   235

				x += GRAPH_X_POSITION_SEPARATION;

   236

			}

   237

		}

   238

	}

   239

}

   240

   241

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

   242

/* GRAPH LEGEND */

   243

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

   244

   245

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

   246

{

   247

	const Player* p;

   248

   249

	switch (e->event) {

   250

	case WE_CREATE: {

   251

		uint i;

   252

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

   253

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

   254

		}

   255

		break;

   256

	}

   257

   258

	case WE_PAINT:

   259

		FOR_ALL_PLAYERS(p) {

   260

			if (!p->is_active) {

   261

				SETBIT(_legend_excluded_players, p->index);

   262

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

   263

			}

   264

		}

   265

		w->DrawWidgets();

   266

   267

		FOR_ALL_PLAYERS(p) {

   268

			if (!p->is_active) continue;

   269

   270

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

   271

   272

			SetDParam(0, p->name_1);

   273

			SetDParam(1, p->name_2);

   274

			SetDParam(2, GetPlayerNameString(p->index, 3));

   275

			DrawString(21, 17 + p->index * 12, STR_7021, HASBIT(_legend_excluded_players, p->index) ? 0x10 : 0xC);

   276

		}

   277

		break;

   278

   279

	case WE_CLICK:

   280

		if (IS_INT_INSIDE(e->we.click.widget, 3, 11)) {

   281

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

   282

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

   283

			w->SetDirty();

   284

			InvalidateWindow(WC_INCOME_GRAPH, 0);

   285

			InvalidateWindow(WC_OPERATING_PROFIT, 0);

   286

			InvalidateWindow(WC_DELIVERED_CARGO, 0);

   287

			InvalidateWindow(WC_PERFORMANCE_HISTORY, 0);

   288

			InvalidateWindow(WC_COMPANY_VALUE, 0);

   289

		}

   290

		break;

   291

	}

   292

}

   293

   294

static const OldWidget _graph_legend_widgets[] = {

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

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

   305

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

   306

{   WIDGETS_END},

   307

};

   308

   309

static const WindowDesc _graph_legend_desc = {

   310

	WDP_AUTO, WDP_AUTO, 250, 114,

   311

	WC_GRAPH_LEGEND, WC_NONE,

   312

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   313

	_graph_legend_widgets,

   314

	GraphLegendWndProc

   315

};

   316

   317

static void ShowGraphLegend(void)

   318

{

   319

	BaseWindow::AllocateFront(&_graph_legend_desc, 0);

   320

}

   321

   322

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

   323

/* OPERATING PROFIT */

   324

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

   325

   326

static void SetupGraphDrawerForPlayers(GraphDrawer *gd)

   327

{

   328

	const Player* p;

   329

	uint excluded_players = _legend_excluded_players;

   330

	byte nums;

   331

	int mo,yr;

   332

   333

	// Exclude the players which aren't valid

   334

	FOR_ALL_PLAYERS(p) {

   335

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

   336

	}

   337

	gd->excluded_data = excluded_players;

   338

	gd->num_vert_lines = 24;

   339

   340

	nums = 0;

   341

	FOR_ALL_PLAYERS(p) {

   342

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

   343

	}

   344

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

   345

   346

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

   347

	yr = _cur_year;

   348

	while (mo < 0) {

   349

		yr--;

   350

		mo += 12;

   351

	}

   352

   353

	gd->year = yr;

   354

	gd->month = mo;

   355

}

   356

   357

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

   358

{

   359

	switch (e->event) {

   360

	case WE_PAINT: {

   361

		GraphDrawer gd;

   362

		const Player* p;

   363

		int i,j;

   364

		int numd;

   365

   366

		w->DrawWidgets();

   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

		numd = 0;

   377

		FOR_ALL_PLAYERS(p) {

   378

			if (p->is_active) {

   379

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

   380

				for (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

	case WE_CLICK:

   393

		if (e->we.click.widget == 2) /* Clicked on Legend */

   394

			ShowGraphLegend();

   395

		break;

   396

	}

   397

}

   398

   399

static const OldWidget _operating_profit_widgets[] = {

   400

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

   401

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

   402

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

   403

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

   404

{   WIDGETS_END},

   405

};

   406

   407

static const WindowDesc _operating_profit_desc = {

   408

	WDP_AUTO, WDP_AUTO, 576, 174,

   409

	WC_OPERATING_PROFIT, WC_NONE,

   410

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   411

	_operating_profit_widgets,

   412

	OperatingProfitWndProc

   413

};

   414

   415

   416

void ShowOperatingProfitGraph(void)

   417

{

   418

	if (BaseWindow::AllocateFront(&_operating_profit_desc, 0)) {

   419

		InvalidateWindow(WC_GRAPH_LEGEND, 0);

   420

	}

   421

}

   422

   423

   424

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

   425

/* INCOME GRAPH */

   426

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

   427

   428

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

   429

{

   430

	switch (e->event) {

   431

	case WE_PAINT: {

   432

		GraphDrawer gd;

   433

		const Player* p;

   434

		int i,j;

   435

		int numd;

   436

   437

		w->DrawWidgets();

   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

		numd = 0;

   447

		FOR_ALL_PLAYERS(p) {

   448

			if (p->is_active) {

   449

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

   450

				for (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)

   466

			ShowGraphLegend();

   467

		break;

   468

	}

   469

}

   470

   471

static const OldWidget _income_graph_widgets[] = {

   472

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

   473

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

   474

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

   475

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

   476

{   WIDGETS_END},

   477

};

   478

   479

static const WindowDesc _income_graph_desc = {

   480

	WDP_AUTO, WDP_AUTO, 576, 142,

   481

	WC_INCOME_GRAPH, WC_NONE,

   482

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   483

	_income_graph_widgets,

   484

	IncomeGraphWndProc

   485

};

   486

   487

void ShowIncomeGraph(void)

   488

{

   489

	if (BaseWindow::AllocateFront(&_income_graph_desc, 0)) {

   490

		InvalidateWindow(WC_GRAPH_LEGEND, 0);

   491

	}