# NewGRF status

STR_NEWGRF_LIST_NONE                                            :None

STR_NEWGRF_LIST_ALL_FOUND                                       :All files present

STR_NEWGRF_LIST_COMPATIBLE                                      :{YELLOW}Found compatible files

STR_NEWGRF_LIST_MISSING                                         :{RED}Missing files

# NewGRF 'it's broken' warnings

STR_NEWGRF_BROKEN                                               :{WHITE}Behaviour of NewGRF '{0:RAW_STRING}' is likely to cause desyncs and/or crashes

STR_NEWGRF_BROKEN_POWERED_WAGON                                 :{WHITE}It changed powered-wagon state for '{1:ENGINE}' when not inside a depot

STR_NEWGRF_BROKEN_VEHICLE_LENGTH                                :{WHITE}It changed vehicle length for '{1:ENGINE}' when not inside a depot

STR_BROKEN_VEHICLE_LENGTH                                       :{WHITE}Train '{VEHICLE}' belonging to '{COMPANY}' has invalid length. It is probably caused by problems with NewGRFs. Game may desync or crash

STR_NEWGRF_BUGGY                                                :{WHITE}NewGRF '{0:RAW_STRING}' provides incorrect information

STR_NEWGRF_BUGGY_ARTICULATED_CARGO                              :{WHITE}Cargo/refit information for '{1:ENGINE}' differs from purchase list after construction. This might cause autorenew/-replace to fail refitting correctly

STR_NEWGRF_BUGGY_ENDLESS_PRODUCTION_CALLBACK                    :{WHITE}'{1:STRING}' caused an endless loop in the production callback

# 'User removed essential NewGRFs'-placeholders for stuff without specs

STR_NEWGRF_INVALID_CARGO                                        :<invalid cargo>

STR_NEWGRF_INVALID_CARGO_ABBREV                                 :??

STR_NEWGRF_INVALID_CARGO_QUANTITY                               :{COMMA} of <invalid cargo>

STR_NEWGRF_INVALID_ENGINE                                       :<invalid vehicle model>

STR_NEWGRF_INVALID_INDUSTRYTYPE                                 :<invalid industry>

# Sign list window

STR_SIGN_LIST_CAPTION                                           :{WHITE}Sign List - {COMMA} Sign{P "" s}

STR_SIGN_LIST_MATCH_CASE                                        :{BLACK}Match case

STR_SIGN_LIST_CLEAR                                             :{BLACK}Clear filter

STR_SIGN_LIST_MATCH_CASE_TOOLTIP                                :{BLACK}Toggle matching case when comparing sign names against the filter string

STR_SIGN_LIST_CLEAR_TOOLTIP                                     :{BLACK}Clear filter string

# Sign window

STR_EDIT_SIGN_CAPTION                                           :{WHITE}Edit sign text

STR_EDIT_SIGN_NEXT_SIGN_TOOLTIP                                 :{BLACK}Go to next sign

STR_EDIT_SIGN_PREVIOUS_SIGN_TOOLTIP                             :{BLACK}Go to previous sign

STR_EDIT_SIGN_SIGN_OSKTITLE                                     :{BLACK}Enter a name for the sign

# Town directory window

STR_TOWN_DIRECTORY_CAPTION                                      :{WHITE}Towns

STR_TOWN_DIRECTORY_NONE                                         :{ORANGE}- None -

STR_TOWN_DIRECTORY_TOWN                                         :{ORANGE}{TOWN}{BLACK} ({COMMA})

STR_TOWN_DIRECTORY_LIST_TOOLTIP                                 :{BLACK}Town names - click on name to centre main view on town. Ctrl+Click opens a new viewport on town location

STR_TOWN_POPULATION                                             :{BLACK}World population: {COMMA}

# Town view window

STR_TOWN_VIEW_TOWN_CAPTION                                      :{WHITE}{TOWN}

STR_TOWN_VIEW_CITY_CAPTION                                      :{WHITE}{TOWN} (City)

				}

			}

		}

	}

	return res;

}

/** Helper for scanning for files with GRF as extension */

class GRFFileScanner : FileScanner {

	uint next_update; ///< The next (realtime tick) we do update the screen.

	uint num_scanned; ///< The number of GRFs we have scanned.

public:

	GRFFileScanner() : next_update(_realtime_tick), num_scanned(0)

	{

	}

	/* virtual */ bool AddFile(const char *filename, size_t basepath_length);

	/** Do the scan for GRFs. */

	static uint DoScan()

	{

		GRFFileScanner fs;

	}

};

bool GRFFileScanner::AddFile(const char *filename, size_t basepath_length)

{

	GRFConfig *c = new GRFConfig(filename + basepath_length);

	bool added = true;

	if (FillGRFDetails(c, false)) {

		if (_all_grfs == NULL) {

			_all_grfs = c;

		} else {

			/* Insert file into list at a position determined by its

			 * name, so the list is sorted as we go along */

			GRFConfig **pd, *d;

			bool stop = false;

			for (pd = &_all_grfs; (d = *pd) != NULL; pd = &d->next) {

				if (c->ident.grfid == d->ident.grfid && memcmp(c->ident.md5sum, d->ident.md5sum, sizeof(c->ident.md5sum)) == 0) added = false;

				/* Because there can be multiple grfs with the same name, make sure we checked all grfs with the same name,

				 *  before inserting the entry. So insert a new grf at the end of all grfs with the same name, instead of

				 *  just after the first with the same name. Avoids doubles in the list. */

				if (strcasecmp(c->GetName(), d->GetName()) <= 0) {

					stop = true;

				} else if (stop) {

					break;

				}

			}

			if (added) {

				c->next = d;

				*pd = c;

			}

		}

	} else {

		added = false;

	}

	this->num_scanned++;

	if (this->next_update <= _realtime_tick) {

		_modal_progress_work_mutex->EndCritical();

		_modal_progress_paint_mutex->BeginCritical();

		const char *name = NULL;

		if (c->name != NULL) name = GetGRFStringFromGRFText(c->name->text);

		if (name == NULL) name = c->filename;

		_modal_progress_work_mutex->BeginCritical();

		_modal_progress_paint_mutex->EndCritical();

		this->next_update = _realtime_tick + 200;

	}

	if (!added) {

		/* File couldn't be opened, or is either not a NewGRF or is a

		 * 'system' NewGRF or it's already known, so forget about it. */

		delete c;

	}

	return added;

}

/**

 * Simple sorter for GRFS

 * @param p1 the first GRFConfig *

 * @param p2 the second GRFConfig *

 * @return the same strcmp would return for the name of the NewGRF.

 */

static int CDECL GRFSorter(GRFConfig * const *p1, GRFConfig * const *p2)

{

};

void ScanNewGRFFiles(NewGRFScanCallback *callback);

void CheckForMissingSprites();

const GRFConfig *FindGRFConfig(uint32 grfid, FindGRFConfigMode mode, const uint8 *md5sum = NULL, uint32 desired_version = 0);

GRFConfig *GetGRFConfig(uint32 grfid, uint32 mask = 0xFFFFFFFF);

GRFConfig **CopyGRFConfigList(GRFConfig **dst, const GRFConfig *src, bool init_only);

void AppendStaticGRFConfigs(GRFConfig **dst);

void AppendToGRFConfigList(GRFConfig **dst, GRFConfig *el);

void ClearGRFConfigList(GRFConfig **config);

void ResetGRFConfig(bool defaults);

GRFListCompatibility IsGoodGRFConfigList(GRFConfig *grfconfig);

bool FillGRFDetails(GRFConfig *config, bool is_static);

char *GRFBuildParamList(char *dst, const GRFConfig *c, const char *last);

/* In newgrf_gui.cpp */

void ShowNewGRFSettings(bool editable, bool show_params, bool exec_changes, GRFConfig **config);

#ifdef ENABLE_NETWORK

/** For communication about GRFs over the network */

#define UNKNOWN_GRF_NAME_PLACEHOLDER "<Unknown>"

GRFTextWrapper *FindUnknownGRFName(uint32 grfid, uint8 *md5sum, bool create);

#endif /* ENABLE_NETWORK */

#endif /* NEWGRF_CONFIG_H */

		nw->avails.ForceRebuild();

		w->InvalidateData();

		ReInitAllWindows();

		DeleteWindowByClass(WC_BUILD_OBJECT);

	}

}

/**

 * Setup the NewGRF gui

 * @param editable allow the user to make changes to the grfconfig in the window

 * @param show_params show information about what parameters are set for the grf files

 * @param exec_changes if changes are made to the list (editable is true), apply these

 *        changes immediately or only update the list

 * @param config pointer to a linked-list of grfconfig's that will be shown

 */

void ShowNewGRFSettings(bool editable, bool show_params, bool exec_changes, GRFConfig **config)

{

	DeleteWindowByClass(WC_GAME_OPTIONS);

	new NewGRFWindow(&_newgrf_desc, editable, show_params, exec_changes, config);

}

	bool   population_in_label;              ///< show the population of a town in his label?

	uint8  right_mouse_btn_emulation;        ///< should we emulate right mouse clicking?

	uint8  scrollwheel_scrolling;            ///< scrolling using the scroll wheel?

	uint8  scrollwheel_multiplier;           ///< how much 'wheel' per incoming event from the OS?

	bool   timetable_arrival_departure;      ///< show arrivals and departures in vehicle timetables

	bool   left_mouse_btn_scrolling;         ///< left mouse button scroll

	bool   pause_on_newgame;                 ///< whether to start new games paused or not

	bool   enable_signal_gui;                ///< show the signal GUI when the signal button is pressed

	Year   coloured_news_year;               ///< when does newspaper become coloured?

	bool   timetable_in_ticks;               ///< whether to show the timetable in ticks rather than days

	bool   quick_goto;                       ///< Allow quick access to 'goto button' in vehicle orders window

	bool   auto_euro;                        ///< automatically switch to euro in 2002

	byte   drag_signals_density;             ///< many signals density

	Year   semaphore_build_before;           ///< build semaphore signals automatically before this year

	byte   news_message_timeout;             ///< how much longer than the news message "age" should we keep the message in the history

	bool   show_track_reservation;           ///< highlight reserved tracks.

	uint8  default_signal_type;              ///< the signal type to build by default.

	uint8  cycle_signal_types;               ///< what signal types to cycle with the build signal tool.

	byte   station_numtracks;                ///< the number of platforms to default on for rail stations

	byte   station_platlength;               ///< the platform length, in tiles, for rail stations

	bool   station_dragdrop;                 ///< whether drag and drop is enabled for stations

	bool   station_show_coverage;            ///< whether to highlight coverage area

	bool   persistent_buildingtools;         ///< keep the building tools active after usage

	bool   expenses_layout;                  ///< layout of expenses window

	uint16 console_backlog_timeout;          ///< the minimum amount of time items should be in the console backlog before they will be removed in ~3 seconds granularity.

	uint16 console_backlog_length;           ///< the minimum amount of items in the console backlog before items will be removed.

#ifdef ENABLE_NETWORK

	uint16 network_chat_box_width;           ///< width of the chat box in pixels

	uint8  network_chat_box_height;          ///< height of the chat box in lines

	uint16 network_chat_timeout;             ///< timeout of chat messages in seconds

#endif

	uint8  developer;                        ///< print non-fatal warnings in console (>= 1), copy debug output to console (== 2)

	bool   show_date_in_logs;                ///< whether to show dates in console logs

	bool   newgrf_developer_tools;           ///< activate NewGRF developer tools and allow modifying NewGRFs in an existing game

	bool   ai_developer_tools;               ///< activate AI developer tools

	bool   scenario_developer;               ///< activate scenario developer: allow modifying NewGRFs in an existing game

	bool   newgrf_show_old_versions;         ///< whether to show old versions in the NewGRF list

	uint8  newgrf_default_palette;           ///< default palette to use for NewGRFs without action 14 palette information

	/**

	 * Returns true when the user has sufficient privileges to edit newgrfs on a running game

	 * @return whether the user has sufficient privileges to edit newgrfs in an existing game

	 */

	bool UserIsAllowedToChangeNewGRFs() const

	{

		return this->scenario_developer || this->newgrf_developer_tools;

[SDTC_BOOL]

var      = gui.station_dragdrop

flags    = SLF_NOT_IN_SAVE | SLF_NO_NETWORK_SYNC

def      = true

[SDTC_BOOL]

var      = gui.station_show_coverage

flags    = SLF_NOT_IN_SAVE | SLF_NO_NETWORK_SYNC

def      = false

[SDTC_BOOL]

var      = gui.persistent_buildingtools

flags    = SLF_NOT_IN_SAVE | SLF_NO_NETWORK_SYNC

def      = true

str      = STR_CONFIG_SETTING_PERSISTENT_BUILDINGTOOLS

[SDTC_BOOL]

var      = gui.expenses_layout

flags    = SLF_NOT_IN_SAVE | SLF_NO_NETWORK_SYNC

def      = false

str      = STR_CONFIG_SETTING_EXPENSES_LAYOUT

proc     = RedrawScreen

; For the dedicated build we'll enable dates in logs by default.

[SDTC_BOOL]

ifdef    = DEDICATED

var      = gui.show_date_in_logs

flags    = SLF_NOT_IN_SAVE | SLF_NO_NETWORK_SYNC

def      = true

[SDTC_BOOL]

ifndef   = DEDICATED

var      = gui.show_date_in_logs

flags    = SLF_NOT_IN_SAVE | SLF_NO_NETWORK_SYNC

def      = false

[SDTC_VAR]

var      = gui.developer

type     = SLE_UINT8

flags    = SLF_NOT_IN_SAVE | SLF_NO_NETWORK_SYNC

def      = 1

min      = 0

max      = 2

[SDTC_BOOL]

var      = gui.newgrf_developer_tools