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 "signs.h"

    14

#include "strings.h"

    15

#include "debug.h"

    16

#include "variables.h"

    17

    18

static uint _legend_excludebits;

    19

static uint _legend_cargobits;

    20

    21

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

    22

/* GENERIC GRAPH DRAWER */

    23

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

    24

    25

enum {GRAPH_NUM = 16};

    26

    27

typedef struct GraphDrawer {

    28

	uint sel; // bitmask of the players *excluded* (e.g. 11111111 means that no players are shown)

    29

	byte num_dataset;

    30

	byte num_on_x_axis;

    31

	byte month;

    32

	byte year;

    33

	bool include_neg;

    34

	byte num_vert_lines;

    35

	uint16 unk61A;

    36

	uint16 unk61C;

    37

	int left, top;

    38

	uint height;

    39

	StringID format_str_y_axis;

    40

	byte color_3, color_2, bg_line_color;

    41

	byte colors[GRAPH_NUM];

    42

	uint64 cost[GRAPH_NUM][24]; // last 2 years

    43

} GraphDrawer;

    44

    45

#define INVALID_VALUE 0x80000000

    46

    47

static void DrawGraph(const GraphDrawer *gw)

    48

{

    49

    50

	int i,j,k;

    51

	uint x,y,old_x,old_y;

    52

	int color;

    53

	int right, bottom;

    54

	int num_x, num_dataset;

    55

	const uint64 *row_ptr, *col_ptr;

    56

	int64 mx;

    57

	int adj_height;

    58

	uint64 y_scaling, tmp;

    59

	int64 value;

    60

	int64 cur_val;

    61

	uint sel;

    62

    63

	/* the colors and cost array of GraphDrawer must accomodate

    64

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

    65

	assert(GRAPH_NUM >= NUM_CARGO && GRAPH_NUM >= MAX_PLAYERS);

    66

    67

	color = _color_list[gw->bg_line_color].window_color_1b;

    68

    69

	/* draw the vertical lines */

    70

	i = gw->num_vert_lines; assert(i > 0);

    71

	x = gw->left + 66;

    72

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

    73

	do {

    74

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

    75

		x += 22;

    76

	} while (--i);

    77

    78

	/* draw the horizontal lines */

    79

	i = 9;

    80

	x = gw->left + 44;

    81

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

    82

	right = gw->left + 44 + gw->num_vert_lines*22-1;

    83

    84

	do {

    85

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

    86

		y -= gw->height >> 3;

    87

	} while (--i);

    88

    89

	/* draw vertical edge line */

    90

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

    91

    92

	adj_height = gw->height;

    93

	if (gw->include_neg) adj_height >>= 1;

    94

    95

	/* draw horiz edge line */

    96

	y = adj_height + gw->top;

    97

	GfxFillRect(x, y, right, y, gw->color_2);

    98

    99

	/* find the max element */

   100

	if (gw->num_on_x_axis == 0)

   101

		return;

   102

   103

	num_dataset = gw->num_dataset;

   104

	assert(num_dataset > 0);

   105

   106

	row_ptr = gw->cost[0];

   107

	mx = 0;

   108

		/* bit selection for the showing of various players, base max element

   109

		 * on to-be shown player-information. This way the graph can scale */

   110

	sel = gw->sel;

   111

	do {

   112

		if (!(sel&1)) {

   113

			num_x = gw->num_on_x_axis;

   114

			assert(num_x > 0);

   115

			col_ptr = row_ptr;

   116

			do {

   117

				if (*col_ptr != INVALID_VALUE) {

   118

					mx = max64(mx, myabs64(*col_ptr));

   119

				}

   120

			} while (col_ptr++, --num_x);

   121

		}

   122

	} while (sel>>=1, row_ptr+=24, --num_dataset);

   123

   124

	/* setup scaling */

   125

	y_scaling = INVALID_VALUE;

   126

	value = adj_height * 2;

   127

   128

	if (mx > value) {

   129

		mx = (mx + 7) & ~7;

   130

		y_scaling = (((uint64) (value>>1) << 32) / mx);

   131

		value = mx;

   132

	}

   133

   134

	/* draw text strings on the y axis */

   135

	tmp = value;

   136

	if (gw->include_neg) tmp >>= 1;

   137

	x = gw->left + 45;

   138

	y = gw->top - 3;

   139

	i = 9;

   140

	do {

   141

		SetDParam(0, gw->format_str_y_axis);

   142

		SetDParam64(1, (int64)tmp);

   143

		tmp -= (value >> 3);

   144

		DrawStringRightAligned(x, y, STR_0170, gw->color_3);

   145

		y += gw->height >> 3;

   146

	} while (--i);

   147

   148

	/* draw strings on the x axis */

   149

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

   150

		x = gw->left + 44;

   151

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

   152

		j = gw->month;

   153

		k = gw->year + MAX_YEAR_BEGIN_REAL;

   154

		i = gw->num_on_x_axis;assert(i>0);

   155

		do {

   156

			SetDParam(2, k);

   157

			SetDParam(0, j + STR_0162_JAN);

   158

			SetDParam(1, j + STR_0162_JAN + 2);

   159

			DrawString(x, y, j == 0 ? STR_016F : STR_016E, gw->color_3);

   160

   161

			j += 3;

   162

			if (j >= 12) {

   163

				j = 0;

   164

				k++;

   165

			}

   166

			x += 22;

   167

		} while (--i);

   168

	} else {

   169

		x = gw->left + 52;

   170

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

   171

		j = gw->unk61A;

   172

		i = gw->num_on_x_axis;assert(i>0);

   173

		do {

   174

			SetDParam(0, j);

   175

			DrawString(x, y, STR_01CB, gw->color_3);

   176

			j += gw->unk61C;

   177

			x += 22;

   178

		} while (--i);

   179

	}

   180

   181

	/* draw lines and dots */

   182

	i = 0;

   183

	row_ptr = gw->cost[0];

   184

	sel = gw->sel; // show only selected lines. GraphDrawer qw->sel set in Graph-Legend (_legend_excludebits)

   185

	do {

   186

		if (!(sel & 1)) {

   187

			x = gw->left + 55;

   188

			j = gw->num_on_x_axis;assert(j>0);

   189

			col_ptr = row_ptr;

   190

			color = gw->colors[i];

   191

			old_y = old_x = INVALID_VALUE;

   192

			do {

   193

				cur_val = *col_ptr++;

   194

				if (cur_val != INVALID_VALUE) {

   195

					y = adj_height - BIGMULSS64(cur_val, y_scaling >> 1, 31) + gw->top;

   196

   197

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

   198

					if (old_x != INVALID_VALUE)

   199

						GfxDrawLine(old_x, old_y, x, y, color);

   200

   201

					old_x = x;

   202

					old_y = y;

   203

				} else {

   204

					old_x = INVALID_VALUE;

   205

				}

   206

			} while (x+=22,--j);

   207

		}

   208

	} while (sel>>=1,row_ptr+=24, ++i < gw->num_dataset);

   209

}

   210

   211

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

   212

/* GRAPH LEGEND */

   213

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

   214

   215

void DrawPlayerIcon(int p, int x, int y)

   216

{

   217

	DrawSprite(SPRITE_PALETTE(PLAYER_SPRITE_COLOR(p) + 0x2EB), x, y);

   218

}

   219

   220

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

   221

{

   222

	const Player* p;

   223

   224

	switch(e->event) {

   225

	case WE_PAINT:

   226

		FOR_ALL_PLAYERS(p) {

   227

			if (!p->is_active)

   228

				SETBIT(_legend_excludebits, p->index);

   229

		}

   230

		w->click_state = ((~_legend_excludebits) << 3);

   231

		DrawWindowWidgets(w);

   232

   233

		FOR_ALL_PLAYERS(p) {

   234

			if (!p->is_active)

   235

				continue;

   236

   237

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

   238

   239

			SetDParam(0, p->name_1);

   240

			SetDParam(1, p->name_2);

   241

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

   242

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

   243

		}

   244

		break;

   245

   246

	case WE_CLICK:

   247

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

   248

			_legend_excludebits ^= (1 << (e->click.widget-3));

   249

			SetWindowDirty(w);

   250

			InvalidateWindow(WC_INCOME_GRAPH, 0);

   251

			InvalidateWindow(WC_OPERATING_PROFIT, 0);

   252

			InvalidateWindow(WC_DELIVERED_CARGO, 0);

   253

			InvalidateWindow(WC_PERFORMANCE_HISTORY, 0);

   254

			InvalidateWindow(WC_COMPANY_VALUE, 0);

   255

		}

   256

		break;

   257

	}

   258

}

   259

   260

static const Widget _graph_legend_widgets[] = {

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

{   WIDGETS_END},

   273

};

   274

   275

static const WindowDesc _graph_legend_desc = {

   276

	-1, -1, 250, 114,

   277

	WC_GRAPH_LEGEND,0,

   278

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   279

	_graph_legend_widgets,

   280

	GraphLegendWndProc

   281

};

   282

   283

static void ShowGraphLegend(void)

   284

{

   285

	AllocateWindowDescFront(&_graph_legend_desc, 0);

   286

}

   287

   288

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

   289

/* OPERATING PROFIT */

   290

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

   291

   292

static void SetupGraphDrawerForPlayers(GraphDrawer *gd)

   293

{

   294

	const Player* p;

   295

	uint excludebits = _legend_excludebits;

   296

	int nums;

   297

	int mo,yr;

   298

   299

	// Exclude the players which aren't valid

   300

	FOR_ALL_PLAYERS(p) {

   301

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

   302

	}

   303

	gd->sel = excludebits;

   304

	gd->num_vert_lines = 24;

   305

   306

	nums = 0;

   307

	FOR_ALL_PLAYERS(p) {

   308

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

   309

	}

   310

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

   311

   312

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

   313

	yr = _cur_year;

   314

	while (mo < 0) {

   315

		yr--;

   316

		mo += 12;

   317

	}

   318

   319

	gd->year = yr;

   320

	gd->month = mo;

   321

}

   322

   323

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

   324

{

   325

	switch(e->event) {

   326

	case WE_PAINT: {

   327

		GraphDrawer gd;

   328

		const Player* p;

   329

		int i,j;

   330

		int numd;

   331

   332

		DrawWindowWidgets(w);

   333

   334

		gd.left = 2;

   335

		gd.top = 18;

   336

		gd.height = 136;

   337

		gd.include_neg = true;

   338

		gd.format_str_y_axis = STR_CURRCOMPACT;

   339

		gd.color_3 = 0x10;

   340

		gd.color_2 = 0xD7;

   341

		gd.bg_line_color = 0xE;

   342

   343

		SetupGraphDrawerForPlayers(&gd);

   344

   345

		numd = 0;

   346

		FOR_ALL_PLAYERS(p) {

   347

			if (p->is_active) {

   348

				gd.colors[numd] = _color_list[p->player_color].window_color_bgb;

   349

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

   350

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

   351

					i++;

   352

				}

   353

			}

   354

			numd++;

   355

		}

   356

   357

		gd.num_dataset = numd;

   358

   359

		DrawGraph(&gd);

   360

	}	break;

   361

	case WE_CLICK:

   362

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

   363

			ShowGraphLegend();

   364

		break;

   365

	}

   366

}

   367

   368

static const Widget _operating_profit_widgets[] = {

   369

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

   370

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

   371

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

   372

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

   373

{   WIDGETS_END},

   374

};

   375

   376

static const WindowDesc _operating_profit_desc = {

   377

	-1, -1, 576, 174,

   378

	WC_OPERATING_PROFIT,0,

   379

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   380

	_operating_profit_widgets,

   381

	OperatingProfitWndProc

   382

};

   383

   384

   385

void ShowOperatingProfitGraph(void)

   386

{

   387

	if (AllocateWindowDescFront(&_operating_profit_desc, 0)) {

   388

		InvalidateWindow(WC_GRAPH_LEGEND, 0);

   389

	}

   390

}

   391

   392

   393

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

   394

/* INCOME GRAPH */

   395

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

   396

   397

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

   398

{

   399

	switch(e->event) {

   400

	case WE_PAINT: {

   401

		GraphDrawer gd;

   402

		const Player* p;

   403

		int i,j;

   404

		int numd;

   405

   406

		DrawWindowWidgets(w);

   407

   408

		gd.left = 2;

   409

		gd.top = 18;

   410

		gd.height = 104;

   411

		gd.include_neg = false;

   412

		gd.format_str_y_axis = STR_CURRCOMPACT;

   413

		gd.color_3 = 0x10;

   414

		gd.color_2 = 0xD7;

   415

		gd.bg_line_color = 0xE;

   416

		SetupGraphDrawerForPlayers(&gd);

   417

   418

		numd = 0;

   419

		FOR_ALL_PLAYERS(p) {

   420

			if (p->is_active) {

   421

				gd.colors[numd] = _color_list[p->player_color].window_color_bgb;

   422

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

   423

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

   424

					i++;

   425

				}

   426

			}

   427

			numd++;

   428

		}

   429

   430

		gd.num_dataset = numd;

   431

   432

		DrawGraph(&gd);

   433

		break;

   434

	}

   435

   436

	case WE_CLICK:

   437

		if (e->click.widget == 2)

   438

			ShowGraphLegend();

   439

		break;

   440

	}

   441

}

   442

   443

static const Widget _income_graph_widgets[] = {

   444

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

   445

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

   446

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

   447

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

   448

{   WIDGETS_END},

   449

};

   450

   451

static const WindowDesc _income_graph_desc = {

   452

	-1, -1, 576, 142,

   453

	WC_INCOME_GRAPH,0,

   454

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   455

	_income_graph_widgets,

   456

	IncomeGraphWndProc

   457

};

   458

   459

void ShowIncomeGraph(void)

   460

{

   461

	if (AllocateWindowDescFront(&_income_graph_desc, 0)) {

   462

		InvalidateWindow(WC_GRAPH_LEGEND, 0);

   463

	}

   464

}

   465

   466

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

   467

/* DELIVERED CARGO */

   468

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

   469

   470

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

   471

{

   472

	switch(e->event) {

   473

	case WE_PAINT: {

   474

		GraphDrawer gd;

   475

		const Player* p;

   476

		int i,j;

   477

		int numd;

   478

   479

		DrawWindowWidgets(w);

   480

   481

		gd.left = 2;

   482

		gd.top = 18;

   483

		gd.height = 104;

   484

		gd.include_neg = false;

   485

		gd.format_str_y_axis = STR_7024;

   486

		gd.color_3 = 0x10;

   487

		gd.color_2 = 0xD7;

   488

		gd.bg_line_color = 0xE;

   489

		SetupGraphDrawerForPlayers(&gd);

   490

   491

		numd = 0;

   492

		FOR_ALL_PLAYERS(p) {

   493

			if (p->is_active) {

   494

				gd.colors[numd] = _color_list[p->player_color].window_color_bgb;

   495

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

   496

					gd.cost[numd][i] = (j >= p->num_valid_stat_ent) ? INVALID_VALUE : (uint64)p->old_economy[j].delivered_cargo;

   497

					i++;

   498

				}

   499

			}

   500

			numd++;

   501

		}

   502

   503

		gd.num_dataset = numd;

   504

   505

		DrawGraph(&gd);

   506

		break;

   507

	}

   508

   509

	case WE_CLICK:

   510

		if (e->click.widget == 2)