#include "toonzqt/studiopaletteviewer.h"

// TnzQt includes

#include "toonzqt/menubarcommand.h"

#include "toonzqt/paletteviewer.h"

#include "toonzqt/dvdialog.h"

#include "toonzqt/trepetitionguard.h"

#include "toonzqt/gutil.h"

#include "toonzqt/icongenerator.h"

#include "toonzqt/intfield.h"

#include "palettesscanpopup.h"

#include "palettedata.h"

// TnzLib includes

#include "toonz/studiopalettecmd.h"

#include "toonz/tpalettehandle.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/toonzscene.h"

#include "toonz/sceneproperties.h"

#include "toonz/txsheethandle.h"

#include "toonz/txshlevelhandle.h"

// TnzCore includes

#include "tconvert.h"

#include "tundo.h"

#include "tsystem.h"

#include "../toonz/menubarcommandids.h"

// Qt includes

#include <qheaderview></qheaderview>

#include <qcontextmenuevent></qcontextmenuevent>

#include <qmenu></qmenu>

#include <qurl></qurl>

#include <qpainter></qpainter>

#include <qvboxlayout></qvboxlayout>

#include <qtoolbar></qtoolbar>

#include <qinputdialog></qinputdialog>

#include <qpushbutton></qpushbutton>

#include <qdrag></qdrag>

#include <time.h></time.h>

using namespace std;

using namespace PaletteViewerGUI;

using namespace DVGui;

//=============================================================================

namespace

{

//-----------------------------------------------------------------------------

/*! Return true if path is in folder \b rootPath of \b StudioPalette.

*/

bool isInStudioPaletteFolder(TFilePath path, TFilePath rootPath)

{

	if (path.getType() != "tpl")

		return false;

	StudioPalette *studioPalette = StudioPalette::instance();

	std::vector<tfilepath> childrenPath;</tfilepath>

	studioPalette->getChildren(childrenPath, rootPath);

	int i;

	for (i = 0; i < (int)childrenPath.size(); i++) {

		if (path == childrenPath[i])

			return true;

		else if (isInStudioPaletteFolder(path, childrenPath[i]))

			return true;

	}

	return false;

}

//-----------------------------------------------------------------------------

/*! Return true if path is in a \b StudioPalette folder.

*/

bool isInStudioPalette(TFilePath path)

{

	if (path.getType() != "tpl")

		return false;

	StudioPalette *studioPalette = StudioPalette::instance();

	if (isInStudioPaletteFolder(path, studioPalette->getLevelPalettesRoot()))

		return true;

	if (isInStudioPaletteFolder(path, studioPalette->getProjectPalettesRoot()))

		return true;

	return false;

}

//-----------------------------------------------------------------------------

} //namespace

//-----------------------------------------------------------------------------

//=============================================================================

// StudioPaletteTreeViewer

//-----------------------------------------------------------------------------

StudioPaletteTreeViewer::StudioPaletteTreeViewer(QWidget *parent,

												 TPaletteHandle *studioPaletteHandle,

												 TPaletteHandle *levelPaletteHandle,

												 TXsheetHandle *xsheetHandle,

												 TXshLevelHandle *currentLevelHandle)

	: QTreeWidget(parent), m_dropItem(0), m_studioPaletteHandle(studioPaletteHandle), m_levelPaletteHandle(levelPaletteHandle), m_currentLevelHandle(currentLevelHandle), m_xsheetHandle(xsheetHandle), m_folderIcon(QIcon()), m_levelPaletteIcon(QIcon()), m_studioPaletteIcon(QIcon())

{

	setIndentation(14);

	setAlternatingRowColors(true);

	header()->close();

	setUniformRowHeights(true);

	setIconSize(QSize(21, 17));

	QList<qtreewidgetitem *=""> paletteItems;</qtreewidgetitem>

	QString open = QString(":Resources/folder_close.png");

	QString close = QString(":Resources/folder_open.png");

	m_folderIcon.addFile(close, QSize(21, 17), QIcon::Normal, QIcon::On);

	m_folderIcon.addFile(open, QSize(21, 17), QIcon::Normal, QIcon::Off);

	QString levelPaletteIcon = QString(":Resources/palette.png");

	m_levelPaletteIcon.addPixmap(levelPaletteIcon, QIcon::Normal, QIcon::On);

	QString studioPaletteIcon = QString(":Resources/studiopalette.png");

	m_studioPaletteIcon.addPixmap(studioPaletteIcon, QIcon::Normal, QIcon::On);

	StudioPalette *studioPalette = StudioPalette::instance();

	TFilePath levelPalettePath = studioPalette->getLevelPalettesRoot();

	paletteItems.append(createRootItem(levelPalettePath));

	TFilePath projectPalettePath = studioPalette->getProjectPalettesRoot();

	if (TSystem::doesExistFileOrLevel(projectPalettePath))

		paletteItems.append(createRootItem(projectPalettePath));

	insertTopLevelItems(0, paletteItems);

	bool ret = connect(this, SIGNAL(itemChanged(QTreeWidgetItem *, int)), SLOT(onItemChanged(QTreeWidgetItem *, int)));

	ret = ret && connect(this, SIGNAL(itemClicked(QTreeWidgetItem *, int)), SLOT(onItemClicked(QTreeWidgetItem *, int)));

	ret = ret && connect(this, SIGNAL(currentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)),

						 SLOT(onCurrentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)));

	ret = ret && connect(this, SIGNAL(itemClicked(QTreeWidgetItem *, int)), this, SLOT(onTreeItemExpanded(QTreeWidgetItem *)));

	//refresh tree with shortcut key

	QAction *refreshAct = CommandManager::instance()->getAction(MI_RefreshTree);

	ret = ret && connect(refreshAct, SIGNAL(triggered()), this, SLOT(onRefreshTreeShortcutTriggered()));

	addAction(refreshAct);

	m_palettesScanPopup = new PalettesScanPopup();

	setAcceptDrops(true);

	//Per la selezione multipla

	setSelectionMode(QAbstractItemView::ExtendedSelection);

	StudioPalette::instance()->addListener(this);

	TProjectManager::instance()->addListener(this);

	refresh();

	assert(ret);

}

//-----------------------------------------------------------------------------

StudioPaletteTreeViewer::~StudioPaletteTreeViewer()

{

	StudioPalette::instance()->removeListener(this);

	TProjectManager::instance()->removeListener(this);

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::setCurrentLevelHandle(TXshLevelHandle *currentLevelHandle)

{

	m_currentLevelHandle = currentLevelHandle;

}

//---------------------------------------------------------------------------

void StudioPaletteTreeViewer::setLevelPaletteHandle(TPaletteHandle *paletteHandle)

{

	m_levelPaletteHandle = paletteHandle;

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::setStdPaletteHandle(TPaletteHandle *studioPaletteHandle)

{

	m_studioPaletteHandle = studioPaletteHandle;

}

//-----------------------------------------------------------------------------

QTreeWidgetItem *StudioPaletteTreeViewer::createRootItem(TFilePath path)

{

	QString rootName = QString::fromStdWString(path.getWideName());

	if (rootName != "Toonz Palettes")

		rootName = "Project Palettes";

	QTreeWidgetItem *rootItem = new QTreeWidgetItem((QTreeWidget *)0, QStringList(rootName));

	rootItem->setIcon(0, m_folderIcon);

	rootItem->setData(1, Qt::UserRole, toQString(path));

	refreshItem(rootItem);

	return rootItem;

}

//-----------------------------------------------------------------------------

bool StudioPaletteTreeViewer::isRootItem(QTreeWidgetItem *item)

{

	assert(item);

	TFilePath path = getItemPath(item);

	StudioPalette *studioPalette = StudioPalette::instance();

	if (path == studioPalette->getLevelPalettesRoot() ||

		path == studioPalette->getProjectPalettesRoot())

		return true;

	return false;

}

//-----------------------------------------------------------------------------

QTreeWidgetItem *StudioPaletteTreeViewer::createItem(const TFilePath path)

{

	StudioPalette *studioPalette = StudioPalette::instance();

	QString itemName = toQString(TFilePath(path.getWideName()));

	QTreeWidgetItem *item = new QTreeWidgetItem((QTreeWidget *)0, QStringList(itemName));

	if (studioPalette->isPalette(path)) {

		if (studioPalette->hasGlobalName(path))

			item->setIcon(0, m_studioPaletteIcon);

		else

			item->setIcon(0, m_levelPaletteIcon);

	} else if (studioPalette->isFolder(path))

		item->setIcon(0, m_folderIcon);

	item->setData(1, Qt::UserRole, toQString(path));

	item->setFlags(item->flags() | Qt::ItemIsEditable);

	return item;

}

//-----------------------------------------------------------------------------

TFilePath StudioPaletteTreeViewer::getItemPath(QTreeWidgetItem *item)

{

	TFilePath path = (item) ? TFilePath(item->data(1, Qt::UserRole).toString().toStdWString())

							: TFilePath();

	return path;

}

//-----------------------------------------------------------------------------

TFilePath StudioPaletteTreeViewer::getCurrentFolderPath()

{

	return getItemPath(currentItem());

}

//-----------------------------------------------------------------------------

QTreeWidgetItem *StudioPaletteTreeViewer::getItem(const TFilePath path)

{

	QList<qtreewidgetitem *=""> oldItems = findItems(QString(""), Qt::MatchContains, 0);</qtreewidgetitem>

	if (oldItems.isEmpty())

		return 0;

	int i;

	for (i = 0; i < (int)oldItems.size(); i++) {

		TFilePath oldItemPath(oldItems[i]->data(1, Qt::UserRole).toString().toStdWString());

		if (oldItemPath == path)

			return oldItems[i];

		else {

			QTreeWidgetItem *item = getFolderItem(oldItems[i], path);

			if (item)

				return item;

		}

	}

	return 0;

}

//-----------------------------------------------------------------------------

QTreeWidgetItem *StudioPaletteTreeViewer::getFolderItem(QTreeWidgetItem *parent, const TFilePath path)

{

	int childrenCount = parent->childCount();

	int i;

	for (i = 0; i < childrenCount; i++) {

		QTreeWidgetItem *item = parent->child(i);

		if (getItemPath(item) == path)

			return item;

		else {

			item = getFolderItem(item, path);

			if (item)

				return item;

		}

	}

	return 0;

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::resetDropItem()

{

	if (!m_dropItem)

		return;

	m_dropItem->setTextColor(0, Qt::black);

	m_dropItem = 0;

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::refresh()

{

	m_openedItems.clear();

	StudioPalette *studioPalette = StudioPalette::instance();

	TFilePath levelPalettePath = studioPalette->getLevelPalettesRoot();

	refreshItem(getItem(levelPalettePath));

	TFilePath projectPalettePath = studioPalette->getProjectPalettesRoot();

	if (!TSystem::doesExistFileOrLevel(projectPalettePath))

		return;

	refreshItem(getItem(projectPalettePath));

	//refresh all expanded items

	QList<qtreewidgetitem *=""> items = findItems(QString(""), Qt::MatchContains | Qt::MatchRecursive, 0);</qtreewidgetitem>

	if (items.isEmpty())

		return;

	for (int i = 0; i < (int)items.size(); i++)

		if (items[i]->isExpanded())

			refreshItem(items[i]);

}

//-----------------------------------------------------------------------------

/*!When expand a tree, prepare the child items of it 

*/

void StudioPaletteTreeViewer::onTreeItemExpanded(QTreeWidgetItem *item)

{

	if (!item)

		return;

	//if this item was not yet opened, then get the children of this item

	if (!m_openedItems.contains(item))

		refreshItem(item);

	//expand the item

	item->setExpanded(!item->isExpanded());

}

//-----------------------------------------------------------------------------

/*! Refresh tree only when this widget has focus

*/

void StudioPaletteTreeViewer::onRefreshTreeShortcutTriggered()

{

	if (hasFocus())

		refresh();

}

//-----------------------------------------------------------------------------

/*! Update the content of item

*/

void StudioPaletteTreeViewer::refreshItem(QTreeWidgetItem *item)

{

	TFilePath folderPath = getItemPath(item);

	assert(folderPath != TFilePath());

	//correct only tpl files and folders

	std::vector<tfilepath> childrenPath;</tfilepath>

	StudioPalette::instance()->getChildren(childrenPath, folderPath);

	int currentChildCount = item->childCount();

	std::vector<qtreewidgetitem *=""> currentChildren;</qtreewidgetitem>

	int i;

	for (i = 0; i < currentChildCount; i++)

		currentChildren.push_back(item->child(i));

	int childrenPathCount = childrenPath.size();

	int itemIndex = 0;

	int pathIndex = 0;

	while (itemIndex < currentChildCount || pathIndex < childrenPathCount) {

		TFilePath path = (pathIndex < childrenPathCount) ? childrenPath[pathIndex] : TFilePath();

		QTreeWidgetItem *currentItem = (itemIndex < currentChildCount) ? currentChildren[itemIndex] : 0;

		TFilePath currentItemPath = getItemPath(currentItem);

		if (path == currentItemPath) {

			itemIndex++;

			pathIndex++;

		} else if ((!path.isEmpty() && path < currentItemPath) ||

				   currentItemPath.isEmpty()) {

			currentItem = createItem(path);

			item->insertChild(itemIndex, currentItem);

			itemIndex++;

			pathIndex++;

		} else {

			assert(currentItemPath < path || path.isEmpty());

			assert(currentItem);

			item->removeChild(currentItem);

			itemIndex++;

		}

	}

	m_openedItems.insert(item);

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::resetProjectPaletteFolder()

{

	int projectPaletteIndex = 1;

	TFilePath projectPalettePath = StudioPalette::instance()->getProjectPalettesRoot();

	// Prendo l'item del project palette.

	QTreeWidgetItem *projectPaletteItem = topLevelItem(projectPaletteIndex);

	if (projectPaletteItem) {

		// Se il path dell'item e' uguale a quello del project palette corrente ritorno.

		if (getItemPath(projectPaletteItem) == projectPalettePath)

			return;

		// Altrimenti lo rimuovo.

		removeItemWidget(projectPaletteItem, 0);

		delete projectPaletteItem;

		//clear the item list in order to search the folder from scratch

		m_openedItems.clear();

		//Toonz Palette is not changed, so resurrect the ToonzPaletteRoot

		m_openedItems.insert(topLevelItem(0));

	}

	if (!TSystem::doesExistFileOrLevel(projectPalettePath))

		return;

	// Creo il nuovo item con il nuovo project folder e lo inserisco nell'albero.

	// Items in the ProjectPaletteRoot are refreshed here. Stored in openedItems as well.

	QTreeWidgetItem *newProjectPaletteItem = createRootItem(projectPalettePath);

	insertTopLevelItem(projectPaletteIndex, newProjectPaletteItem);

	setCurrentItem(0);

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::onItemClicked(QTreeWidgetItem *item, int column)

{

	if (currentItem() && m_studioPaletteHandle && m_currentPalette.getPointer()) {

		// if(m_studioPaletteHandle->getPalette() != m_currentPalette.getPointer())

		{

			m_studioPaletteHandle->setPalette(m_currentPalette.getPointer());

			m_studioPaletteHandle->notifyPaletteSwitched();

			StudioPaletteCmd::updateAllLinkedStyles(m_levelPaletteHandle, m_xsheetHandle);

		}

	}

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::onItemChanged(QTreeWidgetItem *item, int column)

{

	if (item != currentItem() || isRootItem(item))

		return;

	wstring name = item->text(column).toStdWString();

	TFilePath oldPath = getCurrentFolderPath();

	if (oldPath.isEmpty() || name.empty() || oldPath.getWideName() == name)

		return;

	TFilePath newPath(oldPath.getParentDir() + TFilePath(name + toWideString(oldPath.getDottedType())));

	try {

		StudioPaletteCmd::movePalette(newPath, oldPath);

	} catch (TException &e) {

		error(QString(toString(e.getMessage()).c_str()));

		item->setText(column, QString::fromStdWString(oldPath.getWideName()));

	} catch (...) {

		error("Can't rename file");

		item->setText(column, QString::fromStdWString(oldPath.getWideName()));

	}

	refreshItem(getItem(oldPath.getParentDir()));

	setCurrentItem(getItem(newPath));

}

//-----------------------------------------------------------------------------

/*! Called when the current palette is switched

*/

void StudioPaletteTreeViewer::onCurrentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous)

{

	TFilePath oldPath = getItemPath(previous);

	TFilePath newPath = getCurrentFolderPath();

	if (!m_studioPaletteHandle)

		return;

	if (m_currentPalette.getPointer() && m_currentPalette->getDirtyFlag()) {

		TFilePath oldPath = StudioPalette::instance()->getPalettePath(m_currentPalette->getGlobalName());

		if (oldPath == newPath)

			return;

		wstring gname = m_currentPalette->getGlobalName();

		QString question;

		question = "The current palette " + QString::fromStdWString(oldPath.getWideString()) + " \nin the studio palette has been modified. Do you want to save your changes?";

		int ret = DVGui::MsgBox(question, QObject::tr("Save"), QObject::tr("Discard"), QObject::tr("Cancel"), 0);

		if (ret == 3) {

			setCurrentItem(getItem(oldPath));

			return;

		}

		if (ret == 1) {

			//If the palette is level palette (i.e. NOT stdio palette), just overwrite it

			if (gname.empty())

				StudioPalette::instance()->save(oldPath, m_currentPalette.getPointer());

			else

				StudioPalette::instance()->setPalette(oldPath, m_currentPalette.getPointer(), false);

		}

		m_currentPalette->setDirtyFlag(false);

	}

	//load palette here

	m_currentPalette = StudioPalette::instance()->getPalette(newPath, false);

	m_studioPaletteHandle->setPalette(m_currentPalette.getPointer());

	m_studioPaletteHandle->notifyPaletteSwitched();

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::addNewPalette()

{

	if (!currentItem()) {

		error("Error: No folder selected.");

		return;

	}

	TFilePath newPath;

	try {

		newPath = StudioPaletteCmd::createPalette(getCurrentFolderPath(), "", 0);

	} catch (TException &e) {

		error("Can't create palette: " + QString(toString(e.getMessage()).c_str()));

	} catch (...) {

		error("Can't create palette");

	}

	refreshItem(currentItem());

	setCurrentItem(getItem(newPath));

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::addNewFolder()

{

	if (!currentItem()) {

		error("Error: No folder selected.");

		return;

	}

	TFilePath newPath;

	try {

		newPath = StudioPaletteCmd::addFolder(getCurrentFolderPath());

	} catch (TException &e) {

		error("Can't create palette folder: " + QString(toString(e.getMessage()).c_str()));

	} catch (...) {

		error("Can't create palette folder");

	}

	refreshItem(currentItem());

	setCurrentItem(getItem(newPath));

}

//-----------------------------------------------------------------------------

/*! Convert level palette to studio palette. 

*/

void StudioPaletteTreeViewer::convertToStudioPalette()

{

	TFilePath path = getItemPath(currentItem());

	StudioPalette *studioPalette = StudioPalette::instance();

	if (studioPalette->isPalette(path)) {

		TPalette *palette = studioPalette->getPalette(path);

		if (!palette) {

			error("Can't touch palette");

			return;

		}

		if (m_currentPalette->getPaletteName() != palette->getPaletteName()) {

			error("Can't touch palette");

			return;

		}

		QString question;

		question = QString::fromStdWString(L"Convert " + path.getWideString() + L" to Studio Palette and Overwrite. \nAre you sure ?");

		int ret = DVGui::MsgBox(question, QObject::tr("Yes"), QObject::tr("No"));

		if (ret == 0 || ret == 2)

			return;

		// apply global name

		time_t ltime;

		time(<ime);

		wstring gname = toWideString((int)ltime) + L"_" + toWideString(rand());

		m_currentPalette->setGlobalName(gname);

		studioPalette->setStylesGlobalNames(m_currentPalette.getPointer());

		studioPalette->save(path, m_currentPalette.getPointer());

		m_currentPalette->setDirtyFlag(false);

		currentItem()->setIcon(0, m_studioPaletteIcon);

	} else

		error("Can't find palette");

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::deleteItem(QTreeWidgetItem *item)

{

	QTreeWidgetItem *parent = item->parent();

	if (!parent)

		return;

	if (item->childCount() > 0) {

		QString question;

		question = tr("This folder is not empty. Delete anyway?");

		int ret = DVGui::MsgBox(question, QObject::tr("Yes"), QObject::tr("No"));

		if (ret == 0 || ret == 2)

			return;

	}

	TFilePath path = getItemPath(item);

	StudioPalette *studioPalette = StudioPalette::instance();

	if (studioPalette->isFolder(path)) {

		try {

			StudioPaletteCmd::deleteFolder(path);

		} catch (TException &e) {

			error("Can't delete folder: " + QString(toString(e.getMessage()).c_str()));

		} catch (...) {

			error("Can't delete folder");

		}

	} else {

		assert(studioPalette->isPalette(path));

		try {

			StudioPaletteCmd::deletePalette(path);

		} catch (TException &e) {

			error("Can't delete palette: " + QString(toString(e.getMessage()).c_str()));

		} catch (...) {

			error("Can't delete palette");

		}

	}

	refreshItem(parent);

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::deleteItems()

{

	QList<qtreewidgetitem *=""> items = selectedItems();</qtreewidgetitem>

	int count = items.size();

	if (count == 0) {

		error("Nothing to delete");

		return;

	}

	int i;

	TUndoManager::manager()->beginBlock();

	for (i = 0; i < count; i++)

		deleteItem(items[i]);

	TUndoManager::manager()->endBlock();

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::searchForPalette()

{

	m_palettesScanPopup->setCurrentFolder(getCurrentFolderPath());

	int ret = m_palettesScanPopup->exec();

	if (ret == QDialog::Accepted)

		refresh();

}

//-----------------------------------------------------------------------------

class InvalidateIconsUndo : public TUndo

{

	TPaletteP m_targetPalette, m_oldPalette, m_newPalette;

	TXshLevelHandle *m_levelHandle;

public:

	InvalidateIconsUndo(TXshLevelHandle *levelHandle)

		: m_levelHandle(levelHandle)

	{

	}

	void undo() const

	{

		TXshLevel *level = m_levelHandle->getLevel();

		if (level) {

			std::vector<tframeid> fids;</tframeid>

			level->getFids(fids);

			invalidateIcons(level, fids);

		}

	}

	void redo() const

	{

		undo();

	}

	int getSize() const

	{

		return sizeof(*this);

	}

};

//----------------------------------------------------------------------

//-----------------------------------------------------------------------------

class AdjustPaletteDialog : public DVGui::Dialog

{

private:

	IntField *m_tolerance;

public:

	int getTolerance() { return m_tolerance->getValue(); }

	AdjustPaletteDialog()

		: Dialog(0, true, true, "Adjust Current Level to This Palette")

	{

		setWindowTitle(tr("Adjust Current Level to This Palette"));

		beginVLayout();

		m_tolerance = new IntField(this);

		m_tolerance->setRange(0, 255);

		m_tolerance->setValue(0);

		addWidget(tr("Tolerance"), m_tolerance);

		endVLayout();

		QPushButton *okBtn = new QPushButton(tr("Apply"), this);

		okBtn->setDefault(true);

		QPushButton *cancelBtn = new QPushButton(tr("Cancel"), this);

		bool ret = connect(okBtn, SIGNAL(clicked()), this, SLOT(accept()));

		ret = ret && connect(cancelBtn, SIGNAL(clicked()), this, SLOT(reject()));

		assert(ret);

		addButtonBarWidget(okBtn, cancelBtn);

	}

};

//-------------------------------------------------------------------------------------------------

void StudioPaletteTreeViewer::loadInCurrentPaletteAndAdaptLevel()

{

	QList<qtreewidgetitem *=""> items = selectedItems();</qtreewidgetitem>

	assert(items.size() == 1);

	TPalette *palette = m_levelPaletteHandle->getPalette();

	if (!palette)

		return;

	TPalette *newPalette = StudioPalette::instance()->getPalette(getItemPath(items[0]), true);

	if (!newPalette)

		return;

	AdjustPaletteDialog apd;

	if (apd.exec() != QDialog::Accepted)

		return;

	/* awful patch: since in StudioPaletteCmd(defined in toonzlib) I cannot use the invalidateIcons(defined in toonzqt) 

    i do invalidate icons from here using a "fake TUndo", named InvalidateIconsUndo. 

    And, since I need to refresh icons at the end of the processing, i have to put that fake undo twice, one before and one after.

    this way , when the user do either an undo or a redo operation, I am ensured that the last operation is the icon refresh...

  */

	TUndoManager::manager()->beginBlock();

	TUndoManager::manager()->add(new InvalidateIconsUndo(m_currentLevelHandle));

	StudioPaletteCmd::loadIntoCurrentPalette(m_levelPaletteHandle, newPalette, m_currentLevelHandle, apd.getTolerance());

	TUndoManager::manager()->add(new InvalidateIconsUndo(m_currentLevelHandle));

	TUndoManager::manager()->endBlock();

	InvalidateIconsUndo(m_currentLevelHandle).undo();

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::loadInCurrentPalette()

{

	QList<qtreewidgetitem *=""> items = selectedItems();</qtreewidgetitem>

	int count = items.size();

	if (count == 0)

		return;

	TPalette *palette = m_levelPaletteHandle->getPalette();

	if (!palette)

		return;

	if (palette->isLocked()) {

		DVGui::warning("Palette is Locked!");

		return;

	}

	TPalette *newPalette = StudioPalette::instance()->getPalette(getItemPath(items[0]), false);

	if (!newPalette)

		return;

	if (m_xsheetHandle) {

		int ret = DVGui::eraseStylesInDemand(palette, m_xsheetHandle, newPalette);

		if (ret == 0)

			return;

	}

	StudioPaletteCmd::loadIntoCurrentPalette(m_levelPaletteHandle, newPalette);

	m_currentLevelHandle->notifyLevelChange();

	TXshLevel *level = m_currentLevelHandle->getLevel();

	if (level) {

		std::vector<tframeid> fids;</tframeid>

		level->getFids(fids);

		invalidateIcons(level, fids);

	}

	int i;

	for (i = 1; i < count; i++) {

		TFilePath path = getItemPath(items[i]);

		StudioPaletteCmd::mergeIntoCurrentPalette(m_levelPaletteHandle, path);

	}

	// in order to update the title bar of palette viewer

	m_levelPaletteHandle->getPalette()->setDirtyFlag(true);

	m_levelPaletteHandle->notifyPaletteChanged();

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::replaceCurrentPalette()

{

	QList<qtreewidgetitem *=""> items = selectedItems();</qtreewidgetitem>

	int count = items.size();

	if (count == 0)

		return;

	//exec confirmation dialog

	TPalette *current = m_levelPaletteHandle->getPalette();

	if (!current)

		return;

	QString label;

	if (count != 1) //replacing to multiple palettes

		label = QString::fromStdWString(L"Replacing all selected palettes with the palette \"" + current->getPaletteName() + L"\". \nAre you sure ?");

	else {

		TPalette *dstPalette = StudioPalette::instance()->getPalette(getItemPath(items[0]));

		if (!dstPalette)

			return;

		label = QString::fromStdWString(L"Replacing the palette \"" + dstPalette->getPaletteName() + L"\" with the palette \"" + current->getPaletteName() + L"\". \nAre you sure ?");

	}

	int ret = DVGui::MsgBox(label, QObject::tr("Replace"), QObject::tr("Cancel"), 1);

	if (ret == 0 || ret == 2)

		return;

	TUndoManager::manager()->beginBlock();

	int i;

	for (i = 0; i < count; i++)

		StudioPaletteCmd::replaceWithCurrentPalette(m_levelPaletteHandle, m_studioPaletteHandle, getItemPath(items[i]));

	TUndoManager::manager()->endBlock();

	if (m_currentPalette)

		m_currentPalette->setDirtyFlag(false);

	//in order to update display

	onCurrentItemChanged(currentItem(), currentItem());

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::mergeToCurrentPalette()

{

	QList<qtreewidgetitem *=""> items = selectedItems();</qtreewidgetitem>

	int count = items.size();

	if (count == 0)

		return;

	TUndoManager::manager()->beginBlock();

	int i;

	for (i = 0; i < count; i++)

		StudioPaletteCmd::mergeIntoCurrentPalette(m_levelPaletteHandle, getItemPath(items[i]));

	TUndoManager::manager()->endBlock();

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::paintEvent(QPaintEvent *event)

{

	QTreeWidget::paintEvent(event);

	QPainter p(viewport());

	if (m_dropItem) {

		p.setPen(QColor(50, 105, 200));

		p.drawRect(visualItemRect(m_dropItem));

	}

}

//-----------------------------------------------------------------------------

void StudioPaletteTreeViewer::contextMenuEvent(QContextMenuEvent *event)

{