From af451bd5abb372bc7188eef2339244fcf9a7edfc Mon Sep 17 00:00:00 2001 From: Jeremy Hu Date: Sat, 7 Apr 2018 16:44:39 +0800 Subject: [PATCH] Introduce new UI, Introduce part list, Add log viewer, Add QtAwesome icons. --- dust3d.pro | 48 +- src/logbrowser.cpp | 24 + src/logbrowser.h | 25 + src/logbrowserdialog.cpp | 120 ++ src/logbrowserdialog.h | 31 + src/main.cpp | 25 +- src/meshgenerator.cpp | 230 ++++ src/meshgenerator.h | 42 + src/modelofflinerender.cpp | 107 ++ src/modelofflinerender.h | 26 + src/modelwidget.cpp | 24 +- src/modelwidget.h | 6 +- src/skeletondocument.cpp | 706 ++++++++++ src/skeletondocument.h | 184 +++ src/skeletondocumentwindow.cpp | 256 ++++ src/skeletondocumentwindow.h | 27 + src/skeletonedgepropertywidget.cpp | 53 + src/skeletonedgepropertywidget.h | 26 + src/skeletoneditedgeitem.cpp | 74 -- src/skeletoneditedgeitem.h | 25 - src/skeletoneditgraphicsview.cpp | 713 ---------- src/skeletoneditgraphicsview.h | 93 -- src/skeletoneditnodeitem.cpp | 140 -- src/skeletoneditnodeitem.h | 46 - src/skeletongraphicswidget.cpp | 644 +++++++++ src/skeletongraphicswidget.h | 320 +++++ src/skeletonhistorylistwidget.cpp | 0 src/skeletonhistorylistwidget.h | 0 src/skeletonnodepropertywidget.cpp | 50 + src/skeletonnodepropertywidget.h | 26 + src/skeletonpartlistwidget.cpp | 89 ++ src/skeletonpartlistwidget.h | 38 + src/skeletonsnapshot.h | 2 + src/skeletontomesh.cpp | 135 -- src/skeletontomesh.h | 27 - src/skeletonwidget.cpp | 214 --- src/skeletonwidget.h | 36 - src/theme.cpp | 17 + src/theme.h | 5 + src/turnaroundloader.cpp | 18 +- src/turnaroundloader.h | 2 + src/util.cpp | 20 + src/util.h | 10 + thirdparty/QtAwesome/LICENSE.md | 29 + thirdparty/QtAwesome/QtAwesome/QtAwesome.cpp | 1146 +++++++++++++++++ thirdparty/QtAwesome/QtAwesome/QtAwesome.h | 876 +++++++++++++ thirdparty/QtAwesome/QtAwesome/QtAwesome.pri | 12 + thirdparty/QtAwesome/QtAwesome/QtAwesome.pro | 29 + thirdparty/QtAwesome/QtAwesome/QtAwesome.qrc | 5 + .../QtAwesome/QtAwesome/QtAwesomeAnim.cpp | 46 + .../QtAwesome/QtAwesome/QtAwesomeAnim.h | 36 + .../QtAwesome/fonts/fontawesome-4.7.0.ttf | Bin 0 -> 165548 bytes .../QtAwesomeSample/QtAwesomeSample.pro | 20 + thirdparty/QtAwesome/QtAwesomeSample/main.cpp | 63 + thirdparty/QtAwesome/README.md | 230 ++++ 55 files changed, 5655 insertions(+), 1541 deletions(-) create mode 100644 src/logbrowser.cpp create mode 100644 src/logbrowser.h create mode 100644 src/logbrowserdialog.cpp create mode 100644 src/logbrowserdialog.h create mode 100644 src/meshgenerator.cpp create mode 100644 src/meshgenerator.h create mode 100644 src/modelofflinerender.cpp create mode 100644 src/modelofflinerender.h create mode 100644 src/skeletondocument.cpp create mode 100644 src/skeletondocument.h create mode 100644 src/skeletondocumentwindow.cpp create mode 100644 src/skeletondocumentwindow.h create mode 100644 src/skeletonedgepropertywidget.cpp create mode 100644 src/skeletonedgepropertywidget.h delete mode 100644 src/skeletoneditedgeitem.cpp delete mode 100644 src/skeletoneditedgeitem.h delete mode 100644 src/skeletoneditgraphicsview.cpp delete mode 100644 src/skeletoneditgraphicsview.h delete mode 100644 src/skeletoneditnodeitem.cpp delete mode 100644 src/skeletoneditnodeitem.h create mode 100644 src/skeletongraphicswidget.cpp create mode 100644 src/skeletongraphicswidget.h create mode 100644 src/skeletonhistorylistwidget.cpp create mode 100644 src/skeletonhistorylistwidget.h create mode 100644 src/skeletonnodepropertywidget.cpp create mode 100644 src/skeletonnodepropertywidget.h create mode 100644 src/skeletonpartlistwidget.cpp create mode 100644 src/skeletonpartlistwidget.h delete mode 100644 src/skeletontomesh.cpp delete mode 100644 src/skeletontomesh.h delete mode 100644 src/skeletonwidget.cpp delete mode 100644 src/skeletonwidget.h create mode 100644 src/util.cpp create mode 100644 src/util.h create mode 100755 thirdparty/QtAwesome/LICENSE.md create mode 100755 thirdparty/QtAwesome/QtAwesome/QtAwesome.cpp create mode 100755 thirdparty/QtAwesome/QtAwesome/QtAwesome.h create mode 100755 thirdparty/QtAwesome/QtAwesome/QtAwesome.pri create mode 100755 thirdparty/QtAwesome/QtAwesome/QtAwesome.pro create mode 100755 thirdparty/QtAwesome/QtAwesome/QtAwesome.qrc create mode 100755 thirdparty/QtAwesome/QtAwesome/QtAwesomeAnim.cpp create mode 100755 thirdparty/QtAwesome/QtAwesome/QtAwesomeAnim.h create mode 100755 thirdparty/QtAwesome/QtAwesome/fonts/fontawesome-4.7.0.ttf create mode 100755 thirdparty/QtAwesome/QtAwesomeSample/QtAwesomeSample.pro create mode 100755 thirdparty/QtAwesome/QtAwesomeSample/main.cpp create mode 100755 thirdparty/QtAwesome/README.md diff --git a/dust3d.pro b/dust3d.pro index 3ac8c55b..8c4bb5fb 100644 --- a/dust3d.pro +++ b/dust3d.pro @@ -2,10 +2,9 @@ QT += core widgets opengl CONFIG += debug RESOURCES += resources.qrc -INCLUDEPATH += src +include(thirdparty/QtAwesome/QtAwesome/QtAwesome.pri) -SOURCES += src/mainwindow.cpp -HEADERS += src/mainwindow.h +INCLUDEPATH += src SOURCES += src/modelshaderprogram.cpp HEADERS += src/modelshaderprogram.h @@ -13,27 +12,42 @@ HEADERS += src/modelshaderprogram.h SOURCES += src/modelmeshbinder.cpp HEADERS += src/modelmeshbinder.h +SOURCES += src/modelofflinerender.cpp +HEADERS += src/modelofflinerender.h + SOURCES += src/modelwidget.cpp HEADERS += src/modelwidget.h -SOURCES += src/skeletoneditgraphicsview.cpp -HEADERS += src/skeletoneditgraphicsview.h +SOURCES += src/skeletonnodepropertywidget.cpp +HEADERS += src/skeletonnodepropertywidget.h -SOURCES += src/skeletoneditnodeitem.cpp -HEADERS += src/skeletoneditnodeitem.h +SOURCES += src/skeletonedgepropertywidget.cpp +HEADERS += src/skeletonedgepropertywidget.h -SOURCES += src/skeletoneditedgeitem.cpp -HEADERS += src/skeletoneditedgeitem.h +SOURCES += src/skeletondocument.cpp +HEADERS += src/skeletondocument.h -SOURCES += src/skeletontomesh.cpp -HEADERS += src/skeletontomesh.h +SOURCES += src/skeletondocumentwindow.cpp +HEADERS += src/skeletondocumentwindow.h + +SOURCES += src/skeletongraphicswidget.cpp +HEADERS += src/skeletongraphicswidget.h + +SOURCES += src/skeletonhistorylistwidget.cpp +HEADERS += src/skeletonhistorylistwidget.h + +SOURCES += src/skeletonpartlistwidget.cpp +HEADERS += src/skeletonpartlistwidget.h + +SOURCES += src/meshgenerator.cpp +HEADERS += src/meshgenerator.h + +SOURCES += src/util.cpp +HEADERS += src/util.h SOURCES += src/turnaroundloader.cpp HEADERS += src/turnaroundloader.h -SOURCES += src/skeletonwidget.cpp -HEADERS += src/skeletonwidget.h - SOURCES += src/skeletonsnapshot.cpp HEADERS += src/skeletonsnapshot.h @@ -52,6 +66,12 @@ HEADERS += src/mesh.h SOURCES += src/unionmesh.cpp HEADERS += src/unionmesh.h +SOURCES += src/logbrowser.cpp +HEADERS += src/logbrowser.h + +SOURCES += src/logbrowserdialog.cpp +HEADERS += src/logbrowserdialog.h + SOURCES += src/main.cpp INCLUDEPATH += ../meshlite/include diff --git a/src/logbrowser.cpp b/src/logbrowser.cpp new file mode 100644 index 00000000..431d8ed5 --- /dev/null +++ b/src/logbrowser.cpp @@ -0,0 +1,24 @@ +#include "logbrowser.h" +// Modified from https://wiki.qt.io/Browser_for_QDebug_output +#include +#include "logbrowserdialog.h" + +LogBrowser::LogBrowser(QObject *parent) : + QObject(parent) +{ + qRegisterMetaType("QtMsgType"); + m_browserDialog = new LogBrowserDialog; + connect(this, SIGNAL(sendMessage(QtMsgType,QString)), m_browserDialog, SLOT(outputMessage(QtMsgType,QString)), Qt::QueuedConnection); + m_browserDialog->show(); +} + +LogBrowser::~LogBrowser() +{ + delete m_browserDialog; +} + +void LogBrowser::outputMessage(QtMsgType type, const QString &msg) +{ + printf("%s\n", msg.toUtf8().constData()); + emit sendMessage( type, msg ); +} diff --git a/src/logbrowser.h b/src/logbrowser.h new file mode 100644 index 00000000..bc8df370 --- /dev/null +++ b/src/logbrowser.h @@ -0,0 +1,25 @@ +#ifndef LOG_BROWSER_H +#define LOG_BROWSER_H +// Modified from https://wiki.qt.io/Browser_for_QDebug_output +#include + +class LogBrowserDialog; + +class LogBrowser : public QObject +{ + Q_OBJECT +public: + explicit LogBrowser(QObject *parent = 0); + ~LogBrowser(); + +public slots: + void outputMessage(QtMsgType type, const QString &msg); + +signals: + void sendMessage(QtMsgType type, const QString &msg); + +private: + LogBrowserDialog *m_browserDialog; +}; + +#endif // LOGBROWSER_H \ No newline at end of file diff --git a/src/logbrowserdialog.cpp b/src/logbrowserdialog.cpp new file mode 100644 index 00000000..d3958ff2 --- /dev/null +++ b/src/logbrowserdialog.cpp @@ -0,0 +1,120 @@ +#include "logbrowserdialog.h" +// Modified from https://wiki.qt.io/Browser_for_QDebug_output +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +LogBrowserDialog::LogBrowserDialog(QWidget *parent) : + QDialog(parent) +{ + QVBoxLayout *layout = new QVBoxLayout; + setLayout(layout); + + m_browser = new QTextBrowser(this); + layout->addWidget(m_browser); + + QHBoxLayout *buttonLayout = new QHBoxLayout; + buttonLayout->setContentsMargins(0, 0, 0, 0); + layout->addLayout(buttonLayout); + + buttonLayout->addStretch(10); + + m_clearButton = new QPushButton(this); + m_clearButton->setText("Clear"); + buttonLayout->addWidget(m_clearButton); + connect(m_clearButton, SIGNAL(clicked()), m_browser, SLOT(clear())); + + m_saveButton = new QPushButton(this); + m_saveButton->setText("Save Output"); + buttonLayout->addWidget(m_saveButton); + connect(m_saveButton, SIGNAL(clicked()), this, SLOT(save())); + + resize(400, 300); +} + + +LogBrowserDialog::~LogBrowserDialog() +{ + +} + + +void LogBrowserDialog::outputMessage(QtMsgType type, const QString &msg) +{ + switch (type) { + case QtDebugMsg: + m_browser->append(tr("— DEBUG: %1").arg(msg)); + break; + + case QtWarningMsg: + m_browser->append(tr("— WARNING: %1").arg(msg)); + break; + + case QtCriticalMsg: + m_browser->append(tr("— CRITICAL: %1").arg(msg)); + break; + + case QtInfoMsg: + m_browser->append(tr("— INFO: %1").arg(msg)); + break; + + case QtFatalMsg: + m_browser->append(tr("— FATAL: %1").arg(msg)); + break; + } +} + + +void LogBrowserDialog::save() +{ + QString saveFileName = QFileDialog::getSaveFileName(this, + tr("Save Log Output"), + tr("%1/logfile.txt").arg(QDir::homePath()), + tr("Text Files (*.txt);;All Files (*)")); + + if (saveFileName.isEmpty()) + return; + + QFile file(saveFileName); + if (!file.open(QIODevice::WriteOnly)) { + QMessageBox::warning(this, + tr("Error"), + QString(tr("File '%1'
cannot be opened for writing.

" + "The log output could not be saved!")) + .arg(saveFileName)); + return; + } + + QTextStream stream(&file); + stream << m_browser->toPlainText(); + file.close(); +} + +void LogBrowserDialog::closeEvent(QCloseEvent *e) +{ + QMessageBox::StandardButton answer = QMessageBox::question(this, + tr("Close Log Browser?"), + tr("Do you really want to close the log browser?"), + QMessageBox::Yes | QMessageBox::No); + + if (answer == QMessageBox::Yes) + e->accept(); + else + e->ignore(); +} + +void LogBrowserDialog::keyPressEvent(QKeyEvent *e) +{ + // ignore all keyboard events + // protects against accidentally closing of the dialog + // without asking the user + e->ignore(); +} diff --git a/src/logbrowserdialog.h b/src/logbrowserdialog.h new file mode 100644 index 00000000..0d0e6ccb --- /dev/null +++ b/src/logbrowserdialog.h @@ -0,0 +1,31 @@ +#ifndef LOG_BROWSER_DIALOG_H +#define LOG_BROWSER_DIALOG_H +// Modified from https://wiki.qt.io/Browser_for_QDebug_output +#include + +class QTextBrowser; +class QPushButton; + +class LogBrowserDialog : public QDialog +{ + Q_OBJECT +public: + LogBrowserDialog(QWidget *parent = 0); + ~LogBrowserDialog(); + +public slots: + void outputMessage(QtMsgType type, const QString &msg); + +protected slots: + void save(); + +protected: + virtual void keyPressEvent(QKeyEvent *e); + virtual void closeEvent(QCloseEvent *e); + + QTextBrowser *m_browser; + QPushButton *m_clearButton; + QPushButton *m_saveButton; +}; + +#endif // DIALOG_H \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp index 10d15643..5e04e35e 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -2,8 +2,20 @@ #include #include #include -#include "mainwindow.h" -#include "meshlite.h" +#include +#include +#include +#include "logbrowser.h" +#include "skeletondocumentwindow.h" +#include "theme.h" + +QPointer g_logBrowser; + +void outputMessage(QtMsgType type, const QMessageLogContext &context, const QString &msg) +{ + if (g_logBrowser) + g_logBrowser->outputMessage(type, msg); +} int main(int argc, char ** argv) { @@ -24,8 +36,8 @@ int main(int argc, char ** argv) darkPalette.setColor(QPalette::ButtonText, QColor(239,239,239)); darkPalette.setColor(QPalette::BrightText, Qt::red); darkPalette.setColor(QPalette::Link, QColor(42, 130, 218)); - darkPalette.setColor(QPalette::Highlight, QColor(252, 102, 33)); - darkPalette.setColor(QPalette::HighlightedText, Qt::black); + darkPalette.setColor(QPalette::Highlight, Theme::white); + darkPalette.setColor(QPalette::HighlightedText, Qt::white); qApp->setPalette(darkPalette); qApp->setStyleSheet("QToolTip { color: #ffffff; background-color: #fc6621; border: 1px solid white; }"); @@ -36,8 +48,11 @@ int main(int argc, char ** argv) font.setPixelSize(9); font.setBold(false); QApplication::setFont(font); + + g_logBrowser = new LogBrowser; + qInstallMessageHandler(&outputMessage); - MainWindow mainWindow; + SkeletonDocumentWindow mainWindow; mainWindow.showMaximized(); return app.exec(); } diff --git a/src/meshgenerator.cpp b/src/meshgenerator.cpp new file mode 100644 index 00000000..07b337b9 --- /dev/null +++ b/src/meshgenerator.cpp @@ -0,0 +1,230 @@ +#include +#include +#include "meshgenerator.h" +#include "util.h" +#include "skeletondocument.h" +#include "meshlite.h" +#include "modelofflinerender.h" +#include "unionmesh.h" +#include "theme.h" + +MeshGenerator::MeshGenerator(SkeletonSnapshot *snapshot, QThread *thread) : + m_snapshot(snapshot), + m_mesh(nullptr), + m_preview(nullptr), + m_requirePreview(false), + m_previewRender(nullptr), + m_thread(thread) +{ +} + +MeshGenerator::~MeshGenerator() +{ + delete m_snapshot; + delete m_mesh; + delete m_preview; + for (const auto &partPreviewIt: m_partPreviewMap) { + delete partPreviewIt.second; + } + for (const auto &render: m_partPreviewRenderMap) { + delete render.second; + } + delete m_previewRender; +} + +void MeshGenerator::addPreviewRequirement() +{ + m_requirePreview = true; + if (nullptr == m_previewRender) { + m_previewRender = new ModelOfflineRender; + m_previewRender->setRenderThread(m_thread); + } +} + +void MeshGenerator::addPartPreviewRequirement(const QString &partId) +{ + qDebug() << "addPartPreviewRequirement:" << partId; + m_requirePartPreviewMap.insert(partId); + if (m_partPreviewRenderMap.find(partId) == m_partPreviewRenderMap.end()) { + ModelOfflineRender *render = new ModelOfflineRender; + render->setRenderThread(m_thread); + m_partPreviewRenderMap[partId] = render; + } +} + +Mesh *MeshGenerator::takeResultMesh() +{ + Mesh *resultMesh = m_mesh; + m_mesh = nullptr; + return resultMesh; +} + +QImage *MeshGenerator::takePreview() +{ + QImage *resultPreview = m_preview; + m_preview = nullptr; + return resultPreview; +} + +QImage *MeshGenerator::takePartPreview(const QString &partId) +{ + QImage *resultImage = m_partPreviewMap[partId]; + m_partPreviewMap[partId] = nullptr; + return resultImage; +} + +void MeshGenerator::resolveBoundingBox(QRectF *mainProfile, QRectF *sideProfile) +{ + float left = -1; + float right = -1; + float top = -1; + float bottom = -1; + float zLeft = -1; + float zRight = -1; + for (const auto &nodeIt: m_snapshot->nodes) { + float radius = valueOfKeyInMapOrEmpty(nodeIt.second, "radius").toFloat(); + float x = valueOfKeyInMapOrEmpty(nodeIt.second, "x").toFloat(); + float y = valueOfKeyInMapOrEmpty(nodeIt.second, "y").toFloat(); + float z = valueOfKeyInMapOrEmpty(nodeIt.second, "z").toFloat(); + if (left < 0 || x - radius < left) { + left = x - radius; + } + if (top < 0 || y - radius < top) { + top = y - radius; + } + if (x + radius > right) { + right = x + radius; + } + if (y + radius > bottom) { + bottom = y + radius; + } + if (zLeft < 0 || z - radius < zLeft) { + zLeft = z - radius; + } + if (z + radius > zRight) { + zRight = z + radius; + } + } + *mainProfile = QRectF(left, top, right - left, bottom - top); + *sideProfile = QRectF(zLeft, top, zRight - zLeft, bottom - top); +} + +void MeshGenerator::process() +{ + if (nullptr == m_snapshot) + return; + + void *meshliteContext = meshlite_create_context(); + std::map partBmeshMap; + std::map bmeshNodeMap; + + QRectF mainProfile, sideProfile; + resolveBoundingBox(&mainProfile, &sideProfile); + float longHeight = mainProfile.height(); + if (mainProfile.width() > longHeight) + longHeight = mainProfile.width(); + if (sideProfile.width() > longHeight) + longHeight = sideProfile.width(); + float mainProfileMiddleX = mainProfile.x() + mainProfile.width() / 2; + float sideProfileMiddleX = sideProfile.x() + sideProfile.width() / 2; + float mainProfileMiddleY = mainProfile.y() + mainProfile.height() / 2; + + for (const auto &partIdIt: m_snapshot->partIdList) { + int bmeshId = meshlite_bmesh_create(meshliteContext); + partBmeshMap[partIdIt] = bmeshId; + } + + for (const auto &edgeIt: m_snapshot->edges) { + QString partId = valueOfKeyInMapOrEmpty(edgeIt.second, "partId"); + QString fromNodeId = valueOfKeyInMapOrEmpty(edgeIt.second, "from"); + QString toNodeId = valueOfKeyInMapOrEmpty(edgeIt.second, "to"); + qDebug() << "Processing edge " << fromNodeId << "<=>" << toNodeId; + const auto fromIt = m_snapshot->nodes.find(fromNodeId); + const auto toIt = m_snapshot->nodes.find(toNodeId); + if (fromIt == m_snapshot->nodes.end() || toIt == m_snapshot->nodes.end()) + continue; + const auto partBmeshIt = partBmeshMap.find(partId); + if (partBmeshIt == partBmeshMap.end()) + continue; + int bmeshId = partBmeshIt->second; + + int bmeshFromNodeId = 0; + const auto bmeshFromIt = bmeshNodeMap.find(fromNodeId); + if (bmeshFromIt == bmeshNodeMap.end()) { + float radius = valueOfKeyInMapOrEmpty(fromIt->second, "radius").toFloat() / longHeight; + float x = (valueOfKeyInMapOrEmpty(fromIt->second, "x").toFloat() - mainProfileMiddleX) / longHeight; + float y = (valueOfKeyInMapOrEmpty(fromIt->second, "y").toFloat() - mainProfileMiddleY) / longHeight; + float z = (valueOfKeyInMapOrEmpty(fromIt->second, "z").toFloat() - sideProfileMiddleX) / longHeight; + bmeshFromNodeId = meshlite_bmesh_add_node(meshliteContext, bmeshId, x, y, z, radius); + qDebug() << "bmeshId[" << bmeshId << "] add node[" << bmeshFromNodeId << "]" << radius << x << y << z; + bmeshNodeMap[fromNodeId] = bmeshFromNodeId; + } else { + bmeshFromNodeId = bmeshFromIt->second; + qDebug() << "bmeshId[" << bmeshId << "] use existed node[" << bmeshFromNodeId << "]"; + } + + int bmeshToNodeId = 0; + const auto bmeshToIt = bmeshNodeMap.find(toNodeId); + if (bmeshToIt == bmeshNodeMap.end()) { + float radius = valueOfKeyInMapOrEmpty(toIt->second, "radius").toFloat() / longHeight; + float x = (valueOfKeyInMapOrEmpty(toIt->second, "x").toFloat() - mainProfileMiddleX) / longHeight; + float y = (valueOfKeyInMapOrEmpty(toIt->second, "y").toFloat() - mainProfileMiddleY) / longHeight; + float z = (valueOfKeyInMapOrEmpty(toIt->second, "z").toFloat() - sideProfileMiddleX) / longHeight; + bmeshToNodeId = meshlite_bmesh_add_node(meshliteContext, bmeshId, x, y, z, radius); + qDebug() << "bmeshId[" << bmeshId << "] add node[" << bmeshToNodeId << "]" << radius << x << y << z; + bmeshNodeMap[toNodeId] = bmeshToNodeId; + } else { + bmeshToNodeId = bmeshToIt->second; + qDebug() << "bmeshId[" << bmeshId << "] use existed node[" << bmeshToNodeId << "]"; + } + + meshlite_bmesh_add_edge(meshliteContext, bmeshId, bmeshFromNodeId, bmeshToNodeId); + } + + std::map partMeshMap; + std::vector meshIds; + for (const auto &partIdIt: m_snapshot->partIdList) { + int bmeshId = partBmeshMap[partIdIt]; + int meshId = meshlite_bmesh_generate_mesh(meshliteContext, bmeshId, 0); + qDebug() << "m_requirePartPreviewMap.find:" << partIdIt; + if (m_requirePartPreviewMap.find(partIdIt) != m_requirePartPreviewMap.end()) { + ModelOfflineRender *render = m_partPreviewRenderMap[partIdIt]; + render->updateMesh(new Mesh(meshliteContext, meshId)); + QImage *image = new QImage(render->toImage(QSize(Theme::previewImageSize, Theme::previewImageSize))); + m_partPreviewMap[partIdIt] = image; + } + int triangulatedMeshId = meshlite_triangulate(meshliteContext, meshId); + meshIds.push_back(triangulatedMeshId); + } + + int mergedMeshId = 0; + if (meshIds.size() > 0) { + mergedMeshId = unionMeshs(meshliteContext, meshIds); + if (mergedMeshId > 0) { + mergedMeshId = meshlite_combine_coplanar_faces(meshliteContext, mergedMeshId); + } + } + + if (mergedMeshId > 0) { + if (m_requirePreview) { + m_previewRender->updateMesh(new Mesh(meshliteContext, mergedMeshId)); + QImage *image = new QImage(m_previewRender->toImage(QSize(Theme::previewImageSize, Theme::previewImageSize))); + m_preview = image; + } + m_mesh = new Mesh(meshliteContext, mergedMeshId); + } + + if (m_previewRender) { + m_previewRender->setRenderThread(QGuiApplication::instance()->thread()); + } + + for (auto &partPreviewRender: m_partPreviewRenderMap) { + partPreviewRender.second->setRenderThread(QGuiApplication::instance()->thread()); + } + + meshlite_destroy_context(meshliteContext); + + this->moveToThread(QGuiApplication::instance()->thread()); + + emit finished(); +} diff --git a/src/meshgenerator.h b/src/meshgenerator.h new file mode 100644 index 00000000..42f9a8e5 --- /dev/null +++ b/src/meshgenerator.h @@ -0,0 +1,42 @@ +#ifndef MESH_GENERATOR_H +#define MESH_GENERATOR_H +#include +#include +#include +#include +#include +#include +#include "skeletonsnapshot.h" +#include "mesh.h" +#include "modelofflinerender.h" + +class MeshGenerator : public QObject +{ + Q_OBJECT +public: + MeshGenerator(SkeletonSnapshot *snapshot, QThread *thread); + ~MeshGenerator(); + void addPreviewRequirement(); + void addPartPreviewRequirement(const QString &partId); + Mesh *takeResultMesh(); + QImage *takePreview(); + QImage *takePartPreview(const QString &partId); +signals: + void finished(); +public slots: + void process(); +private: + SkeletonSnapshot *m_snapshot; + Mesh *m_mesh; + QImage *m_preview; + std::map m_partPreviewMap; + bool m_requirePreview; + std::set m_requirePartPreviewMap; + ModelOfflineRender *m_previewRender; + std::map m_partPreviewRenderMap; + QThread *m_thread; +private: + void resolveBoundingBox(QRectF *mainProfile, QRectF *sideProfile); +}; + +#endif diff --git a/src/modelofflinerender.cpp b/src/modelofflinerender.cpp new file mode 100644 index 00000000..b1b74e15 --- /dev/null +++ b/src/modelofflinerender.cpp @@ -0,0 +1,107 @@ +#include +#include +#include +#include "modelofflinerender.h" + +ModelOfflineRender::ModelOfflineRender(QScreen *targetScreen) : + QOffscreenSurface(targetScreen), + m_context(nullptr), + m_mesh(nullptr) +{ + create(); + m_context = new QOpenGLContext(); + m_context->setFormat(format()); + m_context->create(); +} + +ModelOfflineRender::~ModelOfflineRender() +{ + delete m_context; + m_context = nullptr; + destroy(); + delete m_mesh; +} + +void ModelOfflineRender::updateMesh(Mesh *mesh) +{ + delete m_mesh; + m_mesh = mesh; +} + +void ModelOfflineRender::setRenderThread(QThread *thread) +{ + m_context->moveToThread(thread); +} + +QImage ModelOfflineRender::toImage(const QSize &size) +{ + QImage image; + + m_context->makeCurrent(this); + + QOpenGLFramebufferObjectFormat format; + format.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil); + QOpenGLFramebufferObject *renderFbo = new QOpenGLFramebufferObject(size, format); + renderFbo->bind(); + m_context->functions()->glViewport(0, 0, size.width(), size.height()); + + if (nullptr != m_mesh) { + int xRot = 0; + int yRot = 0; + int zRot = 0; + QMatrix4x4 proj; + QMatrix4x4 camera; + QMatrix4x4 world; + + ModelShaderProgram *program = new ModelShaderProgram; + ModelMeshBinder meshBinder; + meshBinder.initialize(); + + program->setUniformValue(program->lightPosLoc(), QVector3D(0, 0, 70)); + + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glEnable(GL_DEPTH_TEST); + glEnable(GL_CULL_FACE); + glEnable(GL_LINE_SMOOTH); + + camera.setToIdentity(); + camera.translate(0, 0, -2.5); + + world.setToIdentity(); + world.rotate(180.0f - (xRot / 16.0f), 1, 0, 0); + world.rotate(yRot / 16.0f, 0, 1, 0); + world.rotate(zRot / 16.0f, 0, 0, 1); + + proj.setToIdentity(); + proj.perspective(45.0f, GLfloat(size.width()) / size.height(), 0.01f, 100.0f); + + program->bind(); + program->setUniformValue(program->projMatrixLoc(), proj); + program->setUniformValue(program->mvMatrixLoc(), camera * world); + QMatrix3x3 normalMatrix = world.normalMatrix(); + program->setUniformValue(program->normalMatrixLoc(), normalMatrix); + + meshBinder.updateMesh(m_mesh); + meshBinder.paint(); + + meshBinder.cleanup(); + + program->release(); + delete program; + + m_mesh = nullptr; + } + + m_context->functions()->glFlush(); + + image = renderFbo->toImage(); + + qDebug() << "Generated image size:" << image.size(); + + renderFbo->bindDefault(); + delete renderFbo; + + m_context->doneCurrent(); + + return image; +} diff --git a/src/modelofflinerender.h b/src/modelofflinerender.h new file mode 100644 index 00000000..04896f09 --- /dev/null +++ b/src/modelofflinerender.h @@ -0,0 +1,26 @@ +#ifndef MODEL_OFFLINE_RENDER_H +#define MODEL_OFFLINE_RENDER_H +#include +#include +#include +#include +#include +#include +#include "modelshaderprogram.h" +#include "modelmeshbinder.h" +#include "mesh.h" + +class ModelOfflineRender : QOffscreenSurface +{ +public: + ModelOfflineRender(QScreen *targetScreen = Q_NULLPTR); + ~ModelOfflineRender(); + void setRenderThread(QThread *thread); + void updateMesh(Mesh *mesh); + QImage toImage(const QSize &size); +private: + QOpenGLContext *m_context; + Mesh *m_mesh; +}; + +#endif diff --git a/src/modelwidget.cpp b/src/modelwidget.cpp index 511a2ab4..d46f6feb 100644 --- a/src/modelwidget.cpp +++ b/src/modelwidget.cpp @@ -1,6 +1,6 @@ #include "modelwidget.h" #include "ds3file.h" -#include "skeletoneditgraphicsview.h" +#include "skeletongraphicswidget.h" #include #include #include @@ -16,9 +16,9 @@ ModelWidget::ModelWidget(QWidget *parent) m_xRot(0), m_yRot(0), m_zRot(0), - m_program(NULL), + m_program(nullptr), m_moveStarted(false), - m_graphicsView(NULL) + m_graphicsFunctions(NULL) { // --transparent causes the clear color to be transparent. Therefore, on systems that // support it, the widget will become transparent apart from the logo. @@ -34,11 +34,12 @@ ModelWidget::ModelWidget(QWidget *parent) fmt.setSamples(4); setFormat(fmt); } + setMouseTracking(true); } -void ModelWidget::setGraphicsView(SkeletonEditGraphicsView *view) +void ModelWidget::setGraphicsFunctions(SkeletonGraphicsFunctions *graphicsFunctions) { - m_graphicsView = view; + m_graphicsFunctions = graphicsFunctions; } ModelWidget::~ModelWidget() @@ -91,7 +92,7 @@ void ModelWidget::cleanup() makeCurrent(); m_meshBinder.cleanup(); delete m_program; - m_program = 0; + m_program = nullptr; doneCurrent(); } @@ -124,7 +125,7 @@ void ModelWidget::initializeGL() // Our camera never changes in this example. m_camera.setToIdentity(); - m_camera.translate(0, 0, -2.5); + m_camera.translate(0, 0, -3.5); // Light position is fixed. m_program->setUniformValue(m_program->lightPosLoc(), QVector3D(0, 0, 70)); @@ -164,10 +165,9 @@ void ModelWidget::resizeGL(int w, int h) void ModelWidget::mousePressEvent(QMouseEvent *event) { - if (!m_moveStarted && m_graphicsView && m_graphicsView->mousePress(event, m_graphicsView->mapToScene(m_graphicsView->mapFromGlobal(event->globalPos())))) + if (!m_moveStarted && m_graphicsFunctions && m_graphicsFunctions->mousePress(event)) return; m_lastPos = event->pos(); - setMouseTracking(true); if (event->button() == Qt::LeftButton) { if (!m_moveStarted) { m_moveStartPos = mapToParent(event->pos()); @@ -179,7 +179,7 @@ void ModelWidget::mousePressEvent(QMouseEvent *event) void ModelWidget::mouseReleaseEvent(QMouseEvent *event) { - if (!m_moveStarted && m_graphicsView && m_graphicsView->mouseRelease(event, m_graphicsView->mapToScene(m_graphicsView->mapFromGlobal(event->globalPos())))) + if (!m_moveStarted && m_graphicsFunctions && m_graphicsFunctions->mouseRelease(event)) return; if (m_moveStarted) { m_moveStarted = false; @@ -188,7 +188,7 @@ void ModelWidget::mouseReleaseEvent(QMouseEvent *event) void ModelWidget::mouseMoveEvent(QMouseEvent *event) { - if (!m_moveStarted && m_graphicsView && m_graphicsView->mouseMove(event, m_graphicsView->mapToScene(m_graphicsView->mapFromGlobal(event->globalPos())))) + if (!m_moveStarted && m_graphicsFunctions && m_graphicsFunctions->mouseMove(event)) return; int dx = event->x() - m_lastPos.x(); @@ -210,7 +210,7 @@ void ModelWidget::mouseMoveEvent(QMouseEvent *event) void ModelWidget::wheelEvent(QWheelEvent *event) { - if (!m_moveStarted && m_graphicsView && m_graphicsView->wheel(event, m_graphicsView->mapToScene(m_graphicsView->mapFromGlobal(event->globalPos())))) + if (!m_moveStarted && m_graphicsFunctions && m_graphicsFunctions->wheel(event)) return; if (m_moveStarted) return; diff --git a/src/modelwidget.h b/src/modelwidget.h index a7c35366..475ce3d5 100644 --- a/src/modelwidget.h +++ b/src/modelwidget.h @@ -11,7 +11,7 @@ #include "modelshaderprogram.h" #include "modelmeshbinder.h" -class SkeletonEditGraphicsView; +class SkeletonGraphicsFunctions; class ModelWidget : public QOpenGLWidget, protected QOpenGLFunctions { @@ -26,7 +26,7 @@ public: void updateMesh(Mesh *mesh); void exportMeshAsObj(const QString &filename); - void setGraphicsView(SkeletonEditGraphicsView *view); + void setGraphicsFunctions(SkeletonGraphicsFunctions *graphicsFunctions); public slots: void setXRotation(int angle); @@ -61,7 +61,7 @@ private: bool m_moveStarted; QPoint m_moveStartPos; QRect m_moveStartGeometry; - SkeletonEditGraphicsView *m_graphicsView; + SkeletonGraphicsFunctions *m_graphicsFunctions; }; #endif diff --git a/src/skeletondocument.cpp b/src/skeletondocument.cpp new file mode 100644 index 00000000..c24d9a30 --- /dev/null +++ b/src/skeletondocument.cpp @@ -0,0 +1,706 @@ +#include +#include +#include +#include +#include "skeletondocument.h" +#include "util.h" + +SkeletonDocument::SkeletonDocument() : + m_resultMeshIsObsolete(false), + m_resultMesh(nullptr), + m_meshGenerator(nullptr) +{ +} + +SkeletonDocument::~SkeletonDocument() +{ + delete m_resultMesh; +} + +void SkeletonDocument::uiReady() +{ + emit editModeChanged(); +} + +void SkeletonDocument::removePart(QUuid partId) +{ +} + +void SkeletonDocument::showPart(QUuid partId) +{ +} + +void SkeletonDocument::hidePart(QUuid partId) +{ +} + +void SkeletonDocument::removeEdge(QUuid edgeId) +{ + const SkeletonEdge *edge = findEdge(edgeId); + if (nullptr == edge) { + qDebug() << "Find edge failed:" << edgeId; + return; + } + const SkeletonPart *oldPart = findPart(edge->partId); + if (nullptr == oldPart) { + qDebug() << "Find part failed:" << edge->partId; + return; + } + QString nextPartName = oldPart->name; + QUuid oldPartId = oldPart->id; + std::vector> groups; + splitPartByEdge(&groups, edgeId); + for (auto groupIt = groups.begin(); groupIt != groups.end(); groupIt++) { + SkeletonPart part; + part.name = nextPartName; + for (auto nodeIdIt = (*groupIt).begin(); nodeIdIt != (*groupIt).end(); nodeIdIt++) { + auto nodeIt = nodeMap.find(*nodeIdIt); + if (nodeIt == nodeMap.end()) { + qDebug() << "Find node failed:" << *nodeIdIt; + continue; + } + nodeIt->second.partId = part.id; + part.nodeIds.push_back(nodeIt->first); + for (auto edgeIdIt = nodeIt->second.edgeIds.begin(); edgeIdIt != nodeIt->second.edgeIds.end(); edgeIdIt++) { + auto edgeIt = edgeMap.find(*edgeIdIt); + if (edgeIt == edgeMap.end()) { + qDebug() << "Find edge failed:" << *edgeIdIt; + continue; + } + edgeIt->second.partId = part.id; + } + } + partMap[part.id] = part; + partIds.push_back(part.id); + emit partAdded(part.id); + } + for (auto nodeIdIt = edge->nodeIds.begin(); nodeIdIt != edge->nodeIds.end(); nodeIdIt++) { + auto nodeIt = nodeMap.find(*nodeIdIt); + if (nodeIt == nodeMap.end()) { + qDebug() << "Find node failed:" << *nodeIdIt; + continue; + } + nodeIt->second.edgeIds.erase(std::remove(nodeIt->second.edgeIds.begin(), nodeIt->second.edgeIds.end(), edgeId), nodeIt->second.edgeIds.end()); + emit nodeOriginChanged(nodeIt->first); + } + edgeMap.erase(edgeId); + emit edgeRemoved(edgeId); + partIds.erase(std::remove(partIds.begin(), partIds.end(), oldPartId), partIds.end()); + partMap.erase(oldPartId); + emit partRemoved(oldPartId); + emit partListChanged(); + + emit skeletonChanged(); +} + +void SkeletonDocument::removeNode(QUuid nodeId) +{ + const SkeletonNode *node = findNode(nodeId); + if (nullptr == node) { + qDebug() << "Find node failed:" << nodeId; + return; + } + const SkeletonPart *oldPart = findPart(node->partId); + if (nullptr == oldPart) { + qDebug() << "Find part failed:" << node->partId; + return; + } + QString nextPartName = oldPart->name; + QUuid oldPartId = oldPart->id; + std::vector> groups; + splitPartByNode(&groups, nodeId); + for (auto groupIt = groups.begin(); groupIt != groups.end(); groupIt++) { + SkeletonPart part; + part.name = nextPartName; + for (auto nodeIdIt = (*groupIt).begin(); nodeIdIt != (*groupIt).end(); nodeIdIt++) { + auto nodeIt = nodeMap.find(*nodeIdIt); + if (nodeIt == nodeMap.end()) { + qDebug() << "Find node failed:" << *nodeIdIt; + continue; + } + nodeIt->second.partId = part.id; + part.nodeIds.push_back(nodeIt->first); + for (auto edgeIdIt = nodeIt->second.edgeIds.begin(); edgeIdIt != nodeIt->second.edgeIds.end(); edgeIdIt++) { + auto edgeIt = edgeMap.find(*edgeIdIt); + if (edgeIt == edgeMap.end()) { + qDebug() << "Find edge failed:" << *edgeIdIt; + continue; + } + edgeIt->second.partId = part.id; + } + } + partMap[part.id] = part; + partIds.push_back(part.id); + emit partAdded(part.id); + } + for (auto edgeIdIt = node->edgeIds.begin(); edgeIdIt != node->edgeIds.end(); edgeIdIt++) { + auto edgeIt = edgeMap.find(*edgeIdIt); + if (edgeIt == edgeMap.end()) { + qDebug() << "Find edge failed:" << *edgeIdIt; + continue; + } + QUuid neighborId = edgeIt->second.neighborOf(nodeId); + auto nodeIt = nodeMap.find(neighborId); + if (nodeIt == nodeMap.end()) { + qDebug() << "Find node failed:" << neighborId; + continue; + } + nodeIt->second.edgeIds.erase(std::remove(nodeIt->second.edgeIds.begin(), nodeIt->second.edgeIds.end(), *edgeIdIt), nodeIt->second.edgeIds.end()); + edgeMap.erase(*edgeIdIt); + emit edgeRemoved(*edgeIdIt); + } + nodeMap.erase(nodeId); + emit nodeRemoved(nodeId); + partIds.erase(std::remove(partIds.begin(), partIds.end(), oldPartId), partIds.end()); + partMap.erase(oldPartId); + emit partRemoved(oldPartId); + emit partListChanged(); + + emit skeletonChanged(); +} + +void SkeletonDocument::addNode(float x, float y, float z, float radius, QUuid fromNodeId) +{ + QUuid partId; + const SkeletonNode *fromNode = nullptr; + bool newPartAdded = false; + if (fromNodeId.isNull()) { + SkeletonPart part; + partMap[part.id] = part; + partIds.push_back(part.id); + partId = part.id; + emit partAdded(partId); + newPartAdded = true; + } else { + fromNode = findNode(fromNodeId); + if (nullptr == fromNode) { + qDebug() << "Find node failed:" << fromNodeId; + return; + } + partId = fromNode->partId; + } + SkeletonNode node; + node.partId = partId; + node.radius = radius; + node.x = x; + node.y = y; + node.z = z; + nodeMap[node.id] = node; + partMap[partId].nodeIds.push_back(node.id); + + qDebug() << "Add node " << node.id << x << y << z; + + emit nodeAdded(node.id); + + if (nullptr != fromNode) { + SkeletonEdge edge; + edge.partId = partId; + edge.nodeIds.push_back(fromNode->id); + edge.nodeIds.push_back(node.id); + edgeMap[edge.id] = edge; + + nodeMap[node.id].edgeIds.push_back(edge.id); + nodeMap[fromNode->id].edgeIds.push_back(edge.id); + + emit edgeAdded(edge.id); + } + + emit partChanged(partId); + + if (newPartAdded) + emit partListChanged(); + + emit skeletonChanged(); +} + +const SkeletonEdge *SkeletonDocument::findEdgeByNodes(QUuid firstNodeId, QUuid secondNodeId) const +{ + const SkeletonNode *firstNode = nullptr; + firstNode = findNode(firstNodeId); + if (nullptr == firstNode) { + qDebug() << "Find node failed:" << firstNodeId; + return nullptr; + } + for (auto edgeIdIt = firstNode->edgeIds.begin(); edgeIdIt != firstNode->edgeIds.end(); edgeIdIt++) { + auto edgeIt = edgeMap.find(*edgeIdIt); + if (edgeIt == edgeMap.end()) { + qDebug() << "Find edge failed:" << *edgeIdIt; + continue; + } + if (std::find(edgeIt->second.nodeIds.begin(), edgeIt->second.nodeIds.end(), secondNodeId) != edgeIt->second.nodeIds.end()) + return &edgeIt->second; + } + return nullptr; +} + +void SkeletonDocument::addEdge(QUuid fromNodeId, QUuid toNodeId) +{ + const SkeletonNode *fromNode = nullptr; + const SkeletonNode *toNode = nullptr; + bool toPartRemoved = false; + + fromNode = findNode(fromNodeId); + if (nullptr == fromNode) { + qDebug() << "Find node failed:" << fromNodeId; + return; + } + + toNode = findNode(toNodeId); + if (nullptr == toNode) { + qDebug() << "Find node failed:" << toNodeId; + return; + } + + QUuid toPartId = toNode->partId; + + auto fromPart = partMap.find(fromNode->partId); + if (fromPart == partMap.end()) { + qDebug() << "Find part failed:" << fromNode->partId; + return; + } + + if (fromNode->partId != toNode->partId) { + toPartRemoved = true; + std::vector toGroup; + std::set visitMap; + joinNodeAndNeiborsToGroup(&toGroup, toNodeId, &visitMap); + for (auto nodeIdIt = toGroup.begin(); nodeIdIt != toGroup.end(); nodeIdIt++) { + auto nodeIt = nodeMap.find(*nodeIdIt); + if (nodeIt == nodeMap.end()) { + qDebug() << "Find node failed:" << *nodeIdIt; + continue; + } + nodeIt->second.partId = fromNode->partId; + fromPart->second.nodeIds.push_back(nodeIt->first); + for (auto edgeIdIt = nodeIt->second.edgeIds.begin(); edgeIdIt != nodeIt->second.edgeIds.end(); edgeIdIt++) { + auto edgeIt = edgeMap.find(*edgeIdIt); + if (edgeIt == edgeMap.end()) { + qDebug() << "Find edge failed:" << *edgeIdIt; + continue; + } + edgeIt->second.partId = fromNode->partId; + } + } + } + + SkeletonEdge edge; + edge.partId = fromNode->partId; + edge.nodeIds.push_back(fromNode->id); + edge.nodeIds.push_back(toNodeId); + edgeMap[edge.id] = edge; + + nodeMap[toNodeId].edgeIds.push_back(edge.id); + nodeMap[fromNode->id].edgeIds.push_back(edge.id); + + emit edgeAdded(edge.id); + + if (toPartRemoved) { + partIds.erase(std::remove(partIds.begin(), partIds.end(), toPartId), partIds.end()); + partMap.erase(toPartId); + emit partRemoved(toPartId); + emit partListChanged(); + } + + emit skeletonChanged(); +} + +const SkeletonNode *SkeletonDocument::findNode(QUuid nodeId) const +{ + auto it = nodeMap.find(nodeId); + if (it == nodeMap.end()) + return nullptr; + return &it->second; +} + +const SkeletonEdge *SkeletonDocument::findEdge(QUuid edgeId) const +{ + auto it = edgeMap.find(edgeId); + if (it == edgeMap.end()) + return nullptr; + return &it->second; +} + +const SkeletonPart *SkeletonDocument::findPart(QUuid partId) const +{ + auto it = partMap.find(partId); + if (it == partMap.end()) + return nullptr; + return &it->second; +} + +void SkeletonDocument::scaleNodeByAddRadius(QUuid nodeId, float amount) +{ + auto it = nodeMap.find(nodeId); + if (it == nodeMap.end()) { + qDebug() << "Find node failed:" << nodeId; + return; + } + it->second.radius += amount; + emit nodeRadiusChanged(nodeId); + emit skeletonChanged(); +} + +void SkeletonDocument::moveNodeBy(QUuid nodeId, float x, float y, float z) +{ + auto it = nodeMap.find(nodeId); + if (it == nodeMap.end()) { + qDebug() << "Find node failed:" << nodeId; + return; + } + it->second.x += x; + it->second.y += y; + it->second.z += z; + emit nodeOriginChanged(nodeId); + emit skeletonChanged(); +} + +void SkeletonDocument::setNodeOrigin(QUuid nodeId, float x, float y, float z) +{ + auto it = nodeMap.find(nodeId); + if (it == nodeMap.end()) { + qDebug() << "Find node failed:" << nodeId; + return; + } + it->second.x = x; + it->second.y = y; + it->second.z = z; + emit nodeOriginChanged(nodeId); + emit skeletonChanged(); +} + +void SkeletonDocument::setNodeRadius(QUuid nodeId, float radius) +{ + auto it = nodeMap.find(nodeId); + if (it == nodeMap.end()) { + qDebug() << "Find node failed:" << nodeId; + return; + } + it->second.radius = radius; + emit nodeRadiusChanged(nodeId); + emit skeletonChanged(); +} + +void SkeletonDocument::updateTurnaround(const QImage &image) +{ + turnaround = image; + emit turnaroundChanged(); +} + +void SkeletonDocument::setEditMode(SkeletonDocumentEditMode mode) +{ + if (editMode == mode) + return; + + editMode = mode; + emit editModeChanged(); +} + +void SkeletonDocument::joinNodeAndNeiborsToGroup(std::vector *group, QUuid nodeId, std::set *visitMap, QUuid noUseEdgeId) +{ + if (nodeId.isNull() || visitMap->find(nodeId) != visitMap->end()) + return; + const SkeletonNode *node = findNode(nodeId); + if (nullptr == node) { + qDebug() << "Find node failed:" << nodeId; + return; + } + visitMap->insert(nodeId); + group->push_back(nodeId); + for (auto edgeIt = node->edgeIds.begin(); edgeIt != node->edgeIds.end(); edgeIt++) { + if (noUseEdgeId == *edgeIt) + continue; + const SkeletonEdge *edge = findEdge(*edgeIt); + if (nullptr == edge) { + qDebug() << "Find edge failed:" << *edgeIt; + continue; + } + for (auto nodeIt = edge->nodeIds.begin(); nodeIt != edge->nodeIds.end(); nodeIt++) { + joinNodeAndNeiborsToGroup(group, *nodeIt, visitMap, noUseEdgeId); + } + } +} + +void SkeletonDocument::splitPartByNode(std::vector> *groups, QUuid nodeId) +{ + const SkeletonNode *node = findNode(nodeId); + std::set visitMap; + for (auto edgeIt = node->edgeIds.begin(); edgeIt != node->edgeIds.end(); edgeIt++) { + std::vector group; + const SkeletonEdge *edge = findEdge(*edgeIt); + if (nullptr == edge) { + qDebug() << "Find edge failed:" << *edgeIt; + continue; + } + joinNodeAndNeiborsToGroup(&group, edge->neighborOf(nodeId), &visitMap, *edgeIt); + if (!group.empty()) + groups->push_back(group); + } +} + +void SkeletonDocument::splitPartByEdge(std::vector> *groups, QUuid edgeId) +{ + const SkeletonEdge *edge = findEdge(edgeId); + if (nullptr == edge) { + qDebug() << "Find edge failed:" << edgeId; + return; + } + std::set visitMap; + for (auto nodeIt = edge->nodeIds.begin(); nodeIt != edge->nodeIds.end(); nodeIt++) { + std::vector group; + joinNodeAndNeiborsToGroup(&group, *nodeIt, &visitMap, edgeId); + if (!group.empty()) + groups->push_back(group); + } +} + +void SkeletonDocument::setEdgeBranchMode(QUuid edgeId, SkeletonEdgeBranchMode mode) +{ + auto edgeIt = edgeMap.find(edgeId); + if (edgeIt == edgeMap.end()) { + qDebug() << "Find edge failed:" << edgeId; + return; + } + edgeIt->second.branchMode = mode; +} + +void SkeletonDocument::setNodeRootMarkMode(QUuid nodeId, SkeletonNodeRootMarkMode mode) +{ + auto nodeIt = nodeMap.find(nodeId); + if (nodeIt == nodeMap.end()) { + qDebug() << "Find node failed:" << nodeId; + return; + } + nodeIt->second.rootMarkMode = mode; +} + +void SkeletonDocument::toSnapshot(SkeletonSnapshot *snapshot) +{ + for (const auto &partIt : partMap) { + std::map part; + part["id"] = partIt.second.id.toString(); + part["visible"] = partIt.second.visible ? "true" : "false"; + if (!partIt.second.name.isEmpty()) + part["name"] = partIt.second.name; + snapshot->parts[part["id"]] = part; + } + for (const auto &nodeIt: nodeMap) { + std::map node; + node["id"] = nodeIt.second.id.toString(); + node["radius"] = QString::number(nodeIt.second.radius); + node["x"] = QString::number(nodeIt.second.x); + node["y"] = QString::number(nodeIt.second.y); + node["z"] = QString::number(nodeIt.second.z); + node["rootMarkMode"] = SkeletonNodeRootMarkModeToString(nodeIt.second.rootMarkMode); + node["partId"] = nodeIt.second.partId.toString(); + if (!nodeIt.second.name.isEmpty()) + node["name"] = nodeIt.second.name; + snapshot->nodes[node["id"]] = node; + qDebug() << "Export node to snapshot " << node["id"] << node["x"] << node["y"] << node["z"]; + } + for (const auto &edgeIt: edgeMap) { + if (edgeIt.second.nodeIds.size() != 2) + continue; + std::map edge; + edge["id"] = edgeIt.second.id.toString(); + edge["from"] = edgeIt.second.nodeIds[0].toString(); + edge["to"] = edgeIt.second.nodeIds[1].toString(); + edge["branchMode"] = SkeletonEdgeBranchModeToString(edgeIt.second.branchMode); + edge["partId"] = edgeIt.second.partId.toString(); + if (!edgeIt.second.name.isEmpty()) + edge["name"] = edgeIt.second.name; + snapshot->edges[edge["id"]] = edge; + qDebug() << "Export edge to snapshot " << edge["from"] << "<=>" << edge["to"]; + } + for (const auto &partIdIt: partIds) { + snapshot->partIdList.push_back(partIdIt.toString()); + } +} + +void SkeletonDocument::fromSnapshot(const SkeletonSnapshot &snapshot) +{ + for (const auto &nodeIt: nodeMap) { + emit nodeRemoved(nodeIt.first); + } + for (const auto &edgeIt: edgeMap) { + emit edgeRemoved(edgeIt.first); + } + for (const auto &partIt : partMap) { + emit partRemoved(partIt.first); + } + + nodeMap.clear(); + edgeMap.clear(); + partMap.clear(); + + for (const auto &nodeKv : snapshot.nodes) { + SkeletonNode node(QUuid(nodeKv.first)); + node.name = valueOfKeyInMapOrEmpty(nodeKv.second, "name"); + node.radius = valueOfKeyInMapOrEmpty(nodeKv.second, "radius").toFloat(); + node.x = valueOfKeyInMapOrEmpty(nodeKv.second, "x").toFloat(); + node.y = valueOfKeyInMapOrEmpty(nodeKv.second, "y").toFloat(); + node.z = valueOfKeyInMapOrEmpty(nodeKv.second, "z").toFloat(); + node.partId = QUuid(valueOfKeyInMapOrEmpty(nodeKv.second, "partId")); + node.rootMarkMode = SkeletonNodeRootMarkModeFromString(valueOfKeyInMapOrEmpty(nodeKv.second, "rootMarkMode")); + nodeMap[node.id] = node; + } + for (const auto &edgeKv : snapshot.edges) { + SkeletonEdge edge(QUuid(edgeKv.first)); + edge.name = valueOfKeyInMapOrEmpty(edgeKv.second, "name"); + edge.partId = QUuid(valueOfKeyInMapOrEmpty(edgeKv.second, "partId")); + edge.branchMode = SkeletonEdgeBranchModeFromString(valueOfKeyInMapOrEmpty(edgeKv.second, "branchMode")); + QString fromNodeId = valueOfKeyInMapOrEmpty(edgeKv.second, "from"); + if (!fromNodeId.isEmpty()) + edge.nodeIds.push_back(QUuid(fromNodeId)); + QString toNodeId = valueOfKeyInMapOrEmpty(edgeKv.second, "to"); + if (!toNodeId.isEmpty()) + edge.nodeIds.push_back(QUuid(toNodeId)); + edgeMap[edge.id] = edge; + } + for (const auto &partKv : snapshot.parts) { + SkeletonPart part(QUuid(partKv.first)); + part.name = valueOfKeyInMapOrEmpty(partKv.second, "name"); + part.visible = isTrueValueString(valueOfKeyInMapOrEmpty(partKv.second, "visible")); + partMap[part.id] = part; + } + for (const auto &partIdIt: snapshot.partIdList) { + partIds.push_back(QUuid(partIdIt)); + } + + for (const auto &nodeIt: nodeMap) { + emit nodeAdded(nodeIt.first); + } + for (const auto &edgeIt: edgeMap) { + emit edgeAdded(edgeIt.first); + } + for (const auto &partIt : partMap) { + emit partAdded(partIt.first); + } + + emit partListChanged(); +} + +const char *SkeletonNodeRootMarkModeToString(SkeletonNodeRootMarkMode mode) +{ + switch (mode) { + case SkeletonNodeRootMarkMode::Auto: + return "auto"; + case SkeletonNodeRootMarkMode::MarkAsRoot: + return "markAsRoot"; + case SkeletonNodeRootMarkMode::MarkAsNotRoot: + return "markAsNotRoot"; + default: + return ""; + } +} + +SkeletonNodeRootMarkMode SkeletonNodeRootMarkModeFromString(const QString &mode) +{ + if (mode == "auto") + return SkeletonNodeRootMarkMode::Auto; + if (mode == "markAsRoot") + return SkeletonNodeRootMarkMode::MarkAsRoot; + if (mode == "markAsNotRoot") + return SkeletonNodeRootMarkMode::MarkAsNotRoot; + return SkeletonNodeRootMarkMode::Auto; +} + +const char *SkeletonEdgeBranchModeToString(SkeletonEdgeBranchMode mode) +{ + switch (mode) { + case SkeletonEdgeBranchMode::Auto: + return "auto"; + case SkeletonEdgeBranchMode::NoTrivial: + return "noTrivial"; + case SkeletonEdgeBranchMode::Trivial: + return "trivial"; + default: + return ""; + } +} + +SkeletonEdgeBranchMode SkeletonEdgeBranchModeFromString(const QString &mode) +{ + if (mode == "auto") + return SkeletonEdgeBranchMode::Auto; + if (mode == "noTrivial") + return SkeletonEdgeBranchMode::NoTrivial; + if (mode == "trivial") + return SkeletonEdgeBranchMode::Trivial; + return SkeletonEdgeBranchMode::Auto; +} + +Mesh *SkeletonDocument::takeResultMesh() +{ + Mesh *resultMesh = m_resultMesh; + m_resultMesh = nullptr; + return resultMesh; +} + +void SkeletonDocument::meshReady() +{ + Mesh *resultMesh = m_meshGenerator->takeResultMesh(); + + QImage *resultPreview = m_meshGenerator->takePreview(); + if (resultPreview) { + preview = *resultPreview; + delete resultPreview; + } + + for (auto &part: partMap) { + QImage *resultPartPreview = m_meshGenerator->takePartPreview(part.first.toString()); + if (resultPartPreview) { + part.second.preview = *resultPartPreview; + emit partPreviewChanged(part.first); + delete resultPartPreview; + } + } + + delete m_resultMesh; + m_resultMesh = resultMesh; + + if (nullptr == m_resultMesh) { + qDebug() << "Result mesh is null"; + } + + delete m_meshGenerator; + m_meshGenerator = nullptr; + + qDebug() << "Mesh generation done"; + + emit resultMeshChanged(); + + if (m_resultMeshIsObsolete) { + generateMesh(); + } +} + +void SkeletonDocument::generateMesh() +{ + if (nullptr != m_meshGenerator) { + m_resultMeshIsObsolete = true; + return; + } + + qDebug() << "Mesh generating.."; + + m_resultMeshIsObsolete = false; + + QThread *thread = new QThread; + + SkeletonSnapshot *snapshot = new SkeletonSnapshot; + toSnapshot(snapshot); + m_meshGenerator = new MeshGenerator(snapshot, thread); + m_meshGenerator->moveToThread(thread); + m_meshGenerator->addPreviewRequirement(); + for (auto &part: partMap) { + //if (part.second.previewIsObsolete) { + // part.second.previewIsObsolete = false; + m_meshGenerator->addPartPreviewRequirement(part.first.toString()); + //} + } + connect(thread, &QThread::started, m_meshGenerator, &MeshGenerator::process); + connect(m_meshGenerator, &MeshGenerator::finished, this, &SkeletonDocument::meshReady); + connect(m_meshGenerator, &MeshGenerator::finished, thread, &QThread::quit); + connect(thread, &QThread::finished, thread, &QThread::deleteLater); + thread->start(); +} diff --git a/src/skeletondocument.h b/src/skeletondocument.h new file mode 100644 index 00000000..5dd39399 --- /dev/null +++ b/src/skeletondocument.h @@ -0,0 +1,184 @@ +#ifndef SKELETON_DOCUMENT_H +#define SKELETON_DOCUMENT_H +#include +#include +#include +#include +#include +#include +#include "skeletonsnapshot.h" +#include "mesh.h" +#include "meshgenerator.h" + +enum class SkeletonNodeRootMarkMode +{ + Auto = 0, + MarkAsRoot, + MarkAsNotRoot +}; + +const char *SkeletonNodeRootMarkModeToString(SkeletonNodeRootMarkMode mode); +SkeletonNodeRootMarkMode SkeletonNodeRootMarkModeFromString(const QString &mode); + +class SkeletonNode +{ +public: + SkeletonNode(const QUuid &withId=QUuid()) : + x(0), + y(0), + z(0), + radius(0), + rootMarkMode(SkeletonNodeRootMarkMode::Auto) + { + id = withId.isNull() ? QUuid::createUuid() : withId; + } + QUuid id; + QUuid partId; + QString name; + float x; + float y; + float z; + float radius; + SkeletonNodeRootMarkMode rootMarkMode; + std::vector edgeIds; +}; + +enum class SkeletonEdgeBranchMode +{ + Auto = 0, + Trivial, + NoTrivial +}; + +const char *SkeletonEdgeBranchModeToString(SkeletonEdgeBranchMode mode); +SkeletonEdgeBranchMode SkeletonEdgeBranchModeFromString(const QString &mode); + +class SkeletonEdge +{ +public: + SkeletonEdge(const QUuid &withId=QUuid()) : + branchMode(SkeletonEdgeBranchMode::Auto) + { + id = withId.isNull() ? QUuid::createUuid() : withId; + } + QUuid id; + QUuid partId; + QString name; + SkeletonEdgeBranchMode branchMode; + std::vector nodeIds; + QUuid neighborOf(QUuid nodeId) const + { + if (nodeIds.size() != 2) + return QUuid(); + return nodeIds[0] == nodeId ? nodeIds[1] : nodeIds[0]; + } +}; + +class SkeletonPart +{ +public: + QUuid id; + QString name; + bool visible; + QImage preview; + std::vector nodeIds; + bool previewIsObsolete; + SkeletonPart(const QUuid &withId=QUuid()) : + visible(true), + previewIsObsolete(true) + { + id = withId.isNull() ? QUuid::createUuid() : withId; + } +}; + +class SkeletonHistoryItem +{ +public: + SkeletonSnapshot snapshot; + QImage preview; +}; + +enum class SkeletonDocumentEditMode +{ + Add = 0, + Select, + Drag, + ZoomIn, + ZoomOut +}; + +enum class SkeletonProfile +{ + Unknown = 0, + Main, + Side +}; + +class SkeletonDocument : public QObject +{ + Q_OBJECT +signals: + void partAdded(QUuid partId); + void nodeAdded(QUuid nodeId); + void edgeAdded(QUuid edgeId); + void partRemoved(QUuid partId); + void partListChanged(); + void nodeRemoved(QUuid nodeId); + void edgeRemoved(QUuid edgeId); + void nodeRadiusChanged(QUuid nodeId); + void nodeOriginChanged(QUuid nodeId); + void edgeChanged(QUuid edgeId); + void partChanged(QUuid partId); + void partPreviewChanged(QUuid partId); + void resultMeshChanged(); + void turnaroundChanged(); + void editModeChanged(); + void skeletonChanged(); +public: + SkeletonDocument(); + ~SkeletonDocument(); + std::map partMap; + std::map nodeMap; + std::map edgeMap; + std::vector historyItems; + std::vector partIds; + QImage turnaround; + SkeletonDocumentEditMode editMode; + void toSnapshot(SkeletonSnapshot *snapshot); + void fromSnapshot(const SkeletonSnapshot &snapshot); + const SkeletonNode *findNode(QUuid nodeId) const; + const SkeletonEdge *findEdge(QUuid edgeId) const; + const SkeletonPart *findPart(QUuid partId) const; + const SkeletonEdge *findEdgeByNodes(QUuid firstNodeId, QUuid secondNodeId) const; + Mesh *takeResultMesh(); + QImage preview; + void updateTurnaround(const QImage &image); +public slots: + void removeNode(QUuid nodeId); + void removeEdge(QUuid edgeId); + void removePart(QUuid partId); + void showPart(QUuid partId); + void hidePart(QUuid partId); + void addNode(float x, float y, float z, float radius, QUuid fromNodeId); + void scaleNodeByAddRadius(QUuid nodeId, float amount); + void moveNodeBy(QUuid nodeId, float x, float y, float z); + void setNodeOrigin(QUuid nodeId, float x, float y, float z); + void setNodeRadius(QUuid nodeId, float radius); + void addEdge(QUuid fromNodeId, QUuid toNodeId); + void setEditMode(SkeletonDocumentEditMode mode); + void setEdgeBranchMode(QUuid edgeId, SkeletonEdgeBranchMode mode); + void setNodeRootMarkMode(QUuid nodeId, SkeletonNodeRootMarkMode mode); + void uiReady(); + void generateMesh(); + void meshReady(); +private: + void splitPartByNode(std::vector> *groups, QUuid nodeId); + void joinNodeAndNeiborsToGroup(std::vector *group, QUuid nodeId, std::set *visitMap, QUuid noUseEdgeId=QUuid()); + void splitPartByEdge(std::vector> *groups, QUuid edgeId); +private: + bool m_resultMeshIsObsolete; + MeshGenerator *m_meshGenerator; + Mesh *m_resultMesh; +}; + +#endif diff --git a/src/skeletondocumentwindow.cpp b/src/skeletondocumentwindow.cpp new file mode 100644 index 00000000..e7b8610f --- /dev/null +++ b/src/skeletondocumentwindow.cpp @@ -0,0 +1,256 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include "skeletondocumentwindow.h" +#include "skeletongraphicswidget.h" +#include "skeletonpartlistwidget.h" +#include "skeletonedgepropertywidget.h" +#include "skeletonnodepropertywidget.h" +#include "theme.h" + +SkeletonDocumentWindow::SkeletonDocumentWindow() : + m_document(nullptr), + m_firstShow(true) +{ + m_document = new SkeletonDocument; + + QVBoxLayout *toolButtonLayout = new QVBoxLayout; + toolButtonLayout->setSpacing(0); + toolButtonLayout->setContentsMargins(5, 10, 4, 0); + + QPushButton *undoButton = new QPushButton(QChar(fa::undo)); + undoButton->setFont(Theme::awesome()->font(Theme::toolIconFontSize)); + undoButton->setFixedSize(Theme::toolIconSize, Theme::toolIconSize); + + QPushButton *addButton = new QPushButton(QChar(fa::plus)); + addButton->setFont(Theme::awesome()->font(Theme::toolIconFontSize)); + addButton->setFixedSize(Theme::toolIconSize, Theme::toolIconSize); + + QPushButton *selectButton = new QPushButton(QChar(fa::mousepointer)); + selectButton->setFont(Theme::awesome()->font(Theme::toolIconFontSize)); + selectButton->setFixedSize(Theme::toolIconSize, Theme::toolIconSize); + + QPushButton *dragButton = new QPushButton(QChar(fa::handrocko)); + dragButton->setFont(Theme::awesome()->font(Theme::toolIconFontSize)); + dragButton->setFixedSize(Theme::toolIconSize, Theme::toolIconSize); + + QPushButton *zoomInButton = new QPushButton(QChar(fa::searchplus)); + zoomInButton->setFont(Theme::awesome()->font(Theme::toolIconFontSize)); + zoomInButton->setFixedSize(Theme::toolIconSize, Theme::toolIconSize); + + QPushButton *zoomOutButton = new QPushButton(QChar(fa::searchminus)); + zoomOutButton->setFont(Theme::awesome()->font(Theme::toolIconFontSize)); + zoomOutButton->setFixedSize(Theme::toolIconSize, Theme::toolIconSize); + + QPushButton *changeTurnaroundButton = new QPushButton(QChar(fa::image)); + changeTurnaroundButton->setFont(Theme::awesome()->font(Theme::toolIconFontSize)); + changeTurnaroundButton->setFixedSize(Theme::toolIconSize, Theme::toolIconSize); + + QPushButton *resetButton = new QPushButton(QChar(fa::trash)); + resetButton->setFont(Theme::awesome()->font(Theme::toolIconFontSize)); + resetButton->setFixedSize(Theme::toolIconSize, Theme::toolIconSize); + + toolButtonLayout->addWidget(undoButton); + toolButtonLayout->addSpacing(10); + toolButtonLayout->addWidget(addButton); + toolButtonLayout->addWidget(selectButton); + toolButtonLayout->addWidget(dragButton); + toolButtonLayout->addWidget(zoomInButton); + toolButtonLayout->addWidget(zoomOutButton); + toolButtonLayout->addSpacing(10); + toolButtonLayout->addWidget(changeTurnaroundButton); + toolButtonLayout->addSpacing(30); + toolButtonLayout->addWidget(resetButton); + + QLabel *dust3dJezzasoftLabel = new QLabel; + QImage dust3dJezzasoftImage; + dust3dJezzasoftImage.load(":/resources/dust3d_jezzasoft.png"); + dust3dJezzasoftLabel->setPixmap(QPixmap::fromImage(dust3dJezzasoftImage)); + + QHBoxLayout *logoLayout = new QHBoxLayout; + logoLayout->addWidget(dust3dJezzasoftLabel); + 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); + + SkeletonGraphicsWidget *graphicsWidget = new SkeletonGraphicsWidget(m_document); + + SkeletonGraphicsContainerWidget *containerWidget = new SkeletonGraphicsContainerWidget; + + 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_modelWidget = new ModelWidget(containerWidget); + m_modelWidget->setMinimumSize(128, 128); + m_modelWidget->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum); + m_modelWidget->move(10, 10); + m_modelWidget->setGraphicsFunctions(graphicsWidget); + + SkeletonPartListWidget *partListWidget = new SkeletonPartListWidget(m_document); + + QTabWidget *firstTabWidget = new QTabWidget; + firstTabWidget->setFont(Theme::awesome()->font(Theme::toolIconFontSize * 3 / 4)); + firstTabWidget->setMaximumWidth(200); + firstTabWidget->addTab(partListWidget, QChar(fa::puzzlepiece)); + firstTabWidget->addTab(new QWidget, QChar(fa::history)); + firstTabWidget->addTab(new QWidget, QChar(fa::wrench)); + + SkeletonEdgePropertyWidget *edgePropertyWidget = new SkeletonEdgePropertyWidget(m_document); + SkeletonNodePropertyWidget *nodePropertyWidget = new SkeletonNodePropertyWidget(m_document); + + QVBoxLayout *propertyLayout = new QVBoxLayout; + propertyLayout->addWidget(edgePropertyWidget); + propertyLayout->addWidget(nodePropertyWidget); + + QWidget *propertyWidget = new QWidget; + propertyWidget->setLayout(propertyLayout); + + QTabWidget *secondTabWidget = new QTabWidget; + secondTabWidget->setFont(Theme::awesome()->font(Theme::toolIconFontSize * 3 / 4)); + secondTabWidget->setMaximumWidth(200); + secondTabWidget->setMaximumHeight(90); + secondTabWidget->addTab(propertyWidget, QChar(fa::adjust)); + + QVBoxLayout *mainRightLayout = new QVBoxLayout; + mainRightLayout->setSpacing(0); + mainRightLayout->setContentsMargins(5, 5, 5, 5); + mainRightLayout->addWidget(firstTabWidget); + mainRightLayout->addWidget(secondTabWidget); + + QHBoxLayout *mainLayout = new QHBoxLayout; + mainLayout->setSpacing(0); + mainLayout->setContentsMargins(0, 0, 0, 0); + mainLayout->addLayout(mainLeftLayout); + mainLayout->addWidget(containerWidget); + mainLayout->addLayout(mainRightLayout); + + QWidget *centralWidget = new QWidget; + centralWidget->setLayout(mainLayout); + + setCentralWidget(centralWidget); + setWindowTitle(tr("Dust3D")); + + connect(containerWidget, &SkeletonGraphicsContainerWidget::containerSizeChanged, + graphicsWidget, &SkeletonGraphicsWidget::canvasResized); + + connect(m_document, &SkeletonDocument::turnaroundChanged, + graphicsWidget, &SkeletonGraphicsWidget::turnaroundChanged); + + connect(changeTurnaroundButton, &QPushButton::clicked, this, &SkeletonDocumentWindow::changeTurnaround); + + connect(addButton, &QPushButton::clicked, [=]() { + m_document->setEditMode(SkeletonDocumentEditMode::Add); + }); + + connect(selectButton, &QPushButton::clicked, [=]() { + m_document->setEditMode(SkeletonDocumentEditMode::Select); + }); + + 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_document, &SkeletonDocument::editModeChanged, graphicsWidget, &SkeletonGraphicsWidget::editModeChanged); + + connect(graphicsWidget, &SkeletonGraphicsWidget::addNode, m_document, &SkeletonDocument::addNode); + connect(graphicsWidget, &SkeletonGraphicsWidget::scaleNodeByAddRadius, m_document, &SkeletonDocument::scaleNodeByAddRadius); + connect(graphicsWidget, &SkeletonGraphicsWidget::moveNodeBy, m_document, &SkeletonDocument::moveNodeBy); + connect(graphicsWidget, &SkeletonGraphicsWidget::removeNode, m_document, &SkeletonDocument::removeNode); + connect(graphicsWidget, &SkeletonGraphicsWidget::setEditMode, m_document, &SkeletonDocument::setEditMode); + connect(graphicsWidget, &SkeletonGraphicsWidget::removeEdge, m_document, &SkeletonDocument::removeEdge); + connect(graphicsWidget, &SkeletonGraphicsWidget::addEdge, m_document, &SkeletonDocument::addEdge); + + connect(m_document, &SkeletonDocument::nodeAdded, graphicsWidget, &SkeletonGraphicsWidget::nodeAdded); + connect(m_document, &SkeletonDocument::nodeRemoved, graphicsWidget, &SkeletonGraphicsWidget::nodeRemoved); + connect(m_document, &SkeletonDocument::edgeAdded, graphicsWidget, &SkeletonGraphicsWidget::edgeAdded); + connect(m_document, &SkeletonDocument::edgeRemoved, graphicsWidget, &SkeletonGraphicsWidget::edgeRemoved); + connect(m_document, &SkeletonDocument::nodeRadiusChanged, graphicsWidget, &SkeletonGraphicsWidget::nodeRadiusChanged); + connect(m_document, &SkeletonDocument::nodeOriginChanged, graphicsWidget, &SkeletonGraphicsWidget::nodeOriginChanged); + + connect(m_document, &SkeletonDocument::partListChanged, partListWidget, &SkeletonPartListWidget::partListChanged); + connect(m_document, &SkeletonDocument::partPreviewChanged, partListWidget, &SkeletonPartListWidget::partPreviewChanged); + + connect(graphicsWidget, &SkeletonGraphicsWidget::checkEdge, edgePropertyWidget, &SkeletonEdgePropertyWidget::showProperties); + connect(graphicsWidget, &SkeletonGraphicsWidget::uncheckEdge, [=](QUuid edgeId) { + edgePropertyWidget->hide(); + }); + connect(m_document, &SkeletonDocument::edgeRemoved, [=](QUuid edgeId) { + if (edgeId == edgePropertyWidget->currentEdgeId()) { + edgePropertyWidget->hide(); + } + }); + connect(edgePropertyWidget, &SkeletonEdgePropertyWidget::setEdgeBranchMode, m_document, &SkeletonDocument::setEdgeBranchMode); + + connect(graphicsWidget, &SkeletonGraphicsWidget::checkNode, nodePropertyWidget, &SkeletonNodePropertyWidget::showProperties); + connect(graphicsWidget, &SkeletonGraphicsWidget::uncheckNode, [=](QUuid nodeId) { + nodePropertyWidget->hide(); + }); + connect(m_document, &SkeletonDocument::nodeRemoved, [=](QUuid nodeId) { + if (nodeId == nodePropertyWidget->currentNodeId()) { + nodePropertyWidget->hide(); + } + }); + connect(nodePropertyWidget, &SkeletonNodePropertyWidget::setNodeRootMarkMode, m_document, &SkeletonDocument::setNodeRootMarkMode); + + connect(m_document, &SkeletonDocument::skeletonChanged, m_document, &SkeletonDocument::generateMesh); + + connect(m_document, &SkeletonDocument::resultMeshChanged, [=]() { + m_modelWidget->updateMesh(m_document->takeResultMesh()); + }); + + connect(graphicsWidget, &SkeletonGraphicsWidget::cursorChanged, [=]() { + m_modelWidget->setCursor(graphicsWidget->cursor()); + }); + + connect(this, &SkeletonDocumentWindow::initialized, m_document, &SkeletonDocument::uiReady); +} + +SkeletonDocumentWindow::~SkeletonDocumentWindow() +{ +} + +void SkeletonDocumentWindow::showEvent(QShowEvent *event) +{ + QMainWindow::showEvent(event); + if (m_firstShow) { + m_firstShow = false; + emit initialized(); + } +} + +void SkeletonDocumentWindow::changeTurnaround() +{ + QString fileName = QFileDialog::getOpenFileName(this, tr("Open Turnaround Reference Image"), + QString(), + tr("Image Files (*.png *.jpg *.bmp)")).trimmed(); + if (fileName.isEmpty()) + return; + QImage image; + if (!image.load(fileName)) + return; + m_document->updateTurnaround(image); +} diff --git a/src/skeletondocumentwindow.h b/src/skeletondocumentwindow.h new file mode 100644 index 00000000..4f3a11c2 --- /dev/null +++ b/src/skeletondocumentwindow.h @@ -0,0 +1,27 @@ +#ifndef SKELETON_DOCUMENT_WINDOW_H +#define SKELETON_DOCUMENT_WINDOW_H +#include +#include +#include "skeletondocument.h" +#include "modelwidget.h" + +class SkeletonDocumentWindow : public QMainWindow +{ + Q_OBJECT +signals: + void initialized(); +public: + SkeletonDocumentWindow(); + ~SkeletonDocumentWindow(); +protected: + void showEvent(QShowEvent *event); +public slots: + void changeTurnaround(); +private: + SkeletonDocument *m_document; + bool m_firstShow; + ModelWidget *m_modelWidget; +}; + +#endif + diff --git a/src/skeletonedgepropertywidget.cpp b/src/skeletonedgepropertywidget.cpp new file mode 100644 index 00000000..fcdd9b33 --- /dev/null +++ b/src/skeletonedgepropertywidget.cpp @@ -0,0 +1,53 @@ +#include +#include +#include +#include +#include "skeletonedgepropertywidget.h" + +SkeletonEdgePropertyWidget::SkeletonEdgePropertyWidget(const SkeletonDocument *document) : + m_branchModeComboBox(nullptr), + m_document(document) +{ + m_branchModeComboBox = new QComboBox; + + m_branchModeComboBox->insertItem(0, tr("Auto"), (int)SkeletonEdgeBranchMode::Auto); + m_branchModeComboBox->insertItem(1, tr("No Trivial"), (int)SkeletonEdgeBranchMode::NoTrivial); + m_branchModeComboBox->insertItem(2, tr("Trivial"), (int)SkeletonEdgeBranchMode::Trivial); + + QFormLayout *formLayout = new QFormLayout; + formLayout->addRow(tr("Joint Branch Mode:"), m_branchModeComboBox); + + setLayout(formLayout); + + hide(); + + connect(m_branchModeComboBox, static_cast(&QComboBox::currentIndexChanged), [=](int index) { + if (-1 != index) { + int mode = m_branchModeComboBox->itemData(index).toInt(); + emit setEdgeBranchMode(m_edgeId, static_cast(mode)); + } + }); +} + +void SkeletonEdgePropertyWidget::showProperties(QUuid edgeId) +{ + m_edgeId = edgeId; + updateData(); + show(); +} + +void SkeletonEdgePropertyWidget::updateData() +{ + const SkeletonEdge *edge = m_document->findEdge(m_edgeId); + if (nullptr == edge) { + hide(); + return; + } + int selectIndex = m_branchModeComboBox->findData((int)edge->branchMode); + m_branchModeComboBox->setCurrentIndex(selectIndex); +} + +QUuid SkeletonEdgePropertyWidget::currentEdgeId() +{ + return m_edgeId; +} diff --git a/src/skeletonedgepropertywidget.h b/src/skeletonedgepropertywidget.h new file mode 100644 index 00000000..5e8282b2 --- /dev/null +++ b/src/skeletonedgepropertywidget.h @@ -0,0 +1,26 @@ +#ifndef SKELETON_EDGE_PROPERTY_WIDGET_H +#define SKELETON_EDGE_PROPERTY_WIDGET_H +#include +#include +#include +#include "skeletondocument.h" + +class SkeletonEdgePropertyWidget : public QWidget +{ + Q_OBJECT +signals: + void setEdgeBranchMode(QUuid edgeId, SkeletonEdgeBranchMode mode); +public slots: + void showProperties(QUuid edgeId); +public: + SkeletonEdgePropertyWidget(const SkeletonDocument *document); + QUuid currentEdgeId(); +private: + void updateData(); +private: + QComboBox *m_branchModeComboBox; + const SkeletonDocument *m_document; + QUuid m_edgeId; +}; + +#endif diff --git a/src/skeletoneditedgeitem.cpp b/src/skeletoneditedgeitem.cpp deleted file mode 100644 index 2cde95da..00000000 --- a/src/skeletoneditedgeitem.cpp +++ /dev/null @@ -1,74 +0,0 @@ -#include -#include "skeletoneditedgeitem.h" -#include "theme.h" - -SkeletonEditEdgeItem::SkeletonEditEdgeItem(QGraphicsItem *parent) : - QGraphicsLineItem(parent), - m_firstNode(NULL), - m_secondNode(NULL) -{ - setData(0, "edge"); - m_checked = false; - updateAppearance(); -} - -void SkeletonEditEdgeItem::setChecked(bool checked) -{ - if (m_checked == checked) { - return; - } - m_checked = checked; - updateAppearance(); -} - -bool SkeletonEditEdgeItem::checked() -{ - return m_checked; -} - -void SkeletonEditEdgeItem::updateAppearance() -{ - QPen pen; - if (m_firstNode) { - QColor color = m_firstNode->sideColor(); - color.setAlphaF(Theme::edgeAlpha); - pen.setColor(color); - } else if (m_secondNode) { - QColor color = m_secondNode->sideColor(); - color.setAlphaF(Theme::edgeAlpha); - pen.setColor(color); - } - pen.setWidth(Theme::skeletonEdgeWidth); - setPen(pen); -} - -void SkeletonEditEdgeItem::setNodes(SkeletonEditNodeItem *first, SkeletonEditNodeItem *second) -{ - m_firstNode = first; - m_secondNode = second; - updatePosition(); -} - -bool SkeletonEditEdgeItem::connects(SkeletonEditNodeItem *nodeItem) -{ - return m_firstNode == nodeItem || m_secondNode == nodeItem; -} - -void SkeletonEditEdgeItem::updatePosition() -{ - if (m_firstNode && m_secondNode) { - QLineF line(m_firstNode->origin(), m_secondNode->origin()); - setLine(line); - } - updateAppearance(); -} - -SkeletonEditNodeItem *SkeletonEditEdgeItem::firstNode() -{ - return m_firstNode; -} - -SkeletonEditNodeItem *SkeletonEditEdgeItem::secondNode() -{ - return m_secondNode; -} diff --git a/src/skeletoneditedgeitem.h b/src/skeletoneditedgeitem.h deleted file mode 100644 index 40099e9b..00000000 --- a/src/skeletoneditedgeitem.h +++ /dev/null @@ -1,25 +0,0 @@ -#ifndef SKELETON_EDIT_EDGE_ITEM_H -#define SKELETON_EDIT_EDGE_ITEM_H -#include -#include "skeletoneditnodeitem.h" - -class SkeletonEditEdgeItem : public QGraphicsLineItem -{ -public: - SkeletonEditEdgeItem(QGraphicsItem *parent = 0); - void setNodes(SkeletonEditNodeItem *first, SkeletonEditNodeItem *second); - void updatePosition(); - SkeletonEditNodeItem *firstNode(); - SkeletonEditNodeItem *secondNode(); - bool connects(SkeletonEditNodeItem *nodeItem); - void setChecked(bool checked); - bool checked(); -private: - SkeletonEditNodeItem *m_firstNode; - SkeletonEditNodeItem *m_secondNode; - bool m_checked; -private: - void updateAppearance(); -}; - -#endif diff --git a/src/skeletoneditgraphicsview.cpp b/src/skeletoneditgraphicsview.cpp deleted file mode 100644 index 97287f49..00000000 --- a/src/skeletoneditgraphicsview.cpp +++ /dev/null @@ -1,713 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "skeletoneditgraphicsview.h" -#include "skeletoneditnodeitem.h" -#include "skeletoneditedgeitem.h" -#include "theme.h" - -qreal SkeletonEditGraphicsView::m_initialNodeSize = 128; -qreal SkeletonEditGraphicsView::m_minimalNodeSize = 8; - -SkeletonEditGraphicsView::SkeletonEditGraphicsView(QWidget *parent) : - QGraphicsView(parent), - m_pendingNodeItem(NULL), - m_pendingEdgeItem(NULL), - m_inAddNodeMode(true), - m_nextStartNodeItem(NULL), - m_lastHoverNodeItem(NULL), - m_lastMousePos(0, 0), - m_isMovingNodeItem(false), - m_backgroundLoaded(false), - m_modelWidget(NULL), - m_modelWidgetProxy(NULL), - m_combineEnabled(true), - m_unionEnabled(true), - m_subdivEnabled(false) -{ - setScene(new QGraphicsScene()); - - m_modelWidget = new ModelWidget(this); - m_modelWidget->setMinimumSize(128, 128); - m_modelWidget->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum); - m_modelWidget->move(100, 100); - m_modelWidget->setGraphicsView(this); - m_modelWidgetProxy = scene()->addWidget(m_modelWidget); - - m_backgroundItem = new QGraphicsPixmapItem(); - m_backgroundItem->setOpacity(0.25); - scene()->addItem(m_backgroundItem); - - m_pendingNodeItem = new QGraphicsEllipseItem(0, 0, m_initialNodeSize, m_initialNodeSize); - m_pendingNodeItem->setVisible(false); - scene()->addItem(m_pendingNodeItem); - - m_pendingEdgeItem = new QGraphicsLineItem(0, 0, 0, 0); - m_pendingEdgeItem->setVisible(false); - scene()->addItem(m_pendingEdgeItem); -} - -ModelWidget *SkeletonEditGraphicsView::modelWidget() -{ - return m_modelWidget; -} - -void SkeletonEditGraphicsView::toggleAddNodeMode() -{ - if (!m_backgroundLoaded) - return; - m_inAddNodeMode = !m_inAddNodeMode; - applyAddNodeMode(); -} - -void SkeletonEditGraphicsView::applyAddNodeMode() -{ - m_pendingNodeItem->setVisible(m_inAddNodeMode); - m_pendingEdgeItem->setVisible(m_inAddNodeMode && m_nextStartNodeItem); - setMouseTracking(true); -} - -void SkeletonEditGraphicsView::turnOffAddNodeMode() -{ - if (!m_backgroundLoaded) - return; - m_inAddNodeMode = false; - applyAddNodeMode(); -} - -void SkeletonEditGraphicsView::turnOnAddNodeMode() -{ - if (!m_backgroundLoaded) - return; - m_inAddNodeMode = true; - applyAddNodeMode(); -} - -SkeletonEditNodeItem *SkeletonEditGraphicsView::findNodeItemByPos(QPointF pos) -{ - QList::iterator it; - QList list = scene()->items(); - for (it = list.begin(); it != list.end(); ++it) { - if ((*it)->data(0).toString() == "node") { - SkeletonEditNodeItem *nodeItem = static_cast(*it); - if (nodeItem->shape().contains(pos)) { - return nodeItem; - } - } - } - return NULL; -} - -SkeletonEditEdgeItem *SkeletonEditGraphicsView::findEdgeItemByPos(QPointF pos) -{ - QList::iterator it; - QList list = scene()->items(); - for (it = list.begin(); it != list.end(); ++it) { - if ((*it)->data(0).toString() == "edge") { - SkeletonEditEdgeItem *edgeItem = static_cast(*it); - if (edgeItem->shape().contains(pos)) { - return edgeItem; - } - } - } - return NULL; -} - -SkeletonEditEdgeItem *SkeletonEditGraphicsView::findEdgeItemByNodePair(SkeletonEditNodeItem *first, - SkeletonEditNodeItem *second) -{ - QList::iterator it; - QList list = scene()->items(); - assert(first != second); - for (it = list.begin(); it != list.end(); ++it) { - if ((*it)->data(0).toString() == "edge") { - SkeletonEditEdgeItem *edgeItem = static_cast(*it); - if ((edgeItem->firstNode() == first || edgeItem->secondNode() == first) && - (edgeItem->firstNode() == second || edgeItem->secondNode() == second)) { - return edgeItem; - } - } - } - return NULL; -} - -bool SkeletonEditGraphicsView::mousePress(QMouseEvent *event, const QPointF &scenePos) -{ - bool processed = false; - if (!m_backgroundLoaded) - return false; - QPointF pos = scenePos; - if (event->button() == Qt::LeftButton) { - if (!m_inAddNodeMode) { - if (m_lastHoverNodeItem) { - setNextStartNodeItem(m_lastHoverNodeItem); - m_lastHoverNodeItem = NULL; - processed = true; - } else { - if (m_nextStartNodeItem) { - setNextStartNodeItem(NULL); - processed = true; - } - } - } - } - m_lastMousePos = pos; - return processed; -} - -bool SkeletonEditGraphicsView::mouseDoubleClick(QMouseEvent *event, const QPointF &scenePos) -{ - bool processed = false; - if (QApplication::keyboardModifiers() & Qt::ControlModifier) { - processed = true; - emit changeTurnaroundTriggered(); - } - return processed; -} - -void SkeletonEditGraphicsView::removeSelectedItems() -{ - if (m_nextStartNodeItem) { - SkeletonEditNodeItem *nodeItem = m_nextStartNodeItem; - setNextStartNodeItem(NULL); - removeNodeItem(nodeItem->nextSidePair()); - removeNodeItem(nodeItem); - emit nodesChanged(); - } -} - -void SkeletonEditGraphicsView::removeNodeItem(SkeletonEditNodeItem *nodeItem) -{ - scene()->removeItem(nodeItem); - QList::iterator it; - QList list = scene()->items(); - for (it = list.begin(); it != list.end(); ++it) { - if ((*it)->data(0).toString() == "edge") { - SkeletonEditEdgeItem *edgeItem = static_cast(*it); - if (edgeItem->firstNode() == nodeItem || edgeItem->secondNode() == nodeItem) { - scene()->removeItem(edgeItem); - } - } - } -} - -void SkeletonEditGraphicsView::fetchNodeItemAndAllSidePairs(SkeletonEditNodeItem *nodeItem, std::vector *sidePairs) -{ - sidePairs->push_back(nodeItem); - sidePairs->push_back(nodeItem->nextSidePair()); - sidePairs->push_back(nodeItem->nextSidePair()->nextSidePair()); -} - -void SkeletonEditGraphicsView::removeNodeItemAndSidePairs(SkeletonEditNodeItem *nodeItem) -{ - std::vector nodes; - fetchNodeItemAndAllSidePairs(nodeItem, &nodes); - for (size_t i = 0; i < nodes.size(); i++) { - removeNodeItem(nodes[i]); - } -} - -bool SkeletonEditGraphicsView::keyPress(QKeyEvent *event, const QPointF &scenePos) -{ - bool processed = false; - if (!m_backgroundLoaded) - return false; - if (event->key() == Qt::Key_A) { - toggleAddNodeMode(); - processed = true; - } else if (event->key() == Qt::Key_C) { - m_combineEnabled = !m_combineEnabled; - emit nodesChanged(); - } else if (event->key() == Qt::Key_U) { - m_unionEnabled = !m_unionEnabled; - emit nodesChanged(); - } else if (event->key() == Qt::Key_S) { - m_subdivEnabled = !m_subdivEnabled; - emit nodesChanged(); - } else if (event->key() == Qt::Key_Tab) { - if (m_nextStartNodeItem) - setNextStartNodeItem(m_nextStartNodeItem->nextSidePair()); - } else if (event->key() == Qt::Key_Delete || event->key() ==Qt::Key_Backspace) { - removeSelectedItems(); - processed = true; - } - return processed; -} - -void SkeletonEditGraphicsView::resizeEvent(QResizeEvent *event) -{ - QFrame::resizeEvent(event); - emit sizeChanged(); -} - -SkeletonEditNodeItem *SkeletonEditGraphicsView::addNodeItemAndSidePairs(QRectF area, SkeletonEditNodeItem *fromNodeItem, const QString &sideColorName) -{ - float pairedX = 0; - QRectF pairedRect = area; - if (fromNodeItem) { - pairedX = fromNodeItem->nextSidePair()->rect().x(); - } else { - if (area.center().x() < scene()->sceneRect().width() / 2) { - pairedX = area.center().x() + scene()->sceneRect().width() / 4; - } else { - pairedX = area.center().x() - scene()->sceneRect().width() / 4; - } - } - pairedRect.translate(pairedX - area.x(), 0); - SkeletonEditNodeItem *firstNode = new SkeletonEditNodeItem(area); - scene()->addItem(firstNode); - firstNode->setSideColorName(fromNodeItem ? fromNodeItem->sideColorName() : sideColorName); - SkeletonEditNodeItem *secondNode = new SkeletonEditNodeItem(pairedRect); - scene()->addItem(secondNode); - secondNode->setSideColorName(firstNode->nextSideColorName()); - firstNode->setNextSidePair(secondNode); - secondNode->setNextSidePair(firstNode); - setNextStartNodeItem(firstNode); - if (!fromNodeItem) { - return firstNode; - } - addEdgeItem(fromNodeItem, firstNode); - addEdgeItem(fromNodeItem->nextSidePair(), firstNode->nextSidePair()); - return firstNode; -} - -SkeletonEditNodeItem *SkeletonEditGraphicsView::addNodeItem(float originX, float originY, float radius) -{ - QRectF area(originX - radius, originY - radius, radius * 2, radius * 2); - SkeletonEditNodeItem *firstNode = new SkeletonEditNodeItem(area); - scene()->addItem(firstNode); - return firstNode; -} - -void SkeletonEditGraphicsView::addEdgeItem(SkeletonEditNodeItem *first, SkeletonEditNodeItem *second) -{ - SkeletonEditEdgeItem *newEdge = new SkeletonEditEdgeItem(); - newEdge->setNodes(first, second); - scene()->addItem(newEdge); -} - -bool SkeletonEditGraphicsView::mouseRelease(QMouseEvent *event, const QPointF &scenePos) -{ - bool processed = false; - if (!m_backgroundLoaded) - return false; - if (event->button() == Qt::LeftButton) { - if (m_inAddNodeMode) { - if (m_lastHoverNodeItem && m_nextStartNodeItem && - m_lastHoverNodeItem != m_nextStartNodeItem && - m_lastHoverNodeItem->sideColor() == m_nextStartNodeItem->sideColor()) { - if (!findEdgeItemByNodePair(m_lastHoverNodeItem, m_nextStartNodeItem)) { - addEdgeItem(m_nextStartNodeItem, m_lastHoverNodeItem); - addEdgeItem(m_nextStartNodeItem->nextSidePair(), m_lastHoverNodeItem->nextSidePair()); - processed = true; - emit nodesChanged(); - } - } else { - addNodeItemAndSidePairs(m_pendingNodeItem->rect(), m_nextStartNodeItem); - processed = true; - emit nodesChanged(); - } - } - m_isMovingNodeItem = false; - } - return processed; -} - -bool SkeletonEditGraphicsView::canNodeItemMoveTo(SkeletonEditNodeItem *item, QPointF moveTo) -{ - if (moveTo.x() < 0) - return false; - if (moveTo.y() < 0) - return false; - if (moveTo.x() + item->rect().width() >= scene()->sceneRect().width()) - return false; - if (moveTo.y() + item->rect().height() >= scene()->sceneRect().height()) - return false; - return true; -} - -bool SkeletonEditGraphicsView::mouseMove(QMouseEvent *event, const QPointF &scenePos) -{ - bool processed = false; - if (!m_backgroundLoaded) - return false; - QPointF pos = scenePos; - QPointF moveTo = QPointF(pos.x() - m_pendingNodeItem->rect().width() / 2, pos.y() - m_pendingNodeItem->rect().height() / 2); - if (moveTo.x() < 0) - moveTo.setX(0); - if (moveTo.y() < 0) - moveTo.setY(0); - if (moveTo.x() + m_pendingNodeItem->rect().width() >= scene()->sceneRect().width()) - moveTo.setX(scene()->sceneRect().width() - m_pendingNodeItem->rect().width()); - if (moveTo.y() + m_pendingNodeItem->rect().height() >= scene()->sceneRect().height()) - moveTo.setY(scene()->sceneRect().height() - m_pendingNodeItem->rect().height()); - QSizeF oldSize = m_pendingNodeItem->rect().size(); - m_pendingNodeItem->setRect(moveTo.x(), moveTo.y(), - oldSize.width(), - oldSize.height()); - if (m_nextStartNodeItem) { - m_pendingEdgeItem->setLine(QLineF(m_nextStartNodeItem->origin(), QPointF(moveTo.x() + m_pendingNodeItem->rect().width() / 2, - moveTo.y() + m_pendingNodeItem->rect().height() / 2))); - } - if (!m_isMovingNodeItem) { - SkeletonEditNodeItem *hoverNodeItem = findNodeItemByPos(pos); - if (hoverNodeItem) { - hoverNodeItem->setHovered(true); - processed = true; - } - if (hoverNodeItem != m_lastHoverNodeItem) { - if (m_lastHoverNodeItem) - m_lastHoverNodeItem->setHovered(false); - m_lastHoverNodeItem = hoverNodeItem; - processed = true; - } - } - QPointF curMousePos = pos; - if (m_lastHoverNodeItem) { - if ((event->buttons() & Qt::LeftButton) && - (curMousePos != m_lastMousePos || m_isMovingNodeItem)) { - m_isMovingNodeItem = true; - QRectF rect = m_lastHoverNodeItem->rect(); - QRectF pairedRect; - - rect.translate(curMousePos.x() - m_lastMousePos.x(), curMousePos.y() - m_lastMousePos.y()); - pairedRect = m_lastHoverNodeItem->nextSidePair()->rect(); - pairedRect.translate(0, curMousePos.y() - m_lastMousePos.y()); - - m_lastHoverNodeItem->setRect(rect); - m_lastHoverNodeItem->nextSidePair()->setRect(pairedRect); - - QList::iterator it; - QList list = scene()->items(); - for (it = list.begin(); it != list.end(); ++it) { - if ((*it)->data(0).toString() == "edge") { - SkeletonEditEdgeItem *edgeItem = static_cast(*it); - if (edgeItem->connects(m_lastHoverNodeItem) || - edgeItem->connects(m_lastHoverNodeItem->nextSidePair())) - edgeItem->updatePosition(); - } - } - processed = true; - emit nodesChanged(); - } - } - m_lastMousePos = curMousePos; - return processed; -} - -void SkeletonEditGraphicsView::AddItemRadius(QGraphicsEllipseItem *item, float delta) -{ - QSizeF oldSize = item->rect().size(); - QPointF originPt = QPointF(item->rect().left() + oldSize.width() / 2, - item->rect().top() + oldSize.height() / 2); - QSizeF newSize = QSizeF(oldSize.width() + delta, oldSize.height() + delta); - if (newSize.width() < m_minimalNodeSize || newSize.height() < m_minimalNodeSize) { - newSize.setWidth(m_minimalNodeSize); - newSize.setHeight(m_minimalNodeSize); - } - QPointF newLeftTop = QPointF(originPt.x() - newSize.width() / 2, - originPt.y() - newSize.height() / 2); - if (newLeftTop.x() < 0 || newLeftTop.x() + newSize.width() >= scene()->sceneRect().width()) - return; - if (newLeftTop.y() < 0 || newLeftTop.y() + newSize.height() >= scene()->sceneRect().height()) - return; - item->setRect(newLeftTop.x(), - newLeftTop.y(), - newSize.width(), - newSize.height()); -} - -bool SkeletonEditGraphicsView::canAddItemRadius(QGraphicsEllipseItem *item, float delta) -{ - QSizeF oldSize = item->rect().size(); - QPointF originPt = QPointF(item->rect().left() + oldSize.width() / 2, - item->rect().top() + oldSize.height() / 2); - QSizeF newSize = QSizeF(oldSize.width() + delta, oldSize.height() + delta); - if (newSize.width() < m_minimalNodeSize || newSize.height() < m_minimalNodeSize) { - newSize.setWidth(m_minimalNodeSize); - newSize.setHeight(m_minimalNodeSize); - } - QPointF newLeftTop = QPointF(originPt.x() - newSize.width() / 2, - originPt.y() - newSize.height() / 2); - if (newLeftTop.x() < 0 || newLeftTop.x() + newSize.width() >= scene()->sceneRect().width()) - return false; - if (newLeftTop.y() < 0 || newLeftTop.y() + newSize.height() >= scene()->sceneRect().height()) - return false; - return true; -} - -bool SkeletonEditGraphicsView::wheel(QWheelEvent *event, const QPointF &scenePos) -{ - bool processed = false; - if (!m_backgroundLoaded) - return false; - qreal delta = event->delta() / 10; - if (QGuiApplication::queryKeyboardModifiers().testFlag(Qt::ShiftModifier)) { - if (delta > 0) - delta = 1; - else - delta = -1; - } else { - if (fabs(delta) < 1) - delta = delta < 0 ? -1.0 : 1.0; - } - AddItemRadius(m_pendingNodeItem, delta); - if (!m_inAddNodeMode && m_lastHoverNodeItem) { - AddItemRadius(m_lastHoverNodeItem, delta); - AddItemRadius(m_lastHoverNodeItem->nextSidePair(), delta); - processed = true; - emit nodesChanged(); - } - if (m_inAddNodeMode) - processed = true; - return processed; -} - -void SkeletonEditGraphicsView::setNextStartNodeItem(SkeletonEditNodeItem *item) -{ - if (m_nextStartNodeItem != item) { - if (m_nextStartNodeItem) - m_nextStartNodeItem->setChecked(false); - } - m_nextStartNodeItem = item; - if (m_nextStartNodeItem) - m_nextStartNodeItem->setChecked(true); - applyAddNodeMode(); -} - -void SkeletonEditGraphicsView::updateBackgroundImage(const QImage &image) -{ - QSizeF oldSceneSize = scene()->sceneRect().size(); - QPixmap pixmap = QPixmap::fromImage(image); - scene()->setSceneRect(pixmap.rect()); - m_backgroundItem->setPixmap(pixmap); - adjustItems(oldSceneSize, scene()->sceneRect().size()); - if (!m_backgroundLoaded) { - m_backgroundLoaded = true; - applyAddNodeMode(); - } -} - -QPixmap SkeletonEditGraphicsView::backgroundImage() -{ - return m_backgroundItem->pixmap(); -} - -bool SkeletonEditGraphicsView::hasBackgroundImage() -{ - return m_backgroundLoaded; -} - -void SkeletonEditGraphicsView::adjustItems(QSizeF oldSceneSize, QSizeF newSceneSize) -{ - if (oldSceneSize == newSceneSize) - return; - float radiusMul = (float)newSceneSize.height() / oldSceneSize.height(); - float xMul = (float)newSceneSize.width() / oldSceneSize.width(); - float yMul = radiusMul; - QList::iterator it; - QList list = scene()->items(); - for (it = list.begin(); it != list.end(); ++it) { - if ((*it)->data(0).toString() == "node") { - SkeletonEditNodeItem *nodeItem = static_cast(*it); - nodeItem->setRadius(nodeItem->radius() * radiusMul); - QPointF oldOrigin = nodeItem->origin(); - nodeItem->setOrigin(QPointF(oldOrigin.x() * xMul, oldOrigin.y() * yMul)); - } - } - for (it = list.begin(); it != list.end(); ++it) { - if ((*it)->data(0).toString() == "edge") { - SkeletonEditEdgeItem *edgeItem = static_cast(*it); - edgeItem->updatePosition(); - } - } -} - -void SkeletonEditGraphicsView::loadFromSnapshot(SkeletonSnapshot *snapshot) -{ - float radiusMul = 1.0; - float xMul = 1.0; - float yMul = radiusMul; - - QString canvasWidth = snapshot->canvas["width"]; - QString canvasHeight = snapshot->canvas["height"]; - float canvasWidthVal = canvasWidth.toFloat(); - float canvasHeightVal = canvasHeight.toFloat(); - if (!hasBackgroundImage()) { - QPixmap emptyImage((int)canvasWidthVal, (int)canvasHeightVal); - emptyImage.fill(QWidget::palette().color(QWidget::backgroundRole())); - updateBackgroundImage(emptyImage.toImage()); - } - if (canvasHeightVal > 0) - radiusMul = (float)scene()->sceneRect().height() / canvasHeightVal; - if (canvasWidthVal > 0) - xMul = (float)scene()->sceneRect().width() / canvasWidthVal; - yMul = radiusMul; - - std::map nodeItemMap; - std::map>::iterator nodeIterator; - for (nodeIterator = snapshot->nodes.begin(); nodeIterator != snapshot->nodes.end(); nodeIterator++) { - std::map *snapshotNode = &nodeIterator->second; - SkeletonEditNodeItem *nodeItem = addNodeItem((*snapshotNode)["x"].toFloat() * xMul, - (*snapshotNode)["y"].toFloat() * yMul, - (*snapshotNode)["radius"].toFloat() * radiusMul); - nodeItem->setSideColorName((*snapshotNode)["sideColorName"]); - nodeItem->markAsBranch("true" == (*snapshotNode)["isBranch"]); - nodeItemMap[nodeIterator->first] = nodeItem; - } - for (nodeIterator = snapshot->nodes.begin(); nodeIterator != snapshot->nodes.end(); nodeIterator++) { - std::map *snapshotNode = &nodeIterator->second; - SkeletonEditNodeItem *nodeItem = nodeItemMap[nodeIterator->first]; - nodeItem->setNextSidePair(nodeItemMap[(*snapshotNode)["nextSidePair"]]); - } - - std::map>::iterator edgeIterator; - for (edgeIterator = snapshot->edges.begin(); edgeIterator != snapshot->edges.end(); edgeIterator++) { - std::map *snapshotEdge = &edgeIterator->second; - addEdgeItem(nodeItemMap[(*snapshotEdge)["from"]], nodeItemMap[(*snapshotEdge)["to"]]); - } - - emit nodesChanged(); -} - -void SkeletonEditGraphicsView::saveToSnapshot(SkeletonSnapshot *snapshot) -{ - snapshot->canvas["width"] = QString("%1").arg(scene()->sceneRect().width()); - snapshot->canvas["height"] = QString("%1").arg(scene()->sceneRect().height()); - snapshot->canvas["combine"] = m_combineEnabled ? "true" : "false"; - snapshot->canvas["union"] = m_unionEnabled ? "true" : "false"; - snapshot->canvas["subdiv"] = m_subdivEnabled ? "true" : "false"; - - QList::iterator it; - QList list = scene()->items(); - - int nextNodeId = 1; - std::map nodeIdMap; - for (it = list.begin(); it != list.end(); ++it) { - if ((*it)->data(0).toString() == "node") { - SkeletonEditNodeItem *nodeItem = static_cast(*it); - QString nodeId = QString("node%1").arg(nextNodeId); - std::map *snapshotNode = &snapshot->nodes[nodeId]; - (*snapshotNode)["id"] = nodeId; - (*snapshotNode)["sideColorName"] = nodeItem->sideColorName(); - (*snapshotNode)["radius"] = QString("%1").arg(nodeItem->radius()); - (*snapshotNode)["isBranch"] = QString("%1").arg(nodeItem->isBranch() ? "true" : "false"); - (*snapshotNode)["isRoot"] = QString("%1").arg(nodeItem->isRoot() ? "true" : "false"); - QPointF origin = nodeItem->origin(); - (*snapshotNode)["x"] = QString("%1").arg(origin.x()); - (*snapshotNode)["y"] = QString("%1").arg(origin.y()); - nodeIdMap[nodeItem] = nodeId; - nextNodeId++; - } - } - - for (it = list.begin(); it != list.end(); ++it) { - if ((*it)->data(0).toString() == "node") { - SkeletonEditNodeItem *nodeItem = static_cast(*it); - QString nodeId = nodeIdMap[nodeItem]; - std::map *snapshotNode = &snapshot->nodes[nodeId]; - (*snapshotNode)["nextSidePair"] = nodeIdMap[nodeItem->nextSidePair()]; - } - } - - int nextEdgeId = 1; - for (it = list.begin(); it != list.end(); ++it) { - if ((*it)->data(0).toString() == "edge") { - SkeletonEditEdgeItem *edgeItem = static_cast(*it); - QString edgeId = QString("edge%1").arg(nextEdgeId); - std::map *snapshotEdge = &snapshot->edges[edgeId]; - (*snapshotEdge)["id"] = edgeId; - (*snapshotEdge)["from"] = nodeIdMap[edgeItem->firstNode()]; - (*snapshotEdge)["to"] = nodeIdMap[edgeItem->secondNode()]; - nextEdgeId++; - } - } -} - -void SkeletonEditGraphicsView::markAsBranch() -{ - if (m_nextStartNodeItem) { - m_nextStartNodeItem->markAsBranch(true); - m_nextStartNodeItem->nextSidePair()->markAsBranch(true); - emit nodesChanged(); - } -} - -void SkeletonEditGraphicsView::markAsTrunk() -{ - if (m_nextStartNodeItem) { - m_nextStartNodeItem->markAsBranch(false); - m_nextStartNodeItem->nextSidePair()->markAsBranch(false); - emit nodesChanged(); - } -} - -void SkeletonEditGraphicsView::markAsRoot() -{ - if (m_nextStartNodeItem) { - m_nextStartNodeItem->markAsRoot(true); - m_nextStartNodeItem->nextSidePair()->markAsRoot(true); - emit nodesChanged(); - } -} - -void SkeletonEditGraphicsView::markAsChild() -{ - if (m_nextStartNodeItem) { - m_nextStartNodeItem->markAsRoot(false); - m_nextStartNodeItem->nextSidePair()->markAsRoot(false); - emit nodesChanged(); - } -} - -void SkeletonEditGraphicsView::mouseMoveEvent(QMouseEvent *event) -{ - mouseMove(event, mapToScene(event->pos())); -} - -void SkeletonEditGraphicsView::wheelEvent(QWheelEvent *event) -{ - wheel(event, mapToScene(event->pos())); -} - -void SkeletonEditGraphicsView::mouseReleaseEvent(QMouseEvent *event) -{ - mouseRelease(event, mapToScene(event->pos())); -} - -void SkeletonEditGraphicsView::mousePressEvent(QMouseEvent *event) -{ - mousePress(event, mapToScene(event->pos())); -} - -void SkeletonEditGraphicsView::mouseDoubleClickEvent(QMouseEvent *event) -{ - mouseDoubleClick(event, mapToScene(event->pos())); -} - -void SkeletonEditGraphicsView::keyPressEvent(QKeyEvent *event) -{ - keyPress(event, QPointF()); -} - -bool SkeletonEditGraphicsView::combineEnabled() -{ - return m_combineEnabled; -} - -bool SkeletonEditGraphicsView::unionEnabled() -{ - return m_unionEnabled; -} - -bool SkeletonEditGraphicsView::subdivEnabled() -{ - return m_subdivEnabled; -} - diff --git a/src/skeletoneditgraphicsview.h b/src/skeletoneditgraphicsview.h deleted file mode 100644 index bd603ea6..00000000 --- a/src/skeletoneditgraphicsview.h +++ /dev/null @@ -1,93 +0,0 @@ -#ifndef SKELETON_EDIT_GRAPHICS_VIEW_H -#define SKELETON_EDIT_GRAPHICS_VIEW_H -#include -#include -#include -#include -#include -#include -#include -#include "skeletoneditnodeitem.h" -#include "skeletoneditedgeitem.h" -#include "skeletonsnapshot.h" -#include "modelwidget.h" - -class SkeletonEditGraphicsView : public QGraphicsView -{ - Q_OBJECT -signals: - void sizeChanged(); - void nodesChanged(); - void changeTurnaroundTriggered(); - void edgeCheckStateChanged(); -public slots: - void turnOffAddNodeMode(); - void turnOnAddNodeMode(); - void markAsBranch(); - void markAsTrunk(); - void markAsRoot(); - void markAsChild(); - bool mouseMove(QMouseEvent *event, const QPointF &scenePos); - bool wheel(QWheelEvent *event, const QPointF &scenePos); - bool mouseRelease(QMouseEvent *event, const QPointF &scenePos); - bool mousePress(QMouseEvent *event, const QPointF &scenePos); - bool mouseDoubleClick(QMouseEvent *event, const QPointF &scenePos); - bool keyPress(QKeyEvent *event, const QPointF &scenePos); -public: - SkeletonEditGraphicsView(QWidget *parent = 0); - void updateBackgroundImage(const QImage &image); - bool hasBackgroundImage(); - QPixmap backgroundImage(); - void saveToSnapshot(SkeletonSnapshot *snapshot); - void loadFromSnapshot(SkeletonSnapshot *snapshot); - ModelWidget *modelWidget(); - bool combineEnabled(); - bool unionEnabled(); - bool subdivEnabled(); -protected: - void mouseMoveEvent(QMouseEvent *event); - void wheelEvent(QWheelEvent *event); - void mouseReleaseEvent(QMouseEvent *event); - void mousePressEvent(QMouseEvent *event); - void mouseDoubleClickEvent(QMouseEvent *event); - void keyPressEvent(QKeyEvent *event); - void resizeEvent(QResizeEvent *event); -private: - QGraphicsPixmapItem *m_backgroundItem; - QGraphicsEllipseItem *m_pendingNodeItem; - QGraphicsLineItem *m_pendingEdgeItem; - static qreal m_initialNodeSize; - static qreal m_minimalNodeSize; - bool m_inAddNodeMode; - SkeletonEditNodeItem *m_nextStartNodeItem; - SkeletonEditNodeItem *m_lastHoverNodeItem; - QPointF m_lastMousePos; - bool m_isMovingNodeItem; - bool m_backgroundLoaded; - ModelWidget *m_modelWidget; - QGraphicsProxyWidget *m_modelWidgetProxy; - bool m_combineEnabled; - bool m_unionEnabled; - bool m_subdivEnabled; -private: - void toggleAddNodeMode(); - void applyAddNodeMode(); - SkeletonEditNodeItem *findNodeItemByPos(QPointF pos); - SkeletonEditEdgeItem *findEdgeItemByPos(QPointF pos); - SkeletonEditEdgeItem *findEdgeItemByNodePair(SkeletonEditNodeItem *first, - SkeletonEditNodeItem *second); - void setNextStartNodeItem(SkeletonEditNodeItem *item); - bool canNodeItemMoveTo(SkeletonEditNodeItem *item, QPointF moveTo); - void AddItemRadius(QGraphicsEllipseItem *item, float delta); - bool canAddItemRadius(QGraphicsEllipseItem *item, float delta); - void adjustItems(QSizeF oldSceneSize, QSizeF newSceneSize); - void removeSelectedItems(); - void removeNodeItem(SkeletonEditNodeItem *nodeItem); - void removeNodeItemAndSidePairs(SkeletonEditNodeItem *nodeItem); - void fetchNodeItemAndAllSidePairs(SkeletonEditNodeItem *nodeItem, std::vector *sidePairs); - SkeletonEditNodeItem *addNodeItemAndSidePairs(QRectF area, SkeletonEditNodeItem *fromNodeItem, const QString &sideColorName="red"); - SkeletonEditNodeItem *addNodeItem(float originX, float originY, float radius); - void addEdgeItem(SkeletonEditNodeItem *first, SkeletonEditNodeItem *second); -}; - -#endif diff --git a/src/skeletoneditnodeitem.cpp b/src/skeletoneditnodeitem.cpp deleted file mode 100644 index b5b0e74f..00000000 --- a/src/skeletoneditnodeitem.cpp +++ /dev/null @@ -1,140 +0,0 @@ -#include -#include "skeletoneditnodeitem.h" -#include "theme.h" - -SkeletonEditNodeItem::SkeletonEditNodeItem(const QRectF &rect, QGraphicsItem *parent) : - QGraphicsEllipseItem(rect, parent), - m_hovered(false), - m_checked(false), - m_nextSidePair(NULL), - m_sideColor(Theme::red), - m_sideColorName("red"), - m_isBranch(false), - m_isRoot(false) -{ - setData(0, "node"); - updateAppearance(); -} - -void SkeletonEditNodeItem::markAsBranch(bool isBranch) -{ - m_isBranch = isBranch; - updateAppearance(); -} - -bool SkeletonEditNodeItem::isBranch() -{ - return m_isBranch; -} - -void SkeletonEditNodeItem::markAsRoot(bool isRoot) -{ - m_isRoot = isRoot; - updateAppearance(); -} - -bool SkeletonEditNodeItem::isRoot() -{ - return m_isRoot; -} - -const QString &SkeletonEditNodeItem::sideColorName() -{ - return m_sideColorName; -} - -QString SkeletonEditNodeItem::nextSideColorName() -{ - return Theme::nextSideColorNameMap[m_sideColorName]; -} - -void SkeletonEditNodeItem::setSideColorName(const QString &name) -{ - m_sideColorName = name; - m_sideColor = Theme::sideColorNameToColorMap[m_sideColorName]; - updateAppearance(); -} - -bool SkeletonEditNodeItem::hovered() -{ - return m_hovered; -} - -void SkeletonEditNodeItem::setHovered(bool hovered) -{ - m_hovered = hovered; - updateAppearance(); -} - -bool SkeletonEditNodeItem::checked() -{ - return m_checked; -} - -void SkeletonEditNodeItem::setChecked(bool checked) -{ - m_checked = checked; - updateAppearance(); -} - -SkeletonEditNodeItem *SkeletonEditNodeItem::nextSidePair() -{ - return m_nextSidePair; -} - -void SkeletonEditNodeItem::setNextSidePair(SkeletonEditNodeItem *nodeItem) -{ - m_nextSidePair = nodeItem; - updateAppearance(); -} - -const QColor &SkeletonEditNodeItem::sideColor() -{ - return m_sideColor; -} - -QPointF SkeletonEditNodeItem::origin() -{ - return QPointF(rect().x() + rect().width() / 2, - rect().y() + rect().height() / 2); -} - -float SkeletonEditNodeItem::radius() -{ - return rect().width() / 2; -} - -void SkeletonEditNodeItem::setRadius(float radius) -{ - QPointF oldOrigin = origin(); - setRect(oldOrigin.x() - radius, oldOrigin.y() - radius, - radius * 2, radius * 2); -} - -void SkeletonEditNodeItem::setOrigin(QPointF point) -{ - QPointF moveBy = point - origin(); - QRectF newRect = rect(); - newRect.adjust(moveBy.x(), moveBy.y(), moveBy.x(), moveBy.y()); - setRect(newRect); -} - -void SkeletonEditNodeItem::updateAppearance() -{ - QColor penColor = m_sideColor; - penColor.setAlphaF(m_checked ? Theme::checkedAlpha : (m_isBranch ? Theme::branchAlpha : Theme::normalAlpha)); - QPen pen(penColor); - pen.setWidth(m_isRoot ? (Theme::skeletonNodeBorderSize * 2) : Theme::skeletonNodeBorderSize); - setPen(pen); - - QColor brushColor = m_sideColor; - brushColor.setAlphaF((m_hovered || m_checked) ? Theme::fillAlpha : 0); - QBrush brush(brushColor); - setBrush(brush); -} - -QColor SkeletonEditNodeItem::nextSideColor() -{ - return Theme::sideColorNameToColorMap[Theme::nextSideColorNameMap[m_sideColorName]]; -} - diff --git a/src/skeletoneditnodeitem.h b/src/skeletoneditnodeitem.h deleted file mode 100644 index 7f97a168..00000000 --- a/src/skeletoneditnodeitem.h +++ /dev/null @@ -1,46 +0,0 @@ -#ifndef SKELETON_EDIT_NODE_ITEM_H -#define SKELETON_EDIT_NODE_ITEM_H -#include -#include -#include -#include - -class SkeletonEditEdgeItem; - -class SkeletonEditNodeItem : public QGraphicsEllipseItem -{ -public: - SkeletonEditNodeItem(const QRectF &rect, QGraphicsItem *parent = 0); - QPointF origin(); - void setOrigin(QPointF point); - float radius(); - void setRadius(float radius); - bool hovered(); - void setHovered(bool hovered); - bool checked(); - void setChecked(bool checked); - void markAsBranch(bool isBranch); - bool isBranch(); - void markAsRoot(bool isRoot); - bool isRoot(); - SkeletonEditNodeItem *nextSidePair(); - void setNextSidePair(SkeletonEditNodeItem *nodeItem); - const QColor &sideColor(); - QColor nextSideColor(); - const QString &sideColorName(); - QString nextSideColorName(); - void setSideColorName(const QString &name); -private: - bool m_hovered; - bool m_checked; - SkeletonEditNodeItem *m_nextSidePair; - QColor m_sideColor; - QString m_sideColorName; - bool m_isBranch; - bool m_isRoot; -private: - void updateAppearance(); -}; - -#endif - diff --git a/src/skeletongraphicswidget.cpp b/src/skeletongraphicswidget.cpp new file mode 100644 index 00000000..1a27dea0 --- /dev/null +++ b/src/skeletongraphicswidget.cpp @@ -0,0 +1,644 @@ +#include +#include +#include +#include +#include +#include +#include "skeletongraphicswidget.h" +#include "theme.h" +#include "util.h" + +SkeletonGraphicsWidget::SkeletonGraphicsWidget(const SkeletonDocument *document) : + m_document(document), + m_turnaroundChanged(false), + m_turnaroundLoader(nullptr), + m_dragStarted(false), + m_cursorNodeItem(nullptr), + m_cursorEdgeItem(nullptr), + m_checkedNodeItem(nullptr), + m_moveStarted(false), + m_hoveredNodeItem(nullptr), + m_hoveredEdgeItem(nullptr), + m_checkedEdgeItem(nullptr), + m_lastAddedX(0), + m_lastAddedY(0), + m_lastAddedZ(0) +{ + setRenderHint(QPainter::Antialiasing, false); + setBackgroundBrush(QBrush(QWidget::palette().color(QWidget::backgroundRole()), Qt::SolidPattern)); + setContentsMargins(0, 0, 0, 0); + setFrameStyle(QFrame::NoFrame); + + setAlignment(Qt::AlignCenter); + + setScene(new QGraphicsScene()); + + m_backgroundItem = new QGraphicsPixmapItem(); + m_backgroundItem->setOpacity(0.25); + scene()->addItem(m_backgroundItem); + + m_cursorNodeItem = new SkeletonGraphicsNodeItem(); + m_cursorNodeItem->hide(); + scene()->addItem(m_cursorNodeItem); + + m_cursorEdgeItem = new SkeletonGraphicsEdgeItem(); + m_cursorEdgeItem->hide(); + scene()->addItem(m_cursorEdgeItem); + + scene()->setSceneRect(rect()); + + setMouseTracking(true); +} + +void SkeletonGraphicsWidget::updateItems() +{ + for (auto nodeItemIt = nodeItemMap.begin(); nodeItemIt != nodeItemMap.end(); nodeItemIt++) { + nodeRadiusChanged(nodeItemIt->first); + nodeOriginChanged(nodeItemIt->first); + } +} + +void SkeletonGraphicsWidget::canvasResized() +{ + updateTurnaround(); +} + +void SkeletonGraphicsWidget::turnaroundChanged() +{ + updateTurnaround(); + setTransform(QTransform()); +} + +void SkeletonGraphicsWidget::updateTurnaround() +{ + if (m_document->turnaround.isNull()) + return; + + m_turnaroundChanged = true; + if (m_turnaroundLoader) + return; + + qDebug() << "Fit turnaround to view size:" << parentWidget()->rect().size(); + + m_turnaroundChanged = false; + + QThread *thread = new QThread; + m_turnaroundLoader = new TurnaroundLoader(m_document->turnaround, + parentWidget()->rect().size()); + m_turnaroundLoader->moveToThread(thread); + connect(thread, SIGNAL(started()), m_turnaroundLoader, SLOT(process())); + connect(m_turnaroundLoader, SIGNAL(finished()), this, SLOT(turnaroundImageReady())); + connect(m_turnaroundLoader, SIGNAL(finished()), thread, SLOT(quit())); + connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater())); + thread->start(); +} + +void SkeletonGraphicsWidget::turnaroundImageReady() +{ + QImage *backgroundImage = m_turnaroundLoader->takeResultImage(); + if (backgroundImage && backgroundImage->width() > 0 && backgroundImage->height() > 0) { + qDebug() << "Fit turnaround finished with image size:" << backgroundImage->size(); + setFixedSize(backgroundImage->size()); + scene()->setSceneRect(rect()); + m_backgroundItem->setPixmap(QPixmap::fromImage(*backgroundImage)); + updateItems(); + } else { + qDebug() << "Fit turnaround failed"; + } + delete backgroundImage; + delete m_turnaroundLoader; + m_turnaroundLoader = nullptr; + + if (m_turnaroundChanged) { + updateTurnaround(); + } +} + +void SkeletonGraphicsWidget::updateCursor() +{ + if (SkeletonDocumentEditMode::Add != m_document->editMode) { + m_cursorEdgeItem->hide(); + m_cursorNodeItem->hide(); + } + + switch (m_document->editMode) { + case SkeletonDocumentEditMode::Add: + setCursor(QCursor(Theme::awesome()->icon(fa::plus).pixmap(Theme::toolIconFontSize, Theme::toolIconFontSize))); + break; + case SkeletonDocumentEditMode::Select: + setCursor(QCursor(Theme::awesome()->icon(fa::mousepointer).pixmap(Theme::toolIconFontSize, Theme::toolIconFontSize))); + break; + case SkeletonDocumentEditMode::Drag: + setCursor(QCursor(Theme::awesome()->icon(m_dragStarted ? fa::handrocko : fa::handpapero).pixmap(Theme::toolIconFontSize, Theme::toolIconFontSize))); + break; + case SkeletonDocumentEditMode::ZoomIn: + setCursor(QCursor(Theme::awesome()->icon(fa::searchplus).pixmap(Theme::toolIconFontSize, Theme::toolIconFontSize))); + break; + case SkeletonDocumentEditMode::ZoomOut: + setCursor(QCursor(Theme::awesome()->icon(fa::searchminus).pixmap(Theme::toolIconFontSize, Theme::toolIconFontSize))); + break; + } + + emit cursorChanged(); +} + +void SkeletonGraphicsWidget::editModeChanged() +{ + if (m_checkedNodeItem) { + if (!m_checkedNodeItem->checked()) { + if (m_hoveredNodeItem == m_checkedNodeItem) { + m_checkedNodeItem->setHovered(false); + m_hoveredNodeItem = nullptr; + } + m_checkedNodeItem = nullptr; + } + } + updateCursor(); +} + +void SkeletonGraphicsWidget::mouseMoveEvent(QMouseEvent *event) +{ + QGraphicsView::mouseMoveEvent(event); + mouseMove(event); +} + +void SkeletonGraphicsWidget::wheelEvent(QWheelEvent *event) +{ + if (SkeletonDocumentEditMode::ZoomIn == m_document->editMode || + SkeletonDocumentEditMode::ZoomOut == m_document->editMode || + SkeletonDocumentEditMode::Drag == m_document->editMode) + QGraphicsView::wheelEvent(event); + wheel(event); +} + +void SkeletonGraphicsWidget::mouseReleaseEvent(QMouseEvent *event) +{ + QGraphicsView::mouseReleaseEvent(event); + mouseRelease(event); +} + +void SkeletonGraphicsWidget::mousePressEvent(QMouseEvent *event) +{ + QGraphicsView::mousePressEvent(event); + mousePress(event); +} + +void SkeletonGraphicsWidget::mouseDoubleClickEvent(QMouseEvent *event) +{ + QGraphicsView::mouseDoubleClickEvent(event); + mouseDoubleClick(event); +} + +void SkeletonGraphicsWidget::keyPressEvent(QKeyEvent *event) +{ + QGraphicsView::keyPressEvent(event); + keyPress(event); +} + +bool SkeletonGraphicsWidget::mouseMove(QMouseEvent *event) +{ + if (m_dragStarted) { + QPoint currentGlobalPos = event->globalPos(); + if (verticalScrollBar()) + verticalScrollBar()->setValue(verticalScrollBar()->value() + m_lastGlobalPos.y() - currentGlobalPos.y()); + if (horizontalScrollBar()) + horizontalScrollBar()->setValue(horizontalScrollBar()->value() + m_lastGlobalPos.x() - currentGlobalPos.x()); + m_lastGlobalPos = currentGlobalPos; + return true; + } + + if (SkeletonDocumentEditMode::Select == m_document->editMode || + SkeletonDocumentEditMode::Add == m_document->editMode) { + SkeletonGraphicsNodeItem *newHoverNodeItem = nullptr; + SkeletonGraphicsEdgeItem *newHoverEdgeItem = nullptr; + QList items = scene()->items(mouseEventScenePos(event)); + for (auto it = items.begin(); it != items.end(); it++) { + QGraphicsItem *item = *it; + if (item->data(0) == "node") { + newHoverNodeItem = (SkeletonGraphicsNodeItem *)item; + break; + } else if (item->data(0) == "edge") { + newHoverEdgeItem = (SkeletonGraphicsEdgeItem *)item; + } + } + if (newHoverNodeItem) { + newHoverEdgeItem = nullptr; + } + if (newHoverNodeItem != m_hoveredNodeItem) { + if (nullptr != m_hoveredNodeItem) { + m_hoveredNodeItem->setHovered(false); + } + m_hoveredNodeItem = newHoverNodeItem; + if (nullptr != m_hoveredNodeItem) { + m_hoveredNodeItem->setHovered(true); + } + } + if (newHoverEdgeItem != m_hoveredEdgeItem) { + if (nullptr != m_hoveredEdgeItem) { + m_hoveredEdgeItem->setHovered(false); + } + m_hoveredEdgeItem = newHoverEdgeItem; + if (nullptr != m_hoveredEdgeItem) { + m_hoveredEdgeItem->setHovered(true); + } + } + } + + if (SkeletonDocumentEditMode::Add == m_document->editMode) { + QPointF mouseScenePos = mouseEventScenePos(event); + m_cursorNodeItem->setOrigin(mouseScenePos); + if (!m_cursorNodeItem->isVisible()) { + m_cursorNodeItem->show(); + } + if (m_checkedNodeItem) { + m_cursorEdgeItem->setEndpoints(m_checkedNodeItem, m_cursorNodeItem); + if (!m_cursorEdgeItem->isVisible()) { + m_cursorEdgeItem->show(); + } + } + return true; + } + + if (SkeletonDocumentEditMode::Select == m_document->editMode) { + if (m_moveStarted && m_checkedNodeItem) { + QPointF mouseScenePos = mouseEventScenePos(event); + float byX = sceneRadiusToUnified(mouseScenePos.x() - m_lastScenePos.x()); + float byY = sceneRadiusToUnified(mouseScenePos.y() - m_lastScenePos.y()); + if (SkeletonProfile::Main == m_checkedNodeItem->profile()) { + emit moveNodeBy(m_checkedNodeItem->id(), byX, byY, 0); + } else { + emit moveNodeBy(m_checkedNodeItem->id(), 0, byY, byX); + } + m_lastScenePos = mouseScenePos; + return true; + } + } + + return false; +} + +bool SkeletonGraphicsWidget::wheel(QWheelEvent *event) +{ + qreal delta = event->delta() / 10; + if (QGuiApplication::queryKeyboardModifiers().testFlag(Qt::ShiftModifier)) { + if (delta > 0) + delta = 1; + else + delta = -1; + } else { + if (fabs(delta) < 1) + delta = delta < 0 ? -1.0 : 1.0; + } + if (SkeletonDocumentEditMode::Add == m_document->editMode) { + if (m_cursorNodeItem->isVisible()) { + m_cursorNodeItem->setRadius(m_cursorNodeItem->radius() + delta); + return true; + } + } else if (SkeletonDocumentEditMode::Select == m_document->editMode) { + if (m_hoveredNodeItem) { + emit scaleNodeByAddRadius(m_hoveredNodeItem->id(), sceneRadiusToUnified(delta)); + return true; + } else if (m_checkedNodeItem) { + emit scaleNodeByAddRadius(m_checkedNodeItem->id(), sceneRadiusToUnified(delta)); + return true; + } + } + return false; +} + +bool SkeletonGraphicsWidget::mouseRelease(QMouseEvent *event) +{ + if (event->button() == Qt::LeftButton) { + bool processed = m_dragStarted || m_moveStarted; + if (m_dragStarted) { + m_dragStarted = false; + updateCursor(); + } + if (m_moveStarted) { + m_moveStarted = false; + } + return processed; + } + return false; +} + +QPointF SkeletonGraphicsWidget::mouseEventScenePos(QMouseEvent *event) +{ + return mapToScene(mapFromGlobal(event->globalPos())); +} + +bool SkeletonGraphicsWidget::mousePress(QMouseEvent *event) +{ + if (event->button() == Qt::LeftButton) { + if (SkeletonDocumentEditMode::ZoomIn == m_document->editMode) { + ViewportAnchor lastAnchor = transformationAnchor(); + setTransformationAnchor(QGraphicsView::AnchorUnderMouse) ; + scale(1.5, 1.5); + setTransformationAnchor(lastAnchor); + return true; + } else if (SkeletonDocumentEditMode::ZoomOut == m_document->editMode) { + ViewportAnchor lastAnchor = transformationAnchor(); + setTransformationAnchor(QGraphicsView::AnchorUnderMouse) ; + scale(0.5, 0.5); + setTransformationAnchor(lastAnchor); + if ((!verticalScrollBar() || !verticalScrollBar()->isVisible()) && + (!horizontalScrollBar() || !horizontalScrollBar()->isVisible())) { + setTransform(QTransform()); + } + return true; + } else if (SkeletonDocumentEditMode::Drag == m_document->editMode) { + if (!m_dragStarted) { + m_lastGlobalPos = event->globalPos(); + m_dragStarted = true; + updateCursor(); + } + } else if (SkeletonDocumentEditMode::Add == m_document->editMode) { + if (m_cursorNodeItem->isVisible()) { + if (m_checkedNodeItem) { + if (m_hoveredNodeItem && m_checkedNodeItem && + m_hoveredNodeItem != m_checkedNodeItem && + m_hoveredNodeItem->profile() == m_checkedNodeItem->profile()) { + if (m_document->findEdgeByNodes(m_checkedNodeItem->id(), m_hoveredNodeItem->id())) + return true; + emit addEdge(m_checkedNodeItem->id(), m_hoveredNodeItem->id()); + return true; + } + } + QPointF mainProfile = m_cursorNodeItem->origin(); + QPointF sideProfile = mainProfile; + if (mainProfile.x() >= scene()->width() / 2) { + sideProfile.setX(mainProfile.x() - scene()->width() / 4); + } else { + sideProfile.setX(mainProfile.x() +scene()->width() / 4); + } + QPointF unifiedMainPos = scenePosToUnified(mainProfile); + QPointF unifiedSidePos = scenePosToUnified(sideProfile); + if (isFloatEqual(m_lastAddedX, unifiedMainPos.x()) && isFloatEqual(m_lastAddedY, unifiedMainPos.y()) && isFloatEqual(m_lastAddedZ, unifiedSidePos.x())) + return true; + m_lastAddedX = unifiedMainPos.x(); + m_lastAddedY = unifiedMainPos.y(); + m_lastAddedZ = unifiedSidePos.x(); + qDebug() << "Emit add node " << m_lastAddedX << m_lastAddedY << m_lastAddedZ; + emit addNode(unifiedMainPos.x(), unifiedMainPos.y(), unifiedSidePos.x(), sceneRadiusToUnified(m_cursorNodeItem->radius()), nullptr == m_checkedNodeItem ? QUuid() : m_checkedNodeItem->id()); + return true; + } + } else if (SkeletonDocumentEditMode::Select == m_document->editMode) { + bool processed = false; + if (m_hoveredNodeItem) { + if (m_checkedNodeItem != m_hoveredNodeItem) { + if (m_checkedNodeItem) { + emit uncheckNode(m_checkedNodeItem->id()); + m_checkedNodeItem->setChecked(false); + } + m_checkedNodeItem = m_hoveredNodeItem; + m_checkedNodeItem->setChecked(true); + emit checkNode(m_checkedNodeItem->id()); + } + m_moveStarted = true; + m_lastScenePos = mouseEventScenePos(event); + processed = true; + } else { + if (m_checkedNodeItem) { + m_checkedNodeItem->setChecked(false); + emit uncheckNode(m_checkedNodeItem->id()); + m_checkedNodeItem = nullptr; + processed = true; + } + } + if (m_hoveredEdgeItem) { + if (m_checkedEdgeItem != m_hoveredEdgeItem) { + if (m_checkedEdgeItem) { + emit uncheckEdge(m_checkedEdgeItem->id()); + m_checkedEdgeItem->setChecked(false); + } + m_checkedEdgeItem = m_hoveredEdgeItem; + m_checkedEdgeItem->setChecked(true); + emit checkEdge(m_checkedEdgeItem->id()); + } + } else { + if (m_checkedEdgeItem) { + m_checkedEdgeItem->setChecked(false); + emit uncheckEdge(m_checkedEdgeItem->id()); + m_checkedEdgeItem = nullptr; + processed = true; + } + } + if (processed) { + return true; + } + } + } + return false; +} + +float SkeletonGraphicsWidget::sceneRadiusToUnified(float radius) +{ + if (0 == scene()->height()) + return 0; + return radius / scene()->height(); +} + +float SkeletonGraphicsWidget::sceneRadiusFromUnified(float radius) +{ + return radius * scene()->height(); +} + +QPointF SkeletonGraphicsWidget::scenePosToUnified(QPointF pos) +{ + if (0 == scene()->height()) + return QPointF(0, 0); + return QPointF(pos.x() / scene()->height(), pos.y() / scene()->height()); +} + +QPointF SkeletonGraphicsWidget::scenePosFromUnified(QPointF pos) +{ + return QPointF(pos.x() * scene()->height(), pos.y() * scene()->height()); +} + +bool SkeletonGraphicsWidget::mouseDoubleClick(QMouseEvent *event) +{ + return false; +} + +bool SkeletonGraphicsWidget::keyPress(QKeyEvent *event) +{ + if (event->key() == Qt::Key_Delete || event->key() ==Qt::Key_Backspace) { + bool processed = false; + if (m_checkedNodeItem) { + emit removeNode(m_checkedNodeItem->id()); + processed = true; + } + if (m_checkedEdgeItem) { + emit removeEdge(m_checkedEdgeItem->id()); + processed = true; + } + if (processed) { + return true; + } + } else if (event->key() == Qt::Key_A) { + if (SkeletonDocumentEditMode::Add == m_document->editMode) { + emit setEditMode(SkeletonDocumentEditMode::Select); + } else { + emit setEditMode(SkeletonDocumentEditMode::Add); + } + return true; + } + return false; +} + +void SkeletonGraphicsWidget::nodeAdded(QUuid nodeId) +{ + const SkeletonNode *node = m_document->findNode(nodeId); + if (nullptr == node) { + qDebug() << "New node added but node id not exist:" << nodeId; + return; + } + SkeletonGraphicsNodeItem *mainProfileItem = new SkeletonGraphicsNodeItem(SkeletonProfile::Main); + SkeletonGraphicsNodeItem *sideProfileItem = new SkeletonGraphicsNodeItem(SkeletonProfile::Side); + mainProfileItem->setOrigin(scenePosFromUnified(QPointF(node->x, node->y))); + sideProfileItem->setOrigin(scenePosFromUnified(QPointF(node->z, node->y))); + mainProfileItem->setRadius(sceneRadiusFromUnified(node->radius)); + sideProfileItem->setRadius(sceneRadiusFromUnified(node->radius)); + mainProfileItem->setId(nodeId); + sideProfileItem->setId(nodeId); + scene()->addItem(mainProfileItem); + scene()->addItem(sideProfileItem); + nodeItemMap[nodeId] = std::make_pair(mainProfileItem, sideProfileItem); + + if (nullptr == m_checkedNodeItem) { + m_checkedNodeItem = mainProfileItem; + } else { + if (SkeletonProfile::Main == m_checkedNodeItem->profile()) { + m_checkedNodeItem = mainProfileItem; + } else { + m_checkedNodeItem = sideProfileItem; + } + m_cursorEdgeItem->setEndpoints(m_checkedNodeItem, m_cursorNodeItem); + } +} + +void SkeletonGraphicsWidget::edgeAdded(QUuid edgeId) +{ + const SkeletonEdge *edge = m_document->findEdge(edgeId); + if (nullptr == edge) { + qDebug() << "New edge added but edge id not exist:" << edgeId; + return; + } + if (edge->nodeIds.size() != 2) { + qDebug() << "Invalid node count of edge:" << edgeId; + return; + } + QUuid fromNodeId = edge->nodeIds[0]; + QUuid toNodeId = edge->nodeIds[1]; + auto fromIt = nodeItemMap.find(fromNodeId); + if (fromIt == nodeItemMap.end()) { + qDebug() << "Node not found:" << fromNodeId; + return; + } + auto toIt = nodeItemMap.find(toNodeId); + if (toIt == nodeItemMap.end()) { + qDebug() << "Node not found:" << toNodeId; + return; + } + SkeletonGraphicsEdgeItem *mainProfileEdgeItem = new SkeletonGraphicsEdgeItem(); + SkeletonGraphicsEdgeItem *sideProfileEdgeItem = new SkeletonGraphicsEdgeItem(); + mainProfileEdgeItem->setId(edgeId); + sideProfileEdgeItem->setId(edgeId); + mainProfileEdgeItem->setEndpoints(fromIt->second.first, toIt->second.first); + sideProfileEdgeItem->setEndpoints(fromIt->second.second, toIt->second.second); + scene()->addItem(mainProfileEdgeItem); + scene()->addItem(sideProfileEdgeItem); + edgeItemMap[edgeId] = std::make_pair(mainProfileEdgeItem, sideProfileEdgeItem); +} + +void SkeletonGraphicsWidget::nodeRemoved(QUuid nodeId) +{ + m_lastAddedX = 0; + m_lastAddedY = 0; + m_lastAddedZ = 0; + auto nodeItemIt = nodeItemMap.find(nodeId); + if (nodeItemIt == nodeItemMap.end()) { + qDebug() << "Node removed but node id not exist:" << nodeId; + return; + } + if (m_hoveredNodeItem == nodeItemIt->second.first) + m_hoveredNodeItem = nullptr; + if (m_hoveredNodeItem == nodeItemIt->second.second) + m_hoveredNodeItem = nullptr; + if (m_checkedNodeItem == nodeItemIt->second.first) + m_checkedNodeItem = nullptr; + if (m_checkedNodeItem == nodeItemIt->second.second) + m_checkedNodeItem = nullptr; + delete nodeItemIt->second.first; + delete nodeItemIt->second.second; + nodeItemMap.erase(nodeItemIt); +} + +void SkeletonGraphicsWidget::edgeRemoved(QUuid edgeId) +{ + auto edgeItemIt = edgeItemMap.find(edgeId); + if (edgeItemIt == edgeItemMap.end()) { + qDebug() << "Edge removed but edge id not exist:" << edgeId; + return; + } + if (m_hoveredEdgeItem == edgeItemIt->second.first) + m_hoveredEdgeItem = nullptr; + if (m_hoveredEdgeItem == edgeItemIt->second.second) + m_hoveredEdgeItem = nullptr; + if (m_checkedEdgeItem == edgeItemIt->second.first) + m_checkedEdgeItem = nullptr; + if (m_checkedEdgeItem == edgeItemIt->second.second) + m_checkedEdgeItem = nullptr; + delete edgeItemIt->second.first; + delete edgeItemIt->second.second; + edgeItemMap.erase(edgeItemIt); +} + +void SkeletonGraphicsWidget::nodeRadiusChanged(QUuid nodeId) +{ + const SkeletonNode *node = m_document->findNode(nodeId); + if (nullptr == node) { + qDebug() << "Node changed but node id not exist:" << nodeId; + return; + } + auto it = nodeItemMap.find(nodeId); + if (it == nodeItemMap.end()) { + qDebug() << "Node not found:" << nodeId; + return; + } + float sceneRadius = sceneRadiusFromUnified(node->radius); + it->second.first->setRadius(sceneRadius); + it->second.second->setRadius(sceneRadius); +} + +void SkeletonGraphicsWidget::nodeOriginChanged(QUuid nodeId) +{ + const SkeletonNode *node = m_document->findNode(nodeId); + if (nullptr == node) { + qDebug() << "Node changed but node id not exist:" << nodeId; + return; + } + auto it = nodeItemMap.find(nodeId); + if (it == nodeItemMap.end()) { + qDebug() << "Node not found:" << nodeId; + return; + } + QPointF mainPos = scenePosFromUnified(QPointF(node->x, node->y)); + QPointF sidePos = scenePosFromUnified(QPointF(node->z, node->y)); + it->second.first->setOrigin(mainPos); + it->second.second->setOrigin(sidePos); + for (auto edgeIt = node->edgeIds.begin(); edgeIt != node->edgeIds.end(); edgeIt++) { + auto edgeItemIt = edgeItemMap.find(*edgeIt); + if (edgeItemIt == edgeItemMap.end()) { + qDebug() << "Edge item not found:" << *edgeIt; + continue; + } + edgeItemIt->second.first->updateAppearance(); + edgeItemIt->second.second->updateAppearance(); + } +} + +void SkeletonGraphicsWidget::edgeChanged(QUuid edgeId) +{ +} + diff --git a/src/skeletongraphicswidget.h b/src/skeletongraphicswidget.h new file mode 100644 index 00000000..62c2e99b --- /dev/null +++ b/src/skeletongraphicswidget.h @@ -0,0 +1,320 @@ +#ifndef SKELETON_GRAPHICS_VIEW_H +#define SKELETON_GRAPHICS_VIEW_H +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "skeletondocument.h" +#include "turnaroundloader.h" +#include "theme.h" + +class SkeletonGraphicsNodeItem : public QGraphicsEllipseItem +{ +public: + SkeletonGraphicsNodeItem(SkeletonProfile profile=SkeletonProfile::Unknown) : + m_profile(profile), + m_hovered(false), + m_checked(false) + { + setData(0, "node"); + setRadius(32); + } + + void updateAppearance() + { + QColor color = Theme::white; + + switch (m_profile) + { + case SkeletonProfile::Unknown: + break; + case SkeletonProfile::Main: + color = Theme::red; + break; + case SkeletonProfile::Side: + color = Theme::green; + break; + } + + QColor penColor = color; + penColor.setAlphaF(m_checked ? Theme::checkedAlpha : Theme::normalAlpha); + QPen pen(penColor); + pen.setWidth(0); + setPen(pen); + + QColor brushColor = color; + brushColor.setAlphaF((m_checked || m_hovered) ? Theme::fillAlpha : 0); + QBrush brush(brushColor); + setBrush(brush); + } + + void setOrigin(QPointF point) + { + QPointF moveBy = point - origin(); + QRectF newRect = rect(); + newRect.adjust(moveBy.x(), moveBy.y(), moveBy.x(), moveBy.y()); + setRect(newRect); + updateAppearance(); + } + + QPointF origin() + { + return QPointF(rect().x() + rect().width() / 2, + rect().y() + rect().height() / 2); + } + + float radius() + { + return rect().width() / 2; + } + + void setRadius(float radius) + { + if (radius < 4) + radius = 4; + QPointF oldOrigin = origin(); + setRect(oldOrigin.x() - radius, oldOrigin.y() - radius, + radius * 2, radius * 2); + updateAppearance(); + } + + SkeletonProfile profile() + { + return m_profile; + } + + QUuid id() + { + return m_uuid; + } + + void setId(QUuid id) + { + m_uuid = id; + } + + void setHovered(bool hovered) + { + m_hovered = hovered; + updateAppearance(); + } + + void setChecked(bool checked) + { + m_checked = checked; + updateAppearance(); + } + + bool checked() + { + return m_checked; + } +private: + QUuid m_uuid; + SkeletonProfile m_profile; + bool m_hovered; + bool m_checked; +}; + +class SkeletonGraphicsEdgeItem : public QGraphicsPolygonItem +{ +public: + SkeletonGraphicsEdgeItem() : + m_firstItem(nullptr), + m_secondItem(nullptr), + m_hovered(false), + m_checked(false) + { + setData(0, "edge"); + } + + void setEndpoints(SkeletonGraphicsNodeItem *first, SkeletonGraphicsNodeItem *second) + { + m_firstItem = first; + m_secondItem = second; + updateAppearance(); + } + + void updateAppearance() + { + if (nullptr == m_firstItem || nullptr == m_secondItem) + return; + + QLineF line(m_firstItem->origin(), m_secondItem->origin()); + + QPolygonF polygon; + float radAngle = line.angle() * M_PI / 180; + float dx = 5 * sin(radAngle); + float dy = 5 * cos(radAngle); + QPointF offset1 = QPointF(dx, dy); + QPointF offset2 = QPointF(-dx, -dy); + polygon << line.p1() + offset1 << line.p1() + offset2 << line.p2() + offset2 << line.p2() + offset1; + setPolygon(polygon); + + QColor color = Theme::white; + + switch (m_firstItem->profile()) + { + case SkeletonProfile::Unknown: + break; + case SkeletonProfile::Main: + color = Theme::red; + break; + case SkeletonProfile::Side: + color = Theme::green; + break; + } + + QColor penColor = color; + penColor.setAlphaF((m_checked || m_hovered) ? Theme::checkedAlpha : Theme::normalAlpha); + QPen pen(penColor); + pen.setWidth(0); + setPen(pen); + } + + QUuid id() + { + return m_uuid; + } + + void setId(QUuid id) + { + m_uuid = id; + } + + void setHovered(bool hovered) + { + m_hovered = hovered; + updateAppearance(); + } + + void setChecked(bool checked) + { + m_checked = checked; + updateAppearance(); + } + +private: + QUuid m_uuid; + SkeletonGraphicsNodeItem *m_firstItem; + SkeletonGraphicsNodeItem *m_secondItem; + QPolygonF m_selectionPolygon; + bool m_hovered; + bool m_checked; +}; + +class SkeletonGraphicsFunctions +{ +public: + virtual bool mouseMove(QMouseEvent *event) = 0; + virtual bool wheel(QWheelEvent *event) = 0; + virtual bool mouseRelease(QMouseEvent *event) = 0; + virtual bool mousePress(QMouseEvent *event) = 0; + virtual bool mouseDoubleClick(QMouseEvent *event) = 0; + virtual bool keyPress(QKeyEvent *event) = 0; +}; + +class SkeletonGraphicsWidget : public QGraphicsView, public SkeletonGraphicsFunctions +{ + Q_OBJECT +signals: + void addNode(float x, float y, float z, float radius, QUuid fromNodeId); + void uncheckNode(QUuid nodeId); + void checkNode(QUuid nodeId); + void uncheckEdge(QUuid edgeId); + void checkEdge(QUuid edgeId); + void scaleNodeByAddRadius(QUuid nodeId, float amount); + void moveNodeBy(QUuid nodeId, float x, float y, float z); + void removeNode(QUuid nodeId); + void setEditMode(SkeletonDocumentEditMode mode); + void removeEdge(QUuid edgeId); + void addEdge(QUuid fromNodeId, QUuid toNodeId); + void cursorChanged(); +public: + SkeletonGraphicsWidget(const SkeletonDocument *document); + std::map> nodeItemMap; + std::map> edgeItemMap; + bool mouseMove(QMouseEvent *event); + bool wheel(QWheelEvent *event); + bool mouseRelease(QMouseEvent *event); + bool mousePress(QMouseEvent *event); + bool mouseDoubleClick(QMouseEvent *event); + bool keyPress(QKeyEvent *event); +protected: + void mouseMoveEvent(QMouseEvent *event); + void wheelEvent(QWheelEvent *event); + void mouseReleaseEvent(QMouseEvent *event); + void mousePressEvent(QMouseEvent *event); + void mouseDoubleClickEvent(QMouseEvent *event); + void keyPressEvent(QKeyEvent *event); +public slots: + void nodeAdded(QUuid nodeId); + void edgeAdded(QUuid edgeId); + void nodeRemoved(QUuid nodeId); + void edgeRemoved(QUuid edgeId); + void nodeRadiusChanged(QUuid nodeId); + void nodeOriginChanged(QUuid nodeId); + void edgeChanged(QUuid edgeId); + void turnaroundChanged(); + void canvasResized(); + void editModeChanged(); + void updateCursor(); +private slots: + void turnaroundImageReady(); +private: + QPointF mouseEventScenePos(QMouseEvent *event); + QPointF scenePosToUnified(QPointF pos); + QPointF scenePosFromUnified(QPointF pos); + float sceneRadiusToUnified(float radius); + float sceneRadiusFromUnified(float radius); + void updateTurnaround(); + void updateItems(); +private: + QGraphicsPixmapItem *m_backgroundItem; + const SkeletonDocument *m_document; + bool m_turnaroundChanged; + TurnaroundLoader *m_turnaroundLoader; + bool m_dragStarted; + QPoint m_lastGlobalPos; + bool m_moveStarted; + QPointF m_lastScenePos; + SkeletonGraphicsNodeItem *m_cursorNodeItem; + SkeletonGraphicsEdgeItem *m_cursorEdgeItem; + SkeletonGraphicsNodeItem *m_checkedNodeItem; + SkeletonGraphicsNodeItem *m_hoveredNodeItem; + SkeletonGraphicsEdgeItem *m_hoveredEdgeItem; + SkeletonGraphicsEdgeItem *m_checkedEdgeItem; + float m_lastAddedX; + float m_lastAddedY; + float m_lastAddedZ; +}; + +class SkeletonGraphicsContainerWidget : public QWidget +{ + Q_OBJECT +signals: + void containerSizeChanged(QSize size); +public: + SkeletonGraphicsContainerWidget() : + m_graphicsWidget(nullptr) + { + } + void resizeEvent(QResizeEvent *event) override + { + if (m_graphicsWidget && m_graphicsWidget->size() != event->size()) + emit containerSizeChanged(event->size()); + } + void setGraphicsWidget(SkeletonGraphicsWidget *graphicsWidget) + { + m_graphicsWidget = graphicsWidget; + } +private: + SkeletonGraphicsWidget *m_graphicsWidget; +}; + +#endif diff --git a/src/skeletonhistorylistwidget.cpp b/src/skeletonhistorylistwidget.cpp new file mode 100644 index 00000000..e69de29b diff --git a/src/skeletonhistorylistwidget.h b/src/skeletonhistorylistwidget.h new file mode 100644 index 00000000..e69de29b diff --git a/src/skeletonnodepropertywidget.cpp b/src/skeletonnodepropertywidget.cpp new file mode 100644 index 00000000..88a88101 --- /dev/null +++ b/src/skeletonnodepropertywidget.cpp @@ -0,0 +1,50 @@ +#include +#include "skeletonnodepropertywidget.h" + +SkeletonNodePropertyWidget::SkeletonNodePropertyWidget(const SkeletonDocument *document) : + m_rootMarkModeComboBox(nullptr), + m_document(document) +{ + m_rootMarkModeComboBox = new QComboBox; + + m_rootMarkModeComboBox->insertItem(0, tr("Auto"), (int)SkeletonNodeRootMarkMode::Auto); + m_rootMarkModeComboBox->insertItem(1, tr("Mark as Root"), (int)SkeletonNodeRootMarkMode::MarkAsRoot); + m_rootMarkModeComboBox->insertItem(2, tr("Mark as Not Root"), (int)SkeletonNodeRootMarkMode::MarkAsNotRoot); + + QFormLayout *formLayout = new QFormLayout; + formLayout->addRow(tr("Root Mark:"), m_rootMarkModeComboBox); + + setLayout(formLayout); + + hide(); + + connect(m_rootMarkModeComboBox, static_cast(&QComboBox::currentIndexChanged), [=](int index) { + if (-1 != index) { + int mode = m_rootMarkModeComboBox->itemData(index).toInt(); + emit setNodeRootMarkMode(m_nodeId, static_cast(mode)); + } + }); +} + +void SkeletonNodePropertyWidget::showProperties(QUuid nodeId) +{ + m_nodeId = nodeId; + updateData(); + show(); +} + +void SkeletonNodePropertyWidget::updateData() +{ + const SkeletonNode *node = m_document->findNode(m_nodeId); + if (nullptr == node) { + hide(); + return; + } + int selectIndex = m_rootMarkModeComboBox->findData((int)node->rootMarkMode); + m_rootMarkModeComboBox->setCurrentIndex(selectIndex); +} + +QUuid SkeletonNodePropertyWidget::currentNodeId() +{ + return m_nodeId; +} diff --git a/src/skeletonnodepropertywidget.h b/src/skeletonnodepropertywidget.h new file mode 100644 index 00000000..6f3dcd95 --- /dev/null +++ b/src/skeletonnodepropertywidget.h @@ -0,0 +1,26 @@ +#ifndef SKELETON_NODE_PROPERTY_WIDGET_H +#define SKELETON_NODE_PROPERTY_WIDGET_H +#include +#include +#include +#include "skeletondocument.h" + +class SkeletonNodePropertyWidget : public QWidget +{ + Q_OBJECT +signals: + void setNodeRootMarkMode(QUuid nodeId, SkeletonNodeRootMarkMode mode); +public slots: + void showProperties(QUuid nodeId); +public: + SkeletonNodePropertyWidget(const SkeletonDocument *document); + QUuid currentNodeId(); +private: + void updateData(); +private: + QComboBox *m_rootMarkModeComboBox; + const SkeletonDocument *m_document; + QUuid m_nodeId; +}; + +#endif diff --git a/src/skeletonpartlistwidget.cpp b/src/skeletonpartlistwidget.cpp new file mode 100644 index 00000000..f6c5a82f --- /dev/null +++ b/src/skeletonpartlistwidget.cpp @@ -0,0 +1,89 @@ +#include +#include +#include "skeletonpartlistwidget.h" +#include "theme.h" + +SkeletonPartWidget::SkeletonPartWidget(const SkeletonDocument *document, QUuid partId) : + m_document(document), + m_partId(partId) +{ + m_visibleButton = new QPushButton(QChar(fa::eye)); + //m_visibleButton->setStyleSheet("QPushButton {border: none; background: none;}"); + m_visibleButton->setFont(Theme::awesome()->font(Theme::toolIconFontSize * 2 / 3)); + m_visibleButton->setFixedSize(Theme::toolIconSize * 2 / 3, Theme::toolIconSize * 2 / 3); + + m_previewLabel = new QLabel; + + //m_nameLabel = new QLabel; + + QGridLayout *mainLayout = new QGridLayout; + mainLayout->addWidget(m_visibleButton, 0, 0); + mainLayout->addWidget(m_previewLabel, 0, 1); + //mainLayout->addWidget(m_nameLabel, 0, 2); + + setLayout(mainLayout); +} + +QLabel *SkeletonPartWidget::previewLabel() +{ + return m_previewLabel; +} + +void SkeletonPartWidget::reload() +{ + const SkeletonPart *part = m_document->findPart(m_partId); + if (!part) { + qDebug() << "Part not found:" << m_partId; + return; + } + //m_nameLabel->setText(part->name.isEmpty() ? part->id.toString() : part->name); + m_previewLabel->setPixmap(QPixmap::fromImage(part->preview)); +} + +SkeletonPartListWidget::SkeletonPartListWidget(const SkeletonDocument *document) : + m_document(document) +{ + setSelectionMode(QAbstractItemView::NoSelection); + setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); +} + +void SkeletonPartListWidget::partChanged(QUuid partId) +{ + auto itemIt = m_itemMap.find(partId); + if (itemIt == m_itemMap.end()) { + return; + } +} + +void SkeletonPartListWidget::partListChanged() +{ + clear(); + m_itemMap.clear(); + + for (auto partIdIt = m_document->partIds.begin(); partIdIt != m_document->partIds.end(); partIdIt++) { + QUuid partId = *partIdIt; + QListWidgetItem *item = new QListWidgetItem(this); + item->setSizeHint(QSize(width(), Theme::previewImageSize)); + addItem(item); + SkeletonPartWidget *widget = new SkeletonPartWidget(m_document, partId); + setItemWidget(item, widget); + widget->reload(); + m_itemMap[partId] = item; + } +} + +void SkeletonPartListWidget::partPreviewChanged(QUuid partid) +{ + const SkeletonPart *part = m_document->findPart(partid); + if (!part) { + qDebug() << "Part not found:" << partid; + return; + } + auto item = m_itemMap.find(partid); + if (item == m_itemMap.end()) { + qDebug() << "Part item not found:" << partid; + return; + } + SkeletonPartWidget *widget = (SkeletonPartWidget *)itemWidget(item->second); + widget->previewLabel()->setPixmap(QPixmap::fromImage(part->preview)); +} diff --git a/src/skeletonpartlistwidget.h b/src/skeletonpartlistwidget.h new file mode 100644 index 00000000..385d40d4 --- /dev/null +++ b/src/skeletonpartlistwidget.h @@ -0,0 +1,38 @@ +#ifndef SKELETON_PART_LIST_WIDGET_H +#define SKELETON_PART_LIST_WIDGET_H +#include +#include +#include +#include +#include "skeletondocument.h" + +class SkeletonPartWidget : public QWidget +{ + Q_OBJECT +public: + SkeletonPartWidget(const SkeletonDocument *document, QUuid partId); + void reload(); + QLabel *previewLabel(); +private: + const SkeletonDocument *m_document; + QUuid m_partId; + QLabel *m_previewLabel; + QPushButton *m_visibleButton; + QLabel *m_nameLabel; +}; + +class SkeletonPartListWidget : public QListWidget +{ + Q_OBJECT +public: + SkeletonPartListWidget(const SkeletonDocument *document); +public slots: + void partChanged(QUuid partId); + void partListChanged(); + void partPreviewChanged(QUuid partid); +private: + const SkeletonDocument *m_document; + std::map m_itemMap; +}; + +#endif diff --git a/src/skeletonsnapshot.h b/src/skeletonsnapshot.h index e8a33971..b94974dc 100644 --- a/src/skeletonsnapshot.h +++ b/src/skeletonsnapshot.h @@ -12,6 +12,8 @@ public: std::map canvas; std::map> nodes; std::map> edges; + std::map> parts; + std::vector partIdList; public: SkeletonSnapshot(); void splitByConnectivity(std::vector *groups); diff --git a/src/skeletontomesh.cpp b/src/skeletontomesh.cpp deleted file mode 100644 index f8ae1567..00000000 --- a/src/skeletontomesh.cpp +++ /dev/null @@ -1,135 +0,0 @@ -#include "skeletontomesh.h" -#include "meshlite.h" -#include "skeletoneditnodeitem.h" -#include "skeletoneditedgeitem.h" -#include "skeletonsnapshot.h" -#include "unionmesh.h" -#include - -struct NodeItemInfo -{ - int index; - int neighborCount; -}; - -SkeletonToMesh::SkeletonToMesh(SkeletonSnapshot *snapshot) : - m_mesh(NULL), - m_snapshot(*snapshot) -{ -} - -SkeletonToMesh::~SkeletonToMesh() -{ - delete m_mesh; -} - -Mesh *SkeletonToMesh::takeResultMesh() -{ - Mesh *mesh = m_mesh; - m_mesh = NULL; - return mesh; -} - -#if USE_CARVE == 1 -#define ExternalMesh carve::poly::Polyhedron -#define makeExternalMeshFromMeshlite makeCarveMeshFromMeshlite -#define unionExternalMeshs unionCarveMeshs -#define makeMeshliteMeshFromExternal makeMeshliteMeshFromCarve -#endif - -#if USE_CGAL == 1 -#define ExternalMesh CgalMesh -#define makeExternalMeshFromMeshlite makeCgalMeshFromMeshlite -#define unionExternalMeshs unionCgalMeshs -#define makeMeshliteMeshFromExternal makeMeshliteMeshFromCgal -#endif - -void SkeletonToMesh::process() -{ - std::vector groups; - QRectF globalFront = m_snapshot.boundingBoxFront(); - QRectF globalSide = m_snapshot.boundingBoxSide(); - QString rootNodeId = m_snapshot.rootNode(); - printf("rootNodeId:%s\n", rootNodeId.toUtf8().constData()); - float frontMiddleX = m_snapshot.nodes[rootNodeId]["x"].toFloat(); - float frontMiddleY = m_snapshot.nodes[rootNodeId]["y"].toFloat(); - float sideMiddleX = m_snapshot.nodes[m_snapshot.nodes[rootNodeId]["nextSidePair"]]["x"].toFloat(); - bool combineEnabled = "true" == m_snapshot.canvas["combine"]; - bool unionEnabled = "true" == m_snapshot.canvas["union"]; - bool subdivEnabled = "true" == m_snapshot.canvas["subdiv"]; - m_snapshot.splitByConnectivity(&groups); - - std::vector meshIds; - void *meshliteContext = meshlite_create_context(); - for (size_t i = 0; i < groups.size(); i++) { - SkeletonSnapshot *skeleton = &groups[i]; - //QRectF front = skeleton->boundingBoxFront(); - //QRectF side = skeleton->boundingBoxSide(); - //float canvasWidth = skeleton->canvas["width"].toFloat(); - //float canvasHeight = skeleton->canvas["height"].toFloat(); - float canvasHeight = globalFront.height(); - - std::map bmeshNodeMap; - - std::map>::iterator nodeIterator; - int bmeshId = meshlite_bmesh_create(meshliteContext); - for (nodeIterator = skeleton->nodes.begin(); nodeIterator != skeleton->nodes.end(); nodeIterator++) { - if ("red" != nodeIterator->second["sideColorName"]) - continue; - std::map>::iterator nextSidePair = skeleton->nodes.find(nodeIterator->second["nextSidePair"]); - if (nextSidePair == skeleton->nodes.end()) - continue; - float x = (nodeIterator->second["x"].toFloat() - frontMiddleX) / canvasHeight; - float y = (nodeIterator->second["y"].toFloat() - frontMiddleY) / canvasHeight; - float z = (nextSidePair->second["x"].toFloat() - sideMiddleX) / canvasHeight; - float r = nodeIterator->second["radius"].toFloat() / canvasHeight; - int bmeshNodeId = meshlite_bmesh_add_node(meshliteContext, bmeshId, x, y, z, r); - printf("meshlite_bmesh_add_node x:%f y:%f z:%f r:%f nodeName:%s bmeshNodeId:%d\n", x, y, z, r, nodeIterator->first.toUtf8().constData(), bmeshNodeId); - bmeshNodeMap[nodeIterator->first] = bmeshNodeId; - } - - std::map>::iterator edgeIterator; - for (edgeIterator = skeleton->edges.begin(); edgeIterator != skeleton->edges.end(); edgeIterator++) { - std::map::iterator from = bmeshNodeMap.find(edgeIterator->second["from"]); - if (from == bmeshNodeMap.end()) - continue; - std::map::iterator to = bmeshNodeMap.find(edgeIterator->second["to"]); - if (to == bmeshNodeMap.end()) - continue; - printf("meshlite_bmesh_add_edge %d -> %d\n", from->second, to->second); - meshlite_bmesh_add_edge(meshliteContext, bmeshId, from->second, to->second); - } - - if (bmeshNodeMap.size() > 0 && !skeleton->rootNode().isEmpty()) { - int meshId = meshlite_bmesh_generate_mesh(meshliteContext, bmeshId, bmeshNodeMap[skeleton->rootNode()]); - meshIds.push_back(meshId); - } - - meshlite_bmesh_destroy(meshliteContext, bmeshId); - } - - if (meshIds.size() > 0) { - int mergedMeshId = 0; - if (unionEnabled) { - mergedMeshId = unionMeshs(meshliteContext, meshIds); - } else { - mergedMeshId = mergeMeshs(meshliteContext, meshIds); - } - if (combineEnabled) { - if (mergedMeshId > 0) { - mergedMeshId = meshlite_combine_coplanar_faces(meshliteContext, mergedMeshId); - } - } - if (subdivEnabled) { - if (mergedMeshId > 0 && meshlite_is_triangulated_manifold(meshliteContext, mergedMeshId)) { - mergedMeshId = meshlite_subdivide(meshliteContext, mergedMeshId); - } - } - if (mergedMeshId > 0) { - m_mesh = new Mesh(meshliteContext, mergedMeshId); - } - } - - meshlite_destroy_context(meshliteContext); - emit finished(); -} diff --git a/src/skeletontomesh.h b/src/skeletontomesh.h deleted file mode 100644 index 721e5b1a..00000000 --- a/src/skeletontomesh.h +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef SKELETON_TO_MESH_H -#define SKELETON_TO_MESH_H -#include -#include -#include -#include -#include "skeletoneditgraphicsview.h" -#include "mesh.h" -#include "skeletonsnapshot.h" - -class SkeletonToMesh : public QObject -{ - Q_OBJECT -public: - SkeletonToMesh(SkeletonSnapshot *snapshot); - ~SkeletonToMesh(); - Mesh *takeResultMesh(); -signals: - void finished(); -public slots: - void process(); -private: - Mesh *m_mesh; - SkeletonSnapshot m_snapshot; -}; - -#endif diff --git a/src/skeletonwidget.cpp b/src/skeletonwidget.cpp deleted file mode 100644 index 9dd9bc3e..00000000 --- a/src/skeletonwidget.cpp +++ /dev/null @@ -1,214 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "skeletonwidget.h" -#include "meshlite.h" -#include "skeletontomesh.h" -#include "turnaroundloader.h" - -SkeletonWidget::SkeletonWidget(QWidget *parent) : - QWidget(parent), - m_skeletonToMesh(NULL), - m_skeletonDirty(false), - m_turnaroundLoader(NULL), - m_turnaroundDirty(false) -{ - QHBoxLayout *topLayout = new QHBoxLayout; - topLayout->addStretch(); - topLayout->setContentsMargins(0, 0, 0, 0); - - m_graphicsView = new SkeletonEditGraphicsView(this); - m_graphicsView->setRenderHint(QPainter::Antialiasing, false); - m_graphicsView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); - m_graphicsView->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); - m_graphicsView->setBackgroundBrush(QBrush(QWidget::palette().color(QWidget::backgroundRole()), Qt::SolidPattern)); - m_graphicsView->setContentsMargins(0, 0, 0, 0); - m_graphicsView->setFrameStyle(QFrame::NoFrame); - - /* - m_modelWidget = new ModelWidget(this); - m_modelWidget->setMinimumSize(128, 128); - m_modelWidget->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum); - m_modelWidget->setWindowFlags(Qt::Tool | Qt::Window); - m_modelWidget->setWindowTitle("3D Model"); - */ - - QVBoxLayout *rightLayout = new QVBoxLayout; - rightLayout->addSpacing(0); - rightLayout->addStretch(); - rightLayout->setContentsMargins(0, 0, 0, 0); - - QToolBar *toolbar = new QToolBar; - toolbar->setIconSize(QSize(18, 18)); - toolbar->setOrientation(Qt::Vertical); - - QAction *addAction = new QAction(tr("Add"), this); - addAction->setIcon(QPixmap(":/resources/add.svg")); - toolbar->addAction(addAction); - - QAction *selectAction = new QAction(tr("Select"), this); - selectAction->setIcon(QPixmap(":/resources/rotate.svg")); - toolbar->addAction(selectAction); - - QAction *rangeSelectAction = new QAction(tr("Range Select"), this); - rangeSelectAction->setIcon(QPixmap(":/resources/zoomin.svg")); - toolbar->addAction(rangeSelectAction); - - toolbar->setContentsMargins(0, 0, 0, 0); - - QVBoxLayout *leftLayout = new QVBoxLayout; - leftLayout->addWidget(toolbar); - leftLayout->addStretch(); - leftLayout->addSpacing(0); - leftLayout->setContentsMargins(0, 0, 0, 0); - - QHBoxLayout *middleLayout = new QHBoxLayout; - //middleLayout->addLayout(leftLayout); - middleLayout->addWidget(m_graphicsView); - //middleLayout->addLayout(rightLayout); - middleLayout->setContentsMargins(0, 0, 0, 0); - - QVBoxLayout *mainLayout = new QVBoxLayout; - //mainLayout->addLayout(topLayout); - //mainLayout->addSpacing(10); - mainLayout->addLayout(middleLayout); - mainLayout->setContentsMargins(0, 0, 0, 0); - - setLayout(mainLayout); - setContentsMargins(0, 0, 0, 0); - - setWindowTitle(tr("Dust 3D")); - - bool connectResult; - - connectResult = connect(addAction, SIGNAL(triggered(bool)), m_graphicsView, SLOT(turnOnAddNodeMode())); - assert(connectResult); - - connectResult = connectResult = connect(selectAction, SIGNAL(triggered(bool)), m_graphicsView, SLOT(turnOffAddNodeMode())); - assert(connectResult); - - connectResult = connect(m_graphicsView, SIGNAL(nodesChanged()), this, SLOT(skeletonChanged())); - assert(connectResult); - - connectResult = connect(m_graphicsView, SIGNAL(sizeChanged()), this, SLOT(turnaroundChanged())); - assert(connectResult); - - connectResult = connect(m_graphicsView, SIGNAL(changeTurnaroundTriggered()), this, SLOT(changeTurnaround())); - assert(connectResult); - - //connectResult = connect(clipButton, SIGNAL(clicked()), this, SLOT(saveClip())); - //assert(connectResult); -} - -SkeletonEditGraphicsView *SkeletonWidget::graphicsView() -{ - return m_graphicsView; -} - -ModelWidget *SkeletonWidget::modelWidget() -{ - //return m_modelWidget; - return graphicsView()->modelWidget(); -} - -void SkeletonWidget::showModelingWidgetAtCorner() -{ - /* - if (!m_modelWidget->isVisible()) { - QPoint pos = QPoint(QApplication::desktop()->width(), - QApplication::desktop()->height()); - m_modelWidget->move(pos.x() - m_modelWidget->width(), - pos.y() - m_modelWidget->height()); - m_modelWidget->show(); - }*/ -} - -void SkeletonWidget::meshReady() -{ - Mesh *resultMesh = m_skeletonToMesh->takeResultMesh(); - //showModelingWidgetAtCorner(); - //m_modelWidget->updateMesh(resultMesh); - modelWidget()->updateMesh(resultMesh); - delete m_skeletonToMesh; - m_skeletonToMesh = NULL; - if (m_skeletonDirty) { - skeletonChanged(); - } -} - -void SkeletonWidget::skeletonChanged() -{ - if (m_skeletonToMesh) { - m_skeletonDirty = true; - return; - } - - m_skeletonDirty = false; - - QThread *thread = new QThread; - SkeletonSnapshot snapshot; - m_graphicsView->saveToSnapshot(&snapshot); - m_skeletonToMesh = new SkeletonToMesh(&snapshot); - m_skeletonToMesh->moveToThread(thread); - connect(thread, SIGNAL(started()), m_skeletonToMesh, SLOT(process())); - connect(m_skeletonToMesh, SIGNAL(finished()), this, SLOT(meshReady())); - connect(m_skeletonToMesh, SIGNAL(finished()), thread, SLOT(quit())); - connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater())); - thread->start(); -} - -void SkeletonWidget::turnaroundChanged() -{ - if (m_turnaroundFilename.isEmpty()) - return; - - if (m_turnaroundLoader) { - m_turnaroundDirty = true; - return; - } - - m_turnaroundDirty = false; - - QThread *thread = new QThread; - m_turnaroundLoader = new TurnaroundLoader(m_turnaroundFilename, - m_graphicsView->rect().size()); - m_turnaroundLoader->moveToThread(thread); - connect(thread, SIGNAL(started()), m_turnaroundLoader, SLOT(process())); - connect(m_turnaroundLoader, SIGNAL(finished()), this, SLOT(turnaroundImageReady())); - connect(m_turnaroundLoader, SIGNAL(finished()), thread, SLOT(quit())); - connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater())); - thread->start(); -} - -void SkeletonWidget::turnaroundImageReady() -{ - QImage *backgroundImage = m_turnaroundLoader->takeResultImage(); - if (backgroundImage && backgroundImage->width() > 0 && backgroundImage->height() > 0) { - m_graphicsView->updateBackgroundImage(*backgroundImage); - } - delete backgroundImage; - delete m_turnaroundLoader; - m_turnaroundLoader = NULL; - if (m_turnaroundDirty) { - turnaroundChanged(); - } -} - -void SkeletonWidget::changeTurnaround() -{ - QString fileName = QFileDialog::getOpenFileName(this, tr("Open Turnaround Reference Image"), - QString(), - tr("Image Files (*.png *.jpg *.bmp)")).trimmed(); - if (fileName.isEmpty()) - return; - m_turnaroundFilename = fileName; - turnaroundChanged(); -} - diff --git a/src/skeletonwidget.h b/src/skeletonwidget.h deleted file mode 100644 index 73796e8f..00000000 --- a/src/skeletonwidget.h +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef SKELETON_WIDGET_H -#define SKELETON_WIDGET_H -#include -#include -#include -#include -#include "modelwidget.h" -#include "skeletontomesh.h" -#include "turnaroundloader.h" -#include "skeletoneditgraphicsview.h" - -class SkeletonWidget : public QWidget -{ - Q_OBJECT -public: - SkeletonWidget(QWidget *parent=0); - SkeletonEditGraphicsView *graphicsView(); - ModelWidget *modelWidget(); -public slots: - void skeletonChanged(); - void meshReady(); - void turnaroundChanged(); - void turnaroundImageReady(); - void changeTurnaround(); - void showModelingWidgetAtCorner(); -private: - ModelWidget *m_modelWidget; - SkeletonEditGraphicsView *m_graphicsView; - SkeletonToMesh *m_skeletonToMesh; - bool m_skeletonDirty; - TurnaroundLoader *m_turnaroundLoader; - bool m_turnaroundDirty; - QString m_turnaroundFilename; -}; - -#endif diff --git a/src/theme.cpp b/src/theme.cpp index 2590a3e9..99eee21e 100644 --- a/src/theme.cpp +++ b/src/theme.cpp @@ -25,6 +25,23 @@ float Theme::edgeAlpha = 1.0; float Theme::fillAlpha = 50.0 / 255; int Theme::skeletonNodeBorderSize = 0; int Theme::skeletonEdgeWidth = 0; +int Theme::toolIconFontSize = 16; +int Theme::toolIconSize = 24; +int Theme::previewImageSize = 64; + +QtAwesome *Theme::awesome() +{ + static QtAwesome *s_awesome = nullptr; + if (nullptr == s_awesome) { + s_awesome = new QtAwesome(); + s_awesome->initFontAwesome(); + s_awesome->setDefaultOption("color", Theme::white); + s_awesome->setDefaultOption("color-disabled", QColor(0xcc, 0xcc, 0xcc)); + s_awesome->setDefaultOption("color-active", Theme::white); + s_awesome->setDefaultOption("color-selected", Theme::white); + } + return s_awesome; +} std::map createSideColorNameMap() { std::map map; diff --git a/src/theme.h b/src/theme.h index 8bc81764..594ee0c0 100644 --- a/src/theme.h +++ b/src/theme.h @@ -3,6 +3,7 @@ #include #include #include +#include "QtAwesome.h" class Theme { @@ -22,6 +23,10 @@ public: static QString tabButtonStylesheet; static std::map nextSideColorNameMap; static std::map sideColorNameToColorMap; + static QtAwesome *awesome(); + static int toolIconFontSize; + static int toolIconSize; + static int previewImageSize; }; #endif diff --git a/src/turnaroundloader.cpp b/src/turnaroundloader.cpp index 145786c6..f4ec127b 100644 --- a/src/turnaroundloader.cpp +++ b/src/turnaroundloader.cpp @@ -1,12 +1,18 @@ #include "turnaroundloader.h" TurnaroundLoader::TurnaroundLoader(const QString &filename, QSize viewSize) : - m_resultImage(NULL) + m_resultImage(nullptr) { m_filename = filename; m_viewSize = viewSize; } +TurnaroundLoader::TurnaroundLoader(const QImage &image, QSize viewSize) +{ + m_inputImage = image; + m_viewSize = viewSize; +} + TurnaroundLoader::~TurnaroundLoader() { delete m_resultImage; @@ -15,13 +21,17 @@ TurnaroundLoader::~TurnaroundLoader() QImage *TurnaroundLoader::takeResultImage() { QImage *returnImage = m_resultImage; - m_resultImage = NULL; + m_resultImage = nullptr; return returnImage; } void TurnaroundLoader::process() { - QImage image(m_filename); - m_resultImage = new QImage(image.scaled(m_viewSize, Qt::KeepAspectRatio)); + if (m_inputImage.isNull()) { + QImage image(m_filename); + m_resultImage = new QImage(image.scaled(m_viewSize, Qt::KeepAspectRatio)); + } else { + m_resultImage = new QImage(m_inputImage.scaled(m_viewSize, Qt::KeepAspectRatio)); + } emit finished(); } diff --git a/src/turnaroundloader.h b/src/turnaroundloader.h index 219a121a..dae0a6fd 100644 --- a/src/turnaroundloader.h +++ b/src/turnaroundloader.h @@ -10,6 +10,7 @@ class TurnaroundLoader : public QObject Q_OBJECT public: TurnaroundLoader(const QString &filename, QSize viewSize); + TurnaroundLoader(const QImage &image, QSize viewSize); ~TurnaroundLoader(); QImage *takeResultImage(); signals: @@ -18,6 +19,7 @@ public slots: void process(); private: QImage *m_resultImage; + QImage m_inputImage; QString m_filename; QSize m_viewSize; }; diff --git a/src/util.cpp b/src/util.cpp new file mode 100644 index 00000000..37eefc8b --- /dev/null +++ b/src/util.cpp @@ -0,0 +1,20 @@ +#include +#include "util.h" + +QString valueOfKeyInMapOrEmpty(const std::map &map, const QString &key) +{ + auto it = map.find(key); + if (it == map.end()) + return QString(); + return it->second; +} + +bool isTrueValueString(const QString &str) +{ + return "true" == str || "True" == str || "1" == str; +} + +bool isFloatEqual(float a, float b) +{ + return fabs(a - b) <= 0.000001; +} diff --git a/src/util.h b/src/util.h new file mode 100644 index 00000000..4f614e9b --- /dev/null +++ b/src/util.h @@ -0,0 +1,10 @@ +#ifndef UTIL_H +#define UTIL_H +#include +#include + +QString valueOfKeyInMapOrEmpty(const std::map &map, const QString &key); +bool isTrueValueString(const QString &str); +bool isFloatEqual(float a, float b); + +#endif diff --git a/thirdparty/QtAwesome/LICENSE.md b/thirdparty/QtAwesome/LICENSE.md new file mode 100755 index 00000000..73dc8189 --- /dev/null +++ b/thirdparty/QtAwesome/LICENSE.md @@ -0,0 +1,29 @@ +MIT License +=========== + +Copyright 2013-2015 [Reliable Bits Software by Blommers IT](http://blommersit.nl). All Rights Reserved. +Author [Rick Blommers](mailto:rick@blommersit.nl) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, +and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO +THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS +OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +Font Awesome License +==================== + +[https://github.com/FortAwesome/Font-Awesome](https://github.com/FortAwesome/Font-Awesome) + +The Font Awesome font is licensed under the SIL Open Font License - [http://scripts.sil.org/OFL](http://scripts.sil.org/OFL) +The Font Awesome pictograms are licensed under the CC BY 3.0 License - [http://creativecommons.org/licenses/by/3.0/](http://creativecommons.org/licenses/by/3.0/) +"Font Awesome by Dave Gandy - http://fortawesome.github.com/Font-Awesome" + + diff --git a/thirdparty/QtAwesome/QtAwesome/QtAwesome.cpp b/thirdparty/QtAwesome/QtAwesome/QtAwesome.cpp new file mode 100755 index 00000000..d0c286d8 --- /dev/null +++ b/thirdparty/QtAwesome/QtAwesome/QtAwesome.cpp @@ -0,0 +1,1146 @@ +/** + * QtAwesome - use font-awesome (or other font icons) in your c++ / Qt Application + * + * MIT Licensed + * + * Copyright 2013-2016 - Reliable Bits Software by Blommers IT. All Rights Reserved. + * Author Rick Blommers + */ + +#include "QtAwesome.h" +#include "QtAwesomeAnim.h" + +#include +#include +#include + + + +/// The font-awesome icon painter +class QtAwesomeCharIconPainter: public QtAwesomeIconPainter +{ + +protected: + + QStringList optionKeysForModeAndState( const QString& key, QIcon::Mode mode, QIcon::State state) + { + QString modePostfix; + switch(mode) { + case QIcon::Disabled: + modePostfix = "-disabled"; + break; + case QIcon::Active: + modePostfix = "-active"; + break; + case QIcon::Selected: + modePostfix = "-selected"; + break; + default: // QIcon::Normal: + // modePostfix = ""; + break; + } + + QString statePostfix; + if( state == QIcon::Off) { + statePostfix = "-off"; + } + + // the keys that need to bet tested: key-mode-state | key-mode | key-state | key + QStringList result; + if( !modePostfix.isEmpty() ) { + if( !statePostfix.isEmpty() ) { + result.push_back( key + modePostfix + statePostfix ); + } + result.push_back( key + modePostfix ); + } + if( !statePostfix.isEmpty() ) { + result.push_back( key + statePostfix ); + } + return result; + } + + + QVariant optionValueForModeAndState( const QString& baseKey, QIcon::Mode mode, QIcon::State state, const QVariantMap& options ) + { + foreach( QString key, optionKeysForModeAndState(baseKey, mode, state) ) { + //if ( options.contains(key) && options.value(key).toString().isEmpty()) qDebug() << "Not found:" << key; + if( options.contains(key) && !(options.value(key).toString().isEmpty()) ) + return options.value(key); + } + + return options.value(baseKey); + } + +public: + + + virtual void paint( QtAwesome* awesome, QPainter* painter, const QRect& rect, QIcon::Mode mode, QIcon::State state, const QVariantMap& options ) + { + painter->save(); + + QVariant var =options.value("anim"); + QtAwesomeAnimation* anim = var.value(); + if( anim ) { + anim->setup( *painter, rect ); + } + + // set the default options + QColor color = optionValueForModeAndState("color", mode, state, options).value(); + QString text = optionValueForModeAndState("text", mode, state, options).toString(); + + Q_ASSERT(color.isValid()); + Q_ASSERT(!text.isEmpty()); + + painter->setPen(color); + + // add some 'padding' around the icon + int drawSize = qRound(rect.height()*options.value("scale-factor").toFloat()); + + painter->setFont( awesome->font(drawSize) ); + painter->drawText( rect, text, QTextOption( Qt::AlignCenter|Qt::AlignVCenter ) ); + painter->restore(); + } + +}; + + +//--------------------------------------------------------------------------------------- + + +/// The painter icon engine. +class QtAwesomeIconPainterIconEngine : public QIconEngine +{ + +public: + + QtAwesomeIconPainterIconEngine( QtAwesome* awesome, QtAwesomeIconPainter* painter, const QVariantMap& options ) + : awesomeRef_(awesome) + , iconPainterRef_(painter) + , options_(options) + { + } + + virtual ~QtAwesomeIconPainterIconEngine() {} + + QtAwesomeIconPainterIconEngine* clone() const + { + return new QtAwesomeIconPainterIconEngine( awesomeRef_, iconPainterRef_, options_ ); + } + + virtual void paint(QPainter* painter, const QRect& rect, QIcon::Mode mode, QIcon::State state) + { + Q_UNUSED( mode ); + Q_UNUSED( state ); + iconPainterRef_->paint( awesomeRef_, painter, rect, mode, state, options_ ); + } + + virtual QPixmap pixmap(const QSize& size, QIcon::Mode mode, QIcon::State state) + { + QPixmap pm(size); + pm.fill( Qt::transparent ); // we need transparency + { + QPainter p(&pm); + paint(&p, QRect(QPoint(0,0),size), mode, state); + } + return pm; + } + +private: + + QtAwesome* awesomeRef_; ///< a reference to the QtAwesome instance + QtAwesomeIconPainter* iconPainterRef_; ///< a reference to the icon painter + QVariantMap options_; ///< the options for this icon painter +}; + + +//--------------------------------------------------------------------------------------- + +/// The default icon colors +QtAwesome::QtAwesome( QObject* parent ) + : QObject( parent ) + , namedCodepoints_() +{ + // initialize the default options + setDefaultOption( "color", QColor(50,50,50) ); + setDefaultOption( "color-disabled", QColor(70,70,70,60)); + setDefaultOption( "color-active", QColor(10,10,10)); + setDefaultOption( "color-selected", QColor(10,10,10)); + setDefaultOption( "scale-factor", 0.9 ); + + setDefaultOption( "text", QVariant() ); + setDefaultOption( "text-disabled", QVariant() ); + setDefaultOption( "text-active", QVariant() ); + setDefaultOption( "text-selected", QVariant() ); + + fontIconPainter_ = new QtAwesomeCharIconPainter(); + +} + + +QtAwesome::~QtAwesome() +{ + delete fontIconPainter_; +// delete errorIconPainter_; + qDeleteAll(painterMap_); +} + +/// initializes the QtAwesome icon factory with the given fontname +void QtAwesome::init(const QString& fontname) +{ + fontName_ = fontname; +} + +struct FANameIcon { + const char *name; + fa::icon icon; +}; + +static const FANameIcon faNameIconArray[] = { + { "fa_500px" , fa::fa_500px }, + { "addressbook" , fa::addressbook }, + { "addressbooko" , fa::addressbooko }, + { "addresscard" , fa::addresscard }, + { "addresscardo" , fa::addresscardo }, + { "adjust" , fa::adjust }, + { "adn" , fa::adn }, + { "aligncenter" , fa::aligncenter }, + { "alignjustify" , fa::alignjustify }, + { "alignleft" , fa::alignleft }, + { "alignright" , fa::alignright }, + { "amazon" , fa::amazon }, + { "ambulance" , fa::ambulance }, + { "americansignlanguageinterpreting" , fa::americansignlanguageinterpreting }, + { "anchor" , fa::anchor }, + { "android" , fa::android }, + { "angellist" , fa::angellist }, + { "angledoubledown" , fa::angledoubledown }, + { "angledoubleleft" , fa::angledoubleleft }, + { "angledoubleright" , fa::angledoubleright }, + { "angledoubleup" , fa::angledoubleup }, + { "angledown" , fa::angledown }, + { "angleleft" , fa::angleleft }, + { "angleright" , fa::angleright }, + { "angleup" , fa::angleup }, + { "apple" , fa::apple }, + { "archive" , fa::archive }, + { "areachart" , fa::areachart }, + { "arrowcircledown" , fa::arrowcircledown }, + { "arrowcircleleft" , fa::arrowcircleleft }, + { "arrowcircleodown" , fa::arrowcircleodown }, + { "arrowcircleoleft" , fa::arrowcircleoleft }, + { "arrowcircleoright" , fa::arrowcircleoright }, + { "arrowcircleoup" , fa::arrowcircleoup }, + { "arrowcircleright" , fa::arrowcircleright }, + { "arrowcircleup" , fa::arrowcircleup }, + { "arrowdown" , fa::arrowdown }, + { "arrowleft" , fa::arrowleft }, + { "arrowright" , fa::arrowright }, + { "arrowup" , fa::arrowup }, + { "arrows" , fa::arrows }, + { "arrowsalt" , fa::arrowsalt }, + { "arrowsh" , fa::arrowsh }, + { "arrowsv" , fa::arrowsv }, + { "aslinterpreting" , fa::aslinterpreting }, + { "assistivelisteningsystems" , fa::assistivelisteningsystems }, + { "asterisk" , fa::asterisk }, + { "at" , fa::at }, + { "audiodescription" , fa::audiodescription }, + { "automobile" , fa::automobile }, + { "backward" , fa::backward }, + { "balancescale" , fa::balancescale }, + { "ban" , fa::ban }, + { "bandcamp" , fa::bandcamp }, + { "bank" , fa::bank }, + { "barchart" , fa::barchart }, + { "barcharto" , fa::barcharto }, + { "barcode" , fa::barcode }, + { "bars" , fa::bars }, + { "bath" , fa::bath }, + { "bathtub" , fa::bathtub }, + { "battery" , fa::battery }, + { "battery0" , fa::battery0 }, + { "battery1" , fa::battery1 }, + { "battery2" , fa::battery2 }, + { "battery3" , fa::battery3 }, + { "battery4" , fa::battery4 }, + { "batteryempty" , fa::batteryempty }, + { "batteryfull" , fa::batteryfull }, + { "batteryhalf" , fa::batteryhalf }, + { "batteryquarter" , fa::batteryquarter }, + { "batterythreequarters" , fa::batterythreequarters }, + { "bed" , fa::bed }, + { "beer" , fa::beer }, + { "behance" , fa::behance }, + { "behancesquare" , fa::behancesquare }, + { "bell" , fa::bell }, + { "bello" , fa::bello }, + { "bellslash" , fa::bellslash }, + { "bellslasho" , fa::bellslasho }, + { "bicycle" , fa::bicycle }, + { "binoculars" , fa::binoculars }, + { "birthdaycake" , fa::birthdaycake }, + { "bitbucket" , fa::bitbucket }, + { "bitbucketsquare" , fa::bitbucketsquare }, + { "bitcoin" , fa::bitcoin }, + { "blacktie" , fa::blacktie }, + { "blind" , fa::blind }, + { "bluetooth" , fa::bluetooth }, + { "bluetoothb" , fa::bluetoothb }, + { "bold" , fa::bold }, + { "bolt" , fa::bolt }, + { "bomb" , fa::bomb }, + { "book" , fa::book }, + { "bookmark" , fa::bookmark }, + { "bookmarko" , fa::bookmarko }, + { "braille" , fa::braille }, + { "briefcase" , fa::briefcase }, + { "btc" , fa::btc }, + { "bug" , fa::bug }, + { "building" , fa::building }, + { "buildingo" , fa::buildingo }, + { "bullhorn" , fa::bullhorn }, + { "bullseye" , fa::bullseye }, + { "bus" , fa::bus }, + { "buysellads" , fa::buysellads }, + { "cab" , fa::cab }, + { "calculator" , fa::calculator }, + { "calendar" , fa::calendar }, + { "calendarchecko" , fa::calendarchecko }, + { "calendarminuso" , fa::calendarminuso }, + { "calendaro" , fa::calendaro }, + { "calendarpluso" , fa::calendarpluso }, + { "calendartimeso" , fa::calendartimeso }, + { "camera" , fa::camera }, + { "cameraretro" , fa::cameraretro }, + { "car" , fa::car }, + { "caretdown" , fa::caretdown }, + { "caretleft" , fa::caretleft }, + { "caretright" , fa::caretright }, + { "caretsquareodown" , fa::caretsquareodown }, + { "caretsquareoleft" , fa::caretsquareoleft }, + { "caretsquareoright" , fa::caretsquareoright }, + { "caretsquareoup" , fa::caretsquareoup }, + { "caretup" , fa::caretup }, + { "cartarrowdown" , fa::cartarrowdown }, + { "cartplus" , fa::cartplus }, + { "cc" , fa::cc }, + { "ccamex" , fa::ccamex }, + { "ccdinersclub" , fa::ccdinersclub }, + { "ccdiscover" , fa::ccdiscover }, + { "ccjcb" , fa::ccjcb }, + { "ccmastercard" , fa::ccmastercard }, + { "ccpaypal" , fa::ccpaypal }, + { "ccstripe" , fa::ccstripe }, + { "ccvisa" , fa::ccvisa }, + { "certificate" , fa::certificate }, + { "chain" , fa::chain }, + { "chainbroken" , fa::chainbroken }, + { "check" , fa::check }, + { "checkcircle" , fa::checkcircle }, + { "checkcircleo" , fa::checkcircleo }, + { "checksquare" , fa::checksquare }, + { "checksquareo" , fa::checksquareo }, + { "chevroncircledown" , fa::chevroncircledown }, + { "chevroncircleleft" , fa::chevroncircleleft }, + { "chevroncircleright" , fa::chevroncircleright }, + { "chevroncircleup" , fa::chevroncircleup }, + { "chevrondown" , fa::chevrondown }, + { "chevronleft" , fa::chevronleft }, + { "chevronright" , fa::chevronright }, + { "chevronup" , fa::chevronup }, + { "child" , fa::child }, + { "chrome" , fa::chrome }, + { "circle" , fa::circle }, + { "circleo" , fa::circleo }, + { "circleonotch" , fa::circleonotch }, + { "circlethin" , fa::circlethin }, + { "clipboard" , fa::clipboard }, + { "clocko" , fa::clocko }, + { "clone" , fa::clone }, + { "close" , fa::close }, + { "cloud" , fa::cloud }, + { "clouddownload" , fa::clouddownload }, + { "cloudupload" , fa::cloudupload }, + { "cny" , fa::cny }, + { "code" , fa::code }, + { "codefork" , fa::codefork }, + { "codepen" , fa::codepen }, + { "codiepie" , fa::codiepie }, + { "coffee" , fa::coffee }, + { "cog" , fa::cog }, + { "cogs" , fa::cogs }, + { "columns" , fa::columns }, + { "comment" , fa::comment }, + { "commento" , fa::commento }, + { "commenting" , fa::commenting }, + { "commentingo" , fa::commentingo }, + { "comments" , fa::comments }, + { "commentso" , fa::commentso }, + { "compass" , fa::compass }, + { "compress" , fa::compress }, + { "connectdevelop" , fa::connectdevelop }, + { "contao" , fa::contao }, + { "copy" , fa::copy }, + { "copyright" , fa::copyright }, + { "creativecommons" , fa::creativecommons }, + { "creditcard" , fa::creditcard }, + { "creditcardalt" , fa::creditcardalt }, + { "crop" , fa::crop }, + { "crosshairs" , fa::crosshairs }, + { "css3" , fa::css3 }, + { "cube" , fa::cube }, + { "cubes" , fa::cubes }, + { "cut" , fa::cut }, + { "cutlery" , fa::cutlery }, + { "dashboard" , fa::dashboard }, + { "dashcube" , fa::dashcube }, + { "database" , fa::database }, + { "deaf" , fa::deaf }, + { "deafness" , fa::deafness }, + { "dedent" , fa::dedent }, + { "delicious" , fa::delicious }, + { "desktop" , fa::desktop }, + { "deviantart" , fa::deviantart }, + { "diamond" , fa::diamond }, + { "digg" , fa::digg }, + { "dollar" , fa::dollar }, + { "dotcircleo" , fa::dotcircleo }, + { "download" , fa::download }, + { "dribbble" , fa::dribbble }, + { "driverslicense" , fa::driverslicense }, + { "driverslicenseo" , fa::driverslicenseo }, + { "dropbox" , fa::dropbox }, + { "drupal" , fa::drupal }, + { "edge" , fa::edge }, + { "edit" , fa::edit }, + { "eercast" , fa::eercast }, + { "eject" , fa::eject }, + { "ellipsish" , fa::ellipsish }, + { "ellipsisv" , fa::ellipsisv }, + { "empire" , fa::empire }, + { "envelope" , fa::envelope }, + { "envelopeo" , fa::envelopeo }, + { "envelopeopen" , fa::envelopeopen }, + { "envelopeopeno" , fa::envelopeopeno }, + { "envelopesquare" , fa::envelopesquare }, + { "envira" , fa::envira }, + { "eraser" , fa::eraser }, + { "etsy" , fa::etsy }, + { "eur" , fa::eur }, + { "euro" , fa::euro }, + { "exchange" , fa::exchange }, + { "exclamation" , fa::exclamation }, + { "exclamationcircle" , fa::exclamationcircle }, + { "exclamationtriangle" , fa::exclamationtriangle }, + { "expand" , fa::expand }, + { "expeditedssl" , fa::expeditedssl }, + { "externallink" , fa::externallink }, + { "externallinksquare" , fa::externallinksquare }, + { "eye" , fa::eye }, + { "eyeslash" , fa::eyeslash }, + { "eyedropper" , fa::eyedropper }, + { "fa" , fa::fa }, + { "facebook" , fa::facebook }, + { "facebookf" , fa::facebookf }, + { "facebookofficial" , fa::facebookofficial }, + { "facebooksquare" , fa::facebooksquare }, + { "fastbackward" , fa::fastbackward }, + { "fastforward" , fa::fastforward }, + { "fax" , fa::fax }, + { "feed" , fa::feed }, + { "female" , fa::female }, + { "fighterjet" , fa::fighterjet }, + { "file" , fa::file }, + { "filearchiveo" , fa::filearchiveo }, + { "fileaudioo" , fa::fileaudioo }, + { "filecodeo" , fa::filecodeo }, + { "fileexcelo" , fa::fileexcelo }, + { "fileimageo" , fa::fileimageo }, + { "filemovieo" , fa::filemovieo }, + { "fileo" , fa::fileo }, + { "filepdfo" , fa::filepdfo }, + { "filephotoo" , fa::filephotoo }, + { "filepictureo" , fa::filepictureo }, + { "filepowerpointo" , fa::filepowerpointo }, + { "filesoundo" , fa::filesoundo }, + { "filetext" , fa::filetext }, + { "filetexto" , fa::filetexto }, + { "filevideoo" , fa::filevideoo }, + { "filewordo" , fa::filewordo }, + { "filezipo" , fa::filezipo }, + { "fileso" , fa::fileso }, + { "film" , fa::film }, + { "filter" , fa::filter }, + { "fire" , fa::fire }, + { "fireextinguisher" , fa::fireextinguisher }, + { "firefox" , fa::firefox }, + { "firstorder" , fa::firstorder }, + { "flag" , fa::flag }, + { "flagcheckered" , fa::flagcheckered }, + { "flago" , fa::flago }, + { "flash" , fa::flash }, + { "flask" , fa::flask }, + { "flickr" , fa::flickr }, + { "floppyo" , fa::floppyo }, + { "folder" , fa::folder }, + { "foldero" , fa::foldero }, + { "folderopen" , fa::folderopen }, + { "folderopeno" , fa::folderopeno }, + { "font" , fa::font }, + { "fontawesome" , fa::fontawesome }, + { "fonticons" , fa::fonticons }, + { "fortawesome" , fa::fortawesome }, + { "forumbee" , fa::forumbee }, + { "forward" , fa::forward }, + { "foursquare" , fa::foursquare }, + { "freecodecamp" , fa::freecodecamp }, + { "frowno" , fa::frowno }, + { "futbolo" , fa::futbolo }, + { "gamepad" , fa::gamepad }, + { "gavel" , fa::gavel }, + { "gbp" , fa::gbp }, + { "ge" , fa::ge }, + { "gear" , fa::gear }, + { "gears" , fa::gears }, + { "genderless" , fa::genderless }, + { "getpocket" , fa::getpocket }, + { "gg" , fa::gg }, + { "ggcircle" , fa::ggcircle }, + { "gift" , fa::gift }, + { "git" , fa::git }, + { "gitsquare" , fa::gitsquare }, + { "github" , fa::github }, + { "githubalt" , fa::githubalt }, + { "githubsquare" , fa::githubsquare }, + { "gitlab" , fa::gitlab }, + { "gittip" , fa::gittip }, + { "glass" , fa::glass }, + { "glide" , fa::glide }, + { "glideg" , fa::glideg }, + { "globe" , fa::globe }, + { "google" , fa::google }, + { "googleplus" , fa::googleplus }, + { "googlepluscircle" , fa::googlepluscircle }, + { "googleplusofficial" , fa::googleplusofficial }, + { "googleplussquare" , fa::googleplussquare }, + { "googlewallet" , fa::googlewallet }, + { "graduationcap" , fa::graduationcap }, + { "gratipay" , fa::gratipay }, + { "grav" , fa::grav }, + { "group" , fa::group }, + { "hsquare" , fa::hsquare }, + { "hackernews" , fa::hackernews }, + { "handgrabo" , fa::handgrabo }, + { "handlizardo" , fa::handlizardo }, + { "handodown" , fa::handodown }, + { "handoleft" , fa::handoleft }, + { "handoright" , fa::handoright }, + { "handoup" , fa::handoup }, + { "handpapero" , fa::handpapero }, + { "handpeaceo" , fa::handpeaceo }, + { "handpointero" , fa::handpointero }, + { "handrocko" , fa::handrocko }, + { "handscissorso" , fa::handscissorso }, + { "handspocko" , fa::handspocko }, + { "handstopo" , fa::handstopo }, + { "handshakeo" , fa::handshakeo }, + { "hardofhearing" , fa::hardofhearing }, + { "hashtag" , fa::hashtag }, + { "hddo" , fa::hddo }, + { "header" , fa::header }, + { "headphones" , fa::headphones }, + { "heart" , fa::heart }, + { "hearto" , fa::hearto }, + { "heartbeat" , fa::heartbeat }, + { "history" , fa::history }, + { "home" , fa::home }, + { "hospitalo" , fa::hospitalo }, + { "hotel" , fa::hotel }, + { "hourglass" , fa::hourglass }, + { "hourglass1" , fa::hourglass1 }, + { "hourglass2" , fa::hourglass2 }, + { "hourglass3" , fa::hourglass3 }, + { "hourglassend" , fa::hourglassend }, + { "hourglasshalf" , fa::hourglasshalf }, + { "hourglasso" , fa::hourglasso }, + { "hourglassstart" , fa::hourglassstart }, + { "houzz" , fa::houzz }, + { "html5" , fa::html5 }, + { "icursor" , fa::icursor }, + { "idbadge" , fa::idbadge }, + { "idcard" , fa::idcard }, + { "idcardo" , fa::idcardo }, + { "ils" , fa::ils }, + { "image" , fa::image }, + { "imdb" , fa::imdb }, + { "inbox" , fa::inbox }, + { "indent" , fa::indent }, + { "industry" , fa::industry }, + { "info" , fa::info }, + { "infocircle" , fa::infocircle }, + { "inr" , fa::inr }, + { "instagram" , fa::instagram }, + { "institution" , fa::institution }, + { "internetexplorer" , fa::internetexplorer }, + { "intersex" , fa::intersex }, + { "ioxhost" , fa::ioxhost }, + { "italic" , fa::italic }, + { "joomla" , fa::joomla }, + { "jpy" , fa::jpy }, + { "jsfiddle" , fa::jsfiddle }, + { "key" , fa::key }, + { "keyboardo" , fa::keyboardo }, + { "krw" , fa::krw }, + { "language" , fa::language }, + { "laptop" , fa::laptop }, + { "lastfm" , fa::lastfm }, + { "lastfmsquare" , fa::lastfmsquare }, + { "leaf" , fa::leaf }, + { "leanpub" , fa::leanpub }, + { "legal" , fa::legal }, + { "lemono" , fa::lemono }, + { "leveldown" , fa::leveldown }, + { "levelup" , fa::levelup }, + { "lifebouy" , fa::lifebouy }, + { "lifebuoy" , fa::lifebuoy }, + { "lifering" , fa::lifering }, + { "lifesaver" , fa::lifesaver }, + { "lightbulbo" , fa::lightbulbo }, + { "linechart" , fa::linechart }, + { "link" , fa::link }, + { "linkedin" , fa::linkedin }, + { "linkedinsquare" , fa::linkedinsquare }, + { "linode" , fa::linode }, + { "fa_linux" , fa::fa_linux }, + { "list" , fa::list }, + { "listalt" , fa::listalt }, + { "listol" , fa::listol }, + { "listul" , fa::listul }, + { "locationarrow" , fa::locationarrow }, + { "lock" , fa::lock }, + { "longarrowdown" , fa::longarrowdown }, + { "longarrowleft" , fa::longarrowleft }, + { "longarrowright" , fa::longarrowright }, + { "longarrowup" , fa::longarrowup }, + { "lowvision" , fa::lowvision }, + { "magic" , fa::magic }, + { "magnet" , fa::magnet }, + { "mailforward" , fa::mailforward }, + { "mailreply" , fa::mailreply }, + { "mailreplyall" , fa::mailreplyall }, + { "male" , fa::male }, + { "map" , fa::map }, + { "mapmarker" , fa::mapmarker }, + { "mapo" , fa::mapo }, + { "mappin" , fa::mappin }, + { "mapsigns" , fa::mapsigns }, + { "mars" , fa::mars }, + { "marsdouble" , fa::marsdouble }, + { "marsstroke" , fa::marsstroke }, + { "marsstrokeh" , fa::marsstrokeh }, + { "marsstrokev" , fa::marsstrokev }, + { "maxcdn" , fa::maxcdn }, + { "meanpath" , fa::meanpath }, + { "medium" , fa::medium }, + { "medkit" , fa::medkit }, + { "meetup" , fa::meetup }, + { "meho" , fa::meho }, + { "mercury" , fa::mercury }, + { "microchip" , fa::microchip }, + { "microphone" , fa::microphone }, + { "microphoneslash" , fa::microphoneslash }, + { "minus" , fa::minus }, + { "minuscircle" , fa::minuscircle }, + { "minussquare" , fa::minussquare }, + { "minussquareo" , fa::minussquareo }, + { "mixcloud" , fa::mixcloud }, + { "mobile" , fa::mobile }, + { "mobilephone" , fa::mobilephone }, + { "modx" , fa::modx }, + { "money" , fa::money }, + { "moono" , fa::moono }, + { "mortarboard" , fa::mortarboard }, + { "motorcycle" , fa::motorcycle }, + { "mousepointer" , fa::mousepointer }, + { "music" , fa::music }, + { "navicon" , fa::navicon }, + { "neuter" , fa::neuter }, + { "newspapero" , fa::newspapero }, + { "objectgroup" , fa::objectgroup }, + { "objectungroup" , fa::objectungroup }, + { "odnoklassniki" , fa::odnoklassniki }, + { "odnoklassnikisquare" , fa::odnoklassnikisquare }, + { "opencart" , fa::opencart }, + { "openid" , fa::openid }, + { "opera" , fa::opera }, + { "optinmonster" , fa::optinmonster }, + { "outdent" , fa::outdent }, + { "pagelines" , fa::pagelines }, + { "paintbrush" , fa::paintbrush }, + { "paperplane" , fa::paperplane }, + { "paperplaneo" , fa::paperplaneo }, + { "paperclip" , fa::paperclip }, + { "paragraph" , fa::paragraph }, + { "paste" , fa::paste }, + { "pause" , fa::pause }, + { "pausecircle" , fa::pausecircle }, + { "pausecircleo" , fa::pausecircleo }, + { "paw" , fa::paw }, + { "paypal" , fa::paypal }, + { "pencil" , fa::pencil }, + { "pencilsquare" , fa::pencilsquare }, + { "pencilsquareo" , fa::pencilsquareo }, + { "percent" , fa::percent }, + { "phone" , fa::phone }, + { "phonesquare" , fa::phonesquare }, + { "photo" , fa::photo }, + { "pictureo" , fa::pictureo }, + { "piechart" , fa::piechart }, + { "piedpiper" , fa::piedpiper }, + { "piedpiperalt" , fa::piedpiperalt }, + { "piedpiperpp" , fa::piedpiperpp }, + { "pinterest" , fa::pinterest }, + { "pinterestp" , fa::pinterestp }, + { "pinterestsquare" , fa::pinterestsquare }, + { "plane" , fa::plane }, + { "play" , fa::play }, + { "playcircle" , fa::playcircle }, + { "playcircleo" , fa::playcircleo }, + { "plug" , fa::plug }, + { "plus" , fa::plus }, + { "pluscircle" , fa::pluscircle }, + { "plussquare" , fa::plussquare }, + { "plussquareo" , fa::plussquareo }, + { "podcast" , fa::podcast }, + { "poweroff" , fa::poweroff }, + { "print" , fa::print }, + { "producthunt" , fa::producthunt }, + { "puzzlepiece" , fa::puzzlepiece }, + { "qq" , fa::qq }, + { "qrcode" , fa::qrcode }, + { "question" , fa::question }, + { "questioncircle" , fa::questioncircle }, + { "questioncircleo" , fa::questioncircleo }, + { "quora" , fa::quora }, + { "quoteleft" , fa::quoteleft }, + { "quoteright" , fa::quoteright }, + { "ra" , fa::ra }, + { "random" , fa::random }, + { "ravelry" , fa::ravelry }, + { "rebel" , fa::rebel }, + { "recycle" , fa::recycle }, + { "reddit" , fa::reddit }, + { "redditalien" , fa::redditalien }, + { "redditsquare" , fa::redditsquare }, + { "refresh" , fa::refresh }, + { "registered" , fa::registered }, + { "remove" , fa::remove }, + { "renren" , fa::renren }, + { "reorder" , fa::reorder }, + { "repeat" , fa::repeat }, + { "reply" , fa::reply }, + { "replyall" , fa::replyall }, + { "resistance" , fa::resistance }, + { "retweet" , fa::retweet }, + { "rmb" , fa::rmb }, + { "road" , fa::road }, + { "rocket" , fa::rocket }, + { "rotateleft" , fa::rotateleft }, + { "rotateright" , fa::rotateright }, + { "rouble" , fa::rouble }, + { "rss" , fa::rss }, + { "rsssquare" , fa::rsssquare }, + { "rub" , fa::rub }, + { "ruble" , fa::ruble }, + { "rupee" , fa::rupee }, + { "s15" , fa::s15 }, + { "safari" , fa::safari }, + { "save" , fa::save }, + { "scissors" , fa::scissors }, + { "scribd" , fa::scribd }, + { "search" , fa::search }, + { "searchminus" , fa::searchminus }, + { "searchplus" , fa::searchplus }, + { "sellsy" , fa::sellsy }, + { "send" , fa::send }, + { "sendo" , fa::sendo }, + { "server" , fa::server }, + { "share" , fa::share }, + { "sharealt" , fa::sharealt }, + { "sharealtsquare" , fa::sharealtsquare }, + { "sharesquare" , fa::sharesquare }, + { "sharesquareo" , fa::sharesquareo }, + { "shekel" , fa::shekel }, + { "sheqel" , fa::sheqel }, + { "shield" , fa::shield }, + { "ship" , fa::ship }, + { "shirtsinbulk" , fa::shirtsinbulk }, + { "shoppingbag" , fa::shoppingbag }, + { "shoppingbasket" , fa::shoppingbasket }, + { "shoppingcart" , fa::shoppingcart }, + { "shower" , fa::shower }, + { "signin" , fa::signin }, + { "signlanguage" , fa::signlanguage }, + { "signout" , fa::signout }, + { "signal" , fa::signal }, + { "signing" , fa::signing }, + { "simplybuilt" , fa::simplybuilt }, + { "sitemap" , fa::sitemap }, + { "skyatlas" , fa::skyatlas }, + { "skype" , fa::skype }, + { "slack" , fa::slack }, + { "sliders" , fa::sliders }, + { "slideshare" , fa::slideshare }, + { "smileo" , fa::smileo }, + { "snapchat" , fa::snapchat }, + { "snapchatghost" , fa::snapchatghost }, + { "snapchatsquare" , fa::snapchatsquare }, + { "snowflakeo" , fa::snowflakeo }, + { "soccerballo" , fa::soccerballo }, + { "sort" , fa::sort }, + { "sortalphaasc" , fa::sortalphaasc }, + { "sortalphadesc" , fa::sortalphadesc }, + { "sortamountasc" , fa::sortamountasc }, + { "sortamountdesc" , fa::sortamountdesc }, + { "sortasc" , fa::sortasc }, + { "sortdesc" , fa::sortdesc }, + { "sortdown" , fa::sortdown }, + { "sortnumericasc" , fa::sortnumericasc }, + { "sortnumericdesc" , fa::sortnumericdesc }, + { "sortup" , fa::sortup }, + { "soundcloud" , fa::soundcloud }, + { "spaceshuttle" , fa::spaceshuttle }, + { "spinner" , fa::spinner }, + { "spoon" , fa::spoon }, + { "spotify" , fa::spotify }, + { "square" , fa::square }, + { "squareo" , fa::squareo }, + { "stackexchange" , fa::stackexchange }, + { "stackoverflow" , fa::stackoverflow }, + { "star" , fa::star }, + { "starhalf" , fa::starhalf }, + { "starhalfempty" , fa::starhalfempty }, + { "starhalffull" , fa::starhalffull }, + { "starhalfo" , fa::starhalfo }, + { "staro" , fa::staro }, + { "steam" , fa::steam }, + { "steamsquare" , fa::steamsquare }, + { "stepbackward" , fa::stepbackward }, + { "stepforward" , fa::stepforward }, + { "stethoscope" , fa::stethoscope }, + { "stickynote" , fa::stickynote }, + { "stickynoteo" , fa::stickynoteo }, + { "stop" , fa::stop }, + { "stopcircle" , fa::stopcircle }, + { "stopcircleo" , fa::stopcircleo }, + { "streetview" , fa::streetview }, + { "strikethrough" , fa::strikethrough }, + { "stumbleupon" , fa::stumbleupon }, + { "stumbleuponcircle" , fa::stumbleuponcircle }, + { "subscript" , fa::subscript }, + { "subway" , fa::subway }, + { "suitcase" , fa::suitcase }, + { "suno" , fa::suno }, + { "superpowers" , fa::superpowers }, + { "superscript" , fa::superscript }, + { "support" , fa::support }, + { "table" , fa::table }, + { "tablet" , fa::tablet }, + { "tachometer" , fa::tachometer }, + { "tag" , fa::tag }, + { "tags" , fa::tags }, + { "tasks" , fa::tasks }, + { "taxi" , fa::taxi }, + { "telegram" , fa::telegram }, + { "television" , fa::television }, + { "tencentweibo" , fa::tencentweibo }, + { "terminal" , fa::terminal }, + { "textheight" , fa::textheight }, + { "textwidth" , fa::textwidth }, + { "th" , fa::th }, + { "thlarge" , fa::thlarge }, + { "thlist" , fa::thlist }, + { "themeisle" , fa::themeisle }, + { "thermometer" , fa::thermometer }, + { "thermometer0" , fa::thermometer0 }, + { "thermometer1" , fa::thermometer1 }, + { "thermometer2" , fa::thermometer2 }, + { "thermometer3" , fa::thermometer3 }, + { "thermometer4" , fa::thermometer4 }, + { "thermometerempty" , fa::thermometerempty }, + { "thermometerfull" , fa::thermometerfull }, + { "thermometerhalf" , fa::thermometerhalf }, + { "thermometerquarter" , fa::thermometerquarter }, + { "thermometerthreequarters" , fa::thermometerthreequarters }, + { "thumbtack" , fa::thumbtack }, + { "thumbsdown" , fa::thumbsdown }, + { "thumbsodown" , fa::thumbsodown }, + { "thumbsoup" , fa::thumbsoup }, + { "thumbsup" , fa::thumbsup }, + { "ticket" , fa::ticket }, + { "times" , fa::times }, + { "timescircle" , fa::timescircle }, + { "timescircleo" , fa::timescircleo }, + { "timesrectangle" , fa::timesrectangle }, + { "timesrectangleo" , fa::timesrectangleo }, + { "tint" , fa::tint }, + { "toggledown" , fa::toggledown }, + { "toggleleft" , fa::toggleleft }, + { "toggleoff" , fa::toggleoff }, + { "toggleon" , fa::toggleon }, + { "toggleright" , fa::toggleright }, + { "toggleup" , fa::toggleup }, + { "trademark" , fa::trademark }, + { "train" , fa::train }, + { "transgender" , fa::transgender }, + { "transgenderalt" , fa::transgenderalt }, + { "trash" , fa::trash }, + { "trasho" , fa::trasho }, + { "tree" , fa::tree }, + { "trello" , fa::trello }, + { "tripadvisor" , fa::tripadvisor }, + { "trophy" , fa::trophy }, + { "truck" , fa::truck }, + { "fa_try" , fa::fa_try }, + { "tty" , fa::tty }, + { "tumblr" , fa::tumblr }, + { "tumblrsquare" , fa::tumblrsquare }, + { "turkishlira" , fa::turkishlira }, + { "tv" , fa::tv }, + { "twitch" , fa::twitch }, + { "twitter" , fa::twitter }, + { "twittersquare" , fa::twittersquare }, + { "umbrella" , fa::umbrella }, + { "underline" , fa::underline }, + { "undo" , fa::undo }, + { "universalaccess" , fa::universalaccess }, + { "university" , fa::university }, + { "unlink" , fa::unlink }, + { "unlock" , fa::unlock }, + { "unlockalt" , fa::unlockalt }, + { "unsorted" , fa::unsorted }, + { "upload" , fa::upload }, + { "usb" , fa::usb }, + { "usd" , fa::usd }, + { "user" , fa::user }, + { "usercircle" , fa::usercircle }, + { "usercircleo" , fa::usercircleo }, + { "usermd" , fa::usermd }, + { "usero" , fa::usero }, + { "userplus" , fa::userplus }, + { "usersecret" , fa::usersecret }, + { "usertimes" , fa::usertimes }, + { "users" , fa::users }, + { "vcard" , fa::vcard }, + { "vcardo" , fa::vcardo }, + { "venus" , fa::venus }, + { "venusdouble" , fa::venusdouble }, + { "venusmars" , fa::venusmars }, + { "viacoin" , fa::viacoin }, + { "viadeo" , fa::viadeo }, + { "viadeosquare" , fa::viadeosquare }, + { "videocamera" , fa::videocamera }, + { "vimeo" , fa::vimeo }, + { "vimeosquare" , fa::vimeosquare }, + { "vine" , fa::vine }, + { "vk" , fa::vk }, + { "volumecontrolphone" , fa::volumecontrolphone }, + { "volumedown" , fa::volumedown }, + { "volumeoff" , fa::volumeoff }, + { "volumeup" , fa::volumeup }, + { "warning" , fa::warning }, + { "wechat" , fa::wechat }, + { "weibo" , fa::weibo }, + { "weixin" , fa::weixin }, + { "whatsapp" , fa::whatsapp }, + { "wheelchair" , fa::wheelchair }, + { "wheelchairalt" , fa::wheelchairalt }, + { "wifi" , fa::wifi }, + { "wikipediaw" , fa::wikipediaw }, + { "windowclose" , fa::windowclose }, + { "windowcloseo" , fa::windowcloseo }, + { "windowmaximize" , fa::windowmaximize }, + { "windowminimize" , fa::windowminimize }, + { "windowrestore" , fa::windowrestore }, + { "windows" , fa::windows }, + { "won" , fa::won }, + { "wordpress" , fa::wordpress }, + { "wpbeginner" , fa::wpbeginner }, + { "wpexplorer" , fa::wpexplorer }, + { "wpforms" , fa::wpforms }, + { "wrench" , fa::wrench }, + { "xing" , fa::xing }, + { "xingsquare" , fa::xingsquare }, + { "ycombinator" , fa::ycombinator }, + { "ycombinatorsquare" , fa::ycombinatorsquare }, + { "yahoo" , fa::yahoo }, + { "yc" , fa::yc }, + { "ycsquare" , fa::ycsquare }, + { "yelp" , fa::yelp }, + { "yen" , fa::yen }, + { "yoast" , fa::yoast }, + { "youtube" , fa::youtube }, + { "youtubeplay" , fa::youtubeplay }, + { "youtubesquare" , fa::youtubesquare } +}; + + +/// a specialized init function so font-awesome is loaded and initialized +/// this method return true on success, it will return false if the fnot cannot be initialized +/// To initialize QtAwesome with font-awesome you need to call this method +bool QtAwesome::initFontAwesome( ) +{ + static int fontAwesomeFontId = -1; + + // only load font-awesome once + if( fontAwesomeFontId < 0 ) { + + // The macro below internally calls "qInitResources_QtAwesome()". this initializes + // the resource system. For a .pri project this isn't required, but when building and using a + // static library the resource need to initialized first. + /// + // I've checked th qInitResource_* code and calling this method mutliple times shouldn't be any problem + // (More info about this subject: http://qt-project.org/wiki/QtResources) + Q_INIT_RESOURCE(QtAwesome); + + // load the font file + QFile res(":/fonts/fontawesome-4.7.0.ttf"); + if(!res.open(QIODevice::ReadOnly)) { + qDebug() << "Font awesome font could not be loaded!"; + return false; + } + QByteArray fontData( res.readAll() ); + res.close(); + + // fetch the given font + fontAwesomeFontId = QFontDatabase::addApplicationFontFromData(fontData); + } + + QStringList loadedFontFamilies = QFontDatabase::applicationFontFamilies(fontAwesomeFontId); + if( !loadedFontFamilies.empty() ) { + fontName_= loadedFontFamilies.at(0); + } else { + qDebug() << "Font awesome font is empty?!"; + fontAwesomeFontId = -1; // restore the font-awesome id + return false; + } + + // intialize the map + QHash& m = namedCodepoints_; + for (unsigned i = 0; i < sizeof(faNameIconArray)/sizeof(FANameIcon); ++i) { + m.insert(faNameIconArray[i].name, faNameIconArray[i].icon); + } + + return true; +} + +void QtAwesome::addNamedCodepoint( const QString& name, int codePoint) +{ + namedCodepoints_.insert( name, codePoint); +} + + +/// Sets a default option. These options are passed on to the icon painters +void QtAwesome::setDefaultOption(const QString& name, const QVariant& value) +{ + defaultOptions_.insert( name, value ); +} + + +/// Returns the default option for the given name +QVariant QtAwesome::defaultOption(const QString& name) +{ + return defaultOptions_.value( name ); +} + + +// internal helper method to merge to option amps +static QVariantMap mergeOptions( const QVariantMap& defaults, const QVariantMap& override ) +{ + QVariantMap result= defaults; + if( !override.isEmpty() ) { + QMapIterator itr(override); + while( itr.hasNext() ) { + itr.next(); + result.insert( itr.key(), itr.value() ); + } + } + return result; +} + + +/// Creates an icon with the given code-point +/// +/// awesome->icon( icon_group ) +/// +QIcon QtAwesome::icon(int character, const QVariantMap &options) +{ + // create a merged QVariantMap to have default options and icon-specific options + QVariantMap optionMap = mergeOptions( defaultOptions_, options ); + optionMap.insert("text", QString( QChar(static_cast(character)) ) ); + + return icon( fontIconPainter_, optionMap ); +} + + + +/// Creates an icon with the given name +/// +/// You can use the icon names as defined on http://fortawesome.github.io/Font-Awesome/design.html withour the 'icon-' prefix +/// @param name the name of the icon +/// @param options extra option to pass to the icon renderer +QIcon QtAwesome::icon(const QString& name, const QVariantMap& options) +{ + // when it's a named codepoint + if( namedCodepoints_.count(name) ) { + return icon( namedCodepoints_.value(name), options ); + } + + + // create a merged QVariantMap to have default options and icon-specific options + QVariantMap optionMap = mergeOptions( defaultOptions_, options ); + + // this method first tries to retrieve the icon + QtAwesomeIconPainter* painter = painterMap_.value(name); + if( !painter ) { + return QIcon(); + } + + return icon( painter, optionMap ); +} + +/// Create a dynamic icon by simlpy supplying a painter object +/// The ownership of the painter is NOT transfered. +/// @param painter a dynamic painter that is going to paint the icon +/// @param optionmap the options to pass to the painter +QIcon QtAwesome::icon(QtAwesomeIconPainter* painter, const QVariantMap& optionMap ) +{ + // Warning, when you use memoryleak detection. You should turn it of for the next call + // QIcon's placed in gui items are often cached and not deleted when my memory-leak detection checks for leaks. + // I'm not sure if it's a Qt bug or something I do wrong + QtAwesomeIconPainterIconEngine* engine = new QtAwesomeIconPainterIconEngine( this, painter, optionMap ); + return QIcon( engine ); +} + +/// Adds a named icon-painter to the QtAwesome icon map +/// As the name applies the ownership is passed over to QtAwesome +/// +/// @param name the name of the icon +/// @param painter the icon painter to add for this name +void QtAwesome::give(const QString& name, QtAwesomeIconPainter* painter) +{ + delete painterMap_.value( name ); // delete the old one + painterMap_.insert( name, painter ); +} + +/// Creates/Gets the icon font with a given size in pixels. This can be usefull to use a label for displaying icons +/// Example: +/// +/// QLabel* label = new QLabel( QChar( icon_group ) ); +/// label->setFont( awesome->font(16) ) +QFont QtAwesome::font( int size ) +{ + QFont font( fontName_); + font.setPixelSize(size); + return font; +} diff --git a/thirdparty/QtAwesome/QtAwesome/QtAwesome.h b/thirdparty/QtAwesome/QtAwesome/QtAwesome.h new file mode 100755 index 00000000..5aabd1bf --- /dev/null +++ b/thirdparty/QtAwesome/QtAwesome/QtAwesome.h @@ -0,0 +1,876 @@ +/** + * QtAwesome - use font-awesome (or other font icons) in your c++ / Qt Application + * + * MIT Licensed + * + * Copyright 2013-2015 - Reliable Bits Software by Blommers IT. All Rights Reserved. + * Author Rick Blommers + */ + +#ifndef QTAWESOME_H +#define QTAWESOME_H + +#include "QtAwesomeAnim.h" + +#include +#include +#include +#include +#include + + +/// A list of all icon-names with the codepoint (unicode-value) on the right +/// You can use the names on the page http://fortawesome.github.io/Font-Awesome/design.html +namespace fa { + enum icon { + fa_500px = 0xf26e, + addressbook = 0xf2b9, + addressbooko = 0xf2ba, + addresscard = 0xf2bb, + addresscardo = 0xf2bc, + adjust = 0xf042, + adn = 0xf170, + aligncenter = 0xf037, + alignjustify = 0xf039, + alignleft = 0xf036, + alignright = 0xf038, + amazon = 0xf270, + ambulance = 0xf0f9, + americansignlanguageinterpreting = 0xf2a3, + anchor = 0xf13d, + android = 0xf17b, + angellist = 0xf209, + angledoubledown = 0xf103, + angledoubleleft = 0xf100, + angledoubleright = 0xf101, + angledoubleup = 0xf102, + angledown = 0xf107, + angleleft = 0xf104, + angleright = 0xf105, + angleup = 0xf106, + apple = 0xf179, + archive = 0xf187, + areachart = 0xf1fe, + arrowcircledown = 0xf0ab, + arrowcircleleft = 0xf0a8, + arrowcircleodown = 0xf01a, + arrowcircleoleft = 0xf190, + arrowcircleoright = 0xf18e, + arrowcircleoup = 0xf01b, + arrowcircleright = 0xf0a9, + arrowcircleup = 0xf0aa, + arrowdown = 0xf063, + arrowleft = 0xf060, + arrowright = 0xf061, + arrowup = 0xf062, + arrows = 0xf047, + arrowsalt = 0xf0b2, + arrowsh = 0xf07e, + arrowsv = 0xf07d, + aslinterpreting = 0xf2a3, + assistivelisteningsystems = 0xf2a2, + asterisk = 0xf069, + at = 0xf1fa, + audiodescription = 0xf29e, + automobile = 0xf1b9, + backward = 0xf04a, + balancescale = 0xf24e, + ban = 0xf05e, + bandcamp = 0xf2d5, + bank = 0xf19c, + barchart = 0xf080, + barcharto = 0xf080, + barcode = 0xf02a, + bars = 0xf0c9, + bath = 0xf2cd, + bathtub = 0xf2cd, + battery = 0xf240, + battery0 = 0xf244, + battery1 = 0xf243, + battery2 = 0xf242, + battery3 = 0xf241, + battery4 = 0xf240, + batteryempty = 0xf244, + batteryfull = 0xf240, + batteryhalf = 0xf242, + batteryquarter = 0xf243, + batterythreequarters = 0xf241, + bed = 0xf236, + beer = 0xf0fc, + behance = 0xf1b4, + behancesquare = 0xf1b5, + bell = 0xf0f3, + bello = 0xf0a2, + bellslash = 0xf1f6, + bellslasho = 0xf1f7, + bicycle = 0xf206, + binoculars = 0xf1e5, + birthdaycake = 0xf1fd, + bitbucket = 0xf171, + bitbucketsquare = 0xf172, + bitcoin = 0xf15a, + blacktie = 0xf27e, + blind = 0xf29d, + bluetooth = 0xf293, + bluetoothb = 0xf294, + bold = 0xf032, + bolt = 0xf0e7, + bomb = 0xf1e2, + book = 0xf02d, + bookmark = 0xf02e, + bookmarko = 0xf097, + braille = 0xf2a1, + briefcase = 0xf0b1, + btc = 0xf15a, + bug = 0xf188, + building = 0xf1ad, + buildingo = 0xf0f7, + bullhorn = 0xf0a1, + bullseye = 0xf140, + bus = 0xf207, + buysellads = 0xf20d, + cab = 0xf1ba, + calculator = 0xf1ec, + calendar = 0xf073, + calendarchecko = 0xf274, + calendarminuso = 0xf272, + calendaro = 0xf133, + calendarpluso = 0xf271, + calendartimeso = 0xf273, + camera = 0xf030, + cameraretro = 0xf083, + car = 0xf1b9, + caretdown = 0xf0d7, + caretleft = 0xf0d9, + caretright = 0xf0da, + caretsquareodown = 0xf150, + caretsquareoleft = 0xf191, + caretsquareoright = 0xf152, + caretsquareoup = 0xf151, + caretup = 0xf0d8, + cartarrowdown = 0xf218, + cartplus = 0xf217, + cc = 0xf20a, + ccamex = 0xf1f3, + ccdinersclub = 0xf24c, + ccdiscover = 0xf1f2, + ccjcb = 0xf24b, + ccmastercard = 0xf1f1, + ccpaypal = 0xf1f4, + ccstripe = 0xf1f5, + ccvisa = 0xf1f0, + certificate = 0xf0a3, + chain = 0xf0c1, + chainbroken = 0xf127, + check = 0xf00c, + checkcircle = 0xf058, + checkcircleo = 0xf05d, + checksquare = 0xf14a, + checksquareo = 0xf046, + chevroncircledown = 0xf13a, + chevroncircleleft = 0xf137, + chevroncircleright = 0xf138, + chevroncircleup = 0xf139, + chevrondown = 0xf078, + chevronleft = 0xf053, + chevronright = 0xf054, + chevronup = 0xf077, + child = 0xf1ae, + chrome = 0xf268, + circle = 0xf111, + circleo = 0xf10c, + circleonotch = 0xf1ce, + circlethin = 0xf1db, + clipboard = 0xf0ea, + clocko = 0xf017, + clone = 0xf24d, + close = 0xf00d, + cloud = 0xf0c2, + clouddownload = 0xf0ed, + cloudupload = 0xf0ee, + cny = 0xf157, + code = 0xf121, + codefork = 0xf126, + codepen = 0xf1cb, + codiepie = 0xf284, + coffee = 0xf0f4, + cog = 0xf013, + cogs = 0xf085, + columns = 0xf0db, + comment = 0xf075, + commento = 0xf0e5, + commenting = 0xf27a, + commentingo = 0xf27b, + comments = 0xf086, + commentso = 0xf0e6, + compass = 0xf14e, + compress = 0xf066, + connectdevelop = 0xf20e, + contao = 0xf26d, + copy = 0xf0c5, + copyright = 0xf1f9, + creativecommons = 0xf25e, + creditcard = 0xf09d, + creditcardalt = 0xf283, + crop = 0xf125, + crosshairs = 0xf05b, + css3 = 0xf13c, + cube = 0xf1b2, + cubes = 0xf1b3, + cut = 0xf0c4, + cutlery = 0xf0f5, + dashboard = 0xf0e4, + dashcube = 0xf210, + database = 0xf1c0, + deaf = 0xf2a4, + deafness = 0xf2a4, + dedent = 0xf03b, + delicious = 0xf1a5, + desktop = 0xf108, + deviantart = 0xf1bd, + diamond = 0xf219, + digg = 0xf1a6, + dollar = 0xf155, + dotcircleo = 0xf192, + download = 0xf019, + dribbble = 0xf17d, + driverslicense = 0xf2c2, + driverslicenseo = 0xf2c3, + dropbox = 0xf16b, + drupal = 0xf1a9, + edge = 0xf282, + edit = 0xf044, + eercast = 0xf2da, + eject = 0xf052, + ellipsish = 0xf141, + ellipsisv = 0xf142, + empire = 0xf1d1, + envelope = 0xf0e0, + envelopeo = 0xf003, + envelopeopen = 0xf2b6, + envelopeopeno = 0xf2b7, + envelopesquare = 0xf199, + envira = 0xf299, + eraser = 0xf12d, + etsy = 0xf2d7, + eur = 0xf153, + euro = 0xf153, + exchange = 0xf0ec, + exclamation = 0xf12a, + exclamationcircle = 0xf06a, + exclamationtriangle = 0xf071, + expand = 0xf065, + expeditedssl = 0xf23e, + externallink = 0xf08e, + externallinksquare = 0xf14c, + eye = 0xf06e, + eyeslash = 0xf070, + eyedropper = 0xf1fb, + fa = 0xf2b4, + facebook = 0xf09a, + facebookf = 0xf09a, + facebookofficial = 0xf230, + facebooksquare = 0xf082, + fastbackward = 0xf049, + fastforward = 0xf050, + fax = 0xf1ac, + feed = 0xf09e, + female = 0xf182, + fighterjet = 0xf0fb, + file = 0xf15b, + filearchiveo = 0xf1c6, + fileaudioo = 0xf1c7, + filecodeo = 0xf1c9, + fileexcelo = 0xf1c3, + fileimageo = 0xf1c5, + filemovieo = 0xf1c8, + fileo = 0xf016, + filepdfo = 0xf1c1, + filephotoo = 0xf1c5, + filepictureo = 0xf1c5, + filepowerpointo = 0xf1c4, + filesoundo = 0xf1c7, + filetext = 0xf15c, + filetexto = 0xf0f6, + filevideoo = 0xf1c8, + filewordo = 0xf1c2, + filezipo = 0xf1c6, + fileso = 0xf0c5, + film = 0xf008, + filter = 0xf0b0, + fire = 0xf06d, + fireextinguisher = 0xf134, + firefox = 0xf269, + firstorder = 0xf2b0, + flag = 0xf024, + flagcheckered = 0xf11e, + flago = 0xf11d, + flash = 0xf0e7, + flask = 0xf0c3, + flickr = 0xf16e, + floppyo = 0xf0c7, + folder = 0xf07b, + foldero = 0xf114, + folderopen = 0xf07c, + folderopeno = 0xf115, + font = 0xf031, + fontawesome = 0xf2b4, + fonticons = 0xf280, + fortawesome = 0xf286, + forumbee = 0xf211, + forward = 0xf04e, + foursquare = 0xf180, + freecodecamp = 0xf2c5, + frowno = 0xf119, + futbolo = 0xf1e3, + gamepad = 0xf11b, + gavel = 0xf0e3, + gbp = 0xf154, + ge = 0xf1d1, + gear = 0xf013, + gears = 0xf085, + genderless = 0xf22d, + getpocket = 0xf265, + gg = 0xf260, + ggcircle = 0xf261, + gift = 0xf06b, + git = 0xf1d3, + gitsquare = 0xf1d2, + github = 0xf09b, + githubalt = 0xf113, + githubsquare = 0xf092, + gitlab = 0xf296, + gittip = 0xf184, + glass = 0xf000, + glide = 0xf2a5, + glideg = 0xf2a6, + globe = 0xf0ac, + google = 0xf1a0, + googleplus = 0xf0d5, + googlepluscircle = 0xf2b3, + googleplusofficial = 0xf2b3, + googleplussquare = 0xf0d4, + googlewallet = 0xf1ee, + graduationcap = 0xf19d, + gratipay = 0xf184, + grav = 0xf2d6, + group = 0xf0c0, + hsquare = 0xf0fd, + hackernews = 0xf1d4, + handgrabo = 0xf255, + handlizardo = 0xf258, + handodown = 0xf0a7, + handoleft = 0xf0a5, + handoright = 0xf0a4, + handoup = 0xf0a6, + handpapero = 0xf256, + handpeaceo = 0xf25b, + handpointero = 0xf25a, + handrocko = 0xf255, + handscissorso = 0xf257, + handspocko = 0xf259, + handstopo = 0xf256, + handshakeo = 0xf2b5, + hardofhearing = 0xf2a4, + hashtag = 0xf292, + hddo = 0xf0a0, + header = 0xf1dc, + headphones = 0xf025, + heart = 0xf004, + hearto = 0xf08a, + heartbeat = 0xf21e, + history = 0xf1da, + home = 0xf015, + hospitalo = 0xf0f8, + hotel = 0xf236, + hourglass = 0xf254, + hourglass1 = 0xf251, + hourglass2 = 0xf252, + hourglass3 = 0xf253, + hourglassend = 0xf253, + hourglasshalf = 0xf252, + hourglasso = 0xf250, + hourglassstart = 0xf251, + houzz = 0xf27c, + html5 = 0xf13b, + icursor = 0xf246, + idbadge = 0xf2c1, + idcard = 0xf2c2, + idcardo = 0xf2c3, + ils = 0xf20b, + image = 0xf03e, + imdb = 0xf2d8, + inbox = 0xf01c, + indent = 0xf03c, + industry = 0xf275, + info = 0xf129, + infocircle = 0xf05a, + inr = 0xf156, + instagram = 0xf16d, + institution = 0xf19c, + internetexplorer = 0xf26b, + intersex = 0xf224, + ioxhost = 0xf208, + italic = 0xf033, + joomla = 0xf1aa, + jpy = 0xf157, + jsfiddle = 0xf1cc, + key = 0xf084, + keyboardo = 0xf11c, + krw = 0xf159, + language = 0xf1ab, + laptop = 0xf109, + lastfm = 0xf202, + lastfmsquare = 0xf203, + leaf = 0xf06c, + leanpub = 0xf212, + legal = 0xf0e3, + lemono = 0xf094, + leveldown = 0xf149, + levelup = 0xf148, + lifebouy = 0xf1cd, + lifebuoy = 0xf1cd, + lifering = 0xf1cd, + lifesaver = 0xf1cd, + lightbulbo = 0xf0eb, + linechart = 0xf201, + link = 0xf0c1, + linkedin = 0xf0e1, + linkedinsquare = 0xf08c, + linode = 0xf2b8, + fa_linux = 0xf17c, + list = 0xf03a, + listalt = 0xf022, + listol = 0xf0cb, + listul = 0xf0ca, + locationarrow = 0xf124, + lock = 0xf023, + longarrowdown = 0xf175, + longarrowleft = 0xf177, + longarrowright = 0xf178, + longarrowup = 0xf176, + lowvision = 0xf2a8, + magic = 0xf0d0, + magnet = 0xf076, + mailforward = 0xf064, + mailreply = 0xf112, + mailreplyall = 0xf122, + male = 0xf183, + map = 0xf279, + mapmarker = 0xf041, + mapo = 0xf278, + mappin = 0xf276, + mapsigns = 0xf277, + mars = 0xf222, + marsdouble = 0xf227, + marsstroke = 0xf229, + marsstrokeh = 0xf22b, + marsstrokev = 0xf22a, + maxcdn = 0xf136, + meanpath = 0xf20c, + medium = 0xf23a, + medkit = 0xf0fa, + meetup = 0xf2e0, + meho = 0xf11a, + mercury = 0xf223, + microchip = 0xf2db, + microphone = 0xf130, + microphoneslash = 0xf131, + minus = 0xf068, + minuscircle = 0xf056, + minussquare = 0xf146, + minussquareo = 0xf147, + mixcloud = 0xf289, + mobile = 0xf10b, + mobilephone = 0xf10b, + modx = 0xf285, + money = 0xf0d6, + moono = 0xf186, + mortarboard = 0xf19d, + motorcycle = 0xf21c, + mousepointer = 0xf245, + music = 0xf001, + navicon = 0xf0c9, + neuter = 0xf22c, + newspapero = 0xf1ea, + objectgroup = 0xf247, + objectungroup = 0xf248, + odnoklassniki = 0xf263, + odnoklassnikisquare = 0xf264, + opencart = 0xf23d, + openid = 0xf19b, + opera = 0xf26a, + optinmonster = 0xf23c, + outdent = 0xf03b, + pagelines = 0xf18c, + paintbrush = 0xf1fc, + paperplane = 0xf1d8, + paperplaneo = 0xf1d9, + paperclip = 0xf0c6, + paragraph = 0xf1dd, + paste = 0xf0ea, + pause = 0xf04c, + pausecircle = 0xf28b, + pausecircleo = 0xf28c, + paw = 0xf1b0, + paypal = 0xf1ed, + pencil = 0xf040, + pencilsquare = 0xf14b, + pencilsquareo = 0xf044, + percent = 0xf295, + phone = 0xf095, + phonesquare = 0xf098, + photo = 0xf03e, + pictureo = 0xf03e, + piechart = 0xf200, + piedpiper = 0xf2ae, + piedpiperalt = 0xf1a8, + piedpiperpp = 0xf1a7, + pinterest = 0xf0d2, + pinterestp = 0xf231, + pinterestsquare = 0xf0d3, + plane = 0xf072, + play = 0xf04b, + playcircle = 0xf144, + playcircleo = 0xf01d, + plug = 0xf1e6, + plus = 0xf067, + pluscircle = 0xf055, + plussquare = 0xf0fe, + plussquareo = 0xf196, + podcast = 0xf2ce, + poweroff = 0xf011, + print = 0xf02f, + producthunt = 0xf288, + puzzlepiece = 0xf12e, + qq = 0xf1d6, + qrcode = 0xf029, + question = 0xf128, + questioncircle = 0xf059, + questioncircleo = 0xf29c, + quora = 0xf2c4, + quoteleft = 0xf10d, + quoteright = 0xf10e, + ra = 0xf1d0, + random = 0xf074, + ravelry = 0xf2d9, + rebel = 0xf1d0, + recycle = 0xf1b8, + reddit = 0xf1a1, + redditalien = 0xf281, + redditsquare = 0xf1a2, + refresh = 0xf021, + registered = 0xf25d, + remove = 0xf00d, + renren = 0xf18b, + reorder = 0xf0c9, + repeat = 0xf01e, + reply = 0xf112, + replyall = 0xf122, + resistance = 0xf1d0, + retweet = 0xf079, + rmb = 0xf157, + road = 0xf018, + rocket = 0xf135, + rotateleft = 0xf0e2, + rotateright = 0xf01e, + rouble = 0xf158, + rss = 0xf09e, + rsssquare = 0xf143, + rub = 0xf158, + ruble = 0xf158, + rupee = 0xf156, + s15 = 0xf2cd, + safari = 0xf267, + save = 0xf0c7, + scissors = 0xf0c4, + scribd = 0xf28a, + search = 0xf002, + searchminus = 0xf010, + searchplus = 0xf00e, + sellsy = 0xf213, + send = 0xf1d8, + sendo = 0xf1d9, + server = 0xf233, + share = 0xf064, + sharealt = 0xf1e0, + sharealtsquare = 0xf1e1, + sharesquare = 0xf14d, + sharesquareo = 0xf045, + shekel = 0xf20b, + sheqel = 0xf20b, + shield = 0xf132, + ship = 0xf21a, + shirtsinbulk = 0xf214, + shoppingbag = 0xf290, + shoppingbasket = 0xf291, + shoppingcart = 0xf07a, + shower = 0xf2cc, + signin = 0xf090, + signlanguage = 0xf2a7, + signout = 0xf08b, + signal = 0xf012, + signing = 0xf2a7, + simplybuilt = 0xf215, + sitemap = 0xf0e8, + skyatlas = 0xf216, + skype = 0xf17e, + slack = 0xf198, + sliders = 0xf1de, + slideshare = 0xf1e7, + smileo = 0xf118, + snapchat = 0xf2ab, + snapchatghost = 0xf2ac, + snapchatsquare = 0xf2ad, + snowflakeo = 0xf2dc, + soccerballo = 0xf1e3, + sort = 0xf0dc, + sortalphaasc = 0xf15d, + sortalphadesc = 0xf15e, + sortamountasc = 0xf160, + sortamountdesc = 0xf161, + sortasc = 0xf0de, + sortdesc = 0xf0dd, + sortdown = 0xf0dd, + sortnumericasc = 0xf162, + sortnumericdesc = 0xf163, + sortup = 0xf0de, + soundcloud = 0xf1be, + spaceshuttle = 0xf197, + spinner = 0xf110, + spoon = 0xf1b1, + spotify = 0xf1bc, + square = 0xf0c8, + squareo = 0xf096, + stackexchange = 0xf18d, + stackoverflow = 0xf16c, + star = 0xf005, + starhalf = 0xf089, + starhalfempty = 0xf123, + starhalffull = 0xf123, + starhalfo = 0xf123, + staro = 0xf006, + steam = 0xf1b6, + steamsquare = 0xf1b7, + stepbackward = 0xf048, + stepforward = 0xf051, + stethoscope = 0xf0f1, + stickynote = 0xf249, + stickynoteo = 0xf24a, + stop = 0xf04d, + stopcircle = 0xf28d, + stopcircleo = 0xf28e, + streetview = 0xf21d, + strikethrough = 0xf0cc, + stumbleupon = 0xf1a4, + stumbleuponcircle = 0xf1a3, + subscript = 0xf12c, + subway = 0xf239, + suitcase = 0xf0f2, + suno = 0xf185, + superpowers = 0xf2dd, + superscript = 0xf12b, + support = 0xf1cd, + table = 0xf0ce, + tablet = 0xf10a, + tachometer = 0xf0e4, + tag = 0xf02b, + tags = 0xf02c, + tasks = 0xf0ae, + taxi = 0xf1ba, + telegram = 0xf2c6, + television = 0xf26c, + tencentweibo = 0xf1d5, + terminal = 0xf120, + textheight = 0xf034, + textwidth = 0xf035, + th = 0xf00a, + thlarge = 0xf009, + thlist = 0xf00b, + themeisle = 0xf2b2, + thermometer = 0xf2c7, + thermometer0 = 0xf2cb, + thermometer1 = 0xf2ca, + thermometer2 = 0xf2c9, + thermometer3 = 0xf2c8, + thermometer4 = 0xf2c7, + thermometerempty = 0xf2cb, + thermometerfull = 0xf2c7, + thermometerhalf = 0xf2c9, + thermometerquarter = 0xf2ca, + thermometerthreequarters = 0xf2c8, + thumbtack = 0xf08d, + thumbsdown = 0xf165, + thumbsodown = 0xf088, + thumbsoup = 0xf087, + thumbsup = 0xf164, + ticket = 0xf145, + times = 0xf00d, + timescircle = 0xf057, + timescircleo = 0xf05c, + timesrectangle = 0xf2d3, + timesrectangleo = 0xf2d4, + tint = 0xf043, + toggledown = 0xf150, + toggleleft = 0xf191, + toggleoff = 0xf204, + toggleon = 0xf205, + toggleright = 0xf152, + toggleup = 0xf151, + trademark = 0xf25c, + train = 0xf238, + transgender = 0xf224, + transgenderalt = 0xf225, + trash = 0xf1f8, + trasho = 0xf014, + tree = 0xf1bb, + trello = 0xf181, + tripadvisor = 0xf262, + trophy = 0xf091, + truck = 0xf0d1, + fa_try = 0xf195, + tty = 0xf1e4, + tumblr = 0xf173, + tumblrsquare = 0xf174, + turkishlira = 0xf195, + tv = 0xf26c, + twitch = 0xf1e8, + twitter = 0xf099, + twittersquare = 0xf081, + umbrella = 0xf0e9, + underline = 0xf0cd, + undo = 0xf0e2, + universalaccess = 0xf29a, + university = 0xf19c, + unlink = 0xf127, + unlock = 0xf09c, + unlockalt = 0xf13e, + unsorted = 0xf0dc, + upload = 0xf093, + usb = 0xf287, + usd = 0xf155, + user = 0xf007, + usercircle = 0xf2bd, + usercircleo = 0xf2be, + usermd = 0xf0f0, + usero = 0xf2c0, + userplus = 0xf234, + usersecret = 0xf21b, + usertimes = 0xf235, + users = 0xf0c0, + vcard = 0xf2bb, + vcardo = 0xf2bc, + venus = 0xf221, + venusdouble = 0xf226, + venusmars = 0xf228, + viacoin = 0xf237, + viadeo = 0xf2a9, + viadeosquare = 0xf2aa, + videocamera = 0xf03d, + vimeo = 0xf27d, + vimeosquare = 0xf194, + vine = 0xf1ca, + vk = 0xf189, + volumecontrolphone = 0xf2a0, + volumedown = 0xf027, + volumeoff = 0xf026, + volumeup = 0xf028, + warning = 0xf071, + wechat = 0xf1d7, + weibo = 0xf18a, + weixin = 0xf1d7, + whatsapp = 0xf232, + wheelchair = 0xf193, + wheelchairalt = 0xf29b, + wifi = 0xf1eb, + wikipediaw = 0xf266, + windowclose = 0xf2d3, + windowcloseo = 0xf2d4, + windowmaximize = 0xf2d0, + windowminimize = 0xf2d1, + windowrestore = 0xf2d2, + windows = 0xf17a, + won = 0xf159, + wordpress = 0xf19a, + wpbeginner = 0xf297, + wpexplorer = 0xf2de, + wpforms = 0xf298, + wrench = 0xf0ad, + xing = 0xf168, + xingsquare = 0xf169, + ycombinator = 0xf23b, + ycombinatorsquare = 0xf1d4, + yahoo = 0xf19e, + yc = 0xf23b, + ycsquare = 0xf1d4, + yelp = 0xf1e9, + yen = 0xf157, + yoast = 0xf2b1, + youtube = 0xf167, + youtubeplay = 0xf16a, + youtubesquare = 0xf166 + }; +} + + + +//--------------------------------------------------------------------------------------- + +class QtAwesomeIconPainter; + +/// The main class for managing icons +/// This class requires a 2-phase construction. You must first create the class and then initialize it via an init* method +class QtAwesome : public QObject +{ +Q_OBJECT + +public: + + explicit QtAwesome(QObject *parent = 0); + virtual ~QtAwesome(); + + void init( const QString& fontname ); + bool initFontAwesome(); + + void addNamedCodepoint( const QString& name, int codePoint ); + QHash namedCodePoints() { return namedCodepoints_; } + + void setDefaultOption( const QString& name, const QVariant& value ); + QVariant defaultOption( const QString& name ); + + QIcon icon( int character, const QVariantMap& options = QVariantMap() ); + QIcon icon( const QString& name, const QVariantMap& options = QVariantMap() ); + QIcon icon(QtAwesomeIconPainter* painter, const QVariantMap& optionMap = QVariantMap() ); + + void give( const QString& name, QtAwesomeIconPainter* painter ); + + QFont font( int size ); + + /// Returns the font-name that is used as icon-map + QString fontName() { return fontName_ ; } + +private: + QString fontName_; ///< The font name used for this map + QHash namedCodepoints_; ///< A map with names mapped to code-points + + QHash painterMap_; ///< A map of custom painters + QVariantMap defaultOptions_; ///< The default icon options + QtAwesomeIconPainter* fontIconPainter_; ///< A special painter fo painting codepoints +}; + + +//--------------------------------------------------------------------------------------- + + +/// The QtAwesomeIconPainter is a specialized painter for painting icons +/// your can implement an iconpainter to create custom font-icon code +class QtAwesomeIconPainter +{ +public: + virtual ~QtAwesomeIconPainter() {} + virtual void paint( QtAwesome* awesome, QPainter* painter, const QRect& rect, QIcon::Mode mode, QIcon::State state, const QVariantMap& options ) = 0; +}; + +Q_DECLARE_METATYPE(QtAwesomeAnimation*) + +#endif // QTAWESOME_H diff --git a/thirdparty/QtAwesome/QtAwesome/QtAwesome.pri b/thirdparty/QtAwesome/QtAwesome/QtAwesome.pri new file mode 100755 index 00000000..caef09b4 --- /dev/null +++ b/thirdparty/QtAwesome/QtAwesome/QtAwesome.pri @@ -0,0 +1,12 @@ + +INCLUDEPATH += $$PWD + +SOURCES += $$PWD/QtAwesome.cpp \ + $$PWD/QtAwesomeAnim.cpp + +HEADERS += $$PWD/QtAwesome.h \ + $$PWD/QtAwesomeAnim.h + +RESOURCES += $$PWD/QtAwesome.qrc + + diff --git a/thirdparty/QtAwesome/QtAwesome/QtAwesome.pro b/thirdparty/QtAwesome/QtAwesome/QtAwesome.pro new file mode 100755 index 00000000..4bf64d64 --- /dev/null +++ b/thirdparty/QtAwesome/QtAwesome/QtAwesome.pro @@ -0,0 +1,29 @@ +#------------------------------------------------- +# +# Project created by QtCreator 2013-04-18T13:28:42 +# +#------------------------------------------------- + +TARGET = QtAwesome +TEMPLATE = lib +CONFIG += staticlib c++11 +QT += widgets + +SOURCES += QtAwesome.cpp QtAwesomeAnim.cpp +HEADERS += QtAwesome.h QtAwesomeAnim.h + +isEmpty(PREFIX) { + unix { + PREFIX = /usr + } else { + PREFIX = $$[QT_INSTALL_PREFIX] + } +} + +install_headers.files = QtAwesome.h QtAwesomeAnim.h +install_headers.path = $$PREFIX/include +target.path = $$PREFIX/lib +INSTALLS += install_headers target + +RESOURCES += \ + QtAwesome.qrc diff --git a/thirdparty/QtAwesome/QtAwesome/QtAwesome.qrc b/thirdparty/QtAwesome/QtAwesome/QtAwesome.qrc new file mode 100755 index 00000000..db80a8e1 --- /dev/null +++ b/thirdparty/QtAwesome/QtAwesome/QtAwesome.qrc @@ -0,0 +1,5 @@ + + + fonts/fontawesome-4.7.0.ttf + + diff --git a/thirdparty/QtAwesome/QtAwesome/QtAwesomeAnim.cpp b/thirdparty/QtAwesome/QtAwesome/QtAwesomeAnim.cpp new file mode 100755 index 00000000..8ad44b68 --- /dev/null +++ b/thirdparty/QtAwesome/QtAwesome/QtAwesomeAnim.cpp @@ -0,0 +1,46 @@ +#include "QtAwesomeAnim.h" + +#include +#include +#include +#include +#include + + +QtAwesomeAnimation::QtAwesomeAnimation(QWidget *parentWidget, int interval, int step) + : parentWidgetRef_( parentWidget ) + , timer_( 0 ) + , interval_( interval ) + , step_( step ) + , angle_( 0.0f ) +{ + +} + +void QtAwesomeAnimation::setup( QPainter &painter, const QRect &rect) +{ + // first time set the timer + if( !timer_ ) + { + timer_ = new QTimer(); + connect(timer_,SIGNAL(timeout()), this, SLOT(update()) ); + timer_->start(interval_); + } + else + { + //timer, angle, self.step = self.info[self.parent_widget] + float x_center = rect.width() * 0.5; + float y_center = rect.height() * 0.5; + painter.translate(x_center, y_center); + painter.rotate(angle_); + painter.translate(-x_center, -y_center); + } +} + + +void QtAwesomeAnimation::update() +{ + angle_ += step_; + angle_ = std::fmod( angle_, 360); + parentWidgetRef_->update(); +} diff --git a/thirdparty/QtAwesome/QtAwesome/QtAwesomeAnim.h b/thirdparty/QtAwesome/QtAwesome/QtAwesomeAnim.h new file mode 100755 index 00000000..5e3d11d6 --- /dev/null +++ b/thirdparty/QtAwesome/QtAwesome/QtAwesomeAnim.h @@ -0,0 +1,36 @@ +#ifndef QTAWESOMEANIMATION_H +#define QTAWESOMEANIMATION_H + +#include + +class QPainter; +class QRect; +class QTimer; +class QWidget; + +/// +/// Basic Animation Support for QtAwesome (Inspired by https://github.com/spyder-ide/qtawesome) +/// +class QtAwesomeAnimation : public QObject +{ +Q_OBJECT + +public: + QtAwesomeAnimation( QWidget* parentWidget, int interval=10, int step=1); + + void setup( QPainter& painter, const QRect& rect ); + +public slots: + void update(); + +private: + QWidget* parentWidgetRef_; + QTimer* timer_; + int interval_; + int step_; + float angle_; + +}; + + +#endif // QTAWESOMEANIMATION_H diff --git a/thirdparty/QtAwesome/QtAwesome/fonts/fontawesome-4.7.0.ttf b/thirdparty/QtAwesome/QtAwesome/fonts/fontawesome-4.7.0.ttf new file mode 100755 index 0000000000000000000000000000000000000000..35acda2fa1196aad98c2adf4378a7611dd713aa3 GIT binary patch literal 165548 zcmd4434D~*)jxjkv&@#+*JQHIB(r2Agk&ZO5W=u;0Z~v85Ce*$fTDsRbs2>!AXP+E zv})s8XszXKwXa&S)7IKescosX*7l99R$G?_w7v?NC%^Bx&rC7|(E7f=|L^lpa-Zk9 z`?>d?d+s^so_oVMW6Z|VOlEVZPMtq{)pOIHX3~v25n48F@|3AkA5-983xDXec_W** zHg8HX#uvihecqa7Yb`$*a~)&Wy^KjmE?joS+JOO-B;B|Y@umw`Uvs>da>d0W;5qQ!4Qz zJxL+bkEIe8*8}j>Q>BETG1+ht-^o+}utRA<*p2#Ix&jHe=hB??wf3sZuV5(_`d1DH zgI+ncCI1s*Tuw6@6DFOB@-mE3%l-{_4z<*f9!g8!dcoz@f1eyoO9;V5yN|*Pk0}XYPFk z!g(%@Qka**;2iW8;b{R|Dg0FbU_E9^hd3H%a#EV5;HVvgVS_k;c*=`1YN*`2lhZm3 zqOTF2Pfz8N%lA<(eJUSDWevumUJ;MocT>zZ5W08%2JkP2szU{CP(((>LmzOmB>ZOpelu zIw>A5mu@gGU}>QA1RKFi-$*aQL_KL1GNuOxs0@)VEz%g?77_AY_{e55-&2X`IC z!*9krPH>;hA+4QUe(ZB_4Z@L!DgUN;`X-m}3;G6(Mf9flyest6ciunvokm)?oZmzF z@?{e2C{v;^ys6AQy_IN=B99>#C*fPn3ra`%a_!FN6aIXi^rn1ymrrZ@gw3bA$$zqb zqOxiHDSsYDDkGmZpD$nT@HfSi%fmt6l*S0Iupll)-&7{*yFioy4w3x%GVEpx@jWf@QO?itTs?#7)d3a-Ug&FLt_)FMnmOp5gGJy@z7B*(^RVW^e1dkQ zkMHw*dK%Ayu_({yrG6RifN!GjP=|nt${60CMrjDAK)0HZCYpnJB&8QF&0_TaoF9-S zu?&_mPAU0&@X=Qpc>I^~UdvKIk0usk``F{`3HAbeHC$CyQPtgN@2lwR?3>fKwC|F> zYx{2LyT9-8zVGxM?E7=y2YuRM`{9bijfXoA&pEvG@Fj<@J$%dI`wu^U__@Oe5C8e_ z2ZyyI_9GQXI*-gbvh>I$N3K0`%aQw!JbvW4BL|QC`N#+Vf_#9QLu~J`8d;ySFWi^v zo7>mjx3(|cx3jOOZ+~B=@8!PUzP`iku=8-}aMR(`;kk#q53fC(KD_gA&*A-tGlyS3 z+m)8@1~El#u3as^j;LR~)}{9CG~D_9MNw(aQga zKO~TeK}MY%7{tgG{veXj;r|am2GwFztR{2O|5v~?px`g+cB0=PQ}aFOx^-}vA95F5 zA7=4<%*Y5_FJ|j%P>qdnh_@iTs0Qv3Shg)-OV0=S+zU1vekc4cfZ>81?nWLD;PJf5 zm^TgA&zNr~$ZdkLfD=nH@)f_xSjk$*;M3uDgT;zqnj*X$`6@snD%LSpiMm2N;QAN~ z_kcBPVyrp@Qi?Q@UdCdRu{^&CvWYrt=QCD^e09&FD^N$nM_`>%e`5*`?~&bbh->n~ zJ(9*nTC4`EGNEOm%t%U8(?hP3%1b;hjQAV0Nc?8hxeG3 zaPKiTHp5uQTE@n~b#}l3uJMQ)kGfOHpF%kkn&43O#D#F5Fg6KwPr4VR9c4{M`YDK; z3jZ{uoAx?m(^2k>9gNLvXKdDEjCCQ+Y~-2K00%hd9AfOW{fx~8OmhL>=?SSyfsZaC!Gt-z(=`WU+-&Dfn0#_n3e*q()q-CYLpelpxsjC~b#-P^<1eJJmK#NGc1 zV_&XPb2-)pD^|e^5@<6_cHeE7RC;w7<*1(><1_>^E_ievcm0P?8kubdDQj%vyA=3 z3HKCZFYIRQXH9UujQt#S{T$`}0_FTN4TrE7KVs}9q&bK>55B|Lul6(cGRpdO1Kd`| zeq(~e`?pp&g#Y$EXw}*o`yJwccQ0eFbi*Ov?^iSS>U6j#82bal{s6dMn-2#V{#Xo$ zI$lq~{fx0cA?=^g&OdKq?7tBAUym`?3z*+P_+QpC_SX>Hn~c4gX6!Ab|67K!w~_Ac z_ZWKz;eUUXv46n53-{h3#@>IKu@7En?4O7`qA>R1M~r=hy#Got_OTNVaQ-*)f3gq` zWqlf9>?rCwhC2Ie;GSYEYlZ8Edx9~|1c$Hz6P6|~v_elnBK`=R&nMuzUuN8VKI0ZA z+#be@iW#>ma1S$XYhc_CQta5uxC`H|9>(1-GVW=IdlO`OC*!^vIHdJ2gzINKkYT)d z3*#jl84q5~c0(mMGIK+jJFO2k6NLvlqs#h}}L0klN#8)z2^A6*6 zU5q!Nj7Gdit%LiB@#bE}TbkhZGoIMXcoN~QNYfU9dezGK=;@4)al-X6K6WSL9b4dD zWqdqfOo0cRfI27sjPXfulka7G3er!7o3@tm>3GioJTpUZZ!$jX5aV4vjL$A+d`^n- zxp1e$e?~9k^CmMsKg9T%fbFbqIHX;GIu<72kYZMzEPZ`#55myqXbyss&PdzkU-kng%ZaGx-qUd{ORDE9`W-<*I${1)W@@_xo| z#P?RjZA0Ge?Tp_{4)ER51-F;+Tjw*r6ZPHZW&C#J-;MVj3S2+qccSdOkoNAY8NUbR z-HUYhnc!Y!{C@9;sxqIIma{CrC z{*4;OzZrsik@3eKWBglt8Gju9$G0;6ZPfp5`1hya;Q!vUjQ{6qsNQ=S2c6;1ApV)% zjDJ4@_b}tnn&43HfiA|MBZsgbpsdVv#(xMHfA~D(KUU!0Wc>La#(y%O@fT{~-ede{ zR>pr0_Y2hXOT@kS3F8L=^RH0;%c~jx_4$nd=5@w@I~NXdzuUt2E2!)DYvKACfAu5A zUwe%4KcdXn;r@iOKr8s4QQm)bG5$uH@xLJ7o5hU3g}A?UF#a~+dV4S9??m7ZG5+_} zjQ<05{sZ6d0><|ea8JQ~#Q6It>z^jLhZ*lv;9g|>Fxqwm@O+4TAHKu*zfkVS4R9I8 z{~NIVcQ50g0KQKVb`<_&>lp7xn*Q?{2i@S=9gJ(JgXqP;%S_@4CSmVFk{g($tYngU z2omdDCYcd#!MC-SNwz*FIf|L&M40PMCV4uTQXRtTUT0GMZYDM0-H5Up z-(yk}+^8)~YEHrRGpXe%CMDJ}DT(-2W~^` zjDf-D4fq2U%2=tnQ*LW*>*Q@NeQ=U48Xk01IuzADy1ym0rit^WHK~^SwU449k4??k zJX|$cO-EBU&+R{a*)XQ6t~;?kuP)y%}DA(=%g4sNM$ z8a1k^e#^m%NS4_=9;HTdn_VW0>ap!zx91UcR50pxM}wo(NA}d;)_n~5mQGZt41J8L zZE5Hkn1U{CRFZ(Oxk3tb${0}UQ~92RJG;|T-PJKt>+QV$(z%hy+)Jz~xmNJS#48TFsM{-?LHd-bxvg|X{pRq&u74~nC4i>i16LEAiprfpGA zYjeP(qECX_9cOW$*W=U1YvVDXKItrNcS$?{_zh2o=MDaGyL^>DsNJtwjW%Do^}YA3 z3HS=f@249Yh{jnme5ZRV>tcdeh+=o(;eXg_-64c@tJ&As=oIrFZ& z*Gx&Lr>wdAF8POg_#5blBAP!&nm-O!$wspA>@;>RyOdqWZe?F%--gC9nTXZ%DnmK< z`p0sh@aOosD-jbIoje0ec`&&fWsK?xPdf*L)Qp(MwKKIOtB+EDn(3w-9Ns9O~i z7MwnG8-?RZlv&XIJZUK*;)r!1@Bh4bnRO*JmgwqANa8v4EvHWvBQYYGT?tN4>BRz1 zf1&5N7@@!g89ym5LO{@=9>;Y8=^ExA9{+#aKfFGPwby8wn)db@o}%Z_x0EjQWsmb6 zA9uX(vr-n8$U~x9dhk~VKeI!h^3Z2NXu;>n6BHB%6e2u2VJ!ZykHWv-t19}tU-Yz$ zHXl2#_m7V&O!q(RtK+(Yads868*Wm*!~EzJtW!oq)kw}`iSZl@lNpanZn&u|+px84 zZrN7t&ayK4;4x_@`Q;;XMO4{VelhvW%CtX7w;>J6y=346)vfGe)zJBQ9o$eAhcOPy zjwRa6$CvN-8qHjFi;}h1wAb{Kcnn{;+ITEi`fCUk^_(hJ&q1Z=yo*jRs<94E#yX67 zRj)s)V&gd0VVZGcLALQ|_Lp<4{XEBIF-*yma#;%V*m^xSuqeG?H-7=M0Cq%%W9`2Oe>Ov)OMv8yKrI^mZ$ql{A!!3mw_27Y zE=V#cA@HopguAWPAMhKDb__-Z_(TN7;*A`XxrMefxoz4{Seu)$%$=sPf{vT@Pf_T`RlrC#CPDl$#FnvU|VBC$0(E>+3EG z&3xsml}L_UE3bNGX6T~2dV6S%_M9{`E9kgHPa+9mas{tj$S<&{z?nRzH2b4~4m^Wc zVF+o4`w9BO_!IohZO_=<;=$8j?7KUk(S5llK6wfy9m$GsiN5*e{q(ZS6vU4l6&{s5 zXrJJ@giK>(m%yKhRT;egW||O~pGJ&`7b8-QIchNCms)}88aL8Jh{cIp1uu`FMo!ZP z1fne;+5#%k3SM7Kqe|`%w1JI=6hJJrog4j?5Iq!j=b=0AJS5%ev_9?eR!_H>OLzLM z_U#QLoi=0npY1+gHmde37Kgp)+PKl=nC>pM|EJCAEPBRXQZvb74&LUs*^WCT5Q%L-{O+y zQKgd4Cek)Gjy~OLwb&xJT2>V%wrprI+4aOtWs*;<9pGE>o8u|RvPtYh;P$XlhlqF_ z77X`$AlrH?NJj1CJdEBA8;q*JG-T8nm>hL#38U9ZYO3UTNWdO3rg-pEe5d= zw3Xi@nV)1`P%F?Y4s9yVPgPYT9d#3SLD{*L0U{ z;TtVh?Wb0Lp4MH{o@L6GvhJE=Y2u>{DI_hMtZgl~^3m3#ZUrkn?-5E3A!m!Z>183- zpkovvg1$mQawcNKoQ*tW=gtZqYGqCd)D#K;$p113iB1uE#USvWT}QQ7kM7!al-C^P zmmk!=rY+UJcJLry#vkO%BuM>pb)46x!{DkRYY7wGNK$v=np_sv7nfHZO_=eyqLSK zA6ebf$Bo&P&CR_C*7^|cA>zl^hJ7z0?xu#wFzN=D8 zxm(>@s?z1E;|!Py8HuyHM}_W5*Ff>m5U0Jhy?txDx{jjLGNXs}(CVxgu9Q4tPgE+Hm z*9ll7bz80456xzta(cX+@W!t7xTWR-OgnG_>YM~t&_#5vzC`Mp5aKlXsbO7O0HKAC z2iQF2_|0d6y4$Pu5P-bfZMRzac(Yl{IQgfa0V>u;BJRL(o0$1wD7WOWjKwP)2-6y$ zlPcRhIyDY>{PFLvIr0!VoCe;c_}dp>U-X z`pii$Ju=g+Wy~f|R7yuZZjYAv4AYJT}Ct-OfF$ZUBa> zOiKl0HSvn=+j1=4%5yD}dAq5^vgI~n>UcXZJGkl671v`D74kC?HVsgEVUZNBihyAm zQUE~mz%na<71JU=u_51}DT92@IPPX)0eiDweVeDWmD&fpw12L;-h=5Gq?za0HtmUJ zH@-8qs1E38^OR8g5Q^sI0)J}rOyKu$&o1s=bpx{TURBaQ(!P7i1=oA@B4P>8wu#ek zxZHJqz$1GoJ3_W^(*tZqZsoJlG*66B5j&D6kx@x^m6KxfD?_tCIgCRc?kD~(zmgCm zLGhpE_YBio<-2T9r;^qM0TO{u_N5@cU&P7is8f9-5vh4~t?zMqUEV!d@P{Y)%APE6 zC@k9|i%k6)6t2uJRQQTHt`P5Lgg%h*Fr*Hst8>_$J{ZI{mNBjN$^2t?KP8*6_xXu5xx8ufMp5R?P(R-t`{n6c{!t+*z zh;|Ek#vYp1VLf;GZf>~uUhU}a<>y*ErioacK@F{%7aq0y(Ytu@OPe;mq`jlJD+HtQ zUhr^&Zeh93@tZASEHr)@YqdxFu69(=VFRCysjBoGqZ!U;W1gn5D$myEAmK|$NsF>Z zoV+w>31}eE0iAN9QAY2O+;g%zc>2t#7Dq5vTvb&}E*5lHrkrj!I1b0=@+&c(qJcmok6 zSZAuQ496j<&@a6?K6ox1vRks+RqYD< zT9On_zdVf}IStW^#13*WV8wHQWz$L;0cm)|JDbh|f~*LV8N$;2oL|R99**#AT1smo zob=4dB_WB-D3}~I!ATFHzdW%WacH{qwv5Go2WzQzwRrv)ZajWMp{13T_u;Rz^V-VF z@#62k@#FD#t@v9ye*A%@ODWm-@oM_$_3Cy1BS+(+ujzNF@8a7?`$B^{iX2A-2_nA? zfi2=05XV^;D_2G}Up$eFW|Ofb^zuE)bWHkXR4Jm!Sz0O?)x6QD^kOufR`*v0=|sS?#*ZCvvr^VkV!zhLF3}FHf%+=#@ae1Qq<4~Y1EGYK$Ib1 zg!s~&&u27X&4Ks^(L3%}Npx!_-A)We=0v#yzv03fzxKZ8iV6KIX5U&?>^E?%iIUZ4 z2sD^vRg%kOU!B5@iV{&gBNc9vB)i{Wa@joIa2#4=oAl|-xqj_~$h33%zgk*UWGUV# zf3>{T#2buK?AZH?)h>10N)#VHvOV}%c|wR%HF|pgm8k`*=1l5P8ttZ1Ly@=C5?d9s z)R>B@43V`}=0??4tp?Y}Ox0$SH)yg(!|@V7H^}C-GyAXHFva04omv@`|LCuFRM2`U zxCM>41^p9U3cR>W>`h`{m^VWSL0SNz27{ske7TN1dTpM|P6Hn!^*}+fr>rJ*+GQN{ ziKp9Zda}CgnbNv#9^^&{MChK=E|Wr}tk?tP#Q?iZ%$2k;Eo9~}^tmv?g~PW^C$`N)|awe=5m{Xqd!M=ST?2~(mWjdOsXK#yVMN(qP6`q#tg+rQexf|*BeIU)a z^WuJyPR4WVsATp2E{*y77*kZ9 zEB{*SRHSVGm8ThtES`9!v{E``H)^3d+TG_?{b|eytE1cy^QbPxY3KFTWh&NZi`C?O z;777FMti@+U+IRl7B{=SCc93nKp`>jeW38muw(9T3AqySM#x@9G|p?N;IiNy(KN7? zMz3hIS5SaXrGqD(NIR0ZMnJT%%^~}|cG(Ez!3#)*o{{QjPUIVFOQ%dccgC0*WnAJW zL*1k^HZ5-%bN;%C&2vpW`=;dB5iu4SR48yF$;K8{SY`7mu6c z@q{10W=zwHuav3wid&;5tHCUlUgeVf&>wKuUfEVuUsS%XZ2RPvr>;HI=<(RACmN-M zR8(DJD^lePC9|rUrFgR?>hO#VkFo8}zA@jt{ERalZl$!LP4-GTT`1w}QNUcvuEFRv z`)NyzRG!e-04~~Y1DK>70lGq9rD4J}>V(1*UxcCtBUmyi-Y8Q$NOTQ&VfJIlBRI;7 z5Dr6QNIl|8NTfO>Jf|kZVh7n>hL^)`@3r1BaPIKjxrLrjf8A>RDaI{wYlKG)6-7R~ zsZQ}Kk{T~BDVLo#Zm@cc<&x{X<~boVS5(zfvp1s3RbASf6EKpp>+IFV9s`#Yx#+I& zMz5zL9IUgaqrnG*_=_qm|JBcwfl`bw=c=uU^R>Nm%k4_TeDjy|&K2eKwx!u8 z9&lbdJ?yJ@)>!NgE_vN8+*}$8+Uxk4EBNje>!s2_nOCtE+ie>zl!9&!!I)?QPMD&P zm$5sb#Le|%L<#tZbz%~WWv&yUZH6NLl>OK#CBOp{e~$&fuqQd03DJfLrcWa}IvMu* zy;z7L)WxyINd`m}Fh=l&6EWmHUGLkeP{6Vc;Xq->+AS`1T*b9>SJ#<2Cf!N<)o7Ms z!Gj)CiteiY$f@_OT4C*IODVyil4|R)+8nCf&tw%_BEv!z3RSN|pG(k%hYGrU_Ec^& zNRpzS-nJ*v_QHeHPu}Iub>F_}G1*vdGR~ZSdaG(JEwXM{Df;~AK)j(<_O<)u)`qw* zQduoY)s+$7NdtxaGEAo-cGn7Z5yN#ApXWD1&-5uowpb7bR54QcA7kWG@gybdQQa&cxCKxup2Av3_#{04Z^J#@M&a}P$M<((Zx{A8 z!Ue=%xTpWEzWzKIhsO_xc?e$$ai{S63-$76>gtB?9usV&`qp=Kn*GE5C&Tx`^uyza zw{^ImGi-hkYkP`^0r5vgoSL$EjuxaoKBh2L;dk#~x%`TgefEDi7^(~cmE)UEw*l#i+5f-;!v^P%ZowUbhH*3Av)CifOJX7KS6#d|_83fqJ#8VL=h2KMI zGYTbGm=Q=0lfc{$IDTn;IxIgLZ(Z?)#!mln$0r3A(um zzBIGw6?zmj=H#CkvRoT+C{T=_kfQQ!%8T;loQ5;tH?lZ%M{aG+z75&bhJE`sNSO`$ z`0eget1V7SqB@uA;kQ4UkJ-235xxryG*uzwDPikrWOi1;8WASslh$U4RY{JHgggsL zMaZ|PI2Ise8dMEpuPnW`XYJY^W$n>4PxVOPCO#DnHKfqe+Y7BA6(=QJn}un5MkM7S zkL?&Gvnj|DI!4xt6BV*t)Zv0YV-+(%$}7QcBMZ01jlLEiPk>A3;M^g%K=cNDF6d!7 z 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 d0m +#include +#include +#include +#include + +int main(int argc, char *argv[]) +{ + QApplication app(argc, argv); + QMainWindow w; + + QtAwesome* awesome = new QtAwesome(&w); + awesome->initFontAwesome(); + + QVBoxLayout* layout = new QVBoxLayout(); + + // a simple beer button + //===================== + { + QPushButton* beerButton = new QPushButton( "Cheers!"); + + QVariantMap options; + options.insert("anim", qVariantFromValue( new QtAwesomeAnimation(beerButton) ) ); + beerButton->setIcon( awesome->icon( fa::beer, options ) ); + + layout->addWidget(beerButton); + } + + // a simple beer checkbox button + //============================== + { + QPushButton* toggleButton = new QPushButton("Toggle Me"); + toggleButton->setCheckable(true); + + QVariantMap options; + options.insert("color", QColor(Qt::green) ); + options.insert("text-off", QString(fa::squareo) ); + options.insert("color-off", QColor(Qt::red) ); + toggleButton->setIcon( awesome->icon( fa::checksquareo, options )); + + + layout->addWidget(toggleButton); + } + + + // add the samples + QWidget* samples = new QWidget(); + samples->setLayout(layout); + w.setCentralWidget(samples); + + w.show(); + + return app.exec(); +} diff --git a/thirdparty/QtAwesome/README.md b/thirdparty/QtAwesome/README.md new file mode 100755 index 00000000..8f892b92 --- /dev/null +++ b/thirdparty/QtAwesome/README.md @@ -0,0 +1,230 @@ +QtAwesome - Font Awesome support for Qt applications +==================================================== + +Description +----------- + +QtAwesome is a simple library that can be used to add [Font Awesome](http://fortawesome.github.io/Font-Awesome/) icons to your [Qt application](http://qt-project.org/). + +NOTE: Though the name is QtAwesome and currently it's very Font Awesome based, you can use every other icon/glyph font you want. + +The class can also be used to manage your own dynamic code-drawn icons, by adding named icon-painters. + + +Updated to FontAwesome 4.7.0 +---------------------------- + +This library has been updated to Font Awesome version **4.7.0**. + +* In the 4.5.0 version the _linux name has been changed to fa_linux. (Makes the naming of conflicting/invalid names more consistent, like fa_try and fa_500px) +* You can find the previous FontAwesome 4 c++11 library in the [c++11 branch](https://github.com/gamecreature/QtAwesome/tree/c++11). +* You can find the previous FontAwesome 3 library in the [fontawesome-3 branch](https://github.com/gamecreature/QtAwesome/tree/fontawesome-3). + + +**Note about previous c++11** + +I removed the C++11 requirement. And moved the c++11 code to a c++11 branch. +It's not that I don't like c++11, but the typed enum made the code less flexible then it is now. +Just integers it is. Simpler is better. + + + + +Installation +------------ + +The easiest way to include QtAweome in your project is to copy the QtAwesome directory to your +project tree and add the following `include()` to your Qt project file: + + include(QtAwesome/QtAwesome.pri) + +Now you are good to go! + + +Usage +----- + +You probably want to create a single QtAwesome object for your whole application: + +```` + QtAwesome* awesome = new QtAwesome( qApp ) + awesome->initFontAwesome(); // This line is important as it loads the font and initializes the named icon map + +```` + +* Add an accessor to this object (i.e. a global function, member of your application object, or whatever you like). +* Use an icon name from the [Font Awesome Cheatsheet](http://fortawesome.github.io/Font-Awesome/cheatsheet/). + + +Example +-------- + +```c++ +// You should create a single object of QtAwesome. +QtAwesome* awesome = new QtAwesome( qApp ); +awesome->initFontAwesome(); + +// Next create your icon with the help of the icon-enumeration (no dashes): +QPushButton* beerButton new QPushButton( awesome->icon( fa::beer ), "Cheers!" ); + +// You can also use 'string' names to access the icons. (The string version omits the 'fa-' or 'icon-' prefix and has no dashes ) +QPushButton* coffeeButton new QPushButton( awesome->icon( "coffee" ), "Black please!" ); + +// When you create an icon you can supply some options for your icons: +// The available options can be found at the "Default options"-section + +QVariantMap options; +options.insert( "color" , QColor(255,0,0) ); +QPushButton* musicButton = new QPushButton( awesome->icon( fa::music, options ), "Music" ); + +// You can also change the default options. +// for example if you always would like to have green icons you could call) +awesome->setDefaultOption( "color-disabled", QColor(0,255,0) ); + +// You can also directly render a label with this font +QLabel* label = new QLabel( QChar( fa::group ) ); +label->setFont( awesome->font(16) ); + +``` + +Example custom painter +---------------------- + +This example registers a custom painter for supporting a duplicate icon (it draws 2 "plus marks"): + +```c++ +class DuplicateIconPainter : public QtAwesomeIconPainter +{ +public: + virtual void paint( QtAwesome* awesome, QPainter* painter, const QRect& rectIn, QIcon::Mode mode, QIcon::State state, const QVariantMap& options ) + { + int drawSize = qRound(rectIn.height()*0.5); + int offset = rectIn.height() / 4; + QChar chr = QChar( static_cast(fa::plus) ); + + painter->setFont( awesome->font( drawSize ) ); + + painter->setPen( QColor(100,100,100) ); + painter->drawText( QRect( QPoint(offset*2, offset*2), QSize(drawSize, drawSize) ), chr , QTextOption( Qt::AlignCenter|Qt::AlignVCenter ) ); + + painter->setPen( QColor(50,50,50) ); + painter->drawText( QRect( QPoint(rectIn.width()-drawSize-offset, rectIn.height()-drawSize-offset), QSize(drawSize, drawSize) ), chr , QTextOption( Qt::AlignCenter|Qt::AlignVCenter ) ); + + } +}; + +awesome->give("duplicate", new DuplicateIconPainter() ); +``` + + +Default options: +---------------- + + The following options are default in the QtAwesome class. + +```c++ +setDefaultOption( "color", QColor(50,50,50) ); +setDefaultOption( "color-disabled", QColor(70,70,70,60)); +setDefaultOption( "color-active", QColor(10,10,10)); +setDefaultOption( "color-selected", QColor(10,10,10)); + +setDefaultOption( "text", QString() ); // internal option +setDefaultOption( "text-disabled", QString() ); +setDefaultOption( "text-active", QString() ); +setDefaultOption( "text-selected", QString() ); + +setDefaultOption( "scale-factor", 0.9 ); +``` + + When creating an icon, it first populates the options-map with the default options from the QtAwesome object. + After that the options are expanded/overwritten by the options supplied to the icon. + + It is possible to use another glyph per icon-state. For example to make an icon-unlock symbol switch to locked when selected, + you could supply the following option: + +```c++ + options.insert("text-selected", QString( fa::lock ) ); +``` + +Color and text options have the following structure: +`keyname-iconmode-iconstate` + +Where iconmode normal is empty +And iconstate On is off. + +So the list of items used is: + +- color +- color-disabled +- color-active +- color-selected +- color-off +- color-disabled-off +- color-active-off +- color-selected-off +- text +- text-disabled +- text-active +- text-selected +- text-off +- text-disabled-off +- text-active-off +- text-selected-off + + +License +------- + +MIT License. Copyright 2013 - Reliable Bits Software by Blommers IT. [http://blommersit.nl/](http://blommersit.nl) + +The Font Awesome font is licensed under the SIL Open Font License - [http://scripts.sil.org/OFL](http://scripts.sil.org/OFL) +The Font Awesome pictograms are licensed under the CC BY 3.0 License - [http://creativecommons.org/licenses/by/3.0/](http://creativecommons.org/licenses/by/3.0/) +"Font Awesome by Dave Gandy - http://fortawesome.github.com/Font-Awesome" + +Contact +------- + +* email: +* twitter: [https://twitter.com/gamecreature](https://twitter.com/gamecreature) +* website: [http://blommersit.nl](http://blommersit.nl) (warning Dutch content ahead) +* github: [https://github.com/gamecreature/QtAwesome](https://github.com/gamecreature/QtAwesome) + + +Known issues and workarounds +---------------------------- + +On Mac OS X, placing an qtAwesome icon in QMainWindow menu, doesn't work directly. +See the following issue: [https://github.com/gamecreature/QtAwesome/issues/10] + +A workaround for this problem is converting it to a Pixmap icon like this: + +```c++ +QAction* menuAction = new QAction("test"); +menuAction->setIcon( awesome->icon(fa::beer).pixmap(32,32) ); +``` + + +Remarks +------- + +I've created this project because I needed some nice icons for my own Qt project. After doing a lot of +css/html5 work and being spoiled by the ease of twitter bootstrap with Font Awesome, +I thought it would be nice to be able to use these icons for my Qt project. + +I've slightly changed the code from the original, added some more documentation, but it's still +a work in progress. So feel free to drop me an e-mail for your suggestions and improvements! + +There are still some things todo, like: + + * document the usage of another icon font + * add some tests + * do some code cleanup + +Thanks go to the contributors of this project! + +And of course last but not least, + +Many thanks go to Dave Gandy an the other Font Awesome contributors!! [http://fortawesome.github.com/Font-Awesome](http://fortawesome.github.com/Font-Awesome) +And of course to the Qt team/contributors for supplying this great cross-platform c++ library. + +Contributions are welcome! Feel free to fork and send a pull request through Github.