#include "mainwindow.h"

// Tnz6 includes
#include "menubar.h"
#include "menubarcommandids.h"
#include "xsheetviewer.h"
#include "viewerpane.h"
#include "flipbook.h"
#include "messagepanel.h"
#include "iocommand.h"
#include "tapp.h"
#include "viewerpane.h"
#include "startuppopup.h"
#include "statusbar.h"
#include "aboutpopup.h"

// TnzTools includes
#include "tools/toolcommandids.h"
#include "tools/toolhandle.h"

// TnzQt includes
#include "toonzqt/gutil.h"
#include "toonzqt/icongenerator.h"
#include "toonzqt/viewcommandids.h"
#include "toonzqt/updatechecker.h"
#include "toonzqt/paletteviewer.h"

// TnzLib includes
#include "toonz/toonzfolders.h"
#include "toonz/stage2.h"
#include "toonz/stylemanager.h"
#include "toonz/tscenehandle.h"
#include "toonz/toonzscene.h"
#include "toonz/txshleveltypes.h"
#include "toonz/tproject.h"

// TnzBase includes
#include "tenv.h"

// TnzCore includes
#include "tsystem.h"
#include "timagecache.h"
#include "tthread.h"

// Qt includes
#include <QStackedWidget>
#include <QSettings>
#include <QApplication>
#include <QGLPixelBuffer>
#include <QDebug>
#include <QDesktopServices>
#include <QButtonGroup>
#include <QPushButton>
#include <QLabel>
#include <QMessageBox>

TEnv::IntVar ViewCameraToggleAction("ViewCameraToggleAction", 1);
TEnv::IntVar ViewTableToggleAction("ViewTableToggleAction", 0);
TEnv::IntVar FieldGuideToggleAction("FieldGuideToggleAction", 0);
TEnv::IntVar ViewBBoxToggleAction("ViewBBoxToggleAction1", 1);
TEnv::IntVar EditInPlaceToggleAction("EditInPlaceToggleAction", 0);
TEnv::IntVar RasterizePliToggleAction("RasterizePliToggleAction", 0);
TEnv::IntVar SafeAreaToggleAction("SafeAreaToggleAction", 0);
TEnv::IntVar ViewColorcardToggleAction("ViewColorcardToggleAction", 1);
TEnv::IntVar ViewGuideToggleAction("ViewGuideToggleAction", 1);
TEnv::IntVar ViewRulerToggleAction("ViewRulerToggleAction", 1);
TEnv::IntVar TCheckToggleAction("TCheckToggleAction", 0);
TEnv::IntVar ICheckToggleAction("ICheckToggleAction", 0);
TEnv::IntVar Ink1CheckToggleAction("Ink1CheckToggleAction", 0);
TEnv::IntVar PCheckToggleAction("PCheckToggleAction", 0);
TEnv::IntVar IOnlyToggleAction("IOnlyToggleAction", 0);
TEnv::IntVar BCheckToggleAction("BCheckToggleAction", 0);
TEnv::IntVar GCheckToggleAction("GCheckToggleAction", 0);
TEnv::IntVar ACheckToggleAction("ACheckToggleAction", 0);
TEnv::IntVar LinkToggleAction("LinkToggleAction", 0);
TEnv::IntVar ShowStatusBarAction("ShowStatusBarAction", 1);
// TEnv::IntVar DockingCheckToggleAction("DockingCheckToggleAction", 1);
TEnv::IntVar ShiftTraceToggleAction("ShiftTraceToggleAction", 0);
TEnv::IntVar EditShiftToggleAction("EditShiftToggleAction", 0);
TEnv::IntVar NoShiftToggleAction("NoShiftToggleAction", 0);
TEnv::IntVar TouchGestureControl("TouchGestureControl", 0);
TEnv::IntVar TransparencySliderValue("TransparencySliderValue", 50);

//=============================================================================
namespace {
//=============================================================================

// layout file name may be overwritten by the argument
std::string layoutsFileName           = "layouts.txt";
const std::string currentRoomFileName = "currentRoom.txt";
bool scrambledRooms                   = false;

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

bool readRoomList(std::vector<TFilePath> &roomPaths,
                  const QString &argumentLayoutFileName) {
  bool argumentLayoutFileLoaded = false;

  TFilePath fp;
  /*-レイアウトファイルが指定されている場合--*/
  if (!argumentLayoutFileName.isEmpty()) {
    fp = ToonzFolder::getRoomsFile(argumentLayoutFileName.toStdString());
    if (!TFileStatus(fp).doesExist()) {
      DVGui::warning("Room layout file " + argumentLayoutFileName +
                     " not found!");
      fp = ToonzFolder::getRoomsFile(layoutsFileName);
      if (!TFileStatus(fp).doesExist()) return false;
    } else {
      argumentLayoutFileLoaded = true;
      layoutsFileName          = argumentLayoutFileName.toStdString();
    }
  } else {
    fp = ToonzFolder::getRoomsFile(layoutsFileName);
    if (!TFileStatus(fp).doesExist()) return false;
  }

  Tifstream is(fp);
  for (;;) {
    char buffer[1024];
    is.getline(buffer, sizeof(buffer));
    if (is.eof()) break;
    char *s = buffer;
    while (*s == ' ' || *s == '\t') s++;
    char *t = s;
    while (*t && *t != '\r' && *t != '\n') t++;
    while (t > s && (t[-1] == ' ' || t[-1] == '\t')) t--;
    t[0] = '\0';
    if (s[0] == '\0') continue;
    TFilePath roomPath = fp.getParentDir() + s;
    roomPaths.push_back(roomPath);
  }

  return argumentLayoutFileLoaded;
}

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

void writeRoomList(std::vector<TFilePath> &roomPaths) {
  TFilePath fp = ToonzFolder::getMyRoomsDir() + layoutsFileName;
  TSystem::touchParentDir(fp);
  Tofstream os(fp);
  if (!os) return;
  for (int i = 0; i < (int)roomPaths.size(); i++) {
    TFilePath roomPath = roomPaths[i];
    assert(roomPath.getParentDir() == fp.getParentDir());
    os << roomPath.withoutParentDir() << "\n";
  }
}

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

void writeRoomList(std::vector<Room *> &rooms) {
  std::vector<TFilePath> roomPaths;
  for (int i = 0; i < (int)rooms.size(); i++)
    roomPaths.push_back(rooms[i]->getPath());
  writeRoomList(roomPaths);
}

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

void makePrivate(Room *room) {
  TFilePath layoutDir       = ToonzFolder::getMyRoomsDir();
  TFilePath roomPath        = room->getPath();
  std::string mbSrcFileName = roomPath.getName() + "_menubar.xml";
  if (roomPath == TFilePath() || roomPath.getParentDir() != layoutDir) {
    int count = 1;
    for (;;) {
      roomPath = layoutDir + ("room" + std::to_string(count++) + ".ini");
      if (!TFileStatus(roomPath).doesExist()) break;
    }
    room->setPath(roomPath);
    TSystem::touchParentDir(roomPath);
    room->save();
  }
  /*- create private menubar settings if not exists -*/
  std::string mbDstFileName = roomPath.getName() + "_menubar.xml";
  TFilePath myMBPath        = layoutDir + mbDstFileName;
  if (!TFileStatus(myMBPath).isReadable()) {
    TFilePath templateRoomMBPath =
        ToonzFolder::getTemplateRoomsDir() + mbSrcFileName;
    if (TFileStatus(templateRoomMBPath).doesExist())
      TSystem::copyFile(myMBPath, templateRoomMBPath);
    else {
      TFilePath templateFullMBPath =
          ToonzFolder::getTemplateRoomsDir() + "menubar_template.xml";
      if (TFileStatus(templateFullMBPath).doesExist())
        TSystem::copyFile(myMBPath, templateFullMBPath);
      else
        DVGui::warning(
            QObject::tr("Cannot open menubar settings template file. "
                        "Re-installing Toonz will solve this problem."));
    }
  }
}

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

void makePrivate(std::vector<Room *> &rooms) {
  for (int i = 0; i < (int)rooms.size(); i++) makePrivate(rooms[i]);
}

// major version  :  7 bits
// minor version  :  8 bits
// revision number: 16 bits
int get_version_code_from(std::string ver) {
  int version = 0;

  // major version: assume that the major version is less than 127.
  std::string::size_type const a = ver.find('.');
  std::string const major = (a == std::string::npos) ? ver : ver.substr(0, a);
  version += std::stoi(major) << 24;
  if ((a == std::string::npos) || (a + 1 == ver.length())) {
    return version;
  }

  // minor version: assume that the minor version is less than 255.
  std::string::size_type const b = ver.find('.', a + 1);
  std::string const minor        = (b == std::string::npos)
                                ? ver.substr(a + 1)
                                : ver.substr(a + 1, b - a - 1);
  version += std::stoi(minor) << 16;
  if ((b == std::string::npos) || (b + 1 == ver.length())) {
    return version;
  }

  // revision number: assume that the revision number is less than 32767.
  version += std::stoi(ver.substr(b + 1));

  return version;
}

}  // namespace
//=============================================================================

//=============================================================================
// Room
//-----------------------------------------------------------------------------

void Room::save() {
  DockLayout *layout = dockLayout();

  // Now save layout state
  DockLayout::State state        = layout->saveState();
  std::vector<QRect> &geometries = state.first;

  QSettings settings(toQString(getPath()), QSettings::IniFormat);
  settings.remove("");

  settings.beginGroup("room");

  int i;
  for (i = 0; i < layout->count(); ++i) {
    settings.beginGroup("pane_" + QString::number(i));
    TPanel *pane = static_cast<TPanel *>(layout->itemAt(i)->widget());
    settings.setValue("name", pane->objectName());
    settings.setValue("geometry", geometries[i]);  // Use passed geometry
    if (SaveLoadQSettings *persistent =
            dynamic_cast<SaveLoadQSettings *>(pane->widget()))
      persistent->save(settings);
    if (pane->getViewType() != -1)
      // If panel has different viewtypes, store current one
      settings.setValue("viewtype", pane->getViewType());
    if (pane->objectName() == "FlipBook") {
      // Store flipbook's identification number
      FlipBook *flip = static_cast<FlipBook *>(pane->widget());
      settings.setValue("index", flip->getPoolIndex());
    }
    settings.endGroup();
  }

  // Adding hierarchy string
  settings.setValue("hierarchy", state.second);
  settings.setValue("name", QVariant(QString(m_name)));

  settings.endGroup();
}

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

std::pair<DockLayout *, DockLayout::State> Room::load(const TFilePath &fp) {
  QSettings settings(toQString(fp), QSettings::IniFormat);

  setPath(fp);

  DockLayout *layout = dockLayout();

  settings.beginGroup("room");
  QStringList itemsList = settings.childGroups();

  std::vector<QRect> geometries;
  unsigned int i;
  for (i = 0; i < itemsList.size(); i++) {
    // Panel i
    // NOTE: Panels have to be retrieved in the precise order they were saved.
    // settings.beginGroup(itemsList[i]);  //NO! itemsList has lexicographical
    // ordering!!
    settings.beginGroup("pane_" + QString::number(i));

    TPanel *pane = 0;
    QString paneObjectName;

    // Retrieve panel name
    QVariant name = settings.value("name");
    if (name.canConvert(QVariant::String)) {
      // Allocate panel
      paneObjectName          = name.toString();
      std::string paneStrName = paneObjectName.toStdString();
      pane = TPanelFactory::createPanel(this, paneObjectName);
      if (SaveLoadQSettings *persistent =
              dynamic_cast<SaveLoadQSettings *>(pane->widget()))
        persistent->load(settings);
    }

    if (!pane) {
      // Allocate a message panel
      MessagePanel *message = new MessagePanel(this);
      message->setWindowTitle(name.toString());
      message->setMessage(
          "This panel is not supported by the currently set license!");

      pane = message;
      pane->setPanelType(paneObjectName.toStdString());
      pane->setObjectName(paneObjectName);
    }

    pane->setObjectName(paneObjectName);

    // Add panel to room
    addDockWidget(pane);

    // Store its geometry
    geometries.push_back(settings.value("geometry").toRect());

    // Restore view type if present
    if (settings.contains("viewtype"))
      pane->setViewType(settings.value("viewtype").toInt());

    // Restore flipbook pool indices
    if (paneObjectName == "FlipBook") {
      int index = settings.value("index").toInt();
      dynamic_cast<FlipBook *>(pane->widget())->setPoolIndex(index);
    }

    settings.endGroup();
  }

  // resolve resize events here to avoid unwanted minimize of floating viewer
  qApp->processEvents();

  DockLayout::State state(geometries, settings.value("hierarchy").toString());

  layout->restoreState(state);

  setName(settings.value("name").toString());
  return std::make_pair(layout, state);
}

//=============================================================================
// MainWindow
//-----------------------------------------------------------------------------

#if QT_VERSION >= 0x050500
MainWindow::MainWindow(const QString &argumentLayoutFileName, QWidget *parent,
                       Qt::WindowFlags flags)
#else
MainWindow::MainWindow(const QString &argumentLayoutFileName, QWidget *parent,
                       Qt::WFlags flags)
#endif
    : QMainWindow(parent, flags)
    , m_saveSettingsOnQuit(true)
    , m_oldRoomIndex(0)
    , m_layoutName("") {
  // store a main window pointer in advance of making its contents
  TApp::instance()->setMainWindow(this);

  m_toolsActionGroup = new QActionGroup(this);
  m_toolsActionGroup->setExclusive(true);
  m_currentRoomsChoice = Preferences::instance()->getCurrentRoomChoice();
  makeTransparencyDialog();
  defineActions();
  // user defined shortcuts will be loaded here
  CommandManager::instance()->loadShortcuts();
  TApp::instance()->getCurrentScene()->setDirtyFlag(false);

  // La menuBar altro non è che una toolbar
  // in cui posso inserire quanti custom widget voglio.
  m_topBar = new TopBar(this);

  addToolBar(m_topBar);
  addToolBarBreak(Qt::TopToolBarArea);

  m_stackedWidget = new QStackedWidget(this);

  // For the style sheet
  m_stackedWidget->setObjectName("MainStackedWidget");
  m_stackedWidget->setFrameStyle(QFrame::StyledPanel);

  // To give a border to the stackedWidget.
  /*QFrame *centralWidget = new QFrame(this);
centralWidget->setFrameStyle(QFrame::StyledPanel);
centralWidget->setObjectName("centralWidget");
QHBoxLayout *centralWidgetLayout = new QHBoxLayout;
centralWidgetLayout->setMargin(3);
centralWidgetLayout->addWidget(m_stackedWidget);
centralWidget->setLayout(centralWidgetLayout);*/

  setCentralWidget(m_stackedWidget);

  m_statusBar = new StatusBar(this);
  setStatusBar(m_statusBar);
  m_statusBar->setVisible(ShowStatusBarAction == 1 ? true : false);
  TApp::instance()->setStatusBar(m_statusBar);

  m_aboutPopup = new AboutPopup(this);

  // Leggo i settings
  readSettings(argumentLayoutFileName);

  // Setto le stanze
  QTabBar *roomTabWidget = m_topBar->getRoomTabWidget();
  connect(m_stackedWidget, SIGNAL(currentChanged(int)),
          SLOT(onCurrentRoomChanged(int)));
  connect(roomTabWidget, SIGNAL(currentChanged(int)), m_stackedWidget,
          SLOT(setCurrentIndex(int)));

  /*-- タイトルバーにScene名を表示する --*/
  connect(TApp::instance()->getCurrentScene(), SIGNAL(nameSceneChanged()), this,
          SLOT(changeWindowTitle()));

  changeWindowTitle();

  // Connetto i comandi che sono in RoomTabWidget
  connect(roomTabWidget, SIGNAL(indexSwapped(int, int)),
          SLOT(onIndexSwapped(int, int)));
  connect(roomTabWidget, SIGNAL(insertNewTabRoom()), SLOT(insertNewRoom()));
  connect(roomTabWidget, SIGNAL(deleteTabRoom(int)), SLOT(deleteRoom(int)));
  connect(roomTabWidget, SIGNAL(renameTabRoom(int, const QString)),
          SLOT(renameRoom(int, const QString)));

  setCommandHandler("MI_Quit", this, &MainWindow::onQuit);
  setCommandHandler("MI_Undo", this, &MainWindow::onUndo);
  setCommandHandler("MI_Redo", this, &MainWindow::onRedo);
  setCommandHandler("MI_NewScene", this, &MainWindow::onNewScene);
  setCommandHandler("MI_LoadScene", this, &MainWindow::onLoadScene);
  setCommandHandler("MI_LoadSubSceneFile", this, &MainWindow::onLoadSubScene);
  setCommandHandler("MI_ResetRoomLayout", this, &MainWindow::resetRoomsLayout);
  setCommandHandler(MI_AutoFillToggle, this, &MainWindow::autofillToggle);

  /*-- Animate tool + mode switching shortcuts --*/
  setCommandHandler(MI_EditNextMode, this, &MainWindow::toggleEditNextMode);
  setCommandHandler(MI_EditPosition, this, &MainWindow::toggleEditPosition);
  setCommandHandler(MI_EditRotation, this, &MainWindow::toggleEditRotation);
  setCommandHandler(MI_EditScale, this, &MainWindow::toggleEditNextScale);
  setCommandHandler(MI_EditShear, this, &MainWindow::toggleEditNextShear);
  setCommandHandler(MI_EditCenter, this, &MainWindow::toggleEditNextCenter);
  setCommandHandler(MI_EditAll, this, &MainWindow::toggleEditNextAll);

  /*-- Selection tool + type switching shortcuts --*/
  setCommandHandler(MI_SelectionNextType, this,
                    &MainWindow::toggleSelectionNextType);
  setCommandHandler(MI_SelectionRectangular, this,
                    &MainWindow::toggleSelectionRectangular);
  setCommandHandler(MI_SelectionFreehand, this,
                    &MainWindow::toggleSelectionFreehand);
  setCommandHandler(MI_SelectionPolyline, this,
                    &MainWindow::toggleSelectionPolyline);

  /*-- Geometric tool + shape switching shortcuts --*/
  setCommandHandler(MI_GeometricNextShape, this,
                    &MainWindow::toggleGeometricNextShape);
  setCommandHandler(MI_GeometricRectangle, this,
                    &MainWindow::toggleGeometricRectangle);
  setCommandHandler(MI_GeometricCircle, this,
                    &MainWindow::toggleGeometricCircle);
  setCommandHandler(MI_GeometricEllipse, this,
                    &MainWindow::toggleGeometricEllipse);
  setCommandHandler(MI_GeometricLine, this, &MainWindow::toggleGeometricLine);
  setCommandHandler(MI_GeometricPolyline, this,
                    &MainWindow::toggleGeometricPolyline);
  setCommandHandler(MI_GeometricArc, this, &MainWindow::toggleGeometricArc);
  setCommandHandler(MI_GeometricMultiArc, this,
                    &MainWindow::toggleGeometricMultiArc);
  setCommandHandler(MI_GeometricPolygon, this,
                    &MainWindow::toggleGeometricPolygon);

  /*-- Type tool + style switching shortcuts --*/
  setCommandHandler(MI_TypeNextStyle, this, &MainWindow::toggleTypeNextStyle);
  setCommandHandler(MI_TypeOblique, this, &MainWindow::toggleTypeOblique);
  setCommandHandler(MI_TypeRegular, this, &MainWindow::toggleTypeRegular);
  setCommandHandler(MI_TypeBoldOblique, this,
                    &MainWindow::toggleTypeBoldOblique);
  setCommandHandler(MI_TypeBold, this, &MainWindow::toggleTypeBold);

  /*-- Fill tool + type/mode switching shortcuts --*/
  setCommandHandler(MI_FillNextType, this, &MainWindow::toggleFillNextType);
  setCommandHandler(MI_FillNormal, this, &MainWindow::toggleFillNormal);
  setCommandHandler(MI_FillRectangular, this,
                    &MainWindow::toggleFillRectangular);
  setCommandHandler(MI_FillFreehand, this, &MainWindow::toggleFillFreehand);
  setCommandHandler(MI_FillPolyline, this, &MainWindow::toggleFillPolyline);
  setCommandHandler(MI_FillNextMode, this, &MainWindow::toggleFillNextMode);
  setCommandHandler(MI_FillAreas, this, &MainWindow::toggleFillAreas);
  setCommandHandler(MI_FillLines, this, &MainWindow::toggleFillLines);
  setCommandHandler(MI_FillLinesAndAreas, this,
                    &MainWindow::toggleFillLinesAndAreas);

  /*-- Eraser tool + type switching shortcuts --*/
  setCommandHandler(MI_EraserNextType, this, &MainWindow::toggleEraserNextType);
  setCommandHandler(MI_EraserNormal, this, &MainWindow::toggleEraserNormal);
  setCommandHandler(MI_EraserRectangular, this,
                    &MainWindow::toggleEraserRectangular);
  setCommandHandler(MI_EraserFreehand, this, &MainWindow::toggleEraserFreehand);
  setCommandHandler(MI_EraserPolyline, this, &MainWindow::toggleEraserPolyline);
  setCommandHandler(MI_EraserSegment, this, &MainWindow::toggleEraserSegment);

  /*-- Tape tool + type/mode switching shortcuts --*/
  setCommandHandler(MI_TapeNextType, this, &MainWindow::toggleTapeNextType);
  setCommandHandler(MI_TapeNormal, this, &MainWindow::toggleTapeNormal);
  setCommandHandler(MI_TapeRectangular, this,
                    &MainWindow::toggleTapeRectangular);
  setCommandHandler(MI_TapeNextMode, this, &MainWindow::toggleTapeNextMode);
  setCommandHandler(MI_TapeEndpointToEndpoint, this,
                    &MainWindow::toggleTapeEndpointToEndpoint);
  setCommandHandler(MI_TapeEndpointToLine, this,
                    &MainWindow::toggleTapeEndpointToLine);
  setCommandHandler(MI_TapeLineToLine, this, &MainWindow::toggleTapeLineToLine);

  /*-- Style Picker tool + mode switching shortcuts --*/
  setCommandHandler(MI_PickStyleNextMode, this,
                    &MainWindow::togglePickStyleNextMode);
  setCommandHandler(MI_PickStyleAreas, this, &MainWindow::togglePickStyleAreas);
  setCommandHandler(MI_PickStyleLines, this, &MainWindow::togglePickStyleLines);
  setCommandHandler(MI_PickStyleLinesAndAreas, this,
                    &MainWindow::togglePickStyleLinesAndAreas);

  /*-- RGB Picker tool + type switching shortcuts --*/
  setCommandHandler(MI_RGBPickerNextType, this,
                    &MainWindow::toggleRGBPickerNextType);
  setCommandHandler(MI_RGBPickerNormal, this,
                    &MainWindow::toggleRGBPickerNormal);
  setCommandHandler(MI_RGBPickerRectangular, this,
                    &MainWindow::toggleRGBPickerRectangular);
  setCommandHandler(MI_RGBPickerFreehand, this,
                    &MainWindow::toggleRGBPickerFreehand);
  setCommandHandler(MI_RGBPickerPolyline, this,
                    &MainWindow::toggleRGBPickerPolyline);

  /*-- Skeleton tool + mode switching shortcuts --*/
  setCommandHandler(MI_SkeletonNextMode, this,
                    &MainWindow::ToggleSkeletonNextMode);
  setCommandHandler(MI_SkeletonBuildSkeleton, this,
                    &MainWindow::ToggleSkeletonBuildSkeleton);
  setCommandHandler(MI_SkeletonAnimate, this,
                    &MainWindow::ToggleSkeletonAnimate);
  setCommandHandler(MI_SkeletonInverseKinematics, this,
                    &MainWindow::ToggleSkeletonInverseKinematics);

  /*-- Plastic tool + mode switching shortcuts --*/
  setCommandHandler(MI_PlasticNextMode, this,
                    &MainWindow::TogglePlasticNextMode);
  setCommandHandler(MI_PlasticEditMesh, this,
                    &MainWindow::TogglePlasticEditMesh);
  setCommandHandler(MI_PlasticPaintRigid, this,
                    &MainWindow::TogglePlasticPaintRigid);
  setCommandHandler(MI_PlasticBuildSkeleton, this,
                    &MainWindow::TogglePlasticBuildSkeleton);
  setCommandHandler(MI_PlasticAnimate, this, &MainWindow::TogglePlasticAnimate);

  setCommandHandler(MI_About, this, &MainWindow::onAbout);
  setCommandHandler(MI_OpenOnlineManual, this, &MainWindow::onOpenOnlineManual);
  setCommandHandler(MI_OpenWhatsNew, this, &MainWindow::onOpenWhatsNew);
  // setCommandHandler(MI_OpenCommunityForum, this,
  //                  &MainWindow::onOpenCommunityForum);
  setCommandHandler(MI_OpenReportABug, this, &MainWindow::onOpenReportABug);

  setCommandHandler(MI_MaximizePanel, this, &MainWindow::maximizePanel);
  setCommandHandler(MI_FullScreenWindow, this, &MainWindow::fullScreenWindow);
  setCommandHandler("MI_NewVectorLevel", this,
                    &MainWindow::onNewVectorLevelButtonPressed);
  setCommandHandler("MI_NewToonzRasterLevel", this,
                    &MainWindow::onNewToonzRasterLevelButtonPressed);
  setCommandHandler("MI_NewRasterLevel", this,
                    &MainWindow::onNewRasterLevelButtonPressed);
  setCommandHandler(MI_ClearCacheFolder, this, &MainWindow::clearCacheFolder);
  // remove ffmpegCache if still exists from crashed exit
  QString ffmpegCachePath =
      ToonzFolder::getCacheRootFolder().getQString() + "//ffmpeg";
  if (TSystem::doesExistFileOrLevel(TFilePath(ffmpegCachePath))) {
    TSystem::rmDirTree(TFilePath(ffmpegCachePath));
  }
}

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

MainWindow::~MainWindow() {
  TEnv::saveAllEnvVariables();
  // cleanup ffmpeg cache
  QString ffmpegCachePath =
      ToonzFolder::getCacheRootFolder().getQString() + "//ffmpeg";
  if (TSystem::doesExistFileOrLevel(TFilePath(ffmpegCachePath))) {
    TSystem::rmDirTree(TFilePath(ffmpegCachePath));
  }
}

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

void MainWindow::changeWindowTitle() {
  TApp *app         = TApp::instance();
  ToonzScene *scene = app->getCurrentScene()->getScene();
  if (!scene) return;

  TProject *project   = scene->getProject();
  QString projectName = QString::fromStdString(project->getName().getName());

  QString sceneName = QString::fromStdWString(scene->getSceneName());

  if (sceneName.isEmpty()) sceneName = tr("Untitled");
  if (app->getCurrentScene()->getDirtyFlag()) sceneName += QString("*");

  /*--- レイアウトファイル名を頭に表示させる ---*/
  if (!m_layoutName.isEmpty()) sceneName.prepend(m_layoutName + " : ");

  QString name = sceneName + " [" + projectName + "] : " +
                 QString::fromStdString(TEnv::getApplicationFullName());

  setWindowTitle(name);
}

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

void MainWindow::changeWindowTitle(QString &str) { setWindowTitle(str); }

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

void MainWindow::startupFloatingPanels() {
  // Show all floating panels
  DockLayout *currDockLayout = getCurrentRoom()->dockLayout();
  int i;
  for (i = 0; i < currDockLayout->count(); ++i) {
    TPanel *currPanel = static_cast<TPanel *>(currDockLayout->widgetAt(i));
    if (currPanel->isFloating()) currPanel->show();
  }
}

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

Room *MainWindow::getRoom(int index) const {
  assert(index >= 0 && index < getRoomCount());
  return dynamic_cast<Room *>(m_stackedWidget->widget(index));
}

//-----------------------------------------------------------------------------
/*! Roomを名前から探す
 */
Room *MainWindow::getRoomByName(QString &roomName) {
  for (int i = 0; i < getRoomCount(); i++) {
    Room *room = dynamic_cast<Room *>(m_stackedWidget->widget(i));
    if (room) {
      if (room->getName() == roomName) return room;
    }
  }
  return 0;
}

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

int MainWindow::getRoomCount() const { return m_stackedWidget->count(); }

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

void MainWindow::refreshWriteSettings() { writeSettings(); }

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

void MainWindow::readSettings(const QString &argumentLayoutFileName) {
  QTabBar *roomTabWidget = m_topBar->getRoomTabWidget();

  /*-- Pageを追加すると同時にMenubarを追加する --*/
  StackedMenuBar *stackedMenuBar = m_topBar->getStackedMenuBar();

  std::vector<Room *> rooms;

  // leggo l'elenco dei layout
  std::vector<TFilePath> roomPaths;

  if (readRoomList(roomPaths, argumentLayoutFileName)) {
    if (!argumentLayoutFileName.isEmpty()) {
      /*--
       * タイトルバーに表示するレイアウト名を作る：_layoutがあればそこから省く。無ければ.txtのみ省く
       * --*/
      int pos = (argumentLayoutFileName.indexOf("_layout") == -1)
                    ? argumentLayoutFileName.indexOf(".txt")
                    : argumentLayoutFileName.indexOf("_layout");
      m_layoutName = argumentLayoutFileName.left(pos);
    }
  }

  int i;
  for (i = 0; i < (int)roomPaths.size(); i++) {
    TFilePath roomPath = roomPaths[i];
    if (TFileStatus(roomPath).doesExist()) {
      Room *room = new Room(this);
      m_panelStates.push_back(room->load(roomPath));
      m_stackedWidget->addWidget(room);
      roomTabWidget->addTab(room->getName());

      /*- ここでMenuBarファイルをロードする -*/
      std::string mbFileName = roomPath.getName() + "_menubar.xml";
      stackedMenuBar->loadAndAddMenubar(ToonzFolder::getRoomsFile(mbFileName));

      // room->setDockOptions(QMainWindow::DockOptions(
      //  (QMainWindow::AnimatedDocks | QMainWindow::AllowNestedDocks) &
      //  ~QMainWindow::AllowTabbedDocks));
      rooms.push_back(room);
    }
  }

  // Read the flipbook history
  FlipBookPool::instance()->load(ToonzFolder::getMyModuleDir() +
                                 TFilePath("fliphistory.ini"));

  if (rooms.empty()) {
    // PltEditRoom
    Room *pltEditRoom = createPltEditRoom();
    m_stackedWidget->addWidget(pltEditRoom);
    rooms.push_back(pltEditRoom);
    stackedMenuBar->createMenuBarByName(pltEditRoom->getName());

    // InknPaintRoom
    Room *inknPaintRoom = createInknPaintRoom();
    m_stackedWidget->addWidget(inknPaintRoom);
    rooms.push_back(inknPaintRoom);
    stackedMenuBar->createMenuBarByName(inknPaintRoom->getName());

    // XsheetRoom
    Room *xsheetRoom = createXsheetRoom();
    m_stackedWidget->addWidget(xsheetRoom);
    rooms.push_back(xsheetRoom);
    stackedMenuBar->createMenuBarByName(xsheetRoom->getName());

    // BatchesRoom
    Room *batchesRoom = createBatchesRoom();
    m_stackedWidget->addWidget(batchesRoom);
    rooms.push_back(batchesRoom);
    stackedMenuBar->createMenuBarByName(batchesRoom->getName());

    // BrowserRoom
    Room *browserRoom = createBrowserRoom();
    m_stackedWidget->addWidget(browserRoom);
    rooms.push_back(browserRoom);
    stackedMenuBar->createMenuBarByName(browserRoom->getName());
  }

  /*- If the layout files were loaded from template, then save them as private
   * ones -*/
  makePrivate(rooms);
  writeRoomList(rooms);

  // Imposto la stanza corrente
  TFilePath fp = ToonzFolder::getRoomsFile(currentRoomFileName);
  Tifstream is(fp);
  std::string currentRoomName;
  is >> currentRoomName;
  if (currentRoomName != "") {
    int count = m_stackedWidget->count();
    int index;
    for (index = 0; index < count; index++)
      if (getRoom(index)->getName().toStdString() == currentRoomName) break;
    if (index < count) {
      m_oldRoomIndex = index;
      roomTabWidget->setCurrentIndex(index);
      m_stackedWidget->setCurrentIndex(index);
    }
  }

  RecentFiles::instance()->loadRecentFiles();
}

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

void MainWindow::writeSettings() {
  std::vector<Room *> rooms;
  int i;

  // Flipbook history
  DockLayout *currRoomLayout(getCurrentRoom()->dockLayout());
  for (i = 0; i < currRoomLayout->count(); ++i) {
    // Remove all floating flipbooks from current room and return them into
    // the flipbook pool.
    TPanel *panel = static_cast<TPanel *>(currRoomLayout->itemAt(i)->widget());
    if (panel->isFloating() && panel->getPanelType() == "FlipBook") {
      currRoomLayout->removeWidget(panel);
      FlipBook *flipbook = static_cast<FlipBook *>(panel->widget());
      FlipBookPool::instance()->push(flipbook);
      --i;
    }
  }

  FlipBookPool::instance()->save();

  // Room layouts
  for (i = 0; i < m_stackedWidget->count(); i++) {
    Room *room = getRoom(i);
    rooms.push_back(room);
    room->save();
  }
  if (m_currentRoomsChoice == Preferences::instance()->getCurrentRoomChoice()) {
    writeRoomList(rooms);
  }

  // Current room settings
  Tofstream os(ToonzFolder::getMyRoomsDir() + currentRoomFileName);
  os << getCurrentRoom()->getName().toStdString();

  // Main window settings
  TFilePath fp = ToonzFolder::getMyModuleDir() + TFilePath("mainwindow.ini");
  QSettings settings(toQString(fp), QSettings::IniFormat);

  settings.setValue("MainWindowGeometry", saveGeometry());
}

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

Room *MainWindow::createPltEditRoom() {
  Room *pltEditRoom = new Room(this);
  pltEditRoom->setName("PltEdit");
  pltEditRoom->setObjectName("PltEditRoom");

  m_topBar->getRoomTabWidget()->addTab(tr("PltEdit"));

  DockLayout *layout = pltEditRoom->dockLayout();

  // Viewer
  TPanel *viewer = TPanelFactory::createPanel(pltEditRoom, "ComboViewer");
  if (viewer) {
    pltEditRoom->addDockWidget(viewer);
    layout->dockItem(viewer);

    SceneViewerPanel *svp = qobject_cast<SceneViewerPanel *>(viewer);
    // if (svp) svp->setVisiblePartsFlag(CVPARTS_TOOLBAR | CVPARTS_TOOLOPTIONS);
  }

  // Palette
  TPanel *palettePane = TPanelFactory::createPanel(pltEditRoom, "LevelPalette");
  if (palettePane) {
    pltEditRoom->addDockWidget(palettePane);
    layout->dockItem(palettePane, viewer, Region::bottom);
  }

  // StyleEditor
  TPanel *styleEditorPane =
      TPanelFactory::createPanel(pltEditRoom, "StyleEditor");
  if (styleEditorPane) {
    pltEditRoom->addDockWidget(styleEditorPane);
    layout->dockItem(styleEditorPane, viewer, Region::left);
  }

  // Xsheet
  TPanel *xsheetPane = TPanelFactory::createPanel(pltEditRoom, "Xsheet");
  if (xsheetPane) {
    pltEditRoom->addDockWidget(xsheetPane);
    layout->dockItem(xsheetPane, palettePane, Region::left);
  }

  // Studio Palette
  TPanel *studioPaletteViewer =
      TPanelFactory::createPanel(pltEditRoom, "StudioPalette");
  if (studioPaletteViewer) {
    pltEditRoom->addDockWidget(studioPaletteViewer);
    layout->dockItem(studioPaletteViewer, xsheetPane, Region::left);
  }

  return pltEditRoom;
}

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

Room *MainWindow::createInknPaintRoom() {
  Room *inknPaintRoom = new Room(this);
  inknPaintRoom->setName("InknPaint");
  inknPaintRoom->setObjectName("InknPaintRoom");

  m_topBar->getRoomTabWidget()->addTab(tr("InknPaint"));

  DockLayout *layout = inknPaintRoom->dockLayout();

  // Viewer
  TPanel *viewer = TPanelFactory::createPanel(inknPaintRoom, "ComboViewer");
  if (viewer) {
    inknPaintRoom->addDockWidget(viewer);
    layout->dockItem(viewer);
  }

  // Palette
  TPanel *palettePane =
      TPanelFactory::createPanel(inknPaintRoom, "LevelPalette");
  if (palettePane) {
    inknPaintRoom->addDockWidget(palettePane);
    layout->dockItem(palettePane, viewer, Region::bottom);
  }

  // Filmstrip
  TPanel *filmStripPane =
      TPanelFactory::createPanel(inknPaintRoom, "FilmStrip");
  if (filmStripPane) {
    inknPaintRoom->addDockWidget(filmStripPane);
    layout->dockItem(filmStripPane, viewer, Region::right);
  }

  return inknPaintRoom;
}

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

Room *MainWindow::createXsheetRoom() {
  Room *xsheetRoom = new Room(this);
  xsheetRoom->setName("Xsheet");
  xsheetRoom->setObjectName("XsheetRoom");

  m_topBar->getRoomTabWidget()->addTab(tr("Xsheet"));

  DockLayout *layout = xsheetRoom->dockLayout();

  // Xsheet
  TPanel *xsheetPane = TPanelFactory::createPanel(xsheetRoom, "Xsheet");
  if (xsheetPane) {
    xsheetRoom->addDockWidget(xsheetPane);
    layout->dockItem(xsheetPane);
  }

  // FunctionEditor
  TPanel *functionEditorPane =
      TPanelFactory::createPanel(xsheetRoom, "FunctionEditor");
  if (functionEditorPane) {
    xsheetRoom->addDockWidget(functionEditorPane);
    layout->dockItem(functionEditorPane, xsheetPane, Region::right);
  }

  return xsheetRoom;
}

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

Room *MainWindow::createBatchesRoom() {
  Room *batchesRoom = new Room(this);
  batchesRoom->setName("Batches");
  batchesRoom->setObjectName("BatchesRoom");

  m_topBar->getRoomTabWidget()->addTab("Batches");

  DockLayout *layout = batchesRoom->dockLayout();

  // Tasks
  TPanel *tasksViewer = TPanelFactory::createPanel(batchesRoom, "Tasks");
  if (tasksViewer) {
    batchesRoom->addDockWidget(tasksViewer);
    layout->dockItem(tasksViewer);
  }

  // BatchServers
  TPanel *batchServersViewer =
      TPanelFactory::createPanel(batchesRoom, "BatchServers");
  if (batchServersViewer) {
    batchesRoom->addDockWidget(batchServersViewer);
    layout->dockItem(batchServersViewer, tasksViewer, Region::right);
  }

  return batchesRoom;
}

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

Room *MainWindow::createBrowserRoom() {
  Room *browserRoom = new Room(this);
  browserRoom->setName("Browser");
  browserRoom->setObjectName("BrowserRoom");

  m_topBar->getRoomTabWidget()->addTab("Browser");

  DockLayout *layout = browserRoom->dockLayout();

  // Browser
  TPanel *browserPane = TPanelFactory::createPanel(browserRoom, "Browser");
  if (browserPane) {
    browserRoom->addDockWidget(browserPane);
    layout->dockItem(browserPane);
  }

  // Scene Cast
  TPanel *sceneCastPanel = TPanelFactory::createPanel(browserRoom, "SceneCast");
  if (sceneCastPanel) {
    browserRoom->addDockWidget(sceneCastPanel);
    layout->dockItem(sceneCastPanel, browserPane, Region::bottom);
  }

  return browserRoom;
}

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

Room *MainWindow::getCurrentRoom() const {
  return getRoom(m_stackedWidget->currentIndex());
}

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

void MainWindow::onUndo() {
  bool ret = TUndoManager::manager()->undo();
  if (!ret) DVGui::error(QObject::tr("No more Undo operations available."));
}

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

void MainWindow::onRedo() {
  bool ret = TUndoManager::manager()->redo();
  if (!ret) DVGui::error(QObject::tr("No more Redo operations available."));
}

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

void MainWindow::onNewScene() {
  IoCmd::newScene();
  CommandManager *cm = CommandManager::instance();
  cm->setChecked(MI_ShiftTrace, false);
  cm->setChecked(MI_EditShift, false);
  cm->setChecked(MI_NoShift, false);
  cm->setChecked(MI_VectorGuidedDrawing, false);
}

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

void MainWindow::onLoadScene() { IoCmd::loadScene(); }

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

void MainWindow::onLoadSubScene() { IoCmd::loadSubScene(); }
//-----------------------------------------------------------------------------

void MainWindow::onUpgradeTabPro() {}

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

void MainWindow::onAbout() { m_aboutPopup->exec(); }

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

void MainWindow::onOpenOnlineManual() {
  QDesktopServices::openUrl(QUrl(tr("http://tahoma2d.readthedocs.io")));
}

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

void MainWindow::onOpenWhatsNew() {
  QDesktopServices::openUrl(
      QUrl(tr("https://github.com/turtletooth/tahoma2d/releases/latest")));
}

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

// void MainWindow::onOpenCommunityForum() {
//  QDesktopServices::openUrl(
//      QUrl(tr("https://groups.google.com/forum/#!forum/opentoonz_en")));
//}

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

void MainWindow::onOpenReportABug() {
  QString str = QString(
      tr("To report a bug, click on the button below to open a web browser "
         "window for Tahoma2D's Issues page on https://github.com.  Click on "
         "the 'New issue' button and fill out the form."));

  std::vector<QString> buttons = {QObject::tr("Report a Bug"),
                                  QObject::tr("Close")};
  int ret = DVGui::MsgBox(DVGui::INFORMATION, str, buttons, 1);
  if (ret == 1)
    QDesktopServices::openUrl(
        QUrl("https://github.com/turtletooth/tahoma2d/issues"));
}
//-----------------------------------------------------------------------------

void MainWindow::autofillToggle() {
  TPaletteHandle *h = TApp::instance()->getCurrentPalette();
  h->toggleAutopaint();
}

void MainWindow::resetRoomsLayout() {
  if (!m_saveSettingsOnQuit) return;

  m_saveSettingsOnQuit = false;

  TFilePath layoutDir = ToonzFolder::getMyRoomsDir();
  if (layoutDir != TFilePath()) {
    // TSystem::deleteFile(layoutDir);
    TSystem::rmDirTree(layoutDir);
  }
  /*if (layoutDir != TFilePath()) {
          try {
                  TFilePathSet fpset;
                  TSystem::readDirectory(fpset, layoutDir, true, false);
                  for (auto const& path : fpset) {
                          QString fn = toQString(path.withoutParentDir());
                          if (fn.startsWith("room") || fn.startsWith("popups"))
  {
                                  TSystem::deleteFile(path);
                          }
                  }
          } catch (...) {
          }
  }*/

  DVGui::MsgBoxInPopup(
      DVGui::INFORMATION,
      QObject::tr("The rooms will be reset the next time you run Tahoma2D."));
}

void MainWindow::maximizePanel() {
  DockLayout *currDockLayout = getCurrentRoom()->dockLayout();
  if (currDockLayout->getMaximized() &&
      currDockLayout->getMaximized()->isMaximized()) {
    currDockLayout->getMaximized()->maximizeDock();  // release maximization
    return;
  }

  QPoint p            = mapFromGlobal(QCursor::pos());
  QWidget *currWidget = currDockLayout->containerOf(p);
  DockWidget *currW   = dynamic_cast<DockWidget *>(currWidget);
  if (currW) currW->maximizeDock();
}

void MainWindow::fullScreenWindow() {
  if (isFullScreen())
    setWindowState(Qt::WindowMaximized);
  else
    setWindowState(Qt::WindowFullScreen);
}

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

void MainWindow::onCurrentRoomChanged(int newRoomIndex) {
  Room *oldRoom            = getRoom(m_oldRoomIndex);
  Room *newRoom            = getRoom(newRoomIndex);
  QList<TPanel *> paneList = oldRoom->findChildren<TPanel *>();

  // Change the parent of all the floating dockWidgets
  for (int i = 0; i < paneList.size(); i++) {
    TPanel *pane = paneList.at(i);
    if (pane->isFloating() && !pane->isHidden()) {
      QRect oldGeometry = pane->geometry();
      // Just setting the new parent is not enough for the new layout manager.
      // Must be removed from the old and added to the new.
      oldRoom->removeDockWidget(pane);
      newRoom->addDockWidget(pane);
      // pane->setParent(newRoom);

      // Some flags are lost when the parent changes.
      pane->setFloating(true);
      pane->setGeometry(oldGeometry);
      pane->show();
    }
  }
  m_oldRoomIndex = newRoomIndex;
  TSelection::setCurrent(0);
}

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

void MainWindow::onIndexSwapped(int firstIndex, int secondIndex) {
  assert(firstIndex >= 0 && secondIndex >= 0);
  Room *mainWindow = getRoom(firstIndex);
  m_stackedWidget->removeWidget(mainWindow);
  m_stackedWidget->insertWidget(secondIndex, mainWindow);
}

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

void MainWindow::insertNewRoom() {
  Room *room = new Room(this);
  room->setName("room");
  if (m_saveSettingsOnQuit) makePrivate(room);
  m_stackedWidget->insertWidget(0, room);

  // Finally, old room index is increased by 1
  m_oldRoomIndex++;
}

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

void MainWindow::deleteRoom(int index) {
  Room *room = getRoom(index);

  TFilePath fp = room->getPath();
  try {
    TSystem::deleteFile(fp);
  } catch (...) {
    DVGui::error(tr("Cannot delete") + toQString(fp));
    // Se non ho rimosso la stanza devo rimettere il tab!!
    m_topBar->getRoomTabWidget()->insertTab(index, room->getName());
    return;
  }

  /*- delete menubar settings file as well -*/
  std::string mbFileName = fp.getName() + "_menubar.xml";
  TFilePath mbFp         = fp.getParentDir() + mbFileName;
  TSystem::deleteFile(mbFp);

  // The old room index must be updated if index < of it
  if (index < m_oldRoomIndex) m_oldRoomIndex--;

  m_stackedWidget->removeWidget(room);
  delete room;
}

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

void MainWindow::renameRoom(int index, const QString name) {
  Room *room = getRoom(index);
  room->setName(name);
  if (m_saveSettingsOnQuit) room->save();
}

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

void MainWindow::onMenuCheckboxChanged() {
  QAction *action = qobject_cast<QAction *>(sender());

  int isChecked = action->isChecked();

  CommandManager *cm = CommandManager::instance();

  if (cm->getAction(MI_ViewCamera) == action)
    ViewCameraToggleAction = isChecked;
  else if (cm->getAction(MI_ViewTable) == action)
    ViewTableToggleAction = isChecked;
  else if (cm->getAction(MI_ToggleEditInPlace) == action)
    EditInPlaceToggleAction = isChecked;
  else if (cm->getAction(MI_ViewBBox) == action)
    ViewBBoxToggleAction = isChecked;
  else if (cm->getAction(MI_FieldGuide) == action)
    FieldGuideToggleAction = isChecked;
  else if (cm->getAction(MI_RasterizePli) == action) {
    if (!QGLPixelBuffer::hasOpenGLPbuffers()) isChecked = 0;
    RasterizePliToggleAction                            = isChecked;
  } else if (cm->getAction(MI_SafeArea) == action)
    SafeAreaToggleAction = isChecked;
  else if (cm->getAction(MI_ViewColorcard) == action)
    ViewColorcardToggleAction = isChecked;
  else if (cm->getAction(MI_ViewGuide) == action)
    ViewGuideToggleAction = isChecked;
  else if (cm->getAction(MI_ViewRuler) == action)
    ViewRulerToggleAction = isChecked;
  else if (cm->getAction(MI_TCheck) == action)
    TCheckToggleAction = isChecked;
  // else if (cm->getAction(MI_DockingCheck) == action)
  //  DockingCheckToggleAction = isChecked;
  else if (cm->getAction(MI_ICheck) == action)
    ICheckToggleAction = isChecked;
  else if (cm->getAction(MI_Ink1Check) == action)
    Ink1CheckToggleAction = isChecked;
  else if (cm->getAction(MI_PCheck) == action)
    PCheckToggleAction = isChecked;
  else if (cm->getAction(MI_BCheck) == action)
    BCheckToggleAction = isChecked;
  else if (cm->getAction(MI_GCheck) == action)
    GCheckToggleAction = isChecked;
  else if (cm->getAction(MI_ACheck) == action)
    ACheckToggleAction = isChecked;
  else if (cm->getAction(MI_IOnly) == action)
    IOnlyToggleAction = isChecked;
  else if (cm->getAction(MI_Link) == action)
    LinkToggleAction = isChecked;
  else if (cm->getAction(MI_ShiftTrace) == action)
    ShiftTraceToggleAction = isChecked;
  else if (cm->getAction(MI_EditShift) == action)
    EditShiftToggleAction = isChecked;
  else if (cm->getAction(MI_NoShift) == action)
    NoShiftToggleAction = isChecked;
  else if (cm->getAction(MI_TouchGestureControl) == action)
    TouchGestureControl = isChecked;
}

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

void MainWindow::showEvent(QShowEvent *event) {
  //  QTimer *nt = new QTimer(this);
  //
  //  nt->setSingleShot(true);
  //  nt->setInterval(100);
  //
  //  connect(nt, &QTimer::timeout, [=]() {
  //#ifdef WIN32
  //    if (!m_shownOnce && windowState() == Qt::WindowMaximized) {
  //      int roomsSize = m_panelStates.size();
  //      for (auto iter : m_panelStates) {
  //        iter.first->restoreState(iter.second);
  //      }
  //      m_shownOnce = true;
  //    }
  //#endif
  //  });
  //  nt->connect(nt, SIGNAL(timeout()), SLOT(deleteLater()));
  //
  //  nt->start();

  getCurrentRoom()->layout()->setEnabled(true);  // See main function in
                                                 // main.cpp
  if (Preferences::instance()->isStartupPopupEnabled() &&
      !m_startupPopupShown) {
    StartupPopup *startupPopup = new StartupPopup();
    startupPopup->show();
    m_startupPopupShown = true;
  }
}
extern const char *applicationName;
extern const char *applicationVersion;
//-----------------------------------------------------------------------------
void MainWindow::checkForUpdates() {
  // Since there is only a single version of Tahoma, we can do a simple check
  // against a string
  QString updateUrl("https://tahoma2d.org/files/tahoma-version.txt");

  m_updateChecker = new UpdateChecker(updateUrl);
  connect(m_updateChecker, SIGNAL(done(bool)), this,
          SLOT(onUpdateCheckerDone(bool)));
}
//-----------------------------------------------------------------------------

void MainWindow::onUpdateCheckerDone(bool error) {
  if (error) {
    // Get the last update date
    return;
  }

  int const software_version =
      get_version_code_from(TEnv::getApplicationVersion());
  int const latest_version =
      get_version_code_from(m_updateChecker->getLatestVersion().toStdString());
  if (software_version < latest_version) {
    QStringList buttons;
    buttons.push_back(QObject::tr("Visit Web Site"));
    buttons.push_back(QObject::tr("Cancel"));
    DVGui::MessageAndCheckboxDialog *dialog = DVGui::createMsgandCheckbox(
        DVGui::INFORMATION,
        QObject::tr("An update is available for this software.\nVisit the Web "
                    "site for more information."),
        QObject::tr("Check for the latest version on launch."), buttons, 0,
        Qt::Checked);
    int ret = dialog->exec();
    if (dialog->getChecked() == Qt::Unchecked)
      Preferences::instance()->setValue(latestVersionCheckEnabled, false);
    dialog->deleteLater();
    if (ret == 1) {
      // Write the new last date to file
      QDesktopServices::openUrl(QObject::tr("https://opentoonz.github.io/e/"));
    }
  }

  disconnect(m_updateChecker);
  m_updateChecker->deleteLater();
}
//-----------------------------------------------------------------------------

void MainWindow::closeEvent(QCloseEvent *event) {
  // il riferimento alla variabile booleana doExit viene passato a tutti gli
  // slot che catturano l'emissione
  // del segnale. Impostando a false tale variabile, l'applicazione non viene
  // chiusa!
  bool doExit = true;
  emit exit(doExit);
  if (!doExit) {
    event->ignore();
    return;
  }

  if (!IoCmd::saveSceneIfNeeded(QApplication::tr("Quit"))) {
    event->ignore();
    return;
  }

  // sto facendo quit. interrompo (il prima possibile) le threads
  IconGenerator::instance()->clearRequests();

  if (m_saveSettingsOnQuit) writeSettings();

  // svuoto la directory di output
  TFilePath outputsDir = TEnv::getStuffDir() + "outputs";
  TFilePathSet fps;
  if (TFileStatus(outputsDir).isDirectory()) {
    TSystem::readDirectory(fps, outputsDir);
    TFilePathSet::iterator fpsIt;
    for (fpsIt = fps.begin(); fpsIt != fps.end(); ++fpsIt) {
      TFilePath fp = *fpsIt;
      if (TSystem::doesExistFileOrLevel(fp)) {
        try {
          TSystem::removeFileOrLevel(fp);
        } catch (...) {
        }
      }
    }
  }

  TImageCache::instance()->clear(true);

  event->accept();
  TThread::shutdown();
  qApp->quit();
}

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

QAction *MainWindow::createAction(const char *id, const QString &name,
                                  const QString &defaultShortcut,
                                  QString newStatusTip, CommandType type) {
  QAction *action = new DVAction(name, this);
  action->setIconVisibleInMenu(false);  // Hide icons
  addAction(action);
#ifdef MACOSX
  // To prevent the wrong menu items (due to MacOS menu naming conventions),
  // from
  // taking Preferences, Quit, or About roles (sometimes happens unexpectedly in
  // translations) - all menu items should have "NoRole"
  //  except for Preferences, Quit, and About
  if (strcmp(id, MI_Preferences) == 0)
    action->setMenuRole(QAction::PreferencesRole);
  else if (strcmp(id, MI_Quit) == 0)
    action->setMenuRole(QAction::QuitRole);
  else if (strcmp(id, MI_About) == 0)
    action->setMenuRole(QAction::AboutRole);
  else
    action->setMenuRole(QAction::NoRole);
#endif
  CommandManager::instance()->define(id, type, defaultShortcut.toStdString(),
                                     action);
  action->setStatusTip(newStatusTip);
  return action;
}

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

QAction *MainWindow::createRightClickMenuAction(const char *id,
                                                const QString &name,
                                                const QString &defaultShortcut,
                                                QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip,
                      RightClickMenuCommandType);
}

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

QAction *MainWindow::createMenuFileAction(const char *id, const QString &name,
                                          const QString &defaultShortcut,
                                          QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip,
                      MenuFileCommandType);
}

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

QAction *MainWindow::createMenuEditAction(const char *id, const QString &name,
                                          const QString &defaultShortcut,
                                          QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip,
                      MenuEditCommandType);
}

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

QAction *MainWindow::createMenuScanCleanupAction(const char *id,
                                                 const QString &name,
                                                 const QString &defaultShortcut,
                                                 QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip,
                      MenuScanCleanupCommandType);
}

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

QAction *MainWindow::createMenuLevelAction(const char *id, const QString &name,
                                           const QString &defaultShortcut,
                                           QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip,
                      MenuLevelCommandType);
}

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

QAction *MainWindow::createMenuXsheetAction(const char *id, const QString &name,
                                            const QString &defaultShortcut,
                                            QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip,
                      MenuXsheetCommandType);
}

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

QAction *MainWindow::createMenuCellsAction(const char *id, const QString &name,
                                           const QString &defaultShortcut,
                                           QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip,
                      MenuCellsCommandType);
}

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

QAction *MainWindow::createMenuViewAction(const char *id, const QString &name,
                                          const QString &defaultShortcut,
                                          QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip,
                      MenuViewCommandType);
}

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

QAction *MainWindow::createMenuWindowsAction(const char *id,
                                             const QString &name,
                                             const QString &defaultShortcut,
                                             QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip,
                      MenuWindowsCommandType);
}

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

QAction *MainWindow::createMenuPlayAction(const char *id, const QString &name,
                                          const QString &defaultShortcut,
                                          QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip,
                      MenuPlayCommandType);
}

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

QAction *MainWindow::createMenuRenderAction(const char *id, const QString &name,
                                            const QString &defaultShortcut,
                                            QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip,
                      MenuRenderCommandType);
}

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

QAction *MainWindow::createMenuHelpAction(const char *id, const QString &name,
                                          const QString &defaultShortcut,
                                          QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip,
                      MenuHelpCommandType);
}

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

QAction *MainWindow::createRGBAAction(const char *id, const QString &name,
                                      const QString &defaultShortcut,
                                      QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip, RGBACommandType);
}

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

QAction *MainWindow::createFillAction(const char *id, const QString &name,
                                      const QString &defaultShortcut,
                                      QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip, FillCommandType);
}
//-----------------------------------------------------------------------------

QAction *MainWindow::createMenuAction(const char *id, const QString &name,
                                      QList<QString> list,
                                      QString newStatusTip) {
  QMenu *menu     = new DVMenuAction(name, this, list);
  QAction *action = menu->menuAction();
  action->setStatusTip(newStatusTip);
  CommandManager::instance()->define(id, MenuCommandType, "", action);
  return action;
}

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

QAction *MainWindow::createViewerAction(const char *id, const QString &name,
                                        const QString &defaultShortcut,
                                        QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip, ZoomCommandType);
}

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

QAction *MainWindow::createVisualizationButtonAction(const char *id,
                                                     const QString &name,
                                                     QString newStatusTip) {
  return createAction(id, name, "", newStatusTip,
                      VisualizationButtonCommandType);
}

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

QAction *MainWindow::createMiscAction(const char *id, const QString &name,
                                      const char *defaultShortcut,
                                      QString newStatusTip) {
  QAction *action = new DVAction(name, this);
  action->setStatusTip(newStatusTip);
  CommandManager::instance()->define(id, MiscCommandType, defaultShortcut,
                                     action);
  return action;
}

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

QAction *MainWindow::createToolOptionsAction(const char *id,
                                             const QString &name,
                                             const QString &defaultShortcut,
                                             QString newStatusTip) {
  QAction *action = new DVAction(name, this);
  addAction(action);
  action->setStatusTip(newStatusTip);
  CommandManager::instance()->define(id, ToolModifierCommandType,
                                     defaultShortcut.toStdString(), action);
  return action;
}

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

QAction *MainWindow::createStopMotionAction(const char *id, const QString &name,
                                            const QString &defaultShortcut,
                                            QString newStatusTip) {
  return createAction(id, name, defaultShortcut, newStatusTip,
                      StopMotionCommandType);
}

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

QAction *MainWindow::createToggle(const char *id, const QString &name,
                                  const QString &defaultShortcut,
                                  bool startStatus, CommandType type,
                                  QString newStatusTip) {
  QAction *action = createAction(id, name, defaultShortcut, newStatusTip, type);
  action->setCheckable(true);
  if (startStatus == true) action->trigger();
  bool ret =
      connect(action, SIGNAL(changed()), this, SLOT(onMenuCheckboxChanged()));
  assert(ret);
  return action;
}

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

QAction *MainWindow::createToolAction(const char *id, const char *iconName,
                                      const QString &name,
                                      const QString &defaultShortcut,
                                      QString newStatusTip) {
  QIcon icon      = createQIcon(iconName);
  QAction *action = new DVAction(icon, name, this);
  action->setCheckable(true);
  action->setActionGroup(m_toolsActionGroup);
  action->setIconVisibleInMenu(true);
  action->setStatusTip(newStatusTip);

  // When the viewer is maximized (not fullscreen) the toolbar is hided and the
  // action are disabled,
  // so the tool shortcuts don't work.
  // Adding tool actions to the main window solve this problem!
  addAction(action);

  CommandManager::instance()->define(id, ToolCommandType,
                                     defaultShortcut.toStdString(), action);
  return action;
}

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

void MainWindow::defineActions() {
  QString separator = "                    ";
  QAction *menuAct  = createMenuFileAction(MI_NewScene, tr("&New Scene"),
                                          "Ctrl+N", tr("Create a new scene."));
  menuAct->setIcon(createQIcon("new_scene"));
  menuAct = createMenuFileAction(MI_LoadScene, tr("&Load Scene..."), "Ctrl+L",
                                 tr("Load an existing scene."));
  menuAct->setIcon(createQIcon("load_scene"));
  menuAct =
      createMenuFileAction(MI_SaveScene, tr("&Save Scene"), "Ctrl+Shift+S",
                           tr("Save ONLY the scene.") + separator +
                               tr("This does NOT save levels or images."));
  menuAct->setIcon(createQIcon("save_scene"));
  menuAct = createMenuFileAction(
      MI_SaveSceneAs, tr("&Save Scene As..."), "",
      tr("Save ONLY the scene with a new name.") + separator +
          tr("This does NOT save levels or images."));
  menuAct->setIcon(createQIcon("save_scene_as"));
  menuAct = createMenuFileAction(
      MI_SaveAll, tr("&Save All"), "Ctrl+S",
      tr("Save the scene info and the levels and images.") + separator +
          tr("Saves everything."));
  menuAct->setIconText(tr("Save All"));
  menuAct->setIcon(createQIcon("saveall"));
  menuAct = createMenuFileAction(
      MI_RevertScene, tr("&Revert Scene"), "",
      tr("Revert the scene to its previously saved state."));
  menuAct->setIcon(createQIcon("revert_scene"));

  QAction *act = CommandManager::instance()->getAction(MI_RevertScene);
  if (act) act->setEnabled(false);
  QList<QString> files;
  menuAct = createMenuFileAction(
      MI_LoadFolder, tr("&Load Folder..."), "",
      tr("Load the contents of a folder into the current scene."));
  menuAct->setIcon(createQIcon("load_folder"));
  createMenuFileAction(
      MI_LoadSubSceneFile, tr("&Load As Sub-xsheet..."), "",
      tr("Load an existing scene into the current scene as a sub-xsheet"));
  createMenuAction(MI_OpenRecentScene, tr("&Open Recent Scene File"), files,
                   tr("Load a recently used scene."));
  createMenuAction(MI_OpenRecentLevel, tr("&Open Recent Level File"), files,
                   tr("Load a recently used level."));
  createMenuFileAction(MI_ClearRecentScene, tr("&Clear Recent Scene File List"),
                       "", tr("Remove everything from the recent scene list."));
  createMenuFileAction(MI_ClearRecentLevel, tr("&Clear Recent level File List"),
                       "", tr("Remove everything from the recent level list."));

  menuAct = createMenuLevelAction(MI_NewLevel, tr("&New Level..."), "Alt+N",
                                  tr("Create a new drawing layer."));
  menuAct->setIcon(createQIcon("new_document"));
  menuAct =
      createMenuLevelAction(MI_NewVectorLevel, tr("&New Vector Level"), "",
                            tr("Create a new vector level.") + separator +
                                tr("Vectors can be manipulated easily and have "
                                   "some extra tools and features."));
  menuAct->setIcon(createQIcon("new_vector_level"));
  menuAct = createMenuLevelAction(
      MI_NewToonzRasterLevel, tr("&New Smart Raster Level"), "",
      tr("Create a new Smart Raster level.") + separator +
          tr("Smart Raster levels are color mapped making the colors easier to "
             "adjust at any time."));
  menuAct->setIcon(createQIcon("new_toonz_raster_level"));
  menuAct = createMenuLevelAction(
      MI_NewRasterLevel, tr("&New Raster Level"), "",
      tr("Create a new raster level") + separator +
          tr("Raster levels are traditonal drawing levels") + separator +
          tr("Imported images will be imported as raster levels."));
  menuAct->setIcon(createQIcon("new_raster_level"));
  menuAct = createMenuLevelAction(MI_LoadLevel, tr("&Load Level..."), "",
                                  tr("Load an existing level."));
  menuAct->setIcon(createQIcon("load_level"));
  menuAct = createMenuLevelAction(MI_SaveLevel, tr("&Save Level"), "",
                                  tr("Save the current level.") + separator +
                                      tr("This does not save the scene info."));
  menuAct->setIcon(createQIcon("save_level"));
  menuAct = createMenuLevelAction(MI_SaveAllLevels, tr("&Save All Levels"), "",
                                  tr("Save all levels loaded into the scene.") +
                                      separator +
                                      tr("This does not save the scene info."));
  menuAct->setIcon(createQIcon("save_all_levels"));
  menuAct = createMenuLevelAction(
      MI_SaveLevelAs, tr("&Save Level As..."), "",
      tr("Save the current level as a different name.") + separator +
          tr("This does not save the scene info."));
  menuAct->setIcon(createQIcon("save_level_as"));
  menuAct = createMenuLevelAction(
      MI_ExportLevel, tr("&Export Level..."), "",
      tr("Export the current level as an image sequence."));
  menuAct->setIcon(createQIcon("export_level"));
  menuAct = createMenuFileAction(
      MI_ConvertFileWithInput, tr("&Convert File..."), "",
      tr("Convert an existing file or image sequnce to another format."));
  menuAct->setIcon(createQIcon("convert"));
  createRightClickMenuAction(
      MI_SavePaletteAs, tr("&Save Palette As..."), "",
      tr("Save the current style palette as a separate file with a new name."));
  createRightClickMenuAction(
      MI_OverwritePalette, tr("&Save Palette"), "",
      tr("Save the current style palette as a separate file."));
  createRightClickMenuAction(MI_SaveAsDefaultPalette,
                             tr("&Save As Default Palette"), "",
                             tr("Save the current style palette as the default "
                                "for new levels of the current level type."));
  menuAct = createMenuFileAction(MI_LoadColorModel, tr("&Load Color Model..."),
                                 "", tr("Load an image as a color guide."));
  menuAct->setIcon(createQIcon("load_colormodel"));
  createMenuFileAction(MI_ImportMagpieFile,
                       tr("&Import Toonz Lip Sync File..."), "",
                       tr("Import a lip sync file to be applied to a level."));
  createMenuFileAction(MI_NewProject, tr("&New Project..."), "",
                       tr("Create a new project.") + separator +
                           tr("A project is a container for a collection of "
                              "related scenes and drawings."));
  createMenuFileAction(MI_ProjectSettings, tr("&Switch Project"), "");
  createMenuFileAction(MI_SaveDefaultSettings, tr("&Save Default Settings"), "",
                       tr("Use the current scene's settings as a template for "
                          "all new scenes in the current project."));
  menuAct = createMenuRenderAction(
      MI_OutputSettings, tr("&Output Settings..."), "Ctrl+O",
      tr("Control the output settings for the current scene.") + separator +
          tr("You can render from the output settings window also."));
  menuAct->setIcon(createQIcon("output_settings"));
  menuAct = createMenuRenderAction(
      MI_PreviewSettings, tr("&Preview Settings..."), "",
      tr("Control the settings that will be used to preview the scene."));
  menuAct->setIcon(createQIcon("preview_settings"));
  menuAct = createMenuRenderAction(
      MI_Render, tr("&Save and Render"), "Ctrl+Shift+R",
      tr("Saves the current scene and renders according to the settings and "
         "location set in Output Settings."));
  menuAct->setIcon(createQIcon("render"));
  menuAct = createMenuRenderAction(
      MI_FastRender, tr("&Fast Render to MP4"), "Alt+R",
      tr("Exports an MP4 file to the location specified in the preferences.") +
          separator + tr("This is quicker than going into the Output Settings "
                         "and setting up an MP4 render."));
  menuAct->setIcon(createQIcon("fast_render_mp4"));
  menuAct = createMenuRenderAction(
      MI_Preview, tr("&Preview"), "Ctrl+R",
      tr("Previews the current scene with all effects applied."));
  menuAct->setIcon(createQIcon("preview"));
  createMenuFileAction(
      MI_SoundTrack, tr("&Export Soundtrack"), "",
      tr("Exports the soundtrack to the current scene as a wav file."));
  createStopMotionAction(
      MI_StopMotionExportImageSequence,
      tr("&Export Stop Motion Image Sequence"), "",
      tr("Exports the full resolution stop motion image sequence.") +
          separator + tr("This is especially useful if using a DSLR camera."));
  menuAct = createMenuRenderAction(
      MI_SavePreviewedFrames, tr("&Save Previewed Frames"), "",
      tr("Save the images created during preview to a specified location."));
  menuAct->setIcon(createQIcon("save_previewed_frames"));
  createRightClickMenuAction(MI_RegeneratePreview, tr("&Regenerate Preview"),
                             "", tr("Recreates a set of preview images."));
  createRightClickMenuAction(MI_RegenerateFramePr,
                             tr("&Regenerate Frame Preview"), "",
                             tr("Regenerate the frame preview."));
  createRightClickMenuAction(MI_ClonePreview, tr("&Clone Preview"), "",
                             tr("Creates a clone of the previewed images."));
  createRightClickMenuAction(MI_FreezePreview, tr("&Freeze//Unfreeze Preview"),
                             "", tr("Prevent the preview from being updated."));
  CommandManager::instance()->setToggleTexts(
      MI_FreezePreview, tr("Freeze Preview"), tr("Unfreeze Preview"));
  // createAction(MI_SavePreview,         "&Save Preview",		"");
  createRightClickMenuAction(MI_SavePreset, tr("&Save As Preset"), "");
  menuAct = createMenuFileAction(MI_Preferences, tr("&Preferences..."),
                                 "Ctrl+U", tr("Change Tahoma2D's settings."));
  menuAct->setIcon(createQIcon("gear"));
  createMenuFileAction(MI_ShortcutPopup, tr("&Configure Shortcuts..."), "",
                       tr("Change the shortcuts of Tahoma2D."));

  menuAct = createMenuFileAction(MI_PrintXsheet, tr("&Print Xsheet"), "",
                                 tr("Print the scene's exposure sheet."));
  menuAct->setIcon(createQIcon("printer"));

  createMenuFileAction(MI_ExportXDTS,
                       tr("Export Exchange Digital Time Sheet (XDTS)"), "");

  menuAct = createMenuFileAction(
      "MI_RunScript", tr("Run Script..."), "",
      tr("Run a script to perform a series of actions on a scene."));
  menuAct->setIcon(createQIcon("run_script"));

  menuAct = createMenuFileAction(
      "MI_OpenScriptConsole", tr("Open Script Console..."), "",
      tr("Open a console window where you can enter script commands."));
  menuAct->setIcon(createQIcon("console"));

  menuAct =
      createMenuFileAction(MI_Print, tr("&Print Current Frame..."), "Ctrl+P");
  menuAct->setIcon(createQIcon("printer"));

  createMenuFileAction(MI_Quit, tr("&Quit"), "Ctrl+Q", tr("Bye."));
#ifndef NDEBUG
  createMenuFileAction("MI_ReloadStyle", tr("Reload qss"), "");
#endif
  createMenuAction(MI_LoadRecentImage, tr("&Load Recent Image Files"), files);
  createMenuFileAction(MI_ClearRecentImage,
                       tr("&Clear Recent Flipbook Image List"), "");
  createMenuFileAction(MI_ClearCacheFolder, tr("&Clear Cache Folder"), "");

  createRightClickMenuAction(MI_PreviewFx, tr("Preview Fx"), "");

  menuAct = createMenuEditAction(MI_SelectAll, tr("&Select All"), "Ctrl+A");
  menuAct->setIcon(createQIcon("select_all"));

  menuAct =
      createMenuEditAction(MI_InvertSelection, tr("&Invert Selection"), "");
  menuAct->setIcon(createQIcon("invert_selection"));

  menuAct = createMenuEditAction(MI_Undo, tr("&Undo"), "Ctrl+Z");
  menuAct->setIcon(createQIcon("undo"));

  menuAct = createMenuEditAction(MI_Redo, tr("&Redo"), "Ctrl+Y");
  menuAct->setIcon(createQIcon("redo"));

  menuAct = createMenuEditAction(MI_Cut, tr("&Cut"), "Ctrl+X");
  menuAct->setIcon(createQIcon("cut"));

  menuAct = createMenuEditAction(MI_Copy, tr("&Copy"), "Ctrl+C");
  menuAct->setIcon(createQIcon("content_copy"));

  menuAct = createMenuEditAction(MI_Paste, tr("&Paste Insert"), "Ctrl+V");
  menuAct->setIcon(createQIcon("paste"));
  menuAct = createMenuEditAction(MI_PasteAbove, tr("&Paste Insert Above/After"),
                                 "Ctrl+Shift+V");
  menuAct->setIcon(createQIcon("paste_above_after"));
  menuAct = createMenuEditAction(MI_PasteDuplicate, tr("&Paste as a Copy"), "");
  menuAct->setIcon(createQIcon("paste_duplicate"));
  menuAct = createMenuEditAction(MI_PasteInto, tr("&Paste Into"), "");
  menuAct->setIcon(createQIcon("paste_into"));
  createRightClickMenuAction(MI_PasteValues, tr("&Paste Color && Name"), "");
  createRightClickMenuAction(MI_PasteColors, tr("Paste Color"), "");
  createRightClickMenuAction(MI_PasteNames, tr("Paste Name"), "");
  createRightClickMenuAction(MI_GetColorFromStudioPalette,
                             tr("Get Color from Studio Palette"), "");
  createRightClickMenuAction(MI_ToggleLinkToStudioPalette,
                             tr("Toggle Link to Studio Palette"), "");
  createRightClickMenuAction(MI_RemoveReferenceToStudioPalette,
                             tr("Remove Reference to Studio Palette"), "");
  // createMenuEditAction(MI_PasteNew,     tr("&Paste New"),  "");
  createMenuCellsAction(MI_MergeFrames, tr("&Merge"), "");

  menuAct = createMenuEditAction(MI_Clear, tr("&Delete"), "Del");
  menuAct->setIcon(createQIcon("delete"));
  createMenuEditAction(MI_ClearFrames, tr("&Clear Frames"), "");
  menuAct = createMenuEditAction(MI_Insert, tr("&Insert"), "Ins");
  menuAct->setIcon(createQIcon("insert"));
  menuAct = createMenuEditAction(MI_InsertAbove, tr("&Insert Above/After"),
                                 "Shift+Ins");
  menuAct->setIcon(createQIcon("insert_above_after"));
  menuAct = createMenuEditAction(MI_Group, tr("&Group"), "Ctrl+G");
  menuAct->setIcon(createQIcon("group"));
  menuAct = createMenuEditAction(MI_Ungroup, tr("&Ungroup"), "Ctrl+Shift+G");
  menuAct->setIcon(createQIcon("ungroup"));
  menuAct = createMenuEditAction(MI_EnterGroup, tr("&Enter Group"), "");
  menuAct->setIcon(createQIcon("enter_group"));
  menuAct = createMenuEditAction(MI_ExitGroup, tr("&Exit Group"), "");
  menuAct->setIcon(createQIcon("leave_group"));

  menuAct = createMenuEditAction(MI_SendBack, tr("&Move to Back"), "Ctrl+[");
  menuAct->setIcon(createQIcon("move_to_back"));
  menuAct = createMenuEditAction(MI_SendBackward, tr("&Move Back One"), "[");
  menuAct->setIcon(createQIcon("move_back_one"));
  menuAct = createMenuEditAction(MI_BringForward, tr("&Move Forward One"), "]");
  menuAct->setIcon(createQIcon("move_forward_one"));
  menuAct =
      createMenuEditAction(MI_BringToFront, tr("&Move to Front"), "Ctrl+]");
  menuAct->setIcon(createQIcon("move_to_front"));

  menuAct = createMenuLevelAction(MI_RemoveEndpoints,
                                  tr("&Remove Vector Overflow"), "");
  menuAct->setIcon(createQIcon("remove_vector_overflow"));
  QAction *toggle =
      createToggle(MI_TouchGestureControl, tr("&Touch Gesture Control"), "",
                   TouchGestureControl ? 1 : 0, MiscCommandType);
  toggle->setEnabled(true);
  toggle->setIcon(QIcon(":Resources/touch.svg"));

  QAction *cleanupSettingsAction = createMenuScanCleanupAction(
      MI_CleanupSettings, tr("&Cleanup Settings..."), "");
  cleanupSettingsAction->setIcon(createQIcon("cleanup_settings"));
  toggle = createToggle(MI_CleanupPreview, tr("&Preview Cleanup"), "", 0,
                        MenuScanCleanupCommandType);
  toggle->setIcon(createQIcon("cleanup_preview"));
  CleanupPreviewCheck::instance()->setToggle(toggle);
  toggle = createToggle(MI_CameraTest, tr("&Camera Test"), "", 0,
                        MenuScanCleanupCommandType);
  CameraTestCheck::instance()->setToggle(toggle);

  menuAct = createToggle(MI_OpacityCheck, tr("&Opacity Check"), "Alt+1", false,
                         MenuScanCleanupCommandType);
  menuAct->setIcon(createQIcon("opacity_check"));

  menuAct = createMenuScanCleanupAction(MI_Cleanup, tr("&Cleanup"), "");
  menuAct->setIcon(createQIcon("cleanup"));

  menuAct =
      createMenuScanCleanupAction(MI_PencilTest, tr("&Camera Capture..."), "");
  menuAct->setIcon(createQIcon("camera_capture"));

  menuAct = createMenuLevelAction(MI_AddFrames, tr("&Add Frames..."), "");
  menuAct->setIcon(createQIcon("add_cells"));

  menuAct = createMenuLevelAction(MI_Renumber, tr("&Renumber..."), "");
  menuAct->setIcon(createQIcon("renumber"));
  menuAct = createMenuLevelAction(MI_ReplaceLevel, tr("&Replace Level..."), "");
  menuAct->setIcon(createQIcon("replace_level"));
  menuAct = createMenuLevelAction(MI_RevertToCleanedUp,
                                  tr("&Revert to Cleaned Up"), "");
  menuAct->setIcon(createQIcon("revert_level_to_cleanup"));
  menuAct = createMenuLevelAction(MI_RevertToLastSaved, tr("&Reload"), "");
  menuAct->setIcon(createQIcon("reload_level"));
  createMenuLevelAction(MI_ExposeResource, tr("&Expose in Xsheet"), "");
  createMenuLevelAction(MI_EditLevel, tr("&Display in Level Strip"), "");
  menuAct =
      createMenuLevelAction(MI_LevelSettings, tr("&Level Settings..."), "");
  menuAct->setIcon(createQIcon("level_settings"));
  menuAct = createMenuLevelAction(MI_AdjustLevels, tr("Adjust Levels..."), "");
  menuAct->setIcon(createQIcon("histograms"));
  menuAct =
      createMenuLevelAction(MI_AdjustThickness, tr("Adjust Thickness..."), "");
  menuAct->setIcon(createQIcon("thickness"));
  menuAct = createMenuLevelAction(MI_Antialias, tr("&Antialias..."), "");
  menuAct->setIcon(createQIcon("antialias"));
  menuAct = createMenuLevelAction(MI_Binarize, tr("&Binarize..."), "");
  menuAct->setIcon(createQIcon("binarize"));
  menuAct = createMenuLevelAction(MI_BrightnessAndContrast,
                                  tr("&Brightness and Contrast..."), "");
  menuAct->setIcon(createQIcon("brightness_contrast"));
  menuAct = createMenuLevelAction(MI_LinesFade, tr("&Color Fade..."), "");
  menuAct->setIcon(createQIcon("colorfade"));

  menuAct = createMenuLevelAction(MI_CanvasSize, tr("&Canvas Size..."), "");
  if (menuAct) menuAct->setDisabled(true);
  menuAct->setIcon(createQIcon("resize"));

  menuAct = createMenuLevelAction(MI_FileInfo, tr("&Info..."), "");
  menuAct->setIcon(createQIcon("level_info"));
  createRightClickMenuAction(MI_ViewFile, tr("&View..."), "");
  menuAct = createMenuLevelAction(MI_RemoveUnused,
                                  tr("&Remove All Unused Levels"), "");
  menuAct->setIcon(createQIcon("remove_unused_levels"));
  createMenuLevelAction(MI_ReplaceParentDirectory,
                        tr("&Replace Parent Directory..."), "");
  menuAct =
      createMenuXsheetAction(MI_SceneSettings, tr("&Scene Settings..."), "");
  menuAct->setIcon(createQIcon("scene_settings"));
  menuAct =
      createMenuXsheetAction(MI_CameraSettings, tr("&Camera Settings..."), "");
  menuAct->setIcon(createQIcon("camera_settings"));
  createMiscAction(MI_CameraStage, tr("&Camera Settings..."), "");

  menuAct = createMenuXsheetAction(MI_OpenChild, tr("&Open Sub-Xsheet"), "");
  menuAct->setIcon(createQIcon("sub_enter"));
  menuAct = createMenuXsheetAction(MI_CloseChild, tr("&Close Sub-Xsheet"), "");
  menuAct->setIcon(createQIcon("sub_leave"));
  menuAct =
      createMenuXsheetAction(MI_ExplodeChild, tr("Explode Sub-Xsheet"), "");
  menuAct->setIcon(createQIcon("sub_explode"));
  menuAct = createMenuXsheetAction(MI_Collapse, tr("Collapse"), "");
  menuAct->setIcon(createQIcon("sub_collapse"));
  toggle = createToggle(MI_ToggleEditInPlace, tr("&Toggle Edit In Place"), "",
                        EditInPlaceToggleAction ? 1 : 0, MenuXsheetCommandType);
  toggle->setIconText(tr("Toggle Edit in Place"));
  toggle->setIcon(createQIcon("sub_edit_in_place"));
  menuAct = createMenuXsheetAction(MI_SaveSubxsheetAs,
                                   tr("&Save Sub-Xsheet As..."), "");
  menuAct->setIcon(createQIcon("saveas"));
  menuAct = createMenuXsheetAction(MI_Resequence, tr("Resequence"), "");
  menuAct->setIcon(createQIcon("resequence"));
  menuAct = createMenuXsheetAction(MI_CloneChild, tr("Clone Sub-Xsheet"), "");
  menuAct->setIcon(createQIcon("sub_clone"));

  menuAct = createMenuXsheetAction(MI_ApplyMatchLines,
                                   tr("&Apply Match Lines..."), "");
  menuAct->setIcon(createQIcon("apply_match_lines"));
  menuAct =
      createMenuXsheetAction(MI_MergeCmapped, tr("&Merge Tlv Levels..."), "");
  menuAct->setIcon(createQIcon("merge_levels_tlv"));
  menuAct = createMenuXsheetAction(MI_DeleteMatchLines,
                                   tr("&Delete Match Lines"), "");
  menuAct->setIcon(createQIcon("delete_match_lines"));
  menuAct = createMenuXsheetAction(MI_DeleteInk, tr("&Delete Lines..."), "");
  menuAct->setIcon(createQIcon("delete_lines"));

  menuAct = createMenuXsheetAction(MI_MergeColumns, tr("&Merge Levels"), "");
  menuAct->setIcon(createQIcon("merge_levels"));

  menuAct = createMenuXsheetAction(MI_InsertFx, tr("&New FX..."), "Ctrl+F");
  menuAct->setIcon(createQIcon("fx_new"));

  menuAct = createMenuXsheetAction(MI_NewOutputFx, tr("&New Output"), "Alt+O");
  menuAct->setIcon(createQIcon("output"));

  menuAct = createMenuXsheetAction(MI_InsertSceneFrame, tr("Insert Frame"), "");
  menuAct->setIcon(createQIcon("insert_frame"));

  menuAct = createMenuXsheetAction(MI_RemoveSceneFrame, tr("Remove Frame"), "");
  menuAct->setIcon(createQIcon("remove_frame"));

  menuAct = createMenuXsheetAction(MI_InsertGlobalKeyframe,
                                   tr("Insert Multiple Keys"), "");
  menuAct->setIcon(createQIcon("insert_multiple_keys"));

  menuAct = createMenuXsheetAction(MI_RemoveGlobalKeyframe,
                                   tr("Remove Multiple Keys"), "");
  menuAct->setIcon(createQIcon("remove_multiple_keys"));

  menuAct = createMenuLevelAction(MI_NewNoteLevel, tr("New Note Level"), "");
  menuAct->setIcon(createQIcon("new_note_level"));

  menuAct = createMenuXsheetAction(MI_RemoveEmptyColumns,
                                   tr("Remove Empty Columns"), "");
  menuAct->setIcon(createQIcon("clear"));
  createMenuXsheetAction(MI_LipSyncPopup, tr("&Apply Lip Sync Data to Column"),
                         "Alt+L");
  createRightClickMenuAction(MI_ToggleXSheetToolbar,
                             tr("Toggle XSheet Toolbar"), "");
  createRightClickMenuAction(MI_ToggleXsheetCameraColumn,
                             tr("Show/Hide Xsheet Camera Column"), "");

  menuAct = createMenuCellsAction(MI_Reverse, tr("&Reverse"), "");
  menuAct->setIcon(createQIcon("reverse"));
  menuAct = createMenuCellsAction(MI_Swing, tr("&Swing"), "");
  menuAct->setIcon(createQIcon("swing"));
  menuAct = createMenuCellsAction(MI_Random, tr("&Random"), "");
  menuAct->setIcon(createQIcon("random"));
  menuAct = createMenuCellsAction(MI_Increment, tr("&Autoexpose"), "");
  menuAct->setIcon(createQIcon("autoexpose"));
  menuAct = createMenuCellsAction(MI_Dup, tr("&Repeat..."), "");
  menuAct->setIcon(createQIcon("repeat"));
  createMenuCellsAction(MI_ResetStep, tr("&Reset Step"), "");
  menuAct = createMenuCellsAction(MI_IncreaseStep, tr("&Increase Step"), "'");
  menuAct->setIcon(createQIcon("step_plus"));
  menuAct = createMenuCellsAction(MI_DecreaseStep, tr("&Decrease Step"), ";");
  menuAct->setIcon(createQIcon("step_minus"));
  menuAct = createMenuCellsAction(MI_Step2, tr("&Step 2"), "");
  menuAct->setIcon(createQIcon("step_2"));
  menuAct = createMenuCellsAction(MI_Step3, tr("&Step 3"), "");
  menuAct->setIcon(createQIcon("step_3"));
  menuAct = createMenuCellsAction(MI_Step4, tr("&Step 4"), "");
  menuAct->setIcon(createQIcon("step_4"));
  createMenuCellsAction(MI_Each2, tr("&Each 2"), "");
  createMenuCellsAction(MI_Each3, tr("&Each 3"), "");
  createMenuCellsAction(MI_Each4, tr("&Each 4"), "");
  menuAct = createMenuCellsAction(MI_Rollup, tr("&Roll Up"), "");
  menuAct->setIcon(createQIcon("rollup"));
  menuAct = createMenuCellsAction(MI_Rolldown, tr("&Roll Down"), "");
  menuAct->setIcon(createQIcon("rolldown"));
  menuAct = createMenuCellsAction(MI_TimeStretch, tr("&Time Stretch..."), "");
  menuAct->setIcon(createQIcon("time_stretch"));
  menuAct = createMenuCellsAction(MI_CreateBlankDrawing,
                                  tr("&Create Blank Drawing"), "Alt+D");
  menuAct->setIcon(createQIcon("add_cell"));
  menuAct =
      createMenuCellsAction(MI_Duplicate, tr("&Duplicate Drawing  "), "D");
  menuAct->setIcon(createQIcon("duplicate_drawing"));
  menuAct = createMenuCellsAction(MI_Autorenumber, tr("&Autorenumber"), "");
  menuAct->setIcon(createQIcon("renumber"));
  menuAct = createMenuCellsAction(MI_CloneLevel, tr("&Clone Cells"), "");
  menuAct->setIcon(createQIcon("clone_cells"));
  createMenuCellsAction(MI_DrawingSubForward,
                        tr("Drawing Substitution Forward"), "W");
  createMenuCellsAction(MI_DrawingSubBackward,
                        tr("Drawing Substitution Backward"), "Q");
  createMenuCellsAction(MI_DrawingSubGroupForward,
                        tr("Similar Drawing Substitution Forward"), "Alt+W");
  createMenuCellsAction(MI_DrawingSubGroupBackward,
                        tr("Similar Drawing Substitution Backward"), "Alt+Q");
  menuAct = createMenuCellsAction(MI_Reframe1, tr("Reframe on 1's"), "");
  menuAct->setIcon(createQIcon("on_1s"));
  menuAct = createMenuCellsAction(MI_Reframe2, tr("Reframe on 2's"), "");
  menuAct->setIcon(createQIcon("on_2s"));
  menuAct = createMenuCellsAction(MI_Reframe3, tr("Reframe on 3's"), "");
  menuAct->setIcon(createQIcon("on_3s"));
  menuAct = createMenuCellsAction(MI_Reframe4, tr("Reframe on 4's"), "");
  menuAct->setIcon(createQIcon("on_4s"));
  menuAct = createMenuCellsAction(MI_ReframeWithEmptyInbetweens,
                                  tr("Reframe with Empty Inbetweens..."), "");
  menuAct->setIcon(createQIcon("on_with_empty"));
  menuAct = createMenuCellsAction(MI_AutoInputCellNumber,
                                  tr("Auto Input Cell Number..."), "");
  menuAct->setIcon(createQIcon("auto_input_cell_number"));
  menuAct =
      createMenuCellsAction(MI_FillEmptyCell, tr("&Fill In Empty Cells"), "");
  menuAct->setIcon(createQIcon("fill_empty_cells"));

  menuAct = createRightClickMenuAction(MI_SetKeyframes, tr("&Set Key"), "Z");
  menuAct->setIcon(createQIcon("set_key"));
  menuAct = createRightClickMenuAction(MI_ShiftKeyframesDown,
                                       tr("&Shift Keys Down"), "");
  menuAct->setIcon(createQIcon("shift_keys_down"));
  menuAct =
      createRightClickMenuAction(MI_ShiftKeyframesUp, tr("&Shift Keys Up"), "");
  menuAct->setIcon(createQIcon("shift_keys_up"));

  createRightClickMenuAction(MI_PasteNumbers, tr("&Paste Numbers"), "");

  createToggle(MI_ViewCamera, tr("&Camera Box"), "",
               ViewCameraToggleAction ? 1 : 0, MenuViewCommandType);
  createToggle(MI_ViewTable, tr("&Table"), "", ViewTableToggleAction ? 1 : 0,
               MenuViewCommandType);
  createToggle(MI_FieldGuide, tr("&Grids and Overlays"), "Shift+G",
               FieldGuideToggleAction ? 1 : 0, MenuViewCommandType);
  createToggle(MI_ViewBBox, tr("&Raster Bounding Box"), "",
               ViewBBoxToggleAction ? 1 : 0, MenuViewCommandType);
  createToggle(MI_SafeArea, tr("&Safe Area"), "", SafeAreaToggleAction ? 1 : 0,
               MenuViewCommandType);
  createToggle(MI_ViewColorcard, tr("&Camera BG Color"), "",
               ViewColorcardToggleAction ? 1 : 0, MenuViewCommandType);
  createToggle(MI_ViewGuide, tr("&Guide"), "", ViewGuideToggleAction ? 1 : 0,
               MenuViewCommandType);
  createToggle(MI_ViewRuler, tr("&Ruler"), "", ViewRulerToggleAction ? 1 : 0,
               MenuViewCommandType);
  menuAct = createToggle(MI_TCheck, tr("&Transparency Check  "), "",
                         TCheckToggleAction ? 1 : 0, MenuViewCommandType);
  menuAct->setIcon(createQIcon("transparency_check"));

  QAction *inkCheckAction =
      createToggle(MI_ICheck, tr("&Ink Check"), "", ICheckToggleAction ? 1 : 0,
                   MenuViewCommandType);
  inkCheckAction->setIcon(createQIcon("ink_check"));
  QAction *ink1CheckAction =
      createToggle(MI_Ink1Check, tr("&Ink#1 Check"), "",
                   Ink1CheckToggleAction ? 1 : 0, MenuViewCommandType);
  ink1CheckAction->setIcon(createQIcon("ink_no1_check"));
  /*-- Ink Check と Ink1Checkを排他的にする --*/
  connect(inkCheckAction, SIGNAL(triggered(bool)), this,
          SLOT(onInkCheckTriggered(bool)));
  connect(ink1CheckAction, SIGNAL(triggered(bool)), this,
          SLOT(onInk1CheckTriggered(bool)));

  QAction *paintCheckAction =
      createToggle(MI_PCheck, tr("&Paint Check"), "",
                   PCheckToggleAction ? 1 : 0, MenuViewCommandType);
  paintCheckAction->setIcon(createQIcon("paint_check"));
  QAction *checkModesAction =
      createToggle(MI_IOnly, tr("Inks &Only"), "", IOnlyToggleAction ? 1 : 0,
                   MenuViewCommandType);
  checkModesAction->setIcon(createQIcon("inks_only"));
  QAction *fillCheckAction =
      createToggle(MI_GCheck, tr("&Fill Check"), "", GCheckToggleAction ? 1 : 0,
                   MenuViewCommandType);
  fillCheckAction->setIcon(createQIcon("fill_check"));
  QAction *blackBgCheckAction =
      createToggle(MI_BCheck, tr("&Black BG Check"), "",
                   BCheckToggleAction ? 1 : 0, MenuViewCommandType);
  blackBgCheckAction->setIcon(createQIcon("blackbg_check"));
  QAction *gapCheckAction =
      createToggle(MI_ACheck, tr("&Gap Check"), "", ACheckToggleAction ? 1 : 0,
                   MenuViewCommandType);
  gapCheckAction->setIcon(createQIcon("gap_check"));

  QAction *showStatusBarAction =
      createToggle(MI_ShowStatusBar, tr("&Show Status Bar"), "",
                   ShowStatusBarAction ? 1 : 0, MenuViewCommandType);
  connect(showStatusBarAction, SIGNAL(triggered(bool)), this,
          SLOT(toggleStatusBar(bool)));

  QAction *toggleTransparencyAction =
      createToggle(MI_ToggleTransparent, tr("&Toggle Transparency"), "", 0,
                   MenuViewCommandType);
  connect(toggleTransparencyAction, SIGNAL(triggered(bool)), this,
          SLOT(toggleTransparency(bool)));
  connect(m_transparencyTogglerWindow, &QDialog::finished, [=](int result) {
    toggleTransparency(false);
    toggleTransparencyAction->setChecked(false);
  });

  toggle = createToggle(MI_ShiftTrace, tr("Shift and Trace"), "", false,
                        MenuViewCommandType);
  toggle->setIcon(createQIcon("shift_and_trace"));

  toggle = createToggle(MI_EditShift, tr("Edit Shift"), "", false,
                        MenuViewCommandType);
  toggle->setIcon(createQIcon("shift_and_trace_edit"));
  toggle =
      createToggle(MI_NoShift, tr("No Shift"), "", false, MenuViewCommandType);
  toggle->setIcon(createQIcon("shift_and_trace_no_shift"));
  CommandManager::instance()->enable(MI_EditShift, false);
  CommandManager::instance()->enable(MI_NoShift, false);
  menuAct = createAction(MI_ResetShift, tr("Reset Shift"), "", "",
                         MenuViewCommandType);
  menuAct->setIcon(createQIcon("shift_and_trace_reset"));

  toggle = createToggle(MI_VectorGuidedDrawing, tr("Vector Guided Drawing"), "",
                        Preferences::instance()->isGuidedDrawingEnabled(),
                        MenuViewCommandType);

  if (QGLPixelBuffer::hasOpenGLPbuffers())
    createToggle(MI_RasterizePli, tr("&Visualize Vector As Raster"), "",
                 RasterizePliToggleAction ? 1 : 0, MenuViewCommandType);
  else
    RasterizePliToggleAction = 0;

  createRightClickMenuAction(MI_Histogram, tr("&Histogram"), "");

  // createToolOptionsAction("A_ToolOption_Link", tr("Link"), "");
  menuAct = createToggle(MI_Link, tr("Link Flipbooks"), "",
                         LinkToggleAction ? 1 : 0, MenuPlayCommandType);
  menuAct->setIcon(createQIcon("flipbook_link"));

  menuAct = createMenuPlayAction(MI_Play, tr("Play"), "P");
  menuAct->setIcon(createQIcon("play"));
  createMenuPlayAction(MI_ShortPlay, tr("Short Play"), "Alt+P");
  menuAct = createMenuPlayAction(MI_Loop, tr("Loop"), "L");
  menuAct->setIcon(createQIcon("loop"));
  menuAct = createMenuPlayAction(MI_Pause, tr("Pause"), "");
  menuAct->setIcon(createQIcon("pause"));
  menuAct = createMenuPlayAction(MI_FirstFrame, tr("First Frame"), "Alt+,");
  menuAct->setIcon(createQIcon("framefirst"));
  menuAct = createMenuPlayAction(MI_LastFrame, tr("Last Frame"), "Alt+.");
  menuAct->setIcon(createQIcon("framelast"));
  menuAct = createMenuPlayAction(MI_PrevFrame, tr("Previous Frame"), "Shift+,");
  menuAct->setIcon(createQIcon("frameprev"));
  menuAct = createMenuPlayAction(MI_NextFrame, tr("Next Frame"), "Shift+.");
  menuAct->setIcon(createQIcon("framenext"));
  menuAct = createMenuPlayAction(MI_NextDrawing, tr("Next Drawing"), ".");
  menuAct->setIcon(createQIcon("next_drawing"));
  menuAct = createMenuPlayAction(MI_PrevDrawing, tr("Previous Drawing"), ",");
  menuAct->setIcon(createQIcon("prev_drawing"));
  menuAct = createMenuPlayAction(MI_NextStep, tr("Next Step"), "");
  menuAct->setIcon(createQIcon("nextstep"));
  menuAct = createMenuPlayAction(MI_PrevStep, tr("Previous Step"), "");
  menuAct->setIcon(createQIcon("prevstep"));
  menuAct = createMenuPlayAction(MI_NextKeyframe, tr("Next Key"), "Ctrl+.");
  menuAct->setIcon(createQIcon("nextkey"));
  menuAct = createMenuPlayAction(MI_PrevKeyframe, tr("Previous Key"), "Ctrl+,");
  menuAct->setIcon(createQIcon("prevkey"));

  createRGBAAction(MI_RedChannel, tr("Red Channel"), "");
  createRGBAAction(MI_GreenChannel, tr("Green Channel"), "");
  createRGBAAction(MI_BlueChannel, tr("Blue Channel"), "");
  createRGBAAction(MI_MatteChannel, tr("Alpha Channel"), "");
  createRGBAAction(MI_RedChannelGreyscale, tr("Red Channel Greyscale"), "");
  createRGBAAction(MI_GreenChannelGreyscale, tr("Green Channel Greyscale"), "");
  createRGBAAction(MI_BlueChannelGreyscale, tr("Blue Channel Greyscale"), "");
  /*-- Viewer下部のCompareToSnapshotボタンのトグル --*/
  createViewerAction(MI_CompareToSnapshot, tr("Compare to Snapshot"), "");
  createFillAction(MI_AutoFillToggle,
                   tr("Toggle Autofill on Current Palette Color"), "Shift+A");

  // toggle =
  //     createToggle(MI_DockingCheck, tr("&Lock Room Panes"), "",
  //                  DockingCheckToggleAction ? 1 : 0, MenuWindowsCommandType);
  // DockingCheck::instance()->setToggle(toggle);

  // createRightClickMenuAction(MI_OpenCurrentScene,   tr("&Current Scene"),
  // "");

  createMenuWindowsAction(MI_OpenExport, tr("&Export"), "");

  menuAct =
      createMenuWindowsAction(MI_OpenFileBrowser, tr("&File Browser"), "");
  menuAct->setIcon(createQIcon("filebrowser"));
  menuAct = createMenuWindowsAction(MI_OpenFileViewer, tr("&Flipbook"), "");
  menuAct->setIcon(createQIcon("flipbook"));
  menuAct = createMenuWindowsAction(MI_OpenFunctionEditor,
                                    tr("&Function Editor"), "");
  menuAct->setIcon(createQIcon("function_editor"));
  createMenuWindowsAction(MI_OpenFilmStrip, tr("&Level Strip"), "");
  menuAct = createMenuWindowsAction(MI_OpenPalette, tr("&Palette"), "");
  menuAct->setIcon(createQIcon("palette"));
  menuAct =
      createRightClickMenuAction(MI_OpenPltGizmo, tr("&Palette Gizmo"), "");
  menuAct->setIcon(createQIcon("palettegizmo"));
  createRightClickMenuAction(MI_EraseUnusedStyles, tr("&Delete Unused Styles"),
                             "");
  menuAct = createMenuWindowsAction(MI_OpenTasks, tr("&Tasks"), "");
  menuAct->setIcon(createQIcon("tasks"));
  menuAct =
      createMenuWindowsAction(MI_OpenBatchServers, tr("&Batch Servers"), "");
  menuAct->setIcon(createQIcon("batchservers"));
  menuAct = createMenuWindowsAction(MI_OpenTMessage, tr("&Message Center"), "");
  menuAct->setIcon(createQIcon("messagecenter"));
  menuAct = createMenuWindowsAction(MI_OpenColorModel, tr("&Color Model"), "");
  menuAct->setIcon(createQIcon("colormodel"));
  menuAct =
      createMenuWindowsAction(MI_OpenStudioPalette, tr("&Studio Palette"), "");
  menuAct->setIcon(createQIcon("studiopalette"));

  menuAct = createMenuWindowsAction(MI_OpenSchematic, tr("&Schematic"), "");
  menuAct->setIcon(createQIcon("schematic"));
  menuAct =
      createMenuWindowsAction(MI_FxParamEditor, tr("&FX Editor"), "Ctrl+K");
  menuAct->setIcon(createQIcon("fx_settings"));
  menuAct = createMenuWindowsAction(MI_OpenCleanupSettings,
                                    tr("&Cleanup Settings"), "");
  menuAct->setIcon(createQIcon("cleanup_settings"));

  menuAct = createMenuWindowsAction(MI_OpenFileBrowser2, tr("&Scene Cast"), "");
  menuAct->setIcon(createQIcon("scenecast"));
  menuAct =
      createMenuWindowsAction(MI_OpenStyleControl, tr("&Style Editor"), "");
  menuAct->setIcon(createQIcon("styleeditor"));
  createMenuWindowsAction(MI_OpenToolbar, tr("&Toolbar"), "");
  createMenuWindowsAction(MI_OpenToolOptionBar, tr("&Tool Option Bar"), "");
  createMenuWindowsAction(MI_OpenCommandToolbar, tr("&Command Bar"), "");
  createMenuWindowsAction(MI_OpenStopMotionPanel, tr("&Stop Motion Controls"),
                          "");

  menuAct = createMenuWindowsAction(MI_OpenLevelView, tr("&Viewer"), "");
  menuAct->setIcon(createQIcon("viewer"));
  menuAct = createMenuWindowsAction(MI_OpenXshView, tr("&Xsheet"), "");
  menuAct->setIcon(createQIcon("xsheet"));
  menuAct = createMenuWindowsAction(MI_OpenTimelineView, tr("&Timeline"), "");
  menuAct->setIcon(createQIcon("timeline"));
  //  createAction(MI_TestAnimation,     "Test Animation",   "Ctrl+Return");
  //  createAction(MI_Export,            "Export",           "Ctrl+E");

  menuAct = createMenuWindowsAction(MI_OpenComboViewer, tr("&ComboViewer"), "");
  menuAct->setIcon(createQIcon("viewer"));
  menuAct =
      createMenuWindowsAction(MI_OpenHistoryPanel, tr("&History"), "Ctrl+H");
  menuAct->setIcon(createQIcon("history"));
  menuAct =
      createMenuWindowsAction(MI_AudioRecording, tr("Record Audio"), "Alt+A");
  menuAct->setIcon(createQIcon("recordaudio"));
  createMenuWindowsAction(MI_ResetRoomLayout, tr("&Reset to Default Rooms"),
                          "");
  menuAct = createMenuWindowsAction(MI_MaximizePanel,
                                    tr("Toggle Maximize Panel"), "`");
  menuAct->setIcon(createQIcon("fit_to_window"));
  menuAct = createMenuWindowsAction(MI_FullScreenWindow,
                                    tr("Toggle Main Window's Full Screen Mode"),
                                    "Ctrl+`");
  menuAct->setIcon(createQIcon("toggle_fullscreen"));

  menuAct = createMenuHelpAction(MI_About, tr("&About Tahoma2D..."), "");
  menuAct->setIconText(tr("About Tahoma2D..."));
  menuAct->setIcon(createQIcon("info"));

  menuAct = createMenuWindowsAction(MI_StartupPopup, tr("&Startup Popup..."),
                                    "Alt+S");
  // menuAct->setIcon(createQIcon("opentoonz"));

  menuAct =
      createMenuHelpAction(MI_OpenOnlineManual, tr("&Online Manual..."), "F1");
  menuAct->setIconText(tr("Online Manual..."));
  menuAct->setIcon(createQIcon("manual"));

  menuAct = createMenuHelpAction(MI_OpenWhatsNew, tr("&What's New..."), "");
  menuAct->setIconText(tr("What's New..."));
  menuAct->setIcon(createQIcon("web"));

  // menuAct = createMenuHelpAction(MI_OpenCommunityForum,
  //                                tr("&Community Forum..."), "");
  // menuAct->setIconText(tr("Community Forum..."));
  // menuAct->setIcon(createQIcon("web"));

  menuAct = createMenuHelpAction(MI_OpenReportABug, tr("&Report a Bug..."), "");
  menuAct->setIconText(tr("Report a Bug..."));
  menuAct->setIcon(createQIcon("web"));

  createMenuWindowsAction(MI_OpenGuidedDrawingControls,
                          tr("Guided Drawing Controls"), "");

  createRightClickMenuAction(MI_BlendColors, tr("&Blend colors"), "");

  toggle = createToggle(MI_OnionSkin, tr("Onion Skin Toggle"), "/", false,
                        RightClickMenuCommandType);
  toggle->setIcon(createQIcon("onionskin_toggle"));

  createToggle(MI_ZeroThick, tr("Zero Thick Lines"), "Shift+/", false,
               RightClickMenuCommandType);
  createToggle(MI_CursorOutline, tr("Toggle Cursor Size Outline"), "", false,
               RightClickMenuCommandType);

  createRightClickMenuAction(MI_ToggleCurrentTimeIndicator,
                             tr("Toggle Current Time Indicator"), "");

  // createRightClickMenuAction(MI_LoadSubSceneFile,     tr("Load As
  // Sub-xsheet"),   "");
  // createRightClickMenuAction(MI_LoadResourceFile,     tr("Load"),
  // "");

  menuAct = createRightClickMenuAction(MI_DuplicateFile, tr("Duplicate"), "");
  menuAct->setIcon(createQIcon("duplicate"));

  createRightClickMenuAction(MI_ShowFolderContents, tr("Show Folder Contents"),
                             "");
  createRightClickMenuAction(MI_ConvertFiles, tr("Convert..."), "");
  createRightClickMenuAction(MI_CollectAssets, tr("Collect Assets"), "");
  createRightClickMenuAction(MI_ImportScenes, tr("Import Scene"), "");
  createRightClickMenuAction(MI_ExportScenes, tr("Export Scene..."), "");

  // createRightClickMenuAction(MI_PremultiplyFile,      tr("Premultiply"),
  // "");
  createMenuLevelAction(MI_ConvertToVectors, tr("Convert to Vectors..."), "");
  createMenuLevelAction(MI_ConvertToToonzRaster, tr("Vectors to Smart Raster"),
                        "");
  createMenuLevelAction(MI_ConvertVectorToVector, tr("Simplify Vectors"), "");

  menuAct = createMenuLevelAction(MI_Tracking, tr("Tracking..."), "");
  menuAct->setIcon(createQIcon("tracking_options"));

  menuAct = createRightClickMenuAction(MI_RemoveLevel, tr("Remove Level"), "");
  menuAct->setIcon(createQIcon("remove_level"));

  menuAct = createRightClickMenuAction(MI_AddToBatchRenderList,
                                       tr("Add As Render Task"), "");
  menuAct->setIcon(createQIcon("render_add"));
  menuAct = createRightClickMenuAction(MI_AddToBatchCleanupList,
                                       tr("Add As Cleanup Task"), "");
  menuAct->setIcon(createQIcon("cleanup_add"));

  createRightClickMenuAction(MI_SelectRowKeyframes,
                             tr("Select All Keys in this Frame"), "");
  createRightClickMenuAction(MI_SelectColumnKeyframes,
                             tr("Select All Keys in this Column"), "");
  createRightClickMenuAction(MI_SelectAllKeyframes, tr("Select All Keys"), "");
  createRightClickMenuAction(MI_SelectAllKeyframesNotBefore,
                             tr("Select All Following Keys"), "");
  createRightClickMenuAction(MI_SelectAllKeyframesNotAfter,
                             tr("Select All Previous Keys"), "");
  createRightClickMenuAction(MI_SelectPreviousKeysInColumn,
                             tr("Select Previous Keys in this Column"), "");
  createRightClickMenuAction(MI_SelectFollowingKeysInColumn,
                             tr("Select Following Keys in this Column"), "");
  createRightClickMenuAction(MI_SelectPreviousKeysInRow,
                             tr("Select Previous Keys in this Frame"), "");
  createRightClickMenuAction(MI_SelectFollowingKeysInRow,
                             tr("Select Following Keys in this Frame"), "");
  createRightClickMenuAction(MI_InvertKeyframeSelection,
                             tr("Invert Key Selection"), "");

  createRightClickMenuAction(MI_SetAcceleration, tr("Set Acceleration"), "");
  createRightClickMenuAction(MI_SetDeceleration, tr("Set Deceleration"), "");
  createRightClickMenuAction(MI_SetConstantSpeed, tr("Set Constant Speed"), "");
  createRightClickMenuAction(MI_ResetInterpolation, tr("Reset Interpolation"),
                             "");

  createRightClickMenuAction(MI_UseLinearInterpolation,
                             tr("Linear Interpolation"), "");
  createRightClickMenuAction(MI_UseSpeedInOutInterpolation,
                             tr("Speed In / Speed Out Interpolation"), "");
  createRightClickMenuAction(MI_UseEaseInOutInterpolation,
                             tr("Ease In / Ease Out Interpolation"), "");
  createRightClickMenuAction(MI_UseEaseInOutPctInterpolation,
                             tr("Ease In / Ease Out (%) Interpolation"), "");
  createRightClickMenuAction(MI_UseExponentialInterpolation,
                             tr("Exponential Interpolation"), "");
  createRightClickMenuAction(MI_UseExpressionInterpolation,
                             tr("Expression Interpolation"), "");
  createRightClickMenuAction(MI_UseFileInterpolation, tr("File Interpolation"),
                             "");
  createRightClickMenuAction(MI_UseConstantInterpolation,
                             tr("Constant Interpolation"), "");

  menuAct = createRightClickMenuAction(MI_FoldColumns, tr("Fold Column"), "");
  menuAct->setIcon(createQIcon("fold_column"));

  createRightClickMenuAction(MI_ActivateThisColumnOnly, tr("Show This Only"),
                             "");
  createRightClickMenuAction(MI_ActivateSelectedColumns, tr("Show Selected"),
                             "");
  createRightClickMenuAction(MI_ActivateAllColumns, tr("Show All"), "");
  createRightClickMenuAction(MI_DeactivateSelectedColumns, tr("Hide Selected"),
                             "");
  createRightClickMenuAction(MI_DeactivateAllColumns, tr("Hide All"), "");
  createRightClickMenuAction(MI_ToggleColumnsActivation, tr("Toggle Show/Hide"),
                             "");
  createRightClickMenuAction(MI_EnableThisColumnOnly, tr("ON This Only"), "");
  createRightClickMenuAction(MI_EnableSelectedColumns, tr("ON Selected"), "");
  createRightClickMenuAction(MI_EnableAllColumns, tr("ON All"), "");
  createRightClickMenuAction(MI_DisableAllColumns, tr("OFF All"), "");
  createRightClickMenuAction(MI_DisableSelectedColumns, tr("OFF Selected"), "");
  createRightClickMenuAction(MI_SwapEnabledColumns, tr("Swap ON/OFF"), "");
  createRightClickMenuAction(MI_LockThisColumnOnly, tr("Lock This Only"),
                             "Shift+L");
  createRightClickMenuAction(MI_LockSelectedColumns, tr("Lock Selected"),
                             "Ctrl+Shift+L");
  createRightClickMenuAction(MI_LockAllColumns, tr("Lock All"),
                             "Ctrl+Alt+Shift+L");
  createRightClickMenuAction(MI_UnlockSelectedColumns, tr("Unlock Selected"),
                             "Ctrl+Shift+U");
  createRightClickMenuAction(MI_UnlockAllColumns, tr("Unlock All"),
                             "Ctrl+Alt+Shift+U");
  createRightClickMenuAction(MI_ToggleColumnLocks, tr("Swap Lock/Unlock"), "");
  /*-- カレントカラムの右側のカラムを全て非表示にするコマンド --*/
  createRightClickMenuAction(MI_DeactivateUpperColumns,
                             tr("Hide Upper Columns"), "");

  createRightClickMenuAction(MI_SeparateColors, tr("Separate Colors..."), "");

  createToolAction(T_Edit, "animate", tr("Animate Tool"), "A",
                   tr("Animate Tool: Modifies the position, rotation and size "
                      "of the current column"));
  createToolAction(
      T_Selection, "selection", tr("Selection Tool"), "S",
      tr("Selection Tool: Select parts of your image to transform it."));
  createToolAction(T_Brush, "brush", tr("Brush Tool"), "B",
                   tr("Brush Tool: Draws in the work area freehand"));
  createToolAction(T_Geometric, "geometric", tr("Geometry Tool"), "G",
                   tr("Geometry Tool: Draws geometric shapes"));
  createToolAction(T_Type, "type", tr("Type Tool"), "Y",
                   tr("Type Tool: Adds text"));
  createToolAction(T_Fill, "fill", tr("Fill Tool"), "F",
                   tr("Fill Tool: Fills drawing areas with the current style"));
  createToolAction(
      T_PaintBrush, "paintbrush", tr("Smart Raster Paint Tool"), "",
      tr("Smart Raster Paint: Paints areas in Smart Raster levels"));
  createToolAction(T_Eraser, "eraser", tr("Eraser Tool"), "E",
                   tr("Eraser Tool: Erases lines and areas"));
  createToolAction(
      T_Tape, "tape", tr("Tape Tool"), "T",
      tr("Tape Tool: Closes gaps in raster, joins edges in vector"));
  createToolAction(T_StylePicker, "stylepicker", tr("Style Picker Tool"), "K",
                   tr("Style Picker: Selects style on current drawing"));
  createToolAction(
      T_RGBPicker, "rgbpicker", tr("RGB Picker Tool"), "R",
      tr("RBG Picker: Picks color on screen and applies to current style"));
  createToolAction(T_ControlPointEditor, "controlpointeditor",
                   tr("Control Point Editor Tool"), "C",
                   tr("Control Point Editor: Modifies vector lines by editing "
                      "its control points"));
  createToolAction(T_Pinch, "pinch", tr("Pinch Tool"), "M",
                   tr("Pinch Tool: Pulls vector drawings"));
  createToolAction(T_Pump, "pump", tr("Pump Tool"), "",
                   tr("Pump Tool: Changes vector thickness"));
  createToolAction(T_Magnet, "magnet", tr("Magnet Tool"), "",
                   tr("Magnet Tool: Deforms vector lines"));
  createToolAction(
      T_Bender, "bender", tr("Bender Tool"), "",
      tr("Bender Tool: Bends vector shapes around the first click"));
  createToolAction(T_Iron, "iron", tr("Iron Tool"), "",
                   tr("Iron Tool: Smooths out vector lines"));
  createToolAction(T_Cutter, "cutter", tr("Cutter Tool"), "",
                   tr("Cutter Tool: Splits vector lines"));
  createToolAction(T_Skeleton, "skeleton", tr("Skeleton Tool"), "V",
                   tr("Skeleton Tool: Allows to build a skeleton and animate "
                      "in a cut-out workflow"));
  createToolAction(
      T_Tracker, "radar", tr("Tracker Tool"), "",
      tr("Tracker Tool: Tracks specific regions in a sequence of images"));
  createToolAction(T_Hook, "hook", tr("Hook Tool"), "O");
  createToolAction(T_Zoom, "zoom", tr("Zoom Tool"), "",
                   tr("Zoom Tool: Zooms viewer"));
  createToolAction(T_Rotate, "rotate", tr("Rotate Tool"), "",
                   tr("Rotate Tool: Rotate the viewer"));
  createToolAction(T_Hand, "hand", tr("Hand Tool"), "",
                   tr("Hand Tool: Pans the workspace (Space)"));
  createToolAction(T_Plastic, "plastic", tr("Plastic Tool"), "X",
                   tr("Plastic Tool: Builds a mesh that allows to deform and "
                      "animate a level"));
  createToolAction(T_Ruler, "ruler", tr("Ruler Tool"), "",
                   tr("Ruler Tool: Measure distances on the canvas"));
  createToolAction(T_Finger, "finger", tr("Finger Tool"), "",
                   tr("Finger Tool: Smudges small areas to cover with line"));

  createViewerAction(V_ZoomIn, tr("Zoom In"), "+");
  createViewerAction(V_ZoomOut, tr("Zoom Out"), "-");
  createViewerAction(V_ViewReset, tr("Reset View"), "Alt+0");
  createViewerAction(V_ZoomFit, tr("Fit to Window"), "Alt+9");
  createViewerAction(V_ZoomReset, tr("Reset Zoom"), "");
  createViewerAction(V_RotateReset, tr("Reset Rotation"), "");
  createViewerAction(V_PositionReset, tr("Reset Position"), "");

  createViewerAction(V_ActualPixelSize, tr("Actual Pixel Size"), "N");
  createViewerAction(V_FlipX, tr("Flip Viewer Horizontally"), "");
  createViewerAction(V_FlipY, tr("Flip Viewer Vertically"), "");
  createViewerAction(V_ShowHideFullScreen, tr("Show//Hide Full Screen"),
                     "Alt+F");
  CommandManager::instance()->setToggleTexts(V_ShowHideFullScreen,
                                             tr("Full Screen Mode"),
                                             tr("Exit Full Screen Mode"));
  createToolOptionsAction(MI_SelectNextGuideStroke,
                          tr("Select Next Frame Guide Stroke"), "");
  createToolOptionsAction(MI_SelectPrevGuideStroke,
                          tr("Select Previous Frame Guide Stroke"), "");
  createToolOptionsAction(MI_SelectBothGuideStrokes,
                          tr("Select Prev && Next Frame Guide Strokes"), "");
  createToolOptionsAction(MI_SelectGuideStrokeReset,
                          tr("Reset Guide Stroke Selections"), "");
  createToolOptionsAction(MI_TweenGuideStrokes,
                          tr("Tween Selected Guide Strokes"), "");
  createToolOptionsAction(MI_TweenGuideStrokeToSelected,
                          tr("Tween Guide Strokes to Selected"), "");
  createToolOptionsAction(MI_SelectGuidesAndTweenMode,
                          tr("Select Guide Strokes && Tween Mode"), "");
  createToolOptionsAction(MI_FlipNextGuideStroke,
                          tr("Flip Next Guide Stroke Direction"), "");
  createToolOptionsAction(MI_FlipPrevGuideStroke,
                          tr("Flip Previous Guide Stroke Direction"), "");

  // Following actions are for adding "Visualization" menu items to the command
  // bar. They are separated from the original actions in order to avoid
  // assigning shortcut keys. They must be triggered only from pressing buttons
  // in the command bar. Assinging shortcut keys and registering as MenuItem
  // will break a logic of ShortcutZoomer. So here we register separate items
  // and bypass the command.
  menuAct = createVisualizationButtonAction(VB_ViewReset, tr("Reset View"));
  menuAct->setIcon(createQIcon("reset"));

  menuAct = createVisualizationButtonAction(VB_ZoomFit, tr("Fit to Window"));
  menuAct->setIcon(createQIcon("fit_to_window"));

  createVisualizationButtonAction(VB_ZoomReset, tr("Reset Zoom"));
  createVisualizationButtonAction(VB_RotateReset, tr("Reset Rotation"));
  createVisualizationButtonAction(VB_PositionReset, tr("Reset Position"));

  menuAct = createVisualizationButtonAction(VB_ActualPixelSize,
                                            tr("Actual Pixel Size"));
  menuAct->setIcon(createQIcon("actual_pixel_size"));

  menuAct =
      createVisualizationButtonAction(VB_FlipX, tr("Flip Viewer Horizontally"));
  menuAct->setIcon(createQIcon("fliphoriz_off"));

  menuAct =
      createVisualizationButtonAction(VB_FlipY, tr("Flip Viewer Vertically"));
  menuAct->setIcon(createQIcon("flipvert_off"));

  menuAct = createMiscAction(MI_RefreshTree, tr("Refresh Folder Tree"), "");
  menuAct->setIconText(tr("Refresh"));
  menuAct->setIcon(createQIcon("refresh"));

  createToolOptionsAction("A_ToolOption_GlobalKey", tr("Global Key"), "");

  createToolOptionsAction("A_IncreaseMaxBrushThickness",
                          tr("Brush size - Increase max"), "I");
  createToolOptionsAction("A_DecreaseMaxBrushThickness",
                          tr("Brush size - Decrease max"), "U");
  createToolOptionsAction("A_IncreaseMinBrushThickness",
                          tr("Brush size - Increase min"), "J");
  createToolOptionsAction("A_DecreaseMinBrushThickness",
                          tr("Brush size - Decrease min"), "H");
  createToolOptionsAction("A_IncreaseBrushHardness",
                          tr("Brush hardness - Increase"), "");
  createToolOptionsAction("A_DecreaseBrushHardness",
                          tr("Brush hardness - Decrease"), "");
  createToolOptionsAction("A_ToolOption_SnapSensitivity",
                          tr("Snap Sensitivity"), "");
  createToolOptionsAction("A_ToolOption_AutoGroup", tr("Auto Group"), "");
  createToolOptionsAction("A_ToolOption_BreakSharpAngles",
                          tr("Break sharp angles"), "");
  createToolOptionsAction("A_ToolOption_FrameRange", tr("Frame range"), "F6");
  createToolOptionsAction("A_ToolOption_IK", tr("Inverse Kinematics"), "");
  createToolOptionsAction("A_ToolOption_Invert", tr("Invert"), "");
  createToolOptionsAction("A_ToolOption_Manual", tr("Manual"), "");
  createToolOptionsAction("A_ToolOption_OnionSkin", tr("Onion skin"), "");
  createToolOptionsAction("A_ToolOption_Orientation", tr("Orientation"), "");
  createToolOptionsAction("A_ToolOption_PencilMode", tr("Pencil Mode"), "");
  createToolOptionsAction("A_ToolOption_PreserveThickness",
                          tr("Preserve Thickness"), "");
  createToolOptionsAction("A_ToolOption_PressureSensitivity",
                          tr("Pressure Sensitivity"), "Shift+P");
  createToolOptionsAction("A_ToolOption_SegmentInk", tr("Segment Ink"), "F8");
  createToolOptionsAction("A_ToolOption_Selective", tr("Selective"), "F7");
  createToolOptionsAction("A_ToolOption_DrawOrder",
                          tr("Brush Tool - Draw Order"), "");
  createToolOptionsAction("A_ToolOption_Smooth", tr("Smooth"), "");
  createToolOptionsAction("A_ToolOption_Snap", tr("Snap"), "");
  createToolOptionsAction("A_ToolOption_AutoSelectDrawing",
                          tr("Auto Select Drawing"), "");
  createToolOptionsAction("A_ToolOption_Autofill", tr("Auto Fill"), "");
  createToolOptionsAction("A_ToolOption_JoinVectors", tr("Join Vectors"), "");
  createToolOptionsAction("A_ToolOption_ShowOnlyActiveSkeleton",
                          tr("Show Only Active Skeleton"), "");
  createToolOptionsAction("A_ToolOption_RasterEraser",
                          tr("Brush Tool - Eraser (Raster option)"), "");
  createToolOptionsAction("A_ToolOption_LockAlpha",
                          tr("Brush Tool - Lock Alpha"), "");

  // Option Menu
  createToolOptionsAction("A_ToolOption_BrushPreset", tr("Brush Preset"), "");
  createToolOptionsAction("A_ToolOption_GeometricShape", tr("Geometric Shape"),
                          "");
  createToolOptionsAction("A_ToolOption_GeometricShape:Rectangle",
                          tr("Geometric Shape Rectangle"), "");
  createToolOptionsAction("A_ToolOption_GeometricShape:Circle",
                          tr("Geometric Shape Circle"), "");
  createToolOptionsAction("A_ToolOption_GeometricShape:Ellipse",
                          tr("Geometric Shape Ellipse"), "");
  createToolOptionsAction("A_ToolOption_GeometricShape:Line",
                          tr("Geometric Shape Line"), "");
  createToolOptionsAction("A_ToolOption_GeometricShape:Polyline",
                          tr("Geometric Shape Polyline"), "");
  createToolOptionsAction("A_ToolOption_GeometricShape:Arc",
                          tr("Geometric Shape Arc"), "");
  createToolOptionsAction("A_ToolOption_GeometricShape:MultiArc",
                          tr("Geometric Shape MultiArc"), "");
  createToolOptionsAction("A_ToolOption_GeometricShape:Polygon",
                          tr("Geometric Shape Polygon"), "");
  createToolOptionsAction("A_ToolOption_GeometricEdge", tr("Geometric Edge"),
                          "");
  createToolOptionsAction("A_ToolOption_Mode", tr("Mode"), "");
  menuAct = createToolOptionsAction("A_ToolOption_Mode:Areas",
                                    tr("Mode - Areas"), "");
  menuAct->setIcon(createQIcon("mode_areas"));
  menuAct = createToolOptionsAction("A_ToolOption_Mode:Lines",
                                    tr("Mode - Lines"), "");
  menuAct->setIcon(createQIcon("mode_lines"));
  menuAct = createToolOptionsAction("A_ToolOption_Mode:Lines & Areas",
                                    tr("Mode - Lines && Areas"), "");
  menuAct->setIcon(createQIcon("mode_areas_lines"));
  createToolOptionsAction("A_ToolOption_Mode:Endpoint to Endpoint",
                          tr("Mode - Endpoint to Endpoint"), "");
  createToolOptionsAction("A_ToolOption_Mode:Endpoint to Line",
                          tr("Mode - Endpoint to Line"), "");
  createToolOptionsAction("A_ToolOption_Mode:Line to Line",
                          tr("Mode - Line to Line"), "");
  createToolOptionsAction("A_ToolOption_Type", tr("Type"), "");

  menuAct = createToolOptionsAction("A_ToolOption_Type:Normal",
                                    tr("Type - Normal"), "");
  menuAct->setIcon(createQIcon("type_normal"));

  menuAct = createToolOptionsAction("A_ToolOption_Type:Rectangular",
                                    tr("Type - Rectangular"), "F5");
  menuAct->setIcon(createQIcon("type_rectangular"));

  menuAct = createToolOptionsAction("A_ToolOption_Type:Freehand",
                                    tr("Type - Freehand"), "");
  menuAct->setIcon(createQIcon("type_lasso"));

  menuAct = createToolOptionsAction("A_ToolOption_Type:Polyline",
                                    tr("Type - Polyline"), "");
  menuAct->setIcon(createQIcon("type_polyline"));
  menuAct = createToolOptionsAction("A_ToolOption_Type:Segment",
                                    tr("Type - Segment"), "");
  menuAct->setIcon(createQIcon("type_erase_segment"));

  createToolOptionsAction("A_ToolOption_TypeFont", tr("TypeTool Font"), "");
  createToolOptionsAction("A_ToolOption_TypeSize", tr("TypeTool Size"), "");
  createToolOptionsAction("A_ToolOption_TypeStyle", tr("TypeTool Style"), "");
  createToolOptionsAction("A_ToolOption_TypeStyle:Oblique",
                          tr("TypeTool Style - Oblique"), "");
  createToolOptionsAction("A_ToolOption_TypeStyle:Regular",
                          tr("TypeTool Style - Regular"), "");
  createToolOptionsAction("A_ToolOption_TypeStyle:Bold Oblique",
                          tr("TypeTool Style - Bold Oblique"), "");
  createToolOptionsAction("A_ToolOption_TypeStyle:Bold",
                          tr("TypeTool Style - Bold"), "");

  createToolOptionsAction("A_ToolOption_EditToolActiveAxis", tr("Active Axis"),
                          "");
  createToolOptionsAction("A_ToolOption_EditToolActiveAxis:Position",
                          tr("Active Axis - Position"), "");
  createToolOptionsAction("A_ToolOption_EditToolActiveAxis:Rotation",
                          tr("Active Axis - Rotation"), "");
  createToolOptionsAction("A_ToolOption_EditToolActiveAxis:Scale",
                          tr("Active Axis - Scale"), "");
  createToolOptionsAction("A_ToolOption_EditToolActiveAxis:Shear",
                          tr("Active Axis - Shear"), "");
  createToolOptionsAction("A_ToolOption_EditToolActiveAxis:Center",
                          tr("Active Axis - Center"), "");
  createToolOptionsAction("A_ToolOption_EditToolActiveAxis:All",
                          tr("Active Axis - All"), "");

  createToolOptionsAction("A_ToolOption_SkeletonMode", tr("Skeleton Mode"), "");
  createToolOptionsAction("A_ToolOption_SkeletonMode:Edit Mesh",
                          tr("Edit Mesh Mode"), "");
  createToolOptionsAction("A_ToolOption_SkeletonMode:Paint Rigid",
                          tr("Paint Rigid Mode"), "");
  createToolOptionsAction("A_ToolOption_SkeletonMode:Build Skeleton",
                          tr("Build Skeleton Mode"), "");
  createToolOptionsAction("A_ToolOption_SkeletonMode:Animate",
                          tr("Animate Mode"), "");
  createToolOptionsAction("A_ToolOption_SkeletonMode:Inverse Kinematics",
                          tr("Inverse Kinematics Mode"), "");
  createToolOptionsAction("A_ToolOption_AutoSelect:None", tr("None Pick Mode"),
                          "");
  createToolOptionsAction("A_ToolOption_AutoSelect:Column",
                          tr("Column Pick Mode"), "");
  createToolOptionsAction("A_ToolOption_AutoSelect:Pegbar",
                          tr("Pegbar Pick Mode"), "");
  menuAct =
      createToolOptionsAction("A_ToolOption_PickScreen", tr("Pick Screen"), "");
  menuAct->setIcon(createQIcon("pickscreen"));
  createToolOptionsAction("A_ToolOption_Meshify", tr("Create Mesh"), "");

  menuAct = createToolOptionsAction("A_ToolOption_AutopaintLines",
                                    tr("Fill Tool - Autopaint Lines"), "");
  menuAct->setIcon(createQIcon("fill_auto"));

  /*-- Animate tool + mode switching shortcuts --*/
  createAction(MI_EditNextMode, tr("Animate Tool - Next Mode"), "", "",
               ToolCommandType);
  createAction(MI_EditPosition, tr("Animate Tool - Position"), "", "",
               ToolCommandType);
  createAction(MI_EditRotation, tr("Animate Tool - Rotation"), "", "",
               ToolCommandType);
  createAction(MI_EditScale, tr("Animate Tool - Scale"), "", "",
               ToolCommandType);
  createAction(MI_EditShear, tr("Animate Tool - Shear"), "", "",
               ToolCommandType);
  createAction(MI_EditCenter, tr("Animate Tool - Center"), "", "",
               ToolCommandType);
  createAction(MI_EditAll, tr("Animate Tool - All"), "", "", ToolCommandType);

  /*-- Selection tool + type switching shortcuts --*/
  createAction(MI_SelectionNextType, tr("Selection Tool - Next Type"), "", "",
               ToolCommandType);
  createAction(MI_SelectionRectangular, tr("Selection Tool - Rectangular"), "",
               "", ToolCommandType);
  createAction(MI_SelectionFreehand, tr("Selection Tool - Freehand"), "", "",
               ToolCommandType);
  createAction(MI_SelectionPolyline, tr("Selection Tool - Polyline"), "", "",
               ToolCommandType);

  /*-- Geometric tool + shape switching shortcuts --*/
  createAction(MI_GeometricNextShape, tr("Geometric Tool - Next Shape"), "", "",
               ToolCommandType);
  createAction(MI_GeometricRectangle, tr("Geometric Tool - Rectangle"), "", "",
               ToolCommandType);
  createAction(MI_GeometricCircle, tr("Geometric Tool - Circle"), "", "",
               ToolCommandType);
  createAction(MI_GeometricEllipse, tr("Geometric Tool - Ellipse"), "", "",
               ToolCommandType);
  createAction(MI_GeometricLine, tr("Geometric Tool - Line"), "", "",
               ToolCommandType);
  createAction(MI_GeometricPolyline, tr("Geometric Tool - Polyline"), "", "",
               ToolCommandType);
  createAction(MI_GeometricArc, tr("Geometric Tool - Arc"), "", "",
               ToolCommandType);
  createAction(MI_GeometricMultiArc, tr("Geometric Tool - MultiArc"), "", "",
               ToolCommandType);
  createAction(MI_GeometricPolygon, tr("Geometric Tool - Polygon"), "", "",
               ToolCommandType);

  /*-- Type tool + style switching shortcuts --*/
  createAction(MI_TypeNextStyle, tr("Type Tool - Next Style"), "", "",
               ToolCommandType);
  createAction(MI_TypeOblique, tr("Type Tool - Oblique"), "", "",
               ToolCommandType);
  createAction(MI_TypeRegular, tr("Type Tool - Regular"), "", "",
               ToolCommandType);
  createAction(MI_TypeBoldOblique, tr("Type Tool - Bold Oblique"), "", "",
               ToolCommandType);
  createAction(MI_TypeBold, tr("Type Tool - Bold"), "", "", ToolCommandType);

  /*-- Fill tool + type/mode switching shortcuts --*/
  createAction(MI_FillNextType, tr("Fill Tool - Next Type"), "", "",
               ToolCommandType);

  menuAct = createAction(MI_FillNormal, tr("Fill Tool - Normal"), "", "",
                         ToolCommandType);
  menuAct->setIcon(createQIcon("fill_normal"));
  menuAct = createAction(MI_FillRectangular, tr("Fill Tool - Rectangular"), "",
                         "", ToolCommandType);
  menuAct->setIcon(createQIcon("fill_rectangular"));
  menuAct = createAction(MI_FillFreehand, tr("Fill Tool - Freehand"), "", "",
                         ToolCommandType);
  menuAct->setIcon(createQIcon("fill_freehand"));
  menuAct = createAction(MI_FillPolyline, tr("Fill Tool - Polyline"), "", "",
                         ToolCommandType);
  menuAct->setIcon(createQIcon("fill_polyline"));
  createAction(MI_FillNextMode, tr("Fill Tool - Next Mode"), "", "",
               ToolCommandType);
  createAction(MI_FillAreas, tr("Fill Tool - Areas"), "", "", ToolCommandType);
  createAction(MI_FillLines, tr("Fill Tool - Lines"), "", "", ToolCommandType);
  createAction(MI_FillLinesAndAreas, tr("Fill Tool - Lines & Areas"), "", "",
               ToolCommandType);

  /*-- Eraser tool + type switching shortcuts --*/
  createAction(MI_EraserNextType, tr("Eraser Tool - Next Type"), "", "",
               ToolCommandType);
  createAction(MI_EraserNormal, tr("Eraser Tool - Normal"), "", "",
               ToolCommandType);
  createAction(MI_EraserRectangular, tr("Eraser Tool - Rectangular"), "", "",
               ToolCommandType);
  createAction(MI_EraserFreehand, tr("Eraser Tool - Freehand"), "", "",
               ToolCommandType);
  createAction(MI_EraserPolyline, tr("Eraser Tool - Polyline"), "", "",
               ToolCommandType);
  createAction(MI_EraserSegment, tr("Eraser Tool - Segment"), "", "",
               ToolCommandType);

  /*-- Tape tool + type/mode switching shortcuts --*/
  createAction(MI_TapeNextType, tr("Tape Tool - Next Type"), "", "",
               ToolCommandType);
  createAction(MI_TapeNormal, tr("Tape Tool - Normal"), "", "",
               ToolCommandType);
  createAction(MI_TapeRectangular, tr("Tape Tool - Rectangular"), "", "",
               ToolCommandType);
  createAction(MI_TapeNextMode, tr("Tape Tool - Next Mode"), "", "",
               ToolCommandType);
  createAction(MI_TapeEndpointToEndpoint,
               tr("Tape Tool - Endpoint to Endpoint"), "", "", ToolCommandType);
  createAction(MI_TapeEndpointToLine, tr("Tape Tool - Endpoint to Line"), "",
               "", ToolCommandType);
  createAction(MI_TapeLineToLine, tr("Tape Tool - Line to Line"), "", "",
               ToolCommandType);

  /*-- Style Picker tool + mode switching shortcuts --*/
  createAction(MI_PickStyleNextMode, tr("Style Picker Tool - Next Mode"), "",
               "", ToolCommandType);
  createAction(MI_PickStyleAreas, tr("Style Picker Tool - Areas"), "", "",
               ToolCommandType);
  createAction(MI_PickStyleLines, tr("Style Picker Tool - Lines"), "", "",
               ToolCommandType);
  createAction(MI_PickStyleLinesAndAreas,
               tr("Style Picker Tool - Lines & Areas"), "", "",
               ToolCommandType);

  /*-- RGB Picker tool + type switching shortcuts --*/
  createAction(MI_RGBPickerNextType, tr("RGB Picker Tool - Next Type"), "", "",
               ToolCommandType);
  createAction(MI_RGBPickerNormal, tr("RGB Picker Tool - Normal"), "", "",
               ToolCommandType);
  createAction(MI_RGBPickerRectangular, tr("RGB Picker Tool - Rectangular"), "",
               "", ToolCommandType);
  createAction(MI_RGBPickerFreehand, tr("RGB Picker Tool - Freehand"), "", "",
               ToolCommandType);
  createAction(MI_RGBPickerPolyline, tr("RGB Picker Tool - Polyline"), "", "",
               ToolCommandType);

  /*-- Skeleton tool + mode switching shortcuts --*/
  createAction(MI_SkeletonNextMode, tr("Skeleton Tool - Next Mode"), "", "",
               ToolCommandType);
  createAction(MI_SkeletonBuildSkeleton, tr("Skeleton Tool - Build Skeleton"),
               "", "", ToolCommandType);
  createAction(MI_SkeletonAnimate, tr("Skeleton Tool - Animate"), "", "",
               ToolCommandType);
  createAction(MI_SkeletonInverseKinematics,
               tr("Skeleton Tool - Inverse Kinematics"), "", "",
               ToolCommandType);

  /*-- Plastic tool + mode switching shortcuts --*/
  createAction(MI_PlasticNextMode, tr("Plastic Tool - Next Mode"), "", "",
               ToolCommandType);
  createAction(MI_PlasticEditMesh, tr("Plastic Tool - Edit Mesh"), "", "",
               ToolCommandType);
  createAction(MI_PlasticPaintRigid, tr("Plastic Tool - Paint Rigid"), "", "",
               ToolCommandType);
  createAction(MI_PlasticBuildSkeleton, tr("Plastic Tool - Build Skeleton"), "",
               "", ToolCommandType);
  createAction(MI_PlasticAnimate, tr("Plastic Tool - Animate"), "", "",
               ToolCommandType);

  createMiscAction("A_FxSchematicToggle", tr("Toggle FX/Stage schematic"), "");

  createStopMotionAction(MI_StopMotionCapture, tr("Capture Stop Motion Frame"),
                         "");
  createStopMotionAction(MI_StopMotionRaiseOpacity,
                         tr("Raise Stop Motion Opacity"), "");
  createStopMotionAction(MI_StopMotionLowerOpacity,
                         tr("Lower Stop Motion Opacity"), "");
  createStopMotionAction(MI_StopMotionToggleLiveView,
                         tr("Toggle Stop Motion Live View"), "");
#ifdef WITH_CANON
  createStopMotionAction(MI_StopMotionToggleZoom, tr("Toggle Stop Motion Zoom"),
                         "");
  createStopMotionAction(MI_StopMotionPickFocusCheck,
                         tr("Pick Focus Check Location"), "");
#endif
  createStopMotionAction(MI_StopMotionLowerSubsampling,
                         tr("Lower Stop Motion Level Subsampling"), "");
  createStopMotionAction(MI_StopMotionRaiseSubsampling,
                         tr("Raise Stop Motion Level Subsampling"), "");
  createStopMotionAction(MI_StopMotionJumpToCamera,
                         tr("Go to Stop Motion Insert Frame"), "");
  createStopMotionAction(MI_StopMotionRemoveFrame,
                         tr("Remove frame before Stop Motion Camera"), "");
  createStopMotionAction(MI_StopMotionNextFrame,
                         tr("Next Frame including Stop Motion Camera"), "");
  createStopMotionAction(MI_StopMotionToggleUseLiveViewImages,
                         tr("Show original live view images."), "");
}

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

void MainWindow::onInkCheckTriggered(bool on) {
  if (!on) return;
  QAction *ink1CheckAction =
      CommandManager::instance()->getAction(MI_Ink1Check);
  if (ink1CheckAction) ink1CheckAction->setChecked(false);
}

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

void MainWindow::onInk1CheckTriggered(bool on) {
  if (!on) return;
  QAction *inkCheckAction = CommandManager::instance()->getAction(MI_ICheck);
  if (inkCheckAction) inkCheckAction->setChecked(false);
}

//-----------------------------------------------------------------------------
/*-- Animate tool + mode switching shortcuts --*/
void MainWindow::toggleEditNextMode() {
  if (TApp::instance()->getCurrentTool()->getTool()->getName() == T_Edit)
    CommandManager::instance()
        ->getAction("A_ToolOption_EditToolActiveAxis")
        ->trigger();
  else
    CommandManager::instance()->getAction(T_Edit)->trigger();
}

void MainWindow::toggleEditPosition() {
  CommandManager::instance()->getAction(T_Edit)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_EditToolActiveAxis:Position")
      ->trigger();
}

void MainWindow::toggleEditRotation() {
  CommandManager::instance()->getAction(T_Edit)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_EditToolActiveAxis:Rotation")
      ->trigger();
}

void MainWindow::toggleEditNextScale() {
  CommandManager::instance()->getAction(T_Edit)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_EditToolActiveAxis:Scale")
      ->trigger();
}

void MainWindow::toggleEditNextShear() {
  CommandManager::instance()->getAction(T_Edit)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_EditToolActiveAxis:Shear")
      ->trigger();
}

void MainWindow::toggleEditNextCenter() {
  CommandManager::instance()->getAction(T_Edit)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_EditToolActiveAxis:Center")
      ->trigger();
}

void MainWindow::toggleEditNextAll() {
  CommandManager::instance()->getAction(T_Edit)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_EditToolActiveAxis:All")
      ->trigger();
}

//---------------------------------------------------------------------------------------
/*-- Selection tool + type switching shortcuts --*/
void MainWindow::toggleSelectionNextType() {
  if (TApp::instance()->getCurrentTool()->getTool()->getName() == T_Selection)
    CommandManager::instance()->getAction("A_ToolOption_Type")->trigger();
  else
    CommandManager::instance()->getAction(T_Selection)->trigger();
}

void MainWindow::toggleSelectionRectangular() {
  CommandManager::instance()->getAction(T_Selection)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Type:Rectangular")
      ->trigger();
}

void MainWindow::toggleSelectionFreehand() {
  CommandManager::instance()->getAction(T_Selection)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Type:Freehand")
      ->trigger();
}

void MainWindow::toggleSelectionPolyline() {
  CommandManager::instance()->getAction(T_Selection)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Type:Polyline")
      ->trigger();
}

//---------------------------------------------------------------------------------------
/*-- Geometric tool + shape switching shortcuts --*/
void MainWindow::toggleGeometricNextShape() {
  if (TApp::instance()->getCurrentTool()->getTool()->getName() == T_Geometric)
    CommandManager::instance()
        ->getAction("A_ToolOption_GeometricShape")
        ->trigger();
  else
    CommandManager::instance()->getAction(T_Geometric)->trigger();
}

void MainWindow::toggleGeometricRectangle() {
  CommandManager::instance()->getAction(T_Geometric)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_GeometricShape:Rectangle")
      ->trigger();
}

void MainWindow::toggleGeometricCircle() {
  CommandManager::instance()->getAction(T_Geometric)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_GeometricShape:Circle")
      ->trigger();
}

void MainWindow::toggleGeometricEllipse() {
  CommandManager::instance()->getAction(T_Geometric)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_GeometricShape:Ellipse")
      ->trigger();
}

void MainWindow::toggleGeometricLine() {
  CommandManager::instance()->getAction(T_Geometric)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_GeometricShape:Line")
      ->trigger();
}

void MainWindow::toggleGeometricPolyline() {
  CommandManager::instance()->getAction(T_Geometric)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_GeometricShape:Polyline")
      ->trigger();
}

void MainWindow::toggleGeometricArc() {
  CommandManager::instance()->getAction(T_Geometric)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_GeometricShape:Arc")
      ->trigger();
}

void MainWindow::toggleGeometricMultiArc() {
  CommandManager::instance()->getAction(T_Geometric)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_GeometricShape:MultiArc")
      ->trigger();
}

void MainWindow::toggleGeometricPolygon() {
  CommandManager::instance()->getAction(T_Geometric)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_GeometricShape:Polygon")
      ->trigger();
}
//---------------------------------------------------------------------------------------
/*-- Type tool + mode switching shortcuts --*/
void MainWindow::toggleTypeNextStyle() {
  if (TApp::instance()->getCurrentTool()->getTool()->getName() == T_Type)
    CommandManager::instance()->getAction("A_ToolOption_TypeStyle")->trigger();
  else
    CommandManager::instance()->getAction(T_Type)->trigger();
}

void MainWindow::toggleTypeOblique() {
  CommandManager::instance()->getAction(T_Type)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_TypeStyle:Oblique")
      ->trigger();
}

void MainWindow::toggleTypeRegular() {
  CommandManager::instance()->getAction(T_Type)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_TypeStyle:Regular")
      ->trigger();
}

void MainWindow::toggleTypeBoldOblique() {
  CommandManager::instance()->getAction(T_Type)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_TypeStyle:Bold Oblique")
      ->trigger();
}

void MainWindow::toggleTypeBold() {
  CommandManager::instance()->getAction(T_Type)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_TypeStyle:Bold")
      ->trigger();
}

//---------------------------------------------------------------------------------------
/*-- Fill tool + type/mode switching shortcuts --*/
void MainWindow::toggleFillNextType() {
  if (TApp::instance()->getCurrentTool()->getTool()->getName() == T_Fill)
    CommandManager::instance()->getAction("A_ToolOption_Type")->trigger();
  else
    CommandManager::instance()->getAction(T_Fill)->trigger();
}

void MainWindow::toggleFillNormal() {
  CommandManager::instance()->getAction(T_Fill)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
}

void MainWindow::toggleFillRectangular() {
  CommandManager::instance()->getAction(T_Fill)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Type:Rectangular")
      ->trigger();
}

void MainWindow::toggleFillFreehand() {
  CommandManager::instance()->getAction(T_Fill)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Type:Freehand")
      ->trigger();
}

void MainWindow::toggleFillPolyline() {
  CommandManager::instance()->getAction(T_Fill)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Type:Polyline")
      ->trigger();
}

void MainWindow::toggleFillNextMode() {
  if (TApp::instance()->getCurrentTool()->getTool()->getName() == T_Fill)
    CommandManager::instance()->getAction("A_ToolOption_Mode")->trigger();
  else
    CommandManager::instance()->getAction(T_Fill)->trigger();
}

void MainWindow::toggleFillAreas() {
  CommandManager::instance()->getAction(T_Fill)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Mode:Areas")->trigger();
}

void MainWindow::toggleFillLines() {
  CommandManager::instance()->getAction(T_Fill)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Mode:Lines")->trigger();
}

void MainWindow::toggleFillLinesAndAreas() {
  CommandManager::instance()->getAction(T_Fill)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Mode:Lines & Areas")
      ->trigger();
}

//---------------------------------------------------------------------------------------
/*-- Eraser tool + type switching shortcuts --*/
void MainWindow::toggleEraserNextType() {
  if (TApp::instance()->getCurrentTool()->getTool()->getName() == T_Eraser)
    CommandManager::instance()->getAction("A_ToolOption_Type")->trigger();
  else
    CommandManager::instance()->getAction(T_Eraser)->trigger();
}

void MainWindow::toggleEraserNormal() {
  CommandManager::instance()->getAction(T_Eraser)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
}

void MainWindow::toggleEraserRectangular() {
  CommandManager::instance()->getAction(T_Eraser)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Type:Rectangular")
      ->trigger();
}

void MainWindow::toggleEraserFreehand() {
  CommandManager::instance()->getAction(T_Eraser)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Type:Freehand")
      ->trigger();
}

void MainWindow::toggleEraserPolyline() {
  CommandManager::instance()->getAction(T_Eraser)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Type:Polyline")
      ->trigger();
}

void MainWindow::toggleEraserSegment() {
  CommandManager::instance()->getAction(T_Eraser)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Segment")->trigger();
}
//---------------------------------------------------------------------------------------
/*-- Tape tool + type/mode switching shortcuts --*/
void MainWindow::toggleTapeNextType() {
  if (TApp::instance()->getCurrentTool()->getTool()->getName() == T_Tape)
    CommandManager::instance()->getAction("A_ToolOption_Type")->trigger();
  else
    CommandManager::instance()->getAction(T_Tape)->trigger();
}

void MainWindow::toggleTapeNormal() {
  CommandManager::instance()->getAction(T_Tape)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
}

void MainWindow::toggleTapeRectangular() {
  CommandManager::instance()->getAction(T_Tape)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Type:Rectangular")
      ->trigger();
}

void MainWindow::toggleTapeNextMode() {
  if (TApp::instance()->getCurrentTool()->getTool()->getName() == T_Tape)
    CommandManager::instance()->getAction("A_ToolOption_Mode")->trigger();
  else
    CommandManager::instance()->getAction(T_Tape)->trigger();
}

void MainWindow::toggleTapeEndpointToEndpoint() {
  CommandManager::instance()->getAction(T_Tape)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Mode:Endpoint to Endpoint")
      ->trigger();
}

void MainWindow::toggleTapeEndpointToLine() {
  CommandManager::instance()->getAction(T_Tape)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Mode:Endpoint to Line")
      ->trigger();
}

void MainWindow::toggleTapeLineToLine() {
  CommandManager::instance()->getAction(T_Tape)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Mode:Line to Line")
      ->trigger();
}

//---------------------------------------------------------------------------------------
/*-- Style Picker tool + mode switching shortcuts --*/
void MainWindow::togglePickStyleNextMode() {
  if (TApp::instance()->getCurrentTool()->getTool()->getName() == T_StylePicker)
    CommandManager::instance()->getAction("A_ToolOption_Mode")->trigger();
  else
    CommandManager::instance()->getAction(T_StylePicker)->trigger();
}

void MainWindow::togglePickStyleAreas() {
  CommandManager::instance()->getAction(T_StylePicker)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Mode:Areas")->trigger();
}

void MainWindow::togglePickStyleLines() {
  CommandManager::instance()->getAction(T_StylePicker)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Mode:Lines")->trigger();
}

void MainWindow::togglePickStyleLinesAndAreas() {
  CommandManager::instance()->getAction(T_StylePicker)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Mode:Lines & Areas")
      ->trigger();
}
//-----------------------------------------------------------------------------
/*-- RGB Picker tool + type switching shortcuts --*/
void MainWindow::toggleRGBPickerNextType() {
  if (TApp::instance()->getCurrentTool()->getTool()->getName() == T_RGBPicker)
    CommandManager::instance()->getAction("A_ToolOption_Type")->trigger();
  else
    CommandManager::instance()->getAction(T_RGBPicker)->trigger();
}

void MainWindow::toggleRGBPickerNormal() {
  CommandManager::instance()->getAction(T_RGBPicker)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
}

void MainWindow::toggleRGBPickerRectangular() {
  CommandManager::instance()->getAction(T_RGBPicker)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Type:Rectangular")
      ->trigger();
}

void MainWindow::toggleRGBPickerFreehand() {
  CommandManager::instance()->getAction(T_RGBPicker)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Type:Freehand")
      ->trigger();
}

void MainWindow::toggleRGBPickerPolyline() {
  CommandManager::instance()->getAction(T_RGBPicker)->trigger();
  CommandManager::instance()->getAction("A_ToolOption_Type:Normal")->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_Type:Polyline")
      ->trigger();
}
//-----------------------------------------------------------------------------
/*-- Skeleton tool + type switching shortcuts --*/
void MainWindow::ToggleSkeletonNextMode() {
  if (TApp::instance()->getCurrentTool()->getTool()->getName() == T_Skeleton)
    CommandManager::instance()
        ->getAction("A_ToolOption_SkeletonMode")
        ->trigger();
  else
    CommandManager::instance()->getAction(T_Skeleton)->trigger();
}

void MainWindow::ToggleSkeletonBuildSkeleton() {
  CommandManager::instance()->getAction(T_Skeleton)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_SkeletonMode:Build Skeleton")
      ->trigger();
}

void MainWindow::ToggleSkeletonAnimate() {
  CommandManager::instance()->getAction(T_Skeleton)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_SkeletonMode:Animate")
      ->trigger();
}

void MainWindow::ToggleSkeletonInverseKinematics() {
  CommandManager::instance()->getAction(T_Skeleton)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_SkeletonMode:Inverse Kinematics")
      ->trigger();
}

//-----------------------------------------------------------------------------
/*-- Plastic tool + mode switching shortcuts --*/
void MainWindow::TogglePlasticNextMode() {
  if (TApp::instance()->getCurrentTool()->getTool()->getName() == T_Plastic)
    CommandManager::instance()
        ->getAction("A_ToolOption_SkeletonMode")
        ->trigger();
  else
    CommandManager::instance()->getAction(T_Plastic)->trigger();
}

void MainWindow::TogglePlasticEditMesh() {
  CommandManager::instance()->getAction(T_Plastic)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_SkeletonMode:Edit Mesh")
      ->trigger();
}

void MainWindow::TogglePlasticPaintRigid() {
  CommandManager::instance()->getAction(T_Plastic)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_SkeletonMode:Paint Rigid")
      ->trigger();
}

void MainWindow::TogglePlasticBuildSkeleton() {
  CommandManager::instance()->getAction(T_Plastic)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_SkeletonMode:Build Skeleton")
      ->trigger();
}

void MainWindow::TogglePlasticAnimate() {
  CommandManager::instance()->getAction(T_Plastic)->trigger();
  CommandManager::instance()
      ->getAction("A_ToolOption_SkeletonMode:Animate")
      ->trigger();
}

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

void MainWindow::onNewVectorLevelButtonPressed() {
  int defaultLevelType = Preferences::instance()->getDefLevelType();
  Preferences::instance()->setValue(DefLevelType, PLI_XSHLEVEL);
  CommandManager::instance()->execute("MI_NewLevel");
  Preferences::instance()->setValue(DefLevelType, defaultLevelType);
}

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

void MainWindow::onNewToonzRasterLevelButtonPressed() {
  int defaultLevelType = Preferences::instance()->getDefLevelType();
  Preferences::instance()->setValue(DefLevelType, TZP_XSHLEVEL);
  CommandManager::instance()->execute("MI_NewLevel");
  Preferences::instance()->setValue(DefLevelType, defaultLevelType);
}

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

void MainWindow::onNewRasterLevelButtonPressed() {
  int defaultLevelType = Preferences::instance()->getDefLevelType();
  Preferences::instance()->setValue(DefLevelType, OVL_XSHLEVEL);
  CommandManager::instance()->execute("MI_NewLevel");
  Preferences::instance()->setValue(DefLevelType, defaultLevelType);
}

//-----------------------------------------------------------------------------
// delete unused files / folders in the cache
void MainWindow::clearCacheFolder() {
  // currently cache folder is used for following purposes
  // 1. $CACHE/[ProcessID] : for disk swap of image cache.
  //    To be deleted on exit. Remains on crash.
  // 2. $CACHE/ffmpeg : ffmpeg cache.
  //    To be cleared on the end of rendering, on exist and on launch.
  // 3. $CACHE/temp : untitled scene data.
  //    To be deleted on switching or exiting scenes. Remains on crash.

  // So, this function will delete all files / folders in $CACHE
  // except the following items:
  // 1. $CACHE/[Current ProcessID]
  // 2. $CACHE/temp/[Current scene folder] if the current scene is untitled

  TFilePath cacheRoot                = ToonzFolder::getCacheRootFolder();
  if (cacheRoot.isEmpty()) cacheRoot = TEnv::getStuffDir() + "cache";

  TFilePathSet filesToBeRemoved;

  TSystem::readDirectory(filesToBeRemoved, cacheRoot, false);

  // keep the imagecache folder
  filesToBeRemoved.remove(cacheRoot + std::to_string(TSystem::getProcessId()));
  // keep the untitled scene data folder
  if (TApp::instance()->getCurrentScene()->getScene()->isUntitled()) {
    filesToBeRemoved.remove(cacheRoot + "temp");
    TFilePathSet untitledData =
        TSystem::readDirectory(cacheRoot + "temp", false);
    untitledData.remove(TApp::instance()
                            ->getCurrentScene()
                            ->getScene()
                            ->getScenePath()
                            .getParentDir());
    filesToBeRemoved.insert(filesToBeRemoved.end(), untitledData.begin(),
                            untitledData.end());
  }

  // return if there is no files/folders to be deleted
  if (filesToBeRemoved.size() == 0) {
    QMessageBox::information(
        this, tr("Clear Cache Folder"),
        tr("There are no unused items in the cache folder."));
    return;
  }

  QString message(tr("Deleting the following items:\n"));
  int count = 0;
  for (const auto &fileToBeRemoved : filesToBeRemoved) {
    QString dirPrefix =
        (TFileStatus(fileToBeRemoved).isDirectory()) ? tr("<DIR> ") : "";
    message +=
        "   " + dirPrefix + (fileToBeRemoved - cacheRoot).getQString() + "\n";
    count++;
    if (count == 5) break;
  }
  if (filesToBeRemoved.size() > 5)
    message +=
        tr("   ... and %1 more items\n").arg(filesToBeRemoved.size() - 5);

  message +=
      tr("\nAre you sure?\n\nN.B. Make sure you are not running another "
         "process of Tahoma2D,\nor you may delete necessary files for it.");

  QMessageBox::StandardButton ret = QMessageBox::question(
      this, tr("Clear Cache Folder"), message,
      QMessageBox::StandardButtons(QMessageBox::Ok | QMessageBox::Cancel));

  if (ret != QMessageBox::Ok) return;

  for (const auto &fileToBeRemoved : filesToBeRemoved) {
    try {
      if (TFileStatus(fileToBeRemoved).isDirectory())
        TSystem::rmDirTree(fileToBeRemoved);
      else
        TSystem::deleteFile(fileToBeRemoved);
    } catch (TException &e) {
      QMessageBox::warning(
          this, tr("Clear Cache Folder"),
          tr("Can't delete %1 : ").arg(fileToBeRemoved.getQString()) +
              QString::fromStdWString(e.getMessage()));
    } catch (...) {
      QMessageBox::warning(
          this, tr("Clear Cache Folder"),
          tr("Can't delete %1 : ").arg(fileToBeRemoved.getQString()));
    }
  }
}

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

void MainWindow::toggleStatusBar(bool on) {
  if (!on) {
    m_statusBar->hide();
    ShowStatusBarAction = 0;
  } else {
    m_statusBar->show();
    ShowStatusBarAction = 1;
  }
}

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

void MainWindow::toggleTransparency(bool on) {
  if (!on) {
    this->setProperty("windowOpacity", 1.0);
  } else {
    this->setProperty("windowOpacity", (double)TransparencySliderValue / 100);
    m_transparencyTogglerWindow->show();
  }
}

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

void MainWindow::makeTransparencyDialog() {
  m_transparencyTogglerWindow = new QDialog();
  m_transparencyTogglerWindow->setWindowFlags(Qt::WindowStaysOnTopHint |
                                              Qt::WindowCloseButtonHint);

  m_transparencyTogglerWindow->setFixedHeight(100);
  m_transparencyTogglerWindow->setFixedWidth(250);
  m_transparencyTogglerWindow->setWindowTitle(tr("Tahoma2D Transparency"));
  QPushButton *toggleButton = new QPushButton(this);
  toggleButton->setText(tr("Close to turn off Transparency."));
  connect(toggleButton, &QPushButton::clicked,
          [=]() { m_transparencyTogglerWindow->accept(); });
  m_transparencySlider = new QSlider(this);
  m_transparencySlider->setRange(-100, -30);
  m_transparencySlider->setValue(TransparencySliderValue * -1);
  m_transparencySlider->setOrientation(Qt::Horizontal);
  connect(m_transparencySlider, &QSlider::valueChanged, [=](int value) {
    TransparencySliderValue = value * -1;
    toggleTransparency(true);
  });

  QVBoxLayout *togglerLayout       = new QVBoxLayout(this);
  QHBoxLayout *togglerSliderLayout = new QHBoxLayout(this);
  togglerSliderLayout->addWidget(new QLabel(tr("Amount: "), this));
  togglerSliderLayout->addWidget(m_transparencySlider);
  togglerLayout->addLayout(togglerSliderLayout);
  togglerLayout->addWidget(toggleButton);

  m_transparencyTogglerWindow->setLayout(togglerLayout);
}

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

class ToggleStatusBar final : public MenuItemHandler {
public:
  ToggleStatusBar() : MenuItemHandler("MI_ShowStatusBar") {}
  void execute() override {}
} toggleStatusBar;

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

class ToggleTransparency final : public MenuItemHandler {
public:
  ToggleTransparency() : MenuItemHandler("MI_ToggleTransparent") {}
  void execute() override {}
} toggleTransparency;

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

class ReloadStyle final : public MenuItemHandler {
public:
  ReloadStyle() : MenuItemHandler("MI_ReloadStyle") {}
  void execute() override {
    QString currentStyle = Preferences::instance()->getCurrentStyleSheetPath();
    QFile file(currentStyle);
    file.open(QFile::ReadOnly);
    QString styleSheet = QString(file.readAll());
    qApp->setStyleSheet(styleSheet);
    file.close();
  }
} reloadStyle;

void MainWindow::onQuit() { close(); }

//=============================================================================
// RecentFiles
//=============================================================================

RecentFiles::RecentFiles()
    : m_recentScenes(), m_recentSceneProjects(), m_recentLevels() {}

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

RecentFiles *RecentFiles::instance() {
  static RecentFiles _instance;
  return &_instance;
}

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

RecentFiles::~RecentFiles() {}

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

void RecentFiles::addFilePath(QString path, FileType fileType,
                              QString projectName) {
  QList<QString> files =
      (fileType == Scene) ? m_recentScenes : (fileType == Level)
                                                 ? m_recentLevels
                                                 : m_recentFlipbookImages;
  int i;
  for (i = 0; i < files.size(); i++)
    if (files.at(i) == path) {
      files.removeAt(i);
      if (fileType == Scene) m_recentSceneProjects.removeAt(i);
    }
  files.insert(0, path);
  if (fileType == Scene) m_recentSceneProjects.insert(0, projectName);
  int maxSize = 10;
  if (files.size() > maxSize) {
    files.removeAt(maxSize);
    if (fileType == Scene) m_recentSceneProjects.removeAt(maxSize);
  }

  if (fileType == Scene)
    m_recentScenes = files;
  else if (fileType == Level)
    m_recentLevels = files;
  else
    m_recentFlipbookImages = files;

  refreshRecentFilesMenu(fileType);
  saveRecentFiles();
}

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

void RecentFiles::moveFilePath(int fromIndex, int toIndex, FileType fileType) {
  if (fileType == Scene) {
    m_recentScenes.move(fromIndex, toIndex);
    m_recentSceneProjects.move(fromIndex, toIndex);
  } else if (fileType == Level)
    m_recentLevels.move(fromIndex, toIndex);
  else
    m_recentFlipbookImages.move(fromIndex, toIndex);
  saveRecentFiles();
}

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

void RecentFiles::removeFilePath(int index, FileType fileType) {
  if (fileType == Scene) {
    m_recentScenes.removeAt(index);
    m_recentSceneProjects.removeAt(index);
  } else if (fileType == Level)
    m_recentLevels.removeAt(index);
  saveRecentFiles();
}

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

QString RecentFiles::getFilePath(int index, FileType fileType) const {
  return (fileType == Scene)
             ? m_recentScenes[index]
             : (fileType == Level) ? m_recentLevels[index]
                                   : m_recentFlipbookImages[index];
}

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

QString RecentFiles::getFileProject(int index) const {
  if (index >= m_recentScenes.size() || index >= m_recentSceneProjects.size())
    return "-";
  return m_recentSceneProjects[index];
}

QString RecentFiles::getFileProject(QString fileName) const {
  for (int index = 0; index < m_recentScenes.size(); index++)
    if (m_recentScenes[index] == fileName) return m_recentSceneProjects[index];

  return "-";
}

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

void RecentFiles::clearRecentFilesList(FileType fileType) {
  if (fileType == Scene) {
    m_recentScenes.clear();
    m_recentSceneProjects.clear();
  } else if (fileType == Level)
    m_recentLevels.clear();
  else
    m_recentFlipbookImages.clear();

  refreshRecentFilesMenu(fileType);
  saveRecentFiles();
}

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

void RecentFiles::loadRecentFiles() {
  TFilePath fp = ToonzFolder::getMyModuleDir() + TFilePath("RecentFiles.ini");
  QSettings settings(toQString(fp), QSettings::IniFormat);
  int i;

  QList<QVariant> scenes = settings.value(QString("Scenes")).toList();
  if (!scenes.isEmpty()) {
    for (i = 0; i < scenes.size(); i++)
      m_recentScenes.append(scenes.at(i).toString());
  } else {
    QString scene = settings.value(QString("Scenes")).toString();
    if (!scene.isEmpty()) m_recentScenes.append(scene);
  }

  // Load scene's projects info. This is for display purposes only. For
  // backwards compatibility it is stored and maintained separately.
  QList<QVariant> sceneProjects =
      settings.value(QString("SceneProjects")).toList();
  if (!sceneProjects.isEmpty()) {
    for (i = 0; i < sceneProjects.size(); i++)
      m_recentSceneProjects.append(sceneProjects.at(i).toString());
  } else {
    QString sceneProject = settings.value(QString("SceneProjects")).toString();
    if (!sceneProject.isEmpty()) m_recentSceneProjects.append(sceneProject);
  }
  // Should be 1-to-1. If we're short, append projects list with "-".
  while (m_recentSceneProjects.size() < m_recentScenes.size())
    m_recentSceneProjects.append("-");

  QList<QVariant> levels = settings.value(QString("Levels")).toList();
  if (!levels.isEmpty()) {
    for (i = 0; i < levels.size(); i++) {
      QString path = levels.at(i).toString();
#ifdef x64
      if (path.endsWith(".mov") || path.endsWith(".3gp") ||
          path.endsWith(".pct") || path.endsWith(".pict"))
        continue;
#endif
      m_recentLevels.append(path);
    }
  } else {
    QString level = settings.value(QString("Levels")).toString();
    if (!level.isEmpty()) m_recentLevels.append(level);
  }

  QList<QVariant> flipImages =
      settings.value(QString("FlipbookImages")).toList();
  if (!flipImages.isEmpty()) {
    for (i = 0; i < flipImages.size(); i++)
      m_recentFlipbookImages.append(flipImages.at(i).toString());
  } else {
    QString flipImage = settings.value(QString("FlipbookImages")).toString();
    if (!flipImage.isEmpty()) m_recentFlipbookImages.append(flipImage);
  }

  refreshRecentFilesMenu(Scene);
  refreshRecentFilesMenu(Level);
  refreshRecentFilesMenu(Flip);
}

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

void RecentFiles::saveRecentFiles() {
  TFilePath fp = ToonzFolder::getMyModuleDir() + TFilePath("RecentFiles.ini");
  QSettings settings(toQString(fp), QSettings::IniFormat);
  settings.setValue(QString("Scenes"), QVariant(m_recentScenes));
  settings.setValue(QString("SceneProjects"), QVariant(m_recentSceneProjects));
  settings.setValue(QString("Levels"), QVariant(m_recentLevels));
  settings.setValue(QString("FlipbookImages"),
                    QVariant(m_recentFlipbookImages));
}

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

QList<QString> RecentFiles::getFilesNameList(FileType fileType) {
  QList<QString> files =
      (fileType == Scene) ? m_recentScenes : (fileType == Level)
                                                 ? m_recentLevels
                                                 : m_recentFlipbookImages;
  QList<QString> names;
  int i;
  for (i = 0; i < files.size(); i++) {
    TFilePath path(files.at(i).toStdWString());
    QString str, number;
    names.append(number.number(i + 1) + QString(". ") +
                 str.fromStdWString(path.getWideString()));
  }
  return names;
}

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

void RecentFiles::refreshRecentFilesMenu(FileType fileType) {
  CommandId id = (fileType == Scene) ? MI_OpenRecentScene
                                     : (fileType == Level) ? MI_OpenRecentLevel
                                                           : MI_LoadRecentImage;
  QAction *act = CommandManager::instance()->getAction(id);
  if (!act) return;
  DVMenuAction *menu = dynamic_cast<DVMenuAction *>(act->menu());
  if (!menu) return;
  QList<QString> names = getFilesNameList(fileType);
  if (names.isEmpty())
    menu->setEnabled(false);
  else {
    CommandId clearActionId =
        (fileType == Scene) ? MI_ClearRecentScene : (fileType == Level)
                                                        ? MI_ClearRecentLevel
                                                        : MI_ClearRecentImage;
    menu->setActions(names);
    menu->addSeparator();
    QAction *clearAction = CommandManager::instance()->getAction(clearActionId);
    assert(clearAction);
    menu->addAction(clearAction);
    if (!menu->isEnabled()) menu->setEnabled(true);
  }
}