+ * Copyright (c) 2010-2013 Remko Tronçon

+std::pair<std::vector<std::string>, size_t> Linkify::splitLink(const std::string& input) {

+ std::vector<std::string> result;

+ std::pair<std::vector<std::string>, size_t> pair;

+ std::vector<char> currentURL;

+ bool inURL = false;

+ size_t urlStartsAt = 0;

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

+ char c = input[i];

+ if (inURL) {

+ if (c != ' ' && c != '\t' && c != '\n' && !(c == '*' && i == input.size() - 1 && input[0] == '*')) {

+ // Keep parsing

+ }

+ else {

+ std::string url(input.substr(urlStartsAt, i - urlStartsAt));

+ result.push_back(url);

+ inURL = false;

+ size_t remaining = input.size() - i;

+ if (remaining > 0) {

+ result.push_back(input.substr(i, remaining));

+ }

+ pair.first = result;

+ pair.second = urlStartsAt == 0 ? 0 : 1;

+ return pair;

+ }

+ }

+ else {

+ if (boost::regex_match(input.substr(i, 8), linkifyRegexp)) {

+ urlStartsAt = i;

+ inURL = true;

+ if (i > 0) {

+ result.push_back(input.substr(0, i));

+ }

+ }

+ else {

+ // Just keep swimming

+ }

+ }

+ }

+ if (urlStartsAt > 0 || inURL) {

+ std::string url(input.substr(urlStartsAt, input.size() - urlStartsAt));

+ result.push_back(url);

+ pair.first = result;

+ pair.second = urlStartsAt == 0 ? 0 : 1;

+ }

+ else {

+ pair.first.push_back(input);

+ pair.second = 1;

+ }

+ return pair;

+}

+

+ * Copyright (c) 2010-2013 Remko Tronçon

+#include <vector>

+ /**

+ * Parse the string for a URI. The string will be split by the URI, and the segments plus index of the URI returned.

+ * If no URI is found the index will be result.size() (i.e. an invalid index)

+ *

+ * Examples:

+ * "not a URI" -> <<"not a URI">, -1>

+ * "http://swift.im" -> <<"http://swift.im">, 0

+ * " See http://swift.im" -> <<" See ", "http://swift.im">, 1>

+ * "Right, http://swift.im it is" -> <<"Right, ", "http://swift.im", " it is">, 1>

+ */

+ std::pair<std::vector<std::string>, size_t> splitLink(const std::string& text);

+ * Copyright (c) 2010-2013 Remko Tronçon

+

+ CPPUNIT_TEST(testLinkify_SplitNone);

+ CPPUNIT_TEST(testLinkify_SplitAll);

+ CPPUNIT_TEST(testLinkify_SplitFirst);

+ CPPUNIT_TEST(testLinkify_SplitSecond);

+ CPPUNIT_TEST(testLinkify_SplitMiddle);

+ std::string result = Linkify::linkify("*http://swift.im*");

+

+ CPPUNIT_ASSERT_EQUAL(

+ std::string("*<a href=\"http://swift.im\">http://swift.im</a>*"),

+ result);

+ }

+ void checkResult(const std::string& testling, size_t expectedIndex, std::string expectedSplit[]) {

+ std::pair<std::vector<std::string>, size_t> result = Linkify::splitLink(testling);

+ CPPUNIT_ASSERT_EQUAL(expectedIndex, result.second);

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

+ CPPUNIT_ASSERT_EQUAL(expectedSplit[i], result.first[i]);

+ }

+

+ void testLinkify_SplitNone() {

+ std::string testling = "http this ain't";

+ size_t expectedIndex = 1;

+ std::string expectedSplit[] = {"http this ain't"};

+ checkResult(testling, expectedIndex, expectedSplit);

+ }

+

+ void testLinkify_SplitAll() {

+ std::string testling = "http://swift.im";

+ size_t expectedIndex = 0;

+ std::string expectedSplit[] = {"http://swift.im"};

+ checkResult(testling, expectedIndex, expectedSplit);

+ }

+

+ void testLinkify_SplitFirst() {

+ std::string testling = "http://swift.im is a link";

+ size_t expectedIndex = 0;

+ std::string expectedSplit[] = {"http://swift.im", " is a link"};

+ checkResult(testling, expectedIndex, expectedSplit);

+ }

+

+ void testLinkify_SplitSecond() {

+ std::string testling = "this is a link: http://swift.im";

+ size_t expectedIndex = 1;

+ std::string expectedSplit[] = {"this is a link: ", "http://swift.im"};

+ checkResult(testling, expectedIndex, expectedSplit);

+ }

+

+ void testLinkify_SplitMiddle() {

+ std::string testling = "Shove a link like http://swift.im in the middle";

+ size_t expectedIndex = 1;

+ std::string expectedSplit[] = {"Shove a link like ","http://swift.im", " in the middle"};

+ checkResult(testling, expectedIndex, expectedSplit);

+ }

+

+

+ * Copyright (c) 2010-2013 Kevin Smith

+#include <Swift/Controllers/Chat/ChatController.h>

+#include <Swiften/Elements/DeliveryReceipt.h>

+#include <Swiften/Elements/DeliveryReceiptRequest.h>

+#include <Swiften/Elements/Idle.h>

+#include <Swiften/Base/Log.h>

+#include <Swiften/Client/ClientBlockListManager.h>

+

+#include <Swift/Controllers/Intl.h>

+#include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>

+#include <Swift/Controllers/XMPPEvents/EventController.h>

+#include <Swift/Controllers/FileTransfer/FileTransferController.h>

+#include <Swift/Controllers/StatusUtil.h>

+

+ChatController::ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::map<std::string, std::string>* emoticons)

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, emoticons), eventStream_(eventStream), userWantsReceipts_(userWantsReceipts), settings_(settings), clientBlockListManager_(clientBlockListManager) {

+ chatWindow_->addSystemMessage(parseMessageBody(startMessage), ChatWindow::DefaultDirection);

+ chatWindow_->replaceLastMessage(parseMessageBody(newStatusChangeString));

+ chatWindow_->addPresenceMessage(parseMessageBody(newStatusChangeString), ChatWindow::DefaultDirection);

+ * Copyright (c) 2010-2013 Kevin Smith

+ ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::map<std::string, std::string>* emoticons);

+ * Copyright (c) 2010-2013 Kevin Smith

+#include <Swift/Controllers/Chat/ChatControllerBase.h>

+#include <Swiften/Base/Regex.h>

+

+#include <SwifTools/Linkify.h>

+

+#include <Swift/Controllers/Intl.h>

+#include <Swift/Controllers/XMPPEvents/EventController.h>

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

+#include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>

+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, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::map<std::string, std::string>* emoticons) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), emoticons_(*emoticons) {

+ chatWindow_->addSystemMessage(parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The day is now %1%")) % std::string(boost::posix_time::to_iso_extended_string(now)).substr(0,10))), ChatWindow::DefaultDirection);

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

+ return chatWindow_->addMessage(parseMessageBody(message), senderName, senderIsSelf, label, pathToString(avatarPath), time, highlight);

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

+ chatWindow_->replaceMessage(parseMessageBody(message), id, time, highlight);

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

+ chatWindow_->addSystemMessage(parseMessageBody(std::string(s.str())), ChatWindow::DefaultDirection);

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

+

+ChatWindow::ChatMessage ChatControllerBase::parseMessageBody(const std::string& body) {

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

+ }

+ }

+ }

+ }

+

+

+

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

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

+ regexString += Regex::escape(emoticon.first);

+ }

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

+ while (regex_search(start, text.end(), match, emoticonRegex)) {

+ 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::ChatEmoticonMessagePart> emoticonPart = boost::make_shared<ChatWindow::ChatEmoticonMessagePart>();

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

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

+}

+ * Copyright (c) 2010-2013 Kevin Smith

+#include <string>

+

+#include <Swiften/Network/Timer.h>

+#include <Swiften/Network/TimerFactory.h>

+#include <Swiften/Elements/Stanza.h>

+#include <Swiften/Base/boost_bsignals.h>

+#include <Swiften/Elements/DiscoInfo.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/Elements/SecurityLabelsCatalog.h>

+#include <Swiften/Elements/ErrorPayload.h>

+#include <Swiften/Presence/PresenceOracle.h>

+#include <Swiften/Queries/IQRouter.h>

+#include <Swiften/Base/IDGenerator.h>

+#include <Swiften/MUC/MUCRegistry.h>

+

+#include <Swift/Controllers/XMPPEvents/MessageEvent.h>

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

+ 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, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::map<std::string, std::string>* emoticons);

+ ChatWindow::ChatMessage parseMessageBody(const std::string& body);

+ const std::map<std::string, std::string>& emoticons_;

+ * Copyright (c) 2010-2013 Kevin Smith

+#include <Swift/Controllers/Chat/ChatsManager.h>

+#include <Swiften/Presence/PresenceSender.h>

+#include <Swiften/Client/NickResolver.h>

+#include <Swiften/MUC/MUCManager.h>

+#include <Swiften/Elements/ChatState.h>

+#include <Swiften/Elements/MUCUserPayload.h>

+#include <Swiften/Elements/DeliveryReceipt.h>

+#include <Swiften/Elements/DeliveryReceiptRequest.h>

+#include <Swiften/MUC/MUCBookmarkManager.h>

+#include <Swiften/Avatars/AvatarManager.h>

+#include <Swiften/Elements/MUCInvitationPayload.h>

+#include <Swiften/Roster/XMPPRoster.h>

+#include <Swiften/Client/ClientBlockListManager.h>

+#include <Swiften/Client/StanzaChannel.h>

+

+ ClientBlockListManager* clientBlockListManager,

+ std::map<std::string, std::string>* emoticons) :

+ clientBlockListManager_(clientBlockListManager),

+ emoticons_(emoticons) {

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

+ MUCController* controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, emoticons_);

+ * Copyright (c) 2010-2013 Kevin Smith

+#include <string>

+#include <Swiften/MUC/MUCBookmark.h>

+

+

+ ChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, JoinMUCWindowFactory* joinMUCWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, PresenceSender* presenceSender, UIEventStream* uiEventStream, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency, TimerFactory* timerFactory, MUCRegistry* mucRegistry, EntityCapsProvider* entityCapsProvider, MUCManager* mucManager, MUCSearchWindowFactory* mucSearchWindowFactory, ProfileSettingsProvider* profileSettings, FileTransferOverview* ftOverview, XMPPRoster* roster, bool eagleMode, SettingsProvider* settings, HistoryController* historyController_, WhiteboardManager* whiteboardManager, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::map<std::string, std::string>* emoticons);

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

+ * Copyright (c) 2010-2013 Kevin Smith

+ HighlightManager* highlightManager,

+ std::map<std::string, std::string>* emoticons) :

+ ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, emoticons), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0) {

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

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

+ chatWindow_->addSystemMessage(parseMessageBody(joinMessage), ChatWindow::DefaultDirection);

+ chatWindow_->addPresenceMessage(parseMessageBody(message), ChatWindow::DefaultDirection);

+ chatWindow_->addSystemMessage(parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The room subject is now: %1%")) % message->getSubject())), ChatWindow::DefaultDirection);;

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

+ chatWindow_->addSystemMessage(parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "Trying to enter room %1%")) % toJID_.toString())), ChatWindow::DefaultDirection);

+ chatWindow_->replaceLastMessage(parseMessageBody(generateJoinPartString(joinParts_)));

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

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

+ * Copyright (c) 2010-2013 Kevin Smith

+#include <set>

+#include <string>

+#include <map>

+

+#include <Swiften/Base/boost_bsignals.h>

+

+#include <Swift/Controllers/Chat/ChatControllerBase.h>

+ MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* roster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::map<std::string, std::string>* emoticons);

+ emoticons_ = new std::map<std::string, std::string>();

+ manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, NULL, mucRegistry_, entityCapsManager_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_, NULL, wbManager_, highlightManager_, clientBlockListManager_, emoticons_);

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

+ * Copyright (c) 2010-2013 Kevin Smith

+ emoticons_ = new std::map<std::string, std::string>();

+ controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, NULL, NULL, mucRegistry_, highlightManager_, emoticons_);

+ delete emoticons_;

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

+#include <Swiften/Base/Regex.h>

+ std::string escaped = Regex::escape(s);

+ * Copyright (c) 2010-2013 Kevin Smith

+#include <stdlib.h>

+

+

+#include <Swiften/Network/TimerFactory.h>

+#include <Swiften/Client/Storages.h>

+#include <Swiften/VCards/VCardManager.h>

+#include <Swiften/Client/NickResolver.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Client/Client.h>

+#include <Swiften/Presence/PresenceSender.h>

+#include <Swiften/Elements/ChatState.h>

+#include <Swiften/Elements/Presence.h>

+#include <Swiften/Elements/VCardUpdate.h>

+#include <Swiften/Elements/DiscoInfo.h>

+#include <Swiften/Disco/CapsInfoGenerator.h>

+#include <Swiften/Disco/GetDiscoInfoRequest.h>

+#include <Swiften/Disco/ClientDiscoManager.h>

+#include <Swiften/VCards/GetVCardRequest.h>

+#include <Swiften/StringCodecs/Hexify.h>

+#include <Swiften/Network/NetworkFactories.h>

+#include <Swiften/FileTransfer/FileTransferManager.h>

+#include <Swiften/Client/ClientXMLTracer.h>

+#include <Swiften/Client/StanzaChannel.h>

+#include <Swiften/Client/ClientBlockListManager.h>

+#include <Swiften/Crypto/CryptoProvider.h>

+

+#include <SwifTools/Dock/Dock.h>

+#include <SwifTools/Notifier/TogglableNotifier.h>

+#include <SwifTools/Idle/IdleDetector.h>

+

+#include <Swift/Controllers/BuildVersion.h>

+#include <Swift/Controllers/Chat/UserSearchController.h>

+#include <Swift/Controllers/Chat/ChatsManager.h>

+#include <Swift/Controllers/XMPPEvents/EventController.h>

+#include <Swift/Controllers/EventWindowController.h>

+#include <Swift/Controllers/UIInterfaces/LoginWindow.h>

+#include <Swift/Controllers/UIInterfaces/LoginWindowFactory.h>

+#include <Swift/Controllers/UIInterfaces/MainWindow.h>

+#include <Swift/Controllers/Chat/MUCController.h>

+#include <Swift/Controllers/Roster/RosterController.h>

+#include <Swift/Controllers/SoundEventController.h>

+#include <Swift/Controllers/SoundPlayer.h>

+#include <Swift/Controllers/StatusTracker.h>

+#include <Swift/Controllers/SystemTray.h>

+#include <Swift/Controllers/SystemTrayController.h>

+#include <Swift/Controllers/XMLConsoleController.h>

+#include <Swift/Controllers/FileTransferListController.h>

+#include <Swift/Controllers/UIEvents/UIEventStream.h>

+#include <Swift/Controllers/PresenceNotifier.h>

+#include <Swift/Controllers/EventNotifier.h>

+#include <Swift/Controllers/Storages/StoragesFactory.h>

+#include <Swift/Controllers/WhiteboardManager.h>

+#include <Swift/Controllers/Settings/SettingsProvider.h>

+#include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>

+#include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>

+#include <Swift/Controllers/Storages/CertificateStorageFactory.h>

+#include <Swift/Controllers/Storages/CertificateStorageTrustChecker.h>

+#include <Swift/Controllers/AdHocManager.h>

+

+ const std::map<std::string, std::string>& emoticons,

+ ftOverview_(NULL),

+ emoticons_(emoticons) {

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

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

+ * Copyright (c) 2010-2013 Kevin Smith

+#include <map>

+

+#include <boost/shared_ptr.hpp>

+

+#include <Swiften/Base/boost_bsignals.h>

+#include <Swiften/Network/Timer.h>

+#include <Swiften/Client/ClientError.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/Elements/DiscoInfo.h>

+#include <Swiften/Elements/VCard.h>

+#include <Swiften/Elements/ErrorPayload.h>

+#include <Swiften/Elements/Presence.h>

+#include <Swiften/Elements/CapsInfo.h>

+#include <Swiften/Client/ClientXMLTracer.h>

+

+#include <Swift/Controllers/Settings/SettingsProvider.h>

+#include <Swift/Controllers/ProfileSettingsProvider.h>

+#include <Swift/Controllers/XMPPEvents/ErrorEvent.h>

+#include <Swift/Controllers/UIEvents/UIEvent.h>

+

+ const std::map<std::string, std::string>& emoticons,

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

+#include <vector>

+#include <string>

+

+#include <Swiften/Base/boost_bsignals.h>

+

+ class ChatMessagePart {

+ public:

+ virtual ~ChatMessagePart() {}

+ };

+

+ class ChatMessage {

+ public:

+ ChatMessage() {}

+ ChatMessage(const std::string& text) {

+ append(boost::make_shared<ChatTextMessagePart>(text));

+ }

+ void append(const boost::shared_ptr<ChatMessagePart>& part) {

+ parts_.push_back(part);

+ }

+

+ const std::vector<boost::shared_ptr<ChatMessagePart> >& getParts() const {

+ return parts_;

+ }

+ private:

+ std::vector<boost::shared_ptr<ChatMessagePart> > parts_;

+ };

+

+ class ChatTextMessagePart : public ChatMessagePart {

+ public:

+ ChatTextMessagePart(const std::string& text) : text(text) {}

+ std::string text;

+ };

+

+ class ChatURIMessagePart : public ChatMessagePart {

+ public:

+ ChatURIMessagePart(const std::string& target) : target(target) {}

+ std::string target;

+ };

+

+ class ChatEmoticonMessagePart : public ChatMessagePart {

+ public:

+ std::string imagePath;

+ std::string alternativeText;

+ };

+

+ class ChatHighlightingMessagePart : public ChatMessagePart {

+ public:

+ std::string foregroundColor;

+ std::string backgroundColor;

+ std::string text;

+ };

+

+

+ virtual std::string addMessage(const ChatMessage& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 0;

+ virtual std::string addAction(const ChatMessage& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 0;

+ virtual void addSystemMessage(const ChatMessage& message, Direction direction) = 0;

+ virtual void addPresenceMessage(const ChatMessage& message, Direction direction) = 0;

+ virtual void addErrorMessage(const ChatMessage& message) = 0;

+ virtual void replaceMessage(const ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 0;

+ virtual void replaceWithAction(const ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 0;

+ virtual void replaceLastMessage(const ChatMessage& message) = 0;

+#include <boost/shared_ptr.hpp>

+

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

+#include <Swiften/Base/foreach.h>

+

+ virtual std::string addMessage(const ChatMessage& message, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {

+ lastMessageBody_ = bodyFromMessage(message); return "id";};

+

+ virtual std::string addAction(const ChatMessage& /*message*/, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {return "id";};

+

+ virtual void addSystemMessage(const ChatMessage& /*message*/, Direction /*direction*/) {};

+ virtual void addPresenceMessage(const ChatMessage& /*message*/, Direction /*direction*/) {};

+

+ virtual void addErrorMessage(const ChatMessage& /*message*/) {};

+ virtual void replaceMessage(const ChatMessage& /*message*/, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {};

+ virtual void replaceWithAction(const ChatMessage& /*message*/, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {};

+ virtual void replaceLastMessage(const ChatMessage& /*message*/) {};

+

+ std::string bodyFromMessage(const ChatMessage& message) {

+ boost::shared_ptr<ChatTextMessagePart> text;

+ foreach (boost::shared_ptr<ChatMessagePart> part, message.getParts()) {

+ if ((text = boost::dynamic_pointer_cast<ChatTextMessagePart>(part))) {

+ return text->text;

+ }

+ }

+ return "";

+ }

+

+#include <Swift/QtUI/ChatSnippet.h>

+

+ChatSnippet::Direction ChatSnippet::getDirection(const ChatWindow::ChatMessage& message) {

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

+ std::string text = "";

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

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

+ text = textPart->text;

+ break;

+ }

+ }

+ return getDirection(text);

+}

+

+

+#include <Swiften/Base/foreach.h>

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

+#include <Swift/QtUI/QtChatTheme.h>

+

+ static Direction getDirection(const ChatWindow::ChatMessage& message);

+ Q_FOREACH (QWebElement span, spans) {

+ Q_FOREACH (QWebElement span, spans) {

+ Q_FOREACH (QWebElement span, spans) {

+ Q_FOREACH (QWebElement span, spans) {

+ Q_FOREACH (QWebElement span, spans) {

+ Q_FOREACH(QWebElement element, elements) {

+QtChatWindow::QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream, SettingsProvider* settings) : QtTabbable(), contact_(contact), previousMessageWasSelf_(false), previousMessageKind_(PreviosuMessageWasNone), eventStream_(eventStream), blockingState_(BlockingUnsupported) {

+ChatSnippet::Direction QtChatWindow::getActualDirection(const ChatMessage& message, Direction direction) {

+ const ChatMessage& message,

+ return addMessage(chatMessageToHTML(message), senderName, senderIsSelf, label, avatarPath, "", time, highlight, ChatSnippet::getDirection(message));

+}

+

+QString QtChatWindow::chatMessageToHTML(const ChatMessage& message) {

+ QString result;

+ foreach (boost::shared_ptr<ChatMessagePart> part, message.getParts()) {

+ boost::shared_ptr<ChatTextMessagePart> textPart;

+ boost::shared_ptr<ChatURIMessagePart> uriPart;

+ boost::shared_ptr<ChatEmoticonMessagePart> emoticonPart;

+ boost::shared_ptr<ChatHighlightingMessagePart> highlightPart;

+

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

+ QString text = QtUtilities::htmlEscape(P2QSTRING(textPart->text));

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

+ result += text;

+ continue;

+ }

+ if ((uriPart = boost::dynamic_pointer_cast<ChatURIMessagePart>(part))) {

+ QString uri = QtUtilities::htmlEscape(P2QSTRING(uriPart->target));

+ result += "<a href='" + uri + "' >" + uri + "</a>";

+ continue;

+ }

+ if ((emoticonPart = boost::dynamic_pointer_cast<ChatEmoticonMessagePart>(part))) {

+ QString textStyle = showEmoticons_ ? "style='display:none'" : "";

+ QString imageStyle = showEmoticons_ ? "" : "style='display:none'";

+ result += "<span class='swift_emoticon_image' " + imageStyle + "><img src='" + P2QSTRING(emoticonPart->imagePath) + "'/></span><span class='swift_emoticon_text' " + textStyle + ">" + QtUtilities::htmlEscape(P2QSTRING(emoticonPart->alternativeText)) + "</span>";

+ continue;

+ }

+ if ((highlightPart = boost::dynamic_pointer_cast<ChatHighlightingMessagePart>(part))) {

+ //FIXME: Maybe do something here. Anything, really.

+ continue;

+ }

+

+ }

+ return result;

+/*QString QtChatWindow::linkimoticonify(const std::string& message) const {

+

+ messageHTML.replace(it.key(), );

+}*/

+

+ htmlString += "<span class='swift_inner_message'>" + styleSpanStart + highlightSpanStart + message + highlightSpanEnd + styleSpanEnd + "</span>" ;

+std::string QtChatWindow::addAction(const ChatMessage& message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

+ return addMessage(" *" + chatMessageToHTML(message) + "*", senderName, senderIsSelf, label, avatarPath, "font-style:italic ", time, highlight, ChatSnippet::getDirection(message));

+void QtChatWindow::addErrorMessage(const ChatMessage& errorMessage) {

+ QString errorMessageHTML(chatMessageToHTML(errorMessage));

+

+void QtChatWindow::addSystemMessage(const ChatMessage& message, Direction direction) {

+ QString messageHTML = chatMessageToHTML(message);

+void QtChatWindow::replaceWithAction(const ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

+ replaceMessage(" *" + chatMessageToHTML(message) + "*", id, time, "font-style:italic ", highlight);

+void QtChatWindow::replaceMessage(const ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

+ replaceMessage(chatMessageToHTML(message), id, time, "", highlight);

+void QtChatWindow::addPresenceMessage(const ChatMessage& message, Direction direction) {

+ QString messageHTML = chatMessageToHTML(message);

+ std::string messageText(Q2PSTRING(tr("Sending of multiple files at once isn't supported at this time.")));

+ ChatMessage message;

+ message.append(boost::make_shared<ChatTextMessagePart>(messageText));

+void QtChatWindow::replaceLastMessage(const ChatMessage& message) {

+ messageLog_->replaceLastMessage(chatMessageToHTML(message));

+ htmlString = chatMessageToHTML(ChatMessage(Q2PSTRING(htmlString)));

+ buildChatWindowButton(chatMessageToHTML(ChatMessage(Q2PSTRING((tr("Accept Invite"))))), ButtonMUCInvite, QtUtilities::htmlEscape(P2QSTRING(jid.toString())), QtUtilities::htmlEscape(P2QSTRING(password)), id) +

+ QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream, SettingsProvider* settings);

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

+ std::string addAction(const ChatMessage& message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight);

+ void addSystemMessage(const ChatMessage& message, Direction direction);

+ void addPresenceMessage(const ChatMessage& message, Direction direction);

+ void addErrorMessage(const ChatMessage& message);

+ void replaceMessage(const ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight);

+ void replaceWithAction(const ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight);

+ void replaceLastMessage(const ChatMessage& message);

+ static ChatSnippet::Direction getActualDirection(const ChatMessage& message, Direction direction);

+ QString chatMessageToHTML(const ChatMessage& message);

+QtChatWindowFactory::QtChatWindowFactory(QtSingleWindow* splitter, SettingsProvider* settings, QtSettingsProvider* qtSettings, QtChatTabs* tabs, const QString& themePath) : themePath_(themePath) {

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

+ QtChatWindowFactory(QtSingleWindow* splitter, SettingsProvider* settings, QtSettingsProvider* qtSettings, QtChatTabs* tabs, const QString& themePath);

+#include <Swift/QtUI/QtSwift.h>

+#include <map>

+

+

+#include <QFile>

+#include <Swiften/Base/Paths.h>

+

+#include <SwifTools/Application/PlatformApplicationPathProvider.h>

+#include <SwifTools/AutoUpdater/AutoUpdater.h>

+#include <SwifTools/AutoUpdater/PlatformAutoUpdaterFactory.h>

+

+#include <Swift/Controllers/Storages/CertificateFileStorageFactory.h>

+#include <Swift/Controllers/Storages/FileStoragesFactory.h>

+#include <Swift/QtUI/QtLoginWindow.h>

+#include <Swift/QtUI/QtChatTabs.h>

+#include <Swift/QtUI/QtSystemTray.h>

+#include <Swift/QtUI/QtSoundPlayer.h>

+#include <Swift/QtUI/QtSwiftUtil.h>

+#include <Swift/QtUI/QtUIFactory.h>

+#include <Swift/QtUI/QtChatWindowFactory.h>

+#include <Swift/QtUI/QtSingleWindow.h>

+

+#include <Swift/QtUI/WindowsNotifier.h>

+#include <SwifTools/Notifier/GrowlNotifier.h>

+#include <Swift/QtUI/FreeDesktopNotifier.h>

+#include <SwifTools/Notifier/NullNotifier.h>

+#include <SwifTools/Dock/MacOSXDock.h>

+#include <SwifTools/Dock/NullDock.h>

+#include <Swift/QtUI/QtURIHandler.h>

+#include <Swift/QtUI/QtDBUSURIHandler.h>

+void QtSwift::loadEmoticonsFile(const QString& fileName, std::map<std::string, std::string>& emoticons) {

+ emoticons[Q2PSTRING(tokens[0])] = Q2PSTRING(emoticonFile);

+ std::map<std::string, std::string> emoticons;

+ chatWindowFactory_ = new QtChatWindowFactory(splitter_, settingsHierachy_, qtSettings_, tabs_, "");

+ emoticons,

+ void loadEmoticonsFile(const QString& fileName, std::map<std::string, std::string>& emoticons);

+/*

+ * Copyright (c) 2013 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <Swiften/Base/Regex.h>

+

+#include <string>

+

+#include <boost/regex.hpp>

+

+namespace Swift {

+

+ namespace Regex {

+ std::string escape(const std::string& source) {

+ // escape regex special characters: ^.$| etc

+ // these need to be escaped: [\^\$\|.........]

+ // and then C++ requires '\' to be escaped, too....

+ static const boost::regex esc("([\\^\\.\\$\\|\\(\\)\\[\\]\\*\\+\\?\\/\\{\\}\\\\])");

+ // matched character should be prepended with '\'

+ // replace matched special character with \\\1

+ // and escape once more for C++ rules...

+ static const std::string rep("\\\\\\1");

+ return boost::regex_replace(source, esc, rep);

+ }

+

+ }

+

+}

+

+/*

+ * Copyright (c) 2013 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <string>

+

+#include <Swiften/Base/API.h>

+

+namespace Swift {

+

+ namespace Regex {

+ SWIFTEN_API std::string escape(const std::string& source);

+ }

+

+}

+ "Regex.cpp"