#include <Swiften/Elements/MUCInvitationPayload.h>

#include <Swiften/Elements/MUCUserPayload.h>

#include <Swiften/Base/foreach.h>

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

#include <Swiften/Disco/EntityCapsProvider.h>

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

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

#include <Swiften/Queries/Requests/GetSecurityLabelsCatalogRequest.h>

#include <Swiften/Avatars/AvatarManager.h>

namespace Swift {

ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory), entityCapsProvider_(entityCapsProvider) {

chatWindow_ = chatWindowFactory_->createChatWindow(toJID, eventStream);

chatWindow_->onAllMessagesRead.connect(boost::bind(&ChatControllerBase::handleAllMessagesRead, this));

chatWindow_->onSendMessageRequest.connect(boost::bind(&ChatControllerBase::handleSendMessageRequest, this, _1, _2));

entityCapsProvider_->onCapsChanged.connect(boost::bind(&ChatControllerBase::handleCapsChanged, this, _1));

setOnline(stanzaChannel->isAvailable() && iqRouter->isAvailable());

request->send();

} else {

chatWindow_->setSecurityLabelsEnabled(false);

labelsEnabled_ = false;

}

}

void ChatControllerBase::handleAllMessagesRead() {

if (!unreadMessages_.empty()) {

}

unreadMessages_.clear();

chatWindow_->setUnreadMessageCount(0);

onUnreadCountChanged();

}

}

int ChatControllerBase::getUnreadCount() {

return unreadMessages_.size();

case ErrorPayload::ServiceUnavailable: return QT_TRANSLATE_NOOP("", "The service is unavailable"); break;

case ErrorPayload::SubscriptionRequired: return QT_TRANSLATE_NOOP("", "A subscription is required"); break;

case ErrorPayload::UndefinedCondition: return QT_TRANSLATE_NOOP("", "Undefined condition"); break;

case ErrorPayload::UnexpectedRequest: return QT_TRANSLATE_NOOP("", "Unexpected request"); break;

}

}

return defaultMessage;

}

void ChatControllerBase::handleMUCInvitation(Message::ref message) {

MUCInvitationPayload::ref invite = message->getPayload<MUCInvitationPayload>();

}

void ChatControllerBase::handleMediatedMUCInvitation(Message::ref message) {

MUCUserPayload::Invite invite = *message->getPayload<MUCUserPayload>()->getInvite();

JID from = message->getFrom();

std::string reason;

if (!invite.reason.empty()) {

reason = invite.reason;

}

std::string password;

if (message->getPayload<MUCUserPayload>()->getPassword()) {

password = *message->getPayload<MUCUserPayload>()->getPassword();

}

}

}

#include <boost/optional.hpp>

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

#include "Swiften/Network/Timer.h"

#include "Swiften/Network/TimerFactory.h"

#include "Swiften/Elements/Stanza.h"

#include <string>

#include "Swiften/Elements/DiscoInfo.h"

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

#include "Swiften/JID/JID.h"

#include "Swiften/Elements/SecurityLabelsCatalog.h"

#include "Swiften/Elements/ErrorPayload.h"

#include "Swiften/Presence/PresenceOracle.h"

#include "Swiften/Queries/IQRouter.h"

#include "Swiften/Base/IDGenerator.h"

namespace Swift {

class IQRouter;

IDGenerator idGenerator_;

std::string lastSentMessageStanzaID_;

void createDayChangeTimer();

void handleSendMessageRequest(const std::string &body, bool isCorrectionMessage);

void handleAllMessagesRead();

void handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog>, ErrorPayload::ref error);

void handleDayChangeTick();

void handleMUCInvitation(Message::ref message);

void handleMediatedMUCInvitation(Message::ref message);

protected:

JID selfJID_;

StanzaChannel* stanzaChannel_;

IQRouter* iqRouter_;

ChatWindowFactory* chatWindowFactory_;

ChatWindow* chatWindow_;

JID toJID_;

bool labelsEnabled_;

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

PresenceOracle* presenceOracle_;

AvatarManager* avatarManager_;

#include <Swiften/Base/format.h>

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

#include "SwifTools/Notifier/Notifier.h"

#include "Swiften/Avatars/AvatarManager.h"

#include "Swiften/Client/NickResolver.h"

#include "Swiften/JID/JID.h"

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

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

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

#include "Swift/Controllers/Settings/SettingsProvider.h"

namespace Swift {

EventNotifier::EventNotifier(EventController* eventController, Notifier* notifier, AvatarManager* avatarManager, NickResolver* nickResolver) : eventController(eventController), notifier(notifier), avatarManager(avatarManager), nickResolver(nickResolver) {

eventController->onEventQueueEventAdded.connect(boost::bind(&EventNotifier::handleEventAdded, this, _1));

}

EventNotifier::~EventNotifier() {

else if(boost::shared_ptr<SubscriptionRequestEvent> subscriptionEvent = boost::dynamic_pointer_cast<SubscriptionRequestEvent>(event)) {

JID jid = subscriptionEvent->getJID();

std::string title = jid;

std::string message = str(format(QT_TRANSLATE_NOOP("", "%1% wants to add you to his/her contact list")) % nickResolver->jidToNick(jid));

notifier->showMessage(Notifier::SystemMessage, title, message, boost::filesystem::path(), boost::function<void()>());

}

else if(boost::shared_ptr<ErrorEvent> errorEvent = boost::dynamic_pointer_cast<ErrorEvent>(event)) {

notifier->showMessage(Notifier::SystemMessage, QT_TRANSLATE_NOOP("", "Error"), errorEvent->getText(), boost::filesystem::path(), boost::function<void()>());

}

}

void EventNotifier::handleNotificationActivated(JID jid) {

onNotificationActivated(jid);

}

}

virtual void addSystemMessage(const std::string& message) = 0;

virtual void addPresenceMessage(const std::string& message) = 0;

virtual void addErrorMessage(const std::string& message) = 0;

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

// File transfer related stuff

virtual std::string addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes) = 0;

virtual void setFileTransferProgress(std::string, const int percentageDone) = 0;

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

// message receipts

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

virtual void setContactChatState(ChatState::ChatStateType state) = 0;

virtual void setName(const std::string& name) = 0;

virtual void show() = 0;

virtual void activate() = 0;

virtual void setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels) = 0;

virtual void replaceMessage(const std::string&, const std::string&, const boost::posix_time::ptime&) {};

void setAckState(const std::string& /*id*/, AckState /*state*/) {};

virtual void flash() {};

virtual void setAlert(const std::string& /*alertText*/, const std::string& /*buttonText*/) {};

virtual void cancelAlert() {};

virtual void setCorrectionEnabled(Tristate /*enabled*/) {}

void setAvailableOccupantActions(const std::vector<OccupantAction>&/* actions*/) {}

void setSubject(const std::string& /*subject*/) {}

virtual void showRoomConfigurationForm(Form::ref) {}

virtual void setAffiliations(MUCOccupant::Affiliation, const std::vector<JID>&) {}

virtual void setAvailableRoomActions(const std::vector<RoomAction> &) {};

std::string name_;

std::string lastMessageBody_;

std::vector<SecurityLabelsCatalog::Item> labels_;

bool labelsEnabled_;

SecurityLabelsCatalog::Item label_;

};

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

#include <boost/bind.hpp>

#include <algorithm>

#include <Swiften/Base/foreach.h>

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

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

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

namespace Swift {

EventController::EventController() {

}

EventController::~EventController() {

foreach(boost::shared_ptr<StanzaEvent> event, events_) {

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

}

}

void EventController::handleIncomingEvent(boost::shared_ptr<StanzaEvent> sourceEvent) {

boost::shared_ptr<MessageEvent> messageEvent = boost::dynamic_pointer_cast<MessageEvent>(sourceEvent);

boost::shared_ptr<SubscriptionRequestEvent> subscriptionEvent = boost::dynamic_pointer_cast<SubscriptionRequestEvent>(sourceEvent);

boost::shared_ptr<ErrorEvent> errorEvent = boost::dynamic_pointer_cast<ErrorEvent>(sourceEvent);

events_.push_back(sourceEvent);

sourceEvent->onConclusion.connect(boost::bind(&EventController::handleEventConcluded, this, sourceEvent));

onEventQueueLengthChange(events_.size());

onEventQueueEventAdded(sourceEvent);

if (sourceEvent->getConcluded()) {

handleEventConcluded(sourceEvent);

}

}

}

*/

#include "EventDelegate.h"

#include <QDebug>

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

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

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

namespace Swift {

}

QSize EventDelegate::sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index ) const {

QtEvent* item = static_cast<QtEvent*>(index.internalPointer());

if (!item) {

return QStyledItemDelegate::sizeHint(option, index);

}

switch (getEventType(item->getEvent())) {

case MessageEventType: return messageDelegate_.sizeHint(option, item);

case SubscriptionEventType: return subscriptionDelegate_.sizeHint(option, item);

case ErrorEventType: return errorDelegate_.sizeHint(option, item);

default: return QStyledItemDelegate::sizeHint(option, index);

}

}

void EventDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const {

QtEvent* item = static_cast<QtEvent*>(index.internalPointer());

if (!item) {

QStyledItemDelegate::paint(painter, option, index);

return;

}

switch (getEventType(item->getEvent())) {

case MessageEventType: messageDelegate_.paint(painter, option, item);break;

case SubscriptionEventType: subscriptionDelegate_.paint(painter, option, item);break;

case ErrorEventType: errorDelegate_.paint(painter, option, item);break;

default: QStyledItemDelegate::paint(painter, option, index);

}

}

EventType EventDelegate::getEventType(boost::shared_ptr<StanzaEvent> event) const {

boost::shared_ptr<MessageEvent> messageEvent = boost::dynamic_pointer_cast<MessageEvent>(event);

if (messageEvent) return MessageEventType;

boost::shared_ptr<SubscriptionRequestEvent> subscriptionEvent = boost::dynamic_pointer_cast<SubscriptionRequestEvent>(event);

if (subscriptionEvent) return SubscriptionEventType;

boost::shared_ptr<ErrorEvent> errorEvent = boost::dynamic_pointer_cast<ErrorEvent>(event);

if (errorEvent) return ErrorEventType;

//I don't know what this is.

assert(false);

return MessageEventType;

}

}

#pragma once

#include <QStyledItemDelegate>

#include "Swift/QtUI/Roster/DelegateCommons.h"

#include "Swift/QtUI/EventViewer/TwoLineDelegate.h"

namespace Swift {

class EventDelegate : public QStyledItemDelegate {

Q_OBJECT

public:

EventDelegate();

QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const;

void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const;

private:

EventType getEventType(boost::shared_ptr<StanzaEvent> event) const;

DelegateCommons common_;

TwoLineDelegate messageDelegate_;

TwoLineDelegate subscriptionDelegate_;

TwoLineDelegate errorDelegate_;

};

}

*/

#include "Swift/QtUI/EventViewer/QtEvent.h"

#include <QDateTime>

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

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

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

#include "Swift/QtUI/QtSwiftUtil.h"

namespace Swift {

QtEvent::QtEvent(boost::shared_ptr<StanzaEvent> event, bool active) : event_(event) {

active_ = active;

}

}

boost::shared_ptr<SubscriptionRequestEvent> subscriptionRequestEvent = boost::dynamic_pointer_cast<SubscriptionRequestEvent>(event_);

if (subscriptionRequestEvent) {

return P2QSTRING(subscriptionRequestEvent->getJID().toBare().toString());

}

boost::shared_ptr<ErrorEvent> errorEvent = boost::dynamic_pointer_cast<ErrorEvent>(event_);

if (errorEvent) {

return P2QSTRING(errorEvent->getJID().toBare().toString());

}

return "";

}

QString QtEvent::text() {

boost::shared_ptr<MessageEvent> messageEvent = boost::dynamic_pointer_cast<MessageEvent>(event_);

if (messageEvent) {

return P2QSTRING(messageEvent->getStanza()->getBody());

}

boost::shared_ptr<SubscriptionRequestEvent> subscriptionRequestEvent = boost::dynamic_pointer_cast<SubscriptionRequestEvent>(event_);

else {

message = QString(QObject::tr("%1 would like to add you to their contact list, saying '%2'")).arg(subscriptionRequestEvent->getJID().toBare().toString().c_str()).arg(reason.c_str());

}

return message;

}

boost::shared_ptr<ErrorEvent> errorEvent = boost::dynamic_pointer_cast<ErrorEvent>(event_);

if (errorEvent) {

return P2QSTRING(errorEvent->getText());

}

return "";

}

}

#include <QtDebug>

#include <QBoxLayout>

#include <QPushButton>

#include <QMessageBox>

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

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

#include "Swift/QtUI/QtSubscriptionRequestWindow.h"

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

#include "Swift/Controllers/UIEvents/RequestChatUIEvent.h"

#include "Swift/Controllers/UIEvents/JoinMUCUIEvent.h"

#include "Swiften/Base/Platform.h"

namespace Swift {

QtEventWindow::QtEventWindow(UIEventStream* eventStream) : EventWindow(false) {

return;

}

handleItemActivated(index);

}

void QtEventWindow::handleItemActivated(const QModelIndex& item) {

QtEvent* event = model_->getItem(item.row());

boost::shared_ptr<MessageEvent> messageEvent = boost::dynamic_pointer_cast<MessageEvent>(event->getEvent());

boost::shared_ptr<SubscriptionRequestEvent> subscriptionEvent = boost::dynamic_pointer_cast<SubscriptionRequestEvent>(event->getEvent());

boost::shared_ptr<ErrorEvent> errorEvent = boost::dynamic_pointer_cast<ErrorEvent>(event->getEvent());

if (messageEvent) {

if (messageEvent->getStanza()->getType() == Message::Groupchat) {

eventStream_->send(boost::shared_ptr<UIEvent>(new JoinMUCUIEvent(messageEvent->getStanza()->getFrom().toBare(), messageEvent->getStanza()->getTo().getResource())));

} else {

eventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(messageEvent->getStanza()->getFrom())));

}

} else if (subscriptionEvent) {

QtSubscriptionRequestWindow* window = QtSubscriptionRequestWindow::getWindow(subscriptionEvent, this);

window->show();

} else {

if (errorEvent) {

errorEvent->conclude();

}

QMessageBox msgBox;

msgBox.setText(model_->data(item, Qt::DisplayRole).toString());

msgBox.exec();

}

#include <QStackedWidget>

#include <QTimer>

#include <QMessageBox>

#include <QApplication>

#include <Swiften/Base/Log.h>

#include "QtWebView.h"

#include "QtChatTheme.h"

#include "QtSwiftUtil.h"

namespace Swift {

QtChatView::QtChatView(QtChatTheme* theme, QWidget* parent) : QWidget(parent), fontSizeSteps_(0) {

theme_ = theme;

QVBoxLayout* mainLayout = new QVBoxLayout(this);

void QtChatView::setFileTransferStatus(QString id, const ChatWindow::FileTransferState state, const QString& /* msg */) {

QWebElement ftElement = findDivElementWithID(document_, id);

if (ftElement.isNull()) {

SWIFT_LOG(debug) << "Tried to access FT UI via invalid id! id = " << Q2PSTRING(id) << std::endl;

return;

}

QString newInnerHTML = "";

if (state == ChatWindow::WaitingForAccept) {

}

if (state == ChatWindow::Negotiating) {

// replace with text "Negotiaging" + Cancel button

}

else if (state == ChatWindow::Transferring) {

// progress bar + Cancel Button

newInnerHTML = "<div style=\"position: relative; width: 90%; height: 20px; border: 2px solid grey; -webkit-border-radius: 10px;\">"

"<div class=\"progressbar\" style=\"width: 0%; height: 100%; background: #AAA; -webkit-border-radius: 6px;\">"

"<div class=\"progressbar-value\" style=\"position: absolute; top: 0px; left: 0px; width: 100%; text-align: center; padding-top: 2px;\">"

"0%"

"</div>"

"</div>"

}

else if (state == ChatWindow::Canceled) {

newInnerHTML = "Transfer has been canceled!";

}

else if (state == ChatWindow::Finished) {

// text "Successful transfer"

newInnerHTML = "Transfer completed successfully.";

}

else if (state == ChatWindow::FTFailed) {

newInnerHTML = "Transfer failed.";

}

ftElement.setInnerXml(newInnerHTML);

}

}

void rememberScrolledToBottom();

void setAckXML(const QString& id, const QString& xml);

void setReceiptXML(const QString& id, const QString& xml);

void displayReceiptInfo(const QString& id, bool showIt);

QString getLastSentMessage();

void addToJSEnvironment(const QString&, QObject*);

void setFileTransferProgress(QString id, const int percentageDone);

void setFileTransferStatus(QString id, const ChatWindow::FileTransferState state, const QString& msg);

signals:

void gotFocus();

void fontResized(int);

public slots:

void copySelectionToClipboard();

void scrollToBottom();

void handleLinkClicked(const QUrl&);

#include "SystemMessageSnippet.h"

#include "QtTextEdit.h"

#include "QtSettingsProvider.h"

#include "QtScaledAvatarCache.h"

#include "SwifTools/TabComplete.h"

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

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

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

#include <boost/cstdint.hpp>

#include <boost/format.hpp>

#include <boost/lexical_cast.hpp>

#include <QLabel>

#include <QMessageBox>

#include <QInputDialog>

#include <QApplication>

#include <QUrl>

#include <QPushButton>

#include <QFileDialog>

#include <QMenu>

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

#include <QDebug>

namespace Swift {

settings_ = settings;

unreadCount_ = 0;

idCounter_ = 0;

inputEnabled_ = true;

completer_ = NULL;

affiliationEditor_ = NULL;

theme_ = theme;

isCorrection_ = false;

correctionEnabled_ = Maybe;

messageLog_->setFocusProxy(input_);

connect(qApp, SIGNAL(focusChanged(QWidget*, QWidget*)), this, SLOT(qAppFocusChanged(QWidget*, QWidget*)));

connect(messageLog_, SIGNAL(gotFocus()), input_, SLOT(setFocus()));

resize(400,300);

connect(messageLog_, SIGNAL(fontResized(int)), this, SIGNAL(fontResized(int)));

treeWidget_->onSomethingSelectedChanged.connect(boost::bind(&QtChatWindow::handleOccupantSelectionChanged, this, _1));

treeWidget_->onOccupantActionSelected.connect(boost::bind(boost::ref(onOccupantActionSelected), _1, _2));

}

QtChatWindow::~QtChatWindow() {

if (mucConfigurationWindow_) {

delete mucConfigurationWindow_.data();

}

}

void QtChatWindow::handleOccupantSelectionChanged(RosterItem* item) {

onOccupantSelectionChanged(dynamic_cast<ContactRosterItem*>(item));

}

void QtChatWindow::handleFontResized(int fontSizeSteps) {

messageLog_->resizeFont(fontSizeSteps);

}

void QtChatWindow::handleAlertButtonClicked() {

onAlertButtonClicked();

}

void QtChatWindow::setAlert(const std::string& alertText, const std::string& buttonText) {

htmlString += QString("%3</span> ").arg(Qt::escape(P2QSTRING(label->getDisplayMarking())));

}

QString messageHTML(Qt::escape(P2QSTRING(message)));

messageHTML = P2QSTRING(Linkify::linkify(Q2PSTRING(messageHTML)));

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

QString styleSpanStart = style == "" ? "" : "<span style=\"" + style + "\">";

QString styleSpanEnd = style == "" ? "" : "</span>";

htmlString += styleSpanStart + messageHTML + styleSpanEnd;

if (lastLineTracker_.getShouldMoveLastLine()) {

/* should this be queued? */

messageLog_->addLastSeenLine();

/* if the line is added we should break the snippet */

appendToPrevious = false;

}

QString qAvatarPath = scaledAvatarPath.isEmpty() ? "qrc:/icons/avatar.png" : QUrl::fromLocalFile(scaledAvatarPath).toEncoded();

std::string id = "id" + boost::lexical_cast<std::string>(idCounter_++);

messageLog_->addMessage(boost::shared_ptr<ChatSnippet>(new MessageSnippet(htmlString, Qt::escape(P2QSTRING(senderName)), B2QDATE(time), qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id))));

previousMessageWasSelf_ = senderIsSelf;

previousSenderName_ = P2QSTRING(senderName);

return id;

}

void QtChatWindow::flash() {

emit requestFlash();

}

void QtChatWindow::setAckState(std::string const& id, ChatWindow::AckState state) {

QString xml;

int power = 0;

double engBytes = bytes;

while (engBytes >= 1000) {

++power;

engBytes = engBytes / 1000.0;

}

return str( boost::format("%.1lf %sB") % engBytes % (power > 0 ? siPrefix[power-1] : "") );

}

std::string QtChatWindow::addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes) {

qDebug() << "addFileTransfer";

if (senderIsSelf) {

// outgoing

"<div id='" + ft_id + "'>" +

"</div>";

} else {

// incoming

"<div id='" + ft_id + "'>" +

"</div>";

}

//addMessage(message, senderName, senderIsSelf, boost::shared_ptr<SecurityLabel>(), "", boost::posix_time::second_clock::local_time());

if (lastLineTracker_.getShouldMoveLastLine()) {

/* should this be queued? */

messageLog_->addLastSeenLine();

/* if the line is added we should break the snippet */

appendToPrevious = false;

}

QString qAvatarPath = "qrc:/icons/avatar.png";

std::string id = "ftmessage" + boost::lexical_cast<std::string>(idCounter_++);

}

void QtChatWindow::setFileTransferProgress(std::string id, const int percentageDone) {

messageLog_->setFileTransferProgress(QString::fromStdString(id), percentageDone);

}

void QtChatWindow::setFileTransferStatus(std::string id, const FileTransferState state, const std::string& msg) {

messageLog_->setFileTransferStatus(QString::fromStdString(id), state, QString::fromStdString(msg));

}

}

}

}

void QtChatWindow::addErrorMessage(const std::string& errorMessage) {

if (isWidgetSelected()) {

onAllMessagesRead();

}

QString errorMessageHTML(Qt::escape(P2QSTRING(errorMessage)));

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

messageLog_->addMessage(boost::shared_ptr<ChatSnippet>(new SystemMessageSnippet("<span class=\"error\">" + errorMessageHTML + "</span>", QDateTime::currentDateTime(), false, theme_)));

previousMessageWasSelf_ = false;

}

void QtChatWindow::addSystemMessage(const std::string& message) {

if (isWidgetSelected()) {

onAllMessagesRead();

}

QString messageHTML(Qt::escape(P2QSTRING(message)));

messageHTML = P2QSTRING(Linkify::linkify(Q2PSTRING(messageHTML)));

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

messageLog_->addMessage(boost::shared_ptr<ChatSnippet>(new SystemMessageSnippet(messageHTML, QDateTime::currentDateTime(), false, theme_)));

}

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

if (!id.empty()) {

QString messageHTML(Qt::escape(P2QSTRING(message)));

messageHTML = P2QSTRING(Linkify::linkify(Q2PSTRING(messageHTML)));

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

messageLog_->replaceMessage(messageHTML, P2QSTRING(id), B2QDATE(time));

}

if (isWidgetSelected()) {

onAllMessagesRead();

}

QString messageHTML(Qt::escape(P2QSTRING(message)));

messageHTML = P2QSTRING(Linkify::linkify(Q2PSTRING(messageHTML)));

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

messageLog_->addMessage(boost::shared_ptr<ChatSnippet>(new SystemMessageSnippet(messageHTML, QDateTime::currentDateTime(), false, theme_)));

}

void QtChatWindow::returnPressed() {

if (!inputEnabled_) {

return;

}

messageLog_->scrollToBottom();

lastSentMessage_ = QString(input_->toPlainText());

void QtChatWindow::showRoomConfigurationForm(Form::ref form) {

if (mucConfigurationWindow_) {

delete mucConfigurationWindow_.data();

}

mucConfigurationWindow_ = new QtMUCConfigurationWindow(form);

mucConfigurationWindow_->onFormComplete.connect(boost::bind(boost::ref(onConfigureRequest), _1));

mucConfigurationWindow_->onFormCancelled.connect(boost::bind(boost::ref(onConfigurationFormCancelled)));

}

if (!reason.empty()) {

}

if (!direct) {

}

}

}

class QPushButton;

namespace Swift {

class QtChatView;

class QtOccupantListWidget;

class QtChatTheme;

class TreeWidget;

class QtTextEdit;

class UIEventStream;

class SettingsProvider;

class QtChatWindow : public QtTabbable, public ChatWindow {

Q_OBJECT

public:

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

~QtChatWindow();

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& time);

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

void addSystemMessage(const std::string& message);

void addPresenceMessage(const std::string& message);

void addErrorMessage(const std::string& errorMessage);

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

// message receipts

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

void flash();

QByteArray getSplitterState();

virtual void setAvailableOccupantActions(const std::vector<OccupantAction>& actions);

void setSubject(const std::string& subject);

void showRoomConfigurationForm(Form::ref);

void setAffiliations(MUCOccupant::Affiliation, const std::vector<JID>&);

void setAvailableRoomActions(const std::vector<RoomAction> &actions);

public slots:

void handleChangeSplitterState(QByteArray state);

void handleFontResized(int fontSizeSteps);

void setAlert(const std::string& alertText, const std::string& buttonText = "");

void cancelAlert();

void setCorrectionEnabled(Tristate enabled);

signals:

void geometryChanged();

private slots:

void returnPressed();

void handleInputChanged();

void handleKeyPressEvent(QKeyEvent* event);

void handleSplitterMoved(int pos, int index);

void handleAlertButtonClicked();

void handleActionButtonClicked();

void handleAffiliationEditorAccepted();

private:

void updateTitleWithUnreadCount();

void tabComplete();

void beginCorrection();

void cancelCorrection();

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

void handleOccupantSelectionChanged(RosterItem* item);

int unreadCount_;

bool contactIsTyping_;

LastLineTracker lastLineTracker_;

QString contact_;

QString lastSentMessage_;

QtChatView* messageLog_;

QtChatTheme* theme_;

QtTextEdit* input_;

QLabel* alertLabel_;

QWidget* alertWidget_;

QPushButton* alertButton_;

TabComplete* completer_;

QLineEdit* subject_;

QPushButton* actionButton_;

std::vector<SecurityLabelsCatalog::Item> availableLabels_;

bool isCorrection_;

bool previousMessageWasSelf_;

QString previousSenderName_;

bool inputClearing_;

UIEventStream* eventStream_;

bool inputEnabled_;

QSplitter *logRosterSplitter_;

Tristate correctionEnabled_;

QString alertStyleSheet_;

std::map<QString, QString> descriptions;

QPointer<QtMUCConfigurationWindow> mucConfigurationWindow_;

QPointer<QtAffiliationEditor> affiliationEditor_;

int idCounter_;

SettingsProvider* settings_;

std::vector<ChatWindow::RoomAction> availableRoomActions_;

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

namespace Swift {

}

}

#include <QObject>

#include <map>

namespace Swift {

class FileTransferController;

Q_OBJECT

public:

signals:

};

}

"UserSearch/QtUserSearchDetailsPage.cpp",

"UserSearch/QtUserSearchWindow.cpp",

"UserSearch/UserSearchModel.cpp",

"UserSearch/UserSearchDelegate.cpp",

"QtSubscriptionRequestWindow.cpp",

"QtRosterHeader.cpp",

"QtWebView.cpp",

"qrc_DefaultTheme.cc",

"qrc_Swift.cc",

"QtMUCConfigurationWindow.cpp",

"QtAffiliationEditor.cpp",

"QtUISettingConstants.cpp"

]

myenv["SWIFT_VERSION"] = Version.getBuildVersion(env.Dir("#").abspath, "swift")

if env["PLATFORM"] == "win32" :

res = myenv.RES("#/Swift/resources/Windows/Swift.rc")