+ Q_OBJECT

+

+ public:

+ MyWidget() : application_("MyApplication") {

+ QVBoxLayout *layout = new QVBoxLayout(this);

+ input_ = new QLineEdit(this);

+ layout->addWidget(input_);

+ connect(input_, SIGNAL(returnPressed()), SLOT(handleReturnPressed()));

+ }

+

+ private slots:

+ void handleReturnPressed() {

+ application_.getApplicationMessageDisplay()->setMessage(Q2PSTRING(input_->text()));

+ }

+

+ private:

+ PlatformApplication application_;

+ QLineEdit* input_;

+ QApplication app(argc, argv);

+ MyWidget widget;

+ widget.show();

+ return app.exec();

+#define exclude_columns CRYPTUI_SELECT_LOCATION_COLUMN | CRYPTUI_SELECT_INTENDEDUSE_COLUMN

+ DWORD cbHash = SHA1_HASH_LENGTH;

+ BYTE aHash[SHA1_HASH_LENGTH];

+ std::string result("certstore:");

+ result += cert_store_name;

+ result += ":sha1:";

+ if (CertGetCertificateContextProperty(cert, CERT_HASH_PROP_ID, aHash, &cbHash) == FALSE ) {

+ return "";

+ }

+ ByteArray byteArray = createByteArray((char *)(&aHash[0]), cbHash);

+ result += Hexify::hexify(byteArray);

+ return result;

+ const char* certStoreName = "MY";

+ DWORD storeFlags = CERT_STORE_OPEN_EXISTING_FLAG | CERT_STORE_READONLY_FLAG | CERT_SYSTEM_STORE_CURRENT_USER;

+ HCERTSTORE hstore = CertOpenStore(CERT_STORE_PROV_SYSTEM_A, 0, 0, storeFlags, certStoreName);

+ if (!hstore) {

+ return "";

+ }

+ HWND hwnd = GetForegroundWindow();

+ if (!hwnd) {

+ hwnd = GetActiveWindow();

+ }

+ std::string certificateDialogTitle = QT_TRANSLATE_NOOP("", "TLS Client Certificate Selection");

+ std::string certificateDialogPrompt = QT_TRANSLATE_NOOP("", "Select a certificate to use for authentication");

+ int titleLength = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, certificateDialogTitle.c_str(), -1, NULL, 0);

+ int promptLength = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, certificateDialogPrompt.c_str(), -1, NULL, 0);

+ wchar_t* titleChars = new wchar_t[titleLength];

+ wchar_t* promptChars = new wchar_t[promptLength];

+ //titleChars[titleLength] = '\0';

+ //promptChars[promptLength] = '\0';

+ titleLength = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, certificateDialogTitle.c_str(), -1, titleChars, titleLength);

+ promptLength = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, certificateDialogPrompt.c_str(), -1, promptChars, promptLength);

+ if (titleLength == 0 || promptLength == 0) {

+ int error = GetLastError();

+ switch (error) {

+ case ERROR_INSUFFICIENT_BUFFER: SWIFT_LOG(error) << "Insufficient buffer for rendering cert dialog" << std::endl;break;

+ case ERROR_INVALID_FLAGS: SWIFT_LOG(error) << "Invalid flags for rendering cert dialog" << std::endl;break;

+ case ERROR_INVALID_PARAMETER: SWIFT_LOG(error) << "Invalid parameter for rendering cert dialog" << std::endl;break;

+ case ERROR_NO_UNICODE_TRANSLATION: SWIFT_LOG(error) << "Invalid unicode for rendering cert dialog" << std::endl;break;

+ default: SWIFT_LOG(error) << "Unexpected multibyte conversion errorcode" << std::endl;

+ }

+ }

+ /* Call Windows dialog to select a suitable certificate */

+ PCCERT_CONTEXT cert = CryptUIDlgSelectCertificateFromStore(hstore, hwnd, titleChars, promptChars, exclude_columns, 0, NULL);

+ delete[] titleChars;

+ delete[] promptChars;

+ if (hstore) {

+ CertCloseStore(hstore, 0);

+ }

+ std::string result;

+ if (cert) {

+ result = getCertUri(cert, certStoreName);

+ CertFreeCertificateContext(cert);

+ }

+

+ return result;

+ return (boost::iequals(uri.substr(0, 10), "certstore:"));

+ std::string selectCAPICertificate();

+ bool isCAPIURI(std::string uri);

+ groupDelegate_ = new GroupItemDelegate();

+ delete groupDelegate_;

+ compact_ = compact;

+ emit sizeHintChanged(QModelIndex());

+ ChatListItem* item = static_cast<ChatListItem*>(index.internalPointer());

+ if (item && dynamic_cast<ChatListMUCItem*>(item)) {

+ return mucSizeHint(option, index);

+ }

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

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

+ }

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

+ return groupDelegate_->sizeHint(option, index);

+ }

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

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

+ }

+ return QStyledItemDelegate::sizeHint(option, index);

+ QFontMetrics nameMetrics(common_.nameFont);

+ QFontMetrics statusMetrics(common_.detailFont);

+ int sizeByText = 2 * common_.verticalMargin + nameMetrics.height() + statusMetrics.height();

+ return QSize(150, sizeByText);

+ return mucSizeHint(option, index);

+ ChatListItem* item = static_cast<ChatListItem*>(index.internalPointer());

+ if (item && dynamic_cast<ChatListMUCItem*>(item)) {

+ paintMUC(painter, option, dynamic_cast<ChatListMUCItem*>(item));

+ }

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

+ paintRecent(painter, option, dynamic_cast<ChatListRecentItem*>(item));

+ }

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

+ ChatListGroupItem* group = dynamic_cast<ChatListGroupItem*>(item);

+ groupDelegate_->paint(painter, option, group->data(Qt::DisplayRole).toString(), group->rowCount(), option.state & QStyle::State_Open);

+ }

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

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

+ }

+ else {

+ QStyledItemDelegate::paint(painter, option, index);

+ }

+ painter->save();

+ QRect fullRegion(option.rect);

+ if ( option.state & QStyle::State_Selected ) {

+ painter->fillRect(fullRegion, option.palette.highlight());

+ painter->setPen(option.palette.highlightedText().color());

+ } else {

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

+ painter->setPen(QPen(nameColor));

+ }

+

+ QFontMetrics nameMetrics(common_.nameFont);

+ painter->setFont(common_.nameFont);

+ int extraFontWidth = nameMetrics.width("H");

+ int leftOffset = common_.horizontalMargin * 2 + extraFontWidth / 2;

+ QRect textRegion(fullRegion.adjusted(leftOffset, 0, 0, 0));

+

+ int nameHeight = nameMetrics.height() + common_.verticalMargin;

+ QRect nameRegion(textRegion.adjusted(0, common_.verticalMargin, 0, 0));

+

+ DelegateCommons::drawElidedText(painter, nameRegion, item->data(Qt::DisplayRole).toString());

+

+ painter->setFont(common_.detailFont);

+ painter->setPen(QPen(QColor(160,160,160)));

+

+ QRect detailRegion(textRegion.adjusted(0, nameHeight, 0, 0));

+ DelegateCommons::drawElidedText(painter, detailRegion, item->data(ChatListMUCItem::DetailTextRole).toString());

+

+ painter->restore();

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

+ QString avatarPath;

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

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

+ }

+ QIcon presenceIcon = item->data(ChatListRecentItem::PresenceIconRole).isValid() && !item->data(ChatListRecentItem::PresenceIconRole).value<QIcon>().isNull()

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

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

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

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

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

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

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

+ class ChatListRecentItem;

+ class ChatListWhiteboardItem;

+ class ChatListDelegate : public QStyledItemDelegate {

+ public:

+ ChatListDelegate(bool compact);

+ ~ChatListDelegate();

+ QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const;

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

+ public slots:

+ void setCompact(bool compact);

+ private:

+ void paintMUC(QPainter* painter, const QStyleOptionViewItem& option, ChatListMUCItem* item) const;

+ void paintRecent(QPainter* painter, const QStyleOptionViewItem& option, ChatListRecentItem* item) const;

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

+ QSize mucSizeHint(const QStyleOptionViewItem& /*option*/, const QModelIndex& /*index*/ ) const;

+ QSize recentSizeHint(const QStyleOptionViewItem& /*option*/, const QModelIndex& /*index*/ ) const;

+ bool compact_;

+ DelegateCommons common_;

+ GroupItemDelegate* groupDelegate_;

+ };

+ class ChatListGroupItem : public ChatListItem {

+ public:

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

+ }

+

+

+ private:

+ static bool pointerItemLessThan(const ChatListItem* first, const ChatListItem* second) {

+ QString myName = first->data(Qt::DisplayRole).toString().toLower();

+ QString theirName = second->data(Qt::DisplayRole).toString().toLower();

+ return myName < theirName;

+ }

+

+ QString name_;

+ QList<ChatListItem*> items_;

+ bool sorted_;

+ };

+ class ChatListGroupItem;

+ class ChatListItem {

+ public:

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

+ virtual ~ChatListItem() {}

+ ChatListGroupItem* parent() {return parent_;}

+ virtual QVariant data(int role) const = 0;

+ private:

+ ChatListGroupItem* parent_;

+ };

+ return bookmark_;

+ switch (role) {

+ case Qt::DisplayRole: return P2QSTRING(bookmark_.getName());

+ case DetailTextRole: return P2QSTRING(bookmark_.getRoom().toString());

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

+ case Qt::BackgroundColorRole: return backgroundColor_;

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

+ case StatusTextRole: return statusText_;

+ case AvatarRole: return avatar_;

+ case PresenceIconRole: return getPresenceIcon();*/

+ default: return QVariant();

+ }

+ class ChatListMUCItem : public ChatListItem {

+ public:

+ enum MUCItemRoles {

+ DetailTextRole = Qt::UserRole/*,

+ AvatarRole = Qt::UserRole + 1,

+ PresenceIconRole = Qt::UserRole + 2,

+ StatusShowTypeRole = Qt::UserRole + 3*/

+ };

+ ChatListMUCItem(const MUCBookmark& bookmark, ChatListGroupItem* parent);

+ const MUCBookmark& getBookmark() const;

+ QVariant data(int role) const;

+ private:

+ MUCBookmark bookmark_;

+ QList<ChatListItem*> items_;

+ };

+ root_ = new ChatListGroupItem("", NULL, false);

+ mucBookmarks_ = new ChatListGroupItem(tr("Bookmarked Rooms"), root_);

+ recents_ = new ChatListGroupItem(tr("Recent Chats"), root_, false);

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

+ root_->addItem(whiteboards_);

+ root_->addItem(recents_);

+ root_->addItem(mucBookmarks_);

+ 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 flags = QAbstractItemModel::flags(index);

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

+ flags |= Qt::ItemIsDragEnabled;

+ }

+ return flags;

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

+ mucBookmarks_->clear();

+ endRemoveRows();

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

+ mucBookmarks_->addItem(new ChatListMUCItem(bookmark, mucBookmarks_));

+ endInsertRows();

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

+ ChatListMUCItem* item = dynamic_cast<ChatListMUCItem*>(mucBookmarks_->item(i));

+ if (item->getBookmark() == bookmark) {

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

+ mucBookmarks_->remove(i);

+ endRemoveRows();

+ break;

+ }

+ }

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

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

+ endInsertRows();

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

+ break;

+ }

+ }

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

+ recents_->clear();

+ endRemoveRows();

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

+ foreach (const ChatListWindow::Chat chat, recents) {

+ recents_->addItem(new ChatListRecentItem(chat, recents_));

+ }

+ endInsertRows();

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

+ const ChatListMUCItem* mucItem = NULL;

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

+ ChatListMUCItem* item = dynamic_cast<ChatListMUCItem*>(mucBookmarks_->item(i));

+ if (item->getBookmark().getRoom() == roomJID) {

+ mucItem = item;

+ break;

+ }

+ }

+ return mucItem;

+ return 1;

+ return index.isValid() ? static_cast<ChatListItem*>(index.internalPointer()) : NULL;

+ ChatListItem* item = getItemForIndex(index);

+ return item ? item->data(role) : QVariant();

+ if (!hasIndex(row, column, parent)) {

+ return QModelIndex();

+ }

+ ChatListGroupItem *parentItem = parent.isValid() ? static_cast<ChatListGroupItem*>(parent.internalPointer()) : root_;

+ return row < parentItem->rowCount() ? createIndex(row, column, parentItem->item(row)) : QModelIndex();

+ if (!index.isValid()) {

+ return QModelIndex();

+ }

+ ChatListGroupItem* parent = static_cast<ChatListGroupItem*>(index.internalPointer())->parent();

+ return (parent == root_) ? QModelIndex() : createIndex(parent->parent()->row(parent), 0, parent);

+ ChatListGroupItem* parent = NULL;

+ if (parentIndex.isValid()) {

+ parent = dynamic_cast<ChatListGroupItem*>(static_cast<ChatListItem*>(parentIndex.internalPointer()));

+ } else {

+ parent = root_;

+ }

+ int count = (parent ? parent->rowCount() : 0);

+ return count;

+ class ChatListMUCItem;

+

+ class ChatListModel : public QAbstractItemModel {

+ Q_OBJECT

+ public:

+ ChatListModel();

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

+ void addMUCBookmark(const MUCBookmark& bookmark);

+ void removeMUCBookmark(const MUCBookmark& bookmark);

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

+ void removeWhiteboardSession(const JID& jid);

+ int columnCount(const QModelIndex& parent = QModelIndex()) const;

+ QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;

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

+ QModelIndex parent(const QModelIndex& index) const;

+ int rowCount(const QModelIndex& parent = QModelIndex()) const;

+ ChatListItem* getItemForIndex(const QModelIndex& index) const;

+ void clearBookmarks();

+ void setRecents(const std::list<ChatListWindow::Chat>& recents);

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

+

+ const ChatListMUCItem* getChatListMUCItem(const JID& roomJID) const;

+

+ private:

+ ChatListGroupItem* mucBookmarks_;

+ ChatListGroupItem* recents_;

+ ChatListGroupItem* whiteboards_;

+ ChatListGroupItem* root_;

+

+ QPersistentModelIndex mucBookmarksIndex_;

+ QPersistentModelIndex recentsIndex_;

+ QPersistentModelIndex whiteboardsIndex_;

+ };

+ return chat_;

+ switch (role) {

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

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

+ }

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

+ class ChatListRecentItem : public ChatListItem {

+ public:

+ enum RecentItemRoles {

+ DetailTextRole = Qt::UserRole,

+ AvatarRole = Qt::UserRole + 1,

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

+ StatusShowTypeRole = Qt::UserRole + 3,

+ IdleRole = Qt::UserRole + 4*/

+ };

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

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

+ QVariant data(int role) const;

+ private:

+ QIcon getPresenceIcon() const;

+ ChatListWindow::Chat chat_;

+ };

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

+ }

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

+ };

+ eventStream_ = uiEventStream;

+ settings_ = settings;

+ bookmarksEnabled_ = false;

+ model_ = new ChatListModel();

+ setModel(model_);

+ delegate_ = new ChatListDelegate(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+ setItemDelegate(delegate_);

+ setHeaderHidden(true);

+ setAlternatingRowColors(true);

+ expandAll();

+ setAnimated(true);

+ setIndentation(0);

+ setDragEnabled(true);

+ setRootIsDecorated(true);

+ setupContextMenus();

+ connect(this, SIGNAL(activated(const QModelIndex&)), this, SLOT(handleItemActivated(const QModelIndex&)));

+ connect(this, SIGNAL(clicked(const QModelIndex&)), this, SLOT(handleClicked(const QModelIndex&)));

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

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

+ delete model_;

+ delete delegate_;

+ delete mucMenu_;

+ delete emptyMenu_;

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

+ delegate_->setCompact(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+ repaint();

+ }

+ onClearRecentsRequested();

+ bookmarksEnabled_ = enabled;

+ ChatListGroupItem* item = dynamic_cast<ChatListGroupItem*>(static_cast<ChatListItem*>(index.internalPointer()));

+ if (item) {

+ setExpanded(index, !isExpanded(index));

+ }

+ mucMenu_ = new QMenu();

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

+ emptyMenu_ = new QMenu();

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

+ ChatListItem* item = model_->getItemForIndex(index);

+ if (ChatListMUCItem* mucItem = dynamic_cast<ChatListMUCItem*>(item)) {

+ onMUCBookmarkActivated(mucItem->getBookmark());

+ }

+ else if (ChatListRecentItem* recentItem = dynamic_cast<ChatListRecentItem*>(item)) {

+ onRecentActivated(recentItem->getChat());

+ }

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

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

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

+ }

+ }

+ model_->clearBookmarks();

+ model_->addMUCBookmark(bookmark);

+ model_->removeMUCBookmark(bookmark);

+ model_->addWhiteboardSession(chat);

+ model_->removeWhiteboardSession(jid);

+ model_->setRecents(recents);

+ emit onCountUpdated(unread);

+ isOnline_ = isOnline;

+ const ChatListMUCItem* mucItem = dynamic_cast<const ChatListMUCItem*>(contextMenuItem_);

+ if (!mucItem) return;

+ eventStream_->send(boost::shared_ptr<UIEvent>(new RemoveMUCBookmarkUIEvent(mucItem->getBookmark())));

+ const ChatListRecentItem* item = dynamic_cast<const 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)));

+ }

+ (new QtAddBookmarkWindow(eventStream_))->show();

+ const ChatListMUCItem* mucItem = dynamic_cast<const ChatListMUCItem*>(contextMenuItem_);

+ if (!mucItem) return;

+ QtEditBookmarkWindow* window = new QtEditBookmarkWindow(eventStream_, mucItem->getBookmark());

+ window->show();

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

+ event->acceptProposedAction();

+ }

+ QModelIndex index = indexAt(event->pos());

+ ChatListItem* baseItem = index.isValid() ? static_cast<ChatListItem*>(index.internalPointer()) : NULL;

+ contextMenuItem_ = baseItem;

+

+ foreach(QAction* action, onlineOnlyActions_) {

+ action->setEnabled(isOnline_);

+ }

+

+ if (!baseItem) {

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

+ return;

+ }

+

+ ChatListMUCItem* mucItem = dynamic_cast<ChatListMUCItem*>(baseItem);

+ if (mucItem) {

+ if (!bookmarksEnabled_) {

+ return;

+ }

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

+ return;

+ }

+

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

+ if (recentItem) {

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

+ if (chat.isMUC) {

+ QMenu mucRecentsMenu;

+ QAction* bookmarkAction = NULL;

+ const ChatListMUCItem* mucItem = model_->getChatListMUCItem(chat.jid);

+ if (mucItem) {

+ contextMenuItem_ = mucItem;

+ bookmarkAction = mucRecentsMenu.addAction(tr("Edit Bookmark"), this, SLOT(handleEditBookmark()));

+ }

+ else {

+ bookmarkAction = mucRecentsMenu.addAction(tr("Add to Bookmarks"), this, SLOT(handleAddBookmarkFromRecents()));

+ }

+ bookmarkAction->setEnabled(isOnline_);

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

+ mucRecentsMenu.exec(QCursor::pos());

+ return;

+ }

+ }

+

+ QMenu menu;

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

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

+ class SettingsProvider;

+ class QtChatListWindow : public QTreeView, public ChatListWindow {

+ Q_OBJECT

+ public:

+ QtChatListWindow(UIEventStream *uiEventStream, SettingsProvider* settings, QWidget* parent = NULL);

+ virtual ~QtChatListWindow();

+ void addMUCBookmark(const MUCBookmark& bookmark);

+ void removeMUCBookmark(const MUCBookmark& bookmark);

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

+ void removeWhiteboardSession(const JID& jid);

+ void setBookmarksEnabled(bool enabled);

+ void setRecents(const std::list<ChatListWindow::Chat>& recents);

+ void setUnreadCount(int unread);

+ void clearBookmarks();

+ virtual void setOnline(bool isOnline);

+ signals:

+ void onCountUpdated(int count);

+ private slots:

+ void handleItemActivated(const QModelIndex&);

+ void handleAddBookmark();

+ void handleEditBookmark();

+ void handleRemoveBookmark();

+ void handleAddBookmarkFromRecents();

+ void handleClicked(const QModelIndex& index);

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

+ void handleClearRecentsRequested();

+ protected:

+ void dragEnterEvent(QDragEnterEvent* event);

+ void contextMenuEvent(QContextMenuEvent* event);

+ private:

+ void setupContextMenus();

+ bool bookmarksEnabled_;

+ UIEventStream* eventStream_;

+ ChatListModel* model_;

+ ChatListDelegate* delegate_;

+ QMenu* mucMenu_;

+ QMenu* emptyMenu_;

+ const ChatListItem* contextMenuItem_;

+ SettingsProvider* settings_;

+ QList<QAction*> onlineOnlyActions_;

+ bool isOnline_;

+ };

+ QDate now(QDate::currentDate());

+ QString date = "";

+ if (time.date().daysTo(now) > 0) {

+ date = "ddd ";

+ }

+ if (time.date().month() != now.month()) {

+ date = date + "MMMM ";

+ }

+ if (time.date().daysTo(now) > 6) {

+ date = date + "d ";

+ }

+ if (time.date().year() != now.year()) {

+ date = date + "yy ";

+ }

+ date += "h:mm";

+ return escape(time.toString(date));

+ return "<span class='swift_resizable'>" + text + "</span>";

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

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

+ return getDirection(P2QSTRING(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;

+ class ChatSnippet {

+ public:

+ enum Direction {

+ RTL,

+ LTR

+ };

+

+ ChatSnippet(bool appendToPrevious);

+ virtual ~ChatSnippet();

+

+ virtual const QString& getContent() const = 0;

+ virtual QString getContinuationElementID() const { return ""; }

+

+ boost::shared_ptr<ChatSnippet> getContinuationFallbackSnippet() const {return continuationFallback_;}

+

+ bool getAppendToPrevious() const {

+ return appendToPrevious_;

+ }

+

+ static QString escape(const QString& original) {

+ QString result(original);

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

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

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

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

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

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

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

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

+ result.replace(" ", "&nbsp;&nbsp;");

+ return result;

+ }

+

+ static QString timeToEscapedString(const QDateTime& time);

+

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

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

+ static Direction getDirection(const QString& message);

+

+ protected:

+ static QString directionToCSS(Direction direction);

+

+ QString wrapResizable(const QString& text);

+ void setContinuationFallbackSnippet(boost::shared_ptr<ChatSnippet> continuationFallback) {

+ continuationFallback_ = continuationFallback;

+ }

+ private:

+ bool appendToPrevious_;

+ boost::shared_ptr<ChatSnippet> continuationFallback_;

+ };

+ public:

+ MyNetworkReply() {

+ }

+

+ qint64 readData(char*, qint64) {

+ return 0;

+ }

+

+ virtual void abort() {

+ }

+ public:

+ MyNetworkAccessManager() {

+ }

+

+ QNetworkReply * createRequest (Operation op, const QNetworkRequest& request, QIODevice* outgoingData = 0) {

+ assert(op == QNetworkAccessManager::GetOperation);

+ qDebug() << "Requesting: " << request.url();

+ return QNetworkAccessManager::createRequest(op, request, outgoingData);

+ //return new MyNetworkReply();

+ }

+ QVBoxLayout* mainLayout = new QVBoxLayout(this);

+ webView_ = new QWebView(this);

+

+ QFile file(":/themes/Stockholm/Contents/Resources/Incoming/Content.html");

+ file.open(QIODevice::ReadOnly);

+ QString content = QString::fromUtf8(file.readAll());

+

+ webPage_ = new QWebPage(this);

+ webPage_->setNetworkAccessManager(new MyNetworkAccessManager());

+ webView_->setPage(webPage_);

+ QString pagehtml =

+ "<head>"

+ //"<base href=\"file:///Users/remko/src/swift/resources/themes/Stockholm/Contents/Resources/\"/>"

+ "<base href=\"file:///Users/remko/src/swift/resources/themes/Stockholm/Contents/Resources/\"/>"

+ "<link rel=\"stylesheet\" type=\"text/css\" href=\"main.css\"/>"

+ "<link rel=\"stylesheet\" type=\"text/css\" href=\"Variants/Alt Blue - Blue.css\"/>"

+ "</head><body>" + content + "</body>";

+ qDebug() << pagehtml;

+ webPage_->mainFrame()->setHtml(pagehtml);

+ public:

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

+ setFocusPolicy(Qt::NoFocus);

+

+ QVBoxLayout* mainLayout = new QVBoxLayout(this);

+ mainLayout->setSpacing(0);

+ mainLayout->setContentsMargins(0,0,0,0);

+

+ webView_ = new QWebView(this);

+ webView_->setFocusPolicy(Qt::NoFocus);

+ mainLayout->addWidget(webView_);

+

+ webPage_ = new QWebPage(this);

+ webPage_->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);

+ webView_->setPage(webPage_);

+ connect(webPage_, SIGNAL(selectionChanged()), SLOT(copySelectionToClipboard()));

+

+ QString pageHTML = "<head></head><body><div id=\"chat\"></div></body>";

+ webPage_->mainFrame()->setHtml(pageHTML);

+ }

+

+ void appendHTML(const QString& html) {

+ webPage_->mainFrame()->evaluateJavaScript(

+ "newNode = document.createElement(\"div\");"

+ "newNode.innerHTML = \"" + html + "\";"

+ "chatElement = document.getElementById(\"chat\");"

+ "chatElement.appendChild(newNode);");

+ webPage_->mainFrame()->setScrollBarValue(Qt::Vertical, webPage_->mainFrame()->scrollBarMaximum(Qt::Vertical));

+ }

+

+ private:

+ QWebView* webView_;

+ QWebPage* webPage_;

+ Q_OBJECT

+

+ public:

+ MyWidget() : previousWasIncoming_(false), previousWasOutgoing_(false), previousWasSystem_(false) {

+ QVBoxLayout* mainLayout = new QVBoxLayout(this);

+ chatView_ = new QtChatView(this);

+ mainLayout->addWidget(chatView_);

+ input1_ = new QLineEdit(this);

+ connect(input1_, SIGNAL(returnPressed()), SLOT(addIncoming()));

+ mainLayout->addWidget(input1_);

+ input2_ = new QLineEdit(this);

+ connect(input2_, SIGNAL(returnPressed()), SLOT(addOutgoing()));

+ mainLayout->addWidget(input2_);

+ input3_ = new QLineEdit(this);

+ connect(input3_, SIGNAL(returnPressed()), SLOT(addSystem()));

+ mainLayout->addWidget(input3_);

+

+ resize(300,200);

+ }

+

+ public slots:

+ void addIncoming() {

+ chatView_->addMessage(MessageSnippet(input1_->text(), "Me", QDateTime::currentDateTime(), "qrc:/icons/avatar.png", true, previousWasIncoming_));

+ previousWasIncoming_ = true;

+ previousWasOutgoing_ = false;

+ previousWasSystem_ = false;

+ input1_->clear();

+ }

+

+ void addOutgoing() {

+ chatView_->addMessage(MessageSnippet(input2_->text(), "You", QDateTime::currentDateTime(), "qrc:/icons/avatar.png", false, previousWasOutgoing_));

+ previousWasIncoming_ = false;

+ previousWasOutgoing_ = true;

+ previousWasSystem_ = false;

+ input2_->clear();

+ }

+

+ void addSystem() {

+ chatView_->addMessage(SystemMessageSnippet(input3_->text(), QDateTime::currentDateTime(), previousWasSystem_));

+ previousWasIncoming_ = false;

+ previousWasOutgoing_ = false;

+ previousWasSystem_ = true;

+ input3_->clear();

+ }

+

+ private:

+ bool previousWasIncoming_;

+ bool previousWasOutgoing_;

+ bool previousWasSystem_;

+ QtChatView* chatView_;

+ QLineEdit* input1_;

+ QLineEdit* input2_;

+ QLineEdit* input3_;

+

+ QApplication app(argc, argv);

+ MyWidget w;

+ w.show();

+ return app.exec();

+ /**

+ * This class is here as a workaround for a bug in Qt.

+ * See Case #501.

+ */

+ class CocoaApplicationActivateHelper : public QObject {

+ public:

+ CocoaApplicationActivateHelper();

+ virtual ~CocoaApplicationActivateHelper();

+ private:

+ bool eventFilter(QObject* o, QEvent* e);

+ private:

+ struct Private;

+ Private* p;

+ };

+ (void) event; (void) reply;

+ QApplication::postEvent(qApp, new QEvent(QEvent::ApplicationActivate));

+ CocoaApplicationActivateHelperDelegate* delegate;

+ bool initialized;

+ p = new Private();

+ p->delegate = [[CocoaApplicationActivateHelperDelegate alloc] init];

+ p->initialized = false;

+ qApp->installEventFilter(this);

+ [[NSAppleEventManager sharedAppleEventManager] removeEventHandlerForEventClass:kCoreEventClass andEventID:kAEReopenApplication];

+ [p->delegate release];

+ delete p;

+ if (object == qApp && event->type() == QEvent::ApplicationActivate && !p->initialized) {

+ [[NSAppleEventManager sharedAppleEventManager] setEventHandler:p->delegate andSelector:@selector(handleActivate:withReply:) forEventClass:kCoreEventClass andEventID:kAEReopenApplication];

+ p->initialized = true;

+ }

+ return QObject::eventFilter(object, event);

+ static void 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];

+ messageDelegate_(QtEvent::SenderRole, Qt::DisplayRole, false),

+ subscriptionDelegate_(QtEvent::SenderRole, Qt::DisplayRole, true),

+ errorDelegate_(QtEvent::SenderRole, Qt::DisplayRole, true),

+ mucInviteDelegate_(QtEvent::SenderRole, Qt::DisplayRole, false),

+ incomingFileTransferDelegate_(QtEvent::SenderRole, Qt::DisplayRole, false) {

+ QtEvent* item = static_cast<QtEvent*>(index.internalPointer());

+ if (!item) {

+ return QStyledItemDelegate::sizeHint(option, index);

+ }

+ switch (getEventType(item->getEvent())) {

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

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

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

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

+ case IncomingFileTransferEventType: return incomingFileTransferDelegate_.sizeHint(option, item);

+ }

+ assert(false);

+ return QSize();

+ QtEvent* item = static_cast<QtEvent*>(index.internalPointer());

+ if (!item) {

+ QStyledItemDelegate::paint(painter, option, index);

+ return;

+ }

+ switch (getEventType(item->getEvent())) {

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

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

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

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

+ case IncomingFileTransferEventType: incomingFileTransferDelegate_.paint(painter, option, item);break;

+ }

+ boost::shared_ptr<MessageEvent> messageEvent = boost::dynamic_pointer_cast<MessageEvent>(event);

+ if (messageEvent) {

+ return MessageEventType;

+ }

+ boost::shared_ptr<SubscriptionRequestEvent> subscriptionEvent = boost::dynamic_pointer_cast<SubscriptionRequestEvent>(event);

+ if (subscriptionEvent) {

+ return SubscriptionEventType;

+ }

+ boost::shared_ptr<ErrorEvent> errorEvent = boost::dynamic_pointer_cast<ErrorEvent>(event);

+ if (errorEvent) {

+ return ErrorEventType;

+ }

+ boost::shared_ptr<MUCInviteEvent> mucInviteEvent = boost::dynamic_pointer_cast<MUCInviteEvent>(event);

+ if (mucInviteEvent) {

+ return MUCInviteEventType;

+ }

+ boost::shared_ptr<IncomingFileTransferEvent> incomingFileTransferEvent = boost::dynamic_pointer_cast<IncomingFileTransferEvent>(event);

+ if (incomingFileTransferEvent) {

+ return IncomingFileTransferEventType;

+ }

+ //I don't know what this is.

+ assert(false);

+ return MessageEventType;

+ enum EventType {MessageEventType, SubscriptionEventType, ErrorEventType, MUCInviteEventType, IncomingFileTransferEventType};

+ class EventDelegate : public QStyledItemDelegate {

+ Q_OBJECT

+ public:

+ EventDelegate();

+ QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const;

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

+ private:

+ EventType getEventType(boost::shared_ptr<StanzaEvent> event) const;

+ DelegateCommons common_;

+ TwoLineDelegate messageDelegate_;

+ TwoLineDelegate subscriptionDelegate_;

+ TwoLineDelegate errorDelegate_;

+ TwoLineDelegate mucInviteDelegate_;

+ TwoLineDelegate incomingFileTransferDelegate_;

+ };

+ const int inactiveEventsLimit = 50;

+

+ foreach (QtEvent* event, activeEvents_) {

+ delete event;

+ }

+ foreach (QtEvent* event, inactiveEvents_) {

+ delete event;

+ }

+ QtEvent* event = NULL;

+ if (row < activeEvents_.size()) {

+ event = activeEvents_[row];

+ }

+ else {

+ int inactiveRow = row - activeEvents_.size();

+ if (inactiveRow < inactiveEvents_.size()) {

+ event = inactiveEvents_[inactiveRow];

+ }

+ else {

+ SWIFT_LOG(error) << "Misbehaving EventModel requests row index outside of range";

+ }

+ }

+ return event;

+ return activeEvents_.size();

+ if (!index.isValid()) {

+ return QVariant();

+ }

+ QtEvent* item = getItem(index.row());

+ QVariant result = item ? item->data(role) : QVariant();

+ return result;

+ if (!hasIndex(row, column, parent) || parent.isValid()) {

+ return QModelIndex();

+ }

+ return row < rowCount() ? createIndex(row, column, getItem(row)) : QModelIndex();

+ /* Invalid parent = root, valid parent = child, and we're a list not a tree.*/

+ int count = parent.isValid() ? 0 : activeEvents_.size() + inactiveEvents_.size();

+ return count;

+ beginResetModel();

+ if (active) {

+ activeEvents_.push_front(new QtEvent(event, active));

+ } else {

+ inactiveEvents_.push_front(new QtEvent(event, active));

+ if (inactiveEvents_.size() > inactiveEventsLimit) {

+ removeEvent(inactiveEvents_[inactiveEventsLimit]->getEvent());

+ }

+ }

+ endResetModel();

+ beginResetModel();

+ for (int i = inactiveEvents_.size() - 1; i >= 0; i--) {

+ if (event == inactiveEvents_[i]->getEvent()) {

+ inactiveEvents_.removeAt(i);

+ endResetModel();

+ return;

+ }

+ }

+

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

+ if (event == activeEvents_[i]->getEvent()) {

+ activeEvents_.removeAt(i);

+ endResetModel();

+ return;

+ }

+ }

+ endResetModel();

+ Q_OBJECT

+ public:

+ EventModel();

+ virtual ~EventModel();

+ void addEvent(boost::shared_ptr<StanzaEvent> event, bool active);

+ void removeEvent(boost::shared_ptr<StanzaEvent> event);

+ QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;

+ int rowCount(const QModelIndex& parent = QModelIndex()) const;

+ QtEvent* getItem(int row) const;

+ int getNewEventCount();

+ protected:

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

+ private:

+ QList<QtEvent*> activeEvents_;

+ QList<QtEvent*> inactiveEvents_;

+

+ class EventView : public QListView {

+ Q_OBJECT

+ public:

+ EventView(QWidget* parent);

+ };

+ active_ = active;

+ switch (role) {

+ case Qt::ToolTipRole: return QVariant(text()).toString() + "\n" + B2QDATE(event_->getTime()).toString();

+ case Qt::DisplayRole: return QVariant(text());

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

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

+ case SenderRole: return QVariant(sender());

+ /*case StatusTextRole: return statusText_;

+ case AvatarRole: return avatar_;

+ case PresenceIconRole: return getPresenceIcon();*/

+ default: return QVariant();

+ }

+ boost::shared_ptr<MessageEvent> messageEvent = boost::dynamic_pointer_cast<MessageEvent>(event_);

+ if (messageEvent) {

+ return P2QSTRING(messageEvent->getStanza()->getFrom().toString());

+ }

+ boost::shared_ptr<SubscriptionRequestEvent> subscriptionRequestEvent = boost::dynamic_pointer_cast<SubscriptionRequestEvent>(event_);

+ if (subscriptionRequestEvent) {

+ return P2QSTRING(subscriptionRequestEvent->getJID().toBare().toString());

+ }

+ boost::shared_ptr<ErrorEvent> errorEvent = boost::dynamic_pointer_cast<ErrorEvent>(event_);

+ if (errorEvent) {

+ return P2QSTRING(errorEvent->getJID().toBare().toString());

+ }

+ boost::shared_ptr<MUCInviteEvent> mucInviteEvent = boost::dynamic_pointer_cast<MUCInviteEvent>(event_);

+ if (mucInviteEvent) {

+ return P2QSTRING(mucInviteEvent->getInviter().toString());

+ }

+ boost::shared_ptr<IncomingFileTransferEvent> incomingFTEvent = boost::dynamic_pointer_cast<IncomingFileTransferEvent>(event_);

+ if (incomingFTEvent) {

+ return P2QSTRING(incomingFTEvent->getSender().toString());

+ }

+ return "";

+ boost::shared_ptr<MessageEvent> messageEvent = boost::dynamic_pointer_cast<MessageEvent>(event_);

+ if (messageEvent) {

+ return P2QSTRING(messageEvent->getStanza()->getBody().get_value_or(""));

+ }

+ boost::shared_ptr<SubscriptionRequestEvent> subscriptionRequestEvent = boost::dynamic_pointer_cast<SubscriptionRequestEvent>(event_);

+ if (subscriptionRequestEvent) {

+ std::string reason = subscriptionRequestEvent->getReason();

+ QString message;

+ if (reason.empty()) {

+ message = QString(QObject::tr("%1 would like to add you to their contact list.")).arg(subscriptionRequestEvent->getJID().toBare().toString().c_str());

+ }

+ else {

+ message = QString(QObject::tr("%1 would like to add you to their contact list, saying '%2'")).arg(subscriptionRequestEvent->getJID().toBare().toString().c_str()).arg(reason.c_str());

+ }

+ return message;

+ }

+ boost::shared_ptr<ErrorEvent> errorEvent = boost::dynamic_pointer_cast<ErrorEvent>(event_);

+ if (errorEvent) {

+ return P2QSTRING(errorEvent->getText());

+ }

+ boost::shared_ptr<MUCInviteEvent> mucInviteEvent = boost::dynamic_pointer_cast<MUCInviteEvent>(event_);

+ if (mucInviteEvent) {

+ QString message = QString(QObject::tr("%1 has invited you to enter the %2 room.")).arg(P2QSTRING(mucInviteEvent->getInviter().toBare().toString())).arg(P2QSTRING(mucInviteEvent->getRoomJID().toString()));

+ return message;

+ }

+ boost::shared_ptr<IncomingFileTransferEvent> incomingFTEvent = boost::dynamic_pointer_cast<IncomingFileTransferEvent>(event_);

+ if (incomingFTEvent) {

+ QString message = QString(QObject::tr("%1 would like to send a file to you.")).arg(P2QSTRING(incomingFTEvent->getSender().toBare().toString()));

+ return message;

+ }

+ return "";

+ class QtEvent {

+ public:

+ QtEvent(boost::shared_ptr<StanzaEvent> event, bool active);

+ QVariant data(int role);

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

+ enum EventRoles {

+ SenderRole = Qt::UserRole

+ };

+ private:

+ QString text();

+ QString sender();

+ boost::shared_ptr<StanzaEvent> event_;

+ bool active_;

+ };

+ QBoxLayout* layout = new QBoxLayout(QBoxLayout::TopToBottom, this);

+ layout->setContentsMargins(0,0,0,0);

+ layout->setSpacing(0);

+

+ view_ = new QTreeView(this);

+ layout->addWidget(view_);

+ eventStream_ = eventStream;

+ model_ = new EventModel();

+ view_->setModel(model_);

+ delegate_ = new EventDelegate();

+ view_->setItemDelegate(delegate_);

+ view_->setHeaderHidden(true);

+ view_->setAlternatingRowColors(true);

+ view_->setAnimated(true);

+ view_->setIndentation(0);

+ view_->setRootIsDecorated(true);

+

+ readButton_ = new QPushButton(tr("Display Notice"), this);

+ layout->addWidget(readButton_);

+ readButton_->setEnabled(false);

+ connect(readButton_, SIGNAL(clicked()), this, SLOT(handleReadClicked()));

+ connect(view_, SIGNAL(clicked(const QModelIndex&)), this, SLOT(handleItemClicked(const QModelIndex&)));

+ connect(view_, SIGNAL(activated(const QModelIndex&)), this, SLOT(handleItemActivated(const QModelIndex&)));

+ delete model_;

+ delete delegate_;

+ /* Not view_ because this is the parent */

+ readButton_->setEnabled(true);

+ QModelIndex index = view_->currentIndex();

+ if (!index.isValid()) {

+ return;

+ }

+ handleItemActivated(index);

+ QtEvent* event = model_->getItem(item.row());

+ boost::shared_ptr<MessageEvent> messageEvent = boost::dynamic_pointer_cast<MessageEvent>(event->getEvent());

+ boost::shared_ptr<SubscriptionRequestEvent> subscriptionEvent = boost::dynamic_pointer_cast<SubscriptionRequestEvent>(event->getEvent());

+ boost::shared_ptr<MUCInviteEvent> mucInviteEvent = boost::dynamic_pointer_cast<MUCInviteEvent>(event->getEvent());

+ boost::shared_ptr<IncomingFileTransferEvent> incomingFTEvent = boost::dynamic_pointer_cast<IncomingFileTransferEvent>(event->getEvent());

+ boost::shared_ptr<ErrorEvent> errorEvent = boost::dynamic_pointer_cast<ErrorEvent>(event->getEvent());

+

+ if (messageEvent) {

+ if (messageEvent->getStanza()->getType() == Message::Groupchat) {

+ eventStream_->send(boost::shared_ptr<UIEvent>(new JoinMUCUIEvent(messageEvent->getStanza()->getFrom().toBare(), messageEvent->getStanza()->getTo().getResource())));

+ } else {

+ eventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(messageEvent->getStanza()->getFrom())));

+ }

+ } else if (subscriptionEvent) {

+ QtSubscriptionRequestWindow* window = QtSubscriptionRequestWindow::getWindow(subscriptionEvent, this);

+ window->show();

+ } else if (mucInviteEvent) {

+ eventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(mucInviteEvent->getInviter())));

+ mucInviteEvent->conclude();

+ } else if (incomingFTEvent) {

+ eventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(incomingFTEvent->getSender())));

+ incomingFTEvent->conclude();

+ } else {

+ if (errorEvent) {

+ errorEvent->conclude();

+ }

+ QMessageBox msgBox;

+ msgBox.setText(model_->data(item, Qt::DisplayRole).toString());

+ msgBox.exec();

+ }

+ view_->clearSelection();

+ model_->addEvent(event, active);

+ emit onNewEventCountUpdated(model_->getNewEventCount());

+ readButton_->setEnabled(model_->rowCount() > 0);

+ view_->clearSelection();

+ model_->removeEvent(event);

+ emit onNewEventCountUpdated(model_->getNewEventCount());

+ readButton_->setEnabled(model_->rowCount() > 0);

+ class QtEventWindow : public QWidget, public EventWindow {

+ Q_OBJECT

+ public:

+ QtEventWindow(UIEventStream* eventStream);

+ ~QtEventWindow();

+ void addEvent(boost::shared_ptr<StanzaEvent> event, bool active);

+ void removeEvent(boost::shared_ptr<StanzaEvent> event);

+ signals:

+ void onNewEventCountUpdated(int count);

+ private slots:

+ void handleItemActivated(const QModelIndex& item);

+ void handleItemClicked(const QModelIndex& item);

+ void handleReadClicked();

+ private:

+ EventModel* model_;

+ EventDelegate* delegate_;

+ UIEventStream* eventStream_;

+ QTreeView* view_;

+ QPushButton* readButton_;

+ };

+

+ firstRole_ = firstRole;

+ secondRole_ = secondRole;

+ wrap_ = wrap;

+ QFontMetrics nameMetrics(common_.nameFont);

+ QFontMetrics statusMetrics(common_.detailFont);

+ int sizeByText = 2 * common_.verticalMargin + nameMetrics.height() + statusMetrics.height();

+ return QSize(150, sizeByText);

+ painter->save();

+ QRect fullRegion(option.rect);

+ if ( option.state & QStyle::State_Selected ) {

+ painter->fillRect(fullRegion, option.palette.highlight());

+ painter->setPen(option.palette.highlightedText().color());

+ } else {

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

+ painter->setPen(QPen(nameColor));

+ }

+

+ QFontMetrics nameMetrics(common_.nameFont);

+ painter->setFont(common_.nameFont);

+ int extraFontWidth = nameMetrics.width("H");

+ int leftOffset = common_.horizontalMargin * 2 + extraFontWidth / 2;

+ QRect textRegion(fullRegion.adjusted(leftOffset, 0, 0, 0));

+

+ int nameHeight = nameMetrics.height() + common_.verticalMargin;

+ QRect nameRegion(textRegion.adjusted(0, common_.verticalMargin, 0, 0));

+

+ DelegateCommons::drawElidedText(painter, nameRegion, event->data(firstRole_).toString());

+

+ painter->setFont(common_.detailFont);

+ painter->setPen(QPen(QColor(160,160,160)));

+

+ QRect detailRegion(textRegion.adjusted(0, nameHeight, 0, 0));

+ DelegateCommons::drawElidedText(painter, detailRegion, event->data(secondRole_).toString());

+

+ painter->restore();

+ class TwoLineDelegate {

+ public:

+ TwoLineDelegate(int firstRole, int secondRole, bool wrap);

+ ~TwoLineDelegate();

+ QSize sizeHint(const QStyleOptionViewItem& option, QtEvent* event) const;

+ void paint(QPainter* painter, const QStyleOptionViewItem& option, QtEvent* event) const;

+ private:

+ DelegateCommons common_;

+ int firstRole_;

+ int secondRole_;

+ bool wrap_;

+ };

+ QApplication app(argc, argv);

+ Swift::UIEventStream eventStream;

+ Swift::QtEventWindow* viewer = new Swift::QtEventWindow(&eventStream);

+ viewer->show();

+ boost::shared_ptr<Swift::Message> message1(new Swift::Message());

+ message1->setBody("Oooh, shiny");

+ boost::shared_ptr<Swift::MessageEvent> event1(new Swift::MessageEvent(message1));

+ viewer->addEvent(boost::dynamic_pointer_cast<Swift::StanzaEvent>(event1), true);

+ for (int i = 0; i < 100; i++) {

+ viewer->addEvent(boost::dynamic_pointer_cast<Swift::StanzaEvent>(event1), false);

+ }

+ viewer->addEvent(boost::dynamic_pointer_cast<Swift::StanzaEvent>(boost::make_shared<Swift::ErrorEvent>(Swift::JID("me@example.com"), "Something bad did happen to you.")), true);

+ return app.exec();

+ QDBusConnection bus = QDBusConnection::sessionBus();

+ if (!bus.isConnected()) {

+ return;

+ }

+ std::vector<Notifier::Type> defaultTypes = getDefaultTypes();

+ if (std::find(defaultTypes.begin(), defaultTypes.end(), type) == defaultTypes.end()) {

+ return;

+ }

+

+ QString body = description.c_str();

+ body = body.replace("&", "&amp;");

+ body = body.replace("<", "&lt;");

+ body = body.replace(">", "&gt;");

+

+ int timeout = (type == IncomingMessage || type == SystemMessage) ? DEFAULT_MESSAGE_NOTIFICATION_TIMEOUT_SECONDS : DEFAULT_STATUS_NOTIFICATION_TIMEOUT_SECONDS;

+

+ QDBusMessage msg = QDBusMessage::createMethodCall("org.freedesktop.Notifications", "/org/freedesktop/Notifications", "", "Notify");

+

+ QStringList actions;

+ QMap<QString, QVariant> hints;

+ hints["x-canonical-append"] = QString("allowed");

+ msg << applicationName.c_str();

+ msg << quint32(0); // ID of previous notification to replace

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

+ msg << subject.c_str(); // Summary / Header of the message to display

+ msg << body; // Body of the message to display

+ msg << actions; // Actions from which the user may choose

+ msg << hints; // Hints to the server displaying the message

+ msg << qint32(timeout*1000); // Timeout in milliseconds

+

+ bus.asyncCall(msg);

+ class FreeDesktopNotifier : public Notifier {

+ public:

+ FreeDesktopNotifier(const std::string& name);

+ virtual void showMessage(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picture, boost::function<void()> callback);

+ virtual void purgeCallbacks() {}

+ private:

+ std::string applicationName;

+ QtCachedImageScaler imageScaler;

+ };

+// // MUCSearchItem* item = static_cast<MUCSearchItem*>(index.internalPointer());

+// // if (item && dynamic_cast<MUCSearchMUCItem*>(item)) {

+// // return mucSizeHint(option, index);

+// // } else if (item && dynamic_cast<MUCSearchGroupItem*>(item)) {

+// // return groupDelegate_->sizeHint(option, index);

+// // }

+// return QStyledItemDelegate::sizeHint(option, index);

+// QFontMetrics nameMetrics(common_.nameFont);

+// QFontMetrics statusMetrics(common_.detailFont);

+// int sizeByText = 2 * common_.verticalMargin + nameMetrics.height() + statusMetrics.height();

+// return QSize(150, sizeByText);

+// MUCSearchItem* item = static_cast<MUCSearchItem*>(index.internalPointer());

+// if (item && dynamic_cast<MUCSearchMUCItem*>(item)) {

+// paintMUC(painter, option, dynamic_cast<MUCSearchMUCItem*>(item));

+// } else if (item && dynamic_cast<MUCSearchGroupItem*>(item)) {

+// MUCSearchGroupItem* group = dynamic_cast<MUCSearchGroupItem*>(item);

+// groupDelegate_->paint(painter, option, group->data(Qt::DisplayRole).toString(), group->rowCount(), option.state & QStyle::State_Open);

+// } else {

+// QStyledItemDelegate::paint(painter, option, index);

+// }

+// painter->save();

+// QRect fullRegion(option.rect);

+// if ( option.state & QStyle::State_Selected ) {

+// painter->fillRect(fullRegion, option.palette.highlight());

+// painter->setPen(option.palette.highlightedText().color());

+// } else {

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

+// painter->setPen(QPen(nameColor));

+// }

+

+// QFontMetrics nameMetrics(common_.nameFont);

+// painter->setFont(common_.nameFont);

+// int extraFontWidth = nameMetrics.width("H");

+// int leftOffset = common_.horizontalMargin * 2 + extraFontWidth / 2;

+// QRect textRegion(fullRegion.adjusted(leftOffset, 0, 0, 0));

+

+// int nameHeight = nameMetrics.height() + common_.verticalMargin;

+// QRect nameRegion(textRegion.adjusted(0, common_.verticalMargin, 0, 0));

+

+// painter->drawText(nameRegion, Qt::AlignTop, item->data(Qt::DisplayRole).toString());

+

+// painter->setFont(common_.detailFont);

+// painter->setPen(QPen(QColor(160,160,160)));

+

+// QRect detailRegion(textRegion.adjusted(0, nameHeight, 0, 0));

+// painter->drawText(detailRegion, Qt::AlignTop, item->data(DetailTextRole).toString());

+

+// painter->restore();

+ class MUCSearchDelegate : public QStyledItemDelegate {

+ public:

+ MUCSearchDelegate();

+ ~MUCSearchDelegate();

+ /* QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const; */

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

+ private:

+// void paintMUC(QPainter* painter, const QStyleOptionViewItem& option, MUCSearchMUCItem* item) const;

+// QSize mucSizeHint(const QStyleOptionViewItem& /*option*/, const QModelIndex& /*index*/ ) const;

+ DelegateCommons common_;

+ };

+ parent->addRoom(this);

+ return parent;

+ switch (role) {

+ case Qt::DisplayRole:

+ return QVariant(QObject::tr("No rooms found"));

+ case Qt::FontRole: {

+ QFont font;

+ font.setItalic(true);

+ return font;

+ }

+ case Qt::ForegroundRole:

+ return QColor(Qt::gray);

+ default:

+ return QVariant();

+ }

+ class MUCSearchServiceItem;

+ class MUCSearchEmptyItem : public MUCSearchItem {

+ public:

+ MUCSearchEmptyItem(MUCSearchServiceItem* parent);

+ MUCSearchServiceItem* getParent();

+ QVariant data(int role);

+ private:

+ MUCSearchServiceItem* parent;

+ };

+ class MUCSearchItem {

+ public:

+ virtual ~MUCSearchItem() {}

+ virtual QVariant data(int role) = 0;

+ };

+ emit layoutAboutToBeChanged();

+ services_.clear();

+ emit layoutChanged();

+ emit layoutAboutToBeChanged();

+ services_.push_back(service);

+ emit layoutChanged();

+ return 1;

+ return index.isValid() ? static_cast<MUCSearchItem*>(index.internalPointer())->data(role) : QVariant();

+ if (!hasIndex(row, column, parent)) {

+ return QModelIndex();

+ }

+

+ if (parent.isValid()) {

+ MUCSearchServiceItem* parentItem = static_cast<MUCSearchServiceItem*>(parent.internalPointer());

+ return row < parentItem->rowCount() ? createIndex(row, column, parentItem->getItem(row)) : QModelIndex();

+ } else {

+ return row < services_.size() ? createIndex(row, column, services_[row]) : QModelIndex();

+ }

+ if (!index.isValid()) {

+ return QModelIndex();

+ }

+ MUCSearchItem* item = static_cast<MUCSearchItem*>(index.internalPointer());

+ if (!item) {

+ return QModelIndex();

+ }

+ else if (dynamic_cast<MUCSearchServiceItem*>(item)) {

+ return QModelIndex();

+ }

+

+ MUCSearchServiceItem* parent = NULL;

+ if (MUCSearchRoomItem* roomItem = dynamic_cast<MUCSearchRoomItem*>(item)) {

+ parent = roomItem->getParent();

+ }

+ else if (MUCSearchEmptyItem* emptyItem = dynamic_cast<MUCSearchEmptyItem*>(item)) {

+ parent = emptyItem->getParent();

+ }

+ if (parent) {

+ int row = services_.indexOf(parent);

+ return createIndex(row, 1, parent);

+ }

+ else {

+ return QModelIndex();

+ }

+ if (!parentIndex.isValid()) {

+ return services_.size();

+ }

+ if (dynamic_cast<MUCSearchServiceItem*>(static_cast<MUCSearchItem*>(parentIndex.internalPointer()))) {

+ return services_[parentIndex.row()]->rowCount();

+ }

+ else {

+ return 0;

+ }

+ class MUCSearchModel : public QAbstractItemModel {

+ Q_OBJECT

+ public:

+ MUCSearchModel();

+ void clear();

+ void addService(MUCSearchServiceItem* service);

+ int columnCount(const QModelIndex& parent = QModelIndex()) const;

+ QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;

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

+ QModelIndex parent(const QModelIndex& index) const;

+ int rowCount(const QModelIndex& parent = QModelIndex()) const;

+// ChatListItem* getItemForIndex(const QModelIndex& index) const;

+ private:

+// ChatListGroupItem* mucBookmarks_;

+// ChatListGroupItem* root_;

+ QList<MUCSearchServiceItem*> services_;

+ };

+ parent_->addRoom(this);

+ return parent_;

+ switch (role) {

+ case Qt::DisplayRole: return QVariant(node_);

+ default: return QVariant();

+ }

+ class MUCSearchServiceItem;

+ class MUCSearchRoomItem : public MUCSearchItem {

+ public:

+ MUCSearchRoomItem(const QString& node, MUCSearchServiceItem* parent);

+ MUCSearchServiceItem* getParent();

+ QVariant data(int role);

+ QString getNode() const {return node_;}

+ private:

+ MUCSearchServiceItem* parent_;

+ QString node_;

+ };

+ class MUCSearchServiceItem : public MUCSearchItem {

+ public:

+ MUCSearchServiceItem(const QString& jidString) : jidString_(jidString) {}

+ void addRoom(MUCSearchItem* room) {rooms_.push_back(room);}

+ int rowCount() {return rooms_.count();}

+ MUCSearchItem* getItem(int i) {return rooms_[i];}

+ QVariant data(int role) {

+ switch (role) {

+ case Qt::DisplayRole: return QVariant(jidString_);

+ default: return QVariant();

+ }

+ }

+ QString getHost() const {return jidString_;}

+ private:

+ QList<MUCSearchItem*> rooms_;

+ QString jidString_;

+ };

+ ui_.setupUi(this);

+ setWindowIcon(QIcon(":/logo-icon-16.png"));

+ setModal(true);

+ ui_.filter_->hide();

+ model_ = new MUCSearchModel();

+ delegate_ = new MUCSearchDelegate();

+ ui_.results_->setModel(model_);

+ ui_.results_->setItemDelegate(delegate_);

+ ui_.results_->setHeaderHidden(true);

+ ui_.results_->setRootIsDecorated(true);

+ ui_.results_->setAnimated(true);

+ ui_.results_->setAlternatingRowColors(true);

+ connect(ui_.searchButton, SIGNAL(clicked()), this, SLOT(handleSearch()));

+ connect(ui_.service_, SIGNAL(activated(const QString&)), this, SLOT(handleSearch(const QString&)));

+ connect(ui_.results_->selectionModel(), SIGNAL(selectionChanged (const QItemSelection&, const QItemSelection&)), this, SLOT(handleSelectionChanged (const QItemSelection&, const QItemSelection&)));

+ connect(ui_.results_, SIGNAL(activated(const QModelIndex&)), this, SLOT(handleActivated(const QModelIndex&)));

+ connect(ui_.results_, SIGNAL(activated(const QModelIndex&)), this, SLOT(handleActivated(const QModelIndex&)));

+ // Not using a button box, because i can't seem to be able to make the ok button non-default (on mac)

+ connect(ui_.okButton, SIGNAL(clicked()), this, SLOT(accept()));

+ ui_.okButton->setEnabled(false);

+ connect(ui_.cancelButton, SIGNAL(clicked()), this, SLOT(reject()));

+

+ throbber_ = new QLabel(tr("Searching"), ui_.results_);

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

+ throbber_->setToolTip(tr("Searching"));

+

+ hasHadScrollBars_ = false;

+ updateThrobberPosition();

+ setSearchInProgress(false);

+ updateThrobberPosition();

+ bool isShown = throbber_->isVisible();

+ int resultWidth = ui_.results_->width();

+ int resultHeight = ui_.results_->height();

+ //throbberWidth = throbber_->movie()->scaledSize().width();

+ //throbberHeight = throbber_->movie()->scaledSize().height();

+ int throbberWidth = 16; /* This is nasty, but the above doesn't work! */

+ int throbberHeight = 16;

+ /* It's difficult (or I spent a while trying) to work out whether the scrollbars are currently shown and their appropriate size,

+ * because if you listen for the expanded/collapsed signals, you seem to get them before the scrollbars are updated.

+ * This seems an acceptable workaround.

+ */

+ hasHadScrollBars_ |= ui_.results_->verticalScrollBar()->isVisible();

+ int hMargin = hasHadScrollBars_ ? ui_.results_->verticalScrollBar()->width() + 2 : 2;

+ int vMargin = 2; /* We don't get horizontal scrollbars */

+ throbber_->setGeometry(QRect(resultWidth - throbberWidth - hMargin, resultHeight - throbberHeight - vMargin, throbberWidth, throbberHeight)); /* include margins */

+ throbber_->setVisible(isShown);

+ ui_.service_->clear();

+ foreach (const JID& jid, services) {

+ ui_.service_->addItem(P2QSTRING(jid.toString()));

+ }

+ if (!services.empty()) {

+ ui_.service_->setEditText(P2QSTRING(services.begin()->toString()));

+ }

+ else {

+ ui_.service_->clearEditText();

+ }

+ if (!index.isValid()) {

+ return;

+ }

+ if (dynamic_cast<MUCSearchRoomItem*>(static_cast<MUCSearchItem*>(index.internalPointer()))) {

+ accept();

+ }

+ handleSearch(ui_.service_->currentText());

+ if (!service.isEmpty()) {

+ onSearchService(JID(Q2PSTRING(service)));

+ }

+ QWidget::show();

+ QWidget::activateWindow();

+ model_->clear();

+ updateThrobberPosition();

+ MUCSearchServiceItem* serviceItem = new MUCSearchServiceItem(P2QSTRING(service.getJID().toString()));

+ if (service.getRooms().size() > 0) {

+ foreach (MUCService::MUCRoom room, service.getRooms()) {

+ new MUCSearchRoomItem(P2QSTRING(room.getNode()), serviceItem);

+ }

+ }

+ else {

+ new MUCSearchEmptyItem(serviceItem);

+ }

+ model_->addService(serviceItem);

+ ui_.results_->expandAll();

+ if (searching) {

+ throbber_->movie()->start();

+ } else {

+ throbber_->movie()->stop();

+ }

+ throbber_->setVisible(searching);

+ MUCSearchRoomItem* room = getSelectedRoom();

+ if (room) {

+ onFinished(JID(Q2PSTRING(room->getNode()), Q2PSTRING(room->getParent()->getHost())));

+ }

+ else {

+ onFinished(boost::optional<JID>());

+ }

+ QDialog::accept();

+ onFinished(boost::optional<JID>());

+ QDialog::reject();

+ ui_.okButton->setEnabled(getSelectedRoom());

+ // Not using selectedIndexes(), because this seems to cause a crash in Qt (4.7.0) in the

+ // QModelIndexList destructor.

+ // This is a workaround posted in http://www.qtcentre.org/threads/16933 (although this case

+ // was resolved by linking against the debug libs, ours isn't, and we're not alone)

+ QItemSelection ranges = ui_.results_->selectionModel()->selection();

+ QModelIndexList lstIndex;

+ for (int i = 0; i < ranges.count(); ++i) {

+ QModelIndex parent = ranges.at(i).parent();

+ int right = ranges.at(i).model()->columnCount(parent) - 1;

+ if (ranges.at(i).left() == 0 && ranges.at(i).right() == right) {

+ for (int r = ranges.at(i).top(); r <= ranges.at(i).bottom(); ++r) {

+ lstIndex.append(ranges.at(i).model()->index(r, 0, parent));

+ }

+ }

+ }

+ if (lstIndex.isEmpty()) {

+ return NULL;

+ }

+ else {

+ return dynamic_cast<MUCSearchRoomItem*>(static_cast<MUCSearchItem*>(lstIndex.first().internalPointer()));

+ }