<ResourceCompile Include="..\src\os\windows\ottdres.rc" />

    <ClCompile Include="..\src\os\windows\string_uniscribe.cpp" />

    <ClCompile Include="..\src\os\windows\win32.cpp" />

  </ItemGroup>

  <ItemGroup>

    <None Include="..\media\openttd.ico" />

    <ClCompile Include="..\src\os\windows\win32.cpp">

      <Filter>Windows files</Filter>

    </ClCompile>

      <Filter>Threading</Filter>

    </ClInclude>

  </ItemGroup>

  <ItemGroup>

    <None Include="..\media\openttd.ico" />

    <ResourceCompile Include="..\src\os\windows\ottdres.rc" />

    <ClCompile Include="..\src\os\windows\string_uniscribe.cpp" />

    <ClCompile Include="..\src\os\windows\win32.cpp" />

  </ItemGroup>

  <ItemGroup>

    <None Include="..\media\openttd.ico" />

    <ClCompile Include="..\src\os\windows\win32.cpp">

      <Filter>Windows files</Filter>

    </ClCompile>

      <Filter>Threading</Filter>

    </ClInclude>

  </ItemGroup>

  <ItemGroup>

    <None Include="..\media\openttd.ico" />

    <ResourceCompile Include="..\src\os\windows\ottdres.rc" />

    <ClCompile Include="..\src\os\windows\string_uniscribe.cpp" />

    <ClCompile Include="..\src\os\windows\win32.cpp" />

  </ItemGroup>

  <ItemGroup>

    <None Include="..\media\openttd.ico" />

    <ClCompile Include="..\src\os\windows\win32.cpp">

      <Filter>Windows files</Filter>

    </ClCompile>

      <Filter>Threading</Filter>

    </ClInclude>

  </ItemGroup>

  <ItemGroup>

    <None Include="..\media\openttd.ico" />

#end

# Threading

#include "game/game.hpp"

#include "game/game_instance.hpp"

#include "string_func.h"

#include "safeguards.h"

/**

 * The internal, real, generate function.

 */

{

	/* Make sure everything is done via OWNER_NONE. */

	Backup<CompanyByte> _cur_company(_current_company, OWNER_NONE, FILE_LINE);

 */

void WaitTillGeneratedWorld()

{

	_modal_progress_work_mutex.unlock();

	_modal_progress_paint_mutex.unlock();

	_gw.quit_thread = true;

	_gw.threaded = false;

	_modal_progress_work_mutex.lock();

	_modal_progress_paint_mutex.lock();

	CleanupGeneration();

	SwitchToMode(_switch_mode);

}

	SetupColoursAndInitialWindow();

	SetObjectToPlace(SPR_CURSOR_ZZZ, PAL_NONE, HT_NONE, WC_MAIN_WINDOW, 0);

		DEBUG(misc, 1, "Cannot create genworld thread, reverting to single-threaded mode");

		_gw.threaded = false;

		_modal_progress_work_mutex.unlock();

		_modal_progress_work_mutex.lock();

		return;

	}

#define GENWORLD_H

#include "company_type.h"

/** Constants related to world generation */

enum LandscapeGenerator {

	uint size_y;           ///< Y-size of the map

	GWDoneProc *proc;      ///< Proc that is called when done (can be NULL)

	GWAbortProc *abortp;   ///< Proc that is called when aborting (can be NULL)

};

/** Current stage of world generation process */

		 * This is on purpose. */

		link_graph(orig),

		settings(_settings_game.linkgraph),

		join_date(_date + _settings_game.linkgraph.recalc_time)

{

}

 */

void LinkGraphJob::SpawnThread()

{

		/* Of course this will hang a bit.

		 * On the other hand, if you want to play games which make this hang noticably

		 * on a platform without threads then you'll probably get other problems first.

 */

void LinkGraphJob::JoinThread()

{

	}

}

#ifndef LINKGRAPHJOB_H

#define LINKGRAPHJOB_H

#include "linkgraph.h"

#include <list>

protected:

	const LinkGraph link_graph;       ///< Link graph to by analyzed. Is copied when job is started and mustn't be modified later.

	const LinkGraphSettings settings; ///< Copy of _settings_game.linkgraph at spawn time.

	Date join_date;                   ///< Date when the job is to be joined.

	NodeAnnotationVector nodes;       ///< Extra node data necessary for link graph calculation.

	EdgeAnnotationMatrix edges;       ///< Extra edge data necessary for link graph calculation.

	 * Bare constructor, only for save/load. link_graph, join_date and actually

	 * settings have to be brutally const-casted in order to populate them.

	 */

			join_date(INVALID_DATE) {}

	LinkGraphJob(const LinkGraph &orig);

}

/**

 */

{

	for (uint i = 0; i < lengthof(instance.handlers); ++i) {

		instance.handlers[i]->Run(*job);

	}

	static const uint SPAWN_JOIN_TICK = 21; ///< Tick when jobs are spawned or joined every day.

	static LinkGraphSchedule instance;

	static void Clear();

	void SpawnNext();

#include "../debug.h"

#include "../os/windows/win32.h"

#include "../core/mem_func.hpp"

#include "../fileio_func.h"

#include "../base_media_base.h"

#include "dmusic.h"

} _playback;

/** Handle to our worker thread. */

/** Event to signal the thread that it should look at a state change. */

static HANDLE _thread_event = NULL;

/** Lock access to playback data that is not thread-safe. */

	Sleep(Clamp((block_time - cur_time) / MS_TO_REFTIME, 5, 1000));

}

{

	DEBUG(driver, 2, "DMusic: Entering playback thread");

	_thread_event = CreateEvent(NULL, FALSE, FALSE, NULL);

	if (_thread_event == NULL) return "Can't create thread shutdown event";

	return NULL;

}

void MusicDriver_DMusic::Stop()

{

		_playback.shutdown = true;

		SetEvent(_thread_event);

	}

	/* Unloaded any instruments we loaded. */

 */

class TCPConnecter {

private:

	bool connected;             ///< Whether we succeeded in making the connection

	bool aborted;               ///< Whether we bailed out (i.e. connection making failed)

	bool killed;                ///< Whether we got killed

	void Connect();

protected:

	/** Address we're connecting to */

 */

#include "../../stdafx.h"

#include "tcp.h"

	address(address)

{

	_tcp_connecters.push_back(this);

		this->Connect();

	}

}

 * Entry point for the new threads.

 * @param param the TCPConnecter instance to call Connect on.

 */

{

}

/**

#include "network_internal.h"

#include "core/tcp_listen.h"

class ServerNetworkGameSocketHandler;

/** Make the code look slightly nicer/simpler. */

#include "network.h"

#include "../core/endian_func.hpp"

#include "../company_base.h"

#include "../rev.h"

#include "../newgrf_text.h"

#include "../strings_func.h"

NetworkUDPSocketHandler *_udp_server_socket = NULL; ///< udp server socket

NetworkUDPSocketHandler *_udp_master_socket = NULL; ///< udp master socket

/**

 * Helper function doing the actual work for querying the server.

 * @param address The address of the server.

 * @param needs_mutex Whether we need to acquire locks when sending the packet or not.

 * @param manually Whether the address was entered manually.

 */

{

	/* Clear item in gamelist */

	NetworkGameList *item = CallocT<NetworkGameList>(1);

	item->manually = manually;

	NetworkGameListAddItemDelayed(item);

	if (needs_mutex) lock.lock();

	/* Init the packet */

	Packet p(PACKET_UDP_CLIENT_FIND_SERVER);

}

/**

 */

void NetworkUDPQueryServer(NetworkAddress address, bool manually)

{

	}

}

			/* Somehow we reached the end of the packet */

			if (this->HasClientQuit()) return;

		}

	}

}

/**

 * Thread entry point for de-advertising.

 */

{

	DEBUG(net, 1, "[udp] removing advertise from master server");

	/* Check if we are advertising */

	if (!_networking || !_network_server || !_network_udp_server) return;

	}

}

/**

 * Thread entry point for advertising.

 */

{

	/* Find somewhere to send */

	NetworkAddress out_addr(NETWORK_MASTER_SERVER_HOST, NETWORK_MASTER_SERVER_PORT);

	if (_next_advertisement < _last_advertisement) _next_advertisement = UINT32_MAX;

	if (_next_retry         < _last_advertisement) _next_retry         = UINT32_MAX;

	}

}

#include "video/video_driver.hpp"

#include "strings_func.h"

#include "textfile_gui.h"

#include "fileio_func.h"

#include "fios.h"

 * Really perform the scan for all NewGRFs.

 * @param callback The callback to call after the scanning is complete.

 */

{

	std::unique_lock<std::mutex> lock_work(_modal_progress_work_mutex);

	/* Yes... these are the NewGRF windows */

	InvalidateWindowClassesData(WC_SAVELOAD, 0, true);

	InvalidateWindowData(WC_GAME_OPTIONS, WN_GAME_OPTIONS_NEWGRF_STATE, GOID_NEWGRF_RESCANNED, true);

	DeleteWindowByClass(WC_MODAL_PROGRESS);

	SetModalProgress(false);

	/* Only then can we really start, especially by marking the whole screen dirty. Get those other windows hidden!. */

	MarkWholeScreenDirty();

		_modal_progress_work_mutex.unlock();

		_modal_progress_paint_mutex.unlock();

		DoScanNewGRFFiles(callback);

	VideoDriver::GetInstance()->MainLoop();

	WaitTillSaved();

	/* only save config if we have to */

	if (save_config) {

#include "../../core/random_func.hpp"

#include "../../string_func.h"

#include "../../textbuf_gui.h"

#include "table/strings.h"

	// stub only

	DEBUG(misc, 0, "Failed to open url: %s", url);

}

#include "../../debug.h"

#include "../../string_func.h"

#include "../../fios.h"

#include <dirent.h>

#include <sys/sysctl.h>

#endif

#if defined(__APPLE__)

		/* the mac implementation needs this file included in the same file as main() */

#endif

#include "../../safeguards.h"

	DEBUG(misc, 0, "Failed to open url: %s", url);

	exit(0);

}

#include <errno.h>

#include <sys/stat.h>

#include "../../language.h"

#include "../../safeguards.h"

/**

 * Signal thread name to any attached debuggers.

 */

{

	THREADNAME_INFO info;

	info.dwType = 0x1000;

	info.szName = threadName;

	info.dwFlags = 0;

#pragma warning(push)

	}

#pragma warning(pop)

}

#endif

#define SHGFP_TYPE_CURRENT 0

#endif /* __MINGW32__ */

void Win32SetCurrentLocaleName(const char *iso_code);

int OTTDStringCompare(const char *s1, const char *s2);

#include "../stdafx.h"

#include "../debug.h"

#include "../station_base.h"

#include "../town.h"

#include "../network/network.h"

#include "../window_func.h"

typedef void (*AsyncSaveFinishProc)();                ///< Callback for when the savegame loading is finished.

static AsyncSaveFinishProc _async_save_finish = NULL; ///< Callback to call when the savegame loading is finished.

/**

 * Called by save thread to tell we finished saving.

	_async_save_finish = NULL;

	}

}

	}

}

void WaitTillSaved()

{

	/* Make sure every other state is handled properly as well. */

	ProcessAsyncSaveFinish();

	SlSaveChunks();

	SaveFileStart();

		if (threaded) DEBUG(sl, 1, "Cannot create savegame thread, reverting to single-threaded mode...");

		SaveOrLoadResult result = SaveFileToDisk(false);

#include <windows.h>

#include <mmsystem.h>

#include "../os/windows/win32.h"

#include "../safeguards.h"

static DWORD WINAPI SoundThread(LPVOID arg)

{

	do {

		for (WAVEHDR *hdr = _wave_hdr; hdr != endof(_wave_hdr); hdr++) {