/**

 * Retrieve the engine replacement in a given renewlist for an original engine type.

 * @param erl The renewlist to search in.

 * @param engine Engine type to be replaced.

 * @param group The group related to this replacement.

 * @return The engine type to replace with, or INVALID_ENGINE if no

 * replacement is in the list.

 */

{

	const EngineRenew *er = GetEngineReplacement(erl, engine, group);

	if (er == NULL && (group == DEFAULT_GROUP || (Group::IsValidID(group) && !Group::Get(group)->replace_protection))) {

		/* We didn't find anything useful in the vehicle's own group so we will try ALL_GROUP */

		er = GetEngineReplacement(erl, engine, ALL_GROUP);

	}

	return er == NULL ? INVALID_ENGINE : er->to;

}

/**

 * Add an engine replacement to the given renewlist.

 * @param erl The renewlist to add to.

 * @param old_engine The original engine type.

 * @param new_engine The replacement engine type.

 * @param group The group related to this replacement.

 * @param flags The calling command flags.

 * @return 0 on success, CMD_ERROR on failure.

 */

{

	/* Check if the old vehicle is already in the list */

	EngineRenew *er = GetEngineReplacement(*erl, old_engine, group);

	if (er != NULL) {

		if (flags & DC_EXEC) er->to = new_engine;

		return CommandCost();

	if (!EngineRenew::CanAllocateItem()) return CMD_ERROR;

	if (flags & DC_EXEC) {

		er = new EngineRenew(old_engine, new_engine);

		er->group_id = group;

		/* Insert before the first element */

		er->next = (EngineRenew *)(*erl);

		*erl = (EngineRenewList)er;

	}

 */

struct EngineRenew : EngineRenewPool::PoolItem<&_enginerenew_pool> {

	EngineID from;

	EngineID to;

	EngineRenew *next;

	GroupID group_id;

	EngineRenew(EngineID from = INVALID_ENGINE, EngineID to = INVALID_ENGINE) : from(from), to(to) {}

	~EngineRenew() {}

};

#define FOR_ALL_ENGINE_RENEWS_FROM(var, start) FOR_ALL_ITEMS_FROM(EngineRenew, enginerenew_index, var, start)

}

/**

 * Get the EngineID of the replacement for a vehicle

 * @param v The vehicle to find a replacement for

 * @param c The vehicle's owner (it's faster to forward the pointer than refinding it)

 * @param [out] e the EngineID of the replacement. INVALID_ENGINE if no replacement is found

 * @return Error if the engine to build is not available

 */

{

	assert(v->type != VEH_TRAIN || !v->IsArticulatedPart());

	e = INVALID_ENGINE;

	if (v->type == VEH_TRAIN && Train::From(v)->IsRearDualheaded()) {

		/* we build the rear ends of multiheaded trains with the front ones */

		return CommandCost();

	}

	/* Autoreplace, if engine is available */

	if (e != INVALID_ENGINE && IsEngineBuildable(e, v->type, _current_company)) {

		return CommandCost();

	}

{

	*new_vehicle = NULL;

	/* Shall the vehicle be replaced? */

	const Company *c = Company::Get(_current_company);

	EngineID e;

	if (cost.Failed()) return cost;

	if (e == INVALID_ENGINE) return CommandCost(); // neither autoreplace is set, nor autorenew is triggered

	/* Does it need to be refitted */

	CargoID refit_cargo = GetNewCargoTypeForReplace(old_veh, e, part_of_chain);

	if (refit_cargo == CT_INVALID) return CommandCost(); // incompatible cargoes

	/* Test whether any replacement is set, before issuing a whole lot of commands that would end in nothing changed */

	Vehicle *w = v;

	bool any_replacements = false;

	while (w != NULL) {

		EngineID e;

		if (cost.Failed()) return cost;

		any_replacements |= (e != INVALID_ENGINE);

		w = (!free_wagon && w->type == VEH_TRAIN ? Train::From(w)->GetNextUnit() : NULL);

	}

	CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);

/**

 * Change engine renewal parameters

 * @param tile unused

 * @param flags operation to perform

 * @param p1 packed data

 *   - bits 16-31 = engine group

 * @param p2 packed data

 *   - bits  0-15 = old engine type

 *   - bits 16-31 = new engine type

 * @param text unused

 * @return the cost of this operation or an error

	if (!Engine::IsValidID(old_engine_type)) return CMD_ERROR;

	if (new_engine_type != INVALID_ENGINE) {

		if (!Engine::IsValidID(new_engine_type)) return CMD_ERROR;

		if (!CheckAutoreplaceValidity(old_engine_type, new_engine_type, _current_company)) return CMD_ERROR;

	} else {

		cost = RemoveEngineReplacementForCompany(c, old_engine_type, id_g, flags);

	}

	if (flags & DC_EXEC) GroupStatistics::UpdateAutoreplace(_current_company);

	if ((flags & DC_EXEC) && IsLocalCompany()) InvalidateAutoreplaceWindow(old_engine_type, id_g);

#define AUTOREPLACE_FUNC_H

#include "command_type.h"

#include "company_base.h"

void RemoveAllEngineReplacement(EngineRenewList *erl);

CommandCost RemoveEngineReplacement(EngineRenewList *erl, EngineID engine, GroupID group, DoCommandFlag flags);

/**

 * Remove all engine replacement settings for the given company.

 * @param c the company.

 */

/**

 * Retrieve the engine replacement for the given company and original engine type.

 * @param c company.

 * @param engine Engine type.

 * @param group The group related to this replacement.

 * @return The engine type to replace with, or INVALID_ENGINE if no

 * replacement is in the list.

 */

{

}

/**

 * Check if a company has a replacement set up for the given engine.

 * @param c Company.

 * @param engine Engine type to be replaced.

static inline bool EngineHasReplacementForCompany(const Company *c, EngineID engine, GroupID group)

{

	return EngineReplacementForCompany(c, engine, group) != INVALID_ENGINE;

}

/**

 * Add an engine replacement for the company.

 * @param c Company.

 * @param old_engine The original engine type.

 * @param new_engine The replacement engine type.

 * @param group The group related to this replacement.

 * @param flags The calling command flags.

 * @return 0 on success, CMD_ERROR on failure.

 */

{

}

/**

 * Remove an engine replacement for the company.

 * @param c Company.

 * @param engine The original engine type.

#include "engine_base.h"

#include "window_gui.h"

#include "engine_gui.h"

#include "settings_func.h"

#include "core/geometry_func.hpp"

#include "rail_gui.h"

#include "widgets/autoreplace_widget.h"

uint GetEngineListHeight(VehicleType type);

void DrawEngineList(VehicleType type, int x, int r, int y, const GUIEngineList *eng_list, uint16 min, uint16 max, EngineID selected_id, bool show_count, GroupID selected_group);

void AddRemoveEngineFromAutoreplaceAndBuildWindows(VehicleType type)

{

	InvalidateWindowData(WC_REPLACE_VEHICLE, type, 0); // Update the autoreplace window

	InvalidateWindowClassesData(WC_BUILD_VEHICLE); // The build windows needs updating as well

}

/**

 * Window for the autoreplacing of vehicles.

 */

class ReplaceVehicleWindow : public Window {

	EngineID sel_engine[2];       ///< Selected engine left and right.

	GUIEngineList engines[2];     ///< Left and right list of engines.

		/* Reset the flags about needed updates */

		this->engines[0].RebuildDone();

		this->engines[1].RebuildDone();

		this->reset_sel_engine = false;

	}

public:

	ReplaceVehicleWindow(const WindowDesc *desc, VehicleType vehicletype, GroupID id_g) : Window()

	{

		if (vehicletype == VEH_TRAIN) {

			/* For rail vehicles find the most used vehicle type, which is usually

			 * better than 'just' the first/previous vehicle type. */

				}

				d.width += padding.width;

				d.height += padding.height;

				*size = maxdim(*size, d);

				break;

			}

		}

	}

	virtual void SetStringParameters(int widget) const

	{

		switch (widget) {

			case WID_RV_INFO_TAB: {

				const Company *c = Company::Get(_local_company);

				if (this->sel_engine[0] != INVALID_ENGINE) {

					if (!EngineHasReplacementForCompany(c, this->sel_engine[0], this->sel_group)) {

						SetDParam(0, STR_REPLACE_NOT_REPLACING);

					} else {

					}

				} else {

					SetDParam(0, STR_REPLACE_NOT_REPLACING_VEHICLE_SELECTED);

				}

				DrawString(r.left + WD_FRAMETEXT_LEFT, r.right - WD_FRAMETEXT_RIGHT, r.top + WD_FRAMERECT_TOP, STR_BLACK_STRING, TC_FROMSTRING, SA_HOR_CENTER);

		if (this->engines[0].NeedRebuild() || this->engines[1].NeedRebuild()) this->GenerateLists();

		Company *c = Company::Get(_local_company);

		/* Disable the "Start Replacing" button if:

		 *    Either engines list is empty

		this->SetWidgetDisabledState(WID_RV_START_REPLACE,

										this->sel_engine[0] == INVALID_ENGINE ||

										this->sel_engine[1] == INVALID_ENGINE ||

		/* Disable the "Stop Replacing" button if:

		 *   The left engines list (existing vehicle) is empty

		 *   or The selected vehicle has no replacement set up */

		this->SetWidgetDisabledState(WID_RV_STOP_REPLACE,

										this->sel_engine[0] == INVALID_ENGINE ||

										!EngineHasReplacementForCompany(c, this->sel_engine[0], this->sel_group));

		if (this->window_number == VEH_TRAIN) {

			/* sets the colour of that art thing */

			this->GetWidget<NWidgetCore>(WID_RV_TRAIN_FLUFF_LEFT)->colour  = _company_colours[_local_company];

			this->GetWidget<NWidgetCore>(WID_RV_TRAIN_FLUFF_RIGHT)->colour = _company_colours[_local_company];

			/* Show the selected railtype in the pulldown menu */

			case WID_RV_TRAIN_WAGONREMOVE_TOGGLE: // toggle renew_keep_length

				DoCommandP(0, GetCompanySettingIndex("company.renew_keep_length"), Company::Get(_local_company)->settings.renew_keep_length ? 0 : 1, CMD_CHANGE_COMPANY_SETTING);

				break;

			case WID_RV_START_REPLACE: { // Start replacing

				break;

			}

			case WID_RV_STOP_REPLACE: { // Stop replacing

				EngineID veh_from = this->sel_engine[0];

				DoCommandP(0, this->sel_group << 16, veh_from + (INVALID_ENGINE << 16), CMD_SET_AUTOREPLACE);

			}

		}

	}

	virtual void OnDropdownSelect(int widget, int index)

	{

	}

	virtual void OnResize()

	{

		this->vscroll[0]->SetCapacityFromWidget(this, WID_RV_LEFT_MATRIX);

		this->vscroll[1]->SetCapacityFromWidget(this, WID_RV_RIGHT_MATRIX);

	EndContainer(),

	NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),

		NWidget(WWT_PANEL, COLOUR_GREY, WID_RV_LEFT_DETAILS), SetMinimalSize(228, 102), SetResize(1, 0), EndContainer(),

		NWidget(WWT_PANEL, COLOUR_GREY, WID_RV_RIGHT_DETAILS), SetMinimalSize(228, 102), SetResize(1, 0), EndContainer(),

	EndContainer(),

	NWidget(NWID_HORIZONTAL),

		NWidget(WWT_PANEL, COLOUR_GREY, WID_RV_INFO_TAB), SetMinimalSize(167, 12), SetDataTip(0x0, STR_REPLACE_HELP_REPLACE_INFO_TAB), SetResize(1, 0),

		EndContainer(),

		NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_RV_STOP_REPLACE), SetMinimalSize(150, 12), SetDataTip(STR_REPLACE_VEHICLES_STOP, STR_REPLACE_HELP_STOP_BUTTON),

	EndContainer(),

	NWidget(NWID_HORIZONTAL),

		NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_RV_TRAIN_ENGINEWAGON_TOGGLE), SetMinimalSize(139, 12), SetDataTip(STR_REPLACE_ENGINE_WAGON_SELECT, STR_REPLACE_ENGINE_WAGON_SELECT_HELP),

	EndContainer(),

	NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),

		NWidget(WWT_PANEL, COLOUR_GREY, WID_RV_LEFT_DETAILS), SetMinimalSize(228, 92), SetResize(1, 0), EndContainer(),

		NWidget(WWT_PANEL, COLOUR_GREY, WID_RV_RIGHT_DETAILS), SetMinimalSize(228, 92), SetResize(1, 0), EndContainer(),

	EndContainer(),

	NWidget(NWID_HORIZONTAL),

		NWidget(WWT_PANEL, COLOUR_GREY, WID_RV_INFO_TAB), SetMinimalSize(167, 12), SetDataTip(0x0, STR_REPLACE_HELP_REPLACE_INFO_TAB), SetResize(1, 0), EndContainer(),

		NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_RV_STOP_REPLACE), SetMinimalSize(138, 12), SetDataTip(STR_REPLACE_VEHICLES_STOP, STR_REPLACE_HELP_STOP_BUTTON),

		NWidget(WWT_RESIZEBOX, COLOUR_GREY),

	EndContainer(),

};

STR_REPLACE_VEHICLE_AIRCRAFT                                    :Aircraft

STR_REPLACE_HELP_LEFT_ARRAY                                     :{BLACK}Select the engine type to replace

STR_REPLACE_HELP_RIGHT_ARRAY                                    :{BLACK}Select the new engine type you would like to use in place of the left selected engine type

STR_REPLACE_VEHICLES_START                                      :{BLACK}Start Replacing Vehicles

STR_REPLACE_HELP_START_BUTTON                                   :{BLACK}Press to begin replacement of the left selected engine type with the right selected engine type

STR_REPLACE_NOT_REPLACING                                       :{BLACK}Not replacing

STR_REPLACE_NOT_REPLACING_VEHICLE_SELECTED                      :{BLACK}No vehicle selected

STR_REPLACE_VEHICLES_STOP                                       :{BLACK}Stop Replacing Vehicles

STR_REPLACE_HELP_STOP_BUTTON                                    :{BLACK}Press to stop the replacement of the engine type selected on the left

STR_REPLACE_ENGINE_WAGON_SELECT                                 :{BLACK}Replacing: {ORANGE}{STRING}

STR_REPLACE_ENGINE_WAGON_SELECT_HELP                            :{BLACK}Switch between engine and wagon replacement windows

STR_REPLACE_ENGINES                                             :Engines

static const SaveLoad _engine_renew_desc[] = {

	    SLE_VAR(EngineRenew, from,     SLE_UINT16),

	    SLE_VAR(EngineRenew, to,       SLE_UINT16),

	    SLE_REF(EngineRenew, next,     REF_ENGINE_RENEWS),

	SLE_CONDVAR(EngineRenew, group_id, SLE_UINT16, 60, SL_MAX_VERSION),

	SLE_END()

};

static void Save_ERNW()

{

	EngineRenew *er;

 *  169   23816

 *  170   23826

 *  171   23835

 *  172   23947

 *  173   23967   1.2.0-RC1

 *  174   23973   1.2.x

 */

SavegameType _savegame_type; ///< type of savegame we are loading

uint32 _ttdp_version;     ///< version of TTDP savegame (if applicable)

uint16 _sl_version;       ///< the major savegame version identifier

byte   _sl_minor_version; ///< the minor savegame version, DO NOT USE!

VehiclePool _vehicle_pool("Vehicle");

INSTANTIATE_POOL_METHODS(Vehicle)

/**

 * Function to tell if a vehicle needs to be autorenewed

 * @param *c The vehicle owner

 * @return true if the vehicle is old enough for replacement

 */

{

	/* We can always generate the Company pointer when we have the vehicle.

	 * However this takes time and since the Company pointer is often present

	 * when this function is called then it's faster to pass the pointer as an

	 * argument rather than finding it again. */

	assert(c == Company::Get(this->owner));

	if (this->age - this->max_age < (c->settings.engine_renew_months * 30)) return false;

	/* Only engines need renewing */

	if (this->type == VEH_TRAIN && !Train::From(this)->IsEngine()) return false;

	return true;

	 * There are a lot more reasons for autoreplace to fail than we can test here reasonably. */

	bool pending_replace = false;

	Money needed_money = c->settings.engine_renew_money;

	if (needed_money > c->money) return false;

	for (const Vehicle *v = this; v != NULL; v = (v->type == VEH_TRAIN) ? Train::From(v)->GetNextUnit() : NULL) {

		/* Check engine availability */

		if (new_engine == INVALID_ENGINE || !HasBit(Engine::Get(new_engine)->company_avail, v->owner)) continue;

		/* Check refittability */

		uint32 available_cargo_types, union_mask;

		GetArticulatedRefitMasks(new_engine, true, &union_mask, &available_cargo_types);

		/* Is there anything to refit? */

		if (union_mask != 0) {

		this->service_interval = src->service_interval;

	}

	bool HandleBreakdown();

	bool NeedsServicing() const;

	bool NeedsAutomaticServicing() const;

	/**

	 * Determine the location for the station where the vehicle goes to next.

		case WWT_PUSHTXTBTN:

		case WWT_TEXTBTN_2:

		case WWT_LABEL:

		case WWT_TEXT:

		case WWT_MATRIX:

		case NWID_BUTTON_DROPDOWN:

		case WWT_ARROWBTN:

		case WWT_PUSHARROWBTN:

			this->SetFill(0, 0);

			break;

		case WWT_EDITBOX:

			d2.width += extra.width;

			d2.height += extra.height;

			size = maxdim(size, d2);

			break;

		}

		case WWT_DROPDOWN:

			static const Dimension extra = {WD_DROPDOWNTEXT_LEFT + WD_DROPDOWNTEXT_RIGHT, WD_DROPDOWNTEXT_TOP + WD_DROPDOWNTEXT_BOTTOM};

			padding = &extra;

			if (this->index >= 0) w->SetStringParameters(this->index);

			Dimension d2 = GetStringBoundingBox(this->widget_data);

			d2.width += extra.width;

			d2.height += extra.height;

		case WWT_DROPDOWN:

			if (this->index >= 0) w->SetStringParameters(this->index);

			DrawDropdown(r, this->colour, clicked, this->widget_data);

			break;

		case NWID_BUTTON_DROPDOWN:

			if (this->index >= 0) w->SetStringParameters(this->index);

			DrawButtonDropdown(r, this->colour, clicked, (this->disp_flags & ND_DROPDOWN_ACTIVE) != 0, this->widget_data);

			break;

		default:

			NOT_REACHED();

				*biggest_index = max(*biggest_index, (int)parts->u.widget.index);

				break;

			}

			default:

				if (*dest != NULL) return num_used;

				*dest = new NWidgetLeaf(parts->type, parts->u.widget.colour, parts->u.widget.index, 0x0, STR_NULL);

				*biggest_index = max(*biggest_index, (int)parts->u.widget.index);

				break;

		}

		num_used++;

		parts++;

	WWB_PUSHBUTTON    = 1 << 7,

	WWT_PUSHBTN       = WWT_PANEL    | WWB_PUSHBUTTON,

	WWT_PUSHTXTBTN    = WWT_TEXTBTN  | WWB_PUSHBUTTON,

	WWT_PUSHIMGBTN    = WWT_IMGBTN   | WWB_PUSHBUTTON,

	WWT_PUSHARROWBTN  = WWT_ARROWBTN | WWB_PUSHBUTTON,

};

/** Different forms of sizing nested widgets, using NWidgetBase::AssignSizePosition() */

enum SizingType {

	ST_SMALLEST, ///< Initialize nested widget tree to smallest size. Also updates \e current_x and \e current_y.

	ST_RESIZE,   ///< Resize the nested widget tree.

	~DropdownWindow()

	{

		Window *w2 = FindWindowById(this->parent_wnd_class, this->parent_wnd_num);

		if (w2 != NULL) {

			if (w2->nested_array != NULL) {

				NWidgetCore *nwi2 = w2->GetWidget<NWidgetCore>(this->parent_button);

					nwi2->disp_flags &= ~ND_DROPDOWN_ACTIVE;

				} else {

					w2->RaiseWidget(this->parent_button);

				}

			} else {

				w2->RaiseWidget(this->parent_button);

	wi_rect.left   = nwi->pos_x;

	wi_rect.right  = nwi->pos_x + nwi->current_x - 1;

	wi_rect.top    = nwi->pos_y;

	wi_rect.bottom = nwi->pos_y + nwi->current_y - 1;

	wi_colour = nwi->colour;

		nwi->disp_flags |= ND_DROPDOWN_ACTIVE;

	} else {

		w->LowerWidget(button);

	}

	w->SetWidgetDirty(button);

 * Raise the buttons of the window.

 * @param autoraise Raise only the push buttons of the window.

 */

void Window::RaiseButtons(bool autoraise)

{

	for (uint i = 0; i < this->nested_array_size; i++) {

				(!autoraise || (this->nested_array[i]->type & WWB_PUSHBUTTON)) && this->IsWidgetLowered(i)) {

			this->RaiseWidget(i);

			this->SetWidgetDirty(i);

		}

	}

}