Page MenuHome GnuPG
Files F34621110

No OneTemporary
Actions

View Options

diff --git a/src/ui/keyselectioncombo.cpp b/src/ui/keyselectioncombo.cpp
index 7c7c4cdd..0dcd2a8c 100644
--- a/src/ui/keyselectioncombo.cpp
+++ b/src/ui/keyselectioncombo.cpp
@@ -1,284 +1,283 @@
/* This file is part of Kleopatra, the KDE keymanager
Copyright (c) 2016 Klarälvdalens Datakonsult AB
Kleopatra is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
Kleopatra is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "keyselectioncombo.h"
#include <kleo_ui_debug.h>
#include "kleo/cryptobackendfactory.h"
#include "kleo/dn.h"
#include "models/keylistmodel.h"
#include "models/keylistsortfilterproxymodel.h"
#include "models/keycache.h"
#include "utils/formatting.h"
#include "progressbar.h"
#include <gpgme++/key.h>
#include <QSortFilterProxyModel>
#include <QVector>
#include <KLocalizedString>
#include <KMessageBox>
Q_DECLARE_METATYPE(GpgME::Key)
namespace
{
class ProxyModel : public QSortFilterProxyModel
{
Q_OBJECT
private:
struct CustomItem {
QIcon icon;
QString text;
QVariant data;
};
public:
ProxyModel(QObject *parent = Q_NULLPTR)
: QSortFilterProxyModel(parent)
{
}
~ProxyModel()
{
qDeleteAll(mFrontItems);
qDeleteAll(mBackItems);
}
bool isCustomItem(const int row) const
{
return row < mFrontItems.count() || row >= mFrontItems.count() + QSortFilterProxyModel::rowCount();
}
void prependItem(const QIcon &icon, const QString &text, const QVariant &data)
{
beginInsertRows(QModelIndex(), 0, 0);
mFrontItems.push_front(new CustomItem{ icon, text, data });
endInsertRows();
}
void appendItem(const QIcon &icon, const QString &text, const QVariant &data)
{
beginInsertRows(QModelIndex(), rowCount(), rowCount());
mBackItems.push_back(new CustomItem{ icon, text, data });
endInsertRows();
}
int rowCount(const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE
{
return mFrontItems.count() + QSortFilterProxyModel::rowCount(parent) + mBackItems.count();
}
QModelIndex mapToSource(const QModelIndex &index) const Q_DECL_OVERRIDE
{
if (!isCustomItem(index.row())) {
const int row = index.row() - mFrontItems.count();
const QModelIndex idx = createIndex(row, index.column(), index.internalPointer());
return QSortFilterProxyModel::mapToSource(idx);
} else {
return QModelIndex();
}
}
QModelIndex mapFromSource(const QModelIndex &source_index) const Q_DECL_OVERRIDE
{
const QModelIndex idx = QSortFilterProxyModel::mapFromSource(source_index);
return createIndex(mFrontItems.count() + idx.row(), idx.column(), idx.internalPointer());
}
QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE
{
if (row < 0 || row >= rowCount()) {
return QModelIndex();
}
if (row < mFrontItems.count()) {
return createIndex(row, column, mFrontItems[row]);
} else if (row >= mFrontItems.count() + QSortFilterProxyModel::rowCount()) {
return createIndex(row, column, mBackItems[row - mFrontItems.count() - QSortFilterProxyModel::rowCount()]);
} else {
const QModelIndex mi = QSortFilterProxyModel::index(row - mFrontItems.count(), column, parent);
return createIndex(row, column, mi.internalPointer());
}
}
Qt::ItemFlags flags(const QModelIndex &index) const Q_DECL_OVERRIDE
{
return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemNeverHasChildren;
}
QModelIndex parent(const QModelIndex &) const Q_DECL_OVERRIDE
{
// Flat list
return QModelIndex();
}
QVariant data(const QModelIndex &index, int role) const Q_DECL_OVERRIDE
{
if (isCustomItem(index.row())) {
Q_ASSERT(!mFrontItems.isEmpty() || !mBackItems.isEmpty());
CustomItem *ci = static_cast<CustomItem*>(index.internalPointer());
switch (role) {
case Qt::DisplayRole:
return ci->text;
case Qt::DecorationRole:
return ci->icon;
case Qt::UserRole:
return ci->data;
default:
return QVariant();
}
}
const auto key = QSortFilterProxyModel::data(index, Kleo::KeyListModelInterface::KeyRole).value<GpgME::Key>();
Q_ASSERT(!key.isNull());
if (key.isNull()) {
return QVariant();
}
switch (role) {
case Qt::DisplayRole: {
const auto userID = key.userID(0);
QString name, email;
if (key.protocol() == GpgME::OpenPGP) {
name = userID.name();
email = userID.email();
} else {
const Kleo::DN dn(userID.id());
name = dn[QStringLiteral("CN")];
email = dn[QStringLiteral("EMAIL")];
}
- return i18nc("Name <email> (type, created: date, 0xkeyID)", "%1 (%2, created: %3, %4)",
+ return i18nc("Name <email> (type, created: date)", "%1 (%2, created: %3)",
email.isEmpty() ? name : name.isEmpty() ? email : i18nc("Name <email>", "%1 <%2>", name, email),
key.protocol() == GpgME::OpenPGP ? i18n("OpenPGP") : i18n("S/MIME"),
- Kleo::Formatting::creationDateString(key),
- Kleo::Formatting::prettyKeyID(key.shortKeyID()));
+ Kleo::Formatting::creationDateString(key));
}
case Qt::DecorationRole:
return Kleo::Formatting::iconForUid(key.userID(0));
default:
return QSortFilterProxyModel::data(index, role);
}
return QVariant();
}
private:
QVector<CustomItem*> mFrontItems;
QVector<CustomItem*> mBackItems;
};
} // anonymous namespace
namespace Kleo
{
class KeySelectionComboPrivate
{
public:
KeySelectionComboPrivate(KeySelectionCombo *parent)
: q(parent)
{
}
Kleo::AbstractKeyListModel *model;
Kleo::KeyListSortFilterProxyModel *sortFilterProxy;
ProxyModel *proxyModel;
boost::shared_ptr<Kleo::KeyCache> cache;
private:
KeySelectionCombo * const q;
};
}
using namespace Kleo;
KeySelectionCombo::KeySelectionCombo(QWidget* parent)
: QComboBox(parent)
, d(new KeySelectionComboPrivate(this))
{
setEnabled(false);
d->cache = Kleo::KeyCache::mutableInstance();
connect(d->cache.get(), &Kleo::KeyCache::keyListingDone,
this, [this]() {
qDebug() << "Key listing done";
d->model->useKeyCache(true, true);
setEnabled(true);
setCurrentIndex(0);
});
d->cache->startKeyListing();
d->model = Kleo::AbstractKeyListModel::createFlatKeyListModel(this);
d->sortFilterProxy = new Kleo::KeyListSortFilterProxyModel(this);
d->sortFilterProxy->setSourceModel(d->model);
d->proxyModel = new ProxyModel(this);
d->proxyModel->setSourceModel(d->sortFilterProxy);
setModel(d->proxyModel);
connect(this, static_cast<void(KeySelectionCombo::*)(int)>(&KeySelectionCombo::currentIndexChanged),
this, [this](int row) {
if (d->proxyModel->isCustomItem(row)) {
Q_EMIT customItemSelected(d->proxyModel->index(row, 0).data(Qt::UserRole));
} else {
Q_EMIT currentKeyChanged(currentKey());
}
});
}
KeySelectionCombo::~KeySelectionCombo()
{
delete d;
}
void KeySelectionCombo::setKeyFilter(const boost::shared_ptr<const KeyFilter> &kf)
{
d->sortFilterProxy->setKeyFilter(kf);
}
GpgME::Key Kleo::KeySelectionCombo::currentKey() const
{
return currentData(Kleo::KeyListModelInterface::KeyRole).value<GpgME::Key>();
}
void Kleo::KeySelectionCombo::setCurrentKey(const GpgME::Key &key)
{
const int idx = findData(QVariant::fromValue(key), Kleo::KeyListModelInterface::KeyRole, Qt::MatchExactly);
if (idx > -1) {
setCurrentIndex(idx);
}
}
void KeySelectionCombo::appendCustomItem(const QIcon &icon, const QString &text, const QVariant &data)
{
d->proxyModel->appendItem(icon, text, data);
}
void KeySelectionCombo::prependCustomItem(const QIcon &icon, const QString &text, const QVariant &data)
{
d->proxyModel->prependItem(icon, text, data);
}
#include "keyselectioncombo.moc"

File Metadata

Mime Type
text/x-diff
Expires
Tue, Jan 20, 12:49 AM (5 h, 12 m)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
0d/1f/80a015f053cadbaf2b4e243f2beb

Event Timeline