#include "toonzqt/styleeditor.h"

// TnzQt includes

#include "toonzqt/gutil.h"

#include "toonzqt/filefield.h"

#include "historytypes.h"

#include "toonzqt/lutcalibrator.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

#include "toonz/mypaintbrushstyle.h"

#include "toonz/preferences.h"

// 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></qhboxlayout>

#include <qvboxlayout></qvboxlayout>

#include <qgridlayout></qgridlayout>

#include <qpainter></qpainter>

#include <qbuttongroup></qbuttongroup>

#include <qmouseevent></qmouseevent>

#include <qlabel></qlabel>

#include <qcheckbox></qcheckbox>

#include <qpushbutton></qpushbutton>

#include <qradiobutton></qradiobutton>

#include <qcombobox></qcombobox>

#include <qscrollarea></qscrollarea>

#include <qstackedwidget></qstackedwidget>

#include <qstyleoptionslider></qstyleoptionslider>

#include <qtooltip></qtooltip>

#include <qsplitter></qsplitter>

#include <qmenu></qmenu>

#include <qopenglframebufferobject></qopenglframebufferobject>

using namespace StyleEditorGUI;

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

//    UndoPaletteChange  definition

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

namespace {

class UndoPaletteChange final : 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 override {

    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 override {

    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 override {

    return sizeof(*this) + 2 * sizeof(TColorStyle *);

  }

  QString getHistoryString() override {

    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() override { 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] =

      std::max(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] =

      std::max(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;

  default:

    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;

  default:

    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=""></class>

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=""></class>

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)

    : GLWidgetForHighDpi(parent)

    , m_bgColor(128, 128, 128)  // defaul value in case this value does not set

                                // in the style sheet

{

  setObjectName("HexagonalColorWheel");

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

  setFocusPolicy(Qt::NoFocus);

  m_currentWheel = none;

  if (Preferences::instance()->isColorCalibrationEnabled())

    m_lutCalibrator = new LutCalibrator();

}

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

HexagonalColorWheel::~HexagonalColorWheel() {

  if (m_fbo) delete m_fbo;

}

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

void HexagonalColorWheel::initializeGL() {

  initializeOpenGLFunctions();

  // to be computed once through the software

  if (m_lutCalibrator && !m_lutCalibrator->isInitialized()) {

    m_lutCalibrator->initialize();

    connect(context(), SIGNAL(aboutToBeDestroyed()), this,

            SLOT(onContextAboutToBeDestroyed()));

  }

  QColor const color = getBGColor();

  glClearColor(color.redF(), color.greenF(), color.blueF(), color.alphaF());

  // Without the following lines, the wheel in a floating style editor

  // dissapears on switching the room due to context switching.

  if (m_firstInitialized)

    m_firstInitialized = false;

  else {

    resizeGL(width(), height());

    update();

  }

}

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

void HexagonalColorWheel::resizeGL(int w, int h) {

  w *= getDevPixRatio();

  h *= getDevPixRatio();

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

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

  if (isHorizontallyLong) {

    m_triEdgeLen = (float)h / 1.732f;

    m_triHeight  = (float)h / 2.0f;

    m_wheelPosition.setX(((float)w - (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)h - (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, w, h);

  glMatrixMode(GL_PROJECTION);

  glLoadIdentity();

  glOrtho(0.0, (GLdouble)w, (GLdouble)h, 0.0, 1.0, -1.0);

  // remake fbo with new size

  if (m_lutCalibrator && m_lutCalibrator->isValid()) {

    if (m_fbo) delete m_fbo;

    m_fbo = new QOpenGLFramebufferObject(w, h);

  }

}

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

void HexagonalColorWheel::paintGL() {

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

  // switched

  QColor const color = getBGColor();

  glClearColor(color.redF(), color.greenF(), color.blueF(), color.alphaF());

  glMatrixMode(GL_MODELVIEW);

  if (m_lutCalibrator && m_lutCalibrator->isValid()) m_fbo->bind();

  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();

  if (m_lutCalibrator && m_lutCalibrator->isValid())

    m_lutCalibrator->onEndDraw(m_fbo);

}

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

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).

  QPoint curPos = event->pos() * getDevPixRatio();

  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(curPos, Qt::OddEvenFill)) {

    m_currentWheel = leftWheel;

    clickLeftWheel(curPos);

    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(curPos, Qt::OddEvenFill)) {

    m_currentWheel = rightTriangle;

    clickRightTriangle(curPos);

    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() * getDevPixRatio());

    break;

  case rightTriangle:

    clickRightTriangle(event->pos() * getDevPixRatio());

    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;

  // d is a length from center to edge of the wheel when saturation = 100

  float d = m_triHeight / cosf(phi / 180.0f * 3.1415f);

  int h = (int)theta;

  if (h > 359) h = 359;

  // clamping

  int s = (int)(std::min(p.length() / d, 1.0) * 100.0f);

  m_color.setValues(eValue, h, s);

  emit colorChanged(m_color, true);

}

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

void HexagonalColorWheel::clickRightTriangle(const QPoint &pos) {

  int s, v;

  QPointF p = m_leftp[1] + m_wheelPosition - QPointF(pos);

  if (p.ry() <= 0.0f) {

    s = 0;

    v = 0;

  } else {

    float v_ratio = std::min((float)(p.ry() / (m_triHeight * 2.0f)), 1.0f);

    float s_f     = p.rx() / (m_triEdgeLen * v_ratio);

    v             = (int)(v_ratio * 100.0f);

    s             = (int)(std::min(std::max(s_f, 0.0f), 1.0f) * 100.0f);

  }

  m_color.setValues(eHue, s, v);

  emit colorChanged(m_color, true);

}

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

void HexagonalColorWheel::onContextAboutToBeDestroyed() {

  if (!m_lutCalibrator) return;

  makeCurrent();

  m_lutCalibrator->cleanup();

  doneCurrent();

}

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

//    SquaredColorWheel  implementation