train_gui.cpp

Go to the documentation of this file.
00001 /* $Id: train_gui.cpp 25500 2013-06-28 19:29:08Z rubidium $ */
00002 
00003 /*
00004  * This file is part of OpenTTD.
00005  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
00006  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00007  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
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   /* find a locomotive in the depot. */
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; // must be exactly one.
00038       found = t;
00039     }
00040   }
00041 
00042   /* if we found a loco, */
00043   if (found != NULL) {
00044     found = found->Last();
00045     /* put the new wagon at the end of the loco. */
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   /* Position of highlight box */
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); // Head index is used to mark dragging at end of train.
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       /* Highlight the drag-and-drop destination inside the train. */
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       /* Set the highlight position */
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     /* Highlight the drag-and-drop destination at the end of the train. */
00145     HighlightDragPosition(px, max_width, selection);
00146   }
00147 
00148   if (highlight_l != highlight_r) {
00149     /* Draw the highlight. Now done after drawing all the engines, as
00150      * the next engine after the highlight could overlap it. */
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     /* Draw subtype only */
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.Count();
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) { // Total cargo tab
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.Count();
00315       max_cargo[v->cargo_type] += v->cargo_cap;
00316     }
00317 
00318     /* Set scroll-amount separately from counting, as to not compute num double
00319      * for more carriages of the same type
00320      */
00321     for (CargoID i = 0; i < NUM_CARGO; i++) {
00322       if (max_cargo[i] > 0) num++; // only count carriages that the train has
00323     }
00324     num++; // needs one more because first line is description string
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   /* draw the first 3 details tabs */
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       /* Draw sprites */
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.Count();
00428       max_cargo[u->cargo_type] += u->cargo_cap;
00429       feeder_share             += u->cargo.FeederShare();
00430     }
00431 
00432     /* draw total cargo tab */
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);            // {CARGO} #1
00439         SetDParam(1, act_cargo[i]); // {CARGO} #2
00440         SetDParam(2, i);            // {SHORTCARGO} #1
00441         SetDParam(3, max_cargo[i]); // {SHORTCARGO} #2
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 }