* Copyright (c) 2014 Kevin Smith and Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <cassert>

#include <boost/lexical_cast.hpp>

#include <Swift/QtUI/UserSearch/QtSuggestingJIDInput.h>

#include <Swift/Controllers/HighlightManager.cpp>

#include <Swift/QtUI/QtHighlightEditor.h>

#include <Swift/QtUI/QtSwiftUtil.h>

#include <Swift/QtUI/QtSettingsProvider.h>

#include <QTreeWidgetItem>

#include <QFileDialog>

namespace Swift {

QtHighlightEditor::QtHighlightEditor(QtSettingsProvider* settings, QWidget* parent)

: QWidget(parent), settings_(settings), previousRow_(-1)

{

ui_.setupUi(this);

connect(ui_.listWidget, SIGNAL(currentRowChanged(int)), SLOT(onCurrentRowChanged(int)));

connect(ui_.newButton, SIGNAL(clicked()), SLOT(onNewButtonClicked()));

connect(ui_.deleteButton, SIGNAL(clicked()), SLOT(onDeleteButtonClicked()));

connect(ui_.buttonBox->button(QDialogButtonBox::Apply), SIGNAL(clicked()), SLOT(onApplyButtonClick()));

connect(ui_.buttonBox->button(QDialogButtonBox::Cancel), SIGNAL(clicked()), SLOT(onCancelButtonClick()));

connect(ui_.buttonBox->button(QDialogButtonBox::Ok), SIGNAL(clicked()), SLOT(onOkButtonClick()));

connect(ui_.noColorRadio, SIGNAL(clicked()), SLOT(colorOtherSelect()));

connect(ui_.customColorRadio, SIGNAL(clicked()), SLOT(colorCustomSelect()));

connect(ui_.noSoundRadio, SIGNAL(clicked()), SLOT(soundOtherSelect()));

connect(ui_.defaultSoundRadio, SIGNAL(clicked()), SLOT(soundOtherSelect()));

connect(ui_.customSoundRadio, SIGNAL(clicked()), SLOT(soundCustomSelect()));

/* replace the static line-edit control with the roster autocompleter */

ui_.dummySenderName->setVisible(false);

jid_ = new QtSuggestingJIDInput(this, settings);

ui_.senderName->addWidget(jid_);

jid_->onUserSelected.connect(boost::bind(&QtHighlightEditor::handleOnUserSelected, this, _1));

/* handle autocomplete */

connect(jid_, SIGNAL(textEdited(QString)), SLOT(handleContactSuggestionRequested(QString)));

/* we need to be notified if any of the state changes so that we can update our textual rule description */

connect(ui_.chatRadio, SIGNAL(clicked()), SLOT(widgetClick()));

connect(ui_.roomRadio, SIGNAL(clicked()), SLOT(widgetClick()));

connect(ui_.nickIsKeyword, SIGNAL(clicked()), SLOT(widgetClick()));

connect(ui_.allMsgRadio, SIGNAL(clicked()), SLOT(widgetClick()));

connect(ui_.senderRadio, SIGNAL(clicked()), SLOT(widgetClick()));

connect(jid_, SIGNAL(textChanged(const QString&)), SLOT(widgetClick()));

connect(ui_.keywordRadio, SIGNAL(clicked()), SLOT(widgetClick()));

connect(ui_.keyword, SIGNAL(textChanged(const QString&)), SLOT(widgetClick()));

connect(ui_.matchPartialWords, SIGNAL(clicked()), SLOT(widgetClick()));

connect(ui_.matchCase, SIGNAL(clicked()), SLOT(widgetClick()));

connect(ui_.noColorRadio, SIGNAL(clicked()), SLOT(widgetClick()));

connect(ui_.customColorRadio, SIGNAL(clicked()), SLOT(widgetClick()));

connect(ui_.noSoundRadio, SIGNAL(clicked()), SLOT(widgetClick()));

connect(ui_.defaultSoundRadio, SIGNAL(clicked()), SLOT(widgetClick()));

connect(ui_.customSoundRadio, SIGNAL(clicked()), SLOT(widgetClick()));

/* allow selection of a custom sound file */

connect(ui_.soundFileButton, SIGNAL(clicked()), SLOT(selectSoundFile()));

/* if these are not needed, then they should be removed */

ui_.moveUpButton->setVisible(false);

ui_.moveDownButton->setVisible(false);

setWindowTitle(tr("Highlight Rules"));

}

QtHighlightEditor::~QtHighlightEditor()

{

}

std::string formatShortDescription(const HighlightRule &rule)

{

const std::string chatOrRoom = (rule.getMatchChat() ? "chat" : "room");

std::vector<std::string> senders = rule.getSenders();

std::vector<std::string> keywords = rule.getKeywords();

if (senders.empty() && keywords.empty() && !rule.getNickIsKeyword()) {

return std::string("All ") + chatOrRoom + " messages.";

}

if (rule.getNickIsKeyword()) {

return std::string("All ") + chatOrRoom + " messages that mention my name.";

}

if (!senders.empty()) {

ui_.matchPartialWords->setEnabled(false);

ui_.matchCase->setEnabled(false);

}

if (ui_.chatRadio->isChecked()) {

ui_.allMsgRadio->setText(tr("Apply to all chat messages"));

} else {

ui_.allMsgRadio->setText(tr("Apply to all room messages"));

}

}

void QtHighlightEditor::widgetClick()

{

setChildWidgetStates();

HighlightRule rule = ruleFromDialog();

if (ui_.listWidget->currentItem()) {

ui_.listWidget->currentItem()->setText(P2QSTRING(formatShortDescription(rule)));

}

}

void QtHighlightEditor::disableDialog()

{

ui_.chatRadio->setEnabled(false);

ui_.roomRadio->setEnabled(false);

ui_.allMsgRadio->setEnabled(false);

ui_.nickIsKeyword->setEnabled(false);

ui_.senderRadio->setEnabled(false);

ui_.dummySenderName->setEnabled(false);

ui_.keywordRadio->setEnabled(false);

ui_.keyword->setEnabled(false);

ui_.matchPartialWords->setEnabled(false);

ui_.matchCase->setEnabled(false);

ui_.noColorRadio->setEnabled(false);

ui_.customColorRadio->setEnabled(false);

ui_.foregroundColor->setEnabled(false);

ui_.backgroundColor->setEnabled(false);

ui_.noSoundRadio->setEnabled(false);

ui_.defaultSoundRadio->setEnabled(false);

ui_.customSoundRadio->setEnabled(false);

ui_.soundFile->setEnabled(false);

ui_.soundFileButton->setEnabled(false);

}

void QtHighlightEditor::handleContactSuggestionRequested(const QString& text)

{

std::string stdText = Q2PSTRING(text);

onContactSuggestionsRequested(stdText);

}

void QtHighlightEditor::selectSoundFile()

{

QString path = QFileDialog::getOpenFileName(this, tr("Select sound file..."), QString(), "Sounds (*.wav)");

ui_.soundFile->setText(path);

}

void QtHighlightEditor::handleOnUserSelected(const JID& jid) {

/* this might seem like it should be standard behaviour for the suggesting input box, but is not desirable in all cases */

jid_->setText(P2QSTRING(jid.toString()));

}

void QtHighlightEditor::populateList()

{

previousRow_ = -1;

ui_.listWidget->clear();

HighlightRulesListPtr rules = highlightManager_->getRules();

for (size_t i = 0; i < rules->getSize(); ++i) {

const HighlightRule& rule = rules->getRule(i);

QListWidgetItem *item = new QListWidgetItem();

}

}

return -1;

}

HighlightRule QtHighlightEditor::ruleFromDialog()

{

HighlightRule rule;

if (ui_.chatRadio->isChecked()) {

rule.setMatchChat(true);

rule.setMatchMUC(false);

} else {

rule.setMatchChat(false);

rule.setMatchMUC(true);

}

if (ui_.senderRadio->isChecked()) {

QString senderName = jid_->text();

if (!senderName.isEmpty()) {

std::vector<std::string> senders;

senders.push_back(Q2PSTRING(senderName));

rule.setSenders(senders);

}

}

if (ui_.keywordRadio->isChecked()) {

QString keywordString = ui_.keyword->text();

if (!keywordString.isEmpty()) {

std::vector<std::string> keywords;

keywords.push_back(Q2PSTRING(keywordString));

rule.setKeywords(keywords);

}

}

HighlightAction& action = rule.getAction();

if (ui_.noColorRadio->isChecked()) {

action.setTextColor("");

action.setTextBackground("");

} else {

action.setTextColor(Q2PSTRING(ui_.foregroundColor->getColor().name()));

action.setTextBackground(Q2PSTRING(ui_.backgroundColor->getColor().name()));

}

if (ui_.noSoundRadio->isChecked()) {

action.setPlaySound(false);

} else if (ui_.defaultSoundRadio->isChecked()) {

action.setPlaySound(true);

action.setSoundFile("");

} else {

action.setPlaySound(true);

action.setSoundFile(Q2PSTRING(ui_.soundFile->text()));

}

return rule;

}

void QtHighlightEditor::ruleToDialog(const HighlightRule& rule)

{

ui_.chatRadio->setEnabled(true);

ui_.roomRadio->setEnabled(true);

if (rule.getMatchMUC()) {

ui_.chatRadio->setChecked(false);

ui_.roomRadio->setChecked(true);

} else {

ui_.chatRadio->setChecked(true);

ui_.roomRadio->setChecked(false);

}

ui_.allMsgRadio->setEnabled(true);

ui_.allMsgRadio->setChecked(true); /* this is the default radio button */

jid_->setText("");

ui_.keyword->setText("");

ui_.matchPartialWords->setChecked(false);

ui_.matchCase->setChecked(false);

ui_.nickIsKeyword->setEnabled(true);

if (rule.getNickIsKeyword()) {

ui_.nickIsKeyword->setChecked(true);

}

ui_.senderRadio->setEnabled(true);

std::vector<std::string> senders = rule.getSenders();

if (!senders.empty()) {

ui_.senderRadio->setChecked(true);

jid_->setText(P2QSTRING(senders[0]));

}

ui_.keywordRadio->setEnabled(true);

std::vector<std::string> keywords = rule.getKeywords();

if (!keywords.empty()) {

ui_.keywordRadio->setChecked(true);

ui_.keyword->setText(P2QSTRING(keywords[0]));

ui_.matchPartialWords->setChecked(!rule.getMatchWholeWords());

ui_.matchCase->setChecked(rule.getMatchCase());

}

const HighlightAction& action = rule.getAction();

ui_.noColorRadio->setEnabled(true);

ui_.customColorRadio->setEnabled(true);

ui_.noColorRadio->setChecked(true);

ui_.foregroundColor->setEnabled(false);

ui_.backgroundColor->setEnabled(false);

}

ui_.noSoundRadio->setEnabled(true);

ui_.defaultSoundRadio->setEnabled(true);

ui_.customSoundRadio->setEnabled(true);

ui_.soundFile->setText("");

ui_.soundFile->setEnabled(false);

ui_.soundFileButton->setEnabled(false);

if (action.playSound()) {

if (action.getSoundFile().empty()) {

ui_.defaultSoundRadio->setChecked(true);

} else {

ui_.customSoundRadio->setChecked(true);

ui_.soundFile->setText(P2QSTRING(action.getSoundFile()));

ui_.soundFile->setEnabled(true);

ui_.soundFileButton->setEnabled(true);

}

} else {

ui_.noSoundRadio->setChecked(true);

}

/* set radio button child option states */

setChildWidgetStates();

}

}

<item>

<widget class="QCheckBox" name="matchCase">

<property name="text">

<string>Keyword is case sensitive</string>

</property>

</widget>

</item>

</layout>

</widget>

</item>

<item>

<widget class="QGroupBox" name="groupBox_3">

<property name="sizePolicy">

<sizepolicy hsizetype="Minimum" vsizetype="Minimum">

<horstretch>0</horstretch>

<verstretch>0</verstretch>

</sizepolicy>

</property>

<property name="title">

<string>Highlight Action</string>

</property>

<layout class="QVBoxLayout" name="verticalLayout_5">

<item>

<layout class="QHBoxLayout" name="horizontalLayout_5">

<item>

<widget class="QRadioButton" name="noColorRadio">

<property name="text">

<string>No Highlight</string>

</property>

<property name="checked">

<bool>true</bool>

</property>

</widget>

</item>

<item>

<widget class="QRadioButton" name="customColorRadio">

<property name="text">

<string>Custom Color</string>

</property>

</widget>

</item>

<item>

<spacer name="horizontalSpacer_5">

<property name="orientation">

<enum>Qt::Horizontal</enum>

</property>

<property name="sizeHint" stdset="0">

<size>

<width>40</width>

<height>20</height>

</size>

</property>

</spacer>

</item>

</layout>

</item>

<item>

<layout class="QHBoxLayout" name="horizontalLayout_6">

<item>

<spacer name="horizontalSpacer_2">

<property name="orientation">

<enum>Qt::Horizontal</enum>

</property>

<property name="sizeHint" stdset="0">

<size>

<width>40</width>

<height>20</height>

</size>

</property>

</spacer>

QString imageStyle = showEmoticons_ ? "" : "style='display:none'";

result += "<span class='swift_emoticon_image' " + imageStyle + "><img src='" + P2QSTRING(emoticonPart->imagePath) + "'/></span><span class='swift_emoticon_text' " + textStyle + ">" + QtUtilities::htmlEscape(P2QSTRING(emoticonPart->alternativeText)) + "</span>";

continue;

}

if ((highlightPart = boost::dynamic_pointer_cast<ChatWindow::ChatHighlightingMessagePart>(part))) {

QString spanStart = getHighlightSpanStart(highlightPart->foregroundColor, highlightPart->backgroundColor);

result += spanStart + QtUtilities::htmlEscape(P2QSTRING(highlightPart->text)) + "</span>";

continue;

}

}

return result;

}

std::string QtWebKitChatView::addMessage(

const QString& 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,

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

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

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

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

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

addMessageBottom(boost::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, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

return addMessage(" *" + chatMessageToHTML(message) + "*", senderName, senderIsSelf, label, avatarPath, "font-style:italic ", time, highlight, 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;

}

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

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

addMessageBottom(boost::make_shared<SystemMessageSnippet>("<span class=\"error\">" + errorMessageHTML + "</span>", QDateTime::currentDateTime(), false, theme_, ChatSnippet::getDirection(errorMessage)));

previousMessageWasSelf_ = false;

previousMessageKind_ = PreviousMessageWasSystem;

}

void QtWebKitChatView::addSystemMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) {

if (window_->isWidgetSelected()) {

window_->onAllMessagesRead();

}

QString messageHTML = chatMessageToHTML(message);

addMessageBottom(boost::make_shared<SystemMessageSnippet>(messageHTML, QDateTime::currentDateTime(), false, theme_, getActualDirection(message, direction)));

previousMessageKind_ = PreviousMessageWasSystem;

}

void QtWebKitChatView::replaceWithAction(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

replaceMessage(" *" + chatMessageToHTML(message) + "*", id, time, "font-style:italic ", highlight);

}

void QtWebKitChatView::replaceMessage(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

replaceMessage(chatMessageToHTML(message), id, time, "", highlight);

}

void QtWebKitChatView::replaceMessage(const QString& message, const std::string& id, const boost::posix_time::ptime& time, const QString& style, const HighlightAction& highlight) {

if (!id.empty()) {

if (window_->isWidgetSelected()) {

window_->onAllMessagesRead();

}

QString messageHTML(message);

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

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

messageHTML = styleSpanStart + highlightSpanStart + messageHTML + highlightSpanEnd + styleSpanEnd;

replaceMessage(messageHTML, P2QSTRING(id), B2QDATE(time));

}

else {

std::cerr << "Trying to replace a message with no id";

}

}

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

if (window_->isWidgetSelected()) {

window_->onAllMessagesRead();

}

QString messageHTML = chatMessageToHTML(message);

addMessageBottom(boost::make_shared<SystemMessageSnippet>(messageHTML, QDateTime::currentDateTime(), false, theme_, getActualDirection(message, direction)));

previousMessageKind_ = PreviousMessageWasPresence;

}

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

replaceLastMessage(chatMessageToHTML(message), timestampBehaviour);

}

void QtWebKitChatView::addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct, bool isImpromptu, bool isContinuation) {

if (window_->isWidgetSelected()) {

window_->onAllMessagesRead();

}

QString message;

if (isImpromptu) {

message = QObject::tr("You've been invited to join a chat.") + "\n";

} else {

message = QObject::tr("You've been invited to enter the %1 room.").arg(P2QSTRING(jid.toString())) + "\n";

}