00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "train.h"
00013 #include "roadveh.h"
00014 #include "ship.h"
00015 #include "aircraft.h"
00016 #include "station_base.h"
00017 #include "articulated_vehicles.h"
00018 #include "textbuf_gui.h"
00019 #include "command_func.h"
00020 #include "company_func.h"
00021 #include "vehicle_gui.h"
00022 #include "newgrf_engine.h"
00023 #include "newgrf_text.h"
00024 #include "group.h"
00025 #include "strings_func.h"
00026 #include "window_func.h"
00027 #include "date_func.h"
00028 #include "vehicle_func.h"
00029 #include "gfx_func.h"
00030 #include "widgets/dropdown_func.h"
00031 #include "window_gui.h"
00032 #include "engine_gui.h"
00033 #include "cargotype.h"
00034
00035 #include "table/sprites.h"
00036 #include "table/strings.h"
00037
00043 uint GetEngineListHeight(VehicleType type)
00044 {
00045 return max<uint>(FONT_HEIGHT_NORMAL + WD_MATRIX_TOP + WD_MATRIX_BOTTOM, GetVehicleHeight(type));
00046 }
00047
00048 enum BuildVehicleWidgets {
00049 BUILD_VEHICLE_WIDGET_CAPTION,
00050 BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING,
00051 BUILD_VEHICLE_WIDGET_SORT_DROPDOWN,
00052 BUILD_VEHICLE_WIDGET_CARGO_FILTER_DROPDOWN,
00053 BUILD_VEHICLE_WIDGET_LIST,
00054 BUILD_VEHICLE_WIDGET_SCROLLBAR,
00055 BUILD_VEHICLE_WIDGET_PANEL,
00056 BUILD_VEHICLE_WIDGET_BUILD,
00057 BUILD_VEHICLE_WIDGET_BUILD_SEL,
00058 BUILD_VEHICLE_WIDGET_RENAME,
00059 BUILD_VEHICLE_WIDGET_END
00060 };
00061
00062 static const NWidgetPart _nested_build_vehicle_widgets[] = {
00063 NWidget(NWID_HORIZONTAL),
00064 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
00065 NWidget(WWT_CAPTION, COLOUR_GREY, BUILD_VEHICLE_WIDGET_CAPTION), SetDataTip(STR_JUST_STRING, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
00066 NWidget(WWT_SHADEBOX, COLOUR_GREY),
00067 NWidget(WWT_STICKYBOX, COLOUR_GREY),
00068 EndContainer(),
00069 NWidget(WWT_PANEL, COLOUR_GREY),
00070 NWidget(NWID_HORIZONTAL),
00071 NWidget(NWID_VERTICAL),
00072 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING), SetDataTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0),
00073 NWidget(NWID_SPACER), SetFill(1, 1),
00074 EndContainer(),
00075 NWidget(NWID_VERTICAL),
00076 NWidget(WWT_DROPDOWN, COLOUR_GREY, BUILD_VEHICLE_WIDGET_SORT_DROPDOWN), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_JUST_STRING, STR_TOOLTIP_SORT_CRITERIAP),
00077 NWidget(WWT_DROPDOWN, COLOUR_GREY, BUILD_VEHICLE_WIDGET_CARGO_FILTER_DROPDOWN), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_JUST_STRING, STR_TOOLTIP_FILTER_CRITERIA),
00078 EndContainer(),
00079 EndContainer(),
00080 EndContainer(),
00081
00082 NWidget(NWID_HORIZONTAL),
00083 NWidget(WWT_MATRIX, COLOUR_GREY, BUILD_VEHICLE_WIDGET_LIST), SetResize(1, 1), SetFill(1, 0), SetDataTip(0x101, STR_NULL),
00084 NWidget(WWT_SCROLLBAR, COLOUR_GREY, BUILD_VEHICLE_WIDGET_SCROLLBAR),
00085 EndContainer(),
00086
00087 NWidget(WWT_PANEL, COLOUR_GREY, BUILD_VEHICLE_WIDGET_PANEL), SetMinimalSize(240, 122), SetResize(1, 0), EndContainer(),
00088
00089 NWidget(NWID_HORIZONTAL),
00090 NWidget(NWID_SELECTION, INVALID_COLOUR, BUILD_VEHICLE_WIDGET_BUILD_SEL),
00091 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, BUILD_VEHICLE_WIDGET_BUILD), SetResize(1, 0), SetFill(1, 0),
00092 EndContainer(),
00093 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, BUILD_VEHICLE_WIDGET_RENAME), SetResize(1, 0), SetFill(1, 0),
00094 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
00095 EndContainer(),
00096 };
00097
00099 enum {
00100 CF_ANY = CT_NO_REFIT,
00101 CF_NONE = CT_INVALID,
00102 };
00103
00104 static bool _internal_sort_order;
00105 static byte _last_sort_criteria[] = {0, 0, 0, 0};
00106 static bool _last_sort_order[] = {false, false, false, false};
00107 static byte _last_filter_criteria[] = {0, 0, 0, 0};
00108
00109 static int CDECL EngineNumberSorter(const EngineID *a, const EngineID *b)
00110 {
00111 int r = ListPositionOfEngine(*a) - ListPositionOfEngine(*b);
00112
00113 return _internal_sort_order ? -r : r;
00114 }
00115
00116 static int CDECL EngineIntroDateSorter(const EngineID *a, const EngineID *b)
00117 {
00118 const int va = Engine::Get(*a)->intro_date;
00119 const int vb = Engine::Get(*b)->intro_date;
00120 const int r = va - vb;
00121
00122
00123 if (r == 0) return EngineNumberSorter(a, b);
00124 return _internal_sort_order ? -r : r;
00125 }
00126
00127 static int CDECL EngineNameSorter(const EngineID *a, const EngineID *b)
00128 {
00129 static EngineID last_engine[2] = { INVALID_ENGINE, INVALID_ENGINE };
00130 static char last_name[2][64] = { "\0", "\0" };
00131
00132 const EngineID va = *a;
00133 const EngineID vb = *b;
00134
00135 if (va != last_engine[0]) {
00136 last_engine[0] = va;
00137 SetDParam(0, va);
00138 GetString(last_name[0], STR_ENGINE_NAME, lastof(last_name[0]));
00139 }
00140
00141 if (vb != last_engine[1]) {
00142 last_engine[1] = vb;
00143 SetDParam(0, vb);
00144 GetString(last_name[1], STR_ENGINE_NAME, lastof(last_name[1]));
00145 }
00146
00147 int r = strcmp(last_name[0], last_name[1]);
00148
00149
00150 if (r == 0) return EngineNumberSorter(a, b);
00151 return _internal_sort_order ? -r : r;
00152 }
00153
00154 static int CDECL EngineReliabilitySorter(const EngineID *a, const EngineID *b)
00155 {
00156 const int va = Engine::Get(*a)->reliability;
00157 const int vb = Engine::Get(*b)->reliability;
00158 const int r = va - vb;
00159
00160
00161 if (r == 0) return EngineNumberSorter(a, b);
00162 return _internal_sort_order ? -r : r;
00163 }
00164
00165 static int CDECL EngineCostSorter(const EngineID *a, const EngineID *b)
00166 {
00167 Money va = Engine::Get(*a)->GetCost();
00168 Money vb = Engine::Get(*b)->GetCost();
00169 int r = ClampToI32(va - vb);
00170
00171
00172 if (r == 0) return EngineNumberSorter(a, b);
00173 return _internal_sort_order ? -r : r;
00174 }
00175
00176 static int CDECL EngineSpeedSorter(const EngineID *a, const EngineID *b)
00177 {
00178 int va = Engine::Get(*a)->GetDisplayMaxSpeed();
00179 int vb = Engine::Get(*b)->GetDisplayMaxSpeed();
00180 int r = va - vb;
00181
00182
00183 if (r == 0) return EngineNumberSorter(a, b);
00184 return _internal_sort_order ? -r : r;
00185 }
00186
00187 static int CDECL EnginePowerSorter(const EngineID *a, const EngineID *b)
00188 {
00189 int va = Engine::Get(*a)->GetPower();
00190 int vb = Engine::Get(*b)->GetPower();
00191 int r = va - vb;
00192
00193
00194 if (r == 0) return EngineNumberSorter(a, b);
00195 return _internal_sort_order ? -r : r;
00196 }
00197
00198 static int CDECL EngineRunningCostSorter(const EngineID *a, const EngineID *b)
00199 {
00200 Money va = Engine::Get(*a)->GetRunningCost();
00201 Money vb = Engine::Get(*b)->GetRunningCost();
00202 int r = ClampToI32(va - vb);
00203
00204
00205 if (r == 0) return EngineNumberSorter(a, b);
00206 return _internal_sort_order ? -r : r;
00207 }
00208
00209
00210 static int CDECL TrainEnginePowerVsRunningCostSorter(const EngineID *a, const EngineID *b)
00211 {
00212 const Engine *e_a = Engine::Get(*a);
00213 const Engine *e_b = Engine::Get(*b);
00214
00215
00216
00217
00218
00219
00220
00221 Money va = (e_a->GetRunningCost()) / max(1U, (uint)e_a->GetPower());
00222 Money vb = (e_b->GetRunningCost()) / max(1U, (uint)e_b->GetPower());
00223 int r = ClampToI32(vb - va);
00224
00225
00226 if (r == 0) return EngineNumberSorter(a, b);
00227 return _internal_sort_order ? -r : r;
00228 }
00229
00230 static int CDECL TrainEngineCapacitySorter(const EngineID *a, const EngineID *b)
00231 {
00232 const RailVehicleInfo *rvi_a = RailVehInfo(*a);
00233 const RailVehicleInfo *rvi_b = RailVehInfo(*b);
00234
00235 int va = GetTotalCapacityOfArticulatedParts(*a) * (rvi_a->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);
00236 int vb = GetTotalCapacityOfArticulatedParts(*b) * (rvi_b->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);
00237 int r = va - vb;
00238
00239
00240 if (r == 0) return EngineNumberSorter(a, b);
00241 return _internal_sort_order ? -r : r;
00242 }
00243
00244 static int CDECL TrainEnginesThenWagonsSorter(const EngineID *a, const EngineID *b)
00245 {
00246 int val_a = (RailVehInfo(*a)->railveh_type == RAILVEH_WAGON ? 1 : 0);
00247 int val_b = (RailVehInfo(*b)->railveh_type == RAILVEH_WAGON ? 1 : 0);
00248 int r = val_a - val_b;
00249
00250
00251 if (r == 0) return EngineNumberSorter(a, b);
00252 return _internal_sort_order ? -r : r;
00253 }
00254
00255
00256 static int CDECL RoadVehEngineCapacitySorter(const EngineID *a, const EngineID *b)
00257 {
00258 int va = GetTotalCapacityOfArticulatedParts(*a);
00259 int vb = GetTotalCapacityOfArticulatedParts(*b);
00260 int r = va - vb;
00261
00262
00263 if (r == 0) return EngineNumberSorter(a, b);
00264 return _internal_sort_order ? -r : r;
00265 }
00266
00267
00268 static int CDECL ShipEngineCapacitySorter(const EngineID *a, const EngineID *b)
00269 {
00270 const Engine *e_a = Engine::Get(*a);
00271 const Engine *e_b = Engine::Get(*b);
00272
00273 int va = e_a->GetDisplayDefaultCapacity();
00274 int vb = e_b->GetDisplayDefaultCapacity();
00275 int r = va - vb;
00276
00277
00278 if (r == 0) return EngineNumberSorter(a, b);
00279 return _internal_sort_order ? -r : r;
00280 }
00281
00282
00283 static int CDECL AircraftEngineCargoSorter(const EngineID *a, const EngineID *b)
00284 {
00285 const Engine *e_a = Engine::Get(*a);
00286 const Engine *e_b = Engine::Get(*b);
00287
00288 uint16 mail_a, mail_b;
00289 int va = e_a->GetDisplayDefaultCapacity(&mail_a);
00290 int vb = e_b->GetDisplayDefaultCapacity(&mail_b);
00291 int r = va - vb;
00292
00293 if (r == 0) {
00294
00295 r = mail_a - mail_b;
00296
00297 if (r == 0) {
00298
00299 return EngineNumberSorter(a, b);
00300 }
00301 }
00302 return _internal_sort_order ? -r : r;
00303 }
00304
00305 static EngList_SortTypeFunction * const _sorter[][10] = {{
00306
00307 &EngineNumberSorter,
00308 &EngineCostSorter,
00309 &EngineSpeedSorter,
00310 &EnginePowerSorter,
00311 &EngineIntroDateSorter,
00312 &EngineNameSorter,
00313 &EngineRunningCostSorter,
00314 &TrainEnginePowerVsRunningCostSorter,
00315 &EngineReliabilitySorter,
00316 &TrainEngineCapacitySorter,
00317 }, {
00318
00319 &EngineNumberSorter,
00320 &EngineCostSorter,
00321 &EngineSpeedSorter,
00322 &EngineIntroDateSorter,
00323 &EngineNameSorter,
00324 &EngineRunningCostSorter,
00325 &EngineReliabilitySorter,
00326 &RoadVehEngineCapacitySorter,
00327 }, {
00328
00329 &EngineNumberSorter,
00330 &EngineCostSorter,
00331 &EngineSpeedSorter,
00332 &EngineIntroDateSorter,
00333 &EngineNameSorter,
00334 &EngineRunningCostSorter,
00335 &EngineReliabilitySorter,
00336 &ShipEngineCapacitySorter,
00337 }, {
00338
00339 &EngineNumberSorter,
00340 &EngineCostSorter,
00341 &EngineSpeedSorter,
00342 &EngineIntroDateSorter,
00343 &EngineNameSorter,
00344 &EngineRunningCostSorter,
00345 &EngineReliabilitySorter,
00346 &AircraftEngineCargoSorter,
00347 }};
00348
00349 static const StringID _sort_listing[][11] = {{
00350
00351 STR_SORT_BY_ENGINE_ID,
00352 STR_SORT_BY_COST,
00353 STR_SORT_BY_MAX_SPEED,
00354 STR_SORT_BY_POWER,
00355 STR_SORT_BY_INTRO_DATE,
00356 STR_SORT_BY_NAME,
00357 STR_SORT_BY_RUNNING_COST,
00358 STR_SORT_BY_POWER_VS_RUNNING_COST,
00359 STR_SORT_BY_RELIABILITY,
00360 STR_SORT_BY_CARGO_CAPACITY,
00361 INVALID_STRING_ID
00362 }, {
00363
00364 STR_SORT_BY_ENGINE_ID,
00365 STR_SORT_BY_COST,
00366 STR_SORT_BY_MAX_SPEED,
00367 STR_SORT_BY_INTRO_DATE,
00368 STR_SORT_BY_NAME,
00369 STR_SORT_BY_RUNNING_COST,
00370 STR_SORT_BY_RELIABILITY,
00371 STR_SORT_BY_CARGO_CAPACITY,
00372 INVALID_STRING_ID
00373 }, {
00374
00375 STR_SORT_BY_ENGINE_ID,
00376 STR_SORT_BY_COST,
00377 STR_SORT_BY_MAX_SPEED,
00378 STR_SORT_BY_INTRO_DATE,
00379 STR_SORT_BY_NAME,
00380 STR_SORT_BY_RUNNING_COST,
00381 STR_SORT_BY_RELIABILITY,
00382 STR_SORT_BY_CARGO_CAPACITY,
00383 INVALID_STRING_ID
00384 }, {
00385
00386 STR_SORT_BY_ENGINE_ID,
00387 STR_SORT_BY_COST,
00388 STR_SORT_BY_MAX_SPEED,
00389 STR_SORT_BY_INTRO_DATE,
00390 STR_SORT_BY_NAME,
00391 STR_SORT_BY_RUNNING_COST,
00392 STR_SORT_BY_RELIABILITY,
00393 STR_SORT_BY_CARGO_CAPACITY,
00394 INVALID_STRING_ID
00395 }};
00396
00398 static bool CDECL CargoFilter(const EngineID *eid, const CargoID cid)
00399 {
00400 if (cid == CF_ANY) return true;
00401 uint32 refit_mask = GetUnionOfArticulatedRefitMasks(*eid, true);
00402 return (cid == CF_NONE ? refit_mask == 0 : HasBit(refit_mask, cid));
00403 }
00404
00405 static GUIEngineList::FilterFunction * const _filter_funcs[] = {
00406 &CargoFilter,
00407 };
00408
00409 static int DrawCargoCapacityInfo(int left, int right, int y, EngineID engine, bool refittable)
00410 {
00411 CargoArray cap = GetCapacityOfArticulatedParts(engine);
00412
00413 for (CargoID c = 0; c < NUM_CARGO; c++) {
00414 if (cap[c] == 0) continue;
00415
00416 SetDParam(0, c);
00417 SetDParam(1, cap[c]);
00418 SetDParam(2, refittable ? STR_PURCHASE_INFO_REFITTABLE : STR_EMPTY);
00419 DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
00420 y += FONT_HEIGHT_NORMAL;
00421
00422
00423 refittable = false;
00424 }
00425
00426 return y;
00427 }
00428
00429
00430 static int DrawRailWagonPurchaseInfo(int left, int right, int y, EngineID engine_number, const RailVehicleInfo *rvi)
00431 {
00432 const Engine *e = Engine::Get(engine_number);
00433
00434
00435 SetDParam(0, e->GetCost());
00436 DrawString(left, right, y, STR_PURCHASE_INFO_COST);
00437 y += FONT_HEIGHT_NORMAL;
00438
00439
00440 uint weight = e->GetDisplayWeight();
00441 SetDParam(0, weight);
00442 uint cargo_weight = (e->CanCarryCargo() ? CargoSpec::Get(e->GetDefaultCargoType())->weight * e->GetDisplayDefaultCapacity() >> 4 : 0);
00443 SetDParam(1, cargo_weight + weight);
00444 DrawString(left, right, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT);
00445 y += FONT_HEIGHT_NORMAL;
00446
00447
00448 if (_settings_game.vehicle.wagon_speed_limits) {
00449 uint max_speed = e->GetDisplayMaxSpeed();
00450 if (max_speed > 0) {
00451 SetDParam(0, max_speed);
00452 DrawString(left, right, y, STR_PURCHASE_INFO_SPEED);
00453 y += FONT_HEIGHT_NORMAL;
00454 }
00455 }
00456
00457
00458 if (rvi->running_cost_class != INVALID_PRICE) {
00459 SetDParam(0, e->GetRunningCost());
00460 DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
00461 y += FONT_HEIGHT_NORMAL;
00462 }
00463
00464 return y;
00465 }
00466
00467
00468 static int DrawRailEnginePurchaseInfo(int left, int right, int y, EngineID engine_number, const RailVehicleInfo *rvi)
00469 {
00470 const Engine *e = Engine::Get(engine_number);
00471
00472
00473 SetDParam(0, e->GetCost());
00474 SetDParam(1, e->GetDisplayWeight());
00475 DrawString(left, right, y, STR_PURCHASE_INFO_COST_WEIGHT);
00476 y += FONT_HEIGHT_NORMAL;
00477
00478
00479 SetDParam(0, e->GetDisplayMaxSpeed());
00480 SetDParam(1, e->GetPower());
00481 DrawString(left, right, y, STR_PURCHASE_INFO_SPEED_POWER);
00482 y += FONT_HEIGHT_NORMAL;
00483
00484
00485 if (_settings_game.vehicle.train_acceleration_model != TAM_ORIGINAL && rvi->railtype != RAILTYPE_MAGLEV) {
00486 SetDParam(0, e->GetDisplayMaxTractiveEffort());
00487 DrawString(left, right, y, STR_PURCHASE_INFO_MAX_TE);
00488 y += FONT_HEIGHT_NORMAL;
00489 }
00490
00491
00492 if (rvi->running_cost_class != INVALID_PRICE) {
00493 SetDParam(0, e->GetRunningCost());
00494 DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
00495 y += FONT_HEIGHT_NORMAL;
00496 }
00497
00498
00499 if (rvi->pow_wag_power != 0) {
00500 SetDParam(0, rvi->pow_wag_power);
00501 SetDParam(1, rvi->pow_wag_weight);
00502 DrawString(left, right, y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT);
00503 y += FONT_HEIGHT_NORMAL;
00504 };
00505
00506 return y;
00507 }
00508
00509
00510 static int DrawRoadVehPurchaseInfo(int left, int right, int y, EngineID engine_number)
00511 {
00512 const Engine *e = Engine::Get(engine_number);
00513
00514
00515 SetDParam(0, e->GetCost());
00516 SetDParam(1, e->GetDisplayMaxSpeed());
00517 DrawString(left, right, y, STR_PURCHASE_INFO_COST_SPEED);
00518 y += FONT_HEIGHT_NORMAL;
00519
00520
00521 SetDParam(0, e->GetRunningCost());
00522 DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
00523 y += FONT_HEIGHT_NORMAL;
00524
00525 return y;
00526 }
00527
00528
00529 static int DrawShipPurchaseInfo(int left, int right, int y, EngineID engine_number, bool refittable)
00530 {
00531 const Engine *e = Engine::Get(engine_number);
00532
00533
00534 SetDParam(0, e->GetCost());
00535 SetDParam(1, e->GetDisplayMaxSpeed());
00536 DrawString(left, right, y, STR_PURCHASE_INFO_COST_SPEED);
00537 y += FONT_HEIGHT_NORMAL;
00538
00539
00540 SetDParam(0, e->GetDefaultCargoType());
00541 SetDParam(1, e->GetDisplayDefaultCapacity());
00542 SetDParam(2, refittable ? STR_PURCHASE_INFO_REFITTABLE : STR_EMPTY);
00543 DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
00544 y += FONT_HEIGHT_NORMAL;
00545
00546
00547 SetDParam(0, e->GetRunningCost());
00548 DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
00549 y += FONT_HEIGHT_NORMAL;
00550
00551 return y;
00552 }
00553
00554
00555 static int DrawAircraftPurchaseInfo(int left, int right, int y, EngineID engine_number, bool refittable)
00556 {
00557 const Engine *e = Engine::Get(engine_number);
00558 CargoID cargo = e->GetDefaultCargoType();
00559
00560
00561 SetDParam(0, e->GetCost());
00562 SetDParam(1, e->GetDisplayMaxSpeed());
00563 DrawString(left, right, y, STR_PURCHASE_INFO_COST_SPEED);
00564 y += FONT_HEIGHT_NORMAL;
00565
00566
00567 uint16 mail_capacity;
00568 uint capacity = e->GetDisplayDefaultCapacity(&mail_capacity);
00569 if (mail_capacity > 0) {
00570 SetDParam(0, cargo);
00571 SetDParam(1, capacity);
00572 SetDParam(2, CT_MAIL);
00573 SetDParam(3, mail_capacity);
00574 DrawString(left, right, y, STR_PURCHASE_INFO_AIRCRAFT_CAPACITY);
00575 } else {
00576
00577
00578 SetDParam(0, cargo);
00579 SetDParam(1, capacity);
00580 SetDParam(2, refittable ? STR_PURCHASE_INFO_REFITTABLE : STR_EMPTY);
00581 DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
00582 }
00583 y += FONT_HEIGHT_NORMAL;
00584
00585
00586 SetDParam(0, e->GetRunningCost());
00587 DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
00588 y += FONT_HEIGHT_NORMAL;
00589
00590 return y;
00591 }
00592
00601 static uint ShowAdditionalText(int left, int right, int y, EngineID engine)
00602 {
00603 uint16 callback = GetVehicleCallback(CBID_VEHICLE_ADDITIONAL_TEXT, 0, 0, engine, NULL);
00604 if (callback == CALLBACK_FAILED) return y;
00605
00606
00607 SetDParam(0, GetGRFStringID(GetEngineGRFID(engine), 0xD000 + callback));
00608 PrepareTextRefStackUsage(0);
00609 uint result = DrawStringMultiLine(left, right, y, INT32_MAX, STR_BLACK_STRING);
00610 StopTextRefStackUsage();
00611 return result;
00612 }
00613
00620 int DrawVehiclePurchaseInfo(int left, int right, int y, EngineID engine_number)
00621 {
00622 const Engine *e = Engine::Get(engine_number);
00623 YearMonthDay ymd;
00624 ConvertDateToYMD(e->intro_date, &ymd);
00625 bool refittable = IsArticulatedVehicleRefittable(engine_number);
00626 bool articulated_cargo = false;
00627
00628 switch (e->type) {
00629 default: NOT_REACHED();
00630 case VEH_TRAIN:
00631 if (e->u.rail.railveh_type == RAILVEH_WAGON) {
00632 y = DrawRailWagonPurchaseInfo(left, right, y, engine_number, &e->u.rail);
00633 } else {
00634 y = DrawRailEnginePurchaseInfo(left, right, y, engine_number, &e->u.rail);
00635 }
00636 articulated_cargo = true;
00637 break;
00638
00639 case VEH_ROAD:
00640 y = DrawRoadVehPurchaseInfo(left, right, y, engine_number);
00641 articulated_cargo = true;
00642 break;
00643
00644 case VEH_SHIP:
00645 y = DrawShipPurchaseInfo(left, right, y, engine_number, refittable);
00646 break;
00647
00648 case VEH_AIRCRAFT:
00649 y = DrawAircraftPurchaseInfo(left, right, y, engine_number, refittable);
00650 break;
00651 }
00652
00653 if (articulated_cargo) {
00654
00655 int new_y = DrawCargoCapacityInfo(left, right, y, engine_number, refittable);
00656
00657 if (new_y == y) {
00658 SetDParam(0, CT_INVALID);
00659 SetDParam(2, STR_EMPTY);
00660 DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
00661 y += FONT_HEIGHT_NORMAL;
00662 } else {
00663 y = new_y;
00664 }
00665 }
00666
00667
00668 if (e->type != VEH_TRAIN || e->u.rail.railveh_type != RAILVEH_WAGON) {
00669
00670 SetDParam(0, ymd.year);
00671 SetDParam(1, e->GetLifeLengthInDays() / DAYS_IN_LEAP_YEAR);
00672 DrawString(left, right, y, STR_PURCHASE_INFO_DESIGNED_LIFE);
00673 y += FONT_HEIGHT_NORMAL;
00674
00675
00676 SetDParam(0, ToPercent16(e->reliability));
00677 DrawString(left, right, y, STR_PURCHASE_INFO_RELIABILITY);
00678 y += FONT_HEIGHT_NORMAL;
00679 }
00680
00681
00682 y = ShowAdditionalText(left, right, y, engine_number);
00683 if (refittable) y = ShowRefitOptionsList(left, right, y, engine_number);
00684
00685 return y;
00686 }
00687
00700 void DrawEngineList(VehicleType type, int l, int r, int y, const GUIEngineList *eng_list, uint16 min, uint16 max, EngineID selected_id, bool show_count, GroupID selected_group)
00701 {
00702 static const int sprite_widths[] = { 60, 60, 76, 67 };
00703 static const int sprite_y_offsets[] = { -1, -1, -2, -2 };
00704
00705
00706 assert((uint)type < lengthof(sprite_widths));
00707 assert_compile(lengthof(sprite_y_offsets) == lengthof(sprite_widths));
00708 assert(max <= eng_list->Length());
00709
00710 bool rtl = _dynlang.text_dir == TD_RTL;
00711 int step_size = GetEngineListHeight(type);
00712 int sprite_width = sprite_widths[type];
00713
00714 int sprite_x = (rtl ? r - sprite_width / 2 : l + sprite_width / 2) - 1;
00715 int sprite_y_offset = sprite_y_offsets[type] + step_size / 2;
00716
00717 int text_left = l + (rtl ? WD_FRAMERECT_LEFT : sprite_width);
00718 int text_right = r - (rtl ? sprite_width : WD_FRAMERECT_RIGHT);
00719
00720 int normal_text_y_offset = (step_size - FONT_HEIGHT_NORMAL) / 2;
00721 int small_text_y_offset = step_size - FONT_HEIGHT_SMALL - WD_FRAMERECT_BOTTOM - 1;
00722
00723 for (; min < max; min++, y += step_size) {
00724 const EngineID engine = (*eng_list)[min];
00725
00726 const uint num_engines = GetGroupNumEngines(_local_company, selected_group, engine);
00727
00728 SetDParam(0, engine);
00729 DrawString(text_left, text_right, y + normal_text_y_offset, STR_ENGINE_NAME, engine == selected_id ? TC_WHITE : TC_BLACK);
00730 DrawVehicleEngine(l, r, sprite_x, y + sprite_y_offset, engine, (show_count && num_engines == 0) ? PALETTE_CRASH : GetEnginePalette(engine, _local_company));
00731 if (show_count) {
00732 SetDParam(0, num_engines);
00733 DrawString(text_left, text_right, y + small_text_y_offset, STR_TINY_BLACK_COMA, TC_FROMSTRING, SA_RIGHT);
00734 }
00735 }
00736 }
00737
00738
00739 struct BuildVehicleWindow : Window {
00740 VehicleType vehicle_type;
00741 union {
00742 RailTypeByte railtype;
00743 AirportFTAClass::Flags flags;
00744 RoadTypes roadtypes;
00745 } filter;
00746 bool descending_sort_order;
00747 byte sort_criteria;
00748 bool listview_mode;
00749 EngineID sel_engine;
00750 EngineID rename_engine;
00751 GUIEngineList eng_list;
00752 CargoID cargo_filter[NUM_CARGO + 2];
00753 StringID cargo_filter_texts[NUM_CARGO + 3];
00754 byte cargo_filter_criteria;
00755 int details_height;
00756
00757 BuildVehicleWindow(const WindowDesc *desc, TileIndex tile, VehicleType type) : Window()
00758 {
00759 this->vehicle_type = type;
00760 this->window_number = tile == INVALID_TILE ? (int)type : tile;
00761
00762 this->sel_engine = INVALID_ENGINE;
00763
00764 this->sort_criteria = _last_sort_criteria[type];
00765 this->descending_sort_order = _last_sort_order[type];
00766 this->cargo_filter_criteria = _last_filter_criteria[type];
00767
00768
00769 uint filter_items = 0;
00770
00771
00772 this->cargo_filter[filter_items] = CF_ANY;
00773 this->cargo_filter_texts[filter_items] = STR_PURCHASE_INFO_ALL_TYPES;
00774 filter_items++;
00775
00776
00777
00778 if (type == VEH_TRAIN) {
00779 this->cargo_filter[filter_items] = CF_NONE;
00780 this->cargo_filter_texts[filter_items] = STR_LAND_AREA_INFORMATION_LOCAL_AUTHORITY_NONE;
00781 filter_items++;
00782 }
00783
00784
00785 const CargoSpec *cargo;
00786 FOR_ALL_CARGOSPECS(cargo) {
00787 if (IsCargoInClass(cargo->Index(), CC_SPECIAL)) continue;
00788 this->cargo_filter[filter_items] = cargo->Index();
00789 this->cargo_filter_texts[filter_items] = cargo->name;
00790 filter_items++;
00791 }
00792
00793 this->cargo_filter_texts[filter_items] = INVALID_STRING_ID;
00794 if (this->cargo_filter_criteria >= filter_items) this->cargo_filter_criteria = 0;
00795
00796 this->eng_list.SetFilterFuncs(_filter_funcs);
00797 this->eng_list.SetFilterState(this->cargo_filter[this->cargo_filter_criteria] != CF_ANY);
00798
00799 switch (type) {
00800 default: NOT_REACHED();
00801 case VEH_TRAIN:
00802 this->filter.railtype = (tile == INVALID_TILE) ? RAILTYPE_END : GetRailType(tile);
00803 break;
00804 case VEH_ROAD:
00805 this->filter.roadtypes = (tile == INVALID_TILE) ? ROADTYPES_ALL : GetRoadTypes(tile);
00806 case VEH_SHIP:
00807 break;
00808 case VEH_AIRCRAFT:
00809 this->filter.flags =
00810 tile == INVALID_TILE ? AirportFTAClass::ALL : Station::GetByTile(tile)->Airport()->flags;
00811 break;
00812 }
00813
00814 this->listview_mode = (this->window_number <= VEH_END);
00815
00816 this->CreateNestedTree(desc);
00817
00818
00819
00820 if (this->listview_mode) this->GetWidget<NWidgetStacked>(BUILD_VEHICLE_WIDGET_BUILD_SEL)->SetDisplayedPlane(SZSP_NONE);
00821
00822 NWidgetCore *widget = this->GetWidget<NWidgetCore>(BUILD_VEHICLE_WIDGET_LIST);
00823 widget->tool_tip = STR_BUY_VEHICLE_TRAIN_LIST_TOOLTIP + type;
00824
00825 widget = this->GetWidget<NWidgetCore>(BUILD_VEHICLE_WIDGET_BUILD);
00826 widget->widget_data = STR_BUY_VEHICLE_TRAIN_BUY_VEHICLE_BUTTON + type;
00827 widget->tool_tip = STR_BUY_VEHICLE_TRAIN_BUY_VEHICLE_TOOLTIP + type;
00828
00829 widget = this->GetWidget<NWidgetCore>(BUILD_VEHICLE_WIDGET_RENAME);
00830 widget->widget_data = STR_BUY_VEHICLE_TRAIN_RENAME_BUTTON + type;
00831 widget->tool_tip = STR_BUY_VEHICLE_TRAIN_RENAME_TOOLTIP + type;
00832
00833 this->details_height = ((this->vehicle_type == VEH_TRAIN) ? 10 : 9) * FONT_HEIGHT_NORMAL + WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM;
00834
00835 this->FinishInitNested(desc, tile == INVALID_TILE ? (int)type : tile);
00836
00837 this->owner = (tile != INVALID_TILE) ? GetTileOwner(tile) : _local_company;
00838
00839 this->eng_list.ForceRebuild();
00840 this->GenerateBuildList();
00841
00842 if (this->eng_list.Length() > 0) this->sel_engine = this->eng_list[0];
00843 }
00844
00846 void FilterEngineList()
00847 {
00848 this->eng_list.Filter(this->cargo_filter[this->cargo_filter_criteria]);
00849 if (0 == this->eng_list.Length()) {
00850 this->sel_engine = INVALID_ENGINE;
00851 } else if (!this->eng_list.Contains(this->sel_engine)) {
00852 this->sel_engine = this->eng_list[0];
00853 }
00854 }
00855
00857 bool FilterSingleEngine(EngineID eid)
00858 {
00859 CargoID filter_type = this->cargo_filter[this->cargo_filter_criteria];
00860 return (filter_type == CF_ANY || CargoFilter(&eid, filter_type));
00861 }
00862
00863
00864 void GenerateBuildTrainList()
00865 {
00866 EngineID sel_id = INVALID_ENGINE;
00867 int num_engines = 0;
00868 int num_wagons = 0;
00869
00870 this->filter.railtype = (this->listview_mode) ? RAILTYPE_END : GetRailType(this->window_number);
00871
00872 this->eng_list.Clear();
00873
00874
00875
00876
00877
00878 const Engine *e;
00879 FOR_ALL_ENGINES_OF_TYPE(e, VEH_TRAIN) {
00880 EngineID eid = e->index;
00881 const RailVehicleInfo *rvi = &e->u.rail;
00882
00883 if (this->filter.railtype != RAILTYPE_END && !HasPowerOnRail(rvi->railtype, this->filter.railtype)) continue;
00884 if (!IsEngineBuildable(eid, VEH_TRAIN, _local_company)) continue;
00885
00886
00887 if (!FilterSingleEngine(eid)) continue;
00888
00889 *this->eng_list.Append() = eid;
00890
00891 if (rvi->railveh_type != RAILVEH_WAGON) {
00892 num_engines++;
00893 } else {
00894 num_wagons++;
00895 }
00896
00897 if (eid == this->sel_engine) sel_id = eid;
00898 }
00899
00900 this->sel_engine = sel_id;
00901
00902
00903 _internal_sort_order = false;
00904 EngList_Sort(&this->eng_list, TrainEnginesThenWagonsSorter);
00905
00906
00907 _internal_sort_order = this->descending_sort_order;
00908 EngList_SortPartial(&this->eng_list, _sorter[0][this->sort_criteria], 0, num_engines);
00909
00910
00911 EngList_SortPartial(&this->eng_list, _sorter[0][this->sort_criteria], num_engines, num_wagons);
00912 }
00913
00914
00915 void GenerateBuildRoadVehList()
00916 {
00917 EngineID sel_id = INVALID_ENGINE;
00918
00919 this->eng_list.Clear();
00920
00921 const Engine *e;
00922 FOR_ALL_ENGINES_OF_TYPE(e, VEH_ROAD) {
00923 EngineID eid = e->index;
00924 if (!IsEngineBuildable(eid, VEH_ROAD, _local_company)) continue;
00925 if (!HasBit(this->filter.roadtypes, HasBit(EngInfo(eid)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD)) continue;
00926 *this->eng_list.Append() = eid;
00927
00928 if (eid == this->sel_engine) sel_id = eid;
00929 }
00930 this->sel_engine = sel_id;
00931 }
00932
00933
00934 void GenerateBuildShipList()
00935 {
00936 EngineID sel_id = INVALID_ENGINE;
00937 this->eng_list.Clear();
00938
00939 const Engine *e;
00940 FOR_ALL_ENGINES_OF_TYPE(e, VEH_SHIP) {
00941 EngineID eid = e->index;
00942 if (!IsEngineBuildable(eid, VEH_SHIP, _local_company)) continue;
00943 *this->eng_list.Append() = eid;
00944
00945 if (eid == this->sel_engine) sel_id = eid;
00946 }
00947 this->sel_engine = sel_id;
00948 }
00949
00950
00951 void GenerateBuildAircraftList()
00952 {
00953 EngineID sel_id = INVALID_ENGINE;
00954
00955 this->eng_list.Clear();
00956
00957 const Station *st = this->listview_mode ? NULL : Station::GetByTile(this->window_number);
00958
00959
00960
00961
00962
00963 const Engine *e;
00964 FOR_ALL_ENGINES_OF_TYPE(e, VEH_AIRCRAFT) {
00965 EngineID eid = e->index;
00966 if (!IsEngineBuildable(eid, VEH_AIRCRAFT, _local_company)) continue;
00967
00968 if (!this->listview_mode && !CanVehicleUseStation(eid, st)) continue;
00969
00970 *this->eng_list.Append() = eid;
00971 if (eid == this->sel_engine) sel_id = eid;
00972 }
00973
00974 this->sel_engine = sel_id;
00975 }
00976
00977
00978 void GenerateBuildList()
00979 {
00980 if (!this->eng_list.NeedRebuild()) return;
00981 switch (this->vehicle_type) {
00982 default: NOT_REACHED();
00983 case VEH_TRAIN:
00984 this->GenerateBuildTrainList();
00985 this->eng_list.Compact();
00986 this->eng_list.RebuildDone();
00987 return;
00988 case VEH_ROAD:
00989 this->GenerateBuildRoadVehList();
00990 break;
00991 case VEH_SHIP:
00992 this->GenerateBuildShipList();
00993 break;
00994 case VEH_AIRCRAFT:
00995 this->GenerateBuildAircraftList();
00996 break;
00997 }
00998
00999 this->FilterEngineList();
01000
01001 _internal_sort_order = this->descending_sort_order;
01002 EngList_Sort(&this->eng_list, _sorter[this->vehicle_type][this->sort_criteria]);
01003
01004 this->eng_list.Compact();
01005 this->eng_list.RebuildDone();
01006 }
01007
01008 void OnClick(Point pt, int widget)
01009 {
01010 switch (widget) {
01011 case BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING:
01012 this->descending_sort_order ^= true;
01013 _last_sort_order[this->vehicle_type] = this->descending_sort_order;
01014 this->eng_list.ForceRebuild();
01015 this->SetDirty();
01016 break;
01017
01018 case BUILD_VEHICLE_WIDGET_LIST: {
01019 uint i = (pt.y - this->GetWidget<NWidgetBase>(BUILD_VEHICLE_WIDGET_LIST)->pos_y) / this->resize.step_height + this->vscroll.GetPosition();
01020 size_t num_items = this->eng_list.Length();
01021 this->sel_engine = (i < num_items) ? this->eng_list[i] : INVALID_ENGINE;
01022 this->SetDirty();
01023 break;
01024 }
01025
01026 case BUILD_VEHICLE_WIDGET_SORT_DROPDOWN:
01027 ShowDropDownMenu(this, _sort_listing[this->vehicle_type], this->sort_criteria, BUILD_VEHICLE_WIDGET_SORT_DROPDOWN, 0, 0);
01028 break;
01029
01030 case BUILD_VEHICLE_WIDGET_CARGO_FILTER_DROPDOWN:
01031 ShowDropDownMenu(this, this->cargo_filter_texts, this->cargo_filter_criteria, BUILD_VEHICLE_WIDGET_CARGO_FILTER_DROPDOWN, 0, 0);
01032 break;
01033
01034 case BUILD_VEHICLE_WIDGET_BUILD: {
01035 EngineID sel_eng = this->sel_engine;
01036 if (sel_eng != INVALID_ENGINE) {
01037 CommandCallback *callback;
01038 switch (this->vehicle_type) {
01039 default: NOT_REACHED();
01040 case VEH_TRAIN: callback = (RailVehInfo(sel_eng)->railveh_type == RAILVEH_WAGON) ? CcBuildWagon : CcBuildLoco; break;
01041 case VEH_ROAD: callback = CcBuildRoadVeh; break;
01042 case VEH_SHIP: callback = CcBuildShip; break;
01043 case VEH_AIRCRAFT: callback = CcBuildAircraft; break;
01044 }
01045 DoCommandP(this->window_number, sel_eng, 0, GetCmdBuildVeh(this->vehicle_type), callback);
01046 }
01047 break;
01048 }
01049
01050 case BUILD_VEHICLE_WIDGET_RENAME: {
01051 EngineID sel_eng = this->sel_engine;
01052 if (sel_eng != INVALID_ENGINE) {
01053 this->rename_engine = sel_eng;
01054 SetDParam(0, sel_eng);
01055 ShowQueryString(STR_ENGINE_NAME, STR_QUERY_RENAME_TRAIN_TYPE_CAPTION + this->vehicle_type, MAX_LENGTH_ENGINE_NAME_BYTES, MAX_LENGTH_ENGINE_NAME_PIXELS, this, CS_ALPHANUMERAL, QSF_ENABLE_DEFAULT);
01056 }
01057 break;
01058 }
01059 }
01060 }
01061
01062 virtual void OnInvalidateData(int data)
01063 {
01064 this->eng_list.ForceRebuild();
01065 }
01066
01067 virtual void SetStringParameters(int widget) const
01068 {
01069 switch (widget) {
01070 case BUILD_VEHICLE_WIDGET_CAPTION:
01071 if (this->vehicle_type == VEH_TRAIN && !this->listview_mode) {
01072 const RailtypeInfo *rti = GetRailTypeInfo(this->filter.railtype);
01073 SetDParam(0, rti->strings.build_caption);
01074 } else {
01075 SetDParam(0, (this->listview_mode ? STR_VEHICLE_LIST_AVAILABLE_TRAINS : STR_BUY_VEHICLE_TRAIN_ALL_CAPTION) + this->vehicle_type);
01076 }
01077 break;
01078
01079 case BUILD_VEHICLE_WIDGET_SORT_DROPDOWN:
01080 SetDParam(0, _sort_listing[this->vehicle_type][this->sort_criteria]);
01081 break;
01082
01083 case BUILD_VEHICLE_WIDGET_CARGO_FILTER_DROPDOWN:
01084 SetDParam(0, this->cargo_filter_texts[this->cargo_filter_criteria]);
01085 }
01086 }
01087
01088 virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
01089 {
01090 switch (widget) {
01091 case BUILD_VEHICLE_WIDGET_LIST:
01092 resize->height = GetEngineListHeight(this->vehicle_type);
01093 size->height = 3 * resize->height;
01094 break;
01095
01096 case BUILD_VEHICLE_WIDGET_PANEL:
01097 size->height = this->details_height;
01098 break;
01099 }
01100 }
01101
01102 virtual void DrawWidget(const Rect &r, int widget) const
01103 {
01104 switch (widget) {
01105 case BUILD_VEHICLE_WIDGET_LIST:
01106 DrawEngineList(this->vehicle_type, r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, r.top + WD_FRAMERECT_TOP, &this->eng_list, this->vscroll.GetPosition(), min(this->vscroll.GetPosition() + this->vscroll.GetCapacity(), this->eng_list.Length()), this->sel_engine, false, DEFAULT_GROUP);
01107 break;
01108
01109 case BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING:
01110 this->DrawSortButtonState(BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING, this->descending_sort_order ? SBS_DOWN : SBS_UP);
01111 break;
01112 }
01113 }
01114
01115 virtual void OnPaint()
01116 {
01117 this->GenerateBuildList();
01118 this->vscroll.SetCount(this->eng_list.Length());
01119
01120 this->DrawWidgets();
01121
01122 if (!this->IsShaded()) {
01123 int needed_height = this->details_height;
01124
01125 for (int side = 0; side < 2; side++) {
01126 if (this->sel_engine != INVALID_ENGINE) {
01127 NWidgetBase *nwi = this->GetWidget<NWidgetBase>(BUILD_VEHICLE_WIDGET_PANEL);
01128 int text_end = DrawVehiclePurchaseInfo(nwi->pos_x + WD_FRAMETEXT_LEFT, nwi->pos_x + nwi->current_x - WD_FRAMETEXT_RIGHT,
01129 nwi->pos_y + WD_FRAMERECT_TOP, this->sel_engine);
01130 needed_height = max(needed_height, text_end - (int)nwi->pos_y + WD_FRAMERECT_BOTTOM);
01131 }
01132 }
01133 if (needed_height != this->details_height) {
01134 this->details_height = needed_height;
01135 this->ReInit();
01136 return;
01137 }
01138 }
01139 }
01140
01141 virtual void OnDoubleClick(Point pt, int widget)
01142 {
01143 if (widget == BUILD_VEHICLE_WIDGET_LIST) {
01144
01145 this->OnClick(pt, BUILD_VEHICLE_WIDGET_BUILD);
01146 }
01147 }
01148
01149 virtual void OnQueryTextFinished(char *str)
01150 {
01151 if (str == NULL) return;
01152
01153 DoCommandP(0, this->rename_engine, 0, CMD_RENAME_ENGINE | CMD_MSG(STR_ERROR_CAN_T_RENAME_TRAIN_TYPE + this->vehicle_type), NULL, str);
01154 }
01155
01156 virtual void OnDropdownSelect(int widget, int index)
01157 {
01158 switch (widget) {
01159 case BUILD_VEHICLE_WIDGET_SORT_DROPDOWN:
01160 if (this->sort_criteria != index) {
01161 this->sort_criteria = index;
01162 _last_sort_criteria[this->vehicle_type] = this->sort_criteria;
01163 this->eng_list.ForceRebuild();
01164 }
01165 break;
01166
01167 case BUILD_VEHICLE_WIDGET_CARGO_FILTER_DROPDOWN:
01168 if (this->cargo_filter_criteria != index) {
01169 this->cargo_filter_criteria = index;
01170 _last_filter_criteria[this->vehicle_type] = this->cargo_filter_criteria;
01171
01172 this->eng_list.SetFilterState(this->cargo_filter[this->cargo_filter_criteria] != CF_ANY);
01173 this->eng_list.ForceRebuild();
01174 }
01175 break;
01176 }
01177 this->SetDirty();
01178 }
01179
01180 virtual void OnResize()
01181 {
01182 this->vscroll.SetCapacityFromWidget(this, BUILD_VEHICLE_WIDGET_LIST);
01183 this->GetWidget<NWidgetCore>(BUILD_VEHICLE_WIDGET_LIST)->widget_data = (this->vscroll.GetCapacity() << MAT_ROW_START) + (1 << MAT_COL_START);
01184 }
01185 };
01186
01187 static const WindowDesc _build_vehicle_desc(
01188 WDP_AUTO, 240, 268,
01189 WC_BUILD_VEHICLE, WC_NONE,
01190 WDF_UNCLICK_BUTTONS | WDF_CONSTRUCTION,
01191 _nested_build_vehicle_widgets, lengthof(_nested_build_vehicle_widgets)
01192 );
01193
01194 void ShowBuildVehicleWindow(TileIndex tile, VehicleType type)
01195 {
01196
01197
01198
01199
01200 uint num = (tile == INVALID_TILE) ? (int)type : tile;
01201
01202 assert(IsCompanyBuildableVehicleType(type));
01203
01204 DeleteWindowById(WC_BUILD_VEHICLE, num);
01205
01206 new BuildVehicleWindow(&_build_vehicle_desc, tile, type);
01207 }