Swift/QtUI/DefaultTheme.qrc

checker-report.xml

VERSION.*

using namespace boost;

struct Properties {

}

std::string name;

#include "QtMenulet.h"

#include "Slimber/MainController.h"

#include <Swiften/EventLoop/Qt/QtEventLoop.h>

int main(int argc, char* argv[]) {

QApplication app(argc, argv);

#include "sluift.h"

// A built-in table print function

#define SLUIFT_API extern

#endif

SLUIFT_API int (luaopen_sluift)(lua_State *L);

}

}

}

std::string url(&currentURL[0], currentURL.size());

result << "<a href=\"" << url << "\">" << url << "</a>";

}

namespace {

struct Context {

Context(const boost::function<void()>& callback) : callback(new boost::function<void()>(callback)) {}

boost::function<void()>* callback;

#include <map>

#include <SwifTools/Notifier/Notifier.h>

namespace Swift {

class Win32NotifierWindow;

std::string TabComplete::completeWord(const std::string& word) {

if (word == lastCompletion_) {

size_t match = 0;

for (match = 0; match < lastCompletionCandidates_.size(); match++) {

if (lastCompletionCandidates_[match] == lastCompletion_) {

lastCompletionCandidates_.push_back(candidate);

}

}

}

return lastCompletion_;

}

void ChatController::setOnline(bool online) {

if (!online) {

std::map<boost::shared_ptr<Stanza>, std::string>::iterator it = unackedStanzas_.begin();

chatWindow_->setAckState(it->second, ChatWindow::Failed);

}

unackedStanzas_.clear();

void ChatsManager::handleUserLeftMUC(MUCController* mucController) {

std::map<JID, MUCController*>::iterator it;

if ((*it).second == mucController) {

mucControllers_.erase(it);

delete mucController;

void MUCController::appendToJoinParts(std::vector<NickJoinPart>& joinParts, const NickJoinPart& newEvent) {

std::vector<NickJoinPart>::iterator it = joinParts.begin();

bool matched = false;

if ((*it).nick == newEvent.nick) {

matched = true;

JoinPart type = (*it).type;

//delete chatListWindowFactory_;

delete settings_;

delete profileSettings_;

delete avatarManager_;

delete manager_;

delete directedPresenceSender_;

delete entityCapsManager_;

delete capsProvider_;

delete chatListWindow_;

}

void testFirstOpenWindowIncoming() {

if (others.size() > 1) {

string result(QT_TRANSLATE_NOOP("", "%1% and %2% others (%3%)"));

myString = str(format(result) % myString % others.size() % otherCount);

string result(QT_TRANSLATE_NOOP("", "%1%, %2% (%3%)"));

myString = str(format(result) % myString % others[0].first % otherCount);

}

servicesBeingSearched_.erase(jid);

/* All results are in */

active_ = false;

onWalkComplete();

}

suggestions.push_back(status);

}

}

TypeStringPair suggestion(StatusShow::Online, message);

suggestions.push_back(suggestion);

}

presences_.erase(resource);

}

}

offlinePresence_ = presence;

}

} else {

delete group;

}

}

}

children_.clear();

}

removed = groupRemoved;

}

}

}

onChildrenChanged();

onDataChanged();

it = children_.erase(it);

continue;

}

}

onChildrenChanged();

onDataChanged();

void Roster::removeContact(const JID& jid) {

std::vector<ContactRosterItem*>* items = &itemMap_[fullJIDMapping_ ? jid : jid.toBare()];

items->erase(std::remove_if(items->begin(), items->end(), JIDEqualsTo(jid)), items->end());

itemMap_.erase(fullJIDMapping_ ? jid : jid.toBare());

}

//Causes the delete

std::vector<ContactRosterItem*>* items = &itemMap_[fullJIDMapping_ ? jid : jid.toBare()];

items->erase(std::remove(items->begin(), items->end(), deleted), items->end());

}

}

foreach (ContactRosterItem* item, itemMap_[fullJIDMapping_ ? jid : jid.toBare()]) {

item->removeGroup(groupName);

foreach (RosterFilter *filter, filters_) {

hide &= (*filter)(contact);

}

int newDisplayedSize = group->getDisplayedChildren().size();

if (oldDisplayedSize == 0 && newDisplayedSize > 0) {

onGroupAdded(group);

void SystemTrayController::handleEventQueueLengthChange(int /*length*/) {

EventList events = eventController_->getEvents();

bool found = false;

if (boost::dynamic_pointer_cast<MessageEvent>(*it)) {

found = true;

break;

#pragma once

#include "Swift/Controllers/XMPPEvents/StanzaEvent.h"

namespace Swift {

namespace Swift {

class MockChatWindow : public ChatWindow {

public:

virtual ~MockChatWindow();

virtual std::string addMessage(const std::string& message, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime&) {lastMessageBody_ = message; return "";};

}

return bookmark_;

}

StatusShowTypeRole = Qt::UserRole + 3*/

};

ChatListMUCItem(const MUCBookmark& bookmark, ChatListGroupItem* parent);

QVariant data(int role) const;

private:

MUCBookmark bookmark_;

}

return chat_;

}

StatusShowTypeRole = Qt::UserRole + 3*/

};

ChatListRecentItem(const ChatListWindow::Chat& chat, ChatListGroupItem* parent);

QVariant data(int role) const;

private:

ChatListWindow::Chat chat_;

virtual const QString& getContent() const = 0;

virtual QString getContinuationElementID() const { return ""; }

bool getAppendToPrevious() const {

return appendToPrevious_;

#pragma once

#include <QTreeView>

MUCSearchRoomItem(const QString& node, MUCSearchServiceItem* parent);

MUCSearchServiceItem* getParent();

QVariant data(int role);

private:

MUCSearchServiceItem* parent_;

QString node_;

default: return QVariant();

}

}

private:

QList<MUCSearchItem*> rooms_;

QString jidString_;

}

return qrc_ ? "qrc" + themePath_ : "file://" + themePath_;

}

class QtChatTheme {

public:

QtChatTheme(const QString& themePath);

private:

enum files {Header = 0, Footer, Content, Status, Topic, FileTransferRequest, IncomingContent, IncomingNextContent, IncomingContext, IncomingNextContext, OutgoingContent, OutgoingNextContent, OutgoingContext, OutgoingNextContext, Template, MainCSS, TemplateDefault, EndMarker};

}

Event popEvent() {

Event event = receivedEvents.front();

receivedEvents.pop_front();

return event;

namespace Swift {

class Last : public Payload {

public:

int getSeconds() const {return seconds_;}

void setSeconds(int seconds) {seconds_ = seconds;}

namespace Swift {

}

RosterItemExchangePayload::RosterItemExchangePayload() {

public:

enum Action { Add, Modify, Delete };

Action getAction() const {

return action;

return address;

}

}

return emailAddresses_[0];

}

return EMailAddress();

}

bool hasEvents() {

}

virtual void post(const Event& event) {

std::vector<Event> events;

{

boost::unique_lock<boost::mutex> lock(eventsMutex_);

eventsAvailable_.wait(lock);

}

events.swap(events_);

#include <iostream>

#include <boost/lexical_cast.hpp>

#include <Swiften/History/SQLiteHistoryManager.h>

namespace {

LinkLocalServiceInfo LinkLocalServiceInfo::createFromTXTRecord(const ByteArray& record) {

LinkLocalServiceInfo info;

size_t i = 0;

std::pair<std::string,std::string> entry = readEntry(record, &i);

if (entry.first.empty()) {

break;

void MUCBookmarkManager::removeBookmark(const MUCBookmark& bookmark) {

if (!ready_) return;

std::vector<MUCBookmark>::iterator it;

if ((*it) == bookmark) {

bookmarks_.erase(it);

onBookmarkRemoved(bookmark);

CFIndex length = CFStringGetLength(stringValue) + 1;

buffer.resize(length);

if(CFStringGetCString(stringValue, &buffer[0], length, kCFStringEncodingMacRoman)) {

host += *iter;

}

}

}

PresenceMap presenceMap = i->second;

PresenceMap::const_iterator j = presenceMap.begin();

Presence::ref current = j->second;

results.push_back(current);

}

PresenceMap presenceMap = i->second;

PresenceMap::const_iterator j = presenceMap.begin();

Presence::ref highest;

Presence::ref current = j->second;

if (!highest

|| current->getPriority() > highest->getPriority()

toRemove.clear();

toRemove.insert(toRemove.begin(), added.begin(), added.end());

registerQuery->unregisterService();

Swift::sleep(100);

eventLoop->processEvents();

}

namespace {

bool insideQuotes(const ByteArray& v) {

return false;

}

else if (v.size() == 1) {

i++;

}

else if (s[i] == ',') {

value = "";

expectKey = true;

}

#include <Swiften/Serializer/PresenceSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

result += " " + p.first + "=\"" + p.second + "\"";

}

result += ">";

foreach (boost::shared_ptr<XMLNode> node, childNodes_) {

result += node->serialize();

void StanzaAckRequester::handleAckReceived(unsigned int handledStanzasCount) {

unsigned int i = lastHandledStanzasCount;

while (i != handledStanzasCount) {

std::cerr << "Warning: Server acked more stanzas than we sent" << std::endl;

break;

}

a = pms->abcd[0], b = pms->abcd[1],

c = pms->abcd[2], d = pms->abcd[3];

md5_word_t t;

/* Define storage for little-endian or both types of CPUs. */

md5_word_t xbuf[16];

const md5_word_t *X;

#endif

{

delete commands_;

delete storage_;

delete users_;

delete client_;

}