#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"

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

extern TEnv::IntVar ShowNewStyleButton;

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

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

    , m_styleNameEditor(NULL) {

  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_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 = LargeChips;

    break;

  case CLEANUP_PALETTE:

    defaultChipSize = SmallChips;

    break;

  case STUDIO_PALETTE:

    defaultChipSize = MediumChips;

    break;

  default:

    defaultChipSize = LargeChips;

    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(bool)), this,

               SLOT(update()));

  m_styleSelection->setPaletteHandle(paletteHandle);

  connect(paletteHandle, SIGNAL(colorStyleChanged(bool)), SLOT(update()));

  if (m_styleNameEditor) 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) {

  // When clicking and switching between studio palette and level palette, the

  // signal broadcastColorStyleSwitched is not emitted if the clicked style is

  // previously selected one.

  // Therefore here I introduced the "forceEmit" flag here in order to emit the

  // signal whenever the style is clicked.

  getPaletteHandle()->setStyleIndex(index, true);

}

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

int PageViewer::getCurrentStyleIndex() const {

  return getPaletteHandle()->getStyleIndex();

}

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

/*! Set current page to \b page and update view.

 */

void PageViewer::setPage(TPalette::Page *page) {

  if (m_page == page) return;

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

}

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

/*! 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) {

  // draw with MainColor for TSolidColorStyle(3), TColorCleanupStyle(2001)

  // and TBlackCleanupStyle(2002)

  if (style->getTagId() == 3 || style->getTagId() == 2001 ||

      style->getTagId() == 2002) {

    QColor styleColor((int)style->getMainColor().r,

                      (int)style->getMainColor().g,

                      (int)style->getMainColor().b);

    if (LutManager::instance()->isValid())

      LutManager::instance()->convert(styleColor);

    p.fillRect(chipRect, QBrush(styleColor));

  } else {

    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 =</tfilepath,>

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

    TPoint pickedPos = style->getPickedPosition().pos;

    if (pickedPos != TPoint())

      name += QString(" (%1,%2)").arg(pickedPos.x).arg(pickedPos.y);

    p.drawText(nameRect.adjusted(10, 4, -6, -4), name);

    p.setPen(getSeparatorColor());

  }

  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()).horizontalAdvance(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 length = index.length() * fontSize;

    int w      = (length > 11) ? (length) : 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);

    }

  }

}

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

/*! Draw the chip name \b name inside rectangle \b chipRect using painter \b p.

 * If the name is too wide to fit on the chip, use left align - to show the

 * start of the name. Otherwise, use center align.

 */

static void drawChipName(QPainter &p, const QRect &chipRect,

                         const std::wstring &name) {

  const QString nameQString = QString::fromStdWString(name);

  QRect textRect = p.boundingRect(chipRect, Qt::AlignCenter, nameQString);

  if (chipRect.width() < textRect.width()) {

    // align left if the name is too wide to fit on the chip

    p.drawText(chipRect.adjusted(4, 0, -4, 0), Qt::AlignLeft | Qt::AlignVCenter,

               nameQString);

  } else {

    // otherwise align by center

    p.drawText(chipRect, Qt::AlignCenter, nameQString);

  }

}

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

/*! Paint current page styles using current view mode.

 */

void PageViewer::paintEvent(QPaintEvent *e) {

  QPainter p(this);

  QColor textColor = p.pen().color();

  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] = visible cell range

  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;

  QFont preFont = p.font();

  QFont tmpFont = p.font();

  if (m_viewMode == List) {

    // draw the cells

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

      p.setPen(Qt::black);

      drawColorChip(p, chipRect, style);

      // current style

      if (i == currentStyleIndexInPage && 0 <= i && i < getChipCount()) {

        QRect rect = getItemRect(i);

        if (!m_styleSelection->isSelected(m_page->getIndex(), i)) {

          p.fillRect(rect.adjusted(23, 0, 0, 0), getCurrentCellColor());

        }

      }

      // selected

      if (m_styleSelection->isSelected(m_page->getIndex(), i)) {

        QRect itemRect = getItemRect(i);

        p.fillRect(itemRect.adjusted(23, 0, 0, 0), getSelectedCellColor());

      }

      // name, index and shortcut

      QRect nameRect = getColorNameRect(i);

      drawColorName(p, nameRect, style, styleIndex);

      // if numpad shortcut is activated, draw shortcut scope

      if (Preferences::instance()->isUseNumpadForSwitchingStylesEnabled() &&

          m_viewType == LEVEL_PALETTE &&

          palette->getStyleShortcut(styleIndex) >= 0) {

        p.setPen(QPen(QColor(getListNumpadShortcutBorderColor()), 2));

        p.drawLine(nameRect.topLeft() + QPoint(4, 1),

                   nameRect.bottomLeft() + QPoint(4, 0));

        p.setPen(QPen(QColor(getListNumpadShortcutBorderColor()), 2));

        p.drawLine(nameRect.topLeft() + QPoint(2, 1),

                   nameRect.bottomLeft() + QPoint(2, 0));

        // draw a separator line between shortcut border and name

        p.setPen(QPen(QColor(getSeparatorColor())));

        p.drawLine(nameRect.topLeft() + QPoint(5, 1),

                   nameRect.bottomLeft() + QPoint(5, 0));

      }

      // toggle link

      drawToggleLink(p, chipRect, m_page->getStyle(i));

    }

    if (ShowNewStyleButton && !m_page->getPalette()->isLocked()) {

      int j      = getChipCount();

      QRect rect = getItemRect(j);

      p.setPen(

          QColor(textColor.red(), textColor.green(), textColor.blue(), 128));

      // p.fillRect(rect, QBrush(QColor(0, 0, 0, 64)));

      // p.drawRect(rect);

      tmpFont.setPointSize(16);

      tmpFont.setBold(true);

      p.setFont(tmpFont);

      QString newLabel = tr(" + ");

      p.drawText(rect.adjusted(0, -6, 0, 0), Qt::AlignCenter, newLabel);

      // revert font set

      p.setFont(preFont);

      p.setPen(Qt::black);

    }

  } else {

    int currentStyleIndex = getCurrentStyleIndex();

    int i;

    for (i = i0; i <= i1; i++) {

      TColorStyle *style = m_page->getStyle(i);

      int styleIndex     = m_page->getStyleId(i);

      // if numpad shortcut is activated, draw shortcut scope

      if (Preferences::instance()->isUseNumpadForSwitchingStylesEnabled() &&

          m_viewType == LEVEL_PALETTE &&

          palette->getStyleShortcut(styleIndex) >= 0) {

        QRect itemRect = getItemRect(i);

        // paint dark

        p.setPen(Qt::NoPen);

        p.setBrush(QColor(getNumpadShortcutBgColor()));

        p.drawRect(itemRect);

        // check the neighbours and draw light lines

        p.setPen(QPen(QColor(getNumpadShortcutBorderColor()), 2));

        // top

        if (!hasShortcut(i - m_chipPerRow))

          p.drawLine(itemRect.topLeft(), itemRect.topRight() - QPoint(1, 0));

        // left

        if (i % m_chipPerRow == 0 || !hasShortcut(i - 1))

          p.drawLine(itemRect.topLeft() + QPoint(0, 1), itemRect.bottomLeft());

        // bottom

        if (!hasShortcut(i + m_chipPerRow))

          p.drawLine(itemRect.bottomLeft() + QPoint(1, 0),

                     itemRect.bottomRight());

        // right

        if ((i + 1) % m_chipPerRow == 0 || !hasShortcut(i + 1))

          p.drawLine(itemRect.topRight(),

                     itemRect.bottomRight() - QPoint(0, 1));

      }

      // draw frame if the style is selected or current

      if (m_styleSelection->isSelected(m_page->getIndex(), i)) {

        QRect itemRect = getItemRect(i).adjusted(0, -1, 0, 1);

        p.setPen(Qt::NoPen);

        p.setBrush(getSelectedBorderColor());

        p.drawRoundedRect(itemRect, 7, 25, Qt::RelativeSize);

      } else if (currentStyleIndex == styleIndex) {

        QRect itemRect = getItemRect(i).adjusted(1, 0, -1, 0);

        p.setPen(Qt::NoPen);

        p.setBrush(getSelectedBorderColor());

        p.drawRoundedRect(itemRect, 7, 25, Qt::RelativeSize);

      }

      // 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) {

        if (LutManager::instance()->isValid())

          LutManager::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) {

          drawChipName(p, chipRect, name);

        } else if (m_nameDisplayMode == Original) {

          if (origName != L"") {

            tmpFont.setItalic(true);

            p.setFont(tmpFont);

            drawChipName(p, chipRect, origName);

          } else  // if there is no original name, then display the style name

                  // in brackets

            drawChipName(p, chipRect, L"( " + name + L" )");

        } else if (m_nameDisplayMode == StyleAndOriginal) {

          drawChipName(p, chipRect, name);

          // display original name only when 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().horizontalAdvance(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));

      // draw "Autopaint for lines" indicator

      int offset = 0;

      if (style->getFlags() != 0) {

        QRect aflRect(chipRect.bottomLeft() + QPoint(0, -14), QSize(12, 15));

        p.drawRect(aflRect);

        p.drawText(aflRect, Qt::AlignCenter, "A");

        offset += 12;

      }

      // draw "Picked Position" indicator (not show on small chip mode)

      if (style->getPickedPosition().pos != TPoint() &&

          m_viewMode != SmallChips) {

        QRect ppRect(chipRect.bottomLeft() + QPoint(offset, -14),

                     QSize(12, 15));

        p.drawRect(ppRect);

        QPoint markPos = ppRect.center() + QPoint(1, 0);

        p.drawEllipse(markPos, 3, 3);

        p.drawLine(markPos - QPoint(5, 0), markPos + QPoint(5, 0));

        p.drawLine(markPos - QPoint(0, 5), markPos + QPoint(0, 5));

      }

      // if numpad shortcut is activated, draw shortcut number on top

      if (Preferences::instance()->isUseNumpadForSwitchingStylesEnabled() &&

          m_viewType == LEVEL_PALETTE &&