#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/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/Presence/PresenceSender.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;

: timerFactory_(&boostIOServiceThread_.getIOService()), idleDetector_(&idleQuerier_, &timerFactory_, 100), client_(NULL), presenceSender_(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));

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 presenceSender_;

presenceSender_ = 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));

#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 MainWindowFactory;

class MainWindow;

class NickResolver;

class RosterController;

class XMPPRosterController;

class PresenceSender;

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();

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 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_;

PresenceSender* presenceSender_;

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_;

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_;

};

}

Import("env")

env["SWIFT_CONTROLLERS_FLAGS"] = {

"LIBPATH": [Dir(".")],

"LIBS": ["SwiftControllers"]

}

myenv = env.Clone()

myenv.MergeFlags(env["BOOST_FLAGS"])

myenv.StaticLibrary("SwiftControllers", [

"ChatController.cpp",

"ChatControllerBase.cpp",

"MainController.cpp",

"NickResolver.cpp",

"RosterController.cpp",

"XMPPRosterController.cpp",

"MUCController.cpp",

"EventController.cpp",

"SoundEventController.cpp",

])

env.Append(UNITTEST_SOURCES = [

File("UnitTest/NickResolverTest.cpp"),

File("UnitTest/RosterControllerTest.cpp"),

File("UnitTest/XMPPRosterControllerTest.cpp")

])

#ifndef SWIFTEN_LoginWindowFactory_H

#define SWIFTEN_LoginWindowFactory_H

namespace Swift {

class LoginWindow;

class LoginWindowFactory {

public:

virtual ~LoginWindowFactory() {};

/**

* Transfers ownership of result.

*/

};

}

#endif

#include "QtChatWindowFactory.h"

#include <QDesktopWidget>

#include "QtChatTabs.h"

#include "QtChatWindow.h"

#include "QtSwiftUtil.h"

#include "Roster/QtTreeWidgetFactory.h"

namespace Swift {

settings_ = settings;

if (splitter) {

splitter->addWidget(tabs_);

} else {

QVariant chatTabsGeometryVariant = settings_->getQSettings()->value("chatTabsGeometry");

if (chatTabsGeometryVariant.isValid()) {

tabs_->restoreGeometry(chatTabsGeometryVariant.toByteArray());

}

connect(tabs_, SIGNAL(geometryChanged()), this, SLOT(handleWindowGeometryChanged()));

}

}

ChatWindow* QtChatWindowFactory::createChatWindow(const JID &contact) {

QtChatWindow *chatWindow = new QtChatWindow(P2QSTRING(contact.toString()), treeWidgetFactory_);

tabs_->addTab(chatWindow);

if (!tabs_->isVisible()) {

tabs_->showMinimized();

//tabs_->minimise();

}

//chatWindow->show();

return chatWindow;

}

void QtChatWindowFactory::handleWindowGeometryChanged() {

settings_->getQSettings()->setValue("chatTabsGeometry", tabs_->saveGeometry());

}

}

#ifndef SWIFT_QtChatWindowFactory_H

#define SWIFT_QtChatWindowFactory_H

#include "Swift/Controllers/ChatWindowFactory.h"

#include "Swiften/JID/JID.h"

#include "QtSettingsProvider.h"

#include <QObject>

#include <QSplitter>

namespace Swift {

class QtTreeWidgetFactory;

class QtChatTabs;

class QtChatWindowFactory : public QObject, public ChatWindowFactory {

Q_OBJECT

public:

ChatWindow* createChatWindow(const JID &contact);

private slots:

void handleWindowGeometryChanged();

private:

QtTreeWidgetFactory* treeWidgetFactory_;

QtSettingsProvider* settings_;

QtChatTabs* tabs_;

};

}

#endif

#include "QtLoginWindow.h"

#include "QtAboutWidget.h"

#include "QtSwiftUtil.h"

#include "QtMainWindow.h"

#include <algorithm>

#include <QApplication>

#include <QBoxLayout>

#include <QComboBox>

#include <QDesktopWidget>

#include <QFileDialog>

#include <QStatusBar>

#include <QToolButton>

#include <QLabel>

#include <QMenuBar>

#include <cassert>

namespace Swift{

setWindowTitle("Swift");

resize(200, 500);

setContentsMargins(0,0,0,0);

QWidget *centralWidget = new QWidget(this);

setCentralWidget(centralWidget);

QBoxLayout *topLayout = new QBoxLayout(QBoxLayout::TopToBottom, centralWidget);

stack_ = new QStackedWidget(centralWidget);

topLayout->addWidget(stack_);

topLayout->setMargin(0);

QWidget *wrapperWidget = new QWidget(this);

wrapperWidget->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));

QBoxLayout *layout = new QBoxLayout(QBoxLayout::TopToBottom, wrapperWidget);

layout->addStretch();

QLabel* logo = new QLabel(this);

logo->setPixmap(QPixmap(":/logo-shaded-text.256.png"));

logo->setScaledContents(true);

logo->setFixedSize(192,192);

layout->addWidget(logo);

layout->addStretch();

QLabel* jidLabel = new QLabel(this);

jidLabel->setText("<font size='-1'>User address</font>");

layout->addWidget(jidLabel);

username_ = new QComboBox(this);

username_->setEditable(true);

layout->addWidget(username_);

QLabel* passwordLabel = new QLabel();

passwordLabel->setText("<font size='-1'>Password</font>");

layout->addWidget(passwordLabel);

QWidget* w = new QWidget(this);

w->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));

layout->addWidget(w);

QHBoxLayout* credentialsLayout = new QHBoxLayout(w);

credentialsLayout->setMargin(0);

credentialsLayout->setSpacing(3);

password_ = new QLineEdit(this);

password_->setEchoMode(QLineEdit::Password);

connect(password_, SIGNAL(returnPressed()), this, SLOT(loginClicked()));

connect(username_->lineEdit(), SIGNAL(returnPressed()), password_, SLOT(setFocus()));

connect(username_, SIGNAL(editTextChanged(const QString&)), this, SLOT(handleUsernameTextChanged()));

credentialsLayout->addWidget(password_);

certificateButton_ = new QToolButton(this);

certificateButton_->setCheckable(true);

certificateButton_->setIcon(QIcon(":/icons/certificate.png"));

credentialsLayout->addWidget(certificateButton_);

connect(certificateButton_, SIGNAL(clicked(bool)), SLOT(handleCertficateChecked(bool)));

loginButton_ = new QPushButton(this);

loginButton_->setText(tr("Connect"));

loginButton_->setAutoDefault(true);

loginButton_->setDefault(true);

layout->addWidget(loginButton_);

message_ = new QLabel(this);

message_->setTextFormat(Qt::RichText);

message_->setWordWrap(true);

layout->addWidget(message_);

layout->addStretch();

remember_ = new QCheckBox(tr("Remember Password?"), this);

layout->addWidget(remember_);

connect(loginButton_, SIGNAL(clicked()), SLOT(loginClicked()));

stack_->addWidget(wrapperWidget);

#ifdef SWIFTEN_PLATFORM_MACOSX

menuBar_ = new QMenuBar(NULL);

#else

menuBar_ = menuBar();

#endif

QApplication::setQuitOnLastWindowClosed(false);

swiftMenu_ = new QMenu(tr("Swift"), this);

QAction* aboutAction = new QAction("About Swift", this);

connect(aboutAction, SIGNAL(activated()), SLOT(handleAbout()));

swiftMenu_->addAction(aboutAction);

QAction* quitAction = new QAction("Quit", this);

connect(quitAction, SIGNAL(activated()), SLOT(handleQuit()));

swiftMenu_->addAction(quitAction);

setInitialMenus();

this->show();

}

/**

* Move and resize the window, but respect minimum sizes.

* (Like QWidget::setGeometry, only that will truncate the window

* the setGeometry docs say that it shouldn't do this, but I've just seen it

* maybe we can remove this method if that's a Qt bug (or I'm misusing it)).

*/

void QtLoginWindow::setGentleGeometry(const QRect& rect) {

resize(rect.size());

move(rect.topLeft());

}

QRect QtLoginWindow::defaultPosition() {

QDesktopWidget desktop;

int windowWidth = 200;

int windowHeight = 500;

QRect screen = desktop.screenGeometry(-1); //appear on default screen

windowWidth = std::min(windowWidth, screen.width());

windowHeight = std::min(windowHeight, screen.height());

int left = (screen.width() - windowWidth) / 2;

int height = (screen.height() - windowHeight) / 2;

return QRect(left, height, windowWidth, windowHeight);

}

void QtLoginWindow::addAvailableAccount(const String& defaultJID, const String& defaultPassword, const String& defaultCertificate) {

QString username = P2QSTRING(defaultJID);

int index = -1;

for (int i = 0; i < usernames_.count(); i++) {

if (username == usernames_[i]) {

index = i;

}

}

if (index == -1) {

usernames_.append(username);

passwords_.append(P2QSTRING(defaultPassword));

certificateFiles_.append(P2QSTRING(defaultCertificate));

username_->addItem(username);

} else {

usernames_[index] = username;

passwords_[index] = P2QSTRING(defaultPassword);

}

}

if (!certificateFile_.isEmpty()) {

certificateButton_->setChecked(true);

}

remember_->setChecked(password_->text() != "");

}

void QtLoginWindow::loggedOut() {

if (stack_->count() > 1) {

QWidget* current = stack_->currentWidget();

stack_->setCurrentIndex(0);

stack_->removeWidget(current);

}

setInitialMenus();

setEnabled(true);

}

void QtLoginWindow::loginClicked() {

setEnabled(false);

message_->setText("");

onLoginRequest(Q2PSTRING(username_->currentText()), Q2PSTRING(password_->text()), Q2PSTRING(certificateFile_), remember_->isChecked());

}

void QtLoginWindow::handleCertficateChecked(bool checked) {

if (checked) {

certificateFile_ = QFileDialog::getOpenFileName(this, "Select an authentication certificate", QString(), QString("*.cert"));

if (certificateFile_.isEmpty()) {

certificateButton_->setChecked(false);

}

}

else {

certificateFile_ = "";

}

}

void QtLoginWindow::handleAbout() {

if (!aboutDialog_) {

aboutDialog_ = new QtAboutWidget();

aboutDialog_->show();

}

else {

aboutDialog_->show();

aboutDialog_->raise();

aboutDialog_->activateWindow();

}

}

void QtLoginWindow::handleQuit() {

QApplication::quit();

}

void QtLoginWindow::setInitialMenus() {

menuBar_->clear();

menuBar_->addMenu(swiftMenu_);

}

void QtLoginWindow::morphInto(MainWindow *mainWindow) {

QtMainWindow *qtMainWindow = dynamic_cast<QtMainWindow*>(mainWindow);

assert(qtMainWindow);

stack_->addWidget(qtMainWindow);

stack_->setCurrentWidget(qtMainWindow);

setEnabled(true);

setInitialMenus();

foreach (QMenu* menu, qtMainWindow->getMenus()) {

menuBar_->addMenu(menu);

}

}

void QtLoginWindow::setMessage(const String& message) {

if (!message.isEmpty()) {

message_->setText("<center><font color=\"red\">" + P2QSTRING(message) + "</font></center>");

}

else {

message_->setText("");

}

}

void QtLoginWindow::bringToFront() {

if (isHidden()) {

showNormal();

raise();

activateWindow();

}

else {

hide();

}

}

void QtLoginWindow::resizeEvent(QResizeEvent*) {

emit geometryChanged();

}

void QtLoginWindow::moveEvent(QMoveEvent*) {

emit geometryChanged();

}

}

#ifndef SWIFT_QtLoginWindow_H

#define SWIFT_QtLoginWindow_H

#include <QMainWindow>

#include <QPointer>

#include <QLineEdit>

#include <QPushButton>

#include <QCheckBox>

#include <QStackedWidget>

#include <QMenuBar>

#include "Swift/Controllers/MainWindow.h"

#include "QtAboutWidget.h"

class QLabel;

class QToolButton;

class QComboBox;

namespace Swift {

class QtLoginWindow : public QMainWindow, public LoginWindow {

Q_OBJECT

public:

void morphInto(MainWindow *mainWindow);

virtual void loggedOut();

virtual void setMessage(const String& message);

virtual void addAvailableAccount(const String& defaultJID, const String& defaultPassword, const String& defaultCertificate);

static QRect defaultPosition();

void setGentleGeometry(const QRect&);

signals:

void geometryChanged();

private slots:

void loginClicked();

void handleCertficateChecked(bool);

void handleQuit();

void handleAbout();

void bringToFront();

void handleUsernameTextChanged();

void resizeEvent(QResizeEvent* event);

void moveEvent(QMoveEvent* event);

private:

void setInitialMenus();

QStringList usernames_;

QStringList passwords_;

QStringList certificateFiles_;

QComboBox* username_;

QLineEdit* password_;

QPushButton* loginButton_;

QCheckBox* remember_;

QStackedWidget* stack_;

QLabel* message_;

QString certificateFile_;

QToolButton* certificateButton_;

QMenuBar* menuBar_;

QMenu* swiftMenu_;

QPointer<QtAboutWidget> aboutDialog_;

};

}

#endif

#include "QtLoginWindowFactory.h"

#include "QtLoginWindow.h"

#include <QDesktopWidget>

namespace Swift {

QtLoginWindowFactory::QtLoginWindowFactory(QSplitter* splitter, QtSystemTray* systemTray, QtSettingsProvider* settings) : QObject() {

settings_ = settings;

splitter_ = splitter;

systemTray_ = systemTray;

}

if (splitter_) {

splitter_->insertWidget(0, window_);

return window_;

}

connect(systemTray_, SIGNAL(clicked()), window_, SLOT(bringToFront()));

QVariant loginWindowGeometryVariant = settings_->getQSettings()->value("loginWindowGeometry");

if (loginWindowGeometryVariant.isValid()) {

window_->restoreGeometry(loginWindowGeometryVariant.toByteArray());

}

connect(window_, SIGNAL(geometryChanged()), this, SLOT(handleWindowGeometryChanged()));

return window_;

}

void QtLoginWindowFactory::handleWindowGeometryChanged() {

settings_->getQSettings()->setValue("loginWindowGeometry", window_->saveGeometry());

}

}

#ifndef SWIFT_QtLoginWindowFactory_H

#define SWIFT_QtLoginWindowFactory_H

#include "Swift/QtUI/QtSystemTray.h"

#include <QSplitter>

#include "QtSettingsProvider.h"

namespace Swift {

class QtLoginWindow;

class QtLoginWindowFactory : public QObject, public LoginWindowFactory {

Q_OBJECT

public:

QtLoginWindowFactory(QSplitter* splitter, QtSystemTray* systemTray, QtSettingsProvider* settings);

private slots:

void handleWindowGeometryChanged();

private:

QSplitter* splitter_;

QtSystemTray* systemTray_;

QtSettingsProvider* settings_;

QtLoginWindow* window_;

};

}

#endif

#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 <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_);

rosterWindowFactory_ = new QtMainWindowFactory(treeWidgetFactory_);

soundPlayer_ = new QtSoundPlayer();

if (splitter_) {

splitter_->show();

}

}

QtSwift::~QtSwift() {

delete chatWindowFactory_;

delete rosterWindowFactory_;

delete loginWindowFactory_;

delete treeWidgetFactory_;

delete mainController_;

delete settings_;

delete application_;

delete systemTray_;

delete splitter_;

delete soundPlayer_;

}

}

#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"

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_;

Application* application_;

};

}

#endif

myenv.MergeFlags(env["SWIFT_CONTROLLERS_FLAGS"])

myenv.MergeFlags(env["SWIFTOOLS_FLAGS"])

if myenv["HAVE_XSS"] :

myenv.MergeFlags(env["XSS_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",

"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" :

myenv.AppBundle("Swift", version = buildVersion, resources = ["../resources/MacOSX/Swift.icns"])

if env.get("SWIFT_INSTALLDIR", "") :

env.Install(os.path.join(env["SWIFT_INSTALLDIR"], "bin"), swiftProgram)

if env["PLATFORM"] == "win32" :

if "dist" in COMMAND_LINE_TARGETS or env.GetOption("clean") :

myenv.WindowsBundle("Swift", resources = [

os.path.join(env["OPENSSL_DIR"], "bin", "ssleay32.dll"),

os.path.join(env["OPENSSL_DIR"], "bin", "libeay32.dll"),

],

qtimageformats = ["gif", "ico", "jpeg", "mng", "svg", "tiff"],

qtlibs = ["QtCore4", "QtGui4", "QtNetwork4", "QtWebKit4", "phonon4"])