File indexing completed on 2024-06-23 05:13:49

 /*  crypto/gui/certificateselectionline.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009 Klarälvdalens Datakonsult AB
 
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #include "certificateselectionline.h"
 
 #include <QComboBox>
 #include <QLabel>
 #include <QStackedWidget>
 #include <QStyle>
 #include <QStyleOptionComboBox>
 #include <QStylePainter>
 #include <QToolButton>
 
 #include "utils/kleo_assert.h"
 
 #include <KLocalizedString>
 
 #include <Libkleo/Formatting>
 #include <Libkleo/Predicates>
 
 using namespace Kleo;
 using namespace GpgME;
 
 Q_DECLARE_METATYPE(GpgME::Key)
 
 namespace
 {
 
 static QString make_initial_text(const std::vector<Key> &keys)
 {
     if (keys.empty()) {
         return i18n("(no matching certificates found)");
     } else {
         return i18n("Please select a certificate");
     }
 }
 
 // A QComboBox with an initial text (as known from web browsers)
 //
 // only works with read-only QComboBoxen, doesn't affect sizeHint
 // as it should...
 //
 class ComboBox : public QComboBox
 {
     Q_OBJECT
     Q_PROPERTY(QString initialText READ initialText WRITE setInitialText)
     Q_PROPERTY(QIcon initialIcon READ initialIcon WRITE setInitialIcon)
 public:
     explicit ComboBox(QWidget *parent = nullptr)
         : QComboBox(parent)
         , m_initialText()
         , m_initialIcon()
     {
     }
 
     explicit ComboBox(const QString &initialText, QWidget *parent = nullptr)
         : QComboBox(parent)
         , m_initialText(initialText)
         , m_initialIcon()
     {
     }
 
     explicit ComboBox(const QIcon &initialIcon, const QString &initialText, QWidget *parent = nullptr)
         : QComboBox(parent)
         , m_initialText(initialText)
         , m_initialIcon(initialIcon)
     {
     }
 
     [[nodiscard]] QString initialText() const
     {
         return m_initialText;
     }
     [[nodiscard]] QIcon initialIcon() const
     {
         return m_initialIcon;
     }
 
 public Q_SLOTS:
     void setInitialText(const QString &txt)
     {
         if (txt == m_initialText) {
             return;
         }
         m_initialText = txt;
         if (currentIndex() == -1) {
             update();
         }
     }
     void setInitialIcon(const QIcon &icon)
     {
         if (icon.cacheKey() == m_initialIcon.cacheKey()) {
             return;
         }
         m_initialIcon = icon;
         if (currentIndex() == -1) {
             update();
         }
     }
 
 protected:
     void paintEvent(QPaintEvent *) override
     {
         QStylePainter p(this);
         p.setPen(palette().color(QPalette::Text));
         QStyleOptionComboBox opt;
         initStyleOption(&opt);
         p.drawComplexControl(QStyle::CC_ComboBox, opt);
 
         if (currentIndex() == -1) {
             opt.currentText = m_initialText;
             opt.currentIcon = m_initialIcon;
         }
         p.drawControl(QStyle::CE_ComboBoxLabel, opt);
     }
 
 private:
     QString m_initialText;
     QIcon m_initialIcon;
 };
 } // anonymous namespace
 
 class Kleo::KeysComboBox : public ComboBox
 {
     Q_OBJECT
 public:
     explicit KeysComboBox(QWidget *parent = nullptr)
         : ComboBox(parent)
     {
     }
     explicit KeysComboBox(const QString &initialText, QWidget *parent = nullptr)
         : ComboBox(initialText, parent)
     {
     }
     explicit KeysComboBox(const std::vector<Key> &keys, QWidget *parent = nullptr)
         : ComboBox(make_initial_text(keys), parent)
     {
         setKeys(keys);
     }
 
     void setKeys(const std::vector<Key> &keys)
     {
         clear();
         for (const Key &key : keys) {
             addItem(Formatting::formatForComboBox(key), QVariant::fromValue(key));
         }
     }
 
     std::vector<Key> keys() const
     {
         std::vector<Key> result;
         result.reserve(count());
         for (int i = 0, end = count(); i != end; ++i) {
             result.push_back(qvariant_cast<Key>(itemData(i)));
         }
         return result;
     }
 
     int findOrAdd(const Key &key)
     {
         for (int i = 0, end = count(); i != end; ++i)
             if (_detail::ByFingerprint<std::equal_to>()(key, qvariant_cast<Key>(itemData(i)))) {
                 return i;
             }
         insertItem(0, Formatting::formatForComboBox(key), QVariant::fromValue(key));
         return 0;
     }
 
     void addAndSelectCertificate(const Key &key)
     {
         setCurrentIndex(findOrAdd(key));
     }
 
     Key currentKey() const
     {
         return qvariant_cast<Key>(itemData(currentIndex()));
     }
 };
 
 CertificateSelectionLine::CertificateSelectionLine(const QString &toFrom,
                                                    const QString &mailbox,
                                                    const std::vector<Key> &pgp,
                                                    bool pgpAmbig,
                                                    const std::vector<Key> &cms,
                                                    bool cmsAmbig,
                                                    QWidget *q,
                                                    QGridLayout &glay)
     : pgpAmbiguous(pgpAmbig)
     , cmsAmbiguous(cmsAmbig)
     , mToFromLB(new QLabel(toFrom, q))
     , mMailboxLB(new QLabel(mailbox, q))
     , mSbox(new QStackedWidget(q))
     , mPgpCB(new KeysComboBox(pgp, mSbox))
     , mCmsCB(new KeysComboBox(cms, mSbox))
     , noProtocolCB(new KeysComboBox(i18n("(please choose between OpenPGP and S/MIME first)"), mSbox))
     , mToolTB(new QToolButton(q))
 {
     QFont bold;
     bold.setBold(true);
     mToFromLB->setFont(bold);
 
     mMailboxLB->setTextFormat(Qt::PlainText);
     mToolTB->setText(i18n("..."));
 
     mPgpCB->setEnabled(!pgp.empty());
     mCmsCB->setEnabled(!cms.empty());
     noProtocolCB->setEnabled(false);
 
     mPgpCB->setKeys(pgp);
     if (pgpAmbiguous) {
         mPgpCB->setCurrentIndex(-1);
     }
 
     mCmsCB->setKeys(cms);
     if (cmsAmbiguous) {
         mCmsCB->setCurrentIndex(-1);
     }
 
     mSbox->addWidget(mPgpCB);
     mSbox->addWidget(mCmsCB);
     mSbox->addWidget(noProtocolCB);
     mSbox->setCurrentWidget(noProtocolCB);
 
     const int row = glay.rowCount();
     int col = 0;
     glay.addWidget(mToFromLB, row, col++);
     glay.addWidget(mMailboxLB, row, col++);
     glay.addWidget(mSbox, row, col++);
     glay.addWidget(mToolTB, row, col++);
     Q_ASSERT(col == NumColumns);
 
     q->connect(mPgpCB, SIGNAL(currentIndexChanged(int)), SLOT(slotCompleteChanged()));
     q->connect(mCmsCB, SIGNAL(currentIndexChanged(int)), SLOT(slotCompleteChanged()));
     q->connect(mToolTB, SIGNAL(clicked()), SLOT(slotCertificateSelectionDialogRequested()));
 }
 
 QString CertificateSelectionLine::mailboxText() const
 {
     return mMailboxLB->text();
 }
 
 void CertificateSelectionLine::addAndSelectCertificate(const Key &key) const
 {
     if (KeysComboBox *const cb = comboBox(key.protocol())) {
         cb->addAndSelectCertificate(key);
         cb->setEnabled(true);
     }
 }
 
 void CertificateSelectionLine::showHide(Protocol proto, bool &first, bool showAll, bool op) const
 {
     if (op && (showAll || wasInitiallyAmbiguous(proto))) {
         mToFromLB->setVisible(first);
         first = false;
 
         QFont font = mMailboxLB->font();
         font.setBold(wasInitiallyAmbiguous(proto));
         mMailboxLB->setFont(font);
 
         mSbox->setCurrentIndex(proto);
 
         mMailboxLB->show();
         mSbox->show();
         mToolTB->show();
     } else {
         mToFromLB->hide();
         mMailboxLB->hide();
         mSbox->hide();
         mToolTB->hide();
     }
 }
 
 bool CertificateSelectionLine::wasInitiallyAmbiguous(Protocol proto) const
 {
     return (proto == OpenPGP && pgpAmbiguous) || (proto == CMS && cmsAmbiguous);
 }
 
 bool CertificateSelectionLine::isStillAmbiguous(Protocol proto) const
 {
     kleo_assert(proto == OpenPGP || proto == CMS);
     const KeysComboBox *const cb = comboBox(proto);
     return cb->currentIndex() == -1;
 }
 
 Key CertificateSelectionLine::key(Protocol proto) const
 {
     kleo_assert(proto == OpenPGP || proto == CMS);
     const KeysComboBox *const cb = comboBox(proto);
     return cb->currentKey();
 }
 
 const QToolButton *CertificateSelectionLine::toolButton() const
 {
     return mToolTB;
 }
 
 void CertificateSelectionLine::kill()
 {
     delete mToFromLB;
     delete mMailboxLB;
     delete mSbox;
     delete mToolTB;
 }
 
 KeysComboBox *CertificateSelectionLine::comboBox(Protocol proto) const
 {
     if (proto == OpenPGP) {
         return mPgpCB;
     }
     if (proto == CMS) {
         return mCmsCB;
     }
     return nullptr;
 }
 
 #include "certificateselectionline.moc"