#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QLabel>
#include <QGridLayout>
#include <QToolBar>
#include <QPushButton>
#include <QFileDialog>
#include <QTabWidget>
#include <QtCore/qbuffer.h>
#include <QMessageBox>
#include <QTimer>
#include <QMenuBar>
#include <QPointer>
#include <QApplication>
#include <map>
#include <QDesktopServices>
#include <QDockWidget>
#include <QWidgetAction>
#include <QGraphicsOpacityEffect>
#include <QDir>
#include <QFileInfo>
#include <qtsingleapplication.h>
#include "documentwindow.h"
#include "skeletongraphicswidget.h"
#include "theme.h"
#include "ds3file.h"
#include "snapshot.h"
#include "snapshotxml.h"
#include "logbrowser.h"
#include "util.h"
#include "aboutwidget.h"
#include "version.h"
#include "glbfile.h"
#include "parttreewidget.h"
#include "rigwidget.h"
#include "markiconcreator.h"
#include "motionmanagewidget.h"
#include "materialmanagewidget.h"
#include "imageforever.h"
#include "spinnableawesomebutton.h"
#include "fbxfile.h"
#include "shortcuts.h"
#include "floatnumberwidget.h"
#include "cutfacelistwidget.h"
#include "scriptwidget.h"
#include "variablesxml.h"
#include "updatescheckwidget.h"
#include "modeloffscreenrender.h"
#include "fileforever.h"
#include "documentsaver.h"

int DocumentWindow::m_autoRecovered = false;

LogBrowser *g_logBrowser = nullptr;
std::map<DocumentWindow *, QUuid> g_documentWindows;
QTextBrowser *g_acknowlegementsWidget = nullptr;
AboutWidget *g_aboutWidget = nullptr;
QTextBrowser *g_contributorsWidget = nullptr;
UpdatesCheckWidget *g_updatesCheckWidget = nullptr;

void outputMessage(QtMsgType type, const QMessageLogContext &context, const QString &msg)
{
    if (g_logBrowser)
        g_logBrowser->outputMessage(type, msg, context.file, context.line);
}

const std::map<DocumentWindow *, QUuid> &DocumentWindow::documentWindows()
{
    return g_documentWindows;
}

Document *DocumentWindow::document()
{
    return m_document;
}

void DocumentWindow::showAcknowlegements()
{
    if (!g_acknowlegementsWidget) {
        g_acknowlegementsWidget = new QTextBrowser;
        g_acknowlegementsWidget->setWindowTitle(unifiedWindowTitle(tr("Acknowlegements")));
        g_acknowlegementsWidget->setMinimumSize(QSize(400, 300));
        QFile file(":/ACKNOWLEDGEMENTS.html");
        file.open(QFile::ReadOnly | QFile::Text);
        QTextStream stream(&file);
        g_acknowlegementsWidget->setHtml(stream.readAll());
    }
    g_acknowlegementsWidget->show();
    g_acknowlegementsWidget->activateWindow();
    g_acknowlegementsWidget->raise();
}

void DocumentWindow::showContributors()
{
    if (!g_contributorsWidget) {
        g_contributorsWidget = new QTextBrowser;
        g_contributorsWidget->setWindowTitle(unifiedWindowTitle(tr("Contributors")));
        g_contributorsWidget->setMinimumSize(QSize(400, 300));
        QFile authors(":/AUTHORS");
        authors.open(QFile::ReadOnly | QFile::Text);
        QFile contributors(":/CONTRIBUTORS");
        contributors.open(QFile::ReadOnly | QFile::Text);
        g_contributorsWidget->setHtml("<h1>AUTHORS</h1><pre>" + authors.readAll() + "</pre><h1>CONTRIBUTORS</h1><pre>" + contributors.readAll() + "</pre>");
    }
    g_contributorsWidget->show();
    g_contributorsWidget->activateWindow();
    g_contributorsWidget->raise();
}

void DocumentWindow::showAbout()
{
    if (!g_aboutWidget) {
        g_aboutWidget = new AboutWidget;
    }
    g_aboutWidget->show();
    g_aboutWidget->activateWindow();
    g_aboutWidget->raise();
}

void DocumentWindow::checkForUpdates()
{
    if (!g_updatesCheckWidget) {
        g_updatesCheckWidget = new UpdatesCheckWidget;
    }
    g_updatesCheckWidget->check();
    g_updatesCheckWidget->show();
    g_updatesCheckWidget->activateWindow();
    g_updatesCheckWidget->raise();
}

size_t DocumentWindow::total()
{
    return g_documentWindows.size();
}

DocumentWindow::DocumentWindow() :
    m_document(nullptr),
    m_firstShow(true),
    m_documentSaved(true),
    m_exportPreviewWidget(nullptr),
    m_preferencesWidget(nullptr),
    m_isLastMeshGenerationSucceed(true),
    m_currentUpdatedMeshId(0)
{
    QObject::connect((QtSingleApplication *)QGuiApplication::instance(), 
            &QtSingleApplication::messageReceived, this, [this](const QString &message) {
        if ("activateFromAnotherInstance" == message) {
            show();
            activateWindow();
            raise();
        }
    });
             
    if (!g_logBrowser) {
        g_logBrowser = new LogBrowser;
        qInstallMessageHandler(&outputMessage);
    }

    g_documentWindows.insert({this, QUuid::createUuid()});

    m_document = new Document;
    
    SkeletonGraphicsWidget *graphicsWidget = new SkeletonGraphicsWidget(m_document);
    m_graphicsWidget = graphicsWidget;

    QVBoxLayout *toolButtonLayout = new QVBoxLayout;
    toolButtonLayout->setSpacing(0);
    toolButtonLayout->setContentsMargins(5, 10, 4, 0);

    QPushButton *addButton = new QPushButton(QChar(fa::plus));
    addButton->setToolTip(tr("Add node to canvas"));
    Theme::initAwesomeButton(addButton);

    QPushButton *selectButton = new QPushButton(QChar(fa::mousepointer));
    selectButton->setToolTip(tr("Select node on canvas"));
    Theme::initAwesomeButton(selectButton);
    
    //QPushButton *markerButton = new QPushButton(QChar(fa::edit));
    //markerButton->setToolTip(tr("Marker pen"));
    //Theme::initAwesomeButton(markerButton);
    
    QPushButton *paintButton = new QPushButton(QChar(fa::paintbrush));
    paintButton->setToolTip(tr("Paint brush"));
    Theme::initAwesomeButton(paintButton);

    //QPushButton *dragButton = new QPushButton(QChar(fa::handrocko));
    //dragButton->setToolTip(tr("Enter drag mode"));
    //Theme::initAwesomeButton(dragButton);

    QPushButton *zoomInButton = new QPushButton(QChar(fa::searchplus));
    zoomInButton->setToolTip(tr("Enter zoom in mode"));
    Theme::initAwesomeButton(zoomInButton);

    QPushButton *zoomOutButton = new QPushButton(QChar(fa::searchminus));
    zoomOutButton->setToolTip(tr("Enter zoom out mode"));
    Theme::initAwesomeButton(zoomOutButton);
    
    m_rotationButton = new QPushButton(QChar(fa::caretsquareoup));
    m_rotationButton->setToolTip(tr("Toggle viewport"));
    Theme::initAwesomeButton(m_rotationButton);
    updateRotationButtonState();

    m_xlockButton = new QPushButton(QChar('X'));
    m_xlockButton->setToolTip(tr("X axis locker"));
    initLockButton(m_xlockButton);
    updateXlockButtonState();

    m_ylockButton = new QPushButton(QChar('Y'));
    m_ylockButton->setToolTip(tr("Y axis locker"));
    initLockButton(m_ylockButton);
    updateYlockButtonState();

    m_zlockButton = new QPushButton(QChar('Z'));
    m_zlockButton->setToolTip(tr("Z axis locker"));
    initLockButton(m_zlockButton);
    updateZlockButtonState();
    
    m_radiusLockButton = new QPushButton(QChar(fa::bullseye));
    m_radiusLockButton->setToolTip(tr("Node radius locker"));
    Theme::initAwesomeButton(m_radiusLockButton);
    updateRadiusLockButtonState();
    
    //QPushButton *rotateCounterclockwiseButton = new QPushButton(QChar(fa::rotateleft));
    //rotateCounterclockwiseButton->setToolTip(tr("Rotate whole model (CCW)"));
    //Theme::initAwesomeButton(rotateCounterclockwiseButton);
    
    //QPushButton *rotateClockwiseButton = new QPushButton(QChar(fa::rotateright));
    //rotateClockwiseButton->setToolTip(tr("Rotate whole model"));
    //Theme::initAwesomeButton(rotateClockwiseButton);
    
    auto updateRegenerateIconAndTips = [&](SpinnableAwesomeButton *regenerateButton, bool isSuccessful, bool forceUpdate=false) {
        if (!forceUpdate) {
            if (m_isLastMeshGenerationSucceed == isSuccessful)
                return;
        }
        m_isLastMeshGenerationSucceed = isSuccessful;
        regenerateButton->setToolTip(m_isLastMeshGenerationSucceed ? tr("Regenerate") : tr("Mesh generation failed, please undo or adjust recent changed nodes\nTips:\n  - Don't let generated mesh self-intersect\n  - Make multiple parts instead of one single part for whole model"));
        regenerateButton->setAwesomeIcon(m_isLastMeshGenerationSucceed ? QChar(fa::recycle) : QChar(fa::warning));
    };
    
    SpinnableAwesomeButton *regenerateButton = new SpinnableAwesomeButton();
    updateRegenerateIconAndTips(regenerateButton, m_isLastMeshGenerationSucceed, true);
    connect(m_document, &Document::meshGenerating, this, [=]() {
        regenerateButton->showSpinner(true);
    });
    connect(m_document, &Document::resultMeshChanged, this, [=]() {
        updateRegenerateIconAndTips(regenerateButton, m_document->isMeshGenerationSucceed());
    });
    connect(m_document, &Document::postProcessing, this, [=]() {
        regenerateButton->showSpinner(true);
    });
    connect(m_document, &Document::textureGenerating, this, [=]() {
        regenerateButton->showSpinner(true);
    });
    connect(m_document, &Document::resultTextureChanged, this, [=]() {
        if (!m_document->isMeshGenerating() &&
                !m_document->isPostProcessing() &&
                !m_document->isTextureGenerating()) {
            regenerateButton->showSpinner(false);
        }
    });
    connect(regenerateButton->button(), &QPushButton::clicked, m_document, &Document::regenerateMesh);

    toolButtonLayout->addWidget(addButton);
    toolButtonLayout->addWidget(selectButton);
    //toolButtonLayout->addWidget(markerButton);
    toolButtonLayout->addWidget(paintButton);
    //toolButtonLayout->addWidget(dragButton);
    toolButtonLayout->addWidget(zoomInButton);
    toolButtonLayout->addWidget(zoomOutButton);
    toolButtonLayout->addSpacing(10);
    toolButtonLayout->addWidget(m_rotationButton);
    toolButtonLayout->addSpacing(10);
    toolButtonLayout->addWidget(m_xlockButton);
    toolButtonLayout->addWidget(m_ylockButton);
    toolButtonLayout->addWidget(m_zlockButton);
    toolButtonLayout->addWidget(m_radiusLockButton);
    toolButtonLayout->addSpacing(10);
    //toolButtonLayout->addWidget(rotateCounterclockwiseButton);
    //toolButtonLayout->addWidget(rotateClockwiseButton);
    //toolButtonLayout->addSpacing(10);
    toolButtonLayout->addWidget(regenerateButton);
    

    QLabel *verticalLogoLabel = new QLabel;
    QImage verticalLogoImage;
    verticalLogoImage.load(":/resources/dust3d-vertical.png");
    verticalLogoLabel->setPixmap(QPixmap::fromImage(verticalLogoImage));

    QHBoxLayout *logoLayout = new QHBoxLayout;
    logoLayout->addWidget(verticalLogoLabel);
    logoLayout->setContentsMargins(0, 0, 0, 0);

    QVBoxLayout *mainLeftLayout = new QVBoxLayout;
    mainLeftLayout->setSpacing(0);
    mainLeftLayout->setContentsMargins(0, 0, 0, 0);
    mainLeftLayout->addLayout(toolButtonLayout);
    mainLeftLayout->addStretch();
    mainLeftLayout->addLayout(logoLayout);
    mainLeftLayout->addSpacing(10);

    GraphicsContainerWidget *containerWidget = new GraphicsContainerWidget;
    containerWidget->setGraphicsWidget(graphicsWidget);
    QGridLayout *containerLayout = new QGridLayout;
    containerLayout->setSpacing(0);
    containerLayout->setContentsMargins(1, 0, 0, 0);
    containerLayout->addWidget(graphicsWidget);
    containerWidget->setLayout(containerLayout);
    containerWidget->setMinimumSize(400, 400);
    
    m_graphicsContainerWidget = containerWidget;
    
    //m_infoWidget = new QLabel(containerWidget);
    //m_infoWidget->setAttribute(Qt::WA_TransparentForMouseEvents);
    //QGraphicsOpacityEffect *graphicsOpacityEffect = new QGraphicsOpacityEffect(m_infoWidget);
    //graphicsOpacityEffect->setOpacity(0.5);
    //m_infoWidget->setGraphicsEffect(graphicsOpacityEffect);
    //updateInfoWidgetPosition();
    
    //connect(containerWidget, &GraphicsContainerWidget::containerSizeChanged, this, &DocumentWindow::updateInfoWidgetPosition);

    m_modelRenderWidget = new ModelWidget(containerWidget);
    m_modelRenderWidget->setMoveAndZoomByWindow(false);
    m_modelRenderWidget->move(0, 0);
    m_modelRenderWidget->setAttribute(Qt::WA_TransparentForMouseEvents);
    m_modelRenderWidget->setMousePickRadius(m_document->mousePickRadius());
    if (!Preferences::instance().toonShading())
		m_modelRenderWidget->toggleWireframe();
    m_modelRenderWidget->enableEnvironmentLight();
    m_modelRenderWidget->disableCullFace();
    m_modelRenderWidget->setEyePosition(QVector3D(0.0, 0.0, -4.0));
    m_modelRenderWidget->setMoveToPosition(QVector3D(-0.5, -0.5, 0.0));
    
    connect(containerWidget, &GraphicsContainerWidget::containerSizeChanged,
        m_modelRenderWidget, &ModelWidget::canvasResized);
    
    connect(m_modelRenderWidget, &ModelWidget::mouseRayChanged, m_document,
            [=](const QVector3D &nearPosition, const QVector3D &farPosition) {
        std::set<QUuid> nodeIdSet;
        graphicsWidget->readSkeletonNodeAndEdgeIdSetFromRangeSelection(&nodeIdSet);
        m_document->setMousePickMaskNodeIds(nodeIdSet);
        m_document->pickMouseTarget(nearPosition, farPosition);
    });
    connect(m_modelRenderWidget, &ModelWidget::mousePressed, m_document, [=]() {
        m_document->startPaint();
        if (QGuiApplication::queryKeyboardModifiers().testFlag(Qt::ShiftModifier))
            m_document->setPaintMode(PaintMode::Push);
        else
            m_document->setPaintMode(PaintMode::Pull);
    });
    connect(m_modelRenderWidget, &ModelWidget::mouseReleased, m_document, [=]() {
        m_document->setPaintMode(PaintMode::None);
        m_document->stopPaint();
    });
    connect(m_modelRenderWidget, &ModelWidget::addMouseRadius, m_document, [=](float radius) {
        m_document->setMousePickRadius(m_document->mousePickRadius() + radius);
    });
    connect(m_document, &Document::mousePickRadiusChanged, this, [=]() {
        m_modelRenderWidget->setMousePickRadius(m_document->mousePickRadius());
    });
    connect(m_document, &Document::mouseTargetChanged, this, [=]() {
        m_modelRenderWidget->setMousePickTargetPositionInModelSpace(m_document->mouseTargetPosition());
    });
    
    connect(m_modelRenderWidget, &ModelWidget::renderParametersChanged, this, &DocumentWindow::delayedGenerateNormalAndDepthMaps);
    
    m_graphicsWidget->setModelWidget(m_modelRenderWidget);
    containerWidget->setModelWidget(m_modelRenderWidget);
    
    setTabPosition(Qt::RightDockWidgetArea, QTabWidget::East);

    QDockWidget *partTreeDocker = new QDockWidget(tr("Parts"), this);
    partTreeDocker->setAllowedAreas(Qt::RightDockWidgetArea);
    PartTreeWidget *partTreeWidget = new PartTreeWidget(m_document, partTreeDocker);
    partTreeDocker->setWidget(partTreeWidget);
    addDockWidget(Qt::RightDockWidgetArea, partTreeDocker);
    connect(partTreeDocker, &QDockWidget::topLevelChanged, [=](bool topLevel) {
        Q_UNUSED(topLevel);
        for (const auto &part: m_document->partMap)
            partTreeWidget->partPreviewChanged(part.first);
    });
    
    QDockWidget *materialDocker = new QDockWidget(tr("Materials"), this);
    materialDocker->setAllowedAreas(Qt::RightDockWidgetArea);
    MaterialManageWidget *materialManageWidget = new MaterialManageWidget(m_document, materialDocker);
    materialDocker->setWidget(materialManageWidget);
    connect(materialManageWidget, &MaterialManageWidget::registerDialog, this, &DocumentWindow::registerDialog);
    connect(materialManageWidget, &MaterialManageWidget::unregisterDialog, this, &DocumentWindow::unregisterDialog);
    addDockWidget(Qt::RightDockWidgetArea, materialDocker);
    connect(materialDocker, &QDockWidget::topLevelChanged, [=](bool topLevel) {
        Q_UNUSED(topLevel);
        for (const auto &material: m_document->materialMap)
            emit m_document->materialPreviewChanged(material.first);
    });
    
    QDockWidget *rigDocker = new QDockWidget(tr("Rig"), this);
    rigDocker->setAllowedAreas(Qt::RightDockWidgetArea);
    m_rigWidget = new RigWidget(m_document, rigDocker);
    rigDocker->setWidget(m_rigWidget);
    addDockWidget(Qt::RightDockWidgetArea, rigDocker);
    connect(rigDocker, &QDockWidget::topLevelChanged, [=](bool topLevel) {
        Q_UNUSED(topLevel);
        updateRigWeightRenderWidget();
    });
    
    QDockWidget *poseDocker = new QDockWidget(tr("Poses"), this);
    poseDocker->setAllowedAreas(Qt::RightDockWidgetArea);
    PoseManageWidget *poseManageWidget = new PoseManageWidget(m_document, poseDocker);
    poseDocker->setWidget(poseManageWidget);
    connect(poseManageWidget, &PoseManageWidget::registerDialog, this, &DocumentWindow::registerDialog);
    connect(poseManageWidget, &PoseManageWidget::unregisterDialog, this, &DocumentWindow::unregisterDialog);
    addDockWidget(Qt::RightDockWidgetArea, poseDocker);
    connect(poseDocker, &QDockWidget::topLevelChanged, [=](bool topLevel) {
        Q_UNUSED(topLevel);
        for (const auto &pose: m_document->poseMap)
            emit m_document->posePreviewChanged(pose.first);
    });
    
    QDockWidget *motionDocker = new QDockWidget(tr("Motions"), this);
    motionDocker->setAllowedAreas(Qt::RightDockWidgetArea);
    MotionManageWidget *motionManageWidget = new MotionManageWidget(m_document, motionDocker);
    motionDocker->setWidget(motionManageWidget);
    connect(motionManageWidget, &MotionManageWidget::registerDialog, this, &DocumentWindow::registerDialog);
    connect(motionManageWidget, &MotionManageWidget::unregisterDialog, this, &DocumentWindow::unregisterDialog);
    addDockWidget(Qt::RightDockWidgetArea, motionDocker);
    
    QDockWidget *scriptDocker = new QDockWidget(tr("Script"), this);
    scriptDocker->setAllowedAreas(Qt::RightDockWidgetArea);
    ScriptWidget *scriptWidget = new ScriptWidget(m_document, scriptDocker);
    scriptDocker->setWidget(scriptWidget);
    addDockWidget(Qt::RightDockWidgetArea, scriptDocker);
    
    tabifyDockWidget(partTreeDocker, materialDocker);
    tabifyDockWidget(materialDocker, rigDocker);
    tabifyDockWidget(rigDocker, poseDocker);
    tabifyDockWidget(poseDocker, motionDocker);
    tabifyDockWidget(motionDocker, scriptDocker);
    
    partTreeDocker->raise();

    QHBoxLayout *mainLayout = new QHBoxLayout;
    mainLayout->setSpacing(0);
    mainLayout->setContentsMargins(0, 0, 0, 0);
    mainLayout->addLayout(mainLeftLayout);
    mainLayout->addWidget(containerWidget);
    mainLayout->addSpacing(3);

    QWidget *centralWidget = new QWidget;
    centralWidget->setLayout(mainLayout);

    setCentralWidget(centralWidget);
    setWindowTitle(APP_NAME);

    m_fileMenu = menuBar()->addMenu(tr("&File"));

    m_newWindowAction = new QAction(tr("New Window"), this);
    connect(m_newWindowAction, &QAction::triggered, this, &DocumentWindow::newWindow, Qt::QueuedConnection);
    m_fileMenu->addAction(m_newWindowAction);

    m_newDocumentAction = m_fileMenu->addAction(tr("&New"),
                                         this, &DocumentWindow::newDocument,
                                         QKeySequence::New);

    m_openAction = m_fileMenu->addAction(tr("&Open..."),
                                         this, &DocumentWindow::open,
                                         QKeySequence::Open);
    
    m_openExampleMenu = new QMenu(tr("Open Example"));
    std::vector<QString> exampleModels = {
        "Addax",
        "Backpacker",
        "Bicycle",
        "Cat",
        "Dog",
        "Giraffe",
        "Meerkat",
        "Mosquito",
        "Seagull",
        "Procedural Tree"
    };
    for (const auto &model: exampleModels) {
        QAction *openModelAction = new QAction(model, this);
        connect(openModelAction, &QAction::triggered, this, [this, model]() {
            openExample("model-" + model.toLower().replace(QChar(' '), QChar('-')) + ".ds3");
        });
        m_openExampleMenu->addAction(openModelAction);
    }
    
    m_fileMenu->addMenu(m_openExampleMenu);

    m_saveAction = m_fileMenu->addAction(tr("&Save"),
                                         this, &DocumentWindow::save,
                                         QKeySequence::Save);

    m_saveAsAction = new QAction(tr("Save As..."), this);
    connect(m_saveAsAction, &QAction::triggered, this, &DocumentWindow::saveAs, Qt::QueuedConnection);
    m_fileMenu->addAction(m_saveAsAction);

    m_saveAllAction = new QAction(tr("Save All"), this);
    connect(m_saveAllAction, &QAction::triggered, this, &DocumentWindow::saveAll, Qt::QueuedConnection);
    m_fileMenu->addAction(m_saveAllAction);

    m_fileMenu->addSeparator();
    
    m_showPreferencesAction = new QAction(tr("Preferences..."), this);
    connect(m_showPreferencesAction, &QAction::triggered, this, &DocumentWindow::showPreferences);
    m_fileMenu->addAction(m_showPreferencesAction);
    
    m_fileMenu->addSeparator();
    
    m_importAction = new QAction(tr("Import..."), this);
    connect(m_importAction, &QAction::triggered, this, &DocumentWindow::import, Qt::QueuedConnection);
    m_fileMenu->addAction(m_importAction);
    
    m_fileMenu->addSeparator();

    //m_exportMenu = m_fileMenu->addMenu(tr("Export"));

    m_exportAction = new QAction(tr("Export..."), this);
    connect(m_exportAction, &QAction::triggered, this, &DocumentWindow::showExportPreview, Qt::QueuedConnection);
    m_fileMenu->addAction(m_exportAction);
    
    m_exportAsObjAction = new QAction(tr("Export as OBJ..."), this);
    connect(m_exportAsObjAction, &QAction::triggered, this, &DocumentWindow::exportObjResult, Qt::QueuedConnection);
    m_fileMenu->addAction(m_exportAsObjAction);
    
    m_exportRenderedAsImageAction = new QAction(tr("Export as Image..."), this);
    connect(m_exportRenderedAsImageAction, &QAction::triggered, this, &DocumentWindow::exportRenderedResult, Qt::QueuedConnection);
    m_fileMenu->addAction(m_exportRenderedAsImageAction);
    
    //m_exportAsObjPlusMaterialsAction = new QAction(tr("Wavefront (.obj + .mtl)..."), this);
    //connect(m_exportAsObjPlusMaterialsAction, &QAction::triggered, this, &SkeletonDocumentWindow::exportObjPlusMaterialsResult, Qt::QueuedConnection);
    //m_exportMenu->addAction(m_exportAsObjPlusMaterialsAction);
    
    m_fileMenu->addSeparator();

    m_changeTurnaroundAction = new QAction(tr("Change Reference Sheet..."), this);
    connect(m_changeTurnaroundAction, &QAction::triggered, this, &DocumentWindow::changeTurnaround, Qt::QueuedConnection);
    m_fileMenu->addAction(m_changeTurnaroundAction);
    
    m_fileMenu->addSeparator();

    m_quitAction = m_fileMenu->addAction(tr("&Quit"),
                                         this, &DocumentWindow::close,
                                         QKeySequence::Quit);

    connect(m_fileMenu, &QMenu::aboutToShow, [=]() {
        m_exportAsObjAction->setEnabled(m_graphicsWidget->hasItems());
        //m_exportAsObjPlusMaterialsAction->setEnabled(m_graphicsWidget->hasItems());
        m_exportAction->setEnabled(m_graphicsWidget->hasItems());
        m_exportRenderedAsImageAction->setEnabled(m_graphicsWidget->hasItems());
    });

    m_editMenu = menuBar()->addMenu(tr("&Edit"));

    m_addAction = new QAction(tr("Add..."), this);
    connect(m_addAction, &QAction::triggered, [=]() {
        m_document->setEditMode(SkeletonDocumentEditMode::Add);
    });
    m_editMenu->addAction(m_addAction);

    m_undoAction = new QAction(tr("Undo"), this);
    connect(m_undoAction, &QAction::triggered, m_document, &Document::undo);
    m_editMenu->addAction(m_undoAction);

    m_redoAction = new QAction(tr("Redo"), this);
    connect(m_redoAction, &QAction::triggered, m_document, &Document::redo);
    m_editMenu->addAction(m_redoAction);

    m_deleteAction = new QAction(tr("Delete"), this);
    connect(m_deleteAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::deleteSelected);
    m_editMenu->addAction(m_deleteAction);

    m_breakAction = new QAction(tr("Break"), this);
    connect(m_breakAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::breakSelected);
    m_editMenu->addAction(m_breakAction);

    m_reverseAction = new QAction(tr("Reverse"), this);
    connect(m_reverseAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::reverseSelectedEdges);
    m_editMenu->addAction(m_reverseAction);

    m_connectAction = new QAction(tr("Connect"), this);
    connect(m_connectAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::connectSelected);
    m_editMenu->addAction(m_connectAction);

    m_cutAction = new QAction(tr("Cut"), this);
    connect(m_cutAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::cut);
    m_editMenu->addAction(m_cutAction);

    m_copyAction = new QAction(tr("Copy"), this);
    connect(m_copyAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::copy);
    m_editMenu->addAction(m_copyAction);

    m_pasteAction = new QAction(tr("Paste"), this);
    connect(m_pasteAction, &QAction::triggered, m_document, &Document::paste);
    m_editMenu->addAction(m_pasteAction);

    m_flipHorizontallyAction = new QAction(tr("H Flip"), this);
    connect(m_flipHorizontallyAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::flipHorizontally);
    m_editMenu->addAction(m_flipHorizontallyAction);

    m_flipVerticallyAction = new QAction(tr("V Flip"), this);
    connect(m_flipVerticallyAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::flipVertically);
    m_editMenu->addAction(m_flipVerticallyAction);

    m_rotateClockwiseAction = new QAction(tr("Rotate 90D CW"), this);
    connect(m_rotateClockwiseAction, &QAction::triggered, [=] {
        m_graphicsWidget->rotateClockwise90Degree();
    });
    m_editMenu->addAction(m_rotateClockwiseAction);

    m_rotateCounterclockwiseAction = new QAction(tr("Rotate 90D CCW"), this);
    connect(m_rotateCounterclockwiseAction, &QAction::triggered, [=] {
        m_graphicsWidget->rotateCounterclockwise90Degree();
    });
    m_editMenu->addAction(m_rotateCounterclockwiseAction);

    m_switchXzAction = new QAction(tr("Switch XZ"), this);
    connect(m_switchXzAction, &QAction::triggered, [=] {
        m_graphicsWidget->switchSelectedXZ();
    });
    m_editMenu->addAction(m_switchXzAction);
    
    m_setCutFaceAction = new QAction(tr("Cut Face..."), this);
    connect(m_setCutFaceAction, &QAction::triggered, [=] {
        m_graphicsWidget->showSelectedCutFaceSettingPopup(m_graphicsWidget->mapFromGlobal(QCursor::pos()));
    });
    m_editMenu->addAction(m_setCutFaceAction);
    
    m_clearCutFaceAction = new QAction(tr("Clear Cut Face"), this);
    connect(m_clearCutFaceAction, &QAction::triggered, [=] {
        m_graphicsWidget->clearSelectedCutFace();
    });
    m_editMenu->addAction(m_clearCutFaceAction);
    
    //m_createWrapPartsAction = new QAction(tr("Create Wrap Parts"), this);
    //connect(m_createWrapPartsAction, &QAction::triggered, [=] {
    //    m_graphicsWidget->createWrapParts();
    //});
    //m_editMenu->addAction(m_createWrapPartsAction);

    m_alignToMenu = new QMenu(tr("Align To"));

    m_alignToLocalCenterAction = new QAction(tr("Local Center"), this);
    connect(m_alignToLocalCenterAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::alignSelectedToLocalCenter);
    m_alignToMenu->addAction(m_alignToLocalCenterAction);

    m_alignToLocalVerticalCenterAction = new QAction(tr("Local Vertical Center"), this);
    connect(m_alignToLocalVerticalCenterAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::alignSelectedToLocalVerticalCenter);
    m_alignToMenu->addAction(m_alignToLocalVerticalCenterAction);

    m_alignToLocalHorizontalCenterAction = new QAction(tr("Local Horizontal Center"), this);
    connect(m_alignToLocalHorizontalCenterAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::alignSelectedToLocalHorizontalCenter);
    m_alignToMenu->addAction(m_alignToLocalHorizontalCenterAction);
    
    m_alignToGlobalCenterAction = new QAction(tr("Global Center"), this);
    connect(m_alignToGlobalCenterAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::alignSelectedToGlobalCenter);
    m_alignToMenu->addAction(m_alignToGlobalCenterAction);

    m_alignToGlobalVerticalCenterAction = new QAction(tr("Global Vertical Center"), this);
    connect(m_alignToGlobalVerticalCenterAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::alignSelectedToGlobalVerticalCenter);
    m_alignToMenu->addAction(m_alignToGlobalVerticalCenterAction);

    m_alignToGlobalHorizontalCenterAction = new QAction(tr("Global Horizontal Center"), this);
    connect(m_alignToGlobalHorizontalCenterAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::alignSelectedToGlobalHorizontalCenter);
    m_alignToMenu->addAction(m_alignToGlobalHorizontalCenterAction);

    m_editMenu->addMenu(m_alignToMenu);
    
    m_markAsMenu = new QMenu(tr("Mark As"));

    m_markAsNoneAction = new QAction(tr("None"), this);
    connect(m_markAsNoneAction, &QAction::triggered, [=]() {
        m_graphicsWidget->setSelectedNodesBoneMark(BoneMark::None);
    });
    m_markAsMenu->addAction(m_markAsNoneAction);

    m_markAsMenu->addSeparator();

    for (int i = 0; i < (int)BoneMark::Count - 1; i++) {
        BoneMark boneMark = (BoneMark)(i + 1);
        m_markAsActions[i] = new QAction(MarkIconCreator::createIcon(boneMark), BoneMarkToDispName(boneMark), this);
        connect(m_markAsActions[i], &QAction::triggered, [=]() {
            m_graphicsWidget->setSelectedNodesBoneMark(boneMark);
        });
        m_markAsMenu->addAction(m_markAsActions[i]);
    }

    m_editMenu->addMenu(m_markAsMenu);
    
    m_colorizeAsMenu = new QMenu(tr("Colorize"));
    
    m_colorizeAsBlankAction = new QAction(tr("Blank"), this);
    connect(m_colorizeAsBlankAction, &QAction::triggered, [=]() {
        m_graphicsWidget->fadeSelected();
    });
    m_colorizeAsMenu->addAction(m_colorizeAsBlankAction);
    
    m_colorizeAsAutoAction = new QAction(tr("Auto Color"), this);
    connect(m_colorizeAsAutoAction, &QAction::triggered, [=]() {
        m_graphicsWidget->colorizeSelected();
    });
    m_colorizeAsMenu->addAction(m_colorizeAsAutoAction);
    
    m_editMenu->addMenu(m_colorizeAsMenu);

    m_selectAllAction = new QAction(tr("Select All"), this);
    connect(m_selectAllAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::selectAll);
    m_editMenu->addAction(m_selectAllAction);

    m_selectPartAllAction = new QAction(tr("Select Part"), this);
    connect(m_selectPartAllAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::selectPartAll);
    m_editMenu->addAction(m_selectPartAllAction);

    m_unselectAllAction = new QAction(tr("Unselect All"), this);
    connect(m_unselectAllAction, &QAction::triggered, m_graphicsWidget, &SkeletonGraphicsWidget::unselectAll);
    m_editMenu->addAction(m_unselectAllAction);

    connect(m_editMenu, &QMenu::aboutToShow, [=]() {
        m_undoAction->setEnabled(m_document->undoable());
        m_redoAction->setEnabled(m_document->redoable());
        m_deleteAction->setEnabled(m_graphicsWidget->hasSelection());
        m_breakAction->setEnabled(m_graphicsWidget->hasEdgeSelection());
        m_reverseAction->setEnabled(m_graphicsWidget->hasEdgeSelection());
        m_connectAction->setEnabled(m_graphicsWidget->hasTwoDisconnectedNodesSelection());
        m_cutAction->setEnabled(m_graphicsWidget->hasSelection());
        m_copyAction->setEnabled(m_graphicsWidget->hasSelection());
        m_pasteAction->setEnabled(m_document->hasPastableNodesInClipboard());
        m_flipHorizontallyAction->setEnabled(m_graphicsWidget->hasMultipleSelection());
        m_flipVerticallyAction->setEnabled(m_graphicsWidget->hasMultipleSelection());
        m_rotateClockwiseAction->setEnabled(m_graphicsWidget->hasMultipleSelection());
        m_rotateCounterclockwiseAction->setEnabled(m_graphicsWidget->hasMultipleSelection());
        m_switchXzAction->setEnabled(m_graphicsWidget->hasSelection());
        m_setCutFaceAction->setEnabled(m_graphicsWidget->hasSelection());
        m_clearCutFaceAction->setEnabled(m_graphicsWidget->hasCutFaceAdjustedNodesSelection());
        //m_createWrapPartsAction->setEnabled(m_graphicsWidget->hasSelection());
        m_colorizeAsBlankAction->setEnabled(m_graphicsWidget->hasSelection());
        m_colorizeAsAutoAction->setEnabled(m_graphicsWidget->hasSelection());
        m_alignToGlobalCenterAction->setEnabled(m_graphicsWidget->hasSelection() && m_document->originSettled());
        m_alignToGlobalVerticalCenterAction->setEnabled(m_graphicsWidget->hasSelection() && m_document->originSettled());
        m_alignToGlobalHorizontalCenterAction->setEnabled(m_graphicsWidget->hasSelection() && m_document->originSettled());
        m_alignToLocalCenterAction->setEnabled(m_graphicsWidget->hasMultipleSelection());
        m_alignToLocalVerticalCenterAction->setEnabled(m_graphicsWidget->hasMultipleSelection());
        m_alignToLocalHorizontalCenterAction->setEnabled(m_graphicsWidget->hasMultipleSelection());
        m_alignToMenu->setEnabled((m_graphicsWidget->hasSelection() && m_document->originSettled()) || m_graphicsWidget->hasMultipleSelection());
        m_selectAllAction->setEnabled(m_graphicsWidget->hasItems());
        m_selectPartAllAction->setEnabled(m_graphicsWidget->hasItems());
        m_unselectAllAction->setEnabled(m_graphicsWidget->hasSelection());
    });

    m_viewMenu = menuBar()->addMenu(tr("&View"));

    //auto isModelSitInVisibleArea = [](ModelWidget *modelWidget) {
    //    QRect parentRect = QRect(QPoint(0, 0), modelWidget->parentWidget()->size());
    //    return parentRect.contains(modelWidget->geometry().center());
    //};

    //m_resetModelWidgetPosAction = new QAction(tr("Show Model"), this);
    //connect(m_resetModelWidgetPosAction, &QAction::triggered, [=]() {
    //    if (!isModelSitInVisibleArea(m_modelRenderWidget)) {
    //        m_modelRenderWidget->move(DocumentWindow::m_modelRenderWidgetInitialX, DocumentWindow::m_modelRenderWidgetInitialY);
    //    }
    //});
    //m_viewMenu->addAction(m_resetModelWidgetPosAction);

    m_toggleWireframeAction = new QAction(tr("Toggle Wireframe"), this);
    connect(m_toggleWireframeAction, &QAction::triggered, [=]() {
        m_modelRenderWidget->toggleWireframe();
    });
    m_viewMenu->addAction(m_toggleWireframeAction);
    
    m_toggleRotationAction = new QAction(tr("Toggle Rotation"), this);
    connect(m_toggleRotationAction, &QAction::triggered, [=]() {
        m_modelRenderWidget->toggleRotation();
    });
    m_viewMenu->addAction(m_toggleRotationAction);
    
    m_toggleColorAction = new QAction(tr("Toggle Color"), this);
    connect(m_toggleColorAction, &QAction::triggered, [&]() {
        m_modelRemoveColor = !m_modelRemoveColor;
        Model *mesh = nullptr;
        if (m_document->isMeshGenerating() &&
                m_document->isPostProcessing() &&
                m_document->isTextureGenerating()) {
            mesh = m_document->takeResultMesh();
        } else {
            mesh = m_document->takeResultTextureMesh();
        }
        if (m_modelRemoveColor && mesh)
            mesh->removeColor();
        m_modelRenderWidget->updateMesh(mesh);
    });
    m_viewMenu->addAction(m_toggleColorAction);
    
    m_toggleUvCheckAction = new QAction(tr("Toggle UV Check"), this);
    connect(m_toggleUvCheckAction, &QAction::triggered, [=]() {
        m_modelRenderWidget->toggleUvCheck();
    });
    m_viewMenu->addAction(m_toggleUvCheckAction);

    //connect(m_viewMenu, &QMenu::aboutToShow, [=]() {
    //    m_resetModelWidgetPosAction->setEnabled(!isModelSitInVisibleArea(m_modelRenderWidget));
    //});
    
    m_windowMenu = menuBar()->addMenu(tr("&Window"));
    
    m_showPartsListAction = new QAction(tr("Parts"), this);
    connect(m_showPartsListAction, &QAction::triggered, [=]() {
        partTreeDocker->show();
        partTreeDocker->raise();
    });
    m_windowMenu->addAction(m_showPartsListAction);
    
    m_showMaterialsAction = new QAction(tr("Materials"), this);
    connect(m_showMaterialsAction, &QAction::triggered, [=]() {
        materialDocker->show();
        materialDocker->raise();
    });
    m_windowMenu->addAction(m_showMaterialsAction);
    
    m_showRigAction = new QAction(tr("Rig"), this);
    connect(m_showRigAction, &QAction::triggered, [=]() {
        rigDocker->show();
        rigDocker->raise();
    });
    m_windowMenu->addAction(m_showRigAction);
    
    m_showPosesAction = new QAction(tr("Poses"), this);
    connect(m_showPosesAction, &QAction::triggered, [=]() {
        poseDocker->show();
        poseDocker->raise();
    });
    m_windowMenu->addAction(m_showPosesAction);
    
    m_showMotionsAction = new QAction(tr("Motions"), this);
    connect(m_showMotionsAction, &QAction::triggered, [=]() {
        motionDocker->show();
        motionDocker->raise();
    });
    m_windowMenu->addAction(m_showMotionsAction);
    
    m_showScriptAction = new QAction(tr("Script"), this);
    connect(m_showScriptAction, &QAction::triggered, [=]() {
        scriptDocker->show();
        scriptDocker->raise();
    });
    m_windowMenu->addAction(m_showScriptAction);
    
    QMenu *dialogsMenu = m_windowMenu->addMenu(tr("Dialogs"));
    connect(dialogsMenu, &QMenu::aboutToShow, [=]() {
        dialogsMenu->clear();
        if (this->m_dialogs.empty()) {
            QAction *action = dialogsMenu->addAction(tr("None"));
            action->setEnabled(false);
            return;
        }
        for (const auto &dialog: this->m_dialogs) {
            QAction *action = dialogsMenu->addAction(dialog->windowTitle());
            connect(action, &QAction::triggered, [=]() {
                dialog->show();
                dialog->raise();
            });
        }
    });
    
    m_showDebugDialogAction = new QAction(tr("Debug"), this);
    connect(m_showDebugDialogAction, &QAction::triggered, g_logBrowser, &LogBrowser::showDialog);
    m_windowMenu->addAction(m_showDebugDialogAction);

    m_helpMenu = menuBar()->addMenu(tr("&Help"));
    
    m_gotoHomepageAction = new QAction(tr("Dust3D Homepage"), this);
    connect(m_gotoHomepageAction, &QAction::triggered, this, &DocumentWindow::gotoHomepage);
    m_helpMenu->addAction(m_gotoHomepageAction);

    m_viewSourceAction = new QAction(tr("Source Code"), this);
    connect(m_viewSourceAction, &QAction::triggered, this, &DocumentWindow::viewSource);
    m_helpMenu->addAction(m_viewSourceAction);
    
    m_checkForUpdatesAction = new QAction(tr("Check for Updates..."), this);
    connect(m_checkForUpdatesAction, &QAction::triggered, this, &DocumentWindow::checkForUpdates);
    m_helpMenu->addAction(m_checkForUpdatesAction);

    m_helpMenu->addSeparator();

    m_seeReferenceGuideAction = new QAction(tr("Reference Guide"), this);
    connect(m_seeReferenceGuideAction, &QAction::triggered, this, &DocumentWindow::seeReferenceGuide);
    m_helpMenu->addAction(m_seeReferenceGuideAction);

    m_helpMenu->addSeparator();

    m_aboutAction = new QAction(tr("About"), this);
    connect(m_aboutAction, &QAction::triggered, this, &DocumentWindow::about);
    m_helpMenu->addAction(m_aboutAction);

    m_reportIssuesAction = new QAction(tr("Report Issues"), this);
    connect(m_reportIssuesAction, &QAction::triggered, this, &DocumentWindow::reportIssues);
    m_helpMenu->addAction(m_reportIssuesAction);
    
    m_helpMenu->addSeparator();

    m_seeContributorsAction = new QAction(tr("Contributors"), this);
    connect(m_seeContributorsAction, &QAction::triggered, this, &DocumentWindow::seeContributors);
    m_helpMenu->addAction(m_seeContributorsAction);

    m_seeAcknowlegementsAction = new QAction(tr("Acknowlegements"), this);
    connect(m_seeAcknowlegementsAction, &QAction::triggered, this, &DocumentWindow::seeAcknowlegements);
    m_helpMenu->addAction(m_seeAcknowlegementsAction);

    connect(containerWidget, &GraphicsContainerWidget::containerSizeChanged,
        graphicsWidget, &SkeletonGraphicsWidget::canvasResized);

    connect(m_document, &Document::turnaroundChanged,
        graphicsWidget, &SkeletonGraphicsWidget::turnaroundChanged);

    //connect(rotateCounterclockwiseButton, &QPushButton::clicked, graphicsWidget, &SkeletonGraphicsWidget::rotateAllMainProfileCounterclockwise90DegreeAlongOrigin);
    //connect(rotateClockwiseButton, &QPushButton::clicked, graphicsWidget, &SkeletonGraphicsWidget::rotateAllMainProfileClockwise90DegreeAlongOrigin);

    connect(addButton, &QPushButton::clicked, [=]() {
        m_document->setEditMode(SkeletonDocumentEditMode::Add);
    });

    connect(selectButton, &QPushButton::clicked, [=]() {
        m_document->setEditMode(SkeletonDocumentEditMode::Select);
    });
    
    //connect(markerButton, &QPushButton::clicked, [=]() {
    //    m_document->setEditMode(SkeletonDocumentEditMode::Mark);
    //});
    
    connect(paintButton, &QPushButton::clicked, [=]() {
        m_document->setEditMode(SkeletonDocumentEditMode::Paint);
    });

    //connect(dragButton, &QPushButton::clicked, [=]() {
    //    m_document->setEditMode(SkeletonDocumentEditMode::Drag);
    //});

    connect(zoomInButton, &QPushButton::clicked, [=]() {
        m_document->setEditMode(SkeletonDocumentEditMode::ZoomIn);
    });

    connect(zoomOutButton, &QPushButton::clicked, [=]() {
        m_document->setEditMode(SkeletonDocumentEditMode::ZoomOut);
    });
    
    connect(m_rotationButton, &QPushButton::clicked, this, &DocumentWindow::toggleRotation);

    connect(m_xlockButton, &QPushButton::clicked, [=]() {
        m_document->setXlockState(!m_document->xlocked);
    });
    connect(m_ylockButton, &QPushButton::clicked, [=]() {
        m_document->setYlockState(!m_document->ylocked);
    });
    connect(m_zlockButton, &QPushButton::clicked, [=]() {
        m_document->setZlockState(!m_document->zlocked);
    });
    connect(m_radiusLockButton, &QPushButton::clicked, [=]() {
        m_document->setRadiusLockState(!m_document->radiusLocked);
    });
    
    connect(m_document, &Document::editModeChanged, this, [=]() {
        m_modelRenderWidget->enableMousePicking(SkeletonDocumentEditMode::Paint == m_document->editMode);
    });

    m_partListDockerVisibleSwitchConnection = connect(m_document, &Document::skeletonChanged, [=]() {
        if (m_graphicsWidget->hasItems()) {
            if (partTreeDocker->isHidden())
                partTreeDocker->show();
            disconnect(m_partListDockerVisibleSwitchConnection);
        }
    });

    connect(m_document, &Document::editModeChanged, graphicsWidget, &SkeletonGraphicsWidget::editModeChanged);
    
    connect(graphicsWidget, &SkeletonGraphicsWidget::shortcutToggleWireframe, [=]() {
        m_modelRenderWidget->toggleWireframe();
    });
    
    connect(graphicsWidget, &SkeletonGraphicsWidget::shortcutToggleFlatShading, [=]() {
        Preferences::instance().setFlatShading(!Preferences::instance().flatShading());
    });
    
    connect(graphicsWidget, &SkeletonGraphicsWidget::shortcutToggleRotation, this, &DocumentWindow::toggleRotation);

    connect(graphicsWidget, &SkeletonGraphicsWidget::zoomRenderedModelBy, m_modelRenderWidget, &ModelWidget::zoom);

    connect(graphicsWidget, &SkeletonGraphicsWidget::addNode, m_document, &Document::addNode);
    connect(graphicsWidget, &SkeletonGraphicsWidget::scaleNodeByAddRadius, m_document, &Document::scaleNodeByAddRadius);
    connect(graphicsWidget, &SkeletonGraphicsWidget::moveNodeBy, m_document, &Document::moveNodeBy);
    connect(graphicsWidget, &SkeletonGraphicsWidget::setNodeOrigin, m_document, &Document::setNodeOrigin);
    connect(graphicsWidget, &SkeletonGraphicsWidget::setNodeBoneMark, m_document, &Document::setNodeBoneMark);
    connect(graphicsWidget, &SkeletonGraphicsWidget::clearNodeCutFaceSettings, m_document, &Document::clearNodeCutFaceSettings);
    connect(graphicsWidget, &SkeletonGraphicsWidget::removeNode, m_document, &Document::removeNode);
    connect(graphicsWidget, &SkeletonGraphicsWidget::removePart, m_document, &Document::removePart);
    connect(graphicsWidget, &SkeletonGraphicsWidget::setEditMode, m_document, &Document::setEditMode);
    connect(graphicsWidget, &SkeletonGraphicsWidget::removeEdge, m_document, &Document::removeEdge);
    connect(graphicsWidget, &SkeletonGraphicsWidget::addEdge, m_document, &Document::addEdge);
    connect(graphicsWidget, &SkeletonGraphicsWidget::groupOperationAdded, m_document, &Document::saveSnapshot);
    connect(graphicsWidget, &SkeletonGraphicsWidget::undo, m_document, &Document::undo);
    connect(graphicsWidget, &SkeletonGraphicsWidget::redo, m_document, &Document::redo);
    connect(graphicsWidget, &SkeletonGraphicsWidget::paste, m_document, &Document::paste);
    connect(graphicsWidget, &SkeletonGraphicsWidget::batchChangeBegin, m_document, &Document::batchChangeBegin);
    connect(graphicsWidget, &SkeletonGraphicsWidget::batchChangeEnd, m_document, &Document::batchChangeEnd);
    connect(graphicsWidget, &SkeletonGraphicsWidget::breakEdge, m_document, &Document::breakEdge);
    connect(graphicsWidget, &SkeletonGraphicsWidget::reverseEdge, m_document, &Document::reverseEdge);
    connect(graphicsWidget, &SkeletonGraphicsWidget::moveOriginBy, m_document, &Document::moveOriginBy);
    connect(graphicsWidget, &SkeletonGraphicsWidget::partChecked, m_document, &Document::partChecked);
    connect(graphicsWidget, &SkeletonGraphicsWidget::partUnchecked, m_document, &Document::partUnchecked);
    connect(graphicsWidget, &SkeletonGraphicsWidget::switchNodeXZ, m_document, &Document::switchNodeXZ);

    connect(graphicsWidget, &SkeletonGraphicsWidget::setPartLockState, m_document, &Document::setPartLockState);
    connect(graphicsWidget, &SkeletonGraphicsWidget::setPartVisibleState, m_document, &Document::setPartVisibleState);
    connect(graphicsWidget, &SkeletonGraphicsWidget::setPartSubdivState, m_document, &Document::setPartSubdivState);
    connect(graphicsWidget, &SkeletonGraphicsWidget::setPartChamferState, m_document, &Document::setPartChamferState);
    connect(graphicsWidget, &SkeletonGraphicsWidget::setPartColorState, m_document, &Document::setPartColorState);
    connect(graphicsWidget, &SkeletonGraphicsWidget::setPartDisableState, m_document, &Document::setPartDisableState);
    connect(graphicsWidget, &SkeletonGraphicsWidget::setPartXmirrorState, m_document, &Document::setPartXmirrorState);
    connect(graphicsWidget, &SkeletonGraphicsWidget::setPartRoundState, m_document, &Document::setPartRoundState);
    connect(graphicsWidget, &SkeletonGraphicsWidget::setPartWrapState, m_document, &Document::setPartCutRotation);
    connect(graphicsWidget, &SkeletonGraphicsWidget::addPartByPolygons, m_document, &Document::addPartByPolygons);

    connect(graphicsWidget, &SkeletonGraphicsWidget::setXlockState, m_document, &Document::setXlockState);
    connect(graphicsWidget, &SkeletonGraphicsWidget::setYlockState, m_document, &Document::setYlockState);
    connect(graphicsWidget, &SkeletonGraphicsWidget::setZlockState, m_document, &Document::setZlockState);
    
    connect(graphicsWidget, &SkeletonGraphicsWidget::enableAllPositionRelatedLocks, m_document, &Document::enableAllPositionRelatedLocks);
    connect(graphicsWidget, &SkeletonGraphicsWidget::disableAllPositionRelatedLocks, m_document, &Document::disableAllPositionRelatedLocks);

    connect(graphicsWidget, &SkeletonGraphicsWidget::changeTurnaround, this, &DocumentWindow::changeTurnaround);
    connect(graphicsWidget, &SkeletonGraphicsWidget::open, this, &DocumentWindow::open);
    connect(graphicsWidget, &SkeletonGraphicsWidget::showCutFaceSettingPopup, this, &DocumentWindow::showCutFaceSettingPopup);
    
    connect(graphicsWidget, &SkeletonGraphicsWidget::showOrHideAllComponents, m_document, &Document::showOrHideAllComponents);
    
    connect(m_document, &Document::nodeAdded, graphicsWidget, &SkeletonGraphicsWidget::nodeAdded);
    connect(m_document, &Document::nodeRemoved, graphicsWidget, &SkeletonGraphicsWidget::nodeRemoved);
    connect(m_document, &Document::edgeAdded, graphicsWidget, &SkeletonGraphicsWidget::edgeAdded);
    connect(m_document, &Document::edgeRemoved, graphicsWidget, &SkeletonGraphicsWidget::edgeRemoved);
    connect(m_document, &Document::nodeRadiusChanged, graphicsWidget, &SkeletonGraphicsWidget::nodeRadiusChanged);
    connect(m_document, &Document::nodeBoneMarkChanged, graphicsWidget, &SkeletonGraphicsWidget::nodeBoneMarkChanged);
    connect(m_document, &Document::nodeOriginChanged, graphicsWidget, &SkeletonGraphicsWidget::nodeOriginChanged);
    connect(m_document, &Document::edgeReversed, graphicsWidget, &SkeletonGraphicsWidget::edgeReversed);
    connect(m_document, &Document::partVisibleStateChanged, graphicsWidget, &SkeletonGraphicsWidget::partVisibleStateChanged);
    connect(m_document, &Document::partDisableStateChanged, graphicsWidget, &SkeletonGraphicsWidget::partVisibleStateChanged);
    connect(m_document, &Document::cleanup, graphicsWidget, &SkeletonGraphicsWidget::removeAllContent);
    connect(m_document, &Document::originChanged, graphicsWidget, &SkeletonGraphicsWidget::originChanged);
    connect(m_document, &Document::checkPart, graphicsWidget, &SkeletonGraphicsWidget::selectPartAllById);
    connect(m_document, &Document::enableBackgroundBlur, graphicsWidget, &SkeletonGraphicsWidget::enableBackgroundBlur);
    connect(m_document, &Document::disableBackgroundBlur, graphicsWidget, &SkeletonGraphicsWidget::disableBackgroundBlur);
    connect(m_document, &Document::uncheckAll, graphicsWidget, &SkeletonGraphicsWidget::unselectAll);
    connect(m_document, &Document::checkNode, graphicsWidget, &SkeletonGraphicsWidget::addSelectNode);
    connect(m_document, &Document::checkEdge, graphicsWidget, &SkeletonGraphicsWidget::addSelectEdge);
    
    connect(partTreeWidget, &PartTreeWidget::currentComponentChanged, m_document, &Document::setCurrentCanvasComponentId);
    connect(partTreeWidget, &PartTreeWidget::moveComponentUp, m_document, &Document::moveComponentUp);
    connect(partTreeWidget, &PartTreeWidget::moveComponentDown, m_document, &Document::moveComponentDown);
    connect(partTreeWidget, &PartTreeWidget::moveComponentToTop, m_document, &Document::moveComponentToTop);
    connect(partTreeWidget, &PartTreeWidget::moveComponentToBottom, m_document, &Document::moveComponentToBottom);
    connect(partTreeWidget, &PartTreeWidget::checkPart, m_document, &Document::checkPart);
    connect(partTreeWidget, &PartTreeWidget::createNewComponentAndMoveThisIn, m_document, &Document::createNewComponentAndMoveThisIn);
    connect(partTreeWidget, &PartTreeWidget::createNewChildComponent, m_document, &Document::createNewChildComponent);
    connect(partTreeWidget, &PartTreeWidget::renameComponent, m_document, &Document::renameComponent);
    connect(partTreeWidget, &PartTreeWidget::setComponentExpandState, m_document, &Document::setComponentExpandState);
    connect(partTreeWidget, &PartTreeWidget::setComponentSmoothAll, m_document, &Document::setComponentSmoothAll);
    connect(partTreeWidget, &PartTreeWidget::setComponentSmoothSeam, m_document, &Document::setComponentSmoothSeam);
    connect(partTreeWidget, &PartTreeWidget::setComponentPolyCount, m_document, &Document::setComponentPolyCount);
    connect(partTreeWidget, &PartTreeWidget::setComponentLayer, m_document, &Document::setComponentLayer);
    connect(partTreeWidget, &PartTreeWidget::moveComponent, m_document, &Document::moveComponent);
    connect(partTreeWidget, &PartTreeWidget::removeComponent, m_document, &Document::removeComponent);
    connect(partTreeWidget, &PartTreeWidget::hideOtherComponents, m_document, &Document::hideOtherComponents);
    connect(partTreeWidget, &PartTreeWidget::lockOtherComponents, m_document, &Document::lockOtherComponents);
    connect(partTreeWidget, &PartTreeWidget::hideAllComponents, m_document, &Document::hideAllComponents);
    connect(partTreeWidget, &PartTreeWidget::showAllComponents, m_document, &Document::showAllComponents);
    connect(partTreeWidget, &PartTreeWidget::collapseAllComponents, m_document, &Document::collapseAllComponents);
    connect(partTreeWidget, &PartTreeWidget::expandAllComponents, m_document, &Document::expandAllComponents);
    connect(partTreeWidget, &PartTreeWidget::lockAllComponents, m_document, &Document::lockAllComponents);
    connect(partTreeWidget, &PartTreeWidget::unlockAllComponents, m_document, &Document::unlockAllComponents);
    connect(partTreeWidget, &PartTreeWidget::setPartLockState, m_document, &Document::setPartLockState);
    connect(partTreeWidget, &PartTreeWidget::setPartVisibleState, m_document, &Document::setPartVisibleState);
    connect(partTreeWidget, &PartTreeWidget::setPartColorState, m_document, &Document::setPartColorState);
    connect(partTreeWidget, &PartTreeWidget::setComponentCombineMode, m_document, &Document::setComponentCombineMode);
    connect(partTreeWidget, &PartTreeWidget::setComponentClothStiffness, m_document, &Document::setComponentClothStiffness);
    connect(partTreeWidget, &PartTreeWidget::setComponentClothIteration, m_document, &Document::setComponentClothIteration);
    connect(partTreeWidget, &PartTreeWidget::setComponentClothForce, m_document, &Document::setComponentClothForce);
    connect(partTreeWidget, &PartTreeWidget::setComponentClothOffset, m_document, &Document::setComponentClothOffset);
    connect(partTreeWidget, &PartTreeWidget::setPartTarget, m_document, &Document::setPartTarget);
    connect(partTreeWidget, &PartTreeWidget::setPartBase, m_document, &Document::setPartBase);
    connect(partTreeWidget, &PartTreeWidget::hideDescendantComponents, m_document, &Document::hideDescendantComponents);
    connect(partTreeWidget, &PartTreeWidget::showDescendantComponents, m_document, &Document::showDescendantComponents);
    connect(partTreeWidget, &PartTreeWidget::lockDescendantComponents, m_document, &Document::lockDescendantComponents);
    connect(partTreeWidget, &PartTreeWidget::unlockDescendantComponents, m_document, &Document::unlockDescendantComponents);
    connect(partTreeWidget, &PartTreeWidget::groupOperationAdded, m_document, &Document::saveSnapshot);
    
    connect(partTreeWidget, &PartTreeWidget::addPartToSelection, graphicsWidget, &SkeletonGraphicsWidget::addPartToSelection);
    
    connect(graphicsWidget, &SkeletonGraphicsWidget::partComponentChecked, partTreeWidget, &PartTreeWidget::partComponentChecked);
    
    connect(m_document, &Document::componentNameChanged, partTreeWidget, &PartTreeWidget::componentNameChanged);
    connect(m_document, &Document::componentChildrenChanged, partTreeWidget, &PartTreeWidget::componentChildrenChanged);
    connect(m_document, &Document::componentRemoved, partTreeWidget, &PartTreeWidget::componentRemoved);
    connect(m_document, &Document::componentAdded, partTreeWidget, &PartTreeWidget::componentAdded);
    connect(m_document, &Document::componentExpandStateChanged, partTreeWidget, &PartTreeWidget::componentExpandStateChanged);
    connect(m_document, &Document::componentCombineModeChanged, partTreeWidget, &PartTreeWidget::componentCombineModeChanged);
    connect(m_document, &Document::partPreviewChanged, partTreeWidget, &PartTreeWidget::partPreviewChanged);
    connect(m_document, &Document::partLockStateChanged, partTreeWidget, &PartTreeWidget::partLockStateChanged);
    connect(m_document, &Document::partVisibleStateChanged, partTreeWidget, &PartTreeWidget::partVisibleStateChanged);
    connect(m_document, &Document::partSubdivStateChanged, partTreeWidget, &PartTreeWidget::partSubdivStateChanged);
    connect(m_document, &Document::partDisableStateChanged, partTreeWidget, &PartTreeWidget::partDisableStateChanged);
    connect(m_document, &Document::partXmirrorStateChanged, partTreeWidget, &PartTreeWidget::partXmirrorStateChanged);
    connect(m_document, &Document::partDeformThicknessChanged, partTreeWidget, &PartTreeWidget::partDeformChanged);
    connect(m_document, &Document::partDeformWidthChanged, partTreeWidget, &PartTreeWidget::partDeformChanged);
    connect(m_document, &Document::partDeformMapImageIdChanged, partTreeWidget, &PartTreeWidget::partDeformChanged);
    connect(m_document, &Document::partDeformMapScaleChanged, partTreeWidget, &PartTreeWidget::partDeformChanged);
    connect(m_document, &Document::partRoundStateChanged, partTreeWidget, &PartTreeWidget::partRoundStateChanged);
    connect(m_document, &Document::partChamferStateChanged, partTreeWidget, &PartTreeWidget::partChamferStateChanged);
    connect(m_document, &Document::partColorStateChanged, partTreeWidget, &PartTreeWidget::partColorStateChanged);
    connect(m_document, &Document::partCutRotationChanged, partTreeWidget, &PartTreeWidget::partCutRotationChanged);
    connect(m_document, &Document::partCutFaceChanged, partTreeWidget, &PartTreeWidget::partCutFaceChanged);
    connect(m_document, &Document::partHollowThicknessChanged, partTreeWidget, &PartTreeWidget::partHollowThicknessChanged);
    connect(m_document, &Document::partMaterialIdChanged, partTreeWidget, &PartTreeWidget::partMaterialIdChanged);
    connect(m_document, &Document::partColorSolubilityChanged, partTreeWidget, &PartTreeWidget::partColorSolubilityChanged);
    connect(m_document, &Document::partCountershadeStateChanged, partTreeWidget, &PartTreeWidget::partCountershadeStateChanged);
    
    connect(m_document, &Document::partTargetChanged, partTreeWidget, &PartTreeWidget::partXmirrorStateChanged);
    connect(m_document, &Document::partTargetChanged, partTreeWidget, &PartTreeWidget::partColorStateChanged);
    connect(m_document, &Document::partTargetChanged, partTreeWidget, &PartTreeWidget::partSubdivStateChanged);
    connect(m_document, &Document::partTargetChanged, partTreeWidget, &PartTreeWidget::partRoundStateChanged);
    connect(m_document, &Document::partTargetChanged, partTreeWidget, &PartTreeWidget::partChamferStateChanged);
    connect(m_document, &Document::partTargetChanged, partTreeWidget, &PartTreeWidget::partCutRotationChanged);
    connect(m_document, &Document::partTargetChanged, partTreeWidget, &PartTreeWidget::partDeformChanged);
    
    connect(m_document, &Document::partRemoved, partTreeWidget, &PartTreeWidget::partRemoved);
    connect(m_document, &Document::cleanup, partTreeWidget, &PartTreeWidget::removeAllContent);
    connect(m_document, &Document::partChecked, partTreeWidget, &PartTreeWidget::partChecked);
    connect(m_document, &Document::partUnchecked, partTreeWidget, &PartTreeWidget::partUnchecked);

    connect(m_document, &Document::skeletonChanged, m_document, &Document::generateMesh);
    //connect(m_document, &SkeletonDocument::resultMeshChanged, [=]() {
    //    if ((m_exportPreviewWidget && m_exportPreviewWidget->isVisible())) {
    //        m_document->postProcess();
    //    }
    //});
    //connect(m_document, &SkeletonDocument::textureChanged, [=]() {
    //    if ((m_exportPreviewWidget && m_exportPreviewWidget->isVisible())) {
    //        m_document->generateTexture();
    //    }
    //});
    connect(m_document, &Document::textureChanged, m_document, &Document::generateTexture);
    connect(m_document, &Document::resultMeshChanged, m_document, &Document::postProcess);
    connect(m_document, &Document::postProcessedResultChanged, m_document, &Document::generateRig);
    connect(m_document, &Document::rigChanged, m_document, &Document::generateRig);
    connect(m_document, &Document::postProcessedResultChanged, m_document, &Document::generateTexture);
    //connect(m_document, &SkeletonDocument::resultTextureChanged, m_document, &SkeletonDocument::bakeAmbientOcclusionTexture);
    connect(m_document, &Document::resultTextureChanged, [=]() {
        if (m_document->isMeshGenerating())
            return;
        auto resultTextureMesh = m_document->takeResultTextureMesh();
        if (nullptr != resultTextureMesh) {
            if (resultTextureMesh->meshId() < m_currentUpdatedMeshId) {
                delete resultTextureMesh;
                return;
            }
        }
        if (m_modelRemoveColor && resultTextureMesh)
            resultTextureMesh->removeColor();
        m_modelRenderWidget->updateMesh(resultTextureMesh);
    });
    
    connect(m_document, &Document::resultMeshChanged, [=]() {
        auto resultMesh = m_document->takeResultMesh();
        if (nullptr != resultMesh)
            m_currentUpdatedMeshId = resultMesh->meshId();
        if (m_modelRemoveColor && resultMesh)
            resultMesh->removeColor();
        m_modelRenderWidget->updateMesh(resultMesh);
    });
    
    connect(m_document, &Document::posesChanged, m_document, &Document::generateMotions);
    connect(m_document, &Document::motionsChanged, m_document, &Document::generateMotions);

    connect(graphicsWidget, &SkeletonGraphicsWidget::cursorChanged, [=]() {
        m_modelRenderWidget->setCursor(graphicsWidget->cursor());
        containerWidget->setCursor(graphicsWidget->cursor());
        //m_skeletonRenderWidget->setCursor(graphicsWidget->cursor());
    });

    connect(m_document, &Document::skeletonChanged, this, &DocumentWindow::documentChanged);
    connect(m_document, &Document::turnaroundChanged, this, &DocumentWindow::documentChanged);
    connect(m_document, &Document::optionsChanged, this, &DocumentWindow::documentChanged);
    connect(m_document, &Document::rigChanged, this, &DocumentWindow::documentChanged);
    connect(m_document, &Document::scriptChanged, this, &DocumentWindow::documentChanged);

    connect(m_modelRenderWidget, &ModelWidget::customContextMenuRequested, [=](const QPoint &pos) {
        graphicsWidget->showContextMenu(graphicsWidget->mapFromGlobal(m_modelRenderWidget->mapToGlobal(pos)));
    });

    connect(m_document, &Document::xlockStateChanged, this, &DocumentWindow::updateXlockButtonState);
    connect(m_document, &Document::ylockStateChanged, this, &DocumentWindow::updateYlockButtonState);
    connect(m_document, &Document::zlockStateChanged, this, &DocumentWindow::updateZlockButtonState);
    connect(m_document, &Document::radiusLockStateChanged, this, &DocumentWindow::updateRadiusLockButtonState);
    
    connect(m_rigWidget, &RigWidget::setRigType, m_document, &Document::setRigType);
    
    connect(m_document, &Document::rigTypeChanged, m_rigWidget, &RigWidget::rigTypeChanged);
    connect(m_document, &Document::resultRigChanged, m_rigWidget, &RigWidget::updateResultInfo);
    connect(m_document, &Document::resultRigChanged, this, &DocumentWindow::updateRigWeightRenderWidget);
    
    //connect(m_document, &SkeletonDocument::resultRigChanged, tetrapodPoseEditWidget, &TetrapodPoseEditWidget::updatePreview);
    
    connect(m_document, &Document::poseAdded, this, [=](QUuid poseId) {
        Q_UNUSED(poseId);
        m_document->generatePosePreviews();
    });
    connect(m_document, &Document::poseFramesChanged, this, [=](QUuid poseId) {
        Q_UNUSED(poseId);
        m_document->generatePosePreviews();
    });
    connect(m_document, &Document::resultRigChanged, m_document, &Document::generatePosePreviews);
    
    connect(m_document, &Document::resultRigChanged, m_document, &Document::generateMotions);
    
    connect(m_document, &Document::materialAdded, this, [=](QUuid materialId) {
        Q_UNUSED(materialId);
        m_document->generateMaterialPreviews();
    });
    connect(m_document, &Document::materialLayersChanged, this, [=](QUuid materialId) {
        Q_UNUSED(materialId);
        m_document->generateMaterialPreviews();
    });
    
    connect(m_document, &Document::scriptChanged, m_document, &Document::runScript);
    connect(m_document, &Document::scriptModifiedFromExternal, m_document, &Document::runScript);
    
    initShortCuts(this, m_graphicsWidget);

    connect(this, &DocumentWindow::initialized, m_document, &Document::uiReady);
    connect(this, &DocumentWindow::initialized, this, &DocumentWindow::autoRecover);
    
    m_autoSaver = new AutoSaver(m_document);
    
    QTimer *timer = new QTimer(this);
    timer->setInterval(250);
    connect(timer, &QTimer::timeout, [=] {
        QWidget *focusedWidget = QApplication::focusWidget();
        //qDebug() << (focusedWidget ? ("Focused on:" + QString(focusedWidget->metaObject()->className()) + " title:" + focusedWidget->windowTitle()) : "No Focus") << " isActive:" << isActiveWindow();
        if (nullptr == focusedWidget && isActiveWindow())
            graphicsWidget->setFocus();
    });
    timer->start();
}

void DocumentWindow::toggleRotation()
{
    if (nullptr == m_graphicsWidget)
        return;
    m_graphicsWidget->setRotated(!m_graphicsWidget->rotated());
    updateRotationButtonState();
}

DocumentWindow *DocumentWindow::createDocumentWindow()
{
    DocumentWindow *documentWindow = new DocumentWindow();
    documentWindow->setAttribute(Qt::WA_DeleteOnClose);

    QSize size = Preferences::instance().documentWindowSize();
    if (size.isValid()) {
        documentWindow->resize(size);
        documentWindow->show();
    } else {
        documentWindow->showMaximized();
    }

    return documentWindow;
}

void DocumentWindow::closeEvent(QCloseEvent *event)
{
    if (! m_documentSaved) {
        QMessageBox::StandardButton answer = QMessageBox::question(this,
            APP_NAME,
            tr("Do you really want to close while there are unsaved changes?"),
            QMessageBox::Yes | QMessageBox::No,
            QMessageBox::No);
        if (answer == QMessageBox::No) {
            event->ignore();
            return;
        }
    }
    
    m_autoSaver->stop();

    QSize saveSize;
    if (!isMaximized())
        saveSize = size();
    Preferences::instance().setDocumentWindowSize(saveSize);

    event->accept();
}

void DocumentWindow::setCurrentFilename(const QString &filename)
{
    m_currentFilename = filename;
    m_documentSaved = true;
    updateTitle();
}

void DocumentWindow::updateTitle()
{
    QString appName = APP_NAME;
    QString appVer = APP_HUMAN_VER;
    setWindowTitle(QString("%1 %2 %3%4").arg(appName).arg(appVer).arg(m_currentFilename).arg(m_documentSaved ? "" : "*"));
}

void DocumentWindow::documentChanged()
{
    if (m_documentSaved) {
        m_documentSaved = false;
        updateTitle();
    }
    
    m_autoSaver->documentChanged();
}

void DocumentWindow::newWindow()
{
    DocumentWindow::createDocumentWindow();
}

void DocumentWindow::newDocument()
{
    if (!m_documentSaved) {
        QMessageBox::StandardButton answer = QMessageBox::question(this,
            APP_NAME,
            tr("Do you really want to create new document and lose the unsaved changes?"),
            QMessageBox::Yes | QMessageBox::No,
            QMessageBox::No);
        if (answer != QMessageBox::Yes)
            return;
    }
    m_document->clearHistories();
    m_document->resetScript();
    m_document->reset();
    m_document->saveSnapshot();
}

void DocumentWindow::saveAs()
{
    QString filename = QFileDialog::getSaveFileName(this, QString(), QString(),
       tr("Dust3D Document (*.ds3)"));
    if (filename.isEmpty()) {
        return;
    }
    saveTo(filename);
}

void DocumentWindow::saveAll()
{
    for (auto &it: g_documentWindows) {
        it.first->save();
    }
}

void DocumentWindow::viewSource()
{
    QString url = APP_REPOSITORY_URL;
    qDebug() << "viewSource:" << url;
    QDesktopServices::openUrl(QUrl(url));
}

void DocumentWindow::gotoHomepage()
{
    QString url = APP_HOMEPAGE_URL;
    qDebug() << "gotoHomepage:" << url;
    QDesktopServices::openUrl(QUrl(url));
}

void DocumentWindow::about()
{
    DocumentWindow::showAbout();
}

void DocumentWindow::reportIssues()
{
    QString url = APP_ISSUES_URL;
    qDebug() << "reportIssues:" << url;
    QDesktopServices::openUrl(QUrl(url));
}

void DocumentWindow::seeReferenceGuide()
{
    QString url = APP_REFERENCE_GUIDE_URL;
    qDebug() << "referenceGuide:" << url;
    QDesktopServices::openUrl(QUrl(url));
}

void DocumentWindow::seeAcknowlegements()
{
    DocumentWindow::showAcknowlegements();
}

void DocumentWindow::seeContributors()
{
    DocumentWindow::showContributors();
}

void DocumentWindow::initLockButton(QPushButton *button)
{
    QFont font;
    font.setWeight(QFont::Light);
    font.setPixelSize(Theme::toolIconFontSize);
    font.setBold(false);

    button->setFont(font);
    button->setFixedSize(Theme::toolIconSize, Theme::toolIconSize);
    button->setStyleSheet("QPushButton {color: #f7d9c8}");
    button->setFocusPolicy(Qt::NoFocus);
}

DocumentWindow::~DocumentWindow()
{
    emit uninialized();
    g_documentWindows.erase(this);
    delete m_document;
}

void DocumentWindow::showEvent(QShowEvent *event)
{
    QMainWindow::showEvent(event);
    if (m_firstShow) {
        m_firstShow = false;
        updateTitle();
        m_document->saveSnapshot();
        m_graphicsWidget->setFocus();
        emit initialized();
    }
}

void DocumentWindow::autoRecover()
{
    if (m_autoRecovered)
        return;
    
    m_autoRecovered = true;
    
    QString dir = AutoSaver::autoSavedDir();
    if (dir.isEmpty())
        return;
    
    QDir recoverFromDir(dir, "*.d3b");
    recoverFromDir.setSorting(QDir::Name);
    auto autoSavedFiles = recoverFromDir.entryList();
    if (autoSavedFiles.isEmpty())
        return;
    
    auto filename = dir + QDir::separator() + autoSavedFiles.last();
    openPathAs(filename, "");
    m_documentSaved = false;
    updateTitle();
    QFile::remove(filename);
}

void DocumentWindow::mousePressEvent(QMouseEvent *event)
{
    QMainWindow::mousePressEvent(event);
}

void DocumentWindow::changeTurnaround()
{
    QString fileName = QFileDialog::getOpenFileName(this, QString(), QString(),
        tr("Image Files (*.png *.jpg *.bmp)")).trimmed();
    if (fileName.isEmpty())
        return;
    QImage image;
    if (!image.load(fileName))
        return;
    m_document->updateTurnaround(image);
}

void DocumentWindow::save()
{
    saveTo(m_currentFilename);
}

void DocumentWindow::saveTo(const QString &saveAsFilename)
{
    QString filename = saveAsFilename;

    if (filename.isEmpty()) {
        filename = QFileDialog::getSaveFileName(this, QString(), QString(),
           tr("Dust3D Document (*.ds3)"));
        if (filename.isEmpty()) {
            return;
        }
    }
    
    QApplication::setOverrideCursor(Qt::WaitCursor);
    Snapshot snapshot;
    m_document->toSnapshot(&snapshot);
    if (DocumentSaver::save(&filename, 
            &snapshot, 
            (!m_document->turnaround.isNull() && m_document->turnaroundPngByteArray.size() > 0) ? 
                &m_document->turnaroundPngByteArray : nullptr,
            (!m_document->script().isEmpty()) ? &m_document->script() : nullptr,
            (!m_document->variables().empty()) ? &m_document->variables() : nullptr)) {
        setCurrentFilename(filename);
    }
    QApplication::restoreOverrideCursor();
}

void DocumentWindow::importPath(const QString &path)
{
    QApplication::setOverrideCursor(Qt::WaitCursor);
    Ds3FileReader ds3Reader(path);
    bool documentChanged = false;
    
    for (int i = 0; i < ds3Reader.items().size(); ++i) {
        Ds3ReaderItem item = ds3Reader.items().at(i);
        if (item.type == "asset") {
            if (item.name.startsWith("images/")) {
                QString filename = item.name.split("/")[1];
                QString imageIdString = filename.split(".")[0];
                QUuid imageId = QUuid(imageIdString);
                if (!imageId.isNull()) {
                    QByteArray data;
                    ds3Reader.loadItem(item.name, &data);
                    QImage image = QImage::fromData(data, "PNG");
                    (void)ImageForever::add(&image, imageId);
                }
            }
        }
    }
    
    for (int i = 0; i < ds3Reader.items().size(); ++i) {
        Ds3ReaderItem item = ds3Reader.items().at(i);
        if (item.type == "model") {
            {
                QByteArray data;
                ds3Reader.loadItem(item.name, &data);
                QXmlStreamReader stream(data);
            
                Snapshot snapshot;
                loadSkeletonFromXmlStream(&snapshot, stream, SNAPSHOT_ITEM_MATERIAL);
                m_document->addFromSnapshot(snapshot, Document::SnapshotSource::Import);
                documentChanged = true;
            }
            {
                QByteArray data;
                ds3Reader.loadItem(item.name, &data);
                QXmlStreamReader stream(data);
                
                Snapshot snapshot;
                loadSkeletonFromXmlStream(&snapshot, stream, SNAPSHOT_ITEM_CANVAS | SNAPSHOT_ITEM_COMPONENT);

                QByteArray modelXml;
                QXmlStreamWriter modelStream(&modelXml);
                saveSkeletonToXmlStream(&snapshot, &modelStream);
                if (modelXml.size() > 0) {
                    QUuid fillMeshFileId = FileForever::add(item.name, modelXml);
                    if (!fillMeshFileId.isNull()) {
                        Snapshot partSnapshot;
                        createPartSnapshotForFillMesh(fillMeshFileId, &partSnapshot);
                        m_document->addFromSnapshot(partSnapshot, Document::SnapshotSource::Paste);
                        documentChanged = true;
                    }
                }
            }
        }
    }
    
    if (documentChanged)
        m_document->saveSnapshot();
    
    QApplication::restoreOverrideCursor();
}

void DocumentWindow::createPartSnapshotForFillMesh(const QUuid &fillMeshFileId, Snapshot *snapshot)
{
    if (fillMeshFileId.isNull())
        return;
    
    auto partId = QUuid::createUuid();
    auto partIdString = partId.toString();
    std::map<QString, QString> snapshotPart;
    snapshotPart["id"] = partIdString;
    snapshotPart["fillMesh"] = fillMeshFileId.toString();
    snapshot->parts[partIdString] = snapshotPart;
    
    auto componentId = QUuid::createUuid();
    auto componentIdString = componentId.toString();
    std::map<QString, QString> snapshotComponent;
    snapshotComponent["id"] = componentIdString;
    snapshotComponent["combineMode"] = CombineModeToString(Preferences::instance().componentCombineMode());
    snapshotComponent["linkDataType"] = "partId";
    snapshotComponent["linkData"] = partIdString;
    snapshot->components[componentIdString] = snapshotComponent;
    
    snapshot->rootComponent["children"] = componentIdString;
    
    auto createNode = [&](const QVector3D &position, float radius) {
        auto nodeId = QUuid::createUuid();
        auto nodeIdString = nodeId.toString();
        std::map<QString, QString> snapshotNode;
        snapshotNode["id"] = nodeIdString;
        snapshotNode["x"] = QString::number(position.x());
        snapshotNode["y"] = QString::number(position.y());
        snapshotNode["z"] = QString::number(position.z());
        snapshotNode["radius"] = QString::number(radius);
        snapshotNode["partId"] = partIdString;
        snapshot->nodes[nodeIdString] = snapshotNode;
        return nodeIdString;
    };
    
    auto createEdge = [&](const QString &fromNode, const QString &toNode) {
        auto edgeId = QUuid::createUuid();
        auto edgeIdString = edgeId.toString();
        std::map<QString, QString> snapshotEdge;
        snapshotEdge["id"] = edgeIdString;
        snapshotEdge["from"] = fromNode;
        snapshotEdge["to"] = toNode;
        snapshotEdge["partId"] = partIdString;
        snapshot->edges[edgeIdString] = snapshotEdge;
    };
    
    createEdge(createNode(QVector3D(0.5, 0.5, 1.0), 0.1), 
        createNode(QVector3D(0.5, 0.3, 1.0), 0.1));
}

void DocumentWindow::openPathAs(const QString &path, const QString &asName)
{
    QApplication::setOverrideCursor(Qt::WaitCursor);
    Ds3FileReader ds3Reader(path);
    
    m_document->clearHistories();
    m_document->resetScript();
    m_document->reset();
    m_document->saveSnapshot();
    
    for (int i = 0; i < ds3Reader.items().size(); ++i) {
        Ds3ReaderItem item = ds3Reader.items().at(i);
        if (item.type == "asset") {
            if (item.name.startsWith("images/")) {
                QString filename = item.name.split("/")[1];
                QString imageIdString = filename.split(".")[0];
                QUuid imageId = QUuid(imageIdString);
                if (!imageId.isNull()) {
                    QByteArray data;
                    ds3Reader.loadItem(item.name, &data);
                    QImage image = QImage::fromData(data, "PNG");
                    (void)ImageForever::add(&image, imageId);
                }
            } else if (item.name.startsWith("files/")) {
                QString filename = item.name.split("/")[1];
                QString fileIdString = filename.split(".")[0];
                QUuid fileId = QUuid(fileIdString);
                if (!fileId.isNull()) {
                    QByteArray data;
                    ds3Reader.loadItem(item.name, &data);
                    (void)FileForever::add(item.name, data, fileId);
                }
            }
        }
    }
    
    for (int i = 0; i < ds3Reader.items().size(); ++i) {
        Ds3ReaderItem item = ds3Reader.items().at(i);
        if (item.type == "model") {
            QByteArray data;
            ds3Reader.loadItem(item.name, &data);
            QXmlStreamReader stream(data);
            Snapshot snapshot;
            loadSkeletonFromXmlStream(&snapshot, stream);
            m_document->fromSnapshot(snapshot);
            m_document->saveSnapshot();
        } else if (item.type == "asset") {
            if (item.name == "canvas.png") {
                QByteArray data;
                ds3Reader.loadItem(item.name, &data);
                QImage image = QImage::fromData(data, "PNG");
                m_document->updateTurnaround(image);
            }
        } else if (item.type == "script") {
            if (item.name == "model.js") {
                QByteArray script;
                ds3Reader.loadItem(item.name, &script);
                m_document->initScript(QString::fromUtf8(script.constData()));
            }
        } else if (item.type == "variable") {
            if (item.name == "variables.xml") {
                QByteArray data;
                ds3Reader.loadItem(item.name, &data);
                QXmlStreamReader stream(data);
                std::map<QString, std::map<QString, QString>> variables;
                loadVariablesFromXmlStream(&variables, stream);
                for (const auto &it: variables)
                    m_document->updateVariable(it.first, it.second);
            }
        }
    }
    QApplication::restoreOverrideCursor();

    setCurrentFilename(asName);
}

void DocumentWindow::openExample(const QString &modelName)
{
    if (!m_documentSaved) {
        QMessageBox::StandardButton answer = QMessageBox::question(this,
            APP_NAME,
            tr("Do you really want to open example and lose the unsaved changes?"),
            QMessageBox::Yes | QMessageBox::No,
            QMessageBox::No);
        if (answer != QMessageBox::Yes)
            return;
    }
    
    openPathAs(":/resources/" + modelName, "");
}

void DocumentWindow::open()
{
    if (!m_documentSaved) {
        QMessageBox::StandardButton answer = QMessageBox::question(this,
            APP_NAME,
            tr("Do you really want to open another file and lose the unsaved changes?"),
            QMessageBox::Yes | QMessageBox::No,
            QMessageBox::No);
        if (answer != QMessageBox::Yes)
            return;
    }

    QString filename = QFileDialog::getOpenFileName(this, QString(), QString(),
        tr("Dust3D Document (*.ds3)"));
    if (filename.isEmpty())
        return;
    
    openPathAs(filename, filename);
}

void DocumentWindow::showPreferences()
{
    if (nullptr == m_preferencesWidget) {
        m_preferencesWidget = new PreferencesWidget(m_document, this);
        connect(m_preferencesWidget, &PreferencesWidget::enableBackgroundBlur, m_document, &Document::enableBackgroundBlur);
        connect(m_preferencesWidget, &PreferencesWidget::disableBackgroundBlur, m_document, &Document::disableBackgroundBlur);
    }
    m_preferencesWidget->show();
    m_preferencesWidget->raise();
}

void DocumentWindow::exportRenderedResult()
{
    QString filename = QFileDialog::getSaveFileName(this, QString(), QString(),
       tr("Image (*.png)"));
    if (filename.isEmpty()) {
        return;
    }
    exportImageToFilename(filename);
}

void DocumentWindow::exportObjResult()
{
    QString filename = QFileDialog::getSaveFileName(this, QString(), QString(),
       tr("Wavefront (*.obj)"));
    if (filename.isEmpty()) {
        return;
    }
    exportObjToFilename(filename);
}

void DocumentWindow::exportObjToFilename(const QString &filename)
{
    QApplication::setOverrideCursor(Qt::WaitCursor);
    Model *resultMesh = m_document->takeResultMesh();
    if (nullptr != resultMesh) {
        resultMesh->exportAsObj(filename);
        delete resultMesh;
    }
    QApplication::restoreOverrideCursor();
}

void DocumentWindow::showExportPreview()
{
    if (nullptr == m_exportPreviewWidget) {
        m_exportPreviewWidget = new ExportPreviewWidget(m_document, this);
        connect(m_exportPreviewWidget, &ExportPreviewWidget::regenerate, m_document, &Document::regenerateMesh);
        connect(m_exportPreviewWidget, &ExportPreviewWidget::saveAsGlb, this, &DocumentWindow::exportGlbResult);
        connect(m_exportPreviewWidget, &ExportPreviewWidget::saveAsFbx, this, &DocumentWindow::exportFbxResult);
        connect(m_document, &Document::resultMeshChanged, m_exportPreviewWidget, &ExportPreviewWidget::checkSpinner);
        connect(m_document, &Document::exportReady, m_exportPreviewWidget, &ExportPreviewWidget::checkSpinner);
        connect(m_document, &Document::resultTextureChanged, m_exportPreviewWidget, &ExportPreviewWidget::updateTexturePreview);
        //connect(m_document, &Document::resultBakedTextureChanged, m_exportPreviewWidget, &ExportPreviewWidget::updateTexturePreview);
        registerDialog(m_exportPreviewWidget);
    }
    m_exportPreviewWidget->show();
    m_exportPreviewWidget->raise();
}

void DocumentWindow::exportFbxResult()
{
    QString filename = QFileDialog::getSaveFileName(this, QString(), QString(),
       tr("Autodesk FBX (.fbx)"));
    if (filename.isEmpty()) {
        return;
    }
    exportFbxToFilename(filename);
}

void DocumentWindow::exportFbxToFilename(const QString &filename)
{
    if (!m_document->isExportReady()) {
        qDebug() << "Export but document is not export ready";
        return;
    }
    QApplication::setOverrideCursor(Qt::WaitCursor);
    Outcome skeletonResult = m_document->currentPostProcessedOutcome();
    std::vector<std::pair<QString, std::vector<std::pair<float, JointNodeTree>>>> exportMotions;
    for (const auto &motionId: m_document->motionIdList) {
        const Motion *motion = m_document->findMotion(motionId);
        if (nullptr == motion)
            continue;
        exportMotions.push_back({motion->name, motion->jointNodeTrees});
    }
    FbxFileWriter fbxFileWriter(skeletonResult, m_document->resultRigBones(), m_document->resultRigWeights(), filename,
        m_document->textureImage,
        m_document->textureNormalImage,
        m_document->textureMetalnessImage,
        m_document->textureRoughnessImage,
        m_document->textureAmbientOcclusionImage,
        exportMotions.empty() ? nullptr : &exportMotions);
    fbxFileWriter.save();
    QApplication::restoreOverrideCursor();
}

void DocumentWindow::exportGlbResult()
{
    QString filename = QFileDialog::getSaveFileName(this, QString(), QString(),
       tr("glTF Binary Format (.glb)"));
    if (filename.isEmpty()) {
        return;
    }
    exportGlbToFilename(filename);
}

void DocumentWindow::exportGlbToFilename(const QString &filename)
{
    if (!m_document->isExportReady()) {
        qDebug() << "Export but document is not export ready";
        return;
    }
    QApplication::setOverrideCursor(Qt::WaitCursor);
    Outcome skeletonResult = m_document->currentPostProcessedOutcome();
    std::vector<std::pair<QString, std::vector<std::pair<float, JointNodeTree>>>> exportMotions;
    for (const auto &motionId: m_document->motionIdList) {
        const Motion *motion = m_document->findMotion(motionId);
        if (nullptr == motion)
            continue;
        exportMotions.push_back({motion->name, motion->jointNodeTrees});
    }
    GlbFileWriter glbFileWriter(skeletonResult, m_document->resultRigBones(), m_document->resultRigWeights(), filename,
        m_document->textureHasTransparencySettings,
        m_document->textureImage, m_document->textureNormalImage, m_document->textureMetalnessRoughnessAmbientOcclusionImage, exportMotions.empty() ? nullptr : &exportMotions);
    glbFileWriter.save();
    QApplication::restoreOverrideCursor();
}

void DocumentWindow::updateXlockButtonState()
{
    if (m_document->xlocked)
        m_xlockButton->setStyleSheet("QPushButton {color: #252525}");
    else
        m_xlockButton->setStyleSheet("QPushButton {color: " + Theme::red.name() + "}");
}

void DocumentWindow::updateRotationButtonState()
{
    if (nullptr == m_graphicsWidget)
        return;
    if (m_graphicsWidget->rotated()) {
        m_rotationButton->setText(QChar(fa::caretsquareoleft));
        m_rotationButton->setStyleSheet("QPushButton {color: " + Theme::blue.name() + "}");
    } else {
        m_rotationButton->setText(QChar(fa::caretsquareoup));
        m_rotationButton->setStyleSheet("QPushButton {color: " + Theme::white.name() + "}");
    }
}

void DocumentWindow::updateYlockButtonState()
{
    if (m_document->ylocked)
        m_ylockButton->setStyleSheet("QPushButton {color: #252525}");
    else
        m_ylockButton->setStyleSheet("QPushButton {color: " + Theme::blue.name() + "}");
}

void DocumentWindow::updateZlockButtonState()
{
    if (m_document->zlocked)
        m_zlockButton->setStyleSheet("QPushButton {color: #252525}");
    else
        m_zlockButton->setStyleSheet("QPushButton {color: " + Theme::green.name() + "}");
}

void DocumentWindow::updateRadiusLockButtonState()
{
    if (m_document->radiusLocked)
        m_radiusLockButton->setStyleSheet("QPushButton {color: #252525}");
    else
        m_radiusLockButton->setStyleSheet("QPushButton {color: " + Theme::white.name() + "}");
}

void DocumentWindow::updateRigWeightRenderWidget()
{
    Model *resultRigWeightMesh = m_document->takeResultRigWeightMesh();
    if (nullptr == resultRigWeightMesh) {
        m_rigWidget->rigWeightRenderWidget()->hide();
    } else {
        m_rigWidget->rigWeightRenderWidget()->updateMesh(resultRigWeightMesh);
        m_rigWidget->rigWeightRenderWidget()->show();
        m_rigWidget->rigWeightRenderWidget()->update();
    }
}

void DocumentWindow::registerDialog(QWidget *widget)
{
    m_dialogs.push_back(widget);
}

void DocumentWindow::unregisterDialog(QWidget *widget)
{
    m_dialogs.erase(std::remove(m_dialogs.begin(), m_dialogs.end(), widget), m_dialogs.end());
}

void DocumentWindow::showCutFaceSettingPopup(const QPoint &globalPos, std::set<QUuid> nodeIds)
{
    QMenu popupMenu;
    
    const SkeletonNode *node = nullptr;
    if (1 == nodeIds.size()) {
        node = m_document->findNode(*nodeIds.begin());
    }
    
    QWidget *popup = new QWidget;
    
    FloatNumberWidget *rotationWidget = new FloatNumberWidget;
    rotationWidget->setItemName(tr("Rotation"));
    rotationWidget->setRange(-1, 1);
    rotationWidget->setValue(0);
    if (nullptr != node) {
        rotationWidget->setValue(node->cutRotation);
    }
    
    connect(rotationWidget, &FloatNumberWidget::valueChanged, [=](float value) {
        m_document->batchChangeBegin();
        for (const auto &id: nodeIds) {
            m_document->setNodeCutRotation(id, value);
        }
        m_document->batchChangeEnd();
        m_document->saveSnapshot();
    });
    
    QPushButton *rotationEraser = new QPushButton(QChar(fa::eraser));
    Theme::initAwesomeToolButton(rotationEraser);
    
    connect(rotationEraser, &QPushButton::clicked, [=]() {
        rotationWidget->setValue(0.0);
        m_document->saveSnapshot();
    });
    
    QHBoxLayout *rotationLayout = new QHBoxLayout;
    rotationLayout->addWidget(rotationEraser);
    rotationLayout->addWidget(rotationWidget);
    
    QHBoxLayout *standardFacesLayout = new QHBoxLayout;
    QPushButton *buttons[(int)CutFace::Count] = {0};
    
    CutFaceListWidget *cutFaceListWidget = new CutFaceListWidget(m_document);
    size_t cutFaceTypeCount = (size_t)CutFace::UserDefined;
    
    auto updateCutFaceButtonState = [&](size_t index) {
        if (index != (int)CutFace::UserDefined)
            cutFaceListWidget->selectCutFace(QUuid());
        for (size_t i = 0; i < (size_t)cutFaceTypeCount; ++i) {
            auto button = buttons[i];
            if (i == index) {
                button->setFlat(true);
                button->setEnabled(false);
            } else {
                button->setFlat(false);
                button->setEnabled(true);
            }
        }
    };
    
    cutFaceListWidget->enableMultipleSelection(false);
    if (nullptr != node) {
        cutFaceListWidget->selectCutFace(node->cutFaceLinkedId);
    }
    connect(cutFaceListWidget, &CutFaceListWidget::currentSelectedCutFaceChanged, this, [=](QUuid partId) {
        if (partId.isNull()) {
            CutFace cutFace = CutFace::Quad;
            updateCutFaceButtonState((int)cutFace);
            m_document->batchChangeBegin();
            for (const auto &id: nodeIds) {
                m_document->setNodeCutFace(id, cutFace);
            }
            m_document->batchChangeEnd();
            m_document->saveSnapshot();
        } else {
            updateCutFaceButtonState((int)CutFace::UserDefined);
            m_document->batchChangeBegin();
            for (const auto &id: nodeIds) {
                m_document->setNodeCutFaceLinkedId(id, partId);
            }
            m_document->batchChangeEnd();
            m_document->saveSnapshot();
        }
    });
    if (cutFaceListWidget->isEmpty())
        cutFaceListWidget->hide();
    
    for (size_t i = 0; i < (size_t)cutFaceTypeCount; ++i) {
        CutFace cutFace = (CutFace)i;
        QString iconFilename = ":/resources/" + CutFaceToString(cutFace).toLower() + ".png";
        QPixmap pixmap(iconFilename);
        QIcon buttonIcon(pixmap);
        QPushButton *button = new QPushButton;
        button->setIconSize(QSize(Theme::toolIconSize / 2, Theme::toolIconSize / 2));
        button->setIcon(buttonIcon);
        connect(button, &QPushButton::clicked, [=]() {
            updateCutFaceButtonState(i);
            m_document->batchChangeBegin();
            for (const auto &id: nodeIds) {
                m_document->setNodeCutFace(id, cutFace);
            }
            m_document->batchChangeEnd();
            m_document->saveSnapshot();
        });
        standardFacesLayout->addWidget(button);
        buttons[i] = button;
    }
    standardFacesLayout->addStretch();
    if (nullptr != node) {
        updateCutFaceButtonState((size_t)node->cutFace);
    }
    
    QVBoxLayout *popupLayout = new QVBoxLayout;
    popupLayout->addLayout(rotationLayout);
    popupLayout->addWidget(Theme::createHorizontalLineWidget());
    popupLayout->addLayout(standardFacesLayout);
    popupLayout->addWidget(cutFaceListWidget);
    
    popup->setLayout(popupLayout);
    
    QWidgetAction action(this);
    action.setDefaultWidget(popup);
    
    popupMenu.addAction(&action);
    
    popupMenu.exec(globalPos);
}

void DocumentWindow::setExportWaitingList(const QStringList &filenames)
{
    m_waitingForExportToFilenames = filenames;
}

void DocumentWindow::checkExportWaitingList()
{
    if (m_waitingForExportToFilenames.empty())
        return;
    
    auto list = m_waitingForExportToFilenames;
    m_waitingForExportToFilenames.clear();
    
    bool isSuccessful = m_document->isMeshGenerationSucceed();
    for (const auto &filename: list) {
        if (filename.endsWith(".obj")) {
            exportObjToFilename(filename);
            emit waitingExportFinished(filename, isSuccessful);
        } else if (filename.endsWith(".fbx")) {
            exportFbxToFilename(filename);
            emit waitingExportFinished(filename, isSuccessful);
        } else if (filename.endsWith(".glb")) {
            exportGlbToFilename(filename);
            emit waitingExportFinished(filename, isSuccessful);
        } else {
            emit waitingExportFinished(filename, false);
        }
    }
}

//void DocumentWindow::updateInfoWidgetPosition()
//{
//    m_infoWidget->move(0, m_graphicsContainerWidget->height() - m_infoWidget->height() - 5);
//}

void DocumentWindow::normalAndDepthMapsReady()
{
    QImage *normalMap = m_normalAndDepthMapsGenerator->takeNormalMap();
    QImage *depthMap = m_normalAndDepthMapsGenerator->takeDepthMap();

    m_modelRenderWidget->updateToonNormalAndDepthMaps(normalMap, depthMap);

    delete m_normalAndDepthMapsGenerator;
    m_normalAndDepthMapsGenerator = nullptr;
    
    qDebug() << "Normal and depth maps generation done";
    
    if (m_isNormalAndDepthMapsObsolete) {
        generateNormalAndDepthMaps();
    }
}

void DocumentWindow::generateNormalAndDepthMaps()
{
    if (nullptr != m_normalAndDepthMapsGenerator) {
        m_isNormalAndDepthMapsObsolete = true;
        return;
    }
    
    m_isNormalAndDepthMapsObsolete = false;
    
    auto resultMesh = m_document->takeResultMesh();
    if (nullptr == resultMesh)
		return;
    
    qDebug() << "Normal and depth maps generating...";
    
    QThread *thread = new QThread;
    m_normalAndDepthMapsGenerator = new NormalAndDepthMapsGenerator(m_modelRenderWidget);
    m_normalAndDepthMapsGenerator->updateMesh(resultMesh);
    m_normalAndDepthMapsGenerator->moveToThread(thread);
    m_normalAndDepthMapsGenerator->setRenderThread(thread);
    connect(thread, &QThread::started, m_normalAndDepthMapsGenerator, &NormalAndDepthMapsGenerator::process);
    connect(m_normalAndDepthMapsGenerator, &NormalAndDepthMapsGenerator::finished, this, &DocumentWindow::normalAndDepthMapsReady);
    connect(m_normalAndDepthMapsGenerator, &NormalAndDepthMapsGenerator::finished, thread, &QThread::quit);
    connect(thread, &QThread::finished, thread, &QThread::deleteLater);
    thread->start();
}

void DocumentWindow::delayedGenerateNormalAndDepthMaps()
{
    if (!Preferences::instance().toonShading())
        return;
    if (ToonLine::WithoutLine == Preferences::instance().toonLine())
        return;
    generateNormalAndDepthMaps();
}

void DocumentWindow::exportImageToFilename(const QString &filename)
{
    QApplication::setOverrideCursor(Qt::WaitCursor);
    Model *resultMesh = m_modelRenderWidget->fetchCurrentMesh();
    if (nullptr != resultMesh) {
        ModelOffscreenRender *offlineRender = new ModelOffscreenRender(m_modelRenderWidget->format());
        offlineRender->setXRotation(m_modelRenderWidget->xRot());
        offlineRender->setYRotation(m_modelRenderWidget->yRot());
        offlineRender->setZRotation(m_modelRenderWidget->zRot());
        offlineRender->setEyePosition(m_modelRenderWidget->eyePosition());
        offlineRender->setMoveToPosition(m_modelRenderWidget->moveToPosition());
        if (m_modelRenderWidget->isWireframeVisible())
            offlineRender->enableWireframe();
        if (m_modelRenderWidget->isEnvironmentLightEnabled())
            offlineRender->enableEnvironmentLight();
        offlineRender->setRenderPurpose(0);
        QImage *normalMap = new QImage();
        QImage *depthMap = new QImage();
        m_modelRenderWidget->fetchCurrentToonNormalAndDepthMaps(normalMap, depthMap);
        if (!normalMap->isNull() && !depthMap->isNull()) {
            offlineRender->updateToonNormalAndDepthMaps(normalMap, depthMap);
        } else {
            delete normalMap;
            delete depthMap;
        }
        offlineRender->updateMesh(resultMesh);
        if (Preferences::instance().toonShading())
            offlineRender->setToonShading(true);
        offlineRender->toImage(QSize(m_modelRenderWidget->widthInPixels(),
            m_modelRenderWidget->heightInPixels())).save(filename);
    }
    QApplication::restoreOverrideCursor();
}

void DocumentWindow::import()
{
    QString fileName = QFileDialog::getOpenFileName(this, QString(), QString(),
        tr("Dust3D Document (*.ds3)")).trimmed();
    if (fileName.isEmpty())
        return;
    importPath(fileName);
}