8 files changed, 35 insertions, 119 deletions
diff --git a/Swift/Controllers/IdleDetector.h b/Swift/Controllers/IdleDetector.h
deleted file mode 100644
index 72fe07c..0000000
--- a/Swift/Controllers/IdleDetector.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-#include <boost/signals.hpp>
-#include <boost/shared_ptr.hpp>
-
-namespace Swift {
-class IdleDetector {
-	public:
-		virtual ~IdleDetector() {};
-		virtual void forceNotIdle() = 0;
-		boost::signal<void ()> onInputIdle;
-		boost::signal<void ()> onInputNotIdle;
-};
-}
-
-
diff --git a/Swift/Controllers/MainController.cpp b/Swift/Controllers/MainController.cpp
index f05d42d..f54e0a2 100644
--- a/Swift/Controllers/MainController.cpp
+++ b/Swift/Controllers/MainController.cpp
@@ -1,356 +1,355 @@
 #include "Swift/Controllers/MainController.h"
 
 #include <boost/bind.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/shared_ptr.hpp>
 #include <stdlib.h>
 
 #include "Swiften/Application/Application.h"
 #include "Swiften/Application/ApplicationMessageDisplay.h"
 #include "Swift/Controllers/ChatController.h"
 #include "Swift/Controllers/ChatWindowFactory.h"
 #include "Swift/Controllers/EventController.h"
-#include "Swift/Controllers/IdleDetector.h"
 #include "Swift/Controllers/LoginWindow.h"
 #include "Swift/Controllers/LoginWindowFactory.h"
 #include "Swift/Controllers/MainWindow.h"
 #include "Swift/Controllers/MainWindowFactory.h"
 #include "Swift/Controllers/MUCController.h"
 #include "Swift/Controllers/NickResolver.h"
 #include "Swift/Controllers/ProfileSettingsProvider.h"
 #include "Swift/Controllers/RosterController.h"
 #include "Swift/Controllers/SoundEventController.h"
 #include "Swift/Controllers/SoundPlayer.h"
 #include "Swift/Controllers/SystemTray.h"
 #include "Swift/Controllers/SystemTrayController.h"
 #include "Swift/Controllers/XMPPRosterController.h"
 #include "Swiften/Base/foreach.h"
 #include "Swiften/Base/String.h"
 #include "Swiften/Client/Client.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/Elements/VCardUpdate.h"
 #include "Swiften/Queries/Responders/SoftwareVersionResponder.h"
 #include "Swiften/Roster/TreeWidgetFactory.h"
 #include "Swiften/Settings/SettingsProvider.h"
 #include "Swiften/Elements/DiscoInfo.h"
 #include "Swiften/Queries/Responders/DiscoInfoResponder.h"
 #include "Swiften/Disco/CapsInfoGenerator.h"
 #include "Swiften/Queries/Requests/GetDiscoInfoRequest.h"
 #include "Swiften/Queries/Requests/GetVCardRequest.h"
 #include "Swiften/Avatars/AvatarFileStorage.h"
 #include "Swiften/Avatars/AvatarManager.h"
 #include "Swiften/StringCodecs/SHA1.h"
 
 namespace {
 	void printIncomingData(const Swift::String& data) {
 		std::cout << "<- " << data << std::endl;
 	}
 
 	void printOutgoingData(const Swift::String& data) {
 		std::cout << "-> " << data << std::endl;
 	}
 }
 
 namespace Swift {
 
 static const String CLIENT_NAME = "Swift";
 static const String CLIENT_VERSION = "0.3";
 static const String CLIENT_NODE = "http://swift.im";
 
 typedef std::pair<JID, ChatController*> JIDChatControllerPair;
 typedef std::pair<JID, MUCController*> JIDMUCControllerPair;
 
-MainController::MainController(ChatWindowFactory* chatWindowFactory, MainWindowFactory *mainWindowFactory, LoginWindowFactory *loginWindowFactory, TreeWidgetFactory *treeWidgetFactory, SettingsProvider *settings, Application* application, SystemTray* systemTray, SoundPlayer* soundPlayer, IdleDetector* idleDetector)
-		: client_(NULL), chatWindowFactory_(chatWindowFactory), mainWindowFactory_(mainWindowFactory), loginWindowFactory_(loginWindowFactory), treeWidgetFactory_(treeWidgetFactory), settings_(settings),
-		xmppRosterController_(NULL), rosterController_(NULL), loginWindow_(NULL), clientVersionResponder_(NULL), nickResolver_(NULL), discoResponder_(NULL) {
-	idleDetector_ = idleDetector;
+MainController::MainController(ChatWindowFactory* chatWindowFactory, MainWindowFactory *mainWindowFactory, LoginWindowFactory *loginWindowFactory, TreeWidgetFactory *treeWidgetFactory, SettingsProvider *settings, Application* application, SystemTray* systemTray, SoundPlayer* soundPlayer)
+		: timerFactory_(&boostIOServiceThread_.getIOService()), idleDetector_(&idleQuerier_, &timerFactory_, 100), client_(NULL), chatWindowFactory_(chatWindowFactory), mainWindowFactory_(mainWindowFactory), loginWindowFactory_(loginWindowFactory), treeWidgetFactory_(treeWidgetFactory), settings_(settings), xmppRosterController_(NULL), rosterController_(NULL), loginWindow_(NULL), clientVersionResponder_(NULL), nickResolver_(NULL), discoResponder_(NULL) {
 	application_ = application;
 	presenceOracle_ = NULL;
 	avatarManager_ = NULL;
 
 	avatarStorage_ = new AvatarFileStorage(application_->getAvatarDir());
 
 	eventController_ = new EventController();
 	eventController_->onEventQueueLengthChange.connect(boost::bind(&MainController::handleEventQueueLengthChange, this, _1));
 	systemTrayController_ = new SystemTrayController(eventController_, systemTray);
 	soundEventController_ = new SoundEventController(eventController_, soundPlayer, settings->getBoolSetting("playSounds", true));
 	loginWindow_ = loginWindowFactory_->createLoginWindow();
 	foreach (String profile, settings->getAvailableProfiles()) {
 		ProfileSettingsProvider* profileSettings = new ProfileSettingsProvider(profile, settings);
 		loginWindow_->addAvailableAccount(profileSettings->getStringSetting("jid"), profileSettings->getStringSetting("pass"), profileSettings->getStringSetting("certificate"));
 		delete profileSettings;
 	}
 	loginWindow_->onLoginRequest.connect(boost::bind(&MainController::handleLoginRequest, this, _1, _2, _3, _4));
 	loginWindow_->onCancelLoginRequest.connect(boost::bind(&MainController::handleCancelLoginRequest, this));
+
+	idleDetector_.setIdleTimeSeconds(600);
+	idleDetector_.onIdleChanged.connect(boost::bind(&MainController::handleInputIdleChanged, this, _1));
 }
 
 MainController::~MainController() {
 	foreach (JIDChatControllerPair controllerPair, chatControllers_) {
 		delete controllerPair.second;
 	}
 	foreach (JIDMUCControllerPair controllerPair, mucControllers_) {
 		delete controllerPair.second;
 	}
 	delete systemTrayController_;
 	delete soundEventController_;
 	delete avatarStorage_;
 	resetClient();
 }
 
 void MainController::resetClient() {
 	serverDiscoInfo_ = boost::shared_ptr<DiscoInfo>();
 	xmppRoster_ = boost::shared_ptr<XMPPRoster>();
 	delete presenceOracle_;
 	presenceOracle_ = NULL;
 	delete nickResolver_;
 	nickResolver_ = NULL;
 	delete avatarManager_;
 	avatarManager_ = NULL;
 	delete rosterController_;
 	rosterController_ = NULL;
 	delete xmppRosterController_;
 	xmppRosterController_ = NULL;
 	delete clientVersionResponder_;
 	clientVersionResponder_ = NULL;
 	delete discoResponder_;
 	discoResponder_ = NULL;
 	delete client_;
 	client_ = NULL;
 	
 }
 
 void MainController::handleConnected() {
 	//FIXME: this freshLogin thing is temporary so I can see what's what before I split into a seperate method.
 	bool freshLogin = rosterController_ == NULL;
 	if (freshLogin) {
 		serverDiscoInfo_ = boost::shared_ptr<DiscoInfo>(new DiscoInfo());
 		xmppRoster_ = boost::shared_ptr<XMPPRoster>(new XMPPRoster());
 		presenceOracle_ = new PresenceOracle(client_);
 
 		lastSentPresence_ = boost::shared_ptr<Presence>();
 
 		client_->onPresenceReceived.connect(boost::bind(&MainController::handleIncomingPresence, this, _1));
 
 		nickResolver_ = new NickResolver(xmppRoster_);
 
 		avatarManager_ = new AvatarManager(client_, client_, avatarStorage_, this);
 		rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, treeWidgetFactory_, nickResolver_);
 		rosterController_->onStartChatRequest.connect(boost::bind(&MainController::handleChatRequest, this, _1));
 		rosterController_->onJoinMUCRequest.connect(boost::bind(&MainController::handleJoinMUCRequest, this, _1, _2));
 		rosterController_->onChangeStatusRequest.connect(boost::bind(&MainController::handleChangeStatusRequest, this, _1, _2));
 		rosterController_->onSignOutRequest.connect(boost::bind(&MainController::signOut, this));
 
 		xmppRosterController_ = new XMPPRosterController(client_, xmppRoster_);
 		xmppRosterController_->requestRoster();
 
 		clientVersionResponder_ = new SoftwareVersionResponder(CLIENT_NAME, CLIENT_VERSION, client_);
 		loginWindow_->morphInto(rosterController_->getWindow());
 
 		DiscoInfo discoInfo;
 		discoInfo.addIdentity(DiscoInfo::Identity(CLIENT_NAME, "client", "pc"));
 		discoInfo.addFeature("urn:xmpp:sec-label:0");
 		capsInfo_ = boost::shared_ptr<CapsInfo>(new CapsInfo(CapsInfoGenerator(CLIENT_NODE).generateCapsInfo(discoInfo)));
 
 		discoResponder_ = new DiscoInfoResponder(client_);
 		discoResponder_->setDiscoInfo(discoInfo);
 		discoResponder_->setDiscoInfo(capsInfo_->getNode() + "#" + capsInfo_->getVersion(), discoInfo);
 		serverDiscoInfo_ = boost::shared_ptr<DiscoInfo>(new DiscoInfo());
 	}
 	
 	boost::shared_ptr<GetDiscoInfoRequest> discoInfoRequest(new GetDiscoInfoRequest(JID(), client_));
 	discoInfoRequest->onResponse.connect(boost::bind(&MainController::handleServerDiscoInfoResponse, this, _1, _2));
 	discoInfoRequest->send();
 
 	boost::shared_ptr<GetVCardRequest> vCardRequest(new GetVCardRequest(JID(), client_));
 	vCardRequest->onResponse.connect(boost::bind(&MainController::handleOwnVCardReceived, this, _1, _2));
 	vCardRequest->send();
 
-	idleDetector_->onInputIdle.connect(boost::bind(&MainController::handleInputIdle, this));
-	idleDetector_->onInputNotIdle.connect(boost::bind(&MainController::handleInputNotIdle, this));
-	
 	//Send presence last to catch all the incoming presences.
 	boost::shared_ptr<Presence> initialPresence;
 	if (queuedPresence_.get() != NULL) {
 		initialPresence = queuedPresence_;
 	} else {
 		initialPresence = boost::shared_ptr<Presence>(new Presence());
 	}
 	initialPresence->addPayload(capsInfo_);
 	setManagersEnabled(true);
 	sendPresence(initialPresence);
 }
 
 void MainController::handleEventQueueLengthChange(int count) {
 	application_->getApplicationMessageDisplay()->setMessage(count == 0 ? "" : boost::lexical_cast<std::string>(count).c_str());
 }
 
 void MainController::reconnectAfterError() {
 	performLoginFromCachedCredentials();
 	sendPresence(queuedPresence_);
 }
 
 void MainController::handleChangeStatusRequest(StatusShow::Type show, const String &statusText) {
 	boost::shared_ptr<Presence> presence(new Presence());
 	if (show == StatusShow::None) {
 		// FIXME: This is wrong. None doesn't mean unavailable
 		presence->setType(Presence::Unavailable);
 	}
 	else {
 		presence->setShow(show);
 	}
 	presence->setStatus(statusText);
 	if (presence->getType() != Presence::Unavailable && !client_->isAvailable()) {
 		performLoginFromCachedCredentials();
 		queuedPresence_ = presence;
 	} else {
 		sendPresence(presence);
 	}
 }
 
 void MainController::sendPresence(boost::shared_ptr<Presence> presence) {
 	if (!vCardPhotoHash_.isEmpty()) {
 		presence->addPayload(boost::shared_ptr<VCardUpdate>(new VCardUpdate(vCardPhotoHash_)));
 	}
 	presence->addPayload(capsInfo_);
 	lastSentPresence_ = presence;
 	client_->sendPresence(presence);
 	if (presence->getType() == Presence::Unavailable) {
 		logout();
 	}
 }
 
-void MainController::handleInputIdle() {
-	preIdlePresence_ = lastSentPresence_;
-	boost::shared_ptr<Presence> presence(new Presence());
-	presence->setShow(StatusShow::Away);
-	presence->setStatus("Auto-away");
-	sendPresence(presence);
-}
-
-void MainController::handleInputNotIdle() {
-	if (client_) {
-		sendPresence(preIdlePresence_);
-	} else {
-		queuedPresence_ = preIdlePresence_;
+void MainController::handleInputIdleChanged(bool idle) {
+	if (!client_ || !client_->isAvailable()) {
+		return;
+	}
+	if (idle) {
+		preIdlePresence_ = lastSentPresence_;
+		boost::shared_ptr<Presence> presence(new Presence());
+		presence->setShow(StatusShow::Away);
+		presence->setStatus("Auto-away");
+		sendPresence(presence);
+	}
+	else {
+		if (client_) {
+			sendPresence(preIdlePresence_);
+		} else {
+			queuedPresence_ = preIdlePresence_;
+		}
 	}
 }
 
 void MainController::handleIncomingPresence(boost::shared_ptr<Presence> presence) {
 	//FIXME: subscribe, subscribed
 	rosterController_->handleIncomingPresence(presence);
 }
 
 void MainController::handleLoginRequest(const String &username, const String &password, const String& certificateFile, bool remember) {
 	loginWindow_->setMessage("");
 	ProfileSettingsProvider* profileSettings = new ProfileSettingsProvider(username, settings_);
 	profileSettings->storeString("jid", username);
 	profileSettings->storeString("certificate", certificateFile);
 	profileSettings->storeString("pass", remember ? password : "");
 	loginWindow_->addAvailableAccount(profileSettings->getStringSetting("jid"), profileSettings->getStringSetting("pass"), profileSettings->getStringSetting("certificate"));
 	delete profileSettings;
 	jid_ = JID(username);
 	password_ = password;
 	certificateFile_ = certificateFile;
 	performLoginFromCachedCredentials();
 }
 
 void MainController::performLoginFromCachedCredentials() {
 	if (!client_) {
 		client_ = new Swift::Client(jid_, password_);
 		//client_->onDataRead.connect(&printIncomingData);
 		//client_->onDataWritten.connect(&printOutgoingData);
 		if (!certificateFile_.isEmpty()) {
 			client_->setCertificate(certificateFile_);
 		}
 		client_->onError.connect(boost::bind(&MainController::handleError, this, _1));
 		client_->onConnected.connect(boost::bind(&MainController::handleConnected, this));
 		client_->onMessageReceived.connect(boost::bind(&MainController::handleIncomingMessage, this, _1));
 	}
 	client_->connect();
 }
 
 void MainController::handleError(const ClientError& error) {
 	String message;
 	switch(error.getType()) {
 		case ClientError::UnknownError: message = "Unknown Error"; break;
 		case ClientError::DomainNameResolveError: message = "Unable to find server"; break;
 		case ClientError::ConnectionError: message = "Error connecting to server"; break;
 		case ClientError::ConnectionReadError: message = "Error while receiving server data"; break;
 		case ClientError::ConnectionWriteError: message = "Error while sending data to the server"; break;
 		case ClientError::XMLError: message = "Error parsing server data"; break;
 		case ClientError::AuthenticationFailedError: message = "Login/password invalid"; break;
 		case ClientError::ServerVerificationFailedError: message = "Server verification failed"; break;
 		case ClientError::NoSupportedAuthMechanismsError: message = "Authentication mechanisms not supported"; break;
 		case ClientError::UnexpectedElementError: message = "Unexpected response"; break;
 		case ClientError::ResourceBindError: message = "Error binding resource"; break;
 		case ClientError::SessionStartError: message = "Error starting session"; break;
 		case ClientError::TLSError: message = "Encryption error"; break;
 		case ClientError::ClientCertificateLoadError: message = "Error loading certificate (Invalid password?)"; break;
 		case ClientError::ClientCertificateError: message = "Certificate not authorized"; break;
 	}
 	if (!rosterController_) { //hasn't been logged in yet
 		signOut();
 		loginWindow_->setMessage(message);
 	}
 	logout();
 	if (rosterController_) {
 		//reconnectAfterError();
 	}
 }
 
 void MainController::handleCancelLoginRequest() {
 	signOut();
 }
 
 void MainController::signOut() {
 	logout();
-	idleDetector_->onInputIdle.connect(boost::bind(&MainController::handleInputIdle, this));
-	idleDetector_->onInputNotIdle.connect(boost::bind(&MainController::handleInputNotIdle, this));
 	loginWindow_->loggedOut();
 	foreach (JIDChatControllerPair controllerPair, chatControllers_) {
 		delete controllerPair.second;
 	}
 	chatControllers_.clear();
 	foreach (JIDMUCControllerPair controllerPair, mucControllers_) {
 		delete controllerPair.second;
 	}
 	mucControllers_.clear();
 	delete rosterController_;
 	rosterController_ = NULL;
 	resetClient();
 }
 
 void MainController::logout() {
 	if (client_ && client_->isAvailable()) {
 		client_->disconnect();
 	}
 	if (rosterController_) {
 		rosterController_->getWindow()->setMyStatusType(StatusShow::None);
 		rosterController_->getWindow()->setMyStatusText("");
 	}
 	setManagersEnabled(false);
 }
 
 void MainController::setManagersEnabled(bool enabled) {
 	foreach (JIDChatControllerPair controllerPair, chatControllers_) {
 		//printf("Setting enabled on %d to %d\n", controllerPair.second, enabled);
 		controllerPair.second->setEnabled(enabled);
 	}
 	foreach (JIDMUCControllerPair controllerPair, mucControllers_) {
 		controllerPair.second->setEnabled(enabled);
 	}
 	if (rosterController_) {
 		rosterController_->setEnabled(enabled);
 	}
 }
 
 void MainController::handleChatRequest(const String &contact) {
 	ChatController* controller = getChatController(JID(contact));
 	controller->showChatWindow();
 	controller->activateChatWindow();
 }
 
 ChatController* MainController::getChatController(const JID &contact) {
 	JID lookupContact(contact);
 	if (chatControllers_.find(lookupContact) == chatControllers_.end()) {
 		lookupContact = JID(contact.toBare());
diff --git a/Swift/Controllers/MainController.h b/Swift/Controllers/MainController.h
index df6901d..270b131 100644
--- a/Swift/Controllers/MainController.h
+++ b/Swift/Controllers/MainController.h
@@ -1,118 +1,121 @@
-#ifndef SWIFTEN_MainController_H
-#define SWIFTEN_MainController_H
+#pragma once
 
 #include <boost/signals.hpp>
 #include <boost/shared_ptr.hpp>
 #include <vector>
 
+#include "Swiften/Network/BoostIOServiceThread.h"
+#include "Swiften/Network/BoostTimerFactory.h"
+#include "SwifTools/Idle/PlatformIdleQuerier.h"
+#include "SwifTools/Idle/ActualIdleDetector.h"
 #include "Swiften/Base/String.h"
 #include "Swiften/Client/ClientError.h"
 #include "Swiften/JID/JID.h"
 #include "Swiften/Elements/VCard.h"
 #include "Swiften/Elements/DiscoInfo.h"
 #include "Swiften/Elements/ErrorPayload.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/Elements/Message.h"
 #include "Swiften/Settings/SettingsProvider.h"
 #include "Swiften/Elements/CapsInfo.h"
 #include "Swiften/MUC/MUCRegistry.h"
 #include "Swiften/Roster/XMPPRoster.h"
 
 namespace Swift {
 	class AvatarStorage;
 	class Application;
 	class Client;
 	class ChatWindowFactory;
 	class ChatController;
 	class EventController;
-	class IdleDetector;
 	class MainWindowFactory;
 	class MainWindow;
 	class NickResolver;
 	class RosterController;
 	class XMPPRosterController;
 	class DiscoInfoResponder;
 	class AvatarManager;
 	class LoginWindow;
 	class EventLoop;
 	class SoftwareVersionResponder;
 	class LoginWindowFactory;
 	class TreeWidgetFactory;
 	class MUCController;
 	class PresenceOracle;
 	class SystemTray;
 	class SystemTrayController;
 	class SoundEventController;
 	class SoundPlayer;
 
 	class MainController : public MUCRegistry {
 		public:
-			MainController(ChatWindowFactory* chatWindowFactory, MainWindowFactory *mainWindowFactory, LoginWindowFactory *loginWindowFactory, TreeWidgetFactory* treeWidgetFactory, SettingsProvider *settings, Application* application, SystemTray* systemTray, SoundPlayer* soundPlayer, IdleDetector* idleDetector);
+			MainController(ChatWindowFactory* chatWindowFactory, MainWindowFactory *mainWindowFactory, LoginWindowFactory *loginWindowFactory, TreeWidgetFactory* treeWidgetFactory, SettingsProvider *settings, Application* application, SystemTray* systemTray, SoundPlayer* soundPlayer);
 			~MainController();
 
 
 		private:
 			void resetClient();
 
 			void handleConnected();
 			void handleLoginRequest(const String& username, const String& password, const String& certificateFile, bool remember);
 			void handleCancelLoginRequest();
 			void handleChatRequest(const String& contact);
 			void handleJoinMUCRequest(const JID& muc, const String& nick);
 			void handleIncomingPresence(boost::shared_ptr<Presence> presence);
 			void handleChatControllerJIDChanged(const JID& from, const JID& to);
 			void handleIncomingMessage(boost::shared_ptr<Message> message);
 			void handleChangeStatusRequest(StatusShow::Type show, const String &statusText);
 			void handleError(const ClientError& error);
 			void handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo>, const boost::optional<ErrorPayload>&);
 			void handleEventQueueLengthChange(int count);
 			void handleOwnVCardReceived(boost::shared_ptr<VCard> vCard, const boost::optional<ErrorPayload>& error);
 			ChatController* getChatController(const JID &contact);
 			void sendPresence(boost::shared_ptr<Presence> presence);
-			void handleInputIdle();
-			void handleInputNotIdle();
+			void handleInputIdleChanged(bool);
 			void logout();
 			void signOut();
 
 			virtual bool isMUC(const JID& muc) const;
 	
 			void performLoginFromCachedCredentials();
 			void reconnectAfterError();
 			void setManagersEnabled(bool enabled);
+
+			BoostIOServiceThread boostIOServiceThread_;
+			BoostTimerFactory timerFactory_;
+			PlatformIdleQuerier idleQuerier_;
+			ActualIdleDetector idleDetector_;
 			Client* client_;
 			ChatWindowFactory* chatWindowFactory_;
 			MainWindowFactory* mainWindowFactory_;
 			LoginWindowFactory* loginWindowFactory_;
 			TreeWidgetFactory* treeWidgetFactory_;
 			SettingsProvider *settings_;
 			Application* application_;
 			AvatarStorage* avatarStorage_;
 			ChatController* chatController_;
 			XMPPRosterController* xmppRosterController_;
 			RosterController* rosterController_;
 			EventController* eventController_;
 			LoginWindow* loginWindow_;
 			SoftwareVersionResponder* clientVersionResponder_;
 			NickResolver* nickResolver_;
 			DiscoInfoResponder* discoResponder_;
-			IdleDetector* idleDetector_;
 			boost::shared_ptr<CapsInfo> capsInfo_;
 			std::map<JID, MUCController*> mucControllers_;
 			std::map<JID, ChatController*> chatControllers_;
 			boost::shared_ptr<DiscoInfo> serverDiscoInfo_;
 			boost::shared_ptr<XMPPRoster> xmppRoster_;;
 			JID jid_;
 			PresenceOracle* presenceOracle_;
 			SystemTrayController* systemTrayController_;
 			SoundEventController* soundEventController_;
 			AvatarManager* avatarManager_;
 			boost::shared_ptr<Presence> lastSentPresence_;
 			boost::shared_ptr<Presence> preIdlePresence_;
 			String vCardPhotoHash_;
 			boost::shared_ptr<Presence> queuedPresence_;
 			String password_;
 			String certificateFile_;
 	};
 }
-#endif
-
diff --git a/Swift/QtUI/QtIdleDetector.cpp b/Swift/QtUI/QtIdleDetector.cpp
deleted file mode 100644
index 783cc14..0000000
--- a/Swift/QtUI/QtIdleDetector.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "QtIdleDetector.h"
-
-#include <QCursor>
-
-namespace Swift {
-
-QtIdleDetector::QtIdleDetector() {
-	signalled_ = false;
-	lastMoveTime_ = QDateTime::currentDateTime();
-	lastPosition_ = QCursor::pos();
-	connect(&timer_, SIGNAL(timeout()), this, SLOT(handleTimerTick()));
-	timer_.start(1000);
-}
-
-QtIdleDetector::~QtIdleDetector() {
-}
-
-void QtIdleDetector::forceNotIdle() {
-
-}
-
-void QtIdleDetector::handleTimerTick() {
-	QPoint position = QCursor::pos();
-	QDateTime now = QDateTime::currentDateTime();
-	if (position != lastPosition_) {
-		if (signalled_) {
-			onInputNotIdle();
-		}
-		lastPosition_ = position;
-		lastMoveTime_ = now;
-		signalled_ = false;
-	} else if (!signalled_ && now > lastMoveTime_.addSecs(600) && position == lastPosition_) {
-		signalled_ = true;
-		onInputIdle();
-	}
-}
-
-}
diff --git a/Swift/QtUI/QtIdleDetector.h b/Swift/QtUI/QtIdleDetector.h
deleted file mode 100644
index 444fb15..0000000
--- a/Swift/QtUI/QtIdleDetector.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "Swift/Controllers/IdleDetector.h"
-
-#include <QObject>
-#include <QPoint>
-#include <QTimer>
-#include <QDateTime>
-
-namespace Swift {
-class QtIdleDetector : public QObject, public IdleDetector {
-	Q_OBJECT
-	public:
-		QtIdleDetector();
-		virtual ~QtIdleDetector();
-		virtual void forceNotIdle();
-	private slots:
-		void handleTimerTick();
-	private:
-		QPoint lastPosition_;
-		QDateTime lastMoveTime_;
-		QTimer timer_;
-		bool signalled_;
-};
-}
diff --git a/Swift/QtUI/QtSwift.cpp b/Swift/QtUI/QtSwift.cpp
index 0def66f..2aaa27e 100644
--- a/Swift/QtUI/QtSwift.cpp
+++ b/Swift/QtUI/QtSwift.cpp
@@ -1,66 +1,62 @@
 #include "QtSwift.h"
 
 #include "QtLoginWindowFactory.h"
 #include "QtChatWindowFactory.h"
 #include "QtLoginWindow.h"
 #include "QtChatTabs.h"
 #include "QtMainWindowFactory.h"
 #include "Roster/QtTreeWidgetFactory.h"
 #include "QtSystemTray.h"
 #include "QtSoundPlayer.h"
-#include "QtIdleDetector.h"
-
 #include <boost/bind.hpp>
 #include <QSplitter>
 
 #include "Swiften/Application/Application.h"
 #include "Swiften/Application/Platform/PlatformApplication.h"
 #include "Swiften/Base/String.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/Client/Client.h"
 #include "Swift/Controllers/ChatController.h"
 #include "Swift/Controllers/MainController.h"
 #include "Swift/QtUI/BuildVersion.h"
 
 namespace Swift{
 
 QtSwift::QtSwift(bool netbookMode) {
 	if (netbookMode) {
 		splitter_ = new QSplitter();
 	} else {
 		splitter_ = NULL;
 	}
 	QCoreApplication::setApplicationName("Swift");
 	QCoreApplication::setOrganizationName("Swift");
 	QCoreApplication::setOrganizationDomain("swift.im");
 	QCoreApplication::setApplicationVersion(buildVersion);
 	settings_ = new QtSettingsProvider();
 	application_ = new PlatformApplication("Swift");
 	treeWidgetFactory_ = new QtTreeWidgetFactory(); 
 	systemTray_ = new QtSystemTray();
 	loginWindowFactory_ = new QtLoginWindowFactory(splitter_, systemTray_, settings_);
 	chatWindowFactory_ = new QtChatWindowFactory(treeWidgetFactory_, splitter_, settings_);
 	rosterWindowFactory_ = new QtMainWindowFactory(treeWidgetFactory_);
 	soundPlayer_ = new QtSoundPlayer();
-	idleDetector_ = new QtIdleDetector();
 	if (splitter_) {
 		splitter_->show();
 	}
-	mainController_ = new MainController(chatWindowFactory_, rosterWindowFactory_, loginWindowFactory_, treeWidgetFactory_, settings_, application_, systemTray_, soundPlayer_, idleDetector_);
+	mainController_ = new MainController(chatWindowFactory_, rosterWindowFactory_, loginWindowFactory_, treeWidgetFactory_, settings_, application_, systemTray_, soundPlayer_);
 }
 
 QtSwift::~QtSwift() {
 	delete chatWindowFactory_;
 	delete rosterWindowFactory_;
 	delete loginWindowFactory_;
 	delete treeWidgetFactory_;
 	delete mainController_;
 	delete settings_;
 	delete application_;
 	delete systemTray_;
 	delete splitter_;
 	delete soundPlayer_;
-	delete idleDetector_;
 }
 
 }
diff --git a/Swift/QtUI/QtSwift.h b/Swift/QtUI/QtSwift.h
index 60ff5a7..263dc05 100644
--- a/Swift/QtUI/QtSwift.h
+++ b/Swift/QtUI/QtSwift.h
@@ -1,45 +1,43 @@
 #ifndef SWIFT_QtSwift_H
 #define SWIFT_QtSwift_H
 
 #include "Swiften/Base/String.h"
 #include "Swiften/EventLoop/Qt/QtEventLoop.h"
 #include "QtLoginWindowFactory.h"
 #include "QtMainWindowFactory.h"
 #include "QtChatWindowFactory.h"
 #include "QtSettingsProvider.h"
-#include "QtIdleDetector.h"
 
 class QSplitter;
 
 namespace Swift {
 	class Application;
 	class MainController;
 	class QtChatWindowFactory;
 	class QtMainWindowFactory;
 	class QtLoginWindowFactory;
 	class QtTreeWidgetFactory;
 	class QtSystemTray;
 	class QtSoundPlayer;
 	
 	class QtSwift : public QObject {
 		Q_OBJECT
 		public:
 			QtSwift(bool netbookMode);
 			~QtSwift();
 		private:
 			MainController *mainController_;
 			QtTreeWidgetFactory *treeWidgetFactory_;
 			QtChatWindowFactory *chatWindowFactory_;
 			QtMainWindowFactory *rosterWindowFactory_;
 			QtLoginWindowFactory *loginWindowFactory_;
 			QtEventLoop clientMainThreadCaller_;
 			QtSettingsProvider *settings_;
 			QtSystemTray* systemTray_;
 			QSplitter* splitter_;
 			QtSoundPlayer* soundPlayer_;
-			QtIdleDetector* idleDetector_;
 			Application* application_;
 	};
 }
 
 #endif
diff --git a/Swift/QtUI/SConscript b/Swift/QtUI/SConscript
index d30f3b9..800a009 100644
--- a/Swift/QtUI/SConscript
+++ b/Swift/QtUI/SConscript
@@ -7,97 +7,96 @@ def generateDefaultTheme(env, target, source) :
 	output.write("<RCC version =\"1.0\">")
 	output.write("<qresource prefix=\"/themes/Default\">")
 	for (path, dirs, files) in os.walk(sourceDir) :
 		for file in files :
 			filePath = os.path.join(path,file)
 			output.write("<file alias=\"%(alias)s\">%(path)s</file>" % { 
 					"alias": filePath[len(sourceDir)+1:],
 					"path": filePath
 				})
 	output.write("</qresource>")
 	output.write("</RCC>")
 
 Import("env")
 
 myenv = env.Clone()
 
 myenv.MergeFlags(env["SWIFT_CONTROLLERS_FLAGS"])
 myenv.MergeFlags(env["SWIFTOOLS_FLAGS"])
 myenv.MergeFlags(env["SWIFTEN_FLAGS"])
 myenv.MergeFlags(env["CPPUNIT_FLAGS"])
 myenv.MergeFlags(env["LIBIDN_FLAGS"])
 myenv.MergeFlags(env["BOOST_FLAGS"])
 myenv.MergeFlags(env["SQLITE_FLAGS"])
 myenv.MergeFlags(env["ZLIB_FLAGS"])
 myenv.MergeFlags(env["OPENSSL_FLAGS"])
 myenv.MergeFlags(env.get("LIBXML_FLAGS", ""))
 myenv.MergeFlags(env.get("EXPAT_FLAGS", ""))
 
 myenv.Tool("qt4", toolpath = ["#/BuildTools/SCons/Tools"])
 myenv.Tool("nsis", toolpath = ["#/BuildTools/SCons/Tools"])
 myenv.EnableQt4Modules(['QtCore', 'QtGui', 'QtWebKit'], debug = False)
 myenv.Append(CPPPATH = ["/usr/include/phonon"])
 
 myenv.Append(CPPPATH = ["."])
 
 if env["PLATFORM"] == "win32" :
 	#myenv["LINKFLAGS"] = ["/SUBSYSTEM:CONSOLE"]
 	myenv.Append(LINKFLAGS = ["/SUBSYSTEM:WINDOWS"])
 	myenv.Append(LIBS = "qtmain")
 
 myenv.Command("DefaultTheme.qrc", "../resources/themes/Default", Action(generateDefaultTheme, cmdstr = "$GENCOMSTR"))
 
 sources = [
 		"main.cpp",
 		"QtAboutWidget.cpp",
 		"QtAddContactDialog.cpp",
 		"QtChatWindow.cpp",
 		"QtChatWindowFactory.cpp",
-		"QtIdleDetector.cpp",
 		"QtJoinMUCDialog.cpp",
 		"QtLoginWindow.cpp",
 		"QtLoginWindowFactory.cpp",
 		"QtMainWindow.cpp",
 		"QtMainWindowFactory.cpp",
 		"QtSettingsProvider.cpp",
 		"QtStatusWidget.cpp",
 		"QtSwift.cpp",
 		"QtChatView.cpp",
 		"QtChatTabs.cpp",
 		"QtSoundPlayer.cpp",
 		"QtSystemTray.cpp",
 		"QtTabbable.cpp",
 		"QtTextEdit.cpp",
 		"ChatSnippet.cpp",
 		"MessageSnippet.cpp",
 		"SystemMessageSnippet.cpp",
 		"Roster/RosterModel.cpp",
 		"Roster/QtTreeWidget.cpp",
 		"Roster/QtTreeWidgetItem.cpp",
 		"Roster/RosterDelegate.cpp",
 		"EventViewer/EventView.cpp",
 		"EventViewer/EventModel.cpp",
 		"EventViewer/EventDelegate.cpp",
 		"QtRosterHeader.cpp",
 		"qrc_DefaultTheme.cc",
 		"qrc_Swift.cc",
 	]
 
 myenv.BuildVersion("BuildVersion.h", version = ARGUMENTS.get("swift_version", None))
 
 if env["PLATFORM"] == "win32" :
 	myenv.RES("../resources/Windows/Swift.rc")
 	sources += ["../resources/Windows/Swift.res"]
 
 if env["PLATFORM"] == "darwin" or env["PLATFORM"] == "win32" :
 	swiftProgram = myenv.Program("Swift", sources)
 else :
 	swiftProgram = myenv.Program("swift", sources)
 
 myenv.Uic4("QtJoinMUCDialog.ui")
 myenv.Uic4("QtAddContactDialog.ui")
 myenv.Qrc("DefaultTheme.qrc")
 myenv.Qrc("Swift.qrc")
 
 buildVersion = Version.getBuildVersion(ARGUMENTS.get("swift_version", None))
 
 if env["PLATFORM"] == "darwin" :