386 lines
13 KiB
C++
386 lines
13 KiB
C++
#include "./renamingengine.h"
|
|
#include "./filesystemitemmodel.h"
|
|
#include "./filteredfilesystemitemmodel.h"
|
|
#include "./tageditorobject.h"
|
|
|
|
#include <QDir>
|
|
#include <QStringBuilder>
|
|
|
|
#include <memory>
|
|
|
|
using namespace std;
|
|
|
|
namespace RenamingUtility {
|
|
|
|
RenamingEngine::RenamingEngine(QObject *parent)
|
|
: QObject(parent)
|
|
,
|
|
#ifndef TAGEDITOR_NO_JSENGINE
|
|
m_tagEditorQObj(new TagEditorObject(&m_engine))
|
|
, m_tagEditorJsObj(TAGEDITOR_JS_QOBJECT(m_engine, m_tagEditorQObj))
|
|
,
|
|
#endif
|
|
m_itemsProcessed(0)
|
|
, m_errorsOccured(0)
|
|
, m_aborted(false)
|
|
, m_includeSubdirs(false)
|
|
, m_isBusy(false)
|
|
, m_model(nullptr)
|
|
, m_currentModel(nullptr)
|
|
, m_previewModel(nullptr)
|
|
{
|
|
#ifndef TAGEDITOR_NO_JSENGINE
|
|
m_engine.globalObject().setProperty(QStringLiteral("tageditor"), m_tagEditorJsObj);
|
|
#endif
|
|
connect(this, &RenamingEngine::previewGenerated, this, &RenamingEngine::processPreviewGenerated);
|
|
connect(this, &RenamingEngine::changingsApplied, this, &RenamingEngine::processChangingsApplied);
|
|
}
|
|
|
|
#ifndef TAGEDITOR_NO_JSENGINE
|
|
bool RenamingEngine::setProgram(const TAGEDITOR_JS_VALUE &program)
|
|
{
|
|
if (program.isError()) {
|
|
m_errorMessage = program.property(QStringLiteral("message")).toString();
|
|
m_errorLineNumber = TAGEDITOR_JS_INT(program.property(QStringLiteral("lineNumber")));
|
|
return false;
|
|
} else if (!TAGEDITOR_JS_IS_VALID_PROG(program)) {
|
|
m_errorMessage = tr("Program is not callable. Please don't close a function you didn't open.");
|
|
m_errorLineNumber = 0;
|
|
return false;
|
|
}
|
|
|
|
m_errorMessage.clear();
|
|
m_errorLineNumber = 0;
|
|
m_program = program;
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
bool RenamingEngine::setProgram(const QString &program)
|
|
{
|
|
#ifndef TAGEDITOR_NO_JSENGINE
|
|
return setProgram(m_engine.evaluate(QStringLiteral("(function(){") % program % QStringLiteral("})")));
|
|
#else
|
|
m_errorLineNumber = 0;
|
|
m_errorMessage = tr("Not compiled with ECMA support.");
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
bool RenamingEngine::generatePreview(const QDir &rootDirectory, bool includeSubdirs)
|
|
{
|
|
#ifndef TAGEDITOR_NO_JSENGINE
|
|
if (m_isBusy) {
|
|
return false;
|
|
}
|
|
setRootItem();
|
|
m_includeSubdirs = includeSubdirs;
|
|
m_dir = rootDirectory;
|
|
|
|
(new PreviewGenerator(this))->start();
|
|
return m_isBusy = true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
bool RenamingEngine::applyChangings()
|
|
{
|
|
if (!m_rootItem || m_isBusy) {
|
|
return false;
|
|
}
|
|
(new RenamingThing(this))->start();
|
|
return m_isBusy = true;
|
|
}
|
|
|
|
bool RenamingEngine::clearPreview()
|
|
{
|
|
if (m_isBusy) {
|
|
return false;
|
|
}
|
|
|
|
updateModel(nullptr);
|
|
m_rootItem.reset();
|
|
return true;
|
|
}
|
|
|
|
FileSystemItemModel *RenamingEngine::model()
|
|
{
|
|
if (!m_model) {
|
|
m_model = new FileSystemItemModel(m_rootItem.get(), this);
|
|
}
|
|
return m_model;
|
|
}
|
|
|
|
FilteredFileSystemItemModel *RenamingEngine::currentModel()
|
|
{
|
|
if (!m_currentModel) {
|
|
m_currentModel = new FilteredFileSystemItemModel(ItemStatus::Current, this);
|
|
m_currentModel->setSourceModel(model());
|
|
}
|
|
return m_currentModel;
|
|
}
|
|
|
|
FilteredFileSystemItemModel *RenamingEngine::previewModel()
|
|
{
|
|
if (!m_previewModel) {
|
|
m_previewModel = new FilteredFileSystemItemModel(ItemStatus::New, this);
|
|
m_previewModel->setSourceModel(model());
|
|
}
|
|
return m_previewModel;
|
|
}
|
|
|
|
void RenamingEngine::processPreviewGenerated()
|
|
{
|
|
finalizeTaskCompletion();
|
|
setRootItem(move(m_newlyGeneratedRootItem));
|
|
}
|
|
|
|
void RenamingEngine::processChangingsApplied()
|
|
{
|
|
finalizeTaskCompletion();
|
|
updateModel(nullptr);
|
|
updateModel(m_rootItem.get());
|
|
}
|
|
|
|
void RenamingEngine::resetStatus()
|
|
{
|
|
m_aborted.store(false);
|
|
m_itemsProcessed = 0;
|
|
m_errorsOccured = 0;
|
|
}
|
|
|
|
void RenamingEngine::finalizeTaskCompletion()
|
|
{
|
|
m_engine.moveToThread(thread());
|
|
m_isBusy = false;
|
|
}
|
|
|
|
inline void RenamingEngine::setRootItem(unique_ptr<FileSystemItem> &&rootItem)
|
|
{
|
|
updateModel(rootItem.get());
|
|
m_rootItem = move(rootItem);
|
|
}
|
|
|
|
void RenamingEngine::updateModel(FileSystemItem *rootItem)
|
|
{
|
|
if (m_model) {
|
|
m_model->setRootItem(rootItem);
|
|
}
|
|
}
|
|
|
|
#ifndef TAGEDITOR_NO_JSENGINE
|
|
unique_ptr<FileSystemItem> RenamingEngine::generatePreview(const QDir &dir, FileSystemItem *parent)
|
|
{
|
|
auto item = make_unique<FileSystemItem>(ItemStatus::Current, ItemType::Dir, dir.dirName(), parent);
|
|
item->setApplied(false);
|
|
for (const QFileInfo &entry : dir.entryInfoList()) {
|
|
if (entry.fileName() == QLatin1String("..") || entry.fileName() == QLatin1String(".")) {
|
|
continue;
|
|
}
|
|
FileSystemItem *subItem; // will be deleted by parent
|
|
if (entry.isDir() && m_includeSubdirs) {
|
|
subItem = generatePreview(QDir(entry.absoluteFilePath()), item.get()).release();
|
|
} else if (entry.isFile()) {
|
|
subItem = new FileSystemItem(ItemStatus::Current, ItemType::File, entry.fileName(), item.get());
|
|
subItem->setApplied(false);
|
|
} else {
|
|
subItem = nullptr;
|
|
}
|
|
if (subItem) {
|
|
executeScriptForItem(entry, subItem);
|
|
if (subItem->errorOccured()) {
|
|
++m_errorsOccured;
|
|
}
|
|
}
|
|
++m_itemsProcessed;
|
|
if (isAborted()) {
|
|
return item;
|
|
}
|
|
}
|
|
emit progress(m_itemsProcessed, m_errorsOccured);
|
|
return item;
|
|
}
|
|
#endif
|
|
|
|
void RenamingEngine::applyChangings(FileSystemItem *parentItem)
|
|
{
|
|
for (auto *const item : parentItem->children()) {
|
|
if (!item->applied() && !item->errorOccured()) {
|
|
switch (item->status()) {
|
|
case ItemStatus::New: {
|
|
const FileSystemItem *counterpartItem = item->counterpart(); // holds current name
|
|
const QString currentPath = counterpartItem ? counterpartItem->relativePath() : QString();
|
|
const QString newPath = item->relativePath();
|
|
if (item->name().isEmpty()) {
|
|
// new item name mustn't be empty
|
|
item->setNote(tr("generated name is empty"));
|
|
item->setErrorOccured(true);
|
|
} else if (counterpartItem && !counterpartItem->name().isEmpty()) {
|
|
// rename current item
|
|
if (item->parent() != counterpartItem->parent() || item->name() != counterpartItem->name()) {
|
|
if (m_dir.exists(newPath)) {
|
|
if (item->parent() == counterpartItem->parent()) {
|
|
item->setNote(tr("unable to rename, there is already an entry with the same name"));
|
|
} else {
|
|
item->setNote(tr("unable to move, there is already an entry with the same name"));
|
|
}
|
|
item->setErrorOccured(true);
|
|
} else if (m_dir.rename(currentPath, newPath)) {
|
|
if (item->parent() == counterpartItem->parent()) {
|
|
item->setNote(tr("renamed"));
|
|
} else {
|
|
item->setNote(tr("moved"));
|
|
}
|
|
item->setApplied(true);
|
|
} else {
|
|
item->setNote(tr("unable to rename"));
|
|
item->setErrorOccured(true);
|
|
}
|
|
} else {
|
|
item->setNote(tr("nothing to be changed"));
|
|
item->setApplied(true);
|
|
}
|
|
} else if (item->type() == ItemType::Dir) {
|
|
// create new item, but only if its a dir
|
|
if (m_dir.exists(newPath)) {
|
|
item->setNote(tr("directory already existed"));
|
|
item->setApplied(true);
|
|
} else if (m_dir.mkpath(newPath)) {
|
|
item->setNote(tr("directory created"));
|
|
item->setApplied(true);
|
|
} else {
|
|
item->setNote(tr("unable to create directory"));
|
|
item->setErrorOccured(true);
|
|
}
|
|
} else {
|
|
// can not create new file
|
|
item->setNote(tr("unable to create file"));
|
|
item->setErrorOccured(true);
|
|
}
|
|
break;
|
|
}
|
|
case ItemStatus::Current:
|
|
break;
|
|
}
|
|
}
|
|
if (item->errorOccured()) {
|
|
++m_errorsOccured;
|
|
}
|
|
// apply changings for child items as well
|
|
if (item->type() == ItemType::Dir) {
|
|
applyChangings(item);
|
|
}
|
|
}
|
|
m_itemsProcessed += parentItem->children().size();
|
|
emit progress(m_itemsProcessed, m_errorsOccured);
|
|
}
|
|
|
|
void RenamingEngine::setError(const QList<FileSystemItem *> items)
|
|
{
|
|
for (auto *const item : items) {
|
|
item->setErrorOccured(true);
|
|
item->setNote(tr("skipped due to error of superior item"));
|
|
}
|
|
}
|
|
|
|
#ifndef TAGEDITOR_NO_JSENGINE
|
|
void RenamingEngine::executeScriptForItem(const QFileInfo &fileInfo, FileSystemItem *item)
|
|
{
|
|
// make file info for the specified item available in the script
|
|
m_tagEditorQObj->setFileInfo(fileInfo, item);
|
|
|
|
// execute script
|
|
const auto scriptResult(m_program.call());
|
|
if (scriptResult.isError()) {
|
|
// handle error
|
|
item->setErrorOccured(true);
|
|
item->setNote(scriptResult.toString());
|
|
return;
|
|
}
|
|
|
|
// create preview for action
|
|
const QString &newName = m_tagEditorQObj->newName();
|
|
const QString &newRelativeDirectory = m_tagEditorQObj->newRelativeDirectory();
|
|
switch (m_tagEditorQObj->action()) {
|
|
case ActionType::None:
|
|
item->setNote(tr("no action specified"));
|
|
break;
|
|
case ActionType::Rename:
|
|
if (!newRelativeDirectory.isEmpty()) {
|
|
FileSystemItem *const counterpartParent = item->root()->makeChildAvailable(newRelativeDirectory);
|
|
const QString &counterpartName = newName.isEmpty() ? item->name() : newName;
|
|
if (const auto *const conflictingItem = counterpartParent->findChild(counterpartName, item)) {
|
|
QString conflictingName;
|
|
if (const auto *const conflictingCounterpart = conflictingItem->counterpart()) {
|
|
conflictingCounterpart->relativePath(conflictingName);
|
|
} else {
|
|
conflictingName = conflictingItem->currentName();
|
|
}
|
|
item->setNote(tr("name is already used at new location by '%1'").arg(conflictingName));
|
|
item->setErrorOccured(true);
|
|
} else {
|
|
auto *const counterpart = new FileSystemItem(ItemStatus::New, item->type(), counterpartName, counterpartParent);
|
|
item->setCounterpart(counterpart);
|
|
counterpart->setCheckable(true);
|
|
counterpart->setChecked(true);
|
|
}
|
|
} else if (!newName.isEmpty()) {
|
|
item->setNewName(newName);
|
|
}
|
|
if (FileSystemItem *const newItem = item->counterpart()) {
|
|
if ((newItem->name().isEmpty() || newItem->name() == item->name()) && (newItem->parent() == item->parent())) {
|
|
item->setNote(tr("name doesn't change"));
|
|
} else if (newItem->parent() && newItem->parent()->findChild(newItem->name(), newItem)) {
|
|
item->setNote(tr("generated name is already used"));
|
|
item->setErrorOccured(true);
|
|
} else if (newItem->parent() == item->parent()) {
|
|
item->setNote(tr("will be renamed"));
|
|
newItem->setCheckable(true);
|
|
newItem->setChecked(true);
|
|
} else {
|
|
item->setNote(tr("will be moved"));
|
|
}
|
|
} else if (item->note().isEmpty()) {
|
|
item->setNote(tr("can not be renamed"));
|
|
}
|
|
break;
|
|
default:
|
|
item->setNote(m_tagEditorQObj->note().isEmpty() ? tr("skipped") : m_tagEditorQObj->note());
|
|
}
|
|
}
|
|
|
|
PreviewGenerator::PreviewGenerator(RenamingEngine *engine)
|
|
: QThread(engine)
|
|
, m_engine(engine)
|
|
{
|
|
m_engine->m_engine.moveToThread(this);
|
|
connect(this, &PreviewGenerator::finished, m_engine, &RenamingEngine::previewGenerated, Qt::QueuedConnection);
|
|
connect(this, &PreviewGenerator::finished, this, &PreviewGenerator::deleteLater);
|
|
}
|
|
|
|
void PreviewGenerator::run()
|
|
{
|
|
m_engine->resetStatus();
|
|
m_engine->m_newlyGeneratedRootItem = m_engine->generatePreview(m_engine->m_dir);
|
|
}
|
|
|
|
RenamingThing::RenamingThing(RenamingEngine *engine)
|
|
: QThread(engine)
|
|
, m_engine(engine)
|
|
{
|
|
m_engine->m_engine.moveToThread(this);
|
|
connect(this, &RenamingThing::finished, m_engine, &RenamingEngine::changingsApplied, Qt::QueuedConnection);
|
|
connect(this, &RenamingThing::finished, this, &RenamingThing::deleteLater);
|
|
}
|
|
|
|
void RenamingThing::run()
|
|
{
|
|
m_engine->resetStatus();
|
|
m_engine->applyChangings(m_engine->m_rootItem.get());
|
|
}
|
|
|
|
#endif
|
|
|
|
} // namespace RenamingUtility
|