mirror of
https://gitee.com/vnotex/vnote.git
synced 2025-07-05 13:59:52 +08:00
377 lines
11 KiB
C++
377 lines
11 KiB
C++
#include "notebookmgr.h"
|
|
|
|
#include <versioncontroller/dummyversioncontrollerfactory.h>
|
|
#include <versioncontroller/iversioncontroller.h>
|
|
#include <notebookconfigmgr/vxnotebookconfigmgrfactory.h>
|
|
#include <notebookconfigmgr/inotebookconfigmgr.h>
|
|
#include <notebookbackend/localnotebookbackendfactory.h>
|
|
#include <notebookbackend/inotebookbackend.h>
|
|
#include <notebook/bundlenotebookfactory.h>
|
|
#include <notebook/notebook.h>
|
|
#include <notebook/notebookparameters.h>
|
|
#include "exception.h"
|
|
#include "configmgr.h"
|
|
#include <utils/pathutils.h>
|
|
|
|
using namespace vnotex;
|
|
|
|
NotebookMgr::NotebookMgr(QObject *p_parent)
|
|
: QObject(p_parent),
|
|
m_currentNotebookId(Notebook::InvalidId)
|
|
{
|
|
}
|
|
|
|
void NotebookMgr::init()
|
|
{
|
|
initVersionControllerServer();
|
|
|
|
initConfigMgrServer();
|
|
|
|
initBackendServer();
|
|
|
|
initNotebookServer();
|
|
}
|
|
|
|
void NotebookMgr::initVersionControllerServer()
|
|
{
|
|
m_versionControllerServer.reset(new NameBasedServer<IVersionControllerFactory>);
|
|
|
|
// Dummy Version Controller.
|
|
auto dummyFactory = QSharedPointer<DummyVersionControllerFactory>::create();
|
|
m_versionControllerServer->registerItem(dummyFactory->getName(), dummyFactory);
|
|
}
|
|
|
|
void NotebookMgr::initConfigMgrServer()
|
|
{
|
|
m_configMgrServer.reset(new NameBasedServer<INotebookConfigMgrFactory>);
|
|
|
|
// VX Notebook Config Manager.
|
|
auto vxFactory = QSharedPointer<VXNotebookConfigMgrFactory>::create();
|
|
m_configMgrServer->registerItem(vxFactory->getName(), vxFactory);
|
|
|
|
}
|
|
|
|
void NotebookMgr::initBackendServer()
|
|
{
|
|
m_backendServer.reset(new NameBasedServer<INotebookBackendFactory>);
|
|
|
|
// Local Notebook Backend.
|
|
auto localFactory = QSharedPointer<LocalNotebookBackendFactory>::create();
|
|
m_backendServer->registerItem(localFactory->getName(), localFactory);
|
|
}
|
|
|
|
void NotebookMgr::initNotebookServer()
|
|
{
|
|
m_notebookServer.reset(new NameBasedServer<INotebookFactory>);
|
|
|
|
// Bundle Notebook.
|
|
auto bundleFacotry = QSharedPointer<BundleNotebookFactory>::create();
|
|
m_notebookServer->registerItem(bundleFacotry->getName(), bundleFacotry);
|
|
}
|
|
|
|
QSharedPointer<INotebookFactory> NotebookMgr::getBundleNotebookFactory() const
|
|
{
|
|
return m_notebookServer->getItem(QStringLiteral("bundle.vnotex"));
|
|
}
|
|
|
|
QList<QSharedPointer<INotebookFactory>> NotebookMgr::getAllNotebookFactories() const
|
|
{
|
|
return m_notebookServer->getAllItems();
|
|
}
|
|
|
|
QList<QSharedPointer<IVersionControllerFactory>> NotebookMgr::getAllVersionControllerFactories() const
|
|
{
|
|
return m_versionControllerServer->getAllItems();
|
|
}
|
|
|
|
QList<QSharedPointer<INotebookConfigMgrFactory>> NotebookMgr::getAllNotebookConfigMgrFactories() const
|
|
{
|
|
return m_configMgrServer->getAllItems();
|
|
}
|
|
|
|
QList<QSharedPointer<INotebookBackendFactory>> NotebookMgr::getAllNotebookBackendFactories() const
|
|
{
|
|
return m_backendServer->getAllItems();
|
|
}
|
|
|
|
QSharedPointer<INotebookBackend> NotebookMgr::createNotebookBackend(const QString &p_backendName,
|
|
const QString &p_rootFolderPath) const
|
|
{
|
|
auto factory = m_backendServer->getItem(p_backendName);
|
|
if (factory) {
|
|
return factory->createNotebookBackend(p_rootFolderPath);
|
|
} else {
|
|
Exception::throwOne(Exception::Type::InvalidArgument,
|
|
QString("failed to find notebook backend factory %1").arg(p_backendName));
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
QSharedPointer<IVersionController> NotebookMgr::createVersionController(const QString &p_controllerName) const
|
|
{
|
|
auto factory = m_versionControllerServer->getItem(p_controllerName);
|
|
if (factory) {
|
|
return factory->createVersionController();
|
|
} else {
|
|
Exception::throwOne(Exception::Type::InvalidArgument,
|
|
QString("failed to find version controller factory %1").arg(p_controllerName));
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
QSharedPointer<INotebookConfigMgr> NotebookMgr::createNotebookConfigMgr(const QString &p_mgrName,
|
|
const QSharedPointer<INotebookBackend> &p_backend) const
|
|
{
|
|
auto factory = m_configMgrServer->getItem(p_mgrName);
|
|
if (factory) {
|
|
return factory->createNotebookConfigMgr(p_backend);
|
|
} else {
|
|
Exception::throwOne(Exception::Type::InvalidArgument,
|
|
QString("failed to find notebook config manager factory %1").arg(p_mgrName));
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void NotebookMgr::loadNotebooks()
|
|
{
|
|
readNotebooksFromConfig();
|
|
|
|
loadCurrentNotebookId();
|
|
}
|
|
|
|
static SessionConfig &getSessionConfig()
|
|
{
|
|
return ConfigMgr::getInst().getSessionConfig();
|
|
}
|
|
|
|
void NotebookMgr::loadCurrentNotebookId()
|
|
{
|
|
auto &rootFolderPath = getSessionConfig().getCurrentNotebookRootFolderPath();
|
|
auto notebook = findNotebookByRootFolderPath(rootFolderPath);
|
|
if (notebook) {
|
|
m_currentNotebookId = notebook->getId();
|
|
} else {
|
|
m_currentNotebookId = Notebook::InvalidId;
|
|
}
|
|
|
|
emit currentNotebookChanged(notebook);
|
|
}
|
|
|
|
QSharedPointer<Notebook> NotebookMgr::newNotebook(const QSharedPointer<NotebookParameters> &p_parameters)
|
|
{
|
|
auto factory = m_notebookServer->getItem(p_parameters->m_type);
|
|
if (!factory) {
|
|
Exception::throwOne(Exception::Type::InvalidArgument,
|
|
QString("failed to find notebook factory %1").arg(p_parameters->m_type));
|
|
}
|
|
|
|
auto notebook = factory->newNotebook(*p_parameters);
|
|
addNotebook(notebook);
|
|
|
|
saveNotebooksToConfig();
|
|
|
|
emit notebooksUpdated();
|
|
|
|
setCurrentNotebook(notebook->getId());
|
|
|
|
return notebook;
|
|
}
|
|
|
|
void NotebookMgr::importNotebook(const QSharedPointer<Notebook> &p_notebook)
|
|
{
|
|
Q_ASSERT(p_notebook);
|
|
if (m_notebooks.indexOf(p_notebook) != -1) {
|
|
return;
|
|
}
|
|
|
|
addNotebook(p_notebook);
|
|
|
|
saveNotebooksToConfig();
|
|
|
|
emit notebooksUpdated();
|
|
|
|
setCurrentNotebook(p_notebook->getId());
|
|
}
|
|
|
|
static SessionConfig::NotebookItem notebookToSessionConfig(const QSharedPointer<const Notebook> &p_notebook)
|
|
{
|
|
SessionConfig::NotebookItem item;
|
|
item.m_type = p_notebook->getType();
|
|
item.m_rootFolderPath = p_notebook->getRootFolderPath();
|
|
item.m_backend = p_notebook->getBackend()->getName();
|
|
return item;
|
|
}
|
|
|
|
void NotebookMgr::saveNotebooksToConfig() const
|
|
{
|
|
QVector<SessionConfig::NotebookItem> items;
|
|
items.reserve(m_notebooks.size());
|
|
for (auto &nb : m_notebooks) {
|
|
items.push_back(notebookToSessionConfig(nb));
|
|
}
|
|
|
|
getSessionConfig().setNotebooks(items);
|
|
}
|
|
|
|
void NotebookMgr::readNotebooksFromConfig()
|
|
{
|
|
Q_ASSERT(m_notebooks.isEmpty());
|
|
auto items = getSessionConfig().getNotebooks();
|
|
for (auto &item : items) {
|
|
try {
|
|
auto nb = readNotebookFromConfig(item);
|
|
addNotebook(nb);
|
|
} catch (Exception &p_e) {
|
|
qCritical("failed to read notebook (%s) from config (%s)",
|
|
item.m_rootFolderPath.toStdString().c_str(),
|
|
p_e.what());
|
|
}
|
|
}
|
|
|
|
emit notebooksUpdated();
|
|
}
|
|
|
|
QSharedPointer<Notebook> NotebookMgr::readNotebookFromConfig(const SessionConfig::NotebookItem &p_item)
|
|
{
|
|
auto factory = m_notebookServer->getItem(p_item.m_type);
|
|
if (!factory) {
|
|
Exception::throwOne(Exception::Type::InvalidArgument,
|
|
QString("failed to find notebook factory %1").arg(p_item.m_type));
|
|
}
|
|
|
|
auto backend = createNotebookBackend(p_item.m_backend, p_item.m_rootFolderPath);
|
|
|
|
auto notebook = factory->createNotebook(*this, p_item.m_rootFolderPath, backend);
|
|
return notebook;
|
|
}
|
|
|
|
const QVector<QSharedPointer<Notebook>> &NotebookMgr::getNotebooks() const
|
|
{
|
|
return m_notebooks;
|
|
}
|
|
|
|
ID NotebookMgr::getCurrentNotebookId() const
|
|
{
|
|
return m_currentNotebookId;
|
|
}
|
|
|
|
void NotebookMgr::setCurrentNotebook(ID p_notebookId)
|
|
{
|
|
auto lastId = m_currentNotebookId;
|
|
m_currentNotebookId = p_notebookId;
|
|
auto nb = findNotebookById(p_notebookId);
|
|
if (!nb) {
|
|
m_currentNotebookId = Notebook::InvalidId;
|
|
}
|
|
|
|
if (lastId != m_currentNotebookId) {
|
|
emit currentNotebookChanged(nb);
|
|
}
|
|
|
|
getSessionConfig().setCurrentNotebookRootFolderPath(nb ? nb->getRootFolderPath() : "");
|
|
}
|
|
|
|
QSharedPointer<Notebook> NotebookMgr::findNotebookByRootFolderPath(const QString &p_rootFolderPath) const
|
|
{
|
|
for (auto &nb : m_notebooks) {
|
|
if (PathUtils::areSamePaths(nb->getRootFolderPath(), p_rootFolderPath)) {
|
|
return nb;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
QSharedPointer<Notebook> NotebookMgr::findNotebookById(ID p_id) const
|
|
{
|
|
for (auto &nb : m_notebooks) {
|
|
if (nb->getId() == p_id) {
|
|
return nb;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void NotebookMgr::closeNotebook(ID p_id)
|
|
{
|
|
auto it = std::find_if(m_notebooks.begin(),
|
|
m_notebooks.end(),
|
|
[p_id](const QSharedPointer<Notebook> &p_nb) {
|
|
return p_nb->getId() == p_id;
|
|
});
|
|
if (it == m_notebooks.end()) {
|
|
qWarning() << "failed to find notebook of given id to close" << p_id;
|
|
return;
|
|
}
|
|
|
|
auto notebookToClose = *it;
|
|
emit notebookAboutToClose(notebookToClose.data());
|
|
|
|
m_notebooks.erase(it);
|
|
|
|
saveNotebooksToConfig();
|
|
|
|
emit notebooksUpdated();
|
|
setCurrentNotebookAfterUpdate();
|
|
|
|
qInfo() << QString("notebook %1 (%2) is closed").arg(notebookToClose->getName(),
|
|
notebookToClose->getRootFolderPath());
|
|
}
|
|
|
|
void NotebookMgr::removeNotebook(ID p_id)
|
|
{
|
|
auto it = std::find_if(m_notebooks.begin(),
|
|
m_notebooks.end(),
|
|
[p_id](const QSharedPointer<Notebook> &p_nb) {
|
|
return p_nb->getId() == p_id;
|
|
});
|
|
if (it == m_notebooks.end()) {
|
|
qWarning() << "failed to find notebook of given id to remove" << p_id;
|
|
return;
|
|
}
|
|
|
|
auto nbToRemove = *it;
|
|
emit notebookAboutToRemove(nbToRemove.data());
|
|
|
|
m_notebooks.erase(it);
|
|
|
|
saveNotebooksToConfig();
|
|
|
|
emit notebooksUpdated();
|
|
setCurrentNotebookAfterUpdate();
|
|
|
|
try {
|
|
nbToRemove->remove();
|
|
} catch (Exception &p_e) {
|
|
qWarning() << QString("failed to remove notebook %1 (%2) (%3)").arg(nbToRemove->getName(),
|
|
nbToRemove->getRootFolderPath(),
|
|
p_e.what());
|
|
throw;
|
|
}
|
|
|
|
qInfo() << QString("notebook %1 (%2) is removed").arg(nbToRemove->getName(),
|
|
nbToRemove->getRootFolderPath());
|
|
}
|
|
|
|
void NotebookMgr::setCurrentNotebookAfterUpdate()
|
|
{
|
|
if (!m_notebooks.isEmpty()) {
|
|
setCurrentNotebook(m_notebooks.first()->getId());
|
|
} else {
|
|
setCurrentNotebook(Notebook::InvalidId);
|
|
}
|
|
}
|
|
|
|
void NotebookMgr::addNotebook(const QSharedPointer<Notebook> &p_notebook)
|
|
{
|
|
m_notebooks.push_back(p_notebook);
|
|
connect(p_notebook.data(), &Notebook::updated,
|
|
this, [this, notebook = p_notebook.data()]() {
|
|
emit notebookUpdated(notebook);
|
|
});
|
|
}
|