No OneTemporary
Actions

Size

37 KB

Subscribers

None

View Options

	diff --git a/src/dialogs/selftestdialog.cpp b/src/dialogs/selftestdialog.cpp
	index 03051c519..b51a185ed 100644
	--- a/src/dialogs/selftestdialog.cpp
	+++ b/src/dialogs/selftestdialog.cpp
	@@ -1,518 +1,491 @@
	/* -- mode: c++; c-basic-offset:4 --
	dialogs/selftestdialog.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "selftestdialog.h"

	#include <selftest/selftest.h>
	#include <utils/accessibility.h>
	#include <utils/scrollarea.h>

	#include <Libkleo/SystemInfo>
	#include <Libkleo/TreeView>

	#include <KColorScheme>
	#include <KLocalizedString>

	#include <QAbstractTableModel>
	#include <QApplication>
	#include <QCheckBox>
	#include <QDialogButtonBox>
	#include <QGroupBox>
	#include <QHBoxLayout>
	#include <QHeaderView>
	#include <QLabel>
	#include <QPushButton>
	#include <QSortFilterProxyModel>
	#include <QSplitter>
	#include <QVBoxLayout>

	#include "kleopatra_debug.h"

	using namespace Kleo;
	using namespace Kleo::Dialogs;

	namespace
	{

	class Model : public QAbstractTableModel
	{
	Q_OBJECT
	public:
	explicit Model(QObject *parent = nullptr)
	: QAbstractTableModel(parent)
	, m_tests()
	{
	}

	enum Column {
	TestName,
	TestResult,

	NumColumns
	};

	const std::shared_ptr<SelfTest> &fromModelIndex(const QModelIndex &idx) const
	{
	const unsigned int row = idx.row();
	if (row < m_tests.size()) {
	return m_tests[row];
	}
	static const std::shared_ptr<SelfTest> null;
	return null;
	}

	int rowCount(const QModelIndex &idx) const override
	{
	return idx.isValid() ? 0 : m_tests.size();
	}
	int columnCount(const QModelIndex &) const override
	{
	return NumColumns;
	}

	QVariant data(const QModelIndex &idx, int role) const override
	{
	const unsigned int row = idx.row();
	if (idx.isValid() && row < m_tests.size())
	switch (role) {
	case Qt::DisplayRole:
	case Qt::ToolTipRole:
	switch (idx.column()) {
	case TestName:
	return m_tests[row]->name();
	case TestResult:
	return m_tests[row]->skipped() ? i18n("Skipped") //
	: m_tests[row]->passed() ? i18n("Passed")
	: m_tests[row]->shortError();
	}
	break;
	case Qt::BackgroundRole:
	if (!SystemInfo::isHighContrastModeActive()) {
	KColorScheme scheme(qApp->palette().currentColorGroup());
	return (m_tests[row]->skipped() ? scheme.background(KColorScheme::NeutralBackground)
	: m_tests[row]->passed() ? scheme.background(KColorScheme::PositiveBackground)
	: scheme.background(KColorScheme::NegativeBackground))
	.color();
	}
	}
	return QVariant();
	}

	QVariant headerData(int section, Qt::Orientation o, int role) const override
	{
	if (o == Qt::Horizontal && section >= 0 && section < NumColumns && role == Qt::DisplayRole)
	switch (section) {
	case TestName:
	return i18n("Test Name");
	case TestResult:
	return i18n("Result");
	}
	return QVariant();
	}

	void clear()
	{
	if (m_tests.empty()) {
	return;
	}
	beginRemoveRows(QModelIndex(), 0, m_tests.size() - 1);
	m_tests.clear();
	endRemoveRows();
	}

	void append(const std::vector<std::shared_ptr<SelfTest>> &tests)
	{
	if (tests.empty()) {
	return;
	}
	beginInsertRows(QModelIndex(), m_tests.size(), m_tests.size() + tests.size());
	m_tests.insert(m_tests.end(), tests.begin(), tests.end());
	endInsertRows();
	}

	void reloadData()
	{
	if (!m_tests.empty()) {
	Q_EMIT dataChanged(index(0, 0), index(m_tests.size() - 1, NumColumns - 1));
	}
	}

	const std::shared_ptr<SelfTest> &at(unsigned int idx) const
	{
	return m_tests.at(idx);
	}

	private:
	std::vector<std::shared_ptr<SelfTest>> m_tests;
	};

	class Proxy : public QSortFilterProxyModel
	{
	Q_OBJECT
	public:
	explicit Proxy(QObject *parent = nullptr)
	: QSortFilterProxyModel(parent)
	, m_showAll(true)
	{
	setDynamicSortFilter(true);
	}

	bool showAll() const
	{
	return m_showAll;
	}

	Q_SIGNALS:
	void showAllChanged(bool);

	public Q_SLOTS:
	void setShowAll(bool on)
	{
	if (on == m_showAll) {
	return;
	}
	m_showAll = on;
	invalidateFilter();
	Q_EMIT showAllChanged(on);
	}

	private:
	bool filterAcceptsRow(int src_row, const QModelIndex &src_parent) const override
	{
	if (m_showAll) {
	return true;
	}
	if (const Model const model = qobject_cast<Model >(sourceModel())) {
	if (!src_parent.isValid() && src_row >= 0 && src_row < model->rowCount(src_parent)) {
	if (const std::shared_ptr<SelfTest> &t = model->at(src_row)) {
	return !t->passed();
	} else {
	qCWarning(KLEOPATRA_LOG) << "NULL test??";
	}
	} else {
	if (src_parent.isValid()) {
	qCWarning(KLEOPATRA_LOG) << "view asks for subitems!";
	} else {
	qCWarning(KLEOPATRA_LOG) << "index " << src_row << " is out of range [" << 0 << "," << model->rowCount(src_parent) << "]";
	}
	}
	} else {
	qCWarning(KLEOPATRA_LOG) << "expected a ::Model, got ";
	if (!sourceModel()) {
	qCWarning(KLEOPATRA_LOG) << "a null pointer";
	} else {
	qCWarning(KLEOPATRA_LOG) << sourceModel()->metaObject()->className();
	}
	}
	return false;
	}

	private:
	bool m_showAll;
	};
	-
	-class TreeViewInternal : public TreeView
	-{
	- Q_OBJECT
	-public:
	- using TreeView::TreeView;
	-
	-protected:
	- void focusInEvent(QFocusEvent *event) override
	- {
	- TreeView::focusInEvent(event);
	- // queue the invokation, so that it happens after the widget itself got focus
	- QMetaObject::invokeMethod(this, &TreeViewInternal::forceAccessibleFocusEventForCurrentItem, Qt::QueuedConnection);
	- }
	-
	-private:
	- void forceAccessibleFocusEventForCurrentItem()
	- {
	- // force Qt to send a focus event for the current item to accessibility
	- // tools; otherwise, the user has no idea which item is selected when the
	- // list gets keyboard input focus
	- const auto current = currentIndex();
	- setCurrentIndex({});
	- setCurrentIndex(current);
	- }
	-};
	-
	}

	class SelfTestDialog::Private
	{
	friend class ::Kleo::Dialogs::SelfTestDialog;
	SelfTestDialog *const q;

	public:
	explicit Private(SelfTestDialog *qq)
	: q(qq)
	, model(q)
	, proxy(q)
	, ui(q)
	{
	proxy.setSourceModel(&model);
	ui.resultsTV->setModel(&proxy);

	ui.detailsGB->hide();
	ui.proposedCorrectiveActionGB->hide();

	connect(ui.buttonBox, &QDialogButtonBox::accepted, q, &QDialog::accept);
	connect(ui.buttonBox, &QDialogButtonBox::rejected, q, &QDialog::reject);
	connect(ui.doItPB, &QAbstractButton::clicked, q, [this]() {
	slotDoItClicked();
	});
	connect(ui.rerunPB, &QAbstractButton::clicked, q, &SelfTestDialog::updateRequested);
	connect(ui.resultsTV->selectionModel(), &QItemSelectionModel::selectionChanged, q, [this]() {
	slotSelectionChanged();
	});
	connect(ui.showAllCB, &QAbstractButton::toggled, q, [this](bool checked) {
	proxy.setShowAll(checked);
	if (checked) {
	updateColumnSizes();
	}
	ensureCurrentItemIsVisible();
	});
	proxy.setShowAll(ui.showAllCB->isChecked());

	ui.resultsTV->setFocus();
	}

	private:
	void slotSelectionChanged()
	{
	const int row = selectedRowIndex();
	if (row < 0) {
	ui.detailsLB->setText(i18n("(select test first)"));
	ui.detailsGB->hide();
	ui.proposedCorrectiveActionGB->hide();
	} else {
	const std::shared_ptr<SelfTest> &t = model.at(row);
	ui.detailsLB->setText(t->longError());
	ui.detailsGB->setVisible(!t->passed());
	const QString action = t->proposedFix();
	ui.proposedCorrectiveActionGB->setVisible(!t->passed() && !action.isEmpty());
	ui.proposedCorrectiveActionLB->setText(action);
	ui.doItPB->setVisible(!t->passed() && t->canFixAutomatically());
	QMetaObject::invokeMethod(
	q,
	[this]() {
	ensureCurrentItemIsVisible();
	},
	Qt::QueuedConnection);
	}
	}
	void slotDoItClicked()
	{
	if (const std::shared_ptr<SelfTest> st = model.fromModelIndex(selectedRow()))
	if (st->fix()) {
	model.reloadData();
	}
	}

	private:
	void ensureCurrentItemIsVisible()
	{
	ui.resultsTV->scrollTo(ui.resultsTV->currentIndex());
	}
	void updateColumnSizes()
	{
	ui.resultsTV->header()->resizeSections(QHeaderView::ResizeToContents);
	}

	private:
	QModelIndex selectedRow() const
	{
	const QItemSelectionModel *const ism = ui.resultsTV->selectionModel();
	if (!ism) {
	return QModelIndex();
	}
	const QModelIndexList mil = ism->selectedRows();
	return mil.empty() ? QModelIndex() : proxy.mapToSource(mil.front());
	}
	int selectedRowIndex() const
	{
	return selectedRow().row();
	}

	private:
	Model model;
	Proxy proxy;

	struct UI {
	- TreeViewInternal *resultsTV = nullptr;
	+ TreeView *resultsTV = nullptr;
	QCheckBox *showAllCB = nullptr;
	QGroupBox *detailsGB = nullptr;
	QLabel *detailsLB = nullptr;
	QGroupBox *proposedCorrectiveActionGB = nullptr;
	QLabel *proposedCorrectiveActionLB = nullptr;
	QPushButton *doItPB = nullptr;
	QCheckBox *runAtStartUpCB;
	QDialogButtonBox *buttonBox;
	QPushButton *rerunPB = nullptr;

	LabelHelper labelHelper;

	explicit UI(SelfTestDialog *qq)
	{
	auto mainLayout = new QVBoxLayout{qq};

	{
	auto label = new QLabel{xi18n("<para>These are the results of the Kleopatra self-test suite. Click on a test for details.</para>"
	"<para>Note that all but the first failure might be due to prior tests failing.</para>"),
	qq};
	label->setWordWrap(true);
	labelHelper.addLabel(label);

	mainLayout->addWidget(label);
	}

	auto splitter = new QSplitter{qq};
	splitter->setOrientation(Qt::Vertical);

	{
	auto widget = new QWidget{qq};
	auto vbox = new QVBoxLayout{widget};
	vbox->setContentsMargins(0, 0, 0, 0);

	- resultsTV = new TreeViewInternal{qq};
	+ resultsTV = new TreeView{qq};
	resultsTV->setAccessibleName(i18n("test results"));
	QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
	sizePolicy.setHorizontalStretch(0);
	sizePolicy.setVerticalStretch(1);
	sizePolicy.setHeightForWidth(resultsTV->sizePolicy().hasHeightForWidth());
	resultsTV->setSizePolicy(sizePolicy);
	resultsTV->setMinimumHeight(100);
	resultsTV->setRootIsDecorated(false);
	resultsTV->setAllColumnsShowFocus(true);
	vbox->addWidget(resultsTV);

	splitter->addWidget(widget);
	}
	{
	detailsGB = new QGroupBox{i18nc("@title:group", "Details"), qq};
	auto groupBoxLayout = new QVBoxLayout{detailsGB};

	auto scrollArea = new Kleo::ScrollArea{qq};
	scrollArea->setFocusPolicy(Qt::NoFocus);
	scrollArea->setMinimumHeight(100);
	scrollArea->setFrameShape(QFrame::NoFrame);
	scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	auto scrollAreaLayout = qobject_cast<QBoxLayout *>(scrollArea->widget()->layout());

	detailsLB = new QLabel{qq};
	detailsLB->setTextFormat(Qt::RichText);
	detailsLB->setTextInteractionFlags(Qt::TextSelectableByMouse);
	detailsLB->setWordWrap(true);
	labelHelper.addLabel(detailsLB);

	scrollAreaLayout->addWidget(detailsLB);
	scrollAreaLayout->addStretch();

	groupBoxLayout->addWidget(scrollArea);

	splitter->addWidget(detailsGB);
	}
	{
	proposedCorrectiveActionGB = new QGroupBox{i18nc("@title:group", "Proposed Corrective Action"), qq};
	auto groupBoxLayout = new QVBoxLayout{proposedCorrectiveActionGB};

	auto scrollArea = new Kleo::ScrollArea{qq};
	scrollArea->setFocusPolicy(Qt::NoFocus);
	scrollArea->setMinimumHeight(100);
	scrollArea->setFrameShape(QFrame::NoFrame);
	scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	auto scrollAreaLayout = qobject_cast<QBoxLayout *>(scrollArea->widget()->layout());

	proposedCorrectiveActionLB = new QLabel{qq};
	proposedCorrectiveActionLB->setTextFormat(Qt::RichText);
	proposedCorrectiveActionLB->setTextInteractionFlags(Qt::TextSelectableByMouse);
	proposedCorrectiveActionLB->setWordWrap(true);
	labelHelper.addLabel(proposedCorrectiveActionLB);

	scrollAreaLayout->addWidget(proposedCorrectiveActionLB);
	scrollAreaLayout->addStretch();

	groupBoxLayout->addWidget(scrollArea);

	{
	auto hbox = new QHBoxLayout;
	hbox->addStretch();

	doItPB = new QPushButton{i18nc("@action:button", "Do It"), qq};
	doItPB->setEnabled(false);
	hbox->addWidget(doItPB);

	groupBoxLayout->addLayout(hbox);
	}

	splitter->addWidget(proposedCorrectiveActionGB);
	}

	mainLayout->addWidget(splitter);

	showAllCB = new QCheckBox{i18nc("@option:check", "Show all test results"), qq};
	showAllCB->setChecked(true);
	mainLayout->addWidget(showAllCB);

	runAtStartUpCB = new QCheckBox{i18nc("@option:check", "Run these tests at startup"), qq};
	runAtStartUpCB->setChecked(true);
	mainLayout->addWidget(runAtStartUpCB);

	buttonBox = new QDialogButtonBox{qq};
	buttonBox->setStandardButtons(QDialogButtonBox::Cancel \| QDialogButtonBox::Close \| QDialogButtonBox::Ok);
	buttonBox->button(QDialogButtonBox::Ok)->setText(i18nc("@action:button", "Continue"));
	rerunPB = buttonBox->addButton(i18nc("@action:button", "Rerun Tests"), QDialogButtonBox::ActionRole);

	mainLayout->addWidget(buttonBox);
	}
	} ui;
	};

	SelfTestDialog::SelfTestDialog(QWidget *p, Qt::WindowFlags f)
	: QDialog(p, f)
	, d(new Private(this))
	{
	setWindowTitle(i18nc("@title:window", "Self Test"));
	resize(448, 610);

	setAutomaticMode(false);
	}

	SelfTestDialog::~SelfTestDialog() = default;

	void SelfTestDialog::setTests(const std::vector<std::shared_ptr<SelfTest>> &tests)
	{
	d->model.clear();
	d->model.append(tests);
	d->updateColumnSizes();
	}

	void SelfTestDialog::setRunAtStartUp(bool on)
	{
	d->ui.runAtStartUpCB->setChecked(on);
	}

	bool SelfTestDialog::runAtStartUp() const
	{
	return d->ui.runAtStartUpCB->isChecked();
	}

	void SelfTestDialog::setAutomaticMode(bool automatic)
	{
	d->ui.showAllCB->setChecked(!automatic);
	d->ui.buttonBox->button(QDialogButtonBox::Ok)->setVisible(automatic);
	d->ui.buttonBox->button(QDialogButtonBox::Cancel)->setVisible(automatic);
	d->ui.buttonBox->button(QDialogButtonBox::Close)->setVisible(!automatic);
	}

	#include "moc_selftestdialog.cpp"
	#include "selftestdialog.moc"
	diff --git a/src/view/keytreeview.cpp b/src/view/keytreeview.cpp
	index 74b800eac..34eb1cddf 100644
	--- a/src/view/keytreeview.cpp
	+++ b/src/view/keytreeview.cpp
	@@ -1,665 +1,646 @@
	/* -- mode: c++; c-basic-offset:4 --
	view/keytreeview.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2009 Klarälvdalens Datakonsult AB

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "keytreeview.h"
	#include "searchbar.h"

	#include <Libkleo/KeyList>
	#include <Libkleo/KeyListModel>
	#include <Libkleo/KeyListSortFilterProxyModel>
	#include <Libkleo/KeyRearrangeColumnsProxyModel>
	#include <Libkleo/Predicates>
	#include <Libkleo/TreeView>

	#include "utils/headerview.h"
	#include "utils/tags.h"

	#include <Libkleo/KeyCache>
	#include <Libkleo/KeyFilter>
	#include <Libkleo/Stl_Util>

	#include <gpgme++/key.h>

	#include "kleopatra_debug.h"
	#include <QAction>
	#include <QContextMenuEvent>
	#include <QEvent>
	#include <QHeaderView>
	#include <QItemSelection>
	#include <QItemSelectionModel>
	#include <QLayout>
	#include <QList>
	#include <QMenu>
	#include <QTimer>

	#include <KLocalizedString>
	#include <KSharedConfig>

	static int tagsColumn;

	using namespace Kleo;
	using namespace GpgME;

	Q_DECLARE_METATYPE(GpgME::Key)

	namespace
	{

	class TreeViewInternal : public Kleo::TreeView
	{
	public:
	explicit TreeViewInternal(QWidget *parent = nullptr)
	: Kleo::TreeView{parent}
	{
	connect(this, &TreeView::columnEnabled, this, [this](int column) {
	if (column == tagsColumn) {
	Tags::enableTags();
	}
	});
	}

	QSize minimumSizeHint() const override
	{
	const QSize min = QTreeView::minimumSizeHint();
	return QSize(min.width(), min.height() + 5 * fontMetrics().height());
	}

	-protected:
	- void focusInEvent(QFocusEvent *event) override
	- {
	- QTreeView::focusInEvent(event);
	- // queue the invokation, so that it happens after the widget itself got focus
	- QMetaObject::invokeMethod(this, &TreeViewInternal::forceAccessibleFocusEventForCurrentItem, Qt::QueuedConnection);
	- }
	-
	-private:
	- void forceAccessibleFocusEventForCurrentItem()
	- {
	- // force Qt to send a focus event for the current item to accessibility
	- // tools; otherwise, the user has no idea which item is selected when the
	- // list gets keyboard input focus
	- const auto current = currentIndex();
	- setCurrentIndex({});
	- setCurrentIndex(current);
	- }
	-
	private:
	QMenu *mHeaderPopup = nullptr;

	QList<QAction *> mColumnActions;
	};

	const KeyListModelInterface *keyListModel(const QTreeView &view)
	{
	const KeyListModelInterface const klmi = dynamic_cast<KeyListModelInterface >(view.model());
	Q_ASSERT(klmi);
	return klmi;
	}

	} // anon namespace

	KeyTreeView::KeyTreeView(QWidget *parent)
	: QWidget(parent)
	, m_proxy(new KeyListSortFilterProxyModel(this))
	, m_additionalProxy(nullptr)
	, m_view(new TreeViewInternal(this))
	, m_flatModel(nullptr)
	, m_hierarchicalModel(nullptr)
	, m_stringFilter()
	, m_keyFilter()
	, m_isHierarchical(true)
	{
	init();
	}

	KeyTreeView::KeyTreeView(const KeyTreeView &other)
	: QWidget(nullptr)
	, m_proxy(new KeyListSortFilterProxyModel(this))
	, m_additionalProxy(other.m_additionalProxy ? other.m_additionalProxy->clone() : nullptr)
	, m_view(new TreeViewInternal(this))
	, m_flatModel(other.m_flatModel)
	, m_hierarchicalModel(other.m_hierarchicalModel)
	, m_stringFilter(other.m_stringFilter)
	, m_keyFilter(other.m_keyFilter)
	, m_group(other.m_group)
	, m_isHierarchical(other.m_isHierarchical)
	{
	init();
	setColumnSizes(other.columnSizes());
	setSortColumn(other.sortColumn(), other.sortOrder());
	}

	KeyTreeView::KeyTreeView(const QString &text,
	const std::shared_ptr<KeyFilter> &kf,
	AbstractKeyListSortFilterProxyModel *proxy,
	QWidget *parent,
	const KConfigGroup &group)
	: QWidget(parent)
	, m_proxy(new KeyListSortFilterProxyModel(this))
	, m_additionalProxy(proxy)
	, m_view(new TreeViewInternal(this))
	, m_flatModel(nullptr)
	, m_hierarchicalModel(nullptr)
	, m_stringFilter(text)
	, m_keyFilter(kf)
	, m_group(group)
	, m_isHierarchical(true)
	, m_onceResized(false)
	{
	init();
	}

	void KeyTreeView::setColumnSizes(const std::vector<int> &sizes)
	{
	if (sizes.empty()) {
	return;
	}
	Q_ASSERT(m_view);
	Q_ASSERT(m_view->header());
	Q_ASSERT(qobject_cast<HeaderView >(m_view->header()) == static_cast<HeaderView >(m_view->header()));
	if (auto const hv = static_cast<HeaderView *>(m_view->header())) {
	hv->setSectionSizes(sizes);
	}
	}

	void KeyTreeView::setSortColumn(int sortColumn, Qt::SortOrder sortOrder)
	{
	Q_ASSERT(m_view);
	m_view->sortByColumn(sortColumn, sortOrder);
	}

	int KeyTreeView::sortColumn() const
	{
	Q_ASSERT(m_view);
	Q_ASSERT(m_view->header());
	return m_view->header()->sortIndicatorSection();
	}

	Qt::SortOrder KeyTreeView::sortOrder() const
	{
	Q_ASSERT(m_view);
	Q_ASSERT(m_view->header());
	return m_view->header()->sortIndicatorOrder();
	}

	std::vector<int> KeyTreeView::columnSizes() const
	{
	Q_ASSERT(m_view);
	Q_ASSERT(m_view->header());
	Q_ASSERT(qobject_cast<HeaderView >(m_view->header()) == static_cast<HeaderView >(m_view->header()));
	if (auto const hv = static_cast<HeaderView *>(m_view->header())) {
	return hv->sectionSizes();
	} else {
	return std::vector<int>();
	}
	}

	void KeyTreeView::restoreLayout(const KConfigGroup &group)
	{
	if (!group.isValid() \|\| !m_view->restoreColumnLayout(group.name())) {
	// if config is empty then use default settings
	// The numbers have to be in line with the order in
	// setsSourceColumns above
	m_view->hideColumn(5);

	for (int i = 7; i < m_view->model()->columnCount(); ++i) {
	m_view->hideColumn(i);
	}
	if (KeyCache::instance()->initialized()) {
	QTimer::singleShot(0, this, &KeyTreeView::initializeColumnSizes);
	}
	} else {
	m_onceResized = true;
	}
	if (!m_view->isColumnHidden(tagsColumn)) {
	Tags::enableTags();
	}
	}

	void KeyTreeView::init()
	{
	Q_SET_OBJECT_NAME(m_proxy);
	Q_SET_OBJECT_NAME(m_view);

	if (m_group.isValid()) {
	// Reopen as non const
	KConfig *conf = m_group.config();
	m_group = conf->group(m_group.name());
	}

	if (m_additionalProxy && m_additionalProxy->objectName().isEmpty()) {
	Q_SET_OBJECT_NAME(m_additionalProxy);
	}
	QLayout *layout = new QVBoxLayout(this);
	Q_SET_OBJECT_NAME(layout);
	layout->setContentsMargins(0, 0, 0, 0);
	layout->addWidget(m_view);

	auto headerView = new HeaderView(Qt::Horizontal);
	Q_SET_OBJECT_NAME(headerView);
	headerView->installEventFilter(m_view);
	headerView->setSectionsMovable(true);
	m_view->setHeader(headerView);

	m_view->setSelectionBehavior(QAbstractItemView::SelectRows);
	m_view->setSelectionMode(QAbstractItemView::ExtendedSelection);
	m_view->setAllColumnsShowFocus(false);
	m_view->setSortingEnabled(true);
	m_view->setAccessibleName(i18n("Certificates"));
	m_view->setAccessibleDescription(m_isHierarchical ? i18n("Hierarchical list of certificates") : i18n("List of certificates"));
	// we show details on double-click
	m_view->setExpandsOnDoubleClick(false);

	if (model()) {
	if (m_additionalProxy) {
	m_additionalProxy->setSourceModel(model());
	} else {
	m_proxy->setSourceModel(model());
	}
	}
	if (m_additionalProxy) {
	m_proxy->setSourceModel(m_additionalProxy);
	if (!m_additionalProxy->parent()) {
	m_additionalProxy->setParent(this);
	}
	}

	m_proxy->setFilterRegularExpression(QRegularExpression::escape(m_stringFilter.trimmed()));
	m_proxy->setKeyFilter(m_keyFilter);
	m_proxy->setSortCaseSensitivity(Qt::CaseInsensitive);

	auto rearangingModel = new KeyRearrangeColumnsProxyModel(this);
	rearangingModel->setSourceModel(m_proxy);
	QVector<int> columns = {
	KeyList::PrettyName,
	KeyList::PrettyEMail,
	KeyList::Validity,
	KeyList::ValidFrom,
	KeyList::ValidUntil,
	KeyList::TechnicalDetails,
	KeyList::KeyID,
	KeyList::Fingerprint,
	KeyList::OwnerTrust,
	KeyList::Origin,
	KeyList::LastUpdate,
	KeyList::Issuer,
	KeyList::SerialNumber,
	KeyList::Remarks,
	KeyList::Algorithm,
	KeyList::Keygrip,
	};
	tagsColumn = columns.indexOf(KeyList::Remarks);
	rearangingModel->setSourceColumns(columns);
	m_view->setModel(rearangingModel);

	/* Handle expansion state */
	if (m_group.isValid()) {
	m_expandedKeys = m_group.readEntry("Expanded", QStringList());
	}

	connect(m_view, &QTreeView::expanded, this, [this](const QModelIndex &index) {
	if (!index.isValid()) {
	return;
	}
	const auto &key = index.data(KeyList::KeyRole).value<GpgME::Key>();
	if (key.isNull()) {
	return;
	}
	const auto fpr = QString::fromLatin1(key.primaryFingerprint());

	if (m_expandedKeys.contains(fpr)) {
	return;
	}
	m_expandedKeys << fpr;
	if (m_group.isValid()) {
	m_group.writeEntry("Expanded", m_expandedKeys);
	}
	});

	connect(m_view, &QTreeView::collapsed, this, [this](const QModelIndex &index) {
	if (!index.isValid()) {
	return;
	}
	const auto &key = index.data(KeyList::KeyRole).value<GpgME::Key>();
	if (key.isNull()) {
	return;
	}
	m_expandedKeys.removeAll(QString::fromLatin1(key.primaryFingerprint()));
	if (m_group.isValid()) {
	m_group.writeEntry("Expanded", m_expandedKeys);
	}
	});

	updateModelConnections(nullptr, model());
	}

	void KeyTreeView::restoreExpandState()
	{
	if (!KeyCache::instance()->initialized()) {
	qCWarning(KLEOPATRA_LOG) << "Restore expand state before keycache available. Aborting.";
	return;
	}
	for (const auto &fpr : std::as_const(m_expandedKeys)) {
	const KeyListModelInterface const km = keyListModel(m_view);
	if (!km) {
	qCWarning(KLEOPATRA_LOG) << "invalid model";
	return;
	}
	const auto key = KeyCache::instance()->findByFingerprint(fpr.toLatin1().constData());
	if (key.isNull()) {
	qCDebug(KLEOPATRA_LOG) << "Cannot find:" << fpr << "anymore in cache";
	m_expandedKeys.removeAll(fpr);
	return;
	}
	const auto idx = km->index(key);
	if (!idx.isValid()) {
	qCDebug(KLEOPATRA_LOG) << "Cannot find:" << fpr << "anymore in model";
	m_expandedKeys.removeAll(fpr);
	return;
	}
	m_view->expand(idx);
	}
	}

	void KeyTreeView::setUpTagKeys()
	{
	const auto tagKeys = Tags::tagKeys();
	if (m_hierarchicalModel) {
	m_hierarchicalModel->setRemarkKeys(tagKeys);
	}
	if (m_flatModel) {
	m_flatModel->setRemarkKeys(tagKeys);
	}
	}

	KeyTreeView::~KeyTreeView() = default;

	static QAbstractProxyModel find_last_proxy(QAbstractProxyModel pm)
	{
	Q_ASSERT(pm);
	while (auto const sm = qobject_cast<QAbstractProxyModel *>(pm->sourceModel())) {
	pm = sm;
	}
	return pm;
	}

	void KeyTreeView::updateModelConnections(AbstractKeyListModel oldModel, AbstractKeyListModel newModel)
	{
	if (oldModel == newModel) {
	return;
	}
	if (oldModel) {
	disconnect(oldModel, &QAbstractItemModel::modelAboutToBeReset, this, &KeyTreeView::saveStateBeforeModelChange);
	disconnect(oldModel, &QAbstractItemModel::modelReset, this, &KeyTreeView::restoreStateAfterModelChange);
	disconnect(oldModel, &QAbstractItemModel::rowsAboutToBeInserted, this, &KeyTreeView::saveStateBeforeModelChange);
	disconnect(oldModel, &QAbstractItemModel::rowsInserted, this, &KeyTreeView::restoreStateAfterModelChange);
	disconnect(oldModel, &QAbstractItemModel::rowsAboutToBeRemoved, this, &KeyTreeView::saveStateBeforeModelChange);
	disconnect(oldModel, &QAbstractItemModel::rowsRemoved, this, &KeyTreeView::restoreStateAfterModelChange);
	}
	if (newModel) {
	connect(newModel, &QAbstractItemModel::modelAboutToBeReset, this, &KeyTreeView::saveStateBeforeModelChange);
	connect(newModel, &QAbstractItemModel::modelReset, this, &KeyTreeView::restoreStateAfterModelChange);
	connect(newModel, &QAbstractItemModel::rowsAboutToBeInserted, this, &KeyTreeView::saveStateBeforeModelChange);
	connect(newModel, &QAbstractItemModel::rowsInserted, this, &KeyTreeView::restoreStateAfterModelChange);
	connect(newModel, &QAbstractItemModel::rowsAboutToBeRemoved, this, &KeyTreeView::saveStateBeforeModelChange);
	connect(newModel, &QAbstractItemModel::rowsRemoved, this, &KeyTreeView::restoreStateAfterModelChange);
	}
	}

	void KeyTreeView::setFlatModel(AbstractKeyListModel *model)
	{
	if (model == m_flatModel) {
	return;
	}
	auto oldModel = m_flatModel;
	m_flatModel = model;
	if (!m_isHierarchical)
	// TODO: this fails when called after setHierarchicalView( false )...
	{
	find_last_proxy(m_proxy)->setSourceModel(model);
	updateModelConnections(oldModel, model);
	}
	}

	void KeyTreeView::setHierarchicalModel(AbstractKeyListModel *model)
	{
	if (model == m_hierarchicalModel) {
	return;
	}
	auto oldModel = m_hierarchicalModel;
	m_hierarchicalModel = model;
	if (m_isHierarchical) {
	find_last_proxy(m_proxy)->setSourceModel(model);
	updateModelConnections(oldModel, model);
	m_view->expandAll();
	for (int column = 0; column < m_view->header()->count(); ++column) {
	m_view->header()->resizeSection(column, qMax(m_view->header()->sectionSize(column), m_view->header()->sectionSizeHint(column)));
	}
	}
	}

	void KeyTreeView::setStringFilter(const QString &filter)
	{
	if (filter == m_stringFilter) {
	return;
	}
	m_stringFilter = filter;
	m_proxy->setFilterRegularExpression(QRegularExpression::escape(filter.trimmed()));
	Q_EMIT stringFilterChanged(filter);
	}

	void KeyTreeView::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
	{
	if (filter == m_keyFilter \|\| (filter && m_keyFilter && filter->id() == m_keyFilter->id())) {
	return;
	}
	m_keyFilter = filter;
	m_proxy->setKeyFilter(filter);
	Q_EMIT keyFilterChanged(filter);
	}

	namespace
	{
	QItemSelection itemSelectionFromKeys(const std::vector<Key> &keys, const QTreeView &view)
	{
	const QModelIndexList indexes = keyListModel(view)->indexes(keys);
	return std::accumulate(indexes.cbegin(), indexes.cend(), QItemSelection(), [](QItemSelection selection, const QModelIndex &index) {
	if (index.isValid()) {
	selection.merge(QItemSelection(index, index), QItemSelectionModel::Select);
	}
	return selection;
	});
	}
	}

	void KeyTreeView::selectKeys(const std::vector<Key> &keys)
	{
	m_view->selectionModel()->select(itemSelectionFromKeys(keys, *m_view), QItemSelectionModel::ClearAndSelect \| QItemSelectionModel::Rows);
	}

	std::vector<Key> KeyTreeView::selectedKeys() const
	{
	return keyListModel(*m_view)->keys(m_view->selectionModel()->selectedRows());
	}

	void KeyTreeView::setHierarchicalView(bool on)
	{
	if (on == m_isHierarchical) {
	return;
	}
	if (on && !hierarchicalModel()) {
	qCWarning(KLEOPATRA_LOG) << "hierarchical view requested, but no hierarchical model set";
	return;
	}
	if (!on && !flatModel()) {
	qCWarning(KLEOPATRA_LOG) << "flat view requested, but no flat model set";
	return;
	}
	const std::vector<Key> selectedKeys = this->selectedKeys();
	const Key currentKey = keyListModel(*m_view)->key(m_view->currentIndex());

	auto oldModel = model();
	m_isHierarchical = on;
	find_last_proxy(m_proxy)->setSourceModel(model());
	updateModelConnections(oldModel, model());
	if (on) {
	m_view->expandAll();
	}
	selectKeys(selectedKeys);
	if (!currentKey.isNull()) {
	const QModelIndex currentIndex = keyListModel(*m_view)->index(currentKey);
	if (currentIndex.isValid()) {
	m_view->selectionModel()->setCurrentIndex(currentIndex, QItemSelectionModel::NoUpdate);
	m_view->scrollTo(currentIndex);
	}
	}
	m_view->setAccessibleDescription(m_isHierarchical ? i18n("Hierarchical list of certificates") : i18n("List of certificates"));
	Q_EMIT hierarchicalChanged(on);
	}

	void KeyTreeView::setKeys(const std::vector<Key> &keys, const std::vector<Key::Origin> &extraOrigins)
	{
	std::vector<Key> sorted = keys;

	if (extraOrigins.empty()) {
	_detail::sort_by_fpr(sorted);
	_detail::remove_duplicates_by_fpr(sorted);
	}
	m_keys = sorted;
	if (m_flatModel) {
	m_flatModel->setKeys(sorted, extraOrigins);
	}
	if (m_hierarchicalModel) {
	m_hierarchicalModel->setKeys(sorted, extraOrigins);
	}
	}

	void KeyTreeView::addKeysImpl(const std::vector<Key> &keys, bool select)
	{
	if (keys.empty()) {
	return;
	}
	if (m_keys.empty()) {
	setKeys(keys);
	return;
	}

	std::vector<Key> sorted = keys;
	_detail::sort_by_fpr(sorted);
	_detail::remove_duplicates_by_fpr(sorted);

	std::vector<Key> newKeys = _detail::union_by_fpr(sorted, m_keys);
	m_keys.swap(newKeys);

	if (m_flatModel) {
	m_flatModel->addKeys(sorted);
	}
	if (m_hierarchicalModel) {
	m_hierarchicalModel->addKeys(sorted);
	}

	if (select) {
	selectKeys(sorted);
	}
	}

	void KeyTreeView::addKeysSelected(const std::vector<Key> &keys)
	{
	addKeysImpl(keys, true);
	}

	void KeyTreeView::addKeysUnselected(const std::vector<Key> &keys)
	{
	addKeysImpl(keys, false);
	}

	void KeyTreeView::removeKeys(const std::vector<Key> &keys)
	{
	if (keys.empty()) {
	return;
	}
	std::vector<Key> sorted = keys;
	_detail::sort_by_fpr(sorted);
	_detail::remove_duplicates_by_fpr(sorted);
	std::vector<Key> newKeys;
	newKeys.reserve(m_keys.size());
	std::set_difference(m_keys.begin(), m_keys.end(), sorted.begin(), sorted.end(), std::back_inserter(newKeys), _detail::ByFingerprint<std::less>());
	m_keys.swap(newKeys);

	if (m_flatModel) {
	std::for_each(sorted.cbegin(), sorted.cend(), [this](const Key &key) {
	m_flatModel->removeKey(key);
	});
	}
	if (m_hierarchicalModel) {
	std::for_each(sorted.cbegin(), sorted.cend(), [this](const Key &key) {
	m_hierarchicalModel->removeKey(key);
	});
	}
	}

	void KeyTreeView::disconnectSearchBar()
	{
	for (const auto &connection : m_connections) {
	disconnect(connection);
	}
	m_connections.clear();
	}

	bool KeyTreeView::connectSearchBar(const SearchBar *bar)
	{
	m_connections.reserve(4);
	m_connections.push_back(connect(this, &KeyTreeView::stringFilterChanged, bar, &SearchBar::setStringFilter));
	m_connections.push_back(connect(bar, &SearchBar::stringFilterChanged, this, &KeyTreeView::setStringFilter));
	m_connections.push_back(connect(this, &KeyTreeView::keyFilterChanged, bar, &SearchBar::setKeyFilter));
	m_connections.push_back(connect(bar, &SearchBar::keyFilterChanged, this, &KeyTreeView::setKeyFilter));

	return std::all_of(m_connections.cbegin(), m_connections.cend(), [](const QMetaObject::Connection &conn) {
	return conn;
	});
	}

	void KeyTreeView::initializeColumnSizes()
	{
	if (m_onceResized \|\| m_view->model()->rowCount() == 0) {
	return;
	}
	m_onceResized = true;
	m_view->setColumnWidth(KeyList::PrettyName, 260);
	m_view->setColumnWidth(KeyList::PrettyEMail, 260);

	for (int i = 2; i < m_view->model()->columnCount(); ++i) {
	m_view->resizeColumnToContents(i);
	}
	}

	void KeyTreeView::saveStateBeforeModelChange()
	{
	m_currentKey = keyListModel(*m_view)->key(m_view->currentIndex());
	m_selectedKeys = selectedKeys();
	}

	void KeyTreeView::restoreStateAfterModelChange()
	{
	restoreExpandState();

	selectKeys(m_selectedKeys);
	if (!m_currentKey.isNull()) {
	const QModelIndex currentIndex = keyListModel(*m_view)->index(m_currentKey);
	if (currentIndex.isValid()) {
	m_view->selectionModel()->setCurrentIndex(currentIndex, QItemSelectionModel::NoUpdate);
	m_view->scrollTo(currentIndex);
	}
	}

	setUpTagKeys();
	initializeColumnSizes();
	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Dec 19, 2:04 PM (1 d, 14 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 3b/9d/76cf1820bce4ce61ae21a44de357

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions