#include <boost/bind.hpp>

#include <Swiften/AdHoc/OutgoingAdHocCommandSession.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swift/Controllers/UIEvents/RequestAdHocUIEvent.h>

}

void AdHocManager::setOnline(bool online) {

controller->setOnline(online);

}

}

void AdHocManager::handleServerDiscoItemsResponse(std::shared_ptr<DiscoItems> items, ErrorPayload::ref error) {

std::vector<DiscoItems::Item> commands;

if (!error) {

if (item.getNode() != "http://isode.com/xmpp/commands#test") {

commands.push_back(item);

}

#include <boost/signals2.hpp>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/DiscoItems.h>

class MainWindow;

class UIEventStream;

class AdHocCommandWindowFactory;

class AdHocManager {

public:

AdHocManager(const JID& jid, AdHocCommandWindowFactory* factory, IQRouter* iqRouter, UIEventStream* uiEventStream, MainWindow* mainWindow);

void removeController(std::shared_ptr<AdHocController> contoller);

void setServerDiscoInfo(std::shared_ptr<DiscoInfo> info);

void setOnline(bool online);

private:

void handleServerDiscoItemsResponse(std::shared_ptr<DiscoItems>, ErrorPayload::ref error);

void handleUIEvent(std::shared_ptr<UIEvent> event);

boost::signals2::signal<void (const AdHocController&)> onControllerComplete;

JID jid_;

IQRouter* iqRouter_;

UIEventStream* uiEventStream_;

#include <boost/bind.hpp>

#include <Swiften/Base/format.h>

#include <Swiften/Client/ClientBlockListManager.h>

}

void BlockListController::blockListDifferences(const std::vector<JID> &newBlockList, std::vector<JID> &jidsToUnblock, std::vector<JID> &jidsToBlock) const {

if (std::find(newBlockList.begin(), newBlockList.end(), jid) == newBlockList.end()) {

jidsToUnblock.push_back(jid);

}

}

if (std::find(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid) == blockListBeforeEdit.end()) {

jidsToBlock.push_back(jid);

}

blockListDifferences(blockListEditorWidget_->getCurrentBlockList(), jidsToUnblock, jidsToBlock);

blockListBeforeEdit = blockListManager_->getBlockList()->getItems();

if (std::find(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid) == blockListBeforeEdit.end()) {

blockListBeforeEdit.push_back(jid);

}

}

blockListBeforeEdit.erase(std::remove(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid), blockListBeforeEdit.end());

}

#include <boost/bind.hpp>

#include <boost/regex.hpp>

#include <boost/algorithm/string.hpp>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/format.h>

#include <Swiften/Base/Tristate.h>

#include <Swiften/Client/BlockList.h>

void MUCController::handleBareJIDCapsChanged(const JID& /*jid*/) {

Tristate support = Yes;

bool any = false;

DiscoInfo::ref disco = entityCapsProvider_->getCaps(toJID_.toBare().toString() + "/" + nick);

if (disco && disco->hasFeature(DiscoInfo::MessageCorrectionFeature)) {

any = true;

std::map<std::string, JID> MUCController::getParticipantJIDs() const {

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

std::map<std::string, MUCOccupant> occupants = muc_->getOccupants();

if (occupant.first != nick_) {

participants[occupant.first] = occupant.second.getRealJID().is_initialized() ? occupant.second.getRealJID().get().toBare() : JID();

}

}

void MUCController::sendInvites(const std::vector<JID>& jids, const std::string& reason) const {

muc_->invitePerson(jid, reason, isImpromptu_);

}

}

std::string MUCController::generateJoinPartString(const std::vector<NickJoinPart>& joinParts, bool isImpromptu) {

std::vector<NickJoinPart> sorted[4];

std::string eventStrings[4];

sorted[event.type].push_back(event);

}

std::string result;

// Check for existing bookmark for this room and, if it exists, use it instead.

std::vector<MUCBookmark> bookmarks = mucBookmarkManager_->getBookmarks();

if (bookmark.getRoom() == jid.toBare()) {

roomBookmark = bookmark;

break;

void MUCController::handleUIEvent(std::shared_ptr<UIEvent> event) {

std::shared_ptr<InviteToMUCUIEvent> inviteEvent = std::dynamic_pointer_cast<InviteToMUCUIEvent>(event);

if (inviteEvent && inviteEvent->getRoom() == muc_->getJID()) {

muc_->invitePerson(jid, inviteEvent->getReason(), isImpromptu_);

}

}

muc_->requestAffiliationList(MUCOccupant::Outcast);

}

void MUCController::handleChangeAffiliationsRequest(const std::vector<std::pair<MUCOccupant::Affiliation, JID> >& changes) {

std::set<JID> addedJIDs;

if (change.first != MUCOccupant::NoAffiliation) {

addedJIDs.insert(change.second);

}

}

if (change.first != MUCOccupant::NoAffiliation || addedJIDs.find(change.second) == addedJIDs.end()) {

muc_->changeAffiliation(change.second, change.first);

}

joinContext_ = historyController_->getMUCContext(selfJID_, toJID_, lastActivity_);

bool senderIsSelf = nick_ == message.getFromJID().getResource();

// the chatWindow uses utc timestamps

JID jid = newMessage->getFrom();

boost::optional<boost::posix_time::ptime> time = newMessage->getTimestamp();

boost::posix_time::ptime messageTime = message.getTime() - boost::posix_time::hours(message.getOffset());

if (time && time < messageTime) {

break;

Form::ref result = std::make_shared<Form>(Form::SubmitType);

std::string impromptuConfigs[] = { "muc#roomconfig_enablelogging", "muc#roomconfig_persistentroom", "muc#roomconfig_publicroom", "muc#roomconfig_whois"};

std::set<std::string> impromptuConfigsMissing(impromptuConfigs, impromptuConfigs + 4);

std::shared_ptr<FormField> resultField;

if (field->getName() == "muc#roomconfig_enablelogging") {

resultField = std::make_shared<FormField>(FormField::BooleanType, "0");

}

}

if (config == "muc#roomconfig_publicroom") {

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "This server doesn't support hiding your chat from other users.")), ChatWindow::DefaultDirection);

} else if (config == "muc#roomconfig_whois") {

void MUCController::setImpromptuWindowTitle() {

std::string title;

std::map<std::string, MUCOccupant> occupants = muc_->getOccupants();

if (occupants.size() <= 1) {

title = QT_TRANSLATE_NOOP("", "Empty Chat");

} else {

if (pair.first != nick_) {

title += (title.empty() ? "" : ", ") + pair.first;

}

CPPUNIT_TEST(testChatControllerHighlightingNotificationTesting);

CPPUNIT_TEST(testChatControllerHighlightingNotificationDeduplicateSounds);

CPPUNIT_TEST(testChatControllerMeMessageHandling);

CPPUNIT_TEST(testChatControllerMeMessageHandlingInMUC);

// Carbons tests

uiEventStream_->send(std::make_shared<RequestChatUIEvent>(sender));

// The sender supports delivery receipts.

DiscoInfo::ref disco = std::make_shared<DiscoInfo>();

disco->addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(1)->getPayload<DeliveryReceiptRequest>());

// Two resources respond with message receipts.

Message::ref receiptReply = std::make_shared<Message>();

receiptReply->setFrom(senderJID);

receiptReply->setTo(ownJID);

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(1)->getPayload<DeliveryReceiptRequest>());

// Two resources respond with message receipts.

Message::ref receiptReply = std::make_shared<Message>();

receiptReply->setFrom(senderJID);

receiptReply->setTo(ownJID);

uiEventStream_->send(std::make_shared<RequestChatUIEvent>(sender));

// The sender supports delivery receipts.

DiscoInfo::ref disco = std::make_shared<DiscoInfo>();

disco->addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(1)->getPayload<DeliveryReceiptRequest>());

// Two resources respond with message receipts.

Message::ref reply = std::make_shared<Message>();

reply->setFrom(senderJID);

reply->setTo(ownJID);

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(1)->getPayload<DeliveryReceiptRequest>());

// Two resources respond with message receipts.

Message::ref receiptReply = std::make_shared<Message>();

receiptReply->setFrom(senderJID);

receiptReply->setTo(ownJID);

#include <hippomocks.h>

#include <Swiften/Avatars/NullAvatarManager.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/DummyStanzaChannel.h>

#include <Swiften/Client/NickResolver.h>

occupants.insert(occupant_map::value_type("Ernie", MUCOccupant("Ernie", MUCOccupant::Participant, MUCOccupant::Owner)));

/* populate the MUC with fake users */

muc_->insertOccupant(occupant.second);

}

alterations.push_back(MUCOccupant("Remko", MUCOccupant::NoRole, MUCOccupant::NoAffiliation));

alterations.push_back(MUCOccupant("Ernie", MUCOccupant::Visitor, MUCOccupant::Outcast));

/* perform an alteration to a user's role and affiliation */

occupant_map::iterator occupant = occupants.find(alteration.getNick());

CPPUNIT_ASSERT(occupant != occupants.end());

void testRoleAffiliationStatesVerify(const std::map<std::string, MUCOccupant> &occupants) {

/* verify that the roster is in sync */

GroupRosterItem* group = window_->getRosterModel()->getRoot();

GroupRosterItem* child = dynamic_cast<GroupRosterItem*>(rosterItem);

CPPUNIT_ASSERT(child);

ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(childItem);

CPPUNIT_ASSERT(item);

std::map<std::string, MUCOccupant>::const_iterator occupant = occupants.find(item->getJID().getResource());

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/String.h>

#include <Swiften/Disco/DiscoServiceWalker.h>

#include <Swiften/Disco/GetDiscoInfoRequest.h>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

void UserSearchController::handleDiscoServiceFound(const JID& jid, std::shared_ptr<DiscoInfo> info) {

//bool isUserDirectory = false;

bool supports55 = false;

if ((identity.getCategory() == "directory"

&& identity.getType() == "user")) {

//isUserDirectory = true;

if (resultsPayload->getForm()) {

window_->setResultsForm(resultsPayload->getForm());

} else {

JID jid(item.jid);

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

fields["first"] = item.first;

std::vector<Contact::ref>::iterator i = suggestions.begin();

while (i != suggestions.end()) {

bool found = false;

if ((*i)->jid == jid) {

found = true;

break;

void UserSearchController::handleJIDUpdateRequested(const std::vector<JID>& jids) {

if (window_) {

std::vector<Contact::ref> updates;

updates.push_back(convertJIDtoContact(jid));

}

window_->updateContacts(updates);

void UserSearchController::handleJIDAddRequested(const std::vector<JID>& jids) {

std::vector<Contact::ref> contacts;

contacts.push_back(convertJIDtoContact(jid));

}

window_->addContacts(contacts);

void UserSearchController::loadSavedDirectories() {

savedDirectories_.clear();

if(!stringItem.empty()) {

savedDirectories_.push_back(JID(stringItem));

}

std::string collapsed;

int i = 0;

if (i >= 15) {

break;

}

#include <Swift/Controllers/ChatMessageSummarizer.h>

#include <Swiften/Base/format.h>

#include <Swift/Controllers/Intl.h>

vector<UnreadPair> others;

int currentUnread = 0;

int otherCount = 0;

if (unread.first == current) {

currentUnread += unread.second;

} else {

#include <boost/lambda/lambda.hpp>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/ContactProvider.h>

std::vector<Contact::ref> ContactSuggester::getSuggestions(const std::string& search, bool withMUCNicks) const {

std::vector<Contact::ref> results;

append(results, provider->getContacts(withMUCNicks));

}

#include <Swift/Controllers/ContactsFromXMPPRoster.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Swiften/Roster/XMPPRosterItem.h>

std::vector<Contact::ref> ContactsFromXMPPRoster::getContacts(bool /*withMUCNicks*/) {

std::vector<Contact::ref> results;

std::vector<XMPPRosterItem> rosterItems = roster_->getItems();

Contact::ref contact = std::make_shared<Contact>(rosterItem.getName().empty() ? rosterItem.getJID().toString() : rosterItem.getName(), rosterItem.getJID(), StatusShow::None,"");

contact->statusType = presenceOracle_->getAccountPresence(contact->jid) ? presenceOracle_->getAccountPresence(contact->jid)->getShow() : StatusShow::None;

contact->avatarPath = avatarManager_->getAvatarPath(contact->jid);

#include <boost/signals2.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/FileTransfer/FileTransferManager.h>

namespace Swift {

FileTransferOverview::~FileTransferOverview() {

onNewFileTransferController.disconnect(boost::bind(&FileTransferOverview::handleNewFileTransferController, this, _1));

fileTransferManager->onIncomingFileTransfer.disconnect(boost::bind(&FileTransferOverview::handleIncomingFileTransfer, this, _1));

controller->onStateChanged.disconnect(boost::bind(&FileTransferOverview::handleFileTransferStateChanged, this));

}

}

bool FileTransferOverview::isClearable() const {

bool isClearable = false;

if(controller->getState().type == FileTransfer::State::Finished

|| controller->getState().type == FileTransfer::State::Failed

|| controller->getState().type == FileTransfer::State::Canceled) {

#include <boost/regex.hpp>

#include <boost/serialization/vector.hpp>

#include <Swift/Controllers/Highlighter.h>

#include <Swift/Controllers/SettingConstants.h>

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

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <boost/lambda/lambda.hpp>

#include <Swiften/Base/Regex.h>

namespace Swift {

void HighlightRule::updateRegex() const

{

keywordRegex_.clear();

keywordRegex_.push_back(regexFromString(k));

}

senderRegex_.clear();

senderRegex_.push_back(regexFromString(s));

}

}

// check if a keyword matches

if (!matchesKeyword && !keywords_.empty()) {

if (boost::regex_search(body, keyword)) {

matchesKeyword = true;

break;

}

}

if (boost::regex_search(sender, rx)) {

matchesSender = true;

break;

#include <Swift/Controllers/Highlighter.h>

#include <Swift/Controllers/HighlightManager.h>

namespace Swift {

#include <Swift/Controllers/HistoryViewController.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/Path.h>

#include <Swiften/Client/NickResolver.h>

#include <Swiften/History/HistoryMessage.h>

historyWindow_->setDate(currentResultDate_);

addNewMessage(message, false);

}

}

std::vector<HistoryMessage> messages = historyController_->getMessagesFromPreviousDate(selfJID_, selectedItem_->getJID(), selectedItemType_, date);

addNewMessage(message, true);

}

historyWindow_->resetConversationViewTopInsertPoint();

std::vector<HistoryMessage> messages = historyController_->getMessagesFromNextDate(selfJID_, selectedItem_->getJID(), selectedItemType_, date);

addNewMessage(message, false);

}

}

std::vector<HistoryMessage> messages = historyController_->getMessagesFromDate(selfJID_, selectedItem_->getJID(), selectedItemType_, currentResultDate_);

historyWindow_->setDate(currentResultDate_);

addNewMessage(message, false);

}

}

std::vector<HistoryMessage> messages = historyController_->getMessagesFromDate(selfJID_, selectedItem_->getJID(), selectedItemType_, currentResultDate_);

historyWindow_->setDate(currentResultDate_);

addNewMessage(message, false);

}

}

newDate = date;

}

else if (date < currentResultDate_) {

if (current > date) {

newDate = current;

break;

}

}

else {

if (current < date) {

newDate = current;

break;

std::vector<HistoryMessage> messages = historyController_->getMessagesFromDate(selfJID_, selectedItem_->getJID(), selectedItemType_, currentResultDate_);

historyWindow_->setDate(currentResultDate_);

addNewMessage(message, false);

}

}

return presence;

}

if (presence.get() && presence->getFrom() == jid) {

return presence;

}

#include <Swift/Controllers/PreviousStatusStore.h>

namespace Swift {

PreviousStatusStore::PreviousStatusStore() {

std::vector<TypeStringPair> PreviousStatusStore::getSuggestions(const std::string& message) {

std::vector<TypeStringPair> suggestions;

if (status.second == message) {

suggestions.clear();

suggestions.push_back(status);

namespace Swift {

typedef std::pair<StatusShow::Type, std::string> TypeStringPair;

class PreviousStatusStore {

public:

PreviousStatusStore();

#include <Swift/Controllers/ProfileSettingsProvider.h>

namespace Swift {

ProfileSettingsProvider::ProfileSettingsProvider(const std::string& profile, SettingsProvider* provider) :

profile_(profile) {

provider_ = provider;

bool found = false;

if (existingProfile == profile) {

found = true;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

namespace Swift {

class ProfileSettingsProvider {

public:

ProfileSettingsProvider(const std::string& profile, SettingsProvider* provider);

private:

std::string profileSettingPath(const std::string &settingPath);

SettingsProvider* provider_;

std::string profile_;

};

#include <boost/date_time/posix_time/posix_time.hpp>

#include <Swiften/Base/DateTime.h>

#include <Swiften/Elements/Idle.h>

#include <Swiften/Elements/Presence.h>

#include <boost/bind.hpp>

#include <Swiften/Base/String.h>

#include <Swift/Controllers/Roster/GroupRosterItem.h>

#include <Swift/Controllers/SettingConstants.h>

void RosterGroupExpandinessPersister::save() {

std::string setting;

if (!setting.empty()) {

setting += "\n";

}

#include <boost/cast.hpp>

#include <boost/numeric/conversion/cast.hpp>

#include <Swiften/Network/Timer.h>

#include <Swiften/Network/TimerFactory.h>

// Get a model for the new roster

std::vector<Section> newSections;

if (model) {

if (GroupRosterItem* groupItem = boost::polymorphic_downcast<GroupRosterItem*>(item)) {

//std::cerr << "* " << groupItem->getDisplayName() << std::endl;

Section section(groupItem->getDisplayName());

if (ContactRosterItem* contact = boost::polymorphic_downcast<ContactRosterItem*>(groupChildItem)) {

//std::cerr << " - " << contact->getDisplayJID() << std::endl;

section.items.push_back(Item(contact->getDisplayName(), contact->getStatusText(), contact->getDisplayJID(), contact->getStatusShow(), contact->getAvatarPath()));

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/Settings/SettingsProviderHierachy.h>

#include <Swiften/Base/Log.h>

namespace Swift {

SettingsProviderHierachy::~SettingsProviderHierachy() {

}

bool SettingsProviderHierachy::hasSetting(const std::string& key) {

if (provider->hasSetting(key)) {

return true;

}

std::string SettingsProviderHierachy::getSetting(const Setting<std::string>& setting) {

std::string value = setting.getDefaultValue();

std::string providerSetting = provider->getSetting(setting);

if (provider->hasSetting(setting.getKey())) {

value = providerSetting;

bool SettingsProviderHierachy::getSetting(const Setting<bool>& setting) {

bool value = setting.getDefaultValue();

bool providerSetting = provider->getSetting(setting);

if (provider->hasSetting(setting.getKey())) {

value = providerSetting;

int SettingsProviderHierachy::getSetting(const Setting<int>& setting) {

int value = setting.getDefaultValue();

int providerSetting = provider->getSetting(setting);

if (provider->hasSetting(setting.getKey())) {

value = providerSetting;

bool SettingsProviderHierachy::getIsSettingFinal(const std::string& settingPath) {

bool isFinal = false;

isFinal |= provider->getIsSettingFinal(settingPath);

}

return isFinal;

#include <boost/bind.hpp>

#include <boost/date_time/posix_time/posix_time.hpp>

#include <Swiften/VCards/VCardManager.h>

#include <Swift/Controllers/UIEvents/ShowProfileForRosterItemUIEvent.h>

}

ShowProfileController::~ShowProfileController() {

jidWndPair.second->onWindowAboutToBeClosed.disconnect(boost::bind(&ShowProfileController::handleProfileWindowAboutToBeClosed, this, _1));

delete jidWndPair.second;

}

#include <boost/filesystem/fstream.hpp>

#include <Swiften/Base/String.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/StringCodecs/Hexify.h>

/*

* All rights reserved.

* See the COPYING file for more information.

*/

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

using namespace Swift;

CertificateMemoryStorage::CertificateMemoryStorage() {

}

bool CertificateMemoryStorage::hasCertificate(Certificate::ref certificate) const {

if (storedCert->toDER() == certificate->toDER()) {

return true;

}

#include <Swiften/Base/Path.h>

#include <Swiften/Base/String.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/Elements/VCard.h>

#include <Swiften/Entity/GenericPayloadPersister.h>

#include <boost/filesystem/path.hpp>

#include <boost/signals2.hpp>

#include <Swiften/Elements/StatusShow.h>

#include <Swiften/MUC/MUCBookmark.h>

if (impromptuJIDs.empty()) {

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

&& isMUC == other.isMUC;

bool found = false;

if (jid.second.toBare() == otherJID.second.toBare()) {

found = true;

break;

avatarPath = path;

}

std::string getImpromptuTitle() const {

std::string title;

if (title.empty()) {

title += pair.first;

} else {

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swift/Controllers/ContactSuggester.h>

using namespace Swift;

std::vector<Contact::ref> contacts;

std::vector<std::string> words = wordList();

std::vector<StatusShow::Type> statuses = statusList();

contacts.push_back(std::make_shared<Contact>(name, jid, status, ""));

}

}

/* a = a */

bool isReflexive(const boost::function<bool (const Contact::ref&, const Contact::ref&)>& comparitor) {

std::vector<Contact::ref> contacts = contactList();

if (!comparitor(a, a)) {

return false;

}

/* a = b -> b = a */

bool isSymmetric(const boost::function<bool (const Contact::ref&, const Contact::ref&)>& comparitor) {

std::vector<Contact::ref> contacts = contactList();

if (comparitor(a, b)) {

if (!comparitor(b, a)) {

return false;

/* a = b && b = c -> a = c */

bool isTransitive(const boost::function<bool (const Contact::ref&, const Contact::ref&)>& comparitor) {

std::vector<Contact::ref> contacts = contactList();

if (comparitor(a, b) && comparitor(b, c)) {

if (!comparitor(a, c)) {

return false;

void sortTest() {

std::vector<std::string> words = wordList();

CPPUNIT_ASSERT(isTransitive(boost::bind(Contact::sortPredicate, _1, _2, word)));

}

}

#include <boost/bind.hpp>

#include <Swiften/Client/NickResolver.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Whiteboard/WhiteboardSessionManager.h>

#include <Swift/Controllers/UIEvents/ShowWhiteboardUIEvent.h>

namespace Swift {

WhiteboardManager::WhiteboardManager(WhiteboardWindowFactory* whiteboardWindowFactory, UIEventStream* uiEventStream, NickResolver* nickResolver, WhiteboardSessionManager* whiteboardSessionManager) : whiteboardWindowFactory_(whiteboardWindowFactory), uiEventStream_(uiEventStream), nickResolver_(nickResolver), whiteboardSessionManager_(whiteboardSessionManager) {

#ifdef SWIFT_EXPERIMENTAL_WB

}

WhiteboardManager::~WhiteboardManager() {

delete whiteboardWindowPair.second;

}

}

#include <boost/bind.hpp>

#include <boost/numeric/conversion/cast.hpp>

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

#include <Swift/Controllers/XMPPEvents/IncomingFileTransferEvent.h>

#include <Swift/Controllers/XMPPEvents/MUCInviteEvent.h>

}

EventController::~EventController() {

event->onConclusion.disconnect(boost::bind(&EventController::handleEventConcluded, this, event));

}

}

/* If it's a duplicate subscription request, remove the previous request first */

if (subscriptionEvent) {

EventList existingEvents(events_);

std::shared_ptr<SubscriptionRequestEvent> existingSubscriptionEvent = std::dynamic_pointer_cast<SubscriptionRequestEvent>(existingEvent);

if (existingSubscriptionEvent) {

if (existingSubscriptionEvent->getJID() == subscriptionEvent->getJID()) {

#include <QList>

#include <Swift/QtUI/ChatList/ChatListItem.h>

namespace Swift {

int row(ChatListItem* item) {return items_.indexOf(item);}

QVariant data(int role) const {return (role == Qt::DisplayRole) ? name_ : QVariant();}

void clear() {

delete item;

}

items_.clear();

}

private:

static bool pointerItemLessThan(const ChatListItem* first, const ChatListItem* second) {

QString myName = first->data(Qt::DisplayRole).toString().toLower();

recents_->clear();

endRemoveRows();

beginInsertRows(recentsIndex_, 0, recents.size());

recents_->addItem(new ChatListRecentItem(chat, recents_));

//whiteboards_->addItem(new ChatListRecentItem(chat, whiteboards_));

}

}

dataStream << P2QSTRING(chat.jid.toString());

} else {

dataStream << P2QSTRING(jid.second.toString());

}

}

ChatListItem* baseItem = index.isValid() ? static_cast<ChatListItem*>(index.internalPointer()) : nullptr;

contextMenuItem_ = baseItem;

action->setEnabled(isOnline_);

}

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

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

std::string text = "";

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

text = textPart->text;

break;

#include <QDateTime>

#include <QString>

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

#include <Swift/QtUI/QtChatTheme.h>

#include "CocoaUIHelpers.h"

#include <memory>

#include <boost/type_traits.hpp>

#include <Cocoa/Cocoa.h>

#include <Security/Security.h>

#include <SecurityInterface/SFCertificatePanel.h>

#pragma GCC diagnostic ignored "-Wold-style-cast"

namespace Swift {

void CocoaUIHelpers::displayCertificateChainAsSheet(QWidget* parent, const std::vector<Certificate::ref>& chain) {

NSWindow* parentWindow = [((NSView*)parent->winId()) window];

NSMutableArray* certificates = [[NSMutableArray alloc] init];

// convert chain to SecCertificateRef

ByteArray certAsDER = cert->toDER();

std::shared_ptr<boost::remove_pointer<CFDataRef>::type> certData(CFDataCreate(nullptr, certAsDER.data(), certAsDER.size()), CFRelease);

[certificates addObject: (id)macCert.get()];

}

SFCertificatePanel* panel = [[SFCertificatePanel alloc] init];

//[panel setPolicies:(id)policies.get()];

[panel beginSheetForWindow:parentWindow modalDelegate:nil didEndSelector:nullptr contextInfo:nullptr certificates:certificates showGroup:YES];

}

EventModel::~EventModel() {

delete event;

}

delete event;

}

}

void QtAdHocCommandWindow::handleNextStageReceived(Command::ref command) {

QString notes;

if (!notes.isEmpty()) {

notes += "\n";

}

void QtAdHocCommandWindow::setAvailableActions(Command::ref /*commandResult*/) {

okButton_->show();

okButton_->setEnabled(true);

OutgoingAdHocCommandSession::ActionState state = command_->getActionState(pair.first);

if (state & OutgoingAdHocCommandSession::Present) {

okButton_->hide();

void QtAffiliationEditor::handleCurrentIndexChanged(int index) {

ui_.list->clear();

ui_.list->addItem(P2QSTRING(jid.toString()));

}

}

#include <QStyledItemDelegate>

#include <QValidator>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/JID/JID.h>

void QtBlockListEditorWindow::setCurrentBlockList(const std::vector<JID> &blockedJIDs) {

ui->blockListTreeWidget->clear();

QTreeWidgetItem* item = new QTreeWidgetItem(QStringList(P2QSTRING(jid.toString())) << "");

item->setFlags(item->flags() | Qt::ItemIsEditable);

ui->blockListTreeWidget->addTopLevelItem(item);

#include <QStringList>

#include <QTreeWidgetItem>

#include <Swift/QtUI/ui_QtCertificateViewerDialog.h>

namespace Swift {

// convert Swift certificate chain to qt certificate chain (root goes first)

currentChain.clear();

ByteArray certAsDer = cert->toDER();

QByteArray dataArray(reinterpret_cast<const char*>(certAsDer.data()), certAsDer.size());

currentChain.push_front(QSslCertificate(dataArray, QSsl::Der));

#endif

if (!altNames.empty()) {

ADD_SECTION(tr("Alternate Subject Names"));

if (type == QSsl::EmailEntry) {

ADD_FIELD(tr("E-mail Address"), name);

} else {

}

QtChatTabs::~QtChatTabs() {

delete shortcut;

}

#include <QShortcut>

#include <Swiften/Base/Log.h>

#include <Swift/QtUI/QtTabbable.h>

QList<QWidget*> windows = qApp->topLevelWidgets();

QList<QtTabbable*> tabbables;

QtTabbable* tabbable = dynamic_cast<QtTabbable*>(topLevelWidget);

if (tabbable) {

tabbables << tabbable;

int i = 0;

int defaultIndex = 0;

labelsWidget_->setModel(labelModel_);

if (label.getIsDefault()) {

defaultIndex = i;

break;

}

else {

if (impromptu_) {

// hide options we don't need in impromptu chats

if (availableAction == ChatWindow::ChangeSubject ||

groupsArea->setWidget(groups);

QVBoxLayout* scrollLayout = new QVBoxLayout(groups);

QString groupName = doubleAmpersand(group);

QCheckBox* check = new QCheckBox(groups);

check->setText(groupName);

std::string QtContactEditWidget::getName() const {

std::string name = Q2PSTRING(name_->text());

QList<QRadioButton*> buttons = findChildren<QRadioButton*>();

if (button->isChecked()) {

if (button == nameRadioButton_) {

name = Q2PSTRING(name_->text());

}

void QtContactEditWidget::setSelectedGroups(const std::vector<std::string>& groups) {

checkBoxes_[group]->setCheckState(Qt::Checked);

}

}

std::set<std::string> QtContactEditWidget::getSelectedGroups() const {

std::set<std::string> groups;

if (group.second->checkState() == Qt::Checked) {

groups.insert(group.first);

}

}

// populate new suggestions

suggestionsLayout_->insertWidget(nameLayout_->count() - 2, new QRadioButton(doubleAmpersand(name), this));

}

QRadioButton* suggestedRadioButton = nullptr;

QList<QRadioButton*> radioButtons = findChildren<QRadioButton*>();

if (candidate->text() == name_->text()) {

suggestedRadioButton = candidate;

break;

private:

QString doubleAmpersand(const std::string& name) const;

std::string singleAmpersand(const QString& name) const;

private:

QHBoxLayout* nameLayout_;

QHBoxLayout* suggestionsLayout_;

QRadioButton* nameRadioButton_;

#include <set>

#include <Swift/QtUI/QtSwiftUtil.h>

namespace Swift {

QtEmoticonsGrid::QtEmoticonsGrid(const std::map<std::string, std::string>& emoticons, QWidget* parent) : QGridLayout(parent) {

makeUniqueEmoticonsMap(emoticons);

int row = 0;

int column = 0;

QtEmoticonCell* newCell = new QtEmoticonCell(P2QSTRING(emoticon.first), P2QSTRING(emoticon.second));

addWidget(newCell, row, column);

connect(newCell, SIGNAL(emoticonClicked(QString)), this, SLOT(emoticonClickedSlot(QString)));

void QtEmoticonsGrid::makeUniqueEmoticonsMap(const std::map<std::string, std::string>& emoticons) {

std::set<std::string> paths;

if (paths.find(emoticon.second) == paths.end()) {

uniqueEmoticons_.insert(emoticon);

paths.insert(emoticon.second);

#include <boost/algorithm/string/join.hpp>

#include <Swift/QtUI/QtSwiftUtil.h>

namespace Swift {

// determine field name

std::string name = formResult_->getReportedFields().at(column)->getName();

if (field->getName() == name) {

std::string delimiter = "";

if (field->getType() == FormField::TextMultiType) {

#include <qdebug.h>

#include <Swift/QtUI/QtSwiftUtil.h>

namespace Swift {

QGridLayout* layout = new QGridLayout(scroll);

const std::vector<Form::FormItem> items = form->getItems();

if (items.empty()) { /* single item forms */

QWidget* widget = createWidget(field, field->getType(), 0);

if (widget) {

layout->addWidget(new QLabel(field->getLabel().c_str(), this), row, 0);

std::vector<bool> selected;

/* if this is an editable form, use the 'options' list, otherwise use the 'values' list */

if (form_->getType() != Form::FormType) {

listWidget->addItem(P2QSTRING(value));

selected.push_back(false);

}

} else {

listWidget->addItem(option.label.c_str());

if (field->getType() == FormField::ListSingleType) {

selected.push_back(!field->getValues().empty() && option.value == field->getValues()[0]);

Form::ref QtFormWidget::getCompletedForm() {

Form::ref result(new Form(Form::SubmitType));

std::shared_ptr<FormField> resultField = std::make_shared<FormField>(field->getType());

if (field->getType() == FormField::BooleanType) {

resultField->setBoolValue(qobject_cast<QCheckBox*>(fields_[field->getName()])->checkState() == Qt::Checked);

QString string = widget->toPlainText();

if (!string.isEmpty()) {

QStringList lines = string.split("\n");

resultField->addValue(Q2PSTRING(line));

}

}

}

if (field->getType() == FormField::ListMultiType) {

QListWidget* listWidget = qobject_cast<QListWidget*>(fields_[field->getName()]);

resultField->addValue(field->getOptions()[listWidget->row(item)].value);

}

}

if (!form_) {

return;

}

QWidget* widget = nullptr;

if (field) {

widget = fields_[field->getName()];

}

QDate currentDate;

int snippetPosition = conversation_->getSnippetPositionByDate(date);

if (snippetPosition <= pos) {

currentDate = date;

setInitialMenus();

std::vector<QMenu*> mainWindowMenus = qtMainWindow->getMenus();

viewMenu_ = mainWindowMenus[0];

menuBar_->addMenu(menu);

}

setFocus();

#include <QVBoxLayout>

#include <Swiften/Base/FileSize.h>

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

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

QString chatMessageToString(const ChatWindow::ChatMessage& message) {

QString result;

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

std::shared_ptr<ChatWindow::ChatURIMessagePart> uriPart;

std::shared_ptr<ChatWindow::ChatEmoticonMessagePart> emoticonPart;

// Force recaluclation of all layout geometry in children widgets.

// This is required on Windows to have the correct size even on first show.

QList<QWidget *> children = findChildren<QWidget*>();

child->updateGeometry();

}

std::vector<std::string> QtSettingsProvider::getAvailableProfiles() {

std::vector<std::string> profiles;

QVariant profilesVariant = settings_.value("profileList");

profiles.push_back(std::string(profileQString.toUtf8()));

}

return profiles;

void QtSettingsProvider::removeProfile(const std::string& profile) {

QString profileStart(QString(profile.c_str()) + ":");

if (key.startsWith(profileStart)) {

settings_.remove(key);

}

#include <Swift/QtUI/QtSingleWindow.h>

#include <Swift/QtUI/QtChatTabs.h>

#include <Swift/QtUI/QtSettingsProvider.h>

void QtSingleWindow::handleSplitterMoved(int, int) {

QList<QVariant> variantValues;

QList<int> intValues = sizes();

variantValues.append(QVariant(value));

}

settings_->getQSettings()->setValue(SINGLE_WINDOW_SPLITS, QVariant(variantValues));

void QtSingleWindow::restoreSplitters() {

QList<QVariant> variantValues = settings_->getQSettings()->value(SINGLE_WINDOW_SPLITS).toList();

QList<int> intValues;

intValues.append(value.toInt());

}

setSizes(intValues);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

spellingErrorFormat.setUnderlineColor(QColor(Qt::red));

spellingErrorFormat.setUnderlineStyle(QTextCharFormat::SpellCheckUnderline);

setFormat(boost::get<0>(position), boost::get<1>(position) - boost::get<0>(position), spellingErrorFormat);

};

}

QString text = statusEdit_->text();

newStatusText_ = text;

menu_->clear();

QListWidgetItem* item = new QListWidgetItem(text == "" ? getNoMessage() : text, menu_);

item->setIcon(icons_[type]);

item->setToolTip(P2QSTRING(statusShowTypeToFriendlyName(type)) + ": " + item->text());

item->setData(Qt::UserRole, QVariant(type));

}

std::vector<StatusCache::PreviousStatus> previousStatuses = statusCache_->getMatches(Q2PSTRING(text), 8);

if (savedStatus.first.empty() || std::find_if(allTypes_.begin(), allTypes_.end(),

savedStatus.second == lambda::_1 && savedStatus.first == lambda::bind(&statusShowTypeToFriendlyName, lambda::_1)) != allTypes_.end()) {

continue;

item->setStatusTip(item->toolTip());

item->setData(Qt::UserRole, QVariant(savedStatus.second));

}

if (Q2PSTRING(text) == statusShowTypeToFriendlyName(type)) {

continue;

}

if (x + width > screenWidth) {

x = screenWidth - width;

}

// if (statusEdit_->text() == P2QSTRING(statusShowTypeToFriendlyName(type))) {

statusEdit_->setText("");

// }

}

QtSubscriptionRequestWindow* QtSubscriptionRequestWindow::getWindow(std::shared_ptr<SubscriptionRequestEvent> event, QWidget* parent) {

if (window->getEvent() == event) {

return window;

}

#include <QShortcut>

#include <Swiften/Base/Platform.h>

#include <Swift/QtUI/QtChatTabs.h>

#include <Swift/QtUI/QtUtilities.h>

void QtTagComboBox::setTag(const QString &id, bool value) {

QList<QAction*> tagActions = editMenu->actions();

if (action->data() == id) {

action->setChecked(value);

updateDisplayItem();

bool QtTagComboBox::isTagSet(const QString &id) const {

QList<QAction*> tagActions = editMenu->actions();

if (action->data() == id) {

return action->isChecked();

}

void QtTagComboBox::updateDisplayItem() {

QList<QAction*> tagActions = editMenu->actions();

QString text = "";

if (action->isChecked()) {

if (text != "") {

text += ", ";

}

void QtVCardAddressField::customCleanup() {

widget->hide();

textFieldGridLayout->removeWidget(widget);

}

domesticRadioButton->setVisible(isEditable);

internationalRadioButton->setVisible(isEditable);

QtResizableLineEdit* lineEdit;

if ((lineEdit = dynamic_cast<QtResizableLineEdit*>(widget))) {

lineEdit->setVisible(isEditable ? true : !lineEdit->text().isEmpty());

void QtVCardGeneralField::handleCloseButtonClicked() {

customCleanup();

widget->hide();

layout->removeWidget(widget);

}

void QtVCardOrganizationField::setOrganization(const VCard::Organization& organization) {

organizationLineEdit->setText(P2QSTRING(organization.name));

unitsTreeWidget->clear();

QTreeWidgetItem* item = new QTreeWidgetItem(QStringList(P2QSTRING(unit)) << "");

item->setFlags(item->flags() | Qt::ItemIsEditable);

unitsTreeWidget->addTopLevelItem(item);

void QtVCardOrganizationField::guaranteeEmptyRow() {

bool hasEmptyRow = false;

QList<QTreeWidgetItem*> rows = unitsTreeWidget->findItems("", Qt::MatchFixedString);

if (row->text(0).isEmpty()) {

hasEmptyRow = true;

}

QString QtWebKitChatView::chatMessageToHTML(const ChatWindow::ChatMessage& message) {

QString result;

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

std::shared_ptr<ChatWindow::ChatURIMessagePart> uriPart;

std::shared_ptr<ChatWindow::ChatEmoticonMessagePart> emoticonPart;

void QtFilterWidget::popAllFilters() {

std::vector<RosterFilter*> filters = treeView_->getRoster()->getFilters();

filters_.push_back(filter);

treeView_->getRoster()->removeFilter(filter);

}

void QtFilterWidget::pushAllFilters() {

treeView_->getRoster()->onFilterAdded.disconnect(boost::bind(&QtFilterWidget::handleFilterAdded, this, _1));

treeView_->getRoster()->onFilterRemoved.disconnect(boost::bind(&QtFilterWidget::handleFilterRemoved, this, _1));

treeView_->getRoster()->addFilter(filter);

}

filters_.clear();

}

else {

std::map<QAction*, ChatWindow::OccupantAction> actions;

QString text = "Error: missing string";

switch (availableAction) {

case ChatWindow::Kick: text = tr("Kick user"); break;

if (!roster_) {

return;

}

GroupRosterItem* child = dynamic_cast<GroupRosterItem*>(item);

if (!child) continue;

emit itemExpanded(index(child), child->isExpanded());

// star | name | content

QString currentBlock;

QString type = tel.isFax ? QObject::tr("Fax") : QObject::tr("Telephone");

QString field = buildVCardField(tel.isPreferred, type, htmlEscape(P2QSTRING(tel.number)));

if (tel.isPreferred) {

summary += currentBlock;

currentBlock = "";

QString field = buildVCardField(mail.isPreferred, QObject::tr("E-Mail"), htmlEscape(P2QSTRING(mail.address)));

if (mail.isPreferred) {

currentBlock = field;

summary += currentBlock;

currentBlock = "";

QString field = buildVCardField(false, QObject::tr("Organization"), htmlEscape(P2QSTRING(org.name)));

currentBlock += field;

}

summary += currentBlock;

currentBlock = "";

QString field = buildVCardField(false, QObject::tr("Title"), htmlEscape(P2QSTRING(title)));

currentBlock += field;

}

#include <QMimeData>

#include <Swiften/Base/Path.h>

#include <Swiften/Elements/StatusShow.h>

#include <Swift/QtUI/QtResourceHelper.h>

void QtContactListWidget::updateContacts(const std::vector<Contact::ref>& contactUpdates) {

std::vector<Contact::ref> contacts = contactListModel_->getList();

if (contactUpdate->jid == contact->jid) {

contact = contactUpdate;

break;

#include <memory>

namespace Swift {

void WinUIHelpers::displayCertificateChainAsSheet(QWidget* parent, const std::vector<Certificate::ref>& chain) {