#include <Swift/Controllers/Intl.h>

#include <Swiften/Base/format.h>

#include "Swiften/Avatars/AvatarManager.h"

#include "Swiften/Chat/ChatStateNotifier.h"

#include "Swiften/Chat/ChatStateTracker.h"

setToJID(from);

}

}

chatStateTracker_->handleMessageReceived(message);

}

void ChatController::postHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {

}

void ChatController::postSendMessage(const std::string& body, boost::shared_ptr<Stanza> sentStanza) {

}

lastWasPresence_ = false;

chatStateNotifier_->userSentMessage();

}

void ChatController::handleStanzaAcked(boost::shared_ptr<Stanza> stanza) {

}

}

void ChatController::setOnline(bool online) {

if (!online) {

std::map<boost::shared_ptr<Stanza>, std::string>::iterator it = unackedStanzas_.begin();

chatWindow_->setAckState(it->second, ChatWindow::Failed);

}

unackedStanzas_.clear();

NickResolver* nickResolver_;

ChatStateNotifier* chatStateNotifier_;

ChatStateTracker* chatStateTracker_;

bool isInMUC_;

bool lastWasPresence_;

std::string lastStatusChangeString_;

/*

* Licensed under the GNU General Public License v3.

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

*/

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

#include <sstream>

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory) {

chatWindow_ = chatWindowFactory_->createChatWindow(toJID, eventStream);

chatWindow_->onAllMessagesRead.connect(boost::bind(&ChatControllerBase::handleAllMessagesRead, this));

setOnline(stanzaChannel->isAvailable() && iqRouter->isAvailable());

createDayChangeTimer();

}

chatWindow_->setUnreadMessageCount(0);

}

if (!stanzaChannel_->isAvailable() || body.empty()) {

return;

}

boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();

message->addPayload(boost::shared_ptr<Delay>(new Delay(now, selfJID_)));

}

stanzaChannel_->sendMessage(message);

postSendMessage(message->getBody(), boost::dynamic_pointer_cast<Stanza>(message));

}

void ChatControllerBase::handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog> catalog, ErrorPayload::ref error) {

boost::shared_ptr<Message> message = messageEvent->getStanza();

std::string body = message->getBody();

if (message->isError()) {

chatWindow_->addErrorMessage(errorMessage);

}

else {

JID from = message->getFrom();

std::vector<boost::shared_ptr<Delay> > delayPayloads = message->getPayloads<Delay>();

for (size_t i = 0; useDelayForLatency_ && i < delayPayloads.size(); i++) {

continue;

}

boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();

if (messageTimeStamp) {

timeStamp = *messageTimeStamp;

}

}

chatWindow_->show();

chatWindow_->setUnreadMessageCount(unreadMessages_.size());

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

*/

#include <map>

#include <vector>

#include "Swiften/Elements/ErrorPayload.h"

#include "Swiften/Presence/PresenceOracle.h"

#include "Swiften/Queries/IQRouter.h"

namespace Swift {

class IQRouter;

virtual void setOnline(bool online);

virtual void setEnabled(bool enabled);

virtual void setToJID(const JID& jid) {toJID_ = jid;};

protected:

ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory);

virtual void dayTicked() {};

private:

void createDayChangeTimer();

void handleAllMessagesRead();

void handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog>, ErrorPayload::ref error);

std::string getErrorMessage(boost::shared_ptr<ErrorPayload>);

ChatWindow* chatWindow_;

JID toJID_;

bool labelsEnabled_;

PresenceOracle* presenceOracle_;

AvatarManager* avatarManager_;

bool useDelayForLatency_;

TimerFactory* timerFactory_;

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

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

#include <boost/bind.hpp>

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

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

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

#include "Swiften/MUC/MUCManager.h"

#include "Swiften/Elements/ChatState.h"

#include "Swiften/MUC/MUCBookmarkManager.h"

namespace Swift {

typedef std::pair<JID, ChatController*> JIDChatControllerPair;

typedef std::pair<JID, MUCController*> JIDMUCControllerPair;

ChatsManager::ChatsManager(

JID jid, StanzaChannel* stanzaChannel,

IQRouter* iqRouter,

EntityCapsProvider* entityCapsProvider,

MUCManager* mucManager,

MUCSearchWindowFactory* mucSearchWindowFactory,

jid_(jid),

joinMUCWindowFactory_(joinMUCWindowFactory),

useDelayForLatency_(useDelayForLatency),

presenceSender_ = presenceSender;

uiEventStream_ = uiEventStream;

mucBookmarkManager_ = NULL;

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

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

chatListWindow_ = chatListWindowFactory->createChatListWindow(uiEventStream_);

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

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

setupBookmarks();

}

ChatsManager::~ChatsManager() {

delete mucSearchController_;

}

void ChatsManager::setupBookmarks() {

if (!mucBookmarkManager_) {

mucBookmarkManager_ = new MUCBookmarkManager(iqRouter_);

if (chatListWindow_) {

chatListWindow_->setBookmarksEnabled(false);

}

}

}

chatListWindow_->removeMUCBookmark(bookmark);

}

void ChatsManager::handleUserLeftMUC(MUCController* mucController) {

std::map<JID, MUCController*>::iterator it;

if ((*it).second == mucController) {

mucControllers_.erase(it);

delete mucController;

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

}

ChatController* controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, mucRegistry_->isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_, eventController_, timerFactory_, entityCapsProvider_);

chatControllers_[contact] = controller;

controller->setAvailableServerFeatures(serverDiscoInfo_);

return controller;

}

controller->onUserLeft.connect(boost::bind(&ChatsManager::handleUserLeftMUC, this, controller));

}

mucControllers_[mucJID]->activateChatWindow();

}

void ChatsManager::handleSearchMUCRequest() {

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <boost/shared_ptr.hpp>

#include <string>

namespace Swift {

class EventController;

class IQRouter;

class PresenceSender;

class MUCBookmarkManager;

class ChatListWindowFactory;

class TimerFactory;

class EntityCapsProvider;

class DirectedPresenceSender;

class MUCSearchWindowFactory;

class MUCSearchController;

class ChatsManager {

public:

virtual ~ChatsManager();

void setAvatarManager(AvatarManager* avatarManager);

void setOnline(bool enabled);

void handleMUCBookmarkRemoved(const MUCBookmark& bookmark);

void handleUserLeftMUC(MUCController* mucController);

void handleBookmarksReady();

void setupBookmarks();

ChatController* getChatControllerOrFindAnother(const JID &contact);

ChatController* createNewChatController(const JID &contact);

ChatController* getChatControllerOrCreate(const JID &contact);

EntityCapsProvider* entityCapsProvider_;

MUCManager* mucManager;

MUCSearchController* mucSearchController_;

};

}

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

*/

#include <boost/bind.hpp>

#include <boost/regex.hpp>

#include <Swift/Controllers/Intl.h>

#include <Swiften/Base/format.h>

#define MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS 60000

default: break;

}

}

chatWindow_->addErrorMessage(errorMessage);

if (!rejoinNick.empty()) {

nick_ = rejoinNick;

currentOccupants_.insert(occupant.getNick());

NickJoinPart event(occupant.getNick(), Join);

appendToJoinParts(joinParts_, event);

if (joined_) {

std::string joinString;

MUCOccupant::Role role = occupant.getRole();

return "";

}

JID MUCController::nickToJID(const std::string& nick) {

return JID(toJID_.getNode(), toJID_.getDomain(), nick);

}

if (occupant.getRealJID()) {

realJID = occupant.getRealJID().get();

}

chatWindow_->addSystemMessage(str(format(QT_TRANSLATE_NOOP("", "%1% is now a %2%")) % nick % roleToFriendlyName(occupant.getRole())));

}

void MUCController::appendToJoinParts(std::vector<NickJoinPart>& joinParts, const NickJoinPart& newEvent) {

std::vector<NickJoinPart>::iterator it = joinParts.begin();

bool matched = false;

if ((*it).nick == newEvent.nick) {

matched = true;

JoinPart type = (*it).type;

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/signals/connection.hpp>

#include <string>

namespace Swift {

class StanzaChannel;

void handleJoinFailed(boost::shared_ptr<ErrorPayload> error);

void handleJoinTimeoutTick();

std::string roleToGroupName(MUCOccupant::Role role);

JID nickToJID(const std::string& nick);

std::string roleToFriendlyName(MUCOccupant::Role role);

void receivedActivity();

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/String.h>

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

itemsInProgress_ = 0;

loadSavedServices();

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include "Swiften/JID/JID.h"

#include "Swift/Controllers/UIEvents/UIEvent.h"

#include "Swiften/Elements/DiscoInfo.h"

#include "Swiften/Elements/DiscoItems.h"

#include "Swiften/Elements/ErrorPayload.h"

class MUCSearchController {

public:

~MUCSearchController();

void openSearchWindow();

JID jid_;

MUCSearchWindowFactory* factory_;

IQRouter* iqRouter_;

MUCSearchWindow* window_;

DiscoServiceWalker* walker_;

std::list<JID> services_;

/*

* Licensed under the GNU General Public License v3.

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

*/

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

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

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

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

#include "Swift/Controllers/UIEvents/RequestChatUIEvent.h"

#include "Swift/Controllers/UIEvents/JoinMUCUIEvent.h"

#include "Swift/Controllers/UIEvents/UIEventStream.h"

using namespace Swift;

CPPUNIT_TEST_SUITE_END();

public:

mocks_ = new MockRepository();

jid_ = JID("test@test.com/resource");

stanzaChannel_ = new DummyStanzaChannel();

chatListWindowFactory_ = mocks_->InterfaceMock<ChatListWindowFactory>();

mucSearchWindowFactory_ = mocks_->InterfaceMock<MUCSearchWindowFactory>();

settings_ = new DummySettingsProvider();

avatarManager_ = new NullAvatarManager();

manager_->setAvatarManager(avatarManager_);

void tearDown() {

//delete chatListWindowFactory_;

delete settings_;

delete avatarManager_;

delete manager_;

delete directedPresenceSender_;

delete xmppRoster_;

delete entityCapsManager_;

delete capsProvider_;

}

void testFirstOpenWindowIncoming() {

CapsProvider* capsProvider_;

MUCManager* mucManager_;

DummySettingsProvider* settings_;

};

CPPUNIT_TEST_SUITE_REGISTRATION(ChatsManagerTest);

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

void UserSearchController::handleDiscoServiceFound(const JID& jid, boost::shared_ptr<DiscoInfo> info) {

bool supports55 = false;

foreach (DiscoInfo::Identity identity, info->getIdentities()) {

if ((identity.getCategory() == "directory"

&& identity.getType() == "user")) {

}

}

std::vector<std::string> features = info->getFeatures();

#include <Swift/Controllers/DiscoServiceWalker.h>

#include <Swiften/Base/Log.h>

#include <boost/bind.hpp>

servicesBeingSearched_.erase(jid);

/* All results are in */

active_ = false;

onWalkComplete();

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <stdlib.h>

#include <Swiften/Base/format.h>

#include <Swift/Controllers/Intl.h>

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

#include "Swiften/Network/TimerFactory.h"

#include "Swift/Controllers/BuildVersion.h"

#include "Swiften/Client/Storages.h"

#include "Swiften/VCards/VCardManager.h"

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

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

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

#include "Swift/Controllers/UIEvents/UIEventStream.h"

#include "Swift/Controllers/PresenceNotifier.h"

#include "Swift/Controllers/EventNotifier.h"

#include "SwifTools/Dock/Dock.h"

#include "SwifTools/Notifier/TogglableNotifier.h"

#include "Swiften/Base/foreach.h"

#include "Swift/Controllers/UIEvents/RequestChatUIEvent.h"

#include "Swift/Controllers/UIEvents/ToggleNotificationsUIEvent.h"

#include "Swift/Controllers/UIEvents/JoinMUCUIEvent.h"

#include "Swiften/Network/NetworkFactories.h"

#include <Swift/Controllers/ProfileController.h>

#include <Swift/Controllers/ContactEditController.h>

namespace Swift {

CertificateStorageFactory* certificateStorageFactory,

Dock* dock,

Notifier* notifier,

eventLoop_(eventLoop),

networkFactories_(networkFactories),

uiFactory_(uiFactories),

storagesFactory_(storagesFactory),

certificateStorageFactory_(certificateStorageFactory),

settings_(settings),

loginWindow_(NULL) ,

storages_ = NULL;

certificateStorage_ = NULL;

statusTracker_ = 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;

std::string cachedCertificate;

}

}

loginWindow_->onLoginRequest.connect(boost::bind(&MainController::handleLoginRequest, this, _1, _2, _3, _4, _5));

loginWindow_->onPurgeSavedLoginRequest.connect(boost::bind(&MainController::handlePurgeSavedLoginRequest, this, _1));

loginWindow_->onCancelLoginRequest.connect(boost::bind(&MainController::handleCancelLoginRequest, this));

}

MainController::~MainController() {

//setManagersOffline();

eventController_->disconnectAll();

resetClient();

delete xmlConsoleController_;

delete soundEventController_;

delete systemTrayController_;

delete eventController_;

delete uiEventStream_;

}

void MainController::resetClient() {

resetCurrentError();

resetPendingReconnects();

vCardPhotoHash_.clear();

loginWindow_->setIsLoggingIn(false);

resetCurrentError();

resetPendingReconnects();

bool freshLogin = rosterController_ == NULL;

myStatusLooksOnline_ = true;

if (freshLogin) {

contactEditController_ = new ContactEditController(rosterController_, uiFactory_, uiEventStream_);

client_->onMessageReceived.connect(boost::bind(&ChatsManager::handleIncomingMessage, chatsManager_, _1));

chatsManager_->setAvatarManager(client_->getAvatarManager());

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

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

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

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

}

client_->requestRoster();

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

discoInfoRequest->send();

}

void MainController::handleLoginRequest(const std::string &username, const std::string &password, const std::string& certificateFile, bool remember, bool loginAutomatically) {

jid_ = JID(username);

}

void MainController::handlePurgeSavedLoginRequest(const std::string& username) {

}

void MainController::performLoginFromCachedCredentials() {

/* If we logged in with a bare JID, and we have a full bound JID, re-login with the

* bound JID to try and keep dynamically assigned resources */

JID clientJID = jid_;

certificateStorage_ = certificateStorageFactory_->createCertificateStorage(jid_.toBare());

certificateTrustChecker_ = new CertificateStorageTrustChecker(certificateStorage_);

clientInitialized_ = true;

client_->setCertificateTrustChecker(certificateTrustChecker_);

client_->onDataRead.connect(boost::bind(&XMLConsoleController::handleDataRead, xmlConsoleController_, _1));

if (rosterController_) {

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

}

}

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

if (quitRequested_) {

resetClient();

loginWindow_->quit();

else if (!rosterController_) { //hasn't been logged in yet

signOut();

loginWindow_->setMessage(message);

} else {

logout();

} else {

}

}

}

}

void MainController::setReconnectTimer() {

}

void MainController::signOut() {

eventController_->clear();

logout();

loginWindow_->loggedOut();

}

void MainController::logout() {

systemTrayController_->setMyStatusType(StatusShow::None);

if (clientInitialized_ /*&& client_->isAvailable()*/) {

client_->disconnect();

void MainController::handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo> info, ErrorPayload::ref error) {

if (!error) {

chatsManager_->setServerDiscoInfo(info);

}

}

void MainController::handleVCardReceived(const JID& jid, VCard::ref vCard) {

return;

}

std::string hash = Hexify::hexify(SHA1::getHash(vCard->getPhoto()));

/*

* Licensed under the GNU General Public License v3.

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

*/

class Storages;

class StoragesFactory;

class NetworkFactories;

class MainController {

public:

CertificateStorageFactory* certificateStorageFactory,

Dock* dock,

Notifier* notifier,

~MainController();

void setManagersOffline();

void handleNotificationClicked(const JID& jid);

void handleForceQuit();

private:

EventLoop* eventLoop_;

SettingsProvider *settings_;

ProfileSettingsProvider* profileSettings_;

Dock* dock_;

TogglableNotifier* notifier_;

PresenceNotifier* presenceNotifier_;

EventNotifier* eventNotifier_;

RosterController* rosterController_;

EventController* eventController_;

EventWindowController* eventWindowController_;

LoginWindow* loginWindow_;

UIEventStream* uiEventStream_;

XMLConsoleController* xmlConsoleController_;

JID boundJID_;

SystemTrayController* systemTrayController_;

SoundEventController* soundEventController_;

std::string vCardPhotoHash_;

std::string password_;

std::string certificateFile_;

bool myStatusLooksOnline_;

bool quitRequested_;

static const int SecondsToWaitBeforeForceQuitting;

};

}

suggestions.push_back(status);

}

}

TypeStringPair suggestion(StatusShow::Online, message);

suggestions.push_back(suggestion);

}

#pragma once

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

namespace Swift {

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

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

namespace Swift {

presences_.erase(resource);

}

}

offlinePresence_ = presence;

}

} else {

namespace Swift {

expanded_ = true;

}

}

bool GroupRosterItem::isExpanded() const {

return expanded_;

}

delete group;

}

}

}

children_.clear();

}

removed = groupRemoved;

}

}

}

onChildrenChanged();

onDataChanged();

it = children_.erase(it);

continue;

}

}

onChildrenChanged();

onDataChanged();

} else {

displayedChildren_.erase(std::remove(displayedChildren_.begin(), displayedChildren_.end(), group), displayedChildren_.end());

}

onChildrenChanged();

onDataChanged();

}

void setExpanded(bool expanded);

bool isExpanded() const;

boost::signal<void (bool)> onExpandedChanged;

private:

void handleChildrenChanged(GroupRosterItem* group);

void handleDataChanged(RosterItem* item);

std::vector<RosterItem*> children_;

std::vector<RosterItem*> displayedChildren_;

bool sortByStatus_;

};

}

void Roster::removeContact(const JID& jid) {

std::vector<ContactRosterItem*>* items = &itemMap_[fullJIDMapping_ ? jid : jid.toBare()];

items->erase(std::remove_if(items->begin(), items->end(), JIDEqualsTo(jid)), items->end());

itemMap_.erase(fullJIDMapping_ ? jid : jid.toBare());

}

//Causes the delete

std::vector<ContactRosterItem*>* items = &itemMap_[fullJIDMapping_ ? jid : jid.toBare()];

items->erase(std::remove(items->begin(), items->end(), deleted), items->end());

}

}

foreach (ContactRosterItem* item, itemMap_[fullJIDMapping_ ? jid : jid.toBare()]) {

item->removeGroup(groupName);

foreach (RosterFilter *filter, filters_) {

hide &= (*filter)(contact);

}

int newDisplayedSize = group->getDisplayedChildren().size();

if (oldDisplayedSize == 0 && newDisplayedSize > 0) {

onGroupAdded(group);

#include <boost/bind.hpp>

#include <vector>

#include "Swiften/Base/String.h"

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

onDataChanged();

}

return name_;

}

return sortableDisplayName_;

}

boost::signal<void ()> onDataChanged;

GroupRosterItem* getParent() const;

void setDisplayName(const std::string& name);

private:

std::string name_;

std::string sortableDisplayName_;

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

CPPUNIT_TEST(testRemoveSecondContact);

CPPUNIT_TEST(testRemoveSecondContactSameBare);

CPPUNIT_TEST(testApplyPresenceLikeMUC);

CPPUNIT_TEST_SUITE_END();

public:

}

private:

Roster *roster_;

JID jid1_;

"Roster/GroupRosterItem.cpp",

"Roster/RosterItem.cpp",

"Roster/Roster.cpp",

"EventWindowController.cpp",

"SoundEventController.cpp",

"SystemTrayController.cpp",

"StatusTracker.cpp",

"PresenceNotifier.cpp",

"EventNotifier.cpp",

"XMPPEvents/EventController.cpp",

"UIEvents/UIEvent.cpp",

"UIInterfaces/XMLConsoleWidget.cpp",

"UIInterfaces/ChatListWindow.cpp",

"PreviousStatusStore.cpp",

"StatusUtil.cpp",

"Translator.cpp",

])

env.Append(UNITTEST_SOURCES = [

File("Chat/UnitTest/ChatsManagerTest.cpp"),

File("Chat/UnitTest/MUCControllerTest.cpp"),

File("UnitTest/MockChatWindow.cpp"),

])

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

*/

#include <iostream>

#include <boost/filesystem/fstream.hpp>

boost::filesystem::path certificatePath = getCertificatePath(certificate);

if (boost::filesystem::exists(certificatePath)) {

ByteArray data;

Certificate::ref storedCertificate = certificateFactory->createCertificateFromDER(data);

if (storedCertificate && storedCertificate->toDER() == certificate->toDER()) {

return true;

}

boost::filesystem::ofstream file(certificatePath, boost::filesystem::ofstream::binary|boost::filesystem::ofstream::out);

ByteArray data = certificate->toDER();

file.close();

}

#include <boost/filesystem.hpp>

namespace Swift {

class CertificateFactory;

#pragma once

namespace Swift {

class CertificateFactory;

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

*/

namespace Swift {

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

*/

namespace Swift {

#pragma once

#include <Swiften/TLS/CertificateTrustChecker.h>

namespace Swift {

/**

#pragma once

namespace Swift {

class FileStoragesFactory : public StoragesFactory {

#pragma once

#include "Swiften/Client/MemoryStorages.h"

namespace Swift {

class MemoryStoragesFactory : public StoragesFactory {

public:

MemoryStoragesFactory() {}

namespace Swift {

class Storages;

class StoragesFactory {

public:

void SystemTrayController::handleEventQueueLengthChange(int /*length*/) {

EventList events = eventController_->getEvents();

bool found = false;

if (boost::dynamic_pointer_cast<MessageEvent>(*it)) {

found = true;

break;

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

}

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

namespace Swift {

class ChatListWindow {

public:

virtual ~ChatListWindow();

virtual void setBookmarksEnabled(bool enabled) = 0;

virtual void addMUCBookmark(const MUCBookmark& bookmark) = 0;

virtual void removeMUCBookmark(const MUCBookmark& bookmark) = 0;

};

}

virtual void addSystemMessage(const std::string& message) = 0;

virtual void addPresenceMessage(const std::string& message) = 0;

virtual void addErrorMessage(const std::string& message) = 0;

virtual void setContactChatState(ChatState::ChatStateType state) = 0;

virtual void setName(const std::string& name) = 0;

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

boost::signal<void ()> onUserTyping;

boost::signal<void ()> onUserCancelsTyping;

};

#pragma once

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

namespace Swift {

boost::signal<void (const std::string&, const std::string&, const std::string& /* certificateFile */, bool /* remember password*/, bool /* login automatically */)> onLoginRequest;

virtual void setLoginAutomatically(bool loginAutomatically) = 0;

virtual void quit() = 0;

/** Blocking request whether a cert should be permanently trusted.*/

virtual bool askUserToTrustCertificatePermanently(const std::string& message, Certificate::ref) = 0;

#include <string>

#include "Swiften/JID/JID.h"

#include "Swiften/Elements/StatusShow.h"

#include "Swiften/Base/boost_bsignals.h"

#include <boost/shared_ptr.hpp>

/** Must be able to cope with NULL to clear the roster */

virtual void setRosterModel(Roster* roster) = 0;

virtual void setConnecting() = 0;

boost::signal<void (StatusShow::Type, const std::string&)> onChangeStatusRequest;

boost::signal<void ()> onSignOutRequest;

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

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

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

namespace Swift {

class UIFactory :

public UserSearchWindowFactory,

public JoinMUCWindowFactory,

public ProfileWindowFactory,

public:

virtual ~UIFactory() {}

};

#pragma once

namespace Swift {

class XMLConsoleWidget {

public:

virtual ~XMLConsoleWidget();

virtual void show() = 0;

virtual void activate() = 0;

namespace Swift {

class MockChatWindow : public ChatWindow {

public:

virtual ~MockChatWindow();

virtual std::string addMessage(const std::string& message, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime&) {lastMessageBody_ = message; return "";};

virtual void setRosterModel(Roster* /*roster*/) {};

virtual void setTabComplete(TabComplete*) {};

virtual void replaceLastMessage(const std::string&) {};

void setAckState(const std::string& /*id*/, AckState /*state*/) {};

virtual void flash() {};

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

std::string name_;

std::string lastMessageBody_;

virtual void setMyAvatarPath(const std::string& /*path*/) {};

virtual void setMyStatusText(const std::string& /*status*/) {};

virtual void setMyStatusType(StatusShow::Type /*type*/) {};

virtual void setConnecting() {};

Roster* roster;

}

void testReceiveFirstPresenceCreatesAvailableNotification() {

sendPresence(user1, StatusShow::Online);

}

void testReceiveSecondPresenceCreatesStatusChangeNotification() {

sendPresence(user1, StatusShow::Away);

notifier->notifications.clear();

}

void testReceiveUnavailablePresenceAfterAvailablePresenceCreatesUnavailableNotification() {

sendPresence(user1, StatusShow::Away);

notifier->notifications.clear();

}

void testReceiveUnavailablePresenceWithoutAvailableDoesNotCreateNotification() {

sendUnavailablePresence(user1);

}

void testReceiveAvailablePresenceAfterUnavailableCreatesAvailableNotification() {

sendPresence(user1, StatusShow::Away);

sendUnavailablePresence(user1);

notifier->notifications.clear();

}

void testReceiveAvailablePresenceAfterReconnectCreatesAvailableNotification() {

sendPresence(user1, StatusShow::Away);

stanzaChannel->setAvailable(false);

stanzaChannel->setAvailable(true);

}

void testReceiveAvailablePresenceFromMUCDoesNotCreateNotification() {

mucRegistry->addMUC(JID("teaparty@wonderland.lit"));

sendPresence(JID("teaparty@wonderland.lit/Alice"), StatusShow::Away);

}

void testNotificationPicture() {

sendPresence(user1, StatusShow::Online);

}

void testNotificationActivationEmitsSignal() {

sendPresence(user1, StatusShow::Online);

CPPUNIT_ASSERT(notifier->notifications[0].callback);

}

void testNotificationSubjectContainsNameForJIDInRoster() {

roster->addContact(user1.toBare(), "User 1", std::vector<std::string>(), RosterItemPayload::Both);

sendPresence(user1, StatusShow::Online);

}

void testNotificationSubjectContainsJIDForJIDNotInRoster() {

sendPresence(user1, StatusShow::Online);

}

void testNotificationSubjectContainsStatus() {

sendPresence(user1, StatusShow::Away);

}

void testNotificationMessageContainsStatusMessage() {

sendPresence(user1, StatusShow::Away);

}

void testReceiveFirstPresenceWithQuietPeriodDoesNotNotify() {

testling->setInitialQuietPeriodMS(10);

sendPresence(user1, StatusShow::Online);

}

void testReceivePresenceDuringQuietPeriodDoesNotNotify() {

testling->setInitialQuietPeriodMS(10);

sendPresence(user1, StatusShow::Online);

}

void testReceivePresenceDuringQuietPeriodResetsTimer() {

testling->setInitialQuietPeriodMS(10);

sendPresence(user1, StatusShow::Online);

}

void testReceivePresenceAfterQuietPeriodNotifies() {

testling->setInitialQuietPeriodMS(10);

sendPresence(user1, StatusShow::Online);

}

void testReceiveFirstPresenceWithQuietPeriodDoesNotCountAsQuietPeriod() {

testling->setInitialQuietPeriodMS(10);

timerFactory->setTime(11);

}

void testReceiveFirstPresenceAfterReconnectWithQuietPeriodDoesNotNotify() {

testling->setInitialQuietPeriodMS(10);

sendPresence(user1, StatusShow::Online);

timerFactory->setTime(15);

private:

result->onNotificationActivated.connect(boost::bind(&PresenceNotifierTest::handleNotificationActivated, this, _1));

result->setInitialQuietPeriodMS(0);

return result;

}

}

if (xmlConsoleWidget) {

xmlConsoleWidget->handleDataRead(data);

}

}

if (xmlConsoleWidget) {

xmlConsoleWidget->handleDataWritten(data);

}

#include <boost/shared_ptr.hpp>

#include "Swift/Controllers/UIEvents/UIEventStream.h"

namespace Swift {

~XMLConsoleController();

public:

private:

void handleUIEvent(boost::shared_ptr<UIEvent> event);

#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

/*

* Licensed under the GNU General Public License v3.

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

*/

#include "Swift/QtUI/Roster/GroupItemDelegate.h"

#include "Swift/QtUI/ChatList/ChatListItem.h"

#include "Swift/QtUI/ChatList/ChatListMUCItem.h"

#include "Swift/QtUI/ChatList/ChatListGroupItem.h"

namespace Swift {

ChatListItem* item = static_cast<ChatListItem*>(index.internalPointer());

if (item && dynamic_cast<ChatListMUCItem*>(item)) {

return mucSizeHint(option, index);

return groupDelegate_->sizeHint(option, index);

}

return QStyledItemDelegate::sizeHint(option, index);

return QSize(150, sizeByText);

}

void ChatListDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const {

ChatListItem* item = static_cast<ChatListItem*>(index.internalPointer());

if (item && dynamic_cast<ChatListMUCItem*>(item)) {

paintMUC(painter, option, dynamic_cast<ChatListMUCItem*>(item));

ChatListGroupItem* group = dynamic_cast<ChatListGroupItem*>(item);

groupDelegate_->paint(painter, option, group->data(Qt::DisplayRole).toString(), group->rowCount(), option.state & QStyle::State_Open);

QStyledItemDelegate::paint(painter, option, index);

}

}

painter->setPen(QPen(QColor(160,160,160)));

QRect detailRegion(textRegion.adjusted(0, nameHeight, 0, 0));

painter->restore();

}

}

/*

* Licensed under the GNU General Public License v3.

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

*/

namespace Swift {

class ChatListMUCItem;

class ChatListDelegate : public QStyledItemDelegate {

public:

ChatListDelegate();

void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const;

private:

void paintMUC(QPainter* painter, const QStyleOptionViewItem& option, ChatListMUCItem* item) const;

QSize mucSizeHint(const QStyleOptionViewItem& /*option*/, const QModelIndex& /*index*/ ) const;

DelegateCommons common_;

GroupItemDelegate* groupDelegate_;

/*

* Licensed under the GNU General Public License v3.

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

*/

namespace Swift {

class ChatListGroupItem : public ChatListItem {

public:

void remove(int index) {items_.removeAt(index);};

int rowCount() {return items_.size();};

ChatListItem* item(int i) {return items_[i];};

QString name_;

QList<ChatListItem*> items_;

};

}

}

return bookmark_;

}

#include "Swift/QtUI/ChatList/ChatListItem.h"

namespace Swift {

class ChatListMUCItem : public ChatListItem {

public:

ChatListMUCItem(const MUCBookmark& bookmark, ChatListGroupItem* parent);

QVariant data(int role) const;

private:

MUCBookmark bookmark_;

/*

* Licensed under the GNU General Public License v3.

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

*/

namespace Swift {

ChatListModel::ChatListModel() {

mucBookmarks_ = new ChatListGroupItem(tr("Bookmarked Rooms"), root_);

root_->addItem(mucBookmarks_);

}

emit layoutAboutToBeChanged();

mucBookmarks_->clear();

emit layoutChanged();

}

}

int ChatListModel::columnCount(const QModelIndex& /*parent*/) const {

return 1;

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <QAbstractItemModel>

#include <QList>

namespace Swift {

class ChatListModel : public QAbstractItemModel {

QModelIndex parent(const QModelIndex& index) const;

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

ChatListItem* getItemForIndex(const QModelIndex& index) const;

private:

ChatListGroupItem* mucBookmarks_;

ChatListGroupItem* root_;

};

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <QContextMenuEvent>

#include "Swift/QtUI/ChatList/ChatListMUCItem.h"

#include "Swift/QtUI/QtAddBookmarkWindow.h"

#include "Swift/QtUI/QtEditBookmarkWindow.h"

#include "Swift/Controllers/UIEvents/JoinMUCUIEvent.h"

#include "Swift/Controllers/UIEvents/AddMUCBookmarkUIEvent.h"

#include "Swift/Controllers/UIEvents/RemoveMUCBookmarkUIEvent.h"

#include "Swift/Controllers/UIEvents/EditMUCBookmarkUIEvent.h"

}

void QtChatListWindow::handleItemActivated(const QModelIndex& index) {

ChatListItem* item = model_->getItemForIndex(index);

ChatListMUCItem* mucItem = dynamic_cast<ChatListMUCItem*>(item);

boost::shared_ptr<UIEvent> event(new JoinMUCUIEvent(mucItem->getBookmark().getRoom(), mucItem->getBookmark().getNick()));

eventStream_->send(event);

}

}

}

void QtChatListWindow::addMUCBookmark(const MUCBookmark& bookmark) {

model_->removeMUCBookmark(bookmark);

}

void QtChatListWindow::handleRemoveBookmark() {

ChatListMUCItem* mucItem = dynamic_cast<ChatListMUCItem*>(contextMenuItem_);

if (!mucItem) return;

/*

* Licensed under the GNU General Public License v3.

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

*/

void addMUCBookmark(const MUCBookmark& bookmark);

void removeMUCBookmark(const MUCBookmark& bookmark);

void setBookmarksEnabled(bool enabled);

private slots:

void handleItemActivated(const QModelIndex&);

void handleAddBookmark();

public:

ChatSnippet(bool appendToPrevious);

virtual ~ChatSnippet();

virtual const QString& getContent() const = 0;

virtual QString getContinuationElementID() const { return ""; }

bool getAppendToPrevious() const {

return appendToPrevious_;

}

static QString escape(const QString& original) {

QString result(original);

result.replace("%message%", "&#37;message&#37;");

return result;

}

protected:

void setContinuationFallbackSnippet(boost::shared_ptr<ChatSnippet> continuationFallback) {

continuationFallback_ = continuationFallback;

}

private:

bool appendToPrevious_;

boost::shared_ptr<ChatSnippet> continuationFallback_;

#pragma once

#include <QTreeView>

MUCSearchRoomItem(const QString& node, MUCSearchServiceItem* parent);

MUCSearchServiceItem* getParent();

QVariant data(int role);

private:

MUCSearchServiceItem* parent_;

QString node_;

default: return QVariant();

}

}

private:

QList<MUCSearchItem*> rooms_;

QString jidString_;

this->type = type;

QImage image;

}

if (image.isNull()) {

QString fileName = QFileDialog::getOpenFileName(this, tr("Select picture"), "", tr("Image Files (*.png *.jpg *.gif)"));

if (!fileName.isEmpty()) {

ByteArray data;

QBuffer buffer;

buffer.open(QIODevice::ReadOnly);

QString type = QImageReader::imageFormat(&buffer).toLower();

if (!type.isEmpty()) {

#include "QtChatTabs.h"

#include <algorithm>

#include <QCloseEvent>

#include <QDesktopWidget>

default : tabTextColor = QColor();

}

tabs_->tabBar()->setTabTextColor(index, tabTextColor);

for (int i = 0; i < tabs_->count(); i++) {

QtTabbable* tab = qobject_cast<QtTabbable*>(tabs_->widget(i));

if (tab) {

}

}

}

void QtChatTabs::flash() {

}

return qrc_ ? "qrc" + themePath_ : "file://" + themePath_;

}

class QtChatTheme {

public:

QtChatTheme(const QString& themePath);

private:

enum files {Header = 0, Footer, Content, Status, Topic, FileTransferRequest, IncomingContent, IncomingNextContent, IncomingContext, IncomingNextContext, OutgoingContent, OutgoingNextContent, OutgoingContext, OutgoingNextContext, Template, MainCSS, TemplateDefault, EndMarker};

namespace Swift {

theme_ = theme;

QVBoxLayout* mainLayout = new QVBoxLayout(this);

connect(webView_, SIGNAL(loadFinished(bool)), SLOT(handleViewLoadFinished(bool)));

connect(webView_, SIGNAL(gotFocus()), SIGNAL(gotFocus()));

connect(webView_, SIGNAL(clearRequested()), SLOT(handleClearRequested()));

#ifdef Q_WS_X11

/* To give a border on Linux, where it looks bad without */

QStackedWidget* stack = new QStackedWidget(this);

if (viewReady_) {

addToDOM(snippet);

} else {

}

}

QWebElement QtChatView::snippetToDOM(boost::shared_ptr<ChatSnippet> snippet) {

QWebElement newElement = newInsertPoint_.clone();

Q_ASSERT(!newElement.isNull());

return newElement;

}

newInsertPoint_.prependOutside(newElement);

}

lastElement_ = newElement;

}

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

assert(viewReady_);

rememberScrolledToBottom();

assert(!lastElement_.isNull());

QWebElement replace = lastElement_.findFirst("span.swift_message");

replace.setInnerXml(ChatSnippet::escape(note));

}

void QtChatView::copySelectionToClipboard() {

if (!webPage_->selectedText().isEmpty()) {

webPage_->triggerAction(QWebPage::Copy);

QDesktopServices::openUrl(url);

}

void QtChatView::handleViewLoadFinished(bool ok) {

Q_ASSERT(ok);

viewReady_ = true;

}

void QtChatView::resetView() {

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

void setAckXML(const QString& id, const QString& xml);

signals:

void gotFocus();

public slots:

void copySelectionToClipboard();

void handleLinkClicked(const QUrl&);

void handleKeyPressEvent(QKeyEvent* event);

void resetView();

private slots:

void handleViewLoadFinished(bool);

private:

void headerEncode();

void messageEncode();

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

QWebElement snippetToDOM(boost::shared_ptr<ChatSnippet> snippet);

bool isAtBottom_;

QtWebView* webView_;

QWebPage* webPage_;

QtChatTheme* theme_;

QWebElement newInsertPoint_;

QWebElement lastElement_;

QWebElement document_;

};

/*

* Licensed under the GNU General Public License v3.

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

*/

#include "MessageSnippet.h"

#include "SystemMessageSnippet.h"

#include "QtTextEdit.h"

#include "QtScaledAvatarCache.h"

#include "SwifTools/TabComplete.h"

#include <QApplication>

#include <QBoxLayout>

#include <QCloseEvent>

inputEnabled_ = true;

completer_ = NULL;

theme_ = theme;

updateTitleWithUnreadCount();

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

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

layout->setSpacing(2);

messageLog_ = new QtChatView(theme, this);

treeWidget_ = new QtTreeWidget(eventStream_);

treeWidget_->setEditable(false);

treeWidget_->hide();

QWidget* midBar = new QWidget(this);

layout->addWidget(midBar);

labelsWidget_->setSizeAdjustPolicy(QComboBox::AdjustToContents);

midBarLayout->addWidget(labelsWidget_,0);

input_ = new QtTextEdit(this);

input_->setAcceptRichText(false);

inputClearing_ = false;

contactIsTyping_ = false;

connect(input_, SIGNAL(returnPressed()), this, SLOT(returnPressed()));

connect(input_, SIGNAL(textChanged()), this, SLOT(handleInputChanged()));

setFocusProxy(input_);

midBar->setFocusProxy(input_);

messageLog_->setFocusProxy(input_);

connect(qApp, SIGNAL(focusChanged(QWidget*, QWidget*)), this, SLOT(qAppFocusChanged(QWidget*, QWidget*)));

connect(messageLog_, SIGNAL(gotFocus()), input_, SLOT(setFocus()));

resize(400,300);

}

QtChatWindow::~QtChatWindow() {

}

void QtChatWindow::setTabComplete(TabComplete* completer) {

completer_ = completer;

}

emit requestActiveTab();

} else if (key == Qt::Key_Tab) {

tabComplete();

} else {

messageLog_->handleKeyPressEvent(event);

}

}

void QtChatWindow::tabComplete() {

if (!completer_) {

return;

}

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

QString errorMessageHTML(Qt::escape(P2QSTRING(errorMessage)));

errorMessageHTML.replace("\n","<br/>");

previousMessageWasSelf_ = false;

previousMessageWasSystem_ = true;

previousMessageWasPresence_ = false;

}

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

if (isWidgetSelected()) {

onAllMessagesRead();

return;

}

messageLog_->scrollToBottom();

inputClearing_ = true;

input_->clear();

inputClearing_ = false;

}

}

void QtChatWindow::show() {

emit windowOpening();

}

}

void QtChatWindow::moveEvent(QMoveEvent*) {

}

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

/*

* Licensed under the GNU General Public License v3.

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

*/

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

#include "QtTabbable.h"

#include "Swiften/Base/IDGenerator.h"

class QTextEdit;

class QLineEdit;

class QComboBox;

namespace Swift {

class QtChatView;

void addSystemMessage(const std::string& message);

void addPresenceMessage(const std::string& message);

void addErrorMessage(const std::string& errorMessage);

void show();

void activate();

void setUnreadMessageCount(int count);

void replaceLastMessage(const std::string& message);

void setAckState(const std::string& id, AckState state);

void flash();

signals:

void geometryChanged();

protected slots:

void qAppFocusChanged(QWidget* old, QWidget* now);

void returnPressed();

void handleInputChanged();

void handleKeyPressEvent(QKeyEvent* event);

private:

void updateTitleWithUnreadCount();

void tabComplete();

std::string addMessage(const std::string &message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const QString& style, const boost::posix_time::ptime& time);

int unreadCount_;

bool contactIsTyping_;

QString contact_;

QtChatView* messageLog_;

QtChatTheme* theme_;

QtTextEdit* input_;

QComboBox* labelsWidget_;

QtTreeWidget* treeWidget_;

TabComplete* completer_;

std::vector<SecurityLabelsCatalog::Item> availableLabels_;

bool previousMessageWasSelf_;

bool previousMessageWasSystem_;

bool previousMessageWasPresence_;

UIEventStream* eventStream_;

bool inputEnabled_;

IDGenerator id_;

};

}

namespace Swift {

QtChatWindowFactory::QtChatWindowFactory(QSplitter* splitter, QtSettingsProvider* settings, QtChatTabs* tabs, const QString& themePath) : themePath_(themePath) {

settings_ = settings;

tabs_ = tabs;

if (splitter) {

splitter->addWidget(tabs_);

} else if (tabs_) {

if (chatTabsGeometryVariant.isValid()) {

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

}

theme_ = new QtChatTheme(""); /* Use the inbuilt theme */

}

}

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

if (tabs_) {

tabs_->addTab(chatWindow);

} else {

if (chatGeometryVariant.isValid()) {

chatWindow->restoreGeometry(chatGeometryVariant.toByteArray());

}

}

void QtChatWindowFactory::handleWindowGeometryChanged() {

}

}

QtChatWindowFactory(QSplitter* splitter, QtSettingsProvider* settings, QtChatTabs* tabs, const QString& themePath);

~QtChatWindowFactory();

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

private slots:

void handleWindowGeometryChanged();

private:

QString themePath_;

QtSettingsProvider* settings_;

/*

* Licensed under the GNU General Public License v3.

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

*/

namespace Swift{

uiEventStream_ = uiEventStream;

setWindowTitle("Swift");

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

this->show();

}

bool QtLoginWindow::eventFilter(QObject *obj, QEvent *event) {

if (obj == username_->view() && event->type() == QEvent::KeyPress) {

QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);

}

void QtLoginWindow::loggedOut() {

setInitialMenus();

setIsLoggingIn(false);

}

void QtLoginWindow::loginClicked() {

if (username_->isEnabled()) {

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

} else {

onCancelLoginRequest();

}

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>

virtual void removeAvailableAccount(const std::string& jid);

virtual void setLoginAutomatically(bool loginAutomatically);

virtual void setIsLoggingIn(bool loggingIn);

void selectUser(const std::string& user);

bool askUserToTrustCertificatePermanently(const std::string& message, Certificate::ref certificate);

void hide();

private:

void setInitialMenus();

QStringList usernames_;

QStringList passwords_;

QStringList certificateFiles_;

QAction* toggleNotificationsAction_;

UIEventStream* uiEventStream_;

QPointer<QtAboutWidget> aboutDialog_;

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <QAction>

#include <QTabWidget>

namespace Swift {

QtMainWindow::QtMainWindow(QtSettingsProvider* settings, UIEventStream* uiEventStream) : QWidget(), MainWindow(false) {

uiEventStream_ = uiEventStream;

setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));

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

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

chatListWindow_ = new QtChatListWindow(uiEventStream_);

tabs_->addTab(chatListWindow_, tr("C&hats"));

this->setLayout(mainLayout);

chatUserAction_ = new QAction(tr("Start &Chat"), this);

connect(chatUserAction_, SIGNAL(triggered(bool)), this, SLOT(handleChatUserActionTriggered(bool)));

actionsMenu->addAction(chatUserAction_);

actionsMenu->addSeparator();

QAction* signOutAction = new QAction(tr("&Sign Out"), this);

connect(signOutAction, SIGNAL(triggered()), SLOT(handleSignOutAction()));

connect(treeWidget_, SIGNAL(onSomethingSelectedChanged(bool)), editUserAction_, SLOT(setEnabled(bool)));

lastOfflineState_ = false;

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

}

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

}

QtEventWindow* QtMainWindow::getEventWindow() {

return eventWindow_;

}

void QtMainWindow::handleEventCountUpdated(int count) {

QColor eventTabColor = (count == 0) ? QColor() : QColor(255, 0, 0); // invalid resets to default

tabs_->tabBar()->setTabTextColor(eventIndex, eventTabColor);

QString text = tr("&Notices");

if (count > 0) {

meView_->setConnecting();

}

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <QWidget>

#include <QMenu>

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

#include "Swift/QtUI/QtRosterHeader.h"

#include "Swift/QtUI/EventViewer/QtEventWindow.h"

class QPushButton;

class QToolBar;

class QAction;

class QTabWidget;

namespace Swift {

QtEventWindow* getEventWindow();

QtChatListWindow* getChatListWindow();

void setRosterModel(Roster* roster);

private slots:

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

void handleUIEvent(boost::shared_ptr<UIEvent> event);

void handleEditProfileAction();

void handleAddUserActionTriggered(bool checked);

void handleChatUserActionTriggered(bool checked);

void handleEventCountUpdated(int count);

void handleEditProfileRequest();

private:

std::vector<QMenu*> menus_;

QtTreeWidget* treeWidget_;

QtRosterHeader* meView_;

QAction* editUserAction_;

QAction* chatUserAction_;

QAction* showOfflineAction_;

QtTabWidget* tabs_;

QWidget* contactsTabWidget_;

QWidget* eventsTabWidget_;

QtChatListWindow* chatListWindow_;

UIEventStream* uiEventStream_;

bool lastOfflineState_;

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include "QtUIFactory.h"

#include "QtChatWindowFactory.h"

#include <Swiften/Base/Log.h>

#include "SwifTools/Application/PlatformApplicationPathProvider.h"

#include <string>

#include "Swiften/Base/Platform.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Client/Client.h"

#include "Swift/Controllers/MainController.h"

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

("latency-debug", "Use latency debugging (unsupported)")

("multi-account", po::value<int>()->default_value(1), "Number of accounts to open windows for (unsupported)")

("start-minimized", "Don't show the login/roster window at startup")

;

return result;

}

tabs_ = options.count("no-tabs") && !(splitter_ > 0) ? NULL : new QtChatTabs();

bool startMinimized = options.count("start-minimized") > 0;

settings_ = new QtSettingsProvider();

applicationPathProvider_ = new PlatformApplicationPathProvider(SWIFT_APPLICATION_NAME);

storagesFactory_ = new FileStoragesFactory(applicationPathProvider_->getDataDir());

dock_ = new NullDock();

#endif

if (splitter_) {

splitter_->show();

}

certificateStorageFactory_,

dock_,

notifier_,

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

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

*/

#include <QFontMetrics>

#include <QKeyEvent>

if ((key == Qt::Key_Enter || key == Qt::Key_Return)

&& (modifiers == Qt::NoModifier || modifiers == Qt::KeypadModifier)) {

emit returnPressed();

|| (key == Qt::Key_C && modifiers == Qt::ControlModifier && textCursor().selectedText().isEmpty())

|| (key == Qt::Key_W && modifiers == Qt::ControlModifier)

|| (key == Qt::Key_PageUp && modifiers == Qt::ControlModifier)

|| (key == Qt::Key_PageDown && modifiers == Qt::ControlModifier)

|| (key == Qt::Key_Tab && modifiers == Qt::ControlModifier)

|| (key == Qt::Key_A && modifiers == Qt::AltModifier)

|| (key == Qt::Key_Tab)

) {

emit unhandledKeyPressEvent(event);

QTextEdit::keyPressEvent(event);

}

}

#include "UserSearch/QtUserSearchWindow.h"

#include "QtProfileWindow.h"

#include "QtContactEditWindow.h"

namespace Swift {

QtUIFactory::QtUIFactory(QtSettingsProvider* settings, QtChatTabs* tabs, QSplitter* netbookSplitter, QtSystemTray* systemTray, QtChatWindowFactory* chatWindowFactory, bool startMinimized) : settings(settings), tabs(tabs), netbookSplitter(netbookSplitter), systemTray(systemTray), chatWindowFactory(chatWindowFactory), lastMainWindow(NULL), loginWindow(NULL), startMinimized(startMinimized) {

}

XMLConsoleWidget* QtUIFactory::createXMLConsoleWidget() {

}

ChatWindow* QtUIFactory::createChatWindow(const JID& contact, UIEventStream* eventStream) {

}

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

return new QtContactEditWindow();

}

}

#pragma once

#include <QObject>

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

class QtMainWindow;

class QtChatTheme;

class QtChatWindowFactory;

class QtUIFactory : public QObject, public UIFactory {

Q_OBJECT

virtual JoinMUCWindow* createJoinMUCWindow();

virtual ProfileWindow* createProfileWindow();

virtual ContactEditWindow* createContactEditWindow();

private slots:

void handleLoginWindowGeometryChanged();

private:

QtSettingsProvider* settings;

QtChatWindowFactory* chatWindowFactory;

QtMainWindow* lastMainWindow;

QtLoginWindow* loginWindow;

bool startMinimized;

};

}

// Add our own custom actions

menu->addAction(tr("Clear"), this, SIGNAL(clearRequested()));

menu->exec(ev->globalPos());

delete menu;

signals:

void gotFocus();

void clearRequested();

protected:

void focusInEvent(QFocusEvent* event);

event->accept();

}

}

}

void QtXMLConsoleWidget::appendTextIfEnabled(const std::string& data, const QColor& color) {

void show();

void activate();