#include "toonzqt/styleeditor.h"

// TnzQt includes

#include "toonzqt/gutil.h"

#include "toonzqt/filefield.h"

#include "historytypes.h"

// TnzLib includes

#include "toonz/txshlevel.h"

#include "toonz/stylemanager.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/toonzfolders.h"

#include "toonz/cleanupcolorstyles.h"

#include "toonz/palettecontroller.h"

#include "toonz/imagestyles.h"

#include "toonz/txshsimplelevel.h" //iwsw

#include "toonz/levelproperties.h" //iwsw

// TnzCore includes

#include "tconvert.h"

#include "tfiletype.h"

#include "tsystem.h"

#include "tundo.h"

#include "tcolorstyles.h"

#include "tpalette.h"

#include "tpixel.h"

#include "tvectorimage.h"

#include "trasterimage.h"

#include "tlevel_io.h"

#include "tofflinegl.h"

#include "tropcm.h"

#include "tvectorrenderdata.h"

#include "tsimplecolorstyles.h"

#include "tvectorbrushstyle.h"

// Qt includes

#include <QHBoxLayout>

#include <QVBoxLayout>

#include <QGridLayout>

#include <QPainter>

#include <QButtonGroup>

#include <QMouseEvent>

#include <QLabel>

#include <QCheckBox>

#include <QPushButton>

#include <QRadioButton>

#include <QComboBox>

#include <QScrollArea>

#include <QStackedWidget>

#include <QStyleOptionSlider>

#include <QToolTip>

#include <QSplitter>

using namespace StyleEditorGUI;

//*****************************************************************************

//    UndoPaletteChange  definition

//*****************************************************************************

namespace

{

class UndoPaletteChange : public TUndo

{

	TPaletteHandle *m_paletteHandle;

	TPaletteP m_palette;

	int m_styleId;

	const TColorStyleP m_oldColor, m_newColor;

	std::wstring m_oldName, m_newName;

	bool m_oldEditedFlag, m_newEditedFlag;

	int m_frame;

public:

	UndoPaletteChange(TPaletteHandle *paletteHandle, int styleId,

					  const TColorStyle &oldColor, const TColorStyle &newColor)

		: m_paletteHandle(paletteHandle), m_palette(paletteHandle->getPalette()), m_styleId(styleId), m_oldColor(oldColor.clone()), m_newColor(newColor.clone()), m_oldName(oldColor.getName()), m_newName(newColor.getName()), m_frame(m_palette->getFrame()), m_oldEditedFlag(oldColor.getIsEditedFlag()), m_newEditedFlag(newColor.getIsEditedFlag()) {}

	void undo() const

	{

		m_palette->setStyle(m_styleId, m_oldColor->clone());

		m_palette->getStyle(m_styleId)->setIsEditedFlag(m_oldEditedFlag);

		m_palette->getStyle(m_styleId)->setName(m_oldName);

		if (m_palette->isKeyframe(m_styleId, m_frame))

			m_palette->setKeyframe(m_styleId, m_frame);

		//don't change the dirty flag. because m_palette may not the current palette when undo executed

		m_paletteHandle->notifyColorStyleChanged(false, false);

	}

	void redo() const

	{

		m_palette->setStyle(m_styleId, m_newColor->clone());

		m_palette->getStyle(m_styleId)->setIsEditedFlag(m_newEditedFlag);

		m_palette->getStyle(m_styleId)->setName(m_newName);

		if (m_palette->isKeyframe(m_styleId, m_frame))

			m_palette->setKeyframe(m_styleId, m_frame);

		//don't change the dirty flag. because m_palette may not the current palette when undo executed

		m_paletteHandle->notifyColorStyleChanged(false, false);

	}

	// imprecise - depends on the style

	int getSize() const { return sizeof(*this) + 2 * sizeof(TColorStyle *); }

	QString getHistoryString()

	{

		return QObject::tr("Change Style   Palette : %1  Style#%2  [R%3 G%4 B%5] -> [R%6 G%7 B%8]")

			.arg(QString::fromStdWString(m_palette->getPaletteName()))

			.arg(QString::number(m_styleId))

			.arg(m_oldColor->getMainColor().r)

			.arg(m_oldColor->getMainColor().g)

			.arg(m_oldColor->getMainColor().b)

			.arg(m_newColor->getMainColor().r)

			.arg(m_newColor->getMainColor().g)

			.arg(m_newColor->getMainColor().b);

	}

	int getHistoryType()

	{

		return HistoryType::Palette;

	}

};

} // namespace

//*****************************************************************************

//    ColorModel  implementation

//*****************************************************************************

const int ChannelMaxValues[] = {255, 255, 255, 255, 359, 100, 100};

const int ChannelPairMaxValues[][2] =

	{{255, 255}, {255, 255}, {255, 255}, {255, 255}, {100, 100}, {359, 100}, {359, 100}};

ColorModel::ColorModel()

{

	memset(m_channels, 0, sizeof m_channels);

}

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

void ColorModel::rgb2hsv()

{

	QColor converter(m_channels[0], m_channels[1], m_channels[2]);

	m_channels[4] = tmax(converter.hue(), 0); // hue() ritorna -1 per colori acromatici

	m_channels[5] = converter.saturation() * 100 / 255;

	m_channels[6] = converter.value() * 100 / 255;

}

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

void ColorModel::hsv2rgb()

{

	QColor converter = QColor::fromHsv(

		m_channels[4],

		m_channels[5] * 255 / 100,

		m_channels[6] * 255 / 100);

	m_channels[0] = converter.red();

	m_channels[1] = converter.green();

	m_channels[2] = converter.blue();

}

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

void ColorModel::setTPixel(const TPixel32 &pix)

{

	QColor color(pix.r, pix.g, pix.b, pix.m);

	m_channels[0] = color.red();

	m_channels[1] = color.green();

	m_channels[2] = color.blue();

	m_channels[3] = color.alpha();

	m_channels[4] = tmax(color.hue(), 0); // hue() ritorna -1 per colori acromatici

	m_channels[5] = color.saturation() * 100 / 255;

	m_channels[6] = color.value() * 100 / 255;

}

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

TPixel32 ColorModel::getTPixel() const

{

	return TPixel32(m_channels[0], m_channels[1], m_channels[2], m_channels[3]);

}

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

void ColorModel::setValue(ColorChannel channel, int value)

{

	assert(0 <= (int)channel && (int)channel < 7);

	assert(0 <= value && value <= ChannelMaxValues[channel]);

	m_channels[(int)channel] = value;

	if (channel >= eHue)

		hsv2rgb();

	else if (channel <= eBlue)

		rgb2hsv();

}

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

void ColorModel::setValues(ColorChannel channel, int v, int u)

{

	assert(0 <= (int)channel && (int)channel < 7);

	switch (channel) {

	case eRed:

		setValue(eGreen, v);

		setValue(eBlue, u);

		break;

	case eGreen:

		setValue(eRed, v);

		setValue(eBlue, u);

		break;

	case eBlue:

		setValue(eRed, v);

		setValue(eGreen, u);

		break;

	case eHue:

		setValue(eSaturation, v);

		setValue(eValue, u);

		break;

	case eSaturation:

		setValue(eHue, v);

		setValue(eValue, u);

		break;

	case eValue:

		setValue(eHue, v);

		setValue(eSaturation, u);

		break;

	}

}

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

int ColorModel::getValue(ColorChannel channel) const

{

	assert(0 <= (int)channel && (int)channel < 7);

	return m_channels[(int)channel];

}

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

void ColorModel::getValues(ColorChannel channel, int &u, int &v)

{

	switch (channel) {

	case eRed:

		u = getValue(eGreen);

		v = getValue(eBlue);

		break;

	case eGreen:

		u = getValue(eRed);

		v = getValue(eBlue);

		break;

	case eBlue:

		u = getValue(eRed);

		v = getValue(eGreen);

		break;

	case eHue:

		u = getValue(eSaturation);

		v = getValue(eValue);

		break;

	case eSaturation:

		u = getValue(eHue);

		v = getValue(eValue);

		break;

	case eValue:

		u = getValue(eHue);

		v = getValue(eSaturation);

		break;

	}

}

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

namespace

{

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

class RedShadeMaker

{

	const ColorModel &m_color;

public:

	RedShadeMaker(const ColorModel &color) : m_color(color) {}

	inline QRgb shade(int value) const

	{

		return QColor(value, m_color.g(), m_color.b()).rgba();

	}

};

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

class GreenShadeMaker

{

	const ColorModel &m_color;

public:

	GreenShadeMaker(const ColorModel &color) : m_color(color) {}

	inline QRgb shade(int value) const

	{

		return QColor(m_color.r(), value, m_color.b()).rgba();

	}

};

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

class BlueShadeMaker

{

	const ColorModel &m_color;

public:

	BlueShadeMaker(const ColorModel &color) : m_color(color) {}

	inline QRgb shade(int value) const

	{

		return QColor(m_color.r(), m_color.g(), value).rgba();

	}

};

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

class AlphaShadeMaker

{

	const ColorModel &m_color;

public:

	AlphaShadeMaker(const ColorModel &color) : m_color(color) {}

	inline QRgb shade(int value) const

	{

		return QColor(m_color.r(), m_color.g(), m_color.b(), value).rgba();

	}

};

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

class HueShadeMaker

{

	const ColorModel &m_color;

public:

	HueShadeMaker(const ColorModel &color) : m_color(color) {}

	inline QRgb shade(int value) const

	{

		return QColor::fromHsv(359 * value / 255, m_color.s() * 255 / 100, m_color.v() * 255 / 100).rgba();

	}

};

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

class SaturationShadeMaker

{

	const ColorModel &m_color;

public:

	SaturationShadeMaker(const ColorModel &color) : m_color(color) {}

	inline QRgb shade(int value) const

	{

		return QColor::fromHsv(m_color.h(), value, m_color.v() * 255 / 100).rgba();

	}

};

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

class ValueShadeMaker

{

	const ColorModel &m_color;

public:

	ValueShadeMaker(const ColorModel &color) : m_color(color) {}

	inline QRgb shade(int value) const

	{

		return QColor::fromHsv(m_color.h(), m_color.s() * 255 / 100, value).rgba();

	}

};

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

class RedGreenShadeMaker

{

	const ColorModel &m_color;

public:

	RedGreenShadeMaker(const ColorModel &color) : m_color(color) {}

	inline QRgb shade(int u, int v) const

	{

		return QColor(u, v, m_color.b()).rgba();

	}

};

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

class RedBlueShadeMaker

{

	const ColorModel &m_color;

public:

	RedBlueShadeMaker(const ColorModel &color) : m_color(color) {}

	inline QRgb shade(int u, int v) const

	{

		return QColor(u, m_color.g(), v).rgba();

	}

};

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

class GreenBlueShadeMaker

{

	const ColorModel &m_color;

public:

	GreenBlueShadeMaker(const ColorModel &color) : m_color(color) {}

	inline QRgb shade(int u, int v) const

	{

		return QColor(m_color.r(), u, v).rgba();

	}

};

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

class SaturationValueShadeMaker

{

	const ColorModel &m_color;

public:

	SaturationValueShadeMaker(const ColorModel &color) : m_color(color) {}

	inline QRgb shade(int u, int v) const

	{

		return QColor::fromHsv(m_color.h(), u, v).rgba();

	}

};

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

class HueValueShadeMaker

{

	const ColorModel &m_color;

public:

	HueValueShadeMaker(const ColorModel &color) : m_color(color) {}

	inline QRgb shade(int u, int v) const

	{

		return QColor::fromHsv(359 * u / 255, m_color.s() * 255 / 100, v).rgba();

	}

};

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

class HueSaturationShadeMaker

{

	const ColorModel &m_color;

public:

	HueSaturationShadeMaker(const ColorModel &color) : m_color(color) {}

	inline QRgb shade(int u, int v) const

	{

		return QColor::fromHsv(359 * u / 255, v, m_color.v() * 255 / 100).rgba();

	}

};

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

template <class ShadeMaker>

QPixmap makeLinearShading(

	const ShadeMaker &shadeMaker,

	int size,

	bool isVertical)

{

	assert(size > 0);

	QPixmap bgPixmap;

	int i, dx, dy, w = 1, h = 1;

	int x = 0, y = 0;

	if (isVertical) {

		dx = 0;

		dy = -1;

		h = size;

		y = size - 1;

	} else {

		dx = 1;

		dy = 0;

		w = size;

	}

	QImage image(w, h, QImage::Format_ARGB32);

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

		int v = 255 * i / (size - 1);

		image.setPixel(x, y, shadeMaker.shade(v));

		x += dx;

		y += dy;

	}

	return QPixmap::fromImage(image);

}

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

QPixmap makeLinearShading(

	const ColorModel &color,

	ColorChannel channel,

	int size,

	bool isVertical)

{

	switch (channel) {

	case eRed:

		if (isVertical)

			return makeLinearShading(RedShadeMaker(color), size, isVertical);

		else

			return QPixmap(":Resources/grad_r.png").scaled(size, 1);

	case eGreen:

		if (isVertical)

			return makeLinearShading(GreenShadeMaker(color), size, isVertical);

		else

			return QPixmap(":Resources/grad_g.png").scaled(size, 1);

	case eBlue:

		if (isVertical)

			return makeLinearShading(BlueShadeMaker(color), size, isVertical);

		else

			return QPixmap(":Resources/grad_b.png").scaled(size, 1);

	case eAlpha:

		if (isVertical)

			return makeLinearShading(AlphaShadeMaker(color), size, isVertical);

		else

			return QPixmap(":Resources/grad_m.png").scaled(size, 1);

	case eHue:

		return makeLinearShading(HueShadeMaker(color), size, isVertical);

	case eSaturation:

		return makeLinearShading(SaturationShadeMaker(color), size, isVertical);

	case eValue:

		return makeLinearShading(ValueShadeMaker(color), size, isVertical);

	default:

		assert(0);

	}

	return QPixmap();

}

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

template <class ShadeMaker>

QPixmap makeSquareShading(const ShadeMaker &shadeMaker, int size)

{

	assert(size > 0);

	QPixmap bgPixmap;

	QImage image(size, size, QImage::Format_RGB32);

	int i, j;

	for (j = 0; j < size; j++) {

		int u = 255 - (255 * j / (size - 1));

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

			int v = 255 * i / (size - 1);

			image.setPixel(i, j, shadeMaker.shade(v, u));

		}

	}

	return QPixmap::fromImage(image);

}

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

QPixmap makeSquareShading(

	const ColorModel &color,

	ColorChannel channel,

	int size)

{

	switch (channel) {

	case eRed:

		return makeSquareShading(GreenBlueShadeMaker(color), size);

	case eGreen:

		return makeSquareShading(RedBlueShadeMaker(color), size);

	case eBlue:

		return makeSquareShading(RedGreenShadeMaker(color), size);

	case eHue:

		return makeSquareShading(SaturationValueShadeMaker(color), size);

	case eSaturation:

		return makeSquareShading(HueValueShadeMaker(color), size);

	case eValue:

		return makeSquareShading(HueSaturationShadeMaker(color), size);

	default:

		assert(0);

	}

	return QPixmap();

}

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

} // namespace

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

//*****************************************************************************

//    HexagonalColorWheel  implementation

//*****************************************************************************

HexagonalColorWheel::HexagonalColorWheel(QWidget *parent)

	: QGLWidget(parent), m_bgColor(128, 128, 128) //defaul value in case this value does not set in the style sheet

												  //, m_ghibli3DLutUtil(0)//iwsw commented out temporarily

{

	setObjectName("HexagonalColorWheel");

	setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

	setFocusPolicy(Qt::NoFocus);

	m_currentWheel = none;

	//iwsw commented out temporarily

	/*

	if(Preferences::instance()->isDoColorCorrectionByUsing3DLutEnabled() && Ghibli3DLutUtil::m_isValid)

	{

	m_ghibli3DLutUtil = new Ghibli3DLutUtil();

	m_ghibli3DLutUtil->setInvert();

	}

	*/

}

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

HexagonalColorWheel::~HexagonalColorWheel()

{

	//iwsw commented out temporarily

	/*

	if(m_ghibli3DLutUtil)

	{

	m_ghibli3DLutUtil->onEnd();

	delete m_ghibli3DLutUtil;

	}

	*/

}

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

void HexagonalColorWheel::initializeGL()

{

	qglClearColor(getBGColor());

	//iwsw commented out temporarily

	/*

	if(Preferences::instance()->isDoColorCorrectionByUsing3DLutEnabled() && m_ghibli3DLutUtil)

	m_ghibli3DLutUtil->onInit();

	*/

}

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

void HexagonalColorWheel::resizeGL(int width, int height)

{

	float d = (width - 5.0f) / 2.5f;

	bool isHorizontallyLong = ((d * 1.732f) < height) ? false : true;

	if (isHorizontallyLong) {

		m_triEdgeLen = (float)height / 1.732f;

		m_triHeight = (float)height / 2.0f;

		m_wheelPosition.setX(((float)width - (m_triEdgeLen * 2.5f + 5.0f)) / 2.0f);

		m_wheelPosition.setY(0.0f);

	} else {

		m_triEdgeLen = d;

		m_triHeight = m_triEdgeLen * 0.866f;

		m_wheelPosition.setX(0.0f);

		m_wheelPosition.setY(((float)height - (m_triHeight * 2.0f)) / 2.0f);

	}

	//set all vertices positions

	m_wp[0].setX(m_triEdgeLen);

	m_wp[0].setY(m_triHeight);

	m_wp[1].setX(m_triEdgeLen * 0.5f);

	m_wp[1].setY(0.0f);

	m_wp[2].setX(0.0f);

	m_wp[2].setY(m_triHeight);

	m_wp[3].setX(m_triEdgeLen * 0.5f);

	m_wp[3].setY(m_triHeight * 2.0f);

	m_wp[4].setX(m_triEdgeLen * 1.5f);

	m_wp[4].setY(m_triHeight * 2.0f);

	m_wp[5].setX(m_triEdgeLen * 2.0f);

	m_wp[5].setY(m_triHeight);

	m_wp[6].setX(m_triEdgeLen * 1.5f);

	m_wp[6].setY(0.0f);

	m_leftp[0].setX(m_wp[6].x() + 5.0f);

	m_leftp[0].setY(0.0f);

	m_leftp[1].setX(m_leftp[0].x() + m_triEdgeLen);

	m_leftp[1].setY(m_triHeight * 2.0f);

	m_leftp[2].setX(m_leftp[1].x());

	m_leftp[2].setY(0.0f);

	//GL settings

	glViewport(0, 0, width, height);

	glMatrixMode(GL_PROJECTION);

	glLoadIdentity();

	glOrtho(0.0, (GLdouble)width, (GLdouble)height, 0.0, 1.0, -1.0);

	//iwsw commented out temporarily

	/*

	if(Preferences::instance()->isDoColorCorrectionByUsing3DLutEnabled() && m_ghibli3DLutUtil)

	m_ghibli3DLutUtil->onResize(width,height);

	*/

}

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

void HexagonalColorWheel::paintGL()

{

	//call ClearColor() here in order to update bg color when the stylesheet is switched

	qglClearColor(getBGColor());

	glMatrixMode(GL_MODELVIEW);

	//iwsw commented out temporarily

	/*

	if(Preferences::instance()->isDoColorCorrectionByUsing3DLutEnabled() && m_ghibli3DLutUtil)

	m_ghibli3DLutUtil->startDraw();

	*/

	glClear(GL_COLOR_BUFFER_BIT);

	float v = (float)m_color.getValue(eValue) / 100.0f;

	glPushMatrix();

	//draw hexagonal color wheel

	glTranslatef(m_wheelPosition.rx(), m_wheelPosition.ry(), 0.0f);

	glBegin(GL_TRIANGLE_FAN);

	glColor3f(v, v, v);

	glVertex2f(m_wp[0].x(), m_wp[0].y());

	glColor3f(0.0f, v, 0.0f);

	glVertex2f(m_wp[1].x(), m_wp[1].y());

	glColor3f(0.0f, v, v);

	glVertex2f(m_wp[2].x(), m_wp[2].y());

	glColor3f(0.0f, 0.0f, v);

	glVertex2f(m_wp[3].x(), m_wp[3].y());

	glColor3f(v, 0.0f, v);

	glVertex2f(m_wp[4].x(), m_wp[4].y());

	glColor3f(v, 0.0f, 0.0f);

	glVertex2f(m_wp[5].x(), m_wp[5].y());

	glColor3f(v, v, 0.0f);

	glVertex2f(m_wp[6].x(), m_wp[6].y());

	glColor3f(0.0f, v, 0.0f);

	glVertex2f(m_wp[1].x(), m_wp[1].y());

	glEnd();

	QColor leftCol = QColor().fromHsv(m_color.getValue(eHue), 255, 255);

	//draw triangle color picker

	glBegin(GL_TRIANGLES);

	glColor3f(leftCol.redF(), leftCol.greenF(), leftCol.blueF());

	glVertex2f(m_leftp[0].x(), m_leftp[0].y());

	glColor3f(0.0f, 0.0f, 0.0f);

	glVertex2f(m_leftp[1].x(), m_leftp[1].y());

	glColor3f(1.0f, 1.0f, 1.0f);

	glVertex2f(m_leftp[2].x(), m_leftp[2].y());

	glEnd();

	//draw small quad at current color position

	drawCurrentColorMark();

	glPopMatrix();

	//iwsw commented out temporarily

	/*

	if(Preferences::instance()->isDoColorCorrectionByUsing3DLutEnabled() && m_ghibli3DLutUtil)

	m_ghibli3DLutUtil->endDraw();

	*/

}

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

void HexagonalColorWheel::drawCurrentColorMark()

{

	int h;

	float s, v;

	//show hue in a counterclockwise fashion

	h = 360 - m_color.getValue(eHue);

	s = (float)m_color.getValue(eSaturation) / 100.0f;

	v = (float)m_color.getValue(eValue) / 100.0f;

	// d is a distance from a center of the wheel

	float d, phi;

	phi = (float)(h % 60 - 30) / 180.0f * 3.1415f;

	d = s * m_triHeight / cosf(phi);

	//set marker color

	if (v > 0.4f)

		glColor3f(0.0f, 0.0f, 0.0f);

	else

		glColor3f(1.0f, 1.0f, 1.0f);

	//draw marker (in the wheel)

	glPushMatrix();

	glTranslatef(m_wp[0].x(), m_wp[0].y(), 0.1f);

	glRotatef(h, 0.0, 0.0, 1.0);

	glTranslatef(d, 0.0f, 0.0f);

	glRotatef(-h, 0.0, 0.0, 1.0);

	glBegin(GL_LINE_LOOP);

	glVertex2f(-3, -3);

	glVertex2f(3, -3);

	glVertex2f(3, 3);

	glVertex2f(-3, 3);

	glEnd();

	glPopMatrix();

	//draw marker (in the triangle)

	glPushMatrix();

	glTranslatef(m_leftp[1].x(), m_leftp[1].y(), 0.1f);

	glTranslatef(-m_triEdgeLen * v * s, -m_triHeight * v * 2.0f, 0.0f);

	glBegin(GL_LINE_LOOP);

	glVertex2f(-3, -3);

	glVertex2f(3, -3);

	glVertex2f(3, 3);

	glVertex2f(-3, 3);

	glEnd();

	glPopMatrix();

}

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

void HexagonalColorWheel::mousePressEvent(QMouseEvent *event)

{

	if (~event->buttons() & Qt::LeftButton)

		return;

	// check whether the mouse cursor is in the wheel or in the triangle (or nothing).

	QPolygonF wheelPolygon;

	// in the case of the wheel

	wheelPolygon << m_wp[1] << m_wp[2] << m_wp[3] << m_wp[4] << m_wp[5] << m_wp[6];

	wheelPolygon.translate(m_wheelPosition);

	if (wheelPolygon.toPolygon().containsPoint(event->pos(), Qt::OddEvenFill)) {

		m_currentWheel = leftWheel;

		clickLeftWheel(event->pos());

		return;

	}

	wheelPolygon.clear();

	// in the case of the triangle

	wheelPolygon << m_leftp[0] << m_leftp[1] << m_leftp[2];

	wheelPolygon.translate(m_wheelPosition);

	if (wheelPolygon.toPolygon().containsPoint(event->pos(), Qt::OddEvenFill)) {

		m_currentWheel = rightTriangle;

		clickRightTriangle(event->pos());

		return;

	}

	//... or, in the case of nothing

	m_currentWheel = none;

}

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

void HexagonalColorWheel::mouseMoveEvent(QMouseEvent *event)

{

	// change the behavior according to the current touching wheel

	switch (m_currentWheel) {

	case none:

		break;

	case leftWheel:

		clickLeftWheel(event->pos());

		break;

	case rightTriangle:

		clickRightTriangle(event->pos());

		break;

	}

}

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

void HexagonalColorWheel::mouseReleaseEvent(QMouseEvent *event)

{

	m_currentWheel = none;

	emit colorChanged(m_color, false);

}

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

/*! compute hue and saturation position. saturation value must be clamped

*/

void HexagonalColorWheel::clickLeftWheel(const QPoint &pos)

{

	QLineF p(m_wp[0] + m_wheelPosition, QPointF(pos));

	QLineF horizontal(0, 0, 1, 0);

	float theta = (p.dy() < 0) ? p.angle(horizontal) : 360 - p.angle(horizontal);

	float phi = theta;

	while (phi >= 60.0f)

		phi -= 60.0f;

	phi -= 30.0f;