File indexing completed on 2025-02-23 05:27:12

0001 /*
0002     This file is part of the Kasten Framework, made within the KDE community.
0003 
0004     SPDX-FileCopyrightText: 2007-2009 Friedrich W. H. Kossebau <kossebau@kde.org>
0005 
0006     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
0007 */
0008 
0009 #include "synchronizecontroller.hpp"
0010 
0011 // Kasten core
0012 #include <Kasten/DocumentSyncManager>
0013 #include <Kasten/AbstractModelFileSystemSynchronizer>
0014 #include <Kasten/AbstractDocument>
0015 // KF
0016 #include <KActionCollection>
0017 #include <KStandardAction>
0018 #include <KXMLGUIClient>
0019 #include <KLocalizedString>
0020 // Qt
0021 #include <QUrl>
0022 #include <QAction>
0023 
0024 namespace Kasten {
0025 
0026 SynchronizeController::SynchronizeController(DocumentSyncManager* syncManager, KXMLGUIClient* guiClient)
0027     : mSyncManager(syncManager)
0028 {
0029     KActionCollection* actionCollection = guiClient->actionCollection();
0030 
0031     mSaveAction = KStandardAction::save(this, &SynchronizeController::save, this);
0032 
0033     mReloadAction = new QAction(QIcon::fromTheme(QStringLiteral("view-refresh")),
0034                                 i18nc("@action:inmenu", "Reloa&d"), this);
0035     actionCollection->setDefaultShortcuts(mReloadAction, KStandardShortcut::reload());
0036     connect(mReloadAction, &QAction::triggered,
0037             this, &SynchronizeController::reload);
0038 
0039     actionCollection->addAction(mSaveAction->objectName(), mSaveAction);
0040     actionCollection->addAction(QStringLiteral("file_reload"), mReloadAction);
0041 
0042     setTargetModel(nullptr);
0043 }
0044 
0045 void SynchronizeController::setTargetModel(AbstractModel* model)
0046 {
0047     if (mDocument) {
0048         mDocument->disconnect(this);
0049     }
0050 
0051     mDocument = model ? model->findBaseModel<AbstractDocument*>() : nullptr;
0052 
0053     if (mDocument) {
0054         connect(mDocument, &AbstractDocument::synchronizerChanged,
0055                 this, &SynchronizeController::onSynchronizerChanged);
0056     }
0057     onSynchronizerChanged(mDocument ? mDocument->synchronizer() : nullptr);
0058 }
0059 
0060 void SynchronizeController::save()
0061 {
0062     mSyncManager->save(mDocument);
0063 }
0064 
0065 void SynchronizeController::reload()
0066 {
0067     mSyncManager->reload(mDocument);
0068 }
0069 
0070 void SynchronizeController::onSynchronizerChanged(AbstractModelSynchronizer* newSynchronizer)
0071 {
0072     if (mSynchronizer) {
0073         mSynchronizer->disconnect(this);
0074     }
0075 
0076     mSynchronizer = qobject_cast<AbstractModelFileSystemSynchronizer*>(newSynchronizer);
0077     // TODO: Storable interface should be used by Synchronizer
0078     // synchronizer should report about possible activities
0079     // TODO: check for access rights, may not write
0080     bool canSync = false;
0081     if (mSynchronizer) {
0082         const LocalSyncState localSyncState = mSynchronizer->localSyncState();
0083         const RemoteSyncState remoteSyncState = mSynchronizer->remoteSyncState();
0084         canSync = (localSyncState == LocalHasChanges)
0085                   || (remoteSyncState == RemoteHasChanges)
0086                   || (remoteSyncState == RemoteUnknown);
0087 
0088         connect(mSynchronizer, &AbstractModelSynchronizer::localSyncStateChanged,
0089                 this, &SynchronizeController::onSyncStateChanged);
0090         connect(mSynchronizer, &AbstractModelSynchronizer::remoteSyncStateChanged,
0091                 this, &SynchronizeController::onSyncStateChanged);
0092         connect(mSynchronizer, &QObject::destroyed,
0093                 this, &SynchronizeController::onSynchronizerDeleted);
0094     }
0095 
0096     mSaveAction->setEnabled(canSync);
0097     mReloadAction->setEnabled(canSync);
0098 }
0099 
0100 void SynchronizeController::onSynchronizerDeleted(QObject* synchronizer)
0101 {
0102     if (synchronizer != mSynchronizer) {
0103         return;
0104     }
0105 
0106     mSynchronizer = nullptr;
0107 
0108     mSaveAction->setEnabled(false);
0109     mReloadAction->setEnabled(false);
0110 }
0111 
0112 void SynchronizeController::onSyncStateChanged()
0113 {
0114     const LocalSyncState localSyncState = mSynchronizer->localSyncState();
0115     const RemoteSyncState remoteSyncState = mSynchronizer->remoteSyncState();
0116     const bool canSync = (localSyncState == LocalHasChanges)
0117                          || (remoteSyncState == RemoteHasChanges)
0118                          || (remoteSyncState == RemoteUnknown);
0119 
0120     mSaveAction->setEnabled(canSync);
0121     mReloadAction->setEnabled(canSync);
0122 }
0123 
0124 }
0125 
0126 #include "moc_synchronizecontroller.cpp"