1

/* $Id$ */

     2

     3

/** @file engine_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "table/strings.h"

     8

#include "table/sprites.h"

     9

#include "functions.h"

    10

#include "window.h"

    11

#include "gui.h"

    12

#include "viewport.h"

    13

#include "gfx.h"

    14

#include "engine.h"

    15

#include "command.h"

    16

#include "news.h"

    17

#include "variables.h"

    18

#include "newgrf_engine.h"

    19

    20

    21

static StringID GetEngineCategoryName(EngineID engine)

    22

{

    23

	switch (GetEngine(engine)->type) {

    24

		default: NOT_REACHED();

    29

			switch (RailVehInfo(engine)->railtype) {

    30

				default: NOT_REACHED();

    31

				case RAILTYPE_RAIL:     return STR_8102_RAILROAD_LOCOMOTIVE;

    32

				case RAILTYPE_ELECTRIC: return STR_8102_RAILROAD_LOCOMOTIVE;

    33

				case RAILTYPE_MONO:     return STR_8106_MONORAIL_LOCOMOTIVE;

    34

				case RAILTYPE_MAGLEV:   return STR_8107_MAGLEV_LOCOMOTIVE;

    35

			}

    36

	}

    37

}

    38

    39

static const Widget _engine_preview_widgets[] = {

    40

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

    41

{    WWT_CAPTION,   RESIZE_NONE,     5,    11,   299,     0,    13, STR_8100_MESSAGE_FROM_VEHICLE_MANUFACTURE, STR_018C_WINDOW_TITLE_DRAG_THIS},

    42

{      WWT_PANEL,   RESIZE_NONE,     5,     0,   299,    14,   191, 0x0,                                       STR_NULL},

    43

{ WWT_PUSHTXTBTN,   RESIZE_NONE,     5,    85,   144,   172,   183, STR_00C9_NO,                               STR_NULL},

    44

{ WWT_PUSHTXTBTN,   RESIZE_NONE,     5,   155,   214,   172,   183, STR_00C8_YES,                              STR_NULL},

    45

{   WIDGETS_END},

    46

};

    47

    48

typedef void DrawEngineProc(int x, int y, EngineID engine, SpriteID pal);

    49

typedef void DrawEngineInfoProc(EngineID, int x, int y, int maxw);

    50

    51

struct DrawEngineInfo {

    52

	DrawEngineProc *engine_proc;

    53

	DrawEngineInfoProc *info_proc;

    54

};

    55

    56

static void DrawTrainEngineInfo(EngineID engine, int x, int y, int maxw);

    57

static void DrawRoadVehEngineInfo(EngineID engine, int x, int y, int maxw);

    58

static void DrawShipEngineInfo(EngineID engine, int x, int y, int maxw);

    59

static void DrawAircraftEngineInfo(EngineID engine, int x, int y, int maxw);

    60

    61

static const DrawEngineInfo _draw_engine_list[4] = {

    62

	{ DrawTrainEngine,    DrawTrainEngineInfo    },

    63

	{ DrawRoadVehEngine,  DrawRoadVehEngineInfo  },

    64

	{ DrawShipEngine,     DrawShipEngineInfo     },

    65

	{ DrawAircraftEngine, DrawAircraftEngineInfo },

    66

};

    67

    68

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

    69

{

    70

	switch (e->event) {

    71

	case WE_PAINT: {

    72

		EngineID engine = w->window_number;

    73

		const DrawEngineInfo* dei;

    74

		int width;

    75

    76

		DrawWindowWidgets(w);

    77

    78

		SetDParam(0, GetEngineCategoryName(engine));

    79

		DrawStringMultiCenter(150, 44, STR_8101_WE_HAVE_JUST_DESIGNED_A, 296);

    80

    81

		DrawStringCentered(w->width >> 1, 80, GetCustomEngineName(engine), 0x10);

    82

    83

		dei = &_draw_engine_list[GetEngine(engine)->type];

    84

    85

		width = w->width;

    86

		dei->engine_proc(width >> 1, 100, engine, 0);

    87

		dei->info_proc(engine, width >> 1, 130, width - 52);

    88

		break;

    89

	}

    90

    91

	case WE_CLICK:

    92

		switch (e->we.click.widget) {

    93

			case 4:

    94

				DoCommandP(0, w->window_number, 0, NULL, CMD_WANT_ENGINE_PREVIEW);

    95

				/* Fallthrough */

    96

			case 3:

    97

				DeleteWindow(w);

    98

				break;

    99

		}

   100

		break;

   101

	}

   102

}

   103

   104

static const WindowDesc _engine_preview_desc = {

   105

	WDP_CENTER, WDP_CENTER, 300, 192,

   106

	WC_ENGINE_PREVIEW, WC_NONE,

   107

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   108

	_engine_preview_widgets,

   109

	EnginePreviewWndProc

   110

};

   111

   112

   113

void ShowEnginePreviewWindow(EngineID engine)

   114

{

   115

	AllocateWindowDescFront(&_engine_preview_desc, engine);

   116

}

   117

   118

static void DrawTrainEngineInfo(EngineID engine, int x, int y, int maxw)

   119

{

   120

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   121

	uint multihead = (rvi->railveh_type == RAILVEH_MULTIHEAD) ? 1 : 0;

   122

   123

	SetDParam(0, (_price.build_railvehicle >> 3) * rvi->base_cost >> 5);

   124

	SetDParam(2, rvi->max_speed * 10 / 16);

   125

	SetDParam(3, rvi->power << multihead);

   126

	SetDParam(1, rvi->weight << multihead);

   127

   128

	SetDParam(4, rvi->running_cost_base * _price.running_rail[rvi->running_cost_class] >> 8 << multihead);

   129

   130

	if (rvi->capacity != 0) {

   131

		SetDParam(5, rvi->cargo_type);

   132

		SetDParam(6, rvi->capacity << multihead);

   133

	} else {

   134

		SetDParam(5, CT_INVALID);

   135

	}

   136

	DrawStringMultiCenter(x, y, STR_VEHICLE_INFO_COST_WEIGHT_SPEED_POWER, maxw);

   137

}

   138

   139

static void DrawAircraftEngineInfo(EngineID engine, int x, int y, int maxw)

   140

{

   141

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

   142

	SetDParam(0, (_price.aircraft_base >> 3) * avi->base_cost >> 5);

   143

	SetDParam(1, avi->max_speed);

   144

	SetDParam(2, avi->passenger_capacity);

   145

	SetDParam(3, avi->mail_capacity);

   146

	SetDParam(4, avi->running_cost * _price.aircraft_running >> 8);

   147

   148

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

   149

}

   150

   151

static void DrawRoadVehEngineInfo(EngineID engine, int x, int y, int maxw)

   152

{

   153

	const RoadVehicleInfo *rvi = RoadVehInfo(engine);

   154

   155

	SetDParam(0, (_price.roadveh_base >> 3) * rvi->base_cost >> 5);

   156

	SetDParam(1, rvi->max_speed * 10 / 32);

   157

	SetDParam(2, rvi->running_cost * _price.roadveh_running >> 8);

   158

	SetDParam(3, rvi->cargo_type);

   159

	SetDParam(4, rvi->capacity);

   160

   161

	DrawStringMultiCenter(x, y, STR_902A_COST_SPEED_RUNNING_COST, maxw);

   162

}

   163

   164

static void DrawShipEngineInfo(EngineID engine, int x, int y, int maxw)

   165

{

   166

	const ShipVehicleInfo *svi = ShipVehInfo(engine);

   167

	SetDParam(0, svi->base_cost * (_price.ship_base >> 3) >> 5);

   168

	SetDParam(1, svi->max_speed * 10 / 32);

   169

	SetDParam(2, svi->cargo_type);

   170

	SetDParam(3, svi->capacity);

   171

	SetDParam(4, svi->running_cost * _price.ship_running >> 8);

   172

	DrawStringMultiCenter(x, y, STR_982E_COST_MAX_SPEED_CAPACITY, maxw);

   173

}

   174

   175

   176

StringID GetNewsStringNewVehicleAvail(const NewsItem *ni)

   177

{

   178

	EngineID engine = ni->string_id;

   179

	SetDParam(0, GetEngineCategoryName(engine));

   180

	SetDParam(1, GetCustomEngineName(engine));

   181

	return STR_NEW_VEHICLE_NOW_AVAILABLE_WITH_TYPE;

   182

}

   183

   184

void DrawNewsNewVehicleAvail(Window *w)

   185

{

   186

	DrawNewsBorder(w);

   187

   188

	EngineID engine = WP(w, news_d).ni->string_id;

   189

	const DrawEngineInfo *dei = &_draw_engine_list[GetEngine(engine)->type];

   190

   191

	SetDParam(0, GetEngineCategoryName(engine));

   192

	DrawStringMultiCenter(w->width >> 1, 20, STR_NEW_VEHICLE_NOW_AVAILABLE, w->width - 2);

   193

   194

	GfxFillRect(25, 56, w->width - 25, w->height - 2, 10);

   195

   196

	SetDParam(0, GetCustomEngineName(engine));

   197

	DrawStringMultiCenter(w->width >> 1, 57, STR_NEW_VEHICLE_TYPE, w->width - 2);

   198

   199

	dei->engine_proc(w->width >> 1, 88, engine, 0);

   200

	GfxFillRect(25, 56, w->width - 56, 112, PALETTE_TO_STRUCT_GREY | (1 << USE_COLORTABLE));

   201

	dei->info_proc(engine, w->width >> 1, 129, w->width - 52);

   202

}