#include <boost/bind.hpp>

#include <algorithm>

namespace Swift {

onEventQueueLengthChange(events_.size());

}

}

events_.erase(std::remove(events_.begin(), events_.end(), event), events_.end());

onEventQueueLengthChange(events_.size());

}

#include <boost/shared_ptr.hpp>

#include <vector>

#include "Swiften/Events/MessageEvent.h"

namespace Swift {

class EventController {

public:

boost::signal<void (int)> onEventQueueLengthChange;

private:

};

}

#endif

#include "Swift/Controllers/UIInterfaces/ChatWindowFactory.h"

#include "Swift/Controllers/Chat/ChatsManager.h"

#include "Swift/Controllers/EventController.h"

#include "Swift/Controllers/UIInterfaces/LoginWindow.h"

#include "Swift/Controllers/UIInterfaces/LoginWindowFactory.h"

#include "Swift/Controllers/MainWindow.h"

#include "Swift/Controllers/MainWindowFactory.h"

#include "Swift/Controllers/Chat/MUCController.h"

static const String CLIENT_NODE = "http://swift.im";

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

chatsManager_ = NULL;

uiEventStream_ = new UIEventStream();

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

delete avatarStorage_;

delete xmlConsoleController_;

delete uiEventStream_;

resetClient();

}

nickResolver_ = NULL;

delete avatarManager_;

avatarManager_ = NULL;

delete rosterController_;

rosterController_ = NULL;

delete xmppRosterController_;

xmppRoster_ = boost::shared_ptr<XMPPRoster>(new XMPPRoster());

presenceOracle_ = new PresenceOracle(client_);

nickResolver_ = new NickResolver(xmppRoster_);

lastSentPresence_ = boost::shared_ptr<Presence>();

client_->onPresenceReceived.connect(boost::bind(&MainController::handleIncomingPresence, this, _1));

avatarManager_ = new AvatarManager(client_, client_, avatarStorage_, chatsManager_);

chatsManager_->setAvatarManager(avatarManager_);

rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, treeWidgetFactory_, nickResolver_);

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

class XMLConsoleController;

class UIEventStream;

class XMLConsoleWidgetFactory;

class MainController {

public:

~MainController();

MainWindowFactory* mainWindowFactory_;

LoginWindowFactory* loginWindowFactory_;

TreeWidgetFactory* treeWidgetFactory_;

SettingsProvider *settings_;

Application* application_;

AvatarStorage* avatarStorage_;

XMPPRosterController* xmppRosterController_;

RosterController* rosterController_;

EventController* eventController_;

LoginWindow* loginWindow_;

SoftwareVersionResponder* clientVersionResponder_;

NickResolver* nickResolver_;

"XMPPRosterController.cpp",

"Chat/MUCController.cpp",

"EventController.cpp",

"SoundEventController.cpp",

"SystemTrayController.cpp",

"XMLConsoleController.cpp",

SoundEventController::SoundEventController(EventController* eventController, SoundPlayer* soundPlayer, bool playSounds) {

eventController_ = eventController;

soundPlayer_ = soundPlayer;

playSounds_ = playSounds;

}

if (playSounds_) soundPlayer_->playSound(SoundPlayer::MessageReceived);

}

#include <boost/shared_ptr.hpp>

namespace Swift {

class EventController;

SoundEventController(EventController* eventController, SoundPlayer* soundPlayer, bool playSounds);

void setPlaySounds(bool playSounds);

private:

EventController* eventController_;

SoundPlayer* soundPlayer_;

bool playSounds_;

namespace Swift {

SystemTrayController::SystemTrayController(EventController* eventController, SystemTray* systemTray) {

systemTray_ = systemTray;

eventController_->onEventQueueLengthChange.connect(boost::bind(&SystemTrayController::handleEventQueueLengthChange, this, _1));

}

class SystemTrayController {

public:

private:

void handleEventQueueLengthChange(int length);

#include "EventModel.h"

namespace Swift {

EventModel::EventModel() {

}

EventModel::~EventModel() {

}

}

}

}

#pragma once

#include <QAbstractListModel>

#include <QList>

namespace Swift {

class EventModel : public QAbstractListModel {

Q_OBJECT

public:

EventModel();

~EventModel();

QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;

int rowCount(const QModelIndex& parent = QModelIndex()) const;

};

}

tabs_->addTab(contactsTabWidget_, "Contacts");

this->setLayout(mainLayout);

chatMenu->addAction(signOutAction);

}

void QtMainWindow::handleAddActionTriggered(bool checked) {

Q_UNUSED(checked);

QtAddContactDialog* addContact = new QtAddContactDialog(this);

#include <QMenu>

#include "Swift/Controllers/MainWindow.h"

#include "Swift/QtUI/QtRosterHeader.h"

#include <vector>

void setMyAvatarPath(const String& path);

void setMyStatusText(const String& status);

void setMyStatusType(const StatusShow::Type type);

private slots:

void handleStatusChanged(StatusShow::Type showType, const QString &statusMessage);

void handleShowOfflineToggled(bool);

QTabWidget* tabs_;

QWidget* contactsTabWidget_;

QWidget* eventsTabWidget_;

};

}

namespace Swift {

QtMainWindowFactory::QtMainWindowFactory(QtTreeWidgetFactory *treeWidgetFactory) : treeWidgetFactory_(treeWidgetFactory) {

}

MainWindow* QtMainWindowFactory::createMainWindow() {

QtMainWindow* window = new QtMainWindow(treeWidgetFactory_);

return window;

}

}

public:

QtMainWindowFactory(QtTreeWidgetFactory *treeWidgetFactory);

MainWindow* createMainWindow();

private:

QtTreeWidgetFactory *treeWidgetFactory_;

};

}

#include "QtSystemTray.h"

#include "QtSoundPlayer.h"

#include "QtXMLConsoleWidgetFactory.h"

#include <boost/bind.hpp>

#include <QSplitter>

loginWindowFactory_ = new QtLoginWindowFactory(splitter_, systemTray_, settings_);

chatWindowFactory_ = new QtChatWindowFactory(treeWidgetFactory_, splitter_, settings_, tabs_);

rosterWindowFactory_ = new QtMainWindowFactory(treeWidgetFactory_);

xmlConsoleWidgetFactory_ = new QtXMLConsoleWidgetFactory(tabs_);

soundPlayer_ = new QtSoundPlayer();

if (splitter_) {

splitter_->show();

}

PlatformAutoUpdaterFactory autoUpdaterFactory;

if (autoUpdaterFactory.isSupported()) {

delete soundPlayer_;

delete tabs_;

delete xmlConsoleWidgetFactory_;

}

}

class QtXMLConsoleWidgetFactory;

class QtSystemTray;

class QtSoundPlayer;

class QtSwift : public QObject {

Q_OBJECT

QSplitter* splitter_;

QtSoundPlayer* soundPlayer_;

QtChatTabs* tabs_;

Application* application_;

AutoUpdater* autoUpdater_;

};

"Roster/QtTreeWidget.cpp",

"Roster/QtTreeWidgetItem.cpp",

"Roster/RosterDelegate.cpp",

"EventViewer/EventModel.cpp",

"EventViewer/EventDelegate.cpp",

"QtRosterHeader.cpp",

"qrc_DefaultTheme.cc",

"qrc_Swift.cc",

#include <cassert>

#include <boost/signals.hpp>

#include <boost/shared_ptr.hpp>

namespace Swift {

boost::shared_ptr<Message> getStanza() {return stanza_;}

bool isReadable() {

return getStanza()->isError() || !getStanza()->getBody().isEmpty();

void read() {

assert (isReadable());

}

private: