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

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

+ int closeIconWidth = ui->blockListTreeWidget->fontMetrics().height();

+ ui->blockListTreeWidget->header()->resizeSection(1, closeIconWidth);

+

+#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("");

+ }

+ 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];}

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

+ Q_FOREACH (QWebElement span, spans) {

+ //qDebug() << snippet->getContent();

+ Q_FOREACH (QWebElement span, spans) {

+ //qDebug() << "-----------------";

+ //qDebug() << webPage_->mainFrame()->toHtml();

+ Q_FOREACH (QWebElement span, spans) {

+ Q_FOREACH (QWebElement span, spans) {

+ Q_FOREACH (QWebElement span, spans) {

+static QWebElement findElementWithID(QWebElement document, QString elementName, QString id) {

+ Q_FOREACH(QWebElement element, elements) {

+ * Copyright (c) 2010-2013 Kevin Smith

+#include "QtUtilities.h"

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

+#include <QMimeData>

+#include <QToolButton>

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

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

+ subjectLayout_->addWidget(subject_);

+ QPushButton* actionButton_ = new QPushButton(this);

+ layout->addLayout(subjectLayout_);

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

+ChatSnippet::Direction QtChatWindow::getActualDirection(const ChatMessage& message, Direction direction) {

+ if (direction == DefaultDirection) {

+ return QCoreApplication::translate("QApplication", "QT_LAYOUT_DIRECTION") == "RTL" ? ChatSnippet::RTL : ChatSnippet::LTR;

+ }

+ else {

+ return ChatSnippet::getDirection(message);

+ }

+}

+

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

+ return addMessage(chatMessageToHTML(message), senderName, senderIsSelf, label, avatarPath, "", time, highlight, ChatSnippet::getDirection(message));

+}

+

+QString QtChatWindow::chatMessageToHTML(const ChatMessage& message) {

+ QString result;

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

+ boost::shared_ptr<ChatTextMessagePart> textPart;

+ boost::shared_ptr<ChatURIMessagePart> uriPart;

+ boost::shared_ptr<ChatEmoticonMessagePart> emoticonPart;

+ boost::shared_ptr<ChatHighlightingMessagePart> highlightPart;

+

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

+ QString text = QtUtilities::htmlEscape(P2QSTRING(textPart->text));

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

+ result += text;

+ continue;

+ }

+ if ((uriPart = boost::dynamic_pointer_cast<ChatURIMessagePart>(part))) {

+ QString uri = QtUtilities::htmlEscape(P2QSTRING(uriPart->target));

+ result += "<a href='" + uri + "' >" + uri + "</a>";

+ continue;

+ }

+ if ((emoticonPart = boost::dynamic_pointer_cast<ChatEmoticonMessagePart>(part))) {

+ QString textStyle = showEmoticons_ ? "style='display:none'" : "";

+ 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<ChatHighlightingMessagePart>(part))) {

+ //FIXME: Maybe do something here. Anything, really.

+ continue;

+ }

+

+ }

+ return result;

+}

+

+/*QString QtChatWindow::linkimoticonify(const std::string& message) const {

+ return linkimoticonify(P2QSTRING(message));

+ messageHTML = QtUtilities::htmlEscape(messageHTML);

+

+ messageHTML.replace(it.key(), );

+}*/

+

+QString QtChatWindow::getHighlightSpanStart(const HighlightAction& highlight) {

+ QString color = QtUtilities::htmlEscape(P2QSTRING(highlight.getTextColor()));

+ QString background = QtUtilities::htmlEscape(P2QSTRING(highlight.getTextBackground()));

+ if (color.isEmpty()) {

+ color = "black";

+ }

+ if (background.isEmpty()) {

+ background = "yellow";

+ }

+

+ return QString("<span style=\"color: %1; background: %2\">").arg(color).arg(background);

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

+

+ 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 highlightSpanStart = highlight.highlightText() ? getHighlightSpanStart(highlight) : "";

+ QString highlightSpanEnd = highlight.highlightText() ? "</span>" : "";

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

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

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

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

+// FIXME: Move this to a different file

+static QString encodeButtonArgument(const QString& str) {

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

+static QString decodeButtonArgument(const QString& str) {

+ QString actionText;

+ actionText = tr("Send file");

+ htmlString = actionText + ": " + P2QSTRING(filename) + " ( " + formattedFileSize + ") <br/>" +

+ actionText = tr("Receiving file");

+ htmlString = actionText + ": " + P2QSTRING(filename) + " ( " + formattedFileSize + ") <br/>" +

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

+ messageLog_->setFileTransferProgress(P2QSTRING(id), percentageDone);

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

+ QString actionText;

+ actionText = tr("Starting whiteboard chat");

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

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

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

+ messageLog_->addMessageBottom(boost::make_shared<MessageSnippet>(htmlString, QtUtilities::htmlEscape(contact_), B2QDATE(boost::posix_time::second_clock::local_time()), qAvatarPath, false, false, theme_, P2QSTRING(id), ChatSnippet::getDirection(actionText)));

+ messageLog_->setWhiteboardSessionStatus(P2QSTRING(id), state);

+ messageLog_->setWhiteboardSessionStatus(id, ChatWindow::WhiteboardAccepted);

+ messageLog_->setWhiteboardSessionStatus(id, ChatWindow::WhiteboardTerminated);

+void QtChatWindow::addErrorMessage(const ChatMessage& errorMessage) {

+ QString errorMessageHTML(chatMessageToHTML(errorMessage));

+

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

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

+ QString messageHTML = chatMessageToHTML(message);

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

+void QtChatWindow::replaceWithAction(const 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 QtChatWindow::replaceMessage(const ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

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

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

+ QString highlightSpanStart = highlight.highlightText() ? getHighlightSpanStart(highlight) : "";

+ QString highlightSpanEnd = highlight.highlightText() ? "</span>" : "";

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

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

+ QString messageHTML = chatMessageToHTML(message);

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

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

+void QtChatWindow::replaceLastMessage(const ChatMessage& message) {

+ messageLog_->replaceLastMessage(chatMessageToHTML(message));

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

+ }

+ } else {

+ foreach(ChatWindow::RoomAction availableAction, availableRoomActions_)

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

+ }

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

+}

+

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

+ QString htmlString = message;

+ htmlString += QObject::tr("Reason: %1").arg(P2QSTRING(reason)) + "\n";

+ htmlString += QObject::tr("This person may not have really sent this invitation!") + "\n";

+ htmlString = chatMessageToHTML(ChatMessage(Q2PSTRING(htmlString)));

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

+ buildChatWindowButton(chatMessageToHTML(ChatMessage(Q2PSTRING((tr("Accept Invite"))))), ButtonMUCInvite, QtUtilities::htmlEscape(P2QSTRING(jid.toString())), QtUtilities::htmlEscape(P2QSTRING(password)), id) +

+ messageLog_->addMessageBottom(boost::make_shared<MessageSnippet>(htmlString, QtUtilities::htmlEscape(P2QSTRING(senderName)), B2QDATE(boost::posix_time::second_clock::local_time()), qAvatarPath, false, appendToPrevious, theme_, id, ChatSnippet::getDirection(message)));

+ * Copyright (c) 2010-2013 Kevin Smith

+#include <Swift/QtUI/ChatSnippet.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 replaceLastMessage(const ChatMessage& message);

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

+ void setBlockingState(BlockingState state);

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

+ void replaceMessage(

+ const QString& message,

+ const std::string& id,

+ const boost::posix_time::ptime& time,

+ const QString& style,

+ const HighlightAction& highlight);

+ static ChatSnippet::Direction getActualDirection(const ChatMessage& message, Direction direction);

+ QString chatMessageToHTML(const ChatMessage& message);

+ QString getHighlightSpanStart(const HighlightAction& highlight);

+ QBoxLayout* subjectLayout_;

+ BlockingState blockingState_;

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

+/*

+ * 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

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

+/*

+ * 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

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

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

+#include "QtUtilities.h"

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

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

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

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

+ if (b) {

+ ui->savePushButton->show();

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

+ } else {

+ ui->savePushButton->hide();

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

+ }

+ updateTitle();

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

+ ui->throbberLabel->show();

+ }

+ else {

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

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

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

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

+ }

+ settings_->getQSettings()->setValue(SINGLE_WINDOW_SPLITS, QVariant(variantValues));

+}

+

+void QtSingleWindow::restoreSplitters() {

+ QList<QVariant> variantValues = settings_->getQSettings()->value(SINGLE_WINDOW_SPLITS).toList();

+ QList<int> intValues;

+ foreach (QVariant value, variantValues) {

+ intValues.append(value.toInt());

+ }

+ setSizes(intValues);

+}

+

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

+ insertWidget(0, widget);

+ restoreSplitters();

+}

+

+void QtSingleWindow::handleGeometryChanged() {

+ settings_->getQSettings()->setValue(SINGLE_WINDOW_GEOMETRY, saveGeometry());

+

+}

+

+void QtSingleWindow::resizeEvent(QResizeEvent*) {

+ handleGeometryChanged();

+}

+

+void QtSingleWindow::moveEvent(QMoveEvent*) {

+ handleGeometryChanged();

+}

+

+}

+/*

+ * Copyright (c) 2010-2012 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <QSplitter>

+

+namespace Swift {

+ class QtSettingsProvider;

+

+ class QtSingleWindow : public QSplitter {

+ Q_OBJECT

+ public:

+ QtSingleWindow(QtSettingsProvider* settings);

+ virtual ~QtSingleWindow();

+ void insertAtFront(QWidget* widget);

+ void addWidget(QWidget* widget);

+ protected:

+ void resizeEvent(QResizeEvent*);

+ void moveEvent(QMoveEvent*);

+ private slots:

+ void handleSplitterMoved(int, int);

+ void handleTabsTitleChanged(const QString& title);

+ private:

+ void handleGeometryChanged();

+ void restoreSplitters();

+

+ private:

+

+ QtSettingsProvider* settings_;

+ };

+

+}

+

+ * Copyright (c) 2010-2013 Kevin Smith

+#include <SwifTools/Application/ApplicationPathProvider.h>

+#include <QtSwiftUtil.h>

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

+void QtSoundPlayer::playSound(SoundEffect sound, const std::string& soundResource) {

+

+ playSound(soundResource.empty() ? "/sounds/message-received.wav" : soundResource);

+ QSound::play(P2QSTRING(pathToString(resourcePath)));

+ }

+ else if (boost::filesystem::exists(soundResource)) {

+ QSound::play(P2QSTRING(soundResource));

+ void playSound(SoundEffect sound, const std::string& soundResource);

+/*

+ * Copyright (c) 2011 Vlad Voicu

+ * Licensed under the Simplified BSD license.

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

+ */

+

+#include "Swift/QtUI/QtSpellCheckerWindow.h"

+

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

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

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

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

+

+#include <QCoreApplication>

+#include <QFileDialog>

+#include <QDir>

+#include <QStringList>

+#include <QTimer>

+

+namespace Swift {

+

+QtSpellCheckerWindow::QtSpellCheckerWindow(SettingsProvider* settings, QWidget* parent) : QDialog(parent) {

+ settings_ = settings;

+ ui_.setupUi(this);

+#ifdef HAVE_HUNSPELL

+ ui_.hunspellOptions->show();

+#else

+ ui_.hunspellOptions->hide();

+ QTimer::singleShot(0, this, SLOT(shrinkWindow()));

+#endif

+ connect(ui_.spellChecker, SIGNAL(toggled(bool)), this, SLOT(handleChecker(bool)));

+ connect(ui_.cancel, SIGNAL(clicked()), this, SLOT(handleCancel()));

+ connect(ui_.apply, SIGNAL(clicked()), this, SLOT(handleApply()));

+ connect(ui_.pathButton, SIGNAL(clicked()), this, SLOT(handlePathButton()));

+ setFromSettings();

+}

+

+void QtSpellCheckerWindow::shrinkWindow() {

+ resize(0,0);

+}

+

+void QtSpellCheckerWindow::setFromSettings() {

+ ui_.spellChecker->setChecked(settings_->getSetting(SettingConstants::SPELL_CHECKER));

+ ui_.pathContent->setText(P2QSTRING(settings_->getSetting(SettingConstants::DICT_PATH)));

+ ui_.currentLanguageValue->setText(P2QSTRING(settings_->getSetting(SettingConstants::DICT_FILE)));

+ std::string currentPath = settings_->getSetting(SettingConstants::DICT_PATH);

+ QString filename = "*.dic";

+ QDir dictDirectory = QDir(P2QSTRING(currentPath));

+ QStringList files = dictDirectory.entryList(QStringList(filename), QDir::Files);

+ showFiles(files);

+ setEnabled(settings_->getSetting(SettingConstants::SPELL_CHECKER));

+}

+

+void QtSpellCheckerWindow::handleChecker(bool state) {

+ setEnabled(state);

+}

+

+void QtSpellCheckerWindow::setEnabled(bool state) {

+ ui_.pathContent->setEnabled(state);

+ ui_.languageView->setEnabled(state);

+ ui_.pathButton->setEnabled(state);

+ ui_.pathLabel->setEnabled(state);

+ ui_.currentLanguage->setEnabled(state);

+ ui_.currentLanguageValue->setEnabled(state);

+ ui_.language->setEnabled(state);

+}

+

+void QtSpellCheckerWindow::handleApply() {

+ settings_->storeSetting(SettingConstants::SPELL_CHECKER, ui_.spellChecker->isChecked());

+ QList<QListWidgetItem* > selectedLanguage = ui_.languageView->selectedItems();

+ if (!selectedLanguage.empty()) {

+ settings_->storeSetting(SettingConstants::DICT_FILE, Q2PSTRING((selectedLanguage.first())->text()));

+ }

+ this->done(0);

+}

+

+void QtSpellCheckerWindow::handleCancel() {

+ this->done(0);

+}

+

+void QtSpellCheckerWindow::handlePathButton() {

+ std::string currentPath = settings_->getSetting(SettingConstants::DICT_PATH);

+ QString dirpath = QFileDialog::getExistingDirectory(this, tr("Dictionary Path"), P2QSTRING(currentPath));

+ if (dirpath != P2QSTRING(currentPath)) {

+ ui_.languageView->clear();

+ settings_->storeSetting(SettingConstants::DICT_FILE, "");

+ ui_.currentLanguageValue->setText(" ");

+ }

+ if (!dirpath.isEmpty()) {

+ if (!dirpath.endsWith("/")) {

+ dirpath.append("/");

+ }

+ settings_->storeSetting(SettingConstants::DICT_PATH, Q2PSTRING(dirpath));

+ QDir dictDirectory = QDir(dirpath);

+ ui_.pathContent->setText(dirpath);

+ QString filename = "*.dic";

+ QStringList files = dictDirectory.entryList(QStringList(filename), QDir::Files);

+ showFiles(files);

+ }

+}

+

+void QtSpellCheckerWindow::handlePersonalPathButton() {

+ std::string currentPath = settings_->getSetting(SettingConstants::PERSONAL_DICT_PATH);

+ QString filename = QFileDialog::getOpenFileName(this, tr("Select Personal Dictionary"), P2QSTRING(currentPath), tr("(*.dic"));

+ settings_->storeSetting(SettingConstants::PERSONAL_DICT_PATH, Q2PSTRING(filename));

+}

+

+void QtSpellCheckerWindow::showFiles(const QStringList& files) {

+ ui_.languageView->clear();

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

+ ui_.languageView->insertItem(i, files[i]);

+ }

+}

+

+}

+/*

+ * Copyright (c) 2011 Vlad Voicu

+ * Licensed under the Simplified BSD license.

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

+ */

+

+#pragma once

+

+#include "ui_QtSpellCheckerWindow.h"

+

+#include <QDialog>

+

+namespace Swift {

+ class SettingsProvider;

+ class QtSpellCheckerWindow : public QDialog, protected Ui::QtSpellCheckerWindow {

+ Q_OBJECT

+ public:

+ QtSpellCheckerWindow(SettingsProvider* settings, QWidget* parent = NULL);

+ public slots:

+ void handleChecker(bool state);

+ void handleCancel();

+ void handlePathButton();

+ void handlePersonalPathButton();

+ void handleApply();

+ private slots:

+ void shrinkWindow();

+ private:

+ void setEnabled(bool state);

+ void setFromSettings();

+ void showFiles(const QStringList& files);

+ SettingsProvider* settings_;

+ Ui::QtSpellCheckerWindow ui_;

+ };

+}

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

+<ui version="4.0">

+ <class>QtSpellCheckerWindow</class>

+ <widget class="QDialog" name="QtSpellCheckerWindow">

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>399</width>

+ <height>265</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string>Dialog</string>

+ </property>

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

+ <item>

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

+ <property name="text">

+ <string>Spell Checker Enabled</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QWidget" name="hunspellOptions" native="true">

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

+ <item>

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

+ <item>

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

+ <property name="text">

+ <string>Dictionary Path:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ </item>

+ <item>

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

+ <property name="text">

+ <string>Change</string>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ <item>

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

+ <item>

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

+ <property name="text">

+ <string>Current Language:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="text">

+ <string/>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ <item>

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

+ <item>

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

+ <property name="text">

+ <string>Language:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QListWidget" name="languageView"/>

+ </item>

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ </item>

+ <item>

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

+ <item>

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

+ <property name="text">

+ <string>Cancel</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="text">

+ <string>Apply</string>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ <resources/>

+ <connections/>

+</ui>

+#include <algorithm>

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

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

+

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

+

+namespace lambda = boost::lambda;

+QtStatusWidget::QtStatusWidget(StatusCache* statusCache, QWidget *parent) : QWidget(parent), statusCache_(statusCache), editCursor_(Qt::IBeamCursor), viewCursor_(Qt::PointingHandCursor) {

+ allTypes_.push_back(StatusShow::Online);

+ allTypes_.push_back(StatusShow::FFC);

+ allTypes_.push_back(StatusShow::Away);

+ allTypes_.push_back(StatusShow::XA);

+ allTypes_.push_back(StatusShow::DND);

+ allTypes_.push_back(StatusShow::None);

+

+ std::vector<StatusCache::PreviousStatus> previousStatuses = statusCache_->getMatches(Q2PSTRING(text), 8);

+ foreach (StatusCache::PreviousStatus savedStatus, previousStatuses) {

+ if (savedStatus.first.empty() || std::find_if(allTypes_.begin(), allTypes_.end(),

+ savedStatus.second == lambda::_1 && savedStatus.first == lambda::bind(&statusShowTypeToFriendlyName, lambda::_1)) != allTypes_.end()) {

+ continue;

+ }

+ QListWidgetItem* item = new QListWidgetItem(P2QSTRING(savedStatus.first), menu_);

+ item->setIcon(icons_[savedStatus.second]);

+ item->setToolTip(item->text());

+ item->setStatusTip(item->toolTip());

+ item->setData(Qt::UserRole, QVariant(savedStatus.second));

+ }

+ if (Q2PSTRING(text) == statusShowTypeToFriendlyName(type)) {

+ continue;

+ }

+ resizeMenu();

+void QtStatusWidget::resizeMenu() {

+ int height = menu_->sizeHintForRow(0) * menu_->count();

+ int marginLeft;

+ int marginTop;

+ int marginRight;

+ int marginBottom;

+ menu_->getContentsMargins(&marginLeft, &marginTop, &marginRight, &marginBottom);

+ height += marginTop + marginBottom;

+

+ menu_->setGeometry(menu_->x(), menu_->y(), menu_->width(), height);

+}

+ //foreach (StatusShow::Type type, allTypes_) {

+ // if (statusEdit_->text() == P2QSTRING(statusShowTypeToFriendlyName(type))) {

+ // }

+ //}

+ stack_->setCurrentIndex(0);

+ statusCache_->addRecent(Q2PSTRING(statusText_), selectedStatusType_);

+ class StatusCache;

+

+ QtStatusWidget(StatusCache* statusCache, QWidget *parent);

+ void resizeMenu();

+ StatusCache* statusCache_;

+ std::vector<StatusShow::Type> allTypes_;

+ * Copyright (c) 2010-2013 Kevin Smith

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

+#include <map>

+

+

+#include <QFile>

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

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

+

+#include <SwifTools/Application/PlatformApplicationPathProvider.h>

+#include <SwifTools/AutoUpdater/AutoUpdater.h>

+#include <SwifTools/AutoUpdater/PlatformAutoUpdaterFactory.h>

+

+#include <Swift/Controllers/Storages/CertificateFileStorageFactory.h>

+#include <Swift/Controllers/Storages/FileStoragesFactory.h>

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

+

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

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

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

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

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

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

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

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

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

+#include <SwifTools/Notifier/GrowlNotifier.h>

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

+#include <SwifTools/Notifier/NullNotifier.h>

+#include <SwifTools/Dock/MacOSXDock.h>

+#include <SwifTools/Dock/NullDock.h>

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

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

+//#define SWIFT_APPCAST_URL "http://swift.im/appcast/swift-mac-dev.xml"

+//#define SWIFT_APPCAST_URL ""

+void QtSwift::loadEmoticonsFile(const QString& fileName, std::map<std::string, std::string>& emoticons) {

+ QString emoticonFile = tokens[1];

+ if (!emoticonFile.startsWith(":/") && !emoticonFile.startsWith("qrc:/")) {

+ emoticonFile = "file://" + emoticonFile;

+ }

+ emoticons[Q2PSTRING(tokens[0])] = Q2PSTRING(emoticonFile);

+ xmlSettings_ = loadSettingsFile(P2QSTRING(pathToString(Paths::getExecutablePath() / "system-settings.xml")));

+ std::map<std::string, std::string> emoticons;

+ loadEmoticonsFile(":/emoticons/emoticons.txt", emoticons);

+ loadEmoticonsFile(P2QSTRING(pathToString(Paths::getExecutablePath() / "emoticons.txt")), emoticons);

+

+ if (options.count("netbook-mode")) {

+ splitter_ = new QtSingleWindow(qtSettings_);

+ } else {

+ splitter_ = NULL;

+ }

+ Log::setLogLevel(Swift::Log::debug);

+ tabs_ = options.count("no-tabs") && !splitter_ ? NULL : new QtChatTabs(splitter_ != NULL);

+ storagesFactory_ = new FileStoragesFactory(applicationPathProvider_->getDataDir(), networkFactories_.getCryptoProvider());

+ certificateStorageFactory_ = new CertificateFileStorageFactory(applicationPathProvider_->getDataDir(), tlsFactories_.getCertificateFactory(), networkFactories_.getCryptoProvider());

+ chatWindowFactory_ = new QtChatWindowFactory(splitter_, settingsHierachy_, qtSettings_, tabs_, "");

+ statusCache_ = new StatusCache(applicationPathProvider_);

+

+ QtUIFactory* uiFactory = new QtUIFactory(settingsHierachy_, qtSettings_, tabs_, splitter_, systemTrays_[i], chatWindowFactory_, networkFactories_.getTimerFactory(), statusCache_, startMinimized, !emoticons.empty());

+ emoticons,

+ delete statusCache_;

+ class StatusCache;

+ class QtSingleWindow;

+ void loadEmoticonsFile(const QString& fileName, std::map<std::string, std::string>& emoticons);

+ QtSingleWindow* splitter_;

+ StatusCache* statusCache_;

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

+

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

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

+ virtual AlertType getWidgetAlertState() {return NoActivity;}

+ QtTabbable() : QWidget() {}

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

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

+#include <boost/bind.hpp>

+

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

+

+#include <SwifTools/SpellCheckerFactory.h>

+#include <SwifTools/SpellChecker.h>

+

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

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

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

+#include <QApplication>

+#include <QDebug>

+#include <QMenu>

+QtTextEdit::QtTextEdit(SettingsProvider* settings, QWidget* parent) : QTextEdit(parent) {

+ checker_ = NULL;

+ settings_ = settings;

+#ifdef HAVE_SPELLCHECKER

+ setUpSpellChecker();

+#endif

+}

+

+QtTextEdit::~QtTextEdit() {

+ delete checker_;

+}

+ || (key == Qt::Key_Down)) {

+#ifdef HAVE_SPELLCHECKER

+ if (settings_->getSetting(SettingConstants::SPELL_CHECKER)) {

+ underlineMisspells();

+ }

+#endif

+ }

+}

+

+void QtTextEdit::underlineMisspells() {

+ QTextCursor cursor = textCursor();

+ misspelledPositions_.clear();

+ QTextCharFormat normalFormat;

+ cursor.movePosition(QTextCursor::Start, QTextCursor::MoveAnchor, 1);

+ cursor.movePosition(QTextCursor::End, QTextCursor::KeepAnchor, 1);

+ cursor.setCharFormat(normalFormat);

+ if (checker_ == NULL) {

+ return;

+ }

+ QTextCharFormat spellingErrorFormat;

+ spellingErrorFormat.setUnderlineColor(QColor(Qt::red));

+ spellingErrorFormat.setUnderlineStyle(QTextCharFormat::SpellCheckUnderline);

+ std::string fragment = Q2PSTRING(cursor.selectedText());

+ checker_->checkFragment(fragment, misspelledPositions_);

+ foreach (PositionPair position, misspelledPositions_) {

+ cursor.setPosition(boost::get<0>(position), QTextCursor::MoveAnchor);

+ cursor.setPosition(boost::get<1>(position), QTextCursor::KeepAnchor);

+ cursor.setCharFormat(spellingErrorFormat);

+ cursor.clearSelection();

+ cursor.setCharFormat(normalFormat);

+void QtTextEdit::replaceMisspelledWord(const QString& word, int cursorPosition) {

+ QTextCursor cursor = textCursor();

+ PositionPair wordPosition = getWordFromCursor(cursorPosition);

+ cursor.setPosition(boost::get<0>(wordPosition), QTextCursor::MoveAnchor);

+ cursor.setPosition(boost::get<1>(wordPosition), QTextCursor::KeepAnchor);

+ QTextCharFormat normalFormat;

+ cursor.insertText(word, normalFormat);

+}

+

+PositionPair QtTextEdit::getWordFromCursor(int cursorPosition) {

+ for (PositionPairList::iterator it = misspelledPositions_.begin(); it != misspelledPositions_.end(); ++it) {

+ if (cursorPosition >= boost::get<0>(*it) && cursorPosition <= boost::get<1>(*it)) {

+ return *it;

+ }

+ }

+ return boost::make_tuple(-1,-1);

+}

+

+void QtTextEdit::contextMenuEvent(QContextMenuEvent* event) {

+ QMenu* menu = createStandardContextMenu();

+ QTextCursor cursor = cursorForPosition(event->pos());

+#ifdef HAVE_SPELLCHECKER

+ QAction* insertPoint = menu->actions().first();

+ QAction* settingsAction = new QAction(tr("Spell Checker Options"), menu);

+ menu->insertAction(insertPoint, settingsAction);

+ menu->insertAction(insertPoint, menu->addSeparator());

+ addSuggestions(menu, event);

+ QAction* result = menu->exec(event->globalPos());

+ if (result == settingsAction) {

+ spellCheckerSettingsWindow();

+ }

+ for (std::vector<QAction*>::iterator it = replaceWordActions_.begin(); it != replaceWordActions_.end(); ++it) {

+ if (*it == result) {

+ replaceMisspelledWord((*it)->text(), cursor.position());

+ }

+ }

+#else

+ menu->exec(event->globalPos());

+#endif

+ delete menu;

+}

+

+void QtTextEdit::addSuggestions(QMenu* menu, QContextMenuEvent* event)

+{

+ replaceWordActions_.clear();

+ QAction* insertPoint = menu->actions().first();

+ QTextCursor cursor = cursorForPosition(event->pos());

+ PositionPair wordPosition = getWordFromCursor(cursor.position());

+ if (boost::get<0>(wordPosition) < 0) {

+ // The click was executed outside a spellable word so no

+ // suggestions are necessary

+ return;

+ }

+ cursor.setPosition(boost::get<0>(wordPosition), QTextCursor::MoveAnchor);

+ cursor.setPosition(boost::get<1>(wordPosition), QTextCursor::KeepAnchor);

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

+ checker_->getSuggestions(Q2PSTRING(cursor.selectedText()), wordList);

+ if (wordList.size() == 0) {

+ QAction* noSuggestions = new QAction(tr("No Suggestions"), menu);

+ noSuggestions->setDisabled(true);

+ menu->insertAction(insertPoint, noSuggestions);

+ }

+ else {

+ for (std::vector<std::string>::iterator it = wordList.begin(); it != wordList.end(); ++it) {

+ QAction* wordAction = new QAction(it->c_str(), menu);

+ menu->insertAction(insertPoint, wordAction);

+ replaceWordActions_.push_back(wordAction);

+ }

+ }

+ menu->insertAction(insertPoint, menu->addSeparator());

+}

+

+

+#ifdef HAVE_SPELLCHECKER

+void QtTextEdit::setUpSpellChecker()

+{

+ SpellCheckerFactory* checkerFactory = new SpellCheckerFactory();

+ delete checker_;

+ if (settings_->getSetting(SettingConstants::SPELL_CHECKER)) {

+ std::string dictPath = settings_->getSetting(SettingConstants::DICT_PATH);

+ std::string dictFile = settings_->getSetting(SettingConstants::DICT_FILE);

+ checker_ = checkerFactory->createSpellChecker(dictPath + dictFile);

+ delete checkerFactory;

+ }

+ else {

+ checker_ = NULL;

+ }

+#endif

+void QtTextEdit::spellCheckerSettingsWindow() {

+ if (!spellCheckerWindow_) {

+ spellCheckerWindow_ = new QtSpellCheckerWindow(settings_);

+ settings_->onSettingChanged.connect(boost::bind(&QtTextEdit::handleSettingChanged, this, _1));

+ spellCheckerWindow_->show();

+ }

+ else {

+ spellCheckerWindow_->show();

+ spellCheckerWindow_->raise();

+ spellCheckerWindow_->activateWindow();

+ }

+}

+void QtTextEdit::handleSettingChanged(const std::string& settings) {

+ if (settings == SettingConstants::SPELL_CHECKER.getKey()

+ || settings == SettingConstants::DICT_PATH.getKey()

+ || settings == SettingConstants::DICT_FILE.getKey()) {

+#ifdef HAVE_SPELLCHECKER

+ setUpSpellChecker();

+ underlineMisspells();

+#endif

+ }

+}

+}

+

+#include <SwifTools/SpellParser.h>

+

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

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

+

+#include <QPointer>

+ class SpellChecker;

+ class QtSpellCheckerWindow;

+ QtTextEdit(SettingsProvider* settings, QWidget* parent = 0);

+ virtual ~QtTextEdit();

+ void wordCorrected(QString& word);

+ public slots:

+ void handleSettingChanged(const std::string& settings);

+ virtual void contextMenuEvent(QContextMenuEvent* event);

+ private:

+ SpellChecker *checker_;

+ std::vector<QAction*> replaceWordActions_;

+ PositionPairList misspelledPositions_;

+ SettingsProvider *settings_;

+ QPointer<QtSpellCheckerWindow> spellCheckerWindow_;

+ void addSuggestions(QMenu* menu, QContextMenuEvent* event);

+ void replaceMisspelledWord(const QString& word, int cursorPosition);

+ void setUpSpellChecker();

+ void underlineMisspells();

+ void spellCheckerSettingsWindow();

+ PositionPair getWordFromCursor(int cursorPosition);

+#if QT_VERSION >= 0x050000

+ return std::string(QCoreApplication::translate(context.c_str(), text.c_str(), 0).toUtf8());

+#else

+#endif

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

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

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

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

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

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

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

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

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

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

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

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

+#include <Swift/QtUI/MUCSearch/QtMUCSearchWindow.h>

+#include <Swift/QtUI/UserSearch/QtUserSearchWindow.h>

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

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

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

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

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

+#include <Swift/QtUI/Whiteboard/QtWhiteboardWindow.h>

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

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

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

+QtUIFactory::QtUIFactory(SettingsProviderHierachy* settings, QtSettingsProvider* qtOnlySettings, QtChatTabs* tabs, QtSingleWindow* netbookSplitter, QtSystemTray* systemTray, QtChatWindowFactory* chatWindowFactory, TimerFactory* timerFactory, StatusCache* statusCache, bool startMinimized, bool emoticonsExist) : settings(settings), qtOnlySettings(qtOnlySettings), tabs(tabs), netbookSplitter(netbookSplitter), systemTray(systemTray), chatWindowFactory(chatWindowFactory), timerFactory_(timerFactory), lastMainWindow(NULL), loginWindow(NULL), statusCache(statusCache), startMinimized(startMinimized), emoticonsExist_(emoticonsExist) {

+ lastMainWindow = new QtMainWindow(settings, eventStream, loginWindow->getMenus(), statusCache, emoticonsExist_);

+ netbookSplitter->insertAtFront(loginWindow);

+}

+HighlightEditorWidget* QtUIFactory::createHighlightEditorWidget() {

+ return new QtHighlightEditorWidget();

+}

+

+BlockListEditorWidget *QtUIFactory::createBlockListEditorWidget() {

+ return new QtBlockListEditorWindow();

+}

+

+ class StatusCache;

+ class QtSingleWindow;

+ QtUIFactory(SettingsProviderHierachy* settings, QtSettingsProvider* qtOnlySettings, QtChatTabs* tabs, QtSingleWindow* netbookSplitter, QtSystemTray* systemTray, QtChatWindowFactory* chatWindowFactory, TimerFactory* timerFactory, StatusCache* statusCache, bool startMinimized, bool emoticonsExist);

+ virtual HighlightEditorWidget* createHighlightEditorWidget();

+ virtual BlockListEditorWidget* createBlockListEditorWidget();

+ QtSingleWindow* netbookSplitter;

+ StatusCache* statusCache;

+QtURLValidator::QtURLValidator(QObject* parent) : QValidator(parent) {

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

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

+#include <QTextDocument>

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

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

+QString htmlEscape(const QString& s) {

+#if QT_VERSION >= 0x050000

+ return s.toHtmlEscaped();

+#else

+ return Qt::escape(s);

+#endif

+}

+

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

+ QString htmlEscape(const QString& s);

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtCloseButton.h"

+

+#include <QMouseEvent>

+#include <QPainter>

+#include <QStyle>

+#include <QStyleOption>

+

+namespace Swift {

+

+QtCloseButton::QtCloseButton(QWidget *parent) : QAbstractButton(parent) {

+ lightPixmap = QPixmap(12,12);

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

+ QStyleOption opt;

+ opt.init(this);

+ opt.state = QStyle::State(0);

+ opt.state |= QStyle::State_MouseOver;

+ QPainter lightPixmapPainter(&lightPixmap);

+ style()->drawPrimitive(QStyle::PE_IndicatorTabClose, &opt, &lightPixmapPainter);

+

+ darkPixmap = QPixmap(12,12);

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

+ opt.init(this);

+ opt.state = QStyle::State(0);

+ QPainter darkPixmapPainter(&darkPixmap);

+ style()->drawPrimitive(QStyle::PE_IndicatorTabClose, &opt, &darkPixmapPainter);

+}

+

+QSize QtCloseButton::sizeHint() const {

+ return QSize(width(), height());

+}

+

+bool QtCloseButton::event(QEvent *e) {

+ if (e->type() == QEvent::Enter || e->type() == QEvent::Leave) {

+ update();

+ }

+ return QAbstractButton::event(e);

+}

+

+void QtCloseButton::paintEvent(QPaintEvent *) {

+ QPainter painter(this);

+ painter.setRenderHint(QPainter::HighQualityAntialiasing);

+ if (underMouse()) {

+ painter.drawPixmap(0, 0, height(), height(), darkPixmap);

+ } else {

+ painter.drawPixmap(0, 0, height(), height(), lightPixmap);

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QAbstractButton>

+

+namespace Swift {

+

+ class QtCloseButton : public QAbstractButton {

+ Q_OBJECT

+ public:

+ explicit QtCloseButton(QWidget *parent = 0);

+ virtual QSize sizeHint() const;

+

+ protected:

+ virtual bool event(QEvent *e);

+ virtual void paintEvent(QPaintEvent* );

+

+ private:

+ QPixmap lightPixmap;

+ QPixmap darkPixmap;

+ };

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtRemovableItemDelegate.h"

+

+#include <QEvent>

+#include <QPainter>

+

+namespace Swift {

+

+QtRemovableItemDelegate::QtRemovableItemDelegate(const QStyle* style) : style(style) {

+

+}

+

+void QtRemovableItemDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex&) const {

+ QStyleOption opt;

+ opt.state = QStyle::State(0);

+ opt.state |= QStyle::State_MouseOver;

+ painter->save();

+ painter->fillRect(option.rect, option.state & QStyle::State_Selected ? option.palette.highlight() : option.palette.base());

+ painter->translate(option.rect.x(), option.rect.y()+(option.rect.height() - 12)/2);

+ style->drawPrimitive(QStyle::PE_IndicatorTabClose, &opt, painter);

+ painter->restore();

+}

+

+QWidget* QtRemovableItemDelegate::createEditor(QWidget*, const QStyleOptionViewItem&, const QModelIndex&) const {

+ return NULL;

+}

+

+bool QtRemovableItemDelegate::editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index) {

+ if (event->type() == QEvent::MouseButtonRelease) {

+ model->removeRow(index.row());

+ return true;

+ } else {

+ return QItemDelegate::editorEvent(event, model, option, index);

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QItemDelegate>

+

+namespace Swift {

+

+class QtRemovableItemDelegate : public QItemDelegate {

+ public:

+ QtRemovableItemDelegate(const QStyle* style);

+

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

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

+

+ protected:

+ virtual bool editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index);

+

+ private:

+ const QStyle* style;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtResizableLineEdit.h"

+

+namespace Swift {

+

+QtResizableLineEdit::QtResizableLineEdit(QWidget* parent) :

+ QLineEdit(parent) {

+ connect(this, SIGNAL(textChanged(QString)), SLOT(textChanged(QString)));

+ setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);

+ int marginHeight = 6;

+ setMaximumHeight(fontMetrics().height() + marginHeight);

+}

+

+QtResizableLineEdit::~QtResizableLineEdit() {

+}

+

+bool QtResizableLineEdit::isEditable() const {

+ return editable;

+}

+void QtResizableLineEdit::setEditable(const bool editable) {

+ this->editable = editable;

+ if (editable) {

+ setReadOnly(false);

+ } else {

+ setReadOnly(true);

+ }

+}

+

+

+QSize QtResizableLineEdit::sizeHint() const {

+ int horizontalMargin = 10;

+#if QT_VERSION >= 0x040700

+ int w = fontMetrics().boundingRect(text().isEmpty() ? placeholderText() : text()).width() + horizontalMargin;

+#else

+ int w = fontMetrics().boundingRect(text().isEmpty() ? QString(" ") : text()).width() + horizontalMargin;

+#endif

+ return QSize(w, height());

+}

+

+void QtResizableLineEdit::textChanged(QString) {

+ updateGeometry();

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QLineEdit>

+

+namespace Swift {

+

+ class QtResizableLineEdit : public QLineEdit {

+ Q_OBJECT

+ Q_PROPERTY(bool editable READ isEditable WRITE setEditable)

+

+ public:

+ explicit QtResizableLineEdit(QWidget* parent = 0);

+ ~QtResizableLineEdit();

+

+ bool isEditable() const;

+ void setEditable(const bool);

+

+ virtual QSize sizeHint() const;

+

+ private slots:

+ void textChanged(QString);

+

+ private:

+ bool editable;

+ };

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtTagComboBox.h"

+

+#include <QAbstractItemView>

+#include <QtGui>

+

+namespace Swift {

+

+QtTagComboBox::QtTagComboBox(QWidget* parent) : QComboBox(parent) {

+ setEditable(false);

+ displayModel = new QStandardItemModel();

+ displayItem = new QStandardItem();

+ displayItem->setText("");

+ displayModel->insertRow(0, displayItem);

+ editMenu = new QMenu();

+ this->setModel(displayModel);

+ editable = true;

+}

+

+QtTagComboBox::~QtTagComboBox() {

+

+}

+

+bool QtTagComboBox::isEditable() const {

+ return editable;

+}

+

+void QtTagComboBox::setEditable(const bool editable) {

+ this->editable = editable;

+}

+

+void QtTagComboBox::addTag(const QString &id, const QString &label) {

+ QAction* tagAction = new QAction(editMenu);

+ tagAction->setText(label);

+ tagAction->setCheckable(true);

+ tagAction->setData(QString(id));

+ editMenu->addAction(tagAction);

+}

+

+void QtTagComboBox::setTag(const QString &id, bool value) {

+ QList<QAction*> tagActions = editMenu->actions();

+ foreach(QAction* action, tagActions) {

+ if (action->data() == id) {

+ action->setChecked(value);

+ updateDisplayItem();

+ return;

+ }

+ }

+}

+

+bool QtTagComboBox::isTagSet(const QString &id) const {

+ QList<QAction*> tagActions = editMenu->actions();

+ foreach(QAction* action, tagActions) {

+ if (action->data() == id) {

+ return action->isChecked();

+ }

+ }

+ return false;

+}

+

+void QtTagComboBox::showPopup() {

+

+}

+

+void QtTagComboBox::hidePopup() {

+

+}

+

+bool QtTagComboBox::event(QEvent* event) {

+ if (event->type() == QEvent::MouseButtonPress ||

+ event->type() == QEvent::KeyRelease) {

+ if (!editable) return true;

+

+ QPoint p = mapToGlobal(QPoint(0,0));

+ p += QPoint(0, height());

+ editMenu->exec(p);

+ updateDisplayItem();

+ return true;

+ }

+ return QComboBox::event(event);

+}

+

+void QtTagComboBox::updateDisplayItem() {

+ QList<QAction*> tagActions = editMenu->actions();

+ QString text = "";

+ foreach(QAction* action, tagActions) {

+ if (action->isChecked()) {

+ if (text != "") {

+ text += ", ";

+ }

+ text += action->text();

+ }

+ }

+ setItemText(0, text);

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QComboBox>

+#include <QMenu>

+#include <QStandardItem>

+#include <QStandardItemModel>

+

+namespace Swift {

+

+class QtTagComboBox : public QComboBox {

+ Q_OBJECT

+ Q_PROPERTY(bool editable READ isEditable WRITE setEditable)

+

+ public:

+ explicit QtTagComboBox(QWidget* parent = 0);

+ ~QtTagComboBox();

+

+ bool isEditable() const;

+ void setEditable(const bool);

+

+ void addTag(const QString& id, const QString& label);

+ void setTag(const QString& id, bool value);

+ bool isTagSet(const QString& id) const;

+

+ virtual void showPopup();

+ virtual void hidePopup();

+

+ virtual bool event(QEvent* event);

+

+ private:

+ void updateDisplayItem();

+

+ private:

+ bool editable;

+ QStandardItemModel* displayModel;

+ QStandardItem* displayItem;

+ QMenu* editMenu;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardAddressField.h"

+

+#include <QGridLayout>

+