#include "toonz/studiopalettecmd.h"
#include "toonz/tpalettehandle.h"
#include "toonz/txsheethandle.h"
#include "toonz/txshlevelhandle.h"
#include "tundo.h"
#include "tcolorstyles.h"
#include "tsystem.h"
#include "tconvert.h"
#include "ttoonzimage.h"
#include "timagecache.h"
#include "toonz/studiopalette.h"
#include "toonz/toonzscene.h"
#include "toonz/levelset.h"
#include "toonz/txshsimplelevel.h"
#include "toonz/txshleveltypes.h"
#include "toonz/sceneproperties.h"
#include "toonz/toonzfolders.h"
#include "toonz/txsheet.h"
#include <QApplication>
#include "historytypes.h"
/*! \namespace StudioPaletteCmd
\brief Provides a collection of methods to manage \b StudioPalette.
*/
//=============================================================================
namespace
{
//-----------------------------------------------------------------------------
//=============================================================================
//PaletteAssignUndo : Undo for the "Load into Current Palette" command.
class PaletteAssignUndo : public TUndo
{
TPaletteP m_targetPalette, m_oldPalette, m_newPalette;
TPaletteHandle *m_paletteHandle;
public:
PaletteAssignUndo(
const TPaletteP &targetPalette,
const TPaletteP &oldPalette,
const TPaletteP &newPalette,
TPaletteHandle *paletteHandle)
: m_targetPalette(targetPalette), m_oldPalette(oldPalette), m_newPalette(newPalette), m_paletteHandle(paletteHandle)
{
}
void undo() const
{
m_targetPalette->assign(m_oldPalette.getPointer());
m_paletteHandle->notifyPaletteChanged();
}
void redo() const
{
m_targetPalette->assign(m_newPalette.getPointer());
m_paletteHandle->notifyPaletteChanged();
}
int getSize() const
{
return sizeof(*this) +
(m_targetPalette->getStyleCount() +
m_oldPalette->getStyleCount() +
m_newPalette->getStyleCount()) *
100;
}
QString getHistoryString()
{
return QObject::tr("Load into Current Palette > %1")
.arg(QString::fromStdWString(m_targetPalette->getPaletteName()));
}
int getHistoryType()
{
return HistoryType::Palette;
}
};
//=============================================================================
//StudioPaletteAssignUndo : Undo for the "Replace with Current Palette" command.
class StudioPaletteAssignUndo : public TUndo
{
TPaletteP m_oldPalette, m_newPalette;
TFilePath m_fp;
TPaletteHandle *m_paletteHandle;
public:
StudioPaletteAssignUndo(
const TFilePath &targetPath,
const TPaletteP &oldPalette,
const TPaletteP &newPalette,
TPaletteHandle *paletteHandle)
: m_fp(targetPath), m_oldPalette(oldPalette), m_newPalette(newPalette), m_paletteHandle(paletteHandle)
{
}
void undo() const
{
StudioPalette *sp = StudioPalette::instance();
sp->setPalette(m_fp, m_oldPalette.getPointer(), true);
m_paletteHandle->notifyPaletteChanged();
}
void redo() const
{
StudioPalette *sp = StudioPalette::instance();
sp->setPalette(m_fp, m_newPalette.getPointer(), true);
m_paletteHandle->notifyPaletteChanged();
}
int getSize() const
{
return sizeof(*this) +
(m_oldPalette->getStyleCount() +
m_newPalette->getStyleCount()) *
100;
}
QString getHistoryString()
{
return QObject::tr("Replace with Current Palette > %1")
.arg(QString::fromStdString(m_fp.getLevelName()));
}
int getHistoryType()
{
return HistoryType::Palette;
}
};
//=============================================================================
//DeletePaletteUndo
class DeletePaletteUndo : public TUndo
{
TFilePath m_palettePath;
TPaletteP m_palette;
public:
DeletePaletteUndo(const TFilePath &palettePath)
: m_palettePath(palettePath)
{
m_palette = StudioPalette::instance()->getPalette(m_palettePath);
}
void undo() const
{
StudioPalette::instance()->setPalette(m_palettePath, m_palette->clone(), true);
}
void redo() const
{
StudioPalette::instance()->deletePalette(m_palettePath);
}
int getSize() const
{
return sizeof(*this) + sizeof(TPalette);
}
QString getHistoryString()
{
return QObject::tr("Delete Studio Palette : %1")
.arg(QString::fromStdString(m_palettePath.getLevelName()));
}
int getHistoryType()
{
return HistoryType::Palette;
}
};
//=============================================================================
//CreatePaletteUndo
class CreatePaletteUndo : public TUndo
{
TFilePath m_palettePath;
TPaletteP m_palette;
public:
CreatePaletteUndo(const TFilePath &palettePath)
: m_palettePath(palettePath)
{
m_palette = StudioPalette::instance()->getPalette(m_palettePath);
}
void undo() const
{
StudioPalette::instance()->deletePalette(m_palettePath);
}
void redo() const
{
StudioPalette::instance()->setPalette(m_palettePath, m_palette->clone(), true);
}
int getSize() const
{
return sizeof(*this) + sizeof(TPalette);
}
QString getHistoryString()
{
return QObject::tr("Create Studio Palette : %1")
.arg(QString::fromStdString(m_palettePath.getLevelName()));
}
int getHistoryType()
{
return HistoryType::Palette;
}
};
//=============================================================================
//DeleteFolderUndo
class DeleteFolderUndo : public TUndo
{
TFilePath m_path;
TFilePathSet m_pathSet;
QList<TPaletteP> m_paletteList;
public:
DeleteFolderUndo(const TFilePath &path, const TFilePathSet &pathSet)
: m_path(path), m_pathSet(pathSet), m_paletteList()
{
for (TFilePathSet::const_iterator it = m_pathSet.begin(); it != m_pathSet.end(); it++) {
TFilePath path = *it;
if (path.getType() == "tpl")
m_paletteList.push_back(StudioPalette::instance()->getPalette(path));
}
}
void undo() const
{
StudioPalette::instance()->createFolder(m_path.getParentDir(), m_path.getWideName());
int paletteCount = -1;
for (TFilePathSet::const_iterator it = m_pathSet.begin(); it != m_pathSet.end(); it++) {
TFilePath path = *it;
if (path.getType() == "tpl") //Is a palette
StudioPalette::instance()->setPalette(path, m_paletteList.at(++paletteCount)->clone(), true);
else //Is a folder
StudioPalette::instance()->createFolder(path.getParentDir(), path.getWideName());
}
}
void redo() const
{
StudioPalette::instance()->deleteFolder(m_path);
}
int getSize() const
{
return sizeof(*this) + sizeof(TPalette);
}
QString getHistoryString()
{
return QObject::tr("Delete Studio Palette Folder : %1")
.arg(QString::fromStdString(m_path.getName()));
}
int getHistoryType()
{
return HistoryType::Palette;
}
};
//=============================================================================
//CreateFolderUndo
class CreateFolderUndo : public TUndo
{
TFilePath m_folderPath;
public:
CreateFolderUndo(const TFilePath &folderPath)
: m_folderPath(folderPath)
{
}
void undo() const
{
StudioPalette::instance()->deleteFolder(m_folderPath);
}
void redo() const
{
StudioPalette::instance()->createFolder(m_folderPath.getParentDir(), m_folderPath.getWideName());
}
int getSize() const
{
return sizeof(*this) + sizeof(TPalette);
}
QString getHistoryString()
{
return QObject::tr("Create Studio Palette Folder : %1")
.arg(QString::fromStdString(m_folderPath.getName()));
}
int getHistoryType()
{
return HistoryType::Palette;
}
};
//=============================================================================
//MovePaletteUndo
class MovePaletteUndo : public TUndo
{
TFilePath m_dstPath, m_srcPath;
public:
MovePaletteUndo(const TFilePath &dstPath, const TFilePath &srcPath)
: m_dstPath(dstPath), m_srcPath(srcPath)
{
}
void undo() const
{
StudioPalette::instance()->movePalette(m_srcPath, m_dstPath);
}
void redo() const
{
StudioPalette::instance()->movePalette(m_dstPath, m_srcPath);
}
int getSize() const
{
return sizeof(*this);
}
QString getHistoryString()
{
return QObject::tr("Move Studio Palette Folder : %1 : %2 > %3")
.arg(QString::fromStdString(m_srcPath.getName()))
.arg(QString::fromStdString(m_srcPath.getParentDir().getName()))
.arg(QString::fromStdString(m_dstPath.getParentDir().getName()));
}
int getHistoryType()
{
return HistoryType::Palette;
}
};
//-------------------------------------------------------------
void adaptLevelToPalette(TXshLevelHandle *currentLevelHandle, TPaletteHandle *paletteHandle, TPalette *plt, int tolerance, bool noUndo);
class AdjustIntoCurrentPaletteUndo : public TUndo
{
TXshLevelHandle *m_currentLevelHandle;
TPaletteHandle *m_paletteHandle;
TPaletteP m_oldPalette, m_newPalette;
TFrameId m_fid;
string m_oldImageId;
static int m_idCount;
int m_undoSize;
int m_tolerance;
public:
AdjustIntoCurrentPaletteUndo(TXshLevelHandle *currentLevelHandle, TPaletteHandle *paletteHandle, const TFrameId &fid,
const TImageP &oldImage, const TPaletteP &oldPalette, const TPaletteP &newPalette, int tolerance)
: TUndo(), m_currentLevelHandle(currentLevelHandle), m_paletteHandle(paletteHandle), m_fid(fid), m_oldPalette(oldPalette), m_newPalette(newPalette), m_tolerance(tolerance)
{
m_oldImageId = "AdjustIntoCurrentPaletteUndo_oldImage_" + toString(m_idCount++);
TImageCache::instance()->add(m_oldImageId, (const TImageP)oldImage);
m_undoSize = ((TToonzImageP)oldImage)->getRaster()->getLx() * ((TToonzImageP)oldImage)->getRaster()->getLy() * ((TToonzImageP)oldImage)->getRaster()->getPixelSize();
}
~AdjustIntoCurrentPaletteUndo()
{
TImageCache::instance()->remove(m_oldImageId);
}
void undo() const
{
TImageP img = TImageCache::instance()->get(m_oldImageId, true);
TXshSimpleLevel *level = m_currentLevelHandle->getSimpleLevel();
level->setPalette(m_oldPalette.getPointer());
//img->setPalette(m_oldPalette.getPointer());
level->setFrame(m_fid, img->cloneImage());
level->touchFrame(m_fid);
if (level->getFirstFid() == m_fid) {
m_currentLevelHandle->notifyLevelChange();
m_paletteHandle->setPalette(m_oldPalette.getPointer());
m_oldPalette->setDirtyFlag(true);
m_paletteHandle->notifyPaletteChanged();
}
}
void redo() const
{
adaptLevelToPalette(m_currentLevelHandle, m_paletteHandle, m_newPalette.getPointer(), m_tolerance, true);
}
int getSize() const
{
return m_undoSize;
}
};
//-----------------------------------------------------------------------------
int AdjustIntoCurrentPaletteUndo::m_idCount = 0;
//-----------------------------------------------------------------------------
} // namespace
//=============================================================================
void StudioPaletteCmd::loadIntoCurrentPalette(TPaletteHandle *paletteHandle,
const TFilePath &fp)
{
TPalette *palette = StudioPalette::instance()->getPalette(fp, false);
if (!palette)
return;
loadIntoCurrentPalette(paletteHandle, palette);
}
//-----------------------------------------------------------------------------
namespace
{
map<TPixel, int> ToleranceMap;
int findClosest(const TPixel &color, map<TPixel, int> &colorMap, int tolerance)
{
map<TPixel, int>::const_iterator it;
it = ToleranceMap.find(color);
if (it != ToleranceMap.end())
return it->second;
tolerance *= tolerance;
it = colorMap.begin();
int index = -1, minDist = 99999999;
int dr, dg, db, dm;
for (; it != colorMap.end(); ++it) {
if ((dr = (color.r - it->first.r) * (color.r - it->first.r)) > tolerance)
continue;
if ((dg = (color.g - it->first.g) * (color.g - it->first.g)) > tolerance)
continue;
if ((db = (color.b - it->first.b) * (color.b - it->first.b)) > tolerance)
continue;
if ((dm = (color.m - it->first.m) * (color.m - it->first.m)) > tolerance)
continue;
int currDist = dr + dg + db + dm;
if (currDist < minDist)
minDist = currDist, index = it->second;
}
ToleranceMap[color] = index;
return index;
}
//--------------------------------------------------------------------------------------
int getIndex(const TPixel &color, map<TPixel, int> &colorMap, TPalette *plt, int tolerance)
{
map<TPixel, int>::const_iterator it;
it = colorMap.find(color);
if (it != colorMap.end())
return it->second;
if (tolerance > 0) {
int index = findClosest(color, colorMap, tolerance);
if (index != -1)
return index;
}
int index = plt->addStyle(color);
plt->getPage(0)->addStyle(index);
colorMap[color] = index;
return index;
}
//-------------------------------------------
void adaptIndexes(TToonzImageP timg, map<TPixel, int> &colorMap, TPalette *plt, int tolerance)
{
TPalette *origPlt = timg->getPalette();
TRasterCM32P r = timg->getRaster();
TPixelCM32 oldPrev = TPixelCM32(), newPrev = TPixelCM32();
for (int i = 0; i < r->getLy(); i++) {
TPixelCM32 *pix = r->pixels(i);
for (int j = 0; j < r->getLx(); j++, pix++) {
if (*pix == TPixelCM32())
continue;
if (*pix == oldPrev) {
*pix = newPrev;
continue;
}
oldPrev = *pix;
int ink = pix->getInk();
int paint = pix->getPaint();
if (ink > 0) {
TPixel color = origPlt->getStyle(ink)->getMainColor();
int newIndex = getIndex(color, colorMap, plt, tolerance);
pix->setInk(newIndex);
}
if (paint > 0) {
TPixel color = origPlt->getStyle(paint)->getMainColor();
int newIndex = getIndex(color, colorMap, plt, tolerance);
pix->setPaint(newIndex);
}
newPrev = *pix;
}
}
}
//-----------------------------------------------
void adaptLevelToPalette(TXshLevelHandle *currentLevelHandle, TPaletteHandle *paletteHandle, TPalette *plt, int tolerance, bool noUndo)
{
TXshSimpleLevel *sl = currentLevelHandle->getSimpleLevel();
QApplication::setOverrideCursor(Qt::WaitCursor);
TPalette *oldPalette = sl->getPalette();
ToleranceMap.clear();
map<TPixel, int> colorMap;
for (int i = 0; i < plt->getStyleCount(); i++) {
if (!plt->getStylePage(i))
continue;
colorMap[plt->getStyle(i)->getMainColor()] = i;
}
vector<TFrameId> fids;
sl->getFids(fids);
for (int i = 0; i < (int)fids.size(); i++) {
TToonzImageP timg = (TToonzImageP)sl->getFrame(fids[i], true);
if (!timg)
continue;
if (!noUndo)
TUndoManager::manager()->add(
new AdjustIntoCurrentPaletteUndo(currentLevelHandle, paletteHandle, fids[i], timg->cloneImage(), oldPalette->clone(), plt->clone(), tolerance));
adaptIndexes(timg, colorMap, plt, tolerance);
timg->setPalette(plt);
}
QApplication::restoreOverrideCursor();
currentLevelHandle->getSimpleLevel()->setPalette(plt);
paletteHandle->setPalette(plt);
plt->setDirtyFlag(true);
paletteHandle->notifyPaletteChanged();
currentLevelHandle->notifyLevelChange();
}
} //namespaxce
//-----------------------------------------------------------------------------
void StudioPaletteCmd::loadIntoCurrentPalette(TPaletteHandle *paletteHandle, TPalette *plt, TXshLevelHandle *currentLevelHandle, int tolerance)
{
adaptLevelToPalette(currentLevelHandle, paletteHandle, plt, tolerance, false);
}
//---------------------------------------------------------------------------------------
void StudioPaletteCmd::loadIntoCurrentPalette(TPaletteHandle *paletteHandle,
TPalette *palette)
{
assert(paletteHandle);
TPalette *current = paletteHandle->getPalette();
if (!current)
return;
int styleId = paletteHandle->getStyleIndex();
TPalette *old = current->clone();
while (palette->getStyleCount() < current->getStyleCount()) {
int index = palette->getStyleCount();
assert(index < current->getStyleCount());
TColorStyle *style = current->getStyle(index)->clone();
palette->addStyle(style);
}
//keep the color model path unchanged
TFilePath oldRefImagePath = current->getRefImgPath();
current->assign(palette, true);
current->setDirtyFlag(true);
current->setRefImgPath(oldRefImagePath);
if (paletteHandle->getPalette() == current && styleId >= current->getStyleCount())
paletteHandle->setStyleIndex(1);
TUndoManager::manager()->add(
new PaletteAssignUndo(current, old, current->clone(), paletteHandle));
palette->setDirtyFlag(true);
paletteHandle->notifyPaletteChanged();
}
//-----------------------------------------------------------------------------
void StudioPaletteCmd::mergeIntoCurrentPalette(TPaletteHandle *paletteHandle,
const TFilePath &fp)
{
TPalette *palette = StudioPalette::instance()->getPalette(fp);
if (!palette)
return;
mergeIntoCurrentPalette(paletteHandle, palette);
}
//-----------------------------------------------------------------------------
void StudioPaletteCmd::mergeIntoCurrentPalette(TPaletteHandle *paletteHandle,
TPalette *palette)
{
assert(paletteHandle);
TPalette *current = paletteHandle->getPalette();
if (!current)
return;
if (current->isLocked())
return;
TPalette *old = current->clone();
current->merge(palette, true);
TUndoManager::manager()->add(
new PaletteAssignUndo(current, old, current->clone(), paletteHandle));
palette->setDirtyFlag(true);
paletteHandle->notifyPaletteChanged();
}
//-----------------------------------------------------------------------------
void StudioPaletteCmd::replaceWithCurrentPalette(TPaletteHandle *paletteHandle,
TPaletteHandle *stdPaletteHandle,
const TFilePath &fp)
{
StudioPalette *sp = StudioPalette::instance();
TPalette *palette = sp->getPalette(fp);
if (!palette || palette->isLocked())
return;
assert(paletteHandle);
TPalette *current = paletteHandle->getPalette();
if (!current)
return;
//keep the studio palette's global name unchanged
std::wstring oldGlobalName = palette->getGlobalName();
TPalette *old = palette->clone();
palette->assign(current);
//put back the global name
palette->setGlobalName(oldGlobalName);
sp->setPalette(fp, current, true);
TUndoManager::manager()->add(
new StudioPaletteAssignUndo(fp, old, current->clone(), paletteHandle));
// Cambio la studioPalette correntette(palette);
stdPaletteHandle->setPalette(palette);
stdPaletteHandle->notifyPaletteSwitched();
}
//-----------------------------------------------------------------------------
void StudioPaletteCmd::updateAllLinkedStyles(TPaletteHandle *paletteHandle, TXsheetHandle *xsheetHandle)
{
if (!xsheetHandle)
return;
TXsheet *xsheet = xsheetHandle->getXsheet();
if (!xsheet)
return;
ToonzScene *scene = xsheet->getScene();
if (!scene)
return;
//emit signal only if something changed
bool somethingChanged = false;
StudioPalette *sp = StudioPalette::instance();
TLevelSet *levelSet = scene->getLevelSet();
for (int i = 0; i < levelSet->getLevelCount(); i++) {
TXshLevel *xl = levelSet->getLevel(i);
TXshSimpleLevel *sl = xl ? xl->getSimpleLevel() : 0;
if (!sl)
continue;
TPalette *palette = sl->getPalette();
if (palette) {
somethingChanged = somethingChanged | sp->updateLinkedColors(palette);
if (sl->getType() == TZP_XSHLEVEL) {
std::vector<TFrameId> fids;
sl->getFids(fids);
std::vector<TFrameId>::iterator it;
for (it = fids.begin(); it != fids.end(); ++it) {
TFrameId fid = *it;
string id = sl->getImageId(fid);
}
}
}
}
if (!paletteHandle || !paletteHandle->getPalette())
return;
if (somethingChanged)
paletteHandle->notifyColorStyleChanged();
}
//-----------------------------------------------------------------------------
/*! Delete palette identified by \b fp in \b StudioPalette. If there are any
problems in loading send an error message.
*/
void StudioPaletteCmd::deletePalette(const TFilePath &fp)
{
TUndo *undo = new DeletePaletteUndo(fp);
StudioPalette::instance()->deletePalette(fp);
TUndoManager::manager()->add(undo);
}
//-----------------------------------------------------------------------------
/*! Move palette from TFilePath \b srcPath to \b TFilePath \b dstPath. If there
are any problems in moving send an error message.
*/
void StudioPaletteCmd::movePalette(const TFilePath &dstPath, const TFilePath &srcPath)
{
TSystem::touchParentDir(dstPath);
StudioPalette::instance()->movePalette(dstPath, srcPath);
TUndoManager::manager()->add(new MovePaletteUndo(dstPath, srcPath));
}
//-----------------------------------------------------------------------------
/*! Create palette \b palette in folder \b folderName with name \b paletteName.
If there are any problems send an error message.
*/
TFilePath StudioPaletteCmd::createPalette(const TFilePath &folderName,
string paletteName,
const TPalette *palette)
{
TFilePath palettePath;
TFileStatus status(folderName);
if (!status.isDirectory())
throw TException("Select a folder.");
if (!status.doesExist()) {
TSystem::mkDir(folderName);
FolderListenerManager::instance()->notifyFolderChanged(folderName.getParentDir());
}
palettePath = StudioPalette::instance()->createPalette(folderName, paletteName);
if (palette)
StudioPalette::instance()->setPalette(palettePath, palette, true);
TUndoManager::manager()->add(new CreatePaletteUndo(palettePath));
return palettePath;
}
//-----------------------------------------------------------------------------
/*! Add a folder in StudioPalette TFilePath \b parentFolderPath. If there
are any problems send an error message.
*/
TFilePath StudioPaletteCmd::addFolder(const TFilePath &parentFolderPath)
{
TFilePath folderPath;
folderPath = StudioPalette::instance()->createFolder(parentFolderPath);
if (!folderPath.isEmpty())
TUndoManager::manager()->add(new CreateFolderUndo(folderPath));
return folderPath;
}
//-----------------------------------------------------------------------------
/*! Delete folder \b folderPath. If there are any problems in deleting send an
error message.
*/
void StudioPaletteCmd::deleteFolder(const TFilePath &folderPath)
{
TFilePathSet folderPathSet;
TSystem::readDirectoryTree(folderPathSet, folderPath, true, false);
TUndo *undo = new DeleteFolderUndo(folderPath, folderPathSet);
StudioPalette::instance()->deleteFolder(folderPath);
TUndoManager::manager()->add(undo);
}
//-----------------------------------------------------------------------------
void StudioPaletteCmd::scanPalettes(const TFilePath &folder, const TFilePath &sourcePath)
{
// error("uh oh");
}