Index: ps/trunk/build/premake/extern_libs4.lua
===================================================================
--- ps/trunk/build/premake/extern_libs4.lua	(revision 14952)
+++ ps/trunk/build/premake/extern_libs4.lua	(revision 14953)
@@ -1,737 +1,799 @@
 -- this file provides project_add_extern_libs, which takes care of the
 -- dirty details of adding the libraries' include and lib paths.
 --
 -- TYPICAL TASK: add new library. Instructions:
 -- 1) add a new extern_lib_defs entry
 -- 2) add library name to extern_libs tables in premake.lua for all 'projects' that want to use it
 
 
 -- directory in which OS-specific library subdirectories reside.
 if os.is("macosx") then
 	libraries_dir = rootdir.."/libraries/osx/"
 elseif os.is("windows") then
 	libraries_dir = rootdir.."/libraries/win32/"
 else
 	-- No Unix-specific libs yet (use source directory instead!)
 end
 -- directory for shared, bundled libraries
 libraries_source_dir = rootdir.."/libraries/source/"
+third_party_source_dir = rootdir.."/source/third_party/"
 
 local function add_default_lib_paths(extern_lib)
 	libdirs { libraries_dir .. extern_lib .. "/lib" }
 end
 
 local function add_source_lib_paths(extern_lib)
 	libdirs { libraries_source_dir .. extern_lib .. "/lib" }
 end
 
 local function add_default_include_paths(extern_lib)
 	includedirs { libraries_dir .. extern_lib .. "/include" }
 end
 
 local function add_source_include_paths(extern_lib)
 	includedirs { libraries_source_dir .. extern_lib .. "/include" }
 end
 
+local function add_third_party_include_paths(extern_lib)
+	includedirs { third_party_source_dir .. extern_lib .. "/include" }
+end
+
 
 -- For unixes: add buildflags and linkflags using pkg-config or another similar command.
 -- By default, pkg-config is used. Other commands can be passed as "alternative_cmd".
 -- Running such commands at build/linktime does not work on all environments.
 -- For those environments where it does not work, we already run it now.
 -- Any better ideas?
 local function pkgconfig_cflags(lib, alternative_cmd)
 	local cmd_cflags = ""
 	local result_cflags
 	if not alternative_cmd then
 		cmd_cflags = "pkg-config "..lib.." --cflags"
 	else
 		cmd_cflags = alternative_cmd
 	end
 
 	if _ACTION == "xcode3" or _ACTION == "xcode4" then
 		result_cflags = string.gsub(os.capture(cmd_cflags), "\n", "")
 		buildoptions { result_cflags }
 	else
 		buildoptions { "`"..cmd_cflags.."`" }
 	end
 end
 
 local function pkgconfig_libs(lib, alternative_cmd)
 	local cmd_libs = ""
 	local result_libs
 	if not alternative_cmd then
 		cmd_libs = "pkg-config "..lib.." --libs"
 	else
 		cmd_libs = alternative_cmd
 	end
 
 	if _ACTION == "xcode3" or _ACTION == "xcode4" then
 		-- The syntax of -Wl with the comma separated list doesn't work and -Wl apparently isn't needed in xcode.
 		-- This is a hack, but it works...
 		result_libs = string.gsub(os.capture(cmd_libs), "-Wl", "")
 		result_libs = string.gsub(result_libs, ",", " ")
 		result_libs = string.gsub(result_libs, "\n", "")
 		linkoptions { result_libs }
 	elseif _ACTION == "gmake" then	
 		gnuexternals { "`"..cmd_libs.."`" }
 	else
 		linkoptions { "`"..cmd_libs.."`" }
 	end
 end
 
 function os.capture(cmd)
 	local f = io.popen(cmd, 'r')
 	local s = f:read('*a')
 	return s
 end
 
 local function add_delayload(name, suffix, def)
 
 	if def["no_delayload"] then
 		return
 	end
 
 	-- currently only supported by VC; nothing to do on other platforms.
 	if not os.is("windows") then
 		return
 	end
 
 	-- no extra debug version; use same library in all configs
 	if suffix == "" then
 		linkoptions { "/DELAYLOAD:"..name..".dll" }
 	-- extra debug version available; use in debug config
 	else
 		local dbg_cmd = "/DELAYLOAD:" .. name .. suffix .. ".dll"
 		local cmd     = "/DELAYLOAD:" .. name .. ".dll"
 
 		configuration "Debug"
 			linkoptions { dbg_cmd }
 		configuration "Release"
 			linkoptions { cmd }
 		configuration { }
 	end
 
 end
 
 local function add_default_links(def)
 
 	-- careful: make sure to only use *_names when on the correct platform.
 	local names = {}
 	if os.is("windows") then
 		if def.win_names then
 			names = def.win_names
 		end
 	elseif _OPTIONS["android"] and def.android_names then
 		names = def.android_names
 	elseif os.is("linux") and def.linux_names then
 		names = def.linux_names
 	elseif os.is("macosx") and def.osx_names then
 		names = def.osx_names
 	elseif os.is("bsd") and def.bsd_names then
 		names = def.bsd_names
 	elseif def.unix_names then
 		names = def.unix_names
 	end
 
 	local suffix = "d"
 	-- library is overriding default suffix (typically "" to indicate there is none)
 	if def["dbg_suffix"] then
 		suffix = def["dbg_suffix"]
 	end
 	-- non-Windows doesn't have the distinction of debug vs. release libraries
 	-- (to be more specific, they do, but the two are binary compatible;
 	-- usually only one type - debug or release - is installed at a time).
 	if not os.is("windows") then
 		suffix = ""
 	end
 
 	-- OS X "Frameworks" need to be added in a special way to the link
 	-- i.e. by linkoptions += "-framework ..."
 	if os.is("macosx") and def.osx_frameworks then
 		for i,name in pairs(def.osx_frameworks) do
 			linkoptions { "-framework " .. name }
 		end
 	else
 		for i,name in pairs(names) do
 			configuration "Debug"
 				links { name .. suffix }
 			configuration "Release"
 				links { name }
 			configuration { }
 
 			add_delayload(name, suffix, def)
 		end
 	end
 end
 
 -- Library definitions
 -- In a perfect world, libraries would have a common installation template,
 -- i.e. location of include directory, naming convention for .lib, etc.
 -- this table provides a means of working around each library's differences.
 --
 -- The basic approach is defining two functions per library:
 --
 -- 1. compile_settings
 -- This function should set all settings requred during the compile-phase like
 -- includedirs, defines etc...
 --
 -- 2. link_settings
 -- This function should set all settings required during the link-phase like
 -- libdirs, linkflag etc...
 --
 -- The main reason for separating those settings is different linking behaviour
 -- on osx and xcode. For more details, read the comment in project_add_extern_libs.
 --
 -- There are some helper functions for the most common tasks. You should use them
 -- if they can be used in your situation to make the definitions more consistent and
 -- use their default beviours as a guideline.
 --
 --
 -- add_default_lib_paths(extern_lib)
 --      Description: Add '<libraries root>/<libraryname>/lib'to the libpaths
 --      Parameters:
 --          * extern_lib: <libraryname> to be used in the libpath.
 --
 -- add_default_include_paths(extern_lib)
 --      Description: Add '<libraries root>/<libraryname>/include' to the includepaths
 --      Parameters:
 --          * extern_lib: <libraryname> to be used in the libpath.
 --
 -- add_default_links
 --		Description: Adds links to libraries and configures delayloading.
 -- 		If the *_names parameter for a plattform is missing, no linking will be done
 -- 		on that plattform.
 --		The default assumptions are:
 --		* debug import library and DLL are distinguished with a "d" suffix
 -- 		* the library should be marked for delay-loading.
 --		Parameters:
 --      * win_names: table of import library / DLL names (no extension) when
 --   	  running on Windows.
 --      * unix_names: as above; shared object names when running on non-Windows.
 --      * osx_names: as above; for OS X specifically (overrides unix_names if both are
 --        specified)
 --      * bsd_names: as above; for BSD specifically (overrides unix_names if both are
 --        specified)
 --      * linux_names: ditto for Linux (overrides unix_names if both given)
 --      * dbg_suffix: changes the debug suffix from the above default.
 --        can be "" to indicate the library doesn't have a debug build;
 --        in that case, the same library (without suffix) is used in
 --        all build configurations.
 --      * no_delayload: indicate the library is not to be delay-loaded.
 --        this is necessary for some libraries that do not support it,
 --        e.g. Xerces (which is so stupid as to export variables).
 
 extern_lib_defs = {
 	boost = {
 		compile_settings = function()
 			if os.is("windows") then
 				add_default_include_paths("boost")
 			elseif os.is("macosx") then
 				-- Suppress all the Boost warnings on OS X by including it as a system directory
 				buildoptions { "-isystem../" .. libraries_dir .. "boost/include" }
 			end
 			if os.getversion().description == "OpenBSD" then
 				includedirs { "/usr/local/include" }
 			end
 		end,
 		link_settings = function()
 			if os.is("windows") or os.is("macosx") then
 				add_default_lib_paths("boost")
 			end
 			add_default_links({
 				-- The following are not strictly link dependencies on all systems, but
 				-- are included for compatibility with different versions of Boost
 				android_names = { "boost_filesystem-gcc-mt", "boost_system-gcc-mt" },
 				unix_names = { os.findlib("boost_filesystem-mt") and "boost_filesystem-mt" or "boost_filesystem", os.findlib("boost_system-mt") and "boost_system-mt" or "boost_system" },
 				osx_names = { "boost_filesystem-mt", "boost_system-mt" },
 			})
 		end,
 	},
 	boost_signals = {
 		link_settings = function()
 			add_default_links({
 				android_names = { "boost_signals-gcc-mt" },
 				unix_names = { os.findlib("boost_signals-mt") and "boost_signals-mt" or "boost_signals" },
 				osx_names = { "boost_signals-mt" },
 			})
 		end,
 	},
 	comsuppw = {
 		link_settings = function()
 			add_default_links({
 				win_names = { "comsuppw" },
 				dbg_suffix = "d",
 				no_delayload = 1,
 			})
 		end,
 	},
 	cxxtest = {
 		compile_settings = function()
 			includedirs { libraries_source_dir .. "cxxtest-4.3" }
 		end,
 		link_settings = function()
 			add_source_lib_paths("cxxtest-4.3")
 		end,
 	},
 	enet = {
 		compile_settings = function()
 			if not _OPTIONS["with-system-enet"] then
 				add_source_include_paths("enet")
 			end
 		end,
 		link_settings = function()
 			if not _OPTIONS["with-system-enet"] then
 				add_source_lib_paths("enet")
 			end
 			add_default_links({
 				win_names  = { "enet" },
 				unix_names = { "enet" },
 			})
 		end,
 	},
 	fcollada = {
 		compile_settings = function()
 			add_source_include_paths("fcollada")
 		end,
 		link_settings = function()
 			add_source_lib_paths("fcollada")
 			if os.is("windows") then
 				configuration "Debug"
 					links { "FColladaD" }
 				configuration "Release"
 					links { "FCollada" }
 			 	configuration { }
 			else
 				configuration "Debug"
 					links { "FColladaSD" }
 				configuration "Release"
 					links { "FColladaSR" }
 				configuration { }
 			end
 		end,
 	},
 	ffmpeg = {
 		compile_settings = function()
 			if os.is("windows") then
 				add_default_include_paths("ffmpeg")
 			end
 		end,
 		link_settings = function()
 			if os.is("windows") then
 				add_default_lib_paths("ffmpeg")
 			end
 			add_default_links({
 				win_names = { "avcodec-51", "avformat-51", "avutil-49", "swscale-0" },
 				unix_names = { "avcodec", "avformat", "avutil" },
 				dbg_suffix = "",
 			})
 		end,
 	},
 	gloox = {
 		compile_settings = function()
 			if os.is("windows") then
 				add_default_include_paths("gloox")
 			elseif os.is("macosx") then
 				-- Support GLOOX_CONFIG for overriding the default PATH-based gloox-config
 				gloox_config_path = os.getenv("GLOOX_CONFIG")
 				if not gloox_config_path then
 					gloox_config_path = "gloox-config"
 				end
 				pkgconfig_cflags(nil, gloox_config_path.." --cflags")
 			end
 		end,
 		link_settings = function()
 			if os.is("windows") then
 				add_default_lib_paths("gloox")
 			end
 			if os.is("macosx") then
 				gloox_config_path = os.getenv("GLOOX_CONFIG")
 				if not gloox_config_path then
 					gloox_config_path = "gloox-config"
 				end
 				pkgconfig_libs(nil, gloox_config_path.." --libs")
 			else
 				-- TODO: consider using pkg-config on non-Windows (for compile_settings too)
 				add_default_links({
 					win_names  = { "gloox-1.0" },
 					unix_names = { "gloox" },
 				})
 			end
 		end,
 	},
+	iconv = {
+		compile_settings = function()
+			if os.is("windows") then
+				add_default_include_paths("iconv")
+				defines { "HAVE_ICONV_CONST" }
+				defines { "LIBICONV_STATIC" }
+			end
+		end,
+		link_settings = function()
+			if os.is("windows") then
+				add_default_lib_paths("iconv")
+			end
+			add_default_links({
+				win_names  = { "iconv" },
+				-- TODO: glibc provides symbols for this, so we should only include that (and depend on libiconv) on non-glibc unix
+				--unix_names = { "iconv" },
+				dbg_suffix = "",
+			})
+		end,
+	},
+	icu = {
+		compile_settings = function()
+			if os.is("windows") then
+				add_default_include_paths("icu")
+			elseif os.is("macosx") then
+				-- Support ICU_CONFIG for overriding the default PATH-based icu-config
+				icu_config_path = os.getenv("ICU_CONFIG")
+				if not icu_config_path then
+					icu_config_path = "icu-config"
+				end
+				pkgconfig_cflags(nil, icu_config_path.." --cppflags")
+			end
+		end,
+		link_settings = function()
+			if os.is("windows") then
+				add_default_lib_paths("icu")
+			end
+			if os.is("macosx") then
+				icu_config_path = os.getenv("ICU_CONFIG")
+				if not icu_config_path then
+					icu_config_path = "gloox-config"
+				end
+				pkgconfig_libs(nil, icu_config_path.." --ldflags-searchpath --ldflags-libsonly --ldflags-system")
+			else
+				add_default_links({
+					win_names  = { "icuuc", "icuin" },
+					unix_names = { "icui18n", "icuuc" },
+					dbg_suffix = "",
+				})
+			end
+		end,
+	},
 	libcurl = {
 		compile_settings = function()
 			if os.is("windows") or os.is("macosx") then
 				add_default_include_paths("libcurl")
 			end
 		end,
 		link_settings = function()
 			if os.is("windows") or os.is("macosx") then
 				add_default_lib_paths("libcurl")
 			end
 			add_default_links({
 				win_names  = { "libcurl" },
 				unix_names = { "curl" },
 			})
 		end,
 	},
 	libjpg = {
 		compile_settings = function()
 			if os.is("windows") or os.is("macosx") then
 				add_default_include_paths("libjpg")
 			end
 		end,
 		link_settings = function()
 			if os.is("windows") or os.is("macosx") then
 				add_default_lib_paths("libjpg")
 			end
 			add_default_links({
 				win_names  = { "jpeg-6b" },
 				unix_names = { "jpeg" },
 			})
 		end,
 	},
 	libpng = {
 		compile_settings = function()
 			if os.is("windows") or os.is("macosx") then
 				add_default_include_paths("libpng")
 			end
 			if os.getversion().description == "OpenBSD" then
 				includedirs { "/usr/local/include/libpng" }
 			end
 		end,
 		link_settings = function()
 			if os.is("windows") or os.is("macosx") then
 				add_default_lib_paths("libpng")
 			end
 			add_default_links({
 				win_names  = { "libpng15" },
 				unix_names = { "png" },
 				-- Otherwise ld will sometimes pull in ancient 1.2 from the SDK, which breaks the build :/
 				-- TODO: Figure out why that happens
 				osx_names = { "png15" },
 			})
 		end,
 	},
 	libxml2 = {
 		compile_settings = function()
 			if os.is("windows") then
 				add_default_include_paths("libxml2")
 			elseif os.is("macosx") then
 				-- Support XML2_CONFIG for overriding for the default PATH-based xml2-config
 				xml2_config_path = os.getenv("XML2_CONFIG")
 				if not xml2_config_path then
 					xml2_config_path = "xml2-config"
 				end
 
 				-- use xml2-config instead of pkg-config on OS X
 				pkgconfig_cflags(nil, xml2_config_path.." --cflags")
 				-- libxml2 needs _REENTRANT or __MT__ for thread support;
 				-- OS X doesn't get either set by default, so do it manually
 				defines { "_REENTRANT" }
 			else
 				pkgconfig_cflags("libxml-2.0")
 			end
 		end,
 		link_settings = function()
 			if os.is("windows") then
 				add_default_lib_paths("libxml2")
 				configuration "Debug"
 					links { "libxml2" }
 				configuration "Release"
 					links { "libxml2" }
 				configuration { }
 			elseif os.is("macosx") then
 				xml2_config_path = os.getenv("XML2_CONFIG")
 				if not xml2_config_path then
 					xml2_config_path = "xml2-config"
 				end
 				pkgconfig_libs(nil, xml2_config_path.." --libs")
 			else
 				pkgconfig_libs("libxml-2.0")
 			end
 		end,
 	},
 	miniupnpc = {
 		compile_settings = function()
 			if not _OPTIONS["with-system-miniupnpc"] then
 				add_source_include_paths("miniupnpc")
 			end
 		end,
 		link_settings = function()
 			if not _OPTIONS["with-system-miniupnpc"] then
 				add_source_lib_paths("miniupnpc")
 			end
 			add_default_links({
 				win_names  = { "miniupnpc" },
 				unix_names = { "miniupnpc" },
 			})
 		end,
 	},
 	nvtt = {
 		compile_settings = function()
 			if not _OPTIONS["with-system-nvtt"] then
 				add_source_include_paths("nvtt")
 			end
 			defines { "NVTT_SHARED=1" }
 		end,
 		link_settings = function()
 			if not _OPTIONS["with-system-nvtt"] then
 				add_source_lib_paths("nvtt")
 			end
 			add_default_links({
 				win_names  = { "nvtt" },
 				unix_names = { "nvcore", "nvmath", "nvimage", "nvtt" },
 				osx_names = { "nvcore", "nvmath", "nvimage", "nvtt", "squish" },
 				dbg_suffix = "", -- for performance we always use the release-mode version
 			})
 		end,
 	},
 	openal = {
 		compile_settings = function()
 			if os.is("windows") then
 				add_default_include_paths("openal")
 			end
 		end,
 		link_settings = function()
 			if os.is("windows") then
 				add_default_lib_paths("openal")
 			end
 			add_default_links({
 				win_names  = { "openal32" },
 				unix_names = { "openal" },
 				osx_frameworks = { "OpenAL" },
 				dbg_suffix = "",
 				no_delayload = 1, -- delayload seems to cause errors on startup
 			})
 		end,
 	},
 	opengl = {
 		compile_settings = function()
 			if os.is("windows") then
 				add_default_include_paths("opengl")
 			end
 		end,
 		link_settings = function()
 			if os.is("windows") then
 				add_default_lib_paths("opengl")
 			end
 			if _OPTIONS["gles"] then
 				add_default_links({
 					unix_names = { "GLESv2" },
 					dbg_suffix = "",
 				})
 			else
 				add_default_links({
 					win_names  = { "opengl32", "gdi32" },
 					unix_names = { "GL" },
 					osx_frameworks = { "OpenGL" },
 					dbg_suffix = "",
 					no_delayload = 1, -- delayload seems to cause errors on startup
 				})
 			end
 		end,
 	},
 	sdl = {
 		compile_settings = function()
 			if os.is("windows") then
 				includedirs { libraries_dir .. "sdl/include/SDL" }
 			elseif not _OPTIONS["android"] then
 				-- Support SDL_CONFIG for overriding for the default PATH-based sdl-config
 				sdl_config_path = os.getenv("SDL_CONFIG")
 				if not sdl_config_path then
 					sdl_config_path = "sdl-config"
 				end
 
 				-- "pkg-config sdl --libs" appears to include both static and dynamic libs
 				-- when on MacPorts, which is bad, so use sdl-config instead
 				pkgconfig_cflags(nil, sdl_config_path.." --cflags")
 			end
 		end,
 		link_settings = function()
 			if os.is("windows") then
 				add_default_lib_paths("sdl")
 			elseif not _OPTIONS["android"] then
 				sdl_config_path = os.getenv("SDL_CONFIG")
 				if not sdl_config_path then
 					sdl_config_path = "sdl-config"
 				end
 				pkgconfig_libs(nil, sdl_config_path.." --libs")
 			end
 		end,
 	},
 	spidermonkey = {
 		compile_settings = function()
 			if _OPTIONS["with-system-mozjs24"] then
 				if not _OPTIONS["android"] then
 					pkgconfig_cflags("mozjs-24")
 				end
 				defines { "WITH_SYSTEM_MOZJS24" }
 			else
 				if os.is("windows") then
 					include_dir = "include-win32"
 				else
 					include_dir = "include-unix"
 				end
 				configuration "Debug"
 					includedirs { libraries_source_dir.."spidermonkey/"..include_dir.."-debug" }
 					defines { "DEBUG" }
 				configuration "Release"
 					includedirs { libraries_source_dir.."spidermonkey/"..include_dir.."-release" }
 				configuration { }
 			end
 		end,
 		link_settings = function()
 			if _OPTIONS["with-system-mozjs24"] then
 				if _OPTIONS["android"] then
 					links { "mozjs-24" }
 				else
 					pkgconfig_libs("nspr")
 					pkgconfig_libs("mozjs-24")
 				end
 			else
 				if os.is("macosx") then
 					add_default_lib_paths("nspr")
 					links { "nspr4", "plc4", "plds4" }
 				end
 				configuration "Debug"
 					links { "mozjs24-ps-debug" }
 				configuration "Release"
 					links { "mozjs24-ps-release" }
 				configuration { }
 				add_source_lib_paths("spidermonkey")
 			end
 		end,
 	},
+	tinygettext = {
+		compile_settings = function()
+			add_third_party_include_paths("tinygettext")
+		end,
+	},
 	valgrind = {
 		compile_settings = function()
 			add_source_include_paths("valgrind")
 		end,
 		link_settings = function()
 			add_source_lib_paths("valgrind")
 		end,
 	},
 	vorbis = {
 		compile_settings = function()
 			if os.is("windows") then
 				add_default_include_paths("vorbis")
 			elseif os.is("macosx") then
 				add_default_include_paths("libogg")
 				add_default_include_paths("vorbis")
 			end
 		end,
 		link_settings = function()
 			if os.is("windows") then
 				add_default_lib_paths("vorbis")
 			elseif os.is("macosx") then
 				add_default_lib_paths("libogg")
 				add_default_lib_paths("vorbis")
 			end
 			-- TODO: We need to force linking with these as currently
 			-- they need to be loaded explicitly on execution
 			if os.getversion().description == "OpenBSD" then
 				add_default_links({
 					unix_names = { "ogg",
 						"vorbis" },
 				})
 			end
 			add_default_links({
 				win_names  = { "vorbisfile" },
 				unix_names = { "vorbisfile" },
 				osx_names = { "vorbis", "vorbisenc", "vorbisfile", "ogg" },
 				dbg_suffix = "_d",
 			})
 		end,
 	},
 	wxwidgets = {
 		compile_settings = function()
 			if os.is("windows") then
 				includedirs { libraries_dir.."wxwidgets/include/msvc" }
 				add_default_include_paths("wxwidgets")
 			else
 
 				-- Support WX_CONFIG for overriding for the default PATH-based wx-config
 				wx_config_path = os.getenv("WX_CONFIG")
 				if not wx_config_path then
 					wx_config_path = "wx-config"
 				end
 
 				pkgconfig_cflags(nil, wx_config_path.." --unicode=yes --cxxflags")
 			end
 		end,
 		link_settings = function()
 			if os.is("windows") then
 				libdirs { libraries_dir.."wxwidgets/lib/vc_lib" }
 				configuration "Debug"
 					links { "wxmsw28ud_gl" }
 				configuration "Release"
 					links { "wxmsw28u_gl" }
 				configuration { }
 			else
 				wx_config_path = os.getenv("WX_CONFIG")
 				if not wx_config_path then
 					wx_config_path = "wx-config"
 				end
 				pkgconfig_libs(nil, wx_config_path.." --unicode=yes --libs std,gl")
 			end
 		end,
 	},
 	x11 = {
 		link_settings = function()
 			add_default_links({
 				win_names  = { },
 				unix_names = { "X11" },
 			})
 		end,
 	},
 	xcursor = {
 		link_settings = function()
 			add_default_links({
 				unix_names = { "Xcursor" },
 			})
 		end,
 	},
 	zlib = {
 		compile_settings = function()
 			if os.is("windows") or os.is("macosx") then
 				add_default_include_paths("zlib")
 			end
 		end,
 		link_settings = function()
 			if os.is("windows") or os.is("macosx") then
 				add_default_lib_paths("zlib")
 			end
 			add_default_links({
 				win_names  = { "zlib1" },
 				unix_names = { "z" },
 			})
 		end,
 	},
 }
 
 
 -- add a set of external libraries to the project; takes care of
 -- include / lib path and linking against the import library.
 -- extern_libs: table of library names [string]
 -- target_type: String defining the projects kind [string]
 function project_add_extern_libs(extern_libs, target_type)
 
 	for i,extern_lib in pairs(extern_libs) do
 		local def = extern_lib_defs[extern_lib]
 		assert(def, "external library " .. extern_lib .. " not defined")
 
 		if def.compile_settings then
 			def.compile_settings()
 		end
 
 		-- Linking to external libraries will only be done in the main executable and not in the
 		-- static libraries. Premake would silently skip linking into static libraries for some
 		-- actions anyway (e.g. vs2010).
 		-- On osx using xcode, if this linking would be defined in the static libraries, it would fail to
 		-- link if only dylibs are available. If both *.a and *.dylib are available, it would link statically.
 		-- I couldn't find any problems with that approach.
 		if target_type ~= "StaticLib" and def.link_settings then
 			def.link_settings()
 		end
 	end
 end
Index: ps/trunk/build/premake/premake4.lua
===================================================================
--- ps/trunk/build/premake/premake4.lua	(revision 14952)
+++ ps/trunk/build/premake/premake4.lua	(revision 14953)
@@ -1,1429 +1,1468 @@
 newoption { trigger = "android", description = "Use non-working Android cross-compiling mode" }
 newoption { trigger = "atlas", description = "Include Atlas scenario editor projects" }
 newoption { trigger = "collada", description = "Include COLLADA projects (requires FCollada library)" }
 newoption { trigger = "coverage", description = "Enable code coverage data collection (GCC only)" }
 newoption { trigger = "gles", description = "Use non-working OpenGL ES 2.0 mode" }
 newoption { trigger = "icc", description = "Use Intel C++ Compiler (Linux only; should use either \"--cc icc\" or --without-pch too, and then set CXX=icpc before calling make)" }
 newoption { trigger = "outpath", description = "Location for generated project files" }
 newoption { trigger = "without-audio", description = "Disable use of OpenAL/Ogg/Vorbis APIs" }
 newoption { trigger = "minimal-flags", description = "Only set compiler/linker flags that are really needed. Has no effect on Windows builds" }
 newoption { trigger = "without-nvtt", description = "Disable use of NVTT" }
 newoption { trigger = "without-tests", description = "Disable generation of test projects" }
 newoption { trigger = "without-pch", description = "Disable generation and usage of precompiled headers" }
 newoption { trigger = "without-lobby", description = "Disable the use of gloox and the multiplayer lobby" }
 newoption { trigger = "without-miniupnpc", description = "Disable use of miniupnpc for port forwarding" }
 newoption { trigger = "with-system-nvtt", description = "Search standard paths for nvidia-texture-tools library, instead of using bundled copy" }
 newoption { trigger = "with-system-enet", description = "Search standard paths for libenet, instead of using bundled copy" }
 newoption { trigger = "with-system-miniupnpc", description = "Search standard paths for libminiupnpc, instead of using bundled copy" }
 newoption { trigger = "with-system-mozjs24", description = "Search standard paths for libmozjs24, instead of using bundled copy" }
 newoption { trigger = "with-c++11", description = "Enable C++11 on GCC" }
 newoption { trigger = "sysroot", description = "Set compiler system root path, used for building against a non-system SDK. For example /usr/local becomes SYSROOT/user/local" }
 newoption { trigger = "macosx-version-min", description = "Set minimum required version of the OS X API, the build will possibly fail if an older SDK is used, while newer API functions will be weakly linked (i.e. resolved at runtime)" }
 newoption { trigger = "macosx-bundle", description = "Enable OSX bundle, the argument is the bundle identifier string (e.g. com.wildfiregames.0ad)" }
 
 newoption { trigger = "build-shared-glooxwrapper", description = "Rebuild glooxwrapper DLL for Windows. Requires the same compiler version that gloox was built with" }
 newoption { trigger = "use-shared-glooxwrapper", description = "Use prebuilt glooxwrapper DLL for Windows" }
 
 newoption { trigger = "bindir", description = "Directory for executables (typically '/usr/games'); default is to be relocatable" }
 newoption { trigger = "datadir", description = "Directory for data files (typically '/usr/share/games/0ad'); default is ../data/ relative to executable" }
 newoption { trigger = "libdir", description = "Directory for libraries (typically '/usr/lib/games/0ad'); default is ./ relative to executable" }
 newoption { trigger = "jenkins-tests", description = "configure cxxtest to use the XmlPrinter runner which produces jenkins-compatible output" }
 
 -- Root directory of project checkout relative to this .lua file
 rootdir = "../.."
 
 dofile("extern_libs4.lua")
 
 -- detect CPU architecture (simplistic, currently only supports x86, amd64 and ARM)
 arch = "x86"
 if _OPTIONS["android"] then
 	arch = "arm"
 elseif os.is("windows") then
 	if os.getenv("PROCESSOR_ARCHITECTURE") == "amd64" or os.getenv("PROCESSOR_ARCHITEW6432") == "amd64" then
 		arch = "amd64"
 	end
 else
 	arch = os.getenv("HOSTTYPE")
 	if arch == "x86_64" or arch == "amd64" then
 		arch = "amd64"
 	else
 		os.execute("gcc -dumpmachine > .gccmachine.tmp")
 		local f = io.open(".gccmachine.tmp", "r")
 		local machine = f:read("*line")
 		f:close()
 		if string.find(machine, "x86_64") == 1 or string.find(machine, "amd64") == 1 then
 			arch = "amd64"
 		elseif string.find(machine, "i.86") == 1 then
 			arch = "x86"
 		elseif string.find(machine, "arm") == 1 then
 			arch = "arm"
 		else
 			print("WARNING: Cannot determine architecture from GCC, assuming x86")
 		end
 	end
 end
 
 -- Set up the Solution
 solution "pyrogenesis"
 targetdir(rootdir.."/binaries/system")
 libdirs(rootdir.."/binaries/system")
 if not _OPTIONS["outpath"] then
 	error("You must specify the 'outpath' parameter")
 end
 location(_OPTIONS["outpath"])
 configurations { "Release", "Debug" }
 
 -- Get some environement specific information used later.
 if os.is("windows") then
 	nasmpath(rootdir.."/build/bin/nasm.exe")
 	lcxxtestpath = rootdir.."/build/bin/cxxtestgen.exe"
 	has_broken_pch = false
 else
 
 	lcxxtestpath = rootdir.."/libraries/source/cxxtest-4.3/bin/cxxtestgen"
 
 	if os.is("linux") and arch == "amd64" then
 		nasmformat "elf64"
 	elseif os.is("macosx") and arch == "amd64" then
 		nasmformat "macho64"
 	elseif os.is("macosx") then
 		nasmformat "macho"
 	else
 		nasmformat "elf"
 	end
 
 	-- GCC bug (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=10591) - PCH breaks anonymous namespaces
 	-- Fixed in 4.2.0, but we have to disable PCH for earlier versions, else
 	-- it conflicts annoyingly with wx 2.8 headers.
 	-- It's too late to do this test by the time we start compiling the PCH file, so
 	-- do the test in this build script instead (which is kind of ugly - please fix if
 	-- you have a better idea)
 	if not _OPTIONS["icc"] then
 		os.execute("gcc -dumpversion > .gccver.tmp")
 		local f = io.open(".gccver.tmp", "r")
 		major, dot, minor = f:read(1, 1, 1)
 		f:close()
 		major = 0+major -- coerce to number
 		minor = 0+minor
 		has_broken_pch = (major < 4 or (major == 4 and minor < 2))
 		if has_broken_pch then
 			print("WARNING: Detected GCC <4.2 -- disabling PCH for Atlas (will increase build times)")
 		end
 	end
 end
 
 source_root = rootdir.."/source/" -- default for most projects - overridden by local in others
 
 -- Rationale: projects should not have any additional include paths except for
 -- those required by external libraries. Instead, we should always write the
 -- full relative path, e.g. #include "maths/Vector3d.h". This avoids confusion
 -- ("which file is meant?") and avoids enormous include path lists.
 
 
 -- projects: engine static libs, main exe, atlas, atlas frontends, test.
 
 --------------------------------------------------------------------------------
 -- project helper functions
 --------------------------------------------------------------------------------
 
 function project_set_target(project_name)
 
 	-- Note: On Windows, ".exe" is added on the end, on unices the name is used directly
 
 	local obj_dir_prefix = _OPTIONS["outpath"].."/obj/"..project_name.."_"
 
 	configuration "Debug"
 		objdir(obj_dir_prefix.."Debug")
 		targetsuffix("_dbg")
 
 	configuration "Release"
 		objdir(obj_dir_prefix.."Release")
 
 	configuration { }
 
 end
 
 
 function project_set_build_flags()
 
 	flags { "Symbols", "NoEditAndContinue" }
 	if not _OPTIONS["icc"] and (os.is("windows") or not _OPTIONS["minimal-flags"]) then
 		-- adds the -Wall compiler flag
 		flags { "ExtraWarnings" } -- this causes far too many warnings/remarks on ICC
 	end
 
 	-- disable Windows debug heap, since it makes malloc/free hugely slower when
 	-- running inside a debugger
 	if os.is("windows") then
 		flags { "NoDebugHeap" }
 	end
 
 	configuration "Debug"
 		defines { "DEBUG" }
 
 	configuration "Release"
 		if os.is("windows") or not _OPTIONS["minimal-flags"] then
 			flags { "OptimizeSpeed" }
 		end
 		defines { "NDEBUG", "CONFIG_FINAL=1" }
 
 	configuration { }
 
 	if _OPTIONS["gles"] then
 		defines { "CONFIG2_GLES=1" }
 	end
 
 	if _OPTIONS["without-audio"] then
 		defines { "CONFIG2_AUDIO=0" }
 	end
 
 	if _OPTIONS["without-nvtt"] then
 		defines { "CONFIG2_NVTT=0" }
 	end
 
 	if _OPTIONS["without-lobby"] then
 		defines { "CONFIG2_LOBBY=0" }
 	end
 
 	if _OPTIONS["without-miniupnpc"] then
 		defines { "CONFIG2_MINIUPNPC=0" }
 	end
 
 	-- required for the lowlevel library. must be set from all projects that use it, otherwise it assumes it is
 	-- being used as a DLL (which is currently not the case in 0ad)
 	defines { "LIB_STATIC_LINK" }
 
 	-- various platform-specific build flags
 	if os.is("windows") then
 
 		-- use native wchar_t type (not typedef to unsigned short)
 		flags { "NativeWChar" }
 		flags { "EnableSSE2" } -- Enable SSE2 code generation for VS
 
 		-- VC++ 2008 has implied FPO as the default (newer versions default to /Oy-)
 		-- disable it explicitly since it breaks our stack walker in release build
 		if _ACTION == "vs2008" then
 			buildoptions { "/Oy-" }
 		end
 
 	else	-- *nix
 		if _OPTIONS["icc"] and not _OPTIONS["minimal-flags"] then
 			buildoptions {
 				"-w1",
 				-- "-Wabi",
 				-- "-Wp64", -- complains about OBJECT_TO_JSVAL which is annoying
 				"-Wpointer-arith",
 				"-Wreturn-type",
 				-- "-Wshadow",
 				"-Wuninitialized",
 				"-Wunknown-pragmas",
 				"-Wunused-function",
 				"-wd1292" -- avoid lots of 'attribute "__nonnull__" ignored'
 			}
 			configuration "Debug"
 				buildoptions { "-O0" } -- ICC defaults to -O2
 			configuration { }
 			if os.is("macosx") then
 				linkoptions { "-multiply_defined","suppress" }
 			end
 		else
 			-- exclude most non-essential build options for minimal-flags
 			if not _OPTIONS["minimal-flags"] then
 				buildoptions {
 					-- enable most of the standard warnings
 					"-Wno-switch",		-- enumeration value not handled in switch (this is sometimes useful, but results in lots of noise)
 					"-Wno-reorder",		-- order of initialization list in constructors (lots of noise)
 					"-Wno-invalid-offsetof",	-- offsetof on non-POD types (see comment in renderer/PatchRData.cpp)
 
 					"-Wextra",
 					"-Wno-missing-field-initializers",	-- (this is common in external headers we can't fix)
 
 					-- add some other useful warnings that need to be enabled explicitly
 					"-Wunused-parameter",
 					"-Wredundant-decls",	-- (useful for finding some multiply-included header files)
 					-- "-Wformat=2",		-- (useful sometimes, but a bit noisy, so skip it by default)
 					-- "-Wcast-qual",		-- (useful for checking const-correctness, but a bit noisy, so skip it by default)
 					"-Wnon-virtual-dtor",	-- (sometimes noisy but finds real bugs)
 					"-Wundef",				-- (useful for finding macro name typos)
 
 					-- enable security features (stack checking etc) that shouldn't have
 					-- a significant effect on performance and can catch bugs
 					"-fstack-protector-all",
 					"-U_FORTIFY_SOURCE",	-- (avoid redefinition warning if already defined)
 					"-D_FORTIFY_SOURCE=2",
 
 					-- always enable strict aliasing (useful in debug builds because of the warnings)
 					"-fstrict-aliasing",
 
 					-- don't omit frame pointers (for now), because performance will be impacted
 					-- negatively by the way this breaks profilers more than it will be impacted
 					-- positively by the optimisation
 					"-fno-omit-frame-pointer"
 				}
 
 				if not _OPTIONS["without-pch"] then
 					buildoptions {
 						-- do something (?) so that ccache can handle compilation with PCH enabled
 						-- (ccache 3.1+ also requires CCACHE_SLOPPINESS=time_macros for this to work)
 						"-fpch-preprocess"
 					}
 				end
 
 				if arch == "x86" or arch == "amd64" then
 					buildoptions {
 						-- enable SSE intrinsics
 						"-msse"
 					}
 				end
 
 				if os.is("linux") or os.is("bsd") then
 					linkoptions { "-Wl,--no-undefined", "-Wl,--as-needed" }
 				end
 
 				if arch == "x86" then
 					buildoptions {
 						-- To support intrinsics like __sync_bool_compare_and_swap on x86
 						-- we need to set -march to something that supports them
 						"-march=i686"
 					}
 				end
 			end
 			
 			if _OPTIONS["with-c++11"] then
 				buildoptions {
 					-- Enable C++11 standard. VS2010 and higher automatically support C++11
 					-- but we have to enable it manually on GNU C++ and Intel C++
 					"-std=c++0x"
 				}
 			end
 
 			if arch == "arm" then
 				-- disable warnings about va_list ABI change and use
 				-- compile-time flags for futher configuration.
 				buildoptions { "-Wno-psabi" }
 				if _OPTIONS["android"] then
 					-- Android uses softfp, so we should too.
 					buildoptions { "-mfloat-abi=softfp" }
 				end
 			end
 
 			if _OPTIONS["coverage"] then
 				buildoptions { "-fprofile-arcs", "-ftest-coverage" }
 				links { "gcov" }
 			end
 
 			-- We don't want to require SSE2 everywhere yet, but OS X headers do
 			-- require it (and Intel Macs always have it) so enable it here
 			if os.is("macosx") then
 				buildoptions { "-msse2" }
 			end
 
 			-- Check if SDK path should be used
 			if _OPTIONS["sysroot"] then
 				buildoptions { "-isysroot " .. _OPTIONS["sysroot"] }
 				linkoptions { "-Wl,-syslibroot," .. _OPTIONS["sysroot"] }
 			end
 
 			-- On OS X, sometimes we need to specify the minimum API version to use
 			if _OPTIONS["macosx-version-min"] then
 				buildoptions { "-mmacosx-version-min=" .. _OPTIONS["macosx-version-min"] }
 				-- clang and llvm-gcc look at mmacosx-version-min to determine link target
 				-- and CRT version, and use it to set the macosx_version_min linker flag
 				linkoptions { "-mmacosx-version-min=" .. _OPTIONS["macosx-version-min"] }
 			end
 
 			-- Check if we're building a bundle
 			if _OPTIONS["macosx-bundle"] then
 				defines { "BUNDLE_IDENTIFIER=" .. _OPTIONS["macosx-bundle"] }
 			end
 		end
 
 		if not _OPTIONS["minimal-flags"] then
 			buildoptions {
 				-- Hide symbols in dynamic shared objects by default, for efficiency and for equivalence with
 				-- Windows - they should be exported explicitly with __attribute__ ((visibility ("default")))
 				"-fvisibility=hidden"
 			}
 		end
 
 		if _OPTIONS["bindir"] then
 			defines { "INSTALLED_BINDIR=" .. _OPTIONS["bindir"] }
 		end
 		if _OPTIONS["datadir"] then
 			defines { "INSTALLED_DATADIR=" .. _OPTIONS["datadir"] }
 		end
 		if _OPTIONS["libdir"] then
 			defines { "INSTALLED_LIBDIR=" .. _OPTIONS["libdir"] }
 		end
 
 		if os.is("linux") or os.is("bsd") then
 			-- To use our local shared libraries, they need to be found in the
 			-- runtime dynamic linker path. Add their path to -rpath.
 			if _OPTIONS["libdir"] then
 				linkoptions {"-Wl,-rpath," .. _OPTIONS["libdir"] }
 			else
 				-- On FreeBSD we need to allow use of $ORIGIN
 				if os.is("bsd") then
 					linkoptions { "-Wl,-z,origin" }
 				end
 
 				-- Adding the executable path and taking care of correct escaping
 				if _ACTION == "gmake" then
 					linkoptions { "-Wl,-rpath,'$$ORIGIN'" } 
 				elseif _ACTION == "codeblocks" then
 					linkoptions { "-Wl,-R\\\\$$$ORIGIN" }
 				end
 			end
 		end
 
 	end
 end
 
 -- add X11 includes paths after all the others so they don't conflict with
 -- bundled libs
 function project_add_x11_dirs()
 	if not os.is("windows") and not os.is("macosx") then
 		-- X11 includes may be installed in one of a gadzillion of three places
 		-- Famous last words: "You can't include too much! ;-)"
 		includedirs {
 			"/usr/X11R6/include/X11",
 			"/usr/X11R6/include",
 			"/usr/include/X11"
 		}
 		libdirs { "/usr/X11R6/lib" }
 	end
 end
 
 -- create a project and set the attributes that are common to all projects.
 function project_create(project_name, target_type)
 
 	project(project_name)
 	language "C++"
 	kind(target_type)
 
 	project_set_target(project_name)
 	project_set_build_flags()
 end
 
 
 -- OSX creates a .app bundle if the project type of the main application is set to "WindowedApp".
 -- We don't want this because this bundle would be broken (it lacks all the resources and external dependencies, Info.plist etc...)
 -- Windows opens a console in the background if it's set to ConsoleApp, which is not what we want.
 -- I didn't check if this setting matters for linux, but WindowedApp works there.
 function get_main_project_target_type()
 	if _OPTIONS["android"] then
 		return "SharedLib"
 	elseif os.is("macosx") then
 		return "ConsoleApp"
 	else
 		return "WindowedApp"
 	end
 end
 
 
 -- source_root: rel_source_dirs and rel_include_dirs are relative to this directory
 -- rel_source_dirs: A table of subdirectories. All source files in these directories are added.
 -- rel_include_dirs: A table of subdirectories to be included.
 -- extra_params: table including zero or more of the following:
 -- * no_pch: If specified, no precompiled headers are used for this project.
 -- * pch_dir: If specified, this directory will be used for precompiled headers instead of the default
 --   <source_root>/pch/<projectname>/.
 -- * extra_files: table of filenames (relative to source_root) to add to project
 -- * extra_links: table of library names to add to link step
 function project_add_contents(source_root, rel_source_dirs, rel_include_dirs, extra_params)
 
 	for i,v in pairs(rel_source_dirs) do
 		local prefix = source_root..v.."/"
 		files { prefix.."*.cpp", prefix.."*.h", prefix.."*.inl", prefix.."*.js", prefix.."*.asm", prefix.."*.mm" }
 	end
 
 	-- Put the project-specific PCH directory at the start of the
 	-- include path, so '#include "precompiled.h"' will look in
 	-- there first
 	local pch_dir
 	if not extra_params["pch_dir"] then
 		pch_dir = source_root .. "pch/" .. project().name .. "/"
 	else
 		pch_dir = extra_params["pch_dir"]
 	end
 	includedirs { pch_dir }
 
 	-- Precompiled Headers
 	-- rationale: we need one PCH per static lib, since one global header would
 	-- increase dependencies. To that end, we can either include them as
 	-- "projectdir/precompiled.h", or add "source/PCH/projectdir" to the
 	-- include path and put the PCH there. The latter is better because
 	-- many projects contain several dirs and it's unclear where there the
 	-- PCH should be stored. This way is also a bit easier to use in that
 	-- source files always include "precompiled.h".
 	-- Notes:
 	-- * Visual Assist manages to use the project include path and can
 	--   correctly open these files from the IDE.
 	-- * precompiled.cpp (needed to "Create" the PCH) also goes in
 	--   the abovementioned dir.
 	if (not _OPTIONS["without-pch"] and not extra_params["no_pch"]) then
 		pchheader(pch_dir.."precompiled.h")
 		pchsource(pch_dir.."precompiled.cpp")
 		defines { "USING_PCH" }
 		files { pch_dir.."precompiled.h", pch_dir.."precompiled.cpp" }
 	else
 		flags { "NoPCH" }
 	end
 
 	-- next is source root dir, for absolute (nonrelative) includes
 	-- (e.g. "lib/precompiled.h")
 	includedirs { source_root }
 
 	for i,v in pairs(rel_include_dirs) do
 		includedirs { source_root .. v }
 	end
 
 	if extra_params["extra_files"] then
 		for i,v in pairs(extra_params["extra_files"]) do
 			-- .rc files are only needed on Windows
 			if path.getextension(v) ~= ".rc" or os.is("windows") then
 				files { source_root .. v }
 			end
 		end
 	end
 
 	if extra_params["extra_links"] then
 		links { extra_params["extra_links"] }
 	end
 end
 
 
 -- Add command-line options to set up the manifest dependencies for Windows
 -- (See lib/sysdep/os/win/manifest.cpp)
 function project_add_manifest()
 	linkoptions { "\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='X86' publicKeyToken='6595b64144ccf1df'\"" }
 	configuration "Debug"
 		linkoptions { "\"/manifestdependency:type='win32' name='Microsoft.VC80.DebugCRT' version='8.0.50727.4053' processorArchitecture='x86' publicKeyToken='1fc8b3b9a1e18e3b'\"" }
 	configuration "Release"
 		linkoptions { "\"/manifestdependency:type='win32' name='Microsoft.VC80.CRT' version='8.0.50727.4053' processorArchitecture='x86' publicKeyToken='1fc8b3b9a1e18e3b'\"" }
 	configuration { }
 end
 
 --------------------------------------------------------------------------------
 -- engine static libraries
 --------------------------------------------------------------------------------
 
 -- the engine is split up into several static libraries. this eases separate
 -- distribution of those components, reduces dependencies a bit, and can
 -- also speed up builds.
 -- more to the point, it is necessary to efficiently support a separate
 -- test executable that also includes much of the game code.
 
 -- names of all static libs created. automatically added to the
 -- main app project later (see explanation at end of this file)
 static_lib_names = {}
 static_lib_names_debug = {}
 static_lib_names_release = {}
 
 -- set up one of the static libraries into which the main engine code is split.
 -- extra_params:
 --	no_default_link: If specified, linking won't be done by default.
 -- 	For the rest of extra_params, see project_add_contents().
 -- note: rel_source_dirs and rel_include_dirs are relative to global source_root.
 function setup_static_lib_project (project_name, rel_source_dirs, extern_libs, extra_params)
 
 	local target_type = "StaticLib"
 	project_create(project_name, target_type)
 	project_add_contents(source_root, rel_source_dirs, {}, extra_params)
 	project_add_extern_libs(extern_libs, target_type)
 	project_add_x11_dirs()
 
 	if not extra_params["no_default_link"] then
 		table.insert(static_lib_names, project_name)
 	end
 
 	if os.is("windows") then
 		flags { "NoRTTI" }
 	end
 end
 
+function setup_third_party_static_lib_project (project_name, rel_source_dirs, extern_libs, extra_params)
+
+	setup_static_lib_project(project_name, rel_source_dirs, extern_libs, extra_params)
+	includedirs { source_root .. "third_party/" .. project_name .. "/include/" .. project_name }
+end
+
 function setup_shared_lib_project (project_name, rel_source_dirs, extern_libs, extra_params)
 
 	local target_type = "SharedLib"
 	project_create(project_name, target_type)
 	project_add_contents(source_root, rel_source_dirs, {}, extra_params)
 	project_add_extern_libs(extern_libs, target_type)
 	project_add_x11_dirs()
 
 	if not extra_params["no_default_link"] then
 		table.insert(static_lib_names, project_name)
 	end
 
 	if os.is("windows") then
 		flags { "NoRTTI" }
 		links { "delayimp" }
 	end
 end
 
 
 -- this is where the source tree is chopped up into static libs.
 -- can be changed very easily; just copy+paste a new setup_static_lib_project,
 -- or remove existing ones. static libs are automagically added to
 -- main_exe link step.
 function setup_all_libs ()
 
 	-- relative to global source_root.
 	local source_dirs = {}
 	-- names of external libraries used (see libraries_dir comment)
 	local extern_libs = {}
 
 
 	source_dirs = {
 		"network",
 	}
 	extern_libs = {
 		"spidermonkey",
 		"enet",
 		"boost",	-- dragged in via server->simulation.h->random
 	}
 	if not _OPTIONS["without-miniupnpc"] then
 		table.insert(extern_libs, "miniupnpc")
 	end
 	setup_static_lib_project("network", source_dirs, extern_libs, {})
 
+	source_dirs = {
+		"third_party/tinygettext/src",
+	}
+	extern_libs = {
+		"iconv",
+	}
+	setup_third_party_static_lib_project("tinygettext", source_dirs, extern_libs, { no_pch = 1 })
+	
+	-- it's an external library and we don't want to modify its source to fix warnings, so we just disable them to avoid noise in the compile output
+	if _ACTION == "vs2005" or _ACTION == "vs2008" or _ACTION == "vs2010" or _ACTION == "vs2012" or _ACTION == "vs2013" then
+		buildoptions { 
+			"/wd4127",
+			"/wd4309",
+			"/wd4800",
+			"/wd4100",
+			"/wd4996",
+			"/wd4099",
+			"/wd4503"
+		}
+	end
+
 
 	if not _OPTIONS["without-lobby"] then
 		source_dirs = {
 			"lobby",
 			"lobby/scripting",
 			"third_party/encryption"
 		}
 
 		extern_libs = {
 			"spidermonkey",
 			"boost",
 			"gloox",
 		}
 		setup_static_lib_project("lobby", source_dirs, extern_libs, {})
 
 		if _OPTIONS["use-shared-glooxwrapper"] and not _OPTIONS["build-shared-glooxwrapper"] then
 			table.insert(static_lib_names_debug, "glooxwrapper_dbg")
 			table.insert(static_lib_names_release, "glooxwrapper")
 		else
 			source_dirs = {
 				"lobby/glooxwrapper",
 			}
 			extern_libs = {
 				"boost",
 				"gloox",
 			}
 			if _OPTIONS["build-shared-glooxwrapper"] then
 				setup_shared_lib_project("glooxwrapper", source_dirs, extern_libs, {})
 			else
 				setup_static_lib_project("glooxwrapper", source_dirs, extern_libs, {})
 			end
 		end
 	else
 		source_dirs = {
 			"lobby/scripting",
 			"third_party/encryption"
 		}
 		extern_libs = {
 			"spidermonkey",
 			"boost"
 		}
 		setup_static_lib_project("lobby", source_dirs, extern_libs, {})
 		files { source_root.."lobby/Globals.cpp" }
 	end
 
 
 	source_dirs = {
 		"simulation2",
 		"simulation2/components",
 		"simulation2/helpers",
 		"simulation2/scripting",
 		"simulation2/serialization",
 		"simulation2/system",
 		"simulation2/testcomponents",
 	}
 	extern_libs = {
 		"boost",
 		"opengl",
 		"spidermonkey",
 	}
 	setup_static_lib_project("simulation2", source_dirs, extern_libs, {})
 
 
 	source_dirs = {
 		"scriptinterface",
 	}
 	extern_libs = {
 		"boost",
 		"spidermonkey",
 		"valgrind",
 		"sdl",
 	}
 	setup_static_lib_project("scriptinterface", source_dirs, extern_libs, {})
 
 
 	source_dirs = {
 		"ps",
 		"ps/scripting",
 		"ps/Network",
 		"ps/GameSetup",
 		"ps/XML",
 		"soundmanager",
 		"soundmanager/data",
 		"soundmanager/items",
 		"soundmanager/scripting",
 		"maths",
 		"maths/scripting",
+		"i18n",
+		"i18n/scripting"
 	}
 	extern_libs = {
 		"spidermonkey",
 		"sdl",	-- key definitions
 		"libxml2",
 		"opengl",
 		"zlib",
 		"boost",
 		"enet",
 		"libcurl",
+		"tinygettext",
+		"icu",
+		"iconv",
 	}
 	
 	if not _OPTIONS["without-audio"] then
 		table.insert(extern_libs, "openal")
 		table.insert(extern_libs, "vorbis")
 	end
 	
 	setup_static_lib_project("engine", source_dirs, extern_libs, {})
 
 
 	source_dirs = {
 		"graphics",
 		"graphics/scripting",
 		"renderer",
 		"renderer/scripting",
 		"third_party/mikktspace"
 	}
 	extern_libs = {
 		"opengl",
 		"sdl",	-- key definitions
 		"spidermonkey",	-- for graphics/scripting
 		"boost"
 	}
 	if not _OPTIONS["without-nvtt"] then
 		table.insert(extern_libs, "nvtt")
 	end
 	setup_static_lib_project("graphics", source_dirs, extern_libs, {})
 
 
 	source_dirs = {
 		"tools/atlas/GameInterface",
 		"tools/atlas/GameInterface/Handlers"
 	}
 	extern_libs = {
 		"boost",
 		"sdl",	-- key definitions
 		"opengl",
 		"spidermonkey"
 	}
 	setup_static_lib_project("atlas", source_dirs, extern_libs, {})
 
 
 	source_dirs = {
 		"gui",
-		"gui/scripting"
+		"gui/scripting",
+		"i18n"
 	}
 	extern_libs = {
 		"spidermonkey",
 		"sdl",	-- key definitions
 		"opengl",
 		"boost",
+		"tinygettext",
+		"icu",
+		"iconv",
 	}
 	if not _OPTIONS["without-audio"] then
 		table.insert(extern_libs, "openal")
 	end
 	setup_static_lib_project("gui", source_dirs, extern_libs, {})
 
 
 	source_dirs = {
 		"lib",
 		"lib/adts",
 		"lib/allocators",
 		"lib/external_libraries",
 		"lib/file",
 		"lib/file/archive",
 		"lib/file/common",
 		"lib/file/io",
 		"lib/file/vfs",
 		"lib/pch",
 		"lib/posix",
 		"lib/res",
 		"lib/res/graphics",
 		"lib/sysdep",
 		"lib/tex"
 	}
 	extern_libs = {
 		"boost",
 		"sdl",
 		"opengl",
 		"libpng",
 		"zlib",
 		"libjpg",
 		"valgrind",
 		"cxxtest",
 	}
 
 	-- CPU architecture-specific
 	if arch == "amd64" then
 		table.insert(source_dirs, "lib/sysdep/arch/amd64");
 		table.insert(source_dirs, "lib/sysdep/arch/x86_x64");
 	elseif arch == "x86" then
 		table.insert(source_dirs, "lib/sysdep/arch/ia32");
 		table.insert(source_dirs, "lib/sysdep/arch/x86_x64");
 	elseif arch == "arm" then
 		table.insert(source_dirs, "lib/sysdep/arch/arm");
 	end
 
 	-- OS-specific
 	sysdep_dirs = {
 		linux = { "lib/sysdep/os/linux", "lib/sysdep/os/unix" },
 		-- note: RC file must be added to main_exe project.
 		-- note: don't add "lib/sysdep/os/win/aken.cpp" because that must be compiled with the DDK.
 		windows = { "lib/sysdep/os/win", "lib/sysdep/os/win/wposix", "lib/sysdep/os/win/whrt" },
 		macosx = { "lib/sysdep/os/osx", "lib/sysdep/os/unix" },
 		bsd = { "lib/sysdep/os/bsd", "lib/sysdep/os/unix", "lib/sysdep/os/unix/x" },
 	}
 	for i,v in pairs(sysdep_dirs[os.get()]) do
 		table.insert(source_dirs, v);
 	end
 	
 	if os.is("linux") then
 		if _OPTIONS["android"] then
 			table.insert(source_dirs, "lib/sysdep/os/android")
 		else
 			table.insert(source_dirs, "lib/sysdep/os/unix/x")
 		end
 	end
 
 	-- runtime-library-specific
 	if _ACTION == "vs2005" or _ACTION == "vs2008" or _ACTION == "vs2010" or _ACTION == "vs2012" or _ACTION == "vs2013" then
 		table.insert(source_dirs, "lib/sysdep/rtl/msc");
 	else
 		table.insert(source_dirs, "lib/sysdep/rtl/gcc");
 	end
 
 	setup_static_lib_project("lowlevel", source_dirs, extern_libs, {})
 
 
 	-- Third-party libraries that are built as part of the main project,
 	-- not built externally and then linked
 	source_dirs = {
 		"third_party/mongoose",
 	}
 	extern_libs = {
 	}
 	setup_static_lib_project("mongoose", source_dirs, extern_libs, { no_pch = 1 })
 
 
 	-- CxxTest mock function support
 	extern_libs = {
 		"boost",
 		"cxxtest",
 	}
 
 	-- 'real' implementations, to be linked against the main executable
 	-- (files are added manually and not with setup_static_lib_project
 	-- because not all files in the directory are included)
 	setup_static_lib_project("mocks_real", {}, extern_libs, { no_default_link = 1, no_pch = 1 })
 	files { "mocks/*.h", source_root.."mocks/*_real.cpp" }
 	-- 'test' implementations, to be linked against the test executable
 	setup_static_lib_project("mocks_test", {}, extern_libs, { no_default_link = 1, no_pch = 1 })
 	files { source_root.."mocks/*.h", source_root.."mocks/*_test.cpp" }
 end
 
 --------------------------------------------------------------------------------
 -- main EXE
 --------------------------------------------------------------------------------
 
 -- used for main EXE as well as test
 used_extern_libs = {
 	"opengl",
 	"sdl",
 
 	"libjpg",
 	"libpng",
 	"zlib",
 
 	"spidermonkey",
 	"libxml2",
 
 	"boost",
 	"cxxtest",
 	"comsuppw",
 	"enet",
 	"libcurl",
+	"tinygettext",
+	"icu",
+	"iconv",
 
 	"valgrind",
 }
 
 if not os.is("windows") and not _OPTIONS["android"] and not os.is("macosx") then
 	-- X11 should only be linked on *nix
 	table.insert(used_extern_libs, "x11")
 	table.insert(used_extern_libs, "xcursor")
 end
 
 if not _OPTIONS["without-audio"] then
 	table.insert(used_extern_libs, "openal")
 	table.insert(used_extern_libs, "vorbis")
 end
 
 if not _OPTIONS["without-nvtt"] then
 	table.insert(used_extern_libs, "nvtt")
 end
 
 if not _OPTIONS["without-lobby"] then
 	table.insert(used_extern_libs, "gloox")
 end
 
 if not _OPTIONS["without-miniupnpc"] then
 	table.insert(used_extern_libs, "miniupnpc")
 end
 
 -- Bundles static libs together with main.cpp and builds game executable.
 function setup_main_exe ()
 
 	local target_type = get_main_project_target_type()
 	project_create("pyrogenesis", target_type)
 
 	links { "mocks_real" }
 
 	local extra_params = {
 		extra_files = { "main.cpp" },
 		no_pch = 1
 	}
 	project_add_contents(source_root, {}, {}, extra_params)
 	project_add_extern_libs(used_extern_libs, target_type)
 	project_add_x11_dirs()
 
 	-- Platform Specifics
 	if os.is("windows") then
 
 		files { source_root.."lib/sysdep/os/win/icon.rc" }
 		-- from "lowlevel" static lib; must be added here to be linked in
 		files { source_root.."lib/sysdep/os/win/error_dialog.rc" }
 
 		flags { "NoRTTI" }
 
 		linkoptions {
 			-- wraps main thread in a __try block(see wseh.cpp). replace with mainCRTStartup if that's undesired.
 			"/ENTRY:wseh_EntryPoint",
 
 			-- see wstartup.h
 			"/INCLUDE:_wstartup_InitAndRegisterShutdown",
 
 			-- allow manual unload of delay-loaded DLLs
 			"/DELAY:UNLOAD",
 		}
 
 		-- see manifest.cpp
 		project_add_manifest()
 
 	elseif os.is("linux") or os.is("bsd") then
 
 		if not _OPTIONS["android"] and not (os.getversion().description == "OpenBSD") then
 			links { "rt" }
 		end
 
 		if _OPTIONS["android"] then
 			-- NDK's STANDALONE-TOOLCHAIN.html says this is required
 			linkoptions { "-Wl,--fix-cortex-a8" }
 
 			links { "log" }
 		end
 
 		if os.is("linux") or os.getversion().description == "GNU/kFreeBSD" then
 			links {
 				-- Dynamic libraries (needed for linking for gold)
 				"dl",
 			}
 		elseif os.is("bsd") then
 			links {
 				-- Needed for backtrace* on BSDs
 				"execinfo",
 			}
 		end
 
 		-- Threading support
 		buildoptions { "-pthread" }
 		if not _OPTIONS["android"] then
 			linkoptions { "-pthread" }
 		end
 
 		-- For debug_resolve_symbol
 		configuration "Debug"
 			linkoptions { "-rdynamic" }
 		configuration { }
 
 	elseif os.is("macosx") then
 
 		links { "pthread" }
 		linkoptions { "-framework ApplicationServices", "-framework Cocoa", "-framework CoreFoundation" }
 
 	end
 end
 
 
 --------------------------------------------------------------------------------
 -- atlas
 --------------------------------------------------------------------------------
 
 -- setup a typical Atlas component project
 -- extra_params, rel_source_dirs and rel_include_dirs: as in project_add_contents;
 function setup_atlas_project(project_name, target_type, rel_source_dirs, rel_include_dirs, extern_libs, extra_params)
 
 	local source_root = rootdir.."/source/tools/atlas/" .. project_name .. "/"
 	project_create(project_name, target_type)
 
 	-- if not specified, the default for atlas pch files is in the project root.
 	if not extra_params["pch_dir"] then
 		extra_params["pch_dir"] = source_root
 	end
 
 	project_add_contents(source_root, rel_source_dirs, rel_include_dirs, extra_params)
 	project_add_extern_libs(extern_libs, target_type)
 	project_add_x11_dirs()
 
 	-- Platform Specifics
 	if os.is("windows") then
 		defines { "_UNICODE" }
 		-- Link to required libraries
 		links { "winmm", "comctl32", "rpcrt4", "delayimp", "ws2_32" }
 		-- required to use WinMain() on Windows, otherwise will default to main()
 		flags { "WinMain" }
 
 	elseif os.is("linux") or os.is("bsd") then
 		buildoptions { "-rdynamic", "-fPIC" }
 		linkoptions { "-fPIC", "-rdynamic" }
 
 	elseif os.is("macosx") then
 		-- install_name settings aren't really supported yet by premake, but there are plans for the future.
 		-- we currently use this hack to work around some bugs with wrong install_names.
 		if target_type == "SharedLib" then
 			if _OPTIONS["macosx-bundle"] then
 				-- If we're building a bundle, it will be in ../Frameworks
 				linkoptions { "-install_name @executable_path/../Frameworks/lib"..project_name..".dylib" }
 			else
 				linkoptions { "-install_name @executable_path/lib"..project_name..".dylib" }
 			end
 		end
 	end
 
 end
 
 
 -- build all Atlas component projects
 function setup_atlas_projects()
 
 	setup_atlas_project("AtlasObject", "StaticLib",
 	{	-- src
 		".",
 		"../../../third_party/jsonspirit"
 		
 	},{	-- include
 		"../../../third_party/jsonspirit"
 	},{	-- extern_libs
 		"boost",
 		"libxml2",
 		"wxwidgets"
 	},{	-- extra_params
 		no_pch = 1
 	})
 
 	atlas_src = {
 		"ActorEditor",
 		"CustomControls/Buttons",
 		"CustomControls/Canvas",
 		"CustomControls/ColourDialog",
 		"CustomControls/DraggableListCtrl",
 		"CustomControls/EditableListCtrl",
 		"CustomControls/FileHistory",
 		"CustomControls/HighResTimer",
 		"CustomControls/MapDialog",
 		"CustomControls/SnapSplitterWindow",
 		"CustomControls/VirtualDirTreeCtrl",
 		"CustomControls/Windows",
 		"ErrorReporter",
 		"General",
 		"General/VideoRecorder",
 		"Misc",
 		"ScenarioEditor",
 		"ScenarioEditor/Sections/Common",
 		"ScenarioEditor/Sections/Cinematic",
 		"ScenarioEditor/Sections/Environment",
 		"ScenarioEditor/Sections/Map",
 		"ScenarioEditor/Sections/Object",
 		"ScenarioEditor/Sections/Player",
 		"ScenarioEditor/Sections/Terrain",
 		"ScenarioEditor/Sections/Trigger",
 		"ScenarioEditor/Tools",
 		"ScenarioEditor/Tools/Common",
 	}
 	atlas_extra_links = {
 		"AtlasObject"
 	}
 
 	atlas_extern_libs = {
 		"boost",
 		"boost_signals",
 		"comsuppw",
 		--"ffmpeg", -- disabled for now because it causes too many build difficulties
 		"libxml2",
 		"sdl",	-- key definitions
 		"wxwidgets",
 		"zlib",
 	}
 	if not os.is("windows") and not os.is("macosx") then
 		-- X11 should only be linked on *nix
 		table.insert(atlas_extern_libs, "x11")
 	end
 
 	setup_atlas_project("AtlasUI", "SharedLib", atlas_src,
 	{	-- include
 		"..",
 		"CustomControls",
 		"Misc"
 	},
 	atlas_extern_libs,
 	{	-- extra_params
 		pch_dir = rootdir.."/source/tools/atlas/AtlasUI/Misc/",
 		no_pch = (has_broken_pch),
 		extra_links = atlas_extra_links,
 		extra_files = { "Misc/atlas.rc" }
 	})
 end
 
 
 -- Atlas 'frontend' tool-launching projects
 function setup_atlas_frontend_project (project_name)
 
 	local target_type = get_main_project_target_type()
 	project_create(project_name, target_type)
 	project_add_x11_dirs()
 
 	local source_root = rootdir.."/source/tools/atlas/AtlasFrontends/"
 	files { source_root..project_name..".cpp" }
 
 	if os.is("windows") then
 		files { source_root..project_name..".rc" }
 	end
 
 	includedirs { source_root .. ".." }
 
 	-- Platform Specifics
 	if os.is("windows") then
 		defines { "_UNICODE" }
 
 		-- required to use WinMain() on Windows, otherwise will default to main()
 		flags { "WinMain" }
 		
 		-- see manifest.cpp
 		project_add_manifest()
 
 	else -- Non-Windows, = Unix
 		links { "AtlasObject" }
 	end
 
 	links { "AtlasUI" }
 
 end
 
 function setup_atlas_frontends()
 	setup_atlas_frontend_project("ActorEditor")
 end
 
 
 --------------------------------------------------------------------------------
 -- collada
 --------------------------------------------------------------------------------
 
 function setup_collada_project(project_name, target_type, rel_source_dirs, rel_include_dirs, extern_libs, extra_params)
 
 	project_create(project_name, target_type)
 	local source_root = source_root.."collada/"
 	extra_params["pch_dir"] = source_root
 	project_add_contents(source_root, rel_source_dirs, rel_include_dirs, extra_params)
 	project_add_extern_libs(extern_libs, target_type)
 	project_add_x11_dirs()
 
 	-- Platform Specifics
 	if os.is("windows") then
 		-- required to use WinMain() on Windows, otherwise will default to main()
 		flags { "WinMain" }
 
 	elseif os.is("linux") then
 		defines { "LINUX" }
 
 		links {
 			"dl",
 		}
 
 		-- FCollada is not aliasing-safe, so disallow dangerous optimisations
 		-- (TODO: It'd be nice to fix FCollada, but that looks hard)
 		buildoptions { "-fno-strict-aliasing" }
 
 		buildoptions { "-rdynamic" }
 		linkoptions { "-rdynamic" }
 
 	elseif os.is("bsd") then
 		if os.getversion().description == "OpenBSD" then
 			links { "c", }
 		end
 
 		if os.getversion().description == "GNU/kFreeBSD" then
 			links {
 				"dl",
 			}
 		end
 
 		buildoptions { "-fno-strict-aliasing" }
 
 		buildoptions { "-rdynamic" }
 		linkoptions { "-rdynamic" }
 
 	elseif os.is("macosx") then
 		-- define MACOS-something?
 
 		-- install_name settings aren't really supported yet by premake, but there are plans for the future.
 		-- we currently use this hack to work around some bugs with wrong install_names.
 		if target_type == "SharedLib" then
 			if _OPTIONS["macosx-bundle"] then
 				-- If we're building a bundle, it will be in ../Frameworks
 				linkoptions { "-install_name @executable_path/../Frameworks/lib"..project_name..".dylib" }
 			else
 				linkoptions { "-install_name @executable_path/lib"..project_name..".dylib" }
 			end
 		end
 
 		buildoptions { "-fno-strict-aliasing" }
 		-- On OSX, fcollada uses a few utility functions from coreservices
 		linkoptions { "-framework CoreServices" }
 	end
 
 end
 
 -- build all Collada component projects
 function setup_collada_projects()
 
 	setup_collada_project("Collada", "SharedLib",
 	{	-- src
 		"."
 	},{	-- include
 	},{	-- extern_libs
 		"fcollada",
 		"libxml2"
 	},{	-- extra_params
 	})
 
 end
 
 
 --------------------------------------------------------------------------------
 -- tests
 --------------------------------------------------------------------------------
 
 -- Cxxtestgen needs to create .cpp files from the .h files before they can be compiled.
 -- By default we are using prebuildcommands, but we are also using customizations of premake
 -- for makefiles. The reason is that premake currently has a bug with makefiles and parallel
 -- builds (e.g. -j5). It's not guaranteed that prebuildcommands always run before building.
 -- All the *.cpp and *.h files need to be added to files no matter if prebuildcommands
 -- or customizations are used.
 -- If no customizations are implemented for a specific action (e.g. vs2010), passing the
 -- parameters won't have any effects.
 function configure_cxxtestgen()
 
 	local lcxxtestrootfile = source_root.."test_root.cpp"
 	files { lcxxtestrootfile }
 
 	-- Define the options used for cxxtestgen
 	local lcxxtestoptions = "--have-std"
 	local lcxxtestrootoptions = "--have-std"
 
 	if _OPTIONS["jenkins-tests"] then
 		lcxxtestrootoptions = lcxxtestrootoptions .. " --gui=PsTestWrapper --runner=XmlPrinter"
 	else
 		if os.is("windows") then
 			lcxxtestrootoptions = lcxxtestrootoptions .. " --gui=PsTestWrapper --runner=Win32ODSPrinter"
 		else
 			lcxxtestrootoptions = lcxxtestrootoptions .. " --gui=PsTestWrapper --runner=ErrorPrinter"
 		end
 	end
 
 	-- Precompiled headers - the header is added to all generated .cpp files
 	-- note that the header isn't actually precompiled here, only #included
 	-- so that the build stage can use it as a precompiled header.
 	local include = " --include=precompiled.h"
 	lcxxtestrootoptions = lcxxtestrootoptions .. include
 	lcxxtestoptions = lcxxtestoptions .. include
 
 	-- Set all the parameters used in our cxxtestgen customization in premake.
 	cxxtestrootfile(lcxxtestrootfile)
 	cxxtestpath(lcxxtestpath)
 	cxxtestrootoptions(lcxxtestrootoptions)
 	cxxtestoptions(lcxxtestoptions)
 
 	-- The file paths needs to be made relative to the project directory for the prebuildcommands.
 	-- premake's paths are relative to premake4.lua by default.
 	lcxxtestrootfile = path.rebase(lcxxtestrootfile, path.getabsolute("."), _OPTIONS["outpath"])
 	lcxxtestpath = path.rebase(lcxxtestpath, path.getabsolute("."), _OPTIONS["outpath"])
 
 	-- On windows we have to use backlashes in our paths. We don't have to take care
 	-- of that for the parameters passed to our cxxtestgen customizations.
 	if os.is("windows") then
 		lcxxtestrootfile = path.translate(lcxxtestrootfile, "\\")
 		lcxxtestpath = path.translate(lcxxtestpath, "\\")
 	end
 
 	if _ACTION ~= "gmake" and _ACTION ~= "vs2010" and _ACTION ~= "vs2012" and _ACTION ~= "vs2013" then
 		prebuildcommands { lcxxtestpath.." --root "..lcxxtestrootoptions.." -o "..lcxxtestrootfile }
 	end
 
 	-- Find header files in 'test' subdirectories
 	local all_files = os.matchfiles(source_root .. "**/tests/*.h")
 	for i,v in pairs(all_files) do
 		-- Don't include sysdep tests on the wrong sys
 		-- Don't include Atlas tests unless Atlas is being built
 		if not (string.find(v, "/sysdep/os/win/") and not os.is("windows")) and
 		   not (string.find(v, "/tools/atlas/") and not _OPTIONS["atlas"]) and
 		   not (string.find(v, "/sysdep/arch/x86_x64/") and ((arch ~= "amd64") or (arch ~= "x86")))
 		then
 			local src_file = string.sub(v, 1, -3) .. ".cpp"
 			cxxtestsrcfiles { src_file }
 			files { src_file }
 			cxxtesthdrfiles { v }
 
 			if _ACTION ~= "gmake" and _ACTION ~= "vs2010" and _ACTION ~= "vs2012" and _ACTION ~= "vs2013" then
 				-- see detailed comment above.
 				src_file = path.rebase(src_file, path.getabsolute("."), _OPTIONS["outpath"])
 				v = path.rebase(v, path.getabsolute("."), _OPTIONS["outpath"])
 
 				if os.is("windows") then
 					src_file = path.translate(src_file, "\\")
 					v = path.translate(v, "\\")
 				end
 				prebuildcommands { lcxxtestpath.." --part "..lcxxtestoptions.." -o "..src_file.." "..v }
 			end
 		end
 
 
 	end
 end
 
 
 function setup_tests()
 
 	local target_type = get_main_project_target_type()
 	project_create("test", target_type)
 
 	configure_cxxtestgen()
 
 	links { static_lib_names }
 	configuration "Debug"
 		links { static_lib_names_debug }
 	configuration "Release"
 		links { static_lib_names_release }
 	configuration { }
 
 	links { "mocks_test" }
 	if _OPTIONS["atlas"] then
 		links { "AtlasObject" }
 		project_add_extern_libs({"wxwidgets"}, target_type)
 	end
 	extra_params = {
 		extra_files = { "test_setup.cpp" },
 	}
 
 	project_add_contents(source_root, {}, {}, extra_params)
 	project_add_extern_libs(used_extern_libs, target_type)
 	project_add_x11_dirs()
 
 	-- TODO: should fix the duplication between this OS-specific linking
 	-- code, and the similar version in setup_main_exe
 
 	if os.is("windows") then
 		-- from "lowlevel" static lib; must be added here to be linked in
 		files { source_root.."lib/sysdep/os/win/error_dialog.rc" }
 
 		flags { "NoRTTI" }
 
 		-- see wstartup.h
 		linkoptions { "/INCLUDE:_wstartup_InitAndRegisterShutdown" }
 		-- Enables console for the TEST project on Windows
 		linkoptions { "/SUBSYSTEM:CONSOLE" }
 
 		project_add_manifest()
 
 	elseif os.is("linux") or os.is("bsd") then
 
 		if not _OPTIONS["android"] and not (os.getversion().description == "OpenBSD") then
 			links { "rt" }
 		end
 
 		if _OPTIONS["android"] then
 			-- NDK's STANDALONE-TOOLCHAIN.html says this is required
 			linkoptions { "-Wl,--fix-cortex-a8" }
 		end
 
 		if os.is("linux") or os.getversion().description == "GNU/kFreeBSD" then
 			links {
 				-- Dynamic libraries (needed for linking for gold)
 				"dl",
 			}
 		elseif os.is("bsd") then
 			links {
 				-- Needed for backtrace* on BSDs
 				"execinfo",
 			}
 		end
 
 		-- Threading support
 		buildoptions { "-pthread" }
 		if not _OPTIONS["android"] then
 			linkoptions { "-pthread" }
 		end
 
 		-- For debug_resolve_symbol
 		configuration "Debug"
 			linkoptions { "-rdynamic" }
 		configuration { }
 
 		includedirs { source_root .. "pch/test/" }
 	end
 end
 
 -- must come first, so that VC sets it as the default project and therefore
 -- allows running via F5 without the "where is the EXE" dialog.
 setup_main_exe()
 
 setup_all_libs()
 
 -- add the static libs to the main EXE project. only now (after
 -- setup_all_libs has run) are the lib names known. cannot move
 -- setup_main_exe to run after setup_all_libs (see comment above).
 -- we also don't want to hardcode the names - that would require more
 -- work when changing the static lib breakdown.
 project("pyrogenesis") -- Set the main project active
 	links { static_lib_names }
 	configuration "Debug"
 		links { static_lib_names_debug }
 	configuration "Release"
 		links { static_lib_names_release }
 	configuration { }
 
 if _OPTIONS["atlas"] then
 	setup_atlas_projects()
 	setup_atlas_frontends()
 end
 
 if _OPTIONS["collada"] then
 	setup_collada_projects()
 end
 
 if not _OPTIONS["without-tests"] then
 	setup_tests()
 end
Index: ps/trunk/source/gui/CGUI.cpp
===================================================================
--- ps/trunk/source/gui/CGUI.cpp	(revision 14952)
+++ ps/trunk/source/gui/CGUI.cpp	(revision 14953)
@@ -1,1863 +1,1936 @@
 /* Copyright (C) 2014 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
 CGUI
 */
 
 #include "precompiled.h"
 
 #include <string>
 
 #include <stdarg.h>
 
 #include "GUI.h"
 
 // Types - when including them into the engine.
 #include "CButton.h"
 #include "CImage.h"
 #include "CText.h"
 #include "CCheckBox.h"
 #include "CRadioButton.h"
 #include "CInput.h"
 #include "CList.h"
 #include "COList.h"
 #include "CDropDown.h"
 #include "CProgressBar.h"
 #include "CTooltip.h"
 #include "MiniMap.h"
 #include "scripting/ScriptFunctions.h"
 
 #include "graphics/FontMetrics.h"
 #include "graphics/ShaderManager.h"
 #include "graphics/TextRenderer.h"
 #include "lib/input.h"
 #include "lib/bits.h"
+#include "i18n/L10n.h"
 #include "lib/timer.h"
 #include "lib/sysdep/sysdep.h"
+#include "lib/utf8.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "ps/Hotkey.h"
 #include "ps/Globals.h"
 #include "ps/Overlay.h"
 #include "ps/Profile.h"
 #include "ps/Pyrogenesis.h"
 #include "ps/XML/Xeromyces.h"
 #include "renderer/Renderer.h"
 #include "scriptinterface/ScriptInterface.h"
 
 extern int g_yres;
 
 const double SELECT_DBLCLICK_RATE = 0.5;
 
 InReaction CGUI::HandleEvent(const SDL_Event_* ev)
 {
 	InReaction ret = IN_PASS;
 
 	if (ev->ev.type == SDL_HOTKEYDOWN)
 	{
 		const char* hotkey = static_cast<const char*>(ev->ev.user.data1);
 		std::map<CStr, std::vector<IGUIObject*> >::iterator it = m_HotkeyObjects.find(hotkey);
 		if (it != m_HotkeyObjects.end())
 		{
 			for (size_t i = 0; i < it->second.size(); ++i)
 			{
 				it->second[i]->SendEvent(GUIM_PRESSED, "press");
 			}
 		}
 	}
 
 	else if (ev->ev.type == SDL_MOUSEMOTION)
 	{
 		// Yes the mouse position is stored as float to avoid
 		//  constant conversions when operating in a
 		//  float-based environment.
 		m_MousePos = CPos((float)ev->ev.motion.x, (float)ev->ev.motion.y);
 
 		SGUIMessage msg(GUIM_MOUSE_MOTION);
 		GUI<SGUIMessage>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject, 
 										&IGUIObject::HandleMessage, 
 										msg);
 	}
 
 	// Update m_MouseButtons. (BUTTONUP is handled later.)
 	else if (ev->ev.type == SDL_MOUSEBUTTONDOWN)
 	{
 		switch (ev->ev.button.button)
 		{
 		case SDL_BUTTON_LEFT:
 		case SDL_BUTTON_RIGHT:
 		case SDL_BUTTON_MIDDLE:
 			m_MouseButtons |= Bit<unsigned int>(ev->ev.button.button);
 			break;
 		default:
 			break;
 		}
 	}
 
 	// Update m_MousePos (for delayed mouse button events)
 	CPos oldMousePos = m_MousePos;
 	if (ev->ev.type == SDL_MOUSEBUTTONDOWN || ev->ev.type == SDL_MOUSEBUTTONUP)
 	{
 		m_MousePos = CPos((float)ev->ev.button.x, (float)ev->ev.button.y);
 	}
 
 	// Only one object can be hovered
 	IGUIObject *pNearest = NULL;
 
 	// TODO Gee: (2004-09-08) Big TODO, don't do the below if the SDL_Event is something like a keypress!
 	try
 	{
 		PROFILE( "mouse events" );
 		// TODO Gee: Optimizations needed!
 		//  these two recursive function are quite overhead heavy.
 
 		// pNearest will after this point at the hovered object, possibly NULL
 		pNearest = FindObjectUnderMouse();
 
 		// Now we'll call UpdateMouseOver on *all* objects,
 		//  we'll input the one hovered, and they will each
 		//  update their own data and send messages accordingly
 		GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject, 
 										&IGUIObject::UpdateMouseOver, 
 										pNearest);
 
 		if (ev->ev.type == SDL_MOUSEBUTTONDOWN)
 		{
 			switch (ev->ev.button.button)
 			{
 			case SDL_BUTTON_LEFT:
 				// Focus the clicked object (or focus none if nothing clicked on)
 				SetFocusedObject(pNearest);
 
 				if (pNearest)
 					ret = pNearest->SendEvent(GUIM_MOUSE_PRESS_LEFT, "mouseleftpress");
 				break;
 
 			case SDL_BUTTON_RIGHT:
 				if (pNearest)
 					ret = pNearest->SendEvent(GUIM_MOUSE_PRESS_RIGHT, "mouserightpress");
 				break;
 
 #if !SDL_VERSION_ATLEAST(2, 0, 0)
 			case SDL_BUTTON_WHEELDOWN: // wheel down
 				if (pNearest)
 					ret = pNearest->SendEvent(GUIM_MOUSE_WHEEL_DOWN, "mousewheeldown");
 				break;
 
 			case SDL_BUTTON_WHEELUP: // wheel up
 				if (pNearest)
 					ret = pNearest->SendEvent(GUIM_MOUSE_WHEEL_UP, "mousewheelup");
 				break;
 #endif
 			default:
 				break;
 			}
 		}
 #if SDL_VERSION_ATLEAST(2, 0, 0)
 		else if (ev->ev.type == SDL_MOUSEWHEEL)
 		{
 			if (ev->ev.wheel.y < 0)
 			{
 				if (pNearest)
 					ret = pNearest->SendEvent(GUIM_MOUSE_WHEEL_DOWN, "mousewheeldown");
 			}
 			else if (ev->ev.wheel.y > 0)
 			{
 				if (pNearest)
 					ret = pNearest->SendEvent(GUIM_MOUSE_WHEEL_UP, "mousewheelup");
 			}
 		}
 #endif
 		else if (ev->ev.type == SDL_MOUSEBUTTONUP)
 		{
 			switch (ev->ev.button.button)
 			{
 			case SDL_BUTTON_LEFT:
 				if (pNearest)
 				{
 					double timeElapsed = timer_Time() - pNearest->m_LastClickTime[SDL_BUTTON_LEFT];
 					pNearest->m_LastClickTime[SDL_BUTTON_LEFT] = timer_Time();
 					
 					//Double click?
 					if (timeElapsed < SELECT_DBLCLICK_RATE)
 					{
 						ret = pNearest->SendEvent(GUIM_MOUSE_DBLCLICK_LEFT, "mouseleftdoubleclick");
 					}
 					else
 					{
 						ret = pNearest->SendEvent(GUIM_MOUSE_RELEASE_LEFT, "mouseleftrelease");
 					}
 				}
 				break;
 			case SDL_BUTTON_RIGHT:
 				if (pNearest)
 				{
 					double timeElapsed = timer_Time() - pNearest->m_LastClickTime[SDL_BUTTON_RIGHT];
 					pNearest->m_LastClickTime[SDL_BUTTON_RIGHT] = timer_Time();
 					
 					//Double click?
 					if (timeElapsed < SELECT_DBLCLICK_RATE)
 					{
 						ret = pNearest->SendEvent(GUIM_MOUSE_DBLCLICK_RIGHT, "mouserightdoubleclick");
 					}
 					else
 					{
 						ret = pNearest->SendEvent(GUIM_MOUSE_RELEASE_RIGHT, "mouserightrelease");
 					}
 				}
 				break;
 			}
 
 			// Reset all states on all visible objects
 			GUI<>::RecurseObject(GUIRR_HIDDEN, m_BaseObject, 
 									&IGUIObject::ResetStates);
 
 			// Since the hover state will have been reset, we reload it.
 			GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject, 
 											&IGUIObject::UpdateMouseOver, 
 											pNearest);
 		}
 	}
 	catch (PSERROR_GUI& e)
 	{
 		UNUSED2(e);
 		debug_warn(L"CGUI::HandleEvent error");
 		// TODO Gee: Handle
 	}
 
 	// BUTTONUP's effect on m_MouseButtons is handled after
 	// everything else, so that e.g. 'press' handlers (activated
 	// on button up) see which mouse button had been pressed.
 	if (ev->ev.type == SDL_MOUSEBUTTONUP)
 	{
 		switch (ev->ev.button.button)
 		{
 		case SDL_BUTTON_LEFT:
 		case SDL_BUTTON_RIGHT:
 		case SDL_BUTTON_MIDDLE:
 			m_MouseButtons &= ~Bit<unsigned int>(ev->ev.button.button);
 			break;
 		default:
 			break;
 		}
 	}
 
 	// Restore m_MousePos (for delayed mouse button events)
 	if (ev->ev.type == SDL_MOUSEBUTTONDOWN || ev->ev.type == SDL_MOUSEBUTTONUP)
 	{
 		m_MousePos = oldMousePos;
 	}
 
 	// Handle keys for input boxes
 	if (GetFocusedObject())
 	{
 		if (
 			(ev->ev.type == SDL_KEYDOWN &&
 				ev->ev.key.keysym.sym != SDLK_ESCAPE &&
 				!g_keys[SDLK_LCTRL] && !g_keys[SDLK_RCTRL] &&
 				!g_keys[SDLK_LALT] && !g_keys[SDLK_RALT]) 
 			|| ev->ev.type == SDL_HOTKEYDOWN
 			)
 		{
 			ret = GetFocusedObject()->ManuallyHandleEvent(ev);
 		}
 		// else will return IN_PASS because we never used the button.
 	}
 
 	return ret;
 }
 
 void CGUI::TickObjects()
 {
 	CStr action = "tick";
 	GUI<CStr>::RecurseObject(0, m_BaseObject, 
 							&IGUIObject::ScriptEvent, action);
 
 	// Also update tooltips:
 	m_Tooltip.Update(FindObjectUnderMouse(), m_MousePos, this);
 }
 
 void CGUI::SendEventToAll(const CStr& EventName)
 {
 	// janwas 2006-03-03: spoke with Ykkrosh about EventName case.
 	// when registering, case is converted to lower - this avoids surprise
 	// if someone were to get the case wrong and then not notice their
 	// handler is never called. however, until now, the other end
 	// (sending events here) wasn't converting to lower case,
 	// leading to a similar problem.
 	// now fixed; case is irrelevant since all are converted to lower.
 	GUI<CStr>::RecurseObject(0, m_BaseObject, 
 		&IGUIObject::ScriptEvent, EventName.LowerCase());
 }
 
 //-------------------------------------------------------------------
 //  Constructor / Destructor
 //-------------------------------------------------------------------
 
 CGUI::CGUI(const shared_ptr<ScriptRuntime>& runtime) : m_MouseButtons(0), m_FocusedObject(NULL), m_InternalNameNumber(0)
 {
 	m_ScriptInterface.reset(new ScriptInterface("Engine", "GUIPage", runtime));
 	GuiScriptingInit(*m_ScriptInterface);
 	m_ScriptInterface->LoadGlobalScripts();
 	m_BaseObject = new CGUIDummyObject;
 	m_BaseObject->SetGUI(this);	
 }
 
 CGUI::~CGUI()
 {
 	Destroy();
 
 	if (m_BaseObject)
 		delete m_BaseObject;
 }
 
 //-------------------------------------------------------------------
 //  Functions
 //-------------------------------------------------------------------
 IGUIObject *CGUI::ConstructObject(const CStr& str)
 {
 	if (m_ObjectTypes.count(str) > 0)
 		return (*m_ObjectTypes[str])();
 	else
 	{
 		// Error reporting will be handled with the NULL return.
 		return NULL;
 	}
 }
 
 void CGUI::Initialize()
 {
 	// Add base types!
 	//  You can also add types outside the GUI to extend the flexibility of the GUI.
 	//  Pyrogenesis though will have all the object types inserted from here.
 	AddObjectType("empty",			&CGUIDummyObject::ConstructObject);
 	AddObjectType("button",			&CButton::ConstructObject);
 	AddObjectType("image",			&CImage::ConstructObject);
 	AddObjectType("text",			&CText::ConstructObject);
 	AddObjectType("checkbox",		&CCheckBox::ConstructObject);
 	AddObjectType("radiobutton",	&CRadioButton::ConstructObject);
 	AddObjectType("progressbar",	&CProgressBar::ConstructObject);
 	AddObjectType("minimap",        &CMiniMap::ConstructObject);
 	AddObjectType("input",			&CInput::ConstructObject);
 	AddObjectType("list",			&CList::ConstructObject);
 	AddObjectType("olist",			&COList::ConstructObject);
 	AddObjectType("dropdown",		&CDropDown::ConstructObject);
 	AddObjectType("tooltip",		&CTooltip::ConstructObject);
 }
 
 void CGUI::Draw()
 {
 	// Clear the depth buffer, so the GUI is
 	// drawn on top of everything else
 	glClear(GL_DEPTH_BUFFER_BIT);
 
 	try
 	{
 		// Recurse IGUIObject::Draw() with restriction: hidden
 		//  meaning all hidden objects won't call Draw (nor will it recurse its children)
 		GUI<>::RecurseObject(GUIRR_HIDDEN, m_BaseObject, &IGUIObject::Draw);
 	}
 	catch (PSERROR_GUI& e)
 	{
 		LOGERROR(L"GUI draw error: %hs", e.what());
 	}
 }
 
 void CGUI::DrawSprite(const CGUISpriteInstance& Sprite,
 					  int CellID,
 					  const float& Z,
 					  const CRect& Rect,
 					  const CRect& UNUSED(Clipping))
 {
 	// If the sprite doesn't exist (name == ""), don't bother drawing anything
 	if (Sprite.IsEmpty())
 		return;
 
 	// TODO: Clipping?
 
 	Sprite.Draw(Rect, CellID, m_Sprites, Z);
 }
 
 void CGUI::Destroy()
 {
 	// We can use the map to delete all
 	//  now we don't want to cancel all if one Destroy fails
 	for (map_pObjects::iterator it = m_pAllObjects.begin(); it != m_pAllObjects.end(); ++it)
 	{
 		try
 		{
 			it->second->Destroy();
 		}
 		catch (PSERROR_GUI& e)
 		{
 			UNUSED2(e);
 			debug_warn(L"CGUI::Destroy error");
 			// TODO Gee: Handle
 		}
 		
 		delete it->second;
 	}
 
 	// Clear all
 	m_pAllObjects.clear();
 	for(std::map<CStr, CGUISprite*>::iterator it = m_Sprites.begin(); it != m_Sprites.end(); ++it)
 		delete it->second;
 	m_Sprites.clear();
 	m_Icons.clear();
 }
 
 void CGUI::UpdateResolution()
 {
 	// Update ALL cached
 	GUI<>::RecurseObject(0, m_BaseObject, &IGUIObject::UpdateCachedSize );
 }
 
 void CGUI::AddObject(IGUIObject* pObject)
 {
 	try
 	{
 		// Add CGUI pointer
 		GUI<CGUI*>::RecurseObject(0, pObject, &IGUIObject::SetGUI, this);
 
 		// Add child to base object
 		m_BaseObject->AddChild(pObject); // can throw
 
 		// Cache tree
 		GUI<>::RecurseObject(0, pObject, &IGUIObject::UpdateCachedSize);
 
 		// Loaded
 		SGUIMessage msg(GUIM_LOAD);
 		GUI<SGUIMessage>::RecurseObject(0, pObject, &IGUIObject::HandleMessage, msg);
 	}
 	catch (PSERROR_GUI&)
 	{
 		throw;
 	}
 }
 
 void CGUI::UpdateObjects()
 {
 	// We'll fill a temporary map until we know everything
 	//  succeeded
 	map_pObjects AllObjects;
 
 	try
 	{
 		// Fill freshly
 		GUI< map_pObjects >::RecurseObject(0, m_BaseObject, &IGUIObject::AddToPointersMap, AllObjects );
 	}
 	catch (PSERROR_GUI&)
 	{
 		// Throw the same error
 		throw;
 	}
 
 	// Else actually update the real one
 	m_pAllObjects.swap(AllObjects);
 }
 
 bool CGUI::ObjectExists(const CStr& Name) const
 {
 	return m_pAllObjects.count(Name) != 0;
 }
 
 IGUIObject* CGUI::FindObjectByName(const CStr& Name) const
 {
 	map_pObjects::const_iterator it = m_pAllObjects.find(Name);
 	if (it == m_pAllObjects.end())
 		return NULL;
 	else
 		return it->second;
 }
 
 IGUIObject* CGUI::FindObjectUnderMouse() const
 {
 	IGUIObject* pNearest = NULL;
 	GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject,
 									&IGUIObject::ChooseMouseOverAndClosest,
 									pNearest);
 	return pNearest;
 }
 
 void CGUI::SetFocusedObject(IGUIObject* pObject)
 {
 	if (pObject == m_FocusedObject)
 		return;
 
 	if (m_FocusedObject)
 	{
 		SGUIMessage msg(GUIM_LOST_FOCUS);
 		m_FocusedObject->HandleMessage(msg);
 	}
 
 	m_FocusedObject = pObject;
 
 	if (m_FocusedObject)
 	{
 		SGUIMessage msg(GUIM_GOT_FOCUS);
 		m_FocusedObject->HandleMessage(msg);
 	}
 }
 
 // private struct used only in GenerateText(...)
 struct SGenerateTextImage
 {
 	float m_YFrom,			// The image's starting location in Y
 		  m_YTo,			// The image's end location in Y
 		  m_Indentation;	// The image width in other words
 
 	// Some help functions
 	// TODO Gee: CRect => CPoint ?
 	void SetupSpriteCall(const bool Left, SGUIText::SSpriteCall &SpriteCall, 
 						 const float width, const float y,
 						 const CSize &Size, const CStr& TextureName, 
 						 const float BufferZone, const int CellID)
 	{
 		// TODO Gee: Temp hardcoded values
 		SpriteCall.m_Area.top = y+BufferZone;
 		SpriteCall.m_Area.bottom = y+BufferZone + Size.cy;
 		
 		if (Left)
 		{
 			SpriteCall.m_Area.left = BufferZone;
 			SpriteCall.m_Area.right = Size.cx+BufferZone;
 		}
 		else
 		{
 			SpriteCall.m_Area.left = width-BufferZone - Size.cx;
 			SpriteCall.m_Area.right = width-BufferZone;
 		}
 
 		SpriteCall.m_CellID = CellID;
 		SpriteCall.m_Sprite = TextureName;
 
 		m_YFrom = SpriteCall.m_Area.top-BufferZone;
 		m_YTo = SpriteCall.m_Area.bottom+BufferZone;
 		m_Indentation = Size.cx+BufferZone*2;
 	}
 };
 
 SGUIText CGUI::GenerateText(const CGUIString &string,
 							const CStrW& FontW, const float &Width, const float &BufferZone,
 							const IGUIObject *pObject)
 {
 	SGUIText Text; // object we're generating
 
 	CStrIntern Font(FontW.ToUTF8());
 	
 	if (string.m_Words.size() == 0)
 		return Text;
 
 	float x=BufferZone, y=BufferZone; // drawing pointer
 	int from=0;
 	bool done=false;
 
 	bool FirstLine = true;	// Necessary because text in the first line is shorter
 							// (it doesn't count the line spacing)
 
 	// Images on the left or the right side.
 	std::vector<SGenerateTextImage> Images[2];
 	int pos_last_img=-1;	// Position in the string where last img (either left or right) were encountered.
 							//  in order to avoid duplicate processing.
 
 	// Easier to read.
 	bool WordWrapping = (Width != 0);
 
 	// get the alignment type for the control we are computing the text for since
 	// we are computing the horizontal alignment in this method in order to not have
 	// to run through the TextCalls a second time in the CalculateTextPosition method again
 	EAlign align;
 	GUI<EAlign>::GetSetting(pObject, "text_align", align);
 
 	// Go through string word by word
 	for (int i=0; i<(int)string.m_Words.size()-1 && !done; ++i)
 	{
 		// Pre-process each line one time, so we know which floating images
 		//  will be added for that line.
 
 		// Generated stuff is stored in Feedback.
 		CGUIString::SFeedback Feedback;
 
 		// Preliminary line_height, used for word-wrapping with floating images.
 		float prelim_line_height=0.f;
 
 		// Width and height of all text calls generated.
 		string.GenerateTextCall(this, Feedback, Font,
 								string.m_Words[i], string.m_Words[i+1],
 								FirstLine);
 
 		// Loop through our images queues, to see if images has been added.
 		
 		// Check if this has already been processed.
 		//  Also, floating images are only applicable if Word-Wrapping is on
 		if (WordWrapping && i > pos_last_img)
 		{
 			// Loop left/right
 			for (int j=0; j<2; ++j)
 			{
 				for (std::vector<CStr>::const_iterator it = Feedback.m_Images[j].begin(); 
 					it != Feedback.m_Images[j].end();
 					++it)
 				{
 					SGUIText::SSpriteCall SpriteCall;
 					SGenerateTextImage Image;
 
 					// Y is if no other floating images is above, y. Else it is placed
 					//  after the last image, like a stack downwards.
 					float _y;
 					if (!Images[j].empty())
 						_y = std::max(y, Images[j].back().m_YTo);
 					else
 						_y = y; 
 
 					// Get Size from Icon database
 					SGUIIcon icon = GetIcon(*it);
 
 					CSize size = icon.m_Size;
 					Image.SetupSpriteCall((j==CGUIString::SFeedback::Left), SpriteCall, Width, _y, size, icon.m_SpriteName, BufferZone, icon.m_CellID);
 
 					// Check if image is the lowest thing.
 					Text.m_Size.cy = std::max(Text.m_Size.cy, Image.m_YTo);
 
 					Images[j].push_back(Image);
 					Text.m_SpriteCalls.push_back(SpriteCall);
 				}
 			}
 		}
 
 		pos_last_img = std::max(pos_last_img, i);
 
 		x += Feedback.m_Size.cx;
 		prelim_line_height = std::max(prelim_line_height, Feedback.m_Size.cy);
 
 		// If Width is 0, then there's no word-wrapping, disable NewLine.
 		if ((WordWrapping && (x > Width-BufferZone || Feedback.m_NewLine)) || i == (int)string.m_Words.size()-2)
 		{
 			// Change 'from' to 'i', but first keep a copy of its value.
 			int temp_from = from;
 			from = i;
 
 			static const int From=0, To=1;
 			//int width_from=0, width_to=width;
 			float width_range[2];
 			width_range[From] = BufferZone;
 			width_range[To] = Width - BufferZone;
 
 			// Floating images are only applicable if word-wrapping is enabled.
 			if (WordWrapping)
 			{
 				// Decide width of the line. We need to iterate our floating images.
 				//  this won't be exact because we're assuming the line_height
 				//  will be as our preliminary calculation said. But that may change,
 				//  although we'd have to add a couple of more loops to try straightening
 				//  this problem out, and it is very unlikely to happen noticeably if one
 				//  structures his text in a stylistically pure fashion. Even if not, it
 				//  is still quite unlikely it will happen.
 				// Loop through left and right side, from and to.
 				for (int j=0; j<2; ++j)
 				{
 					for (std::vector<SGenerateTextImage>::const_iterator it = Images[j].begin(); 
 						it != Images[j].end(); 
 						++it)
 					{
 						// We're working with two intervals here, the image's and the line height's.
 						//  let's find the union of these two.
 						float union_from, union_to;
 
 						union_from = std::max(y, it->m_YFrom);
 						union_to = std::min(y+prelim_line_height, it->m_YTo);
 						
 						// The union is not empty
 						if (union_to > union_from)
 						{
 							if (j == From)
 								width_range[From] = std::max(width_range[From], it->m_Indentation);
 							else
 								width_range[To] = std::min(width_range[To], Width - it->m_Indentation);
 						}
 					}
 				}
 			}
 
 			// Reset X for the next loop
 			x = width_range[From];
 
 			// Now we'll do another loop to figure out the height and width of
 			//  the line (the height of the largest character and the width is
 			//  the sum of all of the individual widths). This
 			//  couldn't be determined in the first loop (main loop)
 			//  because it didn't regard images, so we don't know
 			//  if all characters processed, will actually be involved
 			//  in that line.
 			float line_height=0.f;
 			float line_width=0.f;
 			for (int j=temp_from; j<=i; ++j)
 			{
 				// We don't want to use Feedback now, so we'll have to use
 				//  another.
 				CGUIString::SFeedback Feedback2;
 
 				// Don't attach object, it'll suppress the errors
 				//  we want them to be reported in the final GenerateTextCall()
 				//  so that we don't get duplicates.
 				string.GenerateTextCall(this, Feedback2, Font,
 										string.m_Words[j], string.m_Words[j+1],
 										FirstLine);
 
 				// Append X value.
 				x += Feedback2.m_Size.cx;
 
 				if (WordWrapping && x > width_range[To] && j!=temp_from && !Feedback2.m_NewLine)
 					break;
 
 				// Let line_height be the maximum m_Height we encounter.
 				line_height = std::max(line_height, Feedback2.m_Size.cy);
 
 				line_width += Feedback2.m_Size.cx;
 
 				if (WordWrapping && Feedback2.m_NewLine)
 					break;
 			}
 
 			float dx = 0.f;
 			// compute offset based on what kind of alignment
 			switch (align)
 			{
 			case EAlign_Left:
 				// don't add an offset
 				dx = 0.f;
 				break;
 
 			case EAlign_Center:
 				dx = ((width_range[To] - width_range[From]) - line_width) / 2;
 				break;
 
 			case EAlign_Right:
 				dx = width_range[To] - line_width;
 				break;
 
 			default:
 				debug_warn(L"Broken EAlign in CGUI::GenerateText()");
 				break;
 			}
 			// Reset x once more
 			x = width_range[From];
 			// Move down, because font drawing starts from the baseline
 			y += line_height;
 
 			// Do the real processing now
 			for (int j=temp_from; j<=i; ++j)
 			{
 				// We don't want to use Feedback now, so we'll have to use
 				//  another one.
 				CGUIString::SFeedback Feedback2;
 
 				// Defaults
 				string.GenerateTextCall(this, Feedback2, Font,
 										string.m_Words[j], string.m_Words[j+1], 
 										FirstLine, pObject);
 
 				// Iterate all and set X/Y values
 				// Since X values are not set, we need to make an internal
 				//  iteration with an increment that will append the internal
 				//  x, that is what x_pointer is for.
 				float x_pointer=0.f;
 
 				std::vector<SGUIText::STextCall>::iterator it;
 				for (it = Feedback2.m_TextCalls.begin(); it != Feedback2.m_TextCalls.end(); ++it)
 				{
 					it->m_Pos = CPos(dx + x + x_pointer, y);
 
 					x_pointer += it->m_Size.cx;
 
 					if (it->m_pSpriteCall)
 					{
 						it->m_pSpriteCall->m_Area += it->m_Pos - CSize(0,it->m_pSpriteCall->m_Area.GetHeight());
 					}
 				}
 
 				// Append X value.
 				x += Feedback2.m_Size.cx;
 
 				Text.m_Size.cx = std::max(Text.m_Size.cx, x+BufferZone);
 
 				// The first word overrides the width limit, what we
 				//  do, in those cases, are just drawing that word even
 				//  though it'll extend the object.
 				if (WordWrapping) // only if word-wrapping is applicable
 				{
 					if (Feedback2.m_NewLine)
 					{
 						from = j+1;
 
 						// Sprite call can exist within only a newline segment,
 						//  therefore we need this.
 						Text.m_SpriteCalls.insert(Text.m_SpriteCalls.end(), Feedback2.m_SpriteCalls.begin(), Feedback2.m_SpriteCalls.end());
 						break;
 					}
 					else
 					if (x > width_range[To] && j==temp_from)
 					{
 						from = j+1;
 						// do not break, since we want it to be added to m_TextCalls
 					}
 					else
 					if (x > width_range[To])
 					{
 						from = j;
 						break;
 					}
 				}
 
 				// Add the whole Feedback2.m_TextCalls to our m_TextCalls.
 				Text.m_TextCalls.insert(Text.m_TextCalls.end(), Feedback2.m_TextCalls.begin(), Feedback2.m_TextCalls.end());
 				Text.m_SpriteCalls.insert(Text.m_SpriteCalls.end(), Feedback2.m_SpriteCalls.begin(), Feedback2.m_SpriteCalls.end());
 
 				if (j == (int)string.m_Words.size()-2)
 					done = true;
 			}
 
 			// Reset X
 			x = 0.f;
 
 			// Update height of all
 			Text.m_Size.cy = std::max(Text.m_Size.cy, y+BufferZone);
 
 			FirstLine = false;
 
 			// Now if we entered as from = i, then we want
 			//  i being one minus that, so that it will become
 			//  the same i in the next loop. The difference is that
 			//  we're on a new line now.
 			i = from-1;
 		}
 	}
 
 	return Text;
 }
 
 void CGUI::DrawText(SGUIText &Text, const CColor &DefaultColor, 
 					const CPos &pos, const float &z, const CRect &clipping)
 {
 	CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_gui_text);
 
 	tech->BeginPass();
 
 	bool isClipped = (clipping != CRect());
 	if (isClipped)
 	{
 		glEnable(GL_SCISSOR_TEST);
 		glScissor(clipping.left, g_yres - clipping.bottom, clipping.GetWidth(), clipping.GetHeight());
 	}
 
 	CTextRenderer textRenderer(tech->GetShader());
 	textRenderer.SetClippingRect(clipping);
 	textRenderer.Translate(0.0f, 0.0f, z);
 
 	for (std::vector<SGUIText::STextCall>::const_iterator it = Text.m_TextCalls.begin(); 
 		 it != Text.m_TextCalls.end(); 
 		 ++it)
 	{
 		// If this is just a placeholder for a sprite call, continue
 		if (it->m_pSpriteCall)
 			continue;
 
 		CColor color = it->m_UseCustomColor ? it->m_Color : DefaultColor;
 
 		textRenderer.Color(color);
 		textRenderer.Font(it->m_Font);
 		textRenderer.Put((float)(int)(pos.x+it->m_Pos.x), (float)(int)(pos.y+it->m_Pos.y), &it->m_String);
 	}
 
 	textRenderer.Render();
 
 	for (std::list<SGUIText::SSpriteCall>::iterator it=Text.m_SpriteCalls.begin(); 
 		 it!=Text.m_SpriteCalls.end(); 
 		 ++it)
 	{
 		DrawSprite(it->m_Sprite, it->m_CellID, z, it->m_Area + pos);
 	}
 
 	if (isClipped)
 		glDisable(GL_SCISSOR_TEST);
 
 	tech->EndPass();
 }
 
 bool CGUI::GetPreDefinedColor(const CStr& name, CColor &Output)
 {
 	if (m_PreDefinedColors.count(name) == 0)
 	{
 		return false;
 	}
 	else
 	{
 		Output = m_PreDefinedColors[name];
 		return true;
 	}
 }
 
 /**
  * @callgraph
  */
 void CGUI::LoadXmlFile(const VfsPath& Filename, boost::unordered_set<VfsPath>& Paths)
 {
 	Paths.insert(Filename);
 
 	CXeromyces XeroFile;
 	if (XeroFile.Load(g_VFS, Filename) != PSRETURN_OK)
 		// Fail silently
 		return;
 
 	XMBElement node = XeroFile.GetRoot();
 
 	// Check root element's (node) name so we know what kind of
 	//  data we'll be expecting
 	CStr root_name (XeroFile.GetElementString(node.GetNodeName()));
 
 	try
 	{
 
 		if (root_name == "objects")
 		{
 			Xeromyces_ReadRootObjects(node, &XeroFile, Paths);
 
 			// Re-cache all values so these gets cached too.
 			//UpdateResolution();
 		}
 		else
 		if (root_name == "sprites")
 		{
 			Xeromyces_ReadRootSprites(node, &XeroFile);
 		}
 		else
 		if (root_name == "styles")
 		{
 			Xeromyces_ReadRootStyles(node, &XeroFile);
 		}
 		else
 		if (root_name == "setup")
 		{
 			Xeromyces_ReadRootSetup(node, &XeroFile);
 		}
 		else
 		{
 			debug_warn(L"CGUI::LoadXmlFile error");
 			// TODO Gee: Output in log
 		}
 	}
 	catch (PSERROR_GUI& e)
 	{
 		LOGERROR(L"Errors loading GUI file %ls (%u)", Filename.string().c_str(), e.getCode());
 		return;
 	}
 }
 
 //===================================================================
 //	XML Reading Xeromyces Specific Sub-Routines
 //===================================================================
 
 void CGUI::Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths)
 {
 	int el_script = pFile->GetElementID("script");
 
 	std::vector<std::pair<CStr, CStr> > subst;
 
 	// Iterate main children
 	//  they should all be <object> or <script> elements
 	XMBElementList children = Element.GetChildNodes();
 	for (int i=0; i<children.Count; ++i)
 	{
 		//debug_printf(L"Object %d\n", i);
 		XMBElement child = children.Item(i);
 
 		if (child.GetNodeName() == el_script)
 			// Execute the inline script
 			Xeromyces_ReadScript(child, pFile, Paths);
 		else
 			// Read in this whole object into the GUI
 			Xeromyces_ReadObject(child, pFile, m_BaseObject, subst, Paths);
 	}
 }
 
 void CGUI::Xeromyces_ReadRootSprites(XMBElement Element, CXeromyces* pFile)
 {
 	// Iterate main children
 	//  they should all be <sprite> elements
 	XMBElementList children = Element.GetChildNodes();
 	for (int i=0; i<children.Count; ++i)
 	{
 		XMBElement child = children.Item(i);
 
 		// Read in this whole object into the GUI
 		Xeromyces_ReadSprite(child, pFile);
 	}
 }
 
 void CGUI::Xeromyces_ReadRootStyles(XMBElement Element, CXeromyces* pFile)
 {
 	// Iterate main children
 	//  they should all be <styles> elements
 	XMBElementList children = Element.GetChildNodes();
 	for (int i=0; i<children.Count; ++i)
 	{
 		XMBElement child = children.Item(i);
 
 		// Read in this whole object into the GUI
 		Xeromyces_ReadStyle(child, pFile);
 	}
 }
 
 void CGUI::Xeromyces_ReadRootSetup(XMBElement Element, CXeromyces* pFile)
 {
 	// Iterate main children
 	//  they should all be <icon>, <scrollbar> or <tooltip>.
 	XMBElementList children = Element.GetChildNodes();
 	for (int i=0; i<children.Count; ++i)
 	{
 		XMBElement child = children.Item(i);
 
 		// Read in this whole object into the GUI
 
 		CStr name (pFile->GetElementString(child.GetNodeName()));
 
 		if (name == "scrollbar")
 		{
 			Xeromyces_ReadScrollBarStyle(child, pFile);
 		}
 		else
 		if (name == "icon")
 		{
 			Xeromyces_ReadIcon(child, pFile);
 		}
 		else
 		if (name == "tooltip")
 		{
 			Xeromyces_ReadTooltip(child, pFile);
 		}
 		else
 		if (name == "color")
 		{
 			Xeromyces_ReadColor(child, pFile);
 		}
 		else
 		{
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 		}
 	}
 }
 
 void CGUI::Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject *pParent, const std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths)
 {
 	ENSURE(pParent);
 	int i;
 
 	// Our object we are going to create
 	IGUIObject *object = NULL;
 
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	// Well first of all we need to determine the type
 	CStr type (attributes.GetNamedItem(pFile->GetAttributeID("type")));
 	if (type.empty())
 		type = "empty";
 
 	// Construct object from specified type
 	//  henceforth, we need to do a rollback before aborting.
 	//  i.e. releasing this object
 	object = ConstructObject(type);
 
 	if (!object)
 	{
 		// Report error that object was unsuccessfully loaded
 		LOGERROR(L"GUI: Unrecognized object type \"%hs\"", type.c_str());
 		return;
 	}
 
 	// Cache some IDs for element attribute names, to avoid string comparisons
 	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
 	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
 	ELMT(object);
 	ELMT(action);
 	ELMT(repeat);
+	ELMT(translatableAttribute);
+	ELMT(translate);
+	ELMT(attribute);
+	ELMT(keep);
 	ATTR(style);
 	ATTR(type);
 	ATTR(name);
 	ATTR(hotkey);
 	ATTR(z);
 	ATTR(on);
 	ATTR(file);
+	ATTR(id);
 
 	//
 	//	Read Style and set defaults
 	//
 	//	If the setting "style" is set, try loading that setting.
 	//
 	//	Always load default (if it's available) first!
 	//
 	CStr argStyle (attributes.GetNamedItem(attr_style));
 
 	if (m_Styles.count("default") == 1)
 		object->LoadStyle(*this, "default");
 
 	if (! argStyle.empty())
 	{
 		// additional check
 		if (m_Styles.count(argStyle) == 0)
 		{
 			LOGERROR(L"GUI: Trying to use style '%hs' that doesn't exist.", argStyle.c_str());
 		}
 		else object->LoadStyle(*this, argStyle);
 	}
 	
 
 	//
 	//	Read Attributes
 	//
 
 	bool NameSet = false;
 	bool ManuallySetZ = false; // if z has been manually set, this turn true
 
 	CStr hotkeyTag;
 
 	// Now we can iterate all attributes and store
 	for (i=0; i<attributes.Count; ++i)
 	{
 		XMBAttribute attr = attributes.Item(i);
 
 		// If value is "null", then it is equivalent as never being entered
 		if (CStr(attr.Value) == "null")
 			continue;
 
 		// Ignore "type" and "style", we've already checked it
 		if (attr.Name == attr_type || attr.Name == attr_style)
 			continue;
 
 		// Also the name needs some special attention
 		if (attr.Name == attr_name)
 		{
 			CStr name (attr.Value);
 
 			// Apply the requested substitutions
 			for (size_t j = 0; j < NameSubst.size(); ++j)
 				name.Replace(NameSubst[j].first, NameSubst[j].second);
 
 			object->SetName(name);
 			NameSet = true;
 			continue;
 		}
 
 		// Wire up the hotkey tag, if it has one
 		if (attr.Name == attr_hotkey)
 			hotkeyTag = attr.Value;
 
 		if (attr.Name == attr_z)
 			ManuallySetZ = true;
 
 		// Try setting the value
 		if (object->SetSetting(pFile->GetAttributeString(attr.Name), attr.Value.FromUTF8(), true) != PSRETURN_OK)
 		{
 			LOGERROR(L"GUI: (object: %hs) Can't set \"%hs\" to \"%ls\"", object->GetPresentableName().c_str(), pFile->GetAttributeString(attr.Name).c_str(), attr.Value.FromUTF8().c_str());
 
 			// This is not a fatal error
 		}
 	}
 
 	// Check if name isn't set, generate an internal name in that case.
 	if (!NameSet)
 	{
 		object->SetName("__internal(" + CStr::FromInt(m_InternalNameNumber) + ")");
 		++m_InternalNameNumber;
 	}
 
 	// Attempt to register the hotkey tag, if one was provided
 	if (! hotkeyTag.empty())
 		m_HotkeyObjects[hotkeyTag].push_back(object);
 
 	CStrW caption (Element.GetText().FromUTF8());
 	if (! caption.empty())
 	{
 		// Set the setting caption to this
 		object->SetSetting("caption", caption, true);
 
 		// There is no harm if the object didn't have a "caption"
 	}
 
 
 	//
 	//	Read Children
 	//
 
 	// Iterate children
 	XMBElementList children = Element.GetChildNodes();
 
 	for (i=0; i<children.Count; ++i)
 	{
 		// Get node
 		XMBElement child = children.Item(i);
 
 		// Check what name the elements got
 		int element_name = child.GetNodeName();
 
 		if (element_name == elmt_object)
 		{
 			// Call this function on the child
 			Xeromyces_ReadObject(child, pFile, object, NameSubst, Paths);
 		}
 		else if (element_name == elmt_action)
 		{
 			// Scripted <action> element
 
 			// Check for a 'file' parameter
 			CStrW filename (child.GetAttributes().GetNamedItem(attr_file).FromUTF8());
 
 			CStr code;
 
 			// If there is a file, open it and use it as the code
 			if (! filename.empty())
 			{
 				Paths.insert(filename);
 				CVFSFile scriptfile;
 				if (scriptfile.Load(g_VFS, filename) != PSRETURN_OK)
 				{
 					LOGERROR(L"Error opening GUI script action file '%ls'", filename.c_str());
 					throw PSERROR_GUI_JSOpenFailed();
 				}
 
 				code = scriptfile.DecodeUTF8(); // assume it's UTF-8
 			}
 
-			// Read the inline code (concatenating to the file code, if both are specified)
-			code += CStr(child.GetText());
+			XMBElementList grandchildren = child.GetChildNodes();
+			if (grandchildren.Count > 0) // The <action> element contains <keep> and <translate> tags.
+			{
+				for (int i = 0; i < grandchildren.Count; ++i)
+				{
+					XMBElement grandchild = grandchildren.Item(i);
+					if (grandchild.GetNodeName() == elmt_translate)
+					{
+						code += L10n::Instance().Translate(grandchild.GetText());
+					}
+					else if (grandchild.GetNodeName() == elmt_keep)
+					{
+						code += grandchild.GetText();
+					}
+				}
+			}
+			else // It’s pure JavaScript code.
+			{
+				// Read the inline code (concatenating to the file code, if both are specified)
+				code += CStr(child.GetText());
+			}
 
 			CStr action = CStr(child.GetAttributes().GetNamedItem(attr_on));
 			
 			// We need to set the GUI this object belongs to because RegisterScriptHandler requires an associated GUI.
 			object->SetGUI(this);
 			object->RegisterScriptHandler(action.LowerCase(), code, this);
 		}
 		else if (element_name == elmt_repeat)
 		{
 			Xeromyces_ReadRepeat(child, pFile, object, Paths);
 		}
+		else if (element_name == elmt_translatableAttribute)
+		{
+			// This is an element in the form “<translatableAttribute id="attributeName">attributeValue</translatableAttribute>”.
+			CStr attributeName(child.GetAttributes().GetNamedItem(attr_id)); // Read the attribute name.
+			if (!attributeName.empty())
+			{
+				CStr value(child.GetText());
+				if (!value.empty())
+				{
+					CStr translatedValue(L10n::Instance().Translate(value));
+					object->SetSetting(attributeName, translatedValue.UnescapeBackslashes().FromUTF8(), true);
+				}
+			}
+			else // Ignore.
+			{
+				LOGERROR(L"GUI: ‘attribute’ XML element with empty ‘id’ XML attribute found. (object: %hs)", object->GetPresentableName().c_str());
+			}
+		}
+		else if (element_name == elmt_attribute)
+		{
+			// This is an element in the form “<attribute id="attributeName"><keep>Don’t translate this part
+			// </keep><translate>but translate this one.</translate></attribute>”.
+			CStr attributeName(child.GetAttributes().GetNamedItem(attr_id)); // Read the attribute name.
+			if (!attributeName.empty())
+			{
+				CStr translatedValue;
+
+				XMBElementList grandchildren = child.GetChildNodes();
+				for (int i = 0; i < grandchildren.Count; ++i)
+				{
+					XMBElement grandchild = grandchildren.Item(i);
+					if (grandchild.GetNodeName() == elmt_translate)
+					{
+						translatedValue += L10n::Instance().Translate(grandchild.GetText());
+					}
+					else if (grandchild.GetNodeName() == elmt_keep)
+					{
+						translatedValue += grandchild.GetText();
+					}
+				}
+				object->SetSetting(attributeName, translatedValue.UnescapeBackslashes().FromUTF8(), true);
+			}
+			else // Ignore.
+			{
+				LOGERROR(L"GUI: ‘attribute’ XML element with empty ‘id’ XML attribute found. (object: %hs)", object->GetPresentableName().c_str());
+			}
+		}
 		else
 		{
 			// Try making the object read the tag.
 			if (!object->HandleAdditionalChildren(child, pFile))
 			{
 				LOGERROR(L"GUI: (object: %hs) Reading unknown children for its type", object->GetPresentableName().c_str());
 			}
 		}
 	} 
 
 	//
 	//	Check if Z wasn't manually set
 	//
 	if (!ManuallySetZ)
 	{
 		// Set it automatically to 10 plus its parents
 		bool absolute;
 		GUI<bool>::GetSetting(object, "absolute", absolute);
 
 		// If the object is absolute, we'll have to get the parent's Z buffered,
 		//  and add to that!
 		if (absolute)
 		{
 			GUI<float>::SetSetting(object, "z", pParent->GetBufferedZ() + 10.f, true);
 		}
 		else
 		// If the object is relative, then we'll just store Z as "10"
 		{
 			GUI<float>::SetSetting(object, "z", 10.f, true);
 		}
 	}
 
 
 	//
 	//	Input Child
 	//
 
 	try
 	{
 		if (pParent == m_BaseObject)
 			AddObject(object);
 		else
 			pParent->AddChild(object);
 	}
 	catch (PSERROR_GUI& e)
 	{
 		LOGERROR(L"GUI error: %hs", e.what());
 	}
 }
 
 void CGUI::Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject *pParent, boost::unordered_set<VfsPath>& Paths)
 {
 	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
 	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
 	ELMT(object);
 	ATTR(count);
 
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	int count = CStr(attributes.GetNamedItem(attr_count)).ToInt();
 
 	for (int n = 0; n < count; ++n)
 	{
 		std::vector<std::pair<CStr, CStr> > subst;
 		subst.push_back(std::make_pair(CStr("[n]"), "[" + CStr::FromInt(n) + "]"));
 
 		XERO_ITER_EL(Element, child)
 		{
 			if (child.GetNodeName() == elmt_object)
 			{
 				Xeromyces_ReadObject(child, pFile, pParent, subst, Paths);
 			}
 		}
 	}
 }
 
 void CGUI::Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths)
 {
 	// Check for a 'file' parameter
 	CStrW file (Element.GetAttributes().GetNamedItem( pFile->GetAttributeID("file") ).FromUTF8());
 
 	// If there is a file specified, open and execute it
 	if (! file.empty())
 	{
 		Paths.insert(file);
 		try
 		{
 			m_ScriptInterface->LoadGlobalScriptFile(file);
 		}
 		catch (PSERROR_Scripting& e)
 		{
 			LOGERROR(L"GUI: Error executing script %ls: %hs", file.c_str(), e.what());
 		}
 	}
 
 	// Execute inline scripts
 	try
 	{
 		CStr code (Element.GetText());
 		if (! code.empty())
 			m_ScriptInterface->LoadGlobalScript(L"Some XML file", code.FromUTF8());
 	}
 	catch (PSERROR_Scripting& e)
 	{
 		LOGERROR(L"GUI: Error executing inline script: %hs", e.what());
 	}
 }
 
 void CGUI::Xeromyces_ReadSprite(XMBElement Element, CXeromyces* pFile)
 {
 	// Sprite object we're adding
 	CGUISprite* Sprite = new CGUISprite;
 	
 	// and what will be its reference name
 	CStr name;
 
 	//
 	//	Read Attributes
 	//
 
 	// Get name, we know it exists because of DTD requirements
 	name = Element.GetAttributes().GetNamedItem( pFile->GetAttributeID("name") );
 
 	if (m_Sprites.find(name) != m_Sprites.end())
 		LOGWARNING(L"GUI sprite name '%hs' used more than once; first definition will be discarded", name.c_str());
 
 	//
 	//	Read Children (the images)
 	//
 
 	SGUIImageEffects* effects = NULL;
 
 	// Iterate children
 	XMBElementList children = Element.GetChildNodes();
 
 	for (int i=0; i<children.Count; ++i)
 	{
 		// Get node
 		XMBElement child = children.Item(i);
 
 		CStr ElementName (pFile->GetElementString(child.GetNodeName()));
 
 		if (ElementName == "image")
 		{
 			Xeromyces_ReadImage(child, pFile, *Sprite);
 		}
 		else if (ElementName == "effect")
 		{
 			if (effects)
 			{
 				LOGERROR(L"GUI <sprite> must not have more than one <effect>");
 			}
 			else
 			{
 				effects = new SGUIImageEffects;
 				Xeromyces_ReadEffects(child, pFile, *effects);
 			}
 		}
 		else
 		{
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 		}
 	}
 
 	// Apply the effects to every image (unless the image overrides it with
 	// different effects)
 	if (effects)
 		for (std::vector<SGUIImage*>::iterator it = Sprite->m_Images.begin(); it != Sprite->m_Images.end(); ++it)
 			if (! (*it)->m_Effects)
 				(*it)->m_Effects = new SGUIImageEffects(*effects); // do a copy just so it can be deleted correctly later
 
 	delete effects;
 
 	//
 	//	Add Sprite
 	//
 
 	m_Sprites[name] = Sprite;
 }
 
 void CGUI::Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite &parent)
 {
 
 	// Image object we're adding
 	SGUIImage* Image = new SGUIImage;
 	
 	// Set defaults to "0 0 100% 100%"
 	Image->m_TextureSize = CClientArea(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
 	Image->m_Size = CClientArea(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
 	
 	// TODO Gee: Setup defaults here (or maybe they are in the SGUIImage ctor)
 
 	//
 	//	Read Attributes
 	//
 
 	// Now we can iterate all attributes and store
 	XMBAttributeList attributes = Element.GetAttributes();
 	for (int i=0; i<attributes.Count; ++i)
 	{
 		XMBAttribute attr = attributes.Item(i);
 		CStr attr_name (pFile->GetAttributeString(attr.Name));
 		CStrW attr_value (attr.Value.FromUTF8());
 
 		if (attr_name == "texture")
 		{
 			Image->m_TextureName = VfsPath("art/textures/ui") / attr_value;
 		}
 		else
 		if (attr_name == "size")
 		{
 			CClientArea ca;
 			if (!GUI<CClientArea>::ParseString(attr_value, ca))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%ls\")", attr_name.c_str(), attr_value.c_str());
 			else Image->m_Size = ca;
 		}
 		else
 		if (attr_name == "texture_size")
 		{
 			CClientArea ca;
 			if (!GUI<CClientArea>::ParseString(attr_value, ca))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%ls\")", attr_name.c_str(), attr_value.c_str());
 			else Image->m_TextureSize = ca;
 		}
 		else
 		if (attr_name == "real_texture_placement")
 		{
 			CRect rect;
 			if (!GUI<CRect>::ParseString(attr_value, rect))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%ls\")", attr_name.c_str(), attr_value.c_str());
 			else Image->m_TexturePlacementInFile = rect;
 		}
 		else
 		if (attr_name == "cell_size")
 		{
 			CSize size;
 			if (!GUI<CSize>::ParseString(attr_value, size))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%ls\")", attr_name.c_str(), attr_value.c_str());
 			else Image->m_CellSize = size;
 		}
 		else
 		if (attr_name == "fixed_h_aspect_ratio")
 		{
 			float val;
 			if (!GUI<float>::ParseString(attr_value, val))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%ls\")", attr_name.c_str(), attr_value.c_str());
 			else Image->m_FixedHAspectRatio = val;
 		}
 		else
 		if (attr_name == "round_coordinates")
 		{
 			bool b;
 			if (!GUI<bool>::ParseString(attr_value, b))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%ls\")", attr_name.c_str(), attr_value.c_str());
 			else Image->m_RoundCoordinates = b;
 		}
 		else
 		if (attr_name == "wrap_mode")
 		{
 			if (attr_value == L"repeat")
 				Image->m_WrapMode = GL_REPEAT;
 			else if (attr_value == L"mirrored_repeat")
 				Image->m_WrapMode = GL_MIRRORED_REPEAT;
 			else if (attr_value == L"clamp_to_edge")
 				Image->m_WrapMode = GL_CLAMP_TO_EDGE;
 			else
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%ls\")", attr_name.c_str(), attr_value.c_str());
 		}
 		else
 		if (attr_name == "z_level")
 		{
 			float z_level;
 			if (!GUI<float>::ParseString(attr_value, z_level))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%ls\")", attr_name.c_str(), attr_value.c_str());
 			else Image->m_DeltaZ = z_level/100.f;
 		}
 		else
 		if (attr_name == "backcolor")
 		{
 			CColor color;
 			if (!GUI<CColor>::ParseString(attr_value, color))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%ls\")", attr_name.c_str(), attr_value.c_str());
 			else Image->m_BackColor = color;
 		}
 		else
 		if (attr_name == "bordercolor")
 		{
 			CColor color;
 			if (!GUI<CColor>::ParseString(attr_value, color))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%ls\")", attr_name.c_str(), attr_value.c_str());
 			else Image->m_BorderColor = color;
 		}
 		else
 		if (attr_name == "border")
 		{
 			bool b;
 			if (!GUI<bool>::ParseString(attr_value, b))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%ls\")", attr_name.c_str(), attr_value.c_str());
 			else Image->m_Border = b;
 		}
 		else
 		{
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 		}
 	}
 
 	// Look for effects
 	XMBElementList children = Element.GetChildNodes();
 	for (int i=0; i<children.Count; ++i)
 	{
 		XMBElement child = children.Item(i);
 		CStr ElementName (pFile->GetElementString(child.GetNodeName()));
 		if (ElementName == "effect")
 		{
 			if (Image->m_Effects)
 			{
 				LOGERROR(L"GUI <image> must not have more than one <effect>");
 			}
 			else
 			{
 				Image->m_Effects = new SGUIImageEffects;
 				Xeromyces_ReadEffects(child, pFile, *Image->m_Effects);
 			}
 		}
 		else
 		{
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 		}
 	}
 
 	//
 	//	Input
 	//
 
 	parent.AddImage(Image);	
 }
 
 void CGUI::Xeromyces_ReadEffects(XMBElement Element, CXeromyces* pFile, SGUIImageEffects &effects)
 {
 	XMBAttributeList attributes = Element.GetAttributes();
 	for (int i=0; i<attributes.Count; ++i)
 	{
 		XMBAttribute attr = attributes.Item(i);
 		CStr attr_name (pFile->GetAttributeString(attr.Name));
 		CStrW attr_value (attr.Value.FromUTF8());
 
 		if (attr_name == "add_color")
 		{
 			CColor color;
 			if (!GUI<int>::ParseColor(attr_value, color, 0.f))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%ls\")", attr_name.c_str(), attr_value.c_str());
 			else effects.m_AddColor = color;
 		}
 		else if (attr_name == "grayscale")
 		{
 			effects.m_Greyscale = true;
 		}
 		else
 		{
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 		}
 	}
 }
 
 void CGUI::Xeromyces_ReadStyle(XMBElement Element, CXeromyces* pFile)
 {
 	// style object we're adding
 	SGUIStyle style;
 	CStr name;
 	
 	//
 	// Read Attributes
 	//
 
 	// Now we can iterate all attributes and store
 	XMBAttributeList attributes = Element.GetAttributes();
 	for (int i=0; i<attributes.Count; ++i)
 	{
 		XMBAttribute attr = attributes.Item(i);
 		CStr attr_name (pFile->GetAttributeString(attr.Name));
 
 		// The "name" setting is actually the name of the style
 		//  and not a new default
 		if (attr_name == "name")
 			name = attr.Value;
 		else
 			style.m_SettingsDefaults[attr_name] = attr.Value.FromUTF8();
 	}
 
 	//
 	// Add to CGUI
 	//
 
 	m_Styles[name] = style;
 }
 
 void CGUI::Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile)
 {
 	// style object we're adding
 	SGUIScrollBarStyle scrollbar;
 	CStr name;
 
 	// Setup some defaults.
 	scrollbar.m_MinimumBarSize = 0.f;
 	// Using 1.0e10 as a substitute for infinity
 	scrollbar.m_MaximumBarSize = 1.0e10;
 	scrollbar.m_UseEdgeButtons = false;
 
 	//
 	// Read Attributes
 	//
 
 	// Now we can iterate all attributes and store
 	XMBAttributeList attributes = Element.GetAttributes();
 	for (int i=0; i<attributes.Count; ++i)
 	{
 		XMBAttribute attr = attributes.Item(i);
 		CStr attr_name = pFile->GetAttributeString(attr.Name);
 		CStr attr_value (attr.Value); 
 
 		if (attr_value == "null")
 			continue;
 
 		if (attr_name == "name")
 			name = attr_value;
 		else
 		if (attr_name == "show_edge_buttons")
 		{
 			bool b;
 			if (!GUI<bool>::ParseString(attr_value.FromUTF8(), b))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str());
 			else
 				scrollbar.m_UseEdgeButtons = b;
 		}
 		if (attr_name == "width")
 		{
 			float f;
 			if (!GUI<float>::ParseString(attr_value.FromUTF8(), f))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str());
 			else
 				scrollbar.m_Width = f;
 		}
 		else
 		if (attr_name == "minimum_bar_size")
 		{
 			float f;
 			if (!GUI<float>::ParseString(attr_value.FromUTF8(), f))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str());
 			else
 				scrollbar.m_MinimumBarSize = f;
 		}
 		else
 		if (attr_name == "maximum_bar_size")
 		{
 			float f;
 			if (!GUI<float>::ParseString(attr_value.FromUTF8(), f))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str());
 			else
 				scrollbar.m_MaximumBarSize = f;
 		}
 		else
 		if (attr_name == "sprite_button_top")
 			scrollbar.m_SpriteButtonTop = attr_value;
 		else
 		if (attr_name == "sprite_button_top_pressed")
 			scrollbar.m_SpriteButtonTopPressed = attr_value;
 		else
 		if (attr_name == "sprite_button_top_disabled")
 			scrollbar.m_SpriteButtonTopDisabled = attr_value;
 		else
 		if (attr_name == "sprite_button_top_over")
 			scrollbar.m_SpriteButtonTopOver = attr_value;
 		else
 		if (attr_name == "sprite_button_bottom")
 			scrollbar.m_SpriteButtonBottom = attr_value;
 		else
 		if (attr_name == "sprite_button_bottom_pressed")
 			scrollbar.m_SpriteButtonBottomPressed = attr_value;
 		else
 		if (attr_name == "sprite_button_bottom_disabled")
 			scrollbar.m_SpriteButtonBottomDisabled = attr_value;
 		else
 		if (attr_name == "sprite_button_bottom_over")
 			scrollbar.m_SpriteButtonBottomOver = attr_value;
 		else
 		if (attr_name == "sprite_back_vertical")
 			scrollbar.m_SpriteBackVertical = attr_value;
 		else
 		if (attr_name == "sprite_bar_vertical")
 			scrollbar.m_SpriteBarVertical = attr_value;
 		else
 		if (attr_name == "sprite_bar_vertical_over")
 			scrollbar.m_SpriteBarVerticalOver = attr_value;
 		else
 		if (attr_name == "sprite_bar_vertical_pressed")
 			scrollbar.m_SpriteBarVerticalPressed = attr_value;
 	}
 
 	//
 	//	Add to CGUI 
 	//
 
 	m_ScrollBarStyles[name] = scrollbar;
 }
 
 void CGUI::Xeromyces_ReadIcon(XMBElement Element, CXeromyces* pFile)
 {
 	// Icon we're adding
 	SGUIIcon icon;
 	CStr name;
 
 	XMBAttributeList attributes = Element.GetAttributes();
 	for (int i=0; i<attributes.Count; ++i)
 	{
 		XMBAttribute attr = attributes.Item(i);
 		CStr attr_name (pFile->GetAttributeString(attr.Name));
 		CStr attr_value (attr.Value);
 
 		if (attr_value == "null")
 			continue;
 
 		if (attr_name == "name")
 			name = attr_value;
 		else
 		if (attr_name == "sprite")
 			icon.m_SpriteName = attr_value;
 		else
 		if (attr_name == "size")
 		{
 			CSize size;
 			if (!GUI<CSize>::ParseString(attr_value.FromUTF8(), size))
 				LOGERROR(L"Error parsing '%hs' (\"%hs\") inside <icon>.", attr_name.c_str(), attr_value.c_str());
 			else
 				icon.m_Size = size;
 		}
 		else
 		if (attr_name == "cell_id")
 		{
 			int cell_id;
 			if (!GUI<int>::ParseString(attr_value.FromUTF8(), cell_id))
 				LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\") inside <icon>.", attr_name.c_str(), attr_value.c_str());
 			else
 				icon.m_CellID = cell_id;
 		}
 		else
 		{
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 		}
 	}
 
 	m_Icons[name] = icon;
 }
 
 void CGUI::Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile)
 {
 	// Read the tooltip, and store it as a specially-named object
 
 	IGUIObject* object = new CTooltip;
 
 	XMBAttributeList attributes = Element.GetAttributes();
 	for (int i=0; i<attributes.Count; ++i)
 	{
 		XMBAttribute attr = attributes.Item(i);
 		CStr attr_name (pFile->GetAttributeString(attr.Name));
 		CStr attr_value (attr.Value);
 
 		if (attr_name == "name")
 		{
 			object->SetName("__tooltip_" + attr_value);
 		}
 		else
 		{
 			object->SetSetting(attr_name, attr_value.FromUTF8());
 		}
 	}
 
 	AddObject(object);
 }
 
 // Reads Custom Color
 void CGUI::Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile)
 {
 	// Read the color and stor in m_PreDefinedColors
 
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	//IGUIObject* object = new CTooltip;
 	CColor color;
 	CStr name = attributes.GetNamedItem(pFile->GetAttributeID("name"));
 
 	// Try parsing value 
 	CStr value (Element.GetText());
 	if (! value.empty())
 	{
 		// Try setting color to value
 		if (!color.ParseString(value, 255.f))
 		{
 			LOGERROR(L"GUI: Unable to create custom color '%hs'. Invalid color syntax.", name.c_str());
 		}
 		else
 		{
 			// input color
 			m_PreDefinedColors[name] = color;
 		}
 	}
 }
Index: ps/trunk/source/gui/COList.cpp
===================================================================
--- ps/trunk/source/gui/COList.cpp	(revision 14952)
+++ ps/trunk/source/gui/COList.cpp	(revision 14953)
@@ -1,318 +1,347 @@
 #include "precompiled.h"
 #include "COList.h"
+#include "i18n/L10n.h"
 
 #include "ps/CLogger.h"
 
 COList::COList() : CList(),m_HeadingHeight(30.f)
 {
 	AddSetting(GUIST_CGUISpriteInstance,	"sprite_heading");
 }
 
 void COList::SetupText()
 {
 	if (!GetGUI())
 		return;
 
 	CGUIList *pList;
 	GUI<CGUIList>::GetSettingPointer(this, "list_name", pList);
 
 	//ENSURE(m_GeneratedTexts.size()>=1);
 
 	m_ItemsYPositions.resize( pList->m_Items.size()+1 );
 
 	// Delete all generated texts. Some could probably be saved,
 	//  but this is easier, and this function will never be called
 	//  continuously, or even often, so it'll probably be okay.
 	std::vector<SGUIText*>::iterator it;
 	for (it=m_GeneratedTexts.begin(); it!=m_GeneratedTexts.end(); ++it)
 	{
 		if (*it)
 			delete *it;
 	}
 	m_GeneratedTexts.clear();
 
 	CStrW font;
 	if (GUI<CStrW>::GetSetting(this, "font", font) != PSRETURN_OK || font.empty())
 		// Use the default if none is specified
 		// TODO Gee: (2004-08-14) Don't define standard like this. Do it with the default style.
 		font = L"default";
 
 	//CGUIString caption;
 	bool scrollbar;
 	//GUI<CGUIString>::GetSetting(this, "caption", caption);
 	GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 
 	float width = GetListRect().GetWidth();
 	// remove scrollbar if applicable
 	if (scrollbar && GetScrollBar(0).GetStyle())
 		width -= GetScrollBar(0).GetStyle()->m_Width;
 
 	// Cache width for other use
 	m_TotalAvalibleColumnWidth = width;
 
 	float buffer_zone=0.f;
 	GUI<float>::GetSetting(this, "buffer_zone", buffer_zone);
 
 
 	for (unsigned int c=0; c<m_ObjectsDefs.size(); ++c)
 	{
 		SGUIText *text = new SGUIText();
 		CGUIString gui_string;
 		gui_string.SetValue(m_ObjectsDefs[c].m_Heading);
 		*text = GetGUI()->GenerateText(gui_string, font, width, buffer_zone, this);
 		AddText(text);
 	}
 
 
 	// Generate texts
 	float buffered_y = 0.f;
 
 	for (int i=0; i<(int)pList->m_Items.size(); ++i)
 	{
 		m_ItemsYPositions[i] = buffered_y;
 		for (unsigned int c=0; c<m_ObjectsDefs.size(); ++c)
 		{
 			CGUIList * pList_c;
 			GUI<CGUIList>::GetSettingPointer(this, m_ObjectsDefs[c].m_Id, pList_c);
 			SGUIText *text = new SGUIText();
 			*text = GetGUI()->GenerateText(pList_c->m_Items[i], font, width, buffer_zone, this);
 			if (c==0)
 				buffered_y += text->m_Size.cy;
 			AddText(text);
 		}
 	}
 
 	m_ItemsYPositions[pList->m_Items.size()] = buffered_y;
 
 	//if (! scrollbar)
 	//	CalculateTextPosition(m_CachedActualSize, m_TextPos, *m_GeneratedTexts[0]);
 
 	// Setup scrollbar
 	if (scrollbar)
 	{
 		GetScrollBar(0).SetScrollRange( m_ItemsYPositions.back() );
 		GetScrollBar(0).SetScrollSpace( GetListRect().GetHeight() );
 
 		CRect rect = GetListRect();
 		GetScrollBar(0).SetX( rect.right );
 		GetScrollBar(0).SetY( rect.top );
 		GetScrollBar(0).SetZ( GetBufferedZ() );
 		GetScrollBar(0).SetLength( rect.bottom - rect.top );
 	}
 }
 
 CRect COList::GetListRect() const
 {
 	return m_CachedActualSize + CRect(0, m_HeadingHeight, 0, 0);
 }
 
 void COList::HandleMessage(SGUIMessage &Message)
 {
 	CList::HandleMessage(Message);
 //	switch (Message.type)
 //	{
 //	case GUIM_SETTINGS_UPDATED:
 //		if (Message.value.Find("list_") != -1)
 //		{
 //			SetupText();
 //		}
 //	}
 }
 
 bool COList::HandleAdditionalChildren(const XMBElement& child, CXeromyces* pFile)
 {
-	int elmt_item = pFile->GetElementID("item");
-	int elmt_heading = pFile->GetElementID("heading");
-	int elmt_def = pFile->GetElementID("def");
+	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
+	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
+	ELMT(item);
+	ELMT(heading);
+	ELMT(def);
+	ELMT(translatableAttribute);
+	ATTR(id);
 
 	if (child.GetNodeName() == elmt_item)
 	{
 		AddItem(child.GetText().FromUTF8(), child.GetText().FromUTF8());
 		return true;
 	}
 	else if (child.GetNodeName() == elmt_heading)
 	{
 		CStrW text (child.GetText().FromUTF8());
 
 		return true;
 	}
 	else if (child.GetNodeName() == elmt_def)
 	{
 		ObjectDef oDef;
 
 		XMBAttributeList attributes = child.GetAttributes();
 		for (int i=0; i<attributes.Count; ++i)
 		{
 			XMBAttribute attr = attributes.Item(i);
 			CStr attr_name (pFile->GetAttributeString(attr.Name));
 			CStr attr_value (attr.Value);
 
 			if (attr_name == "color")
 			{
 				CColor color;
 				if (!GUI<CColor>::ParseString(attr_value.FromUTF8(), color))
 					LOGERROR(L"GUI: Error parsing '%hs' (\"%ls\")", attr_name.c_str(), attr_value.c_str());
 				else oDef.m_TextColor = color;
 			}
 			else if (attr_name == "id")
 			{
 				oDef.m_Id = "list_"+attr_value;
 			}
 			else if (attr_name == "width")
 			{
 				float width;
 				if (!GUI<float>::ParseString(attr_value.FromUTF8(), width))
 					LOGERROR(L"GUI: Error parsing '%hs' (\"%ls\")", attr_name.c_str(), attr_value.c_str());
 				else
 				{
 					// Check if it's a relative value, and save as decimal if so.
 					if (attr_value.find("%") != std::string::npos)
 					{
 						width = width / 100.f;
 					}
 					oDef.m_Width = width;
 				}
 			}
 			else if (attr_name == "heading")
 			{
 				oDef.m_Heading = attr_value.FromUTF8();
 			}
 
 		}
 
+		XMBElementList grandchildren = child.GetChildNodes();
+		for (int i = 0; i < grandchildren.Count; ++i)
+		{
+			XMBElement grandchild = grandchildren.Item(i);
+			if (grandchild.GetNodeName() == elmt_translatableAttribute)
+			{
+				CStr attributeName(grandchild.GetAttributes().GetNamedItem(attr_id));
+				// only the heading is translatable for list defs
+				if (!attributeName.empty() && attributeName == "heading")
+				{
+					CStr value(grandchild.GetText());
+					if (!value.empty())
+					{
+						CStr translatedValue(L10n::Instance().Translate(value));
+						oDef.m_Heading = translatedValue.FromUTF8();
+					}
+				}
+				else // Ignore.
+				{
+					LOGERROR(L"GUI: translatable attribute in olist def that isn't a heading. (object: %hs)", this->GetPresentableName().c_str());
+				}
+			}
+		}
+
 		m_ObjectsDefs.push_back(oDef);
 
 		AddSetting(GUIST_CGUIList, oDef.m_Id);
 		SetupText();
 
 		return true;
 	}
 	else
 	{
 		return false;
 	}
 }
 
 void COList::DrawList(const int &selected,
 					 const CStr& _sprite,
 					 const CStr& _sprite_selected,
 					 const CStr& _textcolor)
 {
 	float bz = GetBufferedZ();
 
 	// First call draw on ScrollBarOwner
 	bool scrollbar;
 	GUI<bool>::GetSetting(this, "scrollbar", scrollbar);
 
 	if (scrollbar)
 	{
 		// Draw scrollbar
 		IGUIScrollBarOwner::Draw();
 	}
 
 	if (GetGUI())
 	{
 		CRect rect = GetListRect();
 
 		CGUISpriteInstance *sprite=NULL, *sprite_selectarea=NULL;
 		int cell_id;
 		GUI<CGUISpriteInstance>::GetSettingPointer(this, _sprite, sprite);
 		GUI<CGUISpriteInstance>::GetSettingPointer(this, _sprite_selected, sprite_selectarea);
 		GUI<int>::GetSetting(this, "cell_id", cell_id);
 
 		CGUIList *pList;
 		GUI<CGUIList>::GetSettingPointer(this, "list_name", pList);
 
 		GetGUI()->DrawSprite(*sprite, cell_id, bz, rect);
 
 		float scroll=0.f;
 		if (scrollbar)
 		{
 			scroll = GetScrollBar(0).GetPos();
 		}
 
 		if (selected != -1)
 		{
 			ENSURE(selected >= 0 && selected+1 < (int)m_ItemsYPositions.size());
 
 			// Get rectangle of selection:
 			CRect rect_sel(rect.left, rect.top + m_ItemsYPositions[selected] - scroll,
 								 rect.right, rect.top + m_ItemsYPositions[selected+1] - scroll);
 
 			if (rect_sel.top <= rect.bottom &&
 				rect_sel.bottom >= rect.top)
 			{
 				if (rect_sel.bottom > rect.bottom)
 					rect_sel.bottom = rect.bottom;
 				if (rect_sel.top < rect.top)
 					rect_sel.top = rect.top;
 
 				if (scrollbar)
 				{
 					// Remove any overlapping area of the scrollbar.
 					if (rect_sel.right > GetScrollBar(0).GetOuterRect().left &&
 						rect_sel.right <= GetScrollBar(0).GetOuterRect().right)
 						rect_sel.right = GetScrollBar(0).GetOuterRect().left;
 
 					if (rect_sel.left >= GetScrollBar(0).GetOuterRect().left &&
 						rect_sel.left < GetScrollBar(0).GetOuterRect().right)
 						rect_sel.left = GetScrollBar(0).GetOuterRect().right;
 				}
 
 				GetGUI()->DrawSprite(*sprite_selectarea, cell_id, bz+0.05f, rect_sel);
 			}
 		}
 
 		CColor color;
 		GUI<CColor>::GetSetting(this, _textcolor, color);
 
 		CGUISpriteInstance *sprite_heading=NULL;
 		GUI<CGUISpriteInstance>::GetSettingPointer(this, "sprite_heading", sprite_heading);
 		CRect rect_head(m_CachedActualSize.left, m_CachedActualSize.top, m_CachedActualSize.right,
 										m_CachedActualSize.top + m_HeadingHeight);
 		GetGUI()->DrawSprite(*sprite_heading, cell_id, bz, rect_head);
 
 		float xpos = 0;
 		for (unsigned int def=0; def< m_ObjectsDefs.size(); ++def)
 		{
 			DrawText(def, color, m_CachedActualSize.TopLeft() + CPos(xpos, 4), bz+0.1f, rect_head);
 			// Check if it's a decimal value, and if so, assume relative positioning.
 			if (m_ObjectsDefs[def].m_Width < 1 && m_ObjectsDefs[def].m_Width > 0)
 				xpos += m_ObjectsDefs[def].m_Width * m_TotalAvalibleColumnWidth;
 			else
 				xpos += m_ObjectsDefs[def].m_Width;
 		}
 
 		for (int i=0; i<(int)pList->m_Items.size(); ++i)
 		{
 			if (m_ItemsYPositions[i+1] - scroll < 0 ||
 				m_ItemsYPositions[i] - scroll > rect.GetHeight())
 				continue;
 
 			// Clipping area (we'll have to substract the scrollbar)
 			CRect cliparea = GetListRect();
 
 			if (scrollbar)
 			{
 				if (cliparea.right > GetScrollBar(0).GetOuterRect().left &&
 					cliparea.right <= GetScrollBar(0).GetOuterRect().right)
 					cliparea.right = GetScrollBar(0).GetOuterRect().left;
 
 				if (cliparea.left >= GetScrollBar(0).GetOuterRect().left &&
 					cliparea.left < GetScrollBar(0).GetOuterRect().right)
 					cliparea.left = GetScrollBar(0).GetOuterRect().right;
 			}
 
 			xpos = 0;
 			for (unsigned int def=0; def< m_ObjectsDefs.size(); ++def)
 			{
 				DrawText(m_ObjectsDefs.size() * (i+/*Heading*/1) + def, m_ObjectsDefs[def].m_TextColor, rect.TopLeft() + CPos(xpos, -scroll + m_ItemsYPositions[i]), bz+0.1f, cliparea);
 				// Check if it's a decimal value, and if so, assume relative positioning.
 				if (m_ObjectsDefs[def].m_Width < 1 && m_ObjectsDefs[def].m_Width > 0)
 					xpos += m_ObjectsDefs[def].m_Width * m_TotalAvalibleColumnWidth;
 				else
 					xpos += m_ObjectsDefs[def].m_Width;
 			}
 		}
 	}
 }
Index: ps/trunk/source/gui/GUIRenderer.cpp
===================================================================
--- ps/trunk/source/gui/GUIRenderer.cpp	(revision 14952)
+++ ps/trunk/source/gui/GUIRenderer.cpp	(revision 14953)
@@ -1,452 +1,453 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2014 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "GUIRenderer.h"
 
 #include "graphics/ShaderManager.h"
 #include "graphics/TextureManager.h"
 #include "gui/GUIutil.h"
+#include "i18n/L10n.h"
 #include "lib/ogl.h"
 #include "lib/utf8.h"
 #include "lib/res/h_mgr.h"
 #include "lib/tex/tex.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "renderer/Renderer.h"
 
 
 using namespace GUIRenderer;
 
 
 DrawCalls::DrawCalls()
 {
 }
 
 // DrawCalls needs to be copyable, so it can be used in other copyable types.
 // But actually copying data is hard, since we'd need to avoid losing track of
 // who owns various pointers, so instead we just return an empty list.
 // The list should get filled in again (by GUIRenderer::UpdateDrawCallCache)
 // before it's used for rendering. (TODO: Is this class actually used safely
 // in practice?)
 
 DrawCalls::DrawCalls(const DrawCalls&)
 	: std::vector<SDrawCall>()
 {
 }
 
 DrawCalls& DrawCalls::operator=(const DrawCalls&)
 {
 	return *this;
 }
 
 
 void GUIRenderer::UpdateDrawCallCache(DrawCalls &Calls, const CStr& SpriteName, const CRect &Size, int CellID, std::map<CStr, CGUISprite*> &Sprites)
 {
 	// This is called only when something has changed (like the size of the
 	// sprite), so it doesn't need to be particularly efficient.
 
 	// Clean up the old data
 	Calls.clear();
 
 	// If this object has zero size, there's nothing to render. (This happens
 	// with e.g. tooltips that have zero size before they're first drawn, so
 	// it isn't necessarily an error.)
 	if (Size.left == Size.right && Size.top == Size.bottom)
 		return;
 
 
 	std::map<CStr, CGUISprite*>::iterator it (Sprites.find(SpriteName));
 	if (it == Sprites.end())
 	{
 		// Sprite not found. Check whether this a special sprite:
 		//     "stretched:filename.ext" - stretched image
 		//     "stretched:grayscale:filename.ext" - stretched grayscale image
 		//     "cropped:(0.5, 0.25)"    - stretch this ratio (x,y) of the top left of the image
 		//     "colour:r g b a"         - solid colour
 		//
 		// and if so, try to create it as a new sprite.
 		if (SpriteName.substr(0, 10) == "stretched:")
 		{
 			// TODO: Should check (nicely) that this is a valid file?
 			SGUIImage* Image = new SGUIImage;
 			
 			// Allow grayscale images for disabled portraits
 			if (SpriteName.substr(10, 10) == "grayscale:")
 			{
 				Image->m_TextureName = VfsPath("art/textures/ui") / wstring_from_utf8(SpriteName.substr(20));
 				Image->m_Effects = new SGUIImageEffects;
 				Image->m_Effects->m_Greyscale = true;
 			}
 			else
 			{
 				Image->m_TextureName = VfsPath("art/textures/ui") / wstring_from_utf8(SpriteName.substr(10));
 			}
 
 			CClientArea ca(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
 			Image->m_Size = ca;
 			Image->m_TextureSize = ca;
 
 			CGUISprite* Sprite = new CGUISprite;
 			Sprite->AddImage(Image);
 
 			Sprites[SpriteName] = Sprite;
 			
 			it = Sprites.find(SpriteName);
 			ENSURE(it != Sprites.end()); // The insertion above shouldn't fail
 		}
 		else if (SpriteName.substr(0, 8) == "cropped:")
 		{
 			// TODO: Should check (nicely) that this is a valid file?
 			SGUIImage* Image = new SGUIImage;
 
 			double xRatio = SpriteName.BeforeFirst(",").AfterLast("(").ToDouble();
 			double yRatio = SpriteName.BeforeFirst(")").AfterLast(",").ToDouble();
 			
 			int PathStart = SpriteName.Find(")") + 1;
 			
 			Image->m_TextureName = VfsPath("art/textures/ui") / wstring_from_utf8(SpriteName.substr(PathStart));
 
 			CClientArea ca(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
 			CClientArea cb(CRect(0, 0, 0, 0), CRect(0, 0, 100/xRatio, 100/yRatio));
 			Image->m_Size = ca;
 			Image->m_TextureSize = cb;
 
 			CGUISprite* Sprite = new CGUISprite;
 			Sprite->AddImage(Image);
 
 			Sprites[SpriteName] = Sprite;
 			
 			it = Sprites.find(SpriteName);
 			ENSURE(it != Sprites.end()); // The insertion above shouldn't fail
 		}
 		else if (SpriteName.substr(0, 7) == "colour:")
 		{
 			CStrW value = wstring_from_utf8(SpriteName.substr(7));
 			CColor color;
 
 			// Check colour is valid
 			if (!GUI<CColor>::ParseString(value, color))
 			{
 				LOGERROR(L"GUI: Error parsing sprite 'colour' (\"%ls\")", value.c_str());
 				return;
 			}
 
 			SGUIImage* Image = new SGUIImage;
 
 			Image->m_BackColor = color;
 
 			CClientArea ca(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
 			Image->m_Size = ca;
 			Image->m_TextureSize = ca;
 
 			CGUISprite* Sprite = new CGUISprite;
 			Sprite->AddImage(Image);
 
 			Sprites[SpriteName] = Sprite;
 
 			it = Sprites.find(SpriteName);
 			ENSURE(it != Sprites.end()); // The insertion above shouldn't fail
 		}
 		else
 		{
 			// Otherwise, just complain and give up:
 			LOGERROR(L"Trying to use a sprite that doesn't exist (\"%hs\").", SpriteName.c_str());
 			return;
 		}
 	}
 
 	Calls.reserve(it->second->m_Images.size());
 
 	// Iterate through all the sprite's images, loading the texture and
 	// calculating the texture coordinates
 	std::vector<SGUIImage*>::const_iterator cit;
 	for (cit = it->second->m_Images.begin(); cit != it->second->m_Images.end(); ++cit)
 	{
 		SDrawCall Call(*cit); // pointers are safe since we never modify sprites/images after startup
 
 		CRect ObjectSize = (*cit)->m_Size.GetClientArea(Size);
 
 		if (ObjectSize.GetWidth() == 0.0 || ObjectSize.GetHeight() == 0.0)
 		{
 			// Zero sized object. Don't report as an error, since it's common for e.g. hitpoint bars.
 			continue; // i.e. don't continue with this image
 		}
 
 		Call.m_Vertices = ObjectSize;
 		if ((*cit)->m_RoundCoordinates)
 		{
 			// Round the vertex coordinates to integers, to avoid ugly filtering artifacts
 			Call.m_Vertices.left = (int)(Call.m_Vertices.left + 0.5f);
 			Call.m_Vertices.right = (int)(Call.m_Vertices.right + 0.5f);
 			Call.m_Vertices.top = (int)(Call.m_Vertices.top + 0.5f);
 			Call.m_Vertices.bottom = (int)(Call.m_Vertices.bottom + 0.5f);
 		}
 
 		if (!(*cit)->m_TextureName.empty())
 		{
-			CTextureProperties textureProps((*cit)->m_TextureName);
+			CTextureProperties textureProps(L10n::Instance().LocalizePath((*cit)->m_TextureName));
 			textureProps.SetWrap((*cit)->m_WrapMode);
 			CTexturePtr texture = g_Renderer.GetTextureManager().CreateTexture(textureProps);
 			texture->Prefetch();
 			Call.m_HasTexture = true;
 			Call.m_Texture = texture;
 
 			Call.m_EnableBlending = false; // will be overridden if the texture has an alpha channel
 
 			Call.m_ObjectSize = ObjectSize;
 			Call.m_CellID = CellID;
 		}
 		else
 		{
 			Call.m_HasTexture = false;
 			// Enable blending if it's transparent (allowing a little error in the calculations)
 			Call.m_EnableBlending = !(fabs((*cit)->m_BackColor.a - 1.0f) < 0.0000001f);
 		}
 
 		Call.m_BackColor = (*cit)->m_BackColor;
 		Call.m_BorderColor = (*cit)->m_Border ? (*cit)->m_BorderColor : CColor();
 		Call.m_DeltaZ = (*cit)->m_DeltaZ;
 
 		if (!Call.m_HasTexture)
 		{
 			Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_solid);
 		}
 		else if ((*cit)->m_Effects)
 		{
 			if ((*cit)->m_Effects->m_AddColor != CColor())
 			{
 				Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_add);
 				Call.m_ShaderColorParameter = (*cit)->m_Effects->m_AddColor;
 				// Always enable blending if something's being subtracted from
 				// the alpha channel
 				if ((*cit)->m_Effects->m_AddColor.a < 0.f)
 					Call.m_EnableBlending = true;
 			}
 			else if ((*cit)->m_Effects->m_Greyscale)
 			{
 				Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_grayscale);
 			}
 			else /* Slight confusion - why no effects? */
 			{
 				Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_basic);
 			}
 		}
 		else
 		{
 			Call.m_Shader = g_Renderer.GetShaderManager().LoadEffect(str_gui_basic);
 		}
 
 		Calls.push_back(Call);
 	}
 }
 
 CRect SDrawCall::ComputeTexCoords() const
 {
 	float TexWidth = m_Texture->GetWidth();
 	float TexHeight = m_Texture->GetHeight();
 
 	if (!TexWidth || !TexHeight)
 	{
 		return CRect(0, 0, 1, 1);
 	}
 
 	// Textures are positioned by defining a rectangular block of the
 	// texture (usually the whole texture), and a rectangular block on
 	// the screen. The texture is positioned to make those blocks line up.
 
 	// Get the screen's position/size for the block
 	CRect BlockScreen = m_Image->m_TextureSize.GetClientArea(m_ObjectSize);
 
 	if (m_Image->m_FixedHAspectRatio)
 		BlockScreen.right = BlockScreen.left + BlockScreen.GetHeight() * m_Image->m_FixedHAspectRatio;
 
 	// Get the texture's position/size for the block:
 	CRect BlockTex;
 
 	// "real_texture_placement" overrides everything
 	if (m_Image->m_TexturePlacementInFile != CRect())
 	{
 		BlockTex = m_Image->m_TexturePlacementInFile;
 	}
 	// Check whether this sprite has "cell_size" set (and non-zero)
 	else if ((int)m_Image->m_CellSize.cx)
 	{
 		int cols = (int)TexWidth / (int)m_Image->m_CellSize.cx;
 		if (cols == 0)
 			cols = 1; // avoid divide-by-zero
 		int col = m_CellID % cols;
 		int row = m_CellID / cols;
 		BlockTex = CRect(m_Image->m_CellSize.cx*col, m_Image->m_CellSize.cy*row,
 		                 m_Image->m_CellSize.cx*(col+1), m_Image->m_CellSize.cy*(row+1));
 	}
 	// Use the whole texture
 	else
 		BlockTex = CRect(0, 0, TexWidth, TexHeight);
 
 	// When rendering, BlockTex will be transformed onto BlockScreen.
 	// Also, TexCoords will be transformed onto ObjectSize (giving the
 	// UV coords at each vertex of the object). We know everything
 	// except for TexCoords, so calculate it:
 
 	CPos translation (BlockTex.TopLeft()-BlockScreen.TopLeft());
 	float ScaleW = BlockTex.GetWidth()/BlockScreen.GetWidth();
 	float ScaleH = BlockTex.GetHeight()/BlockScreen.GetHeight();
 
 	CRect TexCoords (
 				// Resize (translating to/from the origin, so the
 				// topleft corner stays in the same place)
 				(m_ObjectSize-m_ObjectSize.TopLeft())
 				.Scale(ScaleW, ScaleH)
 				+ m_ObjectSize.TopLeft()
 				// Translate from BlockTex to BlockScreen
 				+ translation
 	);
 
 	// The tex coords need to be scaled so that (texwidth,texheight) is
 	// mapped onto (1,1)
 	TexCoords.left   /= TexWidth;
 	TexCoords.right  /= TexWidth;
 	TexCoords.top    /= TexHeight;
 	TexCoords.bottom /= TexHeight;
 
 	return TexCoords;
 }
 
 void GUIRenderer::Draw(DrawCalls &Calls, float Z)
 {
 	// Called every frame, to draw the object (based on cached calculations)
 
 	// TODO: batching by shader/texture/etc would be nice
 
 	CMatrix3D matrix = GetDefaultGuiMatrix();
 
 	glDisable(GL_BLEND);
 
 	// Set LOD bias so mipmapped textures are prettier
 #if CONFIG2_GLES
 #warning TODO: implement GUI LOD bias for GLES
 #else
 	glTexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, -1.f);
 #endif
 
 	// Iterate through each DrawCall, and execute whatever drawing code is being called
 	for (DrawCalls::const_iterator cit = Calls.begin(); cit != Calls.end(); ++cit)
 	{
 		cit->m_Shader->BeginPass();
 		CShaderProgramPtr shader = cit->m_Shader->GetShader();
 		shader->Uniform(str_transform, matrix);
 
 		if (cit->m_HasTexture)
 		{
 			shader->Uniform(str_color, cit->m_ShaderColorParameter);
 			shader->BindTexture(str_tex, cit->m_Texture);
 
 			if (cit->m_EnableBlending || cit->m_Texture->HasAlpha()) // (shouldn't call HasAlpha before BindTexture)
 			{
 				glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 				glEnable(GL_BLEND);
 			}
 
 			CRect TexCoords = cit->ComputeTexCoords();
 
 			// Ensure the quad has the correct winding order, and update texcoords to match
 			CRect Verts = cit->m_Vertices;
 			if (Verts.right < Verts.left)
 			{
 				std::swap(Verts.right, Verts.left);
 				std::swap(TexCoords.right, TexCoords.left);
 			}
 			if (Verts.bottom < Verts.top)
 			{
 				std::swap(Verts.bottom, Verts.top);
 				std::swap(TexCoords.bottom, TexCoords.top);
 			}
 
 			std::vector<float> data;
 #define ADD(u, v, x, y, z) STMT(data.push_back(u); data.push_back(v); data.push_back(x); data.push_back(y); data.push_back(z))
 			ADD(TexCoords.left, TexCoords.bottom, Verts.left, Verts.bottom, Z + cit->m_DeltaZ);
 			ADD(TexCoords.right, TexCoords.bottom, Verts.right, Verts.bottom, Z + cit->m_DeltaZ);
 			ADD(TexCoords.right, TexCoords.top, Verts.right, Verts.top, Z + cit->m_DeltaZ);
 
 			ADD(TexCoords.right, TexCoords.top, Verts.right, Verts.top, Z + cit->m_DeltaZ);
 			ADD(TexCoords.left, TexCoords.top, Verts.left, Verts.top, Z + cit->m_DeltaZ);
 			ADD(TexCoords.left, TexCoords.bottom, Verts.left, Verts.bottom, Z + cit->m_DeltaZ);
 #undef ADD
 
 			shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 5*sizeof(float), &data[0]);
 			shader->VertexPointer(3, GL_FLOAT, 5*sizeof(float), &data[2]);
 			glDrawArrays(GL_TRIANGLES, 0, 6);
 		}
 		else
 		{
 			shader->Uniform(str_color, cit->m_BackColor);
 
 			if (cit->m_EnableBlending)
 			{
 				glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 				glEnable(GL_BLEND);
 			}
 
 			// Ensure the quad has the correct winding order
 			CRect Verts = cit->m_Vertices;
 			if (Verts.right < Verts.left)
 				std::swap(Verts.right, Verts.left);
 			if (Verts.bottom < Verts.top)
 				std::swap(Verts.bottom, Verts.top);
 
 			std::vector<float> data;
 #define ADD(x, y, z) STMT(data.push_back(x); data.push_back(y); data.push_back(z))
 			ADD(Verts.left, Verts.bottom, Z + cit->m_DeltaZ);
 			ADD(Verts.right, Verts.bottom, Z + cit->m_DeltaZ);
 			ADD(Verts.right, Verts.top, Z + cit->m_DeltaZ);
 
 			ADD(Verts.right, Verts.top, Z + cit->m_DeltaZ);
 			ADD(Verts.left, Verts.top, Z + cit->m_DeltaZ);
 			ADD(Verts.left, Verts.bottom, Z + cit->m_DeltaZ);
 
 			shader->VertexPointer(3, GL_FLOAT, 3*sizeof(float), &data[0]);
 			glDrawArrays(GL_TRIANGLES, 0, 6);
 
 			if (cit->m_BorderColor != CColor())
 			{
 				shader->Uniform(str_color, cit->m_BorderColor);
 
 				data.clear();
 				ADD(Verts.left + 0.5f, Verts.top + 0.5f, Z + cit->m_DeltaZ);
 				ADD(Verts.right - 0.5f, Verts.top + 0.5f, Z + cit->m_DeltaZ);
 				ADD(Verts.right - 0.5f, Verts.bottom - 0.5f, Z + cit->m_DeltaZ);
 				ADD(Verts.left + 0.5f, Verts.bottom - 0.5f, Z + cit->m_DeltaZ);
 
 				shader->VertexPointer(3, GL_FLOAT, 3*sizeof(float), &data[0]);
 				glDrawArrays(GL_LINE_LOOP, 0, 4);
 			}
 #undef ADD
 		}
 		
 		cit->m_Shader->EndPass();
 
 		glDisable(GL_BLEND);
 	}
 
 #if CONFIG2_GLES
 #warning TODO: implement GUI LOD bias for GLES
 #else
 	glTexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, 0.f);
 #endif
 }
Index: ps/trunk/source/gui/GUItext.cpp
===================================================================
--- ps/trunk/source/gui/GUItext.cpp	(revision 14952)
+++ ps/trunk/source/gui/GUItext.cpp	(revision 14953)
@@ -1,587 +1,617 @@
 /* Copyright (C) 2014 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
 GUI text
 */
 
 #include "precompiled.h"
 
 #include "GUI.h"
 #include "graphics/FontMetrics.h"
 #include "ps/CLogger.h"
 #include "ps/Parser.h"
 #include <algorithm>
 
 
 static const wchar_t TagStart = '[';
 static const wchar_t TagEnd   = ']';
 // List of word demlimitor bounds
 // The list contains ranges of word delimitors. The odd indexed chars are the start
 // of a range, the even are the end of a range. The list must be sorted in INCREASING ORDER
 static const int NUM_WORD_DELIMITORS = 4*2;
 static const u16 WordDelimitors[NUM_WORD_DELIMITORS] = {
 	' '   , ' ',    // spaces
 	'-'   , '-',    // hyphens
 	0x3000, 0x3002, // ideographic symbols (maybe this range should be wider)
 	0x4E00, 0x9FFF  // characters in the Chinese unicode block
 // TODO add unicode blocks of other languages that don't use spaces
 };
 
 void CGUIString::SFeedback::Reset()
 {
 	m_Images[Left].clear();
 	m_Images[Right].clear();
 	m_TextCalls.clear();
 	m_SpriteCalls.clear();
 	m_Size = CSize();
 	m_NewLine=false;
 }
 
+// TODO this method should be removed at one point
+// It is a solution for CParser not recognising backslash-escaped quoted
+CStrW UnescapeString(CStrW originalString)
+{
+	// no reason to mess with more memory if there is nothing to unescape
+	if (originalString.Find('&') == -1)
+		return originalString;
+	// clone the string
+	CStrW newString = CStrW();
+	for (ulong i; i < originalString.length(); ++i)
+	{
+		if (originalString[i] == '&' && originalString[i+1] == '#')
+		{
+			i += 2;
+			wchar_t c = 0;
+			while (originalString[i] >= '0' && originalString[i] <= '9')
+			{
+				c = c*10 + (originalString[i] - '0');
+				++i;
+			}
+			ENSURE(originalString[i] == ';');
+			if (c >= ' ')
+				newString += c;
+		}
+		else
+			newString += originalString[i];
+	}
+	return newString;
+}
+
 void CGUIString::GenerateTextCall(const CGUI *pGUI,
 								  SFeedback &Feedback,
 								  CStrIntern DefaultFont,
 								  const int &from, const int &to,
 								  const bool FirstLine,
 								  const IGUIObject *pObject) const
 {
 	// Reset width and height, because they will be determined with incrementation
 	//  or comparisons.
 	Feedback.Reset();
 
 	// Check out which text chunk this is within.
 	//bool match_found = false;
 	std::vector<TextChunk>::const_iterator itTextChunk;
 	for (itTextChunk=m_TextChunks.begin(); itTextChunk!=m_TextChunks.end(); ++itTextChunk)
 	{
 		// Get the area that is overlapped by both the TextChunk and
 		//  by the from/to inputted.
 		int _from, _to;
 		_from = std::max(from, itTextChunk->m_From);
 		_to = std::min(to, itTextChunk->m_To);
 
 		// If from is larger than to, than they are not overlapping
 		if (_to == _from && itTextChunk->m_From == itTextChunk->m_To)
 		{
 			// These should never be able to have more than one tag.
 			ENSURE(itTextChunk->m_Tags.size()==1);
 
 			// Now do second check
 			//  because icons and images are placed on exactly one position
 			//  in the words-list, it can be counted twice if placed on an
 			//  edge. But there is always only one logical preference that
 			//  we want. This check filters the unwanted.
 
 			// it's in the end of one word, and the icon
 			//  should really belong to the beginning of the next one
 			if (_to == to && to >= 1)
 			{
 				if (GetRawString()[to-1] == ' ' ||
 					GetRawString()[to-1] == '-' ||
 					GetRawString()[to-1] == '\n')
 					continue;
 			}
 			// This std::string is just a break
 			if (_from == from && from >= 1)
 			{
 				if (GetRawString()[from] == '\n' &&
 					GetRawString()[from-1] != '\n' &&
 					GetRawString()[from-1] != ' ' &&
 					GetRawString()[from-1] != '-')
 					continue;
 			}
 
 			// Single tags
 			if (itTextChunk->m_Tags[0].m_TagType == CGUIString::TextChunk::Tag::TAG_IMGLEFT)
 			{
 				// Only add the image if the icon exists.
 				if (pGUI->IconExists(itTextChunk->m_Tags[0].m_TagValue))
 				{
 					Feedback.m_Images[SFeedback::Left].push_back(itTextChunk->m_Tags[0].m_TagValue);
 				}
 				else if (pObject)
 				{
 					LOGERROR(L"Trying to use an [imgleft]-tag with an undefined icon (\"%hs\").", itTextChunk->m_Tags[0].m_TagValue.c_str());
 				}
 			}
 			else
 			if (itTextChunk->m_Tags[0].m_TagType == CGUIString::TextChunk::Tag::TAG_IMGRIGHT)
 			{
 				// Only add the image if the icon exists.
 				if (pGUI->IconExists(itTextChunk->m_Tags[0].m_TagValue))
 				{
 					Feedback.m_Images[SFeedback::Right].push_back(itTextChunk->m_Tags[0].m_TagValue);
 				}
 				else if (pObject)
 				{
 					LOGERROR(L"Trying to use an [imgright]-tag with an undefined icon (\"%hs\").", itTextChunk->m_Tags[0].m_TagValue.c_str());
 				}
 			}
 			else
 			if (itTextChunk->m_Tags[0].m_TagType == CGUIString::TextChunk::Tag::TAG_ICON)
 			{
 				// Only add the image if the icon exists.
 				if (pGUI->IconExists(itTextChunk->m_Tags[0].m_TagValue))
 				{
 					// We'll need to setup a text-call that will point
 					//  to the icon, this is to be able to iterate
 					//  through the text-calls without having to
 					//  complex the structure virtually for nothing more.
 					SGUIText::STextCall TextCall;
 
 					// Also add it to the sprites being rendered.
 					SGUIText::SSpriteCall SpriteCall;
 
 					// Get Icon from icon database in pGUI
 					SGUIIcon icon = pGUI->GetIcon(itTextChunk->m_Tags[0].m_TagValue);
 
 					CSize size = icon.m_Size;
 
 					// append width, and make maximum height the height.
 					Feedback.m_Size.cx += size.cx;
 					Feedback.m_Size.cy = std::max(Feedback.m_Size.cy, size.cy);
 
 					// These are also needed later
 					TextCall.m_Size = size;
 					SpriteCall.m_Area = size;
 
 					// Handle additional attributes
 					std::vector<TextChunk::Tag::TagAttribute>::const_iterator att_it;
 					for(att_it = itTextChunk->m_Tags[0].m_TagAttributes.begin(); att_it != itTextChunk->m_Tags[0].m_TagAttributes.end(); ++att_it)
 					{
 						TextChunk::Tag::TagAttribute tagAttrib = (TextChunk::Tag::TagAttribute)(*att_it);
 
 						if (tagAttrib.attrib == "displace" && !tagAttrib.value.empty())
 						{	//Displace the sprite
 							CSize displacement;
 							// Parse the value
 							if (!GUI<CSize>::ParseString(CStr(tagAttrib.value).FromUTF8(), displacement))
 								LOGERROR(L"Error parsing 'displace' value for tag [ICON]");
 							else
 								SpriteCall.m_Area += displacement;
 
 						}
 						else if(tagAttrib.attrib == "tooltip")
 						{
 							SpriteCall.m_Tooltip = CStr(tagAttrib.value).FromUTF8();
 						}
 						else if(tagAttrib.attrib == "tooltip_style")
 						{
 							SpriteCall.m_TooltipStyle = CStr(tagAttrib.value).FromUTF8();
 						}
 					}
 
 					SpriteCall.m_Sprite = icon.m_SpriteName;
 					SpriteCall.m_CellID = icon.m_CellID;
 
 					// Add sprite call
 					Feedback.m_SpriteCalls.push_back(SpriteCall);
 
 					// Finalize text call
 					TextCall.m_pSpriteCall = &Feedback.m_SpriteCalls.back();
 
 					// Add text call
 					Feedback.m_TextCalls.push_back(TextCall);
 				}
 				else if (pObject)
 				{
 					LOGERROR(L"Trying to use an [icon]-tag with an undefined icon (\"%hs\").", itTextChunk->m_Tags[0].m_TagValue.c_str());
 				}
 			}
 		}
 		else
 		if (_to > _from && !Feedback.m_NewLine)
 		{
 			SGUIText::STextCall TextCall;
 
 			// Set defaults
 			TextCall.m_Font = DefaultFont;
 			TextCall.m_UseCustomColor = false;
 
 			// Extract substd::string from RawString.
-			TextCall.m_String = GetRawString().substr(_from, _to-_from);
+			TextCall.m_String = UnescapeString(GetRawString().substr(_from, _to-_from));
 
 			// Go through tags and apply changes.
 			std::vector<CGUIString::TextChunk::Tag>::const_iterator it2;
 			for (it2 = itTextChunk->m_Tags.begin(); it2 != itTextChunk->m_Tags.end(); ++it2)
 			{
 				if (it2->m_TagType == CGUIString::TextChunk::Tag::TAG_COLOR)
 				{
 					// Set custom color
 					TextCall.m_UseCustomColor = true;
 
 					// Try parsing the color std::string
 					if (!GUI<CColor>::ParseString(CStr(it2->m_TagValue).FromUTF8(), TextCall.m_Color))
 					{
 						if (pObject)
 							LOGERROR(L"Error parsing the value of a [color]-tag in GUI text when reading object \"%hs\".", pObject->GetPresentableName().c_str());
 					}
 				}
 				else
 				if (it2->m_TagType == CGUIString::TextChunk::Tag::TAG_FONT)
 				{
 					// TODO Gee: (2004-08-15) Check if Font exists?
 					TextCall.m_Font = CStrIntern(it2->m_TagValue);
 				}
 			}
 
 			// Calculate the size of the font
 			CSize size;
 			int cx, cy;
 			CFontMetrics font (TextCall.m_Font);
 			font.CalculateStringSize(TextCall.m_String.c_str(), cx, cy);
 			// For anything other than the first line, the line spacing
 			// needs to be considered rather than just the height of the text
 			if (! FirstLine)
 				cy = font.GetLineSpacing();
 
 			size.cx = (float)cx;
 			size.cy = (float)cy;
 
 			// Append width, and make maximum height the height.
 			Feedback.m_Size.cx += size.cx;
 			Feedback.m_Size.cy = std::max(Feedback.m_Size.cy, size.cy);
 
 			// These are also needed later
 			TextCall.m_Size = size;
 
 			if (! TextCall.m_String.empty())
 			{
 				if (TextCall.m_String[0] == '\n')
 				{
 					Feedback.m_NewLine = true;
 				}
 			}
 
 			// Add text-chunk
 			Feedback.m_TextCalls.push_back(TextCall);
 		}
 	}
 }
 
 bool CGUIString::TextChunk::Tag::SetTagType(const CStr& tagtype)
 {
 	CStr _tagtype = tagtype.UpperCase();
 
 	if (_tagtype == CStr("COLOR"))
 	{
 		m_TagType = TAG_COLOR;
 		return true;
 	}
 	else
 	if (_tagtype == CStr("FONT"))
 	{
 		m_TagType = TAG_FONT;
 		return true;
 	}
 	else
 	if (_tagtype == CStr("ICON"))
 	{
 		m_TagType = TAG_ICON;
 		return true;
 	}
 	else
 	if (_tagtype == CStr("IMGLEFT"))
 	{
 		m_TagType = TAG_IMGLEFT;
 		return true;
 	}
 	else
 	if (_tagtype == CStr("IMGRIGHT"))
 	{
 		m_TagType = TAG_IMGRIGHT;
 		return true;
 	}
 
 	return false;
 }
 
 void CGUIString::SetValue(const CStrW& str)
 {
 	m_OriginalString = str;
 
 	// clear
 	m_TextChunks.clear();
 	m_Words.clear();
 	m_RawString = CStrW();
 
 	// Setup parser
 	// TODO Gee: (2004-08-16) Create and store this parser object somewhere to save loading time.
 	// TODO PT: Extended CParserCache so that the above is possible (since it currently only
 	// likes one-task parsers)
 	CParser Parser;
 	// I've added the option of an additional parameter. Only used for icons when writing this.
 	Parser.InputTaskType("start", "$ident[_=_$value_[$ident_=_$value_]]");
 	Parser.InputTaskType("end", "/$ident");
 
 	long position = 0;
 	long from=0;		// the position in the raw std::string where the last tag ended
 	long from_nonraw=0;	// like from only in position of the REAL std::string, with tags.
 	long curpos = 0;
 
 	// Current Text Chunk
 	CGUIString::TextChunk CurrentTextChunk;
 
 	for (;;position = curpos+1)
 	{
 		// Find next TagStart character
 		curpos = str.Find(position, TagStart);
 
 		if (curpos == -1)
 		{
 			m_RawString += str.substr(position);
 
 			if (from != (long)m_RawString.length())
 			{
 				CurrentTextChunk.m_From = from;
 				CurrentTextChunk.m_To = (int)m_RawString.length();
 				m_TextChunks.push_back(CurrentTextChunk);
 			}
 
 			break;
 		}
 		else
 		{
 			// First check if there is another TagStart before a TagEnd,
 			//  in that case it's just a regular TagStart and we can continue.
 			long pos_left = str.Find(curpos+1, TagStart);
 			long pos_right = str.Find(curpos+1, TagEnd);
 
 			if (pos_right == -1)
 			{
 				m_RawString += str.substr(position, curpos-position+1);
 				continue;
 			}
 			else
 			if (pos_left != -1 && pos_left < pos_right)
 			{
 				m_RawString += str.substr(position, pos_left-position);
 				continue;
 			}
 			else
 			{
 				m_RawString += str.substr(position, curpos-position);
 
 				// Okay we've found a TagStart and TagEnd, positioned
 				//  at pos and pos_right. Now let's extract the
 				//  interior and try parsing.
 				CStrW tagstr (str.substr(curpos+1, pos_right-curpos-1));
 
 				CParserLine Line;
 				Line.ParseString(Parser, tagstr.ToUTF8());
 
 				// Set to true if the tag is just text.
 				bool justtext = false;
 
 				if (Line.m_ParseOK)
 				{
 					if (Line.m_TaskTypeName == "start")
 					{
  						// The tag
 						TextChunk::Tag tag;
 						std::string Str_TagType;
 
 						Line.GetArgString(0, Str_TagType);
 
 						if (!tag.SetTagType(Str_TagType))
 						{
 							justtext = true;
 						}
 						else
 						{
 							// Check for possible value-std::strings
 							if (Line.GetArgCount() >= 2)
 								Line.GetArgString(1, tag.m_TagValue);
 
 							//Handle arbitrary number of additional parameters
 							size_t argn;
 							for(argn = 2; argn < Line.GetArgCount(); argn += 2)
 							{
 								TextChunk::Tag::TagAttribute a;
 
 								Line.GetArgString(argn, a.attrib);
 								Line.GetArgString(argn+1, a.value);
 
 								tag.m_TagAttributes.push_back(a);
 							}
 
 							// Finalize last
 							if (curpos != from_nonraw)
 							{
 								CurrentTextChunk.m_From = from;
 								CurrentTextChunk.m_To = from + curpos - from_nonraw;
 								m_TextChunks.push_back(CurrentTextChunk);
 								from = CurrentTextChunk.m_To;
 							}
 							from_nonraw = pos_right+1;
 
 							// Some tags does not have a closure, and should be
 							//  stored without text. Like a <tag /> in XML.
 							if (tag.m_TagType == TextChunk::Tag::TAG_IMGLEFT ||
 								tag.m_TagType == TextChunk::Tag::TAG_IMGRIGHT ||
 								tag.m_TagType == TextChunk::Tag::TAG_ICON)
 							{
 								// We need to use a fresh text chunk
 								//  because 'tag' should be the *only* tag.
 								TextChunk FreshTextChunk;
 
 								// They does not work with the text system.
 								FreshTextChunk.m_From = from + pos_right+1 - from_nonraw;
 								FreshTextChunk.m_To = from + pos_right+1 - from_nonraw;
 
 								FreshTextChunk.m_Tags.push_back(tag);
 
 								m_TextChunks.push_back(FreshTextChunk);
 							}
 							else
 							{
 								// Add that tag, but first, erase previous occurences of the
 								//  same tag.
 								std::vector<TextChunk::Tag>::iterator it;
 								for (it = CurrentTextChunk.m_Tags.begin(); it != CurrentTextChunk.m_Tags.end(); ++it)
 								{
 									if (it->m_TagType == tag.m_TagType)
 									{
 										CurrentTextChunk.m_Tags.erase(it);
 										break;
 									}
 								}
 
 								// Add!
 								CurrentTextChunk.m_Tags.push_back(tag);
 							}
 						}
 					}
 					else
 					if (Line.m_TaskTypeName == "end")
 					{
 						// The tag
 						TextChunk::Tag tag;
 						std::string Str_TagType;
 
 						Line.GetArgString(0, Str_TagType);
 
 						if (!tag.SetTagType(Str_TagType))
 						{
 							justtext = true;
 						}
 						else
 						{
 							// Finalize the previous chunk
 							if (curpos != from_nonraw)
 							{
 								CurrentTextChunk.m_From = from;
 								CurrentTextChunk.m_To = from + curpos - from_nonraw;
 								m_TextChunks.push_back(CurrentTextChunk);
 								from = CurrentTextChunk.m_To;
 							}
 							from_nonraw = pos_right+1;
 
 							// Search for the tag, if it's not added, then
 							//  pass it as plain text.
 							std::vector<TextChunk::Tag>::iterator it;
 							for (it = CurrentTextChunk.m_Tags.begin(); it != CurrentTextChunk.m_Tags.end(); ++it)
 							{
 								if (it->m_TagType == tag.m_TagType)
 								{
 									CurrentTextChunk.m_Tags.erase(it);
 									break;
 								}
 							}
 						}
 					}
 				}
 				else justtext = true;
 
 				if (justtext)
 				{
 					// What was within the tags could not be interpreted
 					//  so we'll assume it's just text.
 					m_RawString += str.substr(curpos, pos_right-curpos+1);
 				}
 
 				curpos = pos_right;
 
 				continue;
 			}
 		}
 	}
 
 	// Add a delimiter at start and at end, it helps when
 	//  processing later, because we don't have make exceptions for
 	//  those cases.
 	m_Words.push_back(0);
 
 	// Add word boundaries in increasing order
 	for (u32 i = 0; i < m_RawString.length(); ++i)
 	{
 		wchar_t c = m_RawString[i];
 		if (c == '\n')
 		{
 			m_Words.push_back((int)i);
 			m_Words.push_back((int)i+1);
 			continue;
 		}
 		for (int n = 0; n < NUM_WORD_DELIMITORS; n += 2)
 		{
 			if (c <= WordDelimitors[n+1])
 			{
 				if (c >= WordDelimitors[n])
 					m_Words.push_back((int)i+1);
 				// assume the WordDelimitors list is stored in increasing order
 				break;
 			}
 		}
 	}
 
 	m_Words.push_back((int)m_RawString.length());
 
 	// Remove duplicates (only if larger than 2)
 	if (m_Words.size() > 2)
 	{
 		std::vector<int>::iterator it;
 		int last_word = -1;
 		for (it = m_Words.begin(); it != m_Words.end(); )
 		{
 			if (last_word == *it)
 			{
 				it = m_Words.erase(it);
 			}
 			else
 			{
 				last_word = *it;
 				++it;
 			}
 		}
 	}
 
 #if 0
 	for (int i=0; i<(int)m_Words.size(); ++i)
 	{
 		LOGMESSAGE(L"m_Words[%d] = %d", i, m_Words[i]);
 	}
 
 	for (int i=0; i<(int)m_TextChunks.size(); ++i)
 	{
 		LOGMESSAGE(L"m_TextChunk[%d] = [%d,%d]", i, m_TextChunks[i].m_From, m_TextChunks[i].m_To);
 		for (int j=0; j<(int)m_TextChunks[i].m_Tags.size(); ++j)
 		{
 			LOGMESSAGE(L"--Tag: %d \"%hs\"", (int)m_TextChunks[i].m_Tags[j].m_TagType, m_TextChunks[i].m_Tags[j].m_TagValue.c_str());
 		}
 	}
 #endif
 }
Index: ps/trunk/source/gui/scripting/ScriptFunctions.cpp
===================================================================
--- ps/trunk/source/gui/scripting/ScriptFunctions.cpp	(revision 14952)
+++ ps/trunk/source/gui/scripting/ScriptFunctions.cpp	(revision 14953)
@@ -1,936 +1,959 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2014 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "scriptinterface/ScriptInterface.h"
 
 #include "graphics/Camera.h"
 #include "graphics/GameView.h"
 #include "graphics/MapReader.h"
 #include "gui/GUIManager.h"
 #include "gui/GUI.h"
 #include "gui/IGUIObject.h"
 #include "gui/scripting/JSInterface_GUITypes.h"
 #include "graphics/scripting/JSInterface_GameView.h"
-#include "lib/timer.h"
-#include "lib/utf8.h"
+#include "i18n/L10n.h"
+#include "i18n/scripting/JSInterface_L10n.h"
 #include "lib/svn_revision.h"
 #include "lib/sysdep/sysdep.h"
+#include "lib/timer.h"
+#include "lib/utf8.h"
 #include "lobby/scripting/JSInterface_Lobby.h"
 #include "maths/FixedVector3D.h"
 #include "network/NetClient.h"
 #include "network/NetServer.h"
 #include "network/NetTurnManager.h"
 #include "ps/CLogger.h"
 #include "ps/CConsole.h"
 #include "ps/Errors.h"
 #include "ps/Game.h"
 #include "ps/Globals.h"	// g_frequencyFilter
 #include "ps/GUID.h"
 #include "ps/World.h"
 #include "ps/Hotkey.h"
 #include "ps/Overlay.h"
 #include "ps/ProfileViewer.h"
 #include "ps/Pyrogenesis.h"
 #include "ps/SavedGame.h"
 #include "ps/scripting/JSInterface_ConfigDB.h"
 #include "ps/scripting/JSInterface_Console.h"
 #include "ps/scripting/JSInterface_VFS.h"
 #include "ps/UserReport.h"
 #include "ps/GameSetup/Atlas.h"
 #include "ps/GameSetup/Config.h"
-#include "ps/ConfigDB.h"
 #include "renderer/scripting/JSInterface_Renderer.h"
 #include "tools/atlas/GameInterface/GameLoop.h"
 
 #include "simulation2/Simulation2.h"
 #include "simulation2/components/ICmpAIManager.h"
 #include "simulation2/components/ICmpCommandQueue.h"
 #include "simulation2/components/ICmpGuiInterface.h"
 #include "simulation2/components/ICmpRangeManager.h"
 #include "simulation2/components/ICmpTemplateManager.h"
 #include "simulation2/components/ICmpSelectable.h"
 #include "simulation2/helpers/Selection.h"
 #include "soundmanager/SoundManager.h"
 #include "soundmanager/scripting/JSInterface_Sound.h"
 
 /*
  * This file defines a set of functions that are available to GUI scripts, to allow
  * interaction with the rest of the engine.
  * Functions are exposed to scripts within the global object 'Engine', so
  * scripts should call "Engine.FunctionName(...)" etc.
  */
 
 extern void restart_mainloop_in_atlas(); // from main.cpp
 extern void EndGame();
 extern void kill_mainloop();
 
 namespace {
 
 // Note that the initData argument may only contain clonable data.
 // Functions aren't supported for example!
 // TODO: Use LOGERROR to print a friendly error message when the requirements aren't met instead of failing with debug_warn when cloning.
 void PushGuiPage(ScriptInterface::CxPrivate* pCxPrivate, std::wstring name, CScriptVal initData)
 {
 	g_GUI->PushPage(name, pCxPrivate->pScriptInterface->WriteStructuredClone(initData.get()));
 }
 
 void SwitchGuiPage(ScriptInterface::CxPrivate* pCxPrivate, std::wstring name, CScriptVal initData)
 {
 	g_GUI->SwitchPage(name, pCxPrivate->pScriptInterface, initData);
 }
 
 void PopGuiPage(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	g_GUI->PopPage();
 }
 
 // Note that the args argument may only contain clonable data.
 // Functions aren't supported for example!
 // TODO: Use LOGERROR to print a friendly error message when the requirements aren't met instead of failing with debug_warn when cloning.
 void PopGuiPageCB(ScriptInterface::CxPrivate* pCxPrivate, CScriptVal args)
 {
 	g_GUI->PopPageCB(pCxPrivate->pScriptInterface->WriteStructuredClone(args.get()));
 }
 
 CScriptVal GuiInterfaceCall(ScriptInterface::CxPrivate* pCxPrivate, std::wstring name, CScriptVal data)
 {
 	if (!g_Game)
 		return JSVAL_VOID;
 	CSimulation2* sim = g_Game->GetSimulation2();
 	ENSURE(sim);
 
 	CmpPtr<ICmpGuiInterface> cmpGuiInterface(*sim, SYSTEM_ENTITY);
 	if (!cmpGuiInterface)
 		return JSVAL_VOID;
 
 	int player = -1;
 	if (g_Game)
 		player = g_Game->GetPlayerID();
 
 	CScriptValRooted arg (sim->GetScriptInterface().GetContext(), sim->GetScriptInterface().CloneValueFromOtherContext(*(pCxPrivate->pScriptInterface), data.get()));
 	CScriptVal ret (cmpGuiInterface->ScriptCall(player, name, arg.get()));
 	return pCxPrivate->pScriptInterface->CloneValueFromOtherContext(sim->GetScriptInterface(), ret.get());
 }
 
 void PostNetworkCommand(ScriptInterface::CxPrivate* pCxPrivate, CScriptVal cmd)
 {
 	if (!g_Game)
 		return;
 	CSimulation2* sim = g_Game->GetSimulation2();
 	ENSURE(sim);
 
 	CmpPtr<ICmpCommandQueue> cmpCommandQueue(*sim, SYSTEM_ENTITY);
 	if (!cmpCommandQueue)
 		return;
 
 	jsval cmd2 = sim->GetScriptInterface().CloneValueFromOtherContext(*(pCxPrivate->pScriptInterface), cmd.get());
 
 	cmpCommandQueue->PostNetworkCommand(cmd2);
 }
 
 std::vector<entity_id_t> PickEntitiesAtPoint(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int x, int y, int range)
 {
 	return EntitySelection::PickEntitiesAtPoint(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), x, y, g_Game->GetPlayerID(), false, range);
 }
 
 std::vector<entity_id_t> PickFriendlyEntitiesInRect(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int x0, int y0, int x1, int y1, int player)
 {
 	return EntitySelection::PickEntitiesInRect(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), x0, y0, x1, y1, player, false);
 }
 
 std::vector<entity_id_t> PickFriendlyEntitiesOnScreen(ScriptInterface::CxPrivate* pCxPrivate, int player)
 {
 	return PickFriendlyEntitiesInRect(pCxPrivate, 0, 0, g_xres, g_yres, player);
 }
 
 std::vector<entity_id_t> PickSimilarFriendlyEntities(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string templateName, bool includeOffScreen, bool matchRank, bool allowFoundations)
 {
 	return EntitySelection::PickSimilarEntities(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), templateName, g_Game->GetPlayerID(), includeOffScreen, matchRank, false, allowFoundations);
 }
 
 CFixedVector3D GetTerrainAtScreenPoint(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int x, int y)
 {
 	CVector3D pos = g_Game->GetView()->GetCamera()->GetWorldCoordinates(x, y, true);
 	return CFixedVector3D(fixed::FromFloat(pos.X), fixed::FromFloat(pos.Y), fixed::FromFloat(pos.Z));
 }
 
 std::wstring SetCursor(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring name)
 {
 	std::wstring old = g_CursorName;
 	g_CursorName = name;
 	return old;
 }
 
 int GetPlayerID(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	if (g_Game)
 		return g_Game->GetPlayerID();
 	return -1;
 }
 
 void SetPlayerID(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int id)
 {
 	if (g_Game)
 		g_Game->SetPlayerID(id);
 }
 
 CScriptValRooted GetEngineInfo(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	return SavedGames::GetEngineInfo(*(pCxPrivate->pScriptInterface));
 }
 
 void StartNetworkGame(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	ENSURE(g_NetServer);
 	g_NetServer->StartGame();
 }
 
 void StartGame(ScriptInterface::CxPrivate* pCxPrivate, CScriptVal attribs, int playerID)
 {
 	ENSURE(!g_NetServer);
 	ENSURE(!g_NetClient);
 
 	ENSURE(!g_Game);
 	g_Game = new CGame();
 
 	// Convert from GUI script context to sim script context
 	CSimulation2* sim = g_Game->GetSimulation2();
 	CScriptValRooted gameAttribs (sim->GetScriptInterface().GetContext(),
 			sim->GetScriptInterface().CloneValueFromOtherContext(*(pCxPrivate->pScriptInterface), attribs.get()));
 
 	g_Game->SetPlayerID(playerID);
 	g_Game->StartGame(gameAttribs, "");
 }
 
 CScriptVal StartSavedGame(ScriptInterface::CxPrivate* pCxPrivate, std::wstring name)
 {
 	ENSURE(!g_NetServer);
 	ENSURE(!g_NetClient);
 
 	ENSURE(!g_Game);
 
 	// Load the saved game data from disk
 	CScriptValRooted metadata;
 	std::string savedState;
 	Status err = SavedGames::Load(name, *(pCxPrivate->pScriptInterface), metadata, savedState);
 	if (err < 0)
 		return CScriptVal();
 
 	g_Game = new CGame();
 
 	// Convert from GUI script context to sim script context
 	CSimulation2* sim = g_Game->GetSimulation2();
 	CScriptValRooted gameMetadata (sim->GetScriptInterface().GetContext(),
 		sim->GetScriptInterface().CloneValueFromOtherContext(*(pCxPrivate->pScriptInterface), metadata.get()));
 
 	CScriptValRooted gameInitAttributes;
 	sim->GetScriptInterface().GetProperty(gameMetadata.get(), "initAttributes", gameInitAttributes);
 
 	int playerID;
 	sim->GetScriptInterface().GetProperty(gameMetadata.get(), "player", playerID);
 
 	// Start the game
 	g_Game->SetPlayerID(playerID);
 	g_Game->StartGame(gameInitAttributes, savedState);
 
 	return metadata.get();
 }
 
 void SaveGame(ScriptInterface::CxPrivate* pCxPrivate, std::wstring filename, std::wstring description, CScriptVal GUIMetadata)
 {
 	shared_ptr<ScriptInterface::StructuredClone> GUIMetadataClone = pCxPrivate->pScriptInterface->WriteStructuredClone(GUIMetadata.get());
 	if (SavedGames::Save(filename, description, *g_Game->GetSimulation2(), GUIMetadataClone, g_Game->GetPlayerID()) < 0)
 		LOGERROR(L"Failed to save game");
 }
 
 void SaveGamePrefix(ScriptInterface::CxPrivate* pCxPrivate, std::wstring prefix, std::wstring description, CScriptVal GUIMetadata)
 {
 	shared_ptr<ScriptInterface::StructuredClone> GUIMetadataClone = pCxPrivate->pScriptInterface->WriteStructuredClone(GUIMetadata.get());
 	if (SavedGames::SavePrefix(prefix, description, *g_Game->GetSimulation2(), GUIMetadataClone, g_Game->GetPlayerID()) < 0)
 		LOGERROR(L"Failed to save game");
 }
 
 void SetNetworkGameAttributes(ScriptInterface::CxPrivate* pCxPrivate, CScriptVal attribs)
 {
 	ENSURE(g_NetServer);
 
 	g_NetServer->UpdateGameAttributes(attribs, *(pCxPrivate->pScriptInterface));
 }
 
 void StartNetworkHost(ScriptInterface::CxPrivate* pCxPrivate, std::wstring playerName)
 {
 	ENSURE(!g_NetClient);
 	ENSURE(!g_NetServer);
 	ENSURE(!g_Game);
 
 	g_NetServer = new CNetServer();
 	if (!g_NetServer->SetupConnection())
 	{
 		pCxPrivate->pScriptInterface->ReportError("Failed to start server");
 		SAFE_DELETE(g_NetServer);
 		return;
 	}
 
 	g_Game = new CGame();
 	g_NetClient = new CNetClient(g_Game);
 	g_NetClient->SetUserName(playerName);
 
 	if (!g_NetClient->SetupConnection("127.0.0.1"))
 	{
 		pCxPrivate->pScriptInterface->ReportError("Failed to connect to server");
 		SAFE_DELETE(g_NetClient);
 		SAFE_DELETE(g_Game);
 	}
 }
 
 void StartNetworkJoin(ScriptInterface::CxPrivate* pCxPrivate, std::wstring playerName, std::string serverAddress)
 {
 	ENSURE(!g_NetClient);
 	ENSURE(!g_NetServer);
 	ENSURE(!g_Game);
 
 	g_Game = new CGame();
 	g_NetClient = new CNetClient(g_Game);
 	g_NetClient->SetUserName(playerName);
 	if (!g_NetClient->SetupConnection(serverAddress))
 	{
 		pCxPrivate->pScriptInterface->ReportError("Failed to connect to server");
 		SAFE_DELETE(g_NetClient);
 		SAFE_DELETE(g_Game);
 	}
 }
 
 void DisconnectNetworkGame(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	// TODO: we ought to do async reliable disconnections
 
 	SAFE_DELETE(g_NetServer);
 	SAFE_DELETE(g_NetClient);
 	SAFE_DELETE(g_Game);
 }
 
 CScriptVal PollNetworkClient(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	if (!g_NetClient)
 		return CScriptVal();
 
 	CScriptValRooted poll = g_NetClient->GuiPoll();
 
 	// Convert from net client context to GUI script context
 	return pCxPrivate->pScriptInterface->CloneValueFromOtherContext(g_NetClient->GetScriptInterface(), poll.get());
 }
 
 void AssignNetworkPlayer(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int playerID, std::string guid)
 {
 	ENSURE(g_NetServer);
 
 	g_NetServer->AssignPlayer(playerID, guid);
 }
 
 void SendNetworkChat(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring message)
 {
 	ENSURE(g_NetClient);
 
 	g_NetClient->SendChatMessage(message);
 }
 
 std::vector<CScriptValRooted> GetAIs(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	return ICmpAIManager::GetAIs(*(pCxPrivate->pScriptInterface));
 }
 
 std::vector<CScriptValRooted> GetSavedGames(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	return SavedGames::GetSavedGames(*(pCxPrivate->pScriptInterface));
 }
 
 bool DeleteSavedGame(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring name)
 {
 	return SavedGames::DeleteSavedGame(name);
 }
 
 void OpenURL(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string url)
 {
 	sys_open_url(url);
 }
 
 std::wstring GetMatchID(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	return ps_generate_guid().FromUTF8();
 }
 
 void RestartInAtlas(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	restart_mainloop_in_atlas();
 }
 
 bool AtlasIsAvailable(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	return ATLAS_IsAvailable();
 }
 
 bool IsAtlasRunning(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	return (g_AtlasGameLoop && g_AtlasGameLoop->running);
 }
 
 CScriptVal LoadMapSettings(ScriptInterface::CxPrivate* pCxPrivate, VfsPath pathname)
 {
 	CMapSummaryReader reader;
 
 	if (reader.LoadMap(pathname) != PSRETURN_OK)
 		return CScriptVal();
 
 	return reader.GetMapSettings(*(pCxPrivate->pScriptInterface)).get();
 }
 
 CScriptVal GetMapSettings(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	if (!g_Game)
 		return CScriptVal();
 
 	return pCxPrivate->pScriptInterface->CloneValueFromOtherContext(
 		g_Game->GetSimulation2()->GetScriptInterface(),
 		g_Game->GetSimulation2()->GetMapSettings().get());
 }
 
 /**
  * Get the current X coordinate of the camera.
  */
 float CameraGetX(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	if (g_Game && g_Game->GetView())
 		return g_Game->GetView()->GetCameraX();
 	return -1;
 }
 
 /**
  * Get the current Z coordinate of the camera.
  */
 float CameraGetZ(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	if (g_Game && g_Game->GetView())
 		return g_Game->GetView()->GetCameraZ();
 	return -1;
 }
 
 /**
  * Start / stop camera following mode
  * @param entityid unit id to follow. If zero, stop following mode
  */
 void CameraFollow(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), entity_id_t entityid)
 {
 	if (g_Game && g_Game->GetView())
 		g_Game->GetView()->CameraFollow(entityid, false);
 }
 
 /**
  * Start / stop first-person camera following mode
  * @param entityid unit id to follow. If zero, stop following mode
  */
 void CameraFollowFPS(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), entity_id_t entityid)
 {
 	if (g_Game && g_Game->GetView())
 		g_Game->GetView()->CameraFollow(entityid, true);
 }
 
 /**
  * Set the data (position, orientation and zoom) of the camera
  */
 void SetCameraData(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), entity_pos_t x, entity_pos_t y, entity_pos_t z, entity_pos_t rotx, entity_pos_t roty, entity_pos_t zoom)
 {
 	// called from JS; must not fail
 	if(!(g_Game && g_Game->GetWorld() && g_Game->GetView() && g_Game->GetWorld()->GetTerrain()))
 		return;
 
 	CVector3D Pos = CVector3D(x.ToFloat(), y.ToFloat(), z.ToFloat());
 	float RotX = rotx.ToFloat();
 	float RotY = roty.ToFloat();
 	float Zoom = zoom.ToFloat();
 
 	g_Game->GetView()->SetCamera(Pos, RotX, RotY, Zoom);
 }
 
 /// Move camera to a 2D location
 void CameraMoveTo(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), entity_pos_t x, entity_pos_t z)
 {
 	// called from JS; must not fail
 	if(!(g_Game && g_Game->GetWorld() && g_Game->GetView() && g_Game->GetWorld()->GetTerrain()))
 		return;
 
 	CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
 
 	CVector3D target;
 	target.X = x.ToFloat();
 	target.Z = z.ToFloat();
 	target.Y = terrain->GetExactGroundLevel(target.X, target.Z);
 
 	g_Game->GetView()->MoveCameraTarget(target);
 }
 
 entity_id_t GetFollowedEntity(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	if (g_Game && g_Game->GetView())
 		return g_Game->GetView()->GetFollowedEntity();
 
 	return INVALID_ENTITY;
 }
 
 bool HotkeyIsPressed_(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string hotkeyName)
 {
 	return HotkeyIsPressed(hotkeyName);
 }
 
 void DisplayErrorDialog(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring msg)
 {
 	debug_DisplayError(msg.c_str(), DE_NO_DEBUG_INFO, NULL, NULL, NULL, 0, NULL, NULL);
 }
 
 CScriptVal GetProfilerState(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	return g_ProfileViewer.SaveToJS(*(pCxPrivate->pScriptInterface));
 }
 
 bool IsUserReportEnabled(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	return g_UserReporter.IsReportingEnabled();
 }
 
 void SetUserReportEnabled(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), bool enabled)
 {
 	g_UserReporter.SetReportingEnabled(enabled);
 }
 
 std::string GetUserReportStatus(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	return g_UserReporter.GetStatus();
 }
 
 void SubmitUserReport(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string type, int version, std::wstring data)
 {
 	g_UserReporter.SubmitReport(type.c_str(), version, utf8_from_wstring(data));
 }
 
 void SetSimRate(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), float rate)
 {
 	g_Game->SetSimRate(rate);
 }
 
 float GetSimRate(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	return g_Game->GetSimRate();
 }
 
 void SetTurnLength(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int length)
 {
 	if (g_NetServer)
 		g_NetServer->SetTurnLength(length);
 	else
 		LOGERROR(L"Only network host can change turn length");
 }
 
 // Focus the game camera on a given position.
 void SetCameraTarget(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), float x, float y, float z)
 {
 	g_Game->GetView()->ResetCameraTarget(CVector3D(x, y, z));
 }
 
 // Deliberately cause the game to crash.
 // Currently implemented via access violation (read of address 0).
 // Useful for testing the crashlog/stack trace code.
 int Crash(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	debug_printf(L"Crashing at user's request.\n");
 	return *(volatile int*)0;
 }
 
 void DebugWarn(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	debug_warn(L"Warning at user's request.");
 }
 
 // Force a JS garbage collection cycle to take place immediately.
 // Writes an indication of how long this took to the console.
 void ForceGC(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	double time = timer_Time();
 	JS_GC(pCxPrivate->pScriptInterface->GetJSRuntime());
 	time = timer_Time() - time;
 	g_Console->InsertMessage(L"Garbage collection completed in: %f", time);
 }
 
 void DumpSimState(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	OsPath path = psLogDir()/"sim_dump.txt";
 	std::ofstream file (OsString(path).c_str(), std::ofstream::out | std::ofstream::trunc);
 	g_Game->GetSimulation2()->DumpDebugState(file);
 }
 
 void DumpTerrainMipmap(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	VfsPath filename(L"screenshots/terrainmipmap.png");
 	g_Game->GetWorld()->GetTerrain()->GetHeightMipmap().DumpToDisk(filename);
 	OsPath realPath;
 	g_VFS->GetRealPath(filename, realPath);
 	LOGMESSAGERENDER(L"Terrain mipmap written to '%ls'", realPath.string().c_str());
 }
 
 void EnableTimeWarpRecording(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), unsigned int numTurns)
 {
 	g_Game->GetTurnManager()->EnableTimeWarpRecording(numTurns);
 }
 
 void RewindTimeWarp(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	g_Game->GetTurnManager()->RewindTimeWarp();
 }
 
 void QuickSave(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	g_Game->GetTurnManager()->QuickSave();
 }
 
 void QuickLoad(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	g_Game->GetTurnManager()->QuickLoad();
 }
 
 void SetBoundingBoxDebugOverlay(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), bool enabled)
 {
 	ICmpSelectable::ms_EnableDebugOverlays = enabled;
 }
 
 void Script_EndGame(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	EndGame();
 }
 
 // Cause the game to exit gracefully.
 // params:
 // returns:
 // notes:
 // - Exit happens after the current main loop iteration ends
 //   (since this only sets a flag telling it to end)
 void ExitProgram(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	kill_mainloop();
 }
 
 // Is the game paused?
 bool IsPaused(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	if (!g_Game)
 	{
 		JS_ReportError(pCxPrivate->pScriptInterface->GetContext(), "Game is not started");
 		return false;
 	}
 
 	return g_Game->m_Paused;
 }
 
 // Pause/unpause the game
 void SetPaused(ScriptInterface::CxPrivate* pCxPrivate, bool pause)
 {
 	if (!g_Game)
 	{
 		JS_ReportError(pCxPrivate->pScriptInterface->GetContext(), "Game is not started");
 		return;
 	}
 	g_Game->m_Paused = pause;
 #if CONFIG2_AUDIO
 	if ( g_SoundManager )
 		g_SoundManager->Pause(pause);
 #endif
 }
 
 // Return the global frames-per-second value.
 // params:
 // returns: FPS [int]
 // notes:
 // - This value is recalculated once a frame. We take special care to
 //   filter it, so it is both accurate and free of jitter.
 int GetFps(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	int freq = 0;
 	if (g_frequencyFilter)
 		freq = g_frequencyFilter->StableFrequency();
 	return freq;
 }
 
 CScriptVal GetGUIObjectByName(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), CStr name)
 {
 		IGUIObject* guiObj = g_GUI->FindObjectByName(name);
 		if (guiObj)
 			return OBJECT_TO_JSVAL(guiObj->GetJSObject());
 		else
 			return JSVAL_VOID;
 }
 
 // Return the date/time at which the current executable was compiled.
 // params: mode OR an integer specifying
 //   what to display: -1 for "date time (svn revision)", 0 for date, 1 for time, 2 for svn revision
 // returns: string with the requested timestamp info
 // notes:
 // - Displayed on main menu screen; tells non-programmers which auto-build
 //   they are running. Could also be determined via .EXE file properties,
 //   but that's a bit more trouble.
 // - To be exact, the date/time returned is when scriptglue.cpp was
 //   last compiled, but the auto-build does full rebuilds.
 // - svn revision is generated by calling svnversion and cached in
 //   lib/svn_revision.cpp. it is useful to know when attempting to
 //   reproduce bugs (the main EXE and PDB should be temporarily reverted to
 //   that revision so that they match user-submitted crashdumps).
-CStr GetBuildTimestamp(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int mode)
+std::wstring GetBuildTimestamp(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int mode)
 {
 	char buf[200];
-
-	// see function documentation
-	switch(mode)
+	if (mode == -1) // Date, time and revision.
+	{
+		UDate dateTime = L10n::Instance().ParseDateTime(__DATE__ " " __TIME__, "MMM d yyyy HH:mm:ss", Locale::getUS());
+		std::string dateTimeString = L10n::Instance().LocalizeDateTime(dateTime, L10n::DateTime, SimpleDateFormat::DATE_TIME);
+		char svnRevision[32];
+		sprintf_s(svnRevision, ARRAY_SIZE(svnRevision), "%ls", svn_revision);
+		if (strcmp(svnRevision, "custom build") == 0)
+		{
+			// Translation: First item is a date and time, item between parenthesis is the Subversion revision number of the current build.
+			sprintf_s(buf, ARRAY_SIZE(buf), L10n::Instance().Translate("%s (custom build)").c_str(), dateTimeString.c_str());
+		}
+		else
+		{
+			// Translation: First item is a date and time, item between parenthesis is the Subversion revision number of the current build.
+			sprintf_s(buf, ARRAY_SIZE(buf), L10n::Instance().Translate("%s (%ls)").c_str(), dateTimeString.c_str(), svn_revision);
+		}
+	}
+	else if (mode == 0) // Date.
+	{
+		UDate dateTime = L10n::Instance().ParseDateTime(__DATE__, "MMM d yyyy", Locale::getUS());
+		std::string dateTimeString = L10n::Instance().LocalizeDateTime(dateTime, L10n::Date, SimpleDateFormat::MEDIUM);
+		sprintf_s(buf, ARRAY_SIZE(buf), "%s", dateTimeString.c_str());
+	}
+	else if (mode == 1) // Time.
 	{
-	case -1:
-		sprintf_s(buf, ARRAY_SIZE(buf), "%s %s (%ls)", __DATE__, __TIME__, svn_revision);
-		break;
-	case 0:
-		sprintf_s(buf, ARRAY_SIZE(buf), "%s", __DATE__);
-		break;
-	case 1:
-		sprintf_s(buf, ARRAY_SIZE(buf), "%s", __TIME__);
-		break;
-	case 2:
-		sprintf_s(buf, ARRAY_SIZE(buf), "%ls", svn_revision);
-		break;
+		UDate dateTime = L10n::Instance().ParseDateTime(__TIME__, "HH:mm:ss", Locale::getUS());
+		std::string dateTimeString = L10n::Instance().LocalizeDateTime(dateTime, L10n::Time, SimpleDateFormat::MEDIUM);
+		sprintf_s(buf, ARRAY_SIZE(buf), "%s", dateTimeString.c_str());
+	}
+	else if (mode == 2) // Revision.
+	{
+		char svnRevision[32];
+		sprintf_s(svnRevision, ARRAY_SIZE(svnRevision), "%ls", svn_revision);
+		if (strcmp(svnRevision, "custom build") == 0)
+		{
+			sprintf_s(buf, ARRAY_SIZE(buf), L10n::Instance().Translate("custom build").c_str());
+		}
+		else
+		{
+			sprintf_s(buf, ARRAY_SIZE(buf), "%ls", svn_revision);
+		}
 	}
 
-	return CStr(buf);
+	return wstring_from_utf8(buf);
 }
 
 //-----------------------------------------------------------------------------
 // Timer
 //-----------------------------------------------------------------------------
 
 
 // Script profiling functions: Begin timing a piece of code with StartJsTimer(num)
 // and stop timing with StopJsTimer(num). The results will be printed to stdout
 // when the game exits.
 
 static const size_t MAX_JS_TIMERS = 20;
 static TimerUnit js_start_times[MAX_JS_TIMERS];
 static TimerUnit js_timer_overhead;
 static TimerClient js_timer_clients[MAX_JS_TIMERS];
 static wchar_t js_timer_descriptions_buf[MAX_JS_TIMERS * 12];	// depends on MAX_JS_TIMERS and format string below
 
 static void InitJsTimers(ScriptInterface& scriptInterface)
 {
 	wchar_t* pos = js_timer_descriptions_buf;
 	for(size_t i = 0; i < MAX_JS_TIMERS; i++)
 	{
 		const wchar_t* description = pos;
 		pos += swprintf_s(pos, 12, L"js_timer %d", (int)i)+1;
 		timer_AddClient(&js_timer_clients[i], description);
 	}
 
 	// call several times to get a good approximation of 'hot' performance.
 	// note: don't use a separate timer slot to warm up and then judge
 	// overhead from another: that causes worse results (probably some
 	// caching effects inside JS, but I don't entirely understand why).
 	std::wstring calibration_script =
 		L"Engine.StartXTimer(0);\n" \
 		L"Engine.StopXTimer (0);\n" \
 		L"\n";
 	scriptInterface.LoadGlobalScript("timer_calibration_script", calibration_script);
 	// slight hack: call LoadGlobalScript twice because we can't average several
 	// TimerUnit values because there's no operator/. this way is better anyway
 	// because it hopefully avoids the one-time JS init overhead.
 	js_timer_clients[0].sum.SetToZero();
 	scriptInterface.LoadGlobalScript("timer_calibration_script", calibration_script);
 	js_timer_clients[0].sum.SetToZero();
 	js_timer_clients[0].num_calls = 0;
 }
 
 void StartJsTimer(ScriptInterface::CxPrivate* pCxPrivate, unsigned int slot)
 {
 	ONCE(InitJsTimers(*(pCxPrivate->pScriptInterface)));
 	
 	if (slot >= MAX_JS_TIMERS)
 		LOGERROR(L"Exceeded the maximum number of timer slots for scripts!");
 
 	js_start_times[slot].SetFromTimer();
 }
 
-
 void StopJsTimer(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), unsigned int slot)
 {
 	if (slot >= MAX_JS_TIMERS)
 		LOGERROR(L"Exceeded the maximum number of timer slots for scripts!");
 
 	TimerUnit now;
 	now.SetFromTimer();
 	now.Subtract(js_timer_overhead);
 	BillingPolicy_Default()(&js_timer_clients[slot], js_start_times[slot], now);
 	js_start_times[slot].SetToZero();
 }
-
-
-
 } // namespace
 
 
 
 void GuiScriptingInit(ScriptInterface& scriptInterface)
 {
 	JSI_IGUIObject::init(scriptInterface);
 	JSI_GUITypes::init(scriptInterface);
-	
+
 	JSI_GameView::RegisterScriptFunctions(scriptInterface);
 	JSI_Renderer::RegisterScriptFunctions(scriptInterface);
 	JSI_Console::RegisterScriptFunctions(scriptInterface);
 	JSI_ConfigDB::RegisterScriptFunctions(scriptInterface);
 	JSI_Sound::RegisterScriptFunctions(scriptInterface);
+	JSI_L10n::RegisterScriptFunctions(scriptInterface);
  
 	// VFS (external)
 	scriptInterface.RegisterFunction<CScriptVal, std::wstring, std::wstring, bool, &JSI_VFS::BuildDirEntList>("BuildDirEntList");
 	scriptInterface.RegisterFunction<bool, CStrW, JSI_VFS::FileExists>("FileExists");
 	scriptInterface.RegisterFunction<double, std::wstring, &JSI_VFS::GetFileMTime>("GetFileMTime");
 	scriptInterface.RegisterFunction<unsigned int, std::wstring, &JSI_VFS::GetFileSize>("GetFileSize");
 	scriptInterface.RegisterFunction<CScriptVal, std::wstring, &JSI_VFS::ReadFile>("ReadFile");
 	scriptInterface.RegisterFunction<CScriptVal, std::wstring, &JSI_VFS::ReadFileLines>("ReadFileLines");
 	// GUI manager functions:
 	scriptInterface.RegisterFunction<void, std::wstring, CScriptVal, &PushGuiPage>("PushGuiPage");
 	scriptInterface.RegisterFunction<void, std::wstring, CScriptVal, &SwitchGuiPage>("SwitchGuiPage");
 	scriptInterface.RegisterFunction<void, &PopGuiPage>("PopGuiPage");
 	scriptInterface.RegisterFunction<void, CScriptVal, &PopGuiPageCB>("PopGuiPageCB");
 	scriptInterface.RegisterFunction<CScriptVal, CStr, &GetGUIObjectByName>("GetGUIObjectByName");
 
 	// Simulation<->GUI interface functions:
 	scriptInterface.RegisterFunction<CScriptVal, std::wstring, CScriptVal, &GuiInterfaceCall>("GuiInterfaceCall");
 	scriptInterface.RegisterFunction<void, CScriptVal, &PostNetworkCommand>("PostNetworkCommand");
 
 	// Entity picking
 	scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, int, int, &PickEntitiesAtPoint>("PickEntitiesAtPoint");
 	scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, int, int, int, int, &PickFriendlyEntitiesInRect>("PickFriendlyEntitiesInRect");
 	scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, &PickFriendlyEntitiesOnScreen>("PickFriendlyEntitiesOnScreen");
 	scriptInterface.RegisterFunction<std::vector<entity_id_t>, std::string, bool, bool, bool, &PickSimilarFriendlyEntities>("PickSimilarFriendlyEntities");
 	scriptInterface.RegisterFunction<CFixedVector3D, int, int, &GetTerrainAtScreenPoint>("GetTerrainAtScreenPoint");
 
 	// Network / game setup functions
 	scriptInterface.RegisterFunction<void, &StartNetworkGame>("StartNetworkGame");
 	scriptInterface.RegisterFunction<void, CScriptVal, int, &StartGame>("StartGame");
 	scriptInterface.RegisterFunction<void, &Script_EndGame>("EndGame");
 	scriptInterface.RegisterFunction<void, std::wstring, &StartNetworkHost>("StartNetworkHost");
 	scriptInterface.RegisterFunction<void, std::wstring, std::string, &StartNetworkJoin>("StartNetworkJoin");
 	scriptInterface.RegisterFunction<void, &DisconnectNetworkGame>("DisconnectNetworkGame");
 	scriptInterface.RegisterFunction<CScriptVal, &PollNetworkClient>("PollNetworkClient");
 	scriptInterface.RegisterFunction<void, CScriptVal, &SetNetworkGameAttributes>("SetNetworkGameAttributes");
 	scriptInterface.RegisterFunction<void, int, std::string, &AssignNetworkPlayer>("AssignNetworkPlayer");
 	scriptInterface.RegisterFunction<void, std::wstring, &SendNetworkChat>("SendNetworkChat");
 	scriptInterface.RegisterFunction<std::vector<CScriptValRooted>, &GetAIs>("GetAIs");
 	scriptInterface.RegisterFunction<CScriptValRooted, &GetEngineInfo>("GetEngineInfo");
 
 	// Saved games
 	scriptInterface.RegisterFunction<CScriptVal, std::wstring, &StartSavedGame>("StartSavedGame");
 	scriptInterface.RegisterFunction<std::vector<CScriptValRooted>, &GetSavedGames>("GetSavedGames");
 	scriptInterface.RegisterFunction<bool, std::wstring, &DeleteSavedGame>("DeleteSavedGame");
 	scriptInterface.RegisterFunction<void, std::wstring, std::wstring, CScriptVal, &SaveGame>("SaveGame");
 	scriptInterface.RegisterFunction<void, std::wstring, std::wstring, CScriptVal, &SaveGamePrefix>("SaveGamePrefix");
 	scriptInterface.RegisterFunction<void, &QuickSave>("QuickSave");
 	scriptInterface.RegisterFunction<void, &QuickLoad>("QuickLoad");
 
 	// Misc functions
 	scriptInterface.RegisterFunction<std::wstring, std::wstring, &SetCursor>("SetCursor");
 	scriptInterface.RegisterFunction<int, &GetPlayerID>("GetPlayerID");
 	scriptInterface.RegisterFunction<void, int, &SetPlayerID>("SetPlayerID");
 	scriptInterface.RegisterFunction<void, std::string, &OpenURL>("OpenURL");
 	scriptInterface.RegisterFunction<std::wstring, &GetMatchID>("GetMatchID");
 	scriptInterface.RegisterFunction<void, &RestartInAtlas>("RestartInAtlas");
 	scriptInterface.RegisterFunction<bool, &AtlasIsAvailable>("AtlasIsAvailable");
 	scriptInterface.RegisterFunction<bool, &IsAtlasRunning>("IsAtlasRunning");
 	scriptInterface.RegisterFunction<CScriptVal, VfsPath, &LoadMapSettings>("LoadMapSettings");
 	scriptInterface.RegisterFunction<CScriptVal, &GetMapSettings>("GetMapSettings");
 	scriptInterface.RegisterFunction<float, &CameraGetX>("CameraGetX");
 	scriptInterface.RegisterFunction<float, &CameraGetZ>("CameraGetZ");
 	scriptInterface.RegisterFunction<void, entity_id_t, &CameraFollow>("CameraFollow");
 	scriptInterface.RegisterFunction<void, entity_id_t, &CameraFollowFPS>("CameraFollowFPS");
 	scriptInterface.RegisterFunction<void, entity_pos_t, entity_pos_t, entity_pos_t, entity_pos_t, entity_pos_t, entity_pos_t, &SetCameraData>("SetCameraData");
 	scriptInterface.RegisterFunction<void, entity_pos_t, entity_pos_t, &CameraMoveTo>("CameraMoveTo");
 	scriptInterface.RegisterFunction<entity_id_t, &GetFollowedEntity>("GetFollowedEntity");
 	scriptInterface.RegisterFunction<bool, std::string, &HotkeyIsPressed_>("HotkeyIsPressed");
 	scriptInterface.RegisterFunction<void, std::wstring, &DisplayErrorDialog>("DisplayErrorDialog");
 	scriptInterface.RegisterFunction<CScriptVal, &GetProfilerState>("GetProfilerState");
 	scriptInterface.RegisterFunction<void, &ExitProgram>("Exit");
 	scriptInterface.RegisterFunction<bool, &IsPaused>("IsPaused");
 	scriptInterface.RegisterFunction<void, bool, &SetPaused>("SetPaused");
 	scriptInterface.RegisterFunction<int, &GetFps>("GetFPS");
-	scriptInterface.RegisterFunction<CStr, int, &GetBuildTimestamp>("BuildTime");
+	scriptInterface.RegisterFunction<std::wstring, int, &GetBuildTimestamp>("BuildTime");
 
 	// User report functions
 	scriptInterface.RegisterFunction<bool, &IsUserReportEnabled>("IsUserReportEnabled");
 	scriptInterface.RegisterFunction<void, bool, &SetUserReportEnabled>("SetUserReportEnabled");
 	scriptInterface.RegisterFunction<std::string, &GetUserReportStatus>("GetUserReportStatus");
 	scriptInterface.RegisterFunction<void, std::string, int, std::wstring, &SubmitUserReport>("SubmitUserReport");
 
 	// Development/debugging functions
 	scriptInterface.RegisterFunction<void, unsigned int, &StartJsTimer>("StartXTimer");
 	scriptInterface.RegisterFunction<void, unsigned int, &StopJsTimer>("StopXTimer");
 	scriptInterface.RegisterFunction<void, float, &SetSimRate>("SetSimRate");
 	scriptInterface.RegisterFunction<float, &GetSimRate>("GetSimRate");
 	scriptInterface.RegisterFunction<void, int, &SetTurnLength>("SetTurnLength");
 	scriptInterface.RegisterFunction<void, float, float, float, &SetCameraTarget>("SetCameraTarget");
 	scriptInterface.RegisterFunction<int, &Crash>("Crash");
 	scriptInterface.RegisterFunction<void, &DebugWarn>("DebugWarn");
 	scriptInterface.RegisterFunction<void, &ForceGC>("ForceGC");
 	scriptInterface.RegisterFunction<void, &DumpSimState>("DumpSimState");
 	scriptInterface.RegisterFunction<void, &DumpTerrainMipmap>("DumpTerrainMipmap");
 	scriptInterface.RegisterFunction<void, unsigned int, &EnableTimeWarpRecording>("EnableTimeWarpRecording");
 	scriptInterface.RegisterFunction<void, &RewindTimeWarp>("RewindTimeWarp");
 	scriptInterface.RegisterFunction<void, bool, &SetBoundingBoxDebugOverlay>("SetBoundingBoxDebugOverlay");
 
 	// Lobby functions
 	scriptInterface.RegisterFunction<bool, &JSI_Lobby::HasXmppClient>("HasXmppClient");
 	scriptInterface.RegisterFunction<bool, &JSI_Lobby::IsRankedGame>("IsRankedGame");
 	scriptInterface.RegisterFunction<void, bool, &JSI_Lobby::SetRankedGame>("SetRankedGame");
 #if CONFIG2_LOBBY // Allow the lobby to be disabled
 	scriptInterface.RegisterFunction<void, std::wstring, std::wstring, std::wstring, std::wstring, int, &JSI_Lobby::StartXmppClient>("StartXmppClient");
 	scriptInterface.RegisterFunction<void, std::wstring, std::wstring, &JSI_Lobby::StartRegisterXmppClient>("StartRegisterXmppClient");
 	scriptInterface.RegisterFunction<void, &JSI_Lobby::StopXmppClient>("StopXmppClient");
 	scriptInterface.RegisterFunction<void, &JSI_Lobby::ConnectXmppClient>("ConnectXmppClient");
 	scriptInterface.RegisterFunction<void, &JSI_Lobby::DisconnectXmppClient>("DisconnectXmppClient");
 	scriptInterface.RegisterFunction<void, &JSI_Lobby::RecvXmppClient>("RecvXmppClient");
 	scriptInterface.RegisterFunction<void, &JSI_Lobby::SendGetGameList>("SendGetGameList");
 	scriptInterface.RegisterFunction<void, &JSI_Lobby::SendGetBoardList>("SendGetBoardList");
 	scriptInterface.RegisterFunction<void, &JSI_Lobby::SendGetRatingList>("SendGetRatingList");
 	scriptInterface.RegisterFunction<void, CScriptVal, &JSI_Lobby::SendRegisterGame>("SendRegisterGame");
 	scriptInterface.RegisterFunction<void, CScriptVal, &JSI_Lobby::SendGameReport>("SendGameReport");
 	scriptInterface.RegisterFunction<void, &JSI_Lobby::SendUnregisterGame>("SendUnregisterGame");
 	scriptInterface.RegisterFunction<void, std::wstring, std::wstring, &JSI_Lobby::SendChangeStateGame>("SendChangeStateGame");
 	scriptInterface.RegisterFunction<CScriptVal, &JSI_Lobby::GetPlayerList>("GetPlayerList");
 	scriptInterface.RegisterFunction<CScriptVal, &JSI_Lobby::GetGameList>("GetGameList");
 	scriptInterface.RegisterFunction<CScriptVal, &JSI_Lobby::GetBoardList>("GetBoardList");
 	scriptInterface.RegisterFunction<CScriptVal, &JSI_Lobby::LobbyGuiPollMessage>("LobbyGuiPollMessage");
 	scriptInterface.RegisterFunction<void, std::wstring, &JSI_Lobby::LobbySendMessage>("LobbySendMessage");
 	scriptInterface.RegisterFunction<void, std::wstring, &JSI_Lobby::LobbySetPlayerPresence>("LobbySetPlayerPresence");
 	scriptInterface.RegisterFunction<void, std::wstring, &JSI_Lobby::LobbySetNick>("LobbySetNick");
 	scriptInterface.RegisterFunction<std::wstring, &JSI_Lobby::LobbyGetNick>("LobbyGetNick");
 	scriptInterface.RegisterFunction<void, std::wstring, std::wstring, &JSI_Lobby::LobbyKick>("LobbyKick");
 	scriptInterface.RegisterFunction<void, std::wstring, std::wstring, &JSI_Lobby::LobbyBan>("LobbyBan");
 	scriptInterface.RegisterFunction<std::wstring, std::wstring, &JSI_Lobby::LobbyGetPlayerPresence>("LobbyGetPlayerPresence");
 	scriptInterface.RegisterFunction<std::wstring, std::wstring, &JSI_Lobby::LobbyGetPlayerRole>("LobbyGetPlayerRole");
 	scriptInterface.RegisterFunction<std::wstring, std::wstring, std::wstring, &JSI_Lobby::EncryptPassword>("EncryptPassword");
 	scriptInterface.RegisterFunction<std::wstring, &JSI_Lobby::LobbyGetRoomSubject>("LobbyGetRoomSubject");
 #endif // CONFIG2_LOBBY
 }
Index: ps/trunk/source/i18n/L10n.cpp
===================================================================
--- ps/trunk/source/i18n/L10n.cpp	(nonexistent)
+++ ps/trunk/source/i18n/L10n.cpp	(revision 14953)
@@ -0,0 +1,486 @@
+/* Copyright (c) 2014 Wildfire Games
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "precompiled.h"
+#include "i18n/L10n.h"
+
+#include <iostream>
+#include <string>
+#include <boost/concept_check.hpp>
+
+#include "lib/file/file_system.h"
+#include "lib/utf8.h"
+
+#include "ps/CLogger.h"
+#include "ps/ConfigDB.h"
+#include "ps/Filesystem.h"
+#include "ps/GameSetup/GameSetup.h"
+
+
+L10n& L10n::Instance()
+{
+	static L10n m_instance;
+	return m_instance;
+}
+
+L10n::L10n()
+	: currentLocaleIsOriginalGameLocale(false), dictionary(new tinygettext::Dictionary())
+{
+	LoadListOfAvailableLocales();
+	ReevaluateCurrentLocaleAndReload();
+}
+
+L10n::~L10n()
+{
+	for (std::vector<Locale*>::iterator iterator = availableLocales.begin(); iterator != availableLocales.end(); ++iterator)
+		delete *iterator;
+	delete dictionary;
+}
+
+Locale L10n::GetCurrentLocale()
+{
+	return currentLocale;
+}
+
+bool L10n::SaveLocale(const std::string& localeCode)
+{
+	return SaveLocale(Locale(Locale::createCanonical(localeCode.c_str())));
+}
+
+bool L10n::SaveLocale(Locale locale)
+{	
+	// TODO: Use the ConfigDB functions exposed to js to change the config value
+	// Save the new locale in the settings file.
+	if (!ValidateLocale(locale))
+		return false;
+
+	g_ConfigDB.SetValueString(CFG_USER, "locale", locale.getName());
+	g_ConfigDB.WriteFile(CFG_USER);
+	return true;
+}
+
+bool L10n::ValidateLocale(const std::string& localeCode)
+{
+	return ValidateLocale(Locale::createCanonical(localeCode.c_str()));
+}
+
+// Returns true if both of these conditions are true:
+//  1. ICU has resources for that locale (which also ensures it's a valid locale string) 
+//  2. Either a dictionary for language_country or for language is available.
+bool L10n::ValidateLocale(Locale locale)
+{
+	int32_t count;
+	bool icuSupported = false;
+	const Locale* icuSupportedLocales = Locale::getAvailableLocales(count);
+	for (int i=0; i<count; ++i)
+	{
+		if (icuSupportedLocales[i] == locale)
+		{
+			icuSupported = true;
+			break;
+		}
+	}
+	if(!icuSupported)
+		return false;
+	
+	for (std::vector<Locale*>::iterator iterator = availableLocales.begin(); iterator != availableLocales.end(); ++iterator)
+	{
+		if ((strcmp((*iterator)->getLanguage(), locale.getLanguage()) == 0 && strcmp((*iterator)->getCountry(), "") == 0) ||
+			(strcmp((*iterator)->getLanguage(), locale.getLanguage()) == 0 && strcmp((*iterator)->getCountry(), locale.getCountry()) == 0))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+std::vector<std::wstring> L10n::GetDictionariesForDictLocale(const std::string& locale)
+{
+	std::wstring tmpLocale(locale.begin(), locale.end());
+	std::vector<std::wstring> ret;
+	VfsPaths filenames;
+	if (vfs::GetPathnames(g_VFS, L"l10n/",  tmpLocale.append(L".*.po").c_str(), filenames) < 0)
+		return ret;
+
+	if (filenames.size() == 0)
+	{
+		Locale tmpLocale1 = Locale::createCanonical(locale.c_str());
+		if (vfs::GetPathnames(g_VFS, L"l10n/", wstring_from_utf8(tmpLocale1.getLanguage()).append(L".*.po").c_str(), filenames) < 0)
+			return ret;
+	}
+
+	for (VfsPaths::iterator it = filenames.begin(); it != filenames.end(); ++it)
+	{
+		VfsPath filepath = *it;
+		ret.push_back(filepath.Filename().string());
+	}
+	return ret;
+}
+
+std::string L10n::GetDictionaryLocale(std::string configLocaleString)
+{
+	Locale out;
+	GetDictionaryLocale(configLocaleString, out);
+	return out.getName();
+}
+
+// First, try to get a valid locale from the config, then check if the system locale can be used and otherwise fall back to en_US.
+void L10n::GetDictionaryLocale(std::string configLocaleString, Locale& outLocale)
+{
+	bool validConfigLocale = false;
+	if (!configLocaleString.empty())
+	{
+		Locale configLocale = Locale::createCanonical(configLocaleString.c_str());
+		if (ValidateLocale(configLocale))
+		{
+			outLocale = configLocale;
+			validConfigLocale = true;
+		}
+		else
+			LOGWARNING(L"The configured locale is not valid or no translations are available. Falling back to another locale.");
+	}
+	
+	if (!validConfigLocale)
+	{
+		Locale systemLocale = Locale::getDefault();
+		if (ValidateLocale(systemLocale))
+		{
+			outLocale = systemLocale;
+		}
+		else
+		{
+			outLocale = Locale::getUS();
+		}
+	}
+}
+
+
+// Try to find the best disctionary locale based on user configuration and system locale, set the currentLocale and reload the dictionary.
+void L10n::ReevaluateCurrentLocaleAndReload()
+{
+	std::string locale;
+	CFG_GET_VAL("locale", String, locale);
+	
+	GetDictionaryLocale(locale, currentLocale);
+	currentLocaleIsOriginalGameLocale = (currentLocale == Locale::getUS()) == TRUE;
+	LoadDictionaryForCurrentLocale();
+}
+
+// Get all locales supported by ICU.
+std::vector<std::string> L10n::GetAllLocales()
+{
+	std::vector<std::string> ret;
+	int32_t count;
+	const Locale* icuSupportedLocales = Locale::getAvailableLocales(count);
+	for (int i=0; i<count; ++i)
+		ret.push_back(icuSupportedLocales[i].getName());
+	return ret;
+}
+
+
+std::vector<std::string> L10n::GetSupportedLocaleBaseNames()
+{
+	std::vector<std::string> supportedLocaleCodes;
+	for (std::vector<Locale*>::iterator iterator = availableLocales.begin(); iterator != availableLocales.end(); ++iterator)
+	{
+		if (!InDevelopmentCopy() && strcmp((*iterator)->getBaseName(), "long") == 0)
+			continue;
+		supportedLocaleCodes.push_back((*iterator)->getBaseName());
+	}
+	return supportedLocaleCodes;
+}
+
+std::vector<std::wstring> L10n::GetSupportedLocaleDisplayNames()
+{
+	std::vector<std::wstring> supportedLocaleDisplayNames;
+	for (std::vector<Locale*>::iterator iterator = availableLocales.begin(); iterator != availableLocales.end(); ++iterator)
+	{
+		if (strcmp((*iterator)->getBaseName(), "long") == 0)
+		{
+			if (InDevelopmentCopy())
+				supportedLocaleDisplayNames.push_back(wstring_from_utf8(Translate("Long strings")));
+			continue;
+		}
+
+		UnicodeString utf16LocaleDisplayName;
+		(**iterator).getDisplayName(**iterator, utf16LocaleDisplayName);
+		char localeDisplayName[512];
+		CheckedArrayByteSink sink(localeDisplayName, ARRAY_SIZE(localeDisplayName));
+		utf16LocaleDisplayName.toUTF8(sink);
+		ENSURE(!sink.Overflowed());
+
+		supportedLocaleDisplayNames.push_back(wstring_from_utf8(std::string(localeDisplayName, sink.NumberOfBytesWritten())));
+	}
+	return supportedLocaleDisplayNames;
+}
+
+std::string L10n::GetCurrentLocaleString()
+{
+	return currentLocale.getName();
+}
+
+std::string L10n::GetLocaleLanguage(const std::string& locale)
+{
+	Locale loc = Locale::createCanonical(locale.c_str());
+	return loc.getLanguage();
+}
+
+std::string L10n::GetLocaleBaseName(const std::string& locale)
+{
+	Locale loc = Locale::createCanonical(locale.c_str());
+	return loc.getBaseName();
+}
+
+std::string L10n::GetLocaleCountry(const std::string& locale)
+{
+	Locale loc = Locale::createCanonical(locale.c_str());
+	return loc.getCountry();
+}
+
+std::string L10n::GetLocaleScript(const std::string& locale)
+{
+	Locale loc = Locale::createCanonical(locale.c_str());
+	return loc.getScript();
+}
+
+std::string L10n::Translate(const std::string& sourceString)
+{
+	if (!currentLocaleIsOriginalGameLocale)
+		return dictionary->translate(sourceString);
+
+	return sourceString;
+}
+
+std::string L10n::TranslateWithContext(const std::string& context, const std::string& sourceString)
+{
+	if (!currentLocaleIsOriginalGameLocale)
+		return dictionary->translate_ctxt(context, sourceString);
+
+	return sourceString;
+}
+
+std::string L10n::TranslatePlural(const std::string& singularSourceString, const std::string& pluralSourceString, int number)
+{
+	if (!currentLocaleIsOriginalGameLocale)
+		return dictionary->translate_plural(singularSourceString, pluralSourceString, number);
+
+	if (number == 1)
+		return singularSourceString;
+
+	return pluralSourceString;
+}
+
+std::string L10n::TranslatePluralWithContext(const std::string& context, const std::string& singularSourceString, const std::string& pluralSourceString, int number)
+{
+	if (!currentLocaleIsOriginalGameLocale)
+		return dictionary->translate_ctxt_plural(context, singularSourceString, pluralSourceString, number);
+
+	if (number == 1)
+		return singularSourceString;
+
+	return pluralSourceString;
+}
+
+std::string L10n::TranslateLines(const std::string& sourceString)
+{
+	std::string targetString;
+	std::stringstream stringOfLines(sourceString);
+	std::string line;
+
+	while (std::getline(stringOfLines, line)) {
+		targetString.append(Translate(line));
+		targetString.append("\n");
+	}
+
+	return targetString;
+}
+
+UDate L10n::ParseDateTime(const std::string& dateTimeString, const std::string& dateTimeFormat, const Locale& locale)
+{
+	UErrorCode success = U_ZERO_ERROR;
+	UnicodeString utf16DateTimeString = UnicodeString::fromUTF8(dateTimeString.c_str());
+	UnicodeString utf16DateTimeFormat = UnicodeString::fromUTF8(dateTimeFormat.c_str());
+
+	DateFormat* dateFormatter = new SimpleDateFormat(utf16DateTimeFormat, locale, success);
+	UDate date = dateFormatter->parse(utf16DateTimeString, success);
+	delete dateFormatter;
+
+	return date;
+}
+
+std::string L10n::LocalizeDateTime(const UDate& dateTime, DateTimeType type, DateFormat::EStyle style)
+{
+	UnicodeString utf16Date;
+
+	DateFormat* dateFormatter = CreateDateTimeInstance(type, style, currentLocale);
+	dateFormatter->format(dateTime, utf16Date);
+	char utf8Date[512];
+	CheckedArrayByteSink sink(utf8Date, ARRAY_SIZE(utf8Date));
+	utf16Date.toUTF8(sink);
+	ENSURE(!sink.Overflowed());
+	delete dateFormatter;
+
+	return std::string(utf8Date, sink.NumberOfBytesWritten());
+}
+
+std::string L10n::FormatMillisecondsIntoDateString(UDate milliseconds, const std::string& formatString)
+{
+	UErrorCode success = U_ZERO_ERROR;
+	UnicodeString utf16Date;
+	UnicodeString utf16LocalizedDateTimeFormat = UnicodeString::fromUTF8(formatString.c_str());
+
+	// The format below should never reach the user, the one that matters is the
+	// one from the formatString parameter.
+	UnicodeString utf16SourceDateTimeFormat = UnicodeString::fromUTF8("No format specified (you should not be seeing this string!)");
+
+	SimpleDateFormat* dateFormatter = new SimpleDateFormat(utf16SourceDateTimeFormat, currentLocale, success);
+	dateFormatter->applyLocalizedPattern(utf16LocalizedDateTimeFormat, success);
+	dateFormatter->format(milliseconds, utf16Date);
+	delete dateFormatter;
+
+	char utf8Date[512];
+	CheckedArrayByteSink sink(utf8Date, ARRAY_SIZE(utf8Date));
+	utf16Date.toUTF8(sink);
+	ENSURE(!sink.Overflowed());
+
+	return std::string(utf8Date, sink.NumberOfBytesWritten());
+}
+
+std::string L10n::FormatDecimalNumberIntoString(double number)
+{
+	UErrorCode success = U_ZERO_ERROR;
+	UnicodeString utf16Number;
+	NumberFormat* numberFormatter = NumberFormat::createInstance(currentLocale, UNUM_DECIMAL, success);
+	numberFormatter->format(number, utf16Number);
+	char utf8Number[512];
+	CheckedArrayByteSink sink(utf8Number, ARRAY_SIZE(utf8Number));
+	utf16Number.toUTF8(sink);
+	ENSURE(!sink.Overflowed());
+
+	return std::string(utf8Number, sink.NumberOfBytesWritten());
+}
+
+VfsPath L10n::LocalizePath(VfsPath sourcePath)
+{
+	VfsPath path = sourcePath;
+
+	VfsPath localizedPath = sourcePath.Parent() / L"l10n" / wstring_from_utf8(currentLocale.getLanguage()) / sourcePath.Filename();
+	if (VfsFileExists(localizedPath))
+		path = localizedPath;
+
+	return path;
+}
+
+void L10n::LoadDictionaryForCurrentLocale()
+{
+	delete dictionary;
+	dictionary = new tinygettext::Dictionary();
+
+	VfsPaths filenames;
+	if (vfs::GetPathnames(g_VFS, L"l10n/", (wstring_from_utf8(currentLocale.getBaseName()) + L".*.po").c_str(), filenames) < 0)
+		return;
+	
+	// If not matching country is found, try to fall back to a matching language	
+	if (filenames.size() == 0)
+	{
+		if (vfs::GetPathnames(g_VFS, L"l10n/", (wstring_from_utf8(currentLocale.getLanguage()) + L".*.po").c_str(), filenames) < 0)
+			return;
+	}
+
+	for (VfsPaths::iterator it = filenames.begin(); it != filenames.end(); ++it)
+	{
+		VfsPath filename = *it;
+		CVFSFile file;
+		file.Load(g_VFS, filename);
+		std::string content = file.DecodeUTF8();
+		ReadPoIntoDictionary(content, dictionary);
+	}
+}
+
+void L10n::LoadListOfAvailableLocales()
+{
+	for (std::vector<Locale*>::iterator iterator = availableLocales.begin(); iterator != availableLocales.end(); ++iterator)
+		delete *iterator;
+
+	availableLocales.clear();
+
+	Locale* defaultLocale = new Locale(Locale::getUS());
+	availableLocales.push_back(defaultLocale); // Always available.
+
+	VfsPaths filenames;
+	if (vfs::GetPathnames(g_VFS, L"l10n/", L"*.po", filenames) < 0)
+		return;
+
+	for (VfsPaths::iterator it = filenames.begin(); it != filenames.end(); ++it)
+	{
+		// Note: PO files follow this naming convention: “l10n/<locale code>.<mod name>.po”. For example: “l10n/gl.public.po”.
+		VfsPath filepath = *it;
+		std::string filename = utf8_from_wstring(filepath.string()).substr(strlen("l10n/"));
+		std::size_t lengthToFirstDot = filename.find('.');
+		std::string localeCode = filename.substr(0, lengthToFirstDot);
+		Locale* locale = new Locale(Locale::createCanonical(localeCode.c_str()));
+
+		bool localeIsAlreadyAvailable = false;
+		for (std::vector<Locale*>::iterator iterator = availableLocales.begin(); iterator != availableLocales.end(); ++iterator)
+		{
+			if (*locale == **iterator)
+			{
+				localeIsAlreadyAvailable = true;
+				break;
+			}
+		}
+
+		if (!localeIsAlreadyAvailable)
+			availableLocales.push_back(locale);
+		else 
+			delete locale;
+	}
+}
+
+void L10n::ReadPoIntoDictionary(const std::string& poContent, tinygettext::Dictionary* dictionary)
+{
+	try
+	{
+		std::istringstream inputStream(poContent);
+		tinygettext::POParser::parse("virtual PO file", inputStream, *dictionary, false);
+	}
+	catch(std::exception& e)
+	{
+		LOGERROR(L"[Localization] Exception while reading virtual PO file: %hs", e.what());
+	}
+}
+
+DateFormat* L10n::CreateDateTimeInstance(L10n::DateTimeType type, DateFormat::EStyle style, const Locale& locale)
+{
+	switch(type)
+	{
+	case Date:
+		return SimpleDateFormat::createDateInstance(style, locale);
+
+	case Time:
+		return SimpleDateFormat::createTimeInstance(style, locale);
+
+	case DateTime:
+	default:
+		return SimpleDateFormat::createDateTimeInstance(style, style, locale);
+	}
+}

Property changes on: ps/trunk/source/i18n/L10n.cpp
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: ps/trunk/source/i18n/L10n.h
===================================================================
--- ps/trunk/source/i18n/L10n.h	(nonexistent)
+++ ps/trunk/source/i18n/L10n.h	(revision 14953)
@@ -0,0 +1,95 @@
+/* Copyright (c) 2014 Wildfire Games
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef L10N_H
+#define L10N_H
+
+#include <string>
+#include <vector>
+
+#include "lib/code_annotation.h"
+#include "lib/external_libraries/icu.h"
+#include "lib/external_libraries/tinygettext.h"
+
+#include "lib/file/vfs/vfs_path.h"
+
+class L10n
+{
+	NONCOPYABLE(L10n);
+public:
+
+	L10n();
+	~L10n();
+
+	enum DateTimeType { DateTime, Date, Time };
+
+	static L10n& Instance();
+
+	Locale GetCurrentLocale();
+	std::vector<std::string> GetAllLocales();
+	bool SaveLocale(const std::string& localeCode);
+	bool SaveLocale(Locale locale);
+	std::vector<std::string> GetSupportedLocaleBaseNames();
+	std::vector<std::wstring> GetSupportedLocaleDisplayNames();
+	std::string GetCurrentLocaleString();
+	std::string GetLocaleLanguage(const std::string& locale);
+	std::string GetLocaleBaseName(const std::string& locale);
+	std::string GetLocaleCountry(const std::string& locale);
+	std::string GetLocaleScript(const std::string& locale);
+	std::vector<std::wstring> GetDictionariesForDictLocale(const std::string& locale);
+	std::string GetDictionaryLocale(std::string configLocaleString);
+	void GetDictionaryLocale(std::string configLocaleString, Locale& outLocale);
+	void ReevaluateCurrentLocaleAndReload();
+	bool ValidateLocale(Locale locale);
+	bool ValidateLocale(const std::string& localeCode);
+
+	std::string Translate(const std::string& sourceString);
+	std::string TranslateWithContext(const std::string& context, const std::string& sourceString);
+	std::string TranslatePlural(const std::string& singularSourceString, const std::string& pluralSourceString, int number);
+	std::string TranslatePluralWithContext(const std::string& context, const std::string& singularSourceString, const std::string& pluralSourceString, int number);
+	std::string TranslateLines(const std::string& sourceString);
+
+	UDate ParseDateTime(const std::string& dateTimeString, const std::string& dateTimeFormat, const Locale& locale);
+	std::string LocalizeDateTime(const UDate& dateTime, DateTimeType type, DateFormat::EStyle style);
+	std::string FormatMillisecondsIntoDateString(UDate milliseconds, const std::string& formatString);
+	std::string FormatDecimalNumberIntoString(double number);
+
+	VfsPath LocalizePath(VfsPath sourcePath);
+
+private:
+
+	tinygettext::Dictionary* dictionary;
+	bool isRtlLanguage;
+	Locale currentLocale;
+	std::vector<Locale*> availableLocales;
+	bool currentLocaleIsOriginalGameLocale;
+
+	Locale AutoDetectLocale();
+	void LoadDictionaryForCurrentLocale();
+	void LoadListOfAvailableLocales();
+
+	void ReadPoIntoDictionary(const std::string& poContent, tinygettext::Dictionary* dictionary);
+
+	DateFormat* CreateDateTimeInstance(DateTimeType type, DateFormat::EStyle style, const Locale& locale);
+};
+
+#endif // L10N_H

Property changes on: ps/trunk/source/i18n/L10n.h
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: ps/trunk/source/i18n/scripting/JSInterface_L10n.cpp
===================================================================
--- ps/trunk/source/i18n/scripting/JSInterface_L10n.cpp	(nonexistent)
+++ ps/trunk/source/i18n/scripting/JSInterface_L10n.cpp	(revision 14953)
@@ -0,0 +1,178 @@
+/* Copyright (C) 2014 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "JSInterface_L10n.h"
+
+#include "i18n/L10n.h"
+#include "lib/utf8.h"
+#include "ps/ConfigDB.h"
+
+// Returns a translation of the specified English string into the current language.
+std::wstring JSI_L10n::Translate(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring sourceString)
+{
+	return wstring_from_utf8(L10n::Instance().Translate(utf8_from_wstring(sourceString)));
+}
+
+// Returns a translation of the specified English string, for the specified context.
+std::wstring JSI_L10n::TranslateWithContext(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string context, std::wstring sourceString)
+{
+	return wstring_from_utf8(L10n::Instance().TranslateWithContext(context, utf8_from_wstring(sourceString)));
+}
+
+// Return a translated version of the given strings (singular and plural) depending on an integer value.
+std::wstring JSI_L10n::TranslatePlural(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring singularSourceString, std::wstring pluralSourceString, int number)
+{
+	return wstring_from_utf8(L10n::Instance().TranslatePlural(utf8_from_wstring(singularSourceString), utf8_from_wstring(pluralSourceString), number));
+}
+
+// Return a translated version of the given strings (singular and plural) depending on an integer value, for the specified context.
+std::wstring JSI_L10n::TranslatePluralWithContext(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string context, std::wstring singularSourceString, std::wstring pluralSourceString, int number)
+{
+	return wstring_from_utf8(L10n::Instance().TranslatePluralWithContext(context, utf8_from_wstring(singularSourceString), utf8_from_wstring(pluralSourceString), number));
+}
+
+// Return a translated version of the given string, localizing it line by line.
+std::wstring JSI_L10n::TranslateLines(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring sourceString)
+{
+	return wstring_from_utf8(L10n::Instance().TranslateLines(utf8_from_wstring(sourceString)));
+}
+
+// Return a translated version of the items in the specified array.
+std::vector<std::wstring> JSI_L10n::TranslateArray(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::vector<std::wstring> sourceArray)
+{
+	std::vector<std::wstring> translatedArray;
+	for (std::vector<std::wstring>::iterator iterator = sourceArray.begin(); iterator != sourceArray.end(); ++iterator)
+	{
+		translatedArray.push_back(wstring_from_utf8(L10n::Instance().Translate(utf8_from_wstring(*iterator))));
+	}
+	return translatedArray;
+}
+
+// Return a translated version of the given decimal number.
+std::wstring JSI_L10n::MarkToTranslate(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring sourceString)
+{
+	return sourceString;
+}
+
+// Return a localized version of a time given in milliseconds.
+std::wstring JSI_L10n::FormatMillisecondsIntoDateString(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), UDate milliseconds, std::wstring formatString)
+{
+	return wstring_from_utf8(L10n::Instance().FormatMillisecondsIntoDateString(milliseconds, utf8_from_wstring(formatString)));
+}
+
+// Return a localized version of the given decimal number.
+std::wstring JSI_L10n::FormatDecimalNumberIntoString(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), double number)
+{
+	return wstring_from_utf8(L10n::Instance().FormatDecimalNumberIntoString(number));
+}
+
+std::vector<std::string> JSI_L10n::GetSupportedLocaleBaseNames(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
+{
+	return L10n::Instance().GetSupportedLocaleBaseNames();
+}
+
+std::vector<std::wstring> JSI_L10n::GetSupportedLocaleDisplayNames(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
+{
+	return L10n::Instance().GetSupportedLocaleDisplayNames();
+}
+
+std::string JSI_L10n::GetCurrentLocale(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
+{
+	return L10n::Instance().GetCurrentLocaleString();
+}
+
+std::vector<std::string> JSI_L10n::GetAllLocales(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
+{
+	return L10n::Instance().GetAllLocales();
+}
+
+std::string JSI_L10n::GetDictionaryLocale(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string configLocale)
+{
+	return L10n::Instance().GetDictionaryLocale(configLocale);
+}
+
+std::vector<std::wstring> JSI_L10n::GetDictionariesForDictLocale(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string locale)
+{
+	return L10n::Instance().GetDictionariesForDictLocale(locale);
+}
+
+std::string JSI_L10n::GetLocaleLanguage(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string locale)
+{
+	return L10n::Instance().GetLocaleLanguage(locale);
+}
+
+std::string JSI_L10n::GetLocaleBaseName(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string locale)
+{
+	return L10n::Instance().GetLocaleBaseName(locale);
+}
+
+std::string JSI_L10n::GetLocaleCountry(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string locale)
+{
+	return L10n::Instance().GetLocaleCountry(locale);
+}
+
+std::string JSI_L10n::GetLocaleScript(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string locale)
+{
+	return L10n::Instance().GetLocaleScript(locale);
+}
+
+bool JSI_L10n::ValidateLocale(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string locale)
+{
+	return L10n::Instance().ValidateLocale(locale);
+}
+
+bool JSI_L10n::SaveLocale(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string locale)
+{
+	return L10n::Instance().SaveLocale(locale);
+}
+
+void JSI_L10n::ReevaluateCurrentLocaleAndReload(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
+{
+	L10n::Instance().ReevaluateCurrentLocaleAndReload();
+}
+
+
+void JSI_L10n::RegisterScriptFunctions(ScriptInterface& scriptInterface)
+{
+	scriptInterface.RegisterFunction<std::wstring, std::wstring, &Translate>("Translate");
+	scriptInterface.RegisterFunction<std::wstring, std::string, std::wstring, &TranslateWithContext>("TranslateWithContext");
+	scriptInterface.RegisterFunction<std::wstring, std::wstring, std::wstring, int, &TranslatePlural>("TranslatePlural");
+	scriptInterface.RegisterFunction<std::wstring, std::string, std::wstring, std::wstring, int, &TranslatePluralWithContext>("TranslatePluralWithContext");
+	scriptInterface.RegisterFunction<std::wstring, std::wstring, &TranslateLines>("TranslateLines");
+	scriptInterface.RegisterFunction<std::vector<std::wstring>, std::vector<std::wstring>, &TranslateArray>("TranslateArray");
+	scriptInterface.RegisterFunction<std::wstring, std::wstring, &MarkToTranslate>("MarkToTranslate");
+	scriptInterface.RegisterFunction<std::wstring, UDate, std::wstring, &FormatMillisecondsIntoDateString>("FormatMillisecondsIntoDateString");
+	scriptInterface.RegisterFunction<std::wstring, double, &FormatDecimalNumberIntoString>("FormatDecimalNumberIntoString");
+
+	scriptInterface.RegisterFunction<std::vector<std::string>, &GetSupportedLocaleBaseNames>("GetSupportedLocaleBaseNames");
+	scriptInterface.RegisterFunction<std::vector<std::wstring>, &GetSupportedLocaleDisplayNames>("GetSupportedLocaleDisplayNames");
+	scriptInterface.RegisterFunction<std::string, &GetCurrentLocale>("GetCurrentLocale");
+	scriptInterface.RegisterFunction<std::vector<std::string>, &GetAllLocales>("GetAllLocales");
+	scriptInterface.RegisterFunction<std::string, std::string, &GetDictionaryLocale>("GetDictionaryLocale");
+	scriptInterface.RegisterFunction<std::vector<std::wstring>, std::string, &GetDictionariesForDictLocale>("GetDictionariesForDictLocale");
+
+	scriptInterface.RegisterFunction<std::string, std::string, &GetLocaleLanguage>("GetLocaleLanguage");
+	scriptInterface.RegisterFunction<std::string, std::string, &GetLocaleBaseName>("GetLocaleBaseName");
+	scriptInterface.RegisterFunction<std::string, std::string, &GetLocaleCountry>("GetLocaleCountry");
+	scriptInterface.RegisterFunction<std::string, std::string, &GetLocaleScript>("GetLocaleScript");
+
+	scriptInterface.RegisterFunction<bool, std::string, &ValidateLocale>("ValidateLocale");
+	scriptInterface.RegisterFunction<bool, std::string, &SaveLocale>("SaveLocale");
+	scriptInterface.RegisterFunction<void, &ReevaluateCurrentLocaleAndReload>("ReevaluateCurrentLocaleAndReload");
+}

Property changes on: ps/trunk/source/i18n/scripting/JSInterface_L10n.cpp
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: ps/trunk/source/i18n/scripting/JSInterface_L10n.h
===================================================================
--- ps/trunk/source/i18n/scripting/JSInterface_L10n.h	(nonexistent)
+++ ps/trunk/source/i18n/scripting/JSInterface_L10n.h	(revision 14953)
@@ -0,0 +1,55 @@
+/* Copyright (C) 2014 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_JSINTERFACE_L10N
+#define INCLUDED_JSINTERFACE_L10N
+
+#include "scriptinterface/ScriptInterface.h"
+#include "lib/external_libraries/icu.h"
+
+namespace JSI_L10n
+{
+	void RegisterScriptFunctions(ScriptInterface& ScriptInterface);
+
+	std::wstring Translate(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring sourceString);
+	std::wstring TranslateWithContext(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string context, std::wstring sourceString);
+	std::wstring TranslatePlural(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring singularSourceString, std::wstring pluralSourceString, int number);
+	std::wstring TranslatePluralWithContext(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string context, std::wstring singularSourceString, std::wstring pluralSourceString, int number);
+	std::wstring TranslateLines(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring sourceString);
+	std::vector<std::wstring> TranslateArray(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::vector<std::wstring> sourceArray);
+	std::wstring MarkToTranslate(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring sourceString);
+	std::wstring FormatMillisecondsIntoDateString(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), UDate milliseconds, std::wstring formatString);
+	std::wstring FormatDecimalNumberIntoString(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), double number);
+
+	std::vector<std::string> GetSupportedLocaleBaseNames(ScriptInterface::CxPrivate* UNUSED(pCxPrivate));
+	std::vector<std::wstring> GetSupportedLocaleDisplayNames(ScriptInterface::CxPrivate* UNUSED(pCxPrivate));
+	std::string GetCurrentLocale(ScriptInterface::CxPrivate* UNUSED(pCxPrivate));
+	std::vector<std::string> GetAllLocales(ScriptInterface::CxPrivate* UNUSED(pCxPrivate));
+	std::string GetDictionaryLocale(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string configLocale);
+	std::vector<std::wstring> GetDictionariesForDictLocale(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string locale);
+
+	std::string GetLocaleLanguage(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string locale);
+	std::string GetLocaleBaseName(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string locale);
+	std::string GetLocaleCountry(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string locale);
+	std::string GetLocaleScript(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string locale);
+
+	bool ValidateLocale(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string locale);
+	bool SaveLocale(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string locale);
+	void ReevaluateCurrentLocaleAndReload(ScriptInterface::CxPrivate* UNUSED(pCxPrivate));
+}
+
+#endif

Property changes on: ps/trunk/source/i18n/scripting/JSInterface_L10n.h
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: ps/trunk/source/ps/GameSetup/GameSetup.cpp
===================================================================
--- ps/trunk/source/ps/GameSetup/GameSetup.cpp	(revision 14952)
+++ ps/trunk/source/ps/GameSetup/GameSetup.cpp	(revision 14953)
@@ -1,1323 +1,1338 @@
 /* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "lib/app_hooks.h"
 #include "lib/config2.h"
 #include "lib/input.h"
 #include "lib/ogl.h"
 #include "lib/timer.h"
 #include "lib/external_libraries/libsdl.h"
 #include "lib/file/common/file_stats.h"
 #include "lib/res/h_mgr.h"
 #include "lib/res/graphics/cursor.h"
 #include "lib/sysdep/cursor.h"
 #include "lib/sysdep/cpu.h"
 #include "lib/sysdep/gfx.h"
 #include "lib/sysdep/os_cpu.h"
 #include "lib/tex/tex.h"
 #if OS_WIN
 #include "lib/sysdep/os/win/wversion.h"
 #endif
 
 #include "graphics/CinemaTrack.h"
 #include "graphics/FontMetrics.h"
 #include "graphics/GameView.h"
 #include "graphics/LightEnv.h"
 #include "graphics/MapReader.h"
 #include "graphics/MaterialManager.h"
 #include "graphics/TerrainTextureManager.h"
 #include "gui/GUI.h"
 #include "gui/GUIManager.h"
 #include "gui/scripting/ScriptFunctions.h"
 #include "maths/MathUtil.h"
 #include "network/NetServer.h"
 #include "network/NetClient.h"
 
 #include "ps/CConsole.h"
 #include "ps/CLogger.h"
 #include "ps/ConfigDB.h"
 #include "ps/Filesystem.h"
 #include "ps/Game.h"
 #include "ps/GameSetup/Atlas.h"
 #include "ps/GameSetup/GameSetup.h"
 #include "ps/GameSetup/Paths.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/GameSetup/CmdLineArgs.h"
 #include "ps/GameSetup/HWDetect.h"
 #include "ps/Globals.h"
 #include "ps/Hotkey.h"
 #include "ps/Joystick.h"
 #include "ps/Loader.h"
 #include "ps/Overlay.h"
 #include "ps/Profile.h"
 #include "ps/ProfileViewer.h"
 #include "ps/Profiler2.h"
 #include "ps/Pyrogenesis.h"	// psSetLogDir
 #include "ps/SavedGame.h"
 #include "ps/scripting/JSInterface_Console.h"
 #include "ps/TouchInput.h"
 #include "ps/UserReport.h"
 #include "ps/Util.h"
 #include "ps/VideoMode.h"
 #include "ps/World.h"
 
 #include "renderer/Renderer.h"
 #include "renderer/VertexBufferManager.h"
 #include "renderer/ModelRenderer.h"
 #include "scriptinterface/DebuggingServer.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "scriptinterface/ScriptStats.h"
 #include "simulation2/Simulation2.h"
 #include "lobby/IXmppClient.h"
 #include "soundmanager/scripting/JSInterface_Sound.h"
 #include "soundmanager/ISoundManager.h"
 #include "tools/atlas/GameInterface/GameLoop.h"
 #include "tools/atlas/GameInterface/View.h"
 
 #if !(OS_WIN || OS_MACOSX || OS_ANDROID) // assume all other platforms use X11 for wxWidgets
 #define MUST_INIT_X11 1
 #include <X11/Xlib.h>
 #else
 #define MUST_INIT_X11 0
 #endif
 
 #if OS_WIN
 extern void wmi_Shutdown();
 #endif
 
 #include <iostream>
 
 ERROR_GROUP(System);
 ERROR_TYPE(System, SDLInitFailed);
 ERROR_TYPE(System, VmodeFailed);
 ERROR_TYPE(System, RequiredExtensionsMissing);
 
 bool g_DoRenderGui = true;
 bool g_DoRenderLogger = true;
 bool g_DoRenderCursor = true;
 
 shared_ptr<ScriptRuntime> g_ScriptRuntime;
 
 static const int SANE_TEX_QUALITY_DEFAULT = 5;	// keep in sync with code
 
+bool g_InDevelopmentCopy;
+bool g_CheckedIfInDevelopmentCopy = false;
+
 static void SetTextureQuality(int quality)
 {
 	int q_flags;
 	GLint filter;
 
 retry:
 	// keep this in sync with SANE_TEX_QUALITY_DEFAULT
 	switch(quality)
 	{
 		// worst quality
 	case 0:
 		q_flags = OGL_TEX_HALF_RES|OGL_TEX_HALF_BPP;
 		filter = GL_NEAREST;
 		break;
 		// [perf] add bilinear filtering
 	case 1:
 		q_flags = OGL_TEX_HALF_RES|OGL_TEX_HALF_BPP;
 		filter = GL_LINEAR;
 		break;
 		// [vmem] no longer reduce resolution
 	case 2:
 		q_flags = OGL_TEX_HALF_BPP;
 		filter = GL_LINEAR;
 		break;
 		// [vmem] add mipmaps
 	case 3:
 		q_flags = OGL_TEX_HALF_BPP;
 		filter = GL_NEAREST_MIPMAP_LINEAR;
 		break;
 		// [perf] better filtering
 	case 4:
 		q_flags = OGL_TEX_HALF_BPP;
 		filter = GL_LINEAR_MIPMAP_LINEAR;
 		break;
 		// [vmem] no longer reduce bpp
 	case SANE_TEX_QUALITY_DEFAULT:
 		q_flags = OGL_TEX_FULL_QUALITY;
 		filter = GL_LINEAR_MIPMAP_LINEAR;
 		break;
 		// [perf] add anisotropy
 	case 6:
 		// TODO: add anisotropic filtering
 		q_flags = OGL_TEX_FULL_QUALITY;
 		filter = GL_LINEAR_MIPMAP_LINEAR;
 		break;
 		// invalid
 	default:
 		debug_warn(L"SetTextureQuality: invalid quality");
 		quality = SANE_TEX_QUALITY_DEFAULT;
 		// careful: recursion doesn't work and we don't want to duplicate
 		// the "sane" default values.
 		goto retry;
 	}
 
 	ogl_tex_set_defaults(q_flags, filter);
 }
 
 
 //----------------------------------------------------------------------------
 // GUI integration
 //----------------------------------------------------------------------------
 
 // display progress / description in loading screen
 void GUI_DisplayLoadProgress(int percent, const wchar_t* pending_task)
 {
 	g_GUI->GetActiveGUI()->GetScriptInterface()->SetGlobal("g_Progress", percent, true);
 	g_GUI->GetActiveGUI()->GetScriptInterface()->SetGlobal("g_LoadDescription", pending_task, true);
 	g_GUI->GetActiveGUI()->SendEventToAll("progress");
 }
 
 
 
 void Render()
 {
 	PROFILE3("render");
 
 	if (g_SoundManager)
 		g_SoundManager->IdleTask();
 
 	ogl_WarnIfError();
 
 	g_Profiler2.RecordGPUFrameStart();
 
 	ogl_WarnIfError();
 
 	// prepare before starting the renderer frame
 	if (g_Game && g_Game->IsGameStarted())
 		g_Game->GetView()->BeginFrame();
 
 	if (g_Game)
 		g_Renderer.SetSimulation(g_Game->GetSimulation2());
 
 	// start new frame
 	g_Renderer.BeginFrame();
 
 	ogl_WarnIfError();
 
 	if (g_Game && g_Game->IsGameStarted())
 		g_Game->GetView()->Render();
 
 	ogl_WarnIfError();
 
 	g_Renderer.RenderTextOverlays();
 
 	if (g_DoRenderGui)
 		g_GUI->Draw();
 
 	ogl_WarnIfError();
 
 	// If we're in Atlas game view, render special overlays (e.g. editor bandbox)
 	if (g_AtlasGameLoop && g_AtlasGameLoop->view)
 	{
 		g_AtlasGameLoop->view->DrawOverlays();
 		ogl_WarnIfError();
 	}
 
 	// Text:
 
  	glDisable(GL_DEPTH_TEST);
 
 	g_Console->Render();
 
 	ogl_WarnIfError();
 
 	if (g_DoRenderLogger)
 		g_Logger->Render();
 
 	ogl_WarnIfError();
 
 	// Profile information
 
 	g_ProfileViewer.RenderProfile();
 
 	ogl_WarnIfError();
 
 	// Draw the cursor (or set the Windows cursor, on Windows)
 	if (g_DoRenderCursor)
 	{
 		PROFILE3_GPU("cursor");
 		CStrW cursorName = g_CursorName;
 		if (cursorName.empty())
 		{
 			cursor_draw(g_VFS, NULL, g_mouse_x, g_yres-g_mouse_y, false);
 		}
 		else
 		{
 			bool forceGL = false;
 			CFG_GET_VAL("nohwcursor", Bool, forceGL);
 
 #if CONFIG2_GLES
 #warning TODO: implement cursors for GLES
 #else
 			// set up transform for GL cursor
 			glMatrixMode(GL_PROJECTION);
 			glPushMatrix();
 			glLoadIdentity();
 			glMatrixMode(GL_MODELVIEW);
 			glPushMatrix();
 			glLoadIdentity();
 			CMatrix3D transform;
 			transform.SetOrtho(0.f, (float)g_xres, 0.f, (float)g_yres, -1.f, 1000.f);
 			glLoadMatrixf(&transform._11);
 #endif
 
 #if OS_ANDROID
 #warning TODO: cursors for Android
 #else
 			if (cursor_draw(g_VFS, cursorName.c_str(), g_mouse_x, g_yres-g_mouse_y, forceGL) < 0)
 				LOGWARNING(L"Failed to draw cursor '%ls'", cursorName.c_str());
 #endif
 
 #if CONFIG2_GLES
 #warning TODO: implement cursors for GLES
 #else
 			// restore transform
 			glMatrixMode(GL_PROJECTION);
 			glPopMatrix();
 			glMatrixMode(GL_MODELVIEW);
 			glPopMatrix();
 #endif
 		}
 	}
 
 	glEnable(GL_DEPTH_TEST);
 
 	g_Renderer.EndFrame();
 
 	PROFILE2_ATTR("draw calls: %d", (int)g_Renderer.GetStats().m_DrawCalls);
 	PROFILE2_ATTR("terrain tris: %d", (int)g_Renderer.GetStats().m_TerrainTris);
 	PROFILE2_ATTR("water tris: %d", (int)g_Renderer.GetStats().m_WaterTris);
 	PROFILE2_ATTR("model tris: %d", (int)g_Renderer.GetStats().m_ModelTris);
 	PROFILE2_ATTR("overlay tris: %d", (int)g_Renderer.GetStats().m_OverlayTris);
 	PROFILE2_ATTR("blend splats: %d", (int)g_Renderer.GetStats().m_BlendSplats);
 	PROFILE2_ATTR("particles: %d", (int)g_Renderer.GetStats().m_Particles);
 
 	ogl_WarnIfError();
 
 	g_Profiler2.RecordGPUFrameEnd();
 
 	ogl_WarnIfError();
 }
 
 
 static size_t OperatingSystemFootprint()
 {
 #if OS_WIN
 	switch(wversion_Number())
 	{
 	case WVERSION_2K:
 	case WVERSION_XP:
 		return 150;
 	case WVERSION_XP64:
 		return 200;
 	default:	// newer Windows version: assume the worst, and don't warn
 	case WVERSION_VISTA:
 		return 300;
 	case WVERSION_7:
 		return 250;
 	}
 #else
 	return 200;
 #endif
 }
 
 static size_t ChooseCacheSize()
 {
 	// (all sizes in MiB and signed to allow temporarily negative computations)
 
 	const ssize_t total = (ssize_t)os_cpu_MemorySize();
 	// (NB: os_cpu_MemoryAvailable is useless on Linux because free memory
 	// is marked as "in use" by OS caches.)
 	const ssize_t os = (ssize_t)OperatingSystemFootprint();
 	const ssize_t game = 300;	// estimated working set
 
 	ssize_t cache = 500;	// upper bound: total size of our data
 
 	// the cache reserves contiguous address space, which is a precious
 	// resource on 32-bit systems, so don't use too much:
 	if(ARCH_IA32 || sizeof(void*) == 4)
 		cache = std::min(cache, (ssize_t)200);
 
 	// try to leave over enough memory for the OS and game
 	cache = std::min(cache, total-os-game);
 
 	// always provide at least this much to ensure correct operation
 	cache = std::max(cache, (ssize_t)64);
 
 	debug_printf(L"Cache: %d (total: %d) MiB\n", (int)cache, (int)total);
 	return size_t(cache)*MiB;
 }
 
 
 ErrorReactionInternal psDisplayError(const wchar_t* UNUSED(text), size_t UNUSED(flags))
 {
 	// If we're fullscreen, then sometimes (at least on some particular drivers on Linux)
 	// displaying the error dialog hangs the desktop since the dialog box is behind the
 	// fullscreen window. So we just force the game to windowed mode before displaying the dialog.
 	// (But only if we're in the main thread, and not if we're being reentrant.)
 	if (ThreadUtil::IsMainThread())
 	{
 		static bool reentering = false;
 		if (!reentering)
 		{
 			reentering = true;
 			g_VideoMode.SetFullscreen(false);
 			reentering = false;
 		}
 	}
 
 	// We don't actually implement the error display here, so return appropriately
 	return ERI_NOT_IMPLEMENTED;
 }
 
-static std::vector<CStr> GetMods(const CmdLineArgs& args, bool dev)
+static std::vector<CStr> GetMods(const CmdLineArgs& args)
 {
 	std::vector<CStr> mods = args.GetMultiple("mod");
 	// List of the mods, to be used by the Gui
 	g_modsLoaded.clear();
 	for (size_t i = 0; i < mods.size(); ++i)
 		g_modsLoaded.push_back((std::string)mods[i]);
 	// TODO: It would be nice to remove this hard-coding
 	mods.insert(mods.begin(), "public");
 
 	// Add the user mod if not explicitly disabled or we have a dev copy so
 	// that saved files end up in version control and not in the user mod.
-	if (!dev && !args.Has("noUserMod"))
+	if (!InDevelopmentCopy() && !args.Has("noUserMod"))
 		mods.push_back("user");
 
 	return mods;
 }
 
 static void InitVfs(const CmdLineArgs& args, int flags)
 {
 	TIMER(L"InitVfs");
 
 	const bool setup_error = (flags & INIT_HAVE_DISPLAY_ERROR) == 0;
 
 	const Paths paths(args);
 
 	OsPath logs(paths.Logs());
 	CreateDirectories(logs, 0700);
 
 	psSetLogDir(logs);
 	// desired location for crashlog is now known. update AppHooks ASAP
 	// (particularly before the following error-prone operations):
 	AppHooks hooks = {0};
 	hooks.bundle_logs = psBundleLogs;
 	hooks.get_log_dir = psLogDir;
 	if (setup_error)
 		hooks.display_error = psDisplayError;
 	app_hooks_update(&hooks);
 
 	const size_t cacheSize = ChooseCacheSize();
 	g_VFS = CreateVfs(cacheSize);
 	
 	// Work out whether we are a dev version to make sure saved files
 	// (maps, etc) end up in version control.
 	const OsPath readonlyConfig = paths.RData()/"config"/"";
 	g_VFS->Mount(L"config/", readonlyConfig);
-	bool dev = (g_VFS->GetFileInfo(L"config/dev.cfg", NULL) == INFO::OK);
 
-	const std::vector<CStr> mods = GetMods(args, dev);
+	// Engine localization files.
+	g_VFS->Mount(L"l10n/", paths.RData()/"l10n"/"");
+
+	const std::vector<CStr> mods = GetMods(args);
 
 	OsPath modPath = paths.RData()/"mods";
 	OsPath modUserPath = paths.UserData()/"mods";
 	for (size_t i = 0; i < mods.size(); ++i)
 	{
 		size_t priority = (i+1)*2;	// mods are higher priority than regular mountings, which default to priority 0
 		size_t userFlags = VFS_MOUNT_WATCH|VFS_MOUNT_ARCHIVABLE|VFS_MOUNT_REPLACEABLE;
 		size_t baseFlags = userFlags|VFS_MOUNT_MUST_EXIST;
 		
 		OsPath modName(mods[i]);
-		if (dev)
+		if (InDevelopmentCopy())
 		{
 			// We are running a dev copy, so only mount mods in the user mod path
 			// if the mod does not exist in the data path.
 			if (DirectoryExists(modPath / modName/""))
 				g_VFS->Mount(L"", modPath / modName/"", baseFlags, priority);
 			else
 				g_VFS->Mount(L"", modUserPath / modName/"", userFlags, priority);
 		}
 		else
 		{
 			g_VFS->Mount(L"", modPath / modName/"", baseFlags, priority);
 			// Ensure that user modified files are loaded, if they are present
 			g_VFS->Mount(L"", modUserPath / modName/"", userFlags, priority+1);
 		}
 	}
 
 	// We mount these dirs last as otherwise writing could result in files being placed in a mod's dir.
 	g_VFS->Mount(L"screenshots/", paths.UserData()/"screenshots"/"");
 	g_VFS->Mount(L"saves/", paths.UserData()/"saves"/"", VFS_MOUNT_WATCH);
 	// Mounting with highest priority, so that a mod supplied user.cfg is harmless
 	g_VFS->Mount(L"config/", readonlyConfig, 0, (size_t)-1);
 	if(readonlyConfig != paths.Config())
 		g_VFS->Mount(L"config/", paths.Config(), 0, (size_t)-1);
 
 	g_VFS->Mount(L"cache/", paths.Cache(), VFS_MOUNT_ARCHIVABLE);	// (adding XMBs to archive speeds up subsequent reads)
 
 	// note: don't bother with g_VFS->TextRepresentation - directories
 	// haven't yet been populated and are empty.
 }
 
 
 static void InitPs(bool setup_gui, const CStrW& gui_page, ScriptInterface* srcScriptInterface, CScriptVal initData)
 {
 	{
 		// console
 		TIMER(L"ps_console");
 
 		g_Console->UpdateScreenSize(g_xres, g_yres);
 
 		// Calculate and store the line spacing
 		CFontMetrics font(CStrIntern(CONSOLE_FONT));
 		g_Console->m_iFontHeight = font.GetLineSpacing();
 		g_Console->m_iFontWidth = font.GetCharacterWidth(L'C');
 		g_Console->m_charsPerPage = (size_t)(g_xres / g_Console->m_iFontWidth);
 		// Offset by an arbitrary amount, to make it fit more nicely
 		g_Console->m_iFontOffset = 7;
 
 		double blinkRate = 0.5;
 		CFG_GET_VAL("gui.cursorblinkrate", Double, blinkRate);
 		g_Console->SetCursorBlinkRate(blinkRate);
 	}
 
 	// hotkeys
 	{
 		TIMER(L"ps_lang_hotkeys");
 		LoadHotkeys();
 	}
 
 	if (!setup_gui)
 	{
 		// We do actually need *some* kind of GUI loaded, so use the
 		// (currently empty) Atlas one
 		g_GUI->SwitchPage(L"page_atlas.xml", srcScriptInterface, initData);
 		return;
 	}
 
 	// GUI uses VFS, so this must come after VFS init.
 	g_GUI->SwitchPage(gui_page, srcScriptInterface, initData);
 }
 
 
 static void InitInput()
 {
 #if !SDL_VERSION_ATLEAST(2, 0, 0)
 	SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
 #endif
 
 	g_Joystick.Initialise();
 
 	// register input handlers
 	// This stack is constructed so the first added, will be the last
 	//  one called. This is important, because each of the handlers
 	//  has the potential to block events to go further down
 	//  in the chain. I.e. the last one in the list added, is the
 	//  only handler that can block all messages before they are
 	//  processed.
 	in_add_handler(game_view_handler);
 
 	in_add_handler(CProfileViewer::InputThunk);
 
 	in_add_handler(conInputHandler);
 
 	in_add_handler(HotkeyInputHandler);
 
 	// gui_handler needs to be registered after (i.e. called before!) the
 	// hotkey handler so that input boxes can be typed in without
 	// setting off hotkeys.
 	in_add_handler(gui_handler);
 
 	in_add_handler(touch_input_handler);
 
 	// must be registered after (called before) the GUI which relies on these globals
 	in_add_handler(GlobalsInputHandler);
 }
 
 
 static void ShutdownPs()
 {
 	SAFE_DELETE(g_GUI);
 
 	SAFE_DELETE(g_Console);
 	
 	// This is needed to ensure that no callbacks from the JSAPI try to use 
 	// the profiler when it's already destructed
 	g_ScriptRuntime.reset();
 
 	// disable the special Windows cursor, or free textures for OGL cursors
 	cursor_draw(g_VFS, 0, g_mouse_x, g_yres-g_mouse_y, false);
 }
 
 
 static void InitRenderer()
 {
 	TIMER(L"InitRenderer");
 
 	if(g_NoGLS3TC)
 		ogl_tex_override(OGL_TEX_S3TC, OGL_TEX_DISABLE);
 	if(g_NoGLAutoMipmap)
 		ogl_tex_override(OGL_TEX_AUTO_MIPMAP_GEN, OGL_TEX_DISABLE);
 
 	// create renderer
 	new CRenderer;
 
 	// set renderer options from command line options - NOVBO must be set before opening the renderer
 	g_Renderer.SetOptionBool(CRenderer::OPT_NOVBO, g_NoGLVBO);
 	g_Renderer.SetOptionBool(CRenderer::OPT_SHADOWS, g_Shadows);
 
 	g_Renderer.SetOptionBool(CRenderer::OPT_WATERNORMAL, g_WaterNormal);
 	g_Renderer.SetOptionBool(CRenderer::OPT_WATERREALDEPTH, g_WaterRealDepth);
 	g_Renderer.SetOptionBool(CRenderer::OPT_WATERFOAM, g_WaterFoam);
 	g_Renderer.SetOptionBool(CRenderer::OPT_WATERCOASTALWAVES, g_WaterCoastalWaves);
 	g_Renderer.SetOptionBool(CRenderer::OPT_WATERREFLECTION, g_WaterReflection);
 	g_Renderer.SetOptionBool(CRenderer::OPT_WATERREFRACTION, g_WaterRefraction);
 	g_Renderer.SetOptionBool(CRenderer::OPT_WATERSHADOW, g_WaterShadows);
 	
 	g_Renderer.SetRenderPath(CRenderer::GetRenderPathByName(g_RenderPath));
 	g_Renderer.SetOptionBool(CRenderer::OPT_SHADOWPCF, g_ShadowPCF);
 	g_Renderer.SetOptionBool(CRenderer::OPT_PARTICLES, g_Particles);
 	g_Renderer.SetOptionBool(CRenderer::OPT_SILHOUETTES, g_Silhouettes);
 	g_Renderer.SetOptionBool(CRenderer::OPT_SHOWSKY, g_ShowSky);
 
 	// create terrain related stuff
 	new CTerrainTextureManager;
 
 	g_Renderer.Open(g_xres, g_yres);
 
 	// Setup lighting environment. Since the Renderer accesses the
 	// lighting environment through a pointer, this has to be done before
 	// the first Frame.
 	g_Renderer.SetLightEnv(&g_LightEnv);
 
 	// I haven't seen the camera affecting GUI rendering and such, but the
 	// viewport has to be updated according to the video mode
 	SViewPort vp;
 	vp.m_X = 0;
 	vp.m_Y = 0;
 	vp.m_Width = g_xres;
 	vp.m_Height = g_yres;
 	g_Renderer.SetViewport(vp);
 
 	ColorActivateFastImpl();
 	ModelRenderer::Init();
 }
 
 static void InitSDL()
 {
 #if OS_LINUX
 	// In fullscreen mode when SDL is compiled with DGA support, the mouse
 	// sensitivity often appears to be unusably wrong (typically too low).
 	// (This seems to be reported almost exclusively on Ubuntu, but can be
 	// reproduced on Gentoo after explicitly enabling DGA.)
 	// Disabling the DGA mouse appears to fix that problem, and doesn't
 	// have any obvious negative effects.
 	setenv("SDL_VIDEO_X11_DGAMOUSE", "0", 0);
 #endif
 
 	if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER|SDL_INIT_NOPARACHUTE) < 0)
 	{
 		LOGERROR(L"SDL library initialization failed: %hs", SDL_GetError());
 		throw PSERROR_System_SDLInitFailed();
 	}
 	atexit(SDL_Quit);
 
 #if SDL_VERSION_ATLEAST(2, 0, 0)
 	SDL_StartTextInput();
 #else
 	SDL_EnableUNICODE(1);
 #endif
 }
 
 static void ShutdownSDL()
 {
 	SDL_Quit();
 	sys_cursor_reset();
 }
 
 
 void EndGame()
 {
 	SAFE_DELETE(g_NetClient);
 	SAFE_DELETE(g_NetServer);
 	SAFE_DELETE(g_Game);
 
 	ISoundManager::CloseGame();
 }
 
 
 void Shutdown(int UNUSED(flags))
 {
 	EndGame();
 
 	SAFE_DELETE(g_XmppClient);
 
 	ShutdownPs();
 
 	in_reset_handlers();
 
 	TIMER_BEGIN(L"shutdown TexMan");
 	delete &g_TexMan;
 	TIMER_END(L"shutdown TexMan");
 
 	// destroy renderer
 	TIMER_BEGIN(L"shutdown Renderer");
 	delete &g_Renderer;
 	g_VBMan.Shutdown();
 	TIMER_END(L"shutdown Renderer");
 
 	g_Profiler2.ShutdownGPU();
 
 	// Free cursors before shutting down SDL, as they may depend on SDL.
 	cursor_shutdown();
 
 	TIMER_BEGIN(L"shutdown SDL");
 	ShutdownSDL();
 	TIMER_END(L"shutdown SDL");
 
 	g_VideoMode.Shutdown();
 
 	TIMER_BEGIN(L"shutdown UserReporter");
 	g_UserReporter.Deinitialize();
 	TIMER_END(L"shutdown UserReporter");
 
 	// JS debugger temporarily disabled during the SpiderMonkey upgrade (check trac ticket #2348 for details)
 	//TIMER_BEGIN(L"shutdown DebuggingServer (if active)");
 	//delete g_DebuggingServer;
 	//TIMER_END(L"shutdown DebuggingServer (if active)");
 
 	TIMER_BEGIN(L"shutdown ConfigDB");
 	delete &g_ConfigDB;
 	TIMER_END(L"shutdown ConfigDB");
 
 	// resource
 	// first shut down all resource owners, and then the handle manager.
 	TIMER_BEGIN(L"resource modules");
 
 		ISoundManager::SetEnabled(false);
 
 		g_VFS.reset();
 
 		// this forcibly frees all open handles (thus preventing real leaks),
 		// and makes further access to h_mgr impossible.
 		h_mgr_shutdown();
 
 		file_stats_dump();
 
 	TIMER_END(L"resource modules");
 
 	TIMER_BEGIN(L"shutdown misc");
 		timer_DisplayClientTotals();
 
 		CNetHost::Deinitialize();
 
 		SAFE_DELETE(g_ScriptStatsTable);
 
 		// should be last, since the above use them
 		SAFE_DELETE(g_Logger);
 		delete &g_Profiler;
 		delete &g_ProfileViewer;
 	TIMER_END(L"shutdown misc");
 
 #if OS_WIN
 	TIMER_BEGIN(L"shutdown wmi");
 	wmi_Shutdown();
 	TIMER_END(L"shutdown wmi");
 #endif
 }
 
 #if OS_UNIX
 static void FixLocales()
 {
 #if OS_MACOSX || OS_BSD
 	// OS X requires a UTF-8 locale in LC_CTYPE so that *wprintf can handle
 	// wide characters. Peculiarly the string "UTF-8" seems to be acceptable
 	// despite not being a real locale, and it's conveniently language-agnostic,
 	// so use that.
 	setlocale(LC_CTYPE, "UTF-8");
 #endif
 
 
 	// On misconfigured systems with incorrect locale settings, we'll die
 	// with a C++ exception when some code (e.g. Boost) tries to use locales.
 	// To avoid death, we'll detect the problem here and warn the user and
 	// reset to the default C locale.
 
 
 	// For informing the user of the problem, use the list of env vars that
 	// glibc setlocale looks at. (LC_ALL is checked first, and LANG last.)
 	const char* const LocaleEnvVars[] = {
 		"LC_ALL",
 		"LC_COLLATE",
 		"LC_CTYPE",
 		"LC_MONETARY",
 		"LC_NUMERIC",
 		"LC_TIME",
 		"LC_MESSAGES",
 		"LANG"
 	};
 
 	try
 	{
 		// this constructor is similar to setlocale(LC_ALL, ""),
 		// but instead of returning NULL, it throws runtime_error
 		// when the first locale env variable found contains an invalid value
 		std::locale("");
 	}
 	catch (std::runtime_error&)
 	{
 		LOGWARNING(L"Invalid locale settings");
 
 		for (size_t i = 0; i < ARRAY_SIZE(LocaleEnvVars); i++)
 		{
 			if (char* envval = getenv(LocaleEnvVars[i]))
 				LOGWARNING(L"  %hs=\"%hs\"", LocaleEnvVars[i], envval);
 			else
 				LOGWARNING(L"  %hs=\"(unset)\"", LocaleEnvVars[i]);
 		}
 
 		// We should set LC_ALL since it overrides LANG
 		if (setenv("LC_ALL", std::locale::classic().name().c_str(), 1))
 			debug_warn(L"Invalid locale settings, and unable to set LC_ALL env variable.");
 		else
 			LOGWARNING(L"Setting LC_ALL env variable to: %hs", getenv("LC_ALL"));
 	}
 }
 #else
 static void FixLocales()
 {
 	// Do nothing on Windows
 }
 #endif
 
 void EarlyInit()
 {
 	// If you ever want to catch a particular allocation:
 	//_CrtSetBreakAlloc(232647);
 
 	ThreadUtil::SetMainThread();
 
 	debug_SetThreadName("main");
 	// add all debug_printf "tags" that we are interested in:
 	debug_filter_add(L"TIMER");
 
 	timer_LatchStartTime();
 
 	// initialise profiler early so it can profile startup,
 	// but only after LatchStartTime
 	g_Profiler2.Initialise();
 
 	FixLocales();
 
 	// Because we do GL calls from a secondary thread, Xlib needs to
 	// be told to support multiple threads safely.
 	// This is needed for Atlas, but we have to call it before any other
 	// Xlib functions (e.g. the ones used when drawing the main menu
 	// before launching Atlas)
 #if MUST_INIT_X11
 	int status = XInitThreads();
 	if (status == 0)
 		debug_printf(L"Error enabling thread-safety via XInitThreads\n");
 #endif
 
 	// Initialise the low-quality rand function
 	srand(time(NULL));	// NOTE: this rand should *not* be used for simulation!
 }
 
 bool Autostart(const CmdLineArgs& args);
 
 void Init(const CmdLineArgs& args, int flags)
 {
 	h_mgr_init();
 
 	// Do this as soon as possible, because it chdirs
 	// and will mess up the error reporting if anything
 	// crashes before the working directory is set.
 	InitVfs(args, flags);
 
 	// This must come after VFS init, which sets the current directory
 	// (required for finding our output log files).
 	g_Logger = new CLogger;
 	
 	// Workaround until Simulation and AI use their own threads and also their own runtimes
 	g_ScriptRuntime = ScriptInterface::CreateRuntime(384 * 1024 * 1024);
 
 	// Special command-line mode to dump the entity schemas instead of running the game.
 	// (This must be done after loading VFS etc, but should be done before wasting time
 	// on anything else.)
 	if (args.Has("dumpSchema"))
 	{
 		CSimulation2 sim(NULL, g_ScriptRuntime, NULL);
 		sim.LoadDefaultScripts();
 		std::ofstream f("entity.rng", std::ios_base::out | std::ios_base::trunc);
 		f << sim.GenerateSchema();
 		std::cout << "Generated entity.rng\n";
 		exit(0);
 	}
 
 	// override ah_translate with our i18n code.
 	AppHooks hooks = {0};
 	hooks.translate = psTranslate;
 	hooks.translate_free = psTranslateFree;
 	app_hooks_update(&hooks);
 
 	// Set up the console early, so that debugging
 	// messages can be logged to it. (The console's size
 	// and fonts are set later in InitPs())
 	g_Console = new CConsole();
 
 	CNetHost::Initialize();
 
 	new CProfileViewer;
 	new CProfileManager;	// before any script code
 
 	g_ScriptStatsTable = new CScriptStatsTable;
 	g_ProfileViewer.AddRootTable(g_ScriptStatsTable);
 
 
 #if CONFIG2_AUDIO
 	ISoundManager::CreateSoundManager();
 #endif
 
 	// g_ConfigDB, command line args, globals
 	CONFIG_Init(args);
 
 	// before scripting 
 	// JS debugger temporarily disabled during the SpiderMonkey upgrade (check trac ticket #2348 for details)
 	//if (g_JSDebuggerEnabled)
 	//	g_DebuggingServer = new CDebuggingServer();
 
 	// Optionally start profiler HTTP output automatically
 	// (By default it's only enabled by a hotkey, for security/performance)
 	bool profilerHTTPEnable = false;
 	CFG_GET_VAL("profiler2.http.autoenable", Bool, profilerHTTPEnable);
 	if (profilerHTTPEnable)
 		g_Profiler2.EnableHTTP();
 
 	if (!g_Quickstart)
 		g_UserReporter.Initialize(); // after config
 
 	PROFILE2_EVENT("Init finished");
 }
 
 void InitGraphics(const CmdLineArgs& args, int flags)
 {
 	const bool setup_vmode = (flags & INIT_HAVE_VMODE) == 0;
 
 	if(setup_vmode)
 	{
 		InitSDL();
 
 		if (!g_VideoMode.InitSDL())
 			throw PSERROR_System_VmodeFailed(); // abort startup
 
 #if !SDL_VERSION_ATLEAST(2, 0, 0)
 		SDL_WM_SetCaption("0 A.D.", "0 A.D.");
 #endif
 	}
 
 	RunHardwareDetection();
 
 	const int quality = SANE_TEX_QUALITY_DEFAULT;	// TODO: set value from config file
 	SetTextureQuality(quality);
 
 	ogl_WarnIfError();
 
 	// Optionally start profiler GPU timings automatically
 	// (By default it's only enabled by a hotkey, for performance/compatibility)
 	bool profilerGPUEnable = false;
 	CFG_GET_VAL("profiler2.gpu.autoenable", Bool, profilerGPUEnable);
 	if (profilerGPUEnable)
 		g_Profiler2.EnableGPU();
 
 	if(!g_Quickstart)
 	{
 		WriteSystemInfo();
 		// note: no longer vfs_display here. it's dog-slow due to unbuffered
 		// file output and very rarely needed.
 	}
 
 	if(g_DisableAudio)
 		ISoundManager::SetEnabled(false);
 
 	g_GUI = new CGUIManager();
 
 	// (must come after SetVideoMode, since it calls ogl_Init)
 	if (ogl_HaveExtensions(0, "GL_ARB_vertex_program", "GL_ARB_fragment_program", NULL) != 0 // ARB
 		&& ogl_HaveExtensions(0, "GL_ARB_vertex_shader", "GL_ARB_fragment_shader", NULL) != 0) // GLSL
 	{
 		DEBUG_DISPLAY_ERROR(
 			L"Your graphics card doesn't appear to be fully compatible with OpenGL shaders."
 			L" In the future, the game will not support pre-shader graphics cards."
 			L" You are advised to try installing newer drivers and/or upgrade your graphics card."
 			L" For more information, please see http://www.wildfiregames.com/forum/index.php?showtopic=16734"
 		);
 		// TODO: actually quit once fixed function support is dropped
 	}
 
 	const char* missing = ogl_HaveExtensions(0,
 		"GL_ARB_multitexture",
 		"GL_EXT_draw_range_elements",
 		"GL_ARB_texture_env_combine",
 		"GL_ARB_texture_env_dot3",
 		NULL);
 	if(missing)
 	{
 		wchar_t buf[500];
 		swprintf_s(buf, ARRAY_SIZE(buf),
 			L"The %hs extension doesn't appear to be available on your computer."
 			L" The game may still work, though - you are welcome to try at your own risk."
 			L" If not or it doesn't look right, upgrade your graphics card.",
 			missing
 		);
 		DEBUG_DISPLAY_ERROR(buf);
 		// TODO: i18n
 	}
 
 	if (!ogl_HaveExtension("GL_ARB_texture_env_crossbar"))
 	{
 		DEBUG_DISPLAY_ERROR(
 			L"The GL_ARB_texture_env_crossbar extension doesn't appear to be available on your computer."
 			L" Shadows are not available and overall graphics quality might suffer."
 			L" You are advised to try installing newer drivers and/or upgrade your graphics card.");
 		g_Shadows = false;
 	}
 
 	ogl_WarnIfError();
 	InitRenderer();
 
 	InitInput();
 
 	ogl_WarnIfError();
 
 	try
 	{
 		if (!Autostart(args))
 		{
 			const bool setup_gui = ((flags & INIT_NO_GUI) == 0);
 			// We only want to display the splash screen at startup
 			CScriptValRooted data;
 			if (g_GUI)
 			{
 				shared_ptr<ScriptInterface> scriptInterface = g_GUI->GetScriptInterface();
 				scriptInterface->Eval("({})", data);
 				scriptInterface->SetProperty(data.get(), "isStartup", true);
 			}
 			InitPs(setup_gui, L"page_pregame.xml", g_GUI->GetScriptInterface().get(), data.get());
 		}
 	}
 	catch (PSERROR_Game_World_MapLoadFailed& e)
 	{
 		// Map Loading failed
 
 		// Start the engine so we have a GUI
 		InitPs(true, L"page_pregame.xml", NULL, JSVAL_VOID);
 
 		// Call script function to do the actual work
 		//	(delete game data, switch GUI page, show error, etc.)
 		CancelLoad(CStr(e.what()).FromUTF8());
 	}
 }
 
 void RenderGui(bool RenderingState)
 {
 	g_DoRenderGui = RenderingState;
 }
 
 void RenderLogger(bool RenderingState)
 {
 	g_DoRenderLogger = RenderingState;
 }
 
 void RenderCursor(bool RenderingState)
 {
 	g_DoRenderCursor = RenderingState;
 }
 
 bool Autostart(const CmdLineArgs& args)
 {
 	/*
 	 * Handle various command-line options, for quick testing of various features:
 	 * -autostart=name					-- map name for scenario, or rms name for random map
 	 * -autostart-ai=1:dummybot			-- adds the dummybot AI to player 1
 	 * -autostart-playername=name		-- multiplayer player name
 	 * -autostart-host					-- multiplayer host mode
 	 * -autostart-players=2				-- number of players
 	 * -autostart-client				-- multiplayer client mode
 	 * -autostart-ip=127.0.0.1			-- multiplayer connect to 127.0.0.1
 	 * -autostart-random=104			-- random map, optional seed value = 104 (default is 0, random is -1)
 	 * -autostart-size=192				-- random map size in tiles = 192 (default is 192)
 	 * -autostart-civ=1:hele			-- set player #1 civ to "hele"
 	 *
 	 * Examples:
 	 * -autostart=Acropolis -autostart-host -autostart-players=2		-- Host game on Acropolis map, 2 players
 	 * -autostart=latium -autostart-random=-1							-- Start single player game on latium random map, random rng seed
 	 */
 
 	CStr autoStartName = args.Get("autostart");
 
 #if OS_ANDROID
 	// HACK: currently the most convenient way to test maps on Android;
 	// should find a better solution
 	autoStartName = "Oasis";
 #endif
 
 	if (autoStartName.empty())
 	{
 		return false;
 	}
 
 	g_Game = new CGame();
 
 	ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
 
 	CScriptValRooted attrs;
 	scriptInterface.Eval("({})", attrs);
 	CScriptVal settings;
 	scriptInterface.Eval("({})", settings);
 	CScriptVal playerData;
 	scriptInterface.Eval("([])", playerData);
 
 	// Set different attributes for random or scenario game
 	if (args.Has("autostart-random"))
 	{
 		CStr seedArg = args.Get("autostart-random");
 
 		// Default seed is 0
 		u32 seed = 0;
 		if (!seedArg.empty())
 		{
 			if (seedArg.compare("-1") == 0)
 			{	// Random seed value
 				seed = rand();
 			}
 			else
 			{
 				seed = seedArg.ToULong();
 			}
 		}
 		
 		// Random map definition will be loaded from JSON file, so we need to parse it
 		std::wstring scriptPath = L"maps/random/" + autoStartName.FromUTF8() + L".json";
 		CScriptValRooted scriptData = scriptInterface.ReadJSONFile(scriptPath);
 		if (!scriptData.undefined() && scriptInterface.GetProperty(scriptData.get(), "settings", settings))
 		{
 			// JSON loaded ok - copy script name over to game attributes
 			std::wstring scriptFile;
 			scriptInterface.GetProperty(settings.get(), "Script", scriptFile);
 			scriptInterface.SetProperty(attrs.get(), "script", scriptFile);				// RMS filename
 		}
 		else
 		{
 			// Problem with JSON file
 			LOGERROR(L"Error reading random map script '%ls'", scriptPath.c_str());
 			throw PSERROR_Game_World_MapLoadFailed("Error reading random map script.\nCheck application log for details.");
 		}
 
 		// Get optional map size argument (default 192)
 		uint mapSize = 192;
 		if (args.Has("autostart-size"))
 		{
 			CStr size = args.Get("autostart-size");
 			mapSize = size.ToUInt();
 		}
 
 		scriptInterface.SetProperty(attrs.get(), "map", std::string(autoStartName));
 		scriptInterface.SetProperty(attrs.get(), "mapType", std::string("random"));
 		scriptInterface.SetProperty(settings.get(), "Seed", seed);									// Random seed
 		scriptInterface.SetProperty(settings.get(), "Size", mapSize);								// Random map size (in patches)
 
 		// Get optional number of players (default 2)
 		size_t numPlayers = 2;
 		if (args.Has("autostart-players"))
 		{
 			CStr num = args.Get("autostart-players");
 			numPlayers = num.ToUInt();
 		}
 
 		// Set up player data
 		for (size_t i = 0; i < numPlayers; ++i)
 		{
 			CScriptVal player;
 			scriptInterface.Eval("({})", player);
 
 			// We could load player_defaults.json here, but that would complicate the logic
 			//	even more and autostart is only intended for developers anyway
 			scriptInterface.SetProperty(player.get(), "Civ", std::string("athen"));
 			scriptInterface.SetPropertyInt(playerData.get(), i, player);
 		}
 	}
 	else
 	{
 		// TODO: support akirmish maps
 		std::string mapFile = "maps/scenarios/" + autoStartName;
 		scriptInterface.SetProperty(attrs.get(), "map", mapFile);
 		scriptInterface.SetProperty(attrs.get(), "mapType", std::string("scenario"));
 	}
 
 	// Set player data for AIs
 	//		attrs.settings = { PlayerData: [ { AI: ... }, ... ] }:
 	if (args.Has("autostart-ai"))
 	{
 		std::vector<CStr> aiArgs = args.GetMultiple("autostart-ai");
 		for (size_t i = 0; i < aiArgs.size(); ++i)
 		{
 			// Instead of overwriting existing player data, modify the array
 			CScriptVal player;
 			if (!scriptInterface.GetPropertyInt(playerData.get(), i, player) || player.undefined())
 			{
 				scriptInterface.Eval("({})", player);
 			}
 
 			int playerID = aiArgs[i].BeforeFirst(":").ToInt();
 			CStr name = aiArgs[i].AfterFirst(":");
 
 			scriptInterface.SetProperty(player.get(), "AI", std::string(name));
 			scriptInterface.SetProperty(player.get(), "AIDiff", 2);
 			scriptInterface.SetPropertyInt(playerData.get(), playerID-1, player);
 		}
 	}
 	// Set AI difficulty
 	if (args.Has("autostart-aidiff"))
 	{
 		std::vector<CStr> civArgs = args.GetMultiple("autostart-aidiff");
 		for (size_t i = 0; i < civArgs.size(); ++i)
 		{
 			// Instead of overwriting existing player data, modify the array
 			CScriptVal player;
 			if (!scriptInterface.GetPropertyInt(playerData.get(), i, player) || player.undefined())
 			{
 				scriptInterface.Eval("({})", player);
 			}
 			
 			int playerID = civArgs[i].BeforeFirst(":").ToInt();
 			int difficulty = civArgs[i].AfterFirst(":").ToInt();
 			
 			scriptInterface.SetProperty(player.get(), "AIDiff", difficulty);
 			scriptInterface.SetPropertyInt(playerData.get(), playerID-1, player);
 		}
 	}
 	// Set player data for Civs
 	if (args.Has("autostart-civ"))
 	{
 		std::vector<CStr> civArgs = args.GetMultiple("autostart-civ");
 		for (size_t i = 0; i < civArgs.size(); ++i)
 		{
 			// Instead of overwriting existing player data, modify the array
 			CScriptVal player;
 			if (!scriptInterface.GetPropertyInt(playerData.get(), i, player) || player.undefined())
 			{
 				scriptInterface.Eval("({})", player);
 			}
 			
 			int playerID = civArgs[i].BeforeFirst(":").ToInt();
 			CStr name = civArgs[i].AfterFirst(":");
 			
 			scriptInterface.SetProperty(player.get(), "Civ", std::string(name));
 			scriptInterface.SetPropertyInt(playerData.get(), playerID-1, player);
 		}
 	}
 
 	// Add player data to map settings
 	scriptInterface.SetProperty(settings.get(), "PlayerData", playerData);
 
 	// Add map settings to game attributes
 	scriptInterface.SetProperty(attrs.get(), "settings", settings);
 
 	CScriptVal mpInitData;
 	scriptInterface.Eval("({isNetworked:true, playerAssignments:{}})", mpInitData);
 	scriptInterface.SetProperty(mpInitData.get(), "attribs", attrs);
 
 	// Get optional playername
 	CStrW userName = L"anonymous";
 	if (args.Has("autostart-playername"))
 	{
 		userName = args.Get("autostart-playername").FromUTF8();
 	}
 
 	if (args.Has("autostart-host"))
 	{
 		InitPs(true, L"page_loading.xml", &scriptInterface, mpInitData.get());
 
 		size_t maxPlayers = 2;
 		if (args.Has("autostart-players"))
 		{
 			maxPlayers = args.Get("autostart-players").ToUInt();
 		}
 
 		g_NetServer = new CNetServer(maxPlayers);
 
 		g_NetServer->UpdateGameAttributes(attrs.get(), scriptInterface);
 
 		bool ok = g_NetServer->SetupConnection();
 		ENSURE(ok);
 
 		g_NetClient = new CNetClient(g_Game);
 		g_NetClient->SetUserName(userName);
 		g_NetClient->SetupConnection("127.0.0.1");
 	}
 	else if (args.Has("autostart-client"))
 	{
 		InitPs(true, L"page_loading.xml", &scriptInterface, mpInitData.get());
 
 		g_NetClient = new CNetClient(g_Game);
 		g_NetClient->SetUserName(userName);
 
 		CStr ip = "127.0.0.1";
 		if (args.Has("autostart-ip"))
 		{
 			ip = args.Get("autostart-ip");
 		}
 
 		bool ok = g_NetClient->SetupConnection(ip);
 		ENSURE(ok);
 	}
 	else
 	{
 		g_Game->SetPlayerID(1);
 		g_Game->StartGame(attrs, "");
 
 		LDR_NonprogressiveLoad();
 
 		PSRETURN ret = g_Game->ReallyStartGame();
 		ENSURE(ret == PSRETURN_OK);
 
 		InitPs(true, L"page_session.xml", NULL, JSVAL_VOID);
 	}
 
 	return true;
 }
 
 void CancelLoad(const CStrW& message)
 {
 	// Cancel loader
 	LDR_Cancel();
 
 	// Call the cancelOnError GUI function, defined in ..gui/common/functions_utility_error.js
 	// So all GUI pages that load games should include this script
 	if (g_GUI && g_GUI->HasPages())
 	{
 		if (g_GUI->GetActiveGUI()->GetScriptInterface()->HasProperty(g_GUI->GetActiveGUI()->GetGlobalObject(), "cancelOnError" ))
 			g_GUI->GetActiveGUI()->GetScriptInterface()->CallFunctionVoid(g_GUI->GetActiveGUI()->GetGlobalObject(), "cancelOnError", message);
 	}
 }
+
+bool InDevelopmentCopy()
+{
+	if (!g_CheckedIfInDevelopmentCopy)
+	{
+		g_InDevelopmentCopy = (g_VFS->GetFileInfo(L"config/dev.cfg", NULL) == INFO::OK);
+		g_CheckedIfInDevelopmentCopy = true;
+	}
+	return g_InDevelopmentCopy;
+}
Index: ps/trunk/source/ps/GameSetup/GameSetup.h
===================================================================
--- ps/trunk/source/ps/GameSetup/GameSetup.h	(revision 14952)
+++ ps/trunk/source/ps/GameSetup/GameSetup.h	(revision 14953)
@@ -1,70 +1,72 @@
 /* Copyright (C) 2013 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_GAMESETUP
 #define INCLUDED_GAMESETUP
 
 //
 // GUI integration
 //
 
 // display progress / description in loading screen
 extern void GUI_DisplayLoadProgress(int percent, const wchar_t* pending_task);
 
 extern void Render();
 
 /**
  * initialize global modules that are be needed before Init.
  * must be called from the very beginning of main.
  **/
 extern void EarlyInit();
 
 enum InitFlags
 {
 	// avoid setting a video mode / initializing OpenGL; assume that has
 	// already been done and everything is ready for rendering.
 	// needed by map editor because it creates its own window.
 	INIT_HAVE_VMODE = 1,
 
 	// skip initializing the in-game GUI.
 	// needed by map editor because it uses its own GUI.
 	INIT_NO_GUI = 2,
 
 	// avoid setting display_error app hook
 	// needed by map editor because it has its own wx error display
 	INIT_HAVE_DISPLAY_ERROR = 4
 };
 
 /**
  * enable/disable rendering of the GUI (intended mainly for screenshots)
  */
 extern void RenderGui(bool RenderingState);
 extern void RenderLogger(bool RenderingState);
 
 /**
  * enable/disable rendering of the cursor - this does not hide cursor, but reverts to OS style
  */
 extern void RenderCursor(bool RenderingState);
 
 
 class CmdLineArgs;
 extern void Init(const CmdLineArgs& args, int flags);
 extern void InitGraphics(const CmdLineArgs& args, int flags);
 extern void Shutdown(int flags);
 extern void CancelLoad(const CStrW& message);
 
+extern bool InDevelopmentCopy();
+
 #endif // INCLUDED_GAMESETUP
Index: ps/trunk/source/ps/SavedGame.cpp
===================================================================
--- ps/trunk/source/ps/SavedGame.cpp	(revision 14952)
+++ ps/trunk/source/ps/SavedGame.cpp	(revision 14953)
@@ -1,270 +1,272 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2014 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "SavedGame.h"
 
 #include "graphics/GameView.h"
 #include "gui/GUIManager.h"
 #include "lib/allocators/shared_ptr.h"
 #include "lib/file/archive/archive_zip.h"
+#include "i18n/L10n.h"
+#include "lib/utf8.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "ps/Game.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/Simulation2.h"
 
 static const int SAVED_GAME_VERSION_MAJOR = 1; // increment on incompatible changes to the format
 static const int SAVED_GAME_VERSION_MINOR = 0; // increment on compatible changes to the format
 std::vector<std::string> g_modsLoaded; // list of mods loaded
 
 // TODO: we ought to check version numbers when loading files
 
 
 Status SavedGames::SavePrefix(const std::wstring& prefix, const std::wstring& description, CSimulation2& simulation, shared_ptr<ScriptInterface::StructuredClone> guiMetadataClone, int playerID)
 {
 	// Determine the filename to save under
 	const VfsPath basenameFormat(L"saves/" + prefix + L"-%04d");
 	const VfsPath filenameFormat = basenameFormat.ChangeExtension(L".0adsave");
 	VfsPath filename;
 
 	// Don't make this a static global like NextNumberedFilename expects, because
 	// that wouldn't work when 'prefix' changes, and because it's not thread-safe
 	size_t nextSaveNumber = 0;
 	vfs::NextNumberedFilename(g_VFS, filenameFormat, nextSaveNumber, filename);
 
 	return Save(filename.Filename().string(), description, simulation, guiMetadataClone, playerID);
 }
 
 Status SavedGames::Save(const std::wstring& name, const std::wstring& description, CSimulation2& simulation, shared_ptr<ScriptInterface::StructuredClone> guiMetadataClone, int playerID)
 {
 	// Determine the filename to save under
 	const VfsPath basenameFormat(L"saves/" + name);
 	const VfsPath filename = basenameFormat.ChangeExtension(L".0adsave");
 
 	// ArchiveWriter_Zip can only write to OsPaths, not VfsPaths,
 	// but we'd like to handle saved games via VFS.
 	// To avoid potential confusion from writing with non-VFS then
 	// reading the same file with VFS, we'll just write to a temporary
 	// non-VFS path and then load and save again via VFS,
 	// which is kind of a hack.
 
 	OsPath tempSaveFileRealPath;
 	WARN_RETURN_STATUS_IF_ERR(g_VFS->GetDirectoryRealPath("cache/", tempSaveFileRealPath));
 	tempSaveFileRealPath = tempSaveFileRealPath / "temp.0adsave";
 
 	time_t now = time(NULL);
 
 	// Construct the serialized state to be saved
 
 	std::stringstream simStateStream;
 	if (!simulation.SerializeState(simStateStream))
 		WARN_RETURN(ERR::FAIL);
 
 	CScriptValRooted metadata;
 	simulation.GetScriptInterface().Eval("({})", metadata);
 	simulation.GetScriptInterface().SetProperty(metadata.get(), "version_major", SAVED_GAME_VERSION_MAJOR);
 	simulation.GetScriptInterface().SetProperty(metadata.get(), "version_minor", SAVED_GAME_VERSION_MINOR);
 	simulation.GetScriptInterface().SetProperty(metadata.get(), "mods", g_modsLoaded);
 	simulation.GetScriptInterface().SetProperty(metadata.get(), "time", (double)now);
 	simulation.GetScriptInterface().SetProperty(metadata.get(), "player", playerID);
 	simulation.GetScriptInterface().SetProperty(metadata.get(), "initAttributes", simulation.GetInitAttributes());
 
 	CScriptVal guiMetadata = simulation.GetScriptInterface().ReadStructuredClone(guiMetadataClone);
 
 	// get some camera data
 	CScriptVal cameraMetadata;
 	simulation.GetScriptInterface().Eval("({})", cameraMetadata);
 	simulation.GetScriptInterface().SetProperty(cameraMetadata.get(), "PosX", g_Game->GetView()->GetCameraPosX());
 	simulation.GetScriptInterface().SetProperty(cameraMetadata.get(), "PosY", g_Game->GetView()->GetCameraPosY());
 	simulation.GetScriptInterface().SetProperty(cameraMetadata.get(), "PosZ", g_Game->GetView()->GetCameraPosZ());
 	simulation.GetScriptInterface().SetProperty(cameraMetadata.get(), "RotX", g_Game->GetView()->GetCameraRotX());
 	simulation.GetScriptInterface().SetProperty(cameraMetadata.get(), "RotY", g_Game->GetView()->GetCameraRotY());
 	simulation.GetScriptInterface().SetProperty(cameraMetadata.get(), "Zoom", g_Game->GetView()->GetCameraZoom());
 	simulation.GetScriptInterface().SetProperty(guiMetadata.get(), "camera", cameraMetadata);
 	simulation.GetScriptInterface().SetProperty(metadata.get(), "gui", guiMetadata);
 
 	simulation.GetScriptInterface().SetProperty(metadata.get(), "description", description);
 	
 	std::string metadataString = simulation.GetScriptInterface().StringifyJSON(metadata.get(), true);
 	
 	// Write the saved game as zip file containing the various components
 	PIArchiveWriter archiveWriter = CreateArchiveWriter_Zip(tempSaveFileRealPath, false);
 	if (!archiveWriter)
 		WARN_RETURN(ERR::FAIL);
 
 	WARN_RETURN_STATUS_IF_ERR(archiveWriter->AddMemory((const u8*)metadataString.c_str(), metadataString.length(), now, "metadata.json"));
 	WARN_RETURN_STATUS_IF_ERR(archiveWriter->AddMemory((const u8*)simStateStream.str().c_str(), simStateStream.str().length(), now, "simulation.dat"));
 	archiveWriter.reset(); // close the file
 
 	WriteBuffer buffer;
 	CFileInfo tempSaveFile;
 	WARN_RETURN_STATUS_IF_ERR(GetFileInfo(tempSaveFileRealPath, &tempSaveFile));
 	buffer.Reserve(tempSaveFile.Size());
 	WARN_RETURN_STATUS_IF_ERR(io::Load(tempSaveFileRealPath, buffer.Data().get(), buffer.Size()));
 	WARN_RETURN_STATUS_IF_ERR(g_VFS->CreateFile(filename, buffer.Data(), buffer.Size()));
 
 	OsPath realPath;
 	WARN_RETURN_STATUS_IF_ERR(g_VFS->GetRealPath(filename, realPath));
-	LOGMESSAGERENDER(L"Saved game to '%ls'\n", realPath.string().c_str());
+	LOGMESSAGERENDER(wstring_from_utf8(L10n::Instance().Translate("Saved game to '%ls'") + "\n").c_str(), realPath.string().c_str());
 
 	return INFO::OK;
 }
 
 /**
  * Helper class for retrieving data from saved game archives
  */
 class CGameLoader
 {
 	NONCOPYABLE(CGameLoader);
 public:
 	CGameLoader(ScriptInterface& scriptInterface, CScriptValRooted* metadata, std::string* savedState) :
 		m_ScriptInterface(scriptInterface), m_Metadata(metadata), m_SavedState(savedState)
 	{
 	}
 
 	static void ReadEntryCallback(const VfsPath& pathname, const CFileInfo& fileInfo, PIArchiveFile archiveFile, uintptr_t cbData)
 	{
 		((CGameLoader*)cbData)->ReadEntry(pathname, fileInfo, archiveFile);
 	}
 
 	void ReadEntry(const VfsPath& pathname, const CFileInfo& fileInfo, PIArchiveFile archiveFile)
 	{
 		if (pathname == L"metadata.json" && m_Metadata)
 		{
 			std::string buffer;
 			buffer.resize(fileInfo.Size());
 			WARN_IF_ERR(archiveFile->Load("", DummySharedPtr((u8*)buffer.data()), buffer.size()));
 			*m_Metadata = m_ScriptInterface.ParseJSON(buffer);
 		}
 		else if (pathname == L"simulation.dat" && m_SavedState)
 		{
 			m_SavedState->resize(fileInfo.Size());
 			WARN_IF_ERR(archiveFile->Load("", DummySharedPtr((u8*)m_SavedState->data()), m_SavedState->size()));
 		}
 	}
 
 	ScriptInterface& m_ScriptInterface;
 	CScriptValRooted* m_Metadata;
 	std::string* m_SavedState;
 };
 
 Status SavedGames::Load(const std::wstring& name, ScriptInterface& scriptInterface, CScriptValRooted& metadata, std::string& savedState)
 {
 	// Determine the filename to load
 	const VfsPath basename(L"saves/" + name);
 	const VfsPath filename = basename.ChangeExtension(L".0adsave");
 
 	// Don't crash just because file isn't found, this can happen if the file is deleted from the OS
 	if (!VfsFileExists(filename))
 		return ERR::FILE_NOT_FOUND;
 
 	OsPath realPath;
 	WARN_RETURN_STATUS_IF_ERR(g_VFS->GetRealPath(filename, realPath));
 
 	PIArchiveReader archiveReader = CreateArchiveReader_Zip(realPath);
 	if (!archiveReader)
 		WARN_RETURN(ERR::FAIL);
 
 	CGameLoader loader(scriptInterface, &metadata, &savedState);
 	WARN_RETURN_STATUS_IF_ERR(archiveReader->ReadEntries(CGameLoader::ReadEntryCallback, (uintptr_t)&loader));
 
 	return INFO::OK;	
 }
 
 std::vector<CScriptValRooted> SavedGames::GetSavedGames(ScriptInterface& scriptInterface)
 {
 	TIMER(L"GetSavedGames");
 
 	std::vector<CScriptValRooted> games;
 
 	Status err;
 
 	VfsPaths pathnames;
 	err = vfs::GetPathnames(g_VFS, "saves/", L"*.0adsave", pathnames);
 	WARN_IF_ERR(err);
 
 	for (size_t i = 0; i < pathnames.size(); ++i)
 	{
 		OsPath realPath;
 		err = g_VFS->GetRealPath(pathnames[i], realPath);
 		if (err < 0)
 		{
 			DEBUG_WARN_ERR(err);
 			continue; // skip this file
 		}
 
 		PIArchiveReader archiveReader = CreateArchiveReader_Zip(realPath);
 		if (!archiveReader)
 		{
 			// Triggered by e.g. the file being open in another program
 			LOGWARNING(L"Failed to read saved game '%ls'", realPath.string().c_str());
 			continue; // skip this file
 		}
 
 		CScriptValRooted metadata;
 		CGameLoader loader(scriptInterface, &metadata, NULL);
 		err = archiveReader->ReadEntries(CGameLoader::ReadEntryCallback, (uintptr_t)&loader);
 		if (err < 0)
 		{
 			DEBUG_WARN_ERR(err);
 			continue; // skip this file
 		}
 
 		CScriptValRooted game;
 		scriptInterface.Eval("({})", game);
 		scriptInterface.SetProperty(game.get(), "id", pathnames[i].Basename());
 		scriptInterface.SetProperty(game.get(), "metadata", metadata);
 		games.push_back(game);
 	}
 
 	return games;
 }
 
 bool SavedGames::DeleteSavedGame(const std::wstring& name)
 {
 	const VfsPath basename(L"saves/" + name);
 	const VfsPath filename = basename.ChangeExtension(L".0adsave");
 	OsPath realpath;
 
 	// Make sure it exists in VFS and find its real path
 	if (!VfsFileExists(filename) || g_VFS->GetRealPath(filename, realpath) != INFO::OK)
 		return false; // Error
 
 	// Remove from VFS
 	if (g_VFS->RemoveFile(filename) != INFO::OK)
 		return false; // Error
 
 	// Delete actual file
 	if (wunlink(realpath) != 0)
 		return false; // Error
 
 	// Successfully deleted file
 	return true;
 }
 
 CScriptValRooted SavedGames::GetEngineInfo(ScriptInterface& scriptInterface) 
 { 
 	CScriptValRooted metainfo; 
 	scriptInterface.Eval("({})", metainfo); 
 	scriptInterface.SetProperty(metainfo.get(), "version_major", SAVED_GAME_VERSION_MAJOR); 
 	scriptInterface.SetProperty(metainfo.get(), "version_minor", SAVED_GAME_VERSION_MINOR); 
 	scriptInterface.SetProperty(metainfo.get(), "mods"         , g_modsLoaded);
 	return metainfo; 
 }