/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swift/Controllers/AdHocManager.h>

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/AdHoc/OutgoingAdHocCommandSession.h>

#include <Swift/Controllers/UIInterfaces/MainWindow.h>

#include <Swift/Controllers/UIInterfaces/AdHocCommandWindowFactory.h>

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

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

namespace Swift {

AdHocManager::AdHocManager(const JID& jid, AdHocCommandWindowFactory* factory, IQRouter* iqRouter, UIEventStream* uiEventStream, MainWindow* mainWindow) : jid_(jid) {

iqRouter_ = iqRouter;

uiEventStream_ = uiEventStream;

mainWindow_ = mainWindow;

factory_ = factory;

uiEventStream_->onUIEvent.connect(boost::bind(&AdHocManager::handleUIEvent, this, _1));

}

AdHocManager::~AdHocManager() {

uiEventStream_->onUIEvent.disconnect(boost::bind(&AdHocManager::handleUIEvent, this, _1));

}

void AdHocManager::setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info) {

if (iqRouter_->isAvailable() && info->hasFeature(DiscoInfo::CommandsFeature)) {

if (discoItemsRequest_) {

discoItemsRequest_->onResponse.disconnect(boost::bind(&AdHocManager::handleServerDiscoItemsResponse, this, _1, _2));

discoItemsRequest_.reset();

}

discoItemsRequest_ = GetDiscoItemsRequest::create(JID(jid_.getDomain()), DiscoInfo::CommandsFeature, iqRouter_);

discoItemsRequest_->onResponse.connect(boost::bind(&AdHocManager::handleServerDiscoItemsResponse, this, _1, _2));

discoItemsRequest_->send();

} else {

mainWindow_->setAvailableAdHocCommands(std::vector<DiscoItems::Item>());

}

}

void AdHocManager::handleServerDiscoItemsResponse(boost::shared_ptr<DiscoItems> items, ErrorPayload::ref error) {

std::vector<DiscoItems::Item> commands;

if (!error) {

foreach (DiscoItems::Item item, items->getItems()) {

if (item.getNode() != "http://isode.com/xmpp/commands#test") {

commands.push_back(item);

}

}

}

mainWindow_->setAvailableAdHocCommands(commands);

}

void AdHocManager::handleUIEvent(boost::shared_ptr<UIEvent> event) {

boost::shared_ptr<RequestAdHocUIEvent> adHocEvent = boost::dynamic_pointer_cast<RequestAdHocUIEvent>(event);

if (adHocEvent) {

}

}

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <vector>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/DiscoItems.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

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

namespace Swift {

}

#endif

#ifdef SWIFT_EXPERIMENTAL_WB

discoInfo.addFeature(DiscoInfo::WhiteboardFeature);

#endif

discoInfo.addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);

client_->getDiscoManager()->setCapsNode(CLIENT_NODE);

client_->getDiscoManager()->setDiscoInfo(discoInfo);

userSearchControllerChat_ = new UserSearchController(UserSearchController::StartChat, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithRoster_, client_->getAvatarManager(), client_->getPresenceOracle());

userSearchControllerAdd_ = new UserSearchController(UserSearchController::AddContact, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithoutRoster_, client_->getAvatarManager(), client_->getPresenceOracle());

adHocManager_ = new AdHocManager(JID(boundJID_.getDomain()), uiFactory_, client_->getIQRouter(), uiEventStream_, rosterController_->getWindow());

chatsManager_->onImpromptuMUCServiceDiscovered.connect(boost::bind(&UserSearchController::setCanInitiateImpromptuMUC, userSearchControllerChat_, _1));

}

loginWindow_->setIsLoggingIn(false);

client_->requestRoster();

GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(JID(boundJID_.getDomain()), client_->getIQRouter());

discoInfoRequest->onResponse.connect(boost::bind(&MainController::handleServerDiscoInfoResponse, this, _1, _2));

discoInfoRequest->send();

client_->getVCardManager()->requestOwnVCard();

rosterController_->setJID(boundJID_);

rosterController_->setEnabled(true);

rosterController_->getWindow()->setStreamEncryptionStatus(client_->isStreamEncrypted());

profileController_->setAvailable(true);

contactEditController_->setAvailable(true);

/* Send presence later to catch all the incoming presences. */

sendPresence(statusTracker_->getNextPresence());

/* Enable chats last of all, so rejoining MUCs has the right sent presence */

assert(chatsManager_);

chatsManager_->setOnline(true);

}

void MainController::handleEventQueueLengthChange(int count) {

dock_->setNumberOfPendingMessages(count);

}

void MainController::reconnectAfterError() {

if (reconnectTimer_) {

reconnectTimer_->stop();

}

performLoginFromCachedCredentials();

}

void MainController::handleChangeStatusRequest(StatusShow::Type show, const std::string &statusText) {

boost::shared_ptr<Presence> presence(new Presence());

if (show == StatusShow::None) {

// Note: this is misleading, None doesn't mean unavailable on the wire.

presence->setType(Presence::Unavailable);

resetPendingReconnects();

myStatusLooksOnline_ = false;

offlineRequested_ = true;

}

else {

offlineRequested_ = false;

presence->setShow(show);

}

presence->setStatus(statusText);

statusTracker_->setRequestedPresence(presence);

if (presence->getType() != Presence::Unavailable) {

profileSettings_->storeInt("lastShow", presence->getShow());

profileSettings_->storeString("lastStatus", presence->getStatus());

}

if (presence->getType() != Presence::Unavailable && !client_->isAvailable()) {

performLoginFromCachedCredentials();

} else {

client_->onConnected.connect(boost::bind(&MainController::handleConnected, this));

client_->setSoftwareVersion(CLIENT_NAME, buildVersion);

client_->getVCardManager()->onVCardChanged.connect(boost::bind(&MainController::handleVCardReceived, this, _1, _2));

presenceNotifier_ = new PresenceNotifier(client_->getStanzaChannel(), notifier_, client_->getMUCRegistry(), client_->getAvatarManager(), client_->getNickResolver(), client_->getPresenceOracle(), networkFactories_->getTimerFactory());

presenceNotifier_->onNotificationActivated.connect(boost::bind(&MainController::handleNotificationClicked, this, _1));

eventNotifier_ = new EventNotifier(eventController_, notifier_, client_->getAvatarManager(), client_->getNickResolver());

eventNotifier_->onNotificationActivated.connect(boost::bind(&MainController::handleNotificationClicked, this, _1));

if (certificate_ && !certificate_->isNull()) {

client_->setCertificate(certificate_);

}

boost::shared_ptr<Presence> presence(new Presence());

presence->setShow(static_cast<StatusShow::Type>(profileSettings_->getIntSetting("lastShow", StatusShow::Online)));

presence->setStatus(profileSettings_->getStringSetting("lastStatus"));

statusTracker_->setRequestedPresence(presence);

} else {

/* In case we're in the middle of another login, make sure they don't overlap */

client_->disconnect();

}

systemTrayController_->setConnecting();

if (rosterController_) {

rosterController_->getWindow()->setConnecting();

}

ClientOptions clientOptions = clientOptions_;

bool eagle = settings_->getSetting(SettingConstants::FORGET_PASSWORDS);

clientOptions.forgetPassword = eagle;

clientOptions.useTLS = eagle ? ClientOptions::RequireTLS : clientOptions_.useTLS;

client_->connect(clientOptions);

}

void MainController::handleDisconnected(const boost::optional<ClientError>& error) {

if (rosterController_) {

rosterController_->getWindow()->setStreamEncryptionStatus(false);

}

if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

purgeCachedCredentials();

}

if (quitRequested_) {

resetClient();

loginWindow_->quit();

}

else if (error) {

std::string message;

std::string certificateErrorMessage;

bool forceSignout = false;

switch(error->getType()) {

case ClientError::UnknownError: message = QT_TRANSLATE_NOOP("", "Unknown Error"); break;

case ClientError::DomainNameResolveError: message = QT_TRANSLATE_NOOP("", "Unable to find server"); break;

case ClientError::ConnectionError: message = QT_TRANSLATE_NOOP("", "Error connecting to server"); break;

case ClientError::ConnectionReadError: message = QT_TRANSLATE_NOOP("", "Error while receiving server data"); break;

case ClientError::ConnectionWriteError: message = QT_TRANSLATE_NOOP("", "Error while sending data to the server"); break;

case ClientError::XMLError: message = QT_TRANSLATE_NOOP("", "Error parsing server data"); break;

case ClientError::AuthenticationFailedError: message = QT_TRANSLATE_NOOP("", "Login/password invalid"); break;

case ClientError::CompressionFailedError: message = QT_TRANSLATE_NOOP("", "Error while compressing stream"); break;

case ClientError::ServerVerificationFailedError: message = QT_TRANSLATE_NOOP("", "Server verification failed"); break;

case ClientError::NoSupportedAuthMechanismsError: message = QT_TRANSLATE_NOOP("", "Authentication mechanisms not supported"); break;

case ClientError::UnexpectedElementError: message = QT_TRANSLATE_NOOP("", "Unexpected response"); break;

case ClientError::ResourceBindError: message = QT_TRANSLATE_NOOP("", "Error binding resource"); break;

case ClientError::SessionStartError: message = QT_TRANSLATE_NOOP("", "Error starting session"); break;

case ClientError::StreamError: message = QT_TRANSLATE_NOOP("", "Stream error"); break;

case ClientError::TLSError: message = QT_TRANSLATE_NOOP("", "Encryption error"); break;

case ClientError::ClientCertificateLoadError: message = QT_TRANSLATE_NOOP("", "Error loading certificate (Invalid password?)"); break;

case ClientError::ClientCertificateError: message = QT_TRANSLATE_NOOP("", "Certificate not authorized"); break;

case ClientError::CertificateCardRemoved: message = QT_TRANSLATE_NOOP("", "Certificate card removed"); forceSignout = true; break;

case ClientError::UnknownCertificateError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Unknown certificate"); break;

case ClientError::CertificateExpiredError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate has expired"); break;

case ClientError::CertificateNotYetValidError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate is not yet valid"); break;

case ClientError::CertificateSelfSignedError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate is self-signed"); break;

"Chat/ChatController.cpp",

"Chat/ChatControllerBase.cpp",

"Chat/ChatsManager.cpp",

"Chat/MUCController.cpp",

"Chat/MUCSearchController.cpp",

"Chat/UserSearchController.cpp",

"Chat/ChatMessageParser.cpp",

"ContactSuggester.cpp",

"MainController.cpp",

"ProfileController.cpp",

"ShowProfileController.cpp",

"ContactEditController.cpp",

"FileTransfer/FileTransferController.cpp",

"FileTransfer/FileTransferOverview.cpp",

"FileTransfer/FileTransferProgressInfo.cpp",

"Roster/RosterController.cpp",

"Roster/RosterGroupExpandinessPersister.cpp",

"Roster/ContactRosterItem.cpp",

"Roster/GroupRosterItem.cpp",

"Roster/RosterItem.cpp",

"Roster/Roster.cpp",

"Roster/RosterVCardProvider.cpp",

"Roster/TableRoster.cpp",

"EventWindowController.cpp",

"SoundEventController.cpp",

"SystemTrayController.cpp",

"XMLConsoleController.cpp",

"HistoryViewController.cpp",

"HistoryController.cpp",

"FileTransferListController.cpp",

"BlockListController.cpp",

"StatusTracker.cpp",

"PresenceNotifier.cpp",

"EventNotifier.cpp",

"AdHocManager.cpp",

"XMPPEvents/EventController.cpp",

"UIEvents/UIEvent.cpp",

"UIInterfaces/XMLConsoleWidget.cpp",

"UIInterfaces/ChatListWindow.cpp",

"PreviousStatusStore.cpp",

"ProfileSettingsProvider.cpp",

"Settings/SettingsProviderHierachy.cpp",

"Settings/XMLSettingsProvider.cpp",

"Storages/CertificateStorageFactory.cpp",

"Storages/CertificateStorage.cpp",

"Storages/CertificateFileStorage.cpp",

"Storages/CertificateMemoryStorage.cpp",

"Storages/AvatarFileStorage.cpp",

"Storages/FileStorages.cpp",

"Storages/RosterFileStorage.cpp",

"Storages/CapsFileStorage.cpp",

"Storages/VCardFileStorage.cpp",

"StatusUtil.cpp",

"Translator.cpp",

"XMPPURIController.cpp",

"ChatMessageSummarizer.cpp",

"SettingConstants.cpp",

"WhiteboardManager.cpp",

"StatusCache.cpp",

"HighlightAction.cpp",

"HighlightEditorController.cpp",

"HighlightManager.cpp",

"HighlightRule.cpp",

"Highlighter.cpp",

"ContactsFromXMPPRoster.cpp",

"ContactProvider.cpp",

"Contact.cpp"

])

env.Append(UNITTEST_SOURCES = [

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

namespace Swift {

class AdHocCommandWindow {

public:

virtual ~AdHocCommandWindow() {}

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <Swift/Controllers/UIInterfaces/AdHocCommandWindow.h>

#include <Swiften/AdHoc/OutgoingAdHocCommandSession.h>

namespace Swift {

class AdHocCommandWindowFactory {

public:

virtual ~AdHocCommandWindowFactory() {}

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <boost/bind.hpp>

#include <QBoxLayout>

#include <Swift/QtUI/QtFormWidget.h>

#include <Swift/QtUI/QtSwiftUtil.h>

const int FormLayoutIndex = 1;

namespace Swift {

QtAdHocCommandWindow::QtAdHocCommandWindow(boost::shared_ptr<OutgoingAdHocCommandSession> command) : command_(command) {

formWidget_ = NULL;

setAttribute(Qt::WA_DeleteOnClose);

command->onNextStageReceived.connect(boost::bind(&QtAdHocCommandWindow::handleNextStageReceived, this, _1));

command->onError.connect(boost::bind(&QtAdHocCommandWindow::handleError, this, _1));

command->start();

layout_ = new QBoxLayout(QBoxLayout::TopToBottom, this);

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

layout_->setSpacing(2);

label_ = new QLabel(this);

label_->setTextFormat(Qt::PlainText);

layout_->addWidget(label_);

QWidget* buttonsWidget = new QWidget(this);

layout_->addWidget(buttonsWidget);

QBoxLayout* buttonsLayout = new QBoxLayout(QBoxLayout::LeftToRight, buttonsWidget);

cancelButton_ = new QPushButton(tr("Cancel"), buttonsWidget);

buttonsLayout->addWidget(cancelButton_);

connect(cancelButton_, SIGNAL(clicked()), this, SLOT(handleCancelClicked()));

backButton_ = new QPushButton(tr("Back"), buttonsWidget);

buttonsLayout->addWidget(backButton_);

connect(backButton_, SIGNAL(clicked()), this, SLOT(handlePrevClicked()));

nextButton_ = new QPushButton(tr("Next"), buttonsWidget);

buttonsLayout->addWidget(nextButton_);

connect(nextButton_, SIGNAL(clicked()), this, SLOT(handleNextClicked()));

completeButton_ = new QPushButton(tr("Complete"), buttonsWidget);

buttonsLayout->addWidget(completeButton_);

connect(completeButton_, SIGNAL(clicked()), this, SLOT(handleCompleteClicked()));

nextButton_->setEnabled(false);

backButton_->setEnabled(false);

completeButton_->setEnabled(false);

actions_[Command::Next] = nextButton_;

actions_[Command::Prev] = backButton_;

actions_[Command::Complete] = completeButton_;

actions_[Command::Cancel] = cancelButton_;

}

QtAdHocCommandWindow::~QtAdHocCommandWindow() {

}

void QtAdHocCommandWindow::handleCancelClicked() {

command_->cancel();

close();

}

void QtAdHocCommandWindow::handlePrevClicked() {

command_->goBack();

}

void QtAdHocCommandWindow::handleNextClicked() {

command_->goNext(formWidget_ ? formWidget_->getCompletedForm() : Form::ref());

}

void QtAdHocCommandWindow::handleCompleteClicked() {

command_->complete(formWidget_ ? formWidget_->getCompletedForm() : Form::ref());

}

void QtAdHocCommandWindow::handleNextStageReceived(Command::ref command) {

QString notes;

foreach (Command::Note note, command->getNotes()) {

if (!notes.isEmpty()) {

notes += "\n";

}

QString qNote(P2QSTRING(note.note));

switch (note.type) {

case Command::Note::Error: notes += tr("Error: %1").arg(qNote); break;

case Command::Note::Warn: notes += tr("Warning: %1").arg(qNote); break;

case Command::Note::Info: notes += qNote; break;

}

}

label_->setText(notes);

if (command->getForm()) {

setForm(command->getForm());

/*

* Copyright (c) 2010-2012 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <QWidget>

#include <QPushButton>

#include <QLabel>

#include <Swift/Controllers/UIInterfaces/AdHocCommandWindow.h>

#include <Swiften/AdHoc/OutgoingAdHocCommandSession.h>

class QBoxLayout;

namespace Swift {

class QtFormWidget;

class QtAdHocCommandWindow : public QWidget, public AdHocCommandWindow {

Q_OBJECT

public:

QtAdHocCommandWindow(boost::shared_ptr<OutgoingAdHocCommandSession> command);

virtual ~QtAdHocCommandWindow();

private:

void handleNextStageReceived(Command::ref command);

void handleError(ErrorPayload::ref error);

void setForm(Form::ref);

void setNoForm(bool andHide);

void setAvailableActions(Command::ref commandResult);

private slots:

void handleCancelClicked();

void handlePrevClicked();

void handleNextClicked();

void handleCompleteClicked();

private:

boost::shared_ptr<OutgoingAdHocCommandSession> command_;

QtFormWidget* formWidget_;

Form::ref form_;

QLabel* label_;

QPushButton* backButton_;

QPushButton* nextButton_;

QPushButton* completeButton_;

QPushButton* cancelButton_;

std::map<Command::Action, QPushButton*> actions_;

QBoxLayout* layout_;

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swift/QtUI/QtUIFactory.h>

#include <QSplitter>

#include <Swift/QtUI/QtXMLConsoleWidget.h>

#include <Swift/QtUI/QtChatTabs.h>

#include <Swift/QtUI/QtMainWindow.h>

#include <Swift/QtUI/QtLoginWindow.h>

#include <Swift/QtUI/QtSystemTray.h>

#include <Swift/QtUI/QtSettingsProvider.h>

#include <Swift/QtUI/QtMainWindow.h>

#include <Swift/QtUI/QtChatWindow.h>

#include <Swift/QtUI/QtJoinMUCWindow.h>

#include <Swift/QtUI/QtChatWindowFactory.h>

#include <Swift/QtUI/QtSwiftUtil.h>

#include <Swift/QtUI/MUCSearch/QtMUCSearchWindow.h>

#include <Swift/QtUI/UserSearch/QtUserSearchWindow.h>

#include <Swift/QtUI/QtProfileWindow.h>

#include <Swift/QtUI/QtContactEditWindow.h>

#include <Swift/QtUI/QtAdHocCommandWindow.h>

#include <Swift/QtUI/QtFileTransferListWidget.h>

#include <Swift/QtUI/QtHighlightEditorWidget.h>

#include <Swift/QtUI/Whiteboard/QtWhiteboardWindow.h>

#include <Swift/Controllers/Settings/SettingsProviderHierachy.h>

#include <Swift/QtUI/QtUISettingConstants.h>

#include <Swift/QtUI/QtHistoryWindow.h>

#include <Swiften/Whiteboard/WhiteboardSession.h>

#include <Swift/QtUI/QtSingleWindow.h>

#include <Swift/QtUI/QtBlockListEditorWindow.h>

namespace Swift {

}

void QtUIFactory::handleChatWindowFontResized(int size) {

chatFontSize = size;

settings->storeSetting(QtUISettingConstants::CHATWINDOW_FONT_SIZE, size);

}

UserSearchWindow* QtUIFactory::createUserSearchWindow(UserSearchWindow::Type type, UIEventStream* eventStream, const std::set<std::string>& groups) {

return new QtUserSearchWindow(eventStream, type, groups, qtOnlySettings);

}

JoinMUCWindow* QtUIFactory::createJoinMUCWindow(UIEventStream* uiEventStream) {

return new QtJoinMUCWindow(uiEventStream);

}

ProfileWindow* QtUIFactory::createProfileWindow() {

return new QtProfileWindow();

}

ContactEditWindow* QtUIFactory::createContactEditWindow() {

return new QtContactEditWindow();

}

WhiteboardWindow* QtUIFactory::createWhiteboardWindow(boost::shared_ptr<WhiteboardSession> whiteboardSession) {

return new QtWhiteboardWindow(whiteboardSession);

}

HighlightEditorWidget* QtUIFactory::createHighlightEditorWidget() {

return new QtHighlightEditorWidget();

}

BlockListEditorWidget *QtUIFactory::createBlockListEditorWidget() {

return new QtBlockListEditorWindow();

}

}

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <QObject>

#include <QPointer>

#include <Swift/Controllers/UIInterfaces/UIFactory.h>

class QSplitter;

namespace Swift {

class QtSettingsProvider;

class SettingsProviderHierachy;

class QtChatTabs;

class QtSystemTray;

class QtLoginWindow;

class QtMainWindow;

class QtChatTheme;

class QtChatWindowFactory;

class QtChatWindow;

class TimerFactory;

class historyWindow_;

class WhiteboardSession;

class StatusCache;

class QtSingleWindow;

class QtUIFactory : public QObject, public UIFactory {

Q_OBJECT

public:

QtUIFactory(SettingsProviderHierachy* settings, QtSettingsProvider* qtOnlySettings, QtChatTabs* tabs, QtSingleWindow* netbookSplitter, QtSystemTray* systemTray, QtChatWindowFactory* chatWindowFactory, TimerFactory* timerFactory, StatusCache* statusCache, bool startMinimized, bool emoticonsExist);

virtual XMLConsoleWidget* createXMLConsoleWidget();

virtual HistoryWindow* createHistoryWindow(UIEventStream*);

virtual MainWindow* createMainWindow(UIEventStream* eventStream);

virtual LoginWindow* createLoginWindow(UIEventStream* eventStream);

virtual EventWindow* createEventWindow();

virtual ChatListWindow* createChatListWindow(UIEventStream*);

virtual MUCSearchWindow* createMUCSearchWindow();

virtual ChatWindow* createChatWindow(const JID &contact, UIEventStream* eventStream);

virtual UserSearchWindow* createUserSearchWindow(UserSearchWindow::Type type, UIEventStream* eventStream, const std::set<std::string>& groups);

virtual JoinMUCWindow* createJoinMUCWindow(UIEventStream* uiEventStream);

virtual ProfileWindow* createProfileWindow();

virtual ContactEditWindow* createContactEditWindow();

virtual FileTransferListWidget* createFileTransferListWidget();

virtual WhiteboardWindow* createWhiteboardWindow(boost::shared_ptr<WhiteboardSession> whiteboardSession);

virtual HighlightEditorWidget* createHighlightEditorWidget();

virtual BlockListEditorWidget* createBlockListEditorWidget();

private slots:

void handleLoginWindowGeometryChanged();

void handleChatWindowFontResized(int);

void handleHistoryWindowFontResized(int);

private:

SettingsProviderHierachy* settings;

QtSettingsProvider* qtOnlySettings;

QtChatTabs* tabs;

QtSingleWindow* netbookSplitter;

QtSystemTray* systemTray;

QtChatWindowFactory* chatWindowFactory;

TimerFactory* timerFactory_;

QtMainWindow* lastMainWindow;

QtLoginWindow* loginWindow;

StatusCache* statusCache;

std::vector<QPointer<QtChatWindow> > chatWindows;

bool startMinimized;

int chatFontSize;

int historyFontSize_;

bool emoticonsExist_;

};

}