/*

* Copyright (c) 2010-2017 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

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

#include <memory>

#include <boost/bind.hpp>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/format.h>

#include <Swiften/Chat/ChatStateNotifier.h>

#include <Swiften/Chat/ChatStateTracker.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/NickResolver.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Disco/EntityCapsProvider.h>

#include <Swiften/Disco/FeatureOracle.h>

#include <Swiften/Elements/DeliveryReceipt.h>

#include <Swiften/Elements/DeliveryReceiptRequest.h>

#include <Swiften/Elements/Idle.h>

#include <Swiften/FileTransfer/FileTransferManager.h>

#include <Swift/Controllers/Chat/ChatMessageParser.h>

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

#include <Swift/Controllers/Highlighting/Highlighter.h>

#include <Swift/Controllers/Intl.h>

#include <Swift/Controllers/SettingConstants.h>

#include <Swift/Controllers/StatusUtil.h>

#include <Swift/Controllers/Translator.h>

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

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

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

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

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

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

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

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

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

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

lastWasPresence_ = false;

chatStateNotifier_->userSentMessage();

}

void ChatController::handleStanzaAcked(std::shared_ptr<Stanza> stanza) {

std::map<std::shared_ptr<Stanza>, std::string>::iterator unackedStanza = unackedStanzas_.find(stanza);

if (unackedStanza != unackedStanzas_.end()) {

chatWindow_->setAckState(unackedStanza->second, ChatWindow::Received);

unackedStanzas_.erase(unackedStanza);

}

}

void ChatController::setOnline(bool online) {

if (!online) {

for (auto& stanzaIdPair : unackedStanzas_) {

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

}

unackedStanzas_.clear();

Presence::ref fakeOffline(new Presence());

fakeOffline->setFrom(toJID_);

fakeOffline->setType(Presence::Unavailable);

chatStateTracker_->handlePresenceChange(fakeOffline);

}

ChatControllerBase::setOnline(online);

}

void ChatController::handleNewFileTransferController(FileTransferController* ftc) {

std::string nick = senderDisplayNameFromMessage(ftc->getOtherParty());

ftControllers[ftID] = ftc;

lastWasPresence_ = false;

if (ftc->isIncoming()) {

auto incomingFileTransferEvent = std::make_shared<IncomingFileTransferEvent>(ftc->getOtherParty());

if (hasOpenWindow()) {

incomingFileTransferEvent->conclude();

}

else {

unreadMessages_.push_back(incomingFileTransferEvent);

updateMessageCount();

}

eventController_->handleIncomingEvent(incomingFileTransferEvent);

}

}

void ChatController::handleWhiteboardSessionRequest(bool senderIsSelf) {

lastWbID_ = chatWindow_->addWhiteboardRequest(senderIsSelf);

}

void ChatController::handleWhiteboardStateChange(const ChatWindow::WhiteboardSessionState state) {

chatWindow_->setWhiteboardSessionStatus(lastWbID_, state);

}

void ChatController::handleFileTransferCancel(std::string id) {

SWIFT_LOG(debug) << "handleFileTransferCancel(" << id << ")" << std::endl;

if (ftControllers.find(id) != ftControllers.end()) {

ftControllers[id]->cancel();

} else {

std::cerr << "unknown file transfer UI id" << std::endl;

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

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

#include <memory>

#include <boost/bind.hpp>

#include <boost/filesystem.hpp>

#include <boost/signals2.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/FileTransfer/FileReadBytestream.h>

#include <Swiften/FileTransfer/FileTransferManager.h>

#include <Swiften/FileTransfer/OutgoingJingleFileTransfer.h>

#include <Swift/Controllers/Intl.h>

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

namespace Swift {

FileTransferController::FileTransferController(const JID& receipient, const std::string& filename, FileTransferManager* fileTransferManager) :

sending(true), otherParty(receipient), filename(filename), ftManager(fileTransferManager), ftProgressInfo(nullptr), chatWindow(nullptr), currentState(FileTransfer::State::WaitingForStart) {

}

FileTransferController::FileTransferController(IncomingFileTransfer::ref transfer) :

sending(false), otherParty(transfer->getSender()), filename(transfer->getFileName()), transfer(transfer), ftManager(nullptr), ftProgressInfo(nullptr), chatWindow(nullptr), currentState(FileTransfer::State::WaitingForStart) {

transfer->onStateChanged.connect(boost::bind(&FileTransferController::handleFileTransferStateChange, this, _1));

}

FileTransferController::~FileTransferController() {

delete ftProgressInfo;

transfer->onStateChanged.disconnect(boost::bind(&FileTransferController::handleFileTransferStateChange, this, _1));

}

const JID &FileTransferController::getOtherParty() const {

return otherParty;

}

chatWindow = wnd;

if (sending) {

} else {

}

return uiID;

}

void FileTransferController::setReceipient(const JID& receipient) {

this->otherParty = receipient;

}

bool FileTransferController::isIncoming() const {

return !sending;

}

FileTransfer::State FileTransferController::getState() const {

return currentState;

}

int FileTransferController::getProgress() const {

return ftProgressInfo ? ftProgressInfo->getPercentage() : 0;

}

boost::uintmax_t FileTransferController::getSize() const {

if (transfer) {

return transfer->getFileSizeInBytes();

} else {

return 0;

}

}

void FileTransferController::start(std::string& description) {

SWIFT_LOG(debug) << "FileTransferController::start" << std::endl;

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <string>

#include <boost/cstdint.hpp>

#include <Swiften/FileTransfer/FileReadBytestream.h>

#include <Swiften/FileTransfer/FileTransfer.h>

#include <Swiften/FileTransfer/FileWriteBytestream.h>

#include <Swiften/FileTransfer/IncomingFileTransfer.h>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/FileTransfer/FileTransferProgressInfo.h>

namespace Swift {

class FileTransferManager;

class ChatWindow;

class FileTransferController {

public:

/**

* For outgoing file transfers. It'll create a file transfer via FileTransferManager as soon as the descriptive information is available.

*/

FileTransferController(const JID&, const std::string&, FileTransferManager*);

/**

* For incoming file transfers.

*/

FileTransferController(IncomingFileTransfer::ref transfer);

~FileTransferController();

void setReceipient(const JID& otherParty);

void start(std::string& description);

void accept(std::string& file);

void cancel();

const JID &getOtherParty() const;

bool isIncoming() const;

FileTransfer::State getState() const;

int getProgress() const;

boost::uintmax_t getSize() const;

boost::signals2::signal<void ()> onStateChanged;

boost::signals2::signal<void ()> onProgressChange;

private:

void handleFileTransferStateChange(FileTransfer::State);

void handleProgressPercentageChange(int percentage);

private:

bool sending;

JID otherParty;

std::string filename;

FileTransfer::ref transfer;

std::shared_ptr<FileReadBytestream> fileReadStream;

std::shared_ptr<FileWriteBytestream> fileWriteStream;

FileTransferManager* ftManager;

FileTransferProgressInfo* ftProgressInfo;

ChatWindow* chatWindow;

std::string uiID;

enum BlockingState {BlockingUnsupported, IsBlocked, IsUnblocked};

enum Direction { UnknownDirection, DefaultDirection };

enum MUCType { StandardMUC, ImpromptuMUC };

enum TimestampBehaviour { KeepTimestamp, UpdateTimestamp };

enum RoomBookmarkState { RoomNotBookmarked, RoomBookmarked, RoomAutoJoined };

ChatWindow() {}

virtual ~ChatWindow() {}

/** Add message to window.

* @return id of added message (for acks).

*/

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) = 0;

/** Adds action to window.

* @return id of added message (for acks);

*/

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

/** Adds system message to window

* @return id of added message (for replacement)

*/

virtual std::string addSystemMessage(const ChatMessage& message, Direction direction) = 0;

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

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

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

virtual void replaceSystemMessage(const ChatMessage& message, const std::string& id, const TimestampBehaviour timestampBehaviour) = 0;

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

// File transfer related stuff

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

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

virtual void addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct = true, bool isImpromptu = false, bool isContinuation = false) = 0;

virtual std::string addWhiteboardRequest(bool senderIsSelf) = 0;

virtual void setWhiteboardSessionStatus(std::string id, const ChatWindow::WhiteboardSessionState state) = 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 bool isVisible() const = 0;

virtual void activate() = 0;

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

virtual void setSecurityLabelsEnabled(bool enabled) = 0;

virtual void setCorrectionEnabled(Tristate enabled) = 0;

virtual void setFileTransferEnabled(Tristate enabled) = 0;

virtual void setUnreadMessageCount(int count) = 0;

virtual void convertToMUC(MUCType mucType) = 0;

// virtual TreeWidget *getTreeWidget() = 0;

virtual void setSecurityLabelsError() = 0;

virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() = 0;

virtual void setOnline(bool online) = 0;

virtual void setRosterModel(Roster* model) = 0;

virtual void setTabComplete(TabComplete* completer) = 0;

virtual void replaceLastMessage(const ChatMessage& message, const TimestampBehaviour timestampBehaviour) = 0;

virtual void setAckState(const std::string& id, AckState state) = 0;

virtual void flash() = 0;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <string>

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

namespace Swift {

class MockChatWindow : public ChatWindow {

public:

MockChatWindow() {}

virtual ~MockChatWindow();

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*/) {

lastAddedMessage_ = message;

lastAddedMessageSenderName_ = senderName;

lastAddedMessageSenderIsSelf_ = senderIsSelf;

return "id";

}

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

lastAddedAction_ = message;

lastAddedActionSenderName_ = senderName;

lastAddedActionSenderIsSelf_ = senderIsSelf;

return "id";

}

virtual std::string addSystemMessage(const ChatMessage& message, Direction /*direction*/) {

lastAddedSystemMessage_ = message;

return "id";

}

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

lastAddedPresence_ = message;

}

virtual void addErrorMessage(const ChatMessage& message) {

lastAddedErrorMessage_ = message;

}

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

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

virtual void replaceLastMessage(const ChatMessage& message, const TimestampBehaviour /*timestampBehaviour*/) {

lastReplacedMessage_ = message;

}

virtual void replaceSystemMessage(const ChatMessage& message, const std::string& /*id*/, const TimestampBehaviour /*timestampBehaviour*/) {

lastReplacedSystemMessage_ = message;

}

// File transfer related stuff

virtual void setFileTransferProgress(std::string /*id*/, const int /*alreadyTransferedBytes*/) { }

virtual void setFileTransferStatus(std::string /*id*/, const FileTransferState /*state*/, const std::string& /*msg*/) { }

virtual void setMessageReceiptState(const std::string & id, ReceiptState state) {

receiptChanges_.emplace_back(id, state);

}

virtual void setContactChatState(ChatState::ChatStateType /*state*/) {}

virtual void setName(const std::string& name) {name_ = name;}

virtual void show() {}

virtual bool isVisible() const { return true; }

virtual void activate() {}

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

virtual void setSecurityLabelsEnabled(bool enabled) {labelsEnabled_ = enabled;}

virtual void setUnreadMessageCount(int /*count*/) {}

virtual void convertToMUC(MUCType mucType) {

mucType_ = mucType;

}

virtual void setSecurityLabelsError() {}

virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() {return label_;}

virtual void setOnline(bool /*online*/) {}

virtual void setRosterModel(Roster* roster) { roster_ = roster; }

Roster* getRosterModel() { return roster_; }

virtual void setTabComplete(TabComplete*) {}

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

virtual void flash() {}

virtual AlertID addAlert(const std::string& /*alertText*/) { return 0; }

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <string>

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

#include <QWidget>

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

namespace Swift {

class HighlightAction;

class SecurityLabel;

class QtChatView : public QWidget {

Q_OBJECT

public:

QtChatView(QWidget* parent);

virtual ~QtChatView();

/** Add message to window.

* @return id of added message (for acks).

*/

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) = 0;

/** Adds action to window.

* @return id of added message (for acks);

*/

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) = 0;

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

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

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

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

virtual void replaceSystemMessage(const ChatWindow::ChatMessage& message, const std::string& id, const ChatWindow::TimestampBehaviour /*timestampBehaviour*/) = 0;

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

virtual void replaceLastMessage(const ChatWindow::ChatMessage& message, const ChatWindow::TimestampBehaviour /*timestampBehaviour*/) = 0;

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

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

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

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

virtual std::string addWhiteboardRequest(const QString& contact, bool senderIsSelf) = 0;

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

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

virtual void showEmoticons(bool show) = 0;

virtual void addLastSeenLine() = 0;

public slots:

virtual void resizeFont(int fontSizeSteps) = 0;

virtual void scrollToBottom() = 0;

virtual void handleKeyPressEvent(QKeyEvent* event) = 0;

};

}

return messageLog_->addAction(message, senderName, senderIsSelf, label, avatarPath, time);

}

std::string QtChatWindow::addSystemMessage(const ChatMessage& message, Direction direction) {

handleAppendedToLog();

return messageLog_->addSystemMessage(message, direction);

}

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

handleAppendedToLog();

messageLog_->addPresenceMessage(message, direction);

}

void QtChatWindow::addErrorMessage(const ChatMessage& message) {

handleAppendedToLog();

messageLog_->addErrorMessage(message);

}

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

handleAppendedToLog();

messageLog_->replaceMessage(message, id, time);

}

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

handleAppendedToLog();

messageLog_->replaceWithAction(message, id, time);

}

handleAppendedToLog();

}

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

messageLog_->setFileTransferProgress(id, percentageDone);

}

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

messageLog_->setFileTransferStatus(id, state, msg);

}

std::string QtChatWindow::addWhiteboardRequest(bool senderIsSelf) {

handleAppendedToLog();

return messageLog_->addWhiteboardRequest(contact_, senderIsSelf);

}

void QtChatWindow::setWhiteboardSessionStatus(std::string id, const ChatWindow::WhiteboardSessionState state) {

messageLog_->setWhiteboardSessionStatus(id, state);

}

void QtChatWindow::replaceLastMessage(const ChatMessage& message, const TimestampBehaviour timestampBehaviour) {

messageLog_->replaceLastMessage(message, timestampBehaviour);

}

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

messageLog_->setAckState(id, state);

}

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

messageLog_->setMessageReceiptState(id, state);

}

return P2QSTRING(label->getBackgroundColor());

}

if (role == Qt::DisplayRole) {

std::string selector = availableLabels_[index.row()].getSelector();

std::string displayMarking = label ? label->getDisplayMarking() : "";

QString labelName = selector.empty() ? displayMarking.c_str() : selector.c_str();

return labelName;

}

return QVariant();

}

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

};

class QtChatWindow : public QtTabbable, public ChatWindow {

Q_OBJECT

public:

QtChatWindow(const QString& contact, QtChatTheme* theme, UIEventStream* eventStream, SettingsProvider* settings, QtSettingsProvider* qtOnlySettings, const std::map<std::string, std::string>& emoticonsMap);

virtual ~QtChatWindow();

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

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

std::string addSystemMessage(const ChatMessage& message, Direction direction);

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

void addErrorMessage(const ChatMessage& message);

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

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

// File transfer related stuff

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

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

std::string addWhiteboardRequest(bool senderIsSelf);

void setWhiteboardSessionStatus(std::string id, const ChatWindow::WhiteboardSessionState state);

void show();

bool isVisible() const;

void activate();

void setUnreadMessageCount(int count);

void convertToMUC(MUCType mucType);

// TreeWidget *getTreeWidget();

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

void setSecurityLabelsEnabled(bool enabled);

void setSecurityLabelsError();

SecurityLabelsCatalog::Item getSelectedSecurityLabel();

void setName(const std::string& name);

void setOnline(bool online);

QtTabbable::AlertType getWidgetAlertState();

void setContactChatState(ChatState::ChatStateType state);

void setRosterModel(Roster* roster);

void setTabComplete(TabComplete* completer);

int getCount();

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

void replaceLastMessage(const ChatMessage& message, const TimestampBehaviour timestampBehaviour);

void setAckState(const std::string& id, AckState state);

// message receipts

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

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/QtUI/QtPlainChatView.h>

#include <QDialog>

#include <QFileDialog>

#include <QInputDialog>

#include <QLabel>

#include <QMenu>

#include <QProgressBar>

#include <QPushButton>

#include <QScrollBar>

#include <QTextEdit>

#include <QVBoxLayout>

#include <Swiften/Base/FileSize.h>

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

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

#include <Swift/QtUI/ChatSnippet.h>

#include <Swift/QtUI/QtSwiftUtil.h>

#include <Swift/QtUI/QtUtilities.h>

namespace Swift {

QtPlainChatView::QtPlainChatView(QtChatWindow *window, UIEventStream* eventStream)

: QtChatView(window), window_(window), eventStream_(eventStream), idGenerator_(0) {

}

QString name = id.empty() ? "you" : P2QSTRING(id);

text += QString(tr("At %1 %2 corrected the last action to: <i>")).arg(ChatSnippet::timeToEscapedString(B2QDATE(time))).arg(name);

text += chatMessageToString(message);

text += "</i></p>";

log_->append(text);

}

void QtPlainChatView::replaceLastMessage(const ChatWindow::ChatMessage& message, const ChatWindow::TimestampBehaviour /*timestampBehaviour*/)

{

QString text = "<p>The last message was corrected to:<br/>";

text += chatMessageToString(message);

text += "</p>";

log_->append(text);

}

void QtPlainChatView::replaceSystemMessage(const ChatWindow::ChatMessage& message, const std::string& /*id*/, const ChatWindow::TimestampBehaviour /*timestampBehaviour*/) {

QString text = "<p><i>";

text += chatMessageToString(message);

text += "</i></p>";

log_->append(text);

}

void QtPlainChatView::setAckState(const std::string& /*id*/, ChatWindow::AckState state)

{

if (state == ChatWindow::Failed) {

addSystemMessage(ChatWindow::ChatMessage("Message delivery failed due to disconnection from server."), ChatWindow::DefaultDirection);

}

}

{

const std::string ftId = "ft" + boost::lexical_cast<std::string>(idGenerator_++);

const std::string sizeString = formatSize(sizeInBytes);

FileTransfer* transfer;

if (senderIsSelf) {

QString description = QInputDialog::getText(this, tr("File transfer description"),

tr("Description:"), QLineEdit::Normal, "");

/* NOTE: it is not possible to abort if description is not provided, since we must always return a valid transfer id */

const std::string descriptionMessage = description.isEmpty() ? "" : (" \"" + Q2PSTRING(description) + "\"");

const std::string message = std::string() + "Confirm file transfer: <i>" + filename + " (" + sizeString + " bytes)</i>" + descriptionMessage;

transfer = new FileTransfer(this, senderIsSelf, ftId, filename, ChatWindow::WaitingForAccept, Q2PSTRING(description), message, true);

addSystemMessage(ChatWindow::ChatMessage("Preparing to start file transfer..."), ChatWindow::DefaultDirection);

} else { /* incoming transfer */

const std::string descriptionMessage = description.empty() ? "" : (" \"" + description + "\"");

const std::string message = std::string() + "Incoming file transfer: <i>" + filename + " (" + sizeString + " bytes)</i>" + descriptionMessage;

transfer = new FileTransfer(this, senderIsSelf, ftId, filename, ChatWindow::WaitingForAccept, "", message, true);

addSystemMessage("Incoming file transfer from " + senderName + "...", ChatWindow::DefaultDirection);

}

fileTransfers_[ftId] = transfer;

layout()->addWidget(transfer->dialog_);

return ftId;

}

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

{

FileTransferMap::iterator transfer = fileTransfers_.find(id);

if (transfer != fileTransfers_.end()) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <string>

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

#include <QTextEdit>

#include <QWidget>

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

#include <Swift/QtUI/QtChatView.h>

#include <Swift/QtUI/QtChatWindow.h>

class QTextEdit;

class QProgressBar;

namespace Swift {

class HighlightAction;

class SecurityLabel;

class QtPlainChatView : public QtChatView {

Q_OBJECT

public:

QtPlainChatView(QtChatWindow *window, UIEventStream* eventStream);

virtual ~QtPlainChatView();

/** Add message to window.

* @return id of added message (for acks).

*/

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*/);

/** Adds action to window.

* @return id of added message (for acks);

*/

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*/);

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

virtual void addPresenceMessage(const ChatWindow::ChatMessage& /*message*/, ChatWindow::Direction /*direction*/);

virtual void addErrorMessage(const ChatWindow::ChatMessage& /*message*/);

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

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

virtual void replaceLastMessage(const ChatWindow::ChatMessage& /*message*/, const ChatWindow::TimestampBehaviour /*timestampBehaviour*/);

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

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

virtual void setFileTransferProgress(std::string, const int /*percentageDone*/);

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

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

virtual std::string addWhiteboardRequest(const QString& /*contact*/, bool /*senderIsSelf*/) {return "";}

virtual void setWhiteboardSessionStatus(const std::string& /*id*/, const ChatWindow::WhiteboardSessionState /*state*/) {}

virtual void setMessageReceiptState(const std::string& /*id*/, ChatWindow::ReceiptState /*state*/) {}

virtual void showEmoticons(bool /*show*/) {}

virtual void addLastSeenLine() {}

public slots:

virtual void resizeFont(int /*fontSizeSteps*/) {}

virtual void scrollToBottom();

virtual void handleKeyPressEvent(QKeyEvent* /*event*/) {}

virtual void fileTransferAccept();

virtual void fileTransferReject();

virtual void fileTransferFinish();

virtual void acceptMUCInvite();

virtual void rejectMUCInvite();

private:

struct PopupDialog {

PopupDialog(QtPlainChatView* parent) {

dialog_ = new QFrame(parent);

dialog_->setFrameShape(QFrame::Panel);

dialog_->setFrameShadow(QFrame::Raised);

layout_ = new QHBoxLayout;

dialog_->setLayout(layout_);

}

virtual ~PopupDialog() {

std::string QtWebKitChatView::addMessage(

const QString& message,

const std::string& senderName,

bool senderIsSelf,

std::shared_ptr<SecurityLabel> label,

const std::string& avatarPath,

const QString& style,

const boost::posix_time::ptime& time,

const HighlightAction& highlight,

ChatSnippet::Direction direction) {

QString scaledAvatarPath = QtScaledAvatarCache(32).getScaledAvatarPath(avatarPath.c_str());

QString htmlString;

if (label) {

htmlString = QString("<span style=\"border: thin dashed grey; padding-left: .5em; padding-right: .5em; color: %1; background-color: %2; font-size: 90%; margin-right: .5em; \" class='swift_label'>").arg(QtUtilities::htmlEscape(P2QSTRING(label->getForegroundColor()))).arg(QtUtilities::htmlEscape(P2QSTRING(label->getBackgroundColor())));

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

}

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

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

bool highlightWholeMessage = highlight.getFrontColor() || highlight.getBackColor();

QString highlightSpanStart = highlightWholeMessage ? getHighlightSpanStart(highlight) : "";

QString highlightSpanEnd = highlightWholeMessage ? "</span>" : "";

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

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

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

addMessageBottom(std::make_shared<MessageSnippet>(htmlString, QtUtilities::htmlEscape(P2QSTRING(senderName)), B2QDATE(time), qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id), direction));

previousMessageWasSelf_ = senderIsSelf;

previousSenderName_ = P2QSTRING(senderName);

previousMessageKind_ = PreviousMessageWasMessage;

return id;

}

std::string QtWebKitChatView::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) {

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

}

static QString encodeButtonArgument(const QString& str) {

return QtUtilities::htmlEscape(P2QSTRING(Base64::encode(createByteArray(Q2PSTRING(str)))));

}

static QString decodeButtonArgument(const QString& str) {

return P2QSTRING(byteArrayToString(Base64::decode(Q2PSTRING(str))));

}

QString QtWebKitChatView::buildChatWindowButton(const QString& name, const QString& id, const QString& arg1, const QString& arg2, const QString& arg3, const QString& arg4, const QString& arg5) {

QRegExp regex("[A-Za-z][A-Za-z0-9\\-\\_]+");

Q_ASSERT(regex.exactMatch(id));

QString html = QString("<input id='%2' type='submit' value='%1' onclick='chatwindow.buttonClicked(\"%2\", \"%3\", \"%4\", \"%5\", \"%6\", \"%7\");' />").arg(name).arg(id).arg(encodeButtonArgument(arg1)).arg(encodeButtonArgument(arg2)).arg(encodeButtonArgument(arg3)).arg(encodeButtonArgument(arg4)).arg(encodeButtonArgument(arg5));

return html;

}

void QtWebKitChatView::resizeEvent(QResizeEvent* event) {

// This code ensures that if the user is scrolled all to the bottom of a chat view,

// the view stays scrolled to the bottom if the view is resized or if the message

// input widget becomes multi line.

if (isAtBottom_) {

scrollToBottom();

}

QWidget::resizeEvent(event);

}

SWIFT_LOG(debug) << "addFileTransfer" << std::endl;

QString ft_id = QString("ft%1").arg(P2QSTRING(boost::lexical_cast<std::string>(idCounter_++)));

QString actionText;

QString htmlString;

QString formattedFileSize = P2QSTRING(formatSize(sizeInBytes));

QString sanitizedFileName = QtUtilities::htmlEscape(P2QSTRING(filename));

QString sanitizedDescription = QtUtilities::htmlEscape(P2QSTRING(description));

if (senderIsSelf) {

// outgoing

filePaths_[ft_id] = sanitizedFileName;

actionText = tr("Send file: %1 (%2)").arg(sanitizedFileName).arg(formattedFileSize);

htmlString = actionText + " <br/>" +

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

buildChatWindowButton(tr("Cancel"), ButtonFileTransferCancel, ft_id) +

buildChatWindowButton(tr("Set Description"), ButtonFileTransferSetDescription, ft_id) +

buildChatWindowButton(tr("Send"), ButtonFileTransferSendRequest, ft_id) +

"</div>";

} else {

// incoming

actionText = tr("Receiving file: %1 (%2)").arg(sanitizedFileName).arg(formattedFileSize);

if (!sanitizedDescription.isEmpty()) {

actionText += QString(" \"%1\"").arg(sanitizedDescription);

}

htmlString = actionText + " <br/>" +

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

buildChatWindowButton(tr("Cancel"), ButtonFileTransferCancel, ft_id) +

buildChatWindowButton(tr("Accept"), ButtonFileTransferAcceptRequest, ft_id, P2QSTRING(filename)) +

"</div>";

}

bool appendToPrevious = appendToPreviousCheck(PreviousMessageWasFileTransfer, senderName, senderIsSelf);

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

addMessageBottom(std::make_shared<MessageSnippet>(htmlString, QtUtilities::htmlEscape(P2QSTRING(senderName)), B2QDATE(boost::posix_time::second_clock::universal_time()), qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id), ChatSnippet::getDirection(actionText)));

previousMessageWasSelf_ = senderIsSelf;

previousSenderName_ = P2QSTRING(senderName);

previousMessageKind_ = PreviousMessageWasFileTransfer;

return Q2PSTRING(ft_id);

}

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

setFileTransferProgress(P2QSTRING(id), percentageDone);

}

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

setFileTransferStatus(P2QSTRING(id), state, P2QSTRING(msg));

}

std::string QtWebKitChatView::addWhiteboardRequest(const QString& contact, bool senderIsSelf) {

QString wb_id = QString("wb%1").arg(P2QSTRING(boost::lexical_cast<std::string>(idCounter_++)));

QString htmlString;

QString actionText;

if (senderIsSelf) {

actionText = tr("Starting whiteboard chat");

htmlString = "<div id='" + wb_id + "'>" + actionText + "<br />"+

buildChatWindowButton(tr("Cancel"), ButtonWhiteboardSessionCancel, wb_id) +

"</div>";

} else {

actionText = tr("%1 would like to start a whiteboard chat");

htmlString = "<div id='" + wb_id + "'>" + actionText.arg(QtUtilities::htmlEscape(contact)) + ": <br/>" +

buildChatWindowButton(tr("Cancel"), ButtonWhiteboardSessionCancel, wb_id) +

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <QList>

#include <QString>

#include <QWebElement>

#include <QWidget>

#include <Swiften/Base/Override.h>

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

#include <Swift/QtUI/ChatSnippet.h>

#include <Swift/QtUI/QtChatView.h>

class QWebPage;

class QUrl;

class QDate;

namespace Swift {

class QtWebView;

class QtChatTheme;

class QtChatWindowJSBridge;

class UIEventStream;

class QtChatWindow;

static const QString ButtonWhiteboardShowWindow;

static const QString ButtonFileTransferCancel;

static const QString ButtonFileTransferSetDescription;

static const QString ButtonFileTransferSendRequest;

static const QString ButtonFileTransferAcceptRequest;

static const QString ButtonFileTransferOpenFile;

static const QString ButtonMUCInvite;

public:

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

~QtWebKitChatView();

/** Add message to window.

* @return id of added message (for acks).

*/

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

/** Adds action to window.

* @return id of added message (for acks);

*/

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

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

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

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

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

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

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

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

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

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

virtual void setFileTransferStatus(std::string, const ChatWindow::FileTransferState state, const std::string& msg = "") SWIFTEN_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) SWIFTEN_OVERRIDE;

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

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

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

virtual void showEmoticons(bool show) SWIFTEN_OVERRIDE;

void addMessageTop(std::shared_ptr<ChatSnippet> snippet);

void addMessageBottom(std::shared_ptr<ChatSnippet> snippet);

int getSnippetPositionByDate(const QDate& date); // FIXME : This probably shouldn't have been public

virtual void addLastSeenLine() SWIFTEN_OVERRIDE;

private: // previously public, now private

void replaceLastMessage(const QString& newMessage, const ChatWindow::TimestampBehaviour timestampBehaviour);

void replaceLastMessage(const QString& newMessage, const QString& note);

void replaceMessage(const QString& newMessage, const QString& id, const QDateTime& time);

void replaceSystemMessage(const QString& newMessage, const QString&id, const ChatWindow::TimestampBehaviour timestampBehaviour);

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

void setFileTransferWarning(QString id, QString warningText);

void removeFileTransferWarning(QString id);