+ * Copyright (c) 2010-2018 Isode Limited.

+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, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings)

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider, settings), userWantsReceipts_(userWantsReceipts), clientBlockListManager_(clientBlockListManager) {

+ * Copyright (c) 2010-2018 Isode Limited.

+ 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, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings);

+ virtual ~ChatController() override;

+ virtual void setToJID(const JID& jid) override;

+ virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) override;

+ virtual void setOnline(bool online) override;

+ virtual void setContactIsReceivingPresence(bool /*isReceivingPresence*/) override;

+ virtual ChatWindow* detachChatWindow() override;

+ virtual void handleIncomingOwnMessage(std::shared_ptr<Message> message) override;

+ virtual void cancelReplaces() override;

+ virtual JID getBaseJID() override;

+ virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) override;

+ virtual bool shouldIgnoreMessage(std::shared_ptr<Message> message) override;

+ virtual JID messageCorrectionJID(const JID& fromJID) override;

+ virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) override;

+ virtual void postSendMessage(const std::string &body, std::shared_ptr<Stanza> sentStanza) override;

+ virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) override;

+ virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

+ virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

+ virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) override;

+ virtual void preSendMessageRequest(std::shared_ptr<Message>) override;

+ virtual std::string senderHighlightNameFromMessage(const JID& from) override;

+ virtual std::string senderDisplayNameFromMessage(const JID& from) override;

+ virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message>) const override;

+ virtual void dayTicked() override { lastWasPresence_ = false; }

+ virtual void handleBareJIDCapsChanged(const JID& jid) override;

+ * Copyright (c) 2010-2018 Isode Limited.

+ChatControllerBase::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) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream), roomSecurityMarking_(""), previousMessageSecurityMarking_(""), settings_(settings) {

+ auto displayedLabel = label;

+

+ if (settings_->getSetting(SettingConstants::MUC_MARKING_ELISION)) {

+ if (roomSecurityMarking_ != "") {

+

+ if (label && label->getDisplayMarking() == roomSecurityMarking_) {

+ if (label->getDisplayMarking() == previousMessageSecurityMarking_) {

+ displayedLabel = std::make_shared<SecurityLabel>();

+ }

+ previousMessageSecurityMarking_ = label->getDisplayMarking();

+ }

+ else if (!label || label->getDisplayMarking().empty()) {

+ displayedLabel = std::make_shared<SecurityLabel>();

+ displayedLabel->setDisplayMarking("Unmarked");

+ previousMessageSecurityMarking_ = "Unmarked";

+ }

+ else {

+ previousMessageSecurityMarking_ = displayedLabel->getDisplayMarking();

+ }

+ }

+ }

+

+ return chatWindow_->addAction(chatMessage, senderName, senderIsSelf, displayedLabel, pathToString(avatarPath), time);

+ return chatWindow_->addMessage(chatMessage, senderName, senderIsSelf, displayedLabel, pathToString(avatarPath), time);

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+#endif

+ * Copyright (c) 2010-2018 Isode Limited.

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

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

+ std::string roomSecurityMarking_;

+ std::string previousMessageSecurityMarking_;

+ SettingsProvider* settings_;

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

+ controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, reuseChatwindow ? chatWindowFactoryAdapter : chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, isImpromptu, autoAcceptMUCInviteDecider_, vcardManager_, mucBookmarkManager_, settings_);

+ * Copyright (c) 2010-2018 Isode Limited.

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

+ MUCBookmarkManager* mucBookmarkManager,

+ SettingsProvider* settings) :

+ ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), nickResolver, presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider, settings), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false), clientBlockListManager_(clientBlockListManager), mucBookmarkManager_(mucBookmarkManager) {

+ roster_ = std::make_unique<Roster>(false, true);

+

+ requestSecurityMarking();

+

+void MUCController::requestSecurityMarking() {

+ auto discoInfoRequest = GetDiscoInfoRequest::create(muc_->getJID(), iqRouter_);

+ discoInfoRequest->onResponse.connect(

+ [this](std::shared_ptr<DiscoInfo> discoInfoRef, ErrorPayload::ref errorPayloadRef) {

+ if (!discoInfoRef || errorPayloadRef) {

+ return;

+ }

+ const std::vector<Form::ref>& extensionsList = discoInfoRef->getExtensions();

+ if (extensionsList.empty()) {

+ return;

+ }

+ // Get the correct form if it exists

+ Form::ref roomInfoForm;

+ for (const auto& form : extensionsList) {

+ if (form->getFormType() == "http://jabber.org/protocol/muc#roominfo") {

+ roomInfoForm = form;

+ break;

+ }

+ }

+ if (!roomInfoForm) {

+ return;

+ }

+ // It exists, now examine the security marking data

+ auto marking = roomInfoForm->getField("x-isode#roominfo_marking");

+ if (!marking) {

+ return;

+ }

+ // Now we know the marking is valid

+ auto markingValue = marking->getTextSingleValue();

+ if (markingValue == "") {

+ setMUCSecurityMarkingDefault();

+ return;

+ }

+ auto markingForegroundColor = roomInfoForm->getField("x-isode#roominfo_marking_fg_color");

+ auto markingBackgroundColor = roomInfoForm->getField("x-isode#roominfo_marking_bg_color");

+ std::string markingForegroundColorValue = "Black";

+ std::string markingBackgroundColorValue = "White";

+ if (markingForegroundColor) {

+ markingForegroundColorValue = markingForegroundColor->getTextSingleValue();

+ }

+ if (markingBackgroundColor) {

+ markingBackgroundColorValue = markingBackgroundColor->getTextSingleValue();

+ }

+ setMUCSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);

+ }

+ );

+ discoInfoRequest->send();

+}

+

+void MUCController::setMUCSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue) {

+ roomSecurityMarking_ = markingValue;

+ chatWindow_->setChatSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);

+}

+

+void MUCController::setMUCSecurityMarkingDefault() {

+ roomSecurityMarking_ = "";

+ chatWindow_->removeChatSecurityMarking();

+}

+

+ * Copyright (c) 2010-2018 Isode Limited.

+ MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* xmppRoster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager, MUCBookmarkManager* mucBookmarkManager, SettingsProvider* settings);

+ virtual ~MUCController() override;

+ virtual void setOnline(bool online) override;

+ virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) override;

+ virtual void preSendMessageRequest(std::shared_ptr<Message> message) override;

+ virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) override;

+ virtual std::string senderHighlightNameFromMessage(const JID& from) override;

+ virtual std::string senderDisplayNameFromMessage(const JID& from) override;

+ virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message> message) const override;

+ virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent>) override;

+ virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time) override;

+ virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

+ virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent>, const ChatWindow::ChatMessage& chatMessage) override;

+ virtual void cancelReplaces() override;

+ virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) override;

+ virtual JID messageCorrectionJID(const JID& fromJID) override;

+ virtual void dayTicked() override { clearPresenceQueue(); }

+ virtual void handleBareJIDCapsChanged(const JID& jid) override;

+ void requestSecurityMarking();

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

+ void setMUCSecurityMarkingDefault();

+

+ notifier_ = std::make_unique<DummyNotifier>();

+ auto sendMessageStanza = stanzaChannel_->getStanzaAtIndex<Message>(3);

+ // Check the MUC security marking request

+ auto mucInfoRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[2]);

+ CPPUNIT_ASSERT(mucInfoRequest);

+

+ auto mucJoinPresence = std::dynamic_pointer_cast<Presence>(stanzaChannel_->sentStanzas[3]);

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

+ CPPUNIT_TEST(testSecurityMarkingRequestCompleteMarking);

+ CPPUNIT_TEST(testSecurityMarkingRequestCompleteMarkingWithExtraForm);

+ CPPUNIT_TEST(testSecurityMarkingRequestEmptyMarking);

+ CPPUNIT_TEST(testSecurityMarkingRequestWithMarkingNoFormType);

+ CPPUNIT_TEST(testSecurityMarkingRequestNoMarking);

+ CPPUNIT_TEST(testSecurityMarkingRequestNoForm);

+ CPPUNIT_TEST(testSecurityMarkingRequestError);

+

+ CPPUNIT_TEST(testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingA);

+ CPPUNIT_TEST(testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingB);

+ CPPUNIT_TEST(testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingA);

+ CPPUNIT_TEST(testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingB);

+ CPPUNIT_TEST(testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingC);

+

+ CPPUNIT_TEST(testSecurityMarkingAddedToMessage_NoElision_NoRoomMarkingA);

+ CPPUNIT_TEST(testSecurityMarkingAddedToMessage_NoElision_NoRoomMarkingB);

+ CPPUNIT_TEST(testSecurityMarkingAddedToMessage_NoElision_WithRoomMarkingA);

+ CPPUNIT_TEST(testSecurityMarkingAddedToMessage_NoElision_WithRoomMarkingB);

+

+ controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, nullptr, nullptr, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, false, nullptr, vcardManager_, mucBookmarkManager_, settings_);

+ void setMUCSecurityMarking(const std::string& markingValue, const std::string & markingForegroundColorValue, const std::string& markingBackgroundColorValue, const bool includeFormTypeField = true) {

+ auto form = std::make_shared<Form>(Form::Type::ResultType);

+

+ if (includeFormTypeField) {

+ std::shared_ptr<FormField> formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");

+ formTypeField->setName("FORM_TYPE");

+ form->addField(formTypeField);

+ }

+

+ auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingValue);

+ auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingForegroundColorValue);

+ auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingBackgroundColorValue);

+

+ markingField->setName("x-isode#roominfo_marking");

+ markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");

+ markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");

+

+ form->addField(markingField);

+ form->addField(markingForegroundColorField);

+ form->addField(markingBackgroundColorField);

+

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+ discoInfoRef->addExtension(form);

+

+ auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ }

+

+ Message::ref createTestMessageWithoutSecurityLabel() {

+ auto message = std::make_shared<Message>();

+ message->setType(Message::Type::Groupchat);

+ message->setID("test-id");

+ message->setTo(self_);

+ message->setFrom(mucJID_.withResource("TestNickname"));

+ message->setBody("Do Not Read This Message");

+ return message;

+ }

+

+ void testSecurityMarkingRequestCompleteMarking() {

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red", true);

+

+ CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), window_->markingValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string("Black"), window_->markingForegroundColorValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string("Red"), window_->markingBackgroundColorValue_);

+ }

+

+ void testSecurityMarkingRequestCompleteMarkingWithExtraForm() {

+ auto formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");

+ auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Test|Highest Possible Security");

+ auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Black");

+ auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Red");

+ formTypeField->setName("FORM_TYPE");

+ markingField->setName("x-isode#roominfo_marking");

+ markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");

+ markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");

+

+ auto extraForm = std::make_shared<Form>(Form::Type::ResultType);

+ auto form = std::make_shared<Form>(Form::Type::ResultType);

+ form->addField(formTypeField);

+ form->addField(markingField);

+ form->addField(markingForegroundColorField);

+ form->addField(markingBackgroundColorField);

+

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+ discoInfoRef->addExtension(extraForm);

+ discoInfoRef->addExtension(form);

+

+ auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), window_->markingValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string("Black"), window_->markingForegroundColorValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string("Red"), window_->markingBackgroundColorValue_);

+ }

+

+ void testSecurityMarkingRequestNoColorsInMarking() {

+ auto formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");

+ auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Test|Highest Possible Security");

+ auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "");

+ auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "");

+ formTypeField->setName("FORM_TYPE");

+ markingField->setName("x-isode#roominfo_marking");

+ markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");

+ markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");

+

+ auto form = std::make_shared<Form>(Form::Type::ResultType);

+ form->addField(formTypeField);

+ form->addField(markingField);

+ form->addField(markingForegroundColorField);

+ form->addField(markingBackgroundColorField);

+

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+ discoInfoRef->addExtension(form);

+

+ auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), window_->markingValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string("Black"), window_->markingForegroundColorValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string("White"), window_->markingBackgroundColorValue_);

+ }

+

+ void testSecurityMarkingRequestEmptyMarking() {

+ setMUCSecurityMarking("", "", "", true);

+

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);

+ }

+

+ void testSecurityMarkingRequestWithMarkingNoFormType() {

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red", false);

+

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);

+ }

+

+ void testSecurityMarkingRequestNoMarking() {

+ auto form = std::make_shared<Form>(Form::Type::ResultType);

+

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+ discoInfoRef->addExtension(form);

+

+ auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);

+ }

+

+ void testSecurityMarkingRequestNoForm() {

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+

+ auto infoResponse = IQ::createResult( self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);

+ }

+

+ void testSecurityMarkingRequestError() {

+ auto errorPayload = std::make_shared<ErrorPayload>(ErrorPayload::Condition::NotAuthorized, ErrorPayload::Type::Auth);

+

+ auto infoResponse = IQ::createResult( self_, mucJID_, "test-id", errorPayload);

+ iqChannel_->onIQReceived(infoResponse);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);

+ }

+

+ void testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingA() {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+

+ CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());

+ }

+

+ void testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingB() {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+

+ CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ CPPUNIT_ASSERT_EQUAL(std::string(""), storedSecurityLabel->getDisplayMarking());

+ }

+

+ void testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingA() {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ // Test the first message matching MUC marking. This message SHOULD have a marking

+

+ auto sentMessageEvent1 = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent1);

+

+ auto storedSecurityLabel1 = window_->lastAddedMessageSecurityLabel_;

+

+ CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel1 == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), storedSecurityLabel1->getDisplayMarking());

+

+ // Test a consecutive message matching MUC marking. This message SHOULD NOT have a marking

+

+ auto sentMessageEvent2 = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent2);

+

+ auto storedSecurityLabel2 = window_->lastAddedMessageSecurityLabel_;

+

+ CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel2 == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ CPPUNIT_ASSERT_EQUAL(std::string(""), storedSecurityLabel2->getDisplayMarking());

+ }

+

+ void testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingB() {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("Test|Lower Security Marking", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+

+ CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());

+ }

+

+ void testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingC() {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+

+ CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ CPPUNIT_ASSERT_EQUAL(std::string("Unmarked"), storedSecurityLabel->getDisplayMarking());

+ }

+

+ void testSecurityMarkingAddedToMessage_NoElision_NoRoomMarkingA() {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);

+ setMUCSecurityMarking("", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+

+ CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());

+ }

+

+ void testSecurityMarkingAddedToMessage_NoElision_NoRoomMarkingB() {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);

+ setMUCSecurityMarking("", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+

+ CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ CPPUNIT_ASSERT_EQUAL(std::string(""), storedSecurityLabel->getDisplayMarking());

+ }

+

+ void testSecurityMarkingAddedToMessage_NoElision_WithRoomMarkingA() {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ // Test the first message matching MUC marking. This message SHOULD have a marking

+

+ auto sentMessageEvent1 = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent1);

+

+ auto storedSecurityLabel1 = window_->lastAddedMessageSecurityLabel_;

+

+ CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel1 == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), storedSecurityLabel1->getDisplayMarking());

+

+ // Test a consecutive message matching MUC marking. This message SHOULD ALSO have a marking

+

+ auto sentMessageEvent2 = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent2);

+

+ auto storedSecurityLabel2 = window_->lastAddedMessageSecurityLabel_;

+

+ CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel2 == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), storedSecurityLabel2->getDisplayMarking());

+ }

+

+ void testSecurityMarkingAddedToMessage_NoElision_WithRoomMarkingB() {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);

+ setMUCSecurityMarking("", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+

+ CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ CPPUNIT_ASSERT_EQUAL(std::string(""), storedSecurityLabel->getDisplayMarking());

+ }

+

+Roster::Roster(bool sortByStatus, bool fullJIDMapping) : fullJIDMapping_(fullJIDMapping), sortByStatus_(sortByStatus), root_(std::make_unique<GroupRosterItem>("Dummy-Root", nullptr, sortByStatus_)) {

+ featureOracle_ = std::make_unique<FeatureOracle>(entityCapsManager_, presenceOracle_);

+ storages_ = std::make_unique<MemoryStorages>(crypto_);

+ capsManager_ = std::make_unique<CapsManager>(storages_->getCapsStorage(), stanzaChannel_, router_, crypto_);

+ capsInfoGenerator_ = std::make_unique<CapsInfoGenerator>("", crypto_);

+ roster_ = std::make_unique<Roster>();

+ timerFactory = std::make_unique<DummyTimerFactory>();

+ roster = std::make_unique<Roster>();

+ * Copyright (c) 2012-2018 Isode Limited.

+const SettingsProvider::Setting<bool> SettingConstants::MUC_MARKING_ELISION("mucMarkingElision", true);

+ * Copyright (c) 2012-2018 Isode Limited.

+ /**

+ * The #MUC_MARKING_ELISION setting

+ * specifies whether or not messages with the default muc

+ * marking display their marking, and whether unmarked messages

+ * are marked as such.

+ *

+ * If set true, unmarked messages will be marked with the marking

+ * "unmarked", and messages with the room default marking will

+ * have their markings stripped.

+ */

+ static const SettingsProvider::Setting<bool> MUC_MARKING_ELISION;

+ * Copyright (c) 2010-2018 Isode Limited.

+ class DiscoInfo;

+ class ErrorPayload;

+ virtual void setChatSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue) = 0;

+ virtual void removeChatSecurityMarking() = 0;

+

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

+ lastAddedMessageSecurityLabel_ = label;

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

+ markingValue_ = markingValue;

+ markingForegroundColorValue_ = markingForegroundColorValue;

+ markingBackgroundColorValue_ = markingBackgroundColorValue;

+ }

+

+ void removeChatSecurityMarking() {}

+

+ std::shared_ptr<SecurityLabel> lastAddedMessageSecurityLabel_ = nullptr;

+ std::string markingValue_;

+ std::string markingForegroundColorValue_;

+ std::string markingBackgroundColorValue_;

+ <Package Id='*' Keywords='Installer' Description="Swift Installer" Comments="Swift is available under the GPL version 3" Manufacturer="Swift.im" InstallerVersion='500' Languages='1033' Compressed='yes' SummaryCodepage='1252' />

+ <Property Id="ALLUSERS" Value="2" />

+ <Property Id="MSIINSTALLPERUSER" Value="1" />

+ <Property Id="WIXUIVCREDISTINSTALL" Value="0" />

+

+ <Property Id="VCREDISTINSTALLED">

+ <RegistrySearch Id="VCREDISTINSTALLED"

+ Root="HKLM"

+ Key="SOFTWARE\Wow6432Node\Microsoft\VisualStudio\$(var.MsvcDotVersion)\VC\Runtimes\$(sys.BUILDARCH)"

+ Name="Installed"

+ Type="raw" />

+

+ </Property>

+ have the same GUID (do not run heat.exe with -gg flag) or else when MSI removes the components

+ <Directory Id="APPLICATIONFOLDER" Name="Swift">

+ </Directory>

+

+ <Property Id="WixAppFolder" Value="WixPerUserFolder" />

+

+ <ComponentGroupRef Id='VCFiles' />

+ <!--UIRef Id="WixUI_Mondo"/-->

+ <UIRef Id="WixUI_Swift"/>

+

+ <!--

+ VC Redistributable

+ <InstallUISequence>

+ <!-- Suppress FindRelatedProducts untill the user selects the scope of the install -->

+ <FindRelatedProducts Suppress="yes" />

+ </InstallUISequence>

+ <Custom Action='CRTAction' After='InstallInitialize'>(NOT VCREDISTINSTALLED AND ALLUSERS = 1) OR WIXUIVCREDISTINSTALL = 1</Custom>

+ <Fragment>

+ <DirectoryRef Id="INSTALLDIR">

+ <Component Id="msvcp.dll" Guid="*">

+ <Condition>(NOT (VCREDISTINSTALLED OR ALLUSERS = 1)) AND WIXUIVCREDISTINSTALL = 0 </Condition>

+ <File Id="msvcp$(var.MsvcVersion).dll" KeyPath="yes" Source="$(var.VCCRTPath)\msvcp$(var.MsvcVersion).dll" />

+ </Component>

+ <Component Id="vcruntime.dll" Guid="*">

+ <Condition>(NOT (VCREDISTINSTALLED OR ALLUSERS = 1)) AND WIXUIVCREDISTINSTALL = 0 </Condition>

+ <?if $(var.MsvcVersion) > "120"?>

+ <File Id="vcruntime$(var.MsvcVersion).dll" KeyPath="yes" Source="$(var.VCCRTPath)\vcruntime$(var.MsvcVersion).dll" />

+ <?else?>

+ <File Id="msvcr$(var.MsvcVersion).dll" KeyPath="yes" Source="$(var.VCCRTPath)\msvcr$(var.MsvcVersion).dll" />

+ <?endif?>

+ </Component>

+ </DirectoryRef>

+ </Fragment>

+ <Fragment>

+ <ComponentGroup Id="VCFiles">

+ <ComponentRef Id="msvcp.dll" />

+ <ComponentRef Id="vcruntime.dll" />

+ </ComponentGroup>

+ </Fragment>

+ <Fragment>

+

+ <WixVariable Id="WixUISupportPerUser" Value="1" Overridable="yes" />

+ <WixVariable Id="WixUISupportPerMachine" Value="1" Overridable="yes" />

+

+ <!-- This is Based on WixUI_Mondo, but it adds an InstallScopeDlg dialog -->

+ <UI Id="WixUI_Swift">

+ <TextStyle Id="WixUI_Font_Normal" FaceName="Tahoma" Size="8" />

+ <TextStyle Id="WixUI_Font_Bigger" FaceName="Tahoma" Size="12" />

+ <TextStyle Id="WixUI_Font_Title" FaceName="Tahoma" Size="9" Bold="yes" />

+

+ <Property Id="DefaultUIFont" Value="WixUI_Font_Normal" />

+ <Property Id="WixUI_Mode" Value="Mondo" />

+

+ <DialogRef Id="ErrorDlg" />

+ <DialogRef Id="FatalError" />

+ <DialogRef Id="FilesInUse" />

+ <DialogRef Id="MsiRMFilesInUse" />

+ <DialogRef Id="PrepareDlg" />

+ <DialogRef Id="ProgressDlg" />

+ <DialogRef Id="ResumeDlg" />

+ <DialogRef Id="UserExit" />

+

+ <Publish Dialog="ExitDialog" Control="Finish" Event="EndDialog" Value="Return" Order="999">1</Publish>

+

+ <Publish Dialog="WelcomeDlg" Control="Next" Event="NewDialog" Value="LicenseAgreementDlg">NOT Installed AND NOT PATCH</Publish>

+ <Publish Dialog="WelcomeDlg" Control="Next" Event="NewDialog" Value="VerifyReadyDlg">Installed AND PATCH</Publish>

+

+ <Publish Dialog="LicenseAgreementDlg" Control="Back" Event="NewDialog" Value="WelcomeDlg">1</Publish>

+ <Publish Dialog="LicenseAgreementDlg" Control="Next" Event="NewDialog" Value="InstallScopeDlg" Order="2">LicenseAccepted = "1"</Publish>

+

+ <Publish Dialog="InstallScopeDlg" Control="Back" Event="NewDialog" Value="LicenseAgreementDlg">1</Publish>

+ <!-- override default WixAppFolder of WixPerMachineFolder as standard user won't be shown the radio group to set WixAppFolder -->

+ <Publish Dialog="InstallScopeDlg" Control="Next" Property="WixAppFolder" Value="WixPerUserFolder" Order="1">!(wix.WixUISupportPerUser) AND NOT Privileged</Publish>

+ <Publish Dialog="InstallScopeDlg" Control="Next" Property="ALLUSERS" Value="{}" Order="2">WixAppFolder = "WixPerUserFolder"</Publish>

+ <Publish Dialog="InstallScopeDlg" Control="Next" Property="ALLUSERS" Value="1" Order="3">WixAppFolder = "WixPerMachineFolder"</Publish>

+ <Publish Dialog="InstallScopeDlg" Control="Next" Property="APPLICATIONFOLDER" Value="[WixPerUserFolder]" Order="4">WixAppFolder = "WixPerUserFolder"</Publish>

+ <Publish Dialog="InstallScopeDlg" Control="Next" Property="APPLICATIONFOLDER" Value="[WixPerMachineFolder]" Order="5">WixAppFolder = "WixPerMachineFolder"</Publish>

+ <Publish Dialog="InstallScopeDlg" Control="Next" Event="NewDialog" Value="SetupTypeDlg">1</Publish>

+ <!-- After selecting the scope of the installation, run FindRelatedProducts to find previous versions that needs upgrading -->

+ <Publish Dialog="InstallScopeDlg" Control="Next" Event="DoAction" Value="FindRelatedProducts" Order="6">1</Publish>

+

+ <Publish Dialog="SetupTypeDlg" Control="Back" Event="NewDialog" Value="InstallScopeDlg">1</Publish>

+ <Publish Dialog="SetupTypeDlg" Control="TypicalButton" Event="NewDialog" Value="VCResdistDialog">NOT VCREDISTINSTALLED AND NOT ALLUSERS </Publish>

+ <Publish Dialog="SetupTypeDlg" Control="CustomButton" Event="NewDialog" Value="CustomizeDlg">NOT VCREDISTINSTALLED AND NOT ALLUSERS </Publish>

+ <Publish Dialog="SetupTypeDlg" Control="CompleteButton" Event="NewDialog" Value="VCResdistDialog">NOT VCREDISTINSTALLED AND NOT ALLUSERS </Publish>

+ <Publish Dialog="SetupTypeDlg" Control="TypicalButton" Event="NewDialog" Value="VerifyReadyDlg">VCREDISTINSTALLED OR ALLUSERS = 1</Publish>

+ <Publish Dialog="SetupTypeDlg" Control="CustomButton" Event="NewDialog" Value="CustomizeDlg">VCREDISTINSTALLED OR ALLUSERS = 1</Publish>

+ <Publish Dialog="SetupTypeDlg" Control="CompleteButton" Event="NewDialog" Value="VerifyReadyDlg">VCREDISTINSTALLED OR ALLUSERS = 1</Publish>

+

+ <Dialog Id="VCResdistDialog" Width="260" Height="85" Title="[ProductName] Setup">

+ <Control Id="VcRredistNo" Type="PushButton" X="132" Y="57" Width="56" Height="17" Default="yes" Cancel="yes" Text="!(loc.WixUINo)">

+ <Publish Property="WIXUIVCREDISTINSTALL" Value="0">1</Publish>

+ <Publish Event="NewDialog" Value="VerifyReadyDlg">1</Publish>

+ </Control>

+ <Control Id="VcRredistYes" Type="PushButton" X="72" Y="57" Width="56" Height="17" Text="!(loc.WixUIYes)">

+ <Publish Property="WIXUIVCREDISTINSTALL" Value="1">1</Publish>

+ <Publish Event="NewDialog" Value="VerifyReadyDlg">1</Publish>

+ </Control>

+ <Control Id="Text" Type="Text" X="48" Y="15" Width="194" Height="30" NoPrefix="yes" Text="Visual Studio redistributables installation was not found on your computer. Would you like Swift to install them?" />

+ <Control Id="Icon" Type="Icon" X="15" Y="15" Width="24" Height="24" ToolTip="!(loc.CancelDlgIconTooltip)" FixedSize="yes" IconSize="32" Text="!(loc.CancelDlgIcon)" />

+ </Dialog>

+

+ <Publish Dialog="CustomizeDlg" Control="Back" Event="NewDialog" Value="MaintenanceTypeDlg" Order="1">WixUI_InstallMode = "Change"</Publish>

+ <Publish Dialog="CustomizeDlg" Control="Back" Event="NewDialog" Value="SetupTypeDlg" Order="2">WixUI_InstallMode = "InstallCustom"</Publish>

+ <Publish Dialog="CustomizeDlg" Control="Next" Event="NewDialog" Value="VCResdistDialog" Order="1">NOT VCREDISTINSTALLED AND NOT ALLUSERS</Publish>

+ <Publish Dialog="CustomizeDlg" Control="Next" Event="NewDialog" Value="VerifyReadyDlg" Order="2">VCREDISTINSTALLED OR ALLUSERS = 1</Publish>

+

+ <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="CustomizeDlg" Order="1">WixUI_InstallMode = "InstallCustom"</Publish>

+ <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="SetupTypeDlg" Order="2">WixUI_InstallMode = "InstallTypical" OR WixUI_InstallMode = "InstallComplete"</Publish>

+ <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="CustomizeDlg" Order="3">WixUI_InstallMode = "Change"</Publish>

+ <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="MaintenanceTypeDlg" Order="4">WixUI_InstallMode = "Repair" OR WixUI_InstallMode = "Remove"</Publish>

+ <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="WelcomeDlg" Order="2">WixUI_InstallMode = "Update"</Publish>

+

+ <Publish Dialog="MaintenanceWelcomeDlg" Control="Next" Event="NewDialog" Value="MaintenanceTypeDlg">1</Publish>

+

+ <Publish Dialog="MaintenanceTypeDlg" Control="ChangeButton" Event="NewDialog" Value="CustomizeDlg">1</Publish>

+ <Publish Dialog="MaintenanceTypeDlg" Control="RepairButton" Event="NewDialog" Value="VerifyReadyDlg">1</Publish>

+ <Publish Dialog="MaintenanceTypeDlg" Control="RemoveButton" Event="NewDialog" Value="VerifyReadyDlg">1</Publish>

+ <Publish Dialog="MaintenanceTypeDlg" Control="Back" Event="NewDialog" Value="MaintenanceWelcomeDlg">1</Publish>

+ </UI>

+ <UIRef Id="WixUI_Common" />

+ </Fragment>

+<?xml version="1.0" encoding="utf-8"?>

+<WixLocalization Culture="en-us" xmlns="http://schemas.microsoft.com/wix/2006/localization">

+ <String Id="InstallScopeDlgPerUserDescription">[ProductName] will be installed in a user folder and auto-updates will be enabled. The application be installed only for your user and you do not need to be an Administrator. </String>

+</WixLocalization>

+ ~FlowLayout() override;

+ * Copyright (c) 2010-2018 Isode Limited.

+ messageLog_ = new QtWebKitChatView(this, eventStream_, theme, this, settings); // I accept that passing the ChatWindow in so that the view can call the signals is somewhat inelegant, but it saves a lot of boilerplate. This patch is unpleasant enough already. So let's fix this soon (it at least needs fixing by the time history is sorted), but not now.

+ emojisMenu_ = std::make_unique<QMenu>();

+void QtChatWindow::setChatSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue) {

+ auto layout = static_cast<QBoxLayout*>(this->layout());

+

+ if (securityMarkingLayout_) {

+ layout->removeItem(securityMarkingLayout_);

+ securityMarkingLayout_->removeWidget(securityMarkingDisplay_);

+ delete securityMarkingLayout_;

+ }

+ delete securityMarkingDisplay_;

+

+ securityMarkingLayout_ = new QHBoxLayout();

+ securityMarkingDisplay_ = new QLabel(P2QSTRING(markingValue));

+

+ securityMarkingLayout_->addWidget(securityMarkingDisplay_);

+ layout->insertLayout(1, securityMarkingLayout_);

+

+ auto palette = securityMarkingDisplay_->palette();

+ palette.setColor(securityMarkingDisplay_->foregroundRole(), P2QSTRING(markingForegroundColorValue));

+ palette.setColor(securityMarkingDisplay_->backgroundRole(), P2QSTRING(markingBackgroundColorValue));

+

+ securityMarkingDisplay_->setPalette(palette);

+ securityMarkingDisplay_->setContentsMargins(4,4,4,4);

+ securityMarkingDisplay_->setAutoFillBackground(true);

+ securityMarkingDisplay_->setAlignment(Qt::AlignCenter);

+}

+

+void QtChatWindow::removeChatSecurityMarking() {

+ if (!securityMarkingLayout_) {

+ return;

+ }

+

+ auto layout = static_cast<QBoxLayout*>(this->layout());

+

+ layout->removeItem(securityMarkingLayout_);

+ securityMarkingLayout_->removeWidget(securityMarkingDisplay_);

+

+ delete securityMarkingDisplay_;

+ delete securityMarkingLayout_;

+ securityMarkingDisplay_ = nullptr;

+ securityMarkingLayout_ = nullptr;

+}

+

+ * Copyright (c) 2010-2018 Isode Limited.

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

+ void removeChatSecurityMarking();

+

+ QHBoxLayout* securityMarkingLayout_ = nullptr;

+ QLabel* securityMarkingDisplay_ = nullptr;

+ conversation_ = new QtWebKitChatView(nullptr, nullptr, theme_, this, settings, true); // Horrible unsafe. Do not do this. FIXME

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

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

+QtWebKitChatView::QtWebKitChatView(QtChatWindow* window, UIEventStream* eventStream, QtChatTheme* theme, QWidget* parent, SettingsProvider* settings, bool disableAutoScroll /*= false*/) : QtChatView(parent), window_(window), eventStream_(eventStream), fontSizeSteps_(0), disableAutoScroll_(disableAutoScroll), previousMessageKind_(PreviosuMessageWasNone), previousMessageWasSelf_(false), showEmoticons_(false), insertingLastLine_(false), idCounter_(0), settings_(settings) {

+ std::string messageMarkingValue = "";

+

+ messageMarkingValue = label->getDisplayMarking();

+ htmlString += QString("%1</span> ").arg(QtUtilities::htmlEscape(P2QSTRING(messageMarkingValue)));

+ bool appendToPrevious = appendToPreviousCheck(PreviousMessageWasMessage, senderName, senderIsSelf, label);

+ previousMessageDisplayMarking_ = messageMarkingValue;

+bool QtWebKitChatView::appendToPreviousCheck(PreviousMessageKind messageKind, const std::string& senderName, bool senderIsSelf, const std::shared_ptr<SecurityLabel>& label /*=nullptr*/) {

+ if (settings_->getSetting(SettingConstants::MUC_MARKING_ELISION)) {

+ if (label && label->getDisplayMarking() != previousMessageDisplayMarking_) {

+ if (label->getDisplayMarking() != "") {

+ return false;

+ }

+ }

+ }

+ class SettingsProvider;

+ QtWebKitChatView(QtChatWindow* window, UIEventStream* eventStream, QtChatTheme* theme, QWidget* parent, SettingsProvider* settings, bool disableAutoScroll = false);

+ ~QtWebKitChatView() override;

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

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

+

+ virtual std::string addSystemMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) override;

+ virtual void addPresenceMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) override;

+

+ virtual void addErrorMessage(const ChatWindow::ChatMessage& message) override;

+ virtual void replaceMessage(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time) override;

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

+ virtual void replaceWithAction(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time) override;

+ virtual void replaceLastMessage(const ChatWindow::ChatMessage& message, const ChatWindow::TimestampBehaviour timestampBehaviour) override;

+ virtual void setAckState(const std::string& id, ChatWindow::AckState state) override;

+

+ virtual std::string addFileTransfer(const std::string& senderName, const std::string& avatarPath, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes, const std::string& description) override;

+ virtual void setFileTransferProgress(std::string, const int percentageDone) override;

+ virtual void setFileTransferStatus(std::string, const ChatWindow::FileTransferState state, const std::string& msg = "") override;

+ virtual void addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct, bool isImpromptu, bool isContinuation) override;

+ virtual std::string addWhiteboardRequest(const QString& contact, bool senderIsSelf) override;

+ virtual void setWhiteboardSessionStatus(const std::string& id, const ChatWindow::WhiteboardSessionState state) override;

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

+

+ virtual void showEmoticons(bool show) override;

+ virtual void addLastSeenLine() override;

+ virtual void resizeFont(int fontSizeSteps) override;

+ virtual void scrollToBottom() override;

+ virtual void handleKeyPressEvent(QKeyEvent* event) override;

+ bool appendToPreviousCheck(PreviousMessageKind messageKind, const std::string& senderName, bool senderIsSelf, const std::shared_ptr<SecurityLabel>& label = nullptr);

+ void resizeEvent(QResizeEvent* event) override;

+ std::string previousMessageDisplayMarking_;

+ SettingsProvider* settings_ = nullptr;

+ if env.get("vcredistdir", "") :

+ vcredistdir = os.path.dirname(env["vcredistdir"])

+ else:

+ vcredistdir = os.path.dirname(env["vcredist"])+"\\..\\" + ("x86" if env["win_target_arch"] == "x86" else "x64") + "\\Microsoft.VC"+env.get("MSVC_VERSION", "").replace(".","")[:3]+".CRT\\"

+ 'VCCRTPath': vcredistdir,

+ 'Version': str(myenv["SWIFT_VERSION_MAJOR"]) + "." + str(myenv["SWIFT_VERSION_MINOR"]) + "." + str(myenv["SWIFT_VERSION_PATCH"]),

+ 'MsvcVersion': str(env.get("MSVC_VERSION", "").replace(".","")[:3]),

+ 'MsvcDotVersion': str(env.get("MSVC_VERSION", "")[:4])

+ * Copyright (c) 2010-2017 Isode Limited.

+ virtual ~QtUserSearchWindow() override;

+ virtual void addSavedServices(const std::vector<JID>& services) override;

+ virtual void clear() override;

+ virtual void show() override;

+ virtual void setResults(const std::vector<UserSearchResult>& results) override;

+ virtual void setResultsForm(Form::ref results) override;

+ virtual void setSelectedService(const JID& jid) override;

+ virtual void setServerSupportsSearch(bool error) override;

+ virtual void setSearchError(bool error) override;

+ virtual void setSearchFields(std::shared_ptr<SearchPayload> fields) override;

+ virtual void setNameSuggestions(const std::vector<std::string>& suggestions) override;

+ virtual void prepopulateJIDAndName(const JID& jid, const std::string& name) override;

+ virtual void setContactSuggestions(const std::vector<Contact::ref>& suggestions) override;

+ virtual void setJIDs(const std::vector<JID> &jids) override;

+ virtual void setOriginator(const JID& originator) override;

+ virtual void setRoomJID(const JID &roomJID) override;

+ virtual std::string getReason() const override;

+ virtual std::vector<JID> getJIDs() const override;

+ virtual void setCanStartImpromptuChats(bool supportsImpromptu) override;

+ virtual void updateContacts(const std::vector<Contact::ref> &contacts) override;

+ virtual void addContacts(const std::vector<Contact::ref>& contacts) override;

+ virtual void setCanSupplyDescription(bool allowed) override;

+ virtual void setWarning(const boost::optional<std::string>& message) override;

+ virtual int nextId() const override;