QtNovelUI/WordsIDE/command_list.cpp

#include "command_list.h"
#include "manager_docs.h"
#include "route.h"
#include "DocsManager.h"

using namespace CommandList;
using namespace Core;
using namespace Presents;

NewProject::NewProject(const QDir &dir, const QString &name) : dir_symbo(dir), name_val(name) {}

QString NewProject::name() const { return NAME(NewProject); }

void NewProject::run(Schedule::CommandsDispatcher *core) const {
    auto vmgr = core->get<DocumentsManager>(NAME(DocumentsManager));
    vmgr->projectManager()->newProject(dir_symbo.absolutePath(), name_val);
}

QString NewProject::toText() const { return QString("%1:%2").arg(dir_symbo.absolutePath(), name_val); }

void NewProject::fromText(const QString &line) {
    auto list = line.split(":");
    dir_symbo = QDir(list[0]);
    name_val = list[1];
}

NewPackage::NewPackage(const QString &path_string) { sequence = path_string.split("/", QString::SplitBehavior::SkipEmptyParts); }

QString NewPackage::name() const
{
    return NAME(NewPackage);
}

void NewPackage::run(Schedule::CommandsDispatcher *core) const
{
    auto vmgr = core->get<DocumentsManager>(NAME(DocumentsManager));
    vmgr->createPackage(Route::collect(sequence));
}

QString NewPackage::toText() const
{
    return QStringList(sequence).join("/");
}

void NewPackage::fromText(const QString &line)
{
    sequence = line.split("/");
}

NewFile::NewFile(const Route &group, const QString &name, const QString &suffix)
    : name_val(name), suffix(suffix) { group_val = group.links(); }

QString NewFile::name() const
{
    return NAME(NewFile);
}

void NewFile::run(Schedule::CommandsDispatcher *core) const
{
    auto vmgr = core->get<DocumentsManager>(NAME(DocumentsManager));
    vmgr->createFile(Route::collect(group_val), name_val, suffix);
}

QString NewFile::toText() const
{
    return (QStringList() << QStringList(group_val).join("/") << name_val << suffix).join(":");
}

void NewFile::fromText(const QString &line)
{
    auto list = line.split(":", QString::SkipEmptyParts);
    group_val = list[0].split("/");
    name_val = list[1];
    suffix = list[2];
}

SaveAll::SaveAll()
{

}

QString SaveAll::name() const
{
    return NAME(SaveAll);
}

void SaveAll::run(Schedule::CommandsDispatcher *core) const
{
    auto vmgr = core->get<DocumentsManager>(NAME(DocumentsManager));

    if (vmgr->projectManager()->isOpenning()) {
        vmgr->save();
        vmgr->projectManager()->save();
    }
}

QString SaveAll::toText() const
{
    return "";
}

void SaveAll::fromText(const QString &line) {}

OpenFile::OpenFile(const Core::Route &path_node) { path_store = path_node.links(); }

OpenFile::OpenFile(const QFileInfo &file_path)
{
    final_file = file_path;
}

QString OpenFile::name() const
{
    return NAME(OpenFile);
}

void OpenFile::run(Schedule::CommandsDispatcher *core) const
{
    auto mgr = core->get<DocumentsManager>(NAME(DocumentsManager));
    if(path_store.size()){
        mgr->openFile(QList<Core::Route>() << Route::collect(path_store));
    }
    else{
        auto index = mgr->projectManager()->queryAccess()->queryIndex(final_file);
        auto route = mgr->convertPath(index);

        mgr->openFile(QList<Core::Route>() << route);
    }
}

QString OpenFile::toText() const
{
    return path_store.join("/");
}

void OpenFile::fromText(const QString &line) { path_store = line.split("/"); }

CompVisible::CompVisible(PresentHost *host, FilePresent *target, bool state) : host_ins(host), target_ins(target), state_val(state) {
    path = Route::collect(QList<QString>() << target->name());
}

QString CompVisible::name() const { return QString("/%1[%2]").arg(NAME(CompVisible), target_ins->name()); }

void CompVisible::run(Schedule::CommandsDispatcher *core) const {
    target_ins->widget()->setVisible(state_val);
    if (state_val) {
        host_ins->append(target_ins);
    } else {
        host_ins->remove(target_ins);
    }
}

QString CompVisible::toText() const { return QString("%1/%2").arg(state_val).arg(path.links().join(":")); }

void CompVisible::fromText(const QString &line) {
    auto list = line.split("/");
    state_val = list[0].toUInt();
    path = Route::collect(list[1].split(":"));
}

OpenProject::OpenProject(const QString &path) : project_path(path) {}

QString OpenProject::name() const { return NAME(OpenProject); }

void OpenProject::run(Schedule::CommandsDispatcher *core) const {
    auto vmgr = core->get<DocumentsManager>(NAME(DocumentsManager));
    vmgr->projectManager()->openProject(project_path);
}

QString OpenProject::toText() const { return project_path; }

void OpenProject::fromText(const QString &line) { project_path = line; }

CloseProject::CloseProject() {}

QString CloseProject::name() const { return NAME(CloseProject); }

void CloseProject::run(Schedule::CommandsDispatcher *core) const {
    auto vmgr = core->get<DocumentsManager>(NAME(DocumentsManager));
    vmgr->save();
    vmgr->closeFile(vmgr->actives());
    vmgr->projectManager()->save();
    vmgr->projectManager()->closeProject();
}

QString CloseProject::toText() const { return ""; }

void CloseProject::fromText(const QString &line) {}

DeleteTarget::DeleteTarget(const Core::Route &target) : node_path(target) {}

DeleteTarget::DeleteTarget(const QModelIndex &target) : node_index(target) {}

QString DeleteTarget::name() const { return NAME(DeleteTarget); }

void DeleteTarget::run(Schedule::CommandsDispatcher *core) const {
    auto vmgr = core->get<DocumentsManager>(NAME(DocumentsManager));
    if (!node_index.isValid())
        vmgr->deleteNode(node_path);
    else {
        auto node_path = vmgr->convertPath(node_index);
        vmgr->deleteNode(node_path);
    }
}

QString DeleteTarget::toText() const { return node_path.links().join("/"); }

void DeleteTarget::fromText(const QString &line) { Route::collect(line.split("/", QString::SplitBehavior::SkipEmptyParts)); }