+#include "Swift/QtUI/ChatList/ChatListWhiteboardItem.h"

+ else if (item && dynamic_cast<ChatListWhiteboardItem*>(item)) {

+ return common_.contactSizeHint(option, index, compact_);

+ }

+ else if (item && dynamic_cast<ChatListWhiteboardItem*>(item)) {

+ paintWhiteboard(painter, option, dynamic_cast<ChatListWhiteboardItem*>(item));

+ }

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

+}

+

+void ChatListDelegate::paintWhiteboard(QPainter* painter, const QStyleOptionViewItem& option, ChatListWhiteboardItem* item) const {

+ QColor nameColor = item->data(Qt::TextColorRole).value<QColor>();

+ QString avatarPath;

+ if (item->data(ChatListWhiteboardItem::AvatarRole).isValid() && !item->data(ChatListWhiteboardItem::AvatarRole).value<QString>().isNull()) {

+ avatarPath = item->data(ChatListWhiteboardItem::AvatarRole).value<QString>();

+ }

+ QIcon presenceIcon;/* = item->data(ChatListWhiteboardItem::PresenceIconRole).isValid() && !item->data(ChatListWhiteboardItem::PresenceIconRole).value<QIcon>().isNull()

+ ? item->data(ChatListWhiteboardItem::PresenceIconRole).value<QIcon>()

+ : QIcon(":/icons/offline.png");*/

+ QString name = item->data(Qt::DisplayRole).toString();

+ //qDebug() << "Avatar for " << name << " = " << avatarPath;

+ QString statusText = item->data(ChatListWhiteboardItem::DetailTextRole).toString();

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

+

+ class ChatListWhiteboardItem;

+ void paintWhiteboard(QPainter* painter, const QStyleOptionViewItem& option, ChatListWhiteboardItem* item) const;

+ * Copyright (c) 2010-2014 Kevin Smith

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

+

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

+ virtual ~ChatListGroupItem() {clear();}

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

+ foreach (ChatListItem* item, items_) {

+ delete item;

+ }

+ items_.clear();

+ }

+

+

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

+ ChatListGroupItem* parent() {return parent_;}

+ * Copyright (c) 2010-2014 Kevin Smith

+#include <QMimeData>

+#include <QUrl>

+

+#include <Swift/QtUI/ChatList/ChatListWhiteboardItem.h>

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

+ChatListModel::ChatListModel() : whiteboards_(NULL) {

+#ifdef SWIFT_EXPERIMENTAL_WB

+ whiteboards_ = new ChatListGroupItem(tr("Opened Whiteboards"), root_, false);

+ root_->addItem(whiteboards_);

+#endif

+

+

+ QModelIndex idx = index(0, 0, QModelIndex());

+ while (idx.isValid()) {

+ if (idx.internalPointer() == mucBookmarks_) {

+ mucBookmarksIndex_ = idx;

+ } else if (idx.internalPointer() == recents_) {

+ recentsIndex_ = idx;

+ } else if (idx.internalPointer() == whiteboards_) {

+ whiteboardsIndex_ = idx;

+ }

+ idx = index(idx.row() + 1, 0, QModelIndex());

+ }

+}

+

+Qt::ItemFlags ChatListModel::flags(const QModelIndex& index) const {

+ Qt::ItemFlags flags = QAbstractItemModel::flags(index);

+ if (dynamic_cast<ChatListRecentItem*>(getItemForIndex(index))) {

+ flags |= Qt::ItemIsDragEnabled;

+ }

+ return flags;

+ beginRemoveRows(mucBookmarksIndex_, 0, mucBookmarks_->rowCount());

+ endRemoveRows();

+ beginInsertRows(mucBookmarksIndex_, 0, mucBookmarks_->rowCount());

+ endInsertRows();

+ beginRemoveRows(mucBookmarksIndex_, i, i+1);

+ endRemoveRows();

+ break;

+ }

+ }

+}

+

+void ChatListModel::addWhiteboardSession(const ChatListWindow::Chat& chat) {

+ beginInsertRows(whiteboardsIndex_, 0, whiteboards_->rowCount());

+ whiteboards_->addItem(new ChatListWhiteboardItem(chat, whiteboards_));

+ endInsertRows();

+}

+

+void ChatListModel::removeWhiteboardSession(const JID& jid) {

+ for (int i = 0; i < whiteboards_->rowCount(); i++) {

+ ChatListWhiteboardItem* item = dynamic_cast<ChatListWhiteboardItem*>(whiteboards_->item(i));

+ if (item->getChat().jid == jid) {

+ beginRemoveRows(whiteboardsIndex_, i, i+1);

+ whiteboards_->remove(i);

+ endRemoveRows();

+ beginRemoveRows(recentsIndex_, 0, recents_->rowCount());

+ endRemoveRows();

+ beginInsertRows(recentsIndex_, 0, recents.size());

+//whiteboards_->addItem(new ChatListRecentItem(chat, whiteboards_));

+ }

+ endInsertRows();

+}

+

+QMimeData* ChatListModel::mimeData(const QModelIndexList& indexes) const {

+ QMimeData* data = QAbstractItemModel::mimeData(indexes);

+ ChatListRecentItem *item = dynamic_cast<ChatListRecentItem*>(getItemForIndex(indexes.first()));

+ if (item == NULL) {

+ return data;

+ }

+

+ QByteArray itemData;

+ QDataStream dataStream(&itemData, QIODevice::WriteOnly);

+ const ChatListWindow::Chat& chat = item->getChat();

+

+ QString mimeType = "application/vnd.swift.contact-jid-list";

+ if (!chat.impromptuJIDs.size()) {

+ if (chat.isMUC) {

+ mimeType = "application/vnd.swift.contact-jid-muc";

+ }

+ dataStream << P2QSTRING(chat.jid.toString());

+ } else {

+ typedef std::map<std::string, JID> JIDMap;

+ foreach (const JIDMap::value_type& jid, chat.impromptuJIDs) {

+ dataStream << P2QSTRING(jid.second.toString());

+ }

+

+ data->setData(mimeType, itemData);

+ return data;

+ * Copyright (c) 2010-2014 Kevin Smith

+#include <QPersistentModelIndex>

+ Qt::ItemFlags flags(const QModelIndex& index) const;

+ void addWhiteboardSession(const ChatListWindow::Chat& chat);

+ void removeWhiteboardSession(const JID& jid);

+ QMimeData* mimeData(const QModelIndexList& indexes) const;

+ ChatListGroupItem* whiteboards_;

+

+ QPersistentModelIndex mucBookmarksIndex_;

+ QPersistentModelIndex recentsIndex_;

+ QPersistentModelIndex whiteboardsIndex_;

+ * Copyright (c) 2011-2013 Kevin Smith

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

+#include <Swift/QtUI/ChatList/ChatListRecentItem.h>

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

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

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

+ return QIcon(statusShowTypeToIconPath(chat_.statusType));

+ StatusShowTypeRole = Qt::UserRole + 3,

+ IdleRole = Qt::UserRole + 4*/

+/*

+ * Copyright (c) 2012 Mateusz Piękos

+ * Licensed under the simplified BSD license.

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

+ */

+

+/*

+ * Copyright (c) 2013 Remko Tronçon

+ * Licensed under the GNU General Public License.

+ * See the COPYING file for more information.

+ */

+

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

+

+#include <Swift/QtUI/ChatList/ChatListWhiteboardItem.h>

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

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

+

+namespace Swift {

+ ChatListWhiteboardItem::ChatListWhiteboardItem(const ChatListWindow::Chat& chat, ChatListGroupItem* parent) : ChatListItem(parent), chat_(chat) {

+

+ }

+

+ const ChatListWindow::Chat& ChatListWhiteboardItem::getChat() const {

+ return chat_;

+ }

+

+ QVariant ChatListWhiteboardItem::data(int role) const {

+ switch (role) {

+ case Qt::DisplayRole: return P2QSTRING(chat_.chatName);

+ case DetailTextRole: return P2QSTRING(chat_.activity);

+ /*case Qt::TextColorRole: return textColor_;

+ case Qt::BackgroundColorRole: return backgroundColor_;

+ case Qt::ToolTipRole: return isContact() ? toolTipString() : QVariant();

+ case StatusTextRole: return statusText_;*/

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

+ case PresenceIconRole: return getPresenceIcon();

+ default: return QVariant();

+ }

+ }

+

+ QIcon ChatListWhiteboardItem::getPresenceIcon() const {

+ return QIcon(statusShowTypeToIconPath(chat_.statusType));

+ }

+}

+

+/*

+ * Copyright (c) 2012 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <QList>

+#include <QIcon>

+

+#include <boost/shared_ptr.hpp>

+

+#include <Swiften/MUC/MUCBookmark.h>

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

+

+#include <Swift/QtUI/ChatList/ChatListItem.h>

+

+namespace Swift {

+ class ChatListWhiteboardItem : public ChatListItem {

+ public:

+ enum RecentItemRoles {

+ DetailTextRole = Qt::UserRole,

+ AvatarRole = Qt::UserRole + 1,

+ PresenceIconRole = Qt::UserRole + 2/*,

+ StatusShowTypeRole = Qt::UserRole + 3*/

+ };

+ ChatListWhiteboardItem(const ChatListWindow::Chat& chat, ChatListGroupItem* parent);

+ const ChatListWindow::Chat& getChat() const;

+ QVariant data(int role) const;

+ private:

+ QIcon getPresenceIcon() const;

+ ChatListWindow::Chat chat_;

+ };

+}

+ * Copyright (c) 2010-2014 Kevin Smith

+#include <QMenu>

+#include <QMimeData>

+#include <QUrl>

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

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

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

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

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

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

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

+#include <Swift/QtUI/ChatList/ChatListWhiteboardItem.h>

+QtChatListWindow::QtChatListWindow(UIEventStream *uiEventStream, SettingsProvider* settings, QWidget* parent) : QTreeView(parent), isOnline_(false) {

+ settings_ = settings;

+ setDragEnabled(true);

+ delete mucRecentsMenu_;

+void QtChatListWindow::handleClearRecentsRequested() {

+ onClearRecentsRequested();

+}

+

+ onlineOnlyActions_ << mucMenu_->addAction(tr("Add New Bookmark"), this, SLOT(handleAddBookmark()));

+ onlineOnlyActions_ << mucMenu_->addAction(tr("Edit Bookmark"), this, SLOT(handleEditBookmark()));

+ onlineOnlyActions_ << mucMenu_->addAction(tr("Remove Bookmark"), this, SLOT(handleRemoveBookmark()));

+ mucRecentsMenu_ = new QMenu();

+ onlineOnlyActions_ << mucRecentsMenu_->addAction(tr("Add to Bookmarks"), this, SLOT(handleAddBookmarkFromRecents()));

+ mucRecentsMenu_->addAction(tr("Clear recents"), this, SLOT(handleClearRecentsRequested()));

+ onlineOnlyActions_ << emptyMenu_->addAction(tr("Add New Bookmark"), this, SLOT(handleAddBookmark()));

+ else if (ChatListWhiteboardItem* whiteboardItem = dynamic_cast<ChatListWhiteboardItem*>(item)) {

+ if (!whiteboardItem->getChat().isMUC || bookmarksEnabled_) {

+ eventStream_->send(boost::make_shared<ShowWhiteboardUIEvent>(whiteboardItem->getChat().jid));

+ }

+ }

+void QtChatListWindow::addWhiteboardSession(const ChatListWindow::Chat& chat) {

+ model_->addWhiteboardSession(chat);

+}

+

+void QtChatListWindow::removeWhiteboardSession(const JID& jid) {

+ model_->removeWhiteboardSession(jid);

+}

+

+void QtChatListWindow::setOnline(bool isOnline) {

+ isOnline_ = isOnline;

+}

+

+void QtChatListWindow::handleAddBookmarkFromRecents() {

+ ChatListRecentItem* item = dynamic_cast<ChatListRecentItem*>(contextMenuItem_);

+ if (item) {

+ const ChatListWindow::Chat& chat = item->getChat();

+ MUCBookmark bookmark(chat.jid, chat.jid.toBare().toString());

+ bookmark.setNick(chat.nick);

+ bookmark.setPassword(chat.password);

+ eventStream_->send(boost::shared_ptr<UIEvent>(new AddMUCBookmarkUIEvent(bookmark)));

+ }

+}

+

+void QtChatListWindow::dragEnterEvent(QDragEnterEvent *event) {

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

+ event->acceptProposedAction();

+ }

+}

+

+ foreach(QAction* action, onlineOnlyActions_) {

+ action->setEnabled(isOnline_);

+ }

+

+

+ return;

+

+ ChatListRecentItem* recentItem = dynamic_cast<ChatListRecentItem*>(baseItem);

+ if (recentItem) {

+ const ChatListWindow::Chat& chat = recentItem->getChat();

+ if (chat.isMUC) {

+ mucRecentsMenu_->exec(QCursor::pos());

+ return;

+

+ QMenu menu;

+ menu.addAction(tr("Clear recents"), this, SLOT(handleClearRecentsRequested()));

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

+ * Copyright (c) 2010-2014 Kevin Smith

+ void addWhiteboardSession(const ChatListWindow::Chat& chat);

+ void removeWhiteboardSession(const JID& jid);

+ virtual void setOnline(bool isOnline);

+ void handleAddBookmarkFromRecents();

+ void handleClearRecentsRequested();

+ void dragEnterEvent(QDragEnterEvent* event);

+ QMenu* mucRecentsMenu_;

+ QList<QAction*> onlineOnlyActions_;

+ bool isOnline_;

+ * Copyright (c) 2010-2013 Kevin Smith

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

+

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

+QString ChatSnippet::directionToCSS(Direction direction) {

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

+}

+

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

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

+ std::string text = "";

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

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

+ text = textPart->text;

+ break;

+ }

+ }

+ return getDirection(text);

+}

+

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

+ return getDirection(P2QSTRING(message));

+}

+

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

+ /*

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

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

+ case QChar::DirL:

+ case QChar::DirLRE:

+ case QChar::DirLRO:

+ return ChatSnippet::LTR;

+ case QChar::DirR:

+ case QChar::DirAL:

+ case QChar::DirRLE:

+ case QChar::DirRLO:

+ return ChatSnippet::RTL;

+ case QChar::DirEN:

+ case QChar::DirES:

+ case QChar::DirET:

+ case QChar::DirAN:

+ case QChar::DirCS:

+ case QChar::DirB:

+ case QChar::DirWS:

+ case QChar::DirON:

+ case QChar::DirS:

+ case QChar::DirPDF:

+ case QChar::DirNSM:

+ case QChar::DirBN:

+ break;

+ }

+ }

+ return ChatSnippet::LTR;

+ */

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

+}

+

+

+}

+ * Copyright (c) 2010-2013 Kevin Smith

+

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

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

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

+

+ enum Direction {

+ RTL,

+ LTR

+ };

+

+ result.replace("%wrapped_sender%", "&#37;wrapped_sender&#37;");

+ result.replace("\t", " ");

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

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

+ static Direction getDirection(const QString& message);

+

+ static QString directionToCSS(Direction direction);

+

+ struct Private;

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swiften/TLS/Certificate.h>

+#include <QWidget>

+

+namespace Swift {

+

+class CocoaUIHelpers {

+public:

+ static void displayCertificateChainAsSheet(QWidget* parent, const std::vector<Certificate::ref>& chain);

+};

+

+}

+

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "CocoaUIHelpers.h"

+

+#include <boost/shared_ptr.hpp>

+#include <boost/type_traits.hpp>

+

+#include <Cocoa/Cocoa.h>

+

+#include <Security/Security.h>

+#include <SecurityInterface/SFCertificatePanel.h>

+

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

+

+#pragma GCC diagnostic ignored "-Wold-style-cast"

+

+namespace Swift {

+

+void CocoaUIHelpers::displayCertificateChainAsSheet(QWidget* parent, const std::vector<Certificate::ref>& chain) {

+ NSWindow* parentWindow = [((NSView*)parent->winId()) window];

+ NSMutableArray* certificates = [[NSMutableArray alloc] init];

+ foreach(Certificate::ref cert, chain) {

+ // convert chain to SecCertificateRef

+ ByteArray certAsDER = cert->toDER();

+ boost::shared_ptr<boost::remove_pointer<CFDataRef>::type> certData(CFDataCreate(NULL, certAsDER.data(), certAsDER.size()), CFRelease);

+ boost::shared_ptr<OpaqueSecCertificateRef> macCert(SecCertificateCreateWithData(NULL, certData.get()), CFRelease);

+

+ // add to NSMutable array

+ [certificates addObject: (id)macCert.get()];

+ }

+

+

+ SFCertificatePanel* panel = [[SFCertificatePanel alloc] init];

+ //[panel setPolicies:(id)policies.get()];

+ [panel beginSheetForWindow:parentWindow modalDelegate:nil didEndSelector:NULL contextInfo:NULL certificates:certificates showGroup:YES];

+ [certificates release];

+}

+

+}

+ assert(false);

+ return QSize();

+ if (messageEvent) {

+ return MessageEventType;

+ }

+ if (subscriptionEvent) {

+ return SubscriptionEventType;

+ }

+ if (errorEvent) {

+ return ErrorEventType;

+ }

+ if (mucInviteEvent) {

+ return MUCInviteEventType;

+ }

+#include <QColor>

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

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

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

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

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

+

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

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

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

+ virtual void purgeCallbacks() {}

+

+#ifndef Q_OS_MAC

+ * Copyright (c) 2010-2013 Kevin Smith

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

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

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

+ content_.replace("%wrapped_sender%", wrapResizable(escape(sender)));

+ content_.replace("%sender%", escape(sender));

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

+ content_ = "<span class='date" + time.date().toString(Qt::ISODate) + "'>" + content_ + "</span>";

+ * Copyright (c) 2010-2013 Kevin Smith

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

+ }

+#ifndef Q_OS_MAC

+ * Copyright (c) 2010-2014 Kevin Smith

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

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

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

+

+ errorLabel_ = new QLabel(this);

+ errorLabel_->setText(QString("<b>%1</b>").arg(tr("Unable to complete the command because you have been disconnected")));

+ errorLabel_->setVisible(false);

+ errorLabel_->setFrameStyle(QFrame::Box|QFrame::Sunken);

+ layout_->addWidget(errorLabel_);

+

+

+}

+

+void QtAdHocCommandWindow::setOnline(bool online) {

+ if (!online) {

+ nextButton_->setEnabled(false);

+ backButton_->setEnabled(false);

+ completeButton_->setEnabled(false);

+ errorLabel_->setVisible(true);

+ }

+}

+void QtAdHocCommandWindow::closeEvent(QCloseEvent*) {

+ onClosing();

+ }

+ QString qNote(P2QSTRING(note.note));

+ if (command->getForm()) {

+ setForm(command->getForm());

+ } else {

+ setNoForm(notes.isEmpty());

+ }

+ form_ = form;

+void QtAdHocCommandWindow::setNoForm(bool andHide) {

+ form_.reset();

+ resize(minimumSize());

+ setVisible(!andHide);

+ virtual void setOnline(bool online);

+ void closeEvent(QCloseEvent* event);

+ void setNoForm(bool andHide);

+ QLabel* errorLabel_;

+/*

+ * Copyright (c) 2010-2014 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <boost/bind.hpp>

+#include <QLabel>

+#include <QPushButton>

+#include <QBoxLayout>

+#include <QDialogButtonBox>

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

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

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

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

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

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

+

+const int FormLayoutIndex = 1;

+

+namespace Swift {

+QtAdHocCommandWithJIDWindow::QtAdHocCommandWithJIDWindow(UIEventStream* uiEventStream) : uiEventStream_(uiEventStream) {

+ QVBoxLayout* hlayout = new QVBoxLayout(this);

+

+ QLabel* jidLabel = new QLabel("JID:", this);

+ hlayout->addWidget(jidLabel);

+ jid_ = new QLineEdit(this);

+ hlayout->addWidget(jid_);

+

+ QLabel* commandLabel = new QLabel("Command:", this);

+ hlayout->addWidget(commandLabel);

+ node_ = new QLineEdit(this);

+ hlayout->addWidget(node_);

+

+ QDialogButtonBox* buttonBox = new QDialogButtonBox(this);

+ QPushButton* rejectButton = buttonBox->addButton("Cancel", QDialogButtonBox::RejectRole);

+ connect(rejectButton, SIGNAL(clicked()), this, SLOT(handleRejectClick()));

+ QPushButton* acceptButton = buttonBox->addButton("Complete", QDialogButtonBox::AcceptRole);

+ connect(acceptButton, SIGNAL(clicked()), this, SLOT(handleAcceptClick()));

+ hlayout->addWidget(buttonBox);

+

+ setLayout(hlayout);

+ show();

+}

+

+QtAdHocCommandWithJIDWindow::~QtAdHocCommandWithJIDWindow() {

+}

+

+void QtAdHocCommandWithJIDWindow::handleAcceptClick() {

+ const JID jid = JID(Q2PSTRING(jid_->text()));

+ const std::string node = Q2PSTRING(node_->text());

+ boost::shared_ptr<UIEvent> event(new RequestAdHocWithJIDUIEvent(jid, node));

+ uiEventStream_->send(event);

+ accept();

+}

+

+void QtAdHocCommandWithJIDWindow::handleRejectClick() {

+ reject();

+}

+

+}

+/*

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

+#include <QLineEdit>

+

+#include <Swiften/AdHoc/OutgoingAdHocCommandSession.h>

+

+class QBoxLayout;

+

+namespace Swift {

+ class UIEventStream;

+ class QtFormWidget;

+ class QtAdHocCommandWithJIDWindow : public QDialog {

+ Q_OBJECT

+ public:

+ QtAdHocCommandWithJIDWindow(UIEventStream* eventStream);

+ virtual ~QtAdHocCommandWithJIDWindow();

+ public slots:

+ void handleAcceptClick();

+ void handleRejectClick();

+ private:

+ UIEventStream* uiEventStream_;

+ QLineEdit* jid_;

+ QLineEdit* node_;

+ };

+}

+ * Copyright (c) 2010-2014 Kevin Smith

+QtAddBookmarkWindow::QtAddBookmarkWindow(UIEventStream* eventStream, const MUCBookmark& bookmark) : eventStream_(eventStream) {

+ createFormFromBookmark(bookmark);

+}

+

+ * Copyright (c) 2010-2014 Kevin Smith

+ QtAddBookmarkWindow(UIEventStream* eventStream, const MUCBookmark& bookmark);

+ <string>Edit Affiliations</string>

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

+

+

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

+QtAvatarWidget::QtAvatarWidget(QWidget* parent) : QWidget(parent), editable(false) {

+ if (!editable) {

+ return;

+ }

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

+ Q_PROPERTY(bool editable READ isEditable WRITE setEditable)

+ void setEditable(bool b) {

+ editable = b;

+ }

+

+ bool isEditable() const {

+ return editable;

+ }

+

+ bool editable;

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <QtBlockListEditorWindow.h>

+#include <ui_QtBlockListEditorWindow.h>

+

+#include <boost/bind.hpp>

+

+#include <QLineEdit>

+#include <QMovie>

+#include <QShortcut>

+#include <QStyledItemDelegate>

+#include <QValidator>

+

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

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

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

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

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

+

+namespace Swift {

+

+class QtJIDValidator : public QValidator {

+ public:

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

+ virtual ~QtJIDValidator() {}

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

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

+ }

+};

+

+class QtJIDValidatedItemDelegate : public QItemDelegate {

+ public:

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

+ virtual ~QtJIDValidatedItemDelegate() {}

+

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

+ QLineEdit *editor = new QLineEdit(parent);

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

+ return editor;

+ }

+

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

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

+

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

+ lineEdit->setText(value);

+ }

+

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

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

+ QString currentValue = lineEdit->text();

+ int pos = 0;

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

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

+ } else {

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

+ }

+ }

+

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

+ editor->setGeometry(option.rect);

+ }

+};

+

+QtBlockListEditorWindow::QtBlockListEditorWindow() : QWidget(), ui(new Ui::QtBlockListEditorWindow), removeItemDelegate(0), editItemDelegate(0) {

+ ui->setupUi(this);

+

+ freshBlockListTemplate = tr("Double-click to add contact");

+

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

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

+

+ removeItemDelegate = new QtRemovableItemDelegate(style());

+ editItemDelegate = new QtJIDValidatedItemDelegate(this);

+

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

+

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

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

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

+

+#if QT_VERSION >= 0x050000

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

+#else

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

+#endif

+

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

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

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

+ ui->blockListTreeWidget->setItemDelegateForColumn(0, editItemDelegate);

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

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

+ ui->blockListTreeWidget->installEventFilter(this);

+

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

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

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

+}

+

+QtBlockListEditorWindow::~QtBlockListEditorWindow() {

+}

+

+void QtBlockListEditorWindow::show() {

+ QWidget::showNormal();

+ QWidget::activateWindow();

+ QWidget::raise();

+}

+

+void QtBlockListEditorWindow::hide() {

+ QWidget::hide();

+}

+

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

+ // check whether changed item contains a valid JID and make it removable

+ if (item && item->text(0) != freshBlockListTemplate) {

+ item->setText(1, "");

+ }

+

+ // check for empty rows and add an empty one so the user can add items

+ bool hasEmptyRow = false;

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

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

+ if (row->text(0) == freshBlockListTemplate) {

+ hasEmptyRow = true;

+ }

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

+ ui->blockListTreeWidget->removeItemWidget(row, 0);

+ }

+ }

+

+ if (!hasEmptyRow) {

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

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

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

+ }

+

+ if (!item) {

+ ui->blockListTreeWidget->setCurrentItem(ui->blockListTreeWidget->topLevelItem(0));

+ }

+}

+

+void QtBlockListEditorWindow::applyChanges() {

+ onSetNewBlockList(getCurrentBlockList());

+}

+

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

+ ui->blockListTreeWidget->clear();

+

+ foreach(const JID& jid, blockedJIDs) {

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

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

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

+ }

+ handleItemChanged(0,0);

+}

+

+void QtBlockListEditorWindow::setBusy(bool isBusy) {

+ if (isBusy) {

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

+ ui->throbberLabel->show();

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

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

+ } else {

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

+ ui->throbberLabel->hide();

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

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

+ }

+}

+

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

+ if (!error.empty()) {

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

+ }

+ else {

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

+ }

+}

+

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

+ std::vector<JID> futureBlockedJIDs;

+

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

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

+ JID jid = JID(Q2PSTRING(row->text(0)));

+ if (!jid.toString().empty() && jid.isValid()) {

+ futureBlockedJIDs.push_back(jid);

+ }

+ }

+ return futureBlockedJIDs;

+}

+

+bool QtBlockListEditorWindow::eventFilter(QObject* target, QEvent* event) {

+ if (target == ui->blockListTreeWidget) {

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

+ QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);

+ if (keyEvent->key() == Qt::Key_Backspace) {

+ // remove currently selected item

+ QTreeWidgetItem* currentItem = ui->blockListTreeWidget->currentItem();

+ if (currentItem->text(0) != freshBlockListTemplate) {

+ ui->blockListTreeWidget->takeTopLevelItem(ui->blockListTreeWidget->indexOfTopLevelItem(currentItem));

+ return true;

+ }

+ }

+ else if (keyEvent->key() == Qt::Key_Return) {

+ // open editor for return key d

+ ui->blockListTreeWidget->editItem(ui->blockListTreeWidget->currentItem(), 0);

+ return true;

+ }

+ }

+ }

+ return QWidget::eventFilter(target, event);

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

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

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

+

+#include <QWidget>

+#include <QTreeWidgetItem>

+

+namespace Ui {

+ class QtBlockListEditorWindow;

+}

+

+namespace Swift {

+

+class QtJIDValidatedItemDelegate;

+

+class QtBlockListEditorWindow : public QWidget, public BlockListEditorWidget {

+ Q_OBJECT

+

+ public:

+ QtBlockListEditorWindow();

+ virtual ~QtBlockListEditorWindow();

+

+ virtual void show();

+ virtual void hide();

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

+ virtual void setBusy(bool isBusy);

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

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

+ virtual bool eventFilter(QObject* target, QEvent* event);

+

+ private slots:

+ void handleItemChanged(QTreeWidgetItem*, int);

+ void applyChanges();

+

+ private:

+ Ui::QtBlockListEditorWindow* ui;

+ QtRemovableItemDelegate* removeItemDelegate;

+ QtJIDValidatedItemDelegate* editItemDelegate;

+ QString freshBlockListTemplate;

+};

+

+}

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

+<ui version="4.0">

+ <class>QtBlockListEditorWindow</class>

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

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>333</width>

+ <height>262</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string>Edit Block List</string>

+ </property>

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

+ <property name="spacing">

+ <number>5</number>

+ </property>

+ <property name="leftMargin">

+ <number>5</number>

+ </property>

+ <property name="topMargin">

+ <number>5</number>

+ </property>

+ <property name="rightMargin">

+ <number>5</number>

+ </property>

+ <property name="bottomMargin">

+ <number>5</number>

+ </property>

+ <item>

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

+ <property name="text">

+ <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p align=&quot;justify&quot;&gt;The follwing list shows all contacts that you have currently blocked. You can add contacts to the list at the buttom of the list and remove contacts by clicking on the right column.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>

+ </property>

+ <property name="textFormat">

+ <enum>Qt::RichText</enum>

+ </property>

+ <property name="alignment">

+ <set>Qt::AlignJustify|Qt::AlignVCenter</set>

+ </property>

+ <property name="wordWrap">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <attribute name="headerVisible">

+ <bool>false</bool>

+ </attribute>

+ <column>

+ <property name="text">

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

+ </property>

+ </column>

+ </widget>

+ </item>

+ <item>

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

+ <property name="sizeConstraint">

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

+ </property>

+ <item>

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

+ <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="QPushButton" name="savePushButton">

+ <property name="text">

+ <string>Save</string>

+ </property>

+ <property name="default">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ <resources/>

+ <connections/>

+</ui>

+ * Copyright (c) 2010-2014 Kevin Smith

+ setFixedHeight(sizeHint().height());

+void QtBookmarkDetailWindow::createFormFromBookmark(const MUCBookmark& bookmark) {

+ if (bookmark.getRoom().isValid()) {

+ room_->setText(P2QSTRING(bookmark.getRoom().toString()));

+ }

+

+ if (!bookmark.getName().empty()) {

+ name_->setText(P2QSTRING(bookmark.getName()));

+ }

+

+ if (bookmark.getNick()) {

+ nick_->setText(P2QSTRING((*bookmark.getNick())));

+ }

+

+ if (bookmark.getPassword()) {

+ password_->setText(P2QSTRING((*bookmark.getPassword())));

+ }

+

+ if (bookmark.getAutojoin()) {

+ autojoin_->setCheckState(Qt::Checked);

+ } else {

+ autojoin_->setCheckState(Qt::Unchecked);

+ }

+}

+

+ * Copyright (c) 2010-2014 Kevin Smith

+ protected:

+ void createFormFromBookmark(const MUCBookmark& bookmark);

+

+ <width>382</width>

+ <height>207</height>

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

+ <property name="leftMargin">

+ <number>12</number>

+ </property>

+ <property name="topMargin">

+ <number>12</number>

+ </property>

+ <property name="rightMargin">

+ <number>12</number>

+ </property>

+ <property name="bottomMargin">

+ <number>12</number>

+ <item>

+ <property name="fieldGrowthPolicy">

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

+ </property>

+ </item>

+ </layout>

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

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

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

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

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

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

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

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

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

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtCertificateViewerDialog.h"

+#include "ui_QtCertificateViewerDialog.h"

+

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

+

+#include <QTreeWidgetItem>

+#include <QLabel>

+#include <QDateTime>

+

+namespace Swift {

+

+QtCertificateViewerDialog::QtCertificateViewerDialog(QWidget* parent) : QDialog(parent), ui(new Ui::QtCertificateViewerDialog) {

+ ui->setupUi(this);

+ connect(ui->certChainTreeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)), SLOT(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)));

+

+ setAttribute(Qt::WA_DeleteOnClose);

+}

+

+QtCertificateViewerDialog::~QtCertificateViewerDialog() {

+ delete ui;

+}

+

+void QtCertificateViewerDialog::setCertificateChain(const std::vector<Certificate::ref>& chain) {

+ // clean widgets

+ ui->certChainTreeWidget->clear();

+

+ if (chain.empty()) return;

+

+ // convert Swift certificate chain to qt certificate chain (root goes first)

+ currentChain.clear();

+ foreach(Certificate::ref cert, chain) {

+ ByteArray certAsDer = cert->toDER();

+ QByteArray dataArray(reinterpret_cast<const char*>(certAsDer.data()), certAsDer.size());

+ currentChain.push_front(QSslCertificate(dataArray, QSsl::Der));

+ }

+

+ // fill treeWidget

+ QTreeWidgetItem* root = new QTreeWidgetItem(ui->certChainTreeWidget, QStringList(currentChain.at(0).subjectInfo(QSslCertificate::CommonName)));

+ root->setData(0, Qt::UserRole, QVariant(0));

+ root->setExpanded(true);

+ ui->certChainTreeWidget->addTopLevelItem(root);

+ if (currentChain.size() > 1) {

+ QTreeWidgetItem* parent = root;

+ for (int n = 1; n < currentChain.size(); n++) {

+ QTreeWidgetItem* link = new QTreeWidgetItem(parent, QStringList(QString("↳ ") + currentChain.at(n).subjectInfo(QSslCertificate::CommonName)));

+ link->setExpanded(true);

+ link->setData(0, Qt::UserRole, QVariant(n));

+ parent = link;

+ }

+ ui->certChainTreeWidget->setCurrentItem(parent);

+ } else {

+ ui->certChainTreeWidget->setCurrentItem(root);

+ }

+}

+

+void QtCertificateViewerDialog::displayCertificateChainAsSheet(QWidget* parent, const std::vector<Certificate::ref>& chain) {

+ QtCertificateViewerDialog* dialog = new QtCertificateViewerDialog(parent);

+ dialog->setCertificateChain(chain);

+ dialog->show();

+}

+

+void QtCertificateViewerDialog::currentItemChanged(QTreeWidgetItem* current, QTreeWidgetItem*) {

+ setCertificateDetails(currentChain.at(current->data(0, Qt::UserRole).toInt()));

+}

+

+#define ADD_SECTION( TITLE ) \

+ ui->certGridLayout->addWidget(new QLabel("<strong>" + TITLE + "</strong>"), rowCount++, 0, 1, 2);

+

+#define ADD_FIELD( TITLE, VALUE) \

+ ui->certGridLayout->addWidget(new QLabel(TITLE), rowCount, 0, 1, 1, Qt::AlignRight); \

+ valueLabel = new QLabel(VALUE); \

+ valueLabel->setTextFormat(Qt::PlainText); \

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

+ ui->certGridLayout->addWidget(valueLabel, rowCount++, 1, 1, 1, Qt::AlignLeft);

+

+void QtCertificateViewerDialog::setCertificateDetails(const QSslCertificate& cert) {

+ QLayoutItem* item;

+ while ((item = ui->certGridLayout->takeAt(0)) != NULL ) {

+ delete item->widget();

+ delete item;

+ }

+

+ int rowCount = 0;

+

+ ui->certGridLayout->setColumnStretch(2, 1);

+

+ QLabel* valueLabel = 0;

+

+ ADD_SECTION(tr("General"));

+ ADD_FIELD(tr("Valid From"), cert.effectiveDate().toString(Qt::TextDate));

+ ADD_FIELD(tr("Valid To"), cert.expiryDate().toString(Qt::TextDate));

+ ADD_FIELD(tr("Serial Number"), QString(cert.serialNumber().toHex()));

+ ADD_FIELD(tr("Version"), QString(cert.version()));

+

+ ADD_SECTION(tr("Subject"));

+ ADD_FIELD(tr("Organization"), cert.subjectInfo(QSslCertificate::Organization));

+ ADD_FIELD(tr("Common Name"), cert.subjectInfo(QSslCertificate::CommonName));

+ ADD_FIELD(tr("Locality"), cert.subjectInfo(QSslCertificate::LocalityName));

+ ADD_FIELD(tr("Organizational Unit"), cert.subjectInfo(QSslCertificate::OrganizationalUnitName));

+ ADD_FIELD(tr("Country"), cert.subjectInfo(QSslCertificate::CountryName));

+ ADD_FIELD(tr("State"), cert.subjectInfo(QSslCertificate::StateOrProvinceName));

+

+ if (!cert.alternateSubjectNames().empty()) {

+ ADD_SECTION(tr("Alternate Subject Names"));

+ QMultiMap<QSsl::AlternateNameEntryType, QString> altNames = cert.alternateSubjectNames();

+ foreach (const QSsl::AlternateNameEntryType &type, altNames.uniqueKeys()) {

+ foreach (QString name, altNames.values(type)) {

+ if (type == QSsl::EmailEntry) {

+ ADD_FIELD(tr("E-mail Address"), name);

+ } else {

+ ADD_FIELD(tr("DNS Name"), name);

+ }

+ }

+ }

+ }

+

+ ADD_SECTION(tr("Issuer"));

+ ADD_FIELD(tr("Organization"), cert.issuerInfo(QSslCertificate::Organization));

+ ADD_FIELD(tr("Common Name"), cert.issuerInfo(QSslCertificate::CommonName));

+ ADD_FIELD(tr("Locality"), cert.issuerInfo(QSslCertificate::LocalityName));

+ ADD_FIELD(tr("Organizational Unit"), cert.issuerInfo(QSslCertificate::OrganizationalUnitName));

+ ADD_FIELD(tr("Country"), cert.issuerInfo(QSslCertificate::CountryName));

+ ADD_FIELD(tr("State"), cert.issuerInfo(QSslCertificate::StateOrProvinceName));

+

+ ui->certGridLayout->setRowStretch(rowCount + 1, 1);

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QDialog>

+#include <QList>

+#include <QSslCertificate>

+#include <QTreeWidgetItem>

+

+#include <Swiften/TLS/Certificate.h>

+

+namespace Ui {

+class QtCertificateViewerDialog;

+}

+

+namespace Swift {

+

+class QtCertificateViewerDialog : public QDialog {

+ Q_OBJECT

+

+ public:

+ explicit QtCertificateViewerDialog(QWidget* parent = 0);

+ ~QtCertificateViewerDialog();

+

+ void setCertificateChain(const std::vector<Certificate::ref>& chain);

+

+ static void displayCertificateChainAsSheet(QWidget* parent, const std::vector<Certificate::ref>& chain);

+

+ private slots:

+ void currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*);

+

+ private:

+ void setCertificateDetails(const QSslCertificate& cert);

+

+ private:

+ Ui::QtCertificateViewerDialog *ui;

+ QList<QSslCertificate> currentChain;

+};

+

+}

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

+<ui version="4.0">

+ <class>QtCertificateViewerDialog</class>

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

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>655</width>

+ <height>514</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string>Certificate Viewer</string>

+ </property>

+ <property name="sizeGripEnabled">

+ <bool>true</bool>

+ </property>

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

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

+ <widget class="QDialogButtonBox" name="buttonBox">

+ <property name="orientation">

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

+ </property>

+ <property name="standardButtons">

+ <set>QDialogButtonBox::Ok</set>

+ </property>

+ </widget>

+ </item>

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

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

+ <property name="autoFillBackground">

+ <bool>false</bool>

+ </property>

+ <property name="horizontalScrollBarPolicy">

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

+ </property>

+ <property name="widgetResizable">

+ <bool>true</bool>

+ </property>

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

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>629</width>

+ <height>368</height>

+ </rect>

+ </property>

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

+ <item>

+ <layout class="QGridLayout" name="certGridLayout"/>

+ </item>

+ </layout>

+ </widget>

+ </widget>

+ </item>

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

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

+ <property name="maximumSize">

+ <size>

+ <width>16777215</width>

+ <height>70</height>

+ </size>

+ </property>

+ <property name="editTriggers">

+ <set>QAbstractItemView::NoEditTriggers</set>

+ </property>

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

+ <bool>false</bool>

+ </property>

+ <property name="dragEnabled">

+ <bool>false</bool>

+ </property>

+ <property name="rootIsDecorated">

+ <bool>false</bool>

+ </property>

+ <property name="itemsExpandable">

+ <bool>false</bool>

+ </property>

+ <property name="expandsOnDoubleClick">

+ <bool>false</bool>

+ </property>

+ <attribute name="headerVisible">

+ <bool>false</bool>

+ </attribute>

+ <column>

+ <property name="text">

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

+ </property>

+ </column>

+ </widget>

+ </item>

+ </layout>

+ </widget>

+ <resources/>

+ <connections>

+ <connection>

+ <sender>buttonBox</sender>

+ <signal>accepted()</signal>

+ <receiver>QtCertificateViewerDialog</receiver>

+ <slot>accept()</slot>

+ <hints>

+ <hint type="sourcelabel">

+ <x>248</x>

+ <y>254</y>

+ </hint>

+ <hint type="destinationlabel">

+ <x>157</x>

+ <y>274</y>

+ </hint>

+ </hints>

+ </connection>

+ <connection>

+ <sender>buttonBox</sender>

+ <signal>rejected()</signal>

+ <receiver>QtCertificateViewerDialog</receiver>

+ <slot>reject()</slot>

+ <hints>

+ <hint type="sourcelabel">

+ <x>316</x>

+ <y>260</y>

+ </hint>

+ <hint type="destinationlabel">

+ <x>286</x>

+ <y>274</y>

+ </hint>

+ </hints>

+ </connection>

+ </connections>

+</ui>

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

+#ifndef Q_OS_MAC

+#else

+ setAttribute(Qt::WA_ShowWithoutActivating);

+ tabs_->setMovable(true);

+ int index;

+ if (widget && ((index = tabs_->indexOf(widget)) >= 0)) {

+ if (!singleWindow_) {

+ else {

+ setWindowTitle("");

+ onTitleChanged("");

+ }

+ }

+ else {

+ }

+}

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

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

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

+ setWindowTitle(title);

+ emit onTitleChanged(title);

+#ifndef Q_OS_MAC

+#else

+ /* https://bugreports.qt-project.org/browse/QTBUG-19194

+ * ^ When the above is fixed we can swap the below for just show();

+ * WA_ShowWithoutActivating seems to helpfully not work, so... */

+

+ QWidget* currentWindow = QApplication::activeWindow(); /* Remember who had focus if we're the current application*/

+ show();

+ QCoreApplication::processEvents(); /* Run through the eventloop to clear the show() */

+ if (currentWindow) {

+ currentWindow->activateWindow(); /* Set focus back */

+ }

+#endif

+ QtChatTabs(bool singleWindow);

+ void onTitleChanged(const QString& title);

+ bool singleWindow_;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ * Copyright (c) 2013 Kevin Smith

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

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

+QtChatView::~QtChatView() {

+ * Copyright (c) 2013 Kevin Smith

+#pragma once

+#include <string>

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

+#include <QWidget>

+ class HighlightAction;

+ class SecurityLabel;

+

+ QtChatView(QWidget* parent);

+ virtual ~QtChatView();

+ /** Add message to window.

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

+ */

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

+ /** Adds action to window.

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

+ */

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

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

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

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

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

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

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

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

+ virtual std::string addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes) = 0;

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

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

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

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

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

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

+ virtual void showEmoticons(bool show) = 0;

+ virtual void addLastSeenLine() = 0;

+

+ public slots:

+ virtual void resizeFont(int fontSizeSteps) = 0;

+ virtual void scrollToBottom() = 0;

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

+ * Copyright (c) 2010-2014 Kevin Smith

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

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

+#include <qdebug.h>

+#include <QFileDialog>

+#include <QInputDialog>

+#include <QLabel>

+#include <QMenu>

+#include <QMessageBox>

+#include <QMimeData>

+#include <QPushButton>

+#include <QTextDocument>

+#include <QToolButton>

+#include <QMimeData>

+

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

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

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

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

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

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

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

+

+#include <SwifTools/TabComplete.h>

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

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

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

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

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

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

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

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

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

+namespace Swift {

+

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

+ labelModel_ = NULL;

+ fileTransferEnabled_ = Maybe;

+ alertLayout_ = new QVBoxLayout();

+ layout->addLayout(alertLayout_);

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

+ subjectLayout_->addWidget(subject_);

+ QPushButton* actionButton_ = new QPushButton(this);

+ layout->addLayout(subjectLayout_);

+ if (settings_->getSetting(QtUISettingConstants::USE_PLAIN_CHATS) || settings_->getSetting(QtUISettingConstants::USE_SCREENREADER)) {

+ messageLog_ = new QtPlainChatView(this, eventStream_);

+ }

+ else {

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

+ }

+ treeWidget_ = new QtOccupantListWidget(eventStream_, settings_, QtTreeWidget::MessageDefaultJID, this);

+ midBar_ = new QWidget(this);

+ //layout->addWidget(midBar);

+ midBar_->setAutoFillBackground(true);

+ QHBoxLayout *midBarLayout = new QHBoxLayout(midBar_);

+ //midBarLayout->addStretch();

+ connect(labelsWidget_, SIGNAL(currentIndexChanged(int)), this, SLOT(handleCurrentLabelChanged(int)));

+ defaultLabelsPalette_ = labelsWidget_->palette();

+ input_ = new QtTextEdit(settings_, this);

+ inputBarLayout->addWidget(midBar_);

+

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

+ QHBoxLayout* actionLayout = new QHBoxLayout();

+ actionLayout->addWidget(actionButton_);

+

+ inputBarLayout->addLayout(actionLayout);

+ midBar_->setFocusProxy(input_);

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

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

+

+void QtChatWindow::handleSettingChanged(const std::string& setting) {

+ if (setting == QtUISettingConstants::SHOW_EMOTICONS.getKey()) {

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

+ messageLog_->showEmoticons(showEmoticons);

+ }

+}

+

+ const QObject* alertWidget = QObject::sender()->parent();

+ std::map<AlertID, QWidget*>::const_iterator i = alertWidgets_.begin();

+ for ( ; i != alertWidgets_.end(); ++i) {

+ if (i->second == alertWidget) {

+ removeAlert(i->first);

+ break;

+QtChatWindow::AlertID QtChatWindow::addAlert(const std::string& alertText) {

+ QWidget* alertWidget = new QWidget(this);

+ QHBoxLayout* alertLayout = new QHBoxLayout(alertWidget);

+ alertLayout_->addWidget(alertWidget);

+ QLabel* alertLabel = new QLabel(this);

+ alertLabel->setText(alertText.c_str());

+ alertLayout->addWidget(alertLabel);

+

+ QToolButton* closeButton = new QToolButton(alertWidget);

+ closeButton->setIcon(style()->standardIcon(QStyle::SP_TitleBarCloseButton));

+ closeButton->setIconSize(QSize(16,16));

+ closeButton->setCursor(Qt::ArrowCursor);

+ closeButton->setStyleSheet("QToolButton { border: none; padding: 0px; }");

+ connect (closeButton, SIGNAL(clicked()), this, SLOT(handleAlertButtonClicked()));

+

+ alertLayout->addWidget(closeButton);

+ QPalette palette = alertWidget->palette();

+ palette.setColor(QPalette::Window, QColor(Qt::yellow));

+ palette.setColor(QPalette::WindowText, QColor(Qt::black));

+ alertWidget->setStyleSheet(alertStyleSheet_);

+ alertLabel->setStyleSheet(alertStyleSheet_);

+

+ AlertID id = nextAlertId_++;

+ alertWidgets_[id] = alertWidget;

+ return id;

+}

+

+void QtChatWindow::removeAlert(const AlertID id) {

+ std::map<AlertID, QWidget*>::iterator i = alertWidgets_.find(id);

+ if (i != alertWidgets_.end()) {

+ alertLayout_->removeWidget(i->second);

+ delete i->second;

+ alertWidgets_.erase(i);

+ }

+ }

+ else if ((key == Qt::Key_Up) && input_->toPlainText().isEmpty() && !(lastSentMessage_.isEmpty())) {

+ }

+ else if (key == Qt::Key_Down && isCorrection_ && input_->textCursor().atBlockEnd()) {

+ }

+ else if (key == Qt::Key_Down || key == Qt::Key_Up) {

+ }

+ else {

+ boost::optional<AlertID> newCorrectingAlert;

+ newCorrectingAlert = addAlert(Q2PSTRING(tr("This chat may not support message correction. If you send a correction anyway, it may appear as a duplicate message")));

+ }

+ else if (correctionEnabled_ == ChatWindow::No) {

+ newCorrectingAlert = addAlert(Q2PSTRING(tr("This chat does not support message correction. If you send a correction anyway, it will appear as a duplicate message")));

+

+ if (newCorrectingAlert) {

+ if (correctingAlert_) {

+ removeAlert(*correctingAlert_);

+ }

+ correctingAlert_ = newCorrectingAlert;

+ }

+

+ labelsWidget_->setEnabled(false);

+ if (correctingAlert_) {

+ removeAlert(*correctingAlert_);

+ correctingAlert_.reset();

+ }

+ labelsWidget_->setEnabled(true);

+ }

+ else {

+ while(cursor.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor) && cursor.document()->characterAt(cursor.position() - 1) != ' ') { }

+ delete labelModel_;

+ labelModel_ = new LabelModel();

+ labelModel_->availableLabels_ = labels;

+ labelsWidget_->setModel(labelModel_);

+ break;

+void QtChatWindow::handleCurrentLabelChanged(int index) {

+ if (static_cast<size_t>(index) >= labelModel_->availableLabels_.size()) {

+ qDebug() << "User selected a label that doesn't exist";

+ return;

+ }

+ const SecurityLabelsCatalog::Item& label = labelModel_->availableLabels_[index];

+ if (label.getLabel()) {

+ QPalette palette = labelsWidget_->palette();

+ //palette.setColor(QPalette::Base, P2QSTRING(label.getLabel()->getBackgroundColor()));

+ palette.setColor(labelsWidget_->backgroundRole(), P2QSTRING(label.getLabel()->getBackgroundColor()));

+ palette.setColor(labelsWidget_->foregroundRole(), P2QSTRING(label.getLabel()->getForegroundColor()));

+ labelsWidget_->setPalette(palette);

+ midBar_->setPalette(palette);

+ labelsWidget_->setAutoFillBackground(true);

+ }

+ else {

+ labelsWidget_->setAutoFillBackground(false);

+ labelsWidget_->setPalette(defaultLabelsPalette_);

+ midBar_->setPalette(defaultLabelsPalette_);

+ }

+}

+ }

+ else {

+void QtChatWindow::setFileTransferEnabled(Tristate enabled) {

+ fileTransferEnabled_ = enabled;

+}

+

+ assert(labelsWidget_->currentIndex() >= 0 && static_cast<size_t>(labelsWidget_->currentIndex()) < labelModel_->availableLabels_.size());

+ return labelModel_->availableLabels_[labelsWidget_->currentIndex()];

+void QtChatWindow::convertToMUC(MUCType mucType) {

+ impromptu_ = (mucType == ImpromptuMUC);

+ treeWidget_->setMessageTarget(impromptu_ ? QtTreeWidget::MessageDisplayJID : QtTreeWidget::MessageDefaultJID);

+ isMUC_ = true;

+ subject_->setVisible(!impromptu_);

+ }

+ else {

+ }

+ else {

+bool QtChatWindow::isVisible() const {

+ return QWidget::isVisible();

+}

+

+ if (inputEnabled_) {

+ if (!isMUC_) {

+ event->acceptProposedAction();

+ }

+ }

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

+ if (isMUC_ || supportsImpromptuChat_) {

+ }

+}

+ if (fileTransferEnabled_ == ChatWindow::Yes && event->mimeData()->hasUrls()) {

+ else {

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

+ ChatMessage message;

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

+ addSystemMessage(message, DefaultDirection);

+ }

+ }

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

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

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

+ std::vector<JID> invites;

+ while (!dataStream.atEnd()) {

+ QString jidString;

+ dataStream >> jidString;

+ invites.push_back(Q2PSTRING(jidString));

+ }

+ onInviteToChat(invites);

+ subject_->setToolTip(P2QSTRING(subject));

+ subject_->setCursorPosition(0);

+ QAction* block = NULL;

+ QAction* unblock = NULL;

+

+ if (availableRoomActions_.empty()) {

+ if (blockingState_ == IsBlocked) {

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

+ unblock->setEnabled(inputEnabled_);

+ }

+ else if (blockingState_ == IsUnblocked) {

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

+ block->setEnabled(inputEnabled_);

+ }

+

+ if (supportsImpromptuChat_) {

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

+ invite->setEnabled(inputEnabled_);

+ }

+

+ }

+ else {

+ if (impromptu_) {

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

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

+ availableAction == ChatWindow::Configure ||

+ availableAction == ChatWindow::Affiliations ||

+ availableAction == ChatWindow::Destroy) {

+ continue;

+ }

+ }

+ case ChatWindow::ChangeSubject:

+ changeSubject = contextMenu.addAction(tr("Change subject…"));

+ changeSubject->setEnabled(inputEnabled_);

+ break;

+ case ChatWindow::Configure:

+ configure = contextMenu.addAction(tr("Configure room…"));

+ configure->setEnabled(inputEnabled_);

+ break;

+ case ChatWindow::Affiliations:

+ affiliations = contextMenu.addAction(tr("Edit affiliations…"));

+ affiliations->setEnabled(inputEnabled_);

+ break;

+ case ChatWindow::Destroy:

+ destroy = contextMenu.addAction(tr("Destroy room"));

+ destroy->setEnabled(inputEnabled_);

+ break;

+ case ChatWindow::Invite:

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

+ invite->setEnabled(inputEnabled_);

+ break;

+ }

+ QAction* bookmark = contextMenu.addAction(tr("Add boomark..."));

+ bookmark->setEnabled(inputEnabled_);

+

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

+ }

+ else if (result == block) {

+ onBlockUserRequest();

+ else if (result == unblock) {

+ onUnblockUserRequest();

+ }

+ else if (result == bookmark) {

+ onBookmarkRequest();

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

+void QtChatWindow::setBlockingState(BlockingState state) {

+ blockingState_ = state;

+}

+

+void QtChatWindow::setCanInitiateImpromptuChats(bool supportsImpromptu) {

+ supportsImpromptuChat_ = supportsImpromptu;

+}

+

+void QtChatWindow::showBookmarkWindow(const MUCBookmark& bookmark) {

+ QtAddBookmarkWindow* window = new QtAddBookmarkWindow(eventStream_, bookmark);

+ window->show();

+}

+

+void QtChatWindow::handleAppendedToLog() {

+ if (lastLineTracker_.getShouldMoveLastLine()) {

+ /* should this be queued? */

+ messageLog_->addLastSeenLine();

+ }

+}

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

+ handleAppendedToLog();

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

+

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

+ handleAppendedToLog();

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

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

+ handleAppendedToLog();

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

+}

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

+ handleAppendedToLog();

+ messageLog_->addSystemMessage(message, direction);

+}

+

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

+ handleAppendedToLog();

+ messageLog_->addPresenceMessage(message, direction);

+}

+

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

+ handleAppendedToLog();

+ messageLog_->addErrorMessage(message);

+}

+

+

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

+ handleAppendedToLog();

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

+}

+

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

+ handleAppendedToLog();

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

+}

+

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

+ handleAppendedToLog();

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

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

+ messageLog_->setFileTransferProgress(id, percentageDone);

+}

+

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

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

+}

+

+

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

+ handleAppendedToLog();

+ return messageLog_->addWhiteboardRequest(contact_, senderIsSelf);

+}

+

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

+ messageLog_->setWhiteboardSessionStatus(id, state);

+}

+

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

+ messageLog_->replaceLastMessage(message, timestampBehaviour);

+}

+

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

+ messageLog_->setAckState(id, state);

+}

+

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

+ messageLog_->setMessageReceiptState(id, state);

+ * Copyright (c) 2010-2014 Kevin Smith

+#include <map>

+#include <QPointer>

+#include <QTextCursor>

+#include <QMap>

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

+

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

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

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

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

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

+

+

+ class LabelModel : public QAbstractListModel {

+ LabelModel(QObject* parent = NULL) : QAbstractListModel(parent) {}

+

+ virtual int rowCount(const QModelIndex& /*index*/) const {

+ return static_cast<int>(availableLabels_.size());

+ }

+

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

+ if (!index.isValid()) {

+ return QVariant();

+ }

+ boost::shared_ptr<SecurityLabel> label = availableLabels_[index.row()].getLabel();

+ if (label && role == Qt::TextColorRole) {

+ return P2QSTRING(label->getForegroundColor());

+ }

+ if (label && role == Qt::TextColorRole) {

+ return P2QSTRING(label->getBackgroundColor());

+ }

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

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

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

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

+ return labelName;

+ }

+ return QVariant();

+ }

+

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

+ };

+

+ class QtChatWindow : public QtTabbable, public ChatWindow {

+ Q_OBJECT

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

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

+

+ void addSystemMessage(const ChatMessage& message, Direction direction);

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

+ void addErrorMessage(const ChatMessage& message);

+

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

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

+ std::string addWhiteboardRequest(bool senderIsSelf);

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

+

+ bool isVisible() const;

+ void convertToMUC(MUCType mucType);

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

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

+ void setBlockingState(BlockingState state);

+ virtual void setCanInitiateImpromptuChats(bool supportsImpromptu);

+ virtual void showBookmarkWindow(const MUCBookmark& bookmark);

+ AlertID addAlert(const std::string& alertText);

+ void removeAlert(const AlertID id);

+ void setFileTransferEnabled(Tristate enabled);

+ void handleCurrentLabelChanged(int);

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

+

+ void handleAppendedToLog();

+

+ QWidget* midBar_;

+ QBoxLayout* subjectLayout_;

+ boost::optional<AlertID> correctingAlert_;

+ QVBoxLayout* alertLayout_;

+ std::map<AlertID, QWidget*> alertWidgets_;

+ AlertID nextAlertId_;

+ Tristate fileTransferEnabled_;

+ QPalette defaultLabelsPalette_;

+ LabelModel* labelModel_;

+ BlockingState blockingState_;

+ bool impromptu_;

+ bool isMUC_;

+ bool supportsImpromptuChat_;

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

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

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

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

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

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

+

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

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

+

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

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

+

+ class QtSingleWindow;

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

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

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+/* Contains demo Trolltech code from http://git.forwardbias.in/?p=lineeditclearbutton.git with license: */

+/****************************************************************************

+**

+** Copyright (c) 2007 Trolltech ASA <info@trolltech.com>

+**

+** Use, modification and distribution is allowed without limitation,

+** warranty, liability or support of any kind.

+**

+****************************************************************************/

+

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

+#include <QApplication>

+#include <QToolButton>

+#include <QStyle>

+#include <QKeyEvent>

+

+namespace Swift {

+

+const int QtClosableLineEdit::clearButtonPadding = 2;

+

+QtClosableLineEdit::QtClosableLineEdit(QWidget *parent) : QLineEdit(parent) {

+ clearButton = new QToolButton(this);

+ clearButton->setIcon(style()->standardIcon(QStyle::SP_TitleBarCloseButton));

+ clearButton->setIconSize(QSize(16,16));

+ clearButton->setCursor(Qt::ArrowCursor);

+ clearButton->setStyleSheet("QToolButton { border: none; padding: 0px; }");

+ clearButton->hide();

+ connect(clearButton, SIGNAL(clicked()), this, SLOT(handleCloseButtonClicked()));

+ connect(this, SIGNAL(textChanged(const QString&)), this, SLOT(updateCloseButton(const QString&)));

+ int frameWidth = style()->pixelMetric(QStyle::PM_DefaultFrameWidth);

+ setStyleSheet(QString("QLineEdit { padding-right: %1px; } ").arg(clearButton->sizeHint().width() + frameWidth + 1));

+ QSize minimumSize = minimumSizeHint();

+ setMinimumSize(qMax(minimumSize.width(), clearButton->sizeHint().width() + frameWidth * 2 + clearButtonPadding),

+ qMax(minimumSize.height(), clearButton->sizeHint().height() + frameWidth * 2 + clearButtonPadding));

+}

+

+void QtClosableLineEdit::resizeEvent(QResizeEvent *) {

+ QSize size = clearButton->sizeHint();

+ int frameWidth = style()->pixelMetric(QStyle::PM_DefaultFrameWidth);

+ clearButton->move(rect().right() - frameWidth - size.width(), (rect().bottom() + 1 - size.height())/2);

+}

+

+void QtClosableLineEdit::updateCloseButton(const QString& text) {

+ clearButton->setVisible(!text.isEmpty());

+}

+

+void QtClosableLineEdit::handleCloseButtonClicked() {

+ clear();

+ QApplication::postEvent(this, new QKeyEvent(QEvent::KeyPress, Qt::Key_Escape, Qt::NoModifier));

+ QApplication::postEvent(this, new QKeyEvent(QEvent::KeyRelease, Qt::Key_Escape, Qt::NoModifier));

+}

+

+}

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+/* Contains demo Trolltech code from http://git.forwardbias.in/?p=lineeditclearbutton.git with license: */

+/****************************************************************************

+**

+** Copyright (c) 2007 Trolltech ASA <info@trolltech.com>

+**

+** Use, modification and distribution is allowed without limitation,

+** warranty, liability or support of any kind.

+**

+****************************************************************************/

+

+#pragma once

+

+#include <QLineEdit>

+

+class QToolButton;

+

+namespace Swift {

+

+class QtClosableLineEdit : public QLineEdit

+{

+ Q_OBJECT

+ public:

+ QtClosableLineEdit(QWidget *parent = 0);

+

+ protected:

+ void resizeEvent(QResizeEvent *);

+

+ private slots:

+ void updateCloseButton(const QString &text);

+ void handleCloseButtonClicked();

+

+ private:

+ static const int clearButtonPadding;

+ QToolButton *clearButton;

+};

+

+}

+/*

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

+ };

+

+}

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

+<ui version="4.0">

+ <class>QtConnectionSettings</class>

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

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>406</width>

+ <height>454</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string>Connection Options</string>

+ </property>

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

+ <item>

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

+ <item>

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

+ <property name="text">

+ <string>Connection Method:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QComboBox" name="connectionMethod">

+ <property name="sizePolicy">

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

+ <horstretch>1</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <item>

+ <property name="text">

+ <string>Automatic</string>

+ </property>

+ </item>

+ <item>

+ <property name="text">

+ <string>Manual</string>

+ </property>

+ </item>

+ <item>

+ <property name="text">

+ <string>BOSH</string>

+ </property>

+ </item>

+ </widget>

+ </item>

+ <item>

+ <spacer name="horizontalSpacer">

+ <property name="orientation">

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

+ </property>

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

+ <size>

+ <width>238</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ </layout>

+ </item>

+ <item>

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

+ <property name="orientation">

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

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QStackedWidget" name="stackedWidget">

+ <property name="currentIndex">

+ <number>0</number>

+ </property>

+ <widget class="QWidget" name="page_3"/>

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

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

+ <item>

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

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

+ <item>

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

+ <property name="text">

+ <string>Secure connection:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QComboBox" name="manual_useTLS">

+ <item>

+ <property name="text">

+ <string>Never</string>

+ </property>

+ </item>

+ <item>

+ <property name="text">

+ <string>Encrypt when possible</string>

+ </property>

+ </item>

+ <item>

+ <property name="text">

+ <string>Always encrypt</string>

+ </property>

+ </item>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ <item>

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

+ <property name="text">

+ <string>Allow Compression</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="text">

+ <string>Allow sending password over insecure connection</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>4</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

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

+ <property name="text">

+ <string>Manually select server</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <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>18</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

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

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="text">

+ <string>Hostname:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="sizePolicy">

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

+ <horstretch>4</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="text">

+ <string>Port:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="sizePolicy">

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

+ <horstretch>1</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ <item>

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

+ <property name="title">

+ <string>Connection Proxy</string>

+ </property>

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

+ <item>

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

+ <item>

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

+ <property name="text">

+ <string>Proxy type:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QComboBox" name="manual_proxyType">

+ <property name="currentIndex">

+ <number>1</number>

+ </property>

+ <item>

+ <property name="text">

+ <string>None</string>

+ </property>

+ </item>

+ <item>

+ <property name="text">

+ <string>Use system-configured proxy</string>

+ </property>

+ </item>

+ <item>

+ <property name="text">

+ <string>SOCKS5</string>

+ </property>

+ </item>

+ <item>

+ <property name="text">

+ <string>HTTP Connect</string>

+ </property>

+ </item>

+ </widget>

+ </item>

+ <item>

+ <spacer name="horizontalSpacer_7">

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

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

+ <property name="text">

+ <string>Override system-configured proxy</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <item>

+ <spacer name="horizontalSpacer_8">

+ <property name="orientation">

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

+ </property>

+ <property name="sizeType">

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

+ </property>

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

+ <size>

+ <width>18</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

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

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="text">

+ <string>Hostname:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="sizePolicy">

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

+ <horstretch>4</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="text">

+ <string>Port:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="sizePolicy">

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

+ <horstretch>1</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </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>88</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ </layout>

+ </widget>

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

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

+ <item>

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

+ <item>

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

+ <property name="text">

+ <string>BOSH URI:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="sizePolicy">

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

+ <horstretch>4</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ <item>