#include <boost/bind.hpp>

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

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

#include "Swift/Controllers/XMPPEvents/EventController.h"

else if (JoinMUCUIEvent::ref joinEvent = boost::dynamic_pointer_cast<JoinMUCUIEvent>(event)) {

handleJoinMUCRequest(joinEvent->getJID(), joinEvent->getNick(), false);

}

if (!joinMUCWindow_) {

joinMUCWindow_ = joinMUCWindowFactory_->createJoinMUCWindow();

joinMUCWindow_->onJoinMUC.connect(boost::bind(&ChatsManager::handleJoinMUCRequest, this, _1, _2, _3));

joinMUCWindow_->onSearchMUC.connect(boost::bind(&ChatsManager::handleSearchMUCRequest, this));

}

joinMUCWindow_->setNick(nickResolver_->jidToNick(jid_));

joinMUCWindow_->show();

}

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/String.h>

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include <Swiften/Disco/GetDiscoInfoRequest.h>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

#include <Swift/Controllers/DiscoServiceWalker.h>

#include <Swift/Controllers/UIEvents/UIEventStream.h>

#include <Swift/Controllers/UIEvents/RequestChatWithUserDialogUIEvent.h>

#include <Swift/Controllers/DiscoServiceWalker.h>

#include <Swiften/Base/Log.h>

#include <boost/bind.hpp>

#include "Swiften/Network/NetworkFactories.h"

#include <Swift/Controllers/ProfileController.h>

#include <Swift/Controllers/ContactEditController.h>

namespace Swift {

CertificateStorageFactory* certificateStorageFactory,

Dock* dock,

Notifier* notifier,

bool useDelayForLatency) :

eventLoop_(eventLoop),

networkFactories_(networkFactories),

storagesFactory_(storagesFactory),

certificateStorageFactory_(certificateStorageFactory),

settings_(settings),

loginWindow_(NULL) ,

useDelayForLatency_(useDelayForLatency) {

storages_ = NULL;

loginWindow_ = uiFactory_->createLoginWindow(uiEventStream_);

soundEventController_ = new SoundEventController(eventController_, soundPlayer, settings, uiEventStream_);

std::string selectedLoginJID = settings_->getStringSetting("lastLoginJID");

bool loginAutomatically = settings_->getBoolSetting("loginAutomatically", false);

std::string cachedPassword;

resetClient();

delete xmlConsoleController_;

delete soundEventController_;

delete systemTrayController_;

delete eventController_;

class Storages;

class StoragesFactory;

class NetworkFactories;

class MainController {

public:

CertificateStorageFactory* certificateStorageFactory,

Dock* dock,

Notifier* notifier,

bool useDelayForLatency);

~MainController();

SettingsProvider *settings_;

ProfileSettingsProvider* profileSettings_;

Dock* dock_;

TogglableNotifier* notifier_;

PresenceNotifier* presenceNotifier_;

EventNotifier* eventNotifier_;

JID boundJID_;

SystemTrayController* systemTrayController_;

SoundEventController* soundEventController_;

std::string vCardPhotoHash_;

std::string password_;

std::string certificateFile_;

#pragma once

#include "Swift/Controllers/Settings/SettingsProvider.h"

namespace Swift {

#include "Swift/Controllers/Roster/ContactRosterItem.h"

#include "Swift/Controllers/Roster/GroupRosterItem.h"

namespace Swift {

#include <boost/bind.hpp>

#include <vector>

#include "Swiften/Base/String.h"

#include "Swift/Controllers/Roster/GroupRosterItem.h"

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include "Swift/Controllers/Roster/RosterController.h"

#include "Swift/Controllers/UnitTest/MockMainWindowFactory.h"

// #include "Swiften/Elements/Payload.h"

"CertificateFileStorage.cpp",

"StatusUtil.cpp",

"Translator.cpp",

])

env.Append(UNITTEST_SOURCES = [

#pragma once

#include <boost/shared_ptr.hpp>

#include <string>

#include <Swift/Controllers/UIEvents/UIEvent.h>

namespace Swift {

class RequestJoinMUCUIEvent : public UIEvent {

public:

typedef boost::shared_ptr<RequestJoinMUCUIEvent> ref;

}

};

}

#include <boost/bind.hpp>

#include <algorithm>

#include "Swift/Controllers/XMPPEvents/MessageEvent.h"

#include "Swift/Controllers/XMPPEvents/ErrorEvent.h"

#include "Swift/Controllers/XMPPEvents/SubscriptionRequestEvent.h"

Swift

BuildVersion.h

*.dmg

//qApp->processEvents();

}

void QtChatView::replaceLastMessage(const QString& newMessage) {

assert(viewReady_);

/* FIXME: must be queued? */

Q_OBJECT

public:

QtChatView(QtChatTheme* theme, QWidget* parent);

void addMessage(boost::shared_ptr<ChatSnippet> snippet);

void replaceLastMessage(const QString& newMessage);

void replaceLastMessage(const QString& newMessage, const QString& note);

void rememberScrolledToBottom();

QtChatTheme* theme_;

QWebElement newInsertPoint_;

QWebElement lastElement_;

QWebElement document_;

};

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

layout->setContentsMargins(0,0,0,0);

layout->setSpacing(2);

QSplitter *logRosterSplitter = new QSplitter(this);

logRosterSplitter->setAutoFillBackground(true);

input_ = new QtTextEdit(this);

input_->setAcceptRichText(false);

layout->addWidget(input_);

inputClearing_ = false;

contactIsTyping_ = false;

}

void QtChatWindow::setRosterModel(Roster* roster) {

}

void QtChatWindow::setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels) {

Q_UNUSED(old);

Q_UNUSED(now);

if (isWidgetSelected()) {

input_->setFocus();

onAllMessagesRead();

}

}

void QtChatWindow::setInputEnabled(bool enabled) {

QtTabbable::AlertType QtChatWindow::getWidgetAlertState() {

if (contactIsTyping_) {

return ImpendingActivity;

if (unreadCount_ > 0) {

return WaitingActivity;

}

if (isWidgetSelected()) {

onAllMessagesRead();

}

QString scaledAvatarPath = QtScaledAvatarCache(32).getScaledAvatarPath(avatarPath.c_str());

QString htmlString;

htmlString += styleSpanStart + messageHTML + styleSpanEnd;

bool appendToPrevious = !previousMessageWasSystem_ && !previousMessageWasPresence_ && ((senderIsSelf && previousMessageWasSelf_) || (!senderIsSelf && !previousMessageWasSelf_ && previousSenderName_ == P2QSTRING(senderName)));

QString qAvatarPath = scaledAvatarPath.isEmpty() ? "qrc:/icons/avatar.png" : QUrl::fromLocalFile(scaledAvatarPath).toEncoded();

std::string id = id_.generateID();

messageLog_->addMessage(boost::shared_ptr<ChatSnippet>(new MessageSnippet(htmlString, Qt::escape(P2QSTRING(senderName)), B2QDATE(time), qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id))));

}

void QtChatWindow::moveEvent(QMoveEvent*) {

}

void QtChatWindow::replaceLastMessage(const std::string& message) {

* See Documentation/Licenses/GPLv3.txt for more information.

*/

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

#include "QtTabbable.h"

#include "Swiften/Base/IDGenerator.h"

class QTextEdit;

int unreadCount_;

bool contactIsTyping_;

QString contact_;

QtChatView* messageLog_;

QtChatTheme* theme_;

IDGenerator id_;

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

stack_ = new QStackedWidget(centralWidget);

topLayout->addWidget(stack_);

topLayout->setMargin(0);

layout->addStretch(2);

QLabel* logo = new QLabel(this);

layout->addWidget(loginAutomatically_);

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

#ifdef SWIFTEN_PLATFORM_MACOSX

menuBar_ = new QMenuBar(NULL);

#else

}

void QtLoginWindow::loggedOut() {

setInitialMenus();

setIsLoggingIn(false);

}

void QtLoginWindow::morphInto(MainWindow *mainWindow) {

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

assert(qtMainWindow);

stack_->addWidget(qtMainWindow);

stack_->setCurrentWidget(qtMainWindow);

setEnabled(true);

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <QMainWindow>

#include <QPointer>

private:

void setInitialMenus();

QStringList usernames_;

QStringList passwords_;

QStringList certificateFiles_;

QPointer<QtAboutWidget> aboutDialog_;

};

}

#include "Swift/Controllers/BuildVersion.h"

#include "SwifTools/AutoUpdater/AutoUpdater.h"

#include "SwifTools/AutoUpdater/PlatformAutoUpdaterFactory.h"

#if defined(SWIFTEN_PLATFORM_WINDOWS)

#include "WindowsNotifier.h"

#include "SwifTools/Notifier/GrowlNotifier.h"

#elif defined(SWIFTEN_PLATFORM_LINUX)

#include "FreeDesktopNotifier.h"

#else

#include "SwifTools/Notifier/NullNotifier.h"

#endif

#if defined(SWIFTEN_PLATFORM_MACOSX)

#include "SwifTools/Dock/MacOSXDock.h"

#include "SwifTools/Dock/NullDock.h"

namespace Swift{

dock_ = new NullDock();

#endif

if (splitter_) {

splitter_->show();

}

certificateStorageFactory_,

dock_,

notifier_,

options.count("latency-debug") > 0);

mainControllers_.push_back(mainController);

}

}

delete tabs_;

delete splitter_;

delete dock_;

delete soundPlayer_;

delete chatWindowFactory_;

class QtMUCSearchWindowFactory;

class QtUserSearchWindowFactory;

class EventLoop;

class QtSwift : public QObject {

Q_OBJECT

QSplitter* splitter_;

QtSoundPlayer* soundPlayer_;

Dock* dock_;

QtChatTabs* tabs_;

ApplicationPathProvider* applicationPathProvider_;

StoragesFactory* storagesFactory_;

"QtStatusWidget.cpp",

"QtScaledAvatarCache.cpp",

"QtSwift.cpp",

"QtChatView.cpp",

"QtChatTheme.cpp",

"QtChatTabs.cpp",

myenv["SWIFT_VERSION"] = Version.getBuildVersion("swift")

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

sources += [

"WindowsNotifier.cpp",

"../resources/Windows/Swift.res"

]

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

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

swiftProgram = myenv.Program("Swift", sources)

else :

swiftProgram = myenv.Program("swift", sources)

myenv.Uic4("MUCSearch/QtMUCSearchWindow.ui")

myenv.Uic4("UserSearch/QtUserSearchWizard.ui")

myenv.Uic4("UserSearch/QtUserSearchFirstPage.ui")

if env["HAVE_GROWL"] :

frameworks.append(env["GROWL_FRAMEWORK"])

commonResources[""] = commonResources.get("", []) + ["../resources/MacOSX/Swift.icns"]

if env["DIST"] :

myenv.Command(["Swift-${SWIFT_VERSION}.dmg"], [app], ["Swift/Packaging/MacOSX/package.sh " + app.path + " Swift/Packaging/MacOSX/Swift.dmg.gz $TARGET $QTDIR"])

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

env.InstallAs(os.path.join(env["SWIFT_INSTALLDIR"], "share", "pixmaps", "swift.xpm"), "../resources/logo/logo-icon-32.xpm")

icons_path = os.path.join(env["SWIFT_INSTALLDIR"], "share", "icons", "hicolor")

env.InstallAs(os.path.join(icons_path, "32x32", "apps", "swift.xpm"), "../resources/logo/logo-icon-32.xpm")