#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></qpainter>

#include <qmouseevent></qmouseevent>

#include <qkeyevent></qkeyevent>

#include <qmenubar></qmenubar>

#include <qtooltip></qtooltip>

#include <qdrag></qdrag>

#include <qaction></qaction>

#include <qshortcut></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);</const>

	if (!paletteData || !paletteData->hasStyleIndeces())

		return;

	TPalette *srcPalette = paletteData->getPalette();

	int srcPageIndex = paletteData->getPageIndex();

	std::set<int> srcIndicesInPage = paletteData->getIndicesInPage();</int>

	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>

		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;</tcolorstyle>

		std::set<int>::iterator it;</int>

		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);</tfilepath,>

		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);</ttexturestyle>

		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)

{

	std::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);

				}

				std::wstring name = style->getName();

				std::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)

{