code style fixes:

- reordered includes to prevent accidental dependencies.
- moved arch specific files into their own folder (easier to include with cmake).
- renamed non-class files to reflect new code style (lower case with underscores).
- using full relative paths for includes (easier for understanding dependencies).
- using #pragma once instead of classic-style header guards.

src/lib/arch/win32/ArchDaemonWindows.h

@@ -0,0 +1,157 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2012 Bolton Software Ltd.
+ * Copyright (C) 2002 Chris Schoeneman
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "arch/IArchDaemon.h"
+#include "arch/IArchMultithread.h"
+#include "common/stdstring.h"
+
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <tchar.h>
+
+#define ARCH_DAEMON CArchDaemonWindows
+
+//! Win32 implementation of IArchDaemon
+class CArchDaemonWindows : public IArchDaemon {
+public:
+	typedef int			(*RunFunc)(void);
+
+	CArchDaemonWindows();
+	virtual ~CArchDaemonWindows();
+
+	//! Run the daemon
+	/*!
+	When the client calls \c daemonize(), the \c DaemonFunc should call this
+	function after initialization and argument parsing to perform the
+	daemon processing.  The \c runFunc should perform the daemon's
+	main loop, calling \c daemonRunning(true) when it enters the main loop
+	(i.e. after initialization) and \c daemonRunning(false) when it leaves
+	the main loop.  The \c runFunc is called in a new thread and when the
+	daemon must exit the main loop due to some external control the
+	getDaemonQuitMessage() is posted to the thread.  This function returns
+	what \c runFunc returns.  \c runFunc should call \c daemonFailed() if
+	the daemon fails.
+	*/
+	static int			runDaemon(RunFunc runFunc);
+
+	//! Indicate daemon is in main loop
+	/*!
+	The \c runFunc passed to \c runDaemon() should call this function
+	to indicate when it has entered (\c running is \c true) or exited
+	(\c running is \c false) the main loop.
+	*/
+	static void			daemonRunning(bool running);
+
+	//! Indicate failure of running daemon
+	/*!
+	The \c runFunc passed to \c runDaemon() should call this function
+	to indicate failure.  \c result is returned by \c daemonize().
+	*/
+	static void			daemonFailed(int result);
+
+	//! Get daemon quit message
+	/*!
+	The windows NT daemon tells daemon thread to exit by posting this
+	message to it.  The thread must, of course, have a message queue
+	for this to work.
+	*/
+	static UINT			getDaemonQuitMessage();
+
+	// IArchDaemon overrides
+	virtual void		installDaemon(const char* name,
+							const char* description,
+							const char* pathname,
+							const char* commandLine,
+							const char* dependencies,
+							bool allUsers);
+	virtual void		uninstallDaemon(const char* name, bool allUsers);
+	virtual void		installDaemon();
+	virtual void		uninstallDaemon();
+	virtual int			daemonize(const char* name, DaemonFunc func);
+	virtual bool		canInstallDaemon(const char* name, bool allUsers);
+	virtual bool		isDaemonInstalled(const char* name, bool allUsers);
+	std::string			commandLine() const { return m_commandLine; }
+
+private:
+	static HKEY			openNTServicesKey();
+	static HKEY			open95ServicesKey();
+	static HKEY			openUserStartupKey();
+
+	int					doRunDaemon(RunFunc runFunc);
+	void				doDaemonRunning(bool running);
+	UINT				doGetDaemonQuitMessage();
+
+	static void			setStatus(DWORD state);
+	static void			setStatus(DWORD state, DWORD step, DWORD waitHint);
+	static void			setStatusError(DWORD error);
+
+	static bool			isRunState(DWORD state);
+
+	void				serviceMain(DWORD, LPTSTR*);
+	static void WINAPI	serviceMainEntry(DWORD, LPTSTR*);
+
+	void				serviceHandler(DWORD ctrl);
+	static void WINAPI	serviceHandlerEntry(DWORD ctrl);
+
+	void				start(const char* name);
+	void				stop(const char* name);
+
+private:
+	class XArchDaemonRunFailed {
+	public:
+		XArchDaemonRunFailed(int result) : m_result(result) { }
+
+	public:
+		int				m_result;
+	};
+
+private:
+	static CArchDaemonWindows*	s_daemon;
+
+	CArchMutex			m_serviceMutex;
+	CArchCond			m_serviceCondVar;
+	DWORD				m_serviceState;
+	bool				m_serviceHandlerWaiting;
+	bool				m_serviceRunning;
+
+	DWORD				m_daemonThreadID;
+	DaemonFunc			m_daemonFunc;
+	int					m_daemonResult;
+
+	SERVICE_STATUS_HANDLE m_statusHandle;
+
+	UINT				m_quitMessage;
+
+	std::string			m_commandLine;
+};
+
+#define DEFAULT_DAEMON_NAME _T("Synergy")
+#define DEFAULT_DAEMON_INFO _T("Manages the Synergy foreground processes.")
+
+#define LEGACY_SERVER_DAEMON_NAME _T("Synergy Server")
+#define LEGACY_CLIENT_DAEMON_NAME _T("Synergy Client")
+
+static const TCHAR* const g_daemonKeyPath[] = {
+	_T("SOFTWARE"),
+	_T("The Synergy Project"),
+	_T("Synergy"),
+	_T("Service"),
+	NULL
+};