STR_CONFIG_PATCHES_TOWN_LAYOUT_DEFAULT                          :default

STR_CONFIG_PATCHES_TOWN_LAYOUT_BETTER_ROADS                     :better roads

STR_CONFIG_PATCHES_TOWN_LAYOUT_2X2_GRID                         :2x2 grid

STR_CONFIG_PATCHES_TOWN_LAYOUT_3X3_GRID                         :3x3 grid

STR_CONFIG_PATCHES_TOWN_LAYOUT_RANDOM                           :random

STR_CONFIG_PATCHES_TOOLBAR_POS                                  :{LTBLUE}Position of main toolbar: {ORANGE}{STRING1}

STR_CONFIG_PATCHES_TOOLBAR_POS_LEFT                             :Left

STR_CONFIG_PATCHES_TOOLBAR_POS_CENTER                           :Centre

STR_CONFIG_PATCHES_TOOLBAR_POS_RIGHT                            :Right

STR_CONFIG_PATCHES_SNAP_RADIUS                                  :{LTBLUE}Window snap radius: {ORANGE}{STRING1} px

STR_CONFIG_PATCHES_SNAP_RADIUS_DISABLED                         :{LTBLUE}Window snap radius: {ORANGE}disabled

STR_CONFIG_PATCHES_TOWN_GROWTH                                  :{LTBLUE}Town growth speed: {ORANGE}{STRING1}

STR_CONFIG_PATCHES_TOWN_GROWTH_NONE                             :None

STR_CONFIG_PATCHES_TOWN_GROWTH_SLOW                             :Slow

STR_CONFIG_PATCHES_TOWN_GROWTH_NORMAL                           :Normal

STR_CONFIG_PATCHES_TOWN_GROWTH_FAST                             :Fast

STR_CONFIG_PATCHES_TOWN_GROWTH_VERY_FAST                        :Very fast

STR_CONFIG_PATCHES_LARGER_TOWNS                                 :{LTBLUE}Proportion of towns that will become cities: {ORANGE}1 in {STRING1}

STR_CONFIG_PATCHES_LARGER_TOWNS_DISABLED                        :{LTBLUE}Proportion of towns that will become cities: {ORANGE}None

STR_CONFIG_PATCHES_CITY_SIZE_MULTIPLIER                         :{LTBLUE}Initial city size multiplier: {ORANGE}{STRING1}

STR_CONFIG_MODIFIED_ROAD_REBUILD                                :{LTBLUE}Remove absurd road-elements during the road construction

STR_CONFIG_PATCHES_GUI                                          :{BLACK}Interface

	SDTC_OMANY(gui.date_format_in_default_names,SLE_UINT8,S,MS, 0, 2, "long|short|iso",       STR_CONFIG_PATCHES_DATE_FORMAT_IN_SAVE_NAMES,   NULL),

	 SDTC_BOOL(gui.vehicle_speed,                        S,  0,  true,                        STR_CONFIG_PATCHES_VEHICLESPEED,                NULL),

	 SDTC_BOOL(gui.status_long_date,                     S,  0,  true,                        STR_CONFIG_PATCHES_LONGDATE,                    NULL),

	 SDTC_BOOL(gui.show_finances,                        S,  0,  true,                        STR_CONFIG_PATCHES_SHOWFINANCES,                NULL),

	 SDTC_BOOL(gui.autoscroll,                           S,  0, false,                        STR_CONFIG_PATCHES_AUTOSCROLL,                  NULL),

	 SDTC_BOOL(gui.reverse_scroll,                       S,  0, false,                        STR_CONFIG_PATCHES_REVERSE_SCROLLING,           NULL),

	 SDTC_BOOL(gui.smooth_scroll,                        S,  0, false,                        STR_CONFIG_PATCHES_SMOOTH_SCROLLING,            NULL),

	 SDTC_BOOL(gui.left_mouse_btn_scrolling,             S,  0, false,                        STR_CONFIG_PATCHES_LEFT_MOUSE_BTN_SCROLLING,    NULL),

	 SDTC_BOOL(gui.measure_tooltip,                      S,  0, false,                        STR_CONFIG_PATCHES_MEASURE_TOOLTIP,             NULL),

	  SDTC_VAR(gui.errmsg_duration,           SLE_UINT8, S,  0,     5,        0,       20, 0, STR_CONFIG_PATCHES_ERRMSG_DURATION,             NULL),

	  SDTC_VAR(gui.toolbar_pos,               SLE_UINT8, S, MS,     0,        0,        2, 0, STR_CONFIG_PATCHES_TOOLBAR_POS,                 v_PositionMainToolbar),

	  SDTC_VAR(gui.window_snap_radius,        SLE_UINT8, S, D0,    10,        1,       32, 0, STR_CONFIG_PATCHES_SNAP_RADIUS,                 NULL),

	 SDTC_BOOL(gui.population_in_label,                  S,  0,  true,                        STR_CONFIG_PATCHES_POPULATION_IN_LABEL,         PopulationInLabelActive),

	 SDTC_BOOL(gui.link_terraform_toolbar,               S,  0, false,                        STR_CONFIG_PATCHES_LINK_TERRAFORM_TOOLBAR,      NULL),

	  SDTC_VAR(gui.liveries,                  SLE_UINT8, S, MS,     2,        0,        2, 0, STR_CONFIG_PATCHES_LIVERIES,                    RedrawScreen),

	 SDTC_BOOL(gui.prefer_teamchat,                      S,  0, false,                        STR_CONFIG_PATCHES_PREFER_TEAMCHAT,             NULL),

	  SDTC_VAR(gui.scrollwheel_scrolling,     SLE_UINT8, S, MS,     0,        0,        2, 0, STR_CONFIG_PATCHES_SCROLLWHEEL_SCROLLING,       NULL),

	  SDTC_VAR(gui.scrollwheel_multiplier,    SLE_UINT8, S,  0,     5,        1,       15, 1, STR_CONFIG_PATCHES_SCROLLWHEEL_MULTIPLIER,      NULL),

	 SDTC_BOOL(gui.pause_on_newgame,                     S,  0, false,                        STR_CONFIG_PATCHES_PAUSE_ON_NEW_GAME,           NULL),

	  SDTC_VAR(gui.advanced_vehicle_list,     SLE_UINT8, S, MS,     1,        0,        2, 0, STR_CONFIG_PATCHES_ADVANCED_VEHICLE_LISTS,      NULL),

	 SDTC_BOOL(gui.timetable_in_ticks,                   S,  0, false,                        STR_CONFIG_PATCHES_TIMETABLE_IN_TICKS,          NULL),

	 SDTC_BOOL(gui.quick_goto,                           S,  0, false,                        STR_CONFIG_PATCHES_QUICKGOTO,                   NULL),

	  SDTC_VAR(gui.loading_indicators,        SLE_UINT8, S, MS,     1,        0,        2, 0, STR_CONFIG_PATCHES_LOADING_INDICATORS,          RedrawScreen),

	  SDTC_VAR(gui.default_rail_type,         SLE_UINT8, S, MS,     4,        0,        6, 0, STR_CONFIG_PATCHES_DEFAULT_RAIL_TYPE,           NULL),

static const char *_patches_ui[] = {

	"gui.vehicle_speed",

	"gui.status_long_date",

	"gui.date_format_in_default_names",

	"gui.show_finances",

	"gui.autoscroll",

	"gui.reverse_scroll",

	"gui.smooth_scroll",

	"gui.errmsg_duration",

	"gui.toolbar_pos",

	"gui.measure_tooltip",

	"gui.window_snap_radius",

	"gui.population_in_label",

	"gui.link_terraform_toolbar",

	"gui.liveries",

	"gui.prefer_teamchat",

	/* While the horizontal scrollwheel scrolling is written as general code, only

	 *  the cocoa (OSX) driver generates input for it.

	 *  Since it's also able to completely disable the scrollwheel will we display it on all platforms anyway */

	"gui.scrollwheel_scrolling",

	"gui.scrollwheel_multiplier",

#ifdef __APPLE__

	/* We might need to emulate a right mouse button on mac */

	"gui.right_mouse_btn_emulation",

	byte   errmsg_duration;                  ///< duration of error message

	bool   link_terraform_toolbar;           ///< display terraform toolbar when displaying rail, road, water and airport toolbars

	bool   reverse_scroll;                   ///< right-Click-Scrolling scrolls in the opposite direction

	bool   smooth_scroll;                    ///< smooth scroll viewports

	bool   measure_tooltip;                  ///< show a permanent tooltip when dragging tools

	byte   liveries;                         ///< options for displaying company liveries, 0=none, 1=self, 2=all

	bool   prefer_teamchat;                  ///< choose the chat message target with <ENTER>, true=all clients, false=your team

	uint8  advanced_vehicle_list;            ///< use the "advanced" vehicle list

	uint8  loading_indicators;               ///< show loading indicators

	uint8  default_rail_type;                ///< the default rail type for the rail GUI

	uint8  toolbar_pos;                      ///< position of toolbars, 0=left, 1=center, 2=right

	uint8  window_snap_radius;               ///< windows snap at each other if closer than this

	bool   always_build_infrastructure;      ///< always allow building of infrastructure, even when you do not have the vehicles for it

	byte   autosave;                         ///< how often should we do autosaves?

	bool   keep_all_autosave;                ///< name the autosave in a different way

	bool   autosave_on_exit;                 ///< save an autosave when you quit the game, but do not ask "Do you really want to quit?"

	uint8  date_format_in_default_names;     ///< should the default savegame/screenshot name use long dates (31th Dec 2008), short dates (31-12-2008) or ISO dates (2008-12-31)

	byte   max_num_autosaves;                ///< controls how many autosavegames are made before the game starts to overwrite (names them 0 to max_num_autosaves - 1)

	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   left_mouse_btn_scrolling;         ///< left mouse button scroll

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

	vp->scrollpos_x = pt.x;

	vp->scrollpos_y = pt.y;

	vp->dest_scrollpos_x = pt.x;

	vp->dest_scrollpos_y = pt.y;

	w->viewport = vp;

	vp->virtual_left = 0;//pt.x;

	vp->virtual_top = 0;//pt.y;

}

static Point _vp_move_offs;

{

		if (left + width > w->left &&

				w->left + w->width > left &&

				top + height > w->top &&

				w->top + w->height > top) {

			if (left < w->left) {

				return;

			}

			if (left + width > w->left + w->width) {

				return;

			}

			if (top < w->top) {

				return;

			}

			if (top + height > w->top + w->height) {

				return;

			}

			return;

		}

	}

	{

		int xo = _vp_move_offs.x;

		int yo = _vp_move_offs.y;

		if (abs(xo) >= width || abs(yo) >= height) {

	i = left + width - _screen.width;

	if (i >= 0) width -= i;

	if (width > 0) {

		if (top < 0) {

			height += top;

			top = 0;

		}

		i = top + height - _screen.height;

		if (i >= 0) height -= i;

	}

}

/**

 * Is a xy position inside the viewport of the window?

 * @param w Window to examine its viewport

 * @param x X coordinate of the xy position

 * @param y Y coordinate of the xy position

 * @return Pointer to the viewport if the xy position is in the viewport of the window,

 *         otherwise \c NULL is returned.

 */

ViewPort *IsPtInWindowViewport(const Window *w, int x, int y)

#include "settings_type.h"

#include "cheat_func.h"

#include "window_func.h"

#include "tilehighlight_func.h"

#include "network/network.h"

#include "querystring_gui.h"

#include "table/sprites.h"

static Point _drag_delta; ///< delta between mouse cursor and upper left corner of dragged window

static Window *_mouseover_last_w = NULL; ///< Window of the last MOUSEOVER event

byte _no_scroll;

Point _cursorpos_drag_start;

int _scrollbar_start_pos;

int _scrollbar_size;

byte _scroller_click_timeout;

bool _scrolling_scrollbar;

bool _scrolling_viewport;

byte _special_mouse_mode;

		if (sb->count > sb->cap) {

			int pos = Clamp(sb->pos + wheel, 0, sb->count - sb->cap);

			if (pos != sb->pos) {

				sb->pos = pos;

				w->SetDirty();

			}

		}

	}

}

/**

 *

 * The function goes recursively upwards in the window stack, and splits the rectangle

 * into multiple pieces at the window edges, so obscured parts are not redrawn.

 *

 * @param left Left edge of the rectangle that should be repainted

 * @param top Top edge of the rectangle that should be repainted

 * @param right Right edge of the rectangle that should be repainted

 * @param bottom Bottom edge of the rectangle that should be repainted

 */

{

		if (right > v->left &&

				bottom > v->top &&

				left < v->left + v->width &&

				top < v->top + v->height) {

			/* v and rectangle intersect with eeach other */

			int x;

			if (left < (x = v->left)) {

				return;

			}

			if (right > (x = v->left + v->width)) {

				return;

			}

			if (top < (x = v->top)) {

				return;

			}

			if (bottom > (x = v->top + v->height)) {

				return;

			}

			return;

		}

	}

	/* Setup blitter, and dispatch a repaint event to window *wz */

	DrawPixelInfo *dp = _cur_dpi;

	dp->width = right - left;

	dp->height = bottom - top;

	dp->pitch = _screen.pitch;

	dp->dst_ptr = BlitterFactoryBase::GetCurrentBlitter()->MoveTo(_screen.dst_ptr, left, top);

	dp->zoom = ZOOM_LVL_NORMAL;

}

/**

 * From a rectangle that needs redrawing, find the windows that intersect with the rectangle.

 * These windows should be re-painted.

 * @param left Left edge of the rectangle that should be repainted

 * @param top Top edge of the rectangle that should be repainted

 * @param right Right edge of the rectangle that should be repainted

 * @param bottom Bottom edge of the rectangle that should be repainted

 */

void DrawOverlappedWindowForAll(int left, int top, int right, int bottom)

{

	DrawPixelInfo bk;

	_cur_dpi = &bk;

	FOR_ALL_WINDOWS_FROM_BACK(w) {

		if (right > w->left &&

				bottom > w->top &&

				left < w->left + w->width &&

				top < w->top + w->height) {

			/* Window w intersects with the rectangle => needs repaint */

		}

	}

}

/**

 * Mark entire window as dirty (in need of re-paint)

 * @ingroup dirty

 */

void Window::SetDirty() const

{

	SetDirtyBlocks(this->left, this->top, this->left + this->width, this->top + this->height);

}

 * @param w parent Window to find child of

 * @return a Window pointer that is the child of w, or NULL otherwise */

static Window *FindChildWindow(const Window *w)

{

	Window *v;

	FOR_ALL_WINDOWS_FROM_BACK(v) {

		if (v->parent == w) return v;

	}

	return NULL;

}

/**

 * Delete all children a window might have in a head-recursive manner

 */

void Window::DeleteChildWindows() const

{

	Window *child = FindChildWindow(this);

	while (child != NULL) {

		delete child;

		child = FindChildWindow(this);

	}

}

			_thd.window_class == this->window_class &&

			_thd.window_number == this->window_number) {

		ResetObjectToPlace();

	}

	/* Prevent Mouseover() from resetting mouse-over coordinates on a non-existing window */

	if (_mouseover_last_w == this) _mouseover_last_w = NULL;

	/* Find the window in the z-array, and effectively remove it

	 * by moving all windows after it one to the left. This must be

	 * done before removing the child so we cannot cause recursion

	 * between the deletion of the parent and the child. */

	this->DeleteChildWindows();

	if (this->viewport != NULL) DeleteWindowViewport(this);

	this->SetDirty();

	if (this->widget != NULL) {

		for (const Widget *wi = this->widget; wi->type != WWT_LAST; wi++) {

			if (wi->type == WWT_EDITBOX) _no_scroll--;

		}

		free(this->widget);

			case WC_AIRCRAFT_LIST:

			case WC_BUY_COMPANY:

			case WC_COMPANY:

				continue;

			default:

				w->caption_color = new_owner;

				break;

		}

	}

}

/** Find a window and make it the top-window on the screen. The window

 * gets a white border for a brief period of time to visualize its "activation"

 * @param cls WindowClass of the window to activate

 * @param number WindowNumber of the window to activate

 * @return a pointer to the window thus activated */

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

{

	Window *w = FindWindowById(cls, number);

	if (w != NULL) {

		w->flags4 |= WF_WHITE_BORDER_MASK;

			return false;

	}

}

/** On clicking on a window, make it the frontmost window of all. However

 * there are certain windows that always need to be on-top; these include

 * - Toolbar, Statusbar (always on)

 * - New window, Chatbar (only if open)

 * The window is marked dirty for a repaint if the window is actually moved

 * @param w window that is put into the foreground

 * @return pointer to the window, the same as the input pointer

 */

{

	/* Bring the window just below the vital windows */

	w->SetDirty();

}

/**

 * Assign widgets to a new window by initialising its widget pointers, and by

 * copying the widget array \a widget to \c w->widget to allow for resizable

 * windows.

 * @param w Window on which to attach the widget array

 * @param widget pointer of widget array to fill the window with

 *

 * @post \c w->widget points to allocated memory and contains the copied widget array except for the terminating widget,

 *       \c w->widget_count contains number of widgets in the allocated memory.

 */

static void AssignWidgetToWindow(Window *w, const Widget *widget)

{

 * @param x offset in pixels from the left of the screen

 * @param y offset in pixels from the top of the screen

 * @param min_width minimum width in pixels of the window

 * @param min_height minimum height in pixels of the window

 * @param cls see WindowClass class of the window, used for identification and grouping

 * @param *widget see Widget pointer to the window layout and various elements

 * @param window_number number being assigned to the new window

 * @return Window pointer of the newly created window

 */

void Window::Initialize(int x, int y, int min_width, int min_height,

				WindowClass cls, const Widget *widget, int window_number)

{

	/* Set up window properties */

	this->window_class = cls;

	this->flags4 = WF_WHITE_BORDER_MASK; // just opened windows have a white border

	this->caption_color = 0xFF;

	this->left = x;

	this->top = y;

	this->width = min_width;

	this->height = min_height;

	AssignWidgetToWindow(this, widget);

	this->resize.width = min_width;

	this->resize.height = min_height;

	this->resize.step_width = 1;

	this->resize.step_height = 1;

	this->window_number = window_number;

	/* Hacky way of specifying always-on-top windows. These windows are

		* always above other windows because they are moved below them.

		* status-bar is above news-window because it has been created earlier.

		* Also, as the chat-window is excluded from this, it will always be

		* the last window, thus always on top.

		* XXX - Yes, ugly, probably needs something like w->always_on_top flag

		* to implement correctly, but even then you need some kind of distinction

		* between on-top of chat/news and status windows, because these conflict */

	}

}

/**

 * Resize window towards the default size.

 * Prior to construction, a position for the new window (for its default size)

 * has been found with LocalGetWindowPlacement(). Initially, the window is

 * constructed with minimal size. Resizing the window to its default size is

 * done here.

 * @param def_width default width in pixels of the window

 * @param def_height default height in pixels of the window

 * @see Window::Window(), Window::Initialize()

 */

	}

	return NULL;

}

/**

 * (re)initialize the windowing system

 */

void InitWindowSystem()

{

	IConsoleClose();

	_mouseover_last_w = NULL;

	_no_scroll = 0;

	_scrolling_viewport = 0;

}

/**

 * Close down the windowing system

 */

void UnInitWindowSystem()

{

}

/**

 * Reset the windowing system, by means of shutting it down followed by re-initialization

 */

void ResetWindowSystem()

{

	UnInitWindowSystem();

	InitWindowSystem();

	_thd.pos.x = 0;

	_thd.pos.y = 0;

	_thd.new_pos.x = 0;

	_cursor.delta.y = 0;

	return false;

}

/** Check if a window can be made top-most window, and if so do

 * it. If a window does not obscure any other windows, it will not

 * be brought to the foreground. Also if the only obscuring windows

 * are so-called system-windows, the window will not be moved.

 * The function will return false when a child window of this window is a

 * modal-popup; function returns a false and child window gets a white border

 * @param w Window to bring on-top

 * @return false if the window has an active modal child, true otherwise */

{

	bool bring_to_front = false;

	if (w->window_class == WC_MAIN_WINDOW ||

			IsVitalWindow(w) ||

			w->window_class == WC_TOOLTIPS ||

			w->window_class == WC_DROPDOWN_MENU) {

		return true;

	}

		/* A modal child will prevent the activation of the parent window */

		if (u->parent == w && (u->desc_flags & WDF_MODAL)) {

			u->flags4 |= WF_WHITE_BORDER_MASK;

			u->SetDirty();

			return false;

		}

		if (u->window_class == WC_MAIN_WINDOW ||

				IsVitalWindow(u) ||

				u->window_class == WC_TOOLTIPS ||

				u->window_class == WC_DROPDOWN_MENU) {

			continue;

	int mousewheel = 0;

	if (_cursor.wheel) {

		mousewheel = _cursor.wheel;

		_cursor.wheel = 0;

		_input_events_this_tick++;

	}

	MouseLoop(click, mousewheel);

}

/**