+ common_.paintContact(painter, option, nameColor, avatarPath, presenceIcon, name, statusText, false, item->getChat().unreadCount, compact_);

+ common_.paintContact(painter, option, nameColor, avatarPath, presenceIcon, name, statusText, false, item->getChat().unreadCount, compact_);

+

+ ChatListGroupItem(const QString& name, ChatListGroupItem* parent, bool sorted = true) : ChatListItem(parent), name_(name), sorted_(sorted) {}

+ void addItem(ChatListItem* item) {items_.push_back(item); if (sorted_) {qStableSort(items_.begin(), items_.end(), pointerItemLessThan);}}

+ void remove(int index) {items_.removeAt(index);}

+ int rowCount() {return items_.size();}

+ ChatListItem* item(int i) {return items_[i];}

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

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

+ void clear() {items_.clear();}

+ ChatListItem(ChatListGroupItem* parent) {parent_ = parent;}

+ ChatListGroupItem* parent() {return parent_;}

+ * Copyright (c) 2011-2013 Kevin Smith

+#include <Swiften/Base/Path.h>

+ case Qt::DisplayRole: return chat_.impromptuJIDs.empty() ? P2QSTRING(chat_.chatName) : P2QSTRING(chat_.getImpromptuTitle());

+ case AvatarRole: return QVariant(P2QSTRING(pathToString(chat_.avatarPath)));

+ StatusShowTypeRole = Qt::UserRole + 3,

+ IdleRole = Qt::UserRole + 4*/

+/*

+ * Copyright (c) 2013 Remko Tronçon

+ * Licensed under the GNU General Public License.

+ * See the COPYING file for more information.

+ */

+

+#include <Swiften/Base/Path.h>

+ case AvatarRole: return QVariant(P2QSTRING(pathToString(chat_.avatarPath)));

+ settings_ = settings;

+ * Copyright (c) 2010-2013 Kevin Smith

+#include <Swift/QtUI/ChatSnippet.h>

+

+#include <Swift/QtUI/QtSwiftUtil.h>

+QString ChatSnippet::directionToCSS(Direction direction) {

+ return direction == RTL ? QString("rtl") : QString("ltr");

+}

+

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

+ boost::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;

+ std::string text = "";

+ foreach (boost::shared_ptr<ChatWindow::ChatMessagePart> part, message.getParts()) {

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

+ text = textPart->text;

+ break;

+ }

+ }

+ return getDirection(text);

+}

+

+ChatSnippet::Direction ChatSnippet::getDirection(const std::string& message) {

+ return getDirection(P2QSTRING(message));

+}

+

+ChatSnippet::Direction ChatSnippet::getDirection(const QString& message) {

+ /*

+ for (int i = 0; i < message.size(); ++i) {

+ switch (message.at(i).direction()) {

+ case QChar::DirL:

+ case QChar::DirLRE:

+ case QChar::DirLRO:

+ return ChatSnippet::LTR;

+ case QChar::DirR:

+ case QChar::DirAL:

+ case QChar::DirRLE:

+ case QChar::DirRLO:

+ return ChatSnippet::RTL;

+ case QChar::DirEN:

+ case QChar::DirES:

+ case QChar::DirET:

+ case QChar::DirAN:

+ case QChar::DirCS:

+ case QChar::DirB:

+ case QChar::DirWS:

+ case QChar::DirON:

+ case QChar::DirS:

+ case QChar::DirPDF:

+ case QChar::DirNSM:

+ case QChar::DirBN:

+ break;

+ }

+ }

+ return ChatSnippet::LTR;

+ */

+ return message.isRightToLeft() ? ChatSnippet::RTL : ChatSnippet::LTR;

+}

+

+

+}

+ * Copyright (c) 2010-2013 Kevin Smith

+

+#include <Swiften/Base/foreach.h>

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

+#include <Swift/QtUI/QtChatTheme.h>

+

+ enum Direction {

+ RTL,

+ LTR

+ };

+

+ static Direction getDirection(const std::string& message);

+ static Direction getDirection(const ChatWindow::ChatMessage& message);

+ static Direction getDirection(const QString& message);

+

+ static QString directionToCSS(Direction direction);

+

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

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

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

+ case MUCInviteEventType: return mucInviteDelegate_.sizeHint(option, item);

+ assert(false);

+ return QSize();

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

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

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

+ case MUCInviteEventType: mucInviteDelegate_.paint(painter, option, item);break;

+ if (messageEvent) {

+ return MessageEventType;

+ }

+ if (subscriptionEvent) {

+ return SubscriptionEventType;

+ }

+ if (errorEvent) {

+ return ErrorEventType;

+ }

+ if (mucInviteEvent) {

+ return MUCInviteEventType;

+ }

+#include <QColor>

+ case Qt::TextColorRole: return QColor(active_ ? Qt::black : Qt::darkGray);

+ case Qt::BackgroundColorRole: return QColor(active_ ? Qt::white : Qt::lightGray);

+ boost::shared_ptr<StanzaEvent> getEvent() { return event_; }

+ * Copyright (c) 2010-2013 Remko Tronçon

+#include <Swiften/Base/Path.h>

+

+#include <Swift/QtUI/QtSwiftUtil.h>

+ msg << P2QSTRING(pathToString(imageScaler.getScaledImage(picture, 48))); // Icon to display

+ * Copyright (c) 2010 -2012 Remko Tronçon

+ virtual void purgeCallbacks() {}

+

+#ifndef Q_OS_MAC

+ * Copyright (c) 2010-2013 Kevin Smith

+MessageSnippet::MessageSnippet(const QString& message, const QString& sender, const QDateTime& time, const QString& iconURI, bool isIncoming, bool appendToPrevious, QtChatTheme* theme, const QString& id, Direction direction) : ChatSnippet(appendToPrevious) {

+ setContinuationFallbackSnippet(boost::shared_ptr<ChatSnippet>(new MessageSnippet(message, sender, time, iconURI, isIncoming, false, theme, id, direction)));

+ content_.replace("%direction%", directionToCSS(direction));

+ content_ = QString("<div id='%1'>%2</div>").arg(id).arg(content_);

+ * Copyright (c) 2010-2013 Kevin Smith

+ MessageSnippet(const QString& message, const QString& sender, const QDateTime& time, const QString& iconURI, bool isIncoming, bool appendToPrevious, QtChatTheme* theme, const QString& id, Direction direction);

+ }

+#ifndef Q_OS_MAC

+}

+}

+ * Copyright (c) 2011-2013 Remko Tronçon

+#include <Swiften/Base/Path.h>

+ if (!editable) {

+ return;

+ }

+ readByteArrayFromFile(data, stringToPath(Q2PSTRING(fileName)));

+ Q_PROPERTY(bool editable READ isEditable WRITE setEditable)

+ void setEditable(bool b) {

+ editable = b;

+ }

+

+ bool isEditable() const {

+ return editable;

+ }

+

+ bool editable;

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <QtBlockListEditorWindow.h>

+#include <ui_QtBlockListEditorWindow.h>

+

+#include <boost/bind.hpp>

+

+#include <QLineEdit>

+#include <QMovie>

+#include <QShortcut>

+#include <QStyledItemDelegate>

+#include <QValidator>

+

+#include <Swift/QtUI/QtUtilities.h>

+#include <Swiften/Client/ClientBlockListManager.h>

+#include <Swiften/Base/foreach.h>

+#include <Swift/QtUI/QtSwiftUtil.h>

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+

+class QtJIDValidator : public QValidator {

+ public:

+ QtJIDValidator(QObject* parent) : QValidator(parent) {}

+ virtual ~QtJIDValidator() {}

+ virtual QValidator::State validate(QString& input, int&) const {

+ return JID(Q2PSTRING(input)).isValid() ? Acceptable : Intermediate;

+ }

+};

+

+class QtJIDValidatedItemDelegate : public QItemDelegate {

+ public:

+ QtJIDValidatedItemDelegate(QObject* parent) : QItemDelegate(parent) {}

+ virtual ~QtJIDValidatedItemDelegate() {}

+

+ virtual QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem&, const QModelIndex&) const {

+ QLineEdit *editor = new QLineEdit(parent);

+ editor->setValidator(new QtJIDValidator(editor));

+ return editor;

+ }

+

+ void setEditorData(QWidget *editor, const QModelIndex &index) const {

+ QString value = index.model()->data(index, Qt::EditRole).toString();

+

+ QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);

+ lineEdit->setText(value);

+ }

+

+ void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const {

+ QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);

+ QString currentValue = lineEdit->text();

+ int pos = 0;

+ if (lineEdit->validator()->validate(currentValue, pos) == QValidator::Acceptable) {

+ model->setData(index, lineEdit->text(), Qt::EditRole);

+ } else {

+ model->setData(index, QString(), Qt::EditRole);

+ }

+ }

+

+ void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &/* index */) const {

+ editor->setGeometry(option.rect);

+ }

+};

+

+QtBlockListEditorWindow::QtBlockListEditorWindow() : QWidget(), ui(new Ui::QtBlockListEditorWindow) {

+ ui->setupUi(this);

+ new QShortcut(QKeySequence::Close, this, SLOT(close()));

+ ui->throbberLabel->setMovie(new QMovie(":/icons/throbber.gif", QByteArray(), this));

+

+ itemDelegate = new QtRemovableItemDelegate(style());

+

+ connect(ui->savePushButton, SIGNAL(clicked()), SLOT(applyChanges()));

+

+ ui->blockListTreeWidget->setColumnCount(2);

+ ui->blockListTreeWidget->header()->setStretchLastSection(false);

+ ui->blockListTreeWidget->header()->resizeSection(1, itemDelegate->sizeHint(QStyleOptionViewItem(), QModelIndex()).width());

+

+#if QT_VERSION >= 0x050000

+ ui->blockListTreeWidget->header()->setSectionResizeMode(0, QHeaderView::Stretch);

+#else

+ ui->blockListTreeWidget->header()->setResizeMode(0, QHeaderView::Stretch);

+#endif

+

+ ui->blockListTreeWidget->setHeaderHidden(true);

+ ui->blockListTreeWidget->setRootIsDecorated(false);

+ ui->blockListTreeWidget->setEditTriggers(QAbstractItemView::DoubleClicked);

+ ui->blockListTreeWidget->setItemDelegateForColumn(0, new QtJIDValidatedItemDelegate(this));

+ ui->blockListTreeWidget->setItemDelegateForColumn(1, itemDelegate);

+ connect(ui->blockListTreeWidget, SIGNAL(itemChanged(QTreeWidgetItem*,int)), SLOT(handleItemChanged(QTreeWidgetItem*,int)));

+

+ QTreeWidgetItem* item = new QTreeWidgetItem(QStringList("") << "");

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

+ ui->blockListTreeWidget->addTopLevelItem(item);

+}

+

+QtBlockListEditorWindow::~QtBlockListEditorWindow() {

+}

+

+void QtBlockListEditorWindow::show() {

+ QWidget::show();

+ QWidget::activateWindow();

+}

+

+void QtBlockListEditorWindow::handleItemChanged(QTreeWidgetItem *, int) {

+ bool hasEmptyRow = false;

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

+ foreach(QTreeWidgetItem* row, rows) {

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

+ hasEmptyRow = true;

+ }

+ }

+

+ if (!hasEmptyRow) {

+ QTreeWidgetItem* item = new QTreeWidgetItem(QStringList("") << "");

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

+ ui->blockListTreeWidget->addTopLevelItem(item);

+ }

+}

+

+void QtBlockListEditorWindow::applyChanges() {

+ onSetNewBlockList(getCurrentBlockList());

+}

+

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

+ ui->blockListTreeWidget->clear();

+

+ foreach(const JID& jid, blockedJIDs) {

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

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

+ ui->blockListTreeWidget->addTopLevelItem(item);

+ }

+ handleItemChanged(0,0);

+}

+

+void Swift::QtBlockListEditorWindow::setBusy(bool isBusy) {

+ if (isBusy) {

+ ui->throbberLabel->movie()->start();

+ ui->throbberLabel->show();

+ } else {

+ ui->throbberLabel->movie()->stop();

+ ui->throbberLabel->hide();

+ }

+}

+

+std::vector<JID> Swift::QtBlockListEditorWindow::getCurrentBlockList() const {

+ std::vector<JID> futureBlockedJIDs;

+

+ for(int i=0; i < ui->blockListTreeWidget->topLevelItemCount(); ++i) {

+ QTreeWidgetItem* row = ui->blockListTreeWidget->topLevelItem(i);

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

+ futureBlockedJIDs.push_back(JID(Q2PSTRING(row->text(0))));

+ }

+ }

+ return futureBlockedJIDs;

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swift/Controllers/UIInterfaces/BlockListEditorWidget.h>

+#include <Swift/QtUI/QtVCardWidget/QtRemovableItemDelegate.h>

+

+#include <QWidget>

+#include <QTreeWidgetItem>

+

+namespace Ui {

+ class QtBlockListEditorWindow;

+}

+

+namespace Swift {

+

+class QtBlockListEditorWindow : public QWidget, public BlockListEditorWidget {

+ Q_OBJECT

+

+ public:

+ QtBlockListEditorWindow();

+ virtual ~QtBlockListEditorWindow();

+

+ virtual void show();

+ virtual void setCurrentBlockList(const std::vector<JID>& blockedJIDs);

+ virtual void setBusy(bool isBusy);

+ virtual std::vector<JID> getCurrentBlockList() const;

+

+ private slots:

+ void handleItemChanged(QTreeWidgetItem*, int);

+ void applyChanges();

+

+ private:

+ Ui::QtBlockListEditorWindow* ui;

+ QtRemovableItemDelegate* itemDelegate;

+};

+

+}

+<?xml version="1.0" encoding="UTF-8"?>

+<ui version="4.0">

+ <class>QtBlockListEditorWindow</class>

+ <widget class="QWidget" name="QtBlockListEditorWindow">

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>348</width>

+ <height>262</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string>Edit Block List</string>

+ </property>

+ <layout class="QVBoxLayout" name="verticalLayout">

+ <property name="spacing">

+ <number>5</number>

+ </property>

+ <property name="margin">

+ <number>5</number>

+ </property>

+ <item>

+ <widget class="QTreeWidget" name="blockListTreeWidget">

+ <attribute name="headerVisible">

+ <bool>false</bool>

+ </attribute>

+ <column>

+ <property name="text">

+ <string notr="true">1</string>

+ </property>

+ </column>

+ </widget>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout">

+ <property name="sizeConstraint">

+ <enum>QLayout::SetDefaultConstraint</enum>

+ </property>

+ <item>

+ <spacer name="horizontalSpacer">

+ <property name="orientation">

+ <enum>Qt::Horizontal</enum>

+ </property>

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

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

+ <widget class="QLabel" name="errorLabel">

+ <property name="text">

+ <string/>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QLabel" name="throbberLabel">

+ <property name="text">

+ <string/>

+ </property>

+ <property name="alignment">

+ <set>Qt::AlignCenter</set>

+ </property>

+ <property name="textInteractionFlags">

+ <set>Qt::NoTextInteraction</set>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QPushButton" name="savePushButton">

+ <property name="text">

+ <string>Save</string>

+ </property>

+ <property name="default">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ <resources/>

+ <connections/>

+</ui>

+ * Copyright (c) 2010-2013 Remko Tronçon

+#include <Swiften/Base/Path.h>

+#include <Swift/QtUI/QtSwiftUtil.h>

+ boost::filesystem::path scaledImagePath(imagePath);

+ std::string suffix = "." + boost::lexical_cast<std::string>(size);

+ scaledImagePath = stringToPath(pathToString(scaledImagePath) + suffix);

+ QImage image(P2QSTRING(pathToString(imagePath)));

+ scaledImage.save(P2QSTRING(pathToString(scaledImagePath)), "PNG");

+ image.save(P2QSTRING(pathToString(scaledImagePath)), "PNG");

+QtChatTabs::QtChatTabs(bool singleWindow) : QWidget(), singleWindow_(singleWindow) {

+#ifndef Q_OS_MAC

+ if (!singleWindow_) {

+ hide();

+ }

+ else {

+ setWindowTitle("");

+ onTitleChanged("");

+ }

+ QRegExp hasTrailingGarbage("^(.[-\\w\\s,&]+)([^\\s\\,w].*)$");

+ case QtTabbable::NoActivity : tabTextColor = QColor(); break;

+ QString title = summary.getSummary(current, unreads).c_str();

+ setWindowTitle(title);

+ emit onTitleChanged(title);

+#ifndef Q_OS_MAC

+ QtChatTabs(bool singleWindow);

+ void onTitleChanged(const QString& title);

+ bool singleWindow_;

+ QString getHeader() const {return fileContents_[Header];}

+ QString getFooter() const {return fileContents_[Footer];}

+ QString getContent() const {return fileContents_[Content];}

+ QString getStatus() const {return fileContents_[Status];}

+ QString getTopic() const {return fileContents_[Topic];}

+ QString getFileTransferRequest() const {return fileContents_[FileTransferRequest];}

+ QString getIncomingContent() const {return fileContents_[IncomingContent];}

+ QString getIncomingNextContent() const {return fileContents_[IncomingNextContent];}

+ QString getIncomingContext() const {return fileContents_[IncomingContext];}

+ QString getIncomingNextContext() const {return fileContents_[IncomingNextContext];}

+ QString getOutgoingContent() const {return fileContents_[OutgoingContent];}

+ QString getOutgoingNextContent() const {return fileContents_[OutgoingNextContent];}

+ QString getOutgoingContext() const {return fileContents_[OutgoingContext];}

+ QString getOutgoingNextContext() const {return fileContents_[OutgoingNextContext];}

+ * Copyright (c) 2013 Kevin Smith

+#include <Swift/QtUI/QtChatView.h>

+QtChatView::QtChatView(QWidget* parent) : QWidget(parent) {

+QtChatView::~QtChatView() {

+

+ * Copyright (c) 2013 Kevin Smith

+#pragma once

+#include <string>

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

+#include <QWidget>

+ class HighlightAction;

+ class SecurityLabel;

+

+ Q_OBJECT

+ 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, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 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, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 0;

+

+ virtual void 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, const HighlightAction& highlight) = 0;

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

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

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

+

+ 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 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(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;

+ virtual void resizeFont(int fontSizeSteps) = 0;

+ virtual void scrollToBottom() = 0;

+ virtual void handleKeyPressEvent(QKeyEvent* event) = 0;

+ * Copyright (c) 2010-2013 Kevin Smith

+#include <Swift/QtUI/QtChatWindow.h>

+#include <boost/smart_ptr/make_shared.hpp>

+#include <QFileDialog>

+#include <QInputDialog>

+#include <QLabel>

+#include <QMenu>

+#include <QMessageBox>

+#include <QMimeData>

+#include <QPushButton>

+#include <QTextDocument>

+#include <QToolButton>

+

+#include <Swift/Controllers/Roster/ContactRosterItem.h>

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

+#include <Swift/Controllers/Roster/RosterItem.h>

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

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

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

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

+#include <SwifTools/TabComplete.h>

+#include <Swift/QtUI/Roster/QtOccupantListWidget.h>

+#include <Swift/QtUI/QtSettingsProvider.h>

+#include <Swift/QtUI/QtScaledAvatarCache.h>

+#include <Swift/QtUI/QtTextEdit.h>

+#include <Swift/QtUI/QtUISettingConstants.h>

+#include <Swift/QtUI/QtUtilities.h>

+#include <Swift/QtUI/QtWebKitChatView.h>

+namespace Swift {

+

+QtChatWindow::QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream, SettingsProvider* settings) : QtTabbable(), contact_(contact), eventStream_(eventStream), blockingState_(BlockingUnsupported), isMUC_(false), supportsImpromptuChat_(false) {

+ subjectLayout_ = new QBoxLayout(QBoxLayout::LeftToRight);

+ subjectLayout_->addWidget(subject_);

+ QPushButton* actionButton_ = new QPushButton(this);

+ layout->addLayout(subjectLayout_);

+ messageLog_ = new QtWebKitChatView(this, eventStream_, theme, this); // I accept that passing the ChatWindow in so that the view can call the signals is somewhat inelegant, but it saves a lot of boilerplate. This patch is unpleasant enough already. So let's fix this soon (it at least needs fixing by the time history is sorted), but not now.

+ input_ = new QtTextEdit(settings_, this);

+

+ // using an extra layout to work around Qt margin glitches on OS X

+ QHBoxLayout* actionLayout = new QHBoxLayout();

+ actionLayout->addWidget(actionButton_);

+

+ inputBarLayout->addLayout(actionLayout);

+ messageLog_->showEmoticons(settings_->getSetting(QtUISettingConstants::SHOW_EMOTICONS));

+ bool showEmoticons = settings_->getSetting(QtUISettingConstants::SHOW_EMOTICONS);

+ messageLog_->showEmoticons(showEmoticons);

+void QtChatWindow::convertToMUC(bool impromptuMUC) {

+ impromptu_ = impromptuMUC;

+ isMUC_ = true;

+ subject_->setVisible(!impromptu_);

+ if (!isMUC_) {

+ event->acceptProposedAction();

+ }

+ } else if (event->mimeData()->hasFormat("application/vnd.swift.contact-jid")) {

+ if (isMUC_ || supportsImpromptuChat_) {

+ event->acceptProposedAction();

+ }

+ if (event->mimeData()->hasUrls()) {

+ if (event->mimeData()->urls().size() == 1) {

+ onSendFileRequest(Q2PSTRING(event->mimeData()->urls().at(0).toLocalFile()));

+ } else {

+ std::string messageText(Q2PSTRING(tr("Sending of multiple files at once isn't supported at this time.")));

+ ChatMessage message;

+ message.append(boost::make_shared<ChatTextMessagePart>(messageText));

+ addSystemMessage(message, DefaultDirection);

+ }

+ } else if (event->mimeData()->hasFormat("application/vnd.swift.contact-jid")) {

+ QByteArray dataBytes = event->mimeData()->data("application/vnd.swift.contact-jid");

+ QDataStream dataStream(&dataBytes, QIODevice::ReadOnly);

+ QString jidString;

+ dataStream >> jidString;

+ onInviteToChat(std::vector<JID>(1, JID(Q2PSTRING(jidString))));

+ QAction* block = NULL;

+ QAction* unblock = NULL;

+

+ if (availableRoomActions_.empty()) {

+ if (blockingState_ == IsBlocked) {

+ unblock = contextMenu.addAction(tr("Unblock"));

+ } else if (blockingState_ == IsUnblocked) {

+ block = contextMenu.addAction(tr("Block"));

+ }

+

+ if (supportsImpromptuChat_) {

+ invite = contextMenu.addAction(tr("Invite person to this chat…"));

+ }

+

+ } else {

+ foreach(ChatWindow::RoomAction availableAction, availableRoomActions_)

+ if (impromptu_) {

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

+ if (availableAction == ChatWindow::ChangeSubject ||

+ availableAction == ChatWindow::Configure ||

+ availableAction == ChatWindow::Affiliations ||

+ availableAction == ChatWindow::Destroy) {

+ continue;

+ }

+ }

+ switch(availableAction)

+ {

+ case ChatWindow::ChangeSubject: changeSubject = contextMenu.addAction(tr("Change subject…")); break;

+ case ChatWindow::Configure: configure = contextMenu.addAction(tr("Configure room…")); break;

+ case ChatWindow::Affiliations: affiliations = contextMenu.addAction(tr("Edit affiliations…")); break;

+ case ChatWindow::Destroy: destroy = contextMenu.addAction(tr("Destroy room")); break;

+ case ChatWindow::Invite: invite = contextMenu.addAction(tr("Invite person to this room…")); break;

+ }

+ onInviteToChat(std::vector<JID>());

+ }

+ else if (result == block) {

+ onBlockUserRequest();

+ }

+ else if (result == unblock) {

+ onUnblockUserRequest();

+void QtChatWindow::setAvailableRoomActions(const std::vector<RoomAction>& actions) {

+void QtChatWindow::setBlockingState(BlockingState state) {

+ blockingState_ = state;

+}

+

+void QtChatWindow::setCanInitiateImpromptuChats(bool supportsImpromptu) {

+ supportsImpromptuChat_ = supportsImpromptu;

+}

+

+void QtChatWindow::handleAppendedToLog() {

+ if (lastLineTracker_.getShouldMoveLastLine()) {

+ /* should this be queued? */

+ messageLog_->addLastSeenLine();

+ }

+}

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

+ handleAppendedToLog();

+ messageLog_->addMUCInvitation(senderName, jid, reason, password, direct, isImpromptu, isContinuation);

+}

+std::string QtChatWindow::addMessage(const 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) {

+ handleAppendedToLog();

+ return messageLog_->addMessage(message, senderName, senderIsSelf, label, avatarPath, time, highlight);

+}

+std::string QtChatWindow::addAction(const 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) {

+ handleAppendedToLog();

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

+}

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

+ handleAppendedToLog();

+ 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, const HighlightAction& highlight) {

+ handleAppendedToLog();

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

+}

+

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

+ handleAppendedToLog();

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

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

+ handleAppendedToLog();

+ return messageLog_->addFileTransfer(senderName, senderIsSelf, filename, sizeInBytes);

+}

+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) {

+ messageLog_->replaceLastMessage(message);

+}

+

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

+}

+

+ * Copyright (c) 2010-2013 Kevin Smith

+#include <map>

+

+#include <QPointer>

+#include <QTextCursor>

+#include <QMap>

+

+#include <SwifTools/LastLineTracker.h>

+

+

+#include <Swift/QtUI/ChatSnippet.h>

+#include <Swift/QtUI/QtMUCConfigurationWindow.h>

+#include <Swift/QtUI/QtTabbable.h>

+ // FIXME: Move this to a different file

+ std::string formatSize(const boost::uintmax_t bytes);

+

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

+ std::string addMessage(const 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);

+ std::string addAction(const 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);

+

+ void 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, const HighlightAction& highlight);

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

+ void convertToMUC(bool impromptuMUC = false);

+ void replaceLastMessage(const ChatMessage& message);

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

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

+ void setBlockingState(BlockingState state);

+ virtual void setCanInitiateImpromptuChats(bool supportsImpromptu);

+

+ void handleAppendedToLog();

+

+ QBoxLayout* subjectLayout_;

+ BlockingState blockingState_;

+ bool impromptu_;

+ bool isMUC_;

+ bool supportsImpromptuChat_;

+#include <Swift/QtUI/QtChatWindowFactory.h>

+#include <Swift/QtUI/QtChatTabs.h>

+#include <Swift/QtUI/QtChatWindow.h>

+#include <Swift/QtUI/QtSwiftUtil.h>

+#include <Swift/QtUI/QtChatTheme.h>

+#include <Swift/QtUI/QtSingleWindow.h>

+

+QtChatWindowFactory::QtChatWindowFactory(QtSingleWindow* splitter, SettingsProvider* settings, QtSettingsProvider* qtSettings, QtChatTabs* tabs, const QString& themePath) : themePath_(themePath) {

+ QtChatWindow *chatWindow = new QtChatWindow(P2QSTRING(contact.toString()), theme_, eventStream, settings_);

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

+

+#include <Swiften/JID/JID.h>

+#include <Swift/QtUI/QtSettingsProvider.h>

+

+ class QtSingleWindow;

+ QtChatWindowFactory(QtSingleWindow* splitter, SettingsProvider* settings, QtSettingsProvider* qtSettings, QtChatTabs* tabs, const QString& themePath);

+ void buttonClicked(QString id, QString arg1, QString arg2, QString arg3, QString arg4, QString arg5);

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <QColorDialog>

+#include <QPainter>

+

+#include <Swift/QtUI/QtColorToolButton.h>

+

+namespace Swift {

+

+QtColorToolButton::QtColorToolButton(QWidget* parent) :

+ QToolButton(parent)

+{

+ connect(this, SIGNAL(clicked()), SLOT(onClicked()));

+ setColorIcon(Qt::transparent);

+}

+

+void QtColorToolButton::setColor(const QColor& color)

+{

+ if (color.isValid() != color_.isValid() || (color.isValid() && color != color_)) {

+ color_ = color;

+ setColorIcon(color_);

+ emit colorChanged(color_);

+ }

+}

+

+void QtColorToolButton::onClicked()

+{

+ QColor c = QColorDialog::getColor(color_, this);

+ if (c.isValid()) {

+ setColor(c);

+ }

+}

+

+void QtColorToolButton::setColorIcon(const QColor& color)

+{

+ QPixmap pix(iconSize());

+ pix.fill(color.isValid() ? color : Qt::transparent);

+ setIcon(pix);

+}

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QToolButton>

+

+namespace Swift {

+

+ class QtColorToolButton : public QToolButton {

+ Q_OBJECT

+ Q_PROPERTY(QColor color READ getColor WRITE setColor NOTIFY colorChanged)

+ public:

+ explicit QtColorToolButton(QWidget* parent = NULL);

+ void setColor(const QColor& color);

+ const QColor& getColor() const { return color_; }

+

+ signals:

+ void colorChanged(const QColor&);

+

+ private slots:

+ void onClicked();

+

+ private:

+ void setColorIcon(const QColor& color);

+ QColor color_;

+ };

+

+}

+#include "QtChatWindow.h" // for formatSize

+

+#include "QtSwiftUtil.h"

+ return QVariant(P2QSTRING(controller->getOtherParty().toString()));

+ switch(state.type) {

+ case FileTransfer::State::Initial:

+ assert(false);

+ return QVariant("");

+ return QVariant(P2QSTRING(formatSize((controller->getSize()))));

+ return createIndex(row, column, (void*) 0);

+ NoOfColumns

+/*

+ * Copyright (c) 2013 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+ return QVariant(P2QSTRING(formResult_->getReportedFields().at(section)->getLabel()));

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

+ }

+ else if (field->getType() == FormField::JIDMultiType) {

+ }

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

+ return boost::algorithm::join(field->getValues(), delimiter);

+ * Copyright (c) 2010-2013 Kevin Smith

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

+#include <boost/smart_ptr/make_shared.hpp>

+ listWidget->setSelectionMode(field->getType() == FormField::ListMultiType ? QAbstractItemView::MultiSelection : QAbstractItemView::SingleSelection);

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

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

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

+ selected.push_back(std::find(field->getValues().begin(), field->getValues().end(), text) != field->getValues().end());

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

+ checkWidget->setCheckState(field->getBoolValue() ? Qt::Checked : Qt::Unchecked);

+ if (field->getType() == FormField::FixedType) {

+ QString value = field->getFixedValue().c_str();

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

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

+ QString value = field->getTextMultiValue().c_str();

+ if (field->getType() == FormField::TextPrivateType) {

+ QString value = field->getTextPrivateValue().c_str();

+ if (field->getType() == FormField::TextSingleType) {

+ QString value = field->getTextSingleValue().c_str();

+ if (field->getType() == FormField::JIDSingleType) {

+ QString value = field->getJIDSingleValue().toString().c_str();

+ if (field->getType() == FormField::JIDMultiType) {

+ QString text = boost::join(field->getValues(), "\n").c_str();

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

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

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

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

+ if (field->getType() == FormField::FixedType || field->getType() == FormField::HiddenType) {

+ resultField->addValue(field->getValues().empty() ? "" : field->getValues()[0]);

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

+ resultField->addValue(field->getOptions()[i].value);

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

+ if (!string.isEmpty()) {

+ resultField->setTextMultiValue(Q2PSTRING(string));

+ if (field->getType() == FormField::TextPrivateType || field->getType() == FormField::TextSingleType || field->getType() == FormField::JIDSingleType) {

+ if (!string.isEmpty()) {

+ resultField->addValue(Q2PSTRING(string));

+ if (field->getType() == FormField::JIDMultiType) {

+ if (!string.isEmpty()) {

+ resultField->addValue(Q2PSTRING(line));

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

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

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <cassert>

+

+#include <Swift/QtUI/QtHighlightEditorWidget.h>

+#include <Swift/QtUI/QtHighlightRulesItemModel.h>

+

+namespace Swift {

+

+QtHighlightEditorWidget::QtHighlightEditorWidget(QWidget* parent)

+ : QWidget(parent)

+{

+ ui_.setupUi(this);

+

+ itemModel_ = new QtHighlightRulesItemModel(this);

+ ui_.treeView->setModel(itemModel_);

+ ui_.ruleWidget->setModel(itemModel_);

+

+ for (int i = 0; i < QtHighlightRulesItemModel::NumberOfColumns; ++i) {

+ switch (i) {

+ case QtHighlightRulesItemModel::ApplyTo:

+ case QtHighlightRulesItemModel::Sender:

+ case QtHighlightRulesItemModel::Keyword:

+ case QtHighlightRulesItemModel::Action:

+ ui_.treeView->showColumn(i);

+ break;

+ default:

+ ui_.treeView->hideColumn(i);

+ break;

+ }

+ }

+

+ setHighlightManager(NULL); // setup buttons for empty rules list

+

+ connect(ui_.treeView->selectionModel(), SIGNAL(currentRowChanged(QModelIndex,QModelIndex)), SLOT(onCurrentRowChanged(QModelIndex)));

+

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

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

+

+ connect(ui_.moveUpButton, SIGNAL(clicked()), SLOT(onMoveUpButtonClicked()));

+ connect(ui_.moveDownButton, SIGNAL(clicked()), SLOT(onMoveDownButtonClicked()));

+

+ connect(ui_.closeButton, SIGNAL(clicked()), SLOT(close()));

+

+ setWindowTitle(tr("Highlight Rules"));

+}

+

+QtHighlightEditorWidget::~QtHighlightEditorWidget()

+{

+}

+

+void QtHighlightEditorWidget::show()

+{

+ if (itemModel_->rowCount(QModelIndex())) {

+ selectRow(0);

+ }

+ QWidget::show();

+ QWidget::activateWindow();

+}

+

+void QtHighlightEditorWidget::setHighlightManager(HighlightManager* highlightManager)

+{

+ itemModel_->setHighlightManager(highlightManager);

+ ui_.newButton->setEnabled(highlightManager != NULL);

+

+ ui_.ruleWidget->setEnabled(false);

+ ui_.deleteButton->setEnabled(false);

+ ui_.moveUpButton->setEnabled(false);

+ ui_.moveDownButton->setEnabled(false);

+}

+

+void QtHighlightEditorWidget::closeEvent(QCloseEvent* event) {

+ ui_.ruleWidget->save();

+ event->accept();

+}

+

+void QtHighlightEditorWidget::onNewButtonClicked()

+{

+ int row = getSelectedRow() + 1;

+ itemModel_->insertRow(row, QModelIndex());

+ selectRow(row);

+}

+

+void QtHighlightEditorWidget::onDeleteButtonClicked()

+{

+ int row = getSelectedRow();

+ assert(row >= 0);

+

+ itemModel_->removeRow(row, QModelIndex());

+ if (row == itemModel_->rowCount(QModelIndex())) {

+ --row;

+ }

+ selectRow(row);

+}

+

+void QtHighlightEditorWidget::onMoveUpButtonClicked()

+{

+ int row = getSelectedRow();

+ assert(row > 0);

+

+ ui_.ruleWidget->save();

+ ui_.ruleWidget->setActiveIndex(QModelIndex());

+ itemModel_->swapRows(row, row - 1);

+ selectRow(row - 1);

+}

+

+void QtHighlightEditorWidget::onMoveDownButtonClicked()

+{

+ int row = getSelectedRow();

+ assert(row < itemModel_->rowCount(QModelIndex()) - 1);

+

+ ui_.ruleWidget->save();

+ ui_.ruleWidget->setActiveIndex(QModelIndex());

+ if (itemModel_->swapRows(row, row + 1)) {

+ selectRow(row + 1);

+ }

+}

+

+void QtHighlightEditorWidget::onCurrentRowChanged(const QModelIndex& index)

+{

+ ui_.ruleWidget->save();

+ ui_.ruleWidget->setActiveIndex(index);

+

+ ui_.ruleWidget->setEnabled(index.isValid());

+

+ ui_.deleteButton->setEnabled(index.isValid());

+

+ ui_.moveUpButton->setEnabled(index.isValid() && index.row() != 0);

+ ui_.moveDownButton->setEnabled(index.isValid() && index.row() != itemModel_->rowCount(QModelIndex()) - 1);

+}

+

+void QtHighlightEditorWidget::selectRow(int row)

+{

+ QModelIndex index = itemModel_->index(row, 0, QModelIndex());

+ ui_.treeView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);

+}

+

+/** Return index of selected row or -1 if none is selected */

+int QtHighlightEditorWidget::getSelectedRow() const

+{

+ QModelIndexList rows = ui_.treeView->selectionModel()->selectedRows();

+ return rows.isEmpty() ? -1 : rows[0].row();

+}

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swift/Controllers/UIInterfaces/HighlightEditorWidget.h>

+#include <Swift/QtUI/ui_QtHighlightEditorWidget.h>

+

+namespace Swift {

+

+ class QtHighlightRulesItemModel;

+

+ class QtHighlightEditorWidget : public QWidget, public HighlightEditorWidget {

+ Q_OBJECT

+

+ public:

+ QtHighlightEditorWidget(QWidget* parent = NULL);

+ virtual ~QtHighlightEditorWidget();

+

+ void show();

+

+ void setHighlightManager(HighlightManager* highlightManager);

+

+ private slots:

+ void onNewButtonClicked();

+ void onDeleteButtonClicked();

+ void onMoveUpButtonClicked();

+ void onMoveDownButtonClicked();

+ void onCurrentRowChanged(const QModelIndex&);

+

+ private:

+ virtual void closeEvent(QCloseEvent* event);

+

+ void selectRow(int row);

+ int getSelectedRow() const;

+

+ Ui::QtHighlightEditorWidget ui_;

+ QtHighlightRulesItemModel* itemModel_;

+ };

+

+}

+<?xml version="1.0" encoding="UTF-8"?>

+<ui version="4.0">

+ <class>QtHighlightEditorWidget</class>

+ <widget class="QWidget" name="QtHighlightEditorWidget">

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>419</width>

+ <height>373</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string>Form</string>

+ </property>

+ <layout class="QHBoxLayout" name="horizontalLayout">

+ <item>

+ <layout class="QVBoxLayout" name="verticalLayout_2">

+ <item>

+ <widget class="QLabel" name="label">

+ <property name="text">

+ <string>Incoming messages are checked against the following rules. First rule that matches will be executed.</string>

+ </property>

+ <property name="wordWrap">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QTreeView" name="treeView">

+ <property name="rootIsDecorated">

+ <bool>false</bool>

+ </property>

+ <property name="itemsExpandable">

+ <bool>false</bool>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ <item>

+ <widget class="Swift::QtHighlightRuleWidget" name="ruleWidget" native="true"/>

+ </item>

+ <item>

+ <layout class="QVBoxLayout" name="verticalLayout">

+ <item>

+ <widget class="QPushButton" name="newButton">

+ <property name="text">

+ <string>New</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QPushButton" name="deleteButton">

+ <property name="text">

+ <string>Delete</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <spacer name="verticalSpacer_2">

+ <property name="orientation">

+ <enum>Qt::Vertical</enum>

+ </property>

+ <property name="sizeType">

+ <enum>QSizePolicy::Fixed</enum>

+ </property>

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

+ <size>

+ <width>20</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

+ <widget class="QPushButton" name="moveUpButton">

+ <property name="text">

+ <string>Move up</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QPushButton" name="moveDownButton">

+ <property name="text">

+ <string>Move down</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <spacer name="verticalSpacer_3">

+ <property name="orientation">

+ <enum>Qt::Vertical</enum>

+ </property>

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

+ <size>

+ <width>20</width>

+ <height>40</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

+ <widget class="QPushButton" name="closeButton">

+ <property name="text">

+ <string>Close</string>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ <customwidgets>

+ <customwidget>

+ <class>Swift::QtHighlightRuleWidget</class>

+ <extends>QWidget</extends>

+ <header>QtHighlightRuleWidget.h</header>

+ <container>1</container>

+ </customwidget>

+ </customwidgets>

+ <resources/>

+ <connections/>

+</ui>

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <QDataWidgetMapper>

+#include <QStringListModel>

+#include <QFileDialog>

+

+#include <Swift/QtUI/QtHighlightRuleWidget.h>

+#include <Swift/QtUI/QtHighlightRulesItemModel.h>

+

+namespace Swift {

+

+QtHighlightRuleWidget::QtHighlightRuleWidget(QWidget* parent)

+ : QWidget(parent)

+{

+ ui_.setupUi(this);

+

+ QStringList applyToItems;

+ for (int i = 0; i < QtHighlightRulesItemModel::ApplyToEOL; ++i) {

+ applyToItems << QtHighlightRulesItemModel::getApplyToString(i);

+ }

+ QStringListModel * applyToModel = new QStringListModel(applyToItems, this);

+ ui_.applyTo->setModel(applyToModel);

+

+ connect(ui_.highlightText, SIGNAL(toggled(bool)), SLOT(onHighlightTextToggled(bool)));

+ connect(ui_.customColors, SIGNAL(toggled(bool)), SLOT(onCustomColorsToggled(bool)));

+ connect(ui_.playSound, SIGNAL(toggled(bool)), SLOT(onPlaySoundToggled(bool)));

+ connect(ui_.customSound, SIGNAL(toggled(bool)), SLOT(onCustomSoundToggled(bool)));

+ connect(ui_.soundFileButton, SIGNAL(clicked()), SLOT(onSoundFileButtonClicked()));

+

+ mapper_ = new QDataWidgetMapper(this);

+ hasValidIndex_ = false;

+ model_ = NULL;

+}

+

+QtHighlightRuleWidget::~QtHighlightRuleWidget()

+{

+}

+

+/** Widget does not gain ownership over the model */

+void QtHighlightRuleWidget::setModel(QtHighlightRulesItemModel* model)

+{

+ model_ = model;

+ mapper_->setModel(model_);

+}

+

+void QtHighlightRuleWidget::setActiveIndex(const QModelIndex& index)

+{

+ if (index.isValid()) {

+ if (!hasValidIndex_) {

+ mapper_->addMapping(ui_.applyTo, QtHighlightRulesItemModel::ApplyTo, "currentIndex");

+ mapper_->addMapping(ui_.senders, QtHighlightRulesItemModel::Sender, "plainText");

+ mapper_->addMapping(ui_.keywords, QtHighlightRulesItemModel::Keyword, "plainText");

+ mapper_->addMapping(ui_.nickIsKeyword, QtHighlightRulesItemModel::NickIsKeyword);

+ mapper_->addMapping(ui_.matchCase, QtHighlightRulesItemModel::MatchCase);

+ mapper_->addMapping(ui_.matchWholeWords, QtHighlightRulesItemModel::MatchWholeWords);

+ mapper_->addMapping(ui_.highlightText, QtHighlightRulesItemModel::HighlightText);

+ mapper_->addMapping(ui_.foreground, QtHighlightRulesItemModel::TextColor, "color");

+ mapper_->addMapping(ui_.background, QtHighlightRulesItemModel::TextBackground, "color");

+ mapper_->addMapping(ui_.playSound, QtHighlightRulesItemModel::PlaySound);

+ mapper_->addMapping(ui_.soundFile, QtHighlightRulesItemModel::SoundFile);

+ }

+ mapper_->setCurrentModelIndex(index);

+ ui_.customColors->setChecked(ui_.foreground->getColor().isValid() || ui_.background->getColor().isValid());

+ ui_.customSound->setChecked(!ui_.soundFile->text().isEmpty());

+ ui_.applyTo->focusWidget();

+ } else {

+ if (hasValidIndex_) {

+ mapper_->clearMapping();

+ }

+ }

+

+ hasValidIndex_ = index.isValid();

+}

+

+void QtHighlightRuleWidget::onCustomColorsToggled(bool enabled)

+{

+ if (!enabled) {

+ ui_.foreground->setColor(QColor());

+ ui_.background->setColor(QColor());

+ }

+ ui_.foreground->setEnabled(enabled);

+ ui_.background->setEnabled(enabled);

+}

+

+void QtHighlightRuleWidget::onCustomSoundToggled(bool enabled)

+{

+ if (enabled) {

+ if (ui_.soundFile->text().isEmpty()) {

+ onSoundFileButtonClicked();

+ }

+ } else {

+ ui_.soundFile->clear();

+ }

+ ui_.soundFile->setEnabled(enabled);

+ ui_.soundFileButton->setEnabled(enabled);

+}

+

+void QtHighlightRuleWidget::onSoundFileButtonClicked()

+{

+ QString s = QFileDialog::getOpenFileName(this, tr("Choose sound file"), QString(), tr("Sound files (*.wav)"));

+ if (!s.isEmpty()) {

+ ui_.soundFile->setText(s);

+ }

+}

+

+void QtHighlightRuleWidget::onHighlightTextToggled(bool enabled)

+{

+ ui_.customColors->setEnabled(enabled);

+}

+

+void QtHighlightRuleWidget::onPlaySoundToggled(bool enabled)

+{

+ ui_.customSound->setEnabled(enabled);

+}

+

+void QtHighlightRuleWidget::save()

+{

+ if (hasValidIndex_) {

+ mapper_->submit();

+ }

+}

+

+void QtHighlightRuleWidget::revert()

+{

+ if (hasValidIndex_) {

+ mapper_->revert();

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QWidget>

+#include <QModelIndex>

+

+#include <Swift/QtUI/ui_QtHighlightRuleWidget.h>

+

+class QDataWidgetMapper;

+

+namespace Swift {

+

+ class QtHighlightRulesItemModel;

+

+ class QtHighlightRuleWidget : public QWidget

+ {

+ Q_OBJECT

+

+ public:

+ explicit QtHighlightRuleWidget(QWidget* parent = NULL);

+ ~QtHighlightRuleWidget();

+

+ void setModel(QtHighlightRulesItemModel* model);

+

+ public slots:

+ void setActiveIndex(const QModelIndex&);

+ void save();

+ void revert();

+

+ private slots:

+ void onHighlightTextToggled(bool);

+ void onCustomColorsToggled(bool);

+ void onPlaySoundToggled(bool);

+ void onCustomSoundToggled(bool);

+ void onSoundFileButtonClicked();

+

+ private:

+ QDataWidgetMapper * mapper_;

+ QtHighlightRulesItemModel * model_;

+ bool hasValidIndex_;

+ Ui::QtHighlightRuleWidget ui_;

+ };

+

+}

+<?xml version="1.0" encoding="UTF-8"?>

+<ui version="4.0">

+ <class>QtHighlightRuleWidget</class>

+ <widget class="QWidget" name="QtHighlightRuleWidget">

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>361</width>

+ <height>524</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string>Form</string>

+ </property>

+ <layout class="QVBoxLayout" name="verticalLayout_2">

+ <item>

+ <widget class="QGroupBox" name="groupBox">

+ <property name="title">

+ <string>Rule conditions</string>

+ </property>

+ <layout class="QFormLayout" name="formLayout">

+ <property name="fieldGrowthPolicy">

+ <enum>QFormLayout::ExpandingFieldsGrow</enum>

+ </property>

+ <item row="0" column="0" colspan="2">

+ <widget class="QLabel" name="label">

+ <property name="text">

+ <string>Choose when this rule should be applied.

+If you want to provide more than one sender or keyword, input them in separate lines.</string>

+ </property>

+ <property name="wordWrap">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item row="1" column="0" colspan="2">

+ <widget class="Line" name="line">

+ <property name="orientation">

+ <enum>Qt::Horizontal</enum>

+ </property>

+ </widget>

+ </item>

+ <item row="2" column="0">

+ <widget class="QLabel" name="label_2">

+ <property name="text">

+ <string>&amp;Apply to:</string>

+ </property>

+ <property name="buddy">

+ <cstring>applyTo</cstring>

+ </property>

+ </widget>

+ </item>

+ <item row="2" column="1">

+ <widget class="QComboBox" name="applyTo"/>

+ </item>

+ <item row="3" column="0">

+ <widget class="QLabel" name="label_3">

+ <property name="text">

+ <string>&amp;Senders:</string>

+ </property>

+ <property name="buddy">

+ <cstring>senders</cstring>

+ </property>

+ </widget>

+ </item>

+ <item row="3" column="1">

+ <widget class="QPlainTextEdit" name="senders"/>

+ </item>

+ <item row="4" column="0">

+ <widget class="QLabel" name="label_4">

+ <property name="text">

+ <string>&amp;Keywords:</string>

+ </property>

+ <property name="buddy">

+ <cstring>keywords</cstring>

+ </property>

+ </widget>

+ </item>

+ <item row="4" column="1">

+ <widget class="QPlainTextEdit" name="keywords"/>

+ </item>

+ <item row="5" column="1">

+ <widget class="QCheckBox" name="nickIsKeyword">

+ <property name="text">

+ <string>Treat &amp;nick as a keyword (in MUC)</string>

+ </property>

+ </widget>

+ </item>

+ <item row="6" column="1">

+ <widget class="QCheckBox" name="matchWholeWords">

+ <property name="text">

+ <string>Match whole &amp;words</string>

+ </property>

+ </widget>

+ </item>

+ <item row="7" column="1">

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

+ <property name="text">

+ <string>Match &amp;case</string>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </widget>

+ </item>

+ <item>

+ <widget class="QGroupBox" name="groupBox_2">

+ <property name="title">

+ <string>Actions</string>

+ </property>

+ <layout class="QVBoxLayout" name="verticalLayout">

+ <item>

+ <widget class="QCheckBox" name="highlightText">

+ <property name="text">

+ <string>&amp;Highlight text</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout">

+ <item>

+ <spacer name="horizontalSpacer">

+ <property name="orientation">

+ <enum>Qt::Horizontal</enum>

+ </property>

+ <property name="sizeType">

+ <enum>QSizePolicy::Fixed</enum>

+ </property>

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

+ <size>

+ <width>28</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

+ <widget class="QCheckBox" name="customColors">

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="text">

+ <string>Custom c&amp;olors:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="Swift::QtColorToolButton" name="foreground">

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="text">

+ <string>&amp;Foreground</string>

+ </property>

+ <property name="toolButtonStyle">

+ <enum>Qt::ToolButtonTextBesideIcon</enum>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="Swift::QtColorToolButton" name="background">

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="text">

+ <string>&amp;Background</string>

+ </property>

+ <property name="toolButtonStyle">

+ <enum>Qt::ToolButtonTextBesideIcon</enum>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ <item>

+ <widget class="QCheckBox" name="playSound">

+ <property name="text">

+ <string>&amp;Play sound</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout_2">

+ <item>

+ <spacer name="horizontalSpacer_2">

+ <property name="orientation">

+ <enum>Qt::Horizontal</enum>

+ </property>

+ <property name="sizeType">

+ <enum>QSizePolicy::Fixed</enum>

+ </property>

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

+ <size>

+ <width>28</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

+ <widget class="QCheckBox" name="customSound">

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="text">

+ <string>Custom soun&amp;d:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QLineEdit" name="soundFile">

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="readOnly">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QToolButton" name="soundFileButton">

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="text">

+ <string>...</string>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ </item>

+ <item>

+ <spacer name="verticalSpacer">

+ <property name="orientation">

+ <enum>Qt::Vertical</enum>

+ </property>

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

+ <size>

+ <width>20</width>

+ <height>101</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ </layout>

+ </widget>

+ <customwidgets>

+ <customwidget>

+ <class>Swift::QtColorToolButton</class>

+ <extends>QToolButton</extends>

+ <header>QtColorToolButton.h</header>

+ </customwidget>

+ </customwidgets>

+ <resources/>

+ <connections/>

+</ui>

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+#include <boost/lambda/lambda.hpp>

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

+

+#include <QStringList>

+#include <QColor>

+

+#include <Swift/Controllers/HighlightManager.h>

+#include <Swift/QtUI/QtHighlightRulesItemModel.h>

+#include <Swift/QtUI/QtSwiftUtil.h>

+

+namespace Swift {

+

+QtHighlightRulesItemModel::QtHighlightRulesItemModel(QObject* parent) : QAbstractItemModel(parent), highlightManager_(NULL)

+{

+}

+

+void QtHighlightRulesItemModel::setHighlightManager(HighlightManager* highlightManager)

+{

+ emit layoutAboutToBeChanged();

+ highlightManager_ = highlightManager;

+ emit layoutChanged();

+}

+

+QVariant QtHighlightRulesItemModel::headerData(int section, Qt::Orientation /* orientation */, int role) const

+{

+ if (role == Qt::DisplayRole) {

+ switch (section) {

+ case ApplyTo: return QVariant(tr("Apply to"));

+ case Sender: return QVariant(tr("Sender"));

+ case Keyword: return QVariant(tr("Keyword"));

+ case Action: return QVariant(tr("Action"));

+ case NickIsKeyword: return QVariant(tr("Nick Is Keyword"));

+ case MatchCase: return QVariant(tr("Match Case"));

+ case MatchWholeWords: return QVariant(tr("Match Whole Words"));

+ case HighlightText: return QVariant(tr("Highlight Text"));

+ case TextColor: return QVariant(tr("Text Color"));

+ case TextBackground: return QVariant(tr("Text Background"));

+ case PlaySound: return QVariant(tr("Play Sounds"));

+ case SoundFile: return QVariant(tr("Sound File"));

+ }

+ }

+

+ return QVariant();

+}

+

+int QtHighlightRulesItemModel::columnCount(const QModelIndex& /* parent */) const

+{

+ return NumberOfColumns;

+}

+

+QVariant QtHighlightRulesItemModel::data(const QModelIndex &index, int role) const

+{

+ if (index.isValid() && highlightManager_ && (role == Qt::DisplayRole || role == Qt::EditRole)) {

+

+ const char* separator = (role == Qt::DisplayRole) ? " ; " : "\n";

+

+ if (boost::numeric_cast<std::vector<std::string>::size_type>(index.row()) < highlightManager_->getRules().size()) {

+ const HighlightRule& r = highlightManager_->getRules()[index.row()];

+ switch (index.column()) {

+ case ApplyTo: {

+ int applyTo = 0;

+ if (r.getMatchChat() && r.getMatchMUC()) {

+ applyTo = 1;

+ } else if (r.getMatchChat()) {

+ applyTo = 2;

+ } else if (r.getMatchMUC()) {

+ applyTo = 3;

+ }

+

+ if (role == Qt::DisplayRole) {

+ return QVariant(getApplyToString(applyTo));

+ } else {

+ return QVariant(applyTo);

+ }

+ }

+ case Sender: {

+ std::string s = boost::join(r.getSenders(), separator);

+ return QVariant(P2QSTRING(s));

+ }

+ case Keyword: {

+ std::string s = boost::join(r.getKeywords(), separator);

+ QString qs(P2QSTRING(s));

+ if (role == Qt::DisplayRole && r.getNickIsKeyword()) {

+ qs = tr("<nick>") + (qs.isEmpty() ? "" : separator + qs);

+ }

+ return QVariant(qs);

+ }

+ case Action: {

+ std::vector<std::string> v;

+ const HighlightAction & action = r.getAction();

+ if (action.highlightText()) {

+ v.push_back(Q2PSTRING(tr("Highlight text")));

+ }

+ if (action.playSound()) {

+ v.push_back(Q2PSTRING(tr("Play sound")));

+ }

+ std::string s = boost::join(v, separator);

+ return QVariant(P2QSTRING(s));

+ }

+ case NickIsKeyword: {

+ return QVariant(r.getNickIsKeyword());

+ }

+ case MatchCase: {

+ return QVariant(r.getMatchCase());

+ }

+ case MatchWholeWords: {

+ return QVariant(r.getMatchWholeWords());

+ }

+ case HighlightText: {

+ return QVariant(r.getAction().highlightText());

+ }

+ case TextColor: {

+ return QVariant(QColor(P2QSTRING(r.getAction().getTextColor())));

+ }

+ case TextBackground: {

+ return QVariant(QColor(P2QSTRING(r.getAction().getTextBackground())));

+ }

+ case PlaySound: {

+ return QVariant(r.getAction().playSound());

+ }

+ case SoundFile: {

+ return QVariant(P2QSTRING(r.getAction().getSoundFile()));

+ }

+ }

+ }

+ }

+ return QVariant();

+}

+

+bool QtHighlightRulesItemModel::setData(const QModelIndex &index, const QVariant &value, int role)

+{

+ if (index.isValid() && highlightManager_ && role == Qt::EditRole) {

+ if (boost::numeric_cast<std::vector<std::string>::size_type>(index.row()) < highlightManager_->getRules().size()) {

+ HighlightRule r = highlightManager_->getRule(index.row());

+ std::vector<int> changedColumns;

+ switch (index.column()) {

+ case ApplyTo: {

+ bool ok = false;

+ int applyTo = value.toInt(&ok);

+ if (!ok) {

+ return false;

+ }

+ r.setMatchChat(applyTo == ApplyToAll || applyTo == ApplyToChat);

+ r.setMatchMUC(applyTo == ApplyToAll || applyTo == ApplyToMUC);

+ break;

+ }

+ case Sender:

+ case Keyword: {

+ std::string s = Q2PSTRING(value.toString());

+ std::vector<std::string> v;

+ boost::split(v, s, boost::is_any_of("\n"));

+ v.erase(std::remove_if(v.begin(), v.end(), boost::lambda::_1 == ""), v.end());

+ if (index.column() == Sender) {

+ r.setSenders(v);

+ } else {

+ r.setKeywords(v);

+ }

+ break;

+ }

+ case NickIsKeyword: {

+ r.setNickIsKeyword(value.toBool());

+ changedColumns.push_back(Keyword); // "<nick>"

+ break;

+ }

+ case MatchCase: {

+ r.setMatchCase(value.toBool());

+ break;

+ }

+ case MatchWholeWords: {

+ r.setMatchWholeWords(value.toBool());

+ break;

+ }

+ case HighlightText: {

+ r.getAction().setHighlightText(value.toBool());

+ changedColumns.push_back(Action);

+ break;

+ }

+ case TextColor: {

+ QColor c = value.value<QColor>();

+ r.getAction().setTextColor(c.isValid() ? Q2PSTRING(c.name()) : "");

+ break;

+ }

+ case TextBackground: {

+ QColor c = value.value<QColor>();

+ r.getAction().setTextBackground(c.isValid() ? Q2PSTRING(c.name()) : "");

+ break;

+ }

+ case PlaySound: {

+ r.getAction().setPlaySound(value.toBool());

+ changedColumns.push_back(Action);

+ break;

+ }

+ case SoundFile: {

+ r.getAction().setSoundFile(Q2PSTRING(value.toString()));

+ break;

+ }

+ }

+

+ highlightManager_->setRule(index.row(), r);

+ emit dataChanged(index, index);

+ foreach (int column, changedColumns) {

+ QModelIndex i = createIndex(index.row(), column, (void*) 0);

+ emit dataChanged(i, i);

+ }

+ }

+ }

+

+ return false;

+}

+

+QModelIndex QtHighlightRulesItemModel::parent(const QModelIndex& /* child */) const

+{

+ return QModelIndex();

+}

+

+int QtHighlightRulesItemModel::rowCount(const QModelIndex& /* parent */) const

+{

+ return highlightManager_ ? highlightManager_->getRules().size() : 0;

+}

+

+QModelIndex QtHighlightRulesItemModel::index(int row, int column, const QModelIndex& /* parent */) const

+{

+ return createIndex(row, column, (void*) 0);

+}

+

+bool QtHighlightRulesItemModel::insertRows(int row, int count, const QModelIndex& /* parent */)

+{

+ if (highlightManager_) {

+ beginInsertRows(QModelIndex(), row, row + count);

+ while (count--) {

+ highlightManager_->insertRule(row, HighlightRule());

+ }

+ endInsertRows();

+ return true;

+ }

+ return false;

+}

+

+bool QtHighlightRulesItemModel::removeRows(int row, int count, const QModelIndex& /* parent */)

+{

+ if (highlightManager_) {

+ beginRemoveRows(QModelIndex(), row, row + count);

+ while (count--) {

+ highlightManager_->removeRule(row);

+ }

+ endRemoveRows();

+ return true;

+ }

+ return false;

+}

+

+bool QtHighlightRulesItemModel::swapRows(int row1, int row2)

+{

+ if (highlightManager_) {

+ assert(row1 >= 0 && row2 >= 0 && boost::numeric_cast<std::vector<std::string>::size_type>(row1) < highlightManager_->getRules().size() && boost::numeric_cast<std::vector<std::string>::size_type>(row2) < highlightManager_->getRules().size());

+ HighlightRule r = highlightManager_->getRule(row1);

+ highlightManager_->setRule(row1, highlightManager_->getRule(row2));

+ highlightManager_->setRule(row2, r);

+ emit dataChanged(index(row1, 0, QModelIndex()), index(row1, 0, QModelIndex()));

+ emit dataChanged(index(row2, 0, QModelIndex()), index(row2, 0, QModelIndex()));

+ return true;

+ }

+ return false;

+}

+

+QString QtHighlightRulesItemModel::getApplyToString(int applyTo)

+{

+ switch (applyTo) {

+ case ApplyToNone: return tr("None");

+ case ApplyToAll: return tr("Chat or MUC");

+ case ApplyToChat: return tr("Chat");

+ case ApplyToMUC: return tr("MUC");

+ default: return "";

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QAbstractItemModel>

+

+namespace Swift {

+

+ class HighlightManager;

+

+ class QtHighlightRulesItemModel : public QAbstractItemModel {

+ Q_OBJECT

+

+ public:

+ QtHighlightRulesItemModel(QObject* parent = NULL);

+

+ void setHighlightManager(HighlightManager* highlightManager);

+

+ QVariant headerData(int section, Qt::Orientation orientation, int role) const;

+ int columnCount(const QModelIndex& parent) const;

+ QVariant data(const QModelIndex& index, int role) const;

+ bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);

+ QModelIndex parent(const QModelIndex& child) const;

+ int rowCount(const QModelIndex& parent) const;

+ QModelIndex index(int row, int column, const QModelIndex& parent) const;

+ bool insertRows(int row, int count, const QModelIndex& parent = QModelIndex());

+ bool removeRows(int row, int count, const QModelIndex& parent = QModelIndex());

+ bool swapRows(int row1, int row2);

+

+ static QString getApplyToString(int);

+

+ enum Columns {

+ ApplyTo = 0,

+ Sender,

+ Keyword,

+ Action,

+ NickIsKeyword,

+ MatchCase,

+ MatchWholeWords,

+ HighlightText,

+ TextColor,

+ TextBackground,

+ PlaySound,

+ SoundFile,

+ NumberOfColumns // end of list marker

+ };

+

+ enum ApplyToValues {

+ ApplyToNone = 0,

+ ApplyToAll,

+ ApplyToChat,

+ ApplyToMUC,

+ ApplyToEOL // end of list marker

+ };

+

+ private:

+ HighlightManager* highlightManager_;

+ };

+

+}

+ * Copyright (c) 2012-2013 Catalin Badea

+/*

+ * Copyright (c) 2013 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <boost/date_time/gregorian/gregorian.hpp>

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

+#include <boost/smart_ptr/make_shared.hpp>

+#include <Swiften/History/HistoryMessage.h>

+

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

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

+

+#include <Swift/QtUI/QtSwiftUtil.h>

+#include <Swift/QtUI/MessageSnippet.h>

+#include <Swift/QtUI/QtScaledAvatarCache.h>

+#include <Swift/QtUI/ChatSnippet.h>

+#include <Swift/QtUI/QtUtilities.h>

+#include <Swift/QtUI/Roster/QtTreeWidget.h>

+#include <Swift/QtUI/QtWebKitChatView.h>

+ conversation_ = new QtWebKitChatView(NULL, NULL, theme_, this, true); // Horrible unsafe. Do not do this. FIXME

+ messageHTML = QtUtilities::htmlEscape(messageHTML);

+ conversation_->addMessageTop(boost::shared_ptr<ChatSnippet>(new MessageSnippet(messageHTML, QtUtilities::htmlEscape(P2QSTRING(senderName)), qTime, qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id), ChatSnippet::getDirection(message))));

+ conversation_->addMessageBottom(boost::make_shared<MessageSnippet>(messageHTML, QtUtilities::htmlEscape(P2QSTRING(senderName)), qTime, qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id), ChatSnippet::getDirection(message)));

+ onScrollReachedTop(boost::gregorian::date(boost::numeric_cast<unsigned short>(year), boost::numeric_cast<unsigned short>(month), boost::numeric_cast<unsigned short>(day)));

+ onScrollReachedBottom(boost::gregorian::date(boost::numeric_cast<unsigned short>(year), boost::numeric_cast<unsigned short>(month), boost::numeric_cast<unsigned short>(day)));

+ onCalendarClicked(boost::gregorian::date(boost::numeric_cast<unsigned short>(year), boost::numeric_cast<unsigned short>(month), boost::numeric_cast<unsigned short>(day)));

+ return boost::gregorian::date(boost::numeric_cast<unsigned short>(year), boost::numeric_cast<unsigned short>(month), boost::numeric_cast<unsigned short>(day));

+/*

+ * Copyright (c) 2013 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+

+#include <Swift/Controllers/UIInterfaces/HistoryWindow.h>

+

+#include <Swift/QtUI/QtTabbable.h>

+

+#include <Swift/QtUI/ui_QtHistoryWindow.h>

+

+ class QtTabbable;

+ class QtTreeWidget;

+ class QtWebKitChatView;

+ class QtChatTheme;

+ class SettingsProvider;

+ class UIEventStream;

+

+ QtWebKitChatView* conversation_;

+ <item row="1" column="1" colspan="2">

+ <widget class="QLineEdit" name="nickName"/>

+ </item>

+#include <Swift/Controllers/UIEvents/RequestHighlightEditorUIEvent.h>

+#ifndef Q_OS_MAC

+ highlightEditorAction_ = new QAction(tr("&Edit Highlight Rules"), this);

+ connect(highlightEditorAction_, SIGNAL(triggered()), SLOT(handleShowHighlightEditor()));

+ generalMenu_->addAction(highlightEditorAction_);

+

+void QtLoginWindow::handleShowHighlightEditor() {

+ uiEventStream_->send(boost::make_shared<RequestHighlightEditorUIEvent>());

+}

+

+ void handleShowHighlightEditor();

+ QAction* highlightEditorAction_;

+#include <Swift/Controllers/UIEvents/RequestBlockListDialogUIEvent.h>

+QtMainWindow::QtMainWindow(SettingsProvider* settings, UIEventStream* uiEventStream, QtLoginWindow::QtMenus loginMenus, StatusCache* statusCache, bool emoticonsExist) : QWidget(), MainWindow(false), loginMenus_(loginMenus) {

+ meView_ = new QtRosterHeader(settings, statusCache, this);

+

+ compactRosterAction_ = new QAction(tr("&Compact Roster"), this);

+ compactRosterAction_->setCheckable(true);

+ compactRosterAction_->setChecked(false);

+ connect(compactRosterAction_, SIGNAL(toggled(bool)), SLOT(handleCompactRosterToggled(bool)));

+ viewMenu->addAction(compactRosterAction_);

+ handleCompactRosterToggled(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+

+ openBlockingListEditor_ = new QAction(tr("Edit &Blocking List…"), this);

+ connect(openBlockingListEditor_, SIGNAL(triggered()), SLOT(handleEditBlockingList()));

+ actionsMenu->addAction(openBlockingListEditor_);

+ openBlockingListEditor_->setVisible(false);

+ addUserAction_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_D));

+ chatUserAction_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_N));

+void QtMainWindow::handleEditBlockingList() {

+ uiEventStream_->send(boost::make_shared<RequestBlockListDialogUIEvent>());

+}

+

+ if (settingPath == QtUISettingConstants::COMPACT_ROSTER.getKey()) {

+ handleCompactRosterToggled(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+ }

+}

+

+void QtMainWindow::handleCompactRosterToggled(bool state) {

+ settings_->storeSetting(QtUISettingConstants::COMPACT_ROSTER, state);

+ compactRosterAction_->setChecked(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+void QtMainWindow::setBlockingCommandAvailable(bool isAvailable) {

+ openBlockingListEditor_->setVisible(isAvailable);

+}

+

+ class StatusCache;

+ QtMainWindow(SettingsProvider*, UIEventStream* eventStream, QtLoginWindow::QtMenus loginMenus, StatusCache* statusCache, bool emoticonsExist);

+ void setBlockingCommandAvailable(bool isAvailable);

+ void handleCompactRosterToggled(bool);

+ void handleEditBlockingList();

+ QAction* compactRosterAction_;

+ QAction* openBlockingListEditor_;

+ ShowJID

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "ui_QtProfileWindow.h"

+#include <QCloseEvent>

+#include <QShortcut>

+#include <QTextDocument>

+#include <Swift/QtUI/QtSwiftUtil.h>

+#include <Swift/QtUI/QtUtilities.h>

+QtProfileWindow::QtProfileWindow() :

+ QWidget(),

+ ui(new Ui::QtProfileWindow) {

+ ui->setupUi(this);

+ new QShortcut(QKeySequence::Close, this, SLOT(close()));

+ ui->throbberLabel->setMovie(new QMovie(":/icons/throbber.gif", QByteArray(), this));

+ connect(ui->savePushButton, SIGNAL(clicked()), SLOT(handleSave()));

+ setEditable(false);

+ setAttribute(Qt::WA_DeleteOnClose);

+}

+QtProfileWindow::~QtProfileWindow() {

+ delete ui;

+}

+void QtProfileWindow::setJID(const JID& jid) {

+ this->jid = jid;

+ updateTitle();

+void QtProfileWindow::setVCard(VCard::ref vcard) {

+ ui->vcard->setVCard(vcard);

+ ui->vcard->setEnabled(b);

+ ui->savePushButton->setEnabled(b);

+}

+

+void QtProfileWindow::setEditable(bool b) {

+ ui->throbberLabel->setVisible(b);

+ ui->errorLabel->setVisible(b);

+ ui->savePushButton->setVisible(b);

+ ui->vcard->setEditable(b);

+ updateTitle();

+ ui->throbberLabel->movie()->start();

+ ui->throbberLabel->show();

+ ui->throbberLabel->hide();

+ ui->throbberLabel->movie()->stop();

+ }

+}

+

+void QtProfileWindow::setError(const std::string& error) {

+ if (!error.empty()) {

+ ui->errorLabel->setText("<font color='red'>" + QtUtilities::htmlEscape(P2QSTRING(error)) + "</font>");

+ }

+ else {

+ ui->errorLabel->setText("");

+void QtProfileWindow::updateTitle() {

+ QString jidString;

+ if (jid.isValid()) {

+ jidString = QString(" ( %1 )").arg(P2QSTRING(jid.toString()));

+

+ if (ui->vcard->isEditable()) {

+ setWindowTitle(tr("Edit Profile") + jidString);

+ } else {

+ setWindowTitle(tr("Show Profile") + jidString);

+void QtProfileWindow::closeEvent(QCloseEvent* event) {

+ event->accept();

+ onWindowAboutToBeClosed(jid);

+}

+void QtProfileWindow::handleSave() {

+ onVCardChangeRequest(ui->vcard->getVCard());

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <Swiften/JID/JID.h>

+#include <QWidget>

+

+namespace Ui {

+ class QtProfileWindow;

+}

+

+class QtProfileWindow : public QWidget, public ProfileWindow {

+ Q_OBJECT

+

+ public:

+ QtProfileWindow();

+ virtual ~QtProfileWindow();

+

+ virtual void setJID(const JID& jid);

+ virtual void setVCard(VCard::ref vcard);

+

+ virtual void setEnabled(bool b);

+ virtual void setProcessing(bool processing);

+ virtual void setError(const std::string& error);

+ virtual void setEditable(bool b);

+

+ virtual void show();

+ virtual void hide();

+

+ private:

+ void updateTitle();

+ virtual void closeEvent(QCloseEvent* event);

+

+ private slots:

+ void handleSave();

+

+ private:

+ Ui::QtProfileWindow* ui;

+ JID jid;

+};

+

+<?xml version="1.0" encoding="UTF-8"?>

+<ui version="4.0">

+ <class>QtProfileWindow</class>

+ <widget class="QWidget" name="QtProfileWindow">

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>334</width>

+ <height>197</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string>Edit Profile</string>

+ </property>

+ <layout class="QVBoxLayout" name="verticalLayout" stretch="1,0">

+ <property name="margin">

+ <number>0</number>

+ </property>

+ <item>

+ <widget class="Swift::QtVCardWidget" name="vcard" native="true"/>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout">

+ <property name="sizeConstraint">

+ <enum>QLayout::SetDefaultConstraint</enum>

+ </property>

+ <item>

+ <spacer name="horizontalSpacer">

+ <property name="orientation">

+ <enum>Qt::Horizontal</enum>

+ </property>

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

+ <size>

+ <width>40</width>

+ <height>0</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

+ <widget class="QLabel" name="errorLabel">

+ <property name="text">

+ <string/>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QLabel" name="throbberLabel">

+ <property name="text">

+ <string/>

+ </property>

+ <property name="alignment">

+ <set>Qt::AlignCenter</set>

+ </property>

+ <property name="textInteractionFlags">

+ <set>Qt::NoTextInteraction</set>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QPushButton" name="savePushButton">

+ <property name="text">

+ <string>Save</string>

+ </property>

+ <property name="default">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ <customwidgets>

+ <customwidget>

+ <class>Swift::QtVCardWidget</class>

+ <extends>QWidget</extends>

+ <header>Swift/QtUI/QtVCardWidget/QtVCardWidget.h</header>

+ <container>1</container>

+ </customwidget>

+ </customwidgets>

+ <resources/>

+ <connections/>

+</ui>

+QtRosterHeader::QtRosterHeader(SettingsProvider* settings, StatusCache* statusCache, QWidget* parent) : QWidget(parent) {

+ statusWidget_ = new QtStatusWidget(statusCache, this);

+ class StatusCache;

+ QtRosterHeader(SettingsProvider* settings, StatusCache* statusCache, QWidget* parent = NULL);

+#include <Swiften/Base/Log.h>

+#include <Swift/QtUI/QtSwiftUtil.h>

+

+ if (avatarPixmap.load(path)) {

+ QPixmap maskedAvatar(avatarPixmap.size());

+ maskedAvatar.fill(QColor(0, 0, 0, 0));

+ QPainter maskPainter(&maskedAvatar);

+ maskPainter.setBrush(Qt::black);

+ maskPainter.drawRoundedRect(maskedAvatar.rect(), 25.0, 25.0, Qt::RelativeSize);

+ maskPainter.setCompositionMode(QPainter::CompositionMode_SourceIn);

+ maskPainter.drawPixmap(0, 0, avatarPixmap);

+ maskPainter.end();

+

+ if (!maskedAvatar.scaled(size, size, Qt::KeepAspectRatio, Qt::SmoothTransformation).save(targetFile, "PNG")) {

+ return path;

+ }

+ } else {

+ SWIFT_LOG(debug) << "Failed to load " << Q2PSTRING(path) << std::endl;

+#if !defined(Q_OS_WIN) && !defined(Q_OS_MAC)

+/*

+ * Copyright (c) 2010-2012 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swift/QtUI/QtSingleWindow.h>

+

+

+#include <Swiften/Base/foreach.h>

+#include <Swift/QtUI/QtSettingsProvider.h>

+#include <Swift/QtUI/QtChatTabs.h>

+

+namespace Swift {

+

+static const QString SINGLE_WINDOW_GEOMETRY = QString("SINGLE_WINDOW_GEOMETRY");

+static const QString SINGLE_WINDOW_SPLITS = QString("SINGLE_WINDOW_SPLITS");

+

+QtSingleWindow::QtSingleWindow(QtSettingsProvider* settings) : QSplitter() {

+ settings_ = settings;

+ QVariant geometryVariant = settings_->getQSettings()->value(SINGLE_WINDOW_GEOMETRY);

+ if (geometryVariant.isValid()) {

+ restoreGeometry(geometryVariant.toByteArray());

+ }

+ connect(this, SIGNAL(splitterMoved(int, int)), this, SLOT(handleSplitterMoved(int, int)));

+ restoreSplitters();

+}

+

+QtSingleWindow::~QtSingleWindow() {

+

+}

+

+void QtSingleWindow::addWidget(QWidget* widget) {

+ QtChatTabs* tabs = dynamic_cast<QtChatTabs*>(widget);

+ if (tabs) {

+ connect(tabs, SIGNAL(onTitleChanged(const QString&)), this, SLOT(handleTabsTitleChanged(const QString&)));

+ }

+ QSplitter::addWidget(widget);

+}

+

+void QtSingleWindow::handleTabsTitleChanged(const QString& title) {

+ setWindowTitle(title);

+}

+

+void QtSingleWindow::handleSplitterMoved(int, int) {

+ QList<QVariant> variantValues;

+ QList<int> intValues = sizes();

+ foreach (int value, intValues) {

+ variantValues.append(QVariant(value));

+ }