targetedUnreadMessages_.clear();

for (std::shared_ptr<StanzaEvent> stanzaEvent : unreadMessages_) {

stanzaEvent->conclude();

}

unreadMessages_.clear();

updateMessageCount();

}

}

}

void ChatControllerBase::handleSendMessageRequest(const std::string &body, bool isCorrectionMessage) {

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

return;

}

std::shared_ptr<Message> message(new Message());

message->setTo(toJID_);

message->setType(Swift::Message::Chat);

}

ChatWindow::ChatMessage ChatControllerBase::buildChatWindowChatMessage(const std::string& message, const std::string& senderName, bool senderIsSelf) {

ChatWindow::ChatMessage chatMessage;

chatMessage = chatMessageParser_->parseMessageBody(message, senderName, senderIsSelf);

return chatMessage;

}

void ChatControllerBase::updateMessageCount() {

auto baseJID = getBaseJID();

auto state = chattables_.getState(baseJID);

chattables_.setState(baseJID, state);

#ifndef NOT_YET

onUnreadCountChanged();

#endif

}

std::string ChatControllerBase::addMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& senderName, bool senderIsSelf, const std::shared_ptr<SecurityLabel> label, const boost::filesystem::path& avatarPath, const boost::posix_time::ptime& time) {

auto displayedLabel = label;

std::string addMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::filesystem::path& avatarPath, const boost::posix_time::ptime& time);

void replaceMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& id, const boost::posix_time::ptime& time);

virtual void setOnline(bool online);

void setEnabled(bool enabled);

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

/** Used for determining when something is recent.*/

boost::signals2::signal<void (const std::string& /*activity*/)> onActivity;

boost::signals2::signal<void ()> onUnreadCountChanged;

boost::signals2::signal<void ()> onWindowClosed;

const JID& getToJID() {return toJID_;}

void handleCapsChanged(const JID& jid);

void setCanStartImpromptuChats(bool supportsImpromptu);

virtual ChatWindow* detachChatWindow();

boost::signals2::signal<void(ChatWindow* /*window to reuse*/, const std::vector<JID>& /*invite people*/, const std::string& /*reason*/)> onConvertToMUC;

protected:

ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables);

void ChatsManager::handleMUCBookmarkRemoved(const MUCBookmark& bookmark) {

#ifndef NOT_YET

chatListWindow_->removeMUCBookmark(bookmark);

#endif

}

#ifndef NOT_YET

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

if (mucRegistry_->isMUC(jid)) {

MUCController* controller = mucControllers_[jid.toBare()];

StatusShow::Type type = StatusShow::None;

std::string nick = "";

std::string password = "";

if (controller) {

unreadCount = controller->getUnreadCount();

if (controller->isJoined()) {

type = StatusShow::Online;

cleanupPrivateMessageRecents();

#ifndef NOT_YET

chatListWindow_->setRecents(recentChats_);

#endif

}

#ifndef NOT_YET

void ChatsManager::handleUnreadCountChanged(ChatControllerBase* controller) {

bool controllerIsMUC = dynamic_cast<MUCController*>(controller);

bool isPM = controller && !controllerIsMUC && mucRegistry_->isMUC(controller->getToJID().toBare());

for (ChatListWindow::Chat& chatItem : recentChats_) {

bool match = false;

if (controller) {

/* Matching MUC item */

match |= chatItem.isMUC == controllerIsMUC && chatItem.jid.toBare() == controller->getToJID().toBare();

/* Matching PM */

match |= isPM && chatItem.jid == controller->getToJID();

namespace Swift {

class Chattables {

public:

struct State {

enum class Type {Room, Person};

JID jid;

/// Empty for no name

std::string name;

Type type;

StatusShow::Type status = StatusShow::None;

//avatar

//status

};

const std::vector<JID>& get() const;

const State& getState(const JID& jid) const;

void addJID(const JID& jid, State::Type type);

* All rights reserved.

* See the COPYING file for more information.

*/

#include <gtest/gtest.h>

#include <hippomocks.h>

#include <Swift/Controllers/Chat/Chattables.h>

using namespace Swift;

class ChattablesTest : public ::testing::Test {

protected:

void SetUp() {

beginListSize_ = 0;

endListSize_ = 0;

callsToBegin_ = 0;

callsToEnd_ = 0;

public:

MockChatListWindow() {}

virtual ~MockChatListWindow() {}

void addMUCBookmark(const MUCBookmark& /*bookmark*/) {}

void removeMUCBookmark(const MUCBookmark& /*bookmark*/) {}

void addWhiteboardSession(const ChatListWindow::Chat& /*chat*/) {}

void removeWhiteboardSession(const JID& /*jid*/) {}

void setBookmarksEnabled(bool /*enabled*/) {}

void setRecents(const std::list<ChatListWindow::Chat>& /*recents*/) {}

void clearBookmarks() {}

void setOnline(bool /*isOnline*/) {}

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/Storages/CertificateFileStorage.h>

#include <iostream>

#include <boost/filesystem/fstream.hpp>

#include <Swiften/Elements/StatusShow.h>

#include <Swiften/MUC/MUCBookmark.h>

namespace Swift {

class ChatListWindow {

public:

class Chat {

public:

Chat() : statusType(StatusShow::None), isMUC(false), unreadCount(0), isPrivateMessage(false) {}

: jid(jid), chatName(chatName), activity(activity), statusType(statusType), isMUC(isMUC), nick(nick), password(password), unreadCount(unreadCount), avatarPath(avatarPath), isPrivateMessage(isPrivateMessage) {}

/** Assume that nicks and other transient features aren't important for equality */

bool operator==(const Chat& other) const {

if (impromptuJIDs.empty()) {

return jid.toBare() == other.jid.toBare()

&& isMUC == other.isMUC;

}

if (chatName == other.chatName) {

return true;

}

}

if (!found) {

return false;

}

}

return key_compare(inviteesNames, other.inviteesNames);

}

}

unreadCount = unread;

}

void setStatusType(StatusShow::Type type) {

statusType = type;

}

void setAvatarPath(const boost::filesystem::path& path) {

avatarPath = path;

}

std::string getImpromptuTitle() const {

return title.empty() ? chatName : title;

}

JID jid;

std::string chatName;

std::string activity;

StatusShow::Type statusType;

bool isMUC;

std::string nick;

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

boost::filesystem::path avatarPath;

std::map<std::string, JID> impromptuJIDs;

std::map<JID, std::string> inviteesNames;

bool isPrivateMessage;

};

virtual ~ChatListWindow();

virtual void setBookmarksEnabled(bool enabled) = 0;

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

virtual void addWhiteboardSession(const ChatListWindow::Chat& chat) = 0;

virtual void removeWhiteboardSession(const JID& jid) = 0;

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

virtual void setRecents(const std::list<Chat>& recents) = 0;

virtual void clearBookmarks() = 0;

virtual void setOnline(bool isOnline) = 0;

boost::signals2::signal<void (const MUCBookmark&)> onMUCBookmarkActivated;

boost::signals2::signal<void (const Chat&)> onRecentActivated;

boost::signals2::signal<void (const JID&)> onWhiteboardActivated;

boost::signals2::signal<void ()> onClearRecentsRequested;

};

}

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

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

virtual void show() = 0;

virtual bool isVisible() const = 0;

virtual void activate() = 0;

virtual void setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels) = 0;

virtual void setSecurityLabelsEnabled(bool enabled) = 0;

virtual void setCorrectionEnabled(Tristate enabled) = 0;

virtual void setFileTransferEnabled(Tristate enabled) = 0;

virtual void convertToMUC(MUCType mucType) = 0;

// virtual TreeWidget *getTreeWidget() = 0;

virtual void setSecurityLabelsError() = 0;

virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() = 0;

virtual void setOnline(bool online) = 0;

virtual void setRosterModel(Roster* model) = 0;

virtual void setTabComplete(TabComplete* completer) = 0;

virtual void replaceLastMessage(const ChatMessage& message, const TimestampBehaviour timestampBehaviour) = 0;

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

}

virtual void setContactChatState(ChatState::ChatStateType /*state*/) {}

virtual void setName(const std::string& name) {name_ = name;}

virtual void show() {}

virtual bool isVisible() const { return true; }

virtual void activate() {}

virtual void setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels) {labels_ = labels;}

virtual void setSecurityLabelsEnabled(bool enabled) {labelsEnabled_ = enabled;}

virtual void convertToMUC(MUCType mucType) {

mucType_ = mucType;

}

virtual void setSecurityLabelsError() {}

virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() {return label_;}

virtual void setOnline(bool /*online*/) {}

virtual void setRosterModel(Roster* roster) { roster_ = roster; }

void QtChatListWindow::removeWhiteboardSession(const JID& jid) {

model_->removeWhiteboardSession(jid);

}

void QtChatListWindow::setRecents(const std::list<ChatListWindow::Chat>& recents) {

model_->setRecents(recents);

}

emit onCountUpdated(unread);

}

void QtChatListWindow::setOnline(bool isOnline) {

isOnline_ = isOnline;

}

void QtChatListWindow::handleRemoveBookmark() {

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

public:

QtChatListWindow(UIEventStream *uiEventStream, SettingsProvider* settings, QWidget* parent = nullptr);

virtual ~QtChatListWindow();

void addMUCBookmark(const MUCBookmark& bookmark);

void removeMUCBookmark(const MUCBookmark& bookmark);

void addWhiteboardSession(const ChatListWindow::Chat& chat);

void removeWhiteboardSession(const JID& jid);

void setBookmarksEnabled(bool enabled);

void setRecents(const std::list<ChatListWindow::Chat>& recents);

void clearBookmarks();

virtual void setOnline(bool isOnline);

signals:

private slots:

void handleItemActivated(const QModelIndex&);

void handleEditBookmark();

void handleRemoveBookmark();

void handleClicked(const QModelIndex& index);

void handleSettingChanged(const std::string& setting);

void handleClearRecentsRequested();

protected:

}

}

}

void QtChatWindow::showEvent(QShowEvent* event) {

emit windowOpening();

QWidget::showEvent(event);

}

if (unreadCount_ != count) {

unreadCount_ = count;

updateTitleWithUnreadCount();

emit countUpdated();

}

}

void QtChatWindow::setContactChatState(ChatState::ChatStateType state) {

contactIsTyping_ = (state == ChatState::Composing);

setWindowTitle(contact_);

}

emit titleUpdated();

}

void QtChatWindow::flash() {

emit requestFlash();

}

return unreadCount_;

}

void QtChatWindow::replaceSystemMessage(const ChatWindow::ChatMessage& message, const std::string& id, const ChatWindow::TimestampBehaviour timestampBehaviour) {

messageLog_->replaceSystemMessage(message, id, timestampBehaviour);

}

void QtChatWindow::returnPressed() {

if (!isOnline_ || (blockingState_ == IsBlocked)) {

void setFileTransferProgress(std::string id, const int percentageDone);

void setFileTransferStatus(std::string id, const FileTransferState state, const std::string& msg);

std::string addWhiteboardRequest(bool senderIsSelf);

void setWhiteboardSessionStatus(std::string id, const ChatWindow::WhiteboardSessionState state);

void show();

bool isVisible() const;

void activate();

void convertToMUC(MUCType mucType);

// TreeWidget *getTreeWidget();

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

void setSecurityLabelsEnabled(bool enabled);

void setSecurityLabelsError();

SecurityLabelsCatalog::Item getSelectedSecurityLabel();

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

void setOnline(bool online);

QtTabbable::AlertType getWidgetAlertState();

void setContactChatState(ChatState::ChatStateType state);

void setRosterModel(Roster* roster);

void setTabComplete(TabComplete* completer);

virtual void replaceSystemMessage(const ChatMessage& message, const std::string& id, const TimestampBehaviour timestampBehaviour);

void replaceLastMessage(const ChatMessage& message, const TimestampBehaviour timestampBehaviour);

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

// message receipts

void setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state);

void flash();

QByteArray getSplitterState();

static std::vector<JID> jidListFromQByteArray(const QByteArray& dataBytes);

void resetDayChangeTimer();

void setChatSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue);

void removeChatSecurityMarking();

void handleFocusTimerTick();

private:

bool contactIsTyping_;

LastLineTracker lastLineTracker_;

std::string id_;

QString contact_;

QString lastSentMessage_;

QTextCursor tabCompleteCursor_;

QtChatView* messageLog_;

QtChatTheme* theme_;

QtTextEdit* input_;

namespace Swift {

class QtTabbable : public QWidget {

Q_OBJECT

public:

enum AlertType {NoActivity, WaitingActivity, ImpendingActivity};

virtual ~QtTabbable();

bool isWidgetSelected();

virtual AlertType getWidgetAlertState() {return NoActivity;}

virtual std::string getID() const = 0;

virtual void setEmphasiseFocus(bool /*emphasise*/) {}

protected:

QtTabbable();

virtual bool event(QEvent* event);

virtual void closeEvent(QCloseEvent* event);

signals: