00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "stdafx.h"
00013 #include "window_gui.h"
00014 #include "command_func.h"
00015 #include "train.h"
00016 #include "strings_func.h"
00017 #include "vehicle_func.h"
00018
00019 #include "table/strings.h"
00020
00028 void CcBuildWagon(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2)
00029 {
00030 if (result.Failed()) return;
00031
00032
00033 const Vehicle *found = NULL;
00034 const Train *t;
00035 FOR_ALL_TRAINS(t) {
00036 if (t->IsFrontEngine() && t->tile == tile && t->IsStoppedInDepot()) {
00037 if (found != NULL) return;
00038 found = t;
00039 }
00040 }
00041
00042
00043 if (found != NULL) {
00044 found = found->Last();
00045
00046 DoCommandP(0, _new_vehicle_id, found->index, CMD_MOVE_RAIL_VEHICLE);
00047 InvalidateWindowClassesData(WC_TRAINS_LIST, 0);
00048 }
00049 }
00050
00058 static int HighlightDragPosition(int px, int max_width, VehicleID selection)
00059 {
00060 bool rtl = _current_text_dir == TD_RTL;
00061
00062 assert(selection != INVALID_VEHICLE);
00063 int dragged_width = WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;
00064 for (Train *t = Train::Get(selection); t != NULL; t = t->HasArticulatedPart() ? t->GetNextArticulatedPart() : NULL) {
00065 dragged_width += t->GetDisplayImageWidth(NULL);
00066 }
00067
00068 int drag_hlight_left = rtl ? max(px -dragged_width, 0) : px;
00069 int drag_hlight_right = rtl ? px : min(px + dragged_width, max_width);
00070 int drag_hlight_width = max(drag_hlight_right - drag_hlight_left, 0);
00071
00072 if (drag_hlight_width > 0) {
00073 GfxFillRect(drag_hlight_left + WD_FRAMERECT_LEFT, WD_FRAMERECT_TOP + 1,
00074 drag_hlight_right - WD_FRAMERECT_RIGHT, 13 - WD_FRAMERECT_BOTTOM, _colour_gradient[COLOUR_GREY][7]);
00075 }
00076
00077 return drag_hlight_width;
00078 }
00079
00090 void DrawTrainImage(const Train *v, int left, int right, int y, VehicleID selection, EngineImageType image_type, int skip, VehicleID drag_dest)
00091 {
00092 bool rtl = _current_text_dir == TD_RTL;
00093 Direction dir = rtl ? DIR_E : DIR_W;
00094
00095 DrawPixelInfo tmp_dpi, *old_dpi;
00096
00097 int highlight_l = 0;
00098 int highlight_r = 0;
00099 int max_width = right - left + 1;
00100
00101 if (!FillDrawPixelInfo(&tmp_dpi, left, y, max_width, 14)) return;
00102
00103 old_dpi = _cur_dpi;
00104 _cur_dpi = &tmp_dpi;
00105
00106 int px = rtl ? max_width + skip : -skip;
00107 bool sel_articulated = false;
00108 bool dragging = (drag_dest != INVALID_VEHICLE);
00109 bool drag_at_end_of_train = (drag_dest == v->index);
00110 for (; v != NULL && (rtl ? px > 0 : px < max_width); v = v->Next()) {
00111 if (dragging && !drag_at_end_of_train && drag_dest == v->index) {
00112
00113 int drag_hlight_width = HighlightDragPosition(px, max_width, selection);
00114 px += rtl ? -drag_hlight_width : drag_hlight_width;
00115 }
00116
00117 Point offset;
00118 int width = Train::From(v)->GetDisplayImageWidth(&offset);
00119
00120 if (rtl ? px + width > 0 : px - width < max_width) {
00121 PaletteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);
00122 DrawSprite(v->GetImage(dir, image_type), pal, px + (rtl ? -offset.x : offset.x), 7 + offset.y);
00123 }
00124
00125 if (!v->IsArticulatedPart()) sel_articulated = false;
00126
00127 if (v->index == selection) {
00128
00129 highlight_l = rtl ? px - width : px;
00130 highlight_r = rtl ? px - 1 : px + width - 1;
00131 sel_articulated = true;
00132 } else if ((_cursor.vehchain && highlight_r != 0) || sel_articulated) {
00133 if (rtl) {
00134 highlight_l -= width;
00135 } else {
00136 highlight_r += width;
00137 }
00138 }
00139
00140 px += rtl ? -width : width;
00141 }
00142
00143 if (dragging && drag_at_end_of_train) {
00144
00145 HighlightDragPosition(px, max_width, selection);
00146 }
00147
00148 if (highlight_l != highlight_r) {
00149
00150
00151 DrawFrameRect(highlight_l, 0, highlight_r, 13, COLOUR_WHITE, FR_BORDERONLY);
00152 }
00153
00154 _cur_dpi = old_dpi;
00155 }
00156
00158 struct CargoSummaryItem {
00159 CargoID cargo;
00160 StringID subtype;
00161 uint capacity;
00162 uint amount;
00163 StationID source;
00164
00166 inline bool operator != (const CargoSummaryItem &other) const
00167 {
00168 return this->cargo != other.cargo || this->subtype != other.subtype;
00169 }
00170 };
00171
00172 static const uint TRAIN_DETAILS_MIN_INDENT = 32;
00173 static const uint TRAIN_DETAILS_MAX_INDENT = 72;
00174
00176 typedef SmallVector<CargoSummaryItem, 2> CargoSummary;
00178 static CargoSummary _cargo_summary;
00179
00188 static void TrainDetailsCargoTab(const CargoSummaryItem *item, int left, int right, int y)
00189 {
00190 StringID str;
00191 if (item->amount > 0) {
00192 SetDParam(0, item->cargo);
00193 SetDParam(1, item->amount);
00194 SetDParam(2, item->source);
00195 SetDParam(3, _settings_game.vehicle.freight_trains);
00196 str = FreightWagonMult(item->cargo) > 1 ? STR_VEHICLE_DETAILS_CARGO_FROM_MULT : STR_VEHICLE_DETAILS_CARGO_FROM;
00197 } else {
00198 SetDParam(0, STR_QUANTITY_N_A);
00199 str = item->cargo == INVALID_CARGO ? STR_LTBLUE_STRING : STR_VEHICLE_DETAILS_CARGO_EMPTY;
00200 }
00201
00202 DrawString(left, right, y, str);
00203 }
00204
00213 static void TrainDetailsInfoTab(const Vehicle *v, int left, int right, int y)
00214 {
00215 if (RailVehInfo(v->engine_type)->railveh_type == RAILVEH_WAGON) {
00216 SetDParam(0, v->engine_type);
00217 SetDParam(1, v->value);
00218 DrawString(left, right, y, STR_VEHICLE_DETAILS_TRAIN_WAGON_VALUE);
00219 } else {
00220 SetDParam(0, v->engine_type);
00221 SetDParam(1, v->build_year);
00222 SetDParam(2, v->value);
00223 DrawString(left, right, y, STR_VEHICLE_DETAILS_TRAIN_ENGINE_BUILT_AND_VALUE);
00224 }
00225 }
00226
00235 static void TrainDetailsCapacityTab(const CargoSummaryItem *item, int left, int right, int y)
00236 {
00237 StringID str;
00238 if (item->cargo != INVALID_CARGO) {
00239 SetDParam(0, item->cargo);
00240 SetDParam(1, item->capacity);
00241 SetDParam(4, item->subtype);
00242 SetDParam(5, _settings_game.vehicle.freight_trains);
00243 str = FreightWagonMult(item->cargo) > 1 ? STR_VEHICLE_INFO_CAPACITY_MULT : STR_VEHICLE_INFO_CAPACITY;
00244 } else {
00245
00246 SetDParam(0, item->subtype);
00247 str = STR_VEHICLE_INFO_NO_CAPACITY;
00248 }
00249 DrawString(left, right, y, str);
00250 }
00251
00257 static void GetCargoSummaryOfArticulatedVehicle(const Train *v, CargoSummary *summary)
00258 {
00259 summary->Clear();
00260 do {
00261 if (!v->GetEngine()->CanCarryCargo()) continue;
00262
00263 CargoSummaryItem new_item;
00264 new_item.cargo = v->cargo_cap > 0 ? v->cargo_type : INVALID_CARGO;
00265 new_item.subtype = GetCargoSubtypeText(v);
00266 if (new_item.cargo == INVALID_CARGO && new_item.subtype == STR_EMPTY) continue;
00267
00268 CargoSummaryItem *item = summary->Find(new_item);
00269 if (item == summary->End()) {
00270 item = summary->Append();
00271 item->cargo = new_item.cargo;
00272 item->subtype = new_item.subtype;
00273 item->capacity = 0;
00274 item->amount = 0;
00275 item->source = INVALID_STATION;
00276 }
00277
00278 item->capacity += v->cargo_cap;
00279 item->amount += v->cargo.StoredCount();
00280 if (item->source == INVALID_STATION) item->source = v->cargo.Source();
00281 } while ((v = v->Next()) != NULL && v->IsArticulatedPart());
00282 }
00283
00289 static uint GetLengthOfArticulatedVehicle(const Train *v)
00290 {
00291 uint length = 0;
00292
00293 do {
00294 length += v->GetDisplayImageWidth();
00295 } while ((v = v->Next()) != NULL && v->IsArticulatedPart());
00296
00297 return length;
00298 }
00299
00306 int GetTrainDetailsWndVScroll(VehicleID veh_id, TrainDetailsWindowTabs det_tab)
00307 {
00308 int num = 0;
00309
00310 if (det_tab == TDW_TAB_TOTALS) {
00311 CargoArray act_cargo;
00312 CargoArray max_cargo;
00313 for (const Vehicle *v = Vehicle::Get(veh_id); v != NULL; v = v->Next()) {
00314 act_cargo[v->cargo_type] += v->cargo.StoredCount();
00315 max_cargo[v->cargo_type] += v->cargo_cap;
00316 }
00317
00318
00319
00320
00321 for (CargoID i = 0; i < NUM_CARGO; i++) {
00322 if (max_cargo[i] > 0) num++;
00323 }
00324 num++;
00325 } else {
00326 for (const Train *v = Train::Get(veh_id); v != NULL; v = v->GetNextVehicle()) {
00327 GetCargoSummaryOfArticulatedVehicle(v, &_cargo_summary);
00328 num += max(1u, _cargo_summary.Length());
00329
00330 uint length = GetLengthOfArticulatedVehicle(v);
00331 if (length > TRAIN_DETAILS_MAX_INDENT) num++;
00332 }
00333 }
00334
00335 return num;
00336 }
00337
00349 void DrawTrainDetails(const Train *v, int left, int right, int y, int vscroll_pos, uint16 vscroll_cap, TrainDetailsWindowTabs det_tab)
00350 {
00351
00352 if (det_tab != TDW_TAB_TOTALS) {
00353 bool rtl = _current_text_dir == TD_RTL;
00354 Direction dir = rtl ? DIR_E : DIR_W;
00355 int x = rtl ? right : left;
00356 int sprite_y_offset = 4 + (FONT_HEIGHT_NORMAL - 10) / 2;
00357 int line_height = WD_MATRIX_TOP + FONT_HEIGHT_NORMAL + WD_MATRIX_BOTTOM;
00358 for (; v != NULL && vscroll_pos > -vscroll_cap; v = v->GetNextVehicle()) {
00359 GetCargoSummaryOfArticulatedVehicle(v, &_cargo_summary);
00360
00361
00362 uint dx = 0;
00363 int px = x;
00364 const Train *u = v;
00365 do {
00366 Point offset;
00367 int width = u->GetDisplayImageWidth(&offset);
00368 if (vscroll_pos <= 0 && vscroll_pos > -vscroll_cap) {
00369 PaletteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);
00370 DrawSprite(u->GetImage(dir, EIT_IN_DETAILS), pal, px + (rtl ? -offset.x : offset.x), y - line_height * vscroll_pos + sprite_y_offset + offset.y);
00371 }
00372 px += rtl ? -width : width;
00373 dx += width;
00374 u = u->Next();
00375 } while (u != NULL && u->IsArticulatedPart());
00376
00377 bool separate_sprite_row = (dx > TRAIN_DETAILS_MAX_INDENT);
00378 if (separate_sprite_row) {
00379 vscroll_pos--;
00380 dx = 0;
00381 }
00382
00383 uint num_lines = max(1u, _cargo_summary.Length());
00384 for (uint i = 0; i < num_lines; i++) {
00385 int sprite_width = max<int>(dx, TRAIN_DETAILS_MIN_INDENT) + 3;
00386 int data_left = left + (rtl ? 0 : sprite_width);
00387 int data_right = right - (rtl ? sprite_width : 0);
00388 if (vscroll_pos <= 0 && vscroll_pos > -vscroll_cap) {
00389 int py = y - line_height * vscroll_pos;
00390 if (i > 0 || separate_sprite_row) {
00391 if (vscroll_pos != 0) GfxFillRect(left, py - WD_MATRIX_TOP - 1, right, py - WD_MATRIX_TOP, _colour_gradient[COLOUR_GREY][5]);
00392 }
00393 switch (det_tab) {
00394 case TDW_TAB_CARGO:
00395 if (i < _cargo_summary.Length()) {
00396 TrainDetailsCargoTab(&_cargo_summary[i], data_left, data_right, py);
00397 } else {
00398 DrawString(data_left, data_right, py, STR_QUANTITY_N_A, TC_LIGHT_BLUE);
00399 }
00400 break;
00401
00402 case TDW_TAB_INFO:
00403 if (i == 0) TrainDetailsInfoTab(v, data_left, data_right, py);
00404 break;
00405
00406 case TDW_TAB_CAPACITY:
00407 if (i < _cargo_summary.Length()) {
00408 TrainDetailsCapacityTab(&_cargo_summary[i], data_left, data_right, py);
00409 } else {
00410 SetDParam(0, STR_EMPTY);
00411 DrawString(data_left, data_right, py, STR_VEHICLE_INFO_NO_CAPACITY);
00412 }
00413 break;
00414
00415 default: NOT_REACHED();
00416 }
00417 }
00418 vscroll_pos--;
00419 }
00420 }
00421 } else {
00422 CargoArray act_cargo;
00423 CargoArray max_cargo;
00424 Money feeder_share = 0;
00425
00426 for (const Vehicle *u = v; u != NULL; u = u->Next()) {
00427 act_cargo[u->cargo_type] += u->cargo.StoredCount();
00428 max_cargo[u->cargo_type] += u->cargo_cap;
00429 feeder_share += u->cargo.FeederShare();
00430 }
00431
00432
00433 DrawString(left, right, y, STR_VEHICLE_DETAILS_TRAIN_TOTAL_CAPACITY_TEXT);
00434 y += WD_MATRIX_TOP + FONT_HEIGHT_NORMAL + WD_MATRIX_BOTTOM;
00435
00436 for (CargoID i = 0; i < NUM_CARGO; i++) {
00437 if (max_cargo[i] > 0 && --vscroll_pos < 0 && vscroll_pos > -vscroll_cap) {
00438 SetDParam(0, i);
00439 SetDParam(1, act_cargo[i]);
00440 SetDParam(2, i);
00441 SetDParam(3, max_cargo[i]);
00442 SetDParam(4, _settings_game.vehicle.freight_trains);
00443 DrawString(left, right, y, FreightWagonMult(i) > 1 ? STR_VEHICLE_DETAILS_TRAIN_TOTAL_CAPACITY_MULT : STR_VEHICLE_DETAILS_TRAIN_TOTAL_CAPACITY);
00444 y += WD_MATRIX_TOP + FONT_HEIGHT_NORMAL + WD_MATRIX_BOTTOM;
00445 }
00446 }
00447 SetDParam(0, feeder_share);
00448 DrawString(left, right, y, STR_VEHICLE_INFO_FEEDER_CARGO_VALUE);
00449 }
00450 }