00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "stdafx.h"
00013 #include "engine_base.h"
00014 #include "engine_func.h"
00015 #include "station_base.h"
00016 #include "network/network.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 "string_func.h"
00026 #include "strings_func.h"
00027 #include "window_func.h"
00028 #include "date_func.h"
00029 #include "vehicle_func.h"
00030 #include "widgets/dropdown_func.h"
00031 #include "engine_gui.h"
00032 #include "cargotype.h"
00033 #include "core/geometry_func.hpp"
00034 #include "autoreplace_func.h"
00035
00036 #include "widgets/build_vehicle_widget.h"
00037
00038 #include "table/strings.h"
00039
00045 uint GetEngineListHeight(VehicleType type)
00046 {
00047 return max<uint>(FONT_HEIGHT_NORMAL + WD_MATRIX_TOP + WD_MATRIX_BOTTOM, GetVehicleImageCellSize(type, EIT_PURCHASE).height);
00048 }
00049
00050 static const NWidgetPart _nested_build_vehicle_widgets[] = {
00051 NWidget(NWID_HORIZONTAL),
00052 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
00053 NWidget(WWT_CAPTION, COLOUR_GREY, WID_BV_CAPTION), SetDataTip(STR_WHITE_STRING, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
00054 NWidget(WWT_SHADEBOX, COLOUR_GREY),
00055 NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
00056 NWidget(WWT_STICKYBOX, COLOUR_GREY),
00057 EndContainer(),
00058 NWidget(WWT_PANEL, COLOUR_GREY),
00059 NWidget(NWID_HORIZONTAL),
00060 NWidget(NWID_VERTICAL),
00061 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_BV_SORT_ASSENDING_DESCENDING), SetDataTip(STR_BUTTON_SORT_BY, STR_TOOLTIP_SORT_ORDER), SetFill(1, 0),
00062 NWidget(NWID_SPACER), SetFill(1, 1),
00063 EndContainer(),
00064 NWidget(NWID_VERTICAL),
00065 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_BV_SORT_DROPDOWN), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_JUST_STRING, STR_TOOLTIP_SORT_CRITERIA),
00066 NWidget(WWT_DROPDOWN, COLOUR_GREY, WID_BV_CARGO_FILTER_DROPDOWN), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_JUST_STRING, STR_TOOLTIP_FILTER_CRITERIA),
00067 EndContainer(),
00068 EndContainer(),
00069 EndContainer(),
00070
00071 NWidget(NWID_HORIZONTAL),
00072 NWidget(WWT_MATRIX, COLOUR_GREY, WID_BV_LIST), SetResize(1, 1), SetFill(1, 0), SetMatrixDataTip(1, 0, STR_NULL), SetScrollbar(WID_BV_SCROLLBAR),
00073 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_BV_SCROLLBAR),
00074 EndContainer(),
00075
00076 NWidget(WWT_PANEL, COLOUR_GREY, WID_BV_PANEL), SetMinimalSize(240, 122), SetResize(1, 0), EndContainer(),
00077
00078 NWidget(NWID_HORIZONTAL),
00079 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BV_BUILD_SEL),
00080 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_BV_BUILD), SetResize(1, 0), SetFill(1, 0),
00081 EndContainer(),
00082 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_BV_RENAME), SetResize(1, 0), SetFill(1, 0),
00083 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
00084 EndContainer(),
00085 };
00086
00088 static const CargoID CF_ANY = CT_NO_REFIT;
00089 static const CargoID CF_NONE = CT_INVALID;
00090
00091 static bool _internal_sort_order;
00092 static byte _last_sort_criteria[] = {0, 0, 0, 0};
00093 static bool _last_sort_order[] = {false, false, false, false};
00094 static CargoID _last_filter_criteria[] = {CF_ANY, CF_ANY, CF_ANY, CF_ANY};
00095
00102 static int CDECL EngineNumberSorter(const EngineID *a, const EngineID *b)
00103 {
00104 int r = Engine::Get(*a)->list_position - Engine::Get(*b)->list_position;
00105
00106 return _internal_sort_order ? -r : r;
00107 }
00108
00115 static int CDECL EngineIntroDateSorter(const EngineID *a, const EngineID *b)
00116 {
00117 const int va = Engine::Get(*a)->intro_date;
00118 const int vb = Engine::Get(*b)->intro_date;
00119 const int r = va - vb;
00120
00121
00122 if (r == 0) return EngineNumberSorter(a, b);
00123 return _internal_sort_order ? -r : r;
00124 }
00125
00132 static int CDECL EngineNameSorter(const EngineID *a, const EngineID *b)
00133 {
00134 static EngineID last_engine[2] = { INVALID_ENGINE, INVALID_ENGINE };
00135 static char last_name[2][64] = { "\0", "\0" };
00136
00137 const EngineID va = *a;
00138 const EngineID vb = *b;
00139
00140 if (va != last_engine[0]) {
00141 last_engine[0] = va;
00142 SetDParam(0, va);
00143 GetString(last_name[0], STR_ENGINE_NAME, lastof(last_name[0]));
00144 }
00145
00146 if (vb != last_engine[1]) {
00147 last_engine[1] = vb;
00148 SetDParam(0, vb);
00149 GetString(last_name[1], STR_ENGINE_NAME, lastof(last_name[1]));
00150 }
00151
00152 int r = strnatcmp(last_name[0], last_name[1]);
00153
00154
00155 if (r == 0) return EngineNumberSorter(a, b);
00156 return _internal_sort_order ? -r : r;
00157 }
00158
00165 static int CDECL EngineReliabilitySorter(const EngineID *a, const EngineID *b)
00166 {
00167 const int va = Engine::Get(*a)->reliability;
00168 const int vb = Engine::Get(*b)->reliability;
00169 const int r = va - vb;
00170
00171
00172 if (r == 0) return EngineNumberSorter(a, b);
00173 return _internal_sort_order ? -r : r;
00174 }
00175
00182 static int CDECL EngineCostSorter(const EngineID *a, const EngineID *b)
00183 {
00184 Money va = Engine::Get(*a)->GetCost();
00185 Money vb = Engine::Get(*b)->GetCost();
00186 int r = ClampToI32(va - vb);
00187
00188
00189 if (r == 0) return EngineNumberSorter(a, b);
00190 return _internal_sort_order ? -r : r;
00191 }
00192
00199 static int CDECL EngineSpeedSorter(const EngineID *a, const EngineID *b)
00200 {
00201 int va = Engine::Get(*a)->GetDisplayMaxSpeed();
00202 int vb = Engine::Get(*b)->GetDisplayMaxSpeed();
00203 int r = va - vb;
00204
00205
00206 if (r == 0) return EngineNumberSorter(a, b);
00207 return _internal_sort_order ? -r : r;
00208 }
00209
00216 static int CDECL EnginePowerSorter(const EngineID *a, const EngineID *b)
00217 {
00218 int va = Engine::Get(*a)->GetPower();
00219 int vb = Engine::Get(*b)->GetPower();
00220 int r = va - vb;
00221
00222
00223 if (r == 0) return EngineNumberSorter(a, b);
00224 return _internal_sort_order ? -r : r;
00225 }
00226
00233 static int CDECL EngineTractiveEffortSorter(const EngineID *a, const EngineID *b)
00234 {
00235 int va = Engine::Get(*a)->GetDisplayMaxTractiveEffort();
00236 int vb = Engine::Get(*b)->GetDisplayMaxTractiveEffort();
00237 int r = va - vb;
00238
00239
00240 if (r == 0) return EngineNumberSorter(a, b);
00241 return _internal_sort_order ? -r : r;
00242 }
00243
00250 static int CDECL EngineRunningCostSorter(const EngineID *a, const EngineID *b)
00251 {
00252 Money va = Engine::Get(*a)->GetRunningCost();
00253 Money vb = Engine::Get(*b)->GetRunningCost();
00254 int r = ClampToI32(va - vb);
00255
00256
00257 if (r == 0) return EngineNumberSorter(a, b);
00258 return _internal_sort_order ? -r : r;
00259 }
00260
00267 static int CDECL EnginePowerVsRunningCostSorter(const EngineID *a, const EngineID *b)
00268 {
00269 const Engine *e_a = Engine::Get(*a);
00270 const Engine *e_b = Engine::Get(*b);
00271
00272
00273
00274
00275
00276
00277
00278 Money va = (e_a->GetRunningCost()) / max(1U, (uint)e_a->GetPower());
00279 Money vb = (e_b->GetRunningCost()) / max(1U, (uint)e_b->GetPower());
00280 int r = ClampToI32(vb - va);
00281
00282
00283 if (r == 0) return EngineNumberSorter(a, b);
00284 return _internal_sort_order ? -r : r;
00285 }
00286
00287
00288
00295 static int CDECL TrainEngineCapacitySorter(const EngineID *a, const EngineID *b)
00296 {
00297 const RailVehicleInfo *rvi_a = RailVehInfo(*a);
00298 const RailVehicleInfo *rvi_b = RailVehInfo(*b);
00299
00300 int va = GetTotalCapacityOfArticulatedParts(*a) * (rvi_a->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);
00301 int vb = GetTotalCapacityOfArticulatedParts(*b) * (rvi_b->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);
00302 int r = va - vb;
00303
00304
00305 if (r == 0) return EngineNumberSorter(a, b);
00306 return _internal_sort_order ? -r : r;
00307 }
00308
00315 static int CDECL TrainEnginesThenWagonsSorter(const EngineID *a, const EngineID *b)
00316 {
00317 int val_a = (RailVehInfo(*a)->railveh_type == RAILVEH_WAGON ? 1 : 0);
00318 int val_b = (RailVehInfo(*b)->railveh_type == RAILVEH_WAGON ? 1 : 0);
00319 int r = val_a - val_b;
00320
00321
00322 if (r == 0) return EngineNumberSorter(a, b);
00323 return _internal_sort_order ? -r : r;
00324 }
00325
00326
00327
00334 static int CDECL RoadVehEngineCapacitySorter(const EngineID *a, const EngineID *b)
00335 {
00336 int va = GetTotalCapacityOfArticulatedParts(*a);
00337 int vb = GetTotalCapacityOfArticulatedParts(*b);
00338 int r = va - vb;
00339
00340
00341 if (r == 0) return EngineNumberSorter(a, b);
00342 return _internal_sort_order ? -r : r;
00343 }
00344
00345
00346
00353 static int CDECL ShipEngineCapacitySorter(const EngineID *a, const EngineID *b)
00354 {
00355 const Engine *e_a = Engine::Get(*a);
00356 const Engine *e_b = Engine::Get(*b);
00357
00358 int va = e_a->GetDisplayDefaultCapacity();
00359 int vb = e_b->GetDisplayDefaultCapacity();
00360 int r = va - vb;
00361
00362
00363 if (r == 0) return EngineNumberSorter(a, b);
00364 return _internal_sort_order ? -r : r;
00365 }
00366
00367
00368
00375 static int CDECL AircraftEngineCargoSorter(const EngineID *a, const EngineID *b)
00376 {
00377 const Engine *e_a = Engine::Get(*a);
00378 const Engine *e_b = Engine::Get(*b);
00379
00380 uint16 mail_a, mail_b;
00381 int va = e_a->GetDisplayDefaultCapacity(&mail_a);
00382 int vb = e_b->GetDisplayDefaultCapacity(&mail_b);
00383 int r = va - vb;
00384
00385 if (r == 0) {
00386
00387 r = mail_a - mail_b;
00388
00389 if (r == 0) {
00390
00391 return EngineNumberSorter(a, b);
00392 }
00393 }
00394 return _internal_sort_order ? -r : r;
00395 }
00396
00403 static int CDECL AircraftRangeSorter(const EngineID *a, const EngineID *b)
00404 {
00405 uint16 r_a = Engine::Get(*a)->GetRange();
00406 uint16 r_b = Engine::Get(*b)->GetRange();
00407
00408 int r = r_a - r_b;
00409
00410
00411 if (r == 0) return EngineNumberSorter(a, b);
00412 return _internal_sort_order ? -r : r;
00413 }
00414
00415 static EngList_SortTypeFunction * const _sorter[][11] = {{
00416
00417 &EngineNumberSorter,
00418 &EngineCostSorter,
00419 &EngineSpeedSorter,
00420 &EnginePowerSorter,
00421 &EngineTractiveEffortSorter,
00422 &EngineIntroDateSorter,
00423 &EngineNameSorter,
00424 &EngineRunningCostSorter,
00425 &EnginePowerVsRunningCostSorter,
00426 &EngineReliabilitySorter,
00427 &TrainEngineCapacitySorter,
00428 }, {
00429
00430 &EngineNumberSorter,
00431 &EngineCostSorter,
00432 &EngineSpeedSorter,
00433 &EnginePowerSorter,
00434 &EngineTractiveEffortSorter,
00435 &EngineIntroDateSorter,
00436 &EngineNameSorter,
00437 &EngineRunningCostSorter,
00438 &EnginePowerVsRunningCostSorter,
00439 &EngineReliabilitySorter,
00440 &RoadVehEngineCapacitySorter,
00441 }, {
00442
00443 &EngineNumberSorter,
00444 &EngineCostSorter,
00445 &EngineSpeedSorter,
00446 &EngineIntroDateSorter,
00447 &EngineNameSorter,
00448 &EngineRunningCostSorter,
00449 &EngineReliabilitySorter,
00450 &ShipEngineCapacitySorter,
00451 }, {
00452
00453 &EngineNumberSorter,
00454 &EngineCostSorter,
00455 &EngineSpeedSorter,
00456 &EngineIntroDateSorter,
00457 &EngineNameSorter,
00458 &EngineRunningCostSorter,
00459 &EngineReliabilitySorter,
00460 &AircraftEngineCargoSorter,
00461 &AircraftRangeSorter,
00462 }};
00463
00464 static const StringID _sort_listing[][12] = {{
00465
00466 STR_SORT_BY_ENGINE_ID,
00467 STR_SORT_BY_COST,
00468 STR_SORT_BY_MAX_SPEED,
00469 STR_SORT_BY_POWER,
00470 STR_SORT_BY_TRACTIVE_EFFORT,
00471 STR_SORT_BY_INTRO_DATE,
00472 STR_SORT_BY_NAME,
00473 STR_SORT_BY_RUNNING_COST,
00474 STR_SORT_BY_POWER_VS_RUNNING_COST,
00475 STR_SORT_BY_RELIABILITY,
00476 STR_SORT_BY_CARGO_CAPACITY,
00477 INVALID_STRING_ID
00478 }, {
00479
00480 STR_SORT_BY_ENGINE_ID,
00481 STR_SORT_BY_COST,
00482 STR_SORT_BY_MAX_SPEED,
00483 STR_SORT_BY_POWER,
00484 STR_SORT_BY_TRACTIVE_EFFORT,
00485 STR_SORT_BY_INTRO_DATE,
00486 STR_SORT_BY_NAME,
00487 STR_SORT_BY_RUNNING_COST,
00488 STR_SORT_BY_POWER_VS_RUNNING_COST,
00489 STR_SORT_BY_RELIABILITY,
00490 STR_SORT_BY_CARGO_CAPACITY,
00491 INVALID_STRING_ID
00492 }, {
00493
00494 STR_SORT_BY_ENGINE_ID,
00495 STR_SORT_BY_COST,
00496 STR_SORT_BY_MAX_SPEED,
00497 STR_SORT_BY_INTRO_DATE,
00498 STR_SORT_BY_NAME,
00499 STR_SORT_BY_RUNNING_COST,
00500 STR_SORT_BY_RELIABILITY,
00501 STR_SORT_BY_CARGO_CAPACITY,
00502 INVALID_STRING_ID
00503 }, {
00504
00505 STR_SORT_BY_ENGINE_ID,
00506 STR_SORT_BY_COST,
00507 STR_SORT_BY_MAX_SPEED,
00508 STR_SORT_BY_INTRO_DATE,
00509 STR_SORT_BY_NAME,
00510 STR_SORT_BY_RUNNING_COST,
00511 STR_SORT_BY_RELIABILITY,
00512 STR_SORT_BY_CARGO_CAPACITY,
00513 STR_SORT_BY_RANGE,
00514 INVALID_STRING_ID
00515 }};
00516
00518 static bool CDECL CargoFilter(const EngineID *eid, const CargoID cid)
00519 {
00520 if (cid == CF_ANY) return true;
00521 uint32 refit_mask = GetUnionOfArticulatedRefitMasks(*eid, true) & _standard_cargo_mask;
00522 return (cid == CF_NONE ? refit_mask == 0 : HasBit(refit_mask, cid));
00523 }
00524
00525 static GUIEngineList::FilterFunction * const _filter_funcs[] = {
00526 &CargoFilter,
00527 };
00528
00529 static int DrawCargoCapacityInfo(int left, int right, int y, EngineID engine, bool refittable)
00530 {
00531 CargoArray cap = GetCapacityOfArticulatedParts(engine);
00532
00533 for (CargoID c = 0; c < NUM_CARGO; c++) {
00534 if (cap[c] == 0) continue;
00535
00536 SetDParam(0, c);
00537 SetDParam(1, cap[c]);
00538 SetDParam(2, refittable ? STR_PURCHASE_INFO_REFITTABLE : STR_EMPTY);
00539 DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
00540 y += FONT_HEIGHT_NORMAL;
00541
00542
00543 refittable = false;
00544 }
00545
00546 return y;
00547 }
00548
00549
00550 static int DrawRailWagonPurchaseInfo(int left, int right, int y, EngineID engine_number, const RailVehicleInfo *rvi)
00551 {
00552 const Engine *e = Engine::Get(engine_number);
00553
00554
00555 SetDParam(0, e->GetCost());
00556 DrawString(left, right, y, STR_PURCHASE_INFO_COST);
00557 y += FONT_HEIGHT_NORMAL;
00558
00559
00560 uint weight = e->GetDisplayWeight();
00561 SetDParam(0, weight);
00562 uint cargo_weight = (e->CanCarryCargo() ? CargoSpec::Get(e->GetDefaultCargoType())->weight * GetTotalCapacityOfArticulatedParts(engine_number) / 16 : 0);
00563 SetDParam(1, cargo_weight + weight);
00564 DrawString(left, right, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT);
00565 y += FONT_HEIGHT_NORMAL;
00566
00567
00568 if (_settings_game.vehicle.wagon_speed_limits) {
00569 uint max_speed = e->GetDisplayMaxSpeed();
00570 if (max_speed > 0) {
00571 SetDParam(0, max_speed);
00572 DrawString(left, right, y, STR_PURCHASE_INFO_SPEED);
00573 y += FONT_HEIGHT_NORMAL;
00574 }
00575 }
00576
00577
00578 if (rvi->running_cost_class != INVALID_PRICE) {
00579 SetDParam(0, e->GetRunningCost());
00580 DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
00581 y += FONT_HEIGHT_NORMAL;
00582 }
00583
00584 return y;
00585 }
00586
00587
00588 static int DrawRailEnginePurchaseInfo(int left, int right, int y, EngineID engine_number, const RailVehicleInfo *rvi)
00589 {
00590 const Engine *e = Engine::Get(engine_number);
00591
00592
00593 SetDParam(0, e->GetCost());
00594 SetDParam(1, e->GetDisplayWeight());
00595 DrawString(left, right, y, STR_PURCHASE_INFO_COST_WEIGHT);
00596 y += FONT_HEIGHT_NORMAL;
00597
00598
00599 SetDParam(0, e->GetDisplayMaxSpeed());
00600 SetDParam(1, e->GetPower());
00601 DrawString(left, right, y, STR_PURCHASE_INFO_SPEED_POWER);
00602 y += FONT_HEIGHT_NORMAL;
00603
00604
00605 if (_settings_game.vehicle.train_acceleration_model != AM_ORIGINAL && GetRailTypeInfo(rvi->railtype)->acceleration_type != 2) {
00606 SetDParam(0, e->GetDisplayMaxTractiveEffort());
00607 DrawString(left, right, y, STR_PURCHASE_INFO_MAX_TE);
00608 y += FONT_HEIGHT_NORMAL;
00609 }
00610
00611
00612 if (rvi->running_cost_class != INVALID_PRICE) {
00613 SetDParam(0, e->GetRunningCost());
00614 DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
00615 y += FONT_HEIGHT_NORMAL;
00616 }
00617
00618
00619 if (rvi->pow_wag_power != 0) {
00620 SetDParam(0, rvi->pow_wag_power);
00621 SetDParam(1, rvi->pow_wag_weight);
00622 DrawString(left, right, y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT);
00623 y += FONT_HEIGHT_NORMAL;
00624 }
00625
00626 return y;
00627 }
00628
00629
00630 static int DrawRoadVehPurchaseInfo(int left, int right, int y, EngineID engine_number)
00631 {
00632 const Engine *e = Engine::Get(engine_number);
00633
00634 if (_settings_game.vehicle.roadveh_acceleration_model != AM_ORIGINAL) {
00635
00636 SetDParam(0, e->GetCost());
00637 DrawString(left, right, y, STR_PURCHASE_INFO_COST);
00638 y += FONT_HEIGHT_NORMAL;
00639
00640
00641 int16 weight = e->GetDisplayWeight();
00642 SetDParam(0, weight);
00643 uint cargo_weight = (e->CanCarryCargo() ? CargoSpec::Get(e->GetDefaultCargoType())->weight * GetTotalCapacityOfArticulatedParts(engine_number) / 16 : 0);
00644 SetDParam(1, cargo_weight + weight);
00645 DrawString(left, right, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT);
00646 y += FONT_HEIGHT_NORMAL;
00647
00648
00649 SetDParam(0, e->GetDisplayMaxSpeed());
00650 SetDParam(1, e->GetPower());
00651 DrawString(left, right, y, STR_PURCHASE_INFO_SPEED_POWER);
00652 y += FONT_HEIGHT_NORMAL;
00653
00654
00655 SetDParam(0, e->GetDisplayMaxTractiveEffort());
00656 DrawString(left, right, y, STR_PURCHASE_INFO_MAX_TE);
00657 y += FONT_HEIGHT_NORMAL;
00658 } else {
00659
00660 SetDParam(0, e->GetCost());
00661 SetDParam(1, e->GetDisplayMaxSpeed());
00662 DrawString(left, right, y, STR_PURCHASE_INFO_COST_SPEED);
00663 y += FONT_HEIGHT_NORMAL;
00664 }
00665
00666
00667 SetDParam(0, e->GetRunningCost());
00668 DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
00669 y += FONT_HEIGHT_NORMAL;
00670
00671 return y;
00672 }
00673
00674
00675 static int DrawShipPurchaseInfo(int left, int right, int y, EngineID engine_number, bool refittable)
00676 {
00677 const Engine *e = Engine::Get(engine_number);
00678
00679
00680 uint raw_speed = e->GetDisplayMaxSpeed();
00681 uint ocean_speed = e->u.ship.ApplyWaterClassSpeedFrac(raw_speed, true);
00682 uint canal_speed = e->u.ship.ApplyWaterClassSpeedFrac(raw_speed, false);
00683
00684 SetDParam(0, e->GetCost());
00685 if (ocean_speed == canal_speed) {
00686 SetDParam(1, ocean_speed);
00687 DrawString(left, right, y, STR_PURCHASE_INFO_COST_SPEED);
00688 y += FONT_HEIGHT_NORMAL;
00689 } else {
00690 DrawString(left, right, y, STR_PURCHASE_INFO_COST);
00691 y += FONT_HEIGHT_NORMAL;
00692
00693 SetDParam(0, ocean_speed);
00694 DrawString(left, right, y, STR_PURCHASE_INFO_SPEED_OCEAN);
00695 y += FONT_HEIGHT_NORMAL;
00696
00697 SetDParam(0, canal_speed);
00698 DrawString(left, right, y, STR_PURCHASE_INFO_SPEED_CANAL);
00699 y += FONT_HEIGHT_NORMAL;
00700 }
00701
00702
00703 SetDParam(0, e->GetDefaultCargoType());
00704 SetDParam(1, e->GetDisplayDefaultCapacity());
00705 SetDParam(2, refittable ? STR_PURCHASE_INFO_REFITTABLE : STR_EMPTY);
00706 DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
00707 y += FONT_HEIGHT_NORMAL;
00708
00709
00710 SetDParam(0, e->GetRunningCost());
00711 DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
00712 y += FONT_HEIGHT_NORMAL;
00713
00714 return y;
00715 }
00716
00717
00718 static int DrawAircraftPurchaseInfo(int left, int right, int y, EngineID engine_number, bool refittable)
00719 {
00720 const Engine *e = Engine::Get(engine_number);
00721 CargoID cargo = e->GetDefaultCargoType();
00722
00723
00724 SetDParam(0, e->GetCost());
00725 SetDParam(1, e->GetDisplayMaxSpeed());
00726 DrawString(left, right, y, STR_PURCHASE_INFO_COST_SPEED);
00727 y += FONT_HEIGHT_NORMAL;
00728
00729
00730 uint16 mail_capacity;
00731 uint capacity = e->GetDisplayDefaultCapacity(&mail_capacity);
00732 if (mail_capacity > 0) {
00733 SetDParam(0, cargo);
00734 SetDParam(1, capacity);
00735 SetDParam(2, CT_MAIL);
00736 SetDParam(3, mail_capacity);
00737 DrawString(left, right, y, STR_PURCHASE_INFO_AIRCRAFT_CAPACITY);
00738 } else {
00739
00740
00741 SetDParam(0, cargo);
00742 SetDParam(1, capacity);
00743 SetDParam(2, refittable ? STR_PURCHASE_INFO_REFITTABLE : STR_EMPTY);
00744 DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
00745 }
00746 y += FONT_HEIGHT_NORMAL;
00747
00748
00749 SetDParam(0, e->GetRunningCost());
00750 DrawString(left, right, y, STR_PURCHASE_INFO_RUNNINGCOST);
00751 y += FONT_HEIGHT_NORMAL;
00752
00753 uint16 range = e->GetRange();
00754 if (range != 0) {
00755 SetDParam(0, range);
00756 DrawString(left, right, y, STR_PURCHASE_INFO_AIRCRAFT_RANGE);
00757 y += FONT_HEIGHT_NORMAL;
00758 }
00759
00760 return y;
00761 }
00762
00771 static uint ShowAdditionalText(int left, int right, int y, EngineID engine)
00772 {
00773 uint16 callback = GetVehicleCallback(CBID_VEHICLE_ADDITIONAL_TEXT, 0, 0, engine, NULL);
00774 if (callback == CALLBACK_FAILED || callback == 0x400) return y;
00775 const GRFFile *grffile = Engine::Get(engine)->GetGRF();
00776 if (callback > 0x400) {
00777 ErrorUnknownCallbackResult(grffile->grfid, CBID_VEHICLE_ADDITIONAL_TEXT, callback);
00778 return y;
00779 }
00780
00781 StartTextRefStackUsage(grffile, 6);
00782 uint result = DrawStringMultiLine(left, right, y, INT32_MAX, GetGRFStringID(grffile->grfid, 0xD000 + callback), TC_BLACK);
00783 StopTextRefStackUsage();
00784 return result;
00785 }
00786
00793 int DrawVehiclePurchaseInfo(int left, int right, int y, EngineID engine_number)
00794 {
00795 const Engine *e = Engine::Get(engine_number);
00796 YearMonthDay ymd;
00797 ConvertDateToYMD(e->intro_date, &ymd);
00798 bool refittable = IsArticulatedVehicleRefittable(engine_number);
00799 bool articulated_cargo = false;
00800
00801 switch (e->type) {
00802 default: NOT_REACHED();
00803 case VEH_TRAIN:
00804 if (e->u.rail.railveh_type == RAILVEH_WAGON) {
00805 y = DrawRailWagonPurchaseInfo(left, right, y, engine_number, &e->u.rail);
00806 } else {
00807 y = DrawRailEnginePurchaseInfo(left, right, y, engine_number, &e->u.rail);
00808 }
00809 articulated_cargo = true;
00810 break;
00811
00812 case VEH_ROAD:
00813 y = DrawRoadVehPurchaseInfo(left, right, y, engine_number);
00814 articulated_cargo = true;
00815 break;
00816
00817 case VEH_SHIP:
00818 y = DrawShipPurchaseInfo(left, right, y, engine_number, refittable);
00819 break;
00820
00821 case VEH_AIRCRAFT:
00822 y = DrawAircraftPurchaseInfo(left, right, y, engine_number, refittable);
00823 break;
00824 }
00825
00826 if (articulated_cargo) {
00827
00828 int new_y = DrawCargoCapacityInfo(left, right, y, engine_number, refittable);
00829
00830 if (new_y == y) {
00831 SetDParam(0, CT_INVALID);
00832 SetDParam(2, STR_EMPTY);
00833 DrawString(left, right, y, STR_PURCHASE_INFO_CAPACITY);
00834 y += FONT_HEIGHT_NORMAL;
00835 } else {
00836 y = new_y;
00837 }
00838 }
00839
00840
00841 if (e->type != VEH_TRAIN || e->u.rail.railveh_type != RAILVEH_WAGON) {
00842
00843 SetDParam(0, ymd.year);
00844 SetDParam(1, e->GetLifeLengthInDays() / DAYS_IN_LEAP_YEAR);
00845 DrawString(left, right, y, STR_PURCHASE_INFO_DESIGNED_LIFE);
00846 y += FONT_HEIGHT_NORMAL;
00847
00848
00849 SetDParam(0, ToPercent16(e->reliability));
00850 DrawString(left, right, y, STR_PURCHASE_INFO_RELIABILITY);
00851 y += FONT_HEIGHT_NORMAL;
00852 }
00853
00854 if (refittable) y = ShowRefitOptionsList(left, right, y, engine_number);
00855
00856
00857 y = ShowAdditionalText(left, right, y, engine_number);
00858
00859 return y;
00860 }
00861
00875 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)
00876 {
00877 static const int sprite_y_offsets[] = { -1, -1, -2, -2 };
00878
00879
00880 assert(max <= eng_list->Length());
00881
00882 bool rtl = _current_text_dir == TD_RTL;
00883 int step_size = GetEngineListHeight(type);
00884 int sprite_left = GetVehicleImageCellSize(type, EIT_PURCHASE).extend_left;
00885 int sprite_right = GetVehicleImageCellSize(type, EIT_PURCHASE).extend_right;
00886 int sprite_width = sprite_left + sprite_right;
00887
00888 int sprite_x = rtl ? r - sprite_right - 1 : l + sprite_left + 1;
00889 int sprite_y_offset = sprite_y_offsets[type] + step_size / 2;
00890
00891 Dimension replace_icon = {0, 0};
00892 int count_width = 0;
00893 if (show_count) {
00894 replace_icon = GetSpriteSize(SPR_GROUP_REPLACE_ACTIVE);
00895 SetDParamMaxDigits(0, 3, FS_SMALL);
00896 count_width = GetStringBoundingBox(STR_TINY_BLACK_COMA).width;
00897 }
00898
00899 int text_left = l + (rtl ? WD_FRAMERECT_LEFT + replace_icon.width + 8 + count_width : sprite_width + WD_FRAMETEXT_LEFT);
00900 int text_right = r - (rtl ? sprite_width + WD_FRAMETEXT_RIGHT : WD_FRAMERECT_RIGHT + replace_icon.width + 8 + count_width);
00901 int replace_icon_left = rtl ? l + WD_FRAMERECT_LEFT : r - WD_FRAMERECT_RIGHT - replace_icon.width;
00902 int count_left = l;
00903 int count_right = rtl ? text_left : r - WD_FRAMERECT_RIGHT - replace_icon.width - 8;
00904
00905 int normal_text_y_offset = (step_size - FONT_HEIGHT_NORMAL) / 2;
00906 int small_text_y_offset = step_size - FONT_HEIGHT_SMALL - WD_FRAMERECT_BOTTOM - 1;
00907 int replace_icon_y_offset = (step_size - replace_icon.height) / 2 - 1;
00908
00909 for (; min < max; min++, y += step_size) {
00910 const EngineID engine = (*eng_list)[min];
00911
00912 const uint num_engines = GetGroupNumEngines(_local_company, selected_group, engine);
00913
00914 SetDParam(0, engine);
00915 DrawString(text_left, text_right, y + normal_text_y_offset, STR_ENGINE_NAME, engine == selected_id ? TC_WHITE : TC_BLACK);
00916 DrawVehicleEngine(l, r, sprite_x, y + sprite_y_offset, engine, (show_count && num_engines == 0) ? PALETTE_CRASH : GetEnginePalette(engine, _local_company), EIT_PURCHASE);
00917 if (show_count) {
00918 SetDParam(0, num_engines);
00919 DrawString(count_left, count_right, y + small_text_y_offset, STR_TINY_BLACK_COMA, TC_FROMSTRING, SA_RIGHT | SA_FORCE);
00920 if (EngineHasReplacementForCompany(Company::Get(_local_company), engine, selected_group)) DrawSprite(SPR_GROUP_REPLACE_ACTIVE, num_engines == 0 ? PALETTE_CRASH : PAL_NONE, replace_icon_left, y + replace_icon_y_offset);
00921 }
00922 }
00923 }
00924
00925
00926 struct BuildVehicleWindow : Window {
00927 VehicleType vehicle_type;
00928 union {
00929 RailTypeByte railtype;
00930 RoadTypes roadtypes;
00931 } filter;
00932 bool descending_sort_order;
00933 byte sort_criteria;
00934 bool listview_mode;
00935 EngineID sel_engine;
00936 EngineID rename_engine;
00937 GUIEngineList eng_list;
00938 CargoID cargo_filter[NUM_CARGO + 2];
00939 StringID cargo_filter_texts[NUM_CARGO + 3];
00940 byte cargo_filter_criteria;
00941 int details_height;
00942 Scrollbar *vscroll;
00943
00944 BuildVehicleWindow(WindowDesc *desc, TileIndex tile, VehicleType type) : Window(desc)
00945 {
00946 this->vehicle_type = type;
00947 this->window_number = tile == INVALID_TILE ? (int)type : tile;
00948
00949 this->sel_engine = INVALID_ENGINE;
00950
00951 this->sort_criteria = _last_sort_criteria[type];
00952 this->descending_sort_order = _last_sort_order[type];
00953
00954 switch (type) {
00955 default: NOT_REACHED();
00956 case VEH_TRAIN:
00957 this->filter.railtype = (tile == INVALID_TILE) ? RAILTYPE_END : GetRailType(tile);
00958 break;
00959 case VEH_ROAD:
00960 this->filter.roadtypes = (tile == INVALID_TILE) ? ROADTYPES_ALL : GetRoadTypes(tile);
00961 case VEH_SHIP:
00962 case VEH_AIRCRAFT:
00963 break;
00964 }
00965
00966 this->listview_mode = (this->window_number <= VEH_END);
00967
00968 this->CreateNestedTree();
00969
00970 this->vscroll = this->GetScrollbar(WID_BV_SCROLLBAR);
00971
00972
00973
00974 if (this->listview_mode) this->GetWidget<NWidgetStacked>(WID_BV_BUILD_SEL)->SetDisplayedPlane(SZSP_NONE);
00975
00976
00977 this->SetWidgetDisabledState(WID_BV_RENAME, _networking && !_network_server);
00978
00979 NWidgetCore *widget = this->GetWidget<NWidgetCore>(WID_BV_LIST);
00980 widget->tool_tip = STR_BUY_VEHICLE_TRAIN_LIST_TOOLTIP + type;
00981
00982 widget = this->GetWidget<NWidgetCore>(WID_BV_BUILD);
00983 widget->widget_data = STR_BUY_VEHICLE_TRAIN_BUY_VEHICLE_BUTTON + type;
00984 widget->tool_tip = STR_BUY_VEHICLE_TRAIN_BUY_VEHICLE_TOOLTIP + type;
00985
00986 widget = this->GetWidget<NWidgetCore>(WID_BV_RENAME);
00987 widget->widget_data = STR_BUY_VEHICLE_TRAIN_RENAME_BUTTON + type;
00988 widget->tool_tip = STR_BUY_VEHICLE_TRAIN_RENAME_TOOLTIP + type;
00989
00990 this->details_height = ((this->vehicle_type == VEH_TRAIN) ? 10 : 9) * FONT_HEIGHT_NORMAL + WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM;
00991
00992 this->FinishInitNested(tile == INVALID_TILE ? (int)type : tile);
00993
00994 this->owner = (tile != INVALID_TILE) ? GetTileOwner(tile) : _local_company;
00995
00996 this->eng_list.ForceRebuild();
00997 this->GenerateBuildList();
00998
00999 if (this->eng_list.Length() > 0) this->sel_engine = this->eng_list[0];
01000 }
01001
01003 void SetCargoFilterArray()
01004 {
01005 uint filter_items = 0;
01006
01007
01008 this->cargo_filter[filter_items] = CF_ANY;
01009 this->cargo_filter_texts[filter_items] = STR_PURCHASE_INFO_ALL_TYPES;
01010 filter_items++;
01011
01012
01013
01014 if (this->vehicle_type == VEH_TRAIN) {
01015 this->cargo_filter[filter_items] = CF_NONE;
01016 this->cargo_filter_texts[filter_items] = STR_LAND_AREA_INFORMATION_LOCAL_AUTHORITY_NONE;
01017 filter_items++;
01018 }
01019
01020
01021 const CargoSpec *cs;
01022 FOR_ALL_SORTED_STANDARD_CARGOSPECS(cs) {
01023 this->cargo_filter[filter_items] = cs->Index();
01024 this->cargo_filter_texts[filter_items] = cs->name;
01025 filter_items++;
01026 }
01027
01028
01029 this->cargo_filter_texts[filter_items] = INVALID_STRING_ID;
01030
01031
01032 this->cargo_filter_criteria = 0;
01033
01034
01035 for (uint i = 0; i < filter_items; i++) {
01036 if (this->cargo_filter[i] == _last_filter_criteria[this->vehicle_type]) {
01037 this->cargo_filter_criteria = i;
01038 break;
01039 }
01040 }
01041
01042 this->eng_list.SetFilterFuncs(_filter_funcs);
01043 this->eng_list.SetFilterState(this->cargo_filter[this->cargo_filter_criteria] != CF_ANY);
01044 }
01045
01046 void OnInit()
01047 {
01048 this->SetCargoFilterArray();
01049 }
01050
01052 void FilterEngineList()
01053 {
01054 this->eng_list.Filter(this->cargo_filter[this->cargo_filter_criteria]);
01055 if (0 == this->eng_list.Length()) {
01056 this->sel_engine = INVALID_ENGINE;
01057 } else if (!this->eng_list.Contains(this->sel_engine)) {
01058 this->sel_engine = this->eng_list[0];
01059 }
01060 }
01061
01063 bool FilterSingleEngine(EngineID eid)
01064 {
01065 CargoID filter_type = this->cargo_filter[this->cargo_filter_criteria];
01066 return (filter_type == CF_ANY || CargoFilter(&eid, filter_type));
01067 }
01068
01069
01070 void GenerateBuildTrainList()
01071 {
01072 EngineID sel_id = INVALID_ENGINE;
01073 int num_engines = 0;
01074 int num_wagons = 0;
01075
01076 this->filter.railtype = (this->listview_mode) ? RAILTYPE_END : GetRailType(this->window_number);
01077
01078 this->eng_list.Clear();
01079
01080
01081
01082
01083
01084 const Engine *e;
01085 FOR_ALL_ENGINES_OF_TYPE(e, VEH_TRAIN) {
01086 EngineID eid = e->index;
01087 const RailVehicleInfo *rvi = &e->u.rail;
01088
01089 if (this->filter.railtype != RAILTYPE_END && !HasPowerOnRail(rvi->railtype, this->filter.railtype)) continue;
01090 if (!IsEngineBuildable(eid, VEH_TRAIN, _local_company)) continue;
01091
01092
01093 if (!FilterSingleEngine(eid)) continue;
01094
01095 *this->eng_list.Append() = eid;
01096
01097 if (rvi->railveh_type != RAILVEH_WAGON) {
01098 num_engines++;
01099 } else {
01100 num_wagons++;
01101 }
01102
01103 if (eid == this->sel_engine) sel_id = eid;
01104 }
01105
01106 this->sel_engine = sel_id;
01107
01108
01109 _internal_sort_order = false;
01110 EngList_Sort(&this->eng_list, TrainEnginesThenWagonsSorter);
01111
01112
01113 _internal_sort_order = this->descending_sort_order;
01114 EngList_SortPartial(&this->eng_list, _sorter[0][this->sort_criteria], 0, num_engines);
01115
01116
01117 EngList_SortPartial(&this->eng_list, _sorter[0][this->sort_criteria], num_engines, num_wagons);
01118 }
01119
01120
01121 void GenerateBuildRoadVehList()
01122 {
01123 EngineID sel_id = INVALID_ENGINE;
01124
01125 this->eng_list.Clear();
01126
01127 const Engine *e;
01128 FOR_ALL_ENGINES_OF_TYPE(e, VEH_ROAD) {
01129 EngineID eid = e->index;
01130 if (!IsEngineBuildable(eid, VEH_ROAD, _local_company)) continue;
01131 if (!HasBit(this->filter.roadtypes, HasBit(EngInfo(eid)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD)) continue;
01132 *this->eng_list.Append() = eid;
01133
01134 if (eid == this->sel_engine) sel_id = eid;
01135 }
01136 this->sel_engine = sel_id;
01137 }
01138
01139
01140 void GenerateBuildShipList()
01141 {
01142 EngineID sel_id = INVALID_ENGINE;
01143 this->eng_list.Clear();
01144
01145 const Engine *e;
01146 FOR_ALL_ENGINES_OF_TYPE(e, VEH_SHIP) {
01147 EngineID eid = e->index;
01148 if (!IsEngineBuildable(eid, VEH_SHIP, _local_company)) continue;
01149 *this->eng_list.Append() = eid;
01150
01151 if (eid == this->sel_engine) sel_id = eid;
01152 }
01153 this->sel_engine = sel_id;
01154 }
01155
01156
01157 void GenerateBuildAircraftList()
01158 {
01159 EngineID sel_id = INVALID_ENGINE;
01160
01161 this->eng_list.Clear();
01162
01163 const Station *st = this->listview_mode ? NULL : Station::GetByTile(this->window_number);
01164
01165
01166
01167
01168
01169 const Engine *e;
01170 FOR_ALL_ENGINES_OF_TYPE(e, VEH_AIRCRAFT) {
01171 EngineID eid = e->index;
01172 if (!IsEngineBuildable(eid, VEH_AIRCRAFT, _local_company)) continue;
01173
01174 if (!this->listview_mode && !CanVehicleUseStation(eid, st)) continue;
01175
01176 *this->eng_list.Append() = eid;
01177 if (eid == this->sel_engine) sel_id = eid;
01178 }
01179
01180 this->sel_engine = sel_id;
01181 }
01182
01183
01184 void GenerateBuildList()
01185 {
01186 if (!this->eng_list.NeedRebuild()) return;
01187 switch (this->vehicle_type) {
01188 default: NOT_REACHED();
01189 case VEH_TRAIN:
01190 this->GenerateBuildTrainList();
01191 this->eng_list.Compact();
01192 this->eng_list.RebuildDone();
01193 return;
01194 case VEH_ROAD:
01195 this->GenerateBuildRoadVehList();
01196 break;
01197 case VEH_SHIP:
01198 this->GenerateBuildShipList();
01199 break;
01200 case VEH_AIRCRAFT:
01201 this->GenerateBuildAircraftList();
01202 break;
01203 }
01204
01205 this->FilterEngineList();
01206
01207 _internal_sort_order = this->descending_sort_order;
01208 EngList_Sort(&this->eng_list, _sorter[this->vehicle_type][this->sort_criteria]);
01209
01210 this->eng_list.Compact();
01211 this->eng_list.RebuildDone();
01212 }
01213
01214 void OnClick(Point pt, int widget, int click_count)
01215 {
01216 switch (widget) {
01217 case WID_BV_SORT_ASSENDING_DESCENDING:
01218 this->descending_sort_order ^= true;
01219 _last_sort_order[this->vehicle_type] = this->descending_sort_order;
01220 this->eng_list.ForceRebuild();
01221 this->SetDirty();
01222 break;
01223
01224 case WID_BV_LIST: {
01225 uint i = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_BV_LIST);
01226 size_t num_items = this->eng_list.Length();
01227 this->sel_engine = (i < num_items) ? this->eng_list[i] : INVALID_ENGINE;
01228 this->SetDirty();
01229 if (click_count > 1 && !this->listview_mode) this->OnClick(pt, WID_BV_BUILD, 1);
01230 break;
01231 }
01232
01233 case WID_BV_SORT_DROPDOWN: {
01234 uint32 hidden_mask = 0;
01235
01236 if (this->vehicle_type == VEH_ROAD &&
01237 _settings_game.vehicle.roadveh_acceleration_model == AM_ORIGINAL) {
01238 SetBit(hidden_mask, 3);
01239 SetBit(hidden_mask, 4);
01240 SetBit(hidden_mask, 8);
01241 }
01242
01243 if (this->vehicle_type == VEH_TRAIN &&
01244 _settings_game.vehicle.train_acceleration_model == AM_ORIGINAL) {
01245 SetBit(hidden_mask, 4);
01246 }
01247 ShowDropDownMenu(this, _sort_listing[this->vehicle_type], this->sort_criteria, WID_BV_SORT_DROPDOWN, 0, hidden_mask);
01248 break;
01249 }
01250
01251 case WID_BV_CARGO_FILTER_DROPDOWN:
01252 ShowDropDownMenu(this, this->cargo_filter_texts, this->cargo_filter_criteria, WID_BV_CARGO_FILTER_DROPDOWN, 0, 0);
01253 break;
01254
01255 case WID_BV_BUILD: {
01256 EngineID sel_eng = this->sel_engine;
01257 if (sel_eng != INVALID_ENGINE) {
01258 CommandCallback *callback = (this->vehicle_type == VEH_TRAIN && RailVehInfo(sel_eng)->railveh_type == RAILVEH_WAGON) ? CcBuildWagon : CcBuildPrimaryVehicle;
01259 DoCommandP(this->window_number, sel_eng, 0, GetCmdBuildVeh(this->vehicle_type), callback);
01260 }
01261 break;
01262 }
01263
01264 case WID_BV_RENAME: {
01265 EngineID sel_eng = this->sel_engine;
01266 if (sel_eng != INVALID_ENGINE) {
01267 this->rename_engine = sel_eng;
01268 SetDParam(0, sel_eng);
01269 ShowQueryString(STR_ENGINE_NAME, STR_QUERY_RENAME_TRAIN_TYPE_CAPTION + this->vehicle_type, MAX_LENGTH_ENGINE_NAME_CHARS, this, CS_ALPHANUMERAL, QSF_ENABLE_DEFAULT | QSF_LEN_IN_CHARS);
01270 }
01271 break;
01272 }
01273 }
01274 }
01275
01281 virtual void OnInvalidateData(int data = 0, bool gui_scope = true)
01282 {
01283 if (!gui_scope) return;
01284
01285 if (this->vehicle_type == VEH_ROAD &&
01286 _settings_game.vehicle.roadveh_acceleration_model == AM_ORIGINAL &&
01287 this->sort_criteria > 7) {
01288 this->sort_criteria = 0;
01289 _last_sort_criteria[VEH_ROAD] = 0;
01290 }
01291 this->eng_list.ForceRebuild();
01292 }
01293
01294 virtual void SetStringParameters(int widget) const
01295 {
01296 switch (widget) {
01297 case WID_BV_CAPTION:
01298 if (this->vehicle_type == VEH_TRAIN && !this->listview_mode) {
01299 const RailtypeInfo *rti = GetRailTypeInfo(this->filter.railtype);
01300 SetDParam(0, rti->strings.build_caption);
01301 } else {
01302 SetDParam(0, (this->listview_mode ? STR_VEHICLE_LIST_AVAILABLE_TRAINS : STR_BUY_VEHICLE_TRAIN_ALL_CAPTION) + this->vehicle_type);
01303 }
01304 break;
01305
01306 case WID_BV_SORT_DROPDOWN:
01307 SetDParam(0, _sort_listing[this->vehicle_type][this->sort_criteria]);
01308 break;
01309
01310 case WID_BV_CARGO_FILTER_DROPDOWN:
01311 SetDParam(0, this->cargo_filter_texts[this->cargo_filter_criteria]);
01312 }
01313 }
01314
01315 virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
01316 {
01317 switch (widget) {
01318 case WID_BV_LIST:
01319 resize->height = GetEngineListHeight(this->vehicle_type);
01320 size->height = 3 * resize->height;
01321 break;
01322
01323 case WID_BV_PANEL:
01324 size->height = this->details_height;
01325 break;
01326
01327 case WID_BV_SORT_ASSENDING_DESCENDING: {
01328 Dimension d = GetStringBoundingBox(this->GetWidget<NWidgetCore>(widget)->widget_data);
01329 d.width += padding.width + WD_SORTBUTTON_ARROW_WIDTH * 2;
01330 d.height += padding.height;
01331 *size = maxdim(*size, d);
01332 break;
01333 }
01334 }
01335 }
01336
01337 virtual void DrawWidget(const Rect &r, int widget) const
01338 {
01339 switch (widget) {
01340 case WID_BV_LIST:
01341 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);
01342 break;
01343
01344 case WID_BV_SORT_ASSENDING_DESCENDING:
01345 this->DrawSortButtonState(WID_BV_SORT_ASSENDING_DESCENDING, this->descending_sort_order ? SBS_DOWN : SBS_UP);
01346 break;
01347 }
01348 }
01349
01350 virtual void OnPaint()
01351 {
01352 this->GenerateBuildList();
01353 this->vscroll->SetCount(this->eng_list.Length());
01354
01355 this->DrawWidgets();
01356
01357 if (!this->IsShaded()) {
01358 int needed_height = this->details_height;
01359
01360 if (this->sel_engine != INVALID_ENGINE) {
01361 NWidgetBase *nwi = this->GetWidget<NWidgetBase>(WID_BV_PANEL);
01362 int text_end = DrawVehiclePurchaseInfo(nwi->pos_x + WD_FRAMETEXT_LEFT, nwi->pos_x + nwi->current_x - WD_FRAMETEXT_RIGHT,
01363 nwi->pos_y + WD_FRAMERECT_TOP, this->sel_engine);
01364 needed_height = max(needed_height, text_end - (int)nwi->pos_y + WD_FRAMERECT_BOTTOM);
01365 }
01366 if (needed_height != this->details_height) {
01367 int resize = needed_height - this->details_height;
01368 this->details_height = needed_height;
01369 this->ReInit(0, resize);
01370 return;
01371 }
01372 }
01373 }
01374
01375 virtual void OnQueryTextFinished(char *str)
01376 {
01377 if (str == NULL) return;
01378
01379 DoCommandP(0, this->rename_engine, 0, CMD_RENAME_ENGINE | CMD_MSG(STR_ERROR_CAN_T_RENAME_TRAIN_TYPE + this->vehicle_type), NULL, str);
01380 }
01381
01382 virtual void OnDropdownSelect(int widget, int index)
01383 {
01384 switch (widget) {
01385 case WID_BV_SORT_DROPDOWN:
01386 if (this->sort_criteria != index) {
01387 this->sort_criteria = index;
01388 _last_sort_criteria[this->vehicle_type] = this->sort_criteria;
01389 this->eng_list.ForceRebuild();
01390 }
01391 break;
01392
01393 case WID_BV_CARGO_FILTER_DROPDOWN:
01394 if (this->cargo_filter_criteria != index) {
01395 this->cargo_filter_criteria = index;
01396 _last_filter_criteria[this->vehicle_type] = this->cargo_filter[this->cargo_filter_criteria];
01397
01398 this->eng_list.SetFilterState(this->cargo_filter[this->cargo_filter_criteria] != CF_ANY);
01399 this->eng_list.ForceRebuild();
01400 }
01401 break;
01402 }
01403 this->SetDirty();
01404 }
01405
01406 virtual void OnResize()
01407 {
01408 this->vscroll->SetCapacityFromWidget(this, WID_BV_LIST);
01409 }
01410 };
01411
01412 static WindowDesc _build_vehicle_desc(
01413 WDP_AUTO, "build_vehicle", 240, 268,
01414 WC_BUILD_VEHICLE, WC_NONE,
01415 WDF_CONSTRUCTION,
01416 _nested_build_vehicle_widgets, lengthof(_nested_build_vehicle_widgets)
01417 );
01418
01419 void ShowBuildVehicleWindow(TileIndex tile, VehicleType type)
01420 {
01421
01422
01423
01424
01425 uint num = (tile == INVALID_TILE) ? (int)type : tile;
01426
01427 assert(IsCompanyBuildableVehicleType(type));
01428
01429 DeleteWindowById(WC_BUILD_VEHICLE, num);
01430
01431 new BuildVehicleWindow(&_build_vehicle_desc, tile, type);
01432 }