Index: src/economy.cpp
===================================================================
--- src/economy.cpp	(revision 25285)
+++ src/economy.cpp	(working copy)
@@ -1343,7 +1343,7 @@
 	bool use_autorefit = front->current_order.IsRefit() && front->current_order.GetRefitCargo() == CT_AUTO_REFIT;
 	CargoArray consist_capleft;
 	if (_settings_game.order.improved_load &&
-			((front->current_order.GetLoadType() & OLFB_FULL_LOAD) != 0 || use_autorefit)) {
+			(IsWaitOrder(front->current_order.GetLoadType()) || use_autorefit)) {
 		ReserveConsist(st, front, (use_autorefit && front->load_unload_ticks != 0) ? &consist_capleft : NULL);
 	}
 
@@ -1434,7 +1434,7 @@
 		}
 
 		/* Do not pick up goods when we have no-load set or loading is stopped. */
-		if (front->current_order.GetLoadType() & OLFB_NO_LOAD || HasBit(front->vehicle_flags, VF_STOP_LOADING)) continue;
+		if (IsNoLoadOrder(front->current_order.GetLoadType()) || HasBit(front->vehicle_flags, VF_STOP_LOADING)) continue;
 
 		/* 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) &&
@@ -1598,14 +1598,31 @@
 		}
 		/* We loaded less cargo than possible for all cargo types and it's not full
 		 * load and we're not supposed to wait any longer: stop loading. */
-		if (!anything_unloaded && full_load_amount == 0 && reservation_left == 0 && !(front->current_order.GetLoadType() & OLFB_FULL_LOAD) &&
+		if (!anything_unloaded && full_load_amount == 0 && reservation_left == 0 && !IsWaitOrder(front->current_order.GetLoadType()) &&
 				front->current_order_time >= (uint)max(front->current_order.wait_time - front->lateness_counter, 0)) {
 			SetBit(front->vehicle_flags, VF_STOP_LOADING);
 		}
 	} else {
 		bool finished_loading = true;
-		if (front->current_order.GetLoadType() & OLFB_FULL_LOAD) {
-			if (front->current_order.GetLoadType() == OLF_FULL_LOAD_ANY) {
+		OrderLoadFlags load_type = front->current_order.GetLoadType();
+		if (load_type > OLFB_NO_LOAD && cargo_not_full != 0) {
+			switch (load_type) {
+			case OLF_LOAD_PERCENT: {
+				unsigned int cargo_stored = front->GetConsistTotalStored();
+				unsigned int cargo_max = front->GetConsistTotalCapacity();
+				unsigned int cargo_target = cargo_max * front->current_order.GetLoadArg() / 100;
+				
+				if (cargo_stored < cargo_target) finished_loading = false;
+				} break;
+				
+			case OLF_LOAD_UNITS:
+				if (front->GetConsistTotalStored() < front->current_order.GetLoadArg()) finished_loading = false;
+				break;
+				
+			default: break;
+			}
+		} else if (load_type & OLFB_FULL_LOAD) {
+			if (load_type == OLF_FULL_LOAD_ANY) {
 				/* if the aircraft carries passengers and is NOT full, then
 				 * continue loading, no matter how much mail is in */
 				if ((front->type == VEH_AIRCRAFT && IsCargoInClass(front->cargo_type, CC_PASSENGERS) && front->cargo_cap > front->cargo.StoredCount()) ||
Index: src/lang/english.txt
===================================================================
--- src/lang/english.txt	(revision 25285)
+++ src/lang/english.txt	(working copy)
@@ -3569,6 +3569,10 @@
 STR_ORDER_DROP_UNLOAD                                           :Unload all
 STR_ORDER_DROP_TRANSFER                                         :Transfer
 STR_ORDER_DROP_NO_UNLOADING                                     :No unloading
+STR_ORDER_DROP_SOME_LOAD                                        :Wait for some cargo
+STR_ORDER_DROP_25_LOAD                                          :Wait for 25% load
+STR_ORDER_DROP_50_LOAD                                          :Wait for 50% load
+STR_ORDER_DROP_75_LOAD                                          :Wait for 75% load
 STR_ORDER_TOOLTIP_UNLOAD                                        :{BLACK}Change the unloading behaviour of the highlighted order
 
 STR_ORDER_REFIT                                                 :{BLACK}Refit
@@ -3652,31 +3656,47 @@
 STR_ORDER_FULL_LOAD                                             :(Full load)
 STR_ORDER_FULL_LOAD_ANY                                         :(Full load any cargo)
 STR_ORDER_NO_LOAD                                               :(No loading)
+STR_ORDER_UNITS_LOAD                                            :(Wait for {WEIGHT_LONG} of cargo)
+STR_ORDER_PERCENT_LOAD                                          :(Wait for {NUM}% cargo)
 STR_ORDER_UNLOAD                                                :(Unload and take cargo)
 STR_ORDER_UNLOAD_FULL_LOAD                                      :(Unload and wait for full load)
 STR_ORDER_UNLOAD_FULL_LOAD_ANY                                  :(Unload and wait for any full load)
 STR_ORDER_UNLOAD_NO_LOAD                                        :(Unload and leave empty)
+STR_ORDER_UNLOAD_UNITS_LOAD                                     :(Unload and wait for {WEIGHT_LONG} of cargo)
+STR_ORDER_UNLOAD_PERCENT_LOAD                                   :(Unload and wait for {NUM}% cargo)
 STR_ORDER_TRANSFER                                              :(Transfer and take cargo)
 STR_ORDER_TRANSFER_FULL_LOAD                                    :(Transfer and wait for full load)
 STR_ORDER_TRANSFER_FULL_LOAD_ANY                                :(Transfer and wait for any full load)
 STR_ORDER_TRANSFER_NO_LOAD                                      :(Transfer and leave empty)
+STR_ORDER_TRANSFER_UNITS_LOAD                                   :(Transfer and wait for {WEIGHT_LONG} of cargo)
+STR_ORDER_TRANSFER_PERCENT_LOAD                                 :(Transfer and wait for {NUM}% cargo)
 STR_ORDER_NO_UNLOAD                                             :(No unloading and take cargo)
 STR_ORDER_NO_UNLOAD_FULL_LOAD                                   :(No unloading and wait for full load)
 STR_ORDER_NO_UNLOAD_FULL_LOAD_ANY                               :(No unloading and wait for any full load)
 STR_ORDER_NO_UNLOAD_NO_LOAD                                     :(No unloading and no loading)
+STR_ORDER_NO_UNLOAD_UNITS_LOAD                                  :(No unloading and wait for {WEIGHT_LONG} of cargo)
+STR_ORDER_NO_UNLOAD_PERCENT_LOAD                                :(No unloading and wait for {NUM}% of cargo)
 
 STR_ORDER_AUTO_REFIT                                            :(Auto-refit to {STRING})
 STR_ORDER_FULL_LOAD_REFIT                                       :(Full load with auto-refit to {STRING})
 STR_ORDER_FULL_LOAD_ANY_REFIT                                   :(Full load any cargo with auto-refit to {STRING})
+STR_ORDER_UNITS_LOAD_REFIT                                      :(Wait for {WEIGHT_LONG} of cargo with auto-refit to {STRING})
+STR_ORDER_PERCENT_LOAD_REFIT                                    :(Wait for {NUM}% cargo with auto-refit to {STRING})
 STR_ORDER_UNLOAD_REFIT                                          :(Unload and take cargo with auto-refit to {STRING})
 STR_ORDER_UNLOAD_FULL_LOAD_REFIT                                :(Unload and wait for full load with auto-refit to {STRING})
 STR_ORDER_UNLOAD_FULL_LOAD_ANY_REFIT                            :(Unload and wait for any full load with auto-refit to {STRING})
+STR_ORDER_UNLOAD_UNITS_LOAD_REFIT                               :(Unload and wait for {WEIGHT_LONG} of cargo with auto-refit to {STRING})
+STR_ORDER_UNLOAD_PERCENT_LOAD_REFIT                             :(Unload and wait for {NUM}% cargo with auto-refit to {STRING})
 STR_ORDER_TRANSFER_REFIT                                        :(Transfer and take cargo with auto-refit to {STRING})
 STR_ORDER_TRANSFER_FULL_LOAD_REFIT                              :(Transfer and wait for full load with auto-refit to {STRING})
 STR_ORDER_TRANSFER_FULL_LOAD_ANY_REFIT                          :(Transfer and wait for any full load with auto-refit to {STRING})
+STR_ORDER_TRANSFER_UNITS_LOAD_REFIT                             :(Transfer and wait for {WEIGHT_LONG} of cargo with auto-refit to {STRING})
+STR_ORDER_TRANSFER_PERCENT_LOAD_REFIT                           :(Transfer and wait for {NUM}% cargo with auto-refit to {STRING})
 STR_ORDER_NO_UNLOAD_REFIT                                       :(No unloading and take cargo with auto-refit to {STRING})
 STR_ORDER_NO_UNLOAD_FULL_LOAD_REFIT                             :(No unloading and wait for full load with auto-refit to {STRING})
 STR_ORDER_NO_UNLOAD_FULL_LOAD_ANY_REFIT                         :(No unloading and wait for any full load with auto-refit to {STRING})
+STR_ORDER_NO_UNLOAD_UNITS_LOAD_REFIT                            :(No unloading and wait for {WEIGHT_LONG} of cargo with auto-refit to {STRING})
+STR_ORDER_NO_UNLOAD_PERCENT_LOAD_REFIT                          :(No unloading and wait for {NUM}% of cargo with auto-refit to {STRING})
 
 STR_ORDER_AUTO_REFIT_ANY                                        :available cargo
 
Index: src/order_base.h
===================================================================
--- src/order_base.h	(revision 25285)
+++ src/order_base.h	(working copy)
@@ -39,6 +39,7 @@
 
 	uint8 type;           ///< The type of order + non-stop flags
 	uint8 flags;          ///< Load/unload types, depot order/action types.
+	uint8 load_arg;       ///< Argument to load type, for load by units/percent.
 	DestinationID dest;   ///< The destination of the order.
 
 	CargoID refit_cargo;  ///< Refit CargoID
@@ -127,6 +128,8 @@
 
 	/** How must the consist be loaded? */
 	inline OrderLoadFlags GetLoadType() const { return (OrderLoadFlags)GB(this->flags, 4, 4); }
+	/** Argument to load type, for load by units/percent. */
+	inline uint8 GetLoadArg() const { return this->load_arg; }
 	/** How must the consist be unloaded? */
 	inline OrderUnloadFlags GetUnloadType() const { return (OrderUnloadFlags)GB(this->flags, 0, 4); }
 	/** At which stations must we stop? */
@@ -148,6 +151,8 @@
 
 	/** Set how the consist must be loaded. */
 	inline void SetLoadType(OrderLoadFlags load_type) { SB(this->flags, 4, 4, load_type); }
+	/** Set argument to load type, for load by units/percent. */
+	inline void SetLoadArg(uint8 arg) { this->load_arg = arg; }
 	/** Set how the consist must be unloaded. */
 	inline void SetUnloadType(OrderUnloadFlags unload_type) { SB(this->flags, 0, 4, unload_type); }
 	/** Set whether we must stop at stations or not. */
Index: src/order_cmd.cpp
===================================================================
--- src/order_cmd.cpp	(revision 25285)
+++ src/order_cmd.cpp	(working copy)
@@ -62,6 +62,7 @@
 {
 	this->type  = OT_NOTHING;
 	this->flags = 0;
+	this->load_arg = 0;
 	this->dest  = 0;
 	this->next  = NULL;
 }
@@ -184,7 +185,11 @@
 				(this->GetDepotActionType() & ~ODATFB_NEAREST_DEPOT) == (other.GetDepotActionType() & ~ODATFB_NEAREST_DEPOT);
 	}
 
-	return this->type == other.type && this->flags == other.flags && this->dest == other.dest;
+	return
+			this->type  == other.type &&
+			this->flags == other.flags &&
+			this->load_arg == other.load_arg &&
+			this->dest  == other.dest;
 }
 
 /**
@@ -233,6 +238,7 @@
 {
 	this->type    = (OrderType)GB(packed,  0,  8);
 	this->flags   = GB(packed,  8,  8);
+	this->load_arg = 0;
 	this->dest    = GB(packed, 16, 16);
 	this->next    = NULL;
 	this->refit_cargo   = CT_NO_REFIT;
@@ -272,6 +278,7 @@
 {
 	this->type  = other.type;
 	this->flags = other.flags;
+	this->load_arg = other.load_arg;
 	this->dest  = other.dest;
 
 	this->refit_cargo   = other.refit_cargo;
@@ -729,9 +736,12 @@
 			/* Non stop only allowed for ground vehicles. */
 			if (new_order.GetNonStopType() != ONSF_STOP_EVERYWHERE && !v->IsGroundVehicle()) return CMD_ERROR;
 
+			/* No load and no unload are mutual exclusive. */
+			if (IsNoLoadOrder(new_order.GetLoadType()) && (new_order.GetUnloadType() & OUFB_NO_UNLOAD)) return CMD_ERROR;
+
 			/* Filter invalid load/unload types. */
 			switch (new_order.GetLoadType()) {
-				case OLF_LOAD_IF_POSSIBLE: case OLFB_FULL_LOAD: case OLF_FULL_LOAD_ANY: case OLFB_NO_LOAD: break;
+				case OLF_LOAD_IF_POSSIBLE: case OLFB_FULL_LOAD: case OLF_FULL_LOAD_ANY: case OLFB_NO_LOAD: case OLF_LOAD_PERCENT: break;
 				default: return CMD_ERROR;
 			}
 			switch (new_order.GetUnloadType()) {
@@ -1264,6 +1274,7 @@
 	VehicleID veh          = GB(p1,  0, 20);
 	ModifyOrderFlags mof   = Extract<ModifyOrderFlags, 0, 4>(p2);
 	uint16 data            = GB(p2,  4, 11);
+	uint8 arg              = 0;
 
 	if (mof >= MOF_END) return CMD_ERROR;
 
@@ -1320,8 +1331,31 @@
 			break;
 
 		case MOF_LOAD:
-			if (data > OLFB_NO_LOAD || data == 1) return CMD_ERROR;
-			if (data == order->GetLoadType()) return CMD_ERROR;
+			if (data > OLD_75_LOAD || data == 1) return CMD_ERROR;
+			switch (data) {
+				case OLD_SOME_LOAD:
+					data = OLF_LOAD_UNITS;
+					arg = 1;
+					break;
+					
+				case OLD_25_LOAD:
+					data = OLF_LOAD_PERCENT;
+					arg = 25;
+					break;
+				
+				case OLD_50_LOAD:
+					data = OLF_LOAD_PERCENT;
+					arg = 50;
+					break;
+				
+				case OLD_75_LOAD:
+					data = OLF_LOAD_PERCENT;
+					arg = 75;
+					break;
+					
+				default: break;
+			}
+			if (data == order->GetLoadType() && arg == order->GetLoadArg()) return CMD_ERROR;
 			break;
 
 		case MOF_DEPOT_ACTION:
@@ -1380,10 +1414,18 @@
 
 			case MOF_UNLOAD:
 				order->SetUnloadType((OrderUnloadFlags)data);
+				if ((data & OUFB_NO_UNLOAD) != 0 && IsNoLoadOrder(order->GetLoadType())) {
+					order->SetLoadType((OrderLoadFlags)(order->GetLoadType() & ~OLFB_NO_LOAD));
+				}
 				break;
 
 			case MOF_LOAD:
 				order->SetLoadType((OrderLoadFlags)data);
+				order->SetLoadArg(arg);
+				if (IsNoLoadOrder(data) && (order->GetUnloadType() & OUFB_NO_UNLOAD) != 0) {
+					/* No load + no unload isn't compatible */
+					order->SetUnloadType((OrderUnloadFlags)(order->GetUnloadType() & ~OUFB_NO_UNLOAD));
+				}
 				if (data & OLFB_NO_LOAD) order->SetRefit(CT_NO_REFIT);
 				break;
 
@@ -1467,8 +1509,9 @@
 			 */
 			if (sel_ord == u->cur_real_order_index &&
 					(u->current_order.IsType(OT_GOTO_STATION) || u->current_order.IsType(OT_LOADING)) &&
-					u->current_order.GetLoadType() != order->GetLoadType()) {
+					(u->current_order.GetLoadType() != order->GetLoadType() || u->current_order.GetLoadArg() != order->GetLoadArg())) {
 				u->current_order.SetLoadType(order->GetLoadType());
+				u->current_order.SetLoadArg(order->GetLoadArg());
 			}
 			InvalidateVehicleOrder(u, VIWD_MODIFY_ORDERS);
 		}
Index: src/order_func.h
===================================================================
--- src/order_func.h	(revision 25285)
+++ src/order_func.h	(working copy)
@@ -35,4 +35,24 @@
 
 uint16 GetServiceIntervalClamped(uint interval, bool ispercent);
 
+/**
+ * Check if a given OrderLoadFlags requests waiting for cargo.
+ *
+ * @param order The order's load flags.
+ * @return True if should wait for cargo, false otherwise.
+ */
+static inline int32 IsWaitOrder(uint16 order) {
+        return (order & OLFB_FULL_LOAD || order > OLFB_NO_LOAD);
+}
+
+/**
+ * Check if a given OrderLoadFlags requests not loading cargo.
+ *
+ * @param order The order's load flags.
+ * @return True if should not load cargo, false otherwise.
+ */
+static inline int32 IsNoLoadOrder(uint16 order) {
+        return (order & OLFB_NO_LOAD && order <= OLFB_NO_LOAD);
+}
+
 #endif /* ORDER_FUNC_H */
Index: src/order_gui.cpp
===================================================================
--- src/order_gui.cpp	(revision 25285)
+++ src/order_gui.cpp	(working copy)
@@ -33,7 +33,7 @@
 
 
 /** Order load types that could be given to station orders. */
-static const StringID _station_load_types[][5][5] = {
+static const StringID _station_load_types[][5][7] = {
 	{
 		/* No refitting. */
 		{
@@ -42,30 +42,41 @@
 			STR_ORDER_FULL_LOAD,
 			STR_ORDER_FULL_LOAD_ANY,
 			STR_ORDER_NO_LOAD,
+			STR_ORDER_UNITS_LOAD,
+			STR_ORDER_PERCENT_LOAD,			
 		}, {
 			STR_ORDER_UNLOAD,
 			INVALID_STRING_ID,
 			STR_ORDER_UNLOAD_FULL_LOAD,
 			STR_ORDER_UNLOAD_FULL_LOAD_ANY,
 			STR_ORDER_UNLOAD_NO_LOAD,
+			STR_ORDER_UNLOAD_UNITS_LOAD,
+			STR_ORDER_UNLOAD_PERCENT_LOAD,
 		}, {
 			STR_ORDER_TRANSFER,
 			INVALID_STRING_ID,
 			STR_ORDER_TRANSFER_FULL_LOAD,
 			STR_ORDER_TRANSFER_FULL_LOAD_ANY,
 			STR_ORDER_TRANSFER_NO_LOAD,
+			STR_ORDER_TRANSFER_UNITS_LOAD,
+			STR_ORDER_TRANSFER_PERCENT_LOAD,
 		}, {
 			/* Unload and transfer do not work together. */
 			INVALID_STRING_ID,
 			INVALID_STRING_ID,
 			INVALID_STRING_ID,
 			INVALID_STRING_ID,
+			INVALID_STRING_ID,
+			INVALID_STRING_ID,
+			INVALID_STRING_ID,
 		}, {
 			STR_ORDER_NO_UNLOAD,
 			INVALID_STRING_ID,
 			STR_ORDER_NO_UNLOAD_FULL_LOAD,
 			STR_ORDER_NO_UNLOAD_FULL_LOAD_ANY,
 			STR_ORDER_NO_UNLOAD_NO_LOAD,
+			STR_ORDER_NO_UNLOAD_UNITS_LOAD,
+			STR_ORDER_NO_UNLOAD_PERCENT_LOAD,
 		}
 	}, {
 		/* With auto-refitting. No loading and auto-refitting do not work together. */
@@ -75,30 +86,41 @@
 			STR_ORDER_FULL_LOAD_REFIT,
 			STR_ORDER_FULL_LOAD_ANY_REFIT,
 			INVALID_STRING_ID,
+			STR_ORDER_UNITS_LOAD_REFIT,
+			STR_ORDER_PERCENT_LOAD_REFIT,
 		}, {
 			STR_ORDER_UNLOAD_REFIT,
 			INVALID_STRING_ID,
 			STR_ORDER_UNLOAD_FULL_LOAD_REFIT,
 			STR_ORDER_UNLOAD_FULL_LOAD_ANY_REFIT,
 			INVALID_STRING_ID,
+			STR_ORDER_UNLOAD_UNITS_LOAD_REFIT,
+			STR_ORDER_UNLOAD_PERCENT_LOAD_REFIT,
 		}, {
 			STR_ORDER_TRANSFER_REFIT,
 			INVALID_STRING_ID,
 			STR_ORDER_TRANSFER_FULL_LOAD_REFIT,
 			STR_ORDER_TRANSFER_FULL_LOAD_ANY_REFIT,
 			INVALID_STRING_ID,
+			STR_ORDER_TRANSFER_UNITS_LOAD_REFIT,
+			STR_ORDER_TRANSFER_PERCENT_LOAD_REFIT,
 		}, {
 			/* Unload and transfer do not work together. */
 			INVALID_STRING_ID,
 			INVALID_STRING_ID,
 			INVALID_STRING_ID,
 			INVALID_STRING_ID,
+			INVALID_STRING_ID,
+			INVALID_STRING_ID,
+			INVALID_STRING_ID,
 		}, {
 			STR_ORDER_NO_UNLOAD_REFIT,
 			INVALID_STRING_ID,
 			STR_ORDER_NO_UNLOAD_FULL_LOAD_REFIT,
 			STR_ORDER_NO_UNLOAD_FULL_LOAD_ANY_REFIT,
 			INVALID_STRING_ID,
+			STR_ORDER_NO_UNLOAD_UNITS_LOAD_REFIT,
+			STR_ORDER_NO_UNLOAD_PERCENT_LOAD_REFIT,
 		}
 	}
 };
@@ -117,6 +139,10 @@
 	STR_ORDER_DROP_FULL_LOAD_ALL,
 	STR_ORDER_DROP_FULL_LOAD_ANY,
 	STR_ORDER_DROP_NO_LOADING,
+	STR_ORDER_DROP_SOME_LOAD,
+	STR_ORDER_DROP_25_LOAD,
+	STR_ORDER_DROP_50_LOAD,
+	STR_ORDER_DROP_75_LOAD,
 	INVALID_STRING_ID
 };
 
@@ -268,12 +294,16 @@
 					SetTimetableParams(6, 7, order->wait_time);
 				}
 			} else {
-				SetDParam(3, (order->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) ? STR_EMPTY : _station_load_types[order->IsRefit()][unload][load]);
+				int arg = 3;
+				SetDParam(arg++, (order->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) ? STR_EMPTY : _station_load_types[order->IsRefit()][unload][load]);
 				if (order->IsRefit()) {
-					SetDParam(4, order->IsAutoRefit() ? STR_ORDER_AUTO_REFIT_ANY : CargoSpec::Get(order->GetRefitCargo())->name);
+					SetDParam(arg++, order->IsAutoRefit() ? STR_ORDER_AUTO_REFIT_ANY : CargoSpec::Get(order->GetRefitCargo())->name);
 				}
+				if (order->GetLoadType() == OLF_LOAD_UNITS || order->GetLoadType() == OLF_LOAD_PERCENT) {
+					SetDParam(arg++, order->GetLoadArg());
+				}
 				if (v->type == VEH_TRAIN && (order->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) == 0) {
-					SetDParam(5, order->GetStopLocation() + STR_ORDER_STOP_LOCATION_NEAR_END);
+					SetDParam(arg++, order->GetStopLocation() + STR_ORDER_STOP_LOCATION_NEAR_END);
 				}
 			}
 			break;
Index: src/order_type.h
===================================================================
--- src/order_type.h	(revision 25285)
+++ src/order_type.h	(working copy)
@@ -64,9 +64,25 @@
 	OLFB_FULL_LOAD       = 1 << 1, ///< Full load all cargoes of the consist.
 	OLF_FULL_LOAD_ANY    = 3,      ///< Full load a single cargo of the consist.
 	OLFB_NO_LOAD         = 4,      ///< Do not load anything.
+	OLF_LOAD_UNITS       = 5,      ///< Load at least (arg) units.
+	OLF_LOAD_PERCENT     = 6,      ///< Load at least (arg)%
 };
 
 /**
+ * Loading orders in the GUI drop-down box.
+ */
+enum OrderLoadDropdown {
+	OLD_LOAD_IF_POSSIBLE = 0,      ///< Load if available
+	OLD_FULL_LOAD_ALL    = 2,      ///< Full load all cargo
+	OLD_FULL_LOAD_ANY    = 3,      ///< Full load any cargo
+	OLD_NO_LOADING       = 4,      ///< No loading
+	OLD_SOME_LOAD        = 5,      ///< Wait for some cargo
+	OLD_25_LOAD          = 6,      ///< Wait for 25% load
+	OLD_50_LOAD          = 7,      ///< Wait for 50% load
+	OLD_75_LOAD          = 8,      ///< Wait for 75% load
+};
+
+/**
  * Non-stop order flags.
  */
 enum OrderNonStopFlags {
Index: src/saveload/order_sl.cpp
===================================================================
--- src/saveload/order_sl.cpp	(revision 25285)
+++ src/saveload/order_sl.cpp	(working copy)
@@ -111,6 +111,7 @@
 		 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),
+		 SLE_CONDVAR(Order, load_arg,       SLE_UINT8,  114, 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 */
Index: src/vehicle.cpp
===================================================================
--- src/vehicle.cpp	(revision 25285)
+++ src/vehicle.cpp	(working copy)
@@ -2251,6 +2251,15 @@
 	}
 }
 
+uint Vehicle::GetConsistTotalStored() const
+{
+	uint result = 0;
+	for (const Vehicle *v = this; v != NULL; v = v->Next()) {
+		result += v->cargo.StoredCount();
+	}
+	return result;
+}
+
 uint Vehicle::GetConsistTotalCapacity() const
 {
 	uint result = 0;
Index: src/vehicle_base.h
===================================================================
--- src/vehicle_base.h	(revision 25285)
+++ src/vehicle_base.h	(working copy)
@@ -262,6 +262,7 @@
 
 	void GetConsistFreeCapacities(SmallMap<CargoID, uint> &capacities) const;
 
+	uint GetConsistTotalStored() const;
 	uint GetConsistTotalCapacity() const;
 
 	/**
