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

}

}

unreadMessages_.clear();

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

postHandleIncomingMessage(messageEvent);

}

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

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

joinMUCWindow_ = NULL;

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;

return;

mucBookmarkManager_->replaceBookmark(editMUCBookmarkEvent->getOldBookmark(), editMUCBookmarkEvent->getNewBookmark());

}

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

}

if (!joinMUCWindow_) {

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

}

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

joinMUCWindow_->show();

}

*/

void ChatsManager::handlePresenceChange(boost::shared_ptr<Presence> newPresence) {

if (mucRegistry_->isMUC(newPresence->getFrom().toBare())) return;

//if (newPresence->getType() != Presence::Unavailable) return;

JID fullJID(newPresence->getFrom());

std::map<JID, ChatController*>::iterator it = chatControllers_.find(fullJID);

}

void ChatsManager::setAvatarManager(AvatarManager* avatarManager) {

avatarManager_ = avatarManager;

}

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

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;

}

return controller ? controller : createNewChatController(contact);

}

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

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

return NULL;

} else {

foreach (JIDChatControllerPair pair, chatControllers_) {

if (pair.first.toBare() == contact.toBare()) {

}

}

return NULL;

chatControllers_[to]->setToJID(to);

}

MUCBookmark bookmark(mucJID, mucJID.getNode());

bookmark.setAutojoin(true);

if (nickMaybe) {

mucControllers_[mucJID] = controller;

controller->setAvailableServerFeatures(serverDiscoInfo_);

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

}

}

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

class MUCController;

class MUCManager;

class ChatWindowFactory;

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 setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info);

void handleIncomingMessage(boost::shared_ptr<Message> message);

private:

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

void handleSearchMUCRequest();

void handleMUCSelectedAfterSearch(const JID&);

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

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

std::map<JID, MUCController*> mucControllers_;

std::map<JID, ChatController*> chatControllers_;

EventController* eventController_;

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

}

}

void MUCController::handleJoinTimeoutTick() {

receivedActivity();

chatWindow_->addSystemMessage(str(format(QT_TRANSLATE_NOOP("", "Room %1% is not responding. This operation may never complete.")) % toJID_.toString()));

default: break;

}

}

chatWindow_->addErrorMessage(errorMessage);

if (!rejoinNick.empty()) {

nick_ = rejoinNick;

clearPresenceQueue();

shouldJoinOnReconnect_ = true;

setEnabled(true);

}

void MUCController::handleAvatarChanged(const JID& jid) {

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;

MUCController(const JID& self, MUC::ref muc, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController);

~MUCController();

boost::signal<void ()> onUserLeft;

virtual void setOnline(bool online);

void rejoin();

static void appendToJoinParts(std::vector<NickJoinPart>& joinParts, const NickJoinPart& newEvent);

static std::string generateJoinPartString(const std::vector<NickJoinPart>& joinParts);

static std::string concatenateListOfNames(const std::vector<NickJoinPart>& joinParts);

protected:

void preSendMessageRequest(boost::shared_ptr<Message> message);

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

}

if (event->getConcluded()) {

handleEventConcluded(event);

} else {

}

}

/*

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

loginWindow_->onQuitRequest.connect(boost::bind(&MainController::handleQuitRequest, this));

xmlConsoleController_ = new XMLConsoleController(uiEventStream_, uiFactory_);

}

MainController::~MainController() {

//setManagersOffline();

eventController_->disconnectAll();

resetClient();

delete xmlConsoleController_;

delete soundEventController_;

delete systemTrayController_;

delete eventController_;

delete uiEventStream_;

}

void MainController::resetClient() {

resetCurrentError();

resetPendingReconnects();

vCardPhotoHash_.clear();

void MainController::handleConnected() {

boundJID_ = client_->getJID();

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.

*/

#include <vector>

#include "Swiften/Network/Timer.h"

#include <string>

#include "Swiften/Client/ClientError.h"

#include "Swiften/JID/JID.h"

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

namespace Swift {

class UIFactory;

class EventLoop;

class Client;

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

NetworkFactories* networkFactories_;

UIFactory* uiFactory_;

StoragesFactory* storagesFactory_;

Storages* storages_;

CertificateStorageFactory* certificateStorageFactory_;

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("Roster/UnitTest/RosterControllerTest.cpp"),

File("Roster/UnitTest/RosterTest.cpp"),

File("UnitTest/PreviousStatusStoreTest.cpp"),

File("UnitTest/PresenceNotifierTest.cpp"),

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;

#include <boost/shared_ptr.hpp>

#include <string>

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

namespace Swift {

class JoinMUCUIEvent : public UIEvent {

public:

typedef boost::shared_ptr<JoinMUCUIEvent> ref;

boost::optional<std::string> getNick() {return nick_;};

JID getJID() {return jid_;};

private:

JID jid_;

boost::optional<std::string> nick_;

};

}

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

virtual void setMUC(const std::string& nick) = 0;

virtual void show() = 0;

boost::signal<void ()> onSearchMUC;

};

}

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

namespace Swift {

class JoinMUCWindowFactory {

public:

virtual ~JoinMUCWindowFactory() {};

};

}

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

}

}

}

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

<item row="4" column="1">

<widget class="QCheckBox" name="autojoin_">

<property name="text">

</property>

<property name="checked">

<bool>true</bool>

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