1602 lines
53 KiB
C++
1602 lines
53 KiB
C++
|
||
|
||
#include "cleanuppopup.h"
|
||
|
||
// Toonz includes
|
||
#include "tapp.h"
|
||
#include "imageviewer.h"
|
||
#include "cleanupsettingsmodel.h"
|
||
#include "cellselection.h"
|
||
#include "columnselection.h"
|
||
#include "mainwindow.h"
|
||
|
||
// ToonzQt includes
|
||
#include "toonzqt/gutil.h"
|
||
#include "toonzqt/dvdialog.h"
|
||
#include "toonzqt/lineedit.h"
|
||
#include "toonzqt/menubarcommand.h"
|
||
#include "toonzqt/icongenerator.h"
|
||
|
||
// ToonzLib includes
|
||
#include "toonz/toonzscene.h"
|
||
#include "toonz/txshcell.h"
|
||
#include "toonz/txshsimplelevel.h"
|
||
#include "toonz/txshleveltypes.h"
|
||
#include "toonz/levelproperties.h"
|
||
#include "toonz/imagemanager.h"
|
||
#include "toonz/levelupdater.h"
|
||
#include "toonz/tcleanupper.h"
|
||
#include "toonz/preferences.h"
|
||
#include "toonz/tscenehandle.h"
|
||
#include "toonz/txsheethandle.h"
|
||
#include "toonz/txshlevelhandle.h"
|
||
#include "toonz/palettecontroller.h"
|
||
#include "toonz/tpalettehandle.h"
|
||
#include "toonz/toonzfolders.h"
|
||
|
||
// TnzCore includes
|
||
#include "tsystem.h"
|
||
#include "tlevel_io.h"
|
||
#include "timageinfo.h"
|
||
#include "tstream.h"
|
||
|
||
// Qt includes
|
||
#include <QLabel>
|
||
#include <QPushButton>
|
||
#include <QRadioButton>
|
||
#include <QButtonGroup>
|
||
#include <QCoreApplication>
|
||
#include <QMainWindow>
|
||
#include <QGroupBox>
|
||
|
||
// STL includes
|
||
#include <set>
|
||
#include <map>
|
||
#include <numeric>
|
||
#include <functional>
|
||
|
||
//*****************************************************************************
|
||
// Local namespace stuff
|
||
//*****************************************************************************
|
||
|
||
namespace {
|
||
|
||
enum Resolution {
|
||
NO_RESOLUTION, //!< No required resolution.
|
||
CANCEL, //!< Validation was canceled.
|
||
OVERWRITE, //!< Does not delete old cleanupped levels, but overwrites found
|
||
//! frames.
|
||
WRITE_NEW, //!< Like above, but does not overwrite. Just adds not cleanupped
|
||
//! frames.
|
||
REPLACE, //!< Destroy the old level and build one anew.
|
||
ADD_SUFFIX, //!< Add a suffix to the output path.
|
||
NOPAINT_ONLY //!< overwrite the result only in "nopaint" folder
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
static const std::wstring unpaintedStr = L"-unpainted";
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
inline QString suffix(int num) { return QString("_") + QString::number(num); }
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
inline TFilePath withSuffix(const TFilePath &fp, int num) {
|
||
return fp.withName(fp.getWideName() + suffix(num).toStdWString());
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
inline bool exists(const TFilePath &fp) {
|
||
return TSystem::doesExistFileOrLevel(
|
||
TApp::instance()->getCurrentScene()->getScene()->decodeFilePath(fp));
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
inline bool exists(const TFilePath &fp, int num) {
|
||
return exists(withSuffix(fp, num));
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void loadCleanupParams(CleanupParameters *params, TXshSimpleLevel *sl) {
|
||
params->assign(CleanupSettingsModel::instance()->getCurrentParameters());
|
||
CleanupSettingsModel::loadSettings(params,
|
||
CleanupSettingsModel::getClnPath(sl));
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
double getBestFactor(QSize viewSize, QSize imageSize) {
|
||
if (abs(viewSize.width() - imageSize.width()) >
|
||
abs(viewSize.height() - imageSize.height())) {
|
||
if (viewSize.width() > imageSize.width())
|
||
return double(imageSize.width()) / double(viewSize.width());
|
||
else
|
||
return double(viewSize.width()) / double(imageSize.width());
|
||
} else {
|
||
if (viewSize.height() > imageSize.height())
|
||
return double(imageSize.height()) / double(viewSize.height());
|
||
else
|
||
return double(viewSize.height()) / double(imageSize.height());
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
/*! cleanup後のファイルlevelPathに対してUnpaintedファイルを作る。
|
||
Cleanup後のUnpaintedの保存先を1階層下げる（nopaintフォルダ内に入れ、
|
||
"A_np.tlv"のように"_np"を付ける。"_unpainted"は長いので）
|
||
Paletteをキープするかどうかのフラグを追加
|
||
*/
|
||
void saveUnpaintedLevel(const TFilePath &levelPath, TXshSimpleLevel *sl,
|
||
std::vector<TFrameId> fids, bool keepOriginalPalette) {
|
||
try {
|
||
/*---nopaintフォルダの作成---*/
|
||
TFilePath nopaintDir = levelPath.getParentDir() + "nopaint";
|
||
if (!TFileStatus(nopaintDir).doesExist()) {
|
||
try {
|
||
TSystem::mkDir(nopaintDir);
|
||
} catch (...) {
|
||
return;
|
||
}
|
||
}
|
||
|
||
TFilePath unpaintedLevelPath =
|
||
levelPath.getParentDir() + "nopaint\\" +
|
||
TFilePath(levelPath.getName() + "_np." + levelPath.getType());
|
||
|
||
if (!TSystem::doesExistFileOrLevel(unpaintedLevelPath)) {
|
||
// No unpainted level exists. So, just copy the output file.
|
||
TSystem::copyFile(unpaintedLevelPath, levelPath);
|
||
if (keepOriginalPalette) return;
|
||
|
||
TFilePath levelPalettePath(levelPath.withType("tpl"));
|
||
TFilePath unpaintedLevelPalettePath =
|
||
levelPalettePath.getParentDir() + "nopaint\\" +
|
||
TFilePath(levelPalettePath.getName() + "_np." +
|
||
levelPalettePath.getType());
|
||
|
||
TSystem::copyFile(unpaintedLevelPalettePath, levelPalettePath);
|
||
|
||
return;
|
||
}
|
||
|
||
TLevelWriterP lw(unpaintedLevelPath);
|
||
|
||
if (keepOriginalPalette) lw->setOverwritePaletteFlag(false);
|
||
|
||
int i, fidsCount = fids.size();
|
||
for (i = 0; i < fidsCount; ++i) {
|
||
const TFrameId &fid = fids[i];
|
||
|
||
TToonzImageP ti = sl->getFrame(fid, false);
|
||
if (!ti) continue;
|
||
|
||
lw->getFrameWriter(fid)->save(ti);
|
||
}
|
||
} catch (...) {
|
||
}
|
||
}
|
||
|
||
//------------------------------------------------------------------------------
|
||
/*! Cleanup後のデフォルトPaletteを追加する。
|
||
TODO:
|
||
Cleanup後にデフォルトPaletteの内容を追加する仕様、Preferencesでオプション化
|
||
2016/1/16 shun_iwasawa
|
||
*/
|
||
void addCleanupDefaultPalette(TXshSimpleLevelP sl) {
|
||
/*--- CleanupデフォルトパレットはStudioPaletteフォルダ内に入れる ---*/
|
||
TFilePath palettePath =
|
||
ToonzFolder::getStudioPaletteFolder() + "cleanup_default.tpl";
|
||
TFileStatus pfs(palettePath);
|
||
|
||
if (!pfs.doesExist() || !pfs.isReadable()) {
|
||
DVGui::warning(
|
||
QString("CleanupDefaultPalette file: %1 is not found!")
|
||
.arg(QString::fromStdWString(palettePath.getWideString())));
|
||
return;
|
||
}
|
||
|
||
TIStream is(palettePath);
|
||
if (!is) {
|
||
DVGui::warning(
|
||
QString("CleanupDefaultPalette file: failed to get TIStream"));
|
||
return;
|
||
}
|
||
|
||
std::string tagName;
|
||
if (!is.matchTag(tagName) || tagName != "palette") {
|
||
DVGui::warning(
|
||
QString("CleanupDefaultPalette file: This is not palette file"));
|
||
return;
|
||
}
|
||
|
||
std::string gname;
|
||
is.getTagParam("name", gname);
|
||
TPalette *defaultPalette = new TPalette();
|
||
defaultPalette->loadData(is);
|
||
|
||
sl->getPalette()->setIsCleanupPalette(false);
|
||
|
||
TPalette::Page *dstPage = sl->getPalette()->getPage(0);
|
||
TPalette::Page *srcPage = defaultPalette->getPage(0);
|
||
|
||
for (int srcIndexInPage = 0; srcIndexInPage < srcPage->getStyleCount();
|
||
srcIndexInPage++) {
|
||
int id = srcPage->getStyleId(srcIndexInPage);
|
||
|
||
bool isUsedInCleanupPalette;
|
||
isUsedInCleanupPalette = false;
|
||
|
||
for (int dstIndexInPage = 0; dstIndexInPage < dstPage->getStyleCount();
|
||
dstIndexInPage++) {
|
||
if (dstPage->getStyleId(dstIndexInPage) == id) {
|
||
isUsedInCleanupPalette = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (isUsedInCleanupPalette)
|
||
continue;
|
||
|
||
else {
|
||
int addedId = sl->getPalette()->addStyle(
|
||
srcPage->getStyle(srcIndexInPage)->clone());
|
||
dstPage->addStyle(addedId);
|
||
/*---
|
||
* StudioPalette由来のDefaultPaletteの場合、GrobalName(リンク)を消去する
|
||
* ---*/
|
||
sl->getPalette()->getStyle(addedId)->setGlobalName(L"");
|
||
sl->getPalette()->getStyle(addedId)->setOriginalName(L"");
|
||
}
|
||
}
|
||
delete defaultPalette;
|
||
}
|
||
|
||
} // namespace
|
||
|
||
//*****************************************************************************
|
||
// CleanupLevel definition
|
||
//*****************************************************************************
|
||
|
||
struct CleanupPopup::CleanupLevel {
|
||
TXshSimpleLevel *m_sl; //!< Level to be cleanupped.
|
||
TFilePath m_outputPath; //!< Output path for the cleanupped level.
|
||
std::vector<TFrameId> m_frames; //!< Frames to cleanup.
|
||
Resolution m_resolution; //!< Resolution for verified file conflicts.
|
||
|
||
public:
|
||
CleanupLevel(TXshSimpleLevel *sl, const CleanupParameters ¶ms)
|
||
: m_sl(sl)
|
||
, m_outputPath(CleanupSettingsModel::getOutputPath(m_sl, ¶ms))
|
||
, m_resolution(NO_RESOLUTION) {}
|
||
|
||
bool empty() const { return m_frames.empty(); }
|
||
};
|
||
|
||
//*****************************************************************************
|
||
// CleanupPopup implementation
|
||
//*****************************************************************************
|
||
|
||
CleanupPopup::CleanupPopup()
|
||
: QDialog(TApp::instance()->getMainWindow())
|
||
, m_params(new CleanupParameters)
|
||
, m_updater(new LevelUpdater)
|
||
, m_originalLevelPath()
|
||
, m_originalPalette(0)
|
||
, m_firstLevelFrame(true) {
|
||
setWindowTitle(tr("Cleanup"));
|
||
// Progress Bar
|
||
m_progressLabel = new QLabel(tr("Cleanup in progress"));
|
||
m_progressBar = new QProgressBar;
|
||
// Text
|
||
m_cleanupQuestionLabel = new QLabel(tr("Do you want to cleanup this frame?"));
|
||
|
||
m_imageViewer = new ImageViewer(0, 0, false);
|
||
|
||
// Buttons
|
||
m_cleanupButton = new QPushButton(tr("Cleanup"));
|
||
m_skipButton = new QPushButton(tr("Skip"));
|
||
m_cleanupAllButton = new QPushButton(tr("Cleanup All"));
|
||
QPushButton *cancelButton = new QPushButton(tr("Cancel"));
|
||
m_imgViewBox = new QGroupBox(tr("View"), this);
|
||
|
||
m_imgViewBox->setCheckable(true);
|
||
m_imgViewBox->setChecked(false);
|
||
m_imageViewer->setVisible(false);
|
||
m_imageViewer->resize(406, 306);
|
||
|
||
//---layout
|
||
QVBoxLayout *mainLayout = new QVBoxLayout();
|
||
mainLayout->setMargin(5);
|
||
mainLayout->setSpacing(5);
|
||
{
|
||
mainLayout->addWidget(m_progressLabel, 0);
|
||
mainLayout->addWidget(m_progressBar, 0);
|
||
|
||
mainLayout->addWidget(m_cleanupQuestionLabel);
|
||
|
||
QVBoxLayout *imgBoxLay = new QVBoxLayout();
|
||
imgBoxLay->setMargin(5);
|
||
{ imgBoxLay->addWidget(m_imageViewer); }
|
||
m_imgViewBox->setLayout(imgBoxLay);
|
||
mainLayout->addWidget(m_imgViewBox, 1);
|
||
|
||
QHBoxLayout *buttonLay = new QHBoxLayout();
|
||
buttonLay->setMargin(0);
|
||
buttonLay->setSpacing(5);
|
||
{
|
||
buttonLay->addWidget(m_cleanupButton);
|
||
buttonLay->addWidget(m_skipButton);
|
||
buttonLay->addWidget(m_cleanupAllButton);
|
||
|
||
buttonLay->addWidget(cancelButton);
|
||
}
|
||
mainLayout->addLayout(buttonLay);
|
||
mainLayout->addStretch();
|
||
}
|
||
setLayout(mainLayout);
|
||
|
||
//--- signal-slot connections
|
||
|
||
bool ret = true;
|
||
ret = ret && connect(m_progressBar, SIGNAL(valueChanged(int)), this,
|
||
SLOT(onValueChanged(int)));
|
||
|
||
// NOTE: On MAC it seems that QAbstractButton's pressed() signal is reemitted
|
||
// at
|
||
// every mouseMoveEvent when the button is pressed...
|
||
// This is why clicked() substitutes pressed() below.
|
||
|
||
ret = ret && connect(m_cleanupButton, SIGNAL(clicked()), this,
|
||
SLOT(onCleanupFrame()));
|
||
ret = ret &&
|
||
connect(m_skipButton, SIGNAL(clicked()), this, SLOT(onSkipFrame()));
|
||
ret = ret && connect(m_cleanupAllButton, SIGNAL(clicked()), this,
|
||
SLOT(onCleanupAllFrame()));
|
||
ret = ret &&
|
||
connect(cancelButton, SIGNAL(clicked()), this, SLOT(onCancelCleanup()));
|
||
ret = ret && connect(m_imgViewBox, SIGNAL(toggled(bool)), this,
|
||
SLOT(onImgViewBoxToggled(bool)));
|
||
|
||
assert(ret);
|
||
|
||
reset(); // Initialize remaining variables
|
||
|
||
resize(450, 400);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
CleanupPopup::~CleanupPopup() {}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void CleanupPopup::closeEvent(QCloseEvent *ce) { reset(); }
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void CleanupPopup::reset() {
|
||
closeLevel();
|
||
|
||
m_idx = m_completion = std::pair<int, int>(-1, -1);
|
||
m_cleanupLevels.clear();
|
||
|
||
m_imageViewer->setImage(TImageP());
|
||
|
||
TCleanupper::instance()->setParameters(
|
||
CleanupSettingsModel::instance()->getCurrentParameters());
|
||
|
||
m_cleanupQuestionLabel->show();
|
||
|
||
m_levelAlreadyExists.clear();
|
||
|
||
/*---タイトルバーを元の表示に戻す---*/
|
||
MainWindow *mainWin =
|
||
qobject_cast<MainWindow *>(TApp::instance()->getMainWindow());
|
||
if (mainWin) mainWin->changeWindowTitle();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void CleanupPopup::buildCleanupList() {
|
||
struct locals {
|
||
static inline bool supportsCleanup(TXshSimpleLevel *sl) {
|
||
return (
|
||
sl->getType() & FULLCOLOR_TYPE ||
|
||
(sl->getType() == TZP_XSHLEVEL && !sl->getScannedPath().isEmpty()));
|
||
}
|
||
}; // locals
|
||
|
||
typedef std::set<TFrameId> FramesList;
|
||
|
||
/*--- これからCleanupするLevel/FrameIdのリスト ---*/
|
||
std::map<TXshSimpleLevel *, FramesList>
|
||
cleanupList; // List of frames to be cleanupped
|
||
std::vector<TXshSimpleLevel *>
|
||
levelsList; // List of levels in the cleanup list,
|
||
// ordered as found in the xsheet.
|
||
m_cleanupLevels.clear();
|
||
|
||
// Retrieve current selection
|
||
TCellSelection *selection =
|
||
dynamic_cast<TCellSelection *>(TSelection::getCurrent());
|
||
TColumnSelection *columnSel =
|
||
dynamic_cast<TColumnSelection *>(TSelection::getCurrent());
|
||
/*--- セル選択でも、カラム選択でも無い場合はCleanup自体を無効にする ---*/
|
||
if (!selection && !columnSel) return;
|
||
|
||
TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();
|
||
|
||
/*--- セル選択の場合 ---*/
|
||
if (selection) {
|
||
if (selection->isEmpty()) return;
|
||
// Store frames in the specified selection
|
||
int r0, c0, r1, c1;
|
||
selection->getSelectedCells(r0, c0, r1, c1);
|
||
|
||
int r, c;
|
||
for (c = c0; c <= c1; ++c) {
|
||
for (r = r0; r <= r1; ++r) {
|
||
/*---選択範囲内にLevelが無い場合はcontinue---*/
|
||
const TXshCell &cell = xsh->getCell(r, c);
|
||
if (cell.isEmpty()) continue;
|
||
TXshSimpleLevel *sl = cell.getSimpleLevel();
|
||
if (!(sl && locals::supportsCleanup(sl))) continue;
|
||
/*---もし新しいLevelなら、Levelのリストに登録---*/
|
||
std::map<TXshSimpleLevel *, FramesList>::iterator it =
|
||
cleanupList.find(sl);
|
||
if (it == cleanupList.end()) {
|
||
it = cleanupList.insert(std::make_pair(sl, FramesList())).first;
|
||
levelsList.push_back(sl);
|
||
}
|
||
/*---TFrameIdを登録---*/
|
||
it->second.insert(cell.getFrameId());
|
||
}
|
||
}
|
||
}
|
||
/*--- カラム選択の場合 ---*/
|
||
else {
|
||
int frameCount = xsh->getFrameCount();
|
||
if (columnSel->isEmpty() || frameCount <= 0) return;
|
||
/*--- 選択された各カラムについて ---*/
|
||
std::set<int>::const_iterator it = columnSel->getIndices().begin();
|
||
for (; it != columnSel->getIndices().end(); ++it) {
|
||
int c = (*it);
|
||
for (int r = 0; r < frameCount; r++) {
|
||
/*--- 選択範囲内にLevelが無い場合はcontinue ---*/
|
||
const TXshCell &cell = xsh->getCell(r, c);
|
||
if (cell.isEmpty()) continue;
|
||
TXshSimpleLevel *sl = cell.getSimpleLevel();
|
||
if (!sl && locals::supportsCleanup(sl)) continue;
|
||
/*---もし新しいLevelなら、Levelのリストに登録---*/
|
||
std::map<TXshSimpleLevel *, FramesList>::iterator it =
|
||
cleanupList.find(sl);
|
||
if (it == cleanupList.end()) {
|
||
it = cleanupList.insert(std::make_pair(sl, FramesList())).first;
|
||
levelsList.push_back(sl);
|
||
}
|
||
/*---TFrameIdを登録---*/
|
||
it->second.insert(cell.getFrameId());
|
||
}
|
||
}
|
||
}
|
||
|
||
// Finally, copy the retrieved data to the sorted output vector
|
||
std::vector<TXshSimpleLevel *>::iterator lt, lEnd = levelsList.end();
|
||
for (lt = levelsList.begin(); lt != lEnd; ++lt) {
|
||
loadCleanupParams(
|
||
m_params.get(),
|
||
*lt); // Load cleanup parameters associated with current level.
|
||
// This is necessary since the output path is specified among them.
|
||
m_cleanupLevels.push_back(CleanupLevel(*lt, *m_params.get()));
|
||
CleanupLevel &cl = m_cleanupLevels.back();
|
||
|
||
FramesList &framesList = cleanupList[cl.m_sl];
|
||
cl.m_frames.assign(framesList.begin(), framesList.end());
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
bool CleanupPopup::analyzeCleanupList() {
|
||
ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();
|
||
|
||
bool shownOverwriteDialog = false, shownWritingOnSourceFile = false;
|
||
|
||
/*--- 消されるLevel名の確認ダイアログを出すため ---*/
|
||
QList<TFilePath> filePathsToBeDeleted;
|
||
/* Cleanup前に既存のLevelを消す場合、セルのStatusをScannedに変更するために、
|
||
TXshSimpleLevelポインタを格納しておく
|
||
*/
|
||
QList<TXshSimpleLevel *> levelsToBeDeleted;
|
||
|
||
// Traverse the cleanup list
|
||
for (auto &clt : m_cleanupLevels) {
|
||
TXshSimpleLevel *sl = clt.m_sl;
|
||
|
||
/*--- Cleanup対象LevelのCleanupSettingを取得 ---*/
|
||
loadCleanupParams(m_params.get(),
|
||
sl); // Needed to retrieve output level resolution
|
||
|
||
// Check level existence
|
||
/*--- Cleanup後に得られるであろうTLVのパス ---*/
|
||
TFilePath outputPath = scene->decodeFilePath(clt.m_outputPath);
|
||
{
|
||
/*-- 出力先にTLVファイルが無ければ問題なし(このLevelはCleanupする) --*/
|
||
if (!TSystem::doesExistFileOrLevel(outputPath)) {
|
||
m_levelAlreadyExists[sl] = false;
|
||
continue; // Newly cleaned up level. No problem.
|
||
} else
|
||
m_levelAlreadyExists[sl] = true;
|
||
|
||
// Check whether output file == input file
|
||
/*--- 入力となるScanned（TIFなど）のパスを得る ---*/
|
||
const TFilePath &inputPath =
|
||
scene->decodeFilePath(CleanupSettingsModel::getInputPath(sl));
|
||
|
||
if (!shownWritingOnSourceFile && inputPath == outputPath) {
|
||
shownWritingOnSourceFile = true;
|
||
|
||
int ret = DVGui::MsgBox(tr("Selected drawings will overwrite the "
|
||
"original files after the cleanup process.\n"
|
||
"Do you want to continue?"),
|
||
tr("Ok"), tr("Cancel"));
|
||
|
||
if (ret != 1) return false;
|
||
}
|
||
|
||
/*---一度も上書き確認のダイアログを出していなかったら、ここで出す---*/
|
||
// Reset the overwrite dialog
|
||
if (!shownOverwriteDialog) {
|
||
shownOverwriteDialog = true;
|
||
|
||
if (!m_overwriteDialog)
|
||
m_overwriteDialog.reset(new OverwriteDialog);
|
||
else
|
||
m_overwriteDialog->reset();
|
||
}
|
||
|
||
// Prompt user for file conflict resolution
|
||
clt.m_resolution = Resolution(m_overwriteDialog->execute(&clt.m_outputPath));
|
||
switch (clt.m_resolution) {
|
||
case CANCEL:
|
||
return false;
|
||
|
||
case NO_RESOLUTION:
|
||
assert(false);
|
||
break;
|
||
case REPLACE:
|
||
/*--- 既存のTLVを消すオプションの場合、消されるファイルのリストを作る
|
||
* ---*/
|
||
break;
|
||
case ADD_SUFFIX:
|
||
continue;
|
||
case NOPAINT_ONLY:
|
||
/*--- NOPAINT_ONLY の場合は、nopaintのみを変更。
|
||
ただし、nopaintのLevelは消さず、処理したフレームを Overwrite
|
||
する
|
||
---*/
|
||
outputPath =
|
||
outputPath.getParentDir() + "nopaint\\" +
|
||
TFilePath(outputPath.getName() + "_np." + outputPath.getType());
|
||
/*--- nopaintの有無を確かめる。無ければ次のLevelへ
|
||
* (このLevelはCleanupする) ---*/
|
||
if (!TSystem::doesExistFileOrLevel(outputPath)) {
|
||
m_levelAlreadyExists[sl] = false;
|
||
continue;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
|
||
TLevelP level(0); // Current level info. Yeah the init is a shame... :(
|
||
/*--- 元のLevelと新しいCleanup結果が混合する場合。REPLACE以外 ---*/
|
||
if (clt.m_resolution == OVERWRITE || clt.m_resolution == WRITE_NEW ||
|
||
clt.m_resolution == NOPAINT_ONLY) {
|
||
// Check output resolution consistency
|
||
// Retrieve file resolution
|
||
/*---現在在るTLVのサイズと、CleanupSettingsのサイズが一致しているかチェック---*/
|
||
TDimension oldRes(0, 0);
|
||
try {
|
||
TLevelReaderP lr(outputPath);
|
||
level = lr->loadInfo();
|
||
|
||
if (const TImageInfo *imageInfo = lr->getImageInfo())
|
||
oldRes = TDimension(imageInfo->m_lx, imageInfo->m_ly);
|
||
else
|
||
throw TException();
|
||
} catch (...) {
|
||
// There was a problem reading the existing level data.
|
||
// Thus, the conservative approach is not feasible.
|
||
|
||
// Inform the user and abort cleanup
|
||
DVGui::warning(
|
||
tr("There were errors opening the existing level "
|
||
"\"%1\".\n\nPlease choose to delete the existing level and "
|
||
"create a new one\nwhen running the cleanup process.")
|
||
.arg(QString::fromStdWString(outputPath.getLevelNameW())));
|
||
|
||
return false;
|
||
}
|
||
|
||
// Retrieve output resolution
|
||
TDimension outRes(0, 0);
|
||
TPointD outDpi;
|
||
m_params->getOutputImageInfo(outRes, outDpi.x, outDpi.y);
|
||
|
||
if (oldRes != outRes) {
|
||
DVGui::warning(
|
||
tr("The resulting resolution of level \"%1\"\ndoes not match "
|
||
"with that of previously cleaned up level drawings.\n\nPlease "
|
||
"set the right camera resolution and closest field, or choose "
|
||
"to delete\nthe existing level and create a new one when "
|
||
"running the cleanup process.")
|
||
.arg(QString::fromStdWString(outputPath.getLevelNameW())));
|
||
|
||
return false;
|
||
}
|
||
}
|
||
/*--- REPLACEの場合、消されるファイルパスのリストを作る ---*/
|
||
else if (clt.m_resolution == REPLACE) {
|
||
filePathsToBeDeleted.push_back(outputPath);
|
||
|
||
levelsToBeDeleted.push_back(sl);
|
||
|
||
/*--- パレットファイルも、あれば消す ---*/
|
||
TFilePath palettePath =
|
||
(outputPath.getParentDir() + outputPath.getName()).withType("tpl");
|
||
if (TSystem::doesExistFileOrLevel(palettePath))
|
||
filePathsToBeDeleted.push_back(palettePath);
|
||
/*--- つぎに、nopaintのTLV。これは、REPLACE、NOPAINT_ONLY 両方で消す
|
||
* ---*/
|
||
TFilePath unpaintedLevelPath =
|
||
outputPath.getParentDir() + "nopaint\\" +
|
||
TFilePath(outputPath.getName() + "_np." + outputPath.getType());
|
||
if (TSystem::doesExistFileOrLevel(unpaintedLevelPath)) {
|
||
filePathsToBeDeleted.push_back(unpaintedLevelPath);
|
||
filePathsToBeDeleted.push_back(
|
||
(unpaintedLevelPath.getParentDir() + unpaintedLevelPath.getName())
|
||
.withType("tpl"));
|
||
}
|
||
}
|
||
|
||
// Finally, apply resolution to individual frames.
|
||
/*--- WRITE_NEW は、「未Cleanupのフレームだけ処理する」オプション ---*/
|
||
if (clt.m_resolution == WRITE_NEW) {
|
||
const TLevel::Table *table = level->getTable();
|
||
|
||
clt.m_frames.erase(
|
||
std::remove_if(clt.m_frames.begin(), clt.m_frames.end(),
|
||
[table](TLevel::Table::key_type const &key) {
|
||
return table->count(key);
|
||
}),
|
||
clt.m_frames.end());
|
||
}
|
||
}
|
||
}
|
||
|
||
/*--- ファイル消去の確認ダイアログを表示 ---*/
|
||
if (!filePathsToBeDeleted.isEmpty()) {
|
||
QString question = QObject::tr(
|
||
"Delete and Re-cleanup : The following files will be deleted.\n\n");
|
||
for (int i = 0; i < filePathsToBeDeleted.size(); i++) {
|
||
question +=
|
||
" " +
|
||
QString::fromStdWString(filePathsToBeDeleted[i].getWideString()) +
|
||
"\n";
|
||
}
|
||
question += QObject::tr("\nAre you sure ?");
|
||
|
||
int ret = DVGui::MsgBox(question, QObject::tr("Delete"),
|
||
QObject::tr("Cancel"), 0);
|
||
if (ret == 0 || ret == 2) {
|
||
return false;
|
||
} else if (ret == 1) {
|
||
/*--- 先にCleanup処理で出力先となるファイルを消す ---*/
|
||
try {
|
||
for (int i = 0; i < filePathsToBeDeleted.size(); i++) {
|
||
TSystem::removeFileOrLevel_throw(filePathsToBeDeleted[i]);
|
||
}
|
||
} catch (...) {
|
||
return false;
|
||
}
|
||
|
||
// Reset level status
|
||
for (int i = 0; i < levelsToBeDeleted.size(); i++) {
|
||
TXshSimpleLevel *lev = levelsToBeDeleted.at(i);
|
||
/*--- TLVだった場合、Scanned(TIFレベル)に戻す ---*/
|
||
TFilePath scannedPath = lev->getScannedPath();
|
||
if (scannedPath != TFilePath()) {
|
||
lev->setScannedPath(TFilePath());
|
||
lev->setPath(scannedPath, true);
|
||
lev->clearFrames();
|
||
lev->setType(OVL_XSHLEVEL); // OVL_XSHLEVEL
|
||
lev->setPalette(0);
|
||
if (lev == TApp::instance()->getCurrentLevel()->getLevel())
|
||
TApp::instance()
|
||
->getPaletteController()
|
||
->getCurrentLevelPalette()
|
||
->setPalette(0);
|
||
|
||
lev->load();
|
||
int i, frameCount = lev->getFrameCount();
|
||
for (i = 0; i < frameCount; i++) {
|
||
TFrameId id = lev->index2fid(i);
|
||
IconGenerator::instance()->invalidate(lev, id);
|
||
}
|
||
IconGenerator::instance()->invalidateSceneIcon();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Before returning, erase levels whose frames list is empty
|
||
/*--- Cleanup対象フレームが無くなったLevelを対象から外す ---*/
|
||
m_cleanupLevels.erase(
|
||
std::remove_if(m_cleanupLevels.begin(), m_cleanupLevels.end(),
|
||
std::mem_fn(&CleanupLevel::empty)),
|
||
m_cleanupLevels.end());
|
||
|
||
return true;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
bool CleanupPopup::isValidPosition(const std::pair<int, int> &pos) const {
|
||
if (pos.first < 0 || int(m_cleanupLevels.size()) <= pos.first) return false;
|
||
|
||
const CleanupLevel &cl = m_cleanupLevels[pos.first];
|
||
|
||
if (pos.second < 0 || int(cl.m_frames.size()) <= pos.second) return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
QString CleanupPopup::currentString() const {
|
||
if (!isValidPosition(m_idx)) return QString();
|
||
|
||
const CleanupLevel &cl = m_cleanupLevels[m_idx.first];
|
||
|
||
TXshSimpleLevel *sl = cl.m_sl;
|
||
const TFrameId &fid = cl.m_frames[m_idx.second];
|
||
|
||
TFilePath scannedPath(sl->getScannedPath());
|
||
if (scannedPath.isEmpty()) scannedPath = sl->getPath();
|
||
|
||
TFilePath levelName(scannedPath.getLevelNameW());
|
||
QString imageName = toQString(levelName.withFrame(fid));
|
||
|
||
return tr("Cleanup in progress: ") + imageName + " " +
|
||
QString::number(m_completion.first) + "/" +
|
||
QString::number(m_completion.second);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
/*--- これからCleanupするフレームを取得 ---*/
|
||
TImageP CleanupPopup::currentImage() const {
|
||
if (!isValidPosition(m_idx)) return TImageP();
|
||
|
||
const CleanupLevel &cl = m_cleanupLevels[m_idx.first];
|
||
return cl.m_sl->getFrameToCleanup(cl.m_frames[m_idx.second]);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void CleanupPopup::execute() {
|
||
struct locals {
|
||
static inline int addFrames(int a, const CleanupLevel &cl) {
|
||
return a + int(cl.m_frames.size());
|
||
}
|
||
}; // locals
|
||
|
||
// Re-initialize the list of frames to be cleanupped
|
||
/*--- Cleanup対象のリストを作る ---*/
|
||
buildCleanupList();
|
||
|
||
// In case some cleaned up level already exists, let the user decide what to
|
||
// do
|
||
if (!analyzeCleanupList()) {
|
||
reset();
|
||
return;
|
||
}
|
||
|
||
// Initialize completion variable
|
||
m_completion = std::pair<int, int>(
|
||
0, std::accumulate(m_cleanupLevels.begin(), m_cleanupLevels.end(), 0,
|
||
locals::addFrames));
|
||
|
||
// If there are no (more) frames to cleanup, warn and quit
|
||
int framesCount = m_completion.second;
|
||
if (!framesCount) {
|
||
DVGui::info(
|
||
tr("It is not possible to cleanup: the cleanup list is empty."));
|
||
|
||
reset();
|
||
return;
|
||
}
|
||
|
||
// Initialize the cleanup process and show the popup
|
||
|
||
m_idx = std::pair<int, int>(0, 0);
|
||
|
||
// Reset progress bar
|
||
m_progressLabel->setText(currentString());
|
||
|
||
m_progressBar->setRange(0, framesCount);
|
||
m_progressBar->setValue(0);
|
||
|
||
// show the progress to the main window's title bar
|
||
updateTitleString();
|
||
|
||
TImageP image = currentImage();
|
||
if (image) {
|
||
m_imageViewer->setImage(image);
|
||
|
||
// Set the zoom factor depending on image and viewer sizes, so that the
|
||
// image fits
|
||
// the preview area.
|
||
|
||
QSize viewSize = m_imageViewer->size();
|
||
QSize imageSize = QSize(image->getBBox().getLx(), image->getBBox().getLy());
|
||
double factor = getBestFactor(viewSize, imageSize);
|
||
TPointD delta(0, 0);
|
||
TAffine viewAff =
|
||
TTranslation(delta) * TScale(factor) * TTranslation(-delta);
|
||
m_imageViewer->setViewAff(viewAff);
|
||
}
|
||
|
||
show();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
QString CleanupPopup::setupLevel() {
|
||
// Level's pre-cleanup stuff initialization.
|
||
// Invoked right before the cleanupFrame() of the first level frame.
|
||
|
||
assert(isValidPosition(m_idx));
|
||
|
||
TApp *app = TApp::instance();
|
||
ToonzScene *scene = app->getCurrentScene()->getScene();
|
||
|
||
/*--- これからCleanupするLevel ---*/
|
||
CleanupLevel &cl = m_cleanupLevels[m_idx.first];
|
||
TXshSimpleLevel *sl = cl.m_sl;
|
||
|
||
/*--- 保存先のTLVが既に存在する、かつ、REPLACE でも
|
||
NOPAINT_ONLY でもない場合、Paletteを変更せず維持する ---*/
|
||
if (cl.m_resolution != REPLACE && cl.m_resolution != NOPAINT_ONLY &&
|
||
m_levelAlreadyExists[sl] == true)
|
||
m_keepOriginalPalette = true;
|
||
else
|
||
m_keepOriginalPalette = false;
|
||
|
||
// Update cleanup parameters, loading a cln if necessary
|
||
TCleanupper *cleanupper = TCleanupper::instance();
|
||
|
||
/*--- CleanupSettingsを読み込み、TCleanupperに渡す ---*/
|
||
loadCleanupParams(m_params.get(), sl);
|
||
cleanupper->setParameters(m_params.get());
|
||
|
||
// Touch the output parent directory
|
||
TFilePath &outputPath = cl.m_outputPath;
|
||
|
||
/*--- 保存先PathをFull Pathにする ---*/
|
||
TFilePath decodedPath(scene->decodeFilePath(outputPath));
|
||
if (!TSystem::touchParentDir(decodedPath))
|
||
return tr("Couldn't create directory \"%1\"").arg(decodedPath.getQString());
|
||
|
||
/*---
|
||
* 上書きオプションが選択されているとき、既存のLevel,Palette,Nopaintファイルを消す
|
||
* ---*/
|
||
// If the user decided to remove any existing level, do so now.
|
||
if (cl.m_resolution == REPLACE) {
|
||
const QString &err = resetLevel();
|
||
|
||
if (!err.isEmpty()) return err;
|
||
}
|
||
/*--- Nopaintのみ上書きのオプションが選択されているとき（再Clenaupの場合）
|
||
---*/
|
||
else if (cl.m_resolution == NOPAINT_ONLY) {
|
||
m_originalLevelPath = outputPath;
|
||
/*--- 必要なら、nopaintフォルダを作成 ---*/
|
||
TFilePath nopaintDir = decodedPath.getParentDir() + "nopaint";
|
||
if (!TFileStatus(nopaintDir).doesExist()) {
|
||
try {
|
||
TSystem::mkDir(nopaintDir);
|
||
} catch (...) {
|
||
return NULL;
|
||
}
|
||
}
|
||
/*--- 保存先のパスをnopaintの方に変更 ---*/
|
||
outputPath =
|
||
outputPath.getParentDir() + "nopaint\\" +
|
||
TFilePath(outputPath.getName() + "_np." + outputPath.getType());
|
||
decodedPath = scene->decodeFilePath(outputPath);
|
||
}
|
||
|
||
// Frames are cleaned-up at full-sampling. Thus, clear subsampling on the
|
||
// level.
|
||
if (sl->getProperties()->getSubsampling() != 1) {
|
||
sl->getProperties()->setSubsampling(1);
|
||
sl->invalidateFrames();
|
||
}
|
||
|
||
bool lineProcessing = (m_params->m_lineProcessingMode != lpNone),
|
||
notLineProcessed = (sl->getType() != TZP_XSHLEVEL);
|
||
|
||
if (lineProcessing) {
|
||
/*--- Keep original palette which will be reverted after cleanup ---*/
|
||
if (m_keepOriginalPalette) {
|
||
if ((sl->getType() == TZP_XSHLEVEL || sl->getType() == TZI_XSHLEVEL) &&
|
||
sl->getPalette() != NULL)
|
||
m_originalPalette = sl->getPalette()->clone();
|
||
else /*--- In case the level has been already cleanupped,
|
||
and is cleanupped again from raster level ---*/
|
||
{
|
||
/*--- Load and keep the palette from destination TLV ---*/
|
||
TFilePath targetPalettePath = outputPath.getParentDir() +
|
||
TFilePath(outputPath.getName() + ".tpl");
|
||
TFileStatus pfs(targetPalettePath);
|
||
if (pfs.doesExist() && pfs.isReadable()) {
|
||
TIStream is(targetPalettePath);
|
||
std::string tagName;
|
||
if (!is.matchTag(tagName) || tagName != "palette") {
|
||
DVGui::warning(QString(
|
||
"CleanupDefaultPalette file: This is not palette file"));
|
||
return NULL;
|
||
}
|
||
m_originalPalette = new TPalette();
|
||
m_originalPalette->loadData(is);
|
||
} else
|
||
m_originalPalette = 0;
|
||
}
|
||
}
|
||
|
||
if (notLineProcessed) {
|
||
/*-- Type, Pathを切り替えてTLVにする --*/
|
||
// The level type changes to TLV
|
||
sl->makeTlv(outputPath);
|
||
|
||
// Remap all current images under the IM control to Scanned status.
|
||
int f, fCount = sl->getFrameCount();
|
||
|
||
for (f = 0; f != fCount; ++f) {
|
||
const TFrameId &fid = sl->getFrameId(f);
|
||
|
||
/*--- 「スキャン済み」のステータスにし、画像、アイコンのIDを切り替える
|
||
* ---*/
|
||
sl->setFrameStatus(fid, TXshSimpleLevel::Scanned);
|
||
ImageManager::instance()->rebind(
|
||
sl->getImageId(fid, 0),
|
||
sl->getImageId(fid, TXshSimpleLevel::Scanned));
|
||
|
||
const std::string &oldIconId = sl->getIconId(fid, 0);
|
||
const std::string &newIconId =
|
||
sl->getIconId(fid, TXshSimpleLevel::Scanned);
|
||
|
||
IconGenerator::instance()->remap(newIconId, oldIconId);
|
||
}
|
||
}
|
||
/*--- 対象が既にTLVファイルで、出力先パスが違う場合、切り替える ---*/
|
||
else if (outputPath != sl->getPath()) {
|
||
// Just wants to be written to a different destination path. Update it.
|
||
sl->setPath(outputPath, false);
|
||
}
|
||
|
||
/*-- Cleanup用のパレットを作る --*/
|
||
// Update the level palette
|
||
TPaletteP palette =
|
||
TCleanupper::instance()->createToonzPaletteFromCleanupPalette();
|
||
|
||
sl->setPalette(palette.getPointer());
|
||
|
||
/*--- カレントPaletteを切り替える ---*/
|
||
if (sl == app->getCurrentLevel()->getLevel())
|
||
app->getPaletteController()->getCurrentLevelPalette()->setPalette(
|
||
palette.getPointer());
|
||
|
||
// Notify the xsheet that the level has changed visual type informations
|
||
// (either the level type,
|
||
// cleanup status, etc)
|
||
app->getCurrentXsheet()->notifyXsheetChanged();
|
||
} else if (!m_params->getPath(scene)
|
||
.isEmpty()) // Should never be empty, AFAIK...
|
||
{
|
||
// No line processing
|
||
|
||
if (notLineProcessed) {
|
||
// Just change paths
|
||
if (sl->getScannedPath().isEmpty()) sl->setScannedPath(sl->getPath());
|
||
|
||
sl->setPath(outputPath, false); // Reload frames from the result, too
|
||
} else {
|
||
// Return to scan level type
|
||
sl->clearFrames();
|
||
sl->setType(OVL_XSHLEVEL);
|
||
sl->setPath(outputPath);
|
||
}
|
||
}
|
||
|
||
// Finally, open the LevelUpdater on the level.
|
||
assert(!m_updater->opened());
|
||
try {
|
||
m_updater->open(sl);
|
||
} catch (...) {
|
||
return tr("Couldn't open \"%1\" for write").arg(outputPath.getQString());
|
||
}
|
||
|
||
m_updater->getLevelWriter()->setOverwritePaletteFlag(!m_keepOriginalPalette);
|
||
|
||
return QString();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
/* setupLevel()から、 m_overwriteAction == REPLACE のとき呼ばれる。
|
||
選択LevelのCleanup後Levelを消す
|
||
*/
|
||
QString CleanupPopup::resetLevel() {
|
||
struct locals {
|
||
static bool removeFileOrLevel(const TFilePath &fp) {
|
||
return (!TSystem::doesExistFileOrLevel(fp) ||
|
||
TSystem::removeFileOrLevel(fp));
|
||
}
|
||
|
||
static QString decorate(const TFilePath &fp) {
|
||
return tr("Couldn't remove file \"%1\"").arg(fp.getQString());
|
||
}
|
||
};
|
||
|
||
// Try to remove the existing level
|
||
const CleanupLevel &cl = m_cleanupLevels[m_idx.first];
|
||
|
||
TXshSimpleLevel *sl = cl.m_sl;
|
||
assert(sl);
|
||
|
||
ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();
|
||
|
||
/*--- Cleanup後のTLVファイルパスを得る。すなわちこれから消すファイル ---*/
|
||
// Ensure outputPath != inputPath
|
||
const TFilePath &outputPath = scene->decodeFilePath(cl.m_outputPath),
|
||
&inputPath = scene->decodeFilePath(
|
||
CleanupSettingsModel::getInputPath(sl));
|
||
|
||
if (inputPath == outputPath)
|
||
return QString(); // Cannot remove source file - however, it can be
|
||
// overwritten
|
||
|
||
// Remove existing output files
|
||
if (!locals::removeFileOrLevel(outputPath))
|
||
return locals::decorate(outputPath);
|
||
|
||
if (m_params->m_lineProcessingMode != lpNone) {
|
||
TFilePath fp;
|
||
|
||
// Line processing on - remove palette too
|
||
if (!locals::removeFileOrLevel(fp = outputPath.withType("tpl")))
|
||
return locals::decorate(fp);
|
||
|
||
// Also remove unpainted output path if any
|
||
const TFilePath &unpaintedPath(
|
||
outputPath.getParentDir() + "nopaint\\" +
|
||
TFilePath(outputPath.getName() + "_np." + outputPath.getType()));
|
||
|
||
if (!locals::removeFileOrLevel(unpaintedPath))
|
||
return locals::decorate(unpaintedPath);
|
||
|
||
if (!locals::removeFileOrLevel(fp = unpaintedPath.withType("tpl")))
|
||
return locals::decorate(fp);
|
||
}
|
||
|
||
// Reset level status
|
||
sl->setPath(sl->getPath(), false); // false rebuilds level data
|
||
// NOTE: sl is the INPUT level - so this instruction
|
||
return QString(); // should take place AFTER output availability
|
||
// has been ensured.
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
/*---
|
||
* 現在処理を行っているLevelの最後のフレームの処理が終わってから、フレームを進めるときに呼ばれる
|
||
* ---*/
|
||
void CleanupPopup::closeLevel() {
|
||
if (m_cleanuppedLevelFrames.empty()) {
|
||
if (m_updater->opened()) m_updater->close();
|
||
return;
|
||
}
|
||
|
||
// Save the unpainted level if necessary
|
||
const CleanupLevel &cl = m_cleanupLevels[m_idx.first];
|
||
|
||
TXshSimpleLevel *sl = cl.m_sl;
|
||
assert(sl);
|
||
|
||
/*--- Nopaintのみ上書きの場合、Cleanup前に戻す ---*/
|
||
if (cl.m_resolution == NOPAINT_ONLY && !m_originalLevelPath.isEmpty()) {
|
||
sl->setPath(m_originalLevelPath);
|
||
sl->invalidateFrames();
|
||
std::vector<TFrameId> fIds;
|
||
sl->getFids(fIds);
|
||
invalidateIcons(sl, fIds);
|
||
m_originalLevelPath = TFilePath();
|
||
}
|
||
/*--- Paletteを更新しない場合は、ここで取っておいたPaletteデータを元に戻す
|
||
* ---*/
|
||
if (m_keepOriginalPalette && m_originalPalette) {
|
||
sl->setPalette(m_originalPalette);
|
||
if (sl == TApp::instance()->getCurrentLevel()->getLevel())
|
||
TApp::instance()
|
||
->getPaletteController()
|
||
->getCurrentLevelPalette()
|
||
->setPalette(m_originalPalette);
|
||
sl->invalidateFrames();
|
||
std::vector<TFrameId> fIds;
|
||
sl->getFids(fIds);
|
||
invalidateIcons(sl, fIds);
|
||
TApp::instance()->getCurrentPalette()->notifyPaletteSwitched();
|
||
}
|
||
|
||
// Close the level updater. Silence any exception (ok, something went bad, old
|
||
// story now).
|
||
try {
|
||
m_updater->close();
|
||
} catch (...) {
|
||
}
|
||
|
||
if (sl->getType() == TZP_XSHLEVEL &&
|
||
Preferences::instance()->isSaveUnpaintedInCleanupEnable() &&
|
||
cl.m_resolution !=
|
||
NOPAINT_ONLY) /*--- 再Cleanupの場合は既にNoPaintに上書きしている ---*/
|
||
{
|
||
const TFilePath &outputPath = cl.m_outputPath;
|
||
|
||
ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();
|
||
TFilePath decodedPath(scene->decodeFilePath(outputPath));
|
||
|
||
if (outputPath.getLevelNameW().find(L"-np.") == std::wstring::npos &&
|
||
TFileStatus(decodedPath).doesExist()) {
|
||
saveUnpaintedLevel(decodedPath, sl, m_cleanuppedLevelFrames,
|
||
(m_keepOriginalPalette && m_originalPalette));
|
||
}
|
||
}
|
||
|
||
m_cleanuppedLevelFrames.clear();
|
||
m_firstLevelFrame = true;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
/*-- 各フレームの処理 --*/
|
||
void CleanupPopup::cleanupFrame() {
|
||
assert(isValidPosition(m_idx));
|
||
|
||
TRasterImageP original(currentImage());
|
||
if (!original) return;
|
||
|
||
CleanupLevel &cl = m_cleanupLevels[m_idx.first];
|
||
TXshSimpleLevel *sl = cl.m_sl;
|
||
const TFrameId &fid = cl.m_frames[m_idx.second];
|
||
|
||
assert(sl);
|
||
|
||
// Perform image cleanup
|
||
{
|
||
TCleanupper *cl = TCleanupper::instance();
|
||
const CleanupParameters *params = cl->getParameters();
|
||
|
||
if (params->m_lineProcessingMode == lpNone) {
|
||
// No line processing
|
||
|
||
TRasterImageP ri(original);
|
||
if (params->m_autocenterType != CleanupTypes::AUTOCENTER_NONE) {
|
||
bool autocentered;
|
||
ri = cl->autocenterOnly(original, false, autocentered);
|
||
if (!autocentered)
|
||
DVGui::warning(
|
||
QObject::tr("The autocentering failed on the current drawing."));
|
||
}
|
||
|
||
sl->setFrame(fid, ri);
|
||
|
||
// Update the associated file. In case the operation throws, oh well the
|
||
// image gets skipped.
|
||
try {
|
||
m_updater->update(fid, ri);
|
||
} catch (...) {
|
||
}
|
||
|
||
IconGenerator::instance()->invalidate(sl, fid);
|
||
} else {
|
||
// Perform main processing
|
||
|
||
// Obtain the source dpi. Changed it to be done once at the first frame of
|
||
// each level in order to avoid the following problem:
|
||
// If the original raster level has no dpi (such as TGA images), obtaining
|
||
// dpi in every frame causes dpi mismatch between the first frame and the
|
||
// following frames, since the value
|
||
// TXshSimpleLevel::m_properties->getDpi() will be changed to the
|
||
// dpi of cleanup camera (= TLV's dpi) after finishing the first frame.
|
||
if (m_firstLevelFrame) {
|
||
TPointD dpi;
|
||
original->getDpi(dpi.x, dpi.y);
|
||
if (dpi.x == 0 && dpi.y == 0) dpi = sl->getProperties()->getDpi();
|
||
cl->setSourceDpi(dpi);
|
||
}
|
||
|
||
CleanupPreprocessedImage *cpi;
|
||
{
|
||
TRasterImageP resampledRaster;
|
||
cpi = cl->process(original, m_firstLevelFrame, resampledRaster);
|
||
}
|
||
|
||
if (!cpi) return;
|
||
|
||
// Perform post-processing
|
||
TToonzImageP ti(cl->finalize(cpi));
|
||
|
||
/*--- Cleanup Default Paletteを作成、適用 ---*/
|
||
if (m_firstLevelFrame) {
|
||
addCleanupDefaultPalette(sl);
|
||
sl->getPalette()->setPaletteName(sl->getName());
|
||
}
|
||
|
||
ti->setPalette(sl->getPalette()); // Assigned to sl in setupLevel()
|
||
assert(sl->getPalette());
|
||
|
||
// Update the level data about the cleanupped frame
|
||
sl->setFrameStatus(fid,
|
||
sl->getFrameStatus(fid) | TXshSimpleLevel::Cleanupped);
|
||
sl->setFrame(fid, TImageP()); // Invalidate the old image data
|
||
|
||
// Output the cleanupped image to disk
|
||
try {
|
||
m_updater->update(fid, ti);
|
||
} // The file image data will be reloaded upon request
|
||
catch (...) {
|
||
}
|
||
|
||
// Invalidate icons
|
||
IconGenerator::instance()->invalidate(sl, fid);
|
||
|
||
int autocenterType = params->m_autocenterType;
|
||
if (autocenterType == CleanupTypes::AUTOCENTER_FDG &&
|
||
!cpi->m_autocentered)
|
||
DVGui::warning(
|
||
QObject::tr("The autocentering failed on the current drawing."));
|
||
|
||
delete cpi;
|
||
|
||
if (m_firstLevelFrame) {
|
||
// Update result-dependent level data
|
||
TPointD dpi(0, 0);
|
||
ti->getDpi(dpi.x, dpi.y);
|
||
if (dpi.x != 0 && dpi.y != 0) sl->getProperties()->setDpi(dpi);
|
||
|
||
sl->getProperties()->setImageRes(ti->getSize());
|
||
sl->getProperties()->setBpp(32);
|
||
}
|
||
}
|
||
}
|
||
|
||
// this enables to view the level during cleanup by another user. this
|
||
// behavior may abort Toonz.
|
||
/*
|
||
try { m_updater->flush(); } // Release
|
||
the opened level from writing
|
||
catch(...) {} // It is
|
||
required to have it open for read
|
||
// when
|
||
rebuilding icons... (still dangerous though)
|
||
*/
|
||
m_firstLevelFrame = false;
|
||
m_cleanuppedLevelFrames.push_back(fid);
|
||
|
||
TApp *app = TApp::instance();
|
||
app->getCurrentLevel()->notifyLevelChange();
|
||
app->getCurrentXsheet()->notifyXsheetChanged();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void CleanupPopup::advanceFrame() {
|
||
assert(isValidPosition(m_idx));
|
||
|
||
std::pair<int, int> newIdx = std::make_pair(m_idx.first, m_idx.second + 1);
|
||
|
||
// In case the level was completely processed, close down the old level
|
||
if (!isValidPosition(newIdx)) {
|
||
if (!m_cleanuppedLevelFrames.empty()) closeLevel();
|
||
|
||
newIdx = std::make_pair(m_idx.first + 1, 0);
|
||
}
|
||
|
||
// Advance in the cleanup list
|
||
m_idx = newIdx;
|
||
|
||
if (m_imgViewBox->isChecked()) {
|
||
TImageP image = currentImage();
|
||
if (image) m_imageViewer->setImage(image);
|
||
}
|
||
|
||
// show the progress in the mainwindow's title bar
|
||
updateTitleString();
|
||
|
||
// Update the progress bar
|
||
m_progressBar->setValue(++m_completion.first);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void CleanupPopup::onValueChanged(int value) {
|
||
if (value == m_progressBar->maximum()) {
|
||
close();
|
||
return;
|
||
}
|
||
|
||
m_progressLabel->setText(currentString());
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void CleanupPopup::onCleanupFrame() {
|
||
/*--- Busy時にボタンをUnableする ---*/
|
||
m_cleanupAllButton->setEnabled(false);
|
||
m_cleanupButton->setEnabled(false);
|
||
m_skipButton->setEnabled(false);
|
||
|
||
/*--- 新しいLevelに取り掛かり始めたとき ---*/
|
||
if (m_cleanuppedLevelFrames.empty()) {
|
||
const QString &err = setupLevel();
|
||
|
||
if (!err.isEmpty()) {
|
||
DVGui::error(err);
|
||
return;
|
||
}
|
||
}
|
||
|
||
cleanupFrame();
|
||
advanceFrame();
|
||
|
||
/*--- ボタンを元に戻す---*/
|
||
m_cleanupAllButton->setEnabled(true);
|
||
m_cleanupButton->setEnabled(true);
|
||
m_skipButton->setEnabled(true);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void CleanupPopup::onSkipFrame() { advanceFrame(); }
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void CleanupPopup::onCleanupAllFrame() {
|
||
m_cleanupQuestionLabel->hide();
|
||
|
||
/*--- Busy時にボタンをUnableする ---*/
|
||
m_cleanupAllButton->setEnabled(false);
|
||
m_cleanupButton->setEnabled(false);
|
||
m_skipButton->setEnabled(false);
|
||
|
||
while (isValidPosition(m_idx)) {
|
||
if (m_cleanuppedLevelFrames.empty()) {
|
||
const QString &err = setupLevel();
|
||
|
||
if (!err.isEmpty()) {
|
||
DVGui::error(err);
|
||
return;
|
||
}
|
||
}
|
||
|
||
cleanupFrame();
|
||
advanceFrame();
|
||
|
||
QCoreApplication::processEvents(); // Allow cancels to be received
|
||
}
|
||
/*--- ボタンを元に戻す---*/
|
||
m_cleanupAllButton->setEnabled(true);
|
||
m_cleanupButton->setEnabled(true);
|
||
m_skipButton->setEnabled(true);
|
||
|
||
close();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void CleanupPopup::onCancelCleanup() { close(); }
|
||
|
||
//*****************************************************************************
|
||
// CleanupPopup::OverwriteDialog implementation
|
||
//*****************************************************************************
|
||
|
||
CleanupPopup::OverwriteDialog::OverwriteDialog()
|
||
: DVGui::ValidatedChoiceDialog(TApp::instance()->getMainWindow()) {
|
||
setWindowTitle(tr("Warning!"));
|
||
|
||
bool ret = connect(m_buttonGroup, SIGNAL(buttonClicked(int)),
|
||
SLOT(onButtonClicked(int)));
|
||
assert(ret);
|
||
|
||
// Option 1: OVERWRITE
|
||
QRadioButton *radioButton = new QRadioButton;
|
||
radioButton->setText(
|
||
tr("Cleanup all selected drawings overwriting those previously cleaned "
|
||
"up.*"));
|
||
radioButton->setFixedHeight(20);
|
||
radioButton->setChecked(true); // initial option: OVERWRITE
|
||
|
||
m_buttonGroup->addButton(radioButton, OVERWRITE);
|
||
addWidget(radioButton);
|
||
|
||
// Option 2: WRITE_NEW
|
||
radioButton = new QRadioButton;
|
||
radioButton->setText(
|
||
tr("Cleanup only non-cleaned up drawings and keep those previously "
|
||
"cleaned up.*"));
|
||
radioButton->setFixedHeight(20);
|
||
|
||
m_buttonGroup->addButton(radioButton, WRITE_NEW);
|
||
addWidget(radioButton);
|
||
|
||
// Option 3: REPLACE
|
||
radioButton = new QRadioButton;
|
||
radioButton->setText(
|
||
tr("Delete existing level and create a new level with selected drawings "
|
||
"only."));
|
||
radioButton->setFixedHeight(20);
|
||
|
||
m_buttonGroup->addButton(radioButton, REPLACE);
|
||
addWidget(radioButton);
|
||
|
||
// Option 4: ADD_SUFFIX
|
||
QHBoxLayout *suffixLayout = new QHBoxLayout;
|
||
{
|
||
radioButton = new QRadioButton;
|
||
radioButton->setText(tr("Rename the new level adding the suffix "));
|
||
radioButton->setFixedHeight(20);
|
||
|
||
m_buttonGroup->addButton(radioButton, ADD_SUFFIX);
|
||
suffixLayout->addWidget(radioButton);
|
||
|
||
m_suffix = new DVGui::LineEdit;
|
||
m_suffix->setEnabled(false);
|
||
|
||
suffixLayout->addWidget(m_suffix);
|
||
}
|
||
addLayout(suffixLayout); // Couldnt' place it right after allocation,
|
||
// DVGui::Dialog::addLayout() crashed...
|
||
// Option 5: NOPAINT_ONLY
|
||
radioButton = new QRadioButton(this);
|
||
radioButton->setText(
|
||
tr("This is Re-Cleanup. Overwrite only to the no-paint files."));
|
||
radioButton->setFixedHeight(20);
|
||
m_buttonGroup->addButton(radioButton, NOPAINT_ONLY);
|
||
addWidget(radioButton);
|
||
|
||
QLabel *note = new QLabel(tr("* Palette will not be changed."), this);
|
||
note->setStyleSheet("font-size: 10px; font: italic;");
|
||
addWidget(note);
|
||
|
||
endVLayout();
|
||
|
||
layout()->setSizeConstraint(QLayout::SetFixedSize);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void CleanupPopup::OverwriteDialog::reset() {
|
||
ValidatedChoiceDialog::reset();
|
||
m_suffixText.clear();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
QString CleanupPopup::OverwriteDialog::acceptResolution(void *obj,
|
||
int resolution,
|
||
bool applyToAll) {
|
||
struct locals {
|
||
static inline QString existsStr(const TFilePath &fp) {
|
||
return tr("File \"%1\" already exists.\nWhat do you want to do?")
|
||
.arg(fp.getQString());
|
||
}
|
||
}; // locals
|
||
|
||
assert(obj);
|
||
|
||
TFilePath &fp = *static_cast<TFilePath *>(obj);
|
||
|
||
QString error;
|
||
|
||
switch (resolution) {
|
||
case NO_RESOLUTION:
|
||
// fp was already found to be invalid
|
||
assert(::exists(fp));
|
||
error = locals::existsStr(fp);
|
||
|
||
// Restore previous apply-to-all options if necessary
|
||
if (!error.isEmpty() && appliedToAll()) {
|
||
assert(!m_suffixText.isEmpty());
|
||
m_suffix->setText(m_suffixText);
|
||
}
|
||
break;
|
||
|
||
case ADD_SUFFIX:
|
||
// Save resolution options if necessary
|
||
if (applyToAll) m_suffixText = m_suffix->text();
|
||
|
||
// Test produced file path
|
||
const TFilePath &fp_suf =
|
||
fp.withName(fp.getWideName() + m_suffix->text().toStdWString());
|
||
|
||
if (::exists(fp_suf))
|
||
error = locals::existsStr(fp_suf);
|
||
else
|
||
fp = fp_suf;
|
||
|
||
break;
|
||
}
|
||
|
||
return error;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void CleanupPopup::OverwriteDialog::initializeUserInteraction(const void *obj) {
|
||
const TFilePath &fp = *static_cast<const TFilePath *>(obj);
|
||
|
||
// Generate a suitable initial suffix
|
||
int num = 1;
|
||
for (; ::exists(fp, num); ++num)
|
||
;
|
||
|
||
m_suffix->setText(::suffix(num));
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void CleanupPopup::OverwriteDialog::onButtonClicked(int buttonId) {
|
||
m_suffix->setEnabled(buttonId == ADD_SUFFIX);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void CleanupPopup::onImgViewBoxToggled(bool on) {
|
||
m_imageViewer->setVisible(on);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
/*! Show the progress in the mainwindow's title bar
|
||
*/
|
||
void CleanupPopup::updateTitleString() {
|
||
if (!TApp::instance()->getMainWindow()) return;
|
||
MainWindow *mainWin =
|
||
qobject_cast<MainWindow *>(TApp::instance()->getMainWindow());
|
||
if (!mainWin) return;
|
||
|
||
QString str = QString::number(m_completion.first) + "/" +
|
||
QString::number(m_completion.second) +
|
||
tr(" : Cleanup in progress");
|
||
|
||
mainWin->changeWindowTitle(str);
|
||
}
|
||
|
||
//*****************************************************************************
|
||
// CleanupCommand definition
|
||
//*****************************************************************************
|
||
|
||
class CleanupCommand final : public MenuItemHandler {
|
||
public:
|
||
CleanupCommand() : MenuItemHandler("MI_Cleanup") {}
|
||
|
||
void execute() override {
|
||
static CleanupPopup *popup = new CleanupPopup;
|
||
popup->execute();
|
||
}
|
||
|
||
} CleanupCommand;
|