QtNovelUI/WordsIDE/command_list.cpp

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

using namespace CommandList;
using namespace Components;
using namespace Core;
using namespace MakeTools;

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

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

void NewPackage::run(Schedule::CommandsDispatcher *core) const
{
    auto vmgr = core->get<DocumentsManager>(NAME(DocumentsManager));
    vmgr->newPackage(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->newFile(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(SaveAll));
    vmgr->projectManager()->save();
    vmgr->save();
}

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

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

}

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->close();
    vmgr->projectManager()->save();
    vmgr->projectManager()->closeProject();
}

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];
}

Build::Build(bool fromdisk)
    :all_from_disk(fromdisk)
{

}

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

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

QString Build::toText() const
{
    return QString("%1").arg(all_from_disk);
}

void Build::fromText(const QString &line)
{
    all_from_disk = line.toUInt();
}

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(Route::collect(path_store));
    }
    else{
        auto index = mgr->projectManager()->queryIndex(final_file);
        auto route = mgr->pathOf(index);

        mgr->openFile(route);
    }
}

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

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


StorychainJumpTo::StorychainJumpTo(const QList<QString> &node_path)
{
    jump_path.append(node_path);
}

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

void StorychainJumpTo::run(Schedule::CommandsDispatcher *core) const
{
    auto core_ins = core->get<AppCore>(NAME(AppCore));
    auto chain_ins = core_ins->parseCore()->queryStoryChain(jump_path[0]).first();

    auto vmgr = core->get<DocumentsManager>(NAME(DocumentsManager));
    auto index = vmgr->projectManager()->queryIndex(chain_ins->doc()->filePath());
    auto route = vmgr->pathOf(index);

    vmgr->openFile(route);
    vmgr->activePresentOf(route)->jumpTo(jump_path);
}

QString StorychainJumpTo::toText() const
{
    return jump_path.join("/");
}

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


#include "storychainspresent.h"
using namespace Components;

StorychainDetailShow::StorychainDetailShow(const QList<QString> &chain_path)
    : chain_path(chain_path)
{

}

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

void StorychainDetailShow::run(Schedule::CommandsDispatcher *core) const
{
    auto backend = core->get<StorychainsPresentModel>(NAME(StorychainsPresentModel));
    backend->showDetails(chain_path);
}

QString StorychainDetailShow::toText() const
{
    return chain_path.join("/");
}

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