engine_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 "engine_base.h"
00016 #include "command_func.h"
00017 #include "strings_func.h"
00018 #include "engine_gui.h"
00019 #include "articulated_vehicles.h"
00020 #include "vehicle_func.h"
00021 #include "company_func.h"
00022 #include "rail.h"
00023 #include "settings_type.h"
00024 
00025 #include "widgets/engine_widget.h"
00026 
00027 #include "table/strings.h"
00028 
00034 StringID GetEngineCategoryName(EngineID engine)
00035 {
00036   const Engine *e = Engine::Get(engine);
00037   switch (e->type) {
00038     default: NOT_REACHED();
00039     case VEH_ROAD:              return STR_ENGINE_PREVIEW_ROAD_VEHICLE;
00040     case VEH_AIRCRAFT:          return STR_ENGINE_PREVIEW_AIRCRAFT;
00041     case VEH_SHIP:              return STR_ENGINE_PREVIEW_SHIP;
00042     case VEH_TRAIN:
00043       return GetRailTypeInfo(e->u.rail.railtype)->strings.new_loco;
00044   }
00045 }
00046 
00047 static const NWidgetPart _nested_engine_preview_widgets[] = {
00048   NWidget(NWID_HORIZONTAL),
00049     NWidget(WWT_CLOSEBOX, COLOUR_LIGHT_BLUE),
00050     NWidget(WWT_CAPTION, COLOUR_LIGHT_BLUE), SetDataTip(STR_ENGINE_PREVIEW_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
00051   EndContainer(),
00052   NWidget(WWT_PANEL, COLOUR_LIGHT_BLUE),
00053     NWidget(WWT_EMPTY, INVALID_COLOUR, WID_EP_QUESTION), SetMinimalSize(300, 0), SetPadding(8, 8, 8, 8), SetFill(1, 0),
00054     NWidget(NWID_HORIZONTAL, NC_EQUALSIZE), SetPIP(85, 10, 85),
00055       NWidget(WWT_PUSHTXTBTN, COLOUR_LIGHT_BLUE, WID_EP_NO), SetDataTip(STR_QUIT_NO, STR_NULL), SetFill(1, 0),
00056       NWidget(WWT_PUSHTXTBTN, COLOUR_LIGHT_BLUE, WID_EP_YES), SetDataTip(STR_QUIT_YES, STR_NULL), SetFill(1, 0),
00057     EndContainer(),
00058     NWidget(NWID_SPACER), SetMinimalSize(0, 8),
00059   EndContainer(),
00060 };
00061 
00062 struct EnginePreviewWindow : Window {
00063   static const int VEHICLE_SPACE = 40; // The space to show the vehicle image
00064 
00065   EnginePreviewWindow(const WindowDesc *desc, WindowNumber window_number) : Window()
00066   {
00067     this->InitNested(desc, window_number);
00068   }
00069 
00070   virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
00071   {
00072     if (widget != WID_EP_QUESTION) return;
00073 
00074     EngineID engine = this->window_number;
00075     SetDParam(0, GetEngineCategoryName(engine));
00076     size->height = GetStringHeight(STR_ENGINE_PREVIEW_MESSAGE, size->width) + WD_PAR_VSEP_WIDE + FONT_HEIGHT_NORMAL + VEHICLE_SPACE;
00077     SetDParam(0, engine);
00078     size->height += GetStringHeight(GetEngineInfoString(engine), size->width);
00079   }
00080 
00081   virtual void DrawWidget(const Rect &r, int widget) const
00082   {
00083     if (widget != WID_EP_QUESTION) return;
00084 
00085     EngineID engine = this->window_number;
00086     SetDParam(0, GetEngineCategoryName(engine));
00087     int y = r.top + GetStringHeight(STR_ENGINE_PREVIEW_MESSAGE, r.right - r.top + 1);
00088     y = DrawStringMultiLine(r.left, r.right, r.top, y, STR_ENGINE_PREVIEW_MESSAGE, TC_FROMSTRING, SA_CENTER) + WD_PAR_VSEP_WIDE;
00089 
00090     SetDParam(0, engine);
00091     DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, STR_ENGINE_NAME, TC_BLACK, SA_HOR_CENTER);
00092     y += FONT_HEIGHT_NORMAL;
00093 
00094     DrawVehicleEngine(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, this->width >> 1, y + VEHICLE_SPACE / 2, engine, GetEnginePalette(engine, _local_company), EIT_PREVIEW);
00095 
00096     y += VEHICLE_SPACE;
00097     DrawStringMultiLine(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, r.bottom, GetEngineInfoString(engine), TC_FROMSTRING, SA_CENTER);
00098   }
00099 
00100   virtual void OnClick(Point pt, int widget, int click_count)
00101   {
00102     switch (widget) {
00103       case WID_EP_YES:
00104         DoCommandP(0, this->window_number, 0, CMD_WANT_ENGINE_PREVIEW);
00105         /* FALL THROUGH */
00106       case WID_EP_NO:
00107         delete this;
00108         break;
00109     }
00110   }
00111 };
00112 
00113 static const WindowDesc _engine_preview_desc(
00114   WDP_CENTER, 0, 0,
00115   WC_ENGINE_PREVIEW, WC_NONE,
00116   WDF_CONSTRUCTION,
00117   _nested_engine_preview_widgets, lengthof(_nested_engine_preview_widgets)
00118 );
00119 
00120 
00121 void ShowEnginePreviewWindow(EngineID engine)
00122 {
00123   AllocateWindowDescFront<EnginePreviewWindow>(&_engine_preview_desc, engine);
00124 }
00125 
00131 uint GetTotalCapacityOfArticulatedParts(EngineID engine)
00132 {
00133   uint total = 0;
00134 
00135   CargoArray cap = GetCapacityOfArticulatedParts(engine);
00136   for (CargoID c = 0; c < NUM_CARGO; c++) {
00137     total += cap[c];
00138   }
00139 
00140   return total;
00141 }
00142 
00143 static StringID GetTrainEngineInfoString(const Engine *e)
00144 {
00145   SetDParam(0, e->GetCost());
00146   SetDParam(2, e->GetDisplayMaxSpeed());
00147   SetDParam(3, e->GetPower());
00148   SetDParam(1, e->GetDisplayWeight());
00149   SetDParam(7, e->GetDisplayMaxTractiveEffort());
00150 
00151   SetDParam(4, e->GetRunningCost());
00152 
00153   uint capacity = GetTotalCapacityOfArticulatedParts(e->index);
00154   if (capacity != 0) {
00155     SetDParam(5, e->GetDefaultCargoType());
00156     SetDParam(6, capacity);
00157   } else {
00158     SetDParam(5, CT_INVALID);
00159   }
00160   return (_settings_game.vehicle.train_acceleration_model != AM_ORIGINAL && GetRailTypeInfo(e->u.rail.railtype)->acceleration_type != 2) ? STR_ENGINE_PREVIEW_COST_WEIGHT_SPEED_POWER_MAX_TE : STR_ENGINE_PREVIEW_COST_WEIGHT_SPEED_POWER;
00161 }
00162 
00163 static StringID GetAircraftEngineInfoString(const Engine *e)
00164 {
00165   CargoID cargo = e->GetDefaultCargoType();
00166   uint16 mail_capacity;
00167   uint capacity = e->GetDisplayDefaultCapacity(&mail_capacity);
00168   uint16 range = e->GetRange();
00169 
00170   SetDParam(0, e->GetCost());
00171   SetDParam(1, e->GetDisplayMaxSpeed());
00172   SetDParam(2, cargo);
00173   SetDParam(3, capacity);
00174   SetDParam(7, range);
00175 
00176   if (mail_capacity > 0) {
00177     SetDParam(4, CT_MAIL);
00178     SetDParam(5, mail_capacity);
00179     SetDParam(6, e->GetRunningCost());
00180     return range > 0 ? STR_ENGINE_PREVIEW_COST_MAX_SPEED_RANGE_CAPACITY_CAPACITY_RUNCOST : STR_ENGINE_PREVIEW_COST_MAX_SPEED_CAPACITY_CAPACITY_RUNCOST;
00181   } else {
00182     SetDParam(4, e->GetRunningCost());
00183     return range > 0 ? STR_ENGINE_PREVIEW_COST_MAX_SPEED_RANGE_CAPACITY_RUNCOST : STR_ENGINE_PREVIEW_COST_MAX_SPEED_CAPACITY_RUNCOST;
00184   }
00185 }
00186 
00187 static StringID GetRoadVehEngineInfoString(const Engine *e)
00188 {
00189   if (_settings_game.vehicle.roadveh_acceleration_model == AM_ORIGINAL) {
00190     SetDParam(0, e->GetCost());
00191     SetDParam(1, e->GetDisplayMaxSpeed());
00192     uint capacity = GetTotalCapacityOfArticulatedParts(e->index);
00193     if (capacity != 0) {
00194       SetDParam(2, e->GetDefaultCargoType());
00195       SetDParam(3, capacity);
00196     } else {
00197       SetDParam(2, CT_INVALID);
00198     }
00199     SetDParam(4, e->GetRunningCost());
00200     return STR_ENGINE_PREVIEW_COST_MAX_SPEED_CAPACITY_RUNCOST;
00201   } else {
00202     SetDParam(0, e->GetCost());
00203     SetDParam(2, e->GetDisplayMaxSpeed());
00204     SetDParam(3, e->GetPower());
00205     SetDParam(1, e->GetDisplayWeight());
00206     SetDParam(7, e->GetDisplayMaxTractiveEffort());
00207 
00208     SetDParam(4, e->GetRunningCost());
00209 
00210     uint capacity = GetTotalCapacityOfArticulatedParts(e->index);
00211     if (capacity != 0) {
00212       SetDParam(5, e->GetDefaultCargoType());
00213       SetDParam(6, capacity);
00214     } else {
00215       SetDParam(5, CT_INVALID);
00216     }
00217     return STR_ENGINE_PREVIEW_COST_WEIGHT_SPEED_POWER_MAX_TE;
00218   }
00219 }
00220 
00221 static StringID GetShipEngineInfoString(const Engine *e)
00222 {
00223   SetDParam(0, e->GetCost());
00224   SetDParam(1, e->GetDisplayMaxSpeed());
00225   SetDParam(2, e->GetDefaultCargoType());
00226   SetDParam(3, e->GetDisplayDefaultCapacity());
00227   SetDParam(4, e->GetRunningCost());
00228   return STR_ENGINE_PREVIEW_COST_MAX_SPEED_CAPACITY_RUNCOST;
00229 }
00230 
00231 
00238 StringID GetEngineInfoString(EngineID engine)
00239 {
00240   const Engine *e = Engine::Get(engine);
00241 
00242   switch (e->type) {
00243     case VEH_TRAIN:
00244       return GetTrainEngineInfoString(e);
00245 
00246     case VEH_ROAD:
00247       return GetRoadVehEngineInfoString(e);
00248 
00249     case VEH_SHIP:
00250       return GetShipEngineInfoString(e);
00251 
00252     case VEH_AIRCRAFT:
00253       return GetAircraftEngineInfoString(e);
00254 
00255     default: NOT_REACHED();
00256   }
00257 }
00258 
00268 void DrawVehicleEngine(int left, int right, int preferred_x, int y, EngineID engine, PaletteID pal, EngineImageType image_type)
00269 {
00270   const Engine *e = Engine::Get(engine);
00271 
00272   switch (e->type) {
00273     case VEH_TRAIN:
00274       DrawTrainEngine(left, right, preferred_x, y, engine, pal, image_type);
00275       break;
00276 
00277     case VEH_ROAD:
00278       DrawRoadVehEngine(left, right, preferred_x, y, engine, pal, image_type);
00279       break;
00280 
00281     case VEH_SHIP:
00282       DrawShipEngine(left, right, preferred_x, y, engine, pal, image_type);
00283       break;
00284 
00285     case VEH_AIRCRAFT:
00286       DrawAircraftEngine(left, right, preferred_x, y, engine, pal, image_type);
00287       break;
00288 
00289     default: NOT_REACHED();
00290   }
00291 }
00292 
00298 void EngList_Sort(GUIEngineList *el, EngList_SortTypeFunction compare)
00299 {
00300   uint size = el->Length();
00301   /* out-of-bounds access at the next line for size == 0 (even with operator[] at some systems)
00302    * generally, do not sort if there are less than 2 items */
00303   if (size < 2) return;
00304   QSortT(el->Begin(), size, compare);
00305 }
00306 
00314 void EngList_SortPartial(GUIEngineList *el, EngList_SortTypeFunction compare, uint begin, uint num_items)
00315 {
00316   if (num_items < 2) return;
00317   assert(begin < el->Length());
00318   assert(begin + num_items <= el->Length());
00319   QSortT(el->Get(begin), num_items, compare);
00320 }
00321