namespace Swift {

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

blockListManager_->getBlockList()->onItemAdded.connect(boost::bind(&BlockListController::handleBlockListChanged, this));

blockListManager_->getBlockList()->onItemRemoved.connect(boost::bind(&BlockListController::handleBlockListChanged, this));

void BlockListController::handleUIEvent(boost::shared_ptr<UIEvent> rawEvent) {

// handle UI dialog

boost::shared_ptr<RequestBlockListDialogUIEvent> requestDialogEvent = boost::dynamic_pointer_cast<RequestBlockListDialogUIEvent>(rawEvent);

blockListEditorWidget_ = blockListEditorWidgetFactory_->createBlockListEditorWidget();

blockListEditorWidget_->onSetNewBlockList.connect(boost::bind(&BlockListController::handleSetNewBlockList, this, _1));

}

// handle block state change

boost::shared_ptr<RequestChangeBlockStateUIEvent> changeStateEvent = boost::dynamic_pointer_cast<RequestChangeBlockStateUIEvent>(rawEvent);

if (changeStateEvent->getBlockState() == RequestChangeBlockStateUIEvent::Blocked) {

GenericRequest<BlockPayload>::ref blockRequest = blockListManager_->createBlockJIDRequest(changeStateEvent->getContact());

blockRequest->onResponse.connect(boost::bind(&BlockListController::handleBlockResponse, this, blockRequest, _1, _2, std::vector<JID>(1, changeStateEvent->getContact()), false));

ChatWindow* ChatControllerBase::detachChatWindow() {

ChatWindow* chatWindow = chatWindow_;

return chatWindow;

}

chatWindowFactory_ = chatWindowFactory;

nickResolver_ = nickResolver;

presenceOracle_ = presenceOracle;

serverDiscoInfo_ = boost::make_shared<DiscoInfo>();

presenceSender_ = presenceSender;

uiEventStream_ = uiEventStream;

profileSettings_ = profileSettings;

presenceOracle_->onPresenceChange.connect(boost::bind(&ChatsManager::handlePresenceChange, this, _1));

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

chatListWindow_->onRecentActivated.connect(boost::bind(&ChatsManager::handleRecentActivated, this, _1));

chatListWindow_->onClearRecentsRequested.connect(boost::bind(&ChatsManager::handleClearRecentsRequested, this));

mucSearchController_ = new MUCSearchController(jid_, mucSearchWindowFactory, iqRouter, profileSettings_);

mucSearchController_->onMUCSelected.connect(boost::bind(&ChatsManager::handleMUCSelectedAfterSearch, this, _1));

ftOverview_->onNewFileTransferController.connect(boost::bind(&ChatsManager::handleNewFileTransferController, this, _1));

void ChatsManager::handleClearRecentsRequested() {

recentChats_.clear();

saveRecents();

}

void ChatsManager::handleJIDAddedToRoster(const JID &jid) {

prependRecent(chat);

}

}

}

void ChatsManager::setupBookmarks() {

ChatListWindow::Chat chat = createChatListChatItem(jid, activity, privateMessage);

/* FIXME: handle nick changes */

appendRecent(chat);

saveRecents();

}

ChatController* ChatsManager::getChatControllerIfExists(const JID &contact, bool rebindIfNeeded) {

if (chatControllers_.find(contact) == chatControllers_.end()) {

if (mucRegistry_->isMUC(contact.toBare())) {

}

//Need to look for an unbound window to bind first

JID bare(contact.toBare());

}

}

}

}

}

return chatControllers_[contact];

muc->setCreateAsReservedIfNew();

}

if (reuseChatwindow) {

chatWindowFactoryAdapter = new SingleChatWindowFactoryAdapter(reuseChatwindow);

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

ChatListWindow::Chat createChatListChatItem(const JID& jid, const std::string& activity, bool privateMessage);

void handleChatRequest(const std::string& contact);

void finalizeImpromptuJoin(MUC::ref muc, const std::vector<JID>& jidsToInvite, const std::string& reason, const boost::optional<JID>& reuseChatJID = boost::optional<JID>());

void handleSearchMUCRequest();

void handleMUCSelectedAfterSearch(const JID&);

void rebindControllerJID(const JID& from, const JID& to);

if (stanzaChannel->isAvailable()) {

MUCController::setOnline(true);

}

avatarChangedConnection_ = (avatarManager_->onAvatarChanged.connect(boost::bind(&MUCController::handleAvatarChanged, this, _1)));

}

MUCController::handleBareJIDCapsChanged(muc->getJID());

MUCController::~MUCController() {

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

delete rosterVCardProvider_;

delete roster_;

if (loginCheckTimer_) {

loginCheckTimer_->stop();

}

delete completer_;

}

onActivity("");

}

}

handleAvatarChanged(jid);

}

}

std::string groupName(roleToGroupName(role));

roster_->addContact(newJID, realJID, newNickname, groupName, avatarManager_->getAvatarPath(newJID));

roster_->applyOnItems(SetMUC(newJID, role, affiliation));

handleAvatarChanged(newJID);

}

static const std::string SEARCHED_SERVICES = "searchedServices";

itemsInProgress_ = 0;

loadSavedServices();

}

joinMUCWindowFactory_ = mocks_->InterfaceMock<JoinMUCWindowFactory>();

xmppRoster_ = new XMPPRosterImpl();

mucRegistry_ = new MUCRegistry();

presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

serverDiscoInfo_ = boost::make_shared<DiscoInfo>();

presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

vcardManager_ = new VCardManager(jid_, iqRouter_, vcardStorage_);

mocks_->ExpectCall(chatListWindowFactory_, ChatListWindowFactory::createChatListWindow).With(uiEventStream_).Return(chatListWindow_);

clientBlockListManager_ = new ClientBlockListManager(iqRouter_);

manager_->setAvatarManager(avatarManager_);

}

manager_->handleIncomingMessage(message);

Stanza::ref stanzaContactOnRoster = stanzaChannel_->getStanzaAtIndex<Stanza>(0);

CPPUNIT_ASSERT_EQUAL(st(1), stanzaChannel_->sentStanzas.size());

xmppRoster_->removeContact(messageJID);

CPPUNIT_ASSERT_EQUAL(st(1), stanzaChannel_->sentStanzas.size());

Stanza::ref stanzaContactOnRoster = stanzaChannel_->getStanzaAtIndex<Stanza>(0);

}

/**

CPPUNIT_ASSERT_EQUAL(st(1), stanzaChannel_->sentStanzas.size());

Stanza::ref stanzaContactOnRoster = stanzaChannel_->getStanzaAtIndex<Stanza>(0);

}

void testChatControllerHighlightingNotificationTesting() {

directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

uiEventStream_ = new UIEventStream();

avatarManager_ = new NullAvatarManager();

window_ = new MockChatWindow();

mucRegistry_ = new MUCRegistry();

entityCapsProvider_ = new DummyEntityCapsProvider();

vcardManager_ = new VCardManager(self_, iqRouter_, vcardStorage_);

clientBlockListManager_ = new ClientBlockListManager(iqRouter_);

mucBookmarkManager_ = new MUCBookmarkManager(iqRouter_);

}

void tearDown() {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

vcardManager_->onVCardChanged.connect(boost::bind(&UserSearchController::handleVCardChanged, this, _1, _2));

avatarManager_->onAvatarChanged.connect(boost::bind(&UserSearchController::handleAvatarChanged, this, _1));

presenceOracle_->onPresenceChange.connect(boost::bind(&UserSearchController::handlePresenceChanged, this, _1));

loadSavedDirectories();

}

namespace Swift {

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

vcardManager->onVCardChanged.connect(boost::bind(&ContactEditController::handleVCardChanged, this, _1, _2));

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

namespace Swift {

FileTransferController::FileTransferController(const JID& receipient, const std::string& filename, FileTransferManager* fileTransferManager) :

}

FileTransferController::FileTransferController(IncomingFileTransfer::ref transfer) :

transfer->onStateChanged.connect(boost::bind(&FileTransferController::handleFileTransferStateChange, this, _1));

}

namespace Swift {

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

}

void FileTransferListController::handleUIEvent(boost::shared_ptr<UIEvent> rawEvent) {

boost::shared_ptr<RequestFileTransferListUIEvent> event = boost::dynamic_pointer_cast<RequestFileTransferListUIEvent>(rawEvent);

fileTransferListWidget = fileTransferListWidgetFactory->createFileTransferListWidget();

if (fileTransferOverview) {

fileTransferListWidget->setFileTransferOverview(fileTransferOverview);

namespace Swift {

HighlightEditorController::HighlightEditorController(UIEventStream* uiEventStream, HighlightEditorWindowFactory* highlightEditorWindowFactory, HighlightManager* highlightManager)

{

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

}

HighlightEditorController::~HighlightEditorController()

{

delete highlightEditorWindow_;

}

void HighlightEditorController::handleUIEvent(boost::shared_ptr<UIEvent> rawEvent)

*/

/*

* Licensed under the GNU General Public License.

* See the COPYING file for more information.

*/

avatarManager_(avatarManager),

presenceOracle_(presenceOracle),

historyWindowFactory_(historyWindowFactory),

currentResultDate_(boost::gregorian::not_a_date_time) {

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

void HistoryViewController::handleUIEvent(boost::shared_ptr<UIEvent> rawEvent) {

boost::shared_ptr<RequestHistoryUIEvent> event = boost::dynamic_pointer_cast<RequestHistoryUIEvent>(rawEvent);

historyWindow_ = historyWindowFactory_->createHistoryWindow(uiEventStream_);

historyWindow_->onSelectedContactChanged.connect(boost::bind(&HistoryViewController::handleSelectedContactChanged, this, _1));

historyWindow_->onReturnPressed.connect(boost::bind(&HistoryViewController::handleReturnPressed, this, _1));

void HistoryViewController::reset() {

roster_->removeAll();

contacts_.clear();

historyWindow_->resetConversationView();

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

settings_(settings),

uriHandler_(uriHandler),

idleDetector_(idleDetector),

useDelayForLatency_(useDelayForLatency),

emoticons_(emoticons) {

quitRequested_ = false;

clientInitialized_ = false;

offlineRequested_ = false;

/* FIXME: deal with autologin with a cert*/

handleLoginRequest(selectedLoginJID, cachedPassword, cachedCertificate, CertificateWithKey::ref(), cachedOptions, true, true);

} else {

}

}

resetPendingReconnects();

vCardPhotoHash_.clear();

delete contactEditController_;

delete profileController_;

delete showProfileController_;

delete eventWindowController_;

delete chatsManager_;

#ifdef SWIFT_EXPERIMENTAL_HISTORY

delete historyViewController_;

delete historyController_;

#endif

delete ftOverview_;

delete blockListController_;

delete rosterController_;

delete eventNotifier_;

delete presenceNotifier_;

delete certificateTrustChecker_;

delete certificateStorage_;

delete storages_;

delete statusTracker_;

delete profileSettings_;

delete userSearchControllerChat_;

delete userSearchControllerAdd_;

delete userSearchControllerInvite_;

delete contactSuggesterWithoutRoster_;

delete contactSuggesterWithRoster_;

delete contactsFromRosterProvider_;

delete adHocManager_;

delete whiteboardManager_;

clientInitialized_ = false;

}

purgeCachedCredentials();

}

myStatusLooksOnline_ = true;

if (freshLogin) {

profileController_ = new ProfileController(client_->getVCardManager(), uiFactory_, uiEventStream_);

historyViewController_ = new HistoryViewController(jid_, uiEventStream_, historyController_, client_->getNickResolver(), client_->getAvatarManager(), client_->getPresenceOracle(), uiFactory_);

chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, historyController_, whiteboardManager_, highlightManager_, client_->getClientBlockListManager(), emoticons_, client_->getVCardManager());

#else

#endif

contactsFromRosterProvider_ = new ContactsFromXMPPRoster(client_->getRoster(), client_->getAvatarManager(), client_->getPresenceOracle());

contactSuggesterWithoutRoster_->addContactProvider(chatsManager_);

namespace Swift {

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

}

}

void ProfileController::handleProfileWindowAboutToBeClosed(const JID&) {

}

void ProfileController::setAvailable(bool b) {

*/

ContactRosterItem* GroupRosterItem::removeChild(const JID& jid) {

std::vector<RosterItem*>::iterator it = children_.begin();

while (it != children_.end()) {

ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(*it);

if (contact && contact->getJID() == jid) {

GroupRosterItem* GroupRosterItem::removeGroupChild(const std::string& groupName) {

std::vector<RosterItem*>::iterator it = children_.begin();

while (it != children_.end()) {

GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(*it);

if (group && group->getDisplayName() == groupName) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

Roster::Roster(bool sortByStatus, bool fullJIDMapping) : blockingSupported_(false) {

sortByStatus_ = sortByStatus;

fullJIDMapping_ = fullJIDMapping;

root_->onChildrenChanged.connect(boost::bind(&Roster::handleChildrenChanged, this, root_));

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

handleShowOfflineToggled(settings_->getSetting(SettingConstants::SHOW_OFFLINE));

ownContact_->setVCard(vcardManager_->getVCard(myJID_.toBare()));

ownContact_->setAvatarPath(pathToString(avatarManager_->getAvatarPath(myJID_.toBare())));

mainWindow_->setMyContactRosterItem(ownContact_);

delete offlineFilter_;

delete expandiness_;

if (mainWindow_->canDelete()) {

delete mainWindow_;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

avatarManager_ = new NullAvatarManager();

mainWindowFactory_ = new MockMainWindowFactory();

mucRegistry_ = new MUCRegistry();

channel_ = new DummyIQChannel();

router_ = new IQRouter(channel_);

stanzaChannel_ = new DummyStanzaChannel();

#ifdef SWIFT_EXPERIMENTAL_HISTORY

historyStorage = new SQLiteHistoryStorage(baseDir / "history.db");

#else

#endif

}

#ifdef SWIFT_EXPERIMENTAL_HISTORY

return historyStorage;

#else

#endif

}

virtual void replaceSystemMessage(const ChatMessage& /*message*/, const std::string& /*id*/, const TimestampBehaviour /*timestampBehaviour*/) {}

// File transfer related stuff

virtual void setFileTransferProgress(std::string /*id*/, const int /*alreadyTransferedBytes*/) { }

virtual void setFileTransferStatus(std::string /*id*/, const FileTransferState /*state*/, const std::string& /*msg*/) { }

/*

* All rights reserved.

* See the COPYING file for more information.

*/

class Roster;

class MockMainWindow : public MainWindow {

public:

virtual ~MockMainWindow() {}

virtual void setRosterModel(Roster* roster) {this->roster = roster;}

virtual void setMyNick(const std::string& /*name*/) {}

class MockMainWindowFactory : public MainWindowFactory {

public:

virtual ~MockMainWindowFactory() {}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

user2 = JID("user2@foo.com/baz");

avatarManager = new DummyAvatarManager();

roster = new XMPPRosterImpl();

presenceOracle = new PresenceOracle(stanzaChannel, roster);

timerFactory = new DummyTimerFactory();

}

WhiteboardWindow* WhiteboardManager::findWhiteboardWindow(const JID& contact) {

if (whiteboardWindows_.find(contact.toBare()) == whiteboardWindows_.end()) {

}

return whiteboardWindows_[contact.toBare()];

}

boost::shared_ptr<ShowWhiteboardUIEvent> showWindowEvent = boost::dynamic_pointer_cast<ShowWhiteboardUIEvent>(event);

if (showWindowEvent) {

WhiteboardWindow* window = findWhiteboardWindow(showWindowEvent->getContact());

window->activateWindow();

}

}

session->onRequestRejected.connect(boost::bind(&WhiteboardManager::handleRequestReject, this, _1));

WhiteboardWindow* window = findWhiteboardWindow(contact);

createNewWhiteboardWindow(contact, session);

} else {

window->setSession(session);

session->onRequestAccepted.connect(boost::bind(&WhiteboardManager::handleSessionAccept, this, _1));

WhiteboardWindow* window = findWhiteboardWindow(session->getTo());

createNewWhiteboardWindow(session->getTo(), session);

} else {

window->setSession(session);

void WhiteboardManager::handleSessionAccept(const JID& contact) {

WhiteboardWindow* window = findWhiteboardWindow(contact);

window->show();

}

onRequestAccepted(contact);

namespace Swift {

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

}

void XMLConsoleController::handleUIEvent(boost::shared_ptr<UIEvent> rawEvent) {

boost::shared_ptr<RequestXMLConsoleUIEvent> event = boost::dynamic_pointer_cast<RequestXMLConsoleUIEvent>(rawEvent);

xmlConsoleWidget = xmlConsoleWidgetFactory->createXMLConsoleWidget();

}

xmlConsoleWidget->show();