openttd-ottdgrfs: comparison src/industry

equal deleted inserted replaced

-:6c4314786d68
+:8cbdb511a674
 #include "map_func.h"
 #include "player_func.h"
 #include "settings_type.h"
 #include "tilehighlight_func.h"
 #include "string_func.h"
+#include "sortlist_type.h"
 #include "table/strings.h"
 #include "table/sprites.h"
 bool _ignore_restrictions;
 static const WindowDesc _build_industry_desc = {
 	WDP_AUTO, WDP_AUTO, 170, 212, 170, 212,
 	WC_BUILD_INDUSTRY, WC_NONE,
 	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_RESIZABLE,
 	_build_industry_widgets,
-	NULL,
 };
 class BuildIndustryWindow : public Window {
 	int selected_index;                         ///< index of the element in the matrix
 	IndustryType selected_type;                 ///< industry corresponding to the above index
 	uint16 count;                               ///< How many industries are loaded
 	IndustryType index[NUM_INDUSTRYTYPES + 1];  ///< Type of industry, in the order it was loaded
 	StringID text[NUM_INDUSTRYTYPES + 1];       ///< Text coming from CBM_IND_FUND_MORE_TEXT (if ever)
 	bool enabled[NUM_INDUSTRYTYPES + 1];        ///< availability state, coming from CBID_INDUSTRY_AVAILABLE (if ever)
-public:
+	void SetupArrays()
-	BuildIndustryWindow() : Window(&_build_industry_desc)
 	{
 		IndustryType ind;
 		const IndustrySpec *indsp;
-		/* Shorten the window to the equivalant of the additionnal purchase
-		 * info coming from the callback.  SO it will only be available to tis full
-		 * height when newindistries are loaded */
-		if (!_loaded_newgrf_features.has_newindustries) {
-			this->widget[DPIW_INFOPANEL].bottom -= 44;
-			this->widget[DPIW_FUND_WIDGET].bottom -= 44;
-			this->widget[DPIW_FUND_WIDGET].top -= 44;
-			this->widget[DPIW_RESIZE_WIDGET].bottom -= 44;
-			this->widget[DPIW_RESIZE_WIDGET].top -= 44;
-			this->resize.height = this->height -= 44;
-		}
-		this->timer_enabled = _loaded_newgrf_features.has_newindustries;
-		/* Initialize structures */
 		this->count = 0;
 		for (uint i = 0; i < lengthof(this->index); i++) {
-			this->index[i]   = 0xFF;
+			this->index[i]   = INVALID_INDUSTRYTYPE;
 			this->text[i]    = STR_NULL;
 			this->enabled[i] = false;
 		}
-		this->vscroll.cap = 8; // rows in grid, same in scroller
-		this->resize.step_height = 13;
 		if (_game_mode == GM_EDITOR) { // give room for the Many Random "button"
 			this->index[this->count] = INVALID_INDUSTRYTYPE;
 			this->count++;
 			this->timer_enabled = false;
 		}
+		/* Fill the arrays with industries.
-		/* Fill the _fund_gui structure with industries.
 		 * The tests performed after the enabled allow to load the industries
 		 * In the same way they are inserted by grf (if any)
 		 */
 		for (ind = 0; ind < NUM_INDUSTRYTYPES; ind++) {
 			indsp = GetIndustrySpec(ind);
 			if (indsp->enabled){
 				/* Rule is that editor mode loads all industries.
 				 * In game mode, all non raw industries are loaded too
 				 * and raw ones are loaded only when setting allows it */
-				if (_game_mode != GM_EDITOR && indsp->IsRawIndustry() && _patches.raw_industry_construction == 0) continue;
+				if (_game_mode != GM_EDITOR && indsp->IsRawIndustry() && _patches.raw_industry_construction == 0) {
+					/* Unselect if the industry is no longer in the list */
+					if (this->selected_type == ind) this->selected_index = -1;
+					continue;
+				}
 				this->index[this->count] = ind;
 				this->enabled[this->count] = (_game_mode == GM_EDITOR) || CheckIfCallBackAllowsAvailability(ind, IACT_USERCREATION);
+				/* Keep the selection to the correct line */
+				if (this->selected_type == ind) this->selected_index = this->count;
 				this->count++;
 			}
 		}
-		/* first indutry type is selected.
+		/* first indutry type is selected if the current selection is invalid.
 		 * I'll be damned if there are none available ;) */
-		this->selected_index = 0;
+		if (this->selected_index == -1) {
-		this->selected_type = this->index[0];
+			this->selected_index = 0;
+			this->selected_type = this->index[0];
+		}
+	}
+public:
+	BuildIndustryWindow() : Window(&_build_industry_desc)
+	{
+		/* Shorten the window to the equivalant of the additionnal purchase
+		 * info coming from the callback.  SO it will only be available to its full
+		 * height when newindistries are loaded */
+		if (!_loaded_newgrf_features.has_newindustries) {
+			this->widget[DPIW_INFOPANEL].bottom -= 44;
+			this->widget[DPIW_FUND_WIDGET].bottom -= 44;
+			this->widget[DPIW_FUND_WIDGET].top -= 44;
+			this->widget[DPIW_RESIZE_WIDGET].bottom -= 44;
+			this->widget[DPIW_RESIZE_WIDGET].top -= 44;
+			this->resize.height = this->height -= 44;
+		}
+		this->timer_enabled = _loaded_newgrf_features.has_newindustries;
+		this->vscroll.cap = 8; // rows in grid, same in scroller
+		this->resize.step_height = 13;
+		this->selected_index = -1;
+		this->selected_type = INVALID_INDUSTRYTYPE;
+		/* Initialize arrays */
+		this->SetupArrays();
 		this->callback_timer = DAY_TICKS;
 		this->FindWindowPlacementAndResize(&_build_industry_desc);
 	}
 		}
 		this->SetWidgetDisabledState(DPIW_FUND_WIDGET, !this->enabled[this->selected_index]);
 		SetVScrollCount(this, this->count);
-		DrawWindowWidgets(this);
+		this->DrawWidgets();
 		/* and now with the matrix painting */
 		for (byte i = 0; i < this->vscroll.cap && ((i + this->vscroll.pos) < this->count); i++) {
 			int offset = i * 13;
 			int x = 3;
 	virtual void OnPlaceObjectAbort()
 	{
 		this->RaiseButtons();
 	}
+	virtual void OnInvalidateData(int data = 0)
+	{
+		this->SetupArrays();
+		this->SetDirty();
+	}
 };
 void ShowBuildIndustryWindow()
 {
 	if (_game_mode != GM_EDITOR && !IsValidPlayer(_current_player)) return;
 	byte clicked_line;        ///< The line of the button that has been clicked
 	byte clicked_button;      ///< The button that has been clicked (to raise)
 	byte production_offset_y; ///< The offset of the production texts/buttons
 public:
-	IndustryViewWindow(const WindowDesc *desc, void *data, WindowNumber window_number) : Window(desc, data, window_number)
+	IndustryViewWindow(const WindowDesc *desc, WindowNumber window_number) : Window(desc, window_number)
 	{
 		this->flags4 |= WF_DISABLE_VP_SCROLL;
 		this->editbox_line = 0;
 		this->clicked_line = 0;
 		this->clicked_button = 0;
 		int y = this->widget[IVW_INFO].top + 1;
 		bool first = true;
 		bool has_accept = false;
 		SetDParam(0, this->window_number);
-		DrawWindowWidgets(this);
+		this->DrawWidgets();
 		if (HasBit(ind->callback_flags, CBM_IND_PRODUCTION_CARGO_ARRIVAL) || HasBit(ind->callback_flags, CBM_IND_PRODUCTION_256_TICKS)) {
 			for (byte j = 0; j < lengthof(i->accepts_cargo); j++) {
 				if (i->accepts_cargo[j] == CT_INVALID) continue;
 				has_accept = true;
 			ResizeWindowForWidget(this, IVW_INFO, 0, y - this->widget[IVW_INFO].top);
 			this->SetDirty();
 			return;
 		}
-		DrawWindowViewport(this);
+		this->DrawViewport();
 	}
 	virtual void OnClick(Point pt, int widget)
 	{
 		Industry *i;
 static const WindowDesc _industry_view_desc = {
 	WDP_AUTO, WDP_AUTO, 260, 120, 260, 120,
 	WC_INDUSTRY_VIEW, WC_NONE,
 	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE,
 	_industry_view_widgets,
-	NULL
 };
 void ShowIndustryViewWindow(int industry)
 {
 	AllocateWindowDescFront<IndustryViewWindow>(&_industry_view_desc, industry);
 	IDW_SORTBYNAME,
 	IDW_SORTBYTYPE,
 	IDW_SORTBYPROD,
 	IDW_SORTBYTRANSPORT,
 	IDW_SPACER,
-	IDW_INDUSRTY_LIST,
+	IDW_INDUSTRY_LIST,
 	IDW_SCROLLBAR,
 	IDW_RESIZE,
 };
 /** Widget definition of the industy directory gui */
 {  WWT_SCROLLBAR,    RESIZE_LRB,    13,   496,   507,    14,   177, 0x0,                     STR_0190_SCROLL_BAR_SCROLLS_LIST},  // IDW_SCROLLBAR
 {  WWT_RESIZEBOX,   RESIZE_LRTB,    13,   496,   507,   178,   189, 0x0,                     STR_RESIZE_BUTTON},                 // IDW_RESIZE
 {   WIDGETS_END},
 };
-static uint _num_industry_sort;
 static char _bufcache[96];
 static const Industry* _last_industry;
+static int _internal_sort_order;
-static byte _industry_sort_order;
 static int CDECL GeneralIndustrySorter(const void *a, const void *b)
 {
 	const Industry* i = *(const Industry**)a;
 	const Industry* j = *(const Industry**)b;
 	int r;
-	switch (_industry_sort_order >> 1) {
+	switch (_internal_sort_order >> 1) {
 		default: NOT_REACHED();
 		case 0: /* Sort by Name (handled later) */
 			r = 0;
 			break;
 			GetString(_bufcache, STR_TOWN, lastof(_bufcache));
 		}
 		r = strcmp(buf1, _bufcache);
 	}
-	if (_industry_sort_order & 1) r = -r;
+	if (_internal_sort_order & 1) r = -r;
 	return r;
 }
+typedef GUIList<const Industry*> GUIIndustryList;
 /**
-* Makes a sorted industry list.
+* Rebuild industries list if the VL_REBUILD flag is set
-* When there are no industries, the list has to be made. This so when one
+*
-* starts a new game without industries after playing a game with industries
+* @param sl pointer to industry list
-* the list is not populated with invalid industries from the previous game.
 */
-static void MakeSortedIndustryList()
+static void BuildIndustriesList(GUIIndustryList *sl)
 {
-	const Industry* i;
+	uint n = 0;
-	int n = 0;
+	const Industry *i;
+	if (!(sl->flags & VL_REBUILD)) return;
 	/* Create array for sorting */
-	_industry_sort = ReallocT(_industry_sort, GetMaxIndustryIndex() + 1);
+	const Industry **industry_sort = MallocT<const Industry*>(GetMaxIndustryIndex() + 1);
-	/* Don't attempt a sort if there are no industries */
+	DEBUG(misc, 3, "Building industry list");
-	if (GetNumIndustries() != 0) {
-		FOR_ALL_INDUSTRIES(i) _industry_sort[n++] = i;
+	FOR_ALL_INDUSTRIES(i) industry_sort[n++] = i;
-		qsort((void*)_industry_sort, n, sizeof(_industry_sort[0]), GeneralIndustrySorter);
-	}
+	free((void*)sl->sort_list);
+	sl->sort_list = MallocT<const Industry*>(n);
-	_num_industry_sort = n;
+	sl->list_length = n;
-	_last_industry = NULL; // used for "cache"
+	for (uint i = 0; i < n; ++i) sl->sort_list[i] = industry_sort[i];
-	DEBUG(misc, 3, "Resorting industries list");
-}
+	sl->flags &= ~VL_REBUILD;
+	sl->flags |= VL_RESORT;
+	free((void*)industry_sort);
-static void IndustryDirectoryWndProc(Window *w, WindowEvent *e)
+}
-{
-	switch (e->event) {
-		case WE_PAINT: {
+/**
-			if (_industry_sort_dirty) {
+* Sort industry list if the VL_RESORT flag is set
-				_industry_sort_dirty = false;
+*
-				MakeSortedIndustryList();
+* @param sl pointer to industry list
-			}
+*/
+static void SortIndustriesList(GUIIndustryList *sl)
-			SetVScrollCount(w, _num_industry_sort);
+{
+	if (!(sl->flags & VL_RESORT)) return;
-			DrawWindowWidgets(w);
-			DrawSortButtonState(w, IDW_SORTBYNAME + (_industry_sort_order >> 1), _industry_sort_order & 1 ? SBS_DOWN : SBS_UP);
+	_internal_sort_order = (sl->sort_type << 1) | (sl->flags & VL_DESC);
+	_last_industry = NULL; // used for "cache" in namesorting
-			uint pos = w->vscroll.pos;
+	qsort((void*)sl->sort_list, sl->list_length, sizeof(sl->sort_list[0]), &GeneralIndustrySorter);
-			int n = 0;
+	sl->flags &= ~VL_RESORT;
-			while (pos < _num_industry_sort) {
+}
-				const Industry* i = _industry_sort[pos];
-				const IndustrySpec *indsp = GetIndustrySpec(i->type);
+/**
-				byte p = 0;
+* The list of industries.
+*/
-				/* Industry name */
+struct IndustryDirectoryWindow : public Window, public GUIIndustryList {
-				SetDParam(p++, i->index);
+	static Listing industry_sort;
-				/* Industry productions */
+	IndustryDirectoryWindow(const WindowDesc *desc, WindowNumber number) : Window(desc, number)
-				for (byte j = 0; j < lengthof(i->produced_cargo); j++) {
+	{
-					if (i->produced_cargo[j] == CT_INVALID) continue;
+		this->vscroll.cap = 16;
-					SetDParam(p++, i->produced_cargo[j]);
+		this->resize.height = this->height - 6 * 10; // minimum 10 items
-					SetDParam(p++, i->last_month_production[j]);
+		this->resize.step_height = 10;
-					SetDParam(p++, GetCargoSuffix(j + 3, CST_DIR, (Industry*)i, i->type, indsp));
+		this->FindWindowPlacementAndResize(desc);
-				}
+		this->sort_list = NULL;
-				/* Transported productions */
+		this->flags = VL_REBUILD;
-				for (byte j = 0; j < lengthof(i->produced_cargo); j++) {
+		this->sort_type = industry_sort.criteria;
-					if (i->produced_cargo[j] == CT_INVALID) continue;
+		if (industry_sort.order) this->flags |= VL_DESC;
-					SetDParam(p++, i->last_month_pct_transported[j] * 100 >> 8);
+	}
-				}
+	virtual void OnPaint()
-				/* Drawing the right string */
+	{
-				StringID str = STR_INDUSTRYDIR_ITEM_NOPROD;
+		BuildIndustriesList(this);
-				if (p != 1) str = (p == 5) ? STR_INDUSTRYDIR_ITEM : STR_INDUSTRYDIR_ITEM_TWO;
+		SortIndustriesList(this);
-				DrawStringTruncated(4, 28 + n * 10, str, TC_FROMSTRING, w->widget[IDW_INDUSRTY_LIST].right - 4);
+		SetVScrollCount(this, this->list_length);
-				pos++;
-				if (++n == w->vscroll.cap) break;
+		this->DrawWidgets();
-			}
+		this->DrawSortButtonState(IDW_SORTBYNAME + this->sort_type, this->flags & VL_DESC ? SBS_DOWN : SBS_UP);
-		} break;
+		int max = min(this->vscroll.pos + this->vscroll.cap, this->list_length);
-		case WE_CLICK:
+		int y = 28; // start of the list-widget
-			switch (e->we.click.widget) {
-				case IDW_SORTBYNAME: {
+		for (int n = this->vscroll.pos; n < max; ++n) {
-					_industry_sort_order = _industry_sort_order == 0 ? 1 : 0;
+			const Industry* i = this->sort_list[n];
-					_industry_sort_dirty = true;
+			const IndustrySpec *indsp = GetIndustrySpec(i->type);
-					w->SetDirty();
+			byte p = 0;
-				} break;
+			/* Industry name */
-				case IDW_SORTBYTYPE: {
+			SetDParam(p++, i->index);
-					_industry_sort_order = _industry_sort_order == 2 ? 3 : 2;
-					_industry_sort_dirty = true;
+			/* Industry productions */
-					w->SetDirty();
+			for (byte j = 0; j < lengthof(i->produced_cargo); j++) {
-				} break;
+				if (i->produced_cargo[j] == CT_INVALID) continue;
+				SetDParam(p++, i->produced_cargo[j]);
-				case IDW_SORTBYPROD: {
+				SetDParam(p++, i->last_month_production[j]);
-					_industry_sort_order = _industry_sort_order == 4 ? 5 : 4;
+				SetDParam(p++, GetCargoSuffix(j + 3, CST_DIR, (Industry*)i, i->type, indsp));
-					_industry_sort_dirty = true;
+			}
-					w->SetDirty();
-				} break;
+			/* Transported productions */
+			for (byte j = 0; j < lengthof(i->produced_cargo); j++) {
-				case IDW_SORTBYTRANSPORT: {
+				if (i->produced_cargo[j] == CT_INVALID) continue;
-					_industry_sort_order = _industry_sort_order == 6 ? 7 : 6;
+				SetDParam(p++, i->last_month_pct_transported[j] * 100 >> 8);
-					_industry_sort_dirty = true;
+			}
-					w->SetDirty();
-				} break;
+			/* Drawing the right string */
+			StringID str = STR_INDUSTRYDIR_ITEM_NOPROD;
-				case IDW_INDUSRTY_LIST: {
+			if (p != 1) str = (p == 5) ? STR_INDUSTRYDIR_ITEM : STR_INDUSTRYDIR_ITEM_TWO;
-					int y = (e->we.click.pt.y - 28) / 10;
+			DrawStringTruncated(4, y, str, TC_FROMSTRING, this->widget[IDW_INDUSTRY_LIST].right - 4);
-					uint16 p;
+			y += 10;
-					if (!IsInsideMM(y, 0, w->vscroll.cap)) return;
+		}
-					p = y + w->vscroll.pos;
+	}
-					if (p < _num_industry_sort) {
-						if (_ctrl_pressed) {
+	virtual void OnClick(Point pt, int widget)
-							ShowExtraViewPortWindow(_industry_sort[p]->xy);
+	{
-						} else {
+		switch (widget) {
-							ScrollMainWindowToTile(_industry_sort[p]->xy);
+			case IDW_SORTBYNAME:
-						}
+			case IDW_SORTBYTYPE:
+			case IDW_SORTBYPROD:
+			case IDW_SORTBYTRANSPORT:
+				if (this->sort_type == (widget - IDW_SORTBYNAME)) {
+					this->flags ^= VL_DESC;
+				} else {
+					this->sort_type = widget - IDW_SORTBYNAME;
+					this->flags &= ~VL_DESC;
+				}
+				industry_sort.criteria = this->sort_type;
+				industry_sort.order = HasBit(this->flags, 0);
+				this->flags |= VL_RESORT;
+				this->SetDirty();
+				break;
+			case IDW_INDUSTRY_LIST: {
+				int y = (pt.y - 28) / 10;
+				uint16 p;
+				if (!IsInsideMM(y, 0, this->vscroll.cap)) return;
+				p = y + this->vscroll.pos;
+				if (p < this->list_length) {
+					if (_ctrl_pressed) {
+						ShowExtraViewPortWindow(this->sort_list[p]->xy);
+					} else {
+						ScrollMainWindowToTile(this->sort_list[p]->xy);
 					}
-				} break;
+				}
-			}
+			} break;
-			break;
+		}
+	}
-		case WE_100_TICKS:
-			w->SetDirty();
+	virtual void OnResize(Point new_size, Point delta)
-			break;
+	{
+		this->vscroll.cap += delta.y / 10;
-		case WE_RESIZE:
+	}
-			w->vscroll.cap += e->we.sizing.diff.y / 10;
-			break;
+	virtual void OnInvalidateData(int data)
-	}
+	{
-}
+		this->flags |= (data == 0 ? VL_REBUILD : VL_RESORT);
+		this->InvalidateWidget(IDW_INDUSTRY_LIST);
+	}
+};
+Listing IndustryDirectoryWindow::industry_sort = {0, 0};
 /** Window definition of the industy directory gui */
 static const WindowDesc _industry_directory_desc = {
 	WDP_AUTO, WDP_AUTO, 508, 190, 508, 190,
 	WC_INDUSTRY_DIRECTORY, WC_NONE,
 	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE,
 	_industry_directory_widgets,
-	IndustryDirectoryWndProc
 };
 void ShowIndustryDirectory()
 {
-	Window *w = AllocateWindowDescFront<Window>(&_industry_directory_desc, 0);
+	AllocateWindowDescFront<IndustryDirectoryWindow>(&_industry_directory_desc, 0);
+}
-	if (w != NULL) {
-		w->vscroll.cap = 16;
-		w->resize.height = w->height - 6 * 10; // minimum 10 items
-		w->resize.step_height = 10;
-		w->SetDirty();
-	}
-}

branch	noai
changeset 10645	8cbdb511a674
parent 10513	33cb70ff2f5d
child 10715	6bdf79ffb022