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

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

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

+ virtual void purgeCallbacks() {}

+

+ }

+}

+}

+ if (!editable) {

+ return;

+ }

+ Q_PROPERTY(bool editable READ isEditable WRITE setEditable)

+ void setEditable(bool b) {

+ editable = b;

+ }

+

+ bool isEditable() const {

+ return editable;

+ }

+

+ bool editable;

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

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

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

+std::string QtChatWindow::addMessage(const std::string &message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

+ return addMessage(linkimoticonify(P2QSTRING(message)), senderName, senderIsSelf, label, avatarPath, "", time, highlight);

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

+{

+ QString color = Qt::escape(P2QSTRING(highlight.getTextColor()));

+ QString background = Qt::escape(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) {

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

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

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

+std::string QtChatWindow::addAction(const std::string &message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

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

+// FIXME: Move this to a different file

+static QString encodeButtonArgument(const QString& str) {

+static QString decodeButtonArgument(const QString& str) {

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

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

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

+ replaceMessage(linkimoticonify(P2QSTRING(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;

+ // FIXME: Move this to a different file

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

+

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

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

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

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

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

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

+ QString getHighlightSpanStart(const HighlightAction& highlight);

+/*

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

+

+/*

+ * 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, 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, 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_;

+ };

+

+}

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

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

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

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

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

+

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

+ class StatusCache;

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

+ void handleCompactRosterToggled(bool);

+ QAction* compactRosterAction_;

+/*

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

+QtProfileWindow::QtProfileWindow(QWidget* parent) :

+ QWidget(parent),

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

+}

+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'>" + Qt::escape(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) {

+ onWindowClosed(jid);

+ event->accept();

+}

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

+ explicit QtProfileWindow(QWidget* parent = 0);

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

+/*

+ * 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 <Swift/QtUI/QtSettingsProvider.h>

+#include <Swiften/Base/foreach.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::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);

+ protected:

+ void resizeEvent(QResizeEvent*);

+ void moveEvent(QMoveEvent*);

+ private slots:

+ void handleSplitterMoved(int, int);

+ private:

+ void handleGeometryChanged();

+ void restoreSplitters();

+

+ private:

+

+ QtSettingsProvider* settings_;

+ };

+

+}

+

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

+

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

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

+ QSound::play(soundResource.c_str());

+ }

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

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

+#include <QtSingleWindow.h>

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

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

+//#define SWIFT_APPCAST_URL ""

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

+ QString emoticonFile = tokens[1];

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

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

+ }

+ emoticons[tokens[0]] = emoticonFile;

+ QMap<QString, QString> emoticons;

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

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

+

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

+ splitter_ = new QtSingleWindow(qtSettings_);

+ } else {

+ splitter_ = NULL;

+ }

+ statusCache_ = new StatusCache(applicationPathProvider_);

+

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

+ delete statusCache_;

+ class StatusCache;

+ class QtSingleWindow;

+ void loadEmoticonsFile(const QString& fileName, QMap<QString, QString>& emoticons);

+ QtSingleWindow* splitter_;

+ StatusCache* statusCache_;

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

+

+ virtual AlertType getWidgetAlertState() {return NoActivity;}

+ QtTabbable() : QWidget() {}

+#include <QtHighlightEditorWidget.h>

+#include <QtSingleWindow.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();

+}

+

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

+ QtSingleWindow* netbookSplitter;

+ StatusCache* statusCache;

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

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

+/*

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

+

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

+

+namespace Swift {

+

+QtVCardAddressField::QtVCardAddressField(QWidget* parent, QGridLayout *layout, bool editable) :

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Address")) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+}

+

+QtVCardAddressField::~QtVCardAddressField() {

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+}

+

+void QtVCardAddressField::setupContentWidgets() {

+ textFieldGridLayout = new QGridLayout();

+

+ streetLineEdit = new QtResizableLineEdit(this);

+ textFieldGridLayout->addWidget(streetLineEdit, 0, 0, Qt::AlignVCenter);

+

+ poboxLineEdit = new QtResizableLineEdit(this);

+ textFieldGridLayout->addWidget(poboxLineEdit, 0, 1, Qt::AlignVCenter);

+

+ addressextLineEdit = new QtResizableLineEdit(this);

+ textFieldGridLayout->addWidget(addressextLineEdit, 1, 0, Qt::AlignVCenter);

+

+ cityLineEdit = new QtResizableLineEdit(this);

+ textFieldGridLayout->addWidget(cityLineEdit, 2, 0, Qt::AlignVCenter);

+

+ pocodeLineEdit = new QtResizableLineEdit(this);

+ textFieldGridLayout->addWidget(pocodeLineEdit, 2, 1, Qt::AlignVCenter);

+

+ regionLineEdit = new QtResizableLineEdit(this);

+ textFieldGridLayout->addWidget(regionLineEdit, 3, 0, Qt::AlignVCenter);

+

+ countryLineEdit = new QtResizableLineEdit(this);

+ textFieldGridLayout->addWidget(countryLineEdit, 4, 0, Qt::AlignVCenter);

+ textFieldGridLayout->setVerticalSpacing(2);

+ getGridLayout()->addLayout(textFieldGridLayout, getGridLayout()->rowCount()-1, 2, 5, 2, Qt::AlignVCenter);

+ textFieldGridLayoutItem = getGridLayout()->itemAtPosition(getGridLayout()->rowCount()-1, 2);

+

+#if QT_VERSION >= 0x040700

+ streetLineEdit->setPlaceholderText(tr("Street"));

+ poboxLineEdit->setPlaceholderText(tr("PO Box"));

+ addressextLineEdit->setPlaceholderText(tr("Address Extension"));

+ cityLineEdit->setPlaceholderText(tr("City"));

+ pocodeLineEdit->setPlaceholderText(tr("Postal Code"));

+ regionLineEdit->setPlaceholderText(tr("Region"));

+ countryLineEdit->setPlaceholderText(tr("Country"));

+#endif

+

+ deliveryTypeLabel = new QLabel(this);

+ deliveryTypeLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);

+ getGridLayout()->addWidget(deliveryTypeLabel, getGridLayout()->rowCount()-3, 4, Qt::AlignVCenter);

+

+ domesticRadioButton = new QRadioButton(tr("Domestic Delivery"), this);

+ getGridLayout()->addWidget(domesticRadioButton, getGridLayout()->rowCount()-2, 4, Qt::AlignVCenter);

+

+ internationalRadioButton = new QRadioButton(tr("International Delivery"), this);

+ getGridLayout()->addWidget(internationalRadioButton, getGridLayout()->rowCount()-1, 4, Qt::AlignVCenter);

+

+ buttonGroup = new QButtonGroup(this);

+ buttonGroup->addButton(domesticRadioButton);

+ buttonGroup->addButton(internationalRadioButton);

+

+ setTabOrder(internationalRadioButton, getTagComboBox());

+ getTagComboBox()->addTag("postal", tr("Postal"));

+ getTagComboBox()->addTag("parcel", tr("Parcel"));

+

+ QtVCardHomeWork::setTagComboBox(getTagComboBox());

+

+ textFields << streetLineEdit << poboxLineEdit << addressextLineEdit << cityLineEdit << pocodeLineEdit << regionLineEdit << countryLineEdit;

+ childWidgets << deliveryTypeLabel << domesticRadioButton << internationalRadioButton;

+}

+

+void QtVCardAddressField::customCleanup() {

+ foreach(QWidget* widget, textFields) {

+ widget->hide();

+ textFieldGridLayout->removeWidget(widget);

+ }

+ getGridLayout()->removeItem(textFieldGridLayoutItem);

+}

+

+

+

+bool QtVCardAddressField::isEmpty() const {

+ return streetLineEdit->text().isEmpty() &&

+ poboxLineEdit->text().isEmpty() &&

+ addressextLineEdit->text().isEmpty() &&

+ cityLineEdit->text().isEmpty() &&

+ pocodeLineEdit->text().isEmpty() &&

+ regionLineEdit->text().isEmpty() &&

+ countryLineEdit->text().isEmpty();

+}

+

+void QtVCardAddressField::setAddress(const VCard::Address& address) {

+ setPreferred(address.isPreferred);

+ setHome(address.isHome);

+ setWork(address.isWork);

+ getTagComboBox()->setTag("postal", address.isPostal);

+ getTagComboBox()->setTag("parcel", address.isParcel);

+ domesticRadioButton->setChecked(address.deliveryType == VCard::DomesticDelivery);

+ internationalRadioButton->setChecked(address.deliveryType == VCard::InternationalDelivery);

+ streetLineEdit->setText(P2QSTRING(address.street));

+ poboxLineEdit->setText(P2QSTRING(address.poBox));

+ addressextLineEdit->setText(P2QSTRING(address.addressExtension));

+ cityLineEdit->setText(P2QSTRING(address.locality));

+ pocodeLineEdit->setText(P2QSTRING(address.postalCode));

+ regionLineEdit->setText(P2QSTRING(address.region));

+ countryLineEdit->setText(P2QSTRING(address.country));

+}

+

+VCard::Address QtVCardAddressField::getAddress() const {

+ VCard::Address address;

+ address.isPreferred = getPreferred();

+ address.isHome = getHome();

+ address.isWork = getWork();

+ address.deliveryType = domesticRadioButton->isChecked() ? VCard::DomesticDelivery : (internationalRadioButton->isChecked() ? VCard::InternationalDelivery : VCard::None);

+ address.isPostal = getTagComboBox()->isTagSet("postal");

+ address.isParcel = getTagComboBox()->isTagSet("parcel");

+ address.street = Q2PSTRING(streetLineEdit->text());

+ address.poBox = Q2PSTRING(poboxLineEdit->text());

+ address.addressExtension = Q2PSTRING(addressextLineEdit->text());

+ address.locality = Q2PSTRING(cityLineEdit->text());

+ address.postalCode = Q2PSTRING(pocodeLineEdit->text());

+ address.region = Q2PSTRING(regionLineEdit->text());

+ address.country = Q2PSTRING(countryLineEdit->text());

+ return address;

+}

+

+void QtVCardAddressField::handleEditibleChanged(bool isEditable) {

+ if (streetLineEdit) streetLineEdit->setEditable(isEditable);

+ if (poboxLineEdit) poboxLineEdit->setEditable(isEditable);

+ if (addressextLineEdit) addressextLineEdit->setEditable(isEditable);

+ if (cityLineEdit) cityLineEdit->setEditable(isEditable);

+ if (pocodeLineEdit) pocodeLineEdit->setEditable(isEditable);

+ if (regionLineEdit) regionLineEdit->setEditable(isEditable);

+ if (countryLineEdit) countryLineEdit->setEditable(isEditable);

+

+ if (deliveryTypeLabel) {

+ deliveryTypeLabel->setText(buttonGroup->checkedButton() == 0 ? "" : buttonGroup->checkedButton()->text());

+ deliveryTypeLabel->setVisible(!isEditable);

+ }

+ if (domesticRadioButton) domesticRadioButton->setVisible(isEditable);

+ if (internationalRadioButton) internationalRadioButton->setVisible(isEditable);

+

+ foreach (QWidget* widget, textFields) {

+ QtResizableLineEdit* lineEdit;

+ if ((lineEdit = dynamic_cast<QtResizableLineEdit*>(widget))) {

+ lineEdit->setShown(isEditable ? true : !lineEdit->text().isEmpty());

+ lineEdit->setStyleSheet(isEditable ? "" : "QLineEdit { border: none; background: transparent; }");

+ }

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swiften/Elements/VCard.h>

+

+#include <QButtonGroup>

+#include <QRadioButton>

+

+#include "QtResizableLineEdit.h"

+#include "QtVCardFieldInfo.h"

+#include "QtVCardGeneralField.h"

+#include "QtVCardHomeWork.h"

+

+namespace Swift {

+

+class QtVCardAddressField : public QtVCardGeneralField, public QtVCardHomeWork {

+ Q_OBJECT

+

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO("Address", UNLIMITED_INSTANCES, QtVCardAddressField)

+

+ QtVCardAddressField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardAddressField();

+

+ virtual bool isEmpty() const;

+

+ void setAddress(const VCard::Address& address);

+ VCard::Address getAddress() const;

+

+ protected:

+ virtual void setupContentWidgets();

+ virtual void customCleanup();

+

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+

+ private:

+ QList<QWidget*> textFields;

+ QtResizableLineEdit* streetLineEdit;

+ QtResizableLineEdit* poboxLineEdit;

+ QtResizableLineEdit* addressextLineEdit;

+ QtResizableLineEdit* cityLineEdit;

+ QtResizableLineEdit* pocodeLineEdit;

+ QtResizableLineEdit* regionLineEdit;

+ QtResizableLineEdit* countryLineEdit;

+ QGridLayout* textFieldGridLayout;

+ QLayoutItem* textFieldGridLayoutItem;

+

+ QLabel* deliveryTypeLabel;

+ QRadioButton* domesticRadioButton;

+ QRadioButton* internationalRadioButton;

+ QButtonGroup* buttonGroup;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardAddressLabelField.h"

+

+#include <QGridLayout>

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

+

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

+

+namespace Swift {

+

+QtVCardAddressLabelField::QtVCardAddressLabelField(QWidget* parent, QGridLayout *layout, bool editable) :

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Address Label")) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+}

+

+QtVCardAddressLabelField::~QtVCardAddressLabelField() {

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+}

+

+void QtVCardAddressLabelField::setupContentWidgets() {

+ addressLabelPlainTextEdit = new QPlainTextEdit(this);

+ addressLabelPlainTextEdit->setTabChangesFocus(true);

+ getGridLayout()->addWidget(addressLabelPlainTextEdit, getGridLayout()->rowCount()-1, 2, 3, 2, Qt::AlignVCenter);

+

+ deliveryTypeLabel = new QLabel(this);

+ deliveryTypeLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);

+ getGridLayout()->addWidget(deliveryTypeLabel, getGridLayout()->rowCount()-2, 4, Qt::AlignVCenter);

+

+ domesticRadioButton = new QRadioButton(tr("Domestic Delivery"), this);

+ getGridLayout()->addWidget(domesticRadioButton, getGridLayout()->rowCount()-2, 4, Qt::AlignVCenter);

+

+ internationalRadioButton = new QRadioButton(tr("International Delivery"), this);

+ getGridLayout()->addWidget(internationalRadioButton, getGridLayout()->rowCount()-1, 4, Qt::AlignVCenter);

+

+ buttonGroup = new QButtonGroup(this);

+ buttonGroup->addButton(domesticRadioButton);

+ buttonGroup->addButton(internationalRadioButton);

+

+ setTabOrder(internationalRadioButton, getTagComboBox());

+ getTagComboBox()->addTag("postal", tr("Postal"));

+ getTagComboBox()->addTag("parcel", tr("Parcel"));

+

+ QtVCardHomeWork::setTagComboBox(getTagComboBox());

+ deliveryTypeLabel->hide();

+ childWidgets << addressLabelPlainTextEdit << deliveryTypeLabel << domesticRadioButton << internationalRadioButton;

+}

+

+bool QtVCardAddressLabelField::isEmpty() const {

+ return addressLabelPlainTextEdit->toPlainText().isEmpty();

+}

+

+void QtVCardAddressLabelField::setAddressLabel(const VCard::AddressLabel& addressLabel) {

+ setPreferred(addressLabel.isPreferred);

+ setHome(addressLabel.isHome);

+ setWork(addressLabel.isWork);

+ getTagComboBox()->setTag("postal", addressLabel.isPostal);

+ getTagComboBox()->setTag("parcel", addressLabel.isParcel);

+ domesticRadioButton->setChecked(addressLabel.deliveryType == VCard::DomesticDelivery);

+ internationalRadioButton->setChecked(addressLabel.deliveryType == VCard::InternationalDelivery);

+ std::string joinedLines = boost::algorithm::join(addressLabel.lines, "\n");

+ addressLabelPlainTextEdit->setPlainText(P2QSTRING(joinedLines));

+}

+

+VCard::AddressLabel QtVCardAddressLabelField::getAddressLabel() const {

+ VCard::AddressLabel addressLabel;

+ addressLabel.isPreferred = getPreferred();

+ addressLabel.isHome = getHome();

+ addressLabel.isWork = getWork();

+ addressLabel.deliveryType = domesticRadioButton->isChecked() ? VCard::DomesticDelivery : (internationalRadioButton->isChecked() ? VCard::InternationalDelivery : VCard::None);

+ addressLabel.isPostal = getTagComboBox()->isTagSet("postal");

+ addressLabel.isParcel = getTagComboBox()->isTagSet("parcel");

+

+ std::string lines = Q2PSTRING(addressLabelPlainTextEdit->toPlainText());

+ boost::split(addressLabel.lines, lines, boost::is_any_of("\n"));

+ return addressLabel;

+}

+

+void QtVCardAddressLabelField::handleEditibleChanged(bool isEditable) {

+ if (addressLabelPlainTextEdit) {

+ addressLabelPlainTextEdit->setReadOnly(!isEditable);

+ addressLabelPlainTextEdit->setStyleSheet(isEditable ? "" : "QPlainTextEdit { background: transparent; }");

+ }

+

+ if (deliveryTypeLabel) {

+ deliveryTypeLabel->setText(buttonGroup->checkedButton() == 0 ? "" : buttonGroup->checkedButton()->text());

+ deliveryTypeLabel->setVisible(!isEditable);

+ }

+ if (domesticRadioButton) domesticRadioButton->setVisible(isEditable);

+ if (internationalRadioButton) internationalRadioButton->setVisible(isEditable);

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QButtonGroup>

+#include <QPlainTextEdit>

+#include <QRadioButton>

+#include <Swiften/Elements/VCard.h>

+

+#include "QtVCardFieldInfo.h"

+#include "QtVCardGeneralField.h"

+#include "QtVCardHomeWork.h"

+

+namespace Swift {

+

+class QtVCardAddressLabelField : public QtVCardGeneralField, public QtVCardHomeWork {

+ Q_OBJECT

+

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO("AddressLabel", UNLIMITED_INSTANCES, QtVCardAddressLabelField)

+

+ QtVCardAddressLabelField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardAddressLabelField();

+

+ virtual bool isEmpty() const;

+

+ void setAddressLabel(const VCard::AddressLabel& addressLabel);

+ VCard::AddressLabel getAddressLabel() const;

+

+ protected:

+ virtual void setupContentWidgets();

+

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+

+ private:

+ QPlainTextEdit* addressLabelPlainTextEdit;

+

+ QLabel* deliveryTypeLabel;

+ QRadioButton* domesticRadioButton;

+ QRadioButton* internationalRadioButton;

+ QButtonGroup* buttonGroup;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardBirthdayField.h"

+

+#include <QGridLayout>

+#include <QHBoxLayout>

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

+

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

+

+namespace Swift {

+

+QtVCardBirthdayField::QtVCardBirthdayField(QWidget* parent, QGridLayout *layout, bool editable) :

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Birthday"), false, false) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+}

+

+QtVCardBirthdayField::~QtVCardBirthdayField() {

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+}

+

+void QtVCardBirthdayField::setupContentWidgets() {

+ birthdayLabel = new QLabel(this);

+ birthdayLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);

+ birthdayDateEdit = new QDateEdit(this);

+ birthdayDateEdit->setCalendarPopup(true);

+

+ QHBoxLayout* birthdayLayout = new QHBoxLayout();

+ birthdayLayout->addWidget(birthdayLabel);

+ birthdayLayout->addWidget(birthdayDateEdit);

+

+ getGridLayout()->addLayout(birthdayLayout, getGridLayout()->rowCount()-1, 2, Qt::AlignVCenter);

+

+ getTagComboBox()->hide();

+ birthdayLabel->hide();

+ childWidgets << birthdayLabel << birthdayDateEdit;

+}

+

+bool QtVCardBirthdayField::isEmpty() const {

+ return false;

+}

+

+void QtVCardBirthdayField::setBirthday(const boost::posix_time::ptime& birthday) {

+ birthdayDateEdit->setDate(B2QDATE(birthday).date());

+}

+

+boost::posix_time::ptime QtVCardBirthdayField::getBirthday() const {

+ return boost::posix_time::from_time_t(QDateTime(birthdayDateEdit->date()).toTime_t());

+}

+

+void QtVCardBirthdayField::handleEditibleChanged(bool isEditable) {

+ birthdayLabel->setText(birthdayDateEdit->date().toString(Qt::DefaultLocaleLongDate));

+ birthdayDateEdit->setVisible(isEditable);

+ birthdayLabel->setVisible(!isEditable);

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QDateEdit>

+#include <Swiften/Elements/VCard.h>

+

+#include "QtCloseButton.h"

+#include "QtVCardFieldInfo.h"

+#include "QtVCardGeneralField.h"

+

+namespace Swift {

+

+class QtVCardBirthdayField : public QtVCardGeneralField {

+ Q_OBJECT

+

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO("Birthday", 1, QtVCardBirthdayField)

+

+ QtVCardBirthdayField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardBirthdayField();

+

+ virtual bool isEmpty() const;

+

+ void setBirthday(const boost::posix_time::ptime& addressLabel);

+ boost::posix_time::ptime getBirthday() const;

+

+ protected:

+ virtual void setupContentWidgets();

+

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+

+ private:

+ QLabel* birthdayLabel;

+ QDateEdit* birthdayDateEdit;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardDescriptionField.h"

+

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

+#include <QFontMetrics>

+#include <QGridLayout>

+

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

+

+namespace Swift {

+

+QtVCardDescriptionField::QtVCardDescriptionField(QWidget* parent, QGridLayout *layout, bool editable) :

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Description"), false, false) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+}

+

+QtVCardDescriptionField::~QtVCardDescriptionField() {

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+}

+

+void QtVCardDescriptionField::setupContentWidgets() {

+ descriptionPlainTextEdit = new QPlainTextEdit(this);

+ descriptionPlainTextEdit->setMinimumHeight(70);

+ getGridLayout()->addWidget(descriptionPlainTextEdit, getGridLayout()->rowCount()-1, 2, 2, 2, Qt::AlignVCenter);

+ getTagComboBox()->hide();

+ childWidgets << descriptionPlainTextEdit;

+}

+

+bool QtVCardDescriptionField::isEmpty() const {

+ return descriptionPlainTextEdit->toPlainText().isEmpty();

+}

+

+void QtVCardDescriptionField::setDescription(const std::string& description) {

+ descriptionPlainTextEdit->setPlainText(P2QSTRING(description));

+}

+

+std::string QtVCardDescriptionField::getDescription() const {

+ return Q2PSTRING(descriptionPlainTextEdit->toPlainText());

+}

+

+void QtVCardDescriptionField::handleEditibleChanged(bool isEditable) {

+ if (descriptionPlainTextEdit) {

+ if (isEditable) {

+ descriptionPlainTextEdit->setMinimumHeight(70);

+ } else {

+ QFontMetrics inputMetrics(descriptionPlainTextEdit->document()->defaultFont());

+ QRect horizontalBounds = contentsRect().adjusted(0,0,0,9999);

+ QRect boundingRect = inputMetrics.boundingRect(horizontalBounds, Qt::TextWordWrap, descriptionPlainTextEdit->toPlainText() + "A");

+ int left, top, right, bottom;

+ getContentsMargins(&left, &top, &right, &bottom);

+ int height = boundingRect.height() + top + bottom + inputMetrics.height();

+ descriptionPlainTextEdit->setMinimumHeight(height > 70 ? 70 : height);

+ }

+ descriptionPlainTextEdit->setReadOnly(!isEditable);

+ descriptionPlainTextEdit->setStyleSheet(isEditable ? "" : "QPlainTextEdit { background: transparent; }");

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swiften/Elements/VCard.h>

+

+#include <QPlainTextEdit>

+

+#include "QtVCardFieldInfo.h"

+#include "QtVCardGeneralField.h"

+

+namespace Swift {

+

+class QtVCardDescriptionField : public QtVCardGeneralField {

+ Q_OBJECT

+

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO("Description", 1, QtVCardDescriptionField)

+

+ QtVCardDescriptionField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardDescriptionField();

+

+ virtual bool isEmpty() const;

+

+ void setDescription(const std::string& description);

+ std::string getDescription() const;

+

+ protected:

+ virtual void setupContentWidgets();

+

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+

+ private:

+ QPlainTextEdit* descriptionPlainTextEdit;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QGridLayout>

+#include <QObject>

+#include <QString>

+#include <typeinfo>

+

+#define GENERIC_QT_VCARD_FIELD_INFO(MENU_NAME, ALLOWED_INSTANCES, FIELD_CLASS) \

+ class FieldInfo : public QtVCardFieldInfo { \

+ public: \

+ virtual ~FieldInfo() { \

+ } \

+ \

+ virtual QString getMenuName() const { \

+ return QObject::tr(MENU_NAME); \

+ } \

+ \

+ virtual int getAllowedInstances() const { \

+ return ALLOWED_INSTANCES; \

+ } \

+ \

+ virtual QWidget* createFieldInstance(QWidget* parent, QGridLayout* layout, bool editable) const { \

+ return new FIELD_CLASS(parent, layout, editable); \

+ } \

+ \

+ virtual bool testInstance(QWidget* widget) const { \

+ return dynamic_cast<FIELD_CLASS*>(widget) != 0; \

+ } \

+ };

+

+class QWidget;

+

+namespace Swift {

+

+ class QtVCardFieldInfo {

+ public:

+ static const int UNLIMITED_INSTANCES = -1;

+

+ virtual ~QtVCardFieldInfo() {

+ }

+ virtual QString getMenuName() const = 0;

+ virtual int getAllowedInstances() const = 0;

+ virtual QWidget* createFieldInstance(QWidget* parent, QGridLayout* layout, bool editable) const = 0;

+ virtual bool testInstance(QWidget*) const = 0;

+ };

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardGeneralField.h"

+

+#include <QHBoxLayout>

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

+

+namespace Swift {

+

+QtVCardGeneralField::QtVCardGeneralField(QWidget* parent, QGridLayout* layout, bool editable, int row, QString label, bool preferrable, bool taggable) :

+ QWidget(parent), preferrable(preferrable), taggable(taggable), layout(layout), row(row), preferredCheckBox(0), label(0), labelText(label),

+ tagComboBox(0), closeButton(0) {

+ setEditable(editable);

+}

+

+QtVCardGeneralField::~QtVCardGeneralField() {

+

+}

+

+void QtVCardGeneralField::initialize() {

+ if (preferrable) {

+ preferredCheckBox = new QCheckBox(this);

+ preferredCheckBox->setStyleSheet(

+ "QCheckBox::indicator { width: 18px; height: 18px; }"

+ "QCheckBox::indicator:checked { image: url(:/icons/star-checked.png); }"

+ "QCheckBox::indicator:unchecked { image: url(:/icons/star-unchecked); }"

+ );

+ layout->addWidget(preferredCheckBox, row, 0, Qt::AlignVCenter);

+ childWidgets << preferredCheckBox;

+ }

+ label = new QLabel(this);

+ label->setText(labelText);

+ layout->addWidget(label, row, 1, Qt::AlignVCenter | Qt::AlignRight);

+

+ tagLabel = new QLabel(this);

+ tagLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);

+

+ tagComboBox = new QtTagComboBox(this);

+ closeButton = new QtCloseButton(this);

+ connect(closeButton, SIGNAL(clicked()), SLOT(handleCloseButtonClicked()));

+

+ QHBoxLayout* tagLayout = new QHBoxLayout();

+ tagLayout->addWidget(tagLabel);

+ tagLayout->addWidget(tagComboBox);

+

+ setupContentWidgets();

+ layout->addLayout(tagLayout, row, 4, Qt::AlignTop);

+ layout->addWidget(closeButton, row, 5, Qt::AlignCenter);

+ closeButton->resize(12, 12);

+ tagLabel->hide();

+

+ childWidgets << label << tagComboBox << tagLabel << closeButton;

+}

+

+bool QtVCardGeneralField::isEditable() const {

+ return editable;

+}

+

+void QtVCardGeneralField::setEditable(bool editable) {

+ this->editable = editable;

+ if (tagComboBox) {

+ if (taggable) {

+ tagLabel->setText(tagComboBox->itemText(0));

+ tagComboBox->setVisible(editable);

+ tagLabel->setVisible(!editable);

+ } else {

+ tagLabel->hide();

+ tagComboBox->hide();

+ }

+ }

+ if (closeButton) closeButton->setVisible(editable);

+ if (preferredCheckBox) {

+ if (editable) {

+ preferredCheckBox->show();

+ } else if (!preferredCheckBox->isChecked()) {

+ preferredCheckBox->hide();

+ }

+ preferredCheckBox->setEnabled(editable);

+ }

+ editableChanged(this->editable);

+}

+

+void QtVCardGeneralField::setPreferred(const bool preferred) {

+ if (preferredCheckBox) preferredCheckBox->setChecked(preferred);

+}

+

+bool QtVCardGeneralField::getPreferred() const {

+ return preferredCheckBox ? preferredCheckBox->isChecked() : false;

+}

+

+void QtVCardGeneralField::customCleanup() {

+}

+

+QtTagComboBox* QtVCardGeneralField::getTagComboBox() const {

+ return tagComboBox;

+}

+

+QGridLayout* QtVCardGeneralField::getGridLayout() const {

+ return layout;

+}

+

+void QtVCardGeneralField::handleCloseButtonClicked() {

+ customCleanup();

+ foreach(QWidget* widget, childWidgets) {

+ widget->hide();

+ layout->removeWidget(widget);

+ }

+ deleteField(this);

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QCheckBox>

+#include <QGridLayout>

+#include <QLabel>

+#include <QWidget>

+

+#include "QtCloseButton.h"

+#include "QtTagComboBox.h"

+

+namespace Swift {

+

+/*

+ * covers features like:

+ * - preffered (star ceckbox)

+ * - combo check boxh

+ * - label

+ * - remove button

+ */

+class QtVCardGeneralField : public QWidget {

+ Q_OBJECT

+ Q_PROPERTY(bool editable READ isEditable WRITE setEditable NOTIFY editableChanged)

+ Q_PROPERTY(bool empty READ isEmpty)

+

+ public:

+ explicit QtVCardGeneralField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false, int row = 0, QString label = QString(),

+ bool preferrable = true, bool taggable = true);

+ virtual ~QtVCardGeneralField();

+

+ void initialize();

+

+ virtual bool isEditable() const;

+ virtual void setEditable(bool);

+

+ virtual bool isEmpty() const = 0;

+

+ void setPreferred(const bool preferred);

+ bool getPreferred() const;

+

+ protected:

+ virtual void setupContentWidgets() = 0;

+ virtual void customCleanup();

+

+ QtTagComboBox* getTagComboBox() const;

+ QGridLayout* getGridLayout() const;

+

+ signals:

+ void editableChanged(bool);

+ void deleteField(QtVCardGeneralField*);

+

+ public slots:

+ void handleCloseButtonClicked();

+

+ protected:

+ QList<QWidget*> childWidgets;

+

+ private:

+ bool editable;

+ bool preferrable;

+ bool taggable;

+ QGridLayout* layout;

+ int row;

+ QCheckBox* preferredCheckBox;

+ QLabel* label;

+ QString labelText;

+ QtTagComboBox* tagComboBox;

+ QLabel* tagLabel;

+ QtCloseButton* closeButton;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardHomeWork.h"

+

+namespace Swift {

+

+QtVCardHomeWork::QtVCardHomeWork() : tagComboBox(0) {

+}

+

+QtVCardHomeWork::~QtVCardHomeWork() {

+}

+

+void QtVCardHomeWork::setTagComboBox(QtTagComboBox* tagBox) {

+ tagComboBox = tagBox;

+ tagComboBox->addTag("home", QObject::tr("Home"));

+ tagComboBox->addTag("work", QObject::tr("Work"));

+}

+

+void QtVCardHomeWork::setHome(const bool home) {

+ tagComboBox->setTag("home", home);

+}

+

+bool QtVCardHomeWork::getHome() const {

+ return tagComboBox->isTagSet("home");

+}

+

+void QtVCardHomeWork::setWork(const bool work) {

+ tagComboBox->setTag("work", work);

+}

+

+bool QtVCardHomeWork::getWork() const {

+ return tagComboBox->isTagSet("work");

+}

+

+}

+

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QObject>

+

+#include "QtTagComboBox.h"

+

+namespace Swift {

+

+class QtVCardHomeWork {

+ public:

+ QtVCardHomeWork();

+ virtual ~QtVCardHomeWork();

+

+ void setTagComboBox(QtTagComboBox* tagBox);

+

+ void setHome(const bool home);

+ bool getHome() const;

+ void setWork(const bool work);

+ bool getWork() const;

+

+ private:

+ QtTagComboBox* tagComboBox;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardInternetEMailField.h"

+

+#include <QGridLayout>

+#include <QHBoxLayout>

+#include <QTextDocument>

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

+

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

+

+namespace Swift {

+

+QtVCardInternetEMailField::QtVCardInternetEMailField(QWidget* parent, QGridLayout *layout, bool editable) :

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("E-Mail")) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+}

+

+QtVCardInternetEMailField::~QtVCardInternetEMailField() {

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+}

+

+void QtVCardInternetEMailField::setupContentWidgets() {

+ emailLabel = new QLabel(this);

+ emailLabel->setOpenExternalLinks(true);

+ emailLabel->setTextInteractionFlags(Qt::LinksAccessibleByMouse | Qt::LinksAccessibleByKeyboard);

+ emailLineEdit = new QtResizableLineEdit(this);

+#if QT_VERSION >= 0x040700

+ emailLineEdit->setPlaceholderText(tr("alice@wonderland.lit"));

+#endif

+ QHBoxLayout* emailLayout = new QHBoxLayout();

+ emailLayout->addWidget(emailLabel);

+ emailLayout->addWidget(emailLineEdit);

+ getGridLayout()->addLayout(emailLayout, getGridLayout()->rowCount()-1, 2, 1, 2, Qt::AlignVCenter);

+ setTabOrder(emailLineEdit, getTagComboBox());

+ QtVCardHomeWork::setTagComboBox(getTagComboBox());

+ emailLabel->hide();

+ childWidgets << emailLabel << emailLineEdit;

+}

+

+bool QtVCardInternetEMailField::isEmpty() const {

+ return emailLineEdit->text().isEmpty();

+}

+

+void QtVCardInternetEMailField::setInternetEMailAddress(const VCard::EMailAddress& address) {

+ assert(address.isInternet);

+ setPreferred(address.isPreferred);

+ setHome(address.isHome);

+ setWork(address.isWork);

+ emailLineEdit->setText(P2QSTRING(address.address));

+}

+

+VCard::EMailAddress QtVCardInternetEMailField::getInternetEMailAddress() const {

+ VCard::EMailAddress address;

+ address.isInternet = true;

+ address.isPreferred = getPreferred();

+ address.isHome = getHome();

+ address.isWork = getWork();

+ address.address = Q2PSTRING(emailLineEdit->text());

+ return address;

+}

+

+void QtVCardInternetEMailField::handleEditibleChanged(bool isEditable) {

+ if (isEditable) {

+ if (emailLineEdit) emailLineEdit->show();

+ if (emailLabel) emailLabel->hide();

+ } else {

+ if (emailLineEdit) emailLineEdit->hide();

+ if (emailLabel) {

+ emailLabel->setText(QString("<a href=\"mailto:%1\">%1</a>").arg(Qt::escape(emailLineEdit->text())));

+ emailLabel->show();

+ }

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swiften/Elements/VCard.h>

+

+#include "QtResizableLineEdit.h"

+#include "QtVCardFieldInfo.h"

+#include "QtVCardGeneralField.h"

+#include "QtVCardHomeWork.h"

+

+namespace Swift {

+

+class QtVCardInternetEMailField : public QtVCardGeneralField, public QtVCardHomeWork {

+ Q_OBJECT

+

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO("E-Mail", UNLIMITED_INSTANCES, QtVCardInternetEMailField)

+

+ QtVCardInternetEMailField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardInternetEMailField();

+

+ virtual bool isEmpty() const;

+

+ void setInternetEMailAddress(const VCard::EMailAddress& address);

+ VCard::EMailAddress getInternetEMailAddress() const;

+

+ protected:

+ virtual void setupContentWidgets();

+

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+

+ private:

+ QtResizableLineEdit* emailLineEdit;

+ QLabel* emailLabel;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardJIDField.h"

+

+#include <QGridLayout>

+#include <QTextDocument>

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

+

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

+

+namespace Swift {

+

+QtVCardJIDField::QtVCardJIDField(QWidget* parent, QGridLayout *layout, bool editable) :

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("JID"), false, false) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+}

+

+QtVCardJIDField::~QtVCardJIDField() {

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+}

+

+void QtVCardJIDField::setupContentWidgets() {

+ jidLabel = new QLabel(this);

+ jidLabel->setOpenExternalLinks(true);

+ jidLabel->setTextInteractionFlags(Qt::LinksAccessibleByMouse | Qt::LinksAccessibleByKeyboard);

+ jidLineEdit = new QtResizableLineEdit(this);

+#if QT_VERSION >= 0x040700

+ jidLineEdit->setPlaceholderText(tr("alice@wonderland.lit"));

+#endif

+ QHBoxLayout* jidLayout = new QHBoxLayout();

+ jidLayout->addWidget(jidLabel);

+ jidLayout->addWidget(jidLineEdit);

+ getGridLayout()->addLayout(jidLayout, getGridLayout()->rowCount()-1, 2, 1, 2, Qt::AlignVCenter);

+

+ jidLabel->hide();

+ getTagComboBox()->hide();

+

+ childWidgets << jidLabel << jidLineEdit;

+}

+

+bool QtVCardJIDField::isEmpty() const {

+ return jidLineEdit->text().isEmpty();

+}

+

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

+ std::string jidStr = jid.toBare().toString();

+ jidLineEdit->setText(P2QSTRING(jidStr));

+}

+

+JID QtVCardJIDField::getJID() const {

+ return JID(Q2PSTRING(jidLineEdit->text()));

+}

+

+void QtVCardJIDField::handleEditibleChanged(bool isEditable) {

+ if (isEditable) {

+ if (jidLineEdit) jidLineEdit->show();

+ if (jidLabel) jidLabel->hide();

+ } else {

+ if (jidLineEdit) jidLineEdit->hide();

+ if (jidLabel) {

+ jidLabel->setText(QString("<a href=\"xmpp:%1\">%1</a>").arg(Qt::escape(jidLineEdit->text())));

+ jidLabel->show();

+ }

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swiften/Elements/VCard.h>

+

+#include "QtResizableLineEdit.h"

+#include "QtVCardFieldInfo.h"

+#include "QtVCardGeneralField.h"

+

+namespace Swift {

+

+class QtVCardJIDField : public QtVCardGeneralField {

+ Q_OBJECT

+

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO("JID", UNLIMITED_INSTANCES, QtVCardJIDField)

+

+ QtVCardJIDField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardJIDField();

+

+ virtual bool isEmpty() const;

+

+ void setJID(const JID& jid);

+ JID getJID() const;

+

+ protected:

+ virtual void setupContentWidgets();

+

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+

+ private:

+ QLabel* jidLabel;

+ QtResizableLineEdit* jidLineEdit;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardOrganizationField.h"

+

+#include <QGridLayout>

+#include <QHBoxLayout>

+#include <QHeaderView>

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

+

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

+

+namespace Swift {

+

+QtVCardOrganizationField::QtVCardOrganizationField(QWidget* parent, QGridLayout *layout, bool editable) :

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Organisation"), false, false) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+}

+

+QtVCardOrganizationField::~QtVCardOrganizationField() {

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+}

+

+void QtVCardOrganizationField::setupContentWidgets() {

+ organizationLabel = new QLabel(this);

+ organizationLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);

+ organizationLineEdit = new QtResizableLineEdit(this);

+ QHBoxLayout* organizationLayout = new QHBoxLayout();

+ organizationLayout->addWidget(organizationLabel);

+ organizationLayout->addWidget(organizationLineEdit);

+

+ getGridLayout()->addLayout(organizationLayout, getGridLayout()->rowCount()-1, 2, 1, 2, Qt::AlignVCenter);

+

+ itemDelegate = new QtRemovableItemDelegate(style());

+

+ unitsTreeWidget = new QTreeWidget(this);

+ unitsTreeWidget->setColumnCount(2);

+ unitsTreeWidget->header()->setStretchLastSection(false);

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

+ unitsTreeWidget->header()->resizeSection(1, closeIconWidth);

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

+ unitsTreeWidget->setHeaderHidden(true);

+ unitsTreeWidget->setRootIsDecorated(false);

+ unitsTreeWidget->setEditTriggers(QAbstractItemView::DoubleClicked);

+ unitsTreeWidget->setItemDelegateForColumn(1, itemDelegate);

+ connect(unitsTreeWidget, SIGNAL(itemChanged(QTreeWidgetItem*,int)), SLOT(handleItemChanged(QTreeWidgetItem*,int)));

+ getGridLayout()->addWidget(unitsTreeWidget, getGridLayout()->rowCount()-1, 4, 2, 1);

+

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

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

+ unitsTreeWidget->addTopLevelItem(item);

+

+ getTagComboBox()->hide();

+ organizationLabel->hide();

+ childWidgets << organizationLabel << organizationLineEdit << unitsTreeWidget;

+}

+

+bool QtVCardOrganizationField::isEmpty() const {

+ return organizationLineEdit->text().isEmpty() && unitsTreeWidget->model()->rowCount() != 0;

+}

+

+void QtVCardOrganizationField::setOrganization(const VCard::Organization& organization) {

+ organizationLineEdit->setText(P2QSTRING(organization.name));

+ unitsTreeWidget->clear();

+ foreach(std::string unit, organization.units) {

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

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

+ unitsTreeWidget->addTopLevelItem(item);

+ }

+}

+

+VCard::Organization QtVCardOrganizationField::getOrganization() const {

+ VCard::Organization organization;

+ organization.name = Q2PSTRING(organizationLineEdit->text());

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

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

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

+ organization.units.push_back(Q2PSTRING(row->text(0)));

+ }

+ }

+

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

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

+ unitsTreeWidget->addTopLevelItem(item);

+

+ return organization;

+}

+

+void QtVCardOrganizationField::handleEditibleChanged(bool isEditable) {

+ if (organizationLineEdit) {

+ organizationLineEdit->setVisible(isEditable);

+ organizationLabel->setVisible(!isEditable);

+

+ if (!isEditable) {

+ QString label;

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

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

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

+ label += row->text(0) + ", ";

+ }

+ }

+ label += organizationLineEdit->text();

+ organizationLabel->setText(label);

+ }

+ }

+ if (unitsTreeWidget) unitsTreeWidget->setVisible(isEditable);

+}

+

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

+ bool hasEmptyRow = false;

+ QList<QTreeWidgetItem*> rows = unitsTreeWidget->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);

+ unitsTreeWidget->addTopLevelItem(item);

+ }

+ getTagComboBox()->hide();

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swiften/Elements/VCard.h>

+

+#include <QTreeWidget>

+

+#include "QtRemovableItemDelegate.h"

+#include "QtResizableLineEdit.h"

+#include "QtVCardFieldInfo.h"

+#include "QtVCardGeneralField.h"

+

+namespace Swift {

+

+class QtVCardOrganizationField : public QtVCardGeneralField {

+ Q_OBJECT

+

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO("Organization", UNLIMITED_INSTANCES, QtVCardOrganizationField)

+

+ QtVCardOrganizationField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardOrganizationField();

+

+ virtual bool isEmpty() const;

+

+ void setOrganization(const VCard::Organization& organization);

+ VCard::Organization getOrganization() const;

+

+ protected:

+ virtual void setupContentWidgets();

+

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+

+ private slots:

+ void handleItemChanged(QTreeWidgetItem*, int);

+

+ private:

+ QLabel* organizationLabel;

+ QtResizableLineEdit* organizationLineEdit;

+ QTreeWidget* unitsTreeWidget;

+ QtRemovableItemDelegate* itemDelegate;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardPhotoAndNameFields.h"

+#include "ui_QtVCardPhotoAndNameFields.h"

+

+#include <QMenu>

+

+namespace Swift {

+

+QtVCardPhotoAndNameFields::QtVCardPhotoAndNameFields(QWidget* parent) :

+ QWidget(parent),

+ ui(new Ui::QtVCardPhotoAndNameFields) {

+ ui->setupUi(this);

+ ui->lineEditPREFIX->hide();

+ ui->lineEditMIDDLE->hide();

+ ui->lineEditSUFFIX->hide();

+ ui->lineEditFN->hide();

+ ui->lineEditNICKNAME->hide();

+ ui->labelFULLNAME->hide();

+

+#if QT_VERSION >= 0x040700

+ ui->lineEditFN->setPlaceholderText(tr("Formatted Name"));

+ ui->lineEditNICKNAME->setPlaceholderText(tr("Nickname"));

+ ui->lineEditPREFIX->setPlaceholderText(tr("Prefix"));

+ ui->lineEditGIVEN->setPlaceholderText(tr("Given Name"));

+ ui->lineEditMIDDLE->setPlaceholderText(tr("Middle Name"));

+ ui->lineEditFAMILY->setPlaceholderText(tr("Last Name"));

+ ui->lineEditSUFFIX->setPlaceholderText(tr("Suffix"));

+#endif

+

+ addFieldMenu = new QMenu("Name", this);

+

+ actionSignalMapper = new QSignalMapper(this);

+

+ connect(actionSignalMapper, SIGNAL(mapped(const QString &)), this, SLOT(showField(const QString &)));

+ prepareAddFieldMenu();

+}

+

+QtVCardPhotoAndNameFields::~QtVCardPhotoAndNameFields() {

+ delete ui;

+ delete actionSignalMapper;

+}

+

+bool QtVCardPhotoAndNameFields::isEditable() const {

+ return editable;

+}

+

+void QtVCardPhotoAndNameFields::setEditable(bool editable) {

+ this->editable = editable;

+

+ ui->avatarWidget->setEditable(editable);

+ ui->lineEditFN->setVisible(editable ? true : !ui->lineEditFN->text().isEmpty());

+ ui->lineEditFN->setEditable(editable);

+ ui->lineEditFN->setStyleSheet(editable ? "" : "QLineEdit {border: none; background-color: transparent;}");

+

+ ui->lineEditNICKNAME->setVisible(editable ? true : !ui->lineEditNICKNAME->text().isEmpty());

+ ui->lineEditNICKNAME->setEditable(editable);

+ ui->lineEditNICKNAME->setStyleSheet(editable ? "" : "QLineEdit {border: none; background-color: transparent;}");

+

+ // prefix given middle last suffix

+ ui->lineEditPREFIX->setVisible(editable);

+ ui->lineEditGIVEN->setVisible(editable);

+ ui->lineEditMIDDLE->setVisible(editable);

+ ui->lineEditFAMILY->setVisible(editable);

+ ui->lineEditSUFFIX->setVisible(editable);

+ ui->labelFULLNAME->setVisible(!editable);

+ ui->labelFULLNAME->setText( ui->lineEditPREFIX->text() + " " + ui->lineEditGIVEN->text() + " " +

+ ui->lineEditMIDDLE->text() + " " + ui->lineEditFAMILY->text() + " " + ui->lineEditSUFFIX->text());

+

+ prepareAddFieldMenu();

+}

+

+QMenu* QtVCardPhotoAndNameFields::getAddFieldMenu() const {

+ return addFieldMenu;

+}

+

+void QtVCardPhotoAndNameFields::setAvatar(const ByteArray &data, const std::string &type) {

+ ui->avatarWidget->setAvatar(data, type);

+}

+

+ByteArray QtVCardPhotoAndNameFields::getAvatarData() const {

+ return ui->avatarWidget->getAvatarData();

+}

+

+std::string QtVCardPhotoAndNameFields::getAvatarType() const {

+ return ui->avatarWidget->getAvatarType();

+}

+

+void QtVCardPhotoAndNameFields::setFormattedName(const QString formattedName) {

+ ui->lineEditFN->setText(formattedName);

+}

+

+QString QtVCardPhotoAndNameFields::getFormattedName() const {

+ return ui->lineEditFN->text();

+}

+

+void QtVCardPhotoAndNameFields::setNickname(const QString nickname) {

+ ui->lineEditNICKNAME->setText(nickname);

+}

+

+QString QtVCardPhotoAndNameFields::getNickname() const {

+ return ui->lineEditNICKNAME->text();

+}

+

+void QtVCardPhotoAndNameFields::setPrefix(const QString prefix) {

+ ui->lineEditPREFIX->setText(prefix);

+}

+

+QString QtVCardPhotoAndNameFields::getPrefix() const {

+ return ui->lineEditPREFIX->text();

+}

+

+void QtVCardPhotoAndNameFields::setGivenName(const QString givenName) {

+ ui->lineEditGIVEN->setText(givenName);

+}

+

+QString QtVCardPhotoAndNameFields::getGivenName() const {

+ return ui->lineEditGIVEN->text();

+}

+

+void QtVCardPhotoAndNameFields::setMiddleName(const QString middleName) {

+ ui->lineEditMIDDLE->setText(middleName);

+}

+

+QString QtVCardPhotoAndNameFields::getMiddleName() const {

+ return ui->lineEditMIDDLE->text();

+}

+

+void QtVCardPhotoAndNameFields::setFamilyName(const QString familyName) {

+ ui->lineEditFAMILY->setText(familyName);

+}

+

+QString QtVCardPhotoAndNameFields::getFamilyName() const {

+ return ui->lineEditFAMILY->text();

+}

+

+void QtVCardPhotoAndNameFields::setSuffix(const QString suffix) {

+ ui->lineEditSUFFIX->setText(suffix);

+}

+

+QString QtVCardPhotoAndNameFields::getSuffix() const {

+ return ui->lineEditSUFFIX->text();

+}

+

+void QtVCardPhotoAndNameFields::prepareAddFieldMenu() {

+ foreach(QAction* action, addFieldMenu->actions()) {

+ actionSignalMapper->removeMappings(action);

+ }

+

+ addFieldMenu->clear();

+ foreach(QObject* obj, children()) {

+ QLineEdit* lineEdit = 0;

+ if (!(lineEdit = dynamic_cast<QLineEdit*>(obj))) continue;

+ if (lineEdit->isHidden()) {

+#if QT_VERSION >= 0x040700

+ QAction* action = addFieldMenu->addAction(QString("Add ") + lineEdit->placeholderText(), actionSignalMapper, SLOT(map()));

+#else

+ QAction* action = addFieldMenu->addAction(QString("Add ") + lineEdit->toolTip(), actionSignalMapper, SLOT(map()));

+#endif

+ actionSignalMapper->setMapping(action, lineEdit->objectName());

+ }

+ }

+}

+

+void QtVCardPhotoAndNameFields::showField(const QString& widgetName) {

+ QLineEdit* lineEditToShow = findChild<QLineEdit*>(widgetName);

+ if (lineEditToShow) lineEditToShow->show();

+

+ prepareAddFieldMenu();

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QMenu>

+#include <QSignalMapper>

+#include <QWidget>

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

+

+namespace Ui {

+ class QtVCardPhotoAndNameFields;

+}

+

+

+namespace Swift {

+

+ class QtVCardPhotoAndNameFields : public QWidget {

+ Q_OBJECT

+ Q_PROPERTY(bool editable READ isEditable WRITE setEditable)

+

+ public:

+ explicit QtVCardPhotoAndNameFields(QWidget* parent = 0);

+ ~QtVCardPhotoAndNameFields();

+

+ bool isEditable() const;

+ void setEditable(bool);

+

+ QMenu* getAddFieldMenu() const;

+

+ void setAvatar(const ByteArray& data, const std::string& type);

+ ByteArray getAvatarData() const;

+ std::string getAvatarType() const;

+

+ void setFormattedName(const QString formattedName);

+ QString getFormattedName() const;

+

+ void setNickname(const QString nickname);

+ QString getNickname() const;

+

+ void setPrefix(const QString prefix);

+ QString getPrefix() const;

+

+ void setGivenName(const QString givenName);

+ QString getGivenName() const;

+

+ void setMiddleName(const QString middleName);

+ QString getMiddleName() const;

+

+ void setFamilyName(const QString familyName);

+ QString getFamilyName() const;

+

+ void setSuffix(const QString suffix);

+ QString getSuffix() const;

+

+ public slots:

+ void showField(const QString& widgetName);

+

+ private:

+ void prepareAddFieldMenu();

+

+ private:

+ Ui::QtVCardPhotoAndNameFields* ui;

+ bool editable;

+

+ QMenu* addFieldMenu;

+ QSignalMapper* actionSignalMapper;

+ };

+

+}

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

+<ui version="4.0">

+ <class>QtVCardPhotoAndNameFields</class>

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

+ <property name="enabled">

+ <bool>true</bool>

+ </property>

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>522</width>

+ <height>81</height>

+ </rect>

+ </property>

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Expanding" vsizetype="Preferred">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="windowTitle">

+ <string>Form</string>

+ </property>

+ <layout class="QGridLayout" name="gridLayout" rowstretch="0,0,0,0,0" rowminimumheight="0,0,0,0,0">

+ <property name="sizeConstraint">

+ <enum>QLayout::SetMinimumSize</enum>

+ </property>

+ <property name="horizontalSpacing">

+ <number>5</number>

+ </property>

+ <property name="verticalSpacing">

+ <number>1</number>

+ </property>

+ <property name="margin">

+ <number>0</number>

+ </property>

+ <item row="0" column="0" rowspan="5">

+ <widget class="Swift::QtAvatarWidget" name="avatarWidget" native="true">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Fixed" vsizetype="Fixed">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

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

+ <string/>

+ </property>

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

+ <bool>false</bool>

+ </property>

+ </widget>

+ </item>

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

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

+ <item>

+ <widget class="Swift::QtResizableLineEdit" name="lineEditFN">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Preferred" vsizetype="Fixed">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="font">

+ <font>

+ <pointsize>18</pointsize>

+ <weight>50</weight>

+ <bold>false</bold>

+ </font>

+ </property>

+ <property name="toolTip">

+ <string>Formatted Name</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <spacer name="horizontalSpacer_2">

+ <property name="orientation">

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

+ </property>

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

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ </layout>

+ </item>

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

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

+ <item>

+ <widget class="Swift::QtResizableLineEdit" name="lineEditNICKNAME">

+ <property name="toolTip">

+ <string>Nickname</string>

+ </property>

+ <property name="frame">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <spacer name="horizontalSpacer_3">

+ <property name="orientation">

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

+ </property>

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

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ </layout>

+ </item>

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

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

+ <property name="spacing">

+ <number>2</number>

+ </property>

+ <property name="sizeConstraint">

+ <enum>QLayout::SetMinimumSize</enum>

+ </property>

+ <item>

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

+ <property name="text">

+ <string/>

+ </property>

+ <property name="textInteractionFlags">

+ <set>Qt::TextSelectableByKeyboard|Qt::TextSelectableByMouse</set>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="Swift::QtResizableLineEdit" name="lineEditPREFIX">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Preferred" vsizetype="Fixed">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="toolTip">

+ <string>Prefix</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="Swift::QtResizableLineEdit" name="lineEditGIVEN">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Preferred" vsizetype="Fixed">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="toolTip">

+ <string>Given Name</string>

+ </property>

+ <property name="text">

+ <string/>

+ </property>

+ <property name="readOnly">

+ <bool>false</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="Swift::QtResizableLineEdit" name="lineEditMIDDLE">

+ <property name="enabled">

+ <bool>true</bool>

+ </property>

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Preferred" vsizetype="Fixed">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="toolTip">

+ <string>Middle Name</string>

+ </property>

+ <property name="styleSheet">

+ <string notr="true"/>

+ </property>

+ <property name="frame">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="Swift::QtResizableLineEdit" name="lineEditFAMILY">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Preferred" vsizetype="Fixed">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="toolTip">

+ <string>Last Name</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="Swift::QtResizableLineEdit" name="lineEditSUFFIX">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Preferred" vsizetype="Fixed">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="toolTip">

+ <string>Suffix</string>

+ </property>

+ <property name="readOnly">

+ <bool>false</bool>

+ </property>

+ </widget>

+ </item>

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

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ <customwidgets>

+ <customwidget>

+ <class>Swift::QtResizableLineEdit</class>

+ <extends>QLineEdit</extends>

+ <header>QtResizableLineEdit.h</header>

+ </customwidget>

+ <customwidget>

+ <class>Swift::QtAvatarWidget</class>

+ <extends>QWidget</extends>

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

+ <container>1</container>

+ </customwidget>

+ </customwidgets>

+ <resources/>

+ <connections/>

+</ui>

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardRoleField.h"

+

+#include <QGridLayout>

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

+

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

+

+namespace Swift {

+

+QtVCardRoleField::QtVCardRoleField(QWidget* parent, QGridLayout *layout, bool editable) :

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Role"), false, false) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+}

+

+QtVCardRoleField::~QtVCardRoleField() {

+}

+

+void QtVCardRoleField::setupContentWidgets() {

+ roleLineEdit = new QtResizableLineEdit(this);

+ getGridLayout()->addWidget(roleLineEdit, getGridLayout()->rowCount()-1, 2, 1, 2, Qt::AlignVCenter);

+ getTagComboBox()->hide();

+ childWidgets << roleLineEdit;

+}

+

+bool QtVCardRoleField::isEmpty() const {

+ return roleLineEdit->text().isEmpty();

+}

+

+void QtVCardRoleField::setRole(const std::string& role) {

+ roleLineEdit->setText(P2QSTRING(role));

+}

+

+std::string QtVCardRoleField::getRole() const {

+ return Q2PSTRING(roleLineEdit->text());

+}

+

+void QtVCardRoleField::handleEditibleChanged(bool isEditable) {

+ if (roleLineEdit) {

+ roleLineEdit->setEditable(isEditable);

+ roleLineEdit->setStyleSheet(isEditable ? "" : "QLineEdit { border: none; background: transparent; }");

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swiften/Elements/VCard.h>

+

+#include "QtResizableLineEdit.h"

+#include "QtVCardFieldInfo.h"

+#include "QtVCardGeneralField.h"

+

+namespace Swift {

+

+class QtVCardRoleField : public QtVCardGeneralField {

+ Q_OBJECT

+

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO("Role", UNLIMITED_INSTANCES, QtVCardRoleField)

+

+ QtVCardRoleField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardRoleField();

+

+ virtual bool isEmpty() const;

+

+ void setRole(const std::string& role);

+ std::string getRole() const;

+

+ protected:

+ virtual void setupContentWidgets();

+

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+

+ private:

+ QtResizableLineEdit* roleLineEdit;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardTelephoneField.h"

+

+#include <QGridLayout>

+

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

+

+namespace Swift {

+

+QtVCardTelephoneField::QtVCardTelephoneField(QWidget* parent, QGridLayout *layout, bool editable) :

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Telephone")) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+}

+

+QtVCardTelephoneField::~QtVCardTelephoneField() {

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+}

+

+void QtVCardTelephoneField::setupContentWidgets() {

+ telephoneLineEdit = new QtResizableLineEdit(this);

+#if QT_VERSION >= 0x040700

+ telephoneLineEdit->setPlaceholderText(tr("0118 999 881 999 119 7253"));

+#endif

+ getGridLayout()->addWidget(telephoneLineEdit, getGridLayout()->rowCount()-1, 2, 1, 2, Qt::AlignVCenter);

+ setTabOrder(telephoneLineEdit, getTagComboBox());

+ QtVCardHomeWork::setTagComboBox(getTagComboBox());

+

+ getTagComboBox()->addTag("voice", QObject::tr("Voice"));

+ getTagComboBox()->addTag("fax", QObject::tr("Fax"));

+ getTagComboBox()->addTag("pager", QObject::tr("Pager"));

+ getTagComboBox()->addTag("msg", QObject::tr("Voice Messaging"));

+ getTagComboBox()->addTag("cell", QObject::tr("Cell"));

+ getTagComboBox()->addTag("video", QObject::tr("Video"));

+ getTagComboBox()->addTag("bbs", QObject::tr("Bulletin Board System"));

+ getTagComboBox()->addTag("modem", QObject::tr("Modem"));

+ getTagComboBox()->addTag("isdn", QObject::tr("ISDN"));

+ getTagComboBox()->addTag("pcs", QObject::tr("Personal Communication Services"));

+

+ childWidgets << telephoneLineEdit;

+}

+

+bool QtVCardTelephoneField::isEmpty() const {

+ return telephoneLineEdit->text().isEmpty();

+}

+

+void QtVCardTelephoneField::setTelephone(const VCard::Telephone& telephone) {

+ setPreferred(telephone.isPreferred);

+ setHome(telephone.isHome);

+ setWork(telephone.isWork);

+

+ telephoneLineEdit->setText(P2QSTRING(telephone.number));

+

+ getTagComboBox()->setTag("voice", telephone.isVoice);

+ getTagComboBox()->setTag("fax", telephone.isFax);

+ getTagComboBox()->setTag("pager", telephone.isPager);

+ getTagComboBox()->setTag("msg", telephone.isMSG);

+ getTagComboBox()->setTag("cell", telephone.isCell);

+ getTagComboBox()->setTag("video", telephone.isVideo);

+ getTagComboBox()->setTag("bbs", telephone.isBBS);

+ getTagComboBox()->setTag("modem", telephone.isModem);

+ getTagComboBox()->setTag("isdn", telephone.isISDN);

+ getTagComboBox()->setTag("pcs", telephone.isPCS);

+}

+

+VCard::Telephone QtVCardTelephoneField::getTelephone() const {

+ VCard::Telephone telephone;

+

+ telephone.number = Q2PSTRING(telephoneLineEdit->text());

+

+ telephone.isPreferred = getPreferred();

+ telephone.isHome = getHome();

+ telephone.isWork = getWork();

+

+ telephone.isVoice = getTagComboBox()->isTagSet("voice");

+ telephone.isFax = getTagComboBox()->isTagSet("fax");

+ telephone.isPager = getTagComboBox()->isTagSet("pager");

+ telephone.isMSG = getTagComboBox()->isTagSet("msg");

+ telephone.isCell = getTagComboBox()->isTagSet("cell");

+ telephone.isVideo = getTagComboBox()->isTagSet("video");

+ telephone.isBBS = getTagComboBox()->isTagSet("bbs");

+ telephone.isModem = getTagComboBox()->isTagSet("modem");

+ telephone.isISDN = getTagComboBox()->isTagSet("isdn");

+ telephone.isPCS = getTagComboBox()->isTagSet("pcs");

+

+ return telephone;

+}

+

+void QtVCardTelephoneField::handleEditibleChanged(bool isEditable) {

+ if (telephoneLineEdit) {

+ telephoneLineEdit->setEditable(isEditable);

+ telephoneLineEdit->setStyleSheet(isEditable ? "" : "QLineEdit { border: none; background: transparent; }");

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swiften/Elements/VCard.h>

+

+#include "QtResizableLineEdit.h"

+#include "QtVCardFieldInfo.h"

+#include "QtVCardGeneralField.h"

+#include "QtVCardHomeWork.h"

+

+namespace Swift {

+

+class QtVCardTelephoneField : public QtVCardGeneralField, public QtVCardHomeWork {

+ Q_OBJECT

+

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO("Telephone", UNLIMITED_INSTANCES, QtVCardTelephoneField)

+

+ QtVCardTelephoneField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardTelephoneField();

+

+ virtual bool isEmpty() const;

+

+ void setTelephone(const VCard::Telephone& telephone);

+ VCard::Telephone getTelephone() const;

+

+ protected:

+ virtual void setupContentWidgets();

+

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+

+ private:

+ QtResizableLineEdit* telephoneLineEdit;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardTitleField.h"

+

+#include <QGridLayout>

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

+

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

+

+namespace Swift {

+

+QtVCardTitleField::QtVCardTitleField(QWidget* parent, QGridLayout *layout, bool editable) :

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("Title"), false, false) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+}

+

+QtVCardTitleField::~QtVCardTitleField() {

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+}

+

+void QtVCardTitleField::setupContentWidgets() {

+ titleLineEdit = new QtResizableLineEdit(this);

+ getGridLayout()->addWidget(titleLineEdit, getGridLayout()->rowCount()-1, 2, 1, 2, Qt::AlignVCenter);

+ getTagComboBox()->hide();

+ childWidgets << titleLineEdit;

+}

+

+bool QtVCardTitleField::isEmpty() const {

+ return titleLineEdit->text().isEmpty();

+}

+

+void QtVCardTitleField::setTitle(const std::string& title) {

+ titleLineEdit->setText(P2QSTRING(title));

+}

+

+std::string QtVCardTitleField::getTitle() const {

+ return Q2PSTRING(titleLineEdit->text());

+}

+

+void QtVCardTitleField::handleEditibleChanged(bool isEditable) {

+ if (titleLineEdit) {

+ titleLineEdit->setEditable(isEditable);

+ titleLineEdit->setStyleSheet(isEditable ? "" : "QLineEdit { border: none; background: transparent; }");

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swiften/Elements/VCard.h>

+

+#include "QtResizableLineEdit.h"

+#include "QtVCardFieldInfo.h"

+#include "QtVCardGeneralField.h"

+

+namespace Swift {

+

+class QtVCardTitleField : public QtVCardGeneralField {

+ Q_OBJECT

+

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO("Title", UNLIMITED_INSTANCES, QtVCardTitleField)

+

+ QtVCardTitleField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardTitleField();

+

+ virtual bool isEmpty() const;

+

+ void setTitle(const std::string& title);

+ std::string getTitle() const;

+

+ protected:

+ virtual void setupContentWidgets();

+

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+

+ private:

+ QtResizableLineEdit* titleLineEdit;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardURLField.h"

+

+#include <QGridLayout>

+#include <QHBoxLayout>

+#include <QTextDocument>

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

+

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

+

+namespace Swift {

+

+QtVCardURLField::QtVCardURLField(QWidget* parent, QGridLayout *layout, bool editable) :

+ QtVCardGeneralField(parent, layout, editable, layout->rowCount(), tr("URL"), false, false) {

+ connect(this, SIGNAL(editableChanged(bool)), SLOT(handleEditibleChanged(bool)));

+}

+

+QtVCardURLField::~QtVCardURLField() {

+ disconnect(this, SLOT(handleEditibleChanged(bool)));

+}

+

+void QtVCardURLField::setupContentWidgets() {

+ urlLabel = new QLabel(this);

+ urlLabel->setOpenExternalLinks(true);

+ urlLabel->setTextInteractionFlags(Qt::LinksAccessibleByMouse | Qt::LinksAccessibleByKeyboard);

+ urlLineEdit = new QtResizableLineEdit(this);

+

+ QHBoxLayout* urlLayout = new QHBoxLayout();

+ urlLayout->addWidget(urlLabel);

+ urlLayout->addWidget(urlLineEdit);

+

+ getGridLayout()->addLayout(urlLayout, getGridLayout()->rowCount()-1, 2, 1, 2, Qt::AlignVCenter);

+ getTagComboBox()->hide();

+ urlLabel->hide();

+ childWidgets << urlLabel << urlLineEdit;

+}

+

+bool QtVCardURLField::isEmpty() const {

+ return urlLineEdit->text().isEmpty();

+}

+

+void QtVCardURLField::setURL(const std::string& url) {

+ urlLineEdit->setText(P2QSTRING(url));

+}

+

+std::string QtVCardURLField::getURL() const {

+ return Q2PSTRING(urlLineEdit->text());

+}

+

+void QtVCardURLField::handleEditibleChanged(bool isEditable) {

+ if (isEditable) {

+ if (urlLineEdit) urlLineEdit->show();

+ if (urlLabel) urlLabel->hide();

+ } else {

+ if (urlLineEdit) urlLineEdit->hide();

+ if (urlLabel) {

+ urlLabel->setText(QString("<a href=\"%1\">%1</a>").arg(Qt::escape(urlLineEdit->text())));

+ urlLabel->show();

+ }

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swiften/Elements/VCard.h>

+

+#include "QtResizableLineEdit.h"

+#include "QtVCardFieldInfo.h"

+#include "QtVCardGeneralField.h"

+

+namespace Swift {

+

+class QtVCardURLField : public QtVCardGeneralField {

+ Q_OBJECT

+

+ public:

+ GENERIC_QT_VCARD_FIELD_INFO("URL", UNLIMITED_INSTANCES, QtVCardURLField)

+

+ QtVCardURLField(QWidget* parent = 0, QGridLayout* layout = 0, bool editable = false);

+ virtual ~QtVCardURLField();

+

+ virtual bool isEmpty() const;

+

+ void setURL(const std::string& url);

+ std::string getURL() const;

+

+ protected:

+ virtual void setupContentWidgets();

+

+ public slots:

+ void handleEditibleChanged(bool isEditable);

+

+ private:

+ QLabel* urlLabel;

+ QtResizableLineEdit* urlLineEdit;

+};

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtVCardWidget.h"

+#include "ui_QtVCardWidget.h"

+

+#include <QDebug>

+#include <QLineEdit>

+#include <QMenu>

+

+#include "QtVCardAddressField.h"

+#include "QtVCardAddressLabelField.h"

+#include "QtVCardBirthdayField.h"

+#include "QtVCardDescriptionField.h"

+#include "QtVCardGeneralField.h"

+#include "QtVCardInternetEMailField.h"

+#include "QtVCardJIDField.h"

+#include "QtVCardOrganizationField.h"

+#include "QtVCardRoleField.h"

+#include "QtVCardTelephoneField.h"

+#include "QtVCardTitleField.h"

+#include "QtVCardURLField.h"

+

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

+

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

+

+namespace Swift {

+

+QtVCardWidget::QtVCardWidget(QWidget* parent) :

+ QWidget(parent),

+ ui(new ::Ui::QtVCardWidget) {

+ ui->setupUi(this);

+

+ ui->cardFields->setColumnStretch(0,0);

+ ui->cardFields->setColumnStretch(1,0);

+ ui->cardFields->setColumnStretch(2,2);

+ ui->cardFields->setColumnStretch(3,1);

+ ui->cardFields->setColumnStretch(4,2);

+ menu = new QMenu(this);

+

+ menu->addMenu(ui->photoAndName->getAddFieldMenu());

+ ui->toolButton->setMenu(menu);

+

+ addFieldType(menu, boost::make_shared<QtVCardInternetEMailField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardTelephoneField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardAddressField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardAddressLabelField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardBirthdayField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardJIDField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardDescriptionField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardRoleField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardTitleField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardOrganizationField::FieldInfo>());

+ addFieldType(menu, boost::make_shared<QtVCardURLField::FieldInfo>());

+

+ setEditable(false);

+}

+

+QtVCardWidget::~QtVCardWidget() {

+ delete ui;

+}

+

+bool QtVCardWidget::isEditable() const {

+ return editable;

+}

+

+void QtVCardWidget::setEditable(bool editable) {

+ this->editable = editable;

+

+ ui->photoAndName->setProperty("editable", QVariant(editable));

+

+ foreach(QtVCardGeneralField* field, fields) {

+ field->setEditable(editable);

+ }

+

+ if (editable) {

+ ui->toolButton->show();

+ //if ((findChild<QtVCardBirthdayField*>() == 0)) {

+ //}

+ } else {

+ ui->toolButton->hide();

+ }

+

+ editableChanged(editable);

+}

+

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

+ SWIFT_LOG(debug) << std::endl;

+ clearFields();

+ this->vcard = vcard;

+ ui->photoAndName->setFormattedName(P2QSTRING(vcard->getFullName()));

+ ui->photoAndName->setNickname(P2QSTRING(vcard->getNickname()));

+ ui->photoAndName->setPrefix(P2QSTRING(vcard->getPrefix()));

+ ui->photoAndName->setGivenName(P2QSTRING(vcard->getGivenName()));

+ ui->photoAndName->setMiddleName(P2QSTRING(vcard->getMiddleName()));

+ ui->photoAndName->setFamilyName(P2QSTRING(vcard->getFamilyName()));

+ ui->photoAndName->setSuffix(P2QSTRING(vcard->getSuffix()));

+ ui->photoAndName->setAvatar(vcard->getPhoto(), vcard->getPhotoType());

+

+ foreach (const VCard::EMailAddress& address, vcard->getEMailAddresses()) {

+ if (address.isInternet) {

+ QtVCardInternetEMailField* internetEmailField = new QtVCardInternetEMailField(this, ui->cardFields);

+ internetEmailField->initialize();

+ internetEmailField->setInternetEMailAddress(address);

+ appendField(internetEmailField);

+ }

+ }

+

+ foreach (const VCard::Telephone& telephone, vcard->getTelephones()) {

+ QtVCardTelephoneField* telField = new QtVCardTelephoneField(this, ui->cardFields);

+ telField->initialize();

+ telField->setTelephone(telephone);

+ appendField(telField);

+ }

+

+ foreach (const VCard::Address& address, vcard->getAddresses()) {

+ QtVCardAddressField* addressField = new QtVCardAddressField(this, ui->cardFields);

+ addressField->initialize();

+ addressField->setAddress(address);

+ appendField(addressField);

+ }

+

+ foreach (const VCard::AddressLabel& label, vcard->getAddressLabels()) {

+ QtVCardAddressLabelField* addressLabelField = new QtVCardAddressLabelField(this, ui->cardFields);

+ addressLabelField->initialize();

+ addressLabelField->setAddressLabel(label);

+ appendField(addressLabelField);

+ }

+

+ if (!vcard->getBirthday().is_not_a_date_time()) {

+ QtVCardBirthdayField* bdayField = new QtVCardBirthdayField(this, ui->cardFields);

+ bdayField->initialize();

+ bdayField->setBirthday(vcard->getBirthday());

+ appendField(bdayField);

+ }

+

+ foreach (const JID& jid, vcard->getJIDs()) {

+ QtVCardJIDField* jidField = new QtVCardJIDField(this, ui->cardFields);

+ jidField->initialize();

+ jidField->setJID(jid);

+ appendField(jidField);

+ }

+

+ if (!vcard->getDescription().empty()) {

+ QtVCardDescriptionField* descField = new QtVCardDescriptionField(this, ui->cardFields);

+ descField->initialize();

+ descField->setDescription(vcard->getDescription());

+ appendField(descField);

+ }

+

+ foreach (const VCard::Organization& org, vcard->getOrganizations()) {

+ QtVCardOrganizationField* orgField = new QtVCardOrganizationField(this, ui->cardFields);

+ orgField->initialize();

+ orgField->setOrganization(org);

+ appendField(orgField);

+ }

+

+ foreach (const std::string& role, vcard->getRoles()) {

+ QtVCardRoleField* roleField = new QtVCardRoleField(this, ui->cardFields);

+ roleField->initialize();

+ roleField->setRole(role);

+ appendField(roleField);

+ }

+

+ foreach (const std::string& title, vcard->getTitles()) {

+ QtVCardTitleField* titleField = new QtVCardTitleField(this, ui->cardFields);

+ titleField->initialize();

+ titleField->setTitle(title);

+ appendField(titleField);

+ }

+

+ foreach (const std::string& url, vcard->getURLs()) {

+ QtVCardURLField* urlField = new QtVCardURLField(this, ui->cardFields);

+ urlField->initialize();

+ urlField->setURL(url);

+ appendField(urlField);

+ }

+

+ setEditable(editable);

+}

+

+VCard::ref QtVCardWidget::getVCard() {

+ SWIFT_LOG(debug) << std::endl;

+ clearEmptyFields();

+ vcard->setFullName(Q2PSTRING(ui->photoAndName->getFormattedName()));

+ vcard->setNickname(Q2PSTRING(ui->photoAndName->getNickname()));

+ vcard->setPrefix(Q2PSTRING(ui->photoAndName->getPrefix()));

+ vcard->setGivenName(Q2PSTRING(ui->photoAndName->getGivenName()));

+ vcard->setMiddleName(Q2PSTRING(ui->photoAndName->getMiddleName()));

+ vcard->setFamilyName(Q2PSTRING(ui->photoAndName->getFamilyName()));

+ vcard->setSuffix(Q2PSTRING(ui->photoAndName->getSuffix()));

+ vcard->setPhoto(ui->photoAndName->getAvatarData());

+ vcard->setPhotoType(ui->photoAndName->getAvatarType());

+

+ vcard->clearEMailAddresses();

+ vcard->clearJIDs();

+ vcard->clearURLs();

+ vcard->clearTelephones();

+ vcard->clearRoles();

+ vcard->clearTitles();

+ vcard->clearOrganizations();

+ vcard->clearAddresses();

+ vcard->clearAddressLabels();

+

+

+ QtVCardBirthdayField* bdayField = NULL;

+ QtVCardDescriptionField* descriptionField = NULL;

+

+ foreach(QtVCardGeneralField* field, fields) {

+ QtVCardInternetEMailField* emailField;

+ if ((emailField = dynamic_cast<QtVCardInternetEMailField*>(field))) {

+ vcard->addEMailAddress(emailField->getInternetEMailAddress());

+ continue;

+ }

+

+ QtVCardTelephoneField* telephoneField;

+ if ((telephoneField = dynamic_cast<QtVCardTelephoneField*>(field))) {

+ vcard->addTelephone(telephoneField->getTelephone());

+ continue;

+ }

+

+ QtVCardAddressField* addressField;

+ if ((addressField = dynamic_cast<QtVCardAddressField*>(field))) {

+ vcard->addAddress(addressField->getAddress());

+ continue;

+ }

+

+ QtVCardAddressLabelField* addressLabelField;

+ if ((addressLabelField = dynamic_cast<QtVCardAddressLabelField*>(field))) {

+ vcard->addAddressLabel(addressLabelField->getAddressLabel());

+ continue;

+ }

+

+ if ((bdayField = dynamic_cast<QtVCardBirthdayField*>(field))) {

+ continue;

+ }

+

+ QtVCardJIDField* jidField;

+ if ((jidField = dynamic_cast<QtVCardJIDField*>(field))) {

+ vcard->addJID(jidField->getJID());

+ continue;

+ }

+

+ if ((descriptionField = dynamic_cast<QtVCardDescriptionField*>(field))) {

+ continue;

+ }

+

+ QtVCardOrganizationField* orgField;

+ if ((orgField = dynamic_cast<QtVCardOrganizationField*>(field))) {

+ vcard->addOrganization(orgField->getOrganization());

+ continue;

+ }

+

+ QtVCardRoleField* roleField;

+ if ((roleField = dynamic_cast<QtVCardRoleField*>(field))) {

+ vcard->addRole(roleField->getRole());

+ continue;

+ }

+

+ QtVCardTitleField* titleField;

+ if ((titleField = dynamic_cast<QtVCardTitleField*>(field))) {

+ vcard->addTitle(titleField->getTitle());

+ continue;

+ }

+

+ QtVCardURLField* urlField;

+ if ((urlField = dynamic_cast<QtVCardURLField*>(field))) {

+ vcard->addURL(urlField->getURL());

+ continue;

+ }

+ }

+

+ if (bdayField) {

+ vcard->setBirthday(bdayField->getBirthday());

+ } else {

+ vcard->setBirthday(boost::posix_time::ptime());

+ }

+

+ if (descriptionField) {

+ vcard->setDescription(descriptionField->getDescription());

+ } else {

+ vcard->setDescription("");

+ }

+

+ return vcard;

+}

+

+void QtVCardWidget::addField() {

+ QAction* action = NULL;

+ if ((action = dynamic_cast<QAction*>(sender()))) {

+ boost::shared_ptr<QtVCardFieldInfo> fieldInfo = actionFieldInfo[action];

+ QWidget* newField = fieldInfo->createFieldInstance(this, ui->cardFields, true);

+ QtVCardGeneralField* newGeneralField = dynamic_cast<QtVCardGeneralField*>(newField);

+ if (newGeneralField) {

+ newGeneralField->initialize();

+ }

+ appendField(newGeneralField);

+ }

+}

+

+void QtVCardWidget::removeField(QtVCardGeneralField *field) {

+ fields.remove(field);

+ delete field;

+}

+

+void QtVCardWidget::addFieldType(QMenu* menu, boost::shared_ptr<QtVCardFieldInfo> fieldType) {

+ QAction* action = new QAction(tr("Add ") + fieldType->getMenuName(), this);

+ actionFieldInfo[action] = fieldType;

+ connect(action, SIGNAL(triggered()), this, SLOT(addField()));

+ menu->addAction(action);

+}

+

+int QtVCardWidget::fieldTypeInstances(boost::shared_ptr<QtVCardFieldInfo> fieldType) {

+ int instances = 0;

+ for (int n = 0; n < ui->cardFields->count(); n++) {

+ if (fieldType->testInstance(ui->cardFields->itemAt(n)->widget())) instances++;

+ }

+ return instances;

+}

+

+void layoutDeleteChildren(QLayout *layout) {

+ while(layout->count() > 0) {

+ QLayoutItem* child;

+ if ((child = layout->takeAt(0)) != 0) {

+ if (child->layout()) {

+ layoutDeleteChildren(child->layout());

+ }

+ delete child->widget();

+ delete child;

+ }

+ }

+}

+

+void QtVCardWidget::clearFields() {

+ foreach(QtVCardGeneralField* field, fields) {

+ delete field;

+ }

+ fields.clear();

+

+ assert(ui->cardFields->count() >= 0);

+ layoutDeleteChildren(ui->cardFields);

+}

+

+void QtVCardWidget::clearEmptyFields() {

+ std::vector<QtVCardGeneralField*> items_to_remove;

+ foreach (QtVCardGeneralField* field, fields) {

+ if (field->property("empty").isValid() && field->property("empty").toBool()) {

+ ui->cardFields->removeWidget(field);

+ items_to_remove.push_back(field);

+ delete field;

+ }

+ }

+

+ foreach(QtVCardGeneralField* field, items_to_remove) {

+ fields.remove(field);

+ }

+}

+

+void QtVCardWidget::appendField(QtVCardGeneralField *field) {

+ connect(field, SIGNAL(deleteField(QtVCardGeneralField*)), SLOT(removeField(QtVCardGeneralField*)));

+ fields.push_back(field);

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QWidget>

+#include <Swiften/Elements/VCard.h>

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

+

+#include "QtVCardFieldInfo.h"

+#include "QtVCardGeneralField.h"

+#include "QtVCardPhotoAndNameFields.h"

+

+namespace Ui {

+ class QtVCardWidget;

+}

+

+namespace Swift {

+

+ class QtVCardWidget : public QWidget {

+ Q_OBJECT

+ Q_PROPERTY(bool editable READ isEditable WRITE setEditable)

+

+ public :

+ explicit QtVCardWidget(QWidget* parent = 0);

+ ~QtVCardWidget();

+

+ bool isEditable() const;

+ void setEditable(bool);

+

+ void setVCard(VCard::ref vcard);

+ VCard::ref getVCard();

+

+ signals:

+ void editableChanged(bool editable);

+

+ private slots:

+ void addField();

+ void removeField(QtVCardGeneralField* field);

+

+ private:

+ void addFieldType(QMenu*, boost::shared_ptr<QtVCardFieldInfo>);

+ int fieldTypeInstances(boost::shared_ptr<QtVCardFieldInfo>);

+ void clearFields();

+ void clearEmptyFields();

+ void appendField(QtVCardGeneralField* field);

+

+ private:

+ VCard::ref vcard;

+ Ui::QtVCardWidget* ui;

+ bool editable;

+ QMenu* menu;

+ std::list<QtVCardGeneralField*> fields;

+ std::map<QAction*, boost::shared_ptr<QtVCardFieldInfo> > actionFieldInfo;

+ };

+

+}

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

+<ui version="4.0">

+ <class>QtVCardWidget</class>

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

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>535</width>

+ <height>126</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string>Form</string>

+ </property>

+ <layout class="QGridLayout" name="gridLayout" rowstretch="1,0" columnstretch="1,0">

+ <property name="margin">

+ <number>5</number>

+ </property>

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

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

+ <property name="spacing">

+ <number>2</number>

+ </property>

+ <property name="sizeConstraint">

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

+ </property>

+ <item>

+ <widget class="Swift::QtVCardPhotoAndNameFields" name="photoAndName" native="true"/>

+ </item>

+ <item>

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

+ <property name="orientation">

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

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QScrollArea" name="scrollArea">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Preferred" vsizetype="Preferred">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="frameShape">

+ <enum>QFrame::NoFrame</enum>

+ </property>

+ <property name="frameShadow">

+ <enum>QFrame::Plain</enum>

+ </property>

+ <property name="horizontalScrollBarPolicy">

+ <enum>Qt::ScrollBarAlwaysOff</enum>

+ </property>

+ <property name="widgetResizable">

+ <bool>true</bool>

+ </property>

+ <property name="alignment">

+ <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>

+ </property>

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

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>523</width>

+ <height>76</height>

+ </rect>

+ </property>

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Preferred" vsizetype="Preferred">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

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

+ <property name="sizeConstraint">

+ <enum>QLayout::SetMinAndMaxSize</enum>

+ </property>

+ <property name="margin">

+ <number>0</number>

+ </property>

+ <item>

+ <layout class="QGridLayout" name="cardFields">

+ </layout>

+ </item>

+ <item>

+ <spacer name="verticalSpacer">

+ <property name="orientation">

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

+ </property>

+ <property name="sizeType">

+ <enum>QSizePolicy::Preferred</enum>

+ </property>

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

+ <size>

+ <width>20</width>

+ <height>1000</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ </layout>

+ </widget>

+ </widget>

+ </item>

+ </layout>

+ </item>

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

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

+ <property name="text">

+ <string>Add Field</string>

+ </property>

+ <property name="popupMode">

+ <enum>QToolButton::InstantPopup</enum>

+ </property>

+ <property name="autoRaise">

+ <bool>false</bool>

+ </property>

+ <property name="arrowType">

+ <enum>Qt::NoArrow</enum>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </widget>

+ <customwidgets>

+ <customwidget>

+ <class>Swift::QtVCardPhotoAndNameFields</class>

+ <extends>QWidget</extends>

+ <header>QtVCardPhotoAndNameFields.h</header>

+ <container>1</container>

+ </customwidget>

+ </customwidgets>

+ <resources/>

+ <connections/>

+</ui>

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

+ boost::numeric_cast<unsigned short>(event->count()));

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

+ // Checking for the scrollbar again, because it could have appeared after inserting text.

+ // In practice, I suspect that the scrollbar is always there, but hidden, but since we were

+ // explicitly testing for this already above, I'm leaving the code in.

+ scrollBar = textEdit->verticalScrollBar();

+ if (scrollToBottom && scrollBar) {

+ case ChatWindow::ShowProfile: text = tr("Show profile"); break;

+#include "Swift/Controllers/UIEvents/ShowProfileForRosterItemUIEvent.h"

+ QAction* showProfileForContact = contextMenu.addAction(tr("Show Profile"));

+ else if (result == showProfileForContact) {

+ eventStream_->send(boost::make_shared<ShowProfileForRosterItemUIEvent>(contact->getJID()));

+ }

+ emit sizeHintChanged(QModelIndex());

+

+# Disable warnings that affect Qt

+if "clang" in env["CC"] :

+ myenv.Append(CXXFLAGS = ["-Wno-float-equal", "-Wno-shorten-64-to-32", "-Wno-missing-prototypes", "-Wno-unreachable-code", "-Wno-disabled-macro-expansion", "-Wno-unused-private-field", "-Wno-extra-semi", "-Wno-duplicate-enum", "-Wno-missing-variable-declarations", "-Wno-conversion"])

+

+ "QtSingleWindow.cpp",

+ "QtHighlightEditorWidget.cpp",

+ "QtHighlightRulesItemModel.cpp",

+ "QtHighlightRuleWidget.cpp",

+ "QtColorToolButton.cpp",

+# QtVCardWidget

+sources.extend([

+ "QtVCardWidget/QtCloseButton.cpp",

+ "QtVCardWidget/QtRemovableItemDelegate.cpp",

+ "QtVCardWidget/QtResizableLineEdit.cpp",

+ "QtVCardWidget/QtTagComboBox.cpp",

+ "QtVCardWidget/QtVCardHomeWork.cpp",

+ "QtVCardWidget/QtVCardAddressField.cpp",

+ "QtVCardWidget/QtVCardAddressLabelField.cpp",

+ "QtVCardWidget/QtVCardBirthdayField.cpp",

+ "QtVCardWidget/QtVCardDescriptionField.cpp",

+ "QtVCardWidget/QtVCardInternetEMailField.cpp",

+ "QtVCardWidget/QtVCardJIDField.cpp",

+ "QtVCardWidget/QtVCardOrganizationField.cpp",

+ "QtVCardWidget/QtVCardPhotoAndNameFields.cpp",

+ "QtVCardWidget/QtVCardRoleField.cpp",

+ "QtVCardWidget/QtVCardTelephoneField.cpp",

+ "QtVCardWidget/QtVCardTitleField.cpp",

+ "QtVCardWidget/QtVCardURLField.cpp",

+ "QtVCardWidget/QtVCardGeneralField.cpp",

+ "QtVCardWidget/QtVCardWidget.cpp"

+])

+

+myenv.Uic4("QtVCardWidget/QtVCardPhotoAndNameFields.ui")

+myenv.Uic4("QtVCardWidget/QtVCardWidget.ui")

+myenv.Uic4("QtProfileWindow.ui")

+

+