#include "toonzqt/paletteviewergui.h"
 
// TnzQt includes
#include "toonzqt/styleselection.h"
#include "toonzqt/trepetitionguard.h"
#include "toonzqt/gutil.h"
#include "toonzqt/paletteviewer.h"
#include "toonzqt/selectioncommandids.h"
#include "toonzqt/stylenameeditor.h"
#include "toonzqt/viewcommandids.h"
#include "palettedata.h"
 
// TnzLib includes
#include "toonz/palettecmd.h"
#include "toonz/txshlevel.h"
#include "toonz/studiopalette.h"
#include "toonz/txsheethandle.h"
#include "toonz/tframehandle.h"
#include "toonz/imagestyles.h"
#include "toonz/preferences.h"
 
// TnzCore includes
#include "tcolorstyles.h"
#include "tundo.h"
#include "tenv.h"
 
// Qt includes
#include <QPainter>
#include <QMouseEvent>
#include <QKeyEvent>
#include <QMenuBar>
#include <QToolTip>
#include <QDrag>
#include <QAction>
#include <QShortcut>
 
// enable to set font size for style name separately from other texts
TEnv::IntVar EnvSoftwareCurrentFontSize_StyleName("SoftwareCurrentFontSize_StyleName", 11);
 
using namespace PaletteViewerGUI;
using namespace DVGui;
 
//=============================================================================
/*! \namespace PaletteViewerGUI
		\brief Provides a collection of widget to show \b palette.
		*/
 
//=============================================================================
/*! \enum PaletteViewerGUI::PaletteViewType
		\brief Useful to mark different palette viewer type.
 
		There are three possible palette to view:
		\li level palette, palette of current level;
		\li cleanup palette, current scene cleanup palette;
		\li studio palette.
		*/
 
//=============================================================================
/*! \class PaletteViewerGUI::PageViewer
		\brief The PageViewer class provides an object to view and manage palettes page.
 
		Inherits \b QFrame and \b TSelection::View.
 
		This object allows to show and manage a single palette page. An enum type
		\b PaletteViewerGUI::PageViewer::ViewMode, getViewMode(), specify visualization
		mode, it is possible set it using setViewMode(). Class manage all mouse event,
		move, press, drag and drop.
		*/
/*! \enum PaletteViewerGUI::PageViewer::ViewMode
		Useful to mark different page view moed:
		\li SmallChips: displays styles as small squares; the name of the style is
		displayed as tooltip.
		\li SmallChipsWithName:
		displays styles as small squares with the name insde.
		\li LargeChips: displays the styles on top of the name of the style.
		\li List:				List displays style thumbnails next to their names in a list;
		if the palette styles are referring to a studio palette, its
		path will be displayed along with the style name.
		*/
/*!	\fn TPalette::Page* PageViewer::getPage() const
		Return current page.
		*/
/*!	\fn ViewMode PageViewer::getViewMode() const
		Return current page view mode \b PaletteViewerGUI::PageViewer::ViewMode.
		*/
/*! \fn void TPalette::onSelectionChanged()
		Update current page view.
		*/
PageViewer::PageViewer(QWidget *parent, PaletteViewType viewType, bool hasPasteColors)
	: QFrame(parent), m_page(0), m_chipsOrigin(2, 2), m_chipPerRow(0), m_viewMode(SmallChips), m_styleSelection(new TStyleSelection()), m_frameHandle(0), m_renameTextField(new LineEdit(this)), m_dropPositionIndex(-1), m_dropPageCreated(false), m_startDrag(false), m_viewType(viewType), m_nameDisplayMode(Style), m_hasPasteColors(hasPasteColors), m_changeStyleCommand(0)
{
	setFrameStyle(QFrame::StyledPanel);
	setObjectName("PageViewer");
	setFocusPolicy(Qt::StrongFocus);
	CommandManager *cmd = CommandManager::instance();
	QAction *pasteValueAct = cmd->getAction(MI_PasteInto);
	addAction(pasteValueAct);
	if (m_hasPasteColors) {
		QAction *pasteColorsAct = cmd->getAction(MI_PasteColors);
		addAction(pasteColorsAct);
	}
 
	m_styleNameEditor = new StyleNameEditor(this);
	m_styleNameEditor->hide();
 
	m_renameTextField->hide();
	m_renameTextField->setObjectName("RenameColorTextField");
	connect(m_renameTextField, SIGNAL(editingFinished()), this, SLOT(onStyleRenamed()));
	m_styleSelection->setView(this);
	setAcceptDrops(true);
 
	// applying default chip sizes
	ViewMode defaultChipSize;
	switch (m_viewType) {
	case LEVEL_PALETTE:
		defaultChipSize = (ViewMode)ChipSizeManager::instance()->chipSize_Palette;
		break;
	case CLEANUP_PALETTE:
		defaultChipSize = (ViewMode)ChipSizeManager::instance()->chipSize_Cleanup;
		break;
	case STUDIO_PALETTE:
		defaultChipSize = (ViewMode)ChipSizeManager::instance()->chipSize_Studio;
		break;
	default:
		defaultChipSize = (ViewMode)2;
		break;
	}
	setViewMode(defaultChipSize);
}
 
//-----------------------------------------------------------------------------
 
PageViewer::~PageViewer()
{
	delete m_styleSelection;
}
 
//-----------------------------------------------------------------------------
 
void PageViewer::setPaletteHandle(TPaletteHandle *paletteHandle)
{
	TPaletteHandle *previousPalette = getPaletteHandle();
	if (previousPalette == paletteHandle)
		return;
 
	if (previousPalette)
		disconnect(previousPalette, SIGNAL(colorStyleChanged()), this, SLOT(update()));
 
	m_styleSelection->setPaletteHandle(paletteHandle);
	connect(paletteHandle, SIGNAL(colorStyleChanged()), SLOT(update()));
 
	m_styleNameEditor->setPaletteHandle(paletteHandle);
}
 
//-----------------------------------------------------------------------------
 
TPaletteHandle *PageViewer::getPaletteHandle() const
{
	return m_styleSelection->getPaletteHandle();
}
 
//-----------------------------------------------------------------------------
 
void PageViewer::setXsheetHandle(TXsheetHandle *xsheetHandle)
{
	m_styleSelection->setXsheetHandle(xsheetHandle);
}
 
//-----------------------------------------------------------------------------
 
TXsheetHandle *PageViewer::getXsheetHandle() const
{
	return m_styleSelection->getXsheetHandle();
}
 
//-----------------------------------------------------------------------------
/*! for clearing the cache when executing paste style command from StyleSelection
*/
void PageViewer::setLevelHandle(TXshLevelHandle *levelHandle)
{
	m_styleSelection->setLevelHandle(levelHandle);
}
 
//-----------------------------------------------------------------------------
 
void PageViewer::setFrameHandle(TFrameHandle *frameHandle)
{
	m_frameHandle = frameHandle;
}
 
//-----------------------------------------------------------------------------
 
TFrameHandle *PageViewer::getFrameHandle() const
{
	return m_frameHandle;
}
 
//-----------------------------------------------------------------------------
 
void PageViewer::setCurrentStyleIndex(int index)
{
	getPaletteHandle()->setStyleIndex(index);
}
 
//-----------------------------------------------------------------------------
 
int PageViewer::getCurrentStyleIndex() const
{
	return getPaletteHandle()->getStyleIndex();
}
 
//-----------------------------------------------------------------------------
/*! Set current page to \b page and update view.
*/
void PageViewer::setPage(TPalette::Page *page)
{
	m_page = page;
	computeSize();
	update();
}
 
//-----------------------------------------------------------------------------
/*! Return chip count contained in current page.
*/
int PageViewer::getChipCount() const
{
	return m_page ? m_page->getStyleCount() : 0;
}
 
//-----------------------------------------------------------------------------
/*! Set current view mode \b PaletteViewerGUI::PageViewer::ViewMode to \b viewMode and update view.
*/
void PageViewer::setViewMode(ViewMode viewMode)
{
	if (m_viewMode == viewMode)
		return;
	m_viewMode = viewMode;
	computeSize();
	update();
 
	//keep new view mode for reproducing the same mode when a new palette is made
	switch (m_viewType) {
	case LEVEL_PALETTE:
		ChipSizeManager::instance()->chipSize_Palette = (int)m_viewMode;
		break;
	case CLEANUP_PALETTE:
		ChipSizeManager::instance()->chipSize_Cleanup = (int)m_viewMode;
		break;
	case STUDIO_PALETTE:
		ChipSizeManager::instance()->chipSize_Studio = (int)m_viewMode;
		break;
	default:
		break;
	}
}
 
//-----------------------------------------------------------------------------
/*! Return current chip index by position \b pos.
		N.B. Cannot return chip index > max.
		*/
int PageViewer::posToIndex(const QPoint &pos) const
{
	if (m_chipPerRow == 0)
		return -1;
	QSize chipSize = getChipSize();
	int j = (pos.x() - m_chipsOrigin.x()) / chipSize.width();
	int i = (pos.y() - m_chipsOrigin.y()) / chipSize.height();
	int index = i * m_chipPerRow + j;
	// if(index<0 || index>=getChipCount()) return -1;
	return index;
}
 
//-----------------------------------------------------------------------------
/*! Return item rect of chip identified by \b index. Item rect is the rect of
		chip + name.
		*/
QRect PageViewer::getItemRect(int index) const
{
	if (m_chipPerRow == 0)
		return QRect();
	int row = index / m_chipPerRow;
	int col = index - (row * m_chipPerRow);
	int x0 = m_chipsOrigin.x();
	int y0 = m_chipsOrigin.y();
	QSize chipSize = getChipSize();
	int chipLx = chipSize.width();
	int chipLy = chipSize.height();
	QRect rect(x0 + chipLx * col, y0 + chipLy * row, chipLx, chipLy);
	return rect;
}
 
//-----------------------------------------------------------------------------
/*! Return rect of color area of chip identified by \b index.
*/
QRect PageViewer::getColorChipRect(int index) const
{
	QRect rect = getItemRect(index);
	if (rect.isNull())
		return rect;
	if (m_viewMode == LargeChips)
		rect.setHeight(20);
	else if (m_viewMode == List)
		rect.setWidth(rect.height());
	return rect;
}
 
//-----------------------------------------------------------------------------
/*! Return rect of chip identified by \b index name. (Not in \b SmallChips).
*/
QRect PageViewer::getColorNameRect(int index) const
{
	QRect rect = getItemRect(index);
	if (rect.isNull())
		return rect;
	if (m_viewMode == LargeChips)
		rect.adjust(-10, 14, 10, -14);
	else if (m_viewMode == MediumChips)
		rect.adjust(-15, 7, 15, -7);
	else if (m_viewMode == List)
		rect.setLeft(rect.left() + rect.height());
	else
		return rect;
	return rect;
}
 
//-----------------------------------------------------------------------------
/*! Add color to current page; if indexInPage == -1 add color at the bottom of page.
*/
void PageViewer::drop(int dstIndexInPage, const QMimeData *mimeData)
{
	assert(m_page);
	TPalette *palette = m_page->getPalette();
	if (!palette)
		return;
	int dstPageIndex = m_page->getIndex();
	if ((m_page->getStyleId(0) == 0 || m_page->getStyleId(1) == 1) && dstIndexInPage < 2)
		dstIndexInPage = 2;
	if (dstIndexInPage < 0)
		dstIndexInPage = m_page->getStyleCount();
 
	const PaletteData *paletteData = dynamic_cast<const PaletteData *>(mimeData);
 
	if (!paletteData || !paletteData->hasStyleIndeces())
		return;
 
	TPalette *srcPalette = paletteData->getPalette();
	int srcPageIndex = paletteData->getPageIndex();
	std::set<int> srcIndicesInPage = paletteData->getIndicesInPage();
 
	if (m_dropPageCreated) {
		//Rimuovo e reinserisco la pagina inizializzando l'undo.
		palette->setDirtyFlag(true);
		int pageIndex = palette->getPageCount() - 1;
		palette->erasePage(pageIndex);
		if (dstPageIndex != srcPageIndex && pageIndex == dstPageIndex) {
			TUndoManager::manager()->beginBlock();
			PaletteCmd::addPage(getPaletteHandle());
		} else
			m_dropPageCreated = false;
		getPaletteHandle()->notifyPaletteChanged();
	}
	if (srcPalette == palette) {
		PaletteCmd::arrangeStyles(getPaletteHandle(), dstPageIndex, dstIndexInPage, srcPageIndex, srcIndicesInPage);
 
		//seleziono gli stili spostati
		clearSelection();
		std::set<int>::const_reverse_iterator i;
		int k = 0;
		for (i = srcIndicesInPage.rbegin(); i != srcIndicesInPage.rend(); ++i, ++k) {
			int index = 0;
			if (*i <= dstIndexInPage)
				index = dstIndexInPage - k - 1;
			else
				index = dstIndexInPage + k;
			m_styleSelection->select(dstPageIndex, index, true);
		}
	} else //when dropping the style into another palette
	{
		std::vector<TColorStyle *> styles;
		std::set<int>::iterator it;
		for (it = srcIndicesInPage.begin(); it != srcIndicesInPage.end(); ++it) {
			int indexInPage = *it;
			styles.push_back(srcPalette->getPage(srcPageIndex)->getStyle(indexInPage));
		}
 
		PaletteCmd::addStyles(getPaletteHandle(), dstPageIndex, dstIndexInPage, styles);
	}
 
	if (m_dropPageCreated) {
		m_dropPageCreated = false;
		TUndoManager::manager()->endBlock();
	}
}
 
//-----------------------------------------------------------------------------
/*! Create an empty page to receive drop.
*/
void PageViewer::createDropPage()
{
	if (m_dropPageCreated)
		return;
	m_dropPageCreated = true;
	assert(m_page);
	TPalette *palette = m_page->getPalette();
	if (palette)
		PaletteCmd::addPage(getPaletteHandle(), L"", false);
}
 
//-----------------------------------------------------------------------------
 
void PageViewer::clearSelection()
{
	m_styleSelection->selectNone();
}
 
//-----------------------------------------------------------------------------
/*! Return page chip size, it depend from current \b PaletteViewerGUI::PageViewer::ViewMode.
*/
QSize PageViewer::getChipSize() const
{
	if (m_viewMode == SmallChips || m_viewMode == SmallChipsWithName)
		return QSize(48, 33);
	else if (m_viewMode == MediumChips)
		return QSize(98, 38);
	else if (m_viewMode == LargeChips)
		return QSize(155, 53);
	else
		return QSize(width(), 22);
}
 
//-----------------------------------------------------------------------------
/*! Draw a single chip style \b style in \b chipRect.
*/
void PageViewer::drawColorChip(QPainter &p, QRect &chipRect, TColorStyle *style)
{
	TRaster32P icon = style->getIcon(qsize2Dimension(chipRect.size()));
	p.drawPixmap(chipRect.left(), chipRect.top(), rasterToQPixmap(icon, false));
	p.drawRect(chipRect);
}
 
//-----------------------------------------------------------------------------
/*! Draw style \b style name in \b nameRect.
*/
void PageViewer::drawColorName(QPainter &p, QRect &nameRect, TColorStyle *style, int styleIndex)
{
	if (m_viewMode == SmallChips && style->getFlags() == 0)
		return;
	TPalette *palette = (m_page) ? m_page->getPalette() : 0;
 
	QString name = QString::fromStdWString(style->getName());
	if (m_viewMode == List) {
		p.setPen(getTextColor());
 
		std::pair<TFilePath, int> g = StudioPalette::instance()->getSourceStyle(style);
		if (g.first != TFilePath() && g.second >= 0)
			name += "  " + toQString(g.first) + ":" + QString::number(g.second);
		if (style->getFlags() != 0)
			name += "(autopaint)";
 
		p.drawText(nameRect.adjusted(6, 4, -6, -4), name);
 
		QColor borderCol(getTextColor());
		borderCol.setAlphaF(0.3);
		p.setPen(borderCol);
	}
 
	if (m_viewMode == SmallChips && style->getFlags() != 0) {
		QRect rect(nameRect.left(), nameRect.top(), 9, 9);
		p.fillRect(rect, QBrush(Qt::white));
		p.drawRect(rect);
		p.drawText(rect, Qt::AlignCenter, "a");
	}
	if (m_viewMode == SmallChipsWithName && name != "" && name != "color") {
		QRect rect = nameRect;
		QPen oldPen = p.pen();
		TPixel32 color = style->getMainColor();
		int v = (int)(0.299 * color.r + 0.587 * color.g + 0.114 * color.b);
		p.setPen(v > 127 ? Qt::black : Qt::white);
		int textWidth = QFontMetrics(p.font()).width(name);
		if (textWidth < rect.width() - 2)
			p.drawText(rect, Qt::AlignCenter, name);
		else
			p.drawText(rect.adjusted(2, 0, 0, 0), Qt::AlignLeft | Qt::AlignVCenter, name);
		p.setPen(oldPen);
	}
 
	if (m_viewMode == LargeChips) {
		QString index = QString::number(styleIndex);
		QFont font = p.font();
		int fontSize = font.pointSize();
		if (fontSize == -1)
			fontSize = font.pixelSize();
		int lenght = index.length() * fontSize;
		int w = (lenght > 11) ? (lenght) : 11;
		int h = 11;
		int x0 = nameRect.right() - w + 1;
		int y0 = nameRect.top() - h - 1;
		p.drawText(nameRect.adjusted(6, 1, -6, -1), name);
		QRect indexRect(x0, y0, w, h);
		p.fillRect(indexRect, QBrush(Qt::white));
		p.drawRect(indexRect);
		p.drawText(indexRect, Qt::AlignCenter, index);
 
		QFont f = p.font();
		f.setFamily("Calibri");
		p.setFont(f);
		if (style->getFlags() != 0) {
			QRect rect(nameRect.left(), y0, w, h);
			p.fillRect(rect, QBrush(Qt::white));
			p.drawRect(rect);
			p.drawText(rect.adjusted(0, +1, 0, +1), Qt::AlignCenter, "A");
		}
		TTextureStyle *ts = dynamic_cast<TTextureStyle *>(style);
		if (ts) {
			QRect rect(nameRect.left() + ((style->getFlags() != 0) ? w : 0), y0, w, h);
			p.fillRect(rect, QBrush(Qt::white));
			p.drawRect(rect);
			p.drawText(rect.adjusted(0, +1, 0, +1), Qt::AlignCenter, ts->isPattern() ? "P" : "T");
		}
	}
 
	p.drawRect(nameRect);
}
 
//-----------------------------------------------------------------------------
/*! Draw the toggle to know if \b style is linked to a studio palette.
*/
void PageViewer::drawToggleLink(QPainter &p, QRect &chipRect, TColorStyle *style)
{
	wstring globalName = style->getGlobalName();
	if (globalName != L"" &&
		(globalName[0] == L'-' || globalName[0] == L'+')) {
		TPixel32 c = style->getMainColor();
		int x = chipRect.topRight().x() - 6;
		int y = chipRect.topRight().y();
		QRect rect(x, y, 7, 7);
 
		p.fillRect(rect, QBrush(Qt::white));
		p.setPen(Qt::black);
		p.drawRect(rect);
 
		if (globalName[0] == L'+') {
			QPointF a(x + 2, y + 2);
			QPointF b(x + 2, y + 5);
			QPointF c(x + 5, y + 2);
			QPointF d(x + 5, y + 5);
			p.drawLine(a, b);
			p.drawLine(a, c);
			p.drawLine(a, d);
		}
	}
}
 
//-----------------------------------------------------------------------------
/*! Pain current page styles using current view mode.
*/
void PageViewer::paintEvent(QPaintEvent *e)
{
	QPainter p(this);
	if (m_chipPerRow == 0) {
		p.drawText(QPoint(5, 25), tr("- No Styles -"));
		return;
	}
 
	// currentStyle e palette
	TPalette *palette = (m_page) ? m_page->getPalette() : 0;
	if (!palette)
		return;
 
	// [i0,i1] = range celle visibili
	QRect visibleRect = e->rect();
	int i0 = posToIndex(visibleRect.topLeft());
	if (i0 < 0)
		i0 = 0;
	int i1 = posToIndex(visibleRect.bottomRight());
	if (i1 >= getChipCount())
		i1 = getChipCount() - 1;
 
	if (m_viewMode == List) {
		// disegno le celle
		int i;
		int currentStyleIndexInPage = -1;
		for (i = i0; i <= i1; i++) {
			TColorStyle *style = m_page->getStyle(i);
			int styleIndex = m_page->getStyleId(i);
			if (getCurrentStyleIndex() == styleIndex)
				currentStyleIndexInPage = i;
 
			QRect chipRect = getColorChipRect(i);
			drawColorChip(p, chipRect, style);
 
			// name, index and shortcut
			QRect nameRect = getColorNameRect(i);
			drawColorName(p, nameRect, style, styleIndex);
 
			// selezione
			if (m_styleSelection->isSelected(m_page->getIndex(), i)) {
				p.setPen(Qt::white);
				QRect itemRect = getItemRect(i);
				p.drawRect(itemRect);
				p.drawRect(chipRect.adjusted(1, 1, -1, -1));
			}
			// stile corrente
			if (i == currentStyleIndexInPage && 0 <= i && i < getChipCount()) {
				QRect rect = getItemRect(i);
 
				p.setPen(QColor(180, 210, 255));
				p.drawRect(rect.adjusted(1, 1, -1, -1));
 
				p.setPen(Qt::white);
				p.drawRect(rect.adjusted(2, 2, -2, -2));
				p.setPen(Qt::black);
				p.drawRect(rect.adjusted(3, 3, -3, -3));
 
				if (!m_styleSelection->isSelected(m_page->getIndex(), i)) {
					p.setPen(QColor(225, 225, 225));
					p.drawRect(rect.adjusted(1, 1, -1, -1));
				}
			}
 
			// toggle link
			drawToggleLink(p, chipRect, m_page->getStyle(i));
		}
	} else {
		int currentStyleIndex = getCurrentStyleIndex();
		int i;
		for (i = i0; i <= i1; i++) {
			TColorStyle *style = m_page->getStyle(i);
			int styleIndex = m_page->getStyleId(i);
 
			//draw white frame if the style is selected or current
			if (m_styleSelection->isSelected(m_page->getIndex(), i) || currentStyleIndex == styleIndex) {
				QRect itemRect = getItemRect(i).adjusted(-1, -2, 1, 2);
				p.setPen(Qt::NoPen);
				p.setBrush(Qt::white);
				p.drawRoundRect(itemRect, 7, 25);
			}
			//paint style
			QRect chipRect = getItemRect(i).adjusted(4, 4, -5, -5);
 
			QColor styleColor((int)style->getMainColor().r,
							  (int)style->getMainColor().g,
							  (int)style->getMainColor().b);
			// draw with MainColor for TSolidColorStyle(3), TColorCleanupStyle(2001) and TBlackCleanupStyle(2002)
			if (style->getTagId() == 3 || style->getTagId() == 2001 || style->getTagId() == 2002) {
				//iwsw commented out temporaly
				//if (Preferences::instance()->isDoColorCorrectionByUsing3DLutEnabled())
				//	Ghibli3DLutConverter::instance()->convert(styleColor);
 
				p.fillRect(chipRect, QBrush(styleColor));
 
				// if the style is not 100% opac, draw the bottom part of the chip with the pixmap with alpha
				if ((int)style->getMainColor().m != (int)style->getMainColor().maxChannelValue) {
					QRect bottomRect = chipRect;
					if (m_viewMode == LargeChips) {
						bottomRect.adjust(0, bottomRect.height() - 12, 0, 0);
					} else
						bottomRect.adjust(0, bottomRect.height() - 6, 0, 0);
 
					TRaster32P icon = style->getIcon(qsize2Dimension(bottomRect.size()));
					p.drawPixmap(bottomRect.left(), bottomRect.top(), rasterToQPixmap(icon));
				}
				//Use white line for dark color. Use black line for light color.
				int val = (int)style->getMainColor().r * 30 +
						  (int)style->getMainColor().g * 59 +
						  (int)style->getMainColor().b * 11;
				if (val < 12800)
					p.setPen(Qt::white);
				else
					p.setPen(Qt::black);
 
			} else {
				TRaster32P icon = style->getIcon(qsize2Dimension(chipRect.size()));
				p.drawPixmap(chipRect.left(), chipRect.top(), rasterToQPixmap(icon));
 
				if (m_viewMode == LargeChips) {
					p.setPen(Qt::NoPen);
					p.setBrush(QColor(0, 0, 0, 140));
					QRect zabutonRect = chipRect.adjusted(0, 12, 0, -12);
					p.drawRect(zabutonRect);
				}
				p.setPen(Qt::white);
			}
			p.setBrush(Qt::NoBrush);
 
			//diagonal line indicates that the style color is changed after linked from studio palette
			if (style->getIsEditedFlag()) {
				//draw diagonal line
				p.drawLine(chipRect.topRight(), chipRect.bottomLeft());
 
				//keep center blank for style name
				if (m_viewMode != SmallChips) {
					QRect colorNameRect = chipRect;
					if (m_viewMode == MediumChips)
						colorNameRect.adjust(2, 9, -2, -8);
					else //LargeChip
						colorNameRect.adjust(2, 16, -2, -13);
 
					p.fillRect(colorNameRect, QBrush(styleColor));
				}
			}
 
			//draw style name
			QFont preFont = p.font();
			QFont tmpFont = p.font();
 
			if (m_viewMode != SmallChips) {
 
				if (m_viewMode == MediumChips) {
					tmpFont.setPixelSize(EnvSoftwareCurrentFontSize_StyleName);
					p.setFont(tmpFont);
				} else if (m_viewMode == LargeChips) {
					tmpFont.setPixelSize(EnvSoftwareCurrentFontSize_StyleName + 2);
					p.setFont(tmpFont);
				}
 
				wstring name = style->getName();
				wstring origName = style->getOriginalName();
 
				//display the name (style name and original name) according to the name display mode
				if (m_nameDisplayMode == Style)
					p.drawText(chipRect, Qt::AlignCenter, QString::fromStdWString(name));
				else if (m_nameDisplayMode == Original) {
					if (origName != L"") {
						tmpFont.setItalic(true);
						p.setFont(tmpFont);
						p.drawText(chipRect, Qt::AlignCenter, QString::fromStdWString(origName));
					} else // if there is no original name, then display the style name in brackets
						p.drawText(chipRect, Qt::AlignCenter, QString::fromStdWString(L"( " + name + L" )"));
				} else if (m_nameDisplayMode == StyleAndOriginal) {
					p.drawText(chipRect, Qt::AlignCenter, QString::fromStdWString(name));
 
					//display original name only whne LargeChip view
					if (m_viewMode == LargeChips && origName != L"") {
						tmpFont.setItalic(true);
						tmpFont.setPixelSize(tmpFont.pixelSize() - 3);
						p.setFont(tmpFont);
						p.drawText(chipRect.adjusted(4, 4, -4, -4), Qt::AlignLeft | Qt::AlignTop, QString::fromStdWString(origName));
					}
				}
			}
 
			// draw the frame border if the style is selected or current
			if (m_styleSelection->isSelected(m_page->getIndex(), i) || currentStyleIndex == styleIndex) {
				p.setBrush(Qt::NoBrush);
				p.drawRect(chipRect.adjusted(3, 3, -3, -3));
			}
 
			// draw border
			p.setPen(Qt::black);
			p.setBrush(Qt::NoBrush);
			p.drawRect(chipRect);
 
			// draw style index
			tmpFont.setPointSize(9);
			tmpFont.setItalic(false);
			p.setFont(tmpFont);
			int indexWidth = fontMetrics().width(QString().setNum(styleIndex)) + 4;
			QRect indexRect(chipRect.bottomRight() + QPoint(-indexWidth, -14), chipRect.bottomRight());
			p.setPen(Qt::black);
			p.setBrush(Qt::white);
			p.drawRect(indexRect);
			p.drawText(indexRect, Qt::AlignCenter, QString().setNum(styleIndex));
			// revert font set
			p.setFont(preFont);
			// revert brush
			p.setBrush(Qt::NoBrush);
 
			//draw link indicator
			drawToggleLink(p, chipRect, style);
		}
	}
 
	// indicatore di drop
	if (m_dropPositionIndex >= 0) {
		QRect itemRect = getItemRect(m_dropPositionIndex);
		QRect rect;
		if (m_viewMode == List)
			rect = QRect(itemRect.left(), itemRect.top() - 1, itemRect.width(), 2);
		else
			rect = QRect(itemRect.left() - 1, itemRect.top(), 2, itemRect.height());
		p.setPen(Qt::black);
		p.drawRect(rect);
		p.setPen(Qt::white);
		p.drawRect(rect.adjusted(-1, -1, 1, 1));
	}
}
 
//-----------------------------------------------------------------------------
/*! Recall computeSize().
*/
void PageViewer::resizeEvent(QResizeEvent *)
{
	computeSize();
}
 
//-----------------------------------------------------------------------------
/*! If current page is empty return; otherwise select or unselect chip in regard
		to event position.
		*/
void PageViewer::mousePressEvent(QMouseEvent *event)
{
	if (!m_page)
		return;
	TPalette *palette = m_page->getPalette();
	QPoint pos = event->pos();
	int indexInPage = posToIndex(pos);
	m_startDrag = false;
	if (!m_page)
		return;
	int pageIndex = m_page->getIndex();
 
	// disable style selection in the cleanup palette in order to avoid editing the styles by mistake.
	if (m_viewType == CLEANUP_PALETTE) {
		if (0 <= indexInPage && indexInPage < getChipCount()) {
			//Right-click is available
			if (event->button() == Qt::RightButton) {
				m_styleSelection->makeCurrent();
				m_styleSelection->selectNone();
				m_styleSelection->select(pageIndex);
				m_styleSelection->select(pageIndex, indexInPage, true);
			}
			//Changing the current style is still available
			setCurrentStyleIndex(m_page->getStyleId(indexInPage));
		}
		update();
		return;
	}
 
	if (event->button() == Qt::RightButton) {
		m_styleSelection->makeCurrent();
		//if you are clicking on the color chip
		if (0 <= indexInPage && indexInPage < getChipCount()) {
			//Se pageIndex non e' selezionato lo seleziono
			if (!m_styleSelection->isSelected(pageIndex, indexInPage)) {
				m_styleSelection->select(pageIndex);
				m_styleSelection->select(pageIndex, indexInPage, true);
			}
			//Cambio l'indice corrente
			setCurrentStyleIndex(m_page->getStyleId(indexInPage));
		} else {
			m_styleSelection->selectNone();
			m_styleSelection->select(pageIndex);
		}
		update();
		//update locks when the styleSelection becomes current
		updateCommandLocks();
		return;
	}
	m_dragStartPosition = pos;
	if (indexInPage < 0 || indexInPage >= getChipCount()) {
		// l'utente ha fatto click fuori dai color chip. vuole deselezionare tutto
		// (lasciando la selezione attiva, per un eventuale paste)
		m_styleSelection->select(pageIndex);
		m_styleSelection->makeCurrent();
 
		update();
		//update locks when the styleSelection becomes current
		updateCommandLocks();
		return;
	} else {
		//O si sta selezonando un nuovo item O si vuole iniziare un drag
		if (m_styleSelection->isSelected(pageIndex, indexInPage) &&
			event->modifiers() == Qt::ControlModifier &&
			!m_page->getPalette()->isLocked())
			m_startDrag = true;
		else
			select(indexInPage, event);
	}
}
 
//-----------------------------------------------------------------------------
/*! If left botton is pressed start drag.
*/
void PageViewer::mouseMoveEvent(QMouseEvent *event)
{
	if (!m_page)
		return;
	if (m_viewType == CLEANUP_PALETTE)
		return;
 
	// continuo solo se e' un drag (bottone sinistro premuto)
	if (!(event->buttons() & Qt::LeftButton))
		return;
 
	if (m_page->getPalette()->isLocked())
		return;
 
	// Se spingo ctrl mentre mi sto muovendo con almeno un item selezionato abilito la possibilita' di fare drag.
	if (!m_startDrag &&
		event->modifiers() == Qt::ControlModifier &&
		!m_styleSelection->isEmpty() &&
		(event->pos() - m_dragStartPosition).manhattanLength() > 12)
		m_startDrag = true;
	// faccio partire il drag&drop solo se mi sono mosso di una certa quantita'
	if ((event->pos() - m_dragStartPosition).manhattanLength() > 20 && m_startDrag) {
		assert(m_styleSelection && !m_styleSelection->isEmpty());
		startDragDrop();
	}
}
 
//-----------------------------------------------------------------------------
 
void PageViewer::mouseReleaseEvent(QMouseEvent *event)
{
	if (!m_page)
		return;
	TPalette *palette = m_page->getPalette();
	QPoint pos = event->pos();
	int indexInPage = posToIndex(pos);
	if (m_startDrag && m_dropPositionIndex == -1 && event->modifiers() == Qt::ControlModifier)
		select(indexInPage, event);
	m_startDrag = false;
}
 
//-----------------------------------------------------------------------------
/*! If double click position is not in a chip rect return; otherwise if is in
		name rect open a text field, if is in color rect open a style editor.
		*/
void PageViewer::mouseDoubleClickEvent(QMouseEvent *e)
{
	int index = posToIndex(e->pos());
	if (index < 0 || index >= getChipCount())
		return;
	TColorStyle *style = m_page->getStyle(index);
	if (!style)
		return;
 
	if (m_page->getPalette()->isLocked())
		return;
 
	if (m_viewMode != SmallChips) {
		QRect nameRect = getColorNameRect(index);
		if (nameRect.contains(e->pos())) {
			wstring styleName = style->getName();
			LineEdit *fld = m_renameTextField;
			fld->setText(QString::fromStdWString(styleName));
			fld->setGeometry(nameRect);
			fld->show();
			fld->selectAll();
			fld->setFocus(Qt::OtherFocusReason);
			fld->setAlignment(Qt::AlignCenter);
			return;
		}
	}
 
	m_styleNameEditor->show();
	m_styleNameEditor->raise();
	m_styleNameEditor->activateWindow();
}
 
//-----------------------------------------------------------------------------
void PageViewer::createMenuAction(QMenu &menu, const char *id, QString name, const char *slot)
{
	bool ret = true;
	QAction *act = menu.addAction(name);
	string slotName(slot);
	slotName = string("1") + slotName;
	ret = connect(act, SIGNAL(triggered()), slotName.c_str());
	assert(ret);
}
 
//-----------------------------------------------------------------------------
 
void PageViewer::addNewColor()
{
	PaletteCmd::createStyle(getPaletteHandle(), getPage());
	computeSize();
	update();
}
 
//-----------------------------------------------------------------------------
 
void PageViewer::addNewPage()
{
	PaletteCmd::addPage(getPaletteHandle());
	update();
}
 
//-----------------------------------------------------------------------------
 
/*! Create and open the Right-click menu in page.
*/
void PageViewer::contextMenuEvent(QContextMenuEvent *event)
{
	QMenu menu(this);
 
	CommandManager *cmd = CommandManager::instance();
 
	menu.addAction(cmd->getAction(MI_Copy));
	QAction *pasteValueAct = cmd->getAction(MI_PasteValues);
	menu.addAction(pasteValueAct);
	QAction *pasteColorsAct = cmd->getAction(MI_PasteColors);
	menu.addAction(pasteColorsAct);
	QAction *pasteNamesAct = cmd->getAction(MI_PasteNames);
	menu.addAction(pasteNamesAct);
	QAction *pasteAct = cmd->getAction(MI_Paste);
	menu.addAction(pasteAct);
	QAction *cutAct = cmd->getAction(MI_Cut);
	menu.addAction(cutAct);
 
	menu.addSeparator();
	//iwasawa lockの時は無効化するため
	QAction *clearAct = cmd->getAction(MI_Clear);
	menu.addAction(clearAct);
 
	menu.addSeparator();
	QAction *openPltGizmoAct = cmd->getAction("MI_OpenPltGizmo");
	menu.addAction(openPltGizmoAct);
	QAction *openStyleControlAct = cmd->getAction("MI_OpenStyleControl");
	menu.addAction(openStyleControlAct);
 
	//Verifica se lo stile e' link.
	//Abilita e disabilita le voci di menu' in base a dove si e' cliccato.
	int index = posToIndex(event->pos());
	int indexPage = m_page ? m_page->getIndex() : -1;
 
	bool isLocked = m_page ? m_page->getPalette()->isLocked() : false;
 
	//remove links from studio palette
	if (m_viewType == LEVEL_PALETTE && m_styleSelection && !m_styleSelection->isEmpty() && !isLocked) {
		menu.addSeparator();
		QAction *removeLinkAct = menu.addAction(tr("Remove Links"));
		connect(removeLinkAct, SIGNAL(triggered()), this, SLOT(removeLink()));
	}
 
	if (((indexPage == 0 && index > 0) || (indexPage > 0 && index >= 0)) && index < getChipCount() && !isLocked) {
		//iwsw commented out temporarly
		/*
		wstring globalName = m_page->getStyle(index)->getGlobalName();
		if (m_viewType != STUDIO_PALETTE &&
			globalName != L"" &&
			(globalName[0] == L'-' || globalName[0] == L'+'))
		{
			createMenuAction(menu, "MI_ToggleLinkToStudioPalette", tr("Toggle Link to Studio Palette"), "toggleLink()");
			createMenuAction(menu, "MI_RemoveReferenceToStudioPalette", tr("Remove Reference to Studio Palette"), "eraseToggleLink()");
		}
		*/
		if (pasteValueAct)
			pasteValueAct->setEnabled(true);
		if (pasteColorsAct)
			pasteColorsAct->setEnabled(true);
 
		pasteNamesAct->setEnabled(true);
		pasteAct->setEnabled(true);
		cutAct->setEnabled(true);
		clearAct->setEnabled(true);
	} else {
		if (pasteValueAct)
			pasteValueAct->setEnabled(false);
		if (pasteColorsAct)
			pasteColorsAct->setEnabled(false);
 
		pasteNamesAct->setEnabled(false);
		pasteAct->setEnabled(!isLocked);
		cutAct->setEnabled(false);
		clearAct->setEnabled(false);
	}
 
	// get color from the original studio palette
	if (m_viewType == LEVEL_PALETTE && m_styleSelection && !m_styleSelection->isEmpty() && !isLocked) {
		menu.addSeparator();
		QAction *getBackOriginalAct = cmd->getAction("MI_GetColorFromStudioPalette");
		menu.addAction(getBackOriginalAct);
	}
 
	//iwsw commented out temporarly
	/*
	if (m_viewType != STUDIO_PALETTE)
	{
		menu.addSeparator();
		menu.addAction(cmd->getAction(MI_EraseUnusedStyles));
	}
	*/
	QAction *newStyle = menu.addAction(tr("New Style"));
	connect(newStyle, SIGNAL(triggered()), SLOT(addNewColor()));
	QAction *newPage = menu.addAction(tr("New Page"));
	connect(newPage, SIGNAL(triggered()), SLOT(addNewPage()));
	menu.exec(event->globalPos());
}
 
//-----------------------------------------------------------------------------
/*! Accept drag enter event if evant data ha format \b TStyleSelection::getMimeType().
*/
void PageViewer::dragEnterEvent(QDragEnterEvent *event)
{
	if (!m_page)
		return;
	const PaletteData *paletteData = dynamic_cast<const PaletteData *>(event->mimeData());
	if (paletteData && paletteData->hasStyleIndeces()) {
		if ((m_viewType == CLEANUP_PALETTE && !paletteData->getPalette()->isCleanupPalette()) ||
			(m_viewType == LEVEL_PALETTE && paletteData->getPalette()->isCleanupPalette())) {
			event->ignore();
			return;
		}
		int index = posToIndex(event->pos());
		// non si puo' spostare qualcosa nelle prime due posizioni di pagina 0
		// (occupate da BG e FG)
		if (m_page->getIndex() == 0 && index < 2)
			index = 2;
		if (index < 0)
			index = 0;
		else if (index > m_page->getStyleCount())
			index = m_page->getStyleCount();
		m_dropPositionIndex = index;
		update();
		event->acceptProposedAction();
	}
}
 
//-----------------------------------------------------------------------------
/*! If current page exist and index in event position is different from dropped
		index set right drop position index and accept event.
		*/
void PageViewer::dragMoveEvent(QDragMoveEvent *event)
{
	if (!m_page)
		return;
	int index = posToIndex(event->pos());
	if (index != m_dropPositionIndex) {
		if ((m_page->getStyleId(0) == 0 || m_page->getStyleId(1) == 1) && index < 2)
			index = 2;
		if (index < 0)
			index = 0;
		else if (index > m_page->getStyleCount())
			index = m_page->getStyleCount();
		m_dropPositionIndex = index;
		update();
		event->acceptProposedAction();
	}
}
 
//-----------------------------------------------------------------------------
/*! If event data has correct format drop it in current drop position index.
*/
void PageViewer::dropEvent(QDropEvent *event)
{
	int dstIndexInPage = m_dropPositionIndex;
	m_dropPositionIndex = -1;
	update();
	if (!dynamic_cast<const PaletteData *>(event->mimeData()))
		return;
	drop(dstIndexInPage, event->mimeData());
	event->acceptProposedAction();
}
 
//-----------------------------------------------------------------------------
/*! Set to -1 drag position index and update view.
*/
void PageViewer::dragLeaveEvent(QDragLeaveEvent *event)
{
	m_dropPositionIndex = -1;
	update();
}
 
//-----------------------------------------------------------------------------
/*! Start drag and drop; if current page exist set drag and drop event data.
*/
void PageViewer::startDragDrop()
{
	TRepetitionGuard guard;
	if (!guard.hasLock())
		return;
 
	assert(m_page);
	TPalette *palette = m_page->getPalette();
	if (!palette || !m_page || !m_styleSelection)
		return;
	int pageIndex = m_page->getIndex();
 
	if (!m_styleSelection->canHandleStyles())
		return;
 
	PaletteData *paletteData = new PaletteData();
	paletteData->setPaletteData(palette, pageIndex, m_styleSelection->getIndicesInPage());
	QDrag *drag = new QDrag(this);
	drag->setMimeData(paletteData);
	Qt::DropAction dropAction = drag->exec(Qt::MoveAction);
	if (m_dropPageCreated) {
		m_dropPageCreated = false;
		int pageIndex = palette->getPageCount() - 1;
		if (palette->getPage(pageIndex)->getStyleCount() == 0) {
			palette->erasePage(pageIndex);
			getPaletteHandle()->notifyPaletteChanged();
		} else
			palette->setDirtyFlag(true);
	}
}
 
//-----------------------------------------------------------------------------
 
void PageViewer::keyPressEvent(QKeyEvent *e)
{
	int key = e->key();
 
	if (key == Qt::Key_Up) { //Row = frame precedente a quello settato
		int frameIndex = m_frameHandle->getFrameIndex() - 1;
		if (frameIndex < 0)
			return;
		m_frameHandle->setFrameIndex(frameIndex);
	} else if (key == Qt::Key_Down) { //Row = frame successivo a quello settato
		int frameIndex = m_frameHandle->getFrameIndex() + 1;
		m_frameHandle->setFrameIndex(frameIndex);
	} else {
		CommandManager *cManager = CommandManager::instance();
 
		if (key == cManager->getKeyFromShortcut(cManager->getShortcutFromId(V_ZoomIn)))
			zoomInChip();
		else if (key == cManager->getKeyFromShortcut(cManager->getShortcutFromId(V_ZoomOut)))
			zoomOutChip();
		else
			e->ignore();
	}
}
 
//-----------------------------------------------------------------------------
 
void PageViewer::showEvent(QShowEvent *)
{
	TPaletteHandle *paletteHandle = getPaletteHandle();
	if (!paletteHandle)
		return;
	connect(paletteHandle, SIGNAL(colorStyleChanged()), SLOT(update()), Qt::UniqueConnection);
}
 
//-----------------------------------------------------------------------------
 
void PageViewer::hideEvent(QHideEvent *)
{
	TPaletteHandle *paletteHandle = getPaletteHandle();
	if (!paletteHandle)
		return;
	disconnect(paletteHandle, SIGNAL(colorStyleChanged()), this, SLOT(update()));
}
 
//-----------------------------------------------------------------------------
/*! Manage page tooltip.
*/
bool PageViewer::event(QEvent *e)
{
	if (m_page && e->type() == QEvent::ToolTip) {
		QHelpEvent *helpEvent = dynamic_cast<QHelpEvent *>(e);
		QString toolTip;
		QPoint pos = helpEvent->pos();
		int indexInPage = posToIndex(pos);
		if (0 <= indexInPage && indexInPage < m_page->getStyleCount()) {
			TColorStyle *style = m_page->getStyle(indexInPage);
			if (style) {
				int styleIndex = m_page->getStyleId(indexInPage);
				toolTip = "#" + QString::number(styleIndex) + " " + QString::fromStdWString(style->getName());
 
				int shortcutKey = m_page->getPalette()->getStyleShortcut(styleIndex);
				if (shortcutKey > 0)
					toolTip += QString::fromStdWString(wstring(L" (") + (wchar_t)shortcutKey + L")");
			}
		}
		if (toolTip != "")
			QToolTip::showText(helpEvent->globalPos(), toolTip);
		else
			QToolTip::hideText();
		e->accept();
	}
	return QFrame::event(e);
}
 
//-----------------------------------------------------------------------------
/*! Add chip identified by \b indexInPage to style selection if it was not
		selected; remove it from style selection otherwise. Manage CTRL SHIFT
		pressed case.
		*/
void PageViewer::select(int indexInPage, QMouseEvent *event)
{
	bool selected = false;
	assert(m_page);
	TPalette *palette = m_page->getPalette();
	int pageIndex = m_page->getIndex();
	bool on = true;
 
	bool wasSelected = m_styleSelection->isSelected(pageIndex, indexInPage);
	if (event->modifiers() == Qt::NoModifier)
		m_styleSelection->selectNone();
	else if (event->modifiers() == Qt::CTRL && wasSelected)
		on = false;
	else if (event->modifiers() == Qt::SHIFT && !m_styleSelection->isEmpty()) {
		// premuto shift. la selezione si estende fino ai piu' vicini colori selezionati (prima e dopo)
		// a e' b diventeranno gli estremi della selezione
		int a = -1, b = -1, i = 0;
		for (i = 0; i < m_page->getStyleCount(); i++)
			if (m_styleSelection->isSelected(pageIndex, i)) {
				if (i < indexInPage)
					a = i;
				else if (i > indexInPage) {
					b = i;
					break;
				}
			}
		if (a >= 0 && b >= 0) {
			assert(a < indexInPage && indexInPage < b);
			a++;
			b--;
		} else if (a >= 0) {
			assert(b < 0 && a < indexInPage);
			a++;
			b = indexInPage;
		} else if (b >= 0) {
			assert(a < 0 && indexInPage < b);
			b--;
			a = indexInPage;
		} else
			a = b = indexInPage;
		for (i = a; i <= b; i++) {
			m_styleSelection->select(pageIndex, i, true);
			selected = true;
		}
	}
 
	bool isStyleChanged = false;
	if (on)
		selected = true;
	int styleIndex = m_page->getStyleId(indexInPage);
	if (selected) {
		setCurrentStyleIndex(styleIndex);
 
		ChangeStyleCommand *changeStyleCommand = getChangeStyleCommand();
		if (changeStyleCommand)
			isStyleChanged = changeStyleCommand->onStyleChanged();
	}
	if (!isStyleChanged) {
		m_styleSelection->select(pageIndex, indexInPage, on);
		m_styleSelection->makeCurrent();
		updateCommandLocks();
	}
	update();
}
 
//-----------------------------------------------------------------------------
/*! Compute page size in regard to chip count.
*/
void PageViewer::computeSize()
{
	if (!m_page) {
		m_chipPerRow = 0;
		return;
	}
	int w = parentWidget()->width();
	int chipCount = getChipCount();
	QSize chipSize = getChipSize();
	m_chipPerRow = m_viewMode == List ? 1 : (w - 8) / chipSize.width();
	if (m_chipPerRow == 0)
		m_chipPerRow = 1;
	int rowCount = (chipCount + m_chipPerRow - 1) / m_chipPerRow;
	setMinimumSize(w, rowCount * chipSize.height() + 10);
}
 
//-----------------------------------------------------------------------------
/*! If palette, referred to current page, exist and is animated set it to
		current frame.
		*/
void PageViewer::onFrameChanged()
{
	TPalette *palette = (m_page) ? m_page->getPalette() : 0;
	if (palette && palette->isAnimated())
		update();
}
 
//-----------------------------------------------------------------------------
/*! Rename current style and update its view in current page.
*/
//recall from m_renameTextField
void PageViewer::onStyleRenamed()
{
	m_renameTextField->hide();
	wstring newName = m_renameTextField->text().toStdWString();
	assert(getPaletteHandle());
	PaletteCmd::renamePaletteStyle(getPaletteHandle(), newName);
}
 
//-----------------------------------------------------------------------------
/*! Recall \b TStyleSelection::toggleLink() to current page style selection.
*/
void PageViewer::toggleLink()
{
	if (!m_page || !m_styleSelection || m_styleSelection->isEmpty())
		return;
	m_styleSelection->toggleLink();
	update();
	emit changeWindowTitleSignal();
}
 
//-----------------------------------------------------------------------------
/*! Recall \b TStyleSelection::eraseToggleLink() to current page style selection.
*/
void PageViewer::eraseToggleLink()
{
	if (!m_page || !m_styleSelection || m_styleSelection->isEmpty())
		return;
	m_styleSelection->eraseToggleLink();
}
 
//=============================================================================
/*! \class PaletteViewerGUI::PaletteTabBar
		\brief The PaletteTabBar class provides a bar with tab to show and manage palette
		page.
 
		Inherits \b QTabBar.
		This object allows to move a tab with mouseMoveEvent, rename a tab in
		doubleClickevent and create a new tab in drag and drop.
		*/
/*!	\fn void PaletteTabBar::setPageViewer(PageViewer *pageViewer)
		Set current tab bar page to \b pageViewer.
 
		\fn void PaletteTabBar::tabTextChanged(int index)
		This signal is emitted when tab associated text change.
 
		\fn void PaletteTabBar::movePage(int srcIndex, int dstIndex)
		This signal is emitted to notify tab position change.
		*/
PaletteTabBar::PaletteTabBar(QWidget *parent, bool hasPageCommand)
	: QTabBar(parent), m_renameTextField(new LineEdit(this)), m_renameTabIndex(-1), m_pageViewer(0), m_hasPageCommand(hasPageCommand)
{
	setObjectName("PaletteTabBar");
	setDrawBase(false);
	m_renameTextField->hide();
	connect(m_renameTextField, SIGNAL(editingFinished()), this, SLOT(updateTabName()));
	if (m_hasPageCommand)
		setAcceptDrops(true);
}
 
//-----------------------------------------------------------------------------
/*! Hide rename text field and recall \b QTabBar::mousePressEvent().
*/
void PaletteTabBar::mousePressEvent(QMouseEvent *event)
{
	m_renameTextField->hide();
	QTabBar::mousePressEvent(event);
	m_pageViewer->getSelection()->select(currentIndex());
	m_pageViewer->getSelection()->makeCurrent();
}
 
//-----------------------------------------------------------------------------
/*! If left button is pressed and a tab is selected emit signal \b movePage.
		In any case recall \b QTabBar::mousePressEvent().
		*/
void PaletteTabBar::mouseMoveEvent(QMouseEvent *event)
{
	if (event->buttons() == Qt::LeftButton && event->modifiers() == Qt::ControlModifier && !m_pageViewer->getPage()->getPalette()->isLocked()) {
		int srcIndex = currentIndex();
		int dstIndex = tabAt(event->pos());
		if (dstIndex >= 0 && dstIndex < count() && dstIndex != srcIndex) {
			QRect rect = tabRect(srcIndex);
			int x = event->pos().x();
			if (x < rect.left() || x > rect.right()) {
				emit movePage(srcIndex, dstIndex);
			}
		}
	}
	QTabBar::mouseMoveEvent(event);
}
 
//-----------------------------------------------------------------------------
/*! Set a text field with focus in event position to edit tab name.
*/
void PaletteTabBar::mouseDoubleClickEvent(QMouseEvent *event)
{
	if (!m_hasPageCommand)
		return;
	if (m_pageViewer->getPage()->getPalette()->isLocked())
		return;
	int index = tabAt(event->pos());
	if (index < 0)
		return;
	m_renameTabIndex = index;
	LineEdit *fld = m_renameTextField;
	fld->setText(tabText(index));
	fld->setGeometry(tabRect(index));
	fld->setAlignment(Qt::AlignCenter);
	fld->show();
	fld->selectAll();
	fld->setFocus(Qt::OtherFocusReason);
}
 
//-----------------------------------------------------------------------------
/*! If event data is a paletteData accept drag event; otherwise return.
*/
void PaletteTabBar::dragEnterEvent(QDragEnterEvent *event)
{
	if (!m_hasPageCommand)
		return;
	const PaletteData *paletteData = dynamic_cast<const PaletteData *>(event->mimeData());
	if (!paletteData)
		return;
	if ((m_pageViewer->getViewType() == CLEANUP_PALETTE && !paletteData->getPalette()->isCleanupPalette()) ||
		(m_pageViewer->getViewType() == LEVEL_PALETTE && paletteData->getPalette()->isCleanupPalette())) {
		event->ignore();
		return;
	}
	event->acceptProposedAction();
}
 
//-----------------------------------------------------------------------------
/*! If tab in event position exist set it as current, otherwise create a new tab
		recalling PageViewer::createDropPage().
		*/
void PaletteTabBar::dragMoveEvent(QDragMoveEvent *event)
{
	if (!m_hasPageCommand)
		return;
	const PaletteData *paletteData = dynamic_cast<const PaletteData *>(event->mimeData());
	if (!paletteData)
		return;
	if (paletteData->getPalette() == m_pageViewer->getPage()->getPalette() && paletteData->hasOnlyPalette())
		return;
	int tabIndex = tabAt(event->pos());
	if (0 <= tabIndex && tabIndex < count())
		setCurrentIndex(tabIndex);
	else
		m_pageViewer->createDropPage();
	event->acceptProposedAction();
}
 
//-----------------------------------------------------------------------------
/*! Recall PageViewer::drop().
*/
void PaletteTabBar::dropEvent(QDropEvent *event)
{
	if (!m_hasPageCommand)
		return;
	if (!dynamic_cast<const PaletteData *>(event->mimeData()))
		return;
	m_pageViewer->drop(-1, event->mimeData());
	event->acceptProposedAction();
}
 
//-----------------------------------------------------------------------------
/*! If current rename tab index is a valid index, set tab text to rename text
		field text; hide the rename text field and emit tabTextChanged() signal.
		*/
void PaletteTabBar::updateTabName()
{
	int index = m_renameTabIndex;
	if (index < 0)
		return;
	m_renameTabIndex = -1;
	if (m_renameTextField->text() != "")
		setTabText(index, m_renameTextField->text());
	m_renameTextField->hide();
	emit tabTextChanged(index);
}
 
//=============================================================================
 
/*!
  \class  PaletteViewerGUI::PaletteIconWidget
 
  \brief  PaletteIconWidget class provides a widget to show a palette icon.
  */
 
#if QT_VERSION >= 0x050500
PaletteIconWidget::PaletteIconWidget(QWidget *parent, Qt::WindowFlags flags)
#else
PaletteIconWidget::PaletteIconWidget(QWidget *parent, Qt::WFlags flags)
#endif
	: QWidget(parent, flags), m_isOver(false)
{
	setFixedSize(30, 20);
	setToolTip(QObject::tr("Palette"));
}
 
//-----------------------------------------------------------------------------
 
PaletteIconWidget::~PaletteIconWidget()
{
}
 
//-----------------------------------------------------------------------------
 
void PaletteIconWidget::paintEvent(QPaintEvent *)
{
	QPainter p(this);
 
	if (m_isOver) {
		static QPixmap dragPaletteIconPixmapOver(":Resources/dragpalette_over.png");
		p.drawPixmap(5, 2, dragPaletteIconPixmapOver);
	} else {
		static QPixmap dragPaletteIconPixmap(":Resources/dragpalette.png");
		p.drawPixmap(5, 2, dragPaletteIconPixmap);
	}
}
 
//-----------------------------------------------------------------------------
 
void PaletteIconWidget::mousePressEvent(QMouseEvent *me)
{
	if (me->button() != Qt::LeftButton) {
		me->ignore();
		return;
	}
 
	m_mousePressPos = me->pos();
	m_dragged = false;
 
	me->accept();
}
 
//-----------------------------------------------------------------------------
 
void PaletteIconWidget::mouseMoveEvent(QMouseEvent *me)
{
	if ((me->pos() - m_mousePressPos).manhattanLength() > 20 &&
		!m_dragged) {
		m_dragged = true;
		emit startDrag();
	}
 
	me->accept();
}
 
//-----------------------------------------------------------------------------
 
void PaletteIconWidget::enterEvent(QEvent *event)
{
	m_isOver = true;
}
 
//-----------------------------------------------------------------------------
 
void PaletteIconWidget::leaveEvent(QEvent *event)
{
	m_isOver = false;
}
 
//-----------------------------------------------------------------------------
 
void PageViewer::zoomInChip()
{
	ViewMode currentView = getViewMode();
	if (currentView == List || currentView == LargeChips)
		return;
	else if (currentView == SmallChips)
		setViewMode(MediumChips);
	else if (currentView == MediumChips)
		setViewMode(LargeChips);
}
void PageViewer::zoomOutChip()
{
	ViewMode currentView = getViewMode();
	if (currentView == List || currentView == SmallChips)
		return;
	else if (currentView == LargeChips)
		setViewMode(MediumChips);
	else if (currentView == MediumChips)
		setViewMode(SmallChips);
}
 
//-----------------------------------------------------------------------------
 
void PageViewer::setNameDisplayMode(NameDisplayMode mode)
{
	if (m_nameDisplayMode == mode)
		return;
	m_nameDisplayMode = mode;
 
	update();
}
 
//-----------------------------------------------------------------------------
/*! lock the commands when the styleSelection set to current
*/
void PageViewer::updateCommandLocks()
{
	if (!m_page)
		return;
	//iwasawa
 
	bool isLocked = m_page->getPalette()->isLocked();
 
	CommandManager *cmd = CommandManager::instance();
 
	cmd->getAction("MI_Paste")->setEnabled(!isLocked);
	cmd->getAction("MI_PasteValues")->setEnabled(!isLocked);
	cmd->getAction("MI_PasteColors")->setEnabled(!isLocked);
	cmd->getAction("MI_Clear")->setEnabled(!isLocked);
	cmd->getAction("MI_BlendColors")->setEnabled(!isLocked);
	cmd->getAction("MI_PasteNames")->setEnabled(!isLocked);
	cmd->getAction("MI_GetColorFromStudioPalette")->setEnabled(!isLocked);
}
 
//-----------------------------------------------------------------------------
/*! remove link and revert to the normal style
*/
void PageViewer::removeLink()
{
	if (!m_page || !m_styleSelection || m_styleSelection->isEmpty())
		return;
 
	if (m_styleSelection->removeLink())
		emit changeWindowTitleSignal();
}