25 #include "strings.h"

    30 	BUILD_TRAIN_WIDGET_SORT_ASSENDING_DESENTING,

    31 	BUILD_TRAIN_WIDGET_SORT_TEXT,

    32 	BUILD_TRAIN_WIDGET_SORT_DROPDOWN,

    62 static bool _internal_sort_order; // descending/ascending

    63 static byte _last_sort_criteria = 0;

    64 static bool _last_sort_order = false;

    65 

    66 typedef int CDECL VehicleSortListingTypeFunction(const void*, const void*);

    67 

    68 static int CDECL TrainEngineNumberSorter(const void *a, const void *b)

    69 {

    70 	const EngineID va = *(const EngineID*)a;

    71 	const EngineID vb = *(const EngineID*)b;

    72 	int r = va - vb;

    73 

    74 	return _internal_sort_order ? -r : r;

    75 }

    76 

    77 static int CDECL TrainEngineCostSorter(const void *a, const void *b)

    78 {

    79 	const int va = RailVehInfo(*(const EngineID*)a)->base_cost;

    80 	const int vb = RailVehInfo(*(const EngineID*)b)->base_cost;

    81 	int r = va - vb;

    82 

    83 	return _internal_sort_order ? -r : r;

    84 }

    85 

    86 static int CDECL TrainEngineSpeedSorter(const void *a, const void *b)

    87 {

    88 	const int va = RailVehInfo(*(const EngineID*)a)->max_speed;

    89 	const int vb = RailVehInfo(*(const EngineID*)b)->max_speed;

    90 	const int r = va - vb;

    91 

    92 	if (r == 0) {

    93 		/* Use EngineID to sort instead since we want consistent sorting */

    94 		return TrainEngineNumberSorter(a, b);

    95 	}

    96 	return _internal_sort_order ? -r : r;

    97 }

    98 

    99 static int CDECL TrainEnginePowerSorter(const void *a, const void *b)

   100 {

   101 	const RailVehicleInfo *rvi_a = RailVehInfo(*(const EngineID*)a);

   102 	const RailVehicleInfo *rvi_b = RailVehInfo(*(const EngineID*)b);

   103 

   104 	const int va = rvi_a->power << (rvi_a->flags & RVI_MULTIHEAD ? 1 : 0);

   105 	const int vb = rvi_b->power << (rvi_b->flags & RVI_MULTIHEAD ? 1 : 0);

   106 	const int r = va - vb;

   107 

   108 	if (r == 0) {

   109 		/* Use EngineID to sort instead since we want consistent sorting */

   110 		return TrainEngineNumberSorter(a, b);

   111 	}

   112 	return _internal_sort_order ? -r : r;

   113 }

   114 

   115 static int CDECL TrainEngineIntroDateSorter(const void *a, const void *b)

   116 {

   117 	const int va = GetEngine(*(const EngineID*)a)->intro_date;

   118 	const int vb = GetEngine(*(const EngineID*)b)->intro_date;

   119 	const int r = va - vb;

   120 

   121 	if (r == 0) {

   122 		/* Use EngineID to sort instead since we want consistent sorting */

   123 		return TrainEngineNumberSorter(a, b);

   124 	}

   125 	return _internal_sort_order ? -r : r;

   126 }

   127 

   128 static EngineID _last_engine; // cached vehicle to hopefully speed up name-sorting

   129 

   130 static char _bufcache[64]; // used together with _last_vehicle to hopefully speed up stringsorting

   131 static int CDECL TrainEngineNameSorter(const void *a, const void *b)

   132 {

   133 	const EngineID va = *(const EngineID*)a;

   134 	const EngineID vb = *(const EngineID*)b;

   135 	char buf1[64] = "\0";

   136 	int r;

   137 

   138 	SetDParam(0, GetCustomEngineName(va));

   139 	GetString(buf1, STR_JUST_STRING);

   140 

   141 	if (vb != _last_engine) {

   142 		_last_engine = vb;

   143 		_bufcache[0] = '\0';

   144 

   145 		SetDParam(0, GetCustomEngineName(vb));

   146 		GetString(_bufcache, STR_JUST_STRING);

   147 	}

   148 

   149 	r =  strcmp(buf1, _bufcache); // sort by name

   150 

   151 	if (r == 0) {

   152 		/* Use EngineID to sort instead since we want consistent sorting */

   153 		return TrainEngineNumberSorter(a, b);

   154 	}

   155 

   156 	return (_internal_sort_order & 1) ? -r : r;

   157 }

   158 

   159 static int CDECL TrainEngineRunningCostSorter(const void *a, const void *b)

   160 {

   161 	const RailVehicleInfo *rvi_a = RailVehInfo(*(const EngineID*)a);

   162 	const RailVehicleInfo *rvi_b = RailVehInfo(*(const EngineID*)b);

   163 

   164 	const int va = rvi_a->running_cost_base * _price.running_rail[rvi_a->running_cost_class] * (rvi_a->flags & RVI_MULTIHEAD ? 2 : 1);

   165 	const int vb = rvi_b->running_cost_base * _price.running_rail[rvi_b->running_cost_class] * (rvi_b->flags & RVI_MULTIHEAD ? 2 : 1);

   166 	const int r = va - vb;

   167 

   168 	if (r == 0) {

   169 		/* Use EngineID to sort instead since we want consistent sorting */

   170 		return TrainEngineNumberSorter(a, b);

   171 	}

   172 	return _internal_sort_order ? -r : r;

   173 }

   174 

   175 static int CDECL TrainEnginePowerVsRunningCostSorter(const void *a, const void *b)

   176 {

   177 	const RailVehicleInfo *rvi_a = RailVehInfo(*(const EngineID*)a);

   178 	const RailVehicleInfo *rvi_b = RailVehInfo(*(const EngineID*)b);

   179 

   180 	/* Here we are using a few tricks to get the right sort.

   181 	 * We want power/running cost, but since we usually got higher running cost than power and we store the result in an int,

   182 	 * we will actually calculate cunning cost/power (to make it more than 1).

   183 	 * Because of this, the return value have to be reversed as well and we return b - a instead of a - b.

   184 	 * Another thing is that both power and running costs should be doubled for multiheaded engines.

   185 	 * Since it would be multipling with 2 in both numerator and denumerator, it will even themselves out and we skip checking for multiheaded. */

   186 	const int va = (rvi_a->running_cost_base * _price.running_rail[rvi_a->running_cost_class]) / rvi_a->power;

   187 	const int vb = (rvi_b->running_cost_base * _price.running_rail[rvi_b->running_cost_class]) / rvi_b->power;

   188 	const int r = vb - va;

   189 

   190 	if (r == 0) {

   191 		/* Use EngineID to sort instead since we want consistent sorting */

   192 		return TrainEngineNumberSorter(a, b);

   193 	}

   194 	return _internal_sort_order ? -r : r;

   195 }

   196 

   197 static int CDECL TrainEngineReliabilitySorter(const void *a, const void *b)

   198 {

   199 	const int va = GetEngine(*(const EngineID*)a)->reliability;

   200 	const int vb = GetEngine(*(const EngineID*)b)->reliability;

   201 	const int r = va - vb;

   202 

   203 	if (r == 0) {

   204 		/* Use EngineID to sort instead since we want consistent sorting */

   205 		return TrainEngineNumberSorter(a, b);

   206 	}

   207 	return _internal_sort_order ? -r : r;

   208 }

   209 

   210 static VehicleSortListingTypeFunction* const _engine_sorter[] = {

   211 	&TrainEngineNumberSorter,

   212 	&TrainEngineCostSorter,

   213 	&TrainEngineSpeedSorter,

   214 	&TrainEnginePowerSorter,

   215 	&TrainEngineIntroDateSorter,

   216 	&TrainEngineNameSorter,

   217 	&TrainEngineRunningCostSorter,

   218 	&TrainEnginePowerVsRunningCostSorter,

   219 	&TrainEngineReliabilitySorter,

   220 };

   221 

   222 static const StringID _engine_sort_listing[] = {

   223 	STR_ENGINE_SORT_ENGINE_ID,

   224 	STR_ENGINE_SORT_COST,

   225 	STR_SORT_BY_MAX_SPEED,

   226 	STR_ENGINE_SORT_POWER,

   227 	STR_ENGINE_SORT_INTRO_DATE,

   228 	STR_SORT_BY_DROPDOWN_NAME,

   229 	STR_ENGINE_SORT_RUNNING_COST,

   230 	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,

   231 	STR_SORT_BY_RELIABILITY,

   232 	INVALID_STRING_ID

   233 };

   439 static void SortTrainBuildList(Window *w)

   440 {

   441 	_internal_sort_order = WP(w,buildtrain_d).decenting_sort_order;

   442 	qsort((void*)WP(w,buildtrain_d).engines, WP(w,buildtrain_d).num_engines, sizeof(WP(w,buildtrain_d).engines[0]),

   443 		  _engine_sorter[WP(w,buildtrain_d).sort_criteria]);

   444 }

   445 

   465 		SortTrainBuildList(w);

   529 	DrawString(85, 15, _engine_sort_listing[WP(w,buildtrain_d).sort_criteria], 0x10);

   530 	DoDrawString(WP(w,buildtrain_d).decenting_sort_order ? DOWNARROW : UPARROW, 69, 15, 0x10);

   544 			WP(w,buildtrain_d).sort_criteria     = _last_sort_criteria;

   545 			WP(w,buildtrain_d).decenting_sort_order = _last_sort_order;

   564 				case BUILD_TRAIN_WIDGET_SORT_ASSENDING_DESENTING:

   565 					WP(w,buildtrain_d).decenting_sort_order = !WP(w,buildtrain_d).decenting_sort_order;

   566 					_last_sort_order = WP(w,buildtrain_d).decenting_sort_order;

   567 					SortTrainBuildList(w);

   568 					SetWindowDirty(w);

   569 					break;

   570 

   571 				case BUILD_TRAIN_WIDGET_SORT_TEXT: case BUILD_TRAIN_WIDGET_SORT_DROPDOWN:/* Select sorting criteria dropdown menu */

   572 					ShowDropDownMenu(w, _engine_sort_listing, WP(w,buildtrain_d).sort_criteria, BUILD_TRAIN_WIDGET_SORT_DROPDOWN, 0, 0);

   573 					return;

   574 

   629 		case WE_DROPDOWN_SELECT: /* we have selected a dropdown item in the list */

   630 			if (WP(w,buildtrain_d).sort_criteria != e->we.dropdown.index) {

   631 				WP(w,buildtrain_d).sort_criteria = e->we.dropdown.index;

   632 				_last_sort_criteria = e->we.dropdown.index;

   633 				SortTrainBuildList(w);

   634 			}

   635 			SetWindowDirty(w);

   636 			break;

   637