KeeShare code formatting and spelling correction

src/CMakeLists.txt

@@ -202,7 +202,7 @@ add_feature_info(Auto-Type WITH_XC_AUTOTYPE "Automatic password typing")
 add_feature_info(Networking WITH_XC_NETWORKING "Compile KeePassXC with network access code (e.g. for downloading website icons)")
 add_feature_info(KeePassXC-Browser WITH_XC_BROWSER "Browser integration with KeePassXC-Browser")
 add_feature_info(SSHAgent WITH_XC_SSHAGENT "SSH agent integration compatible with KeeAgent")
-add_feature_info(KeeSharee WITH_XC_KEESHARE "Sharing integration with KeeShare")
+add_feature_info(KeeShare WITH_XC_KEESHARE "Sharing integration with KeeShare")
 add_feature_info(KeeShare-Secure WITH_XC_KEESHARE_SECURE "Sharing integration with KeeShare with secure sources")
 add_feature_info(YubiKey WITH_XC_YUBIKEY "YubiKey HMAC-SHA1 challenge-response")
 if(APPLE)

src/keeshare/DatabaseSettingsWidgetKeeShare.cpp

@@ -45,8 +45,8 @@ void DatabaseSettingsWidgetKeeShare::loadSettings(QSharedPointer<Database> db)
 
     m_referencesModel.reset(new QStandardItemModel());
 
-    m_referencesModel->setHorizontalHeaderLabels(
+    m_referencesModel->setHorizontalHeaderLabels(QStringList() << tr("Breadcrumb") << tr("Type") << tr("Path")
-        QStringList() << tr("Breadcrumb") << tr("Type") << tr("Path") << tr("Last Signer") << tr("Certificates"));
+                                                               << tr("Last Signer") << tr("Certificates"));
     const QList<Group*> groups = db->rootGroup()->groupsRecursive(true);
     for (const Group* group : groups) {
         if (!KeeShare::isShared(group)) {

src/keeshare/KeeShare.cpp

@@ -32,11 +32,11 @@
 
 namespace
 {
-static const QString KeeShare_Reference("KeeShare/Reference");
+    static const QString KeeShare_Reference("KeeShare/Reference");
-static const QString KeeShare_Own("KeeShare/Settings.own");
+    static const QString KeeShare_Own("KeeShare/Settings.own");
-static const QString KeeShare_Foreign("KeeShare/Settings.foreign");
+    static const QString KeeShare_Foreign("KeeShare/Settings.foreign");
-static const QString KeeShare_Active("KeeShare/Settings.active");
+    static const QString KeeShare_Active("KeeShare/Settings.active");
-}
+} // namespace
 
 KeeShare* KeeShare::m_instance = nullptr;
 
@@ -129,12 +129,12 @@ bool KeeShare::isEnabled(const Group* group)
 {
     const auto reference = KeeShare::referenceOf(group);
 #if !defined(WITH_XC_KEESHARE_SECURE)
-    if (reference.path.endsWith(signedContainerFileType(), Qt::CaseInsensitive)){
+    if (reference.path.endsWith(signedContainerFileType(), Qt::CaseInsensitive)) {
         return false;
     }
 #endif
 #if !defined(WITH_XC_KEESHARE_INSECURE)
-    if (reference.path.endsWith(unsignedContainerFileType(), Qt::CaseInsensitive)){
+    if (reference.path.endsWith(unsignedContainerFileType(), Qt::CaseInsensitive)) {
         return false;
     }
 #endif
@@ -198,13 +198,13 @@ void KeeShare::connectDatabase(QSharedPointer<Database> newDb, QSharedPointer<Da
     }
 }
 
-const QString &KeeShare::signedContainerFileType()
+const QString& KeeShare::signedContainerFileType()
 {
     static const QString filetype("kdbx.share");
     return filetype;
 }
 
-const QString &KeeShare::unsignedContainerFileType()
+const QString& KeeShare::unsignedContainerFileType()
 {
     static const QString filetype("kdbx");
     return filetype;

src/keeshare/KeeShare.h

@@ -32,7 +32,7 @@ class QXmlStreamReader;
 
 class KeeShare : public QObject
 {
-Q_OBJECT
+    Q_OBJECT
 public:
     static KeeShare* instance();
     static void init(QObject* parent);
@@ -41,7 +41,7 @@ public:
     static QPixmap indicatorBadge(const Group* group, QPixmap pixmap);
 
     static bool isShared(const Group* group);
-    static bool isEnabled(const Group *group);
+    static bool isEnabled(const Group* group);
 
     static KeeShareSettings::Own own();
     static KeeShareSettings::Active active();

src/keeshare/KeeShareSettings.cpp

@@ -97,7 +97,7 @@ namespace KeeShareSettings
             }
             specific(reader);
         }
-    }
+    } // namespace
 
     void Certificate::serialize(QXmlStreamWriter& writer, const Certificate& certificate)
     {
@@ -295,12 +295,12 @@ namespace KeeShareSettings
         return own;
     }
 
-    bool ScopedCertificate::operator==(const ScopedCertificate &other) const
+    bool ScopedCertificate::operator==(const ScopedCertificate& other) const
     {
         return trust == other.trust && path == other.path && certificate == other.certificate;
     }
 
-    bool ScopedCertificate::operator!=(const ScopedCertificate &other) const
+    bool ScopedCertificate::operator!=(const ScopedCertificate& other) const
     {
         return !operator==(other);
     }
@@ -309,26 +309,26 @@ namespace KeeShareSettings
     {
         writer.writeAttribute("Path", scopedCertificate.path);
         QString trust = "Ask";
-        if(scopedCertificate.trust == KeeShareSettings::Trust::Trusted) {
+        if (scopedCertificate.trust == KeeShareSettings::Trust::Trusted) {
             trust = "Trusted";
         }
-        if(scopedCertificate.trust == KeeShareSettings::Trust::Untrusted){
+        if (scopedCertificate.trust == KeeShareSettings::Trust::Untrusted) {
             trust = "Untrusted";
         }
         writer.writeAttribute("Trust", trust);
         Certificate::serialize(writer, scopedCertificate.certificate);
     }
 
-    ScopedCertificate ScopedCertificate::deserialize(QXmlStreamReader &reader)
+    ScopedCertificate ScopedCertificate::deserialize(QXmlStreamReader& reader)
     {
         ScopedCertificate scopedCertificate;
         scopedCertificate.path = reader.attributes().value("Path").toString();
         scopedCertificate.trust = KeeShareSettings::Trust::Ask;
         auto trust = reader.attributes().value("Trust").toString();
-        if(trust.compare("Trusted", Qt::CaseInsensitive) == 0) {
+        if (trust.compare("Trusted", Qt::CaseInsensitive) == 0) {
             scopedCertificate.trust = KeeShareSettings::Trust::Trusted;
         }
-        if(trust.compare("Untrusted", Qt::CaseInsensitive) == 0) {
+        if (trust.compare("Untrusted", Qt::CaseInsensitive) == 0) {
             scopedCertificate.trust = KeeShareSettings::Trust::Untrusted;
         }
         scopedCertificate.certificate = Certificate::deserialize(reader);
@@ -494,4 +494,4 @@ namespace KeeShareSettings
         });
         return sign;
     }
-}
+} // namespace KeeShareSettings

src/keeshare/KeeShareSettings.h

@@ -99,7 +99,8 @@ namespace KeeShareSettings
         static Own generate();
     };
 
-    enum class Trust {
+    enum class Trust
+    {
         Ask,
         Untrusted,
         Trusted
@@ -113,8 +114,14 @@ namespace KeeShareSettings
         bool operator==(const ScopedCertificate& other) const;
         bool operator!=(const ScopedCertificate& other) const;
 
-        bool isUnknown() const { return certificate.isNull(); }
+        bool isUnknown() const
-        bool isKnown() const { return !certificate.isNull(); }
+        {
+            return certificate.isNull();
+        }
+        bool isKnown() const
+        {
+            return !certificate.isNull();
+        }
 
         static void serialize(QXmlStreamWriter& writer, const ScopedCertificate& certificate);
         static ScopedCertificate deserialize(QXmlStreamReader& reader);
@@ -169,6 +176,6 @@ namespace KeeShareSettings
         static QString serialize(const Reference& reference);
         static Reference deserialize(const QString& raw);
     };
-};
+}; // namespace KeeShareSettings
 
 #endif // KEEPASSXC_KEESHARESETTINGS_H

src/keeshare/SettingsWidgetKeeShare.cpp

@@ -70,21 +70,25 @@ void SettingsWidgetKeeShare::loadSettings()
 
 void SettingsWidgetKeeShare::updateForeignCertificates()
 {
-	 m_importedCertificateModel.reset(new QStandardItemModel());
+    auto headers = QStringList() << tr("Path") << tr("Status");
-	 m_importedCertificateModel->setHorizontalHeaderLabels(QStringList() << tr("Path") << tr("Status")
 #if defined(WITH_XC_KEESHARE_SECURE)
-																			 << tr("Signer") << tr("Fingerprint") << tr("Certificate")
+    headers << tr("Signer") << tr("Fingerprint") << tr("Certificate");
 #endif
-																			 );
+
+    m_importedCertificateModel.reset(new QStandardItemModel());
+    m_importedCertificateModel->setHorizontalHeaderLabels(headers);
 
     for (const auto& scopedCertificate : m_foreign.certificates) {
         const auto items = QList<QStandardItem*>()
                            << new QStandardItem(scopedCertificate.path)
-				<< new QStandardItem(scopedCertificate.trust == KeeShareSettings::Trust::Ask ? tr("Ask")
+                           << new QStandardItem(scopedCertificate.trust == KeeShareSettings::Trust::Ask
-																													  : (scopedCertificate.trust == KeeShareSettings::Trust::Trusted ? tr("Trusted")
+                                                    ? tr("Ask")
+                                                    : (scopedCertificate.trust == KeeShareSettings::Trust::Trusted
+                                                           ? tr("Trusted")
                                                            : tr("Untrusted")))
 #if defined(WITH_XC_KEESHARE_SECURE)
-				<< new QStandardItem(scopedCertificate.isKnown() ? scopedCertificate.certificate.signer : tr("Unknown"))
+                           << new QStandardItem(scopedCertificate.isKnown() ? scopedCertificate.certificate.signer
+                                                                            : tr("Unknown"))
                            << new QStandardItem(scopedCertificate.certificate.fingerprint())
                            << new QStandardItem(scopedCertificate.certificate.publicKey())
 #endif
@@ -93,6 +97,7 @@ void SettingsWidgetKeeShare::updateForeignCertificates()
     }
 
     m_ui->importedCertificateTableView->setModel(m_importedCertificateModel.data());
+    m_ui->importedCertificateTableView->resizeColumnsToContents();
 }
 
 void SettingsWidgetKeeShare::updateOwnCertificate()
@@ -140,7 +145,8 @@ void SettingsWidgetKeeShare::importCertificate()
     }
     const auto filetype = tr("key.share", "Filetype for KeeShare key");
     const auto filters = QString("%1 (*." + filetype + ");;%2 (*)").arg(tr("KeeShare key file"), tr("All files"));
-	 QString filename = fileDialog()->getOpenFileName(this, tr("Select path"), defaultDirPath, filters, nullptr, QFileDialog::Options(0));
+    QString filename = fileDialog()->getOpenFileName(
+        this, tr("Select path"), defaultDirPath, filters, nullptr, QFileDialog::Options(0));
     if (filename.isEmpty()) {
         return;
     }
@@ -160,7 +166,8 @@ void SettingsWidgetKeeShare::exportCertificate()
         QMessageBox warning;
         warning.setIcon(QMessageBox::Warning);
         warning.setWindowTitle(tr("Exporting changed certificate"));
-		  warning.setText(tr("The exported certificate is not the same as the one in use. Do you want to export the current certificate?"));
+        warning.setText(tr("The exported certificate is not the same as the one in use. Do you want to export the "
+                           "current certificate?"));
         auto yes = warning.addButton(QMessageBox::StandardButton::Yes);
         auto no = warning.addButton(QMessageBox::StandardButton::No);
         warning.setDefaultButton(no);
@@ -177,7 +184,8 @@ void SettingsWidgetKeeShare::exportCertificate()
     const auto filetype = tr("key.share", "Filetype for KeeShare key");
     const auto filters = QString("%1 (*." + filetype + ");;%2 (*)").arg(tr("KeeShare key file"), tr("All files"));
     QString filename = tr("%1.%2", "Template for KeeShare key file").arg(m_own.certificate.signer).arg(filetype);
-	 filename = fileDialog()->getSaveFileName(this, tr("Select path"), defaultDirPath, filters, nullptr, QFileDialog::Options(0), filetype, filename);
+    filename = fileDialog()->getSaveFileName(
+        this, tr("Select path"), defaultDirPath, filters, nullptr, QFileDialog::Options(0), filetype, filename);
     if (filename.isEmpty()) {
         return;
     }

src/keeshare/ShareObserver.cpp

@@ -51,30 +51,31 @@
 
 namespace
 {
-static const QString KeeShare_Signature("container.share.signature");
+    static const QString KeeShare_Signature("container.share.signature");
-static const QString KeeShare_Container("container.share.kdbx");
+    static const QString KeeShare_Container("container.share.kdbx");
 
-enum Trust
+    enum Trust
-{
+    {
         Invalid,
         Own,
         UntrustedForever,
         UntrustedOnce,
         TrustedOnce,
         TrustedForever,
-};
+    };
 
-bool isOfExportType(const QFileInfo &fileInfo, const QString type)
+    bool isOfExportType(const QFileInfo& fileInfo, const QString type)
-{
+    {
         return fileInfo.fileName().endsWith(type, Qt::CaseInsensitive);
-}
+    }
 
-QPair<Trust, KeeShareSettings::Certificate> check(QByteArray& data,
+    QPair<Trust, KeeShareSettings::Certificate>
+    check(QByteArray& data,
           const KeeShareSettings::Reference& reference,
           const KeeShareSettings::Certificate& ownCertificate,
           const QList<KeeShareSettings::ScopedCertificate>& knownCertificates,
           const KeeShareSettings::Sign& sign)
-{
+    {
         KeeShareSettings::Certificate certificate;
         if (!sign.signature.isEmpty()) {
             certificate = sign.certificate;
@@ -87,10 +88,15 @@ QPair<Trust, KeeShareSettings::Certificate> check(QByteArray& data,
             }
 
             if (ownCertificate.key == sign.certificate.key) {
-                return {Own, ownCertificate };
+                return {Own, ownCertificate};
             }
         }
-     enum Scope { Invalid, Global, Local };
+        enum Scope
+        {
+            Invalid,
+            Global,
+            Local
+        };
         Scope scope = Invalid;
         KeeShareSettings::Trust trusted = KeeShareSettings::Trust::Ask;
         for (const auto& scopedCertificate : knownCertificates) {
@@ -105,19 +111,19 @@ QPair<Trust, KeeShareSettings::Certificate> check(QByteArray& data,
                 break;
             }
         }
-     if (scope != Invalid && trusted != KeeShareSettings::Trust::Ask){
+        if (scope != Invalid && trusted != KeeShareSettings::Trust::Ask) {
             // we introduce now scopes if there is a global
             return {trusted == KeeShareSettings::Trust::Trusted ? TrustedForever : UntrustedForever, certificate};
         }
 
         QMessageBox warning;
-     if (sign.signature.isEmpty()){
+        if (sign.signature.isEmpty()) {
             warning.setIcon(QMessageBox::Warning);
             warning.setWindowTitle(ShareObserver::tr("Import from container without signature"));
-          warning.setText(ShareObserver::tr("We cannot verify the source of the shared container because it is not signed. Do you really want to import from %1?")
+            warning.setText(ShareObserver::tr("We cannot verify the source of the shared container because it is not "
+                                              "signed. Do you really want to import from %1?")
                                 .arg(reference.path));
-     }
+        } else {
-     else {
             warning.setIcon(QMessageBox::Question);
             warning.setWindowTitle(ShareObserver::tr("Import from container with certificate"));
             warning.setText(ShareObserver::tr("Do you want to trust %1 with the fingerprint of %2 from %3")
@@ -129,20 +135,20 @@ QPair<Trust, KeeShareSettings::Certificate> check(QByteArray& data,
         auto trustedOnce = warning.addButton(ShareObserver::tr("Just this time"), QMessageBox::ButtonRole::YesRole);
         warning.setDefaultButton(untrustedOnce);
         warning.exec();
-     if (warning.clickedButton() == trustedForever){
+        if (warning.clickedButton() == trustedForever) {
-          return {TrustedForever, certificate };
+            return {TrustedForever, certificate};
         }
-     if (warning.clickedButton() == trustedOnce){
+        if (warning.clickedButton() == trustedOnce) {
             return {TrustedOnce, certificate};
         }
-     if (warning.clickedButton() == untrustedOnce){
+        if (warning.clickedButton() == untrustedOnce) {
-          return {UntrustedOnce, certificate };
+            return {UntrustedOnce, certificate};
         }
-     if (warning.clickedButton() == untrustedForever){
+        if (warning.clickedButton() == untrustedForever) {
-          return {UntrustedForever, certificate };
+            return {UntrustedForever, certificate};
+        }
+        return {UntrustedOnce, certificate};
     }
-     return {UntrustedOnce, certificate };
-}
 
 } // End Namespace
 
@@ -195,7 +201,8 @@ void ShareObserver::reinitialize()
         m_groupToReference.remove(couple.group);
         m_referenceToGroup.remove(couple.oldReference);
         m_shareToGroup.remove(couple.oldReference.path);
-        if (couple.newReference.isValid() && ((active.in && couple.newReference.isImporting())
+        if (couple.newReference.isValid()
+            && ((active.in && couple.newReference.isImporting())
                 || (active.out && couple.newReference.isExporting()))) {
             m_groupToReference[couple.group] = couple.newReference;
             m_referenceToGroup[couple.newReference] = couple.group;
@@ -301,11 +308,12 @@ void ShareObserver::handleFileUpdated(const QString& path)
     notifyAbout(success, warning, error);
 }
 
-ShareObserver::Result ShareObserver::importSingedContainerInto(const KeeShareSettings::Reference& reference, Group* targetGroup)
+ShareObserver::Result ShareObserver::importSingedContainerInto(const KeeShareSettings::Reference& reference,
+                                                               Group* targetGroup)
 {
 #if !defined(WITH_XC_KEESHARE_SECURE)
     Q_UNUSED(targetGroup);
-    return { reference.path, Result::Warning, tr("Signed share container are not supported - import prevented") };
+    return {reference.path, Result::Warning, tr("Signed share container are not supported - import prevented")};
 #else
     QuaZip zip(reference.path);
     if (!zip.open(QuaZip::mdUnzip)) {
@@ -359,7 +367,8 @@ ShareObserver::Result ShareObserver::importSingedContainerInto(const KeeShareSet
     case UntrustedForever:
     case TrustedForever: {
         bool found = false;
-        const auto trusted = trust.first == TrustedForever ? KeeShareSettings::Trust::Trusted : KeeShareSettings::Trust::Untrusted;
+        const auto trusted =
+            trust.first == TrustedForever ? KeeShareSettings::Trust::Trusted : KeeShareSettings::Trust::Untrusted;
         for (KeeShareSettings::ScopedCertificate& scopedCertificate : foreign.certificates) {
             if (scopedCertificate.certificate.key == trust.second.key && scopedCertificate.path == reference.path) {
                 scopedCertificate.certificate.signer = trust.second.signer;
@@ -369,7 +378,7 @@ ShareObserver::Result ShareObserver::importSingedContainerInto(const KeeShareSet
             }
         }
         if (!found) {
-            foreign.certificates << KeeShareSettings::ScopedCertificate{ reference.path, trust.second, trusted};
+            foreign.certificates << KeeShareSettings::ScopedCertificate{reference.path, trust.second, trusted};
             // we need to update with the new signer
             KeeShare::setForeign(foreign);
         }
@@ -409,14 +418,15 @@ ShareObserver::Result ShareObserver::importSingedContainerInto(const KeeShareSet
 #endif
 }
 
-ShareObserver::Result ShareObserver::importUnsignedContainerInto(const KeeShareSettings::Reference& reference, Group* targetGroup)
+ShareObserver::Result ShareObserver::importUnsignedContainerInto(const KeeShareSettings::Reference& reference,
+                                                                 Group* targetGroup)
 {
 #if !defined(WITH_XC_KEESHARE_INSECURE)
     Q_UNUSED(targetGroup);
     return {reference.path, Result::Warning, tr("Unsigned share container are not supported - import prevented")};
 #else
     QFile file(reference.path);
-    if (!file.open(QIODevice::ReadOnly)){
+    if (!file.open(QIODevice::ReadOnly)) {
         qCritical("Unable to open file %s.", qPrintable(reference.path));
         return {reference.path, Result::Error, tr("File is not readable")};
     }
@@ -438,11 +448,12 @@ ShareObserver::Result ShareObserver::importUnsignedContainerInto(const KeeShareS
     const auto own = KeeShare::own();
     const auto sign = KeeShareSettings::Sign(); // invalid sign
     auto trust = check(payload, reference, own.certificate, foreign.certificates, sign);
-    switch(trust.first) {
+    switch (trust.first) {
     case UntrustedForever:
     case TrustedForever: {
         bool found = false;
-        const auto trusted = trust.first == TrustedForever ? KeeShareSettings::Trust::Trusted : KeeShareSettings::Trust::Untrusted;
+        const auto trusted =
+            trust.first == TrustedForever ? KeeShareSettings::Trust::Trusted : KeeShareSettings::Trust::Untrusted;
         for (KeeShareSettings::ScopedCertificate& scopedCertificate : foreign.certificates) {
             if (scopedCertificate.certificate.key == trust.second.key && scopedCertificate.path == reference.path) {
                 scopedCertificate.certificate.signer = trust.second.signer;
@@ -452,7 +463,7 @@ ShareObserver::Result ShareObserver::importUnsignedContainerInto(const KeeShareS
             }
         }
         if (!found) {
-            foreign.certificates << KeeShareSettings::ScopedCertificate{ reference.path, trust.second, trusted};
+            foreign.certificates << KeeShareSettings::ScopedCertificate{reference.path, trust.second, trusted};
             // we need to update with the new signer
             KeeShare::setForeign(foreign);
         }
@@ -491,7 +502,8 @@ ShareObserver::Result ShareObserver::importUnsignedContainerInto(const KeeShareS
 #endif
 }
 
-ShareObserver::Result ShareObserver::importContainerInto(const KeeShareSettings::Reference& reference, Group* targetGroup)
+ShareObserver::Result ShareObserver::importContainerInto(const KeeShareSettings::Reference& reference,
+                                                         Group* targetGroup)
 {
     const QFileInfo info(reference.path);
     if (!info.exists()) {
@@ -612,11 +624,13 @@ QSharedPointer<Database> ShareObserver::database()
     return m_db;
 }
 
-ShareObserver::Result ShareObserver::exportIntoReferenceSignedContainer(const KeeShareSettings::Reference &reference, Database *targetDb)
+ShareObserver::Result ShareObserver::exportIntoReferenceSignedContainer(const KeeShareSettings::Reference& reference,
+                                                                        Database* targetDb)
 {
 #if !defined(WITH_XC_KEESHARE_SECURE)
     Q_UNUSED(targetDb);
-    return {reference.path, Result::Warning, tr("Overwriting signed share container is not supported - export prevented")};
+    return {
+        reference.path, Result::Warning, tr("Overwriting signed share container is not supported - export prevented")};
 #else
     QByteArray bytes;
     {
@@ -678,11 +692,14 @@ ShareObserver::Result ShareObserver::exportIntoReferenceSignedContainer(const Ke
 #endif
 }
 
-ShareObserver::Result ShareObserver::exportIntoReferenceUnsignedContainer(const KeeShareSettings::Reference &reference, Database *targetDb)
+ShareObserver::Result ShareObserver::exportIntoReferenceUnsignedContainer(const KeeShareSettings::Reference& reference,
+                                                                          Database* targetDb)
 {
 #if !defined(WITH_XC_KEESHARE_INSECURE)
     Q_UNUSED(targetDb);
-    return {reference.path, Result::Warning, tr("Overwriting unsigned share container is not supported - export prevented")};
+    return {reference.path,
+            Result::Warning,
+            tr("Overwriting unsigned share container is not supported - export prevented")};
 #else
     QFile file(reference.path);
     const bool fileOpened = file.open(QIODevice::WriteOnly);

src/keeshare/ShareObserver.h

@@ -35,7 +35,7 @@ class Database;
 
 class ShareObserver : public QObject
 {
-Q_OBJECT
+    Q_OBJECT
 
 public:
     explicit ShareObserver(QSharedPointer<Database> db, QObject* parent = nullptr);
@@ -79,8 +79,9 @@ private:
     static void resolveReferenceAttributes(Entry* targetEntry, const Database* sourceDb);
 
     static Database* exportIntoContainer(const KeeShareSettings::Reference& reference, const Group* sourceRoot);
-    static Result exportIntoReferenceUnsignedContainer(const KeeShareSettings::Reference &reference, Database *targetDb);
+    static Result exportIntoReferenceUnsignedContainer(const KeeShareSettings::Reference& reference,
-    static Result exportIntoReferenceSignedContainer(const KeeShareSettings::Reference &reference, Database *targetDb);
+                                                       Database* targetDb);
+    static Result exportIntoReferenceSignedContainer(const KeeShareSettings::Reference& reference, Database* targetDb);
     static Result importSingedContainerInto(const KeeShareSettings::Reference& reference, Group* targetGroup);
     static Result importUnsignedContainerInto(const KeeShareSettings::Reference& reference, Group* targetGroup);
     static Result importContainerInto(const KeeShareSettings::Reference& reference, Group* targetGroup);

src/keeshare/group/EditGroupWidgetKeeShare.cpp

@@ -57,9 +57,8 @@ EditGroupWidgetKeeShare::EditGroupWidgetKeeShare(QWidget* parent)
 
     connect(KeeShare::instance(), SIGNAL(activeChanged()), SLOT(showSharingState()));
 
-	 const auto types = QList<KeeShareSettings::Type>() << KeeShareSettings::Inactive
+    const auto types = QList<KeeShareSettings::Type>()
-																		 << KeeShareSettings::ImportFrom
+                       << KeeShareSettings::Inactive << KeeShareSettings::ImportFrom << KeeShareSettings::ExportTo
-																		 << KeeShareSettings::ExportTo
                        << KeeShareSettings::SynchronizeWith;
     for (const auto& type : types) {
         QString name;
@@ -116,8 +115,8 @@ void EditGroupWidgetKeeShare::showSharingState()
     const auto reference = KeeShare::referenceOf(m_temporaryGroup);
     if (!reference.path.isEmpty()) {
         bool supported = false;
-		  for(const auto &extension : supportedExtensions){
+        for (const auto& extension : supportedExtensions) {
-				if (reference.path.endsWith(extension, Qt::CaseInsensitive)){
+            if (reference.path.endsWith(extension, Qt::CaseInsensitive)) {
                 supported = true;
                 break;
             }
@@ -210,14 +209,16 @@ void EditGroupWidgetKeeShare::launchPathSelectionDialog()
 #if defined(WITH_XC_KEESHARE_INSECURE)
     defaultFiletype = KeeShare::unsignedContainerFileType();
     supportedExtensions << KeeShare::unsignedContainerFileType();
-	 knownFilters.prepend(QString("%1 (*.%2)").arg(tr("KeeShare unsigned container"), KeeShare::unsignedContainerFileType()));
+    knownFilters.prepend(
+        QString("%1 (*.%2)").arg(tr("KeeShare unsigned container"), KeeShare::unsignedContainerFileType()));
 #else
     unsupportedExtensions << KeeShare::unsignedContainerFileType();
 #endif
 #if defined(WITH_XC_KEESHARE_SECURE)
     defaultFiletype = KeeShare::signedContainerFileType();
     supportedExtensions << KeeShare::signedContainerFileType();
-	 knownFilters.prepend(QString("%1 (*.%2)").arg(tr("KeeShare signed container"), KeeShare::signedContainerFileType()));
+    knownFilters.prepend(
+        QString("%1 (*.%2)").arg(tr("KeeShare signed container"), KeeShare::signedContainerFileType()));
 #else
     unsupportedExtensions << KeeShare::signedContainerFileType();
 #endif
@@ -229,18 +230,35 @@ void EditGroupWidgetKeeShare::launchPathSelectionDialog()
     }
     switch (reference.type) {
     case KeeShareSettings::ImportFrom:
-		  filename = fileDialog()->getFileName(
+        filename = fileDialog()->getFileName(this,
-				this, tr("Select import source"), defaultDirPath, filters, nullptr, QFileDialog::DontConfirmOverwrite,
+                                             tr("Select import source"),
-				defaultFiletype, filename);
+                                             defaultDirPath,
+                                             filters,
+                                             nullptr,
+                                             QFileDialog::DontConfirmOverwrite,
+                                             defaultFiletype,
+                                             filename);
         break;
     case KeeShareSettings::ExportTo:
-		  filename = fileDialog()->getFileName(
+        filename = fileDialog()->getFileName(this,
-				this, tr("Select export target"), defaultDirPath, filters, nullptr, QFileDialog::Option(0), defaultFiletype, filename);
+                                             tr("Select export target"),
+                                             defaultDirPath,
+                                             filters,
+                                             nullptr,
+                                             QFileDialog::Option(0),
+                                             defaultFiletype,
+                                             filename);
         break;
     case KeeShareSettings::SynchronizeWith:
     case KeeShareSettings::Inactive:
-		  filename = fileDialog()->getFileName(
+        filename = fileDialog()->getFileName(this,
-				this, tr("Select import/export file"), defaultDirPath, filters, nullptr, QFileDialog::Option(0), defaultFiletype, filename);
+                                             tr("Select import/export file"),
+                                             defaultDirPath,
+                                             filters,
+                                             nullptr,
+                                             QFileDialog::Option(0),
+                                             defaultFiletype,
+                                             filename);
         break;
     }
 
@@ -248,13 +266,13 @@ void EditGroupWidgetKeeShare::launchPathSelectionDialog()
         return;
     }
     bool validFilename = false;
-	 for(const auto& extension : supportedExtensions + unsupportedExtensions){
+    for (const auto& extension : supportedExtensions + unsupportedExtensions) {
         if (filename.endsWith(extension, Qt::CaseInsensitive)) {
             validFilename = true;
             break;
         }
     }
-	 if (!validFilename){
+    if (!validFilename) {
         filename += (!filename.endsWith(".") ? "." : "") + defaultFiletype;
     }