/* This order has a refit, if this is the first vehicle part carrying cargo and the whole vehicle is empty, try refitting. */

		if (front->current_order.IsRefit() && artic_part == 1 && IsArticulatedVehicleEmpty(v) &&

				(v->type != VEH_AIRCRAFT || (Aircraft::From(v)->IsNormalAircraft() && v->Next()->cargo.Count() == 0))) {

			Vehicle *v_start = v->GetFirstEnginePart();

			CargoID new_cid = front->current_order.GetRefitCargo();

			/* Remove old capacity from consist capacity */

			consist_capleft[v_start->cargo_type] -= v_start->cargo_cap;

			for (Vehicle *w = v_start; w->HasArticulatedPart(); ) {

				w = w->GetNextArticulatedPart();

				consist_capleft[w->cargo_type] -= w->cargo_cap;

				FOR_EACH_SET_CARGO_ID(cid, refit_mask) {

					/* Consider refitting to this cargo, if other vehicles of the consist cannot

					 * already take the cargo without refitting */

					if ((int)st->goods[cid].cargo.Count() > (int)consist_capleft[cid] + amount) {

						/* Try to find out if auto-refitting would succeed. In case the refit is allowed,

						 * the returned refit capacity will be greater than zero. */

						if (_returned_refit_capacity > 0) {

							amount = st->goods[cid].cargo.Count() - consist_capleft[cid];

							new_cid = cid;

						}

					}

				}

			}

			/* Refit if given a valid cargo. */

			if (new_cid < NUM_CARGO) {

				if (cost.Succeeded()) front->profit_this_year -= cost.GetCost() << 8;

				ge = &st->goods[v->cargo_type];

			}

			/* Add new capacity to consist capacity and reserve cargo */

			w = v_start;

	uint8 type;           ///< The type of order + non-stop flags

	uint8 flags;          ///< Load/unload types, depot order/action types.

	DestinationID dest;   ///< The destination of the order.

	CargoID refit_cargo;  ///< Refit CargoID

public:

	Order *next;          ///< Pointer to next order. If NULL, end of list

	uint16 wait_time;    ///< How long in ticks to wait at the destination.

	uint16 travel_time;  ///< How long in ticks the journey to this destination should take.

	 */

	inline OrderType GetType() const { return (OrderType)GB(this->type, 0, 4); }

	void Free();

	void MakeGoToStation(StationID destination);

	void MakeGoToWaypoint(StationID destination);

	void MakeLoading(bool ordered);

	void MakeLeaveStation();

	void MakeDummy();

	void MakeConditional(VehicleOrderID order);

	void MakeImplicit(StationID destination);

	 * Get the cargo to to refit to.

	 * @pre IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION)

	 * @return the cargo type.

	 */

	inline CargoID GetRefitCargo() const { return this->refit_cargo; }

	/** How must the consist be loaded? */

	inline OrderLoadFlags GetLoadType() const { return (OrderLoadFlags)GB(this->flags, 4, 4); }

	/** How must the consist be unloaded? */

	inline OrderUnloadFlags GetUnloadType() const { return (OrderUnloadFlags)GB(this->flags, 0, 4); }

	/** At which stations must we stop? */

 * Makes this order a Go To Depot order.

 * @param destination   the depot to go to.

 * @param order         is this order a 'default' order, or an overridden vehicle order?

 * @param non_stop_type how to get to the depot?

 * @param action        what to do in the depot?

 * @param cargo         the cargo type to change to.

 */

{

	this->type = OT_GOTO_DEPOT;

	this->SetDepotOrderType(order);

	this->SetDepotActionType(action);

	this->SetNonStopType(non_stop_type);

	this->dest = destination;

}

/**

 * Makes this order a Go To Waypoint order.

 * @param destination the waypoint to go to.

 */

	this->dest = destination;

}

/**

 * Make this depot/station order also a refit order.

 * @param cargo   the cargo type to change to.

 * @pre IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION).

 */

{

	this->refit_cargo = cargo;

}

/**

 * Does this order have the same type, flags and destination?

 * @param other the second order to compare to.

 * @return true if the type, flags and destination match.

{

	this->type    = (OrderType)GB(packed,  0,  8);

	this->flags   = GB(packed,  8,  8);

	this->dest    = GB(packed, 16, 16);

	this->next    = NULL;

	this->refit_cargo   = CT_NO_REFIT;

	this->wait_time     = 0;

	this->travel_time   = 0;

	this->max_speed     = UINT16_MAX;

}

/**

{

	this->type  = other.type;

	this->flags = other.flags;

	this->dest  = other.dest;

	this->refit_cargo   = other.refit_cargo;

	this->wait_time   = other.wait_time;

	this->travel_time = other.travel_time;

	this->max_speed   = other.max_speed;

}

 * Add/remove refit orders from an order

 * @param tile Not used

 * @param flags operation to perform

 * @param p1 VehicleIndex of the vehicle having the order

 * @param p2 bitmask

 *   - bit 0-7 CargoID

 *   - bit 16-23 number of order to modify

 * @param text unused

 * @return the cost of this operation or an error

 */

CommandCost CmdOrderRefit(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)

{

	VehicleID veh = GB(p1, 0, 20);

	VehicleOrderID order_number  = GB(p2, 16, 8);

	CargoID cargo = GB(p2, 0, 8);

	if (cargo >= NUM_CARGO && cargo != CT_NO_REFIT && cargo != CT_AUTO_REFIT) return CMD_ERROR;

	const Vehicle *v = Vehicle::GetIfValid(veh);

	if (v == NULL || !v->IsPrimaryVehicle()) return CMD_ERROR;

	/* Automatic refit cargo is only supported for goto station orders. */

	if (cargo == CT_AUTO_REFIT && !order->IsType(OT_GOTO_STATION)) return CMD_ERROR;

	if (order->GetLoadType() & OLFB_NO_LOAD) return CMD_ERROR;

	if (flags & DC_EXEC) {

		/* Make the depot order an 'always go' order. */

		if (cargo != CT_NO_REFIT && order->IsType(OT_GOTO_DEPOT)) {

			order->SetDepotOrderType((OrderDepotTypeFlags)(order->GetDepotOrderType() & ~ODTFB_SERVICE));

			order->SetDepotActionType((OrderDepotActionFlags)(order->GetDepotActionType() & ~ODATFB_HALT));

		}

		for (Vehicle *u = v->FirstShared(); u != NULL; u = u->NextShared()) {

			/* Update any possible open window of the vehicle */

			InvalidateVehicleOrder(u, VIWD_MODIFY_ORDERS);

			/* If the vehicle already got the current depot set as current order, then update current order as well */

			if (u->cur_real_order_index == order_number && (u->current_order.GetDepotOrderType() & ODTFB_PART_OF_ORDERS)) {

			}

		}

	}

	return CommandCost();

}

				if (v->FindClosestDepot(&location, &destination, &reverse)) {

					/* PBS reservations cannot reverse */

					if (pbs_look_ahead && reverse) return false;

					v->dest_tile = location;

					/* If there is no depot in front, reverse automatically (trains only) */

					if (v->type == VEH_TRAIN && reverse) DoCommand(v->tile, v->index, 0, DC_EXEC, CMD_REVERSE_TRAIN_DIRECTION);

					if (v->type == VEH_AIRCRAFT) {

						Aircraft *a = Aircraft::From(v);

	static const SaveLoad _order_desc[] = {

		     SLE_VAR(Order, type,           SLE_UINT8),

		     SLE_VAR(Order, flags,          SLE_UINT8),

		     SLE_VAR(Order, dest,           SLE_UINT16),

		     SLE_REF(Order, next,           REF_ORDER),

		 SLE_CONDVAR(Order, refit_cargo,    SLE_UINT8,   36, SL_MAX_VERSION),

		 SLE_CONDVAR(Order, wait_time,      SLE_UINT16,  67, SL_MAX_VERSION),

		 SLE_CONDVAR(Order, travel_time,    SLE_UINT16,  67, SL_MAX_VERSION),

		 SLE_CONDVAR(Order, max_speed,      SLE_UINT16, 172, SL_MAX_VERSION),

		/* Leftover from the minor savegame version stuff

		 * We will never use those free bytes, but we have to keep this line to allow loading of old savegames */

		 SLE_CONDVAR(Vehicle, current_order.type,    SLE_UINT8,                    5, SL_MAX_VERSION),

		 SLE_CONDVAR(Vehicle, current_order.flags,   SLE_UINT8,                    5, SL_MAX_VERSION),

		 SLE_CONDVAR(Vehicle, current_order.dest,    SLE_UINT16,                   5, SL_MAX_VERSION),

		/* Refit in current order */

		 SLE_CONDVAR(Vehicle, current_order.refit_cargo,   SLE_UINT8,             36, SL_MAX_VERSION),

		/* Timetable in current order */

		 SLE_CONDVAR(Vehicle, current_order.wait_time,     SLE_UINT16,            67, SL_MAX_VERSION),

		 SLE_CONDVAR(Vehicle, current_order.travel_time,   SLE_UINT16,            67, SL_MAX_VERSION),

		 SLE_CONDVAR(Vehicle, current_order.max_speed,     SLE_UINT16,           174, SL_MAX_VERSION),

		 SLE_CONDVAR(Vehicle, timetable_start,       SLE_INT32,                  129, SL_MAX_VERSION),

			/* We are heading for another depot, keep driving. */

			return;

		}

		if (t.IsRefit()) {

			Backup<CompanyByte> cur_company(_current_company, v->owner, FILE_LINE);

			cur_company.Restore();

			if (cost.Failed()) {

				_vehicles_to_autoreplace[v] = false;

				if (v->owner == _local_company) {

					/* Notify the user that we stopped the vehicle */

				/* Skip cargo type if it's not listed */

				if (!HasBit(cmask, cid)) {

					current_index++;

					continue;

				}

					/* Make a note of the original cargo type. It has to be

					 * changed to test the cargo & subtype... */

					CargoID temp_cargo = v->cargo_type;

					byte temp_subtype  = v->cargo_subtype;

					v->cargo_type = cid;

	}

	RefitWindow(const WindowDesc *desc, const Vehicle *v, VehicleOrderID order, bool auto_refit) : Window()

	{

		this->sel = -1;

		this->auto_refit = auto_refit;

		this->CreateNestedTree(desc);

		this->vscroll = this->GetScrollbar(WID_VR_SCROLLBAR);

		this->hscroll = (v->IsGroundVehicle() ? this->GetScrollbar(WID_VR_HSCROLLBAR) : NULL);

		this->GetWidget<NWidgetCore>(WID_VR_SELECT_HEADER)->tool_tip = STR_REFIT_TRAIN_LIST_TOOLTIP + v->type;

		this->GetWidget<NWidgetCore>(WID_VR_MATRIX)->tool_tip        = STR_REFIT_TRAIN_LIST_TOOLTIP + v->type;

		this->GetWidget<NWidgetStacked>(WID_VR_SHOW_HSCROLLBAR)->SetDisplayedPlane(v->IsGroundVehicle() ? 0 : SZSP_HORIZONTAL);

		this->GetWidget<NWidgetCore>(WID_VR_VEHICLE_PANEL_DISPLAY)->tool_tip = (v->type == VEH_TRAIN) ? STR_REFIT_SELECT_VEHICLES_TOOLTIP : STR_NULL;

		this->FinishInitNested(desc, v->index);

		this->owner = v->owner;

		this->SetWidgetDisabledState(WID_VR_REFIT, this->sel == -1);

	}

	virtual void OnInit()

	{

		if (this->cargo != NULL) {

					const Vehicle *v = Vehicle::Get(this->window_number);

					if (this->order == INVALID_VEH_ORDER_ID) {

						bool delete_window = this->selected_vehicle == v->index && this->num_vehicles == UINT8_MAX;

						if (DoCommandP(v->tile, this->selected_vehicle, this->cargo->cargo | this->cargo->subtype << 8 | this->num_vehicles << 16, GetCmdRefitVeh(v)) && delete_window) delete this;

					} else {

					}

				}

				break;

		}

	}

	_nested_vehicle_refit_widgets, lengthof(_nested_vehicle_refit_widgets)

);

/**

 * Show the refit window for a vehicle

 * @param *v The vehicle to show the refit window for

 * @param parent the parent window of the refit window

 * @param auto_refit Choose cargo for auto-refitting

 */

void ShowVehicleRefitWindow(const Vehicle *v, VehicleOrderID order, Window *parent, bool auto_refit)

{

	DeleteWindowById(WC_VEHICLE_REFIT, v->index);