#include "toonzqt/paletteviewer.h"

// TnzQt includes

#include "toonzqt/gutil.h"

#include "toonzqt/keyframenavigator.h"

#include "toonzqt/trepetitionguard.h"

#include "toonzqt/dvdialog.h"

#include "toonzqt/dvscrollwidget.h"

#include "toonzqt/studiopaletteviewer.h"

#include "palettedata.h"

// TnzLib includes

#include "toonz/palettecmd.h"

#include "toonz/studiopalettecmd.h"

#include "toonz/txshlevel.h"

#include "toonz/toonzscene.h"

#include "toonz/sceneproperties.h"

#include "toonz/studiopalette.h"

#include "toonz/tframehandle.h"

// TnzCore includes

#include "tconvert.h"

// Qt includes

#include <qvboxlayout></qvboxlayout>

#include <qtoolbar></qtoolbar>

#include <qscrollarea></qscrollarea>

#include <qmouseevent></qmouseevent>

#include <qmenubar></qmenubar>

#include <qtoolbutton></qtoolbutton>

#include <qurl></qurl>

#include <qapplication></qapplication>

#include <qlabel></qlabel>

#include <qdrag></qdrag>

using namespace PaletteViewerGUI;

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

/*! \class PaletteViewer

		\brief The PaletteViewer class provides an object to view and manage palette view.

		Inherits \b QWidget.

		This object allows to show and manage palette; it's possible distinguish three

		view type, class can show: current level palette, current studio palette or

		current cleanup palette, using setPalette() to set palette viewer.

		The object is composed of a vertical layout with three widget:

		\li a tab bar \b PaletteViewerGUI::TabBar in which are displayed palette page

		\b createTabBar();

		\li a central frame \b PaletteViewerGUI::PageViewer in which are displayed

		all style of current page in palette

		\li a button bar, \b createToolBar(), \b createPaletteToolBar()

		and \b createSavePaletteToolBar();

		A collection of method allows you to manage this object and its interaction

		with palette.

		*/

/*!	\fn const TPaletteP PaletteViewer::&getPalette() const

		Return current viewer palette.

		*/

/*!	\fn void PaletteViewer::createToolBar()

		Create down button bar.

		*/

/*!	\fn void PaletteViewer::updateToolBar()

		Update button bar.

		*/

PaletteViewer::PaletteViewer(QWidget *parent, PaletteViewType viewType, bool hasSaveToolBar, bool hasPageCommand, bool hasPasteColors)

	: QFrame(parent), m_tabBarContainer(0), m_pagesBar(0), m_paletteToolBar(0), m_savePaletteToolBar(0), m_pageViewer(0), m_pageViewerScrollArea(0), m_indexPageToDelete(-1), m_viewType(viewType), m_frameHandle(0), m_paletteHandle(0), m_changeStyleCommand(0), m_xsheetHandle(0), m_hasSavePaletteToolbar(hasSaveToolBar), m_hasPageCommand(hasPageCommand), m_isSaveActionEnabled(true), m_lockPaletteAction(0), m_lockPaletteToolButton(0)

{

	setObjectName("OnePixelMarginFrame");

	setFrameStyle(QFrame::StyledPanel);

	createTabBar();

	//Create pageView

	m_pageViewerScrollArea = new QScrollArea();

	m_pageViewerScrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

	m_pageViewerScrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);

	m_pageViewerScrollArea->setWidgetResizable(true);

	m_pageViewer = new PageViewer(m_pageViewerScrollArea, m_viewType, hasPasteColors);

	m_pageViewerScrollArea->setWidget(m_pageViewer);

	m_pagesBar->setPageViewer(m_pageViewer);

	// Create toolbar. It is an horizontal layout with three internal toolbar.

	DvScrollWidget *toolbarScrollWidget = new DvScrollWidget;

	toolbarScrollWidget->setObjectName("ToolBarContainer"); // Toonz's qss files are instructed to leave a

	// 1px grey margin on top for scroll buttons

	QWidget *toolBarWidget = new QWidget; // children of this parent name.

	toolbarScrollWidget->setWidget(toolBarWidget);

	toolBarWidget->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);

	toolBarWidget->setFixedHeight(22);

	m_paletteToolBar = new QToolBar(toolBarWidget);

	m_savePaletteToolBar = new QToolBar(toolBarWidget);

	createToolBar();

	QHBoxLayout *toolBarLayout = new QHBoxLayout(toolBarWidget);

	toolBarLayout->setMargin(0);

	toolBarLayout->setSpacing(0);

	{

		toolBarLayout->addWidget(m_savePaletteToolBar, 0, Qt::AlignRight);

		toolBarLayout->addWidget(m_paletteToolBar, 0, Qt::AlignRight);

	}

	toolBarWidget->setLayout(toolBarLayout);

	// This widget is used to set the background color of the tabBar

	// using the styleSheet.

	// It is also used to take 6px on the left before the tabBar

	// and to draw the two lines on the bottom size

	m_tabBarContainer = new TabBarContainter(this);

	QVBoxLayout *mainLayout = new QVBoxLayout(this);

	mainLayout->setMargin(0);

	mainLayout->setSpacing(0);

	{

		// To add 6px (on the left) before the TabBar

		QHBoxLayout *hLayout = new QHBoxLayout;

		hLayout->setMargin(0);

		//hLayout->setAlignment(Qt::AlignLeft);

		//hLayout->addSpacing(6);

		{

			hLayout->addWidget(m_pagesBar, 0);

			hLayout->addStretch(1);

			hLayout->addWidget(toolbarScrollWidget, 0);

		}

		m_tabBarContainer->setLayout(hLayout);

		// To align this panel with the style Editor

		mainLayout->addWidget(m_tabBarContainer, 0);

		mainLayout->addWidget(m_pageViewerScrollArea, 1);

	}

	setLayout(mainLayout);

	connect(m_pagesBar, SIGNAL(currentChanged(int)), this, SLOT(setPageView(int)));

	connect(m_pagesBar, SIGNAL(movePage(int, int)), this, SLOT(movePage(int, int)));

	connect(m_pageViewer, SIGNAL(changeWindowTitleSignal()), this, SLOT(changeWindowTitle()));

	changeWindowTitle();

	setAcceptDrops(true);

}

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

PaletteViewer::~PaletteViewer()

{

	delete m_changeStyleCommand;

}

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

void PaletteViewer::setPaletteHandle(TPaletteHandle *paletteHandle)

{

	if (m_paletteHandle == paletteHandle)

		return;

	bool ret = true;

	if (m_paletteHandle)

		ret = ret && disconnect(m_paletteHandle,0,this,0);

	m_paletteHandle = paletteHandle;

	if (m_paletteHandle && isVisible()) {

		ret = ret && connect(m_paletteHandle, SIGNAL(paletteSwitched()), this, SLOT(onPaletteSwitched()));

		ret = ret && connect(m_paletteHandle, SIGNAL(paletteChanged()), this, SLOT(onPaletteChanged()));

		ret = ret && connect(m_paletteHandle, SIGNAL(paletteChanged()), this, SLOT(changeWindowTitle()));

		ret = ret && connect(m_paletteHandle, SIGNAL(paletteTitleChanged()), this, SLOT(changeWindowTitle()));

		ret = ret && connect(m_paletteHandle, SIGNAL(colorStyleSwitched()), this, SLOT(onColorStyleSwitched()));

		ret = ret && connect(m_paletteHandle, SIGNAL(colorStyleChanged()), this, SLOT(changeWindowTitle()));

		ret = ret && connect(m_paletteHandle, SIGNAL(paletteDirtyFlagChanged()), this, SLOT(changeWindowTitle()));

	}

	assert(ret);

	if (m_viewType != CLEANUP_PALETTE)

		m_keyFrameButton->setPaletteHandle(m_paletteHandle);

	m_pageViewer->setPaletteHandle(m_paletteHandle);

	setPageView(0);

	updateTabBar();

	updatePaletteToolBar();

}

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

void PaletteViewer::setFrameHandle(TFrameHandle *frameHandle)

{

	m_frameHandle = frameHandle;

	if (m_viewType != CLEANUP_PALETTE)

		m_keyFrameButton->setFrameHandle(m_frameHandle);

	m_pageViewer->setFrameHandle(m_frameHandle);

}

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

void PaletteViewer::setXsheetHandle(TXsheetHandle *xsheetHandle)

{

	m_xsheetHandle = xsheetHandle;

	m_pageViewer->setXsheetHandle(m_xsheetHandle);

}

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

/*!for clearing level cache after "paste style" command called from style selection

*/

void PaletteViewer::setLevelHandle(TXshLevelHandle *levelHandle)

{

	m_pageViewer->setLevelHandle(levelHandle);

}

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

TPalette *PaletteViewer::getPalette()

{

	if (!m_paletteHandle)

		return 0;

	return m_paletteHandle->getPalette();

}

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

void PaletteViewer::updateView()

{

	changeWindowTitle();

	setPageView(0);

	clearStyleSelection();

	updateTabBar();

	updatePaletteToolBar();

	updateSavePaletteToolBar();

}

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

void PaletteViewer::enableSaveAction(bool enable)

{

	if (!m_savePaletteToolBar)

		return;

	QList<qaction *=""> actions;</qaction>

	actions = m_savePaletteToolBar->actions();

	enable = !getPalette() ? false : enable;

	m_isSaveActionEnabled = enable;

	int i;

	for (i = 0; i < actions.count() - 1; i++) {

		QAction *act = actions[i];

		if (act->text() == tr("&Save Palette As") || act->text() == tr("&Save Palette"))

			act->setEnabled(enable);

	}

}

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

/*! Create tab bar to select palette page.

*/

void PaletteViewer::createTabBar()

{

	m_pagesBar = new PaletteTabBar(this, m_hasPageCommand);

	connect(m_pagesBar, SIGNAL(tabTextChanged(int)), this, SLOT(onTabTextChanged(int)));

	if (!getPalette())

		return;

	updateTabBar();

}

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

/*! Create right part of button bar.

*/

void PaletteViewer::createPaletteToolBar()

{

	m_paletteToolBar->clear();

	m_paletteToolBar->setMovable(false);

	m_paletteToolBar->setIconSize(QSize(23, 20));

	m_paletteToolBar->setLayoutDirection(Qt::RightToLeft);

	//Lock button to avoid editing the palette by mistake

	if (m_viewType == LEVEL_PALETTE) {

		QIcon lockIcon = createQIconOnOffPNG("lockpalette");

		m_lockPaletteToolButton = new QToolButton(this);

		m_lockPaletteToolButton->setIcon(lockIcon);

		m_lockPaletteToolButton->setCheckable(true);

		m_lockPaletteToolButton->setObjectName("PaletteLockButton");

		m_lockPaletteToolButton->setToolTip(tr("Lock Palette"));

		if (getPalette()) {

			m_lockPaletteToolButton->setChecked(getPalette()->isLocked());

		}

		connect(m_lockPaletteToolButton, SIGNAL(clicked(bool)), this, SLOT(setIsLocked(bool)));

		m_paletteToolBar->addWidget(m_lockPaletteToolButton);

	} else if (m_viewType == STUDIO_PALETTE) {

		QToolButton *toolButton = new QToolButton(this);

		toolButton->setPopupMode(QToolButton::InstantPopup);

		QIcon lockIcon = createQIconOnOffPNG("lockpalette");

		toolButton->setIcon(lockIcon);

		toolButton->setObjectName("PaletteLockButton");

		toolButton->setToolTip(tr("Lock Palette"));

		toolButton->setCheckable(true);

		QMenu *lockMenu = new QMenu(toolButton);

		m_lockPaletteAction = new QAction(tr("&Lock Palette"), toolButton);

		m_lockPaletteAction->setCheckable(true);

		lockMenu->addAction(m_lockPaletteAction);

		toolButton->setMenu(lockMenu);

		if (getPalette()) {

			m_lockPaletteAction->setChecked(getPalette()->isLocked());

		}

		connect(m_lockPaletteAction, SIGNAL(triggered(bool)), this, SLOT(setIsLocked(bool)));

		connect(m_lockPaletteAction, SIGNAL(toggled(bool)), toolButton, SLOT(setChecked(bool)));

		m_paletteToolBar->addWidget(toolButton);

	}

	// Attenzione: alcune modifiche sono state fatte a livello di stylesheet

	QToolButton *viewModeButton = new QToolButton(this);

	viewModeButton->setPopupMode(QToolButton::InstantPopup);

	QIcon viewModeIcon = createQIconPNG("options");

	viewModeButton->setIcon(viewModeIcon);

	QMenu *viewMode = new QMenu(QString("Options"), viewModeButton);

	viewMode->setToolTip(tr("Options"));

	QActionGroup *viewModeGroup = new QActionGroup(viewMode);

	connect(viewModeGroup, SIGNAL(triggered(QAction *)), this, SLOT(onViewMode(QAction *)));

	QAction *smallThumbAct = new QAction(tr("&Small Thumbnails View"), viewModeButton);

	smallThumbAct->setData(PageViewer::SmallChips);

	QAction *mediumThumbAct = new QAction(tr("&Medium Thumbnails View"), viewModeButton);

	mediumThumbAct->setData(PageViewer::MediumChips);

	QAction *largeThumbAct = new QAction(tr("&Large Thumbnails View"), viewModeButton);

	largeThumbAct->setData(PageViewer::LargeChips);

	QAction *listAct = new QAction(tr("&List View"), viewModeButton);

	listAct->setData(PageViewer::List);

	viewModeGroup->addAction(smallThumbAct);

	viewModeGroup->addAction(mediumThumbAct);

	viewModeGroup->addAction(largeThumbAct);

	viewModeGroup->addAction(listAct);

	QAction *styleDisplayAct = new QAction(tr("Style Name"), viewModeButton);

	styleDisplayAct->setData(PageViewer::Style);

	QAction *originalDisplayAct = new QAction(tr("StudioPalette Name"), viewModeButton);

	originalDisplayAct->setData(PageViewer::Original);

	QAction *bothDisplayAct = new QAction(tr("Both Names"), viewModeButton);

	bothDisplayAct->setData(PageViewer::StyleAndOriginal);

	QActionGroup *nameDisplayModeGroup = new QActionGroup(viewMode);

	connect(nameDisplayModeGroup, SIGNAL(triggered(QAction *)), this, SLOT(onNameDisplayMode(QAction *)));

	nameDisplayModeGroup->addAction(styleDisplayAct);

	nameDisplayModeGroup->addAction(originalDisplayAct);

	nameDisplayModeGroup->addAction(bothDisplayAct);

	viewMode->addAction(smallThumbAct);

	viewModeGroup->addAction(mediumThumbAct);

	viewMode->addAction(largeThumbAct);

	viewMode->addAction(listAct);

	viewMode->addSeparator();

	viewMode->addAction(styleDisplayAct);

	viewMode->addAction(originalDisplayAct);

	viewMode->addAction(bothDisplayAct);

	viewModeButton->setMenu(viewMode);

	// Attenzione: avendo invertito la direzione devo aggiungere gli oggetti al contrario

	m_paletteToolBar->addWidget(viewModeButton);

	m_paletteToolBar->addSeparator();

	if (m_hasPageCommand) {

		QAction *addPage;

		QIcon addPageIcon = createQIconPNG("newpage");

		addPage = new QAction(addPageIcon, tr("&New Page"), m_paletteToolBar);

		connect(addPage, SIGNAL(triggered()), this, SLOT(addNewPage()));

		m_paletteToolBar->addAction(addPage);

	}

	QIcon newColorIcon = createQIconPNG("newstyle");

	QAction *addColor = new QAction(newColorIcon, tr("&New Style"), m_paletteToolBar);

	connect(addColor, SIGNAL(triggered()), this, SLOT(addNewColor()));

	m_paletteToolBar->addAction(addColor);

	m_paletteToolBar->addSeparator();

	//KeyFrame button

	if (m_viewType != CLEANUP_PALETTE) {

		m_keyFrameButton = new PaletteKeyframeNavigator(m_paletteToolBar);

		m_paletteToolBar->addWidget(m_keyFrameButton);

		m_paletteToolBar->addSeparator();

		m_keyFrameButton->setSelection(m_pageViewer->getSelection());

	}

	updatePaletteToolBar();

}

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

/*! Create left part of button bar; insert different actions in according to

		current viewer palette type.

		*/

void PaletteViewer::createSavePaletteToolBar()

{

	m_savePaletteToolBar->clear();

	m_savePaletteToolBar->setMovable(false);

	m_savePaletteToolBar->setIconSize(QSize(22, 20));

	if (!m_hasSavePaletteToolbar || m_viewType == CLEANUP_PALETTE) {

		m_savePaletteToolBar->hide();

		return;

	}

	//save palette as

	QIcon saveAsPaletteIcon = createQIconOnOffPNG("savepaletteas", false);

	QAction *saveAsPalette = new QAction(saveAsPaletteIcon, tr("&Save Palette As"), m_savePaletteToolBar);

	//overwrite palette

	QIcon savePaletteIcon = createQIconOnOffPNG("savepalette", false);

	QAction *savePalette = new QAction(savePaletteIcon, tr("&Save Palette"), m_savePaletteToolBar);

	if (m_viewType == STUDIO_PALETTE) {

		connect(savePalette, SIGNAL(triggered()), this, SLOT(saveStudioPalette()));

		m_savePaletteToolBar->addAction(savePalette);

	} else if (m_viewType == LEVEL_PALETTE) {

		//save load palette

		PaletteIconWidget *movePalette = new PaletteIconWidget(m_savePaletteToolBar);

		connect(movePalette, SIGNAL(startDrag()), this, SLOT(startDragDrop()));

		QAction *act = m_savePaletteToolBar->addWidget(movePalette);

		act->setText(tr("&Move Palette"));

		m_savePaletteToolBar->addSeparator();

		//save palette as

		connect(saveAsPalette, SIGNAL(triggered()),

				CommandManager::instance()->getAction("MI_SavePaletteAs"), SIGNAL(triggered()));

		m_savePaletteToolBar->addAction(saveAsPalette);

		//overwrite palette

		connect(savePalette, SIGNAL(triggered()),

				CommandManager::instance()->getAction("MI_OverwritePalette"), SIGNAL(triggered()));

		m_savePaletteToolBar->addAction(savePalette);

	}

	updateSavePaletteToolBar();

}

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

/*! Update page tab bar adding or removing tab in accord with viewer palette.

*/

void PaletteViewer::updateTabBar()

{

	int tabCount = m_pagesBar->count();

	int i;

	//Se ci sono tab li butto

	for (i = tabCount - 1; i >= 0; i--)

		m_pagesBar->removeTab(i);

	TPalette *palette = getPalette();

	if (!palette)

		return;

	QIcon tabIcon(":Resources/palette_tabicon.png");

	m_pagesBar->setIconSize(QSize(20, 15));

	//Aggiungo i tab in funzione delle pagine di m_palette

	for (i = 0; i < palette->getPageCount(); i++) {

		TPalette::Page *page = palette->getPage(i);

		std::wstring ws = page->getName();

		QString pageName = QString::fromStdWString(ws);

		m_pagesBar->addTab(tabIcon, pageName);

	}

	m_pagesBar->update();

}

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

/*! Update right button bar, enable its action if current viewer palette is empty.

*/

void PaletteViewer::updatePaletteToolBar()

{

	if (!m_paletteToolBar)

		return;

	QList<qaction *=""> actions;</qaction>

	actions = m_paletteToolBar->actions();

	TPalette *palette = getPalette();

	bool enable = !palette ? false : true;

	bool enableNewStyleAct = enable;

	//limit the number of cleanup styles to 7

	if (palette && palette->isCleanupPalette())

		enableNewStyleAct = (palette->getStyleInPagesCount() < 8);

	if (m_viewType != CLEANUP_PALETTE)

		m_keyFrameButton->setEnabled(enable);

	int i;

	for (i = 0; i < actions.count(); i++) {

		QAction *act = actions[i];

		if (act->text() == tr("&New Style")) {

			act->setEnabled(enableNewStyleAct);

			continue;

		}

		act->setEnabled(enable);

	}

}

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

/*! Update left button bar, enable its action if current viewer palette is empty.

*/

void PaletteViewer::updateSavePaletteToolBar()

{

	if (!m_savePaletteToolBar)

		return;

	QList<qaction *=""> actions;</qaction>

	actions = m_savePaletteToolBar->actions();

	bool enable = !getPalette() ? false : true;

	int i;

	for (i = 0; i < actions.count(); i++) {

		QAction *act = actions[i];

		if (act->text() == tr("&Save Palette As") ||

			act->text() == tr("&Save Palette") ||

			act->text() == tr("&Palette Gizmo"))

			act->setEnabled(enable);

		else if (m_viewType != STUDIO_PALETTE && i == 0) //move action

			actions[i]->setVisible(enable);

		else

			actions[i]->setEnabled(false);

	}

}

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

/*! Resize the widget and its child.

*/

void PaletteViewer::resizeEvent(QResizeEvent *event)

{

	QWidget::resizeEvent(event);

	if (m_pageViewer)

		m_pageViewer->computeSize();

	if (m_pagesBar)

		m_pagesBar->setMaximumWidth(width() - 12);

}

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

void PaletteViewer::setChangeStyleCommand(ChangeStyleCommand *changeStyleCommand)

{

	if (m_changeStyleCommand)

		delete m_changeStyleCommand;

	m_changeStyleCommand = changeStyleCommand;

	m_pageViewer->setChangeStyleCommand(m_changeStyleCommand);

}

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

/*! Create and open the Right-click menu.

*/

void PaletteViewer::contextMenuEvent(QContextMenuEvent *event)

{

	m_indexPageToDelete = -1;

	QPoint pos = event->pos();

	if (!getPalette() || !m_tabBarContainer->geometry().contains(pos))

		return;

	QMenu *menu = new QMenu(this);

	if (m_hasPageCommand) {

		QAction *newPage = menu->addAction(tr("New Page"));

		connect(newPage, SIGNAL(triggered()), SLOT(addNewPage()));

		if (m_pagesBar->geometry().contains(pos)) {

			int tabIndex = m_pagesBar->tabAt(pos);

			TPalette::Page *page = getPalette()->getPage(tabIndex);

			if (page) {

				bool canRemovePage = true;

				if (page->getStyleId(0) == 0 || page->getStyleId(1) == 1)

					canRemovePage = false;

				if (canRemovePage) {

					m_indexPageToDelete = tabIndex;

					QAction *deletePage = menu->addAction(tr("Delete Page"));

					connect(deletePage, SIGNAL(triggered()), SLOT(deletePage()));

				}

			}

		}

	}

	if (m_viewType == LEVEL_PALETTE && m_isSaveActionEnabled) {

		menu->addSeparator();

		menu->addAction(CommandManager::instance()->getAction("MI_OverwritePalette"));

		menu->addAction(CommandManager::instance()->getAction("MI_SavePaletteAs"));

	}

	menu->exec(event->globalPos());

}

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

void PaletteViewer::showEvent(QShowEvent *)

{

	onPaletteSwitched();

	changeWindowTitle();

	if (!m_paletteHandle)

		return;

	connect(m_paletteHandle, SIGNAL(paletteSwitched()), this, SLOT(onPaletteSwitched()));

	connect(m_paletteHandle, SIGNAL(paletteChanged()), this, SLOT(onPaletteChanged()));

	connect(m_paletteHandle, SIGNAL(paletteTitleChanged()), this, SLOT(changeWindowTitle()));

	connect(m_paletteHandle, SIGNAL(colorStyleSwitched()), this, SLOT(onColorStyleSwitched()));

	connect(m_paletteHandle, SIGNAL(colorStyleChanged()), this, SLOT(changeWindowTitle()));

	connect(m_paletteHandle, SIGNAL(paletteDirtyFlagChanged()), this, SLOT(changeWindowTitle()));

	if (!m_frameHandle)

		return;

	//Connessione necessaria per aggiornare lo stile in caso di palette animate.

	connect(m_frameHandle, SIGNAL(frameSwitched()), this, SLOT(onFrameSwitched()));

}

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

void PaletteViewer::hideEvent(QHideEvent *)

{

	disconnect(m_paletteHandle, SIGNAL(paletteSwitched()), this, SLOT(onPaletteSwitched()));

	disconnect(m_paletteHandle, SIGNAL(paletteChanged()), this, SLOT(onPaletteChanged()));

	disconnect(m_paletteHandle, SIGNAL(paletteTitleChanged()), this, SLOT(changeWindowTitle()));

	disconnect(m_paletteHandle, SIGNAL(colorStyleSwitched()), this, SLOT(onColorStyleSwitched()));

	disconnect(m_paletteHandle, SIGNAL(colorStyleChanged()), this, SLOT(changeWindowTitle()));

	disconnect(m_paletteHandle, SIGNAL(paletteDirtyFlagChanged()), this, SLOT(changeWindowTitle()));

	if (!m_frameHandle)

		return;

	disconnect(m_frameHandle, SIGNAL(frameSwitched()), this, SLOT(onFrameSwitched()));

}

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

/*! If currente palette viewer exist verify event data, if is a PaletteData or

		has urls accept event.

		*/

void PaletteViewer::dragEnterEvent(QDragEnterEvent *event)

{

	TPalette *palette = getPalette();

	if (!palette || m_viewType == CLEANUP_PALETTE)

		return;

	const QMimeData *mimeData = event->mimeData();

	const PaletteData *paletteData = dynamic_cast<const *="" palettedata="">(mimeData);</const>

	if (paletteData) {

		// Sto "draggando" stili.

		if (paletteData->hasStyleIndeces()) {

			m_pageViewer->createDropPage();

			if (!palette)

				m_pagesBar->setCurrentIndex(palette->getPageCount() - 1);

		}

		// Accetto l'evento

		event->acceptProposedAction();

		return;

	}

	if (!acceptResourceDrop(mimeData->urls()))

		return;

	QList<qurl> urls = mimeData->urls();</qurl>

	int count = urls.size();

	if (count == 0)

		return;

	//Accetto l'evento solo se ho tutte palette.

	int i;

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

		TFilePath path(urls[i].toLocalFile().toStdWString());

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

			return;

	}

	event->acceptProposedAction();

}

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

/*! Execute drop event.

*/

void PaletteViewer::dropEvent(QDropEvent *event)

{

	if (m_viewType == CLEANUP_PALETTE)

		return;

	const QMimeData *mimeData = event->mimeData();

	QPoint tollBarPos = m_savePaletteToolBar->mapFrom(this, event->pos());

	QAction *currentAction = m_savePaletteToolBar->actionAt(tollBarPos);

	bool loadPalette = currentAction && currentAction->text() == QString(tr("&Move Palette"));

	// ho i path delle palette

	if (mimeData->hasUrls()) {

		QList<qurl> urls = mimeData->urls();</qurl>

		int count = urls.size();

		if (count == 0)

			return;

		int i;

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

			TFilePath path(urls[i].toLocalFile().toStdWString());

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

				return;

			if (loadPalette && i == 0) {

				if (m_xsheetHandle) {

					TPalette *newPalette = StudioPalette::instance()->getPalette(path, false);

					if (!newPalette)

						return;

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

					if (ret == 0)

						return;

				}

				StudioPaletteCmd::loadIntoCurrentPalette(m_paletteHandle, path);

			} else

				StudioPaletteCmd::mergeIntoCurrentPalette(m_paletteHandle, path);

			if (loadPalette) {

				TFilePath refImagePath = StudioPalette::instance()->getPalette(path, true)->getRefImgPath();

				if (!refImagePath.isEmpty() && getPalette()->getRefImgPath().isEmpty()) {

					getPalette()->setRefImgPath(refImagePath);

					m_paletteHandle->notifyPaletteChanged();

				}

			}

		}

		event->acceptProposedAction();

		return;

	}

	const PaletteData *paletteData = dynamic_cast<const *="" palettedata="">(mimeData);</const>

	if (!paletteData)

		return;

	// Sto inserendo stili

	if (paletteData->hasStyleIndeces()) {

		m_pageViewer->drop(-1, mimeData);

		event->acceptProposedAction();

	} else {

		// Ho la palette da inserire

		TPalette *palette = paletteData->getPalette();

		if (getPalette() == palette)

			return;

		if (loadPalette) {

			if (m_xsheetHandle) {

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

				if (ret == 0)

					return;

			}

			StudioPaletteCmd::loadIntoCurrentPalette(m_paletteHandle, palette);

		} else

			StudioPaletteCmd::mergeIntoCurrentPalette(m_paletteHandle, palette);

	}

}

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

/*! Start drag and drop; if current page exist set drag and drop event data.

*/

void PaletteViewer::startDragDrop()

{

	TRepetitionGuard guard;

	if (!guard.hasLock())

		return;

	if (m_viewType == CLEANUP_PALETTE)

		return;

	assert(m_viewType != STUDIO_PALETTE && m_viewType != CLEANUP_PALETTE);

	TPalette *palette = getPalette();

	if (!palette)

		return;

	QDrag *drag = new QDrag(this);

	PaletteData *paletteData = new PaletteData();

	paletteData->setPalette(palette);

	drag->setMimeData(paletteData);

	Qt::DropAction dropAction = drag->exec(Qt::CopyAction | Qt::MoveAction);

}

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

void PaletteViewer::clearStyleSelection()

{

	m_pageViewer->clearSelection();

}

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

/*! Set current view page to \b currentIndexPage

*/

void PaletteViewer::setPageView(int currentIndexPage)

{

	TPalette *palette = getPalette();

	TPalette::Page *page = palette ? palette->getPage(currentIndexPage) : 0;

	m_pageViewer->setPage(page);

}

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

/*! If current palette viewer is not empty create emit a signal to create new

		palette page.

		*/

void PaletteViewer::addNewPage()

{

	TPalette *palette = getPalette();

	if (palette) {

		if (palette->isLocked())

			return;

		updateTabBar();

		PaletteCmd::addPage(m_paletteHandle);

	}

}

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

/*! Create a new style in current page view of current palette viewer emit a signal

		to create a new style.

		*/

void PaletteViewer::addNewColor()

{

	if (!getPalette() || getPalette()->isLocked())

		return;

	TPalette::Page *page = m_pageViewer->getPage();

	update();

	PaletteCmd::createStyle(m_paletteHandle, page);

	m_pageViewer->computeSize();

	if (m_viewType == CLEANUP_PALETTE)

		updatePaletteToolBar();

}

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

/*! Emit a signal to delete a page of current palette viewer.

*/

void PaletteViewer::deletePage()

{

	TPalette *palette = getPalette();

	if (!palette || palette->isLocked())

		return;

	if (m_xsheetHandle) {

		std::vector<int> styleIds;</int>

		TPalette::Page *page = palette->getPage(m_indexPageToDelete);

		if (!page)

			return; //La pagina dovrebbe esserci sempre

		int i;

		for (i = 0; i < page->getStyleCount(); i++)

			styleIds.push_back(page->getStyleId(i));

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

		if (ret == 0)

			return;

	}

	PaletteCmd::destroyPage(m_paletteHandle, m_indexPageToDelete);

	updateTabBar();

	palette->setDirtyFlag(true);

	if (m_viewType == CLEANUP_PALETTE)

		updatePaletteToolBar();

}

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

/*! If current palette view is studio palette and palette has a global name

		save current viewer palette in studio palette.

		*/

void PaletteViewer::saveStudioPalette()

{

	StudioPalette *sp = StudioPalette::instance();

	TPalette *palette = getPalette();

	if (!palette) {

		DVGui::warning("No current palette");

		return;

	}

	std::wstring gname = palette->getGlobalName();

	if (gname.empty()) {

		StudioPaletteViewer *parentSPV = qobject_cast<studiopaletteviewer *="">(parentWidget());</studiopaletteviewer>

		if (!parentSPV) {

			DVGui::warning("No GlobalName");

			return;

		} else {

			TFilePath palettePath = parentSPV->getCurrentItemPath();

			if (palettePath.isEmpty())

				DVGui::warning("No GlobalName, No Filepath");