engine_gui.cpp

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