#include "toonzqt/paletteviewer.h"

// TnzQt includes

#include "toonzqt/gutil.h"

#include "toonzqt/keyframenavigator.h"

#include "toonzqt/trepetitionguard.h"

#include "toonzqt/dvdialog.h"

#include "toonzqt/dvscrollwidget.h"

#include "toonzqt/studiopaletteviewer.h"

#include "toonzqt/styleselection.h"

#include "toonzqt/stylenameeditor.h"

#include "palettedata.h"

#include "docklayout.h"

// TnzLib includes

#include "toonz/palettecmd.h"

#include "toonz/studiopalettecmd.h"

#include "toonz/txshlevel.h"

#include "toonz/toonzscene.h"

#include "toonz/sceneproperties.h"

#include "toonz/studiopalette.h"

#include "toonz/tframehandle.h"

#include "toonz/fullcolorpalette.h"

#include "toonz/preferences.h"

// TnzCore includes

#include "saveloadqsettings.h"

#include "tconvert.h"

#include "tsystem.h"

#include "tenv.h"

// Qt includes

#include <qsettings></qsettings>

#include <qvboxlayout></qvboxlayout>

#include <qtoolbar></qtoolbar>

#include <qscrollarea></qscrollarea>

#include <qmouseevent></qmouseevent>

#include <qmenubar></qmenubar>

#include <qtoolbutton></qtoolbutton>

#include <qurl></qurl>

#include <qapplication></qapplication>

#include <qlabel></qlabel>

#include <qdrag></qdrag>

TEnv::IntVar ShowNewStyleButton("ShowNewStyleButton", 1);

using namespace PaletteViewerGUI;

namespace {

bool isStudioGhibliLayout() {

  // To prevent interruption to users of long established layout, we will handle

  // that if the current room choice is [StudioGhibli], make sure the toolbar is

  // set to display [ABOVE] styles like before by default.

  //

  // All other choices has the reverse behaviour. This will affect both

  // currently docked and newly opened floating panels.

  QString currentRoomChoice = Preferences::instance()->getCurrentRoomChoice();

  return currentRoomChoice.contains("StudioGhibli", Qt::CaseInsensitive);

}

}  // namespace

//=============================================================================

/*! \class PaletteViewer

\brief The PaletteViewer class provides an object to view and

manage palette view.

Inherits \b QWidget.

This object allows to show and manage palette; it's possible

distinguish three

view type, class can show: current level palette, current studio

palette or

current cleanup palette, using setPalette() to set palette

viewer.

The object is composed of a vertical layout with three widget:

\li a tab bar \b PaletteViewerGUI::TabBar in which are displayed

palette page

\b createTabBar();

\li a central frame \b PaletteViewerGUI::PageViewer in which are

displayed

all style of current page in palette

\li a button bar, \b createToolBar(), \b createPaletteToolBar()

and \b createSavePaletteToolBar();

A collection of method allows you to manage this object and its

interaction

with palette.

*/

/*!	\fn const TPaletteP PaletteViewer::&getPalette() const

Return current viewer palette.

*/

/*!	\fn void PaletteViewer::createToolBar()

Create down button bar.

*/

/*!	\fn void PaletteViewer::updateToolBar()

Update button bar.

*/

PaletteViewer::PaletteViewer(QWidget *parent, PaletteViewType viewType,

                             bool hasSaveToolBar, bool hasPageCommand,

                             bool hasPasteColors)

    : QFrame(parent)

    , m_tabBarContainer(0)

    , m_pagesBar(0)

    , m_paletteToolBar(0)

    , m_savePaletteToolBar(0)

    , m_pageViewer(0)

    , m_pageViewerScrollArea(0)

    , m_indexPageToDelete(-1)

    , m_viewType(viewType)

    , m_frameHandle(0)

    , m_paletteHandle(0)

    , m_changeStyleCommand(0)

    , m_xsheetHandle(0)

    , m_hasSavePaletteToolbar(hasSaveToolBar)

    , m_hasPageCommand(hasPageCommand)

    , m_isSaveActionEnabled(true)

    , m_lockPaletteAction(0)

    , m_lockPaletteToolButton(0)

    , m_toolbarOnTop(false)

    , m_showToolbarOnTopAct(nullptr)

    , m_toolbarContainer(0)

    , m_styleNameEditor(nullptr)

    , m_hLayout(0) {

  setObjectName("OnePixelMarginFrame");

  setFrameStyle(QFrame::StyledPanel);

  createTabBar();

  // Create pageView

  m_pageViewerScrollArea = new QScrollArea();

  m_pageViewerScrollArea->setObjectName(

      "PltPageViewerScrollArea");  // for setting border between toolbar in

                                   // stylesheet

  m_pageViewerScrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

  m_pageViewerScrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);

  m_pageViewerScrollArea->setWidgetResizable(true);

  m_pageViewer =

      new PageViewer(m_pageViewerScrollArea, m_viewType, hasPasteColors);

  m_pageViewerScrollArea->setWidget(m_pageViewer);

  m_pagesBar->setPageViewer(m_pageViewer);

  // Create toolbar. It is an horizontal layout with three internal toolbar.

  m_toolbarContainer = new DvScrollWidget;

  m_toolbarContainer->setObjectName("ToolBarContainer");

  QWidget *toolBarWidget = new QWidget;  // children of this parent name.

  m_toolbarContainer->setWidget(toolBarWidget);

  toolBarWidget->setSizePolicy(QSizePolicy::MinimumExpanding,

                               QSizePolicy::Fixed);

  toolBarWidget->setFixedHeight(22);

  m_paletteToolBar     = new QToolBar(toolBarWidget);

  m_savePaletteToolBar = new QToolBar(toolBarWidget);

  createToolBar();

  QHBoxLayout *toolBarLayout = new QHBoxLayout(toolBarWidget);

  toolBarLayout->setMargin(0);

  toolBarLayout->setSpacing(0);

  {

    toolBarLayout->addWidget(m_savePaletteToolBar, 0, Qt::AlignLeft);

    toolBarLayout->addItem(

        new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum));

    toolBarLayout->addWidget(m_paletteToolBar, 0, Qt::AlignRight);

  }

  toolBarWidget->setLayout(toolBarLayout);

  // This is for setting tab container bg color in stylesheet

  m_tabBarContainer = new TabBarContainter(this);

  QVBoxLayout *mainLayout = new QVBoxLayout(this);

  mainLayout->setMargin(0);

  mainLayout->setSpacing(0);

  {

    m_hLayout = new QHBoxLayout;

    m_hLayout->setMargin(0);

    {

      m_hLayout->addWidget(m_pagesBar, 0);

      m_hLayout->addStretch(1);

    }

    m_tabBarContainer->setLayout(m_hLayout);

    // To align this panel with the style Editor

    mainLayout->addWidget(m_tabBarContainer, 0);

    mainLayout->addWidget(m_pageViewerScrollArea, 1);

    mainLayout->addWidget(m_toolbarContainer, 0);

  }

  setLayout(mainLayout);

  connect(m_pagesBar, SIGNAL(currentChanged(int)), this,

          SLOT(setPageView(int)));

  connect(m_pagesBar, SIGNAL(movePage(int, int)), this,

          SLOT(movePage(int, int)));

  connect(m_pageViewer, SIGNAL(changeWindowTitleSignal()), this,

          SLOT(changeWindowTitle()));

  connect(m_pageViewer, SIGNAL(switchToPage(int)), this,

          SLOT(onSwitchToPage(int)));

  changeWindowTitle();

  setAcceptDrops(true);

  // set Toolbar on top by default for Studio Ghibli Layout

  if (m_toolbarOnTop != isStudioGhibliLayout()) toggleToolbarOnTop();

}

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

PaletteViewer::~PaletteViewer() { delete m_changeStyleCommand; }

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

void PaletteViewer::toggleToolbarOnTop() {

  m_toolbarOnTop = !m_toolbarOnTop;

  // Swap toolbar position in layout

  if (m_toolbarOnTop) {

    // Show a border line between toolbar and pageViewerScrollArea when toolbar

    // is set to below styles only, this is styled in the stylesheet, set it to

    // 0px width to hide it when toolbar is set to display above styles.

    m_pageViewerScrollArea->setStyleSheet("border-width: 0px;");  // hide

    m_hLayout->addWidget(m_toolbarContainer);

    m_showToolbarOnTopAct->setText(tr("Set Toolbar Below Styles"));

  } else {

    m_pageViewerScrollArea->setStyleSheet("border-width: 1px;");  // show

    layout()->addWidget(m_toolbarContainer);

    m_showToolbarOnTopAct->setText(tr("Set Toolbar Above Styles"));

  }

}

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

void PaletteViewer::applyToolbarPartVisibility(int part, bool visible) {

  for (QAction *action : m_toolbarParts.values(part)) {

    action->setVisible(visible);

  }

}

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

void PaletteViewer::toggleKeyframeVisibility(bool checked) {

  applyToolbarPartVisibility(TBVisKeyframe, checked);

}

void PaletteViewer::toggleNewStylePageVisibility(bool checked) {

  applyToolbarPartVisibility(TBVisNewStylePage, checked);

}

void PaletteViewer::togglePaletteGizmoVisibility(bool checked) {

  applyToolbarPartVisibility(TBVisPaletteGizmo, checked);

}

void PaletteViewer::toggleNameEditorVisibility(bool checked) {

  applyToolbarPartVisibility(TBVisNameEditor, checked);

}

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

void PaletteViewer::toggleVariableWidth(bool checked) {

  DockWidget *dock = dynamic_cast<dockwidget *="">(parentWidget());</dockwidget>

  if (dock) {

    dock->setFixWidthMode(checked ? DockWidget::variable

                                  : DockWidget::sizeable);

  }

}

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

void PaletteViewer::save(QSettings &settings) const {

  int toolbarOnTop = m_toolbarOnTop ? 1 : 0;

  settings.setValue("toolbarOnTop", toolbarOnTop);

  int visibleParts = m_toolbarVisibleOtherParts;

  if (m_visibleKeysAction->isChecked()) visibleParts |= 0x01;

  if (m_visibleNewAction->isChecked()) visibleParts |= 0x02;

  if (m_visibleGizmoAction->isChecked()) visibleParts |= 0x04;

  if (m_visibleNameAction->isChecked()) visibleParts |= 0x08;

  settings.setValue("toolbarVisibleMsk", visibleParts);

  int variableWidth = m_variableWidthAction->isChecked() ? 1 : 0;

  settings.setValue("variableWidth", variableWidth);

}

void PaletteViewer::load(QSettings &settings) {

  bool toolbarOnTop =

      settings.value("toolbarOnTop", m_toolbarOnTop).toInt() != 0;

  if (toolbarOnTop != m_toolbarOnTop) toggleToolbarOnTop();

  int visibleParts;

  QVariant visibleVar = settings.value("toolbarVisibleMsk");

  if (visibleVar.canConvert(QVariant::Int)) {

    visibleParts = visibleVar.toInt();

  } else {

    visibleParts = 3;  // Show keyframes and new style/page

  }

  m_visibleKeysAction->setChecked(visibleParts & 0x01);

  m_visibleNewAction->setChecked(visibleParts & 0x02);

  m_visibleGizmoAction->setChecked(visibleParts & 0x04);

  m_visibleNameAction->setChecked(visibleParts & 0x08);

  m_toolbarVisibleOtherParts = visibleParts & ~0x0F;  // Reserve

  applyToolbarPartVisibility(TBVisKeyframe, visibleParts & 0x01);

  applyToolbarPartVisibility(TBVisNewStylePage, visibleParts & 0x02);

  applyToolbarPartVisibility(TBVisPaletteGizmo, visibleParts & 0x04);

  applyToolbarPartVisibility(TBVisNameEditor, visibleParts & 0x08);

  bool variableWidth = settings.value("variableWidth", true).toInt() != 0;

  m_variableWidthAction->setChecked(variableWidth);

  toggleVariableWidth(variableWidth);

}

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

void PaletteViewer::setPaletteHandle(TPaletteHandle *paletteHandle) {

  if (m_paletteHandle == paletteHandle) return;

  bool ret = true;

  if (m_paletteHandle) ret = ret && disconnect(m_paletteHandle, 0, this, 0);

  m_paletteHandle = paletteHandle;

  if (m_paletteHandle && isVisible()) {

    ret = ret && connect(m_paletteHandle, SIGNAL(paletteSwitched()), this,

                         SLOT(onPaletteSwitched()));

    ret = ret && connect(m_paletteHandle, SIGNAL(paletteChanged()), this,

                         SLOT(onPaletteChanged()));

    ret = ret && connect(m_paletteHandle, SIGNAL(paletteChanged()), this,

                         SLOT(changeWindowTitle()));

    ret = ret && connect(m_paletteHandle, SIGNAL(paletteTitleChanged()), this,

                         SLOT(changeWindowTitle()));

    ret = ret && connect(m_paletteHandle, SIGNAL(colorStyleSwitched()), this,

                         SLOT(onColorStyleSwitched()));

    ret = ret && connect(m_paletteHandle, SIGNAL(colorStyleChanged(bool)), this,

                         SLOT(changeWindowTitle()));

    ret = ret && connect(m_paletteHandle, SIGNAL(paletteDirtyFlagChanged()),

                         this, SLOT(changeWindowTitle()));

  }

  assert(ret);

  if (m_viewType != CLEANUP_PALETTE)

    m_keyFrameButton->setPaletteHandle(m_paletteHandle);

  m_pageViewer->setPaletteHandle(m_paletteHandle);

  setPageView(0);

  updateTabBar();

  updatePaletteToolBar();

}

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

void PaletteViewer::setFrameHandle(TFrameHandle *frameHandle) {

  m_frameHandle = frameHandle;

  if (m_viewType != CLEANUP_PALETTE)

    m_keyFrameButton->setFrameHandle(m_frameHandle);

  m_pageViewer->setFrameHandle(m_frameHandle);

}

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

void PaletteViewer::setXsheetHandle(TXsheetHandle *xsheetHandle) {

  m_xsheetHandle = xsheetHandle;

  m_pageViewer->setXsheetHandle(m_xsheetHandle);

}

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

/*!for clearing level cache after "paste style" command called from style

 * selection

 */

void PaletteViewer::setLevelHandle(TXshLevelHandle *levelHandle) {

  m_pageViewer->setLevelHandle(levelHandle);

}

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

TPalette *PaletteViewer::getPalette() {

  if (!m_paletteHandle) return 0;

  return m_paletteHandle->getPalette();

}

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

void PaletteViewer::updateView() {

  changeWindowTitle();

  setPageView(0);

  clearStyleSelection();

  updateTabBar();

  updatePaletteToolBar();

  updateSavePaletteToolBar();

}

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

void PaletteViewer::enableSaveAction(bool enable) {

  if (!m_savePaletteToolBar) return;

  QList<qaction *=""> actions;</qaction>

  actions               = m_savePaletteToolBar->actions();

  enable                = !getPalette() ? false : enable;

  m_isSaveActionEnabled = enable;

  int i;

  for (i = 0; i < actions.count() - 1; i++) {

    QAction *act = actions[i];

    if (act->text() == tr("&Save Palette As") ||

        act->text() == tr("&Save Palette"))

      act->setEnabled(enable);

  }

}

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

/*! Create tab bar to select palette page.

 */

void PaletteViewer::createTabBar() {

  m_pagesBar = new PaletteTabBar(this, m_hasPageCommand);

  connect(m_pagesBar, SIGNAL(tabTextChanged(int)), this,

          SLOT(onTabTextChanged(int)));

  if (!getPalette()) return;

  updateTabBar();

}

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

/*! Create right part of button bar.

 */

void PaletteViewer::createPaletteToolBar() {

  m_paletteToolBar->clear();

  m_paletteToolBar->setMovable(false);

  m_paletteToolBar->setIconSize(QSize(20, 20));

  m_paletteToolBar->setLayoutDirection(Qt::RightToLeft);

  // Lock button to avoid editing the palette by mistake

  if (m_viewType == LEVEL_PALETTE) {

    m_lockPaletteToolButton = new QToolButton(this);

    m_lockPaletteToolButton->setIcon(createQIcon("lock"));

    m_lockPaletteToolButton->setCheckable(true);

    m_lockPaletteToolButton->setObjectName("PaletteLockButton");

    m_lockPaletteToolButton->setToolTip(tr("Lock Palette"));

    if (getPalette()) {

      m_lockPaletteToolButton->setChecked(getPalette()->isLocked());

    }

    connect(m_lockPaletteToolButton, SIGNAL(clicked(bool)), this,

            SLOT(setIsLocked(bool)));

    m_paletteToolBar->addWidget(m_lockPaletteToolButton);

  } else if (m_viewType == STUDIO_PALETTE) {

    QToolButton *toolButton = new QToolButton(this);

    toolButton->setPopupMode(QToolButton::InstantPopup);

    toolButton->setIcon(createQIcon("lock"));

    toolButton->setObjectName("PaletteLockButton");

    toolButton->setToolTip(tr("Lock Palette"));

    toolButton->setCheckable(true);

    QMenu *lockMenu     = new QMenu(toolButton);

    m_lockPaletteAction = new QAction(tr("&Lock Palette"), toolButton);

    m_lockPaletteAction->setCheckable(true);

    lockMenu->addAction(m_lockPaletteAction);

    toolButton->setMenu(lockMenu);

    if (getPalette()) {

      m_lockPaletteAction->setChecked(getPalette()->isLocked());

    }

    connect(m_lockPaletteAction, SIGNAL(triggered(bool)), this,

            SLOT(setIsLocked(bool)));

    connect(m_lockPaletteAction, SIGNAL(toggled(bool)), toolButton,

            SLOT(setChecked(bool)));

    m_paletteToolBar->addWidget(toolButton);

  }

  // Attenzione: alcune modifiche sono state fatte a livello di stylesheet

  QToolButton *viewModeButton = new QToolButton(this);

  viewModeButton->setPopupMode(QToolButton::InstantPopup);

  QIcon viewModeIcon = createQIcon("menu");

  viewModeButton->setIcon(viewModeIcon);

  QMenu *viewMode = new QMenu(QString("Options"), viewModeButton);

  viewMode->setToolTip(tr("Options"));

  viewMode->setLayoutDirection(Qt::LeftToRight);

  QActionGroup *viewModeGroup = new QActionGroup(viewMode);

  viewModeGroup->setExclusive(true);

  connect(viewModeGroup, SIGNAL(triggered(QAction *)), this,

          SLOT(onViewMode(QAction *)));

  auto addViewAction = [&](const QString &label, PageViewer::ViewMode mode) {

    QAction *viewAction = new QAction(label, viewMode);

    viewAction->setData(mode);

    viewAction->setCheckable(true);

    if (m_pageViewer->getViewMode() == mode) viewAction->setChecked(true);

    viewModeGroup->addAction(viewAction);

    viewMode->addAction(viewAction);

  };

  addViewAction(tr("&Small Thumbnails View"), PageViewer::SmallChips);

  addViewAction(tr("&Medium Thumbnails View"), PageViewer::MediumChips);

  addViewAction(tr("&Large Thumbnails View"), PageViewer::LargeChips);

  addViewAction(tr("&List View"), PageViewer::List);

  viewMode->addSeparator();

  QActionGroup *nameDisplayModeGroup = new QActionGroup(viewMode);

  nameDisplayModeGroup->setExclusive(true);

  connect(nameDisplayModeGroup, SIGNAL(triggered(QAction *)), this,

          SLOT(onNameDisplayMode(QAction *)));

  auto addNameDisplayAction = [&](const QString &label,

                                  PageViewer::NameDisplayMode mode) {

    QAction *nameDisplayAction = new QAction(label, viewMode);

    nameDisplayAction->setData(mode);

    nameDisplayAction->setCheckable(true);

    if (m_pageViewer->getNameDisplayMode() == mode)

      nameDisplayAction->setChecked(true);

    nameDisplayModeGroup->addAction(nameDisplayAction);

    viewMode->addAction(nameDisplayAction);

  };

  addNameDisplayAction(tr("Style Name"), PageViewer::Style);

  addNameDisplayAction(tr("StudioPalette Name"), PageViewer::Original);

  addNameDisplayAction(tr("Both Names"), PageViewer::StyleAndOriginal);

  viewMode->addSeparator();

  // Docked panels will automatically adjust width based of the window size

  m_variableWidthAction = new QAction(tr("Auto Adjust Panel Width"));

  m_variableWidthAction->setCheckable(true);

  m_variableWidthAction->setChecked(true);

  viewMode->addAction(m_variableWidthAction);

  connect(m_variableWidthAction, SIGNAL(toggled(bool)), this,

          SLOT(toggleVariableWidth(bool)));

  viewMode->addSeparator();

  // Add ability to show or hide buttons

  QMenu *visibleButtons = new QMenu(tr("Visible Toolbar Buttons"));

  m_visibleKeysAction = new QAction(tr("KeyFrame"));

  m_visibleKeysAction->setCheckable(true);

  m_visibleKeysAction->setChecked(true);

  visibleButtons->addAction(m_visibleKeysAction);

  m_visibleNewAction = new QAction(tr("New Style/Page"));

  m_visibleNewAction->setCheckable(true);

  m_visibleNewAction->setChecked(true);

  visibleButtons->addAction(m_visibleNewAction);

  m_visibleGizmoAction = new QAction(tr("Palette Gizmo"));

  m_visibleGizmoAction->setCheckable(true);

  m_visibleGizmoAction->setChecked(true);

  visibleButtons->addAction(m_visibleGizmoAction);

  m_visibleNameAction = new QAction(tr("Name Editor"));

  m_visibleNameAction->setCheckable(true);

  m_visibleNameAction->setChecked(true);

  visibleButtons->addAction(m_visibleNameAction);

  viewMode->addMenu(visibleButtons);

  if (m_viewType == CLEANUP_PALETTE) m_visibleKeysAction->setVisible(false);

  if (m_viewType != LEVEL_PALETTE) m_visibleGizmoAction->setVisible(false);

  connect(m_visibleKeysAction, SIGNAL(toggled(bool)), this,

          SLOT(toggleKeyframeVisibility(bool)));

  connect(m_visibleNewAction, SIGNAL(toggled(bool)), this,

          SLOT(toggleNewStylePageVisibility(bool)));

  connect(m_visibleGizmoAction, SIGNAL(toggled(bool)), this,

          SLOT(togglePaletteGizmoVisibility(bool)));

  connect(m_visibleNameAction, SIGNAL(toggled(bool)), this,

          SLOT(toggleNameEditorVisibility(bool)));

  viewMode->addMenu(visibleButtons);

  m_showToolbarOnTopAct = new QAction;

  if (m_toolbarOnTop)

    m_showToolbarOnTopAct->setText(tr("Set Toolbar Below Styles"));

  else

    m_showToolbarOnTopAct->setText(tr("Set Toolbar Above Styles"));

  viewMode->addAction(m_showToolbarOnTopAct);

  connect(m_showToolbarOnTopAct, SIGNAL(triggered()), this,

          SLOT(toggleToolbarOnTop()));

  QString str              = (ShowNewStyleButton) ? tr("Hide New Style Button")

                                                  : tr("Show New Style Button");

  QAction *showNewStyleBtn = viewMode->addAction(str);

  connect(showNewStyleBtn, SIGNAL(triggered()), this,

          SLOT(onShowNewStyleButtonToggled()));

  viewModeButton->setMenu(viewMode);

  // Attenzione: avendo invertito la direzione devo aggiungere gli oggetti al

  // contrario

  m_paletteToolBar->addWidget(viewModeButton);

  m_paletteToolBar->addSeparator();

  m_toolbarParts.clear();

  QAction *openStyleNameEditorAct = new QAction(tr("Name Editor"));

  openStyleNameEditorAct->setIcon(createQIcon("rename", false, true));

  connect(openStyleNameEditorAct, &QAction::triggered, [&]() {

    if (!m_styleNameEditor) {

      m_styleNameEditor = new StyleNameEditor(this);

      m_styleNameEditor->setPaletteHandle(getPaletteHandle());

    }

    m_styleNameEditor->show();

    m_styleNameEditor->raise();

    m_styleNameEditor->activateWindow();

  });

  m_paletteToolBar->addAction(openStyleNameEditorAct);

  m_toolbarParts.insert(TBVisNameEditor, openStyleNameEditorAct);

  m_toolbarParts.insert(TBVisNameEditor, m_paletteToolBar->addSeparator());

  if (m_viewType == LEVEL_PALETTE) {

    CommandManager *cmd = CommandManager::instance();

    m_sharedGizmoAction = cmd->getAction("MI_OpenPltGizmo");

    // Clone palette gizmo action so visibility can be control

    QAction *palGizmo = new DVAction(m_sharedGizmoAction->icon(),

                                     m_sharedGizmoAction->text(), this);

    connect(palGizmo, &QAction::triggered,

            [&]() { m_sharedGizmoAction->trigger(); });

    m_paletteToolBar->addAction(palGizmo);

    m_toolbarParts.insert(TBVisPaletteGizmo, palGizmo);

    m_toolbarParts.insert(TBVisPaletteGizmo, m_paletteToolBar->addSeparator());

  }

  if (m_hasPageCommand) {

    QAction *addPage;

    QIcon addPageIcon = createQIcon("newpage");

    addPage = new QAction(addPageIcon, tr("&New Page"), m_paletteToolBar);

    connect(addPage, SIGNAL(triggered()), this, SLOT(addNewPage()));

    m_paletteToolBar->addAction(addPage);

    m_toolbarParts.insert(TBVisNewStylePage, addPage);

  }

  QIcon newColorIcon = createQIcon("newstyle");

  QAction *addColor =

      new QAction(newColorIcon, tr("&New Style"), m_paletteToolBar);

  connect(addColor, SIGNAL(triggered()), this, SLOT(addNewColor()));

  m_paletteToolBar->addAction(addColor);

  m_toolbarParts.insert(TBVisNewStylePage, addColor);

  m_toolbarParts.insert(TBVisNewStylePage, m_paletteToolBar->addSeparator());

  // KeyFrame button

  if (m_viewType != CLEANUP_PALETTE) {

    m_keyFrameButton = new PaletteKeyframeNavigator(m_paletteToolBar);

    m_toolbarParts.insert(TBVisKeyframe,

                          m_paletteToolBar->addWidget(m_keyFrameButton));

    m_toolbarParts.insert(TBVisKeyframe, m_paletteToolBar->addSeparator());

    m_keyFrameButton->setSelection(m_pageViewer->getSelection());

  }

  updatePaletteToolBar();

}

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

/*! Create left part of button bar; insert different actions in according to

current viewer palette type.

*/

void PaletteViewer::createSavePaletteToolBar() {

  m_savePaletteToolBar->clear();

  m_savePaletteToolBar->setMovable(false);

  m_savePaletteToolBar->setIconSize(QSize(20, 20));

  if (!m_hasSavePaletteToolbar || m_viewType == CLEANUP_PALETTE) {

    m_savePaletteToolBar->hide();

    return;

  }

  // save palette as

  QAction *saveAsPalette = new QAction(

      createQIcon("saveas"), tr("&Save Palette As"), m_savePaletteToolBar);

  // overwrite palette

  QAction *savePalette = new QAction(createQIcon("save"), tr("&Save Palette"),

                                     m_savePaletteToolBar);

  if (m_viewType == STUDIO_PALETTE) {

    connect(savePalette, SIGNAL(triggered()), this, SLOT(saveStudioPalette()));

    m_savePaletteToolBar->addAction(savePalette);

  } else if (m_viewType == LEVEL_PALETTE) {

    // save load palette

    PaletteIconWidget *movePalette =

        new PaletteIconWidget(m_savePaletteToolBar);

    connect(movePalette, SIGNAL(startDrag()), this, SLOT(startDragDrop()));

    QAction *act = m_savePaletteToolBar->addWidget(movePalette);

    act->setText(tr("&Move Palette"));

    m_savePaletteToolBar->addSeparator();

    // save palette as

    connect(saveAsPalette, SIGNAL(triggered()),

            CommandManager::instance()->getAction("MI_SavePaletteAs"),

            SIGNAL(triggered()));

    m_savePaletteToolBar->addAction(saveAsPalette);

    // overwrite palette

    connect(savePalette, SIGNAL(triggered()),

            CommandManager::instance()->getAction("MI_OverwritePalette"),

            SIGNAL(triggered()));

    m_savePaletteToolBar->addAction(savePalette);

  }

  updateSavePaletteToolBar();

}

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

/*! Update page tab bar adding or removing tab in accord with viewer palette.

 */

void PaletteViewer::updateTabBar() {

  int tabCount = m_pagesBar->count();

  int i;

  // Se ci sono tab li butto

  for (i = tabCount - 1; i >= 0; i--) m_pagesBar->removeTab(i);

  TPalette *palette = getPalette();

  if (!palette) return;

  QIcon tabIcon = createQIcon("palette_tab");

  m_pagesBar->setIconSize(QSize(16, 16));

  // Aggiungo i tab in funzione delle pagine di m_palette

  for (i = 0; i < palette->getPageCount(); i++) {

    TPalette::Page *page = palette->getPage(i);

    std::wstring ws      = page->getName();

    QString pageName     = QString::fromStdWString(ws);

    m_pagesBar->addTab(tabIcon, pageName);

  }

  m_pagesBar->update();

}

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

/*! Update right button bar, enable its action if current viewer palette is

 * empty.

 */

void PaletteViewer::updatePaletteToolBar() {

  if (!m_paletteToolBar) return;

  QList<qaction *=""> actions;</qaction>

  actions                = m_paletteToolBar->actions();

  TPalette *palette      = getPalette();

  bool enable            = !palette ? false : true;

  bool enableNewStyleAct = enable;

  // limit the number of cleanup styles to 7

  if (palette && palette->isCleanupPalette())

    enableNewStyleAct = (palette->getStyleInPagesCount() < 8);

  if (m_viewType != CLEANUP_PALETTE) m_keyFrameButton->setEnabled(enable);

  int i;

  for (i = 0; i < actions.count(); i++) {

    QAction *act = actions[i];

    if (act->text() == tr("&New Style")) {

      act->setEnabled(enableNewStyleAct);

      continue;

    }

    act->setEnabled(enable);

  }

}

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

/*! Update left button bar, enable its action if current viewer palette is

 * empty.

 */

void PaletteViewer::updateSavePaletteToolBar() {

  if (!m_savePaletteToolBar) return;

  QList<qaction *=""> actions;</qaction>

  actions     = m_savePaletteToolBar->actions();

  bool enable = !getPalette() ? false : true;

  int i;

  for (i = 0; i < actions.count(); i++) {

    QAction *act = actions[i];

    if (act->text() == tr("&Save Palette As") ||

        act->text() == tr("&Save Palette") ||

        act->text() == tr("&Palette Gizmo"))

      act->setEnabled(enable);

    else if (m_viewType != STUDIO_PALETTE && i == 0)  // move action

      actions[i]->setVisible(enable);

    else

      actions[i]->setEnabled(false);

  }

}

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

/*! Resize the widget and its child.

 */

void PaletteViewer::resizeEvent(QResizeEvent *event) {

  QWidget::resizeEvent(event);

  if (m_pageViewer) m_pageViewer->computeSize();

  if (m_pagesBar) m_pagesBar->setMaximumWidth(width() - 12);

}

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

void PaletteViewer::setChangeStyleCommand(

    ChangeStyleCommand *changeStyleCommand) {

  if (m_changeStyleCommand) delete m_changeStyleCommand;

  m_changeStyleCommand = changeStyleCommand;

  m_pageViewer->setChangeStyleCommand(m_changeStyleCommand);

}

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

/*! Create and open the Right-click menu.

 */

void PaletteViewer::contextMenuEvent(QContextMenuEvent *event) {

  m_indexPageToDelete = -1;

  QPoint pos          = event->pos();

  if (!getPalette() || !m_tabBarContainer->geometry().contains(pos)) return;

  QMenu *menu = new QMenu(this);

  if (m_hasPageCommand) {

    QAction *newPage = menu->addAction(createQIcon("newpage"), tr("New Page"));

    connect(newPage, SIGNAL(triggered()), SLOT(addNewPage()));

    if (m_pagesBar->geometry().contains(pos)) {

      int tabIndex         = m_pagesBar->tabAt(pos);

      TPalette::Page *page = getPalette()->getPage(tabIndex);

      if (page) {

        bool canRemovePage = true;

        if (page->getStyleId(0) == 0 || page->getStyleId(1) == 1)

          canRemovePage = false;

        if (canRemovePage) {

          m_indexPageToDelete = tabIndex;

          QAction *deletePage =

              menu->addAction(createQIcon("delete"), tr("Delete Page"));

          connect(deletePage, SIGNAL(triggered()), SLOT(deletePage()));

        }

      }

    }

  }

  if (m_viewType == LEVEL_PALETTE && m_isSaveActionEnabled) {

    menu->addSeparator();

    menu->addAction(

        CommandManager::instance()->getAction("MI_OverwritePalette"));

    menu->addAction(CommandManager::instance()->getAction("MI_SavePaletteAs"));

  }

  if (m_viewType == LEVEL_PALETTE && !getPalette()->isLocked() &&

      m_isSaveActionEnabled &&

      !FullColorPalette::instance()->isFullColorPalette(getPalette())) {

    menu->addSeparator();

    menu->addAction(

        CommandManager::instance()->getAction("MI_EraseUnusedStyles"));

  }

  menu->exec(event->globalPos());

}

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

void PaletteViewer::mousePressEvent(QMouseEvent *event) {

  QFrame::mousePressEvent(event);

  if (event->button() == Qt::RightButton) {

    m_pageViewer->getSelection()->makeCurrent();

    m_pageViewer->updateCommandLocks();

  }

}

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

void PaletteViewer::showEvent(QShowEvent *) {

  onPaletteSwitched();

  changeWindowTitle();

  toggleVariableWidth(m_variableWidthAction->isChecked());

  if (!m_paletteHandle) return;

  connect(m_paletteHandle, SIGNAL(paletteSwitched()), this,

          SLOT(onPaletteSwitched()));

  connect(m_paletteHandle, SIGNAL(paletteChanged()), this,

          SLOT(onPaletteChanged()));

  connect(m_paletteHandle, SIGNAL(paletteTitleChanged()), this,

          SLOT(changeWindowTitle()));

  connect(m_paletteHandle, SIGNAL(colorStyleSwitched()), this,

          SLOT(onColorStyleSwitched()));

  connect(m_paletteHandle, SIGNAL(colorStyleChanged(bool)), this,

          SLOT(changeWindowTitle()));

  connect(m_paletteHandle, SIGNAL(paletteDirtyFlagChanged()), this,