train_gui.cpp

Go to the documentation of this file.
00001 /* $Id$ */
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 "gfx_func.h"
00015 #include "command_func.h"
00016 #include "vehicle_gui.h"
00017 #include "train.h"
00018 #include "strings_func.h"
00019 #include "vehicle_func.h"
00020 #include "window_func.h"
00021 
00022 #include "table/sprites.h"
00023 #include "table/strings.h"
00024 
00032 void CcBuildWagon(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2)
00033 {
00034   if (result.Failed()) return;
00035 
00036   /* find a locomotive in the depot. */
00037   const Vehicle *found = NULL;
00038   const Train *t;
00039   FOR_ALL_TRAINS(t) {
00040     if (t->IsFrontEngine() && t->tile == tile &&
00041         t->track == TRACK_BIT_DEPOT) {
00042       if (found != NULL) return; // must be exactly one.
00043       found = t;
00044     }
00045   }
00046 
00047   /* if we found a loco, */
00048   if (found != NULL) {
00049     found = found->Last();
00050     /* put the new wagon at the end of the loco. */
00051     DoCommandP(0, _new_vehicle_id, found->index, CMD_MOVE_RAIL_VEHICLE);
00052     InvalidateWindowClassesData(WC_TRAINS_LIST, 0);
00053   }
00054 }
00055 
00063 static int HighlightDragPosition(int px, int max_width, VehicleID selection)
00064 {
00065   bool rtl = _current_text_dir == TD_RTL;
00066 
00067   assert(selection != INVALID_VEHICLE);
00068   Point offset;
00069   int dragged_width = Train::Get(selection)->GetDisplayImageWidth(&offset) + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;
00070 
00071   int drag_hlight_left = rtl ? max(px -dragged_width, 0) : px;
00072   int drag_hlight_right = rtl ? px : min(px + dragged_width, max_width);
00073   int drag_hlight_width = max(drag_hlight_right - drag_hlight_left, 0);
00074 
00075   if (drag_hlight_width > 0) {
00076     GfxFillRect(drag_hlight_left + WD_FRAMERECT_LEFT, WD_FRAMERECT_TOP + 1,
00077         drag_hlight_right - WD_FRAMERECT_RIGHT, 13 - WD_FRAMERECT_BOTTOM, _colour_gradient[COLOUR_GREY][7]);
00078   }
00079 
00080   return drag_hlight_width;
00081 }
00082 
00093 void DrawTrainImage(const Train *v, int left, int right, int y, VehicleID selection, int skip, VehicleID drag_dest)
00094 {
00095   bool rtl = _current_text_dir == TD_RTL;
00096   Direction dir = rtl ? DIR_E : DIR_W;
00097 
00098   DrawPixelInfo tmp_dpi, *old_dpi;
00099   /* Position of highlight box */
00100   int highlight_l = 0;
00101   int highlight_r = 0;
00102   int max_width = right - left + 1;
00103 
00104   if (!FillDrawPixelInfo(&tmp_dpi, left, y, max_width, 14)) return;
00105 
00106   old_dpi = _cur_dpi;
00107   _cur_dpi = &tmp_dpi;
00108 
00109   int px = rtl ? max_width + skip : -skip;
00110   bool sel_articulated = false;
00111   bool dragging = (drag_dest != INVALID_VEHICLE);
00112   bool drag_at_end_of_train = (drag_dest == v->index); // Head index is used to mark dragging at end of train.
00113   for (; v != NULL && (rtl ? px > 0 : px < max_width); v = v->Next()) {
00114     if (dragging && !drag_at_end_of_train && drag_dest == v->index) {
00115       /* Highlight the drag-and-drop destination inside the train. */
00116       int drag_hlight_width = HighlightDragPosition(px, max_width, selection);
00117       px += rtl ? -drag_hlight_width : drag_hlight_width;
00118     }
00119 
00120     Point offset;
00121     int width = Train::From(v)->GetDisplayImageWidth(&offset);
00122 
00123     if (rtl ? px + width > 0 : px - width < max_width) {
00124       PaletteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);
00125       DrawSprite(v->GetImage(dir), pal, px + (rtl ? -offset.x : offset.x), 7 + offset.y);
00126     }
00127 
00128     if (!v->IsArticulatedPart()) sel_articulated = false;
00129 
00130     if (v->index == selection) {
00131       /* Set the highlight position */
00132       highlight_l = rtl ? px - width : px;
00133       highlight_r = rtl ? px - 1 : px + width - 1;
00134       sel_articulated = true;
00135     } else if ((_cursor.vehchain && highlight_r != 0) || sel_articulated) {
00136       if (rtl) {
00137         highlight_l -= width;
00138       } else {
00139         highlight_r += width;
00140       }
00141     }
00142 
00143     px += rtl ? -width : width;
00144   }
00145 
00146   if (dragging && drag_at_end_of_train) {
00147     /* Highlight the drag-and-drop destination at the end of the train. */
00148     HighlightDragPosition(px, max_width, selection);
00149   }
00150 
00151   if (highlight_l != highlight_r) {
00152     /* Draw the highlight. Now done after drawing all the engines, as
00153      * the next engine after the highlight could overlap it. */
00154     DrawFrameRect(highlight_l, 0, highlight_r, 13, COLOUR_WHITE, FR_BORDERONLY);
00155   }
00156 
00157   _cur_dpi = old_dpi;
00158 }
00159 
00161 struct CargoSummaryItem {
00162   CargoID cargo;    
00163   StringID subtype; 
00164   uint capacity;    
00165   uint amount;      
00166   StationID source; 
00167 
00169   FORCEINLINE bool operator != (const CargoSummaryItem &other) const
00170   {
00171     return this->cargo != other.cargo || this->subtype != other.subtype;
00172   }
00173 };
00174 
00175 static const uint TRAIN_DETAILS_MIN_INDENT = 32; 
00176 static const uint TRAIN_DETAILS_MAX_INDENT = 72; 
00177 
00179 typedef SmallVector<CargoSummaryItem, 2> CargoSummary;
00181 static CargoSummary _cargo_summary;
00182 
00191 static void TrainDetailsCargoTab(const CargoSummaryItem *item, int left, int right, int y)
00192 {
00193   StringID str = STR_VEHICLE_DETAILS_CARGO_EMPTY;
00194 
00195   if (item->amount > 0) {
00196     SetDParam(0, item->cargo);
00197     SetDParam(1, item->amount);
00198     SetDParam(2, item->source);
00199     SetDParam(3, _settings_game.vehicle.freight_trains);
00200     str = FreightWagonMult(item->cargo) > 1 ? STR_VEHICLE_DETAILS_CARGO_FROM_MULT : STR_VEHICLE_DETAILS_CARGO_FROM;
00201   }
00202 
00203   DrawString(left, right, y, str);
00204 }
00205 
00214 static void TrainDetailsInfoTab(const Vehicle *v, int left, int right, int y)
00215 {
00216   if (RailVehInfo(v->engine_type)->railveh_type == RAILVEH_WAGON) {
00217     SetDParam(0, v->engine_type);
00218     SetDParam(1, v->value);
00219     DrawString(left, right, y, STR_VEHICLE_DETAILS_TRAIN_WAGON_VALUE, TC_FROMSTRING, SA_LEFT | SA_STRIP);
00220   } else {
00221     SetDParam(0, v->engine_type);
00222     SetDParam(1, v->build_year);
00223     SetDParam(2, v->value);
00224     DrawString(left, right, y, STR_VEHICLE_DETAILS_TRAIN_ENGINE_BUILT_AND_VALUE, TC_FROMSTRING, SA_LEFT | SA_STRIP);
00225   }
00226 }
00227 
00236 static void TrainDetailsCapacityTab(const CargoSummaryItem *item, int left, int right, int y)
00237 {
00238   SetDParam(0, item->cargo);
00239   SetDParam(1, item->capacity);
00240   SetDParam(4, item->subtype);
00241   SetDParam(5, _settings_game.vehicle.freight_trains);
00242   DrawString(left, right, y, FreightWagonMult(item->cargo) > 1 ? STR_VEHICLE_INFO_CAPACITY_MULT : STR_VEHICLE_INFO_CAPACITY);
00243 }
00244 
00250 static void GetCargoSummaryOfArticulatedVehicle(const Train *v, CargoSummary *summary)
00251 {
00252   summary->Clear();
00253   do {
00254     if (v->cargo_cap == 0) continue;
00255 
00256     CargoSummaryItem new_item;
00257     new_item.cargo = v->cargo_type;
00258     new_item.subtype = GetCargoSubtypeText(v);
00259 
00260     CargoSummaryItem *item = summary->Find(new_item);
00261     if (item == summary->End()) {
00262       item = summary->Append();
00263       item->cargo = new_item.cargo;
00264       item->subtype = new_item.subtype;
00265       item->capacity = 0;
00266       item->amount = 0;
00267       item->source = INVALID_STATION;
00268     }
00269 
00270     item->capacity += v->cargo_cap;
00271     item->amount += v->cargo.Count();
00272     if (item->source == INVALID_STATION) item->source = v->cargo.Source();
00273   } while ((v = v->Next()) != NULL && v->IsArticulatedPart());
00274 }
00275 
00281 static uint GetLengthOfArticulatedVehicle(const Train *v)
00282 {
00283   uint length = 0;
00284 
00285   do {
00286     length += v->GetDisplayImageWidth();
00287   } while ((v = v->Next()) != NULL && v->IsArticulatedPart());
00288 
00289   return length;
00290 }
00291 
00298 int GetTrainDetailsWndVScroll(VehicleID veh_id, TrainDetailsWindowTabs det_tab)
00299 {
00300   int num = 0;
00301 
00302   if (det_tab == TDW_TAB_TOTALS) { // Total cargo tab
00303     CargoArray act_cargo;
00304     CargoArray max_cargo;
00305     CargoDestSummary dests[NUM_CARGO];
00306     for (const Vehicle *v = Vehicle::Get(veh_id); v != NULL; v = v->Next()) {
00307       act_cargo[v->cargo_type] += v->cargo.Count();
00308       max_cargo[v->cargo_type] += v->cargo_cap;
00309       AddVehicleCargoDestSummary(v, &dests[v->cargo_type]);
00310     }
00311 
00312     /* Set scroll-amount seperately from counting, as to not compute num double
00313      * for more carriages of the same type
00314      */
00315     for (CargoID i = 0; i < NUM_CARGO; i++) {
00316       if (max_cargo[i] > 0) num++; // only count carriages that the train has
00317       num += (int)dests[i].size();
00318     }
00319     num += 2; // needs one more because first line is description string
00320   } else {
00321     for (const Train *v = Train::Get(veh_id); v != NULL; v = v->GetNextVehicle()) {
00322       GetCargoSummaryOfArticulatedVehicle(v, &_cargo_summary);
00323       num += max(1u, _cargo_summary.Length());
00324 
00325       uint length = GetLengthOfArticulatedVehicle(v);
00326       if (length > TRAIN_DETAILS_MAX_INDENT) num++;
00327     }
00328   }
00329 
00330   return num;
00331 }
00332 
00344 void DrawTrainDetails(const Train *v, int left, int right, int y, int vscroll_pos, uint16 vscroll_cap, TrainDetailsWindowTabs det_tab)
00345 {
00346   /* draw the first 3 details tabs */
00347   if (det_tab != TDW_TAB_TOTALS) {
00348     bool rtl = _current_text_dir == TD_RTL;
00349     Direction dir = rtl ? DIR_E : DIR_W;
00350     int x = rtl ? right : left;
00351     int sprite_y_offset = 4 + (FONT_HEIGHT_NORMAL - 10) / 2;
00352     int line_height = WD_MATRIX_TOP + FONT_HEIGHT_NORMAL + WD_MATRIX_BOTTOM;
00353     for (; v != NULL && vscroll_pos > -vscroll_cap; v = v->GetNextVehicle()) {
00354       GetCargoSummaryOfArticulatedVehicle(v, &_cargo_summary);
00355 
00356       /* Draw sprites */
00357       uint dx = 0;
00358       int px = x;
00359       const Train *u = v;
00360       do {
00361         Point offset;
00362         int width = u->GetDisplayImageWidth(&offset);
00363         if (vscroll_pos <= 0 && vscroll_pos > -vscroll_cap) {
00364           PaletteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);
00365           DrawSprite(u->GetImage(dir), pal, px + (rtl ? -offset.x : offset.x), y - line_height * vscroll_pos + sprite_y_offset + offset.y);
00366         }
00367         px += rtl ? -width : width;
00368         dx += width;
00369         u = u->Next();
00370       } while (u != NULL && u->IsArticulatedPart());
00371 
00372       bool separate_sprite_row = (dx > TRAIN_DETAILS_MAX_INDENT);
00373       if (separate_sprite_row) {
00374         vscroll_pos--;
00375         dx = 0;
00376       }
00377 
00378       uint num_lines = max(1u, _cargo_summary.Length());
00379       for (uint i = 0; i < num_lines; i++) {
00380         int sprite_width = max<int>(dx, TRAIN_DETAILS_MIN_INDENT) + 3;
00381         int data_left  = left + (rtl ? 0 : sprite_width);
00382         int data_right = right - (rtl ? sprite_width : 0);
00383         if (vscroll_pos <= 0 && vscroll_pos > -vscroll_cap) {
00384           int py = y - line_height * vscroll_pos;
00385           if (i > 0 || separate_sprite_row) {
00386             if (vscroll_pos != 0) GfxFillRect(left, py - WD_MATRIX_TOP - 1, right, py - WD_MATRIX_TOP, _colour_gradient[COLOUR_GREY][5]);
00387           }
00388           switch (det_tab) {
00389             case TDW_TAB_CARGO:
00390               if (i < _cargo_summary.Length()) {
00391                 TrainDetailsCargoTab(&_cargo_summary[i], data_left, data_right, py);
00392               } else {
00393                 DrawString(data_left, data_right, py, STR_QUANTITY_N_A, TC_LIGHT_BLUE);
00394               }
00395               break;
00396 
00397             case TDW_TAB_INFO:
00398               if (i == 0) TrainDetailsInfoTab(v, data_left, data_right, py);
00399               break;
00400 
00401             case TDW_TAB_CAPACITY:
00402               if (i < _cargo_summary.Length()) {
00403                 TrainDetailsCapacityTab(&_cargo_summary[i], data_left, data_right, py);
00404               } else {
00405                 DrawString(data_left, data_right, py, STR_VEHICLE_INFO_NO_CAPACITY);
00406               }
00407               break;
00408 
00409             default: NOT_REACHED();
00410           }
00411         }
00412         vscroll_pos--;
00413       }
00414     }
00415   } else {
00416     CargoArray act_cargo;
00417     CargoArray max_cargo;
00418     CargoDestSummary dests[NUM_CARGO];
00419     Money feeder_share = 0;
00420 
00421     for (const Vehicle *u = v; u != NULL; u = u->Next()) {
00422       act_cargo[u->cargo_type] += u->cargo.Count();
00423       max_cargo[u->cargo_type] += u->cargo_cap;
00424       feeder_share             += u->cargo.FeederShare();
00425 
00426       AddVehicleCargoDestSummary(u, &dests[u->cargo_type]);
00427     }
00428 
00429     /* draw total cargo tab */
00430     DrawString(left, right, y, STR_VEHICLE_DETAILS_TRAIN_TOTAL_CAPACITY_TEXT);
00431     y += WD_MATRIX_TOP + FONT_HEIGHT_NORMAL + WD_MATRIX_BOTTOM;
00432 
00433     for (CargoID i = 0; i < NUM_CARGO; i++) {
00434       if (max_cargo[i] > 0 && --vscroll_pos < 0 && vscroll_pos > -vscroll_cap) {
00435         SetDParam(0, i);            // {CARGO} #1
00436         SetDParam(1, act_cargo[i]); // {CARGO} #2
00437         SetDParam(2, i);            // {SHORTCARGO} #1
00438         SetDParam(3, max_cargo[i]); // {SHORTCARGO} #2
00439         SetDParam(4, _settings_game.vehicle.freight_trains);
00440         DrawString(left, right, y, FreightWagonMult(i) > 1 ? STR_VEHICLE_DETAILS_TRAIN_TOTAL_CAPACITY_MULT : STR_VEHICLE_DETAILS_TRAIN_TOTAL_CAPACITY);
00441         y += WD_MATRIX_TOP + FONT_HEIGHT_NORMAL + WD_MATRIX_BOTTOM;
00442       }
00443 
00444       for (CargoDestSummary::const_iterator row = dests[i].begin(); row != dests[i].end() && vscroll_pos > -vscroll_cap; ++row) {
00445         if (--vscroll_pos < 0) {
00446           SetDParam(0, i);          // {SHORTCARGO} #1
00447           SetDParam(1, row->count); // {SHORTCARGO} #2
00448           SetDParam(2, row->type == ST_INDUSTRY ? STR_INDUSTRY_NAME : (row->type == ST_TOWN ? STR_TOWN_NAME : STR_COMPANY_NAME)); // {STRING1}
00449           SetDParam(3, row->dest);  // Parameter of {STRING1}
00450           DrawString(left + 2 * WD_PAR_VSEP_WIDE, right, y, STR_VEHICLE_DETAILS_CARGO_TO);
00451           y += WD_MATRIX_TOP + FONT_HEIGHT_NORMAL + WD_MATRIX_BOTTOM;
00452         }
00453       }
00454     }
00455     SetDParam(0, feeder_share);
00456     DrawString(left, right, y, STR_VEHICLE_INFO_FEEDER_CARGO_VALUE);
00457   }
00458 }

Generated on Sun May 8 07:30:21 2011 for OpenTTD by  doxygen 1.6.1