Katana_mirror/kde-extraapps
1
0
Fork 0
mirror of https://bitbucket.org/smil3y/kde-extraapps.git synced 2025-02-23 18:32:53 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
kde-extraapps/kgpg/keysmanager.cpp

2861 lines
85 KiB
C++
Raw Blame History

/*
* Copyright (C) 2002 Jean-Baptiste Mardelle <bj@altern.org>
* Copyright (C) 2007,2008,2009,2010,2011,2012,2013
* Rolf Eike Beer <kde@opensource.sf-tec.de>
* Copyright (C) 2011 Luis Ángel Fernández Fernández <laffdez@gmail.com>
*/
/***************************************************************************
* *
* This program 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. *
* *
***************************************************************************/
#include "keysmanager.h"
#include "caff.h"
#include "core/images.h"
#include "core/kgpgkey.h"
#include "detailedconsole.h"
#include "groupedit.h"
#include "keyadaptor.h"
#include "keyexport.h"
#include "keyinfodialog.h"
#include "keyservers.h"
#include "keytreeview.h"
#include "kgpg.h"
#include "kgpgchangekey.h"
#include "kgpgkeygenerate.h"
#include "kgpgoptions.h"
#include "kgpgrevokewidget.h"
#include "kgpgsettings.h"
#include "newkey.h"
#include "selectpublickeydialog.h"
#include "selectsecretkey.h"
#include "sourceselect.h"
#include "editor/kgpgeditor.h"
#include "editor/kgpgtextedit.h"
#include "model/keylistproxymodel.h"
#include "transactions/kgpgaddphoto.h"
#include "transactions/kgpgadduid.h"
#include "transactions/kgpgdecrypt.h"
#include "transactions/kgpgdelkey.h"
#include "transactions/kgpgdelsign.h"
#include "transactions/kgpgdeluid.h"
#include "transactions/kgpgencrypt.h"
#include "transactions/kgpgexport.h"
#include "transactions/kgpggeneratekey.h"
#include "transactions/kgpggeneraterevoke.h"
#include "transactions/kgpgimport.h"
#include "transactions/kgpgkeyservergettransaction.h"
#include "transactions/kgpgprimaryuid.h"
#include "transactions/kgpgsignkey.h"
#include "transactions/kgpgsignuid.h"
#include "transactions/kgpgtransactionjob.h"
#include <akonadi/contact/contacteditor.h>
#include <akonadi/contact/contacteditordialog.h>
#include <akonadi/contact/contactsearchjob.h>
#include <KAction>
#include <KActionCollection>
#include <KDebug>
#include <KFileDialog>
#include <KFind>
#include <KFindDialog>
#include <KIcon>
#include <KInputDialog>
#include <KLineEdit>
#include <KLocale>
#include <KMenu>
#include <KMessageBox>
#include <KMimeType>
#include <KMimeTypeTrader>
#include <KProcess>
#include <KRecentFilesAction>
#include <KRun>
#include <KSelectAction>
#include <KService>
#include <KShortcut>
#include <KStandardAction>
#include <KStandardDirs>
#include <KStandardShortcut>
#include <KStatusBar>
#include <KStatusNotifierItem>
#include <KToggleAction>
#include <KToolBar>
#include <KToolInvocation>
#include <KUniqueApplication>
#include <KUrl>
#include <KVBox>
#include <QApplication>
#include <QClipboard>
#include <QDesktopWidget>
#include <QDir>
#include <QEvent>
#include <QFile>
#include <QKeySequence>
#include <QLabel>
#include <QList>
#include <QMetaObject>
#include <QPainter>
#include <QPrintDialog>
#include <QPrinter>
#include <QProcess>
#include <QTextStream>
#include <QWidget>
#include <QtDBus/QtDBus>
#include <kabc/addresseelist.h>
// #include <kabc/key.h> TODO
#include <kio/global.h>
#include <kjobtrackerinterface.h>
#include <ktip.h>
#include <solid/networking.h>
using namespace KgpgCore;
KeysManager::KeysManager(QWidget *parent)
: KXmlGuiWindow(parent),
imodel(new KGpgItemModel(this)),
m_adduid(NULL),
m_genkey(NULL),
m_delkey(NULL),
terminalkey(NULL),
m_trayicon(NULL)
{
new KeyAdaptor(this);
QDBusConnection::sessionBus().registerObject(QLatin1String( "/KeyInterface" ), this);
setAttribute(Qt::WA_DeleteOnClose, false);
setWindowTitle(i18n("Key Management"));
KStandardAction::quit(this, SLOT(quitApp()), actionCollection());
actionCollection()->addAction(KStandardAction::Preferences, QLatin1String( "options_configure" ), this, SLOT(showOptions()));
openEditor = actionCollection()->addAction(QLatin1String("kgpg_editor"), this, SLOT(slotOpenEditor()));
openEditor->setIcon(KIcon( QLatin1String( "accessories-text-editor" )));
openEditor->setText(i18n("&Open Editor"));
kserver = actionCollection()->addAction( QLatin1String("key_server"), this, SLOT(showKeyServer()));
kserver->setText( i18n("&Key Server Dialog") );
kserver->setIcon( KIcon( QLatin1String( "network-server" )) );
goToDefaultKey = actionCollection()->addAction(QLatin1String("go_default_key"), this, SLOT(slotGotoDefaultKey()));
goToDefaultKey->setIcon(KIcon( QLatin1String( "go-home" )));
goToDefaultKey->setText(i18n("&Go to Default Key"));
goToDefaultKey->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Home));
s_kgpgEditor = new KgpgEditor(this, imodel, Qt::Dialog);
s_kgpgEditor->setAttribute(Qt::WA_DeleteOnClose, false);
// this must come after kserver, preferences, and openEditor are created
// because they are used to set up the tray icon context menu
readOptions();
if (showTipOfDay)
installEventFilter(this);
KAction *action;
action = actionCollection()->addAction(QLatin1String("help_tipofday"), this, SLOT(slotTip()));
action->setIcon( KIcon( QLatin1String( "help-hint" )) );
action->setText( i18n("Tip of the &Day") );
action = actionCollection()->addAction(QLatin1String("gpg_man"), this, SLOT(slotManpage()));
action->setText( i18n("View GnuPG Manual") );
action->setIcon( KIcon( QLatin1String( "help-contents" )) );
action = actionCollection()->addAction(QLatin1String("key_refresh"), this, SLOT(refreshkey()));
action->setIcon(KIcon( QLatin1String( "view-refresh" )));
action->setText(i18n("&Refresh List"));
action->setShortcuts(KStandardShortcut::reload());
longId = actionCollection()->add<KToggleAction>(QLatin1String("show_long_keyid"), this, SLOT(slotShowLongId(bool)));
longId->setText(i18n("Show &Long Key Id"));
longId->setChecked(KGpgSettings::showLongKeyId());
QAction *infoKey = actionCollection()->addAction(QLatin1String("key_info"), this, SLOT(keyproperties()));
infoKey->setIcon(KIcon( QLatin1String( "document-properties-key" )));
infoKey->setText(i18n("K&ey Properties"));
QAction *openKeyUrl = actionCollection()->addAction(QLatin1String("key_url"), this, SLOT(slotOpenKeyUrl()));
openKeyUrl->setIcon(KIcon(QLatin1String("applications-internet")));
openKeyUrl->setText(i18n("&Open Key URL"));
editKey = actionCollection()->addAction(QLatin1String("key_edit"), this, SLOT(slotedit()));
editKey->setIcon(KIcon( QLatin1String( "utilities-terminal" )));
editKey->setText(i18n("Edit Key in &Terminal"));
editKey->setShortcut(QKeySequence(Qt::ALT + Qt::Key_Return));
KAction *generateKey = actionCollection()->addAction(QLatin1String("key_gener"), this, SLOT(slotGenerateKey()));
generateKey->setIcon(KIcon( QLatin1String( "key-generate-pair" )));
generateKey->setText(i18n("&Generate Key Pair..."));
generateKey->setShortcuts(KStandardShortcut::shortcut(KStandardShortcut::New));
exportPublicKey = actionCollection()->addAction(QLatin1String("key_export"), this, SLOT(slotexport()));
exportPublicKey->setIcon(KIcon( QLatin1String( "document-export-key" )));
exportPublicKey->setShortcuts(KStandardShortcut::shortcut(KStandardShortcut::Copy));
KAction *importKey = actionCollection()->addAction(QLatin1String("key_import"), this, SLOT(slotPreImportKey()));
importKey->setIcon(KIcon( QLatin1String( "document-import-key" )));
importKey->setText(i18n("&Import Key..."));
importKey->setShortcuts(KStandardShortcut::shortcut(KStandardShortcut::Paste));
m_sendEmail = actionCollection()->addAction(QLatin1String("send_mail"), this, SLOT(slotSendEmail()));
m_sendEmail->setIcon(KIcon(QLatin1String("mail-send")));
m_sendEmail->setText(i18n("Send Ema&il"));
QAction *newContact = actionCollection()->addAction(QLatin1String("add_kab"), this, SLOT(addToKAB()));
newContact->setIcon(KIcon( QLatin1String( "contact-new" )));
newContact->setText(i18n("&Create New Contact in Address Book"));
createGroup = actionCollection()->addAction(QLatin1String("create_group"), this, SLOT(createNewGroup()));
createGroup->setIcon(Images::group());
editCurrentGroup = actionCollection()->addAction(QLatin1String("edit_group"), this, SLOT(editGroup()));
editCurrentGroup->setText(i18n("&Edit Group..."));
delGroup = actionCollection()->addAction(QLatin1String("delete_group"), this, SLOT(deleteGroup()));
delGroup->setText(i18n("&Delete Group"));
delGroup->setIcon(KIcon( QLatin1String( "edit-delete" )));
m_groupRename = actionCollection()->addAction(QLatin1String("rename_group"), this, SLOT(renameGroup()));
m_groupRename->setText(i18n("&Rename Group"));
m_groupRename->setIcon(KIcon( QLatin1String( "edit-rename" )));
m_groupRename->setShortcut(QKeySequence(Qt::Key_F2));
deleteKey = actionCollection()->addAction(QLatin1String("key_delete"), this, SLOT(confirmdeletekey()));
deleteKey->setIcon(KIcon( QLatin1String( "edit-delete" )));
deleteKey->setShortcut(QKeySequence(Qt::Key_Delete));
setDefaultKey = actionCollection()->addAction(QLatin1String("key_default"), this, SLOT(slotSetDefKey()));
setDefaultKey->setText(i18n("Set as De&fault Key"));
QAction *addPhoto = actionCollection()->addAction(QLatin1String("add_photo"), this, SLOT(slotAddPhoto()));
addPhoto->setText(i18n("&Add Photo..."));
QAction *addUid = actionCollection()->addAction(QLatin1String("add_uid"), this, SLOT(slotAddUid()));
addUid->setText(i18n("&Add User Id..."));
QAction *exportSecretKey = actionCollection()->addAction(QLatin1String("key_sexport"), this, SLOT(slotexportsec()));
exportSecretKey->setText(i18n("Export Secret Key..."));
QAction *deleteKeyPair = actionCollection()->addAction(QLatin1String("key_pdelete"), this, SLOT(deleteseckey()));
deleteKeyPair->setText(i18n("Delete Key Pair"));
deleteKeyPair->setIcon(KIcon( QLatin1String( "edit-delete" )));
m_revokeKey = actionCollection()->addAction(QLatin1String("key_revoke"), this, SLOT(revokeWidget()));
m_revokeKey->setText(i18n("Revoke Key..."));
QAction *regeneratePublic = actionCollection()->addAction(QLatin1String("key_regener"), this, SLOT(slotregenerate()));
regeneratePublic->setText(i18n("&Regenerate Public Key"));
delUid = actionCollection()->addAction(QLatin1String("del_uid"), this, SLOT(slotDelUid()));
delUid->setIcon(KIcon( QLatin1String( "edit-delete" )));
setPrimUid = actionCollection()->addAction(QLatin1String("prim_uid"), this, SLOT(slotPrimUid()));
setPrimUid->setText(i18n("Set User Id as &Primary"));
QAction *openPhoto = actionCollection()->addAction(QLatin1String("key_photo"), this, SLOT(slotShowPhoto()));
openPhoto->setIcon(KIcon( QLatin1String( "image-x-generic" )));
openPhoto->setText(i18n("&Open Photo"));
QAction *deletePhoto = actionCollection()->addAction(QLatin1String("delete_photo"), this, SLOT(slotDeletePhoto()));
deletePhoto->setIcon(KIcon( QLatin1String( "edit-delete" )));
deletePhoto->setText(i18n("&Delete Photo"));
delSignKey = actionCollection()->addAction(QLatin1String("key_delsign"), this, SLOT(delsignkey()));
delSignKey->setIcon(KIcon( QLatin1String( "edit-delete" )));
delSignKey->setEnabled(false);
importAllSignKeys = actionCollection()->addAction(QLatin1String("key_importallsign"), this, SLOT(importallsignkey()));
importAllSignKeys->setIcon(KIcon( QLatin1String( "document-import" )));
importAllSignKeys->setText(i18n("Import &Missing Signatures From Keyserver"));
refreshKey = actionCollection()->addAction(QLatin1String("key_server_refresh"), this, SLOT(refreshKeyFromServer()));
refreshKey->setIcon(KIcon( QLatin1String( "view-refresh" )));
signKey = actionCollection()->addAction(QLatin1String("key_sign"), this, SLOT(signkey()));
signKey->setIcon(KIcon( QLatin1String( "document-sign-key" )));
signUid = actionCollection()->addAction(QLatin1String("key_sign_uid"), this, SLOT(signuid()));
signUid->setIcon(KIcon( QLatin1String( "document-sign-key" )));
signMailUid = actionCollection()->addAction(QLatin1String("key_sign_mail_uid"), this, SLOT(caff()));
signMailUid->setIcon(KIcon( QLatin1String( "document-sign-key" )));
importSignatureKey = actionCollection()->addAction(QLatin1String("key_importsign"), this, SLOT(preimportsignkey()));
importSignatureKey->setIcon(KIcon( QLatin1String( "document-import-key" )));
sTrust = actionCollection()->add<KToggleAction>(QLatin1String("show_trust"), this, SLOT(slotShowTrust()));
sTrust->setText(i18n("Trust"));
sSize = actionCollection()->add<KToggleAction>(QLatin1String("show_size"), this, SLOT(slotShowSize()));
sSize->setText(i18n("Size"));
sCreat = actionCollection()->add<KToggleAction>(QLatin1String("show_creat"), this, SLOT(slotShowCreation()));
sCreat->setText(i18n("Creation"));
sExpi = actionCollection()->add<KToggleAction>(QLatin1String("show_expi"), this, SLOT(slotShowExpiration()));
sExpi->setText(i18n("Expiration"));
photoProps = actionCollection()->add<KSelectAction>(QLatin1String( "photo_settings" ));
photoProps->setIcon(KIcon( QLatin1String( "image-x-generic" )));
photoProps->setText(i18n("&Photo ID's"));
// Keep the list in kgpg.kcfg in sync with this one!
QStringList list;
list.append(i18n("Disable"));
list.append(i18nc("small picture", "Small"));
list.append(i18nc("medium picture", "Medium"));
list.append(i18nc("large picture", "Large"));
photoProps->setItems(list);
trustProps = actionCollection()->add<KSelectAction>(QLatin1String( "trust_filter_settings" ));
trustProps->setText(i18n("Minimum &Trust"));
QStringList tlist;
tlist.append(i18nc("no filter: show all keys", "&None"));
tlist.append(i18nc("show only active keys", "&Active"));
tlist.append(i18nc("show only keys with at least marginal trust", "&Marginal"));
tlist.append(i18nc("show only keys with at least full trust", "&Full"));
tlist.append(i18nc("show only ultimately trusted keys", "&Ultimate"));
trustProps->setItems(tlist);
iproxy = new KeyListProxyModel(this);
iproxy->setKeyModel(imodel);
connect(this, SIGNAL(readAgainOptions()), iproxy, SLOT(settingsChanged()));
iview = new KeyTreeView(this, iproxy);
connect(iview, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(defaultAction(QModelIndex)));
connect(iview, SIGNAL(importDrop(KUrl::List)), SLOT(slotImport(KUrl::List)));
iview->setSelectionMode(QAbstractItemView::ExtendedSelection);
setCentralWidget(iview);
iview->resizeColumnsToContents();
iview->setAlternatingRowColors(true);
iview->setSortingEnabled(true);
connect(iview, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(slotMenu(QPoint)));
iview->setContextMenuPolicy(Qt::CustomContextMenu);
connect(iview->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)), this, SLOT(checkList()));
connect (iview, SIGNAL(returnPressed()), SLOT(slotDefaultAction()));
hPublic = actionCollection()->add<KToggleAction>(QLatin1String("show_secret"), iproxy, SLOT(setOnlySecret(bool)));
hPublic->setIcon(KIcon( QLatin1String( "view-key-secret" )));
hPublic->setText(i18n("&Show Only Secret Keys"));
hPublic->setChecked(KGpgSettings::showSecret());
int psize = KGpgSettings::photoProperties();
photoProps->setCurrentItem(psize);
slotSetPhotoSize(psize);
psize = KGpgSettings::trustLevel();
trustProps->setCurrentItem(psize);
slotSetTrustFilter(psize);
slotShowLongId(KGpgSettings::showLongKeyId());
m_popuppub = new KMenu(this);
m_popuppub->addAction(exportPublicKey);
m_popuppub->addAction(m_sendEmail);
m_popuppub->addAction(signMailUid);
m_popuppub->addAction(signKey);
m_popuppub->addAction(signUid);
m_popuppub->addAction(deleteKey);
m_popuppub->addAction(infoKey);
m_popuppub->addAction(openKeyUrl);
m_popuppub->addAction(editKey);
m_popuppub->addAction(refreshKey);
m_popuppub->addAction(createGroup);
m_popuppub->addSeparator();
m_popuppub->addAction(importAllSignKeys);
m_popupsec = new KMenu(this);
m_popupsec->addAction(exportPublicKey);
m_popupsec->addAction(m_sendEmail);
m_popupsec->addAction(signKey);
m_popupsec->addAction(signUid);
m_popupsec->addAction(signMailUid);
m_popupsec->addAction(infoKey);
m_popupsec->addAction(openKeyUrl);
m_popupsec->addAction(editKey);
m_popupsec->addAction(refreshKey);
m_popupsec->addAction(setDefaultKey);
m_popupsec->addSeparator();
m_popupsec->addAction(importAllSignKeys);
m_popupsec->addSeparator();
m_popupsec->addAction(addPhoto);
m_popupsec->addAction(addUid);
m_popupsec->addAction(exportSecretKey);
m_popupsec->addAction(deleteKeyPair);
m_popupgroup = new KMenu(this);
m_popupgroup->addAction(editCurrentGroup);
m_popupgroup->addAction(m_groupRename);
m_popupgroup->addAction(delGroup);
m_popupgroup->addAction(refreshKey);
m_popupout = new KMenu(this);
m_popupout->addAction(importKey);
m_popupsig = new KMenu();
m_popupsig->addAction(importSignatureKey);
m_popupsig->addAction(delSignKey);
m_popupphoto = new KMenu(this);
m_popupphoto->addAction(openPhoto);
m_popupphoto->addAction(signUid);
m_popupphoto->addAction(signMailUid);
m_popupphoto->addAction(deletePhoto);
m_popupuid = new KMenu(this);
m_popupuid->addAction(m_sendEmail);
m_popupuid->addAction(signMailUid);
m_popupuid->addAction(signUid);
m_popupuid->addAction(delUid);
m_popupuid->addAction(setPrimUid);
m_popuporphan = new KMenu(this);
m_popuporphan->addAction(regeneratePublic);
m_popuporphan->addAction(deleteKeyPair);
exportPublicKey->setEnabled(false);
KConfigGroup cg = KConfigGroup(KGlobal::config().data(), "KeyView");
iview->restoreLayout(cg);
connect(photoProps, SIGNAL(triggered(int)), this, SLOT(slotSetPhotoSize(int)));
connect(trustProps, SIGNAL(triggered(int)), this, SLOT(slotSetTrustFilter(int)));
QLabel *searchLabel = new QLabel(i18n("Search:"), this);
m_listviewsearch = new KLineEdit(this);
m_listviewsearch->setClearButtonShown(true);
QWidget *searchWidget = new QWidget(this);
QHBoxLayout *searchLayout = new QHBoxLayout(searchWidget);
searchLayout->setMargin(0);
searchLayout->addWidget(searchLabel);
searchLayout->addWidget(m_listviewsearch);
searchLayout->addStretch();
KAction *searchLineAction = new KAction(i18nc("Name of the action that is a search line, shown for example in the toolbar configuration dialog",
"Search Line"), this);
actionCollection()->addAction(QLatin1String( "search_line" ), searchLineAction);
searchLineAction->setDefaultWidget(searchWidget);
action = actionCollection()->addAction(QLatin1String("search_focus"), m_listviewsearch, SLOT(setFocus()));
action->setText(i18nc("Name of the action that gives the focus to the search line", "Focus Search Line"));
action->setShortcut(QKeySequence(Qt::Key_F6));
connect(m_listviewsearch, SIGNAL(textChanged(QString)), iproxy, SLOT(setFilterFixedString(QString)));
setActionDescriptions(1);
// get all keys data
setupGUI(KXmlGuiWindow::Create | Save | ToolBar | StatusBar | Keys, QLatin1String( "keysmanager.rc" ));
sTrust->setChecked(KGpgSettings::showTrust());
iview->setColumnHidden(2, !KGpgSettings::showTrust());
sSize->setChecked(KGpgSettings::showSize());
iview->setColumnHidden(3, !KGpgSettings::showSize());
sCreat->setChecked(KGpgSettings::showCreat());
iview->setColumnHidden(4, !KGpgSettings::showCreat());
sExpi->setChecked(KGpgSettings::showExpi());
iview->setColumnHidden(5, !KGpgSettings::showExpi());
iproxy->setOnlySecret(KGpgSettings::showSecret());
KStatusBar *statusbar = statusBar();
statusbar->insertPermanentFixedItem(KGpgItemModel::statusCountMessageString(9999, 999), 0);
statusbar->changeItem(QString(), 0);
cg = KConfigGroup(KGlobal::config().data(), "MainWindow");
setAutoSaveSettings(cg, true);
applyMainWindowSettings(cg);
connect(this, SIGNAL(fontChanged(QFont)), s_kgpgEditor, SLOT(slotSetFont(QFont)));
m_netnote = Solid::Networking::notifier();
connect(m_netnote, SIGNAL(shouldConnect()), SLOT(slotNetworkUp()));
connect(m_netnote, SIGNAL(shouldDisconnect()), SLOT(slotNetworkDown()));
toggleNetworkActions(Solid::Networking::status() == Solid::Networking::Unknown || Solid::Networking::status() == Solid::Networking::Connected);
importSignatureKey->setEnabled(false);
stateChanged("empty_list");
QMetaObject::invokeMethod(this, "refreshkey", Qt::QueuedConnection);
}
KeysManager::~KeysManager()
{
}
void KeysManager::slotGenerateKey()
{
if (m_genkey) {
KMessageBox::error(this,
i18n("Another key generation operation is still in progress.\nPlease wait a moment until this operation is complete."),
i18n("Generating new key pair"));
return;
}
QPointer<KgpgKeyGenerate> kg = new KgpgKeyGenerate(this);
if (kg->exec() == QDialog::Accepted) {
if (!kg->isExpertMode()) {
KGpgGenerateKey *genkey = new KGpgGenerateKey(this, kg->name(), kg->email(),
kg->comment(), kg->algo(), kg->size(), kg->days(), kg->expiration(),
kg->caps());
m_genkey = new KGpgTransactionJob(genkey);
connect(m_genkey, SIGNAL(result(KJob*)), SLOT(slotGenerateKeyDone(KJob*)));
KIO::getJobTracker()->registerJob(m_genkey);
m_genkey->start();
QApplication::setOverrideCursor(Qt::BusyCursor);
} else {
KConfigGroup config(KGlobal::config(), "General");
QString terminalApp(config.readPathEntry("TerminalApplication", QLatin1String( "konsole" )));
QStringList args;
args << QLatin1String( "-e" )
<< KGpgSettings::gpgBinaryPath()
<< QLatin1String("--gen-key")
<< QLatin1String("--expert");
QProcess *genKeyProc = new QProcess(this);
genKeyProc->start(terminalApp, args);
if (!genKeyProc->waitForStarted(-1)) {
KMessageBox::error(this, i18n("Generating new key pair"),
i18n("Can not start \"konsole\" application for expert mode."));
} else {
genKeyProc->waitForFinished(-1);
refreshkey();
}
}
}
delete kg;
}
void KeysManager::showKeyManager()
{
show();
}
void KeysManager::slotOpenEditor()
{
KgpgEditor *kgpgtxtedit = new KgpgEditor(this, imodel, Qt::Window);
connect(this, SIGNAL(fontChanged(QFont)), kgpgtxtedit, SLOT(slotSetFont(QFont)));
kgpgtxtedit->show();
}
void KeysManager::changeMessage(const QString &msg, const bool keep)
{
int timeout = keep ? 0 : 10000;
statusBar()->showMessage(msg, timeout);
}
void KeysManager::updateStatusCounter()
{
statusBar()->changeItem(imodel->statusCountMessage(), 0);
}
void KeysManager::slotGenerateKeyDone(KJob *job)
{
changeMessage(i18nc("Application ready for user input", "Ready"));
QApplication::restoreOverrideCursor();
KGpgTransactionJob *tjob = qobject_cast<KGpgTransactionJob *>(job);
const KGpgGenerateKey * const genkey = qobject_cast<const KGpgGenerateKey *>(tjob->getTransaction());
int res = tjob->getResultCode();
const QString infomessage(i18n("Generating new key pair"));
switch (res) {
case KGpgTransaction::TS_BAD_PASSPHRASE:
KMessageBox::error(this, i18n("Bad passphrase. Cannot generate a new key pair."), infomessage);
break;
case KGpgTransaction::TS_USER_ABORTED:
KMessageBox::error(this, i18n("Aborted by the user. Cannot generate a new key pair."), infomessage);
break;
case KGpgTransaction::TS_INVALID_EMAIL:
KMessageBox::error(this, i18n("The email address is not valid. Cannot generate a new key pair."), infomessage);
break;
case KGpgGenerateKey::TS_INVALID_NAME:
KMessageBox::error(this, i18n("The name is not accepted by gpg. Cannot generate a new key pair."), infomessage);
break;
case KGpgTransaction::TS_OK: {
updateStatusCounter();
QPointer<KDialog> keyCreated = new KDialog(this);
keyCreated->setCaption(i18n("New Key Pair Created"));
keyCreated->setButtons(KDialog::Ok);
keyCreated->setDefaultButton(KDialog::Ok);
keyCreated->setModal(true);
newKey *page = new newKey(keyCreated);
page->TLname->setText(QLatin1String( "<b>" ) + genkey->getName() + QLatin1String( "</b>" ));
const QString email(genkey->getEmail());
page->TLemail->setText(QLatin1String( "<b>" ) + email + QLatin1String( "</b>" ));
QString revurl;
const QString gpgPath(KGpgSettings::gpgConfigPath());
if (!gpgPath.isEmpty())
revurl = KUrl::fromPath(gpgPath).directory(KUrl::AppendTrailingSlash);
else
revurl = QDir::homePath() + QLatin1Char( '/' );
if (!email.isEmpty())
page->kURLRequester1->setUrl(QString(revurl + email.section(QLatin1Char( '@' ), 0, 0) + QLatin1String( ".revoke" )));
else
page->kURLRequester1->setUrl(QString(revurl + genkey->getName().section(QLatin1Char(' '), 0, 0) + QLatin1String(".revoke")));
const QString fingerprint(genkey->getFingerprint());
page->TLid->setText(QLatin1String( "<b>" ) + fingerprint.right(8) + QLatin1String( "</b>" ));
page->LEfinger->setText(fingerprint);
page->CBdefault->setChecked(true);
page->show();
keyCreated->setMainWidget(page);
keyCreated->exec();
if (keyCreated.isNull())
return;
imodel->refreshKey(fingerprint);
KGpgKeyNode *knode = imodel->getRootNode()->findKey(fingerprint);
if (page->CBdefault->isChecked())
imodel->setDefaultKey(knode);
iview->selectNode(knode);
if (page->CBsave->isChecked() || page->CBprint->isChecked()) {
KUrl revurl;
if (page->CBsave->isChecked())
revurl = page->kURLRequester1->url();
KGpgGenerateRevoke *genRev = new KGpgGenerateRevoke(this, fingerprint, revurl,
0, i18n("backup copy"));
connect(genRev, SIGNAL(done(int)), SLOT(slotRevokeGenerated(int)));
if (page->CBprint->isChecked())
connect(genRev, SIGNAL(revokeCertificate(QString)), SLOT(doPrint(QString)));
genRev->start();
}
delete keyCreated;
break;
}
default:
KMessageBox::detailedError(this,
i18n("gpg process did not finish. Cannot generate a new key pair."),
genkey->gpgErrorMessage(), infomessage);
}
m_genkey = NULL;
}
void KeysManager::slotShowTrust()
{
bool b = !sTrust->isChecked();
iview->setColumnHidden(KEYCOLUMN_TRUST, b);
if (!b && (iview->columnWidth(KEYCOLUMN_TRUST) == 0))
iview->resizeColumnToContents(KEYCOLUMN_TRUST);
}
void KeysManager::slotShowExpiration()
{
bool b = !sExpi->isChecked();
iview->setColumnHidden(KEYCOLUMN_EXPIR, b);
if (!b && (iview->columnWidth(KEYCOLUMN_EXPIR) == 0))
iview->resizeColumnToContents(KEYCOLUMN_EXPIR);
}
void KeysManager::slotShowSize()
{
bool b = !sSize->isChecked();
iview->setColumnHidden(KEYCOLUMN_SIZE, b);
if (!b && (iview->columnWidth(KEYCOLUMN_SIZE) == 0))
iview->resizeColumnToContents(KEYCOLUMN_SIZE);
}
void KeysManager::slotShowCreation()
{
bool b = !sCreat->isChecked();
iview->setColumnHidden(KEYCOLUMN_CREAT, b);
if (!b && (iview->columnWidth(KEYCOLUMN_CREAT) == 0))
iview->resizeColumnToContents(KEYCOLUMN_CREAT);
}
void KeysManager::slotShowLongId(bool b)
{
iproxy->setIdLength(b ? 16 : 8);
}
void KeysManager::slotSetTrustFilter(int i)
{
KgpgCore::KgpgKeyTrustFlag t;
Q_ASSERT((i >= 0) && (i < 5));
switch (i) {
case 0:
t = TRUST_MINIMUM;
break;
case 1:
t = TRUST_UNDEFINED;
break;
case 2:
t = TRUST_MARGINAL;
break;
case 3:
t = TRUST_FULL;
break;
default:
t = TRUST_ULTIMATE;
}
iproxy->setTrustFilter(t);
}
bool KeysManager::eventFilter(QObject *, QEvent *e)
{
if ((e->type() == QEvent::Show) && (showTipOfDay)) {
KTipDialog::showTip(this, QLatin1String("kgpg/tips"), false);
showTipOfDay = false;
}
return false;
}
void KeysManager::slotGotoDefaultKey()
{
iview->selectNode(imodel->getRootNode()->findKey(KGpgSettings::defaultKey()));
}
void KeysManager::refreshKeyFromServer()
{
QList<KGpgNode *> keysList(iview->selectedNodes());
if (keysList.isEmpty())
return;
QStringList keyIDS;
foreach (KGpgNode *item, keysList) {
if (item->getType() == ITYPE_GROUP)
{
for (int j = 0; j < item->getChildCount(); j++)
keyIDS << item->getChild(j)->getId();
continue;
}
if (item->getType() & ITYPE_PAIR) {
keyIDS << item->getId();
} else {
KMessageBox::sorry(this, i18n("You can only refresh primary keys. Please check your selection."));
return;
}
}
QString proxy;
if (KGpgSettings::useProxy())
proxy = QLatin1String( qgetenv("http_proxy") );
KGpgRefreshKeys *t = new KGpgRefreshKeys(this, KGpgSettings::keyServers().first(), keyIDS, true, proxy);
connect(t, SIGNAL(done(int)), SLOT(slotKeyRefreshDone(int)));
QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
t->start();
}
void KeysManager::slotKeyRefreshDone(int result)
{
KGpgRefreshKeys *t = qobject_cast<KGpgRefreshKeys *>(sender());
Q_ASSERT(t != NULL);
if (result == KGpgTransaction::TS_USER_ABORTED) {
t->deleteLater();
QApplication::restoreOverrideCursor();
return;
}
const QStringList log(t->getLog());
const QStringList keys = KGpgImport::getImportedIds(log, 0xffff);
const QStringList message(KGpgImport::getImportMessage(log));
t->deleteLater();
if (!keys.empty())
imodel->refreshKeys(keys);
QApplication::restoreOverrideCursor();
(void) new KgpgDetailedInfo(this, message.join(QLatin1String("\n")), log.join(QLatin1String("<br/>")),
KGpgImport::getDetailedImportMessage(log, imodel).split(QLatin1Char('\n')));
}
void KeysManager::slotDelUid()
{
KGpgUidNode *nd = iview->selectedNode()->toUidNode();
KGpgDelUid *deluid = new KGpgDelUid(this, nd);
connect(deluid, SIGNAL(done(int)), SLOT(slotDelUidDone(int)));
deluid->start();
}
void KeysManager::slotDelUidDone(int result)
{
KGpgDelUid * const deluid = qobject_cast<KGpgDelUid *>(sender());
Q_ASSERT(deluid != NULL);
sender()->deleteLater();
if (result == KGpgTransaction::TS_OK)
imodel->refreshKey(deluid->getKeyId());
// FIXME: do something useful with result if it is a failure
}
void KeysManager::slotPrimUid()
{
KGpgPrimaryUid *puid = new KGpgPrimaryUid(this, iview->selectedNode()->toUidNode());
connect(puid, SIGNAL(done(int)), SLOT(slotPrimUidDone(int)));
puid->start();
}
void KeysManager::slotPrimUidDone(int result)
{
const QString kid(qobject_cast<KGpgPrimaryUid *>(sender())->getKeyId());
sender()->deleteLater();
if (result == KGpgTransaction::TS_OK)
imodel->refreshKey(kid);
// FIXME: some error reporting
}
void KeysManager::slotregenerate()
{
QString regID = iview->selectedNode()->getId();
KProcess *p1, *p2, *p3;
p1 = new KProcess(this);
*p1 << KGpgSettings::gpgBinaryPath()
<< QLatin1String("--no-secmem-warning")
<< QLatin1String("--export-secret-key")
<< regID;
p1->setOutputChannelMode(KProcess::OnlyStdoutChannel);
p2 = new KProcess(this);
*p2 << QLatin1String("gpgsplit")
<< QLatin1String("--no-split")
<< QLatin1String("--secret-to-public");
p2->setOutputChannelMode(KProcess::OnlyStdoutChannel);
p3 = new KProcess(this);
*p3 << KGpgSettings::gpgBinaryPath()
<< QLatin1String("--import");
p1->setStandardOutputProcess(p2);
p2->setStandardOutputProcess(p3);
p1->start();
p2->start();
p3->start();
p1->waitForFinished();
p2->waitForFinished();
p3->waitForFinished();
delete p1;
delete p2;
delete p3;
imodel->refreshKey(regID);
}
void KeysManager::slotAddUid()
{
if (m_adduid) {
KMessageBox::error(this, i18n("Another operation is still in progress.\nPlease wait a moment until this operation is complete."),
i18n("Add New User Id"));
return;
}
addUidWidget = new KDialog(this );
addUidWidget->setCaption( i18n("Add New User Id") );
addUidWidget->setButtons( KDialog::Ok | KDialog::Cancel );
addUidWidget->setDefaultButton( KDialog::Ok );
addUidWidget->setModal( true );
addUidWidget->enableButtonOk(false);
AddUid *keyUid = new AddUid(addUidWidget);
addUidWidget->setMainWidget(keyUid);
//keyUid->setMinimumSize(keyUid->sizeHint());
keyUid->setMinimumWidth(300);
connect(keyUid->kLineEdit1, SIGNAL(textChanged(QString)), this, SLOT(slotAddUidEnable(QString)));
if (addUidWidget->exec() != QDialog::Accepted)
return;
m_adduid = new KGpgAddUid(this, iview->selectedNode()->getId(), keyUid->kLineEdit1->text(),
keyUid->kLineEdit2->text(), keyUid->kLineEdit3->text());
connect(m_adduid, SIGNAL(done(int)), SLOT(slotAddUidFin(int)));
m_adduid->start();
}
void KeysManager::slotAddUidFin(int res)
{
// TODO error reporting
if (res == 0)
imodel->refreshKey(m_adduid->getKeyid());
m_adduid->deleteLater();
m_adduid = NULL;
}
void KeysManager::slotAddUidEnable(const QString & name)
{
addUidWidget->enableButtonOk(name.length() > 4);
}
void KeysManager::slotAddPhoto()
{
QString mess = i18n("The image must be a JPEG file. Remember that the image is stored within your public key, so "
"if you use a very large picture, your key will become very large as well. The size should not exceed 6 KiB. "
"An image size of around 240x288 is a good size to use.");
if (KMessageBox::warningContinueCancel(0, mess) != KMessageBox::Continue)
return;
QString imagepath = KFileDialog::getOpenFileName(KUrl(), QLatin1String( "image/jpeg" ), 0);
if (imagepath.isEmpty())
return;
KGpgAddPhoto *addphoto = new KGpgAddPhoto(this, iview->selectedNode()->getId(), imagepath);
connect(addphoto, SIGNAL(done(int)), SLOT(slotAddPhotoFinished(int)));
addphoto->start();
}
void KeysManager::slotAddPhotoFinished(int res)
{
sender()->deleteLater();
// TODO : add res == 3 (bad passphrase)
if (res == 0)
slotUpdatePhoto();
}
void KeysManager::slotDeletePhoto()
{
KGpgNode *nd = iview->selectedNode();
KGpgUatNode *und = nd->toUatNode();
KGpgKeyNode *parent = und->getParentKeyNode();
QString mess = i18n("<qt>Are you sure you want to delete Photo id <b>%1</b><br/>from key <b>%2 &lt;%3&gt;</b>?</qt>",
und->getId(), parent->getName(), parent->getEmail());
KGpgDelUid *deluid = new KGpgDelUid(this, und);
connect(deluid, SIGNAL(done(int)), SLOT(slotDelPhotoFinished(int)));
deluid->start();
}
void KeysManager::slotDelPhotoFinished(int res)
{
sender()->deleteLater();
// TODO : add res == 3 (bad passphrase)
if (res == 0) {
KGpgNode *nd = iview->selectedNode();
imodel->refreshKey(nd->getParentKeyNode()->toKeyNode());
}
}
void KeysManager::slotUpdatePhoto()
{
KGpgNode *nd = iview->selectedNode();
imodel->refreshKey(nd->toKeyNode());
}
void KeysManager::slotSetPhotoSize(int size)
{
switch(size) {
case 1:
iproxy->setPreviewSize(22);
break;
case 2:
iproxy->setPreviewSize(42);
break;
case 3:
iproxy->setPreviewSize(65);
break;
default:
iproxy->setPreviewSize(0);
break;
}
}
void KeysManager::addToKAB()
{
KGpgNode *nd = iview->selectedNode();
if (nd == NULL)
return;
Akonadi::ContactSearchJob * const job = new Akonadi::ContactSearchJob();
job->setLimit(1);
job->setQuery(Akonadi::ContactSearchJob::Email, nd->getEmail());
connect(job, SIGNAL(result(KJob*)), this, SLOT(slotAddressbookSearchResult(KJob*)));
m_addIds[job] = nd;
}
void KeysManager::slotAddressbookSearchResult(KJob *job)
{
KGpgNode * const nd = m_addIds.value(job, 0);
if (!nd)
return;
Akonadi::ContactSearchJob *searchJob = qobject_cast<Akonadi::ContactSearchJob*>(job);
Q_ASSERT(searchJob);
const KABC::Addressee::List addresseeList = searchJob->contacts();
m_addIds.take(job);
Akonadi::ContactEditorDialog *dlg;
// KABC::Key key; TODO
if (!addresseeList.isEmpty()) {
dlg = new Akonadi::ContactEditorDialog(Akonadi::ContactEditorDialog::EditMode, this);
dlg->setContact(searchJob->items().first());
} else {
KABC::Addressee addressee;
addressee.setNameFromString(nd->getName());
addressee.setEmails(QStringList(nd->getEmail()));
dlg = new Akonadi::ContactEditorDialog(Akonadi::ContactEditorDialog::CreateMode, this);
dlg->editor()->setContactTemplate(addressee);
}
connect(dlg, SIGNAL(finished()), dlg, SLOT(deleteLater()));
dlg->show();
}
void KeysManager::slotManpage()
{
KToolInvocation::startServiceByDesktopName(QLatin1String("khelpcenter"),
QLatin1String("man:/gpg"), 0, 0, 0, QByteArray(), true);
}
void KeysManager::slotTip()
{
KTipDialog::showTip(this, QLatin1String("kgpg/tips"), true);
}
void KeysManager::showKeyServer()
{
QPointer<KeyServer> ks = new KeyServer(this, imodel);
connect(ks, SIGNAL(importFinished(QStringList)), imodel, SLOT(refreshKeys(QStringList)));
ks->exec();
delete ks;
refreshkey();
}
void KeysManager::checkList()
{
QList<KGpgNode *> exportList = iview->selectedNodes();
switch (exportList.count()) {
case 0:
stateChanged("empty_list");
return;
case 1:
if (exportList.at(0)->getType() == ITYPE_GROUP) {
stateChanged(QLatin1String( "group_selected" ));
} else {
stateChanged(QLatin1String( "single_selected" ));
m_revokeKey->setEnabled(exportList.at(0)->getType() == ITYPE_PAIR);
if (terminalkey)
editKey->setEnabled(false);
m_sendEmail->setEnabled(!exportList[0]->getEmail().isEmpty());
setDefaultKey->setEnabled(!imodel->isDefaultKey(exportList[0]));
}
break;
default:
stateChanged(QLatin1String( "multi_selected" ));
}
if (!m_online)
refreshKey->setEnabled(false);
switch (exportList.at(0)->getType()) {
case ITYPE_PUBLIC:
changeMessage(i18n("Public Key"));
break;
case ITYPE_SUB:
changeMessage(i18n("Sub Key"));
break;
case ITYPE_PAIR:
changeMessage(i18n("Secret Key Pair"));
break;
case ITYPE_GROUP:
changeMessage(i18n("Key Group"));
break;
case ITYPE_SIGN:
changeMessage(i18n("Signature"));
break;
case ITYPE_UID:
changeMessage(i18n("User ID"));
break;
case ITYPE_REVSIGN:
changeMessage(i18n("Revocation Signature"));
break;
case ITYPE_UAT:
changeMessage(i18n("Photo ID"));
break;
case ITYPE_SECRET:
changeMessage(i18n("Orphaned Secret Key"));
break;
case ITYPE_GPUBLIC:
case ITYPE_GSECRET:
case ITYPE_GPAIR:
changeMessage(i18n("Group member"));
break;
default:
kDebug(2100) << "Oops, unmatched type value" << exportList.at(0)->getType();
}
}
void KeysManager::quitApp()
{
// close window
saveToggleOpts();
qApp->quit();
}
void KeysManager::saveToggleOpts(void)
{
KConfigGroup cg = KConfigGroup(KGlobal::config().data(), "KeyView");
iview->saveLayout(cg);
KGpgSettings::setPhotoProperties(photoProps->currentItem());
KGpgSettings::setShowTrust(sTrust->isChecked());
KGpgSettings::setShowExpi(sExpi->isChecked());
KGpgSettings::setShowCreat(sCreat->isChecked());
KGpgSettings::setShowSize(sSize->isChecked());
KGpgSettings::setTrustLevel(trustProps->currentItem());
KGpgSettings::setShowSecret(hPublic->isChecked());
KGpgSettings::setShowLongKeyId(longId->isChecked());
KGpgSettings::self()->writeConfig();
}
void KeysManager::readOptions()
{
m_clipboardmode = QClipboard::Clipboard;
if (KGpgSettings::useMouseSelection() && (kapp->clipboard()->supportsSelection()))
m_clipboardmode = QClipboard::Selection;
if (imodel != NULL)
updateStatusCounter();
showTipOfDay = KGpgSettings::showTipOfDay();
if (KGpgSettings::showSystray()) {
setupTrayIcon();
} else {
delete m_trayicon;
m_trayicon = NULL;
}
}
void KeysManager::showOptions()
{
if (KConfigDialog::showDialog(QLatin1String( "settings" )))
return;
QPointer<kgpgOptions> optionsDialog = new kgpgOptions(this, imodel);
connect(optionsDialog, SIGNAL(settingsUpdated()), SLOT(readAllOptions()));
connect(optionsDialog, SIGNAL(homeChanged()), imodel, SLOT(refreshKeys()));
connect(optionsDialog, SIGNAL(homeChanged()), imodel, SLOT(refreshGroups()));
connect(optionsDialog, SIGNAL(refreshTrust(KgpgCore::KgpgKeyTrust,QColor)), imodel, SLOT(refreshTrust(KgpgCore::KgpgKeyTrust,QColor)));
connect(optionsDialog, SIGNAL(changeFont(QFont)), SIGNAL(fontChanged(QFont)));
optionsDialog->exec();
delete optionsDialog;
s_kgpgEditor->m_recentfiles->setMaxItems(KGpgSettings::recentFiles());
}
void KeysManager::readAllOptions()
{
readOptions();
emit readAgainOptions();
}
void KeysManager::slotSetDefKey()
{
setDefaultKeyNode(iview->selectedNode()->toKeyNode());
}
void KeysManager::slotSetDefaultKey(const QString &newID)
{
KGpgKeyNode *ndef = imodel->getRootNode()->findKey(newID);
if (ndef == NULL) {
KGpgSettings::setDefaultKey(newID);
KGpgSettings::self()->writeConfig();
return;
}
setDefaultKeyNode(ndef);
}
void KeysManager::setDefaultKeyNode(KGpgKeyNode *key)
{
const QString &newID(key->getId());
if (newID == KGpgSettings::defaultKey())
return;
KGpgSettings::setDefaultKey(newID);
KGpgSettings::self()->writeConfig();
imodel->setDefaultKey(key);
}
void
KeysManager::setActionDescriptions(int cnt)
{
signUid->setText(i18np("&Sign User ID ...", "&Sign User IDs ...", cnt));
signMailUid->setText(i18np("Sign and &Mail User ID ...", "Sign and &Mail User IDs ...", cnt));
exportPublicKey->setText(i18np("E&xport Public Key...", "E&xport Public Keys...", cnt));
refreshKey->setText(i18np("&Refresh Key From Keyserver", "&Refresh Keys From Keyserver", cnt));
createGroup->setText(i18np("&Create Group with Selected Key...", "&Create Group with Selected Keys...", cnt));
signKey->setText(i18np("&Sign Key...", "&Sign Keys...", cnt));
delUid->setText(i18np("&Delete User ID", "&Delete User IDs", cnt));
delSignKey->setText(i18np("Delete Sign&ature", "Delete Sign&atures", cnt));
importSignatureKey->setText(i18np("Import Key From Keyserver", "Import Keys From Keyserver", cnt));
deleteKey->setText(i18np("&Delete Key", "&Delete Keys", cnt));
}
void
KeysManager::slotMenu(const QPoint &pos)
{
QPoint globpos = iview->mapToGlobal(pos);
bool sametype;
KgpgItemType itype;
QList<KGpgNode *> ndlist(iview->selectedNodes(&sametype, &itype));
bool unksig = false;
QSet<QString> l;
int cnt = ndlist.count();
// find out if an item has unknown signatures. Only check if the item has been
// expanded before as expansion is very expensive and can take several seconds
// that will freeze the UI meanwhile.
foreach (KGpgNode *nd, ndlist) {
if (!nd->hasChildren())
continue;
KGpgExpandableNode *exnd = nd->toExpandableNode();
if (!exnd->wasExpanded()) {
unksig = true;
break;
}
getMissingSigs(l, exnd);
if (!l.isEmpty()) {
unksig = true;
break;
}
}
importAllSignKeys->setEnabled(unksig && m_online);
signUid->setEnabled(!(itype & ~(ITYPE_PAIR | ITYPE_UID | ITYPE_UAT)));
signMailUid->setEnabled(signUid->isEnabled());
setActionDescriptions(cnt);
if (itype == ITYPE_SIGN) {
bool allunksig = true;
foreach (KGpgNode *nd, ndlist) {
allunksig = nd->toSignNode()->isUnknown();
if (!allunksig)
break;
}
importSignatureKey->setEnabled(allunksig && m_online);
delSignKey->setEnabled( (cnt == 1) );
m_popupsig->exec(globpos);
} else if (itype == ITYPE_UID) {
if (cnt == 1) {
KGpgKeyNode *knd = ndlist.at(0)->toUidNode()->getParentKeyNode();
setPrimUid->setEnabled(knd->getType() & ITYPE_SECRET);
}
m_popupuid->exec(globpos);
} else if ((itype == ITYPE_UAT) && (cnt == 1)) {
m_popupphoto->exec(globpos);
} else if ((itype == ITYPE_PAIR) && (cnt == 1)) {
m_popupsec->exec(globpos);
} else if ((itype == ITYPE_SECRET) && (cnt == 1)) {
m_popuporphan->exec(globpos);
} else if (itype == ITYPE_GROUP) {
delGroup->setEnabled( (cnt == 1) );
editCurrentGroup->setEnabled( (cnt == 1) );
m_groupRename->setEnabled( (cnt == 1) );
m_popupgroup->exec(globpos);
} else if (!(itype & ~(ITYPE_PAIR | ITYPE_GROUP))) {
signKey->setEnabled(!(itype & ITYPE_GROUP));
deleteKey->setEnabled(!(itype & ITYPE_GROUP));
setDefaultKey->setEnabled( (cnt == 1) );
m_popuppub->exec(globpos);
} else if (!(itype & ~(ITYPE_UID | ITYPE_PAIR | ITYPE_UAT))) {
setPrimUid->setEnabled(false);
delUid->setEnabled(false);
m_popupuid->exec(globpos);
} else {
m_popupout->exec(globpos);
}
}
void KeysManager::revokeWidget()
{
KGpgNode *nd = iview->selectedNode();
KDialog *keyRevokeDialog = new KGpgRevokeDialog(this, nd->toKeyNode());
connect(keyRevokeDialog, SIGNAL(finished(int)), SLOT(slotRevokeDialogFinished(int)));
keyRevokeDialog->open();
}
void KeysManager::slotRevokeDialogFinished(int result)
{
sender()->deleteLater();
if (result != QDialog::Accepted)
return;
KGpgRevokeDialog *keyRevokeDialog = qobject_cast<KGpgRevokeDialog *>(sender());
KGpgGenerateRevoke *genRev = new KGpgGenerateRevoke(this, keyRevokeDialog->getId(), keyRevokeDialog->saveUrl(),
keyRevokeDialog->getReason(), keyRevokeDialog->getDescription());
connect(genRev, SIGNAL(done(int)), SLOT(slotRevokeGenerated(int)));
if (keyRevokeDialog->printChecked())
connect(genRev, SIGNAL(revokeCertificate(QString)), SLOT(doPrint(QString)));
if (keyRevokeDialog->importChecked())
connect(genRev, SIGNAL(revokeCertificate(QString)), SLOT(slotImportRevokeTxt(QString)));
genRev->start();
}
void KeysManager::slotRevokeGenerated(int result)
{
KGpgGenerateRevoke *genRev = qobject_cast<KGpgGenerateRevoke *>(sender());
genRev->deleteLater();
switch (result) {
case KGpgTransaction::TS_OK:
case KGpgTransaction::TS_USER_ABORTED:
break;
default:
KMessageBox::detailedSorry(this, i18n("Creation of the revocation certificate failed..."), genRev->getOutput());
break;
}
}
void KeysManager::slotImportRevokeTxt(const QString &revokeText)
{
KGpgImport *import = new KGpgImport(this, revokeText);
connect(import, SIGNAL(done(int)), SLOT(slotImportDone(int)));
import->start();
}
void KeysManager::slotexportsec()
{
// export secret key
const QString warn(i18n("<qt>Secret keys <b>should not</b> be saved in an unsafe place.<br/>"
"If someone else can access this file, encryption with this key will be compromised.<br/>Continue key export?</qt>"));
int result = KMessageBox::warningContinueCancel(this, warn);
if (result != KMessageBox::Continue)
return;
KGpgNode *nd = iview->selectedNode();
QString sname(nd->getEmail().section(QLatin1Char( '@' ), 0, 0).section(QLatin1Char( '.' ), 0, 0));
if (sname.isEmpty())
sname = nd->getName().section(QLatin1Char( ' ' ), 0, 0);
sname.append(QLatin1String( ".asc" ));
sname.prepend(QDir::homePath() + QLatin1Char( '/' ));
KUrl url(KFileDialog::getSaveUrl(sname, i18n( "*.asc|*.asc Files" ), this, i18n("Export PRIVATE KEY As")));
if(!url.isEmpty()) {
KGpgExport *exp = new KGpgExport(this, QStringList(nd->getId()), url.path(), QStringList(QLatin1String( "--armor" )), true);
connect(exp, SIGNAL(done(int)), SLOT(slotExportSecFinished(int)));
exp->start();
}
}
void KeysManager::slotExportSecFinished(int result)
{
KGpgExport *exp = qobject_cast<KGpgExport *>(sender());
Q_ASSERT(exp != NULL);
if (result == KGpgTransaction::TS_OK) {
KMessageBox::information(this,
i18n("<qt>Your <b>private</b> key \"%1\" was successfully exported to<br/>%2.<br/><b>Do not</b> leave it in an insecure place.</qt>",
exp->getKeyIds().first(), exp->getOutputFile()));
} else {
KMessageBox::sorry(this, i18n("Your secret key could not be exported.\nCheck the key."));
}
}
void KeysManager::slotexport()
{
bool same;
KgpgItemType tp;
QList<KGpgNode *> ndlist(iview->selectedNodes(&same, &tp));
if (ndlist.isEmpty())
return;
if (!(tp & ITYPE_PUBLIC) || (tp & ~ITYPE_GPAIR))
return;
QString sname;
if (ndlist.count() == 1) {
sname = ndlist.at(0)->getEmail().section(QLatin1Char( '@' ), 0, 0).section(QLatin1Char( '.' ), 0, 0);
if (sname.isEmpty())
sname = ndlist.at(0)->getName().section(QLatin1Char(' '), 0, 0);
} else
sname = QLatin1String( "keyring" );
QStringList klist;
for (int i = 0; i < ndlist.count(); ++i) {
klist << ndlist.at(i)->getId();
}
sname.append(QLatin1String( ".asc" ));
sname.prepend(QDir::homePath() + QLatin1Char( '/' ));
QStringList serverList(KGpgSettings::keyServers());
serverList.replaceInStrings(QRegExp( QLatin1String( " .*") ), QLatin1String( "" ) ); // Remove kde 3.5 (Default) tag.
if (!serverList.isEmpty()) {
QString defaultServer = serverList.takeFirst();
qSort(serverList);
serverList.prepend(defaultServer);
}
QPointer<KeyExport> page = new KeyExport(this, serverList);
page->newFilename->setUrl(sname);
if (!m_online)
page->checkServer->setEnabled(false);
if (page->exec() == QDialog::Accepted) {
// export to file
QString exportAttr;
if (page->checkAttrAll->isChecked()) {
// nothing
} else if (page->checkAttrPhoto->isChecked()) {
exportAttr = QLatin1String( "no-export-attributes" );
} else {
exportAttr = QLatin1String( "export-minimal" );
}
QStringList expopts;
if (!exportAttr.isEmpty())
expopts << QLatin1String( "--export-options" ) << exportAttr;
if (page->checkServer->isChecked()) {
KeyServer *expServer = new KeyServer(0, imodel);
expServer->slotSetExportAttribute(exportAttr);
expServer->slotSetKeyserver(page->destServer->currentText());
expServer->slotExport(klist);
} else if (page->checkFile->isChecked()) {
const QString expname(page->newFilename->url().path().simplified());
if (!expname.isEmpty()) {
expopts.append(QLatin1String( "--armor" ));
KGpgExport *exp = new KGpgExport(this, klist, expname, expopts);
connect(exp, SIGNAL(done(int)), SLOT(slotExportFinished(int)));
exp->start();
}
} else {
KGpgExport *exp = new KGpgExport(this, klist, expopts);
if (page->checkClipboard->isChecked())
connect(exp, SIGNAL(done(int)), SLOT(slotProcessExportClip(int)));
else
connect(exp, SIGNAL(done(int)), SLOT(slotProcessExportMail(int)));
exp->start();
}
}
delete page;
}
void KeysManager::slotExportFinished(int result)
{
KGpgExport *exp = qobject_cast<KGpgExport *>(sender());
Q_ASSERT(exp != NULL);
if (result == KGpgTransaction::TS_OK) {
KMessageBox::information(this,
i18np("<qt>The public key was successfully exported to<br/>%2</qt>",
"<qt>The %1 public keys were successfully exported to<br/>%2</qt>",
exp->getKeyIds().count(), exp->getOutputFile()));
} else {
KMessageBox::sorry(this, i18n("Your public key could not be exported\nCheck the key."));
}
exp->deleteLater();
}
void KeysManager::slotProcessExportMail(int result)
{
KGpgExport *exp = qobject_cast<KGpgExport *>(sender());
Q_ASSERT(exp != NULL);
// start default Mail application
if (result == KGpgTransaction::TS_OK) {
KToolInvocation::invokeMailer(QString(), QString(), QString(), QString(),QLatin1String( exp->getOutputData() ));
} else {
KMessageBox::sorry(this, i18n("Your public key could not be exported\nCheck the key."));
}
exp->deleteLater();
}
void KeysManager::slotProcessExportClip(int result)
{
KGpgExport *exp = qobject_cast<KGpgExport *>(sender());
Q_ASSERT(exp != NULL);
if (result == KGpgTransaction::TS_OK) {
kapp->clipboard()->setText(QLatin1String( exp->getOutputData() ), m_clipboardmode);
} else {
KMessageBox::sorry(this, i18n("Your public key could not be exported\nCheck the key."));
}
exp->deleteLater();
}
void KeysManager::showKeyInfo(const QString &keyID)
{
KGpgKeyNode *key = imodel->getRootNode()->findKey(keyID);
if (key == NULL)
return;
showProperties(key);
}
void KeysManager::slotShowPhoto()
{
KService::List list(KMimeTypeTrader::self()->query(QLatin1String( "image/jpeg" )));
if (list.isEmpty()) {
KMessageBox::sorry(NULL, i18n("<qt>A viewer for JPEG images is not specified.<br/>Please check your installation.</qt>"),
i18n("Show photo"));
return;
}
KGpgNode *nd = iview->selectedNode();
KGpgUatNode *und = nd->toUatNode();
KGpgKeyNode *parent = und->getParentKeyNode();
KService::Ptr ptr = list.first();
KProcess p;
p << KGpgSettings::gpgBinaryPath()
<< QLatin1String("--no-tty")
<< QLatin1String("--photo-viewer")
<< (ptr->desktopEntryName() + QLatin1String( " %i" ))
<< QLatin1String("--edit-key")
<< parent->getId()
<< QLatin1String("uid")
<< und->getId()
<< QLatin1String("showphoto")
<< QLatin1String("quit");
p.startDetached();
}
void KeysManager::defaultAction(const QModelIndex &index)
{
KGpgNode *nd = iproxy->nodeForIndex(index);
defaultAction(nd);
}
void KeysManager::slotDefaultAction()
{
defaultAction(iview->selectedNode());
}
void KeysManager::defaultAction(KGpgNode *nd)
{
if (nd == NULL)
return;
if (iview->isEditing())
return;
switch (nd->getType()) {
case ITYPE_GROUP:
editGroup();
break;
case ITYPE_UAT:
slotShowPhoto();
break;
case ITYPE_SIGN:
case ITYPE_GPUBLIC:
case ITYPE_GSECRET:
case ITYPE_GPAIR:
iview->selectNode(nd->toRefNode()->getRefNode());
break;
case ITYPE_SECRET:
slotregenerate();
break;
case ITYPE_PAIR:
case ITYPE_PUBLIC:
showProperties(nd);
return;
}
}
void
KeysManager::showProperties(KGpgNode *n)
{
switch (n->getType()) {
case ITYPE_UAT:
return;
case ITYPE_PUBLIC:
case ITYPE_PAIR: {
KGpgKeyNode *k = n->toKeyNode();
QPointer<KgpgKeyInfo> opts = new KgpgKeyInfo(k, imodel, this);
connect(opts, SIGNAL(keyNeedsRefresh(KGpgKeyNode*)), imodel, SLOT(refreshKey(KGpgKeyNode*)));
connect(opts->keychange, SIGNAL(keyNeedsRefresh(KGpgKeyNode*)), imodel, SLOT(refreshKey(KGpgKeyNode*)));
opts->exec();
delete opts;
}
default:
return;
}
}
void KeysManager::keyproperties()
{
KGpgNode *cur = iview->selectedNode();
if (cur == NULL)
return;
KGpgKeyNode *kn;
switch (cur->getType()) {
case ITYPE_SECRET:
case ITYPE_GSECRET:
if (KMessageBox::questionYesNo(this,
i18n("<p>This key is an orphaned secret key (secret key without public key.) It is currently not usable.</p>"
"<p>Would you like to regenerate the public key?</p>"),
QString(), KGuiItem(i18n("Generate")), KGuiItem(i18n("Do Not Generate"))) == KMessageBox::Yes)
slotregenerate();
return;
case ITYPE_PAIR:
case ITYPE_PUBLIC: {
kn = cur->toKeyNode();
break;
}
case ITYPE_GPAIR:
case ITYPE_GPUBLIC: {
kn = cur->toGroupMemberNode()->getRefNode();
break;
}
default:
kDebug(2100) << "Oops, called with invalid item type" << cur->getType();
return;
}
QPointer<KgpgKeyInfo> opts = new KgpgKeyInfo(kn, imodel, this);
connect(opts, SIGNAL(keyNeedsRefresh(KGpgKeyNode*)), imodel, SLOT(refreshKey(KGpgKeyNode*)));
opts->exec();
delete opts;
}
void KeysManager::deleteGroup()
{
KGpgNode *nd = iview->selectedNode();
if (!nd || (nd->getType() != ITYPE_GROUP))
return;
int result = KMessageBox::warningContinueCancel(this, i18n("<qt>Are you sure you want to delete group <b>%1</b> ?</qt>",
nd->getName()), QString(), KGuiItem(i18n("Delete"), QLatin1String("edit-delete")));
if (result != KMessageBox::Continue)
return;
nd->toGroupNode()->remove();
imodel->delNode(nd);
updateStatusCounter();
}
void KeysManager::renameGroup()
{
if (iview->selectionModel()->selectedIndexes().isEmpty())
return;
QModelIndex selectedNodeIndex = iview->selectionModel()->selectedIndexes().first();
iview->edit(selectedNodeIndex);
}
void KeysManager::createNewGroup()
{
QStringList badkeys;
KGpgKeyNode::List keysList;
KgpgItemType tp;
KGpgNode::List ndlist(iview->selectedNodes(NULL, &tp));
if (ndlist.isEmpty())
return;
if (tp & ~ITYPE_PAIR) {
KMessageBox::sorry(this, i18n("<qt>You cannot create a group containing signatures, subkeys or other groups.</qt>"));
return;
}
KgpgKeyTrustFlag mintrust;
if (KGpgSettings::allowUntrustedGroupMembers()) {
mintrust = KgpgCore::TRUST_UNDEFINED;
} else {
mintrust = KgpgCore::TRUST_FULL;
}
foreach (KGpgNode *nd, ndlist) {
if (nd->getTrust() >= mintrust) {
keysList.append(nd->toKeyNode());
} else {
badkeys += i18nc("<Name> (<Email>) ID: <KeyId>", "%1 (%2) ID: %3",
nd->getName(), nd->getEmail(), nd->getId());
}
}
QString groupName(KInputDialog::getText(i18n("Create New Group"),
i18nc("Enter the name of the group you are creating now", "Enter new group name:"),
QString(), 0, this));
if (groupName.isEmpty())
return;
if (!keysList.isEmpty()) {
if (!badkeys.isEmpty())
KMessageBox::informationList(this, i18n("Following keys are not valid or not trusted and will not be added to the group:"), badkeys);
iview->selectNode(imodel->addGroup(groupName, keysList));
updateStatusCounter();
} else {
KMessageBox::sorry(this,
i18n("<qt>No valid or trusted key was selected. The group <b>%1</b> will not be created.</qt>",
groupName));
}
}
void KeysManager::editGroup()
{
KGpgNode *nd = iview->selectedNode();
if (!nd || (nd->getType() != ITYPE_GROUP))
return;
KGpgGroupNode *gnd = nd->toGroupNode();
QPointer<KDialog> dialogGroupEdit = new KDialog(this );
dialogGroupEdit->setCaption( i18n("Group Properties") );
dialogGroupEdit->setButtons( KDialog::Ok | KDialog::Cancel );
dialogGroupEdit->setDefaultButton( KDialog::Ok );
dialogGroupEdit->setModal( true );
QList<KGpgNode *> members(gnd->getChildren());
groupEdit *gEdit = new groupEdit(dialogGroupEdit, &members, imodel);
dialogGroupEdit->setMainWidget(gEdit);
gEdit->show();
if (dialogGroupEdit->exec() == QDialog::Accepted)
imodel->changeGroup(gnd, members);
delete dialogGroupEdit;
}
void KeysManager::signkey()
{
// another sign operation is still running
if (!signList.isEmpty())
return;
KgpgItemType tp;
QList<KGpgNode *> tmplist = iview->selectedNodes(NULL, &tp);
if (tmplist.isEmpty())
return;
if (tp & ~ITYPE_PAIR) {
KMessageBox::sorry(this, i18n("You can only sign primary keys. Please check your selection."));
return;
}
if (tmplist.count() == 1) {
KGpgKeyNode *nd = tmplist.at(0)->toKeyNode();
QString opt;
if (nd->getEmail().isEmpty())
opt = i18n("<qt>You are about to sign key:<br /><br />%1<br />ID: %2<br />Fingerprint: <br /><b>%3</b>.<br /><br />"
"You should check the key fingerprint by phoning or meeting the key owner to be sure that someone "
"is not trying to intercept your communications.</qt>",
nd->getName(), nd->getId().right(8), nd->getBeautifiedFingerprint());
else
opt = i18n("<qt>You are about to sign key:<br /><br />%1 (%2)<br />ID: %3<br />Fingerprint: <br /><b>%4</b>.<br /><br />"
"You should check the key fingerprint by phoning or meeting the key owner to be sure that someone "
"is not trying to intercept your communications.</qt>",
nd->getName(), nd->getEmail(), nd->getId().right(8), nd->getBeautifiedFingerprint());
if (KMessageBox::warningContinueCancel(this, opt) != KMessageBox::Continue) {
return;
}
signList.append(nd);
} else {
QStringList signKeyList;
foreach (KGpgNode *n, tmplist) {
const KGpgKeyNode *nd = n->toKeyNode();
if (nd->getEmail().isEmpty())
signKeyList += i18nc("Name: ID", "%1: %2", nd->getName(), nd->getBeautifiedFingerprint());
else
signKeyList += i18nc("Name (Email): ID", "%1 (%2): %3", nd->getName(), nd->getEmail(), nd->getBeautifiedFingerprint());
signList.append(n->toSignableNode());
}
if (KMessageBox::Continue != KMessageBox::warningContinueCancelList(this,
i18n("<qt>You are about to sign the following keys in one pass.<br/><b>If you have not carefully checked all fingerprints,"
" the security of your communications may be compromised.</b></qt>"),
signKeyList))
return;
}
QPointer<KgpgSelectSecretKey> opts = new KgpgSelectSecretKey(this, imodel, signList.count());
if (opts->exec() != QDialog::Accepted) {
delete opts;
signList.clear();
return;
}
globalkeyID = QString(opts->getKeyID());
const bool localsign = opts->isLocalSign();
const int checklevel = opts->getSignTrust();
bool isterminal = opts->isTerminalSign();
delete opts;
if (isterminal) {
const QString keyid(signList.at(0)->getId());
signList.clear();
signKeyOpenConsole(globalkeyID, keyid, checklevel, localsign);
} else {
keyCount = 0;
m_signuids = false;
signLoop(localsign, checklevel);
}
}
void KeysManager::signuid()
{
// another sign operation is still running
if (!signList.isEmpty())
return;
KgpgItemType tp;
KGpgNode::List tmplist = iview->selectedNodes(NULL, &tp);
if (tmplist.isEmpty())
return;
if (tp & ~(ITYPE_PAIR | ITYPE_UID | ITYPE_UAT)) {
KMessageBox::sorry(this, i18n("You can only sign user ids and photo ids. Please check your selection."));
return;
}
if (tmplist.count() == 1) {
KGpgSignableNode *nd = tmplist.at(0)->toSignableNode();
KGpgKeyNode *pnd;
if (tp & ITYPE_PUBLIC)
pnd = nd->toKeyNode();
else
pnd = nd->getParentKeyNode()->toKeyNode();
QString opt;
if (nd->getEmail().isEmpty())
opt = i18n("<qt>You are about to sign user id:<br /><br />%1<br />ID: %2<br />Fingerprint: <br /><b>%3</b>.<br /><br />"
"You should check the key fingerprint by phoning or meeting the key owner to be sure that someone "
"is not trying to intercept your communications.</qt>", nd->getName(), nd->getId(), pnd->getBeautifiedFingerprint());
else
opt = i18n("<qt>You are about to sign user id:<br /><br />%1 (%2)<br />ID: %3<br />Fingerprint: <br /><b>%4</b>.<br /><br />"
"You should check the key fingerprint by phoning or meeting the key owner to be sure that someone "
"is not trying to intercept your communications.</qt>", nd->getName(), nd->getEmail(), nd->getId(), pnd->getBeautifiedFingerprint());
if (KMessageBox::warningContinueCancel(this, opt) != KMessageBox::Continue) {
return;
}
signList.append(nd);
} else {
QStringList signKeyList;
foreach (KGpgNode *nd, tmplist) {
const KGpgKeyNode *pnd = (nd->getType() & (ITYPE_UID | ITYPE_UAT)) ?
nd->getParentKeyNode()->toKeyNode() : nd->toKeyNode();
if (nd->getEmail().isEmpty())
signKeyList += i18nc("Name: ID", "%1: %2",
nd->getName(), pnd->getBeautifiedFingerprint());
else
signKeyList += i18nc("Name (Email): ID", "%1 (%2): %3",
nd->getName(), nd->getEmail(), pnd->getBeautifiedFingerprint());
signList.append(nd->toSignableNode());
}
if (KMessageBox::warningContinueCancelList(this,
i18n("<qt>You are about to sign the following user ids in one pass.<br/><b>If you have not carefully checked all fingerprints,"
" the security of your communications may be compromised.</b></qt>"),
signKeyList) != KMessageBox::Continue)
return;
}
QPointer<KgpgSelectSecretKey> opts = new KgpgSelectSecretKey(this, imodel, signList.count());
if (opts->exec() != QDialog::Accepted) {
delete opts;
signList.clear();
return;
}
globalkeyID = QString(opts->getKeyID());
const bool localsign = opts->isLocalSign();
const int checklevel = opts->getSignTrust();
bool isterminal = opts->isTerminalSign();
delete opts;
if (isterminal) {
const QString keyid(signList.at(0)->getId());
signList.clear();
signKeyOpenConsole(globalkeyID, keyid, checklevel, localsign);
} else {
keyCount = 0;
m_signuids = true;
signLoop(localsign, checklevel);
}
}
void KeysManager::signLoop(const bool localsign, const int checklevel)
{
Q_ASSERT(keyCount < signList.count());
KGpgSignableNode *nd = signList.at(keyCount);
QString uid;
QString keyid;
const KGpgSignTransactionHelper::carefulCheck cc = static_cast<KGpgSignTransactionHelper::carefulCheck>(checklevel);
KGpgTransaction *sta;
if (m_signuids) {
sta = new KGpgSignUid(this, globalkeyID, nd, localsign, cc);
} else {
sta = new KGpgSignKey(this, globalkeyID, nd->toKeyNode(), localsign, cc);
}
connect(sta, SIGNAL(done(int)), SLOT(signatureResult(int)));
sta->start();
}
void KeysManager::signatureResult(int success)
{
KGpgSignTransactionHelper *ta;
KGpgSignUid *suid = qobject_cast<KGpgSignUid *>(sender());
if (suid != NULL) {
ta = static_cast<KGpgSignTransactionHelper *>(suid);
} else {
ta = static_cast<KGpgSignTransactionHelper *>(static_cast<KGpgSignKey *>(sender()));
}
KGpgKeyNode *nd = const_cast<KGpgKeyNode *>(ta->getKey());
const bool localsign = ta->getLocal();
const int checklevel = ta->getChecking();
const QString signer(ta->getSigner());
sender()->deleteLater();
switch (success) {
case KGpgTransaction::TS_OK:
if (refreshList.indexOf(nd) == -1)
refreshList.append(nd);
break;
case KGpgTransaction::TS_BAD_PASSPHRASE:
KMessageBox::sorry(this, i18n("<qt>Bad passphrase, key <b>%1 (%2)</b> not signed.</qt>",
nd->getName(), nd->getEmail()));
break;
case KGpgSignTransactionHelper::TS_ALREADY_SIGNED:
KMessageBox::sorry(this, i18n("<qt>The key <b>%1 (%2)</b> is already signed.</qt>",
nd->getName(), nd->getEmail()));
break;
default:
if (KMessageBox::questionYesNo(this,
i18n("<qt>Signing key <b>%1</b> with key <b>%2</b> failed.<br />"
"Do you want to try signing the key in console mode?</qt>",
nd->getId(), signer)) == KMessageBox::Yes)
signKeyOpenConsole(signer, nd->getId(), checklevel, localsign);
}
if (++keyCount == signList.count()) {
signList.clear();
imodel->refreshKeys(refreshList);
refreshList.clear();
} else {
signLoop(localsign, checklevel);
}
}
void KeysManager::caff()
{
KgpgItemType tp;
KGpgNode::List tmplist = iview->selectedNodes(NULL, &tp);
KGpgSignableNode::List slist;
if (tmplist.isEmpty())
return;
if (tp & ~(ITYPE_PAIR | ITYPE_UID | ITYPE_UAT)) {
KMessageBox::sorry(this, i18n("You can only sign user ids and photo ids. Please check your selection."));
return;
}
foreach (KGpgNode *nd, tmplist) {
switch (nd->getType()) {
case KgpgCore::ITYPE_PAIR:
case KgpgCore::ITYPE_PUBLIC: {
KGpgKeyNode *knd = qobject_cast<KGpgKeyNode *>(nd);
if (!knd->wasExpanded())
knd->getChildCount();
}
}
slist.append(nd->toSignableNode());
}
QPointer<KgpgSelectSecretKey> opts = new KgpgSelectSecretKey(this, imodel, slist.count(), false, false);
if (opts->exec() != QDialog::Accepted) {
delete opts;
return;
}
KGpgCaff *ca = new KGpgCaff(this, slist, QStringList(opts->getKeyID()), opts->getSignTrust(), KGpgCaff::IgnoreAlreadySigned);
delete opts;
connect(ca, SIGNAL(done()), SLOT(slotCaffDone()));
connect(ca, SIGNAL(aborted()), SLOT(slotCaffDone()));
ca->run();
}
void KeysManager::slotCaffDone()
{
Q_ASSERT(qobject_cast<KGpgCaff *>(sender()) != NULL);
sender()->deleteLater();
}
void KeysManager::signKeyOpenConsole(const QString &signer, const QString &keyid, const int checking, const bool local)
{
KConfigGroup config(KGlobal::config(), "General");
KProcess process;
process << config.readPathEntry("TerminalApplication", QLatin1String("konsole"))
<< QLatin1String("-e")
<< KGpgSettings::gpgBinaryPath()
<< QLatin1String("--no-secmem-warning")
<< QLatin1String("-u") << signer
<< QLatin1String("--default-cert-level")
<< QString(checking);
if (!local)
process << QLatin1String( "--sign-key" ) << keyid;
else
process << QLatin1String( "--lsign-key" ) << keyid;
process.execute();
}
void KeysManager::getMissingSigs(QSet<QString> &missingKeys, const KGpgExpandableNode *nd)
{
foreach (const KGpgNode *ch, nd->getChildren()) {
if (ch->hasChildren()) {
getMissingSigs(missingKeys, ch->toExpandableNode());
continue;
} else if (ch->getType() == ITYPE_SIGN) {
if (ch->toSignNode()->isUnknown())
missingKeys << ch->getId();
}
}
}
void KeysManager::importallsignkey()
{
const QList<KGpgNode *> sel(iview->selectedNodes());
QSet<QString> missingKeys;
if (sel.isEmpty())
return;
foreach (const KGpgNode *nd, sel) {
if (nd->hasChildren()) {
getMissingSigs(missingKeys, nd->toExpandableNode());
} else if (nd->getType() == ITYPE_SIGN) {
const KGpgSignNode *sn = nd->toSignNode();
if (sn->isUnknown())
missingKeys << sn->getId();
}
}
if (missingKeys.isEmpty()) {
KMessageBox::information(this,
i18np("All signatures for this key are already in your keyring",
"All signatures for this keys are already in your keyring", sel.count()));
return;
}
importRemoteKeys(missingKeys.toList());
}
void KeysManager::preimportsignkey()
{
const QList<KGpgNode *> exportList(iview->selectedNodes());
QStringList idlist;
if (exportList.empty())
return;
foreach (const KGpgNode *nd, exportList)
idlist << nd->getId();
importRemoteKeys(idlist);
}
bool KeysManager::importRemoteKey(const QString &keyIDs)
{
return importRemoteKeys(keyIDs.simplified().split(QLatin1Char( ' ' )), false);
}
bool KeysManager::importRemoteKeys(const QStringList &keyIDs, const bool dialog)
{
QStringList kservers(KeyServer::getServerList());
if (kservers.isEmpty())
return false;
KGpgReceiveKeys *proc = new KGpgReceiveKeys(this, kservers.first(), keyIDs, dialog, QLatin1String( qgetenv("http_proxy") ));
connect(proc, SIGNAL(done(int)), SLOT(importRemoteFinished(int)));
proc->start();
return true;
}
void KeysManager::importRemoteFinished(int result)
{
KGpgReceiveKeys *t = qobject_cast<KGpgReceiveKeys *>(sender());
Q_ASSERT(t != NULL);
const QStringList keys(KGpgImport::getImportedIds(t->getLog()));
t->deleteLater();
if (result == KGpgTransaction::TS_OK)
imodel->refreshKeys(keys);
}
void KeysManager::refreshKeys(const QStringList& ids)
{
imodel->refreshKeys(ids);
}
void KeysManager::delsignkey()
{
KGpgNode *nd = iview->selectedNode();
if (nd == NULL)
return;
QString uid;
QString parentKey;
KGpgExpandableNode *parent = nd->getParentKeyNode();
switch (parent->getType()) {
case ITYPE_PAIR:
case ITYPE_PUBLIC:
uid = QLatin1Char( '1' );
parentKey = parent->getId();
break;
case ITYPE_UID:
case ITYPE_UAT:
uid = parent->getId();
parentKey = parent->getParentKeyNode()->getId();
break;
default:
Q_ASSERT(0);
return;
}
const QString signID(nd->getId());
QString signMail(nd->getNameComment());
QString parentMail(parent->getNameComment());
if (!parent->getEmail().isEmpty())
parentMail += QLatin1String( " &lt;" ) + parent->getEmail() + QLatin1String( "&gt;" );
if (!nd->getEmail().isEmpty())
signMail += QLatin1String( " &lt;" ) + nd->getEmail() + QLatin1String( "&gt;" );
if (parentKey == signID) {
KMessageBox::sorry(this, i18n("Edit key manually to delete a self-signature."));
return;
}
QString ask = i18n("<qt>Are you sure you want to delete signature<br /><b>%1</b><br />from user id <b>%2</b><br />of key: <b>%3</b>?</qt>",
signMail, parentMail, parentKey);
if (KMessageBox::questionYesNo(this, ask, QString(), KStandardGuiItem::del(), KStandardGuiItem::cancel()) != KMessageBox::Yes)
return;
KGpgDelSign *delsig = new KGpgDelSign(this, nd->toSignNode());
connect(delsig, SIGNAL(done(int)), SLOT(delsignatureResult(int)));
delsig->start();
}
void KeysManager::delsignatureResult(int success)
{
sender()->deleteLater();
if (success == KGpgTransaction::TS_OK) {
KGpgNode *nd = iview->selectedNode()->getParentKeyNode();
while (!(nd->getType() & ITYPE_PAIR))
nd = nd->getParentKeyNode();
imodel->refreshKey(nd->toKeyNode());
} else {
KMessageBox::sorry(this, i18n("Requested operation was unsuccessful, please edit the key manually."));
}
}
void KeysManager::slotSendEmail()
{
QStringList maillist;
foreach (const KGpgNode *nd, iview->selectedNodes()) {
if (nd->getEmail().isEmpty())
continue;
maillist << QLatin1Char('"') + nd->getName() + QLatin1String("\" <") + nd->getEmail() + QLatin1Char('>');
}
if (maillist.isEmpty())
return;
KToolInvocation::invokeMailer(maillist.join(QLatin1String(", ")), QString());
}
void KeysManager::slotedit()
{
KGpgNode *nd = iview->selectedNode();
Q_ASSERT(nd != NULL);
if (!(nd->getType() & ITYPE_PAIR))
return;
if (terminalkey)
return;
if ((m_delkey != NULL) && m_delkey->keys().contains(nd->toKeyNode()))
return;
KProcess *kp = new KProcess(this);
KConfigGroup config(KGlobal::config(), "General");
*kp << config.readPathEntry("TerminalApplication", QLatin1String("konsole"))
<< QLatin1String("-e")
<< KGpgSettings::gpgBinaryPath()
<< QLatin1String("--no-secmem-warning")
<< QLatin1String("--edit-key")
<< nd->getId()
<< QLatin1String("help");
terminalkey = nd->toKeyNode();
editKey->setEnabled(false);
connect(kp, SIGNAL(finished(int)), SLOT(slotEditDone(int)));
kp->start();
}
void KeysManager::slotEditDone(int exitcode)
{
if (exitcode == 0)
imodel->refreshKey(terminalkey);
terminalkey = NULL;
editKey->setEnabled(true);
}
void KeysManager::doPrint(const QString &txt)
{
QPrinter prt;
//kDebug(2100) << "Printing..." ;
QPointer<QPrintDialog> printDialog = new QPrintDialog(&prt, this);
if (printDialog->exec() == QDialog::Accepted) {
QPainter painter(&prt);
int width = painter.device()->width();
int height = painter.device()->height();
painter.drawText(0, 0, width, height, Qt::AlignLeft|Qt::AlignTop|Qt::TextDontClip, txt);
}
delete printDialog;
}
void KeysManager::removeFromGroups(KGpgKeyNode *node)
{
QStringList groupNames;
foreach (const KGpgGroupNode *gnd, node->getGroups())
groupNames << gnd->getName();
if (groupNames.isEmpty())
return;
const QString ask = i18np("<qt>The key you are deleting is a member of the following key group. Do you want to remove it from this group?</qt>",
"<qt>The key you are deleting is a member of the following key groups. Do you want to remove it from these groups?</qt>",
groupNames.count());
if (KMessageBox::questionYesNoList(this, ask, groupNames, i18n("Delete key")) != KMessageBox::Yes)
return;
bool groupDeleted = false;
foreach (KGpgGroupMemberNode *gref, node->getGroupRefs()) {
KGpgGroupNode *group = gref->getParentKeyNode();
bool deleteWholeGroup = (group->getChildCount() == 1) &&
(group->getChild(0)->toGroupMemberNode() == gref);
if (deleteWholeGroup)
deleteWholeGroup = (KMessageBox::questionYesNo(this,
i18n("You are removing the last key from key group %1.<br/>Do you want to delete the group, too?", group->getName()),
i18n("Delete key")) == KMessageBox::Yes);
if (!deleteWholeGroup) {
imodel->deleteFromGroup(group, gref);
} else {
group->remove();
imodel->delNode(group);
groupDeleted = true;
}
}
if (groupDeleted) {
updateStatusCounter();
}
}
void KeysManager::deleteseckey()
{
KGpgKeyNode *nd = iview->selectedNode()->toKeyNode();
Q_ASSERT(nd != NULL);
// delete a key
int result = KMessageBox::warningContinueCancel(this,
i18n("<p>Delete <b>secret</b> key pair <b>%1</b>?</p>Deleting this key pair means you will never be able to decrypt files encrypted with this key again.",
nd->getNameComment()),
QString(),
KGuiItem(i18n("Delete"), QLatin1String( "edit-delete" )));
if (result != KMessageBox::Continue)
return;
if (terminalkey == nd)
return;
if (m_delkey != NULL) {
KMessageBox::error(this,
i18n("Another key delete operation is still in progress.\nPlease wait a moment until this operation is complete."),
i18n("Delete key"));
return;
}
removeFromGroups(nd);
m_delkey = new KGpgDelKey(this, nd);
connect(m_delkey, SIGNAL(done(int)), SLOT(secretKeyDeleted(int)));
m_delkey->start();
}
void KeysManager::secretKeyDeleted(int retcode)
{
KGpgKeyNode *delkey = m_delkey->keys().first();
if (retcode == 0) {
KMessageBox::information(this, i18n("Key <b>%1</b> deleted.", delkey->getBeautifiedFingerprint()), i18n("Delete key"));
imodel->delNode(delkey);
} else {
KMessageBox::error(this, i18n("Deleting key <b>%1</b> failed.", delkey->getBeautifiedFingerprint()), i18n("Delete key"));
}
m_delkey->deleteLater();
m_delkey = NULL;
}
void KeysManager::confirmdeletekey()
{
if (m_delkey) {
KMessageBox::error(this,
i18n("Another key delete operation is still in progress.\nPlease wait a moment until this operation is complete."),
i18n("Delete key"));
return;
}
KgpgCore::KgpgItemType pt;
bool same;
QList<KGpgNode *> ndlist(iview->selectedNodes(&same, &pt));
if (ndlist.isEmpty())
return;
// do not delete a key currently edited in terminal
if ((!(pt & ~ITYPE_PAIR)) && (ndlist.at(0) == terminalkey) && (ndlist.count() == 1)) {
KMessageBox::error(this,
i18n("Can not delete key <b>%1</b> while it is edited in terminal.",
terminalkey->getBeautifiedFingerprint()), i18n("Delete key"));
return;
} else if (pt == ITYPE_GROUP) {
deleteGroup();
return;
} else if (!(pt & ITYPE_GROUP) && (pt & ITYPE_SECRET) && (ndlist.count() == 1)) {
deleteseckey();
return;
} else if ((pt == ITYPE_UID) && (ndlist.count() == 1)) {
slotDelUid();
return;
} else if ((pt & ITYPE_GROUP) && !(pt & ~ITYPE_GPAIR)) {
bool invalidDelete = false;
foreach (const KGpgNode *nd, ndlist)
if (nd->getType() == ITYPE_GROUP) {
invalidDelete = true;
break;
}
// only allow removing group members if they belong to the same group
if (!invalidDelete) {
const KGpgNode * const group = ndlist.first()->getParentKeyNode();
foreach (const KGpgNode *nd, ndlist)
if (nd->getParentKeyNode() != group) {
invalidDelete = true;
break;
}
}
if (!invalidDelete) {
KGpgGroupNode *gnd = ndlist.first()->getParentKeyNode()->toGroupNode();
QList<KGpgNode *> members = gnd->getChildren();
foreach (KGpgNode *nd, ndlist) {
int r = members.removeAll(nd);
Q_ASSERT(r == 1);
Q_UNUSED(r);
}
imodel->changeGroup(gnd, members);
return;
}
}
if (pt & ~ITYPE_PAIR) {
KMessageBox::error(this,
i18n("You have selected items that are not keys. They can not be deleted with this menu entry."),
i18n("Delete key"));
return;
}
QStringList keysToDelete;
QStringList deleteIds;
QStringList secList;
KGpgKeyNode::List delkeys;
bool secretKeyInside = (pt & ITYPE_SECRET);
foreach (KGpgNode *nd, ndlist) {
KGpgKeyNode *ki = nd->toKeyNode();
if (ki->getType() & ITYPE_SECRET) {
secList += ki->getNameComment();
} else if (ki != terminalkey) {
keysToDelete += ki->getNameComment();
deleteIds << ki->getId();
delkeys << ki;
}
}
if (secretKeyInside) {
int result = KMessageBox::warningContinueCancel(this,
i18n("<qt>The following are secret key pairs:<br/><b>%1</b><br/>They will not be deleted.</qt>",
secList.join( QLatin1String( "<br />" ))));
if (result != KMessageBox::Continue)
return;
}
if (keysToDelete.isEmpty())
return;
int result = KMessageBox::warningContinueCancelList(this,
i18np("<qt><b>Delete the following public key?</b></qt>",
"<qt><b>Delete the following %1 public keys?</b></qt>",
keysToDelete.count()), keysToDelete, QString(),
KStandardGuiItem::del());
if (result != KMessageBox::Continue)
return;
foreach (KGpgNode *nd, ndlist)
removeFromGroups(nd->toKeyNode());
m_delkey = new KGpgDelKey(this, delkeys);
connect(m_delkey, SIGNAL(done(int)), SLOT(slotDelKeyDone(int)));
m_delkey->start();
}
void KeysManager::slotDelKeyDone(int res)
{
if (res == 0) {
foreach (KGpgKeyNode *kn, m_delkey->keys())
imodel->delNode(kn);
}
m_delkey->deleteLater();
m_delkey = NULL;
updateStatusCounter();
}
void KeysManager::slotPreImportKey()
{
QPointer<KDialog> dial = new KDialog(this);
dial->setCaption(i18n("Key Import"));
dial->setButtons(KDialog::Ok | KDialog::Cancel);
dial->setDefaultButton(KDialog::Ok);
dial->setModal(true);
SrcSelect *page = new SrcSelect();
dial->setMainWidget(page);
page->newFilename->setWindowTitle(i18n("Open File"));
page->newFilename->setMode(KFile::File);
if (dial->exec() == QDialog::Accepted) {
if (page->checkFile->isChecked()) {
KUrl impname = page->newFilename->url();
if (!impname.isEmpty())
slotImport(KUrl::List(impname));
} else if (page->checkServer->isChecked()) {
const QString ids(page->keyIds->text().simplified());
if (!ids.isEmpty())
importRemoteKeys(ids.split(QLatin1Char( ' ' )));
} else {
slotImport(kapp->clipboard()->text(m_clipboardmode));
}
}
delete dial;
}
void KeysManager::slotImport(const QString &text)
{
if (text.isEmpty())
return;
KGpgImport *imp;
if (!KGpgImport::isKey(text) && KGpgDecrypt::isEncryptedText(text)) {
if (KMessageBox::questionYesNo(this,
i18n("<qt>The text in the clipboard does not look like a key, but like encrypted text.<br />Do you want to decrypt it first"
" and then try importing it?</qt>"),
i18n("Import from Clipboard")) != KMessageBox::Yes)
return;
imp = new KGpgImport(this);
KGpgDecrypt *decr = new KGpgDecrypt(this, text);
imp->setInputTransaction(decr);
} else {
imp = new KGpgImport(this, text);
}
startImport(imp);
}
void KeysManager::slotImport(const KUrl::List &files)
{
startImport(new KGpgImport(this, files));
}
void KeysManager::startImport(KGpgImport *import)
{
changeMessage(i18n("Importing..."), true);
connect(import, SIGNAL(done(int)), SLOT(slotImportDone(int)));
import->start();
}
void KeysManager::slotImportDone(int result)
{
KGpgImport *import = qobject_cast<KGpgImport *>(sender());
Q_ASSERT(import != NULL);
const QStringList rawmsgs(import->getMessages());
if (result != 0) {
KMessageBox::detailedSorry(this, i18n("Key importing failed. Please see the detailed log for more information."),
rawmsgs.join(QLatin1String("\n")) , i18n("Key Import"));
}
QStringList keys(import->getImportedIds(0x1f));
const bool needsRefresh = !keys.isEmpty();
keys << import->getImportedIds(0);
if (!keys.isEmpty()) {
const QString msg(import->getImportMessage());
const QStringList keynames(import->getImportedKeys());
new KgpgDetailedInfo(this, msg, rawmsgs.join(QLatin1String("\n")), keynames, i18n("Key Import"));
if (needsRefresh)
imodel->refreshKeys(keys);
else
changeMessage(i18nc("Application ready for user input", "Ready"));
} else{
changeMessage(i18nc("Application ready for user input", "Ready"));
}
import->deleteLater();
}
void KeysManager::refreshkey()
{
imodel->refreshKeys();
updateStatusCounter();
}
KGpgItemModel *KeysManager::getModel()
{
return imodel;
}
void
KeysManager::slotNetworkUp()
{
toggleNetworkActions(true);
}
void
KeysManager::slotNetworkDown()
{
toggleNetworkActions(false);
}
void
KeysManager::toggleNetworkActions(bool online)
{
m_online = online;
kserver->setEnabled(online);
importSignatureKey->setEnabled(online);
importAllSignKeys->setEnabled(online);
refreshKey->setEnabled(online);
}
void
KeysManager::setupTrayIcon()
{
bool newtray = (m_trayicon == NULL);
if (newtray) {
m_trayicon = new KStatusNotifierItem(this);
m_trayicon->setIconByName(QLatin1String( "kgpg" ));
m_trayicon->setToolTip(QLatin1String( "kgpg" ), i18n("KGpg - encryption tool"), QString());
}
switch (KGpgSettings::leftClick()) {
case KGpgSettings::EnumLeftClick::Editor:
m_trayicon->setAssociatedWidget(s_kgpgEditor);
break;
case KGpgSettings::EnumLeftClick::KeyManager:
m_trayicon->setAssociatedWidget(this);
break;
}
m_trayicon->setCategory(KStatusNotifierItem::ApplicationStatus);
if (!newtray)
return;
KMenu *conf_menu = m_trayicon->contextMenu();
QAction *KgpgOpenManager = actionCollection()->addAction(QLatin1String("kgpg_manager"), this, SLOT(show()));
KgpgOpenManager->setIcon(KIcon( QLatin1String( "kgpg" )));
KgpgOpenManager->setText(i18n("Ke&y Manager"));
QAction *KgpgEncryptClipboard = actionCollection()->addAction(QLatin1String("clip_encrypt"), this, SLOT(clipEncrypt()));
KgpgEncryptClipboard->setText(i18n("&Encrypt Clipboard"));
QAction *KgpgDecryptClipboard = actionCollection()->addAction(QLatin1String("clip_decrypt"), this, SLOT(clipDecrypt()));
KgpgDecryptClipboard->setText(i18n("&Decrypt Clipboard"));
QAction *KgpgSignClipboard = actionCollection()->addAction(QLatin1String("clip_sign"), this, SLOT(clipSign()));
KgpgSignClipboard->setText(i18n("&Sign/Verify Clipboard"));
KgpgSignClipboard->setIcon(KIcon( QLatin1String( "document-sign-key" )));
QAction *KgpgPreferences = KStandardAction::preferences(this, SLOT(showOptions()), actionCollection());
conf_menu->addAction( KgpgEncryptClipboard );
conf_menu->addAction( KgpgDecryptClipboard );
conf_menu->addAction( KgpgSignClipboard );
conf_menu->addAction( KgpgOpenManager );
conf_menu->addAction( openEditor );
conf_menu->addAction( kserver );
conf_menu->addSeparator();
conf_menu->addAction( KgpgPreferences );
}
void
KeysManager::showTrayMessage(const QString &message)
{
if (m_trayicon == NULL)
return;
m_trayicon->showMessage(QString(), message, QLatin1String( "kgpg" ));
}
KShortcut
KeysManager::goDefaultShortcut() const
{
return goToDefaultKey->shortcut();
}
void
KeysManager::clipEncrypt()
{
const QString cliptext(kapp->clipboard()->text(m_clipboardmode));
if (cliptext.isEmpty()) {
Q_ASSERT(m_trayicon != NULL);
m_trayicon->showMessage(QString(), i18n("Clipboard is empty."), QLatin1String( "kgpg" ));
return;
}
QPointer<KgpgSelectPublicKeyDlg> dialog = new KgpgSelectPublicKeyDlg(this, imodel, goToDefaultKey->shortcut(), true);
if (dialog->exec() == KDialog::Accepted) {
KGpgEncrypt::EncryptOptions encOptions = KGpgEncrypt::AsciiArmored;
QStringList options;
if (!dialog->getCustomOptions().isEmpty() && KGpgSettings::allowCustomEncryptionOptions())
options = dialog->getCustomOptions().split(QLatin1Char(' '), QString::SkipEmptyParts);
if (dialog->getUntrusted())
encOptions |= KGpgEncrypt::AllowUntrustedEncryption;
if (dialog->getHideId())
encOptions |= KGpgEncrypt::HideKeyId;
if (KGpgSettings::pgpCompatibility())
options.append(QLatin1String( "--pgp6" ));
KGpgEncrypt *enc = new KGpgEncrypt(this, dialog->selectedKeys(), cliptext, encOptions, options);
connect(enc, SIGNAL(done(int)), SLOT(slotSetClip(int)));
m_trayicon->setStatus(KStatusNotifierItem::Active);
enc->start();
}
delete dialog;
}
void
KeysManager::slotSetClip(int result)
{
KGpgEncrypt *enc = qobject_cast<KGpgEncrypt *>(sender());
Q_ASSERT(enc != NULL);
sender()->deleteLater();
m_trayicon->setStatus(KStatusNotifierItem::Passive);
if (result != KGpgTransaction::TS_OK)
return;
kapp->clipboard()->setText(enc->encryptedText().join(QLatin1String("\n")), m_clipboardmode);
Q_ASSERT(m_trayicon != NULL);
m_trayicon->showMessage(QString(), i18n("Text successfully encrypted."), QLatin1String( "kgpg" ));
}
void
KeysManager::slotOpenKeyUrl()
{
KGpgNode *cur = iview->selectedNode();
if (cur == NULL)
return;
QString id;
switch (cur->getType()) {
case ITYPE_PAIR:
case ITYPE_PUBLIC: {
id = cur->toKeyNode()->getFingerprint();
break;
}
case ITYPE_GPAIR:
case ITYPE_GPUBLIC: {
id = cur->getId();
break;
}
default:
return;
}
const QStringList servers = KGpgSettings::infoServers();
if (servers.isEmpty())
return;
QString url = servers.first();
url.replace(QLatin1String("$$ID8$$"), id.right(8).toUpper());
url.replace(QLatin1String("$$ID16$$"), id.toUpper());
url.replace(QLatin1String("$$FPR$$"), id.toUpper());
url.replace(QLatin1String("$$id8$$"), id.right(8).toLower());
url.replace(QLatin1String("$$id16$$"), id.toLower());
url.replace(QLatin1String("$$fpr$$"), id.toLower());
new KRun(url, this);
}
void
KeysManager::clipDecrypt()
{
const QString cliptext(kapp->clipboard()->text(m_clipboardmode).trimmed());
if (cliptext.isEmpty()) {
Q_ASSERT(m_trayicon != NULL);
m_trayicon->showMessage(QString(), i18n("Clipboard is empty."), QLatin1String( "kgpg" ));
return;
}
KgpgEditor *kgpgtxtedit = new KgpgEditor(this, imodel, 0);
kgpgtxtedit->setAttribute(Qt::WA_DeleteOnClose);
connect(this, SIGNAL(fontChanged(QFont)), kgpgtxtedit, SLOT(slotSetFont(QFont)));
kgpgtxtedit->m_editor->setPlainText(cliptext);
kgpgtxtedit->m_editor->slotDecode();
kgpgtxtedit->show();
}
void
KeysManager::clipSign()
{
QString cliptext = kapp->clipboard()->text(m_clipboardmode);
if (cliptext.isEmpty()) {
Q_ASSERT(m_trayicon != NULL);
m_trayicon->showMessage(QString(), i18n("Clipboard is empty."), QLatin1String( "kgpg" ));
return;
}
KgpgEditor *kgpgtxtedit = new KgpgEditor(this, imodel, 0);
kgpgtxtedit->setAttribute(Qt::WA_DeleteOnClose);
connect(kgpgtxtedit->m_editor, SIGNAL(verifyFinished()), kgpgtxtedit, SLOT(closeWindow()));
kgpgtxtedit->m_editor->signVerifyText(cliptext);
kgpgtxtedit->show();
}
#include "keysmanager.moc"
Reference in a new issue View git blame Copy permalink