File indexing completed on 2024-04-14 05:39:28

 // SPDX-FileCopyrightText: 2020 Simon Persson <simon.persson@mykolab.com>
 //
 // SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
 
 #include "filedigger.h"
 #include "mergedvfsmodel.h"
 #include "restoredialog.h"
 #include "versionlistmodel.h"
 #include "versionlistdelegate.h"
 
 #include <KDirOperator>
 #include <KFilePlacesView>
 #include <KFilePlacesModel>
 #include <KGuiItem>
 #include <KIO/OpenUrlJob>
 #include <KIO/JobUiDelegate>
 #include <KIO/JobUiDelegateFactory>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KStandardAction>
 #include <KToolBar>
 
 #include <QGuiApplication>
 #include <QLabel>
 #include <QListView>
 #include <QPushButton>
 #include <QSplitter>
 #include <QTimer>
 #include <QTreeView>
 #include <QVBoxLayout>
 #include <utility>
 #include <kio_version.h>
 
 FileDigger::FileDigger(QString pRepoPath, QString pBranchName, QWidget *pParent)
     : KMainWindow(pParent), mRepoPath(std::move(pRepoPath)), mBranchName(std::move(pBranchName)), mDirOperator(nullptr)
 {
     setWindowIcon(QIcon::fromTheme(QStringLiteral("kup")));
     KToolBar *lAppToolBar = toolBar();
     lAppToolBar->addAction(KStandardAction::quit(this, SLOT(close()), this));
     QTimer::singleShot(0, this, [this]{repoPathAvailable();});
 }
 
 QSize FileDigger::sizeHint() const {
     return {800, 600};
 }
 
 void FileDigger::updateVersionModel(const QModelIndex &pCurrent, const QModelIndex &pPrevious) {
     Q_UNUSED(pPrevious)
     mVersionModel->setNode(MergedVfsModel::node(pCurrent));
     mVersionView->selectionModel()->setCurrentIndex(mVersionModel->index(0,0),
                                                     QItemSelectionModel::Select);
 }
 
 void FileDigger::open(const QModelIndex &pIndex) {
 
     auto *job = new KIO::OpenUrlJob(pIndex.data(VersionBupUrlRole).toUrl(),
                  pIndex.data(VersionMimeTypeRole).toString());
 #if KIO_VERSION > QT_VERSION_CHECK(5, 98, 0)
     auto *delegate = KIO::createDefaultJobUiDelegate(KIO::JobUiDelegate::AutoHandlingEnabled, this);
 #else
     auto *delegate = new KIO::JobUiDelegate(KIO::JobUiDelegate::AutoHandlingEnabled, this);
 #endif
     job->setUiDelegate(delegate);
     job->start();
 }
 
 void FileDigger::restore(const QModelIndex &pIndex) {
     auto lDialog = new RestoreDialog(pIndex.data(VersionSourceInfoRole).value<BupSourceInfo>(), this);
     lDialog->setAttribute(Qt::WA_DeleteOnClose);
     lDialog->show();
 }
 
 void FileDigger::repoPathAvailable() {
     if(mRepoPath.isEmpty()) {
         createSelectionView();
     } else {
         QGuiApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
         MergedRepository *lRepository = createRepo();
         if(lRepository != nullptr) {
             createRepoView(lRepository);
         }
         QGuiApplication::restoreOverrideCursor();
     }
 }
 
 void FileDigger::checkFileWidgetPath() {
     KFileItemList lList = mDirOperator->selectedItems();
     if(lList.isEmpty()) {
         mRepoPath = mDirOperator->url().toLocalFile();
     } else {
         mRepoPath = lList.first().url().toLocalFile();
     }
     mBranchName = QStringLiteral("kup");
     repoPathAvailable();
 }
 
 void FileDigger::enterUrl(const QUrl &pUrl) {
     mDirOperator->setUrl(pUrl, true);
 }
 
 MergedRepository *FileDigger::createRepo() {
     auto lRepository = new MergedRepository(nullptr, mRepoPath, mBranchName);
     if(!lRepository->open()) {
         KMessageBox::error(nullptr, xi18nc("@info messagebox, %1 is a folder path",
                                        "The backup archive <filename>%1</filename> could not be opened. "
                                        "Check if the backups really are located there.",
                                        mRepoPath));
         return nullptr;
     }
     if(!lRepository->readBranch()) {
         if(!lRepository->permissionsOk()) {
             KMessageBox::error(nullptr, xi18nc("@info messagebox",
                                            "You do not have permission needed to read this backup archive."));
         } else {
             MergedRepository::askForIntegrityCheck();
         }
         return nullptr;
     }
     return lRepository;
 }
 
 void FileDigger::createRepoView(MergedRepository *pRepository) {
     auto lSplitter = new QSplitter();
     mMergedVfsModel = new MergedVfsModel(pRepository, this);
     mMergedVfsView = new QTreeView();
     mMergedVfsView->setHeaderHidden(true);
     mMergedVfsView->setSelectionMode(QAbstractItemView::SingleSelection);
     mMergedVfsView->setModel(mMergedVfsModel);
     lSplitter->addWidget(mMergedVfsView);
     connect(mMergedVfsView->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)),
             this, SLOT(updateVersionModel(QModelIndex,QModelIndex)));
 
     mVersionView = new QListView();
     mVersionView->setSelectionMode(QAbstractItemView::SingleSelection);
     mVersionModel = new VersionListModel(this);
     mVersionView->setModel(mVersionModel);
     auto lVersionDelegate = new VersionListDelegate(mVersionView,this);
     mVersionView->setItemDelegate(lVersionDelegate);
     lSplitter->addWidget(mVersionView);
     connect(lVersionDelegate, SIGNAL(openRequested(QModelIndex)), SLOT(open(QModelIndex)));
     connect(lVersionDelegate, SIGNAL(restoreRequested(QModelIndex)), SLOT(restore(QModelIndex)));
     mMergedVfsView->setFocus();
 
     //expand all levels from the top until the node has more than one child
     QModelIndex lIndex;
     forever {
         mMergedVfsView->expand(lIndex);
         if(mMergedVfsModel->rowCount(lIndex) == 1) {
             lIndex = mMergedVfsModel->index(0, 0, lIndex);
         } else {
             break;
         }
     }
     mMergedVfsView->selectionModel()->setCurrentIndex(mMergedVfsModel->index(0, 0, lIndex), QItemSelectionModel::Select);
     setCentralWidget(lSplitter);
 }
 
 void FileDigger::createSelectionView() {
     if(mDirOperator != nullptr) {
         return;
     }
     auto lLabel = new QLabel(i18n("Select location of backup archive to open."));
 
     auto lPlaces = new KFilePlacesView;
     lPlaces->setModel(new KFilePlacesModel);
 
     mDirOperator = new KDirOperator();
 #if KIO_VERSION < QT_VERSION_CHECK(5, 100, 0)
     mDirOperator->setView(KFile::Tree);
 #else
     mDirOperator->setViewMode(KFile::Tree);
 #endif
     mDirOperator->setMode(KFile::Directory);
     mDirOperator->setEnableDirHighlighting(true);
     mDirOperator->setShowHiddenFiles(true);
 
     connect(lPlaces, &KFilePlacesView::urlChanged, this, &FileDigger::enterUrl);
 
     auto lOkButton = new QPushButton(this);
     KGuiItem::assign(lOkButton, KStandardGuiItem::ok());
     connect(lOkButton, &QPushButton::pressed, this, &FileDigger::checkFileWidgetPath);
 
 
     auto lSelectionView = new QWidget;
     auto lVLayout1 = new QVBoxLayout;
     auto lSplitter = new QSplitter;
 
     lVLayout1->addWidget(lLabel);
     lSplitter->addWidget(lPlaces);
     lSplitter->addWidget(mDirOperator);
     lVLayout1->addWidget(lSplitter, 1);
     lVLayout1->addWidget(lOkButton);
     lSelectionView->setLayout(lVLayout1);
     setCentralWidget(lSelectionView);
 }