#endif

}

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

if (catalog && !error) {

if (catalog->getItems().size() == 0) {

chatWindow_->setSecurityLabelsEnabled(false);

labelsEnabled_ = false;

} else {

labelsEnabled_ = true;

chatWindow_->setAvailableSecurityLabels(catalog->getItems());

chatWindow_->setSecurityLabelsEnabled(true);

}

} else {

labelsEnabled_ = false;

chatWindow_->setSecurityLabelsError();

}

}

void ChatControllerBase::showChatWindow() {

chatWindow_->show();

}

void ChatControllerBase::activateChatWindow() {

chatWindow_->activate();

}

bool ChatControllerBase::hasOpenWindow() const {

return chatWindow_ && chatWindow_->isVisible();

}

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

if (boost::starts_with(message, "/me ")) {

return chatWindow_->addAction(chatMessageParser_->parseMessageBody(String::getSplittedAtFirst(message, ' ').second), senderName, senderIsSelf, label, pathToString(avatarPath), time, highlight);

} else {

}

}

void ChatControllerBase::replaceMessage(const std::string& message, const std::string& id, bool senderIsSelf, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

if (boost::starts_with(message, "/me ")) {

chatWindow_->replaceWithAction(chatMessageParser_->parseMessageBody(String::getSplittedAtFirst(message, ' ').second), id, time, highlight);

} else {

}

}

bool ChatControllerBase::isFromContact(const JID& from) {

return from.toBare() == toJID_.toBare();

}

void ChatControllerBase::handleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {

preHandleIncomingMessage(messageEvent);

if (messageEvent->isReadable() && !messageEvent->getConcluded()) {

unreadMessages_.push_back(messageEvent);

if (messageEvent->targetsMe()) {

targetedUnreadMessages_.push_back(messageEvent);

}

}

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

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

HighlightAction highlight;

if (message->isError()) {

if (!message->getTo().getResource().empty()) {

std::string errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't send message: %1%")) % getErrorMessage(message->getPayload<ErrorPayload>()));

chatWindow_->addErrorMessage(chatMessageParser_->parseMessageBody(errorMessage));

}

}

else if (messageEvent->getStanza()->getPayload<MUCInvitationPayload>()) {

handleMUCInvitation(messageEvent->getStanza());

return;

}

else if (messageEvent->getStanza()->getPayload<MUCUserPayload>() && messageEvent->getStanza()->getPayload<MUCUserPayload>()->getInvite()) {

handleMediatedMUCInvitation(messageEvent->getStanza());

return;

}

else {

if (!messageEvent->isReadable()) {

return;

/*

* Copyright (c) 2013-2014 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

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

#include <vector>

#include <utility>

#include <boost/smart_ptr/make_shared.hpp>

#include <boost/algorithm/string.hpp>

#include <Swiften/Base/Regex.h>

#include <Swiften/Base/foreach.h>

#include <SwifTools/Linkify.h>

namespace Swift {

ChatMessageParser::ChatMessageParser(const std::map<std::string, std::string>& emoticons, HighlightRulesListPtr highlightRules, bool mucMode)

: emoticons_(emoticons), highlightRules_(highlightRules), mucMode_(mucMode) {

}

typedef std::pair<std::string, std::string> StringPair;

ChatWindow::ChatMessage parsedMessage;

std::string remaining = body;

/* Parse one, URLs */

while (!remaining.empty()) {

bool found = false;

std::pair<std::vector<std::string>, size_t> links = Linkify::splitLink(remaining);

remaining = "";

for (size_t i = 0; i < links.first.size(); i++) {

const std::string& part = links.first[i];

if (found) {

// Must be on the last part, then

remaining = part;

}

else {

if (i == links.second) {

found = true;

parsedMessage.append(boost::make_shared<ChatWindow::ChatURIMessagePart>(part));

}

else {

parsedMessage.append(boost::make_shared<ChatWindow::ChatTextMessagePart>(part));

}

}

}

}

/* do emoticon substitution */

parsedMessage = emoticonHighlight(parsedMessage);

if (!senderIsSelf) { /* do not highlight our own messsages */

/* do word-based color highlighting */

}

return parsedMessage;

}

ChatWindow::ChatMessage ChatMessageParser::emoticonHighlight(const ChatWindow::ChatMessage& message)

{

ChatWindow::ChatMessage parsedMessage = message;

std::string regexString;

/* Parse two, emoticons */

foreach (StringPair emoticon, emoticons_) {

/* Construct a regexp that finds an instance of any of the emoticons inside a group

* at the start or end of the line, or beside whitespace.

*/

regexString += regexString.empty() ? "" : "|";

std::string escaped = "(" + Regex::escape(emoticon.first) + ")";

regexString += "^" + escaped + "|";

regexString += escaped + "$|";

regexString += "\\s" + escaped + "|";

regexString += escaped + "\\s";

}

if (!regexString.empty()) {

regexString += "";

boost::regex emoticonRegex(regexString);

ChatWindow::ChatMessage newMessage;

foreach (boost::shared_ptr<ChatWindow::ChatMessagePart> part, parsedMessage.getParts()) {

boost::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;

if ((textPart = boost::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(part))) {

try {

boost::match_results<std::string::const_iterator> match;

const std::string& text = textPart->text;

std::string::const_iterator start = text.begin();

if (start != matchStart) {

/* If we're skipping over plain text since the previous emoticon, record it as plain text */

newMessage.append(boost::make_shared<ChatWindow::ChatTextMessagePart>(std::string(start, matchStart)));

}

boost::shared_ptr<ChatWindow::ChatEmoticonMessagePart> emoticonPart = boost::make_shared<ChatWindow::ChatEmoticonMessagePart>();

std::string matchString = match[matchIndex].str();

std::map<std::string, std::string>::const_iterator emoticonIterator = emoticons_.find(matchString);

assert (emoticonIterator != emoticons_.end());

const StringPair& emoticon = *emoticonIterator;

emoticonPart->imagePath = emoticon.second;

emoticonPart->alternativeText = emoticon.first;

newMessage.append(emoticonPart);

start = matchEnd;

}

if (start != text.end()) {

/* If there's plain text after the last emoticon, record it */

newMessage.append(boost::make_shared<ChatWindow::ChatTextMessagePart>(std::string(start, text.end())));

}

}

catch (std::runtime_error) {

/* Basically too expensive to compute the regex results and it gave up, so pass through as text */

newMessage.append(part);

}

}

else {

newMessage.append(part);

}

}

parsedMessage = newMessage;

}

return parsedMessage;

}

{

ChatWindow::ChatMessage parsedMessage = message;

for (size_t i = 0; i < highlightRules_->getSize(); ++i) {

const HighlightRule& rule = highlightRules_->getRule(i);

if (rule.getMatchMUC() && !mucMode_) {

continue; /* this rule only applies to MUC's, and this is a CHAT */

} else if (rule.getMatchChat() && mucMode_) {

continue; /* this rule only applies to CHAT's, and this is a MUC */

}

ChatWindow::ChatMessage newMessage;

foreach (boost::shared_ptr<ChatWindow::ChatMessagePart> part, parsedMessage.getParts()) {

boost::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;

if ((textPart = boost::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(part))) {

try {

boost::match_results<std::string::const_iterator> match;

const std::string& text = textPart->text;

std::string::const_iterator start = text.begin();

while (regex_search(start, text.end(), match, regex)) {

std::string::const_iterator matchStart = match[0].first;

std::string::const_iterator matchEnd = match[0].second;

if (start != matchStart) {

/* If we're skipping over plain text since the previous emoticon, record it as plain text */

newMessage.append(boost::make_shared<ChatWindow::ChatTextMessagePart>(std::string(start, matchStart)));

}

boost::shared_ptr<ChatWindow::ChatHighlightingMessagePart> highlightPart = boost::make_shared<ChatWindow::ChatHighlightingMessagePart>();

highlightPart->text = match.str();

highlightPart->foregroundColor = rule.getAction().getTextColor();

highlightPart->backgroundColor = rule.getAction().getTextBackground();

newMessage.append(highlightPart);

start = matchEnd;

}

if (start != text.end()) {

/* If there's plain text after the last emoticon, record it */

newMessage.append(boost::make_shared<ChatWindow::ChatTextMessagePart>(std::string(start, text.end())));

}

}

catch (std::runtime_error) {

/* Basically too expensive to compute the regex results and it gave up, so pass through as text */

newMessage.append(part);

}

} else {

newMessage.append(part);

}

}

/*

* Copyright (c) 2013-2014 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <string>

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

namespace Swift {

class ChatMessageParser {

public:

ChatMessageParser(const std::map<std::string, std::string>& emoticons, HighlightRulesListPtr highlightRules, bool mucMode = false);

private:

ChatWindow::ChatMessage emoticonHighlight(const ChatWindow::ChatMessage& parsedMessage);

std::map<std::string, std::string> emoticons_;

HighlightRulesListPtr highlightRules_;

bool mucMode_;

};

}

CPPUNIT_ASSERT_EQUAL(text, part->text);

}

void assertURL(const ChatWindow::ChatMessage& result, size_t index, const std::string& text) {

boost::shared_ptr<ChatWindow::ChatURIMessagePart> part = boost::dynamic_pointer_cast<ChatWindow::ChatURIMessagePart>(result.getParts()[index]);

CPPUNIT_ASSERT_EQUAL(text, part->target);

}

static HighlightRule ruleFromKeyword(const std::string& keyword, bool matchCase, bool matchWholeWord)

{

HighlightRule rule;

std::vector<std::string> keywords;

keywords.push_back(keyword);

rule.setKeywords(keywords);

rule.setMatchCase(matchCase);

rule.setMatchWholeWords(matchWholeWord);

rule.setMatchChat(true);

return rule;

}

static const HighlightRulesListPtr ruleListFromKeyword(const std::string& keyword, bool matchCase, bool matchWholeWord)

{

boost::shared_ptr<HighlightManager::HighlightRulesList> list = boost::make_shared<HighlightManager::HighlightRulesList>();

list->addRule(ruleFromKeyword(keyword, matchCase, matchWholeWord));

return list;

}

static const HighlightRulesListPtr ruleListFromKeywords(const HighlightRule &rule1, const HighlightRule &rule2)

{

boost::shared_ptr<HighlightManager::HighlightRulesList> list = boost::make_shared<HighlightManager::HighlightRulesList>();

list->addRule(rule1);

list->addRule(rule2);

return list;

}

void testFullBody() {

const std::string no_special_message = "a message with no special content";

ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

ChatWindow::ChatMessage result = testling.parseMessageBody(no_special_message);

assertText(result, 0, no_special_message);

testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", false, false));

result = testling.parseMessageBody(":) shiny :( trigger :) http://wonderland.lit/blah http://denmark.lit boom boom");

assertEmoticon(result, 0, smile1_, smile1Path_);

assertText(result, 1, " shiny ");

assertEmoticon(result, 2, smile2_, smile2Path_);

assertText(result, 3, " ");

assertHighlight(result, 4, "trigger");

assertText(result, 5, " ");

assertEmoticon(result, 6, smile1_, smile1Path_);

assertText(result, 7, " ");

assertURL(result, 8, "http://wonderland.lit/blah");

assertText(result, 9, " ");

assertURL(result, 10, "http://denmark.lit");

assertText(result, 11, " boom boom");

testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", false, false));

result = testling.parseMessageBody("testtriggermessage");

assertText(result, 0, "test");

assertHighlight(result, 1, "trigger");

assertText(result, 2, "message");

testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", false, true));

result = testling.parseMessageBody("testtriggermessage");

assertText(result, 0, "testtriggermessage");

testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", true, false));

result = testling.parseMessageBody("TrIgGeR");

assertText(result, 0, "TrIgGeR");

assertText(result, 0, "zero ");

assertHighlight(result, 1, "oNe");

assertText(result, 2, " two ");

assertHighlight(result, 3, "tHrEe");

testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, false), ruleFromKeyword("three", true, false)));

result = testling.parseMessageBody("zero oNe two tHrEe");

assertText(result, 0, "zero ");

assertHighlight(result, 1, "oNe");

assertText(result, 2, " two tHrEe");

testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", true, false), ruleFromKeyword("three", true, false)));

result = testling.parseMessageBody("zero oNe two tHrEe");

assertText(result, 0, "zero oNe two tHrEe");

testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, false), ruleFromKeyword("three", false, false)));

result = testling.parseMessageBody("zeroonetwothree");

assertText(result, 0, "zero");

assertHighlight(result, 1, "one");

assertText(result, 2, "two");

assertHighlight(result, 3, "three");

testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", true, false), ruleFromKeyword("three", false, false)));

result = testling.parseMessageBody("zeroOnEtwoThReE");

assertText(result, 0, "zeroOnEtwo");

assertHighlight(result, 1, "ThReE");

testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, true), ruleFromKeyword("three", false, false)));

result = testling.parseMessageBody("zeroonetwothree");

assertText(result, 0, "zeroonetwo");

assertHighlight(result, 1, "three");

testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, true), ruleFromKeyword("three", false, true)));

result = testling.parseMessageBody("zeroonetwothree");

assertText(result, 0, "zeroonetwothree");

}

void testOneEmoticon() {

ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

ChatWindow::ChatMessage result = testling.parseMessageBody(" :) ");

assertText(result, 0, " ");

assertEmoticon(result, 1, smile1_, smile1Path_);

assertText(result, 2, " ");

}

void testBareEmoticon() {

ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

ChatWindow::ChatMessage result = testling.parseMessageBody(":)");

assertEmoticon(result, 0, smile1_, smile1Path_);

}

void testHiddenEmoticon() {

ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

ChatWindow::ChatMessage result = testling.parseMessageBody("b:)a");

assertText(result, 0, "b:)a");

}

void testEndlineEmoticon() {

ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

ChatWindow::ChatMessage result = testling.parseMessageBody("Lazy:)");

assertText(result, 0, "Lazy");

assertEmoticon(result, 1, smile1_, smile1Path_);

}

void testBoundedEmoticons() {

ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

ChatWindow::ChatMessage result = testling.parseMessageBody(":)Lazy:(");

assertEmoticon(result, 0, smile1_, smile1Path_);

assertText(result, 1, "Lazy");