1

/* $Id$ */

     2

     3

/** @file engine_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "gui.h"

     8

#include "window_gui.h"

     9

#include "gfx_func.h"

    10

#include "engine_func.h"

    11

#include "command_func.h"

    12

#include "economy_func.h"

    13

#include "news_func.h"

    14

#include "variables.h"

    15

#include "newgrf_engine.h"

    16

#include "strings_func.h"

    17

    18

#include "table/strings.h"

    19

#include "table/sprites.h"

    20

    21

static StringID GetEngineCategoryName(EngineID engine)

    22

{

    23

	switch (GetEngine(engine)->type) {

    24

		default: NOT_REACHED();

    25

		case VEH_ROAD:              return STR_8103_ROAD_VEHICLE;

    26

		case VEH_AIRCRAFT:          return STR_8104_AIRCRAFT;

    27

		case VEH_SHIP:              return STR_8105_SHIP;

    28

		case VEH_TRAIN:

    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

		SetDParam(0, engine);

    82

		DrawStringCentered(w->width >> 1, 80, STR_ENGINE_NAME, TC_BLACK);

    83

    84

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

    85

    86

		width = w->width;

    87

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

    88

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

    89

		break;

    90

	}

    91

    92

	case WE_CLICK:

    93

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

    94

			case 4:

    95

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

    96

				/* Fallthrough */

    97

			case 3:

    98

				DeleteWindow(w);

    99

				break;

   100

		}

   101

		break;

   102

	}

   103

}

   104

   105

static const WindowDesc _engine_preview_desc = {

   106

	WDP_CENTER, WDP_CENTER, 300, 192, 300, 192,

   107

	WC_ENGINE_PREVIEW, WC_NONE,

   108

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   109

	_engine_preview_widgets,

   110

	EnginePreviewWndProc

   111

};

   112

   113

   114

void ShowEnginePreviewWindow(EngineID engine)

   115

{

   116

	AllocateWindowDescFront(&_engine_preview_desc, engine);

   117

}

   118

   119

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

   120

{

   121

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   122

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

   123

   124

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

   125

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

   126

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

   127

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

   128

   129

	SetDParam(4, rvi->running_cost * GetPriceByIndex(rvi->running_cost_class) >> 8 << multihead);

   130

   131

	if (rvi->capacity != 0) {

   132

		SetDParam(5, rvi->cargo_type);

   133

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

   134

	} else {

   135

		SetDParam(5, CT_INVALID);

   136

	}

   137

	DrawStringMultiCenter(x, y, STR_VEHICLE_INFO_COST_WEIGHT_SPEED_POWER, maxw);

   138

}

   139

   140

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

   141

{

   142

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

   143

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

   144

	SetDParam(1, avi->max_speed * 10 / 16);

   145

	SetDParam(2, avi->passenger_capacity);

   146

	SetDParam(3, avi->mail_capacity);

   147

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

   148

   149

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

   150

}

   151

   152

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

   153

{

   154

	const RoadVehicleInfo *rvi = RoadVehInfo(engine);

   155

   156

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

   157

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

   158

	SetDParam(2, rvi->running_cost * GetPriceByIndex(rvi->running_cost_class) >> 8);

   159

	SetDParam(3, rvi->cargo_type);

   160

	SetDParam(4, rvi->capacity);

   161

   162

	DrawStringMultiCenter(x, y, STR_902A_COST_SPEED_RUNNING_COST, maxw);

   163

}

   164

   165

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

   166

{

   167

	const ShipVehicleInfo *svi = ShipVehInfo(engine);

   168

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

   169

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

   170

	SetDParam(2, svi->cargo_type);

   171

	SetDParam(3, svi->capacity);

   172

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

   173

	DrawStringMultiCenter(x, y, STR_982E_COST_MAX_SPEED_CAPACITY, maxw);

   174

}

   175

   176

   177

StringID GetNewsStringNewVehicleAvail(const NewsItem *ni)

   178

{

   179

	EngineID engine = ni->string_id;

   180

	SetDParam(0, GetEngineCategoryName(engine));

   181

	SetDParam(1, engine);

   182

	return STR_NEW_VEHICLE_NOW_AVAILABLE_WITH_TYPE;

   183

}

   184

   185

void DrawNewsNewVehicleAvail(Window *w, const NewsItem *ni)

   186

{

   187

	DrawNewsBorder(w);

   188

   189

	EngineID engine = ni->string_id;

   190

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

   191

   192

	SetDParam(0, GetEngineCategoryName(engine));

   193

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

   194

   195

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

   196

   197

	SetDParam(0, engine);

   198

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

   199

   200

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

   201

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

   202

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

   203

}