├── screenshot.png
├── common.pri
├── EzGraver.pro
├── EzGraverUi
    ├── clicklabel.cpp
    ├── main.cpp
    ├── EzGraverUi.pro
    ├── clicklabel.h
    ├── mainwindow.h
    ├── imagelabel.cpp
    ├── imagelabel.h
    ├── mainwindow.cpp
    └── mainwindow.ui
├── EzGraverCore
    ├── specifications.h
    ├── ezgravercore_global.h
    ├── ezgraver_v1.cpp
    ├── ezgraver_v2.cpp
    ├── EzGraverCore.pro
    ├── ezgraver_v1.h
    ├── ezgraver_v2.h
    ├── factory.h
    ├── factory.cpp
    ├── ezgraver_v3.h
    ├── ezgraver_v3.cpp
    ├── ezgraver.cpp
    └── ezgraver.h
├── .gitignore
├── .drone.sec
├── EzGraverCli
    ├── EzGraverCli.pro
    └── main.cpp
├── LICENSE
├── appveyor.yml
├── .drone.yml
├── .travis.yml
└── README.md


/screenshot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/camrein/EzGraver/HEAD/screenshot.png


--------------------------------------------------------------------------------
/common.pri:
--------------------------------------------------------------------------------
1 | DEFINES += EZ_VERSION=\\\"$$(EZ_VERSION)\\\"
2 | 
3 | CONFIG += c++11
4 | 


--------------------------------------------------------------------------------
/EzGraver.pro:
--------------------------------------------------------------------------------
1 | TEMPLATE = subdirs
2 | 
3 | CONFIG += ordered
4 | 
5 | SUBDIRS += \
6 |     EzGraverCore \
7 |     EzGraverCli \
8 |     EzGraverUi
9 | 


--------------------------------------------------------------------------------
/EzGraverUi/clicklabel.cpp:
--------------------------------------------------------------------------------
 1 | #include "clicklabel.h"
 2 | 
 3 | #include <QMouseEvent>
 4 | 
 5 | ClickLabel::ClickLabel(QWidget* parent) : QLabel{parent} {}
 6 | ClickLabel::~ClickLabel() {}
 7 | 
 8 | void ClickLabel::mouseReleaseEvent(QMouseEvent*) {
 9 |     emit clicked();
10 | }
11 | 


--------------------------------------------------------------------------------
/EzGraverCore/specifications.h:
--------------------------------------------------------------------------------
 1 | #ifndef SETTINGS_H
 2 | #define SETTINGS_H
 3 | 
 4 | namespace Ez {
 5 | namespace Specifications {
 6 | 
 7 | /*! The image width */
 8 | int const ImageWidth{512};
 9 | 
10 | /*! The image height */
11 | int const ImageHeight{512};
12 | 
13 | }
14 | }
15 | 
16 | #endif // SETTINGS_H
17 | 


--------------------------------------------------------------------------------
/EzGraverUi/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "mainwindow.h"
 2 | #include <QApplication>
 3 | #include <QString>
 4 | 
 5 | int main(int argc, char *argv[]) {
 6 |     QApplication a(argc, argv);
 7 |     MainWindow w;
 8 |     w.show();
 9 |     w.setWindowTitle(QString{"EzGraver %1"}.arg(EZ_VERSION));
10 | 
11 |     return a.exec();
12 | }
13 | 


--------------------------------------------------------------------------------
/EzGraverCore/ezgravercore_global.h:
--------------------------------------------------------------------------------
 1 | #ifndef EZGRAVERCORE_GLOBAL_H
 2 | #define EZGRAVERCORE_GLOBAL_H
 3 | 
 4 | #include <QtCore/qglobal.h>
 5 | 
 6 | #if defined(EZGRAVERCORE_LIBRARY)
 7 | #  define EZGRAVERCORESHARED_EXPORT Q_DECL_EXPORT
 8 | #else
 9 | #  define EZGRAVERCORESHARED_EXPORT Q_DECL_IMPORT
10 | #endif
11 | 
12 | #endif // EZGRAVERCORE_GLOBAL_H
13 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # C++ objects and libs
 2 | 
 3 | *.slo
 4 | *.lo
 5 | *.o
 6 | *.a
 7 | *.la
 8 | *.lai
 9 | *.so
10 | *.dll
11 | *.dylib
12 | 
13 | # Qt-es
14 | 
15 | /.qmake.cache
16 | /.qmake.stash
17 | *.pro.user
18 | *.pro.user.*
19 | *.qbs.user
20 | *.qbs.user.*
21 | *.moc
22 | moc_*.cpp
23 | qrc_*.cpp
24 | ui_*.h
25 | Makefile*
26 | *build-*
27 | 
28 | # QtCreator
29 | 
30 | *.autosave
31 | 
32 | # QtCtreator Qml
33 | *.qmlproject.user
34 | *.qmlproject.user.*
35 | 
36 | # QtCtreator CMake
37 | CMakeLists.txt.user
38 | 
39 | 


--------------------------------------------------------------------------------
/.drone.sec:
--------------------------------------------------------------------------------
1 | eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkExMjhHQ00ifQ.s7gMtvokhwFYScYC2yya0NXW1A2TbKNFrB1NlWwRNyqXrkPVtkYJUWNjAZ1K5ol69-FLvNH_ESEBYRFnAC8-pnh7t9Kmq-EzitK-abNFMqY-7VeoqCMufA8gsJCI27srFjZh9UuLvWsZmOggPoU7OrX12aKyMIbUS0f6a3K4hJN-fi2R8YlYV9UuY_fFbWDQ4ZDkhzS1OMZvwS59o8455C-C_YgL2ufKqwo06FqMLtOt7uVRNxYgTWguGVn8XKr6CAFF-JA7KObCRSE2pGZAjt_Ep-eZgq9HSB6169cFkOrVzxKLH-LOa8oTOVyGBWHsg23NR6pNXIEwSof4d6IBUg.w_2a5xX8z_ngnnvg.pHfpgNx6gb9baILVpU9f6C1J-Ajd1GHmdA3ZJf3t9JkPObS5vwkMxRdPgz2wFqz1W247j9wfNmVei9hvZTVI4rATOsTWem212Rt3NDyKzIs.xpe_AhaTO8mZq4oa7fC8Dg


--------------------------------------------------------------------------------
/EzGraverCore/ezgraver_v1.cpp:
--------------------------------------------------------------------------------
 1 | #include "ezgraver_v1.h"
 2 | 
 3 | #include <QDebug>
 4 | 
 5 | namespace Ez {
 6 | 
 7 | void EzGraverV1::up() {
 8 |     qDebug() << "moving up";
 9 |     _transmit(0xF5);
10 | }
11 | 
12 | void EzGraverV1::down() {
13 |     qDebug() << "moving down";
14 |     _transmit(0xF6);
15 | }
16 | 
17 | void EzGraverV1::left() {
18 |     qDebug() << "moving left";
19 |     _transmit(0xF7);
20 | }
21 | 
22 | void EzGraverV1::right() {
23 |     qDebug() << "moving right";
24 |     _transmit(0xF8);
25 | }
26 | 
27 | }
28 | 


--------------------------------------------------------------------------------
/EzGraverCore/ezgraver_v2.cpp:
--------------------------------------------------------------------------------
 1 | #include "ezgraver_v2.h"
 2 | 
 3 | #include <QDebug>
 4 | 
 5 | namespace Ez {
 6 | 
 7 | void EzGraverV2::up() {
 8 |     qDebug() << "moving up";
 9 |     _transmit("\xf5\x01");
10 | }
11 | 
12 | void EzGraverV2::down() {
13 |     qDebug() << "moving down";
14 |     _transmit("\xf5\x02");
15 | }
16 | 
17 | void EzGraverV2::left() {
18 |     qDebug() << "moving left";
19 |     _transmit("\xf5\x03");
20 | }
21 | 
22 | void EzGraverV2::right() {
23 |     qDebug() << "moving right";
24 |     _transmit("\xf5\x04");
25 | }
26 | 
27 | }
28 | 


--------------------------------------------------------------------------------
/EzGraverCli/EzGraverCli.pro:
--------------------------------------------------------------------------------
 1 | include(../common.pri)
 2 | 
 3 | QT += core
 4 | QT += serialport
 5 | 
 6 | TARGET = EzGraverCli
 7 | CONFIG += console
 8 | CONFIG -= app_bundle
 9 | 
10 | TEMPLATE = app
11 | 
12 | SOURCES += main.cpp
13 | 
14 | win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../EzGraverCore/release/ -lEzGraverCore
15 | else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../EzGraverCore/debug/ -lEzGraverCore
16 | else:unix: LIBS += -L$$OUT_PWD/../EzGraverCore/ -lEzGraverCore
17 | 
18 | INCLUDEPATH += $$PWD/../EzGraverCore
19 | DEPENDPATH += $$PWD/../EzGraverCore
20 | 


--------------------------------------------------------------------------------
/EzGraverCore/EzGraverCore.pro:
--------------------------------------------------------------------------------
 1 | include(../common.pri)
 2 | 
 3 | QT += core
 4 | QT += serialport
 5 | 
 6 | TARGET = EzGraverCore
 7 | TEMPLATE = lib
 8 | 
 9 | DEFINES += EZGRAVERCORE_LIBRARY
10 | 
11 | SOURCES += ezgraver.cpp \
12 |     ezgraver_v1.cpp \
13 |     ezgraver_v2.cpp \
14 |     factory.cpp \
15 |     ezgraver_v3.cpp
16 | 
17 | HEADERS += ezgraver.h\
18 |         ezgravercore_global.h \
19 |     ezgraver_v1.h \
20 |     ezgraver_v2.h \
21 |     specifications.h \
22 |     factory.h \
23 |     ezgraver_v3.h
24 | 
25 | unix {
26 |     target.path = /usr/lib
27 |     INSTALLS += target
28 | }
29 | 


--------------------------------------------------------------------------------
/EzGraverCore/ezgraver_v1.h:
--------------------------------------------------------------------------------
 1 | #ifndef EZGRAVERV1_H
 2 | #define EZGRAVERV1_H
 3 | 
 4 | #include <QSerialPort>
 5 | 
 6 | #include <memory>
 7 | 
 8 | #include "ezgraver.h"
 9 | 
10 | namespace Ez {
11 | 
12 | struct EzGraverV1 : EzGraver {
13 |     using EzGraver::EzGraver;
14 | 
15 |     /*! Moves the engraver up. */
16 |     void up() override;
17 | 
18 |     /*! Moves the engraver down. */
19 |     void down() override;
20 | 
21 |     /*! Moves the engraver left. */
22 |     void left() override;
23 | 
24 |     /*! Moves the engraver right. */
25 |     void right() override;
26 | };
27 | 
28 | }
29 | 
30 | #endif // EZGRAVERV1_H
31 | 


--------------------------------------------------------------------------------
/EzGraverCore/ezgraver_v2.h:
--------------------------------------------------------------------------------
 1 | #ifndef EZGRAVERV2_H
 2 | #define EZGRAVERV2_H
 3 | 
 4 | #include <QSerialPort>
 5 | 
 6 | #include <memory>
 7 | 
 8 | #include "ezgraver.h"
 9 | 
10 | namespace Ez {
11 | 
12 | struct EzGraverV2 : EzGraver {
13 |     using EzGraver::EzGraver;
14 | 
15 |     /*! Moves the engraver up. */
16 |     void up() override;
17 | 
18 |     /*! Moves the engraver down. */
19 |     void down() override;
20 | 
21 |     /*! Moves the engraver left. */
22 |     void left() override;
23 | 
24 |     /*! Moves the engraver right. */
25 |     void right() override;
26 | };
27 | 
28 | }
29 | 
30 | #endif // EZGRAVERV2_H
31 | 


--------------------------------------------------------------------------------
/EzGraverUi/EzGraverUi.pro:
--------------------------------------------------------------------------------
 1 | include(../common.pri)
 2 | 
 3 | QT += core
 4 | QT += gui
 5 | QT += serialport
 6 | 
 7 | greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 8 | 
 9 | TARGET = EzGraverUi
10 | TEMPLATE = app
11 | 
12 | 
13 | SOURCES += main.cpp\
14 |         mainwindow.cpp \
15 |     clicklabel.cpp \
16 |     imagelabel.cpp
17 | 
18 | HEADERS  += mainwindow.h \
19 |     clicklabel.h \
20 |     imagelabel.h
21 | 
22 | FORMS    += mainwindow.ui
23 | 
24 | win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../EzGraverCore/release/ -lEzGraverCore
25 | else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../EzGraverCore/debug/ -lEzGraverCore
26 | else:unix: LIBS += -L$$OUT_PWD/../EzGraverCore/ -lEzGraverCore
27 | 
28 | INCLUDEPATH += $$PWD/../EzGraverCore
29 | DEPENDPATH += $$PWD/../EzGraverCore
30 | 


--------------------------------------------------------------------------------
/EzGraverUi/clicklabel.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLICKLABEL_H
 2 | #define CLICKLABEL_H
 3 | 
 4 | #include <QtWidgets/QLabel>
 5 | 
 6 | /*!
 7 |  * A label extended with the possibility to retrieve click events.
 8 |  */
 9 | class ClickLabel : public QLabel {
10 |     Q_OBJECT
11 | 
12 | public:
13 |     /*!
14 |      * Creates a new instance with the given \a parent.
15 |      *
16 |      * \param parent The parent of the label.
17 |      */
18 |     explicit ClickLabel(QWidget* parent=NULL);
19 | 
20 |     /*!
21 |      * Frees all required resources upon deconstruction.
22 |      */
23 |     virtual ~ClickLabel();
24 | 
25 | signals:
26 |     /*!
27 |      * Signal emitted as soon as a click has been registered on the label.
28 |      */
29 |     void clicked();
30 | 
31 | protected:
32 |     /*!
33 |      * Retrieves the event of releasing a mouse button on the de
34 |      *
35 |      * \param event
36 |      */
37 |     void mouseReleaseEvent(QMouseEvent* event);
38 | };
39 | 
40 | #endif // CLICKLABEL_H
41 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2016-2017 Christoph Amrein
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/EzGraverCore/factory.h:
--------------------------------------------------------------------------------
 1 | #ifndef EZGRAVER_FACTORY_H
 2 | #define EZGRAVER_FACTORY_H
 3 | 
 4 | #include "ezgravercore_global.h"
 5 | 
 6 | #include <QString>
 7 | #include <QList>
 8 | #include <QStringList>
 9 | 
10 | #include <memory>
11 | 
12 | #include "ezgraver.h"
13 | 
14 | namespace Ez {
15 | 
16 | /*!
17 |  * Creates an instance and connects to the given \a portName.
18 |  *
19 |  * \param portName The port the connection should be established to.
20 |  * \param protocol The protocol version to use.
21 |  * \return An instance of the EzGraver as a shared pointer.
22 |  * \throws std::runtime_error Thrown if no connection to the specified port could be established.
23 |  * \throws std::invalid_argument Thrown if the provided protocol code is unknown.
24 |  */
25 | EZGRAVERCORESHARED_EXPORT std::shared_ptr<EzGraver> create(QString const& portName, int protocol = 1);
26 | 
27 | /*!
28 |  * Gets the available protocols.
29 |  *
30 |  * \return The available protocols.
31 |  */
32 | EZGRAVERCORESHARED_EXPORT QList<int> protocols();
33 | 
34 | /*!
35 |  * Gets a list of all available ports.
36 |  *
37 |  * \return A list with all ports.
38 |  */
39 | EZGRAVERCORESHARED_EXPORT QStringList availablePorts();
40 | 
41 | }
42 | 
43 | 
44 | #endif // EZGRAVER_FACTORY_H
45 | 


--------------------------------------------------------------------------------
/appveyor.yml:
--------------------------------------------------------------------------------
 1 | environment:
 2 |   matrix:
 3 |     - arch: x64
 4 |       QT_DIR: C:\Qt\5.7\msvc2015_64
 5 |     - arch: x86
 6 |       QT_DIR: C:\Qt\5.7\msvc2015
 7 | 
 8 | install:
 9 |   - set PATH=%PATH%;%QT_DIR%\bin
10 | # TODO descide Decide whether vcredist_$(arch).exe should be packaged with the application or published separately. 
11 | #  - set VCINSTALLDIR=C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC
12 | 
13 | before_build:
14 |   - set EZ_VERSION=%APPVEYOR_REPO_TAG_NAME%
15 |   - cd EzGraverCli & qmake -config release -tp vc -spec win32-msvc2015 EzGraverCli.pro & cd ..
16 |   - cd EzGraverCore & qmake -config release -tp vc -spec win32-msvc2015 EzGraverCore.pro & cd ..
17 |   - cd EzGraverUi & qmake -config release -tp vc -spec win32-msvc2015 EzGraverUi.pro & cd ..
18 |   - qmake -config release -tp vc -spec win32-msvc2015 EzGraver.pro
19 | 
20 | configuration:
21 |   - Release
22 | 
23 | after_build:
24 |   - mkdir deploy
25 |   - copy EzGraverCli\release\EzGraverCli.exe deploy\EzGraverCli.exe
26 |   - copy EzGraverCore\release\EzGraverCore.dll deploy\EzGraverCore.dll
27 |   - copy EzGraverUi\release\EzGraverUi.exe deploy\EzGraverUi.exe
28 |   - windeployqt --release --no-translations --no-angle --no-opengl-sw deploy/EzGraverCli.exe
29 |   - windeployqt --release --no-translations --no-angle --no-opengl-sw deploy/EzGraverCore.dll
30 |   - windeployqt --release --no-translations --no-angle --no-opengl-sw deploy/EzGraverUi.exe
31 |   - 7z a EzGraver_win_%arch%.zip .\deploy\*
32 | 
33 | artifacts:
34 |   - path: EzGraver_win_$(arch).zip
35 |   
36 | deploy:
37 |   provider: GitHub
38 |   auth_token:
39 |     secure: kQ5w9sYhOflgqli0RP05IzEMc946SuYcK7nyhsOivYd5MoC6QLgg9tknjt8ALkTn
40 |   artifact: EzGraver_win_$(arch).zip
41 |   draft: false
42 |   prerelease: false
43 |   on:
44 |     appveyor_repo_tag: true
45 | 


--------------------------------------------------------------------------------
/.drone.yml:
--------------------------------------------------------------------------------
 1 | build: 
 2 |   image: teaci/msys$$arch
 3 |   shell: mingw$$arch
 4 |   pull: true
 5 |   commands:
 6 |     # Compilation
 7 |     - export EZ_VERSION=$CI_TAG
 8 |     - if [ $$arch = 32 ]; then target=i686; fi
 9 |     - if [ $$arch = 64 ]; then target=x86_64; fi
10 |     - pacman -S --needed --noconfirm --noprogressbar mingw-w64-${target}-pkg-config mingw-w64-${target}-qt5 zip
11 |     - qmake -v
12 |     - qmake -config release EzGraver.pro
13 |     - make
14 |     # Dependency collection
15 |     # windeployqt searches for icu*.dll instead of libicu*.dll
16 |     - mkdir dependencies
17 |     - cp /mingw$$arch/bin/libicudt*.dll dependencies/
18 |     - cp /mingw$$arch/bin/libicuin*.dll dependencies/
19 |     - cp /mingw$$arch/bin/libicuuc*.dll dependencies/
20 |     - for file in dependencies/lib* ; do mv "$file" "${file/lib/}" ; done
21 |     - PATH=$PATH:$PWD/dependencies
22 |     # Deployment
23 |     - mkdir deploy
24 |     - cp EzGraverCli/release/EzGraverCli.exe deploy/
25 |     - cp EzGraverCore/release/EzGraverCore.dll deploy/
26 |     - cp EzGraverUi/release/EzGraverUi.exe deploy/
27 |     - windeployqt --release --no-translations --no-angle --no-opengl-sw deploy/EzGraverCli.exe
28 |     - windeployqt --release --no-translations --no-angle --no-opengl-sw deploy/EzGraverCore.dll
29 |     - windeployqt --release --no-translations --no-angle --no-opengl-sw deploy/EzGraverUi.exe
30 |     # Add missing libraries. MSYS libs have to be added as well.
31 |     # Generate final zip
32 |     - if [ $$arch = 32 ]; then zip -r EzGraver_win_x86.zip deploy/; fi
33 |     - if [ $$arch = 64 ]; then zip -r EzGraver_win_x64.zip deploy/; fi
34 | 
35 | #publish:
36 | #  github_release:
37 | #    api_key: $$GITHUB_RELEASES_TOKEN
38 | #    files:
39 | #      - EzGraver_win_x86.zip
40 | #      - EzGraver_win_x64.zip
41 | #    when:
42 | #      event: tag
43 | 
44 | matrix:
45 |   arch:
46 |     - 64
47 |     - 32
48 | 


--------------------------------------------------------------------------------
/EzGraverCore/factory.cpp:
--------------------------------------------------------------------------------
 1 | #include "factory.h"
 2 | 
 3 | #include <QString>
 4 | #include <QSerialPort>
 5 | #include <QSerialPortInfo>
 6 | #include <QDebug>
 7 | 
 8 | #include <stdexcept>
 9 | 
10 | #include "ezgraver.h"
11 | #include "ezgraver_v1.h"
12 | #include "ezgraver_v2.h"
13 | #include "ezgraver_v3.h"
14 | 
15 | namespace Ez {
16 | 
17 | std::shared_ptr<EzGraver> create(QString const& portName, int protocol) {
18 |     qDebug() << "instantiating EzGraver on port" << portName << "with protocol version" << protocol;
19 | 
20 |     std::shared_ptr<QSerialPort> serial{new QSerialPort(portName)};
21 |     serial->setBaudRate(QSerialPort::Baud57600, QSerialPort::AllDirections);
22 |     serial->setParity(QSerialPort::Parity::NoParity);
23 |     serial->setDataBits(QSerialPort::DataBits::Data8);
24 |     serial->setStopBits(QSerialPort::StopBits::OneStop);
25 | 
26 |     if(!serial->open(QIODevice::ReadWrite)) {
27 |         qDebug() << "failed to establish a connection on port" << portName;
28 |         qDebug() << serial->errorString();
29 |         throw std::runtime_error{QString{"failed to connect to port %1 (%2)"}.arg(portName, serial->errorString()).toStdString()};
30 |     }
31 | 
32 |     switch(protocol) {
33 |     case 1:
34 |         return std::make_shared<EzGraverV1>(serial);
35 |     case 2:
36 |         return std::make_shared<EzGraverV2>(serial);
37 |     case 3:
38 |         return std::make_shared<EzGraverV3>(serial);
39 |     default:
40 |         throw std::invalid_argument{QString{"unsupported protocol '%1' selected"}.arg(protocol).toStdString()};
41 |     }
42 | }
43 | 
44 | QList<int> protocols() {
45 |     return QList<int>{1, 2, 3};
46 | }
47 | 
48 | QStringList availablePorts() {
49 |     auto toPortName = [](QSerialPortInfo const& port) { return port.portName(); };
50 |     auto ports = QSerialPortInfo::availablePorts();
51 |     QStringList result{};
52 | 
53 |     std::transform(ports.cbegin(), ports.cend(), std::back_inserter(result), toPortName);
54 |     return result;
55 | }
56 | 
57 | }
58 | 
59 | 


--------------------------------------------------------------------------------
/EzGraverCore/ezgraver_v3.h:
--------------------------------------------------------------------------------
 1 | #ifndef EZGRAVERV3_H
 2 | #define EZGRAVERV3_H
 3 | 
 4 | #include <QSerialPort>
 5 | 
 6 | #include <memory>
 7 | 
 8 | #include "ezgraver.h"
 9 | 
10 | namespace Ez {
11 | 
12 | struct EzGraverV3 : EzGraver {
13 |     using EzGraver::EzGraver;
14 | 
15 |     /*!
16 |      * Starts the engraving process with the given \a burnTime.
17 |      *
18 |      * \param burnTime The burn time to use in milliseconds.
19 |      */
20 |     void start(unsigned char const& burnTime) override;
21 | 
22 |     /*!
23 |      * Pauses the engraving process at the given location. The process
24 |      * can be continued by invoking start.
25 |      */
26 |     void pause() override;
27 | 
28 |     /*! Resets the engraver. */
29 |     void reset() override;
30 | 
31 |     /*! Moves the engraver to the home position. */
32 |     void home() override;
33 | 
34 |     /*! Moves the engraver to the center. */
35 |     void center() override;
36 | 
37 |     /*! Draws a preview of the currently loaded image. */
38 |     void preview() override;
39 | 
40 |     /*! Moves the engraver up. */
41 |     void up() override;
42 | 
43 |     /*! Moves the engraver down. */
44 |     void down() override;
45 | 
46 |     /*! Moves the engraver left. */
47 |     void left() override;
48 | 
49 |     /*! Moves the engraver right. */
50 |     void right() override;
51 | 
52 |     /*!
53 |      * Erases the EEPROM of the engraver. This is necessary before uploading
54 |      * any new image to it.
55 |      * Erasing the EEPROM takes a while. Sending image data to early causes
56 |      * that some of the leading pixels are lost. Waiting for about 5 seconds
57 |      * seems to be sufficient.
58 |      *
59 |      * \return The recommended time in ms to wait until uploading the image.
60 |      */
61 |     int erase() override;
62 | 
63 |     /*!
64 |      * Uploads the given \a image to the EEPROM. It is mandatory to use \a erase()
65 |      * it prior uploading an image. The image will automatically be scaled, inverted,
66 |      * mirrored and converted to a monochrome bitmap.
67 |      *
68 |      * \param image The image to upload to the EEPROM for engraving.
69 |      * \return The number of bytes being sent to the device.
70 |      */
71 |     int uploadImage(QImage const& image) override;
72 | 
73 | private:
74 |     void _setBurnTime(unsigned char const& burnTime);
75 | };
76 | 
77 | }
78 | 
79 | #endif // EZGRAVERV3_H
80 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: cpp
 2 | sudo: required
 3 | dist: trusty
 4 | 
 5 | os:
 6 |     - linux
 7 |     - osx
 8 | 
 9 | before_install:
10 |     - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update ; fi
11 |     - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install qt55 ; fi
12 |     - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew link --force qt55 ; fi
13 |     - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo add-apt-repository --yes ppa:beineri/opt-qt551-trusty ; fi
14 |     - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo apt-get update -qq ; fi
15 |     - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo apt-get install -qq qt55base qt55serialport ; fi
16 |     - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo apt-get install -qq libudev-dev ; fi
17 |     - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then source /opt/qt55/bin/qt55-env.sh ; fi
18 | 
19 | script:
20 |     - export EZ_VERSION=$TRAVIS_TAG
21 |     - echo "Building $EZ_VERSION"
22 |     - qmake -v
23 |     - qmake -config release EzGraver.pro
24 |     - make
25 |     - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then mkdir EzGraverUi/EzGraverUi.app/Contents/Frameworks/ ; fi
26 |     - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then cp EzGraverCore/libEzGraverCore.1.dylib EzGraverUi/EzGraverUi.app/Contents/Frameworks/libEzGraverCore.1.dylib ; fi
27 |     - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then macdeployqt EzGraverUi/EzGraverUi.app -dmg ; fi
28 |     - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then otool -L EzGraverUi/EzGraverUi.app/Contents/MacOS/EzGraverUi ; fi
29 |     - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then mv EzGraverUi/EzGraverUi.dmg EzGraverUi/EzGraver_osx.dmg; fi
30 | 
31 | deploy:
32 |     provider: releases
33 |     api_key:
34 |         secure: jIWIt+ocrCrp564ezeKQ9SAu1xo/22/6crqyhFRM7YqOZHFloJdqf1xTSS3IVrkxNmFJ6uyGX1ZJfCnrxilyXPdXi35qE3WoNYPtHypWaLo4szD/F8orsWvoG/QvAeEQwXDQ4010d0ao4RQSj07mxAPjrn88h8WrIfJ0N19et8O7qXGMGnCB0lMaaqlpN9uycEg3ZYJY0uxhljk9dMESFz/0t68KUNMVttAgoEvxXhTnWUrNheigIxD0fpssDdXRNUbg9r2RS/yZyOLR5yybi2xKfKx3WxsDtJQTNTVVfFtcwiwCozsbM3vwRZzZtmc22KxLediZyvSNZUJ7RUfSZnd88HHwKWAQHj04UaeBLgoj0lxRKorWEcWfBQPpFy1nT9c0nQGGpq6+LZHehd+ZAqmf17y5o1HxEYRszMsgHLNEgqZomEkgUG8cWkoylz7QRm0+Ia0wvoQz7C0Neg57VLUPi1OmlxPo4GQuskoUGptA5OFnDiLwtkPEWuLeLroxFiZtsSWqJicqWPUgg14bGNMG3/VVD3vf7M80MCIHCuHtyP+s78DiZlkxil0KH2f2ORhqkNocJOrjtFpuXriHfbKYwD4O2EAQTHB1mMLviL05oaJLvPaODYX/+ua5BAmPdIyC5Mil3M0+WBqFxf4Do1KhwQCId78AOUMGGqeLc74=
35 |     file: EzGraverUi/EzGraver_osx.dmg
36 |     skip_cleanup: true
37 |     on:
38 |         repo: camrein/EzGraver
39 |         condition: $TRAVIS_OS_NAME = osx
40 |         tags: true
41 | 


--------------------------------------------------------------------------------
/EzGraverUi/mainwindow.h:
--------------------------------------------------------------------------------
 1 | #ifndef MAINWINDOW_H
 2 | #define MAINWINDOW_H
 3 | 
 4 | #include <QMainWindow>
 5 | #include <QTimer>
 6 | #include <QSettings>
 7 | #include <QString>
 8 | 
 9 | #include <memory>
10 | #include <functional>
11 | 
12 | #include "ezgraver.h"
13 | 
14 | namespace Ui {
15 | class MainWindow;
16 | }
17 | 
18 | class MainWindow : public QMainWindow {
19 |     Q_OBJECT
20 |     Q_PROPERTY(bool connected READ connected NOTIFY connectedChanged)
21 | 
22 | public:
23 |     explicit MainWindow(QWidget* parent = NULL);
24 |     ~MainWindow();
25 | 
26 |     bool connected() const;
27 | signals:
28 |     void connectedChanged(bool connected);
29 | 
30 | private slots:
31 |     void on_connect_clicked();
32 |     void on_home_clicked();
33 |     void on_up_clicked();
34 |     void on_left_clicked();
35 |     void on_center_clicked();
36 |     void on_right_clicked();
37 |     void on_down_clicked();
38 |     void on_upload_clicked();
39 |     void on_preview_clicked();
40 |     void on_start_clicked();
41 |     void on_pause_clicked();
42 |     void on_reset_clicked();
43 |     void on_disconnect_clicked();
44 |     void on_image_clicked();
45 | 
46 |     void updatePorts();
47 |     void bytesWritten(qint64 bytes);
48 |     void updateProgress(qint64 bytes);
49 |     void updateEngraveProgress();
50 | 
51 | protected:
52 |     void dragEnterEvent(QDragEnterEvent* event);
53 |     void dropEvent(QDropEvent* event);
54 | 
55 | private:
56 |     /*! The delay between each port list update. */
57 |     static int const PortUpdateDelay{1000};
58 |     /*! The delay between each progress update while erasing the EEPROM. */
59 |     static int const EraseProgressDelay{500};
60 | 
61 |     Ui::MainWindow* _ui;
62 |     QTimer _portTimer{};
63 |     QImage _image{};
64 |     QSettings _settings{"EzGraver", "EzGraver"};
65 | 
66 |     std::shared_ptr<Ez::EzGraver> _ezGraver{};
67 |     std::function<void(qint64)> _bytesWrittenProcessor{[](qint64){}};
68 |     bool _connected{false};
69 | 
70 |     void _initBindings();
71 |     void _initUploadBindings();
72 |     void _initConnectionBindings();
73 |     void _initSetupBindings();
74 |     void _initTransformationBindings();
75 |     void _initLayerBindings();
76 | 
77 |     void _initConversionFlags();
78 |     void _initProtocols();
79 | 
80 |     void _setConnected(bool connected);
81 |     void _printVerbose(QString const& verbose);
82 |     void _loadImage(QString const& fileName);
83 |     void _eraseProgressed(QTimer* eraseProgressTimer, QImage const& image, int const& waitTimeMs);
84 |     void _uploadImage(QImage const& image);
85 | };
86 | 
87 | #endif // MAINWINDOW_H
88 | 


--------------------------------------------------------------------------------
/EzGraverCore/ezgraver_v3.cpp:
--------------------------------------------------------------------------------
 1 | #include "ezgraver_v3.h"
 2 | 
 3 | #include <QDebug>
 4 | #include <QByteArray>
 5 | #include <QBuffer>
 6 | 
 7 | #include "specifications.h"
 8 | 
 9 | namespace Ez {
10 | 
11 | void EzGraverV3::start(unsigned char const& burnTime) {
12 |     _setBurnTime(burnTime);
13 |     qDebug() << "starting engrave process";
14 |     _transmit(QByteArray::fromRawData("\xFF\x01\x01\x00", 4));
15 | }
16 | 
17 | void EzGraverV3::_setBurnTime(unsigned char const& burnTime) {
18 |     if(burnTime < 0x01 || burnTime > 0xF0) {
19 |         throw new std::out_of_range("burntime out of range");
20 |     }
21 |     qDebug() << "setting burn time to:" << static_cast<int>(burnTime);
22 | 
23 |     QByteArray payload{"\xFF\x05?\x00", 4};
24 |     payload[2] = burnTime;
25 |     _transmit(payload);
26 | }
27 | 
28 | void EzGraverV3::pause() {
29 |     qDebug() << "pausing engrave process";
30 |     _transmit(QByteArray::fromRawData("\xFF\x01\x02\x00", 4));
31 | }
32 | 
33 | void EzGraverV3::reset() {
34 |     qDebug() << "resetting";
35 |     _transmit(QByteArray::fromRawData("\xFF\x04\x01\x00", 4));
36 | }
37 | 
38 | void EzGraverV3::home() {
39 |     qDebug() << "moving to home";
40 |     _transmit(0xF3);
41 | }
42 | 
43 | void EzGraverV3::center() {
44 |     qDebug() << "moving to center";
45 |     _transmit(QByteArray::fromRawData("\xFF\x02\x01\x00", 4));
46 | }
47 | 
48 | void EzGraverV3::preview() {
49 |     qDebug() << "drawing image preview";
50 |     _transmit(QByteArray::fromRawData("\xFF\x02\x02\x00", 4));
51 | }
52 | 
53 | void EzGraverV3::up() {
54 |     qDebug() << "moving up";
55 |     _transmit(QByteArray::fromRawData("\xFF\x03\x01\x00", 4));
56 | }
57 | 
58 | void EzGraverV3::down() {
59 |     qDebug() << "moving down";
60 |     _transmit(QByteArray::fromRawData("\xFF\x03\x02\x00", 4));
61 | }
62 | 
63 | void EzGraverV3::left() {
64 |     qDebug() << "moving left";
65 |     _transmit(QByteArray::fromRawData("\xFF\x03\x03\x00", 4));
66 | }
67 | 
68 | void EzGraverV3::right() {
69 |     qDebug() << "moving right";
70 |     _transmit(QByteArray::fromRawData("\xFF\x03\x04\x00", 4));
71 | }
72 | 
73 | int EzGraverV3::erase() {
74 |     qDebug() << "erasing EEPROM";
75 |     _transmit(QByteArray::fromRawData("\xFF\x06\x01\x00", 4));
76 |     return 50;
77 | }
78 | 
79 | int EzGraverV3::uploadImage(QImage const& originalImage) {
80 |     qDebug() << "converting image to bitmap";
81 |     QImage image{originalImage
82 |             .scaled(Ez::Specifications::ImageWidth, Ez::Specifications::ImageHeight)
83 |             .mirrored()
84 |             .convertToFormat(QImage::Format_Mono)};
85 |     QByteArray bytes{};
86 |     QBuffer buffer{&bytes};
87 |     image.save(&buffer, "BMP");
88 | 
89 |     // protocol v3 neither needs the BMP header nor the invertion of the pixels.
90 |     return EzGraver::uploadImage(bytes.mid(62));
91 | }
92 | 
93 | }
94 | 


--------------------------------------------------------------------------------
/EzGraverCore/ezgraver.cpp:
--------------------------------------------------------------------------------
  1 | #include "ezgraver.h"
  2 | 
  3 | #include <QSerialPort>
  4 | #include <QSerialPortInfo>
  5 | #include <QDebug>
  6 | #include <QBitmap>
  7 | #include <QBuffer>
  8 | 
  9 | #include <iterator>
 10 | #include <algorithm>
 11 | #include <functional>
 12 | 
 13 | #include "specifications.h"
 14 | 
 15 | namespace Ez {
 16 | 
 17 | EzGraver::EzGraver(std::shared_ptr<QSerialPort> serial) : _serial{serial} {}
 18 | 
 19 | void EzGraver::start(unsigned char const& burnTime) {
 20 |     _setBurnTime(burnTime);
 21 |     qDebug() << "starting engrave process";
 22 |     _transmit(0xF1);
 23 | }
 24 | 
 25 | void EzGraver::_setBurnTime(unsigned char const& burnTime) {
 26 |     if(burnTime < 0x01 || burnTime > 0xF0) {
 27 |         throw new std::out_of_range("burntime out of range");
 28 |     }
 29 |     qDebug() << "setting burn time to:" << static_cast<int>(burnTime);
 30 |     _transmit(burnTime);
 31 | }
 32 | 
 33 | void EzGraver::pause() {
 34 |     qDebug() << "pausing engrave process";
 35 |     _transmit(0xF2);
 36 | }
 37 | 
 38 | void EzGraver::reset() {
 39 |     qDebug() << "resetting";
 40 |     _transmit(0xF9);
 41 | }
 42 | 
 43 | void EzGraver::home() {
 44 |     qDebug() << "moving to home";
 45 |     _transmit(0xF3);
 46 | }
 47 | 
 48 | void EzGraver::center() {
 49 |     qDebug() << "moving to center";
 50 |     _transmit(0xFB);
 51 | }
 52 | 
 53 | void EzGraver::preview() {
 54 |     qDebug() << "drawing image preview";
 55 |     _transmit(0xF4);
 56 | }
 57 | 
 58 | int EzGraver::erase() {
 59 |     qDebug() << "erasing EEPROM";
 60 |     _transmit(QByteArray{8, '\xFE'});
 61 |     return 6000;
 62 | }
 63 | 
 64 | int EzGraver::uploadImage(QImage const& originalImage) {
 65 |     qDebug() << "converting image to bitmap";
 66 |     QImage image{originalImage
 67 |             .scaled(Ez::Specifications::ImageWidth, Ez::Specifications::ImageHeight)
 68 |             .mirrored()
 69 |             .convertToFormat(QImage::Format_Mono)};
 70 |     image.invertPixels();
 71 | 
 72 |     QByteArray bytes{};
 73 |     QBuffer buffer{&bytes};
 74 |     image.save(&buffer, "BMP");
 75 |     return uploadImage(bytes);
 76 | }
 77 | 
 78 | int EzGraver::uploadImage(QByteArray const& image) {
 79 |     qDebug() << "uploading image";
 80 |     // Data is chunked in order to get at least some progress updates
 81 |     _transmit(image, 8192);
 82 |     return image.size();
 83 | }
 84 | 
 85 | void EzGraver::awaitTransmission(int msecs) {
 86 |     _serial->waitForBytesWritten(msecs);
 87 | }
 88 | 
 89 | std::shared_ptr<QSerialPort> EzGraver::serialPort() {
 90 |     return _serial;
 91 | }
 92 | 
 93 | void EzGraver::_transmit(unsigned char const& data) {
 94 |     _transmit(QByteArray{1, static_cast<char>(data)});
 95 | }
 96 | 
 97 | void EzGraver::_transmit(QByteArray const& data) {
 98 |     qDebug() << "transmitting" << data.size() << "bytes:" << data.toHex();
 99 |     _serial->write(data);
100 |     _serial->flush();
101 | }
102 | 
103 | void EzGraver::_transmit(QByteArray const& data, int chunkSize) {
104 |     qDebug() << "transmitting" << data.size() << "bytes in chunks of size" << chunkSize;
105 |     for(int i{0}; i < data.size(); i += chunkSize) {
106 |         _serial->write(data.mid(i, chunkSize));
107 |         _serial->flush();
108 |     }
109 | }
110 | 
111 | EzGraver::~EzGraver() {
112 |     qDebug() << "EzGraver is being destroyed, closing serial port";
113 |     _serial->close();
114 | }
115 | 
116 | }
117 | 
118 | 


--------------------------------------------------------------------------------
/EzGraverCli/main.cpp:
--------------------------------------------------------------------------------
  1 | #include <QCoreApplication>
  2 | #include <QThread>
  3 | 
  4 | #include <iterator>
  5 | #include <algorithm>
  6 | #include <iostream>
  7 | #include <memory>
  8 | #include <exception>
  9 | 
 10 | #include "ezgraver.h"
 11 | #include "factory.h"
 12 | #include "specifications.h"
 13 | 
 14 | std::ostream& operator<<(std::ostream& lhv, QString const& rhv) {
 15 |     return lhv << rhv.toStdString();
 16 | }
 17 | 
 18 | void showHelp() {
 19 |     std::cout << "Usage: EzGraverCli <option> [arguments...]\n\n";
 20 |     std::cout << "Available options:\n";
 21 |     std::cout << "  v - Prints the version information\n";
 22 |     std::cout << "  a - Shows the available ports\n";
 23 |     std::cout << "  h <port> - Moves the engraver to the home position\n";
 24 |     std::cout << "  s <port> - Starts the engraving process with the burn time 60\n";
 25 |     std::cout << "  p <port> - Pauses the engraver\n";
 26 |     std::cout << "  r <port> - Resets the engraver\n";
 27 |     std::cout << "  u <port> <image> - Uploads the given image to the engraver\n";
 28 | }
 29 | 
 30 | void showAvailablePorts() {
 31 |     auto ports = Ez::availablePorts();
 32 |     std::cout << "Available Ports: ";
 33 |     std::ostream_iterator<QString> out{std::cout, " "};
 34 |     std::copy(ports.cbegin(), ports.cend(), out);
 35 |     std::cout << '\n';
 36 | }
 37 | 
 38 | void uploadImage(std::shared_ptr<Ez::EzGraver>& engraver, QList<QString> const& arguments) {
 39 |     if(arguments.size() < 2) {
 40 |         std::cout << "No image provided\n";
 41 |         return;
 42 |     }
 43 | 
 44 |     auto fileName = arguments[1];
 45 |     QImage image{};
 46 |     if(!image.load(fileName)) {
 47 |         std::cout << "Error while loading image '" << fileName << "'\n";
 48 |         return;
 49 |     }
 50 | 
 51 |     std::cout << "erasing EEPROM\n";
 52 |     auto waitTimeMs = engraver->erase();
 53 |     engraver->awaitTransmission();
 54 |     QThread::msleep(waitTimeMs);
 55 | 
 56 |     std::cout << "uploading image to EEPROM\n";
 57 |     engraver->uploadImage(image);
 58 | }
 59 | 
 60 | void processCommand(char const& command, QList<QString> const& arguments) {
 61 |     try {
 62 |         auto engraver = Ez::create(arguments[0]);
 63 | 
 64 |         switch(command) {
 65 |         case 'h':
 66 |             engraver->home();
 67 |             break;
 68 |         case 'c':
 69 |             engraver->center();
 70 |             break;
 71 |         case 's':
 72 |             engraver->start(60);
 73 |             break;
 74 |         case 'r':
 75 |             engraver->reset();
 76 |             break;
 77 |         case 'p':
 78 |             engraver->pause();
 79 |             break;
 80 |         case 'u':
 81 |             uploadImage(engraver, arguments);
 82 |             break;
 83 |         default:
 84 |             std::cout << "Unknown command: '" << command << "'\n";
 85 |             showHelp();
 86 |         }
 87 | 
 88 |         engraver->awaitTransmission();
 89 |     } catch(std::exception const& e) {
 90 |         std::cout << "Error: " << e.what() << '\n';
 91 |     }
 92 | }
 93 | 
 94 | void handleArguments(QStringList const& arguments) {
 95 |     if(arguments.size() < 2) {
 96 |         showHelp();
 97 |         return;
 98 |     }
 99 | 
100 |     auto command = arguments[1][0].toLatin1();
101 |     switch(command) {
102 |     case 'a':
103 |         showAvailablePorts();
104 |         return;
105 |     case 'v':
106 |         std::cout << "EzGraver " << EZ_VERSION << '\n';
107 |         return;
108 |     }
109 | 
110 |     if(arguments.size() < 3) {
111 |         showHelp();
112 |         return;
113 |     }
114 | 
115 |     processCommand(command, arguments.mid(2));
116 | }
117 | 
118 | int main(int argc, char* argv[]) {
119 |     QCoreApplication app{argc, argv};
120 | 
121 |     QStringList arguments{};
122 |     std::copy(argv, argv+argc, std::back_inserter(arguments));
123 |     handleArguments(arguments);
124 | }
125 | 


--------------------------------------------------------------------------------
/EzGraverCore/ezgraver.h:
--------------------------------------------------------------------------------
  1 | #ifndef EZGRAVER_H
  2 | #define EZGRAVER_H
  3 | 
  4 | #include "ezgravercore_global.h"
  5 | 
  6 | #include <QImage>
  7 | #include <QSerialPort>
  8 | #include <QSize>
  9 | 
 10 | #include <memory>
 11 | 
 12 | namespace Ez {
 13 | /*!
 14 |  * Allows accessing a NEJE engraver using the serial port it was instantiated with.
 15 |  * The connection is closed as soon as the object is destroyed.
 16 |  */
 17 | struct EZGRAVERCORESHARED_EXPORT EzGraver {
 18 |     /*!
 19 |      * Creates an instance of the EzGraver.
 20 |      *
 21 |      * \param serial The serial port to use.
 22 |      */
 23 |     explicit EzGraver(std::shared_ptr<QSerialPort> serial);
 24 | 
 25 |     /*!
 26 |      * Starts the engraving process with the given \a burnTime.
 27 |      *
 28 |      * \param burnTime The burn time to use in milliseconds.
 29 |      */
 30 |     virtual void start(unsigned char const& burnTime);
 31 | 
 32 |     /*!
 33 |      * Pauses the engraving process at the given location. The process
 34 |      * can be continued by invoking start.
 35 |      */
 36 |     virtual void pause();
 37 | 
 38 |     /*! Resets the engraver. */
 39 |     virtual void reset();
 40 | 
 41 |     /*! Moves the engraver to the home position. */
 42 |     virtual void home();
 43 | 
 44 |     /*! Moves the engraver to the center. */
 45 |     virtual void center();
 46 | 
 47 |     /*! Draws a preview of the currently loaded image. */
 48 |     virtual void preview();
 49 | 
 50 |     /*! Moves the engraver up. */
 51 |     virtual void up() = 0;
 52 | 
 53 |     /*! Moves the engraver down. */
 54 |     virtual void down() = 0;
 55 | 
 56 |     /*! Moves the engraver left. */
 57 |     virtual void left() = 0;
 58 | 
 59 |     /*! Moves the engraver right. */
 60 |     virtual void right() = 0;
 61 | 
 62 |     /*!
 63 |      * Erases the EEPROM of the engraver. This is necessary before uploading
 64 |      * any new image to it.
 65 |      * Erasing the EEPROM takes a while. Sending image data to early causes
 66 |      * that some of the leading pixels are lost. Waiting for about 5 seconds
 67 |      * seems to be sufficient.
 68 |      *
 69 |      * \return The recommended time in ms to wait until uploading the image.
 70 |      */
 71 |     virtual int erase();
 72 | 
 73 |     /*!
 74 |      * Uploads the given \a image to the EEPROM. It is mandatory to use \a erase()
 75 |      * it prior uploading an image. The image will automatically be scaled, inverted,
 76 |      * mirrored and converted to a monochrome bitmap.
 77 |      *
 78 |      * \param image The image to upload to the EEPROM for engraving.
 79 |      * \return The number of bytes being sent to the device.
 80 |      */
 81 |     virtual int uploadImage(QImage const& image);
 82 | 
 83 |     /*!
 84 |      * Uploads any given \a image byte array to the EEPROM. It has to be a monochrome
 85 |      * bitmap of the dimensions 512x512. Every white pixel is being engraved.
 86 |      *
 87 |      * \param image The image byte array to upload to the EEPROM.
 88 |      * \return The number of bytes being sent to the device.
 89 |      */
 90 |     int uploadImage(QByteArray const& image);
 91 | 
 92 |     /*!
 93 |      * Waits until the current serial port buffer is fully written to the device.
 94 |      *
 95 |      * \param msecs The time in milliseconds to await the transmission to complete.
 96 |      */
 97 |     void awaitTransmission(int msecs=-1);
 98 | 
 99 |     /*!
100 |      * Gets the serialport used by the EzGraver instance.
101 |      *
102 |      * \return The serial port used.
103 |      */
104 |     std::shared_ptr<QSerialPort> serialPort();
105 | 
106 |     EzGraver() = delete;
107 |     virtual ~EzGraver();
108 | 
109 | protected:
110 |     void _transmit(unsigned char const& data);
111 |     void _transmit(QByteArray const& data);
112 |     void _transmit(QByteArray const& data, int chunkSize);
113 | 
114 | private:
115 |     std::shared_ptr<QSerialPort> _serial;
116 | 
117 |     void _setBurnTime(unsigned char const& burnTime);
118 | };
119 | 
120 | }
121 | 
122 | #endif // EZGRAVER_H
123 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | | Linux / OSX | Windows | Latest  | Downloads |
 3 | |-------------|---------|---------|-----------|
 4 | |[![Travis Build Status](https://travis-ci.org/camrein/EzGraver.svg?branch=master)](https://travis-ci.org/camrein/EzGraver)|[![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/g98wrysmliq4t8d9/branch/master?svg=true)](https://ci.appveyor.com/project/camrein/ezgraver)|[![Latest GitHub Release](https://img.shields.io/github/release/camrein/EzGraver.svg)](https://github.com/camrein/EzGraver/releases/latest)|[![Total Downloads](https://img.shields.io/github/downloads/camrein/EzGraver/total.svg)](https://github.com/camrein/EzGraver/releases/latest)|
 5 | 
 6 | # Archived
 7 | 
 8 | EzGraver is no longer actively maintained. Therefore, the repository has been archived.
 9 | 
10 | # About
11 | EzGraver is an open source software allowing users to use with laser engravers by NEJE. It supports Linux, OSX, and Windows. It provides both a command-line interface and a graphical user interface. The latest release is available on the [releases page](https://github.com/camrein/EzGraver/releases/latest).
12 | 
13 | ![EzGraver Screenshot](screenshot.png)
14 | 
15 | # Before Running
16 | On all platforms (Linux, OSX, and Windows), it is required that the proper drivers are installed. If that's not the case, the engraver will not be detected and not listed in the dropdown. There were reports (at least for Windows) that the [Arduino](https://www.arduino.cc/en/Main/Software) drivers are working.
17 | 
18 | Additionally, Windows requires the installation of [Visual C++ Redistributable for Visual Studio 2015](https://www.microsoft.com/en-us/download/details.aspx?id=48145) too. Otherwise, errors like *VCRUNTIME140.dll* or *MSVCP140.dll* could not be found will be shown.
19 | 
20 | Linux may require running EzGraver with extended privileges. This possibly identifies itself with a *permission denied* error. To gain access to the serial device, add the user to the group of allowed serial port users (*dialout* for Ubuntu).
21 | 
22 | # Command-Line Interface
23 | Besides the graphical user interface, EzGraver provides a pure command-line interface too.
24 | ```bash
25 | Usage: EzGraverCli <option> [arguments...]
26 | 
27 | Available options:
28 |   v - Prints the version information
29 |   a - Shows the available ports
30 |   h <port> - Moves the engraver to the home position
31 |   s <port> - Starts the engraving process with the burn time 60
32 |   p <port> - Pauses the engraver
33 |   r <port> - Resets the engraver
34 |   u <port> <image> - Uploads the given image to the engraver
35 | ```
36 | 
37 | # Building
38 | EzGraver was developed with QT 5.7. The lowest known API-Requirement is [QT 5.4](http://doc.qt.io/qt-5.7/qtimer.html#singleShot-4). Continuous integration on Travis-CI, Tea-CI and AppVeyor is done with at least QT 5.5.
39 | 
40 | ## Windows
41 | Download the latest QT release and build it using QT Creator. Builds have been tested on the following kits:
42 | - Desktop QT 5.7.0 MinGW 32bit
43 | - Desktop QT 5.7.0 MSVC2015 64bit
44 | 
45 | ## OS X
46 | First, install a sufficient QT version. In this example, QT 5.5 is being installed.
47 | ```bash
48 | brew update
49 | brew install qt55
50 | brew link --force qt55
51 | ```
52 | 
53 | Now build EzGraver.
54 | ```bash
55 | qmake -config release EzGraver.pro
56 | make
57 | ```
58 | 
59 | Copy EzGraverCore into the frameworks directory and then generate the \*.dmg file for deployment.
60 | ```bash
61 | mkdir EzGraverUi/EzGraverUi.app/Contents/Frameworks/
62 | cp EzGraverCore/libEzGraverCore.1.dylib EzGraverUi/EzGraverUi.app/Contents/Frameworks/libEzGraverCore.1.dylib
63 | macdeployqt EzGraverUi/EzGraverUi.app -dmg
64 | ```
65 | 
66 | 
67 | ## Ubuntu
68 | Before loading QT from the official Ubuntu repositories, it is recommended to ensure that they contain the required version.
69 | ```bash
70 | apt-get install build-essential qt5-qmake qtbase5-dev libqt5serialport5-dev
71 | ```
72 | 
73 | Ensure the desired QT version has been installed.
74 | ```bash
75 | qmake -qt=qt5 -v
76 | ```
77 | 
78 | Now build EzGraver.
79 | ```bash
80 | qmake -qt=qt5 -config release EzGraver.pro
81 | make
82 | ```
83 | 
84 | Install the binaries.
85 | ```bash
86 | make install
87 | ```
88 | 
89 | # Support EzGraver
90 | Knowing that people enjoy EzGraver is a great honor. If you like to support it, stars are appreciated and will help others getting aware of EzGraver.
91 | Feature requests, bug reports, general feedback, and code contributions are always welcome and will support further improvements of EzGraver.
92 | 
93 | # Acknowledgment
94 | Many thanks to:
95 | 
96 | * [Frederik Andersson](https://github.com/Na1w) for providing the control codes for protocol v1.
97 | * [AlexNk](https://github.com/AlexNk) for providing the control codes for protocol v2.
98 | * [maturz](https://github.com/maturz) and [Richard Kircheis](https://github.com/tinyisland) for providing data and help to support the protocol v3.
99 | 


--------------------------------------------------------------------------------
/EzGraverUi/imagelabel.cpp:
--------------------------------------------------------------------------------
  1 | #include "imagelabel.h"
  2 | 
  3 | #include <QPainter>
  4 | 
  5 | #include <algorithm>
  6 | 
  7 | #include "ezgraver.h"
  8 | 
  9 | ImageLabel::ImageLabel(QWidget* parent) : ClickLabel{parent} {
 10 |     resetProgressImage();
 11 |     connect(&_refreshTimer, &QTimer::timeout, this, &ImageLabel::_updateDisplayedImage);
 12 | }
 13 | 
 14 | ImageLabel::~ImageLabel() {}
 15 | 
 16 | QImage ImageLabel::image() const {
 17 |     return _image;
 18 | }
 19 | 
 20 | void ImageLabel::setImage(QImage const& image) {
 21 |     _image = image;
 22 |     _updateEngraveImage();
 23 |     emit imageLoadedChanged(true);
 24 |     emit imageChanged(image);
 25 | }
 26 | 
 27 | QImage ImageLabel::engraveImage() const {
 28 |     return _engraveImage;
 29 | }
 30 | 
 31 | void ImageLabel::setEngraveImage(QImage const& engraveImage) {
 32 |     _engraveImage = engraveImage;
 33 |     _updateDisplayedImage();
 34 |     emit engraveImageChanged(engraveImage);
 35 | }
 36 | 
 37 | void ImageLabel::setPixelEngraved(QPoint const& location) {
 38 |     if(!_refreshTimer.isActive()) {
 39 |         _refreshTimer.start(ImageRefreshIntervalDelay);
 40 |     }
 41 | 
 42 |     _progressImage.setPixel(location, qRgb(255, 0, 0));
 43 |     emit progressImageChanged(_progressImage);
 44 | }
 45 | 
 46 | QImage ImageLabel::progressImage() const {
 47 |     return _progressImage;
 48 | }
 49 | 
 50 | void ImageLabel::setProgressImage(QImage const& progressImage) {
 51 |     _progressImage = progressImage;
 52 |     _updateDisplayedImage();
 53 |     emit progressImageChanged(progressImage);
 54 | }
 55 | 
 56 | void ImageLabel::resetProgressImage() {
 57 |     QImage image{QSize{Ez::Specifications::ImageWidth, Ez::Specifications::ImageHeight}, QImage::Format_ARGB32};
 58 |     image.fill(qRgba(0, 0, 0, 0));
 59 |     setProgressImage(image);
 60 | }
 61 | 
 62 | Qt::ImageConversionFlags ImageLabel::conversionFlags() const {
 63 |     return _flags;
 64 | }
 65 | 
 66 | void ImageLabel::setConversionFlags(Qt::ImageConversionFlags const& flags) {
 67 |     _flags = flags;
 68 |     _updateEngraveImage();
 69 |     emit conversionFlagsChanged(flags);
 70 | }
 71 | 
 72 | bool ImageLabel::grayscale() const {
 73 |     return _grayscale;
 74 | }
 75 | 
 76 | void ImageLabel::setGrayscale(bool const& enabled) {
 77 |     _grayscale = enabled;
 78 |     _updateEngraveImage();
 79 |     emit grayscaleChanged(enabled);
 80 | }
 81 | 
 82 | int ImageLabel::layer() const {
 83 |     return _layer;
 84 | }
 85 | 
 86 | void ImageLabel::setLayer(int const& layer) {
 87 |     _layer = layer;
 88 |     _updateEngraveImage();
 89 |     emit layerChanged(layer);
 90 | }
 91 | 
 92 | int ImageLabel::layerCount() const {
 93 |     return _layerCount;
 94 | }
 95 | 
 96 | void ImageLabel::setLayerCount(int const& layerCount) {
 97 |     _layerCount = layerCount;
 98 |     _updateEngraveImage();
 99 |     emit layerCountChanged(layerCount);
100 | }
101 | 
102 | bool ImageLabel::keepAspectRatio() const {
103 |     return _keepAspectRatio;
104 | }
105 | 
106 | void ImageLabel::setKeepAspectRatio(bool const& keepAspectRatio) {
107 |     _keepAspectRatio = keepAspectRatio;
108 |     _updateEngraveImage();
109 |     emit keepAspectRatioChanged(keepAspectRatio);
110 | }
111 | 
112 | bool ImageLabel::flipHorizontally() const {
113 |     return _flipHorizontally;
114 | }
115 | 
116 | void ImageLabel::setFlipHorizontally(bool const& flipHorizontally) {
117 |     _flipHorizontally = flipHorizontally;
118 |     _updateEngraveImage();
119 |     emit flipHorizontallyChanged(flipHorizontally);
120 | }
121 | 
122 | bool ImageLabel::flipVertically() const {
123 |     return _flipVertically;
124 | }
125 | 
126 | void ImageLabel::setFlipVertically(bool const& flipVertically) {
127 |     _flipVertically = flipVertically;
128 |     _updateEngraveImage();
129 |     emit flipVerticallyChanged(flipVertically);
130 | }
131 | 
132 | bool ImageLabel::transformed() const {
133 |     return _transformed;
134 | }
135 | 
136 | void ImageLabel::setTransformed(bool const& transformed) {
137 |     _transformed = transformed;
138 |     _updateEngraveImage();
139 |     emit transformedChanged(transformed);
140 | }
141 | 
142 | float ImageLabel::imageScale() const {
143 |     return _imageScale;
144 | }
145 | 
146 | void ImageLabel::setImageScale(float const& imageScale) {
147 |     _imageScale = imageScale;
148 |     _updateEngraveImage();
149 |     emit imageScaleChanged(imageScale);
150 | }
151 | 
152 | int ImageLabel::imageRotation() const {
153 |     return _imageRotation;
154 | }
155 | 
156 | void ImageLabel::setImageRotation(int const& imageRotation) {
157 |     _imageRotation = imageRotation;
158 |     _updateEngraveImage();
159 |     emit imageRotationChanged(imageRotation);
160 | }
161 | 
162 | void ImageLabel::_updateEngraveImage() {
163 |     if(!imageLoaded()) {
164 |         return;
165 |     }
166 | 
167 |     // Draw white background, otherwise transparency is converted to black.
168 |     QImage image{QSize{Ez::Specifications::ImageWidth, Ez::Specifications::ImageHeight}, QImage::Format_ARGB32};
169 |     image.fill(QColor{Qt::white});
170 |     QPainter painter{&image};
171 | 
172 |     QImage flipped{_image.mirrored(_flipHorizontally, _flipVertically)};
173 | 
174 |     if(_transformed) {
175 |         QTransform rotation{};
176 |         rotation.rotate(_imageRotation);
177 |         auto rotated = flipped.transformed(rotation);
178 | 
179 |         auto scaled = rotated.scaled(rotated.width() * _imageScale, rotated.height() * _imageScale);
180 |         QPoint position{(image.width() - scaled.width()) / 2, (image.height() - scaled.height()) / 2};
181 | 
182 |         painter.drawImage(position, scaled);
183 |     } else if(_keepAspectRatio) {
184 |         // As at this time, the target image is quadratic, scaling according the larger dimension is sufficient.
185 |         auto scaled = (flipped.width() > flipped.height() ? flipped.scaledToWidth(image.width()) : flipped.scaledToHeight(image.height()));
186 |         auto position = (flipped.width() > flipped.height() ? QPoint{0, (image.height() - scaled.height()) / 2} : QPoint{(image.width() - scaled.width()) / 2, 0});
187 |         painter.drawImage(position, scaled);
188 |     } else {
189 |         painter.drawImage(QPoint{}, flipped.scaled(image.size()));
190 |     }
191 | 
192 |     auto targetImage = _grayscale ? _createGrayscaleImage(image) : image.convertToFormat(QImage::Format_Mono, _flags);
193 |     setEngraveImage(targetImage);
194 | }
195 | 
196 | void ImageLabel::_updateDisplayedImage() {
197 |     QImage image{QSize{Ez::Specifications::ImageWidth, Ez::Specifications::ImageHeight}, QImage::Format_ARGB32};
198 |     QPainter painter{&image};
199 |     painter.drawImage(QPoint{}, _engraveImage);
200 |     painter.drawImage(QPoint{}, _progressImage);
201 |     setPixmap(QPixmap::fromImage(image));
202 | }
203 | 
204 | QImage ImageLabel::_createGrayscaleImage(QImage const& original) const {
205 |     auto colorTable = _createColorTable();
206 |     QImage grayed = original.convertToFormat(QImage::Format_Indexed8, colorTable, _flags);
207 |     if(_layer == 0) {
208 |         return grayed;
209 |     }
210 | 
211 |     auto visibleLayer = _layer-1;
212 |     int i{0};
213 |     std::transform(colorTable.begin(), colorTable.end(), colorTable.begin(), [&i,visibleLayer](QRgb) {
214 |         return i++ == visibleLayer ? qRgb(0, 0, 0) : qRgb(255, 255, 255);
215 |     });
216 |     grayed.setColorTable(colorTable);
217 | 
218 |     return grayed.convertToFormat(QImage::Format_Mono, _flags);
219 | }
220 | 
221 | QVector<QRgb> ImageLabel::_createColorTable() const {
222 |     QVector<QRgb> colorTable(_layerCount - 1);
223 | 
224 |     int i{0};
225 |     std::generate(colorTable.begin(), colorTable.end(), [this, &i] {
226 |       int gray = (256 / (_layerCount-1)) * (i++);
227 |       return qRgb(gray, gray, gray);
228 |     });
229 |     colorTable.push_back(qRgb(255, 255, 255));
230 | 
231 |     return colorTable;
232 | }
233 | 
234 | bool ImageLabel::imageLoaded() const {
235 |     return !_image.isNull();
236 | }
237 | 
238 | void ImageLabel::setImageDimensions(QSize const& dimensions) {
239 |     auto span = this->lineWidth()*2;
240 |     setMinimumWidth(dimensions.width() + span);
241 |     setMinimumHeight(dimensions.height() + span);
242 | }
243 | 


--------------------------------------------------------------------------------
/EzGraverUi/imagelabel.h:
--------------------------------------------------------------------------------
  1 | #ifndef IMAGELABEL_H
  2 | #define IMAGELABEL_H
  3 | 
  4 | #include <QImage>
  5 | #include <QPixmap>
  6 | #include <QTimer>
  7 | #include <QVector>
  8 | 
  9 | #include "clicklabel.h"
 10 | 
 11 | #include "specifications.h"
 12 | 
 13 | class ImageLabel : public ClickLabel {
 14 |     Q_OBJECT
 15 |     Q_PROPERTY(QImage image READ image WRITE setImage NOTIFY imageChanged)
 16 |     Q_PROPERTY(QImage engraveImage READ engraveImage WRITE setEngraveImage NOTIFY engraveImageChanged)
 17 |     Q_PROPERTY(QImage progressImage READ progressImage WRITE setProgressImage RESET resetProgressImage NOTIFY progressImageChanged)
 18 | 
 19 |     Q_PROPERTY(Qt::ImageConversionFlags conversionFlags READ conversionFlags WRITE setConversionFlags NOTIFY conversionFlagsChanged)
 20 | 
 21 |     Q_PROPERTY(bool grayscale READ grayscale WRITE setGrayscale NOTIFY grayscaleChanged)
 22 |     Q_PROPERTY(int layer READ layer WRITE setLayer NOTIFY layerChanged)
 23 |     Q_PROPERTY(int layerCount READ layerCount WRITE setLayerCount NOTIFY layerCountChanged)
 24 | 
 25 |     Q_PROPERTY(bool keepAspectRatio READ keepAspectRatio WRITE setKeepAspectRatio NOTIFY keepAspectRatioChanged)
 26 |     Q_PROPERTY(bool flipHorizontally READ flipHorizontally WRITE setFlipHorizontally NOTIFY flipHorizontallyChanged)
 27 |     Q_PROPERTY(bool flipVertically READ flipVertically WRITE setFlipVertically NOTIFY flipVerticallyChanged)
 28 | 
 29 |     Q_PROPERTY(bool transformed READ transformed WRITE setTransformed NOTIFY transformedChanged)
 30 |     Q_PROPERTY(float imageScale READ imageScale WRITE setImageScale NOTIFY imageScaleChanged)
 31 |     Q_PROPERTY(float imageRotation READ imageRotation WRITE setImageRotation NOTIFY imageRotationChanged)
 32 | 
 33 |     Q_PROPERTY(bool imageLoaded READ imageLoaded NOTIFY imageLoadedChanged)
 34 | 
 35 | public:
 36 |     /*!
 37 |      * Creates a new instance with the given \a parent.
 38 |      *
 39 |      * \param parent The parent of the label.
 40 |      */
 41 |     explicit ImageLabel(QWidget* parent=NULL);
 42 | 
 43 |     /*!
 44 |      * Frees all required resources upon deconstruction.
 45 |      */
 46 |     virtual ~ImageLabel();
 47 | 
 48 |     /*!
 49 |      * Gets the currently loaded image without the application of
 50 |      * any conversion.
 51 |      *
 52 |      * \return The currently loaded image.
 53 |      */
 54 |     QImage image() const;
 55 | 
 56 |     /*!
 57 |      * Changes the currently displayed image to the given image
 58 |      * and applies the selected conversion method.
 59 |      *
 60 |      * \param image The image to load.
 61 |      */
 62 |     void setImage(QImage const& image);
 63 | 
 64 |     /*!
 65 |      * Gets the currently active engraving image.
 66 |      *
 67 |      * \return The current engraving image.
 68 |      */
 69 |     QImage engraveImage() const;
 70 | 
 71 |     /*!
 72 |      * Changes the currently active engraving image.
 73 |      *
 74 |      * \param engravePixmap The image that is used for engraving.
 75 |      */
 76 |     void setEngraveImage(QImage const& engraveImage);
 77 | 
 78 |     /*!
 79 |      * Gets the image that represents the current engraving progress.
 80 |      *
 81 |      * \return The image representing the current progress.
 82 |      */
 83 |     QImage progressImage() const;
 84 | 
 85 |     /*!
 86 |      * Sets the image that represents the current engraving progress.
 87 |      *
 88 |      * \param progressImage An image that represents the current engraving progress.
 89 |      */
 90 |     void setProgressImage(QImage const& progressImage);
 91 | 
 92 |     /*!
 93 |      * Marks the pixel at the specified point as engraved.
 94 |      *
 95 |      * \param location The location of the pixel to mark as engraved.
 96 |      */
 97 |     void setPixelEngraved(QPoint const& location);
 98 | 
 99 |     /*!
100 |      * Resets the image that represents the current engraving progress to its initial (empty) state.
101 |      */
102 |     void resetProgressImage();
103 | 
104 |     /*!
105 |      * Gets the currently selected conversion flags.
106 |      *
107 |      * \return The currently selected conversion flags.
108 |      */
109 |     Qt::ImageConversionFlags conversionFlags() const;
110 | 
111 |     /*!
112 |      * Changes the applied conversion flags to the given one and
113 |      * updates the currently displayed image.
114 |      *
115 |      * \param flags The conversion flags to use.
116 |      */
117 |     void setConversionFlags(Qt::ImageConversionFlags const& flags);
118 | 
119 |     /*!
120 |      * Gets if grayscale is enabled.
121 |      *
122 |      * \return \c true if grayscale is enabled.
123 |      */
124 |     bool grayscale() const;
125 | 
126 |     /*!
127 |      * Enables/disables the grayscale setting of the image.
128 |      *
129 |      * \param enabled \c true if the image should be handled as grayscale.
130 |      */
131 |     void setGrayscale(bool const& enabled);
132 | 
133 |     /*!
134 |      * Gets the currently selected grayscale layer.
135 |      *
136 |      * \return The currently selected grayscale layer.
137 |      */
138 |     int layer() const;
139 | 
140 |     /*!
141 |      * Changes the displayed grayscale layer to the provided one.
142 |      *
143 |      * \param layer The layer to display.
144 |      */
145 |     void setLayer(int const& layer);
146 | 
147 |     /*!
148 |      * Gets the currently used number of layers.
149 |      *
150 |      * \return The currently user number of layers.
151 |      */
152 |     int layerCount() const;
153 | 
154 |     /*!
155 |      * Changes the used number of layers.
156 |      *
157 |      * \param layer The number of layers.
158 |      */
159 |     void setLayerCount(int const& layerCount);
160 | 
161 |     /*!
162 |      * Gets the if the aspect ratio of the image should be kept.
163 |      *
164 |      * \return Returns \c true if the aspect ratio should be kept.
165 |      */
166 |     bool keepAspectRatio() const;
167 | 
168 |     /*!
169 |      * Sets the the aspect ratio of the image should be kept.
170 |      *
171 |      * \param keepAspectRatio \c true if the aspect ratio should be kept.
172 |      */
173 |     void setKeepAspectRatio(bool const& keepAspectRatio);
174 | 
175 |     /*!
176 |      * Gets the if image should be flipped horizontally.
177 |      *
178 |      * \return Returns \c true if the image should be flipped horizontally.
179 |      */
180 |     bool flipHorizontally() const;
181 | 
182 |     /*!
183 |      * Sets the the the image should be flipped horizontally.
184 |      *
185 |      * \param flipHorizontally \c true if the should be flipped horizontally.
186 |      */
187 |     void setFlipHorizontally(bool const& flipHorizontally);
188 | 
189 |     /*!
190 |      * Gets the if image should be flipped vertically.
191 |      *
192 |      * \return Returns \c true if the image should be flipped vertically.
193 |      */
194 |     bool flipVertically() const;
195 | 
196 |     /*!
197 |      * Sets the the the image should be flipped vertically.
198 |      *
199 |      * \param flipHorizontally \c true if the should be flipped vertically.
200 |      */
201 |     void setFlipVertically(bool const& flipVertically);
202 | 
203 |     /*!
204 |      * Gets if the image is being transformed.
205 |      *
206 |      * \return Returns \c true if the image is being transformed.
207 |      */
208 |     bool transformed() const;
209 | 
210 |     /*!
211 |      * Sets if the image is being transformed.
212 |      *
213 |      * \param transformed \c true if the image is being transformed.
214 |      */
215 |     void setTransformed(bool const& transformed);
216 | 
217 |     /*!
218 |      * Gets the current image scale.
219 |      *
220 |      * \return The image scale. 1.0 equals to 100% (original size).
221 |      */
222 |     float imageScale() const;
223 | 
224 |     /*!
225 |      * Sets the image scale of the image.
226 |      *
227 |      * \param imageScale The image scale. 1.0 equals to 100% (original size).
228 |      */
229 |     void setImageScale(float const& imageScale);
230 | 
231 |     /*!
232 |      * Gets the current image rotation.
233 |      *
234 |      * \return The image rotation in degrees.
235 |      */
236 |     int imageRotation() const;
237 | 
238 |     /*!
239 |      * Sets the image rotation of the image.
240 |      *
241 |      * \param imageRotation The image rotation in degrees.
242 |      */
243 |     void setImageRotation(int const& imageRotation);
244 | 
245 |     /*!
246 |      * Gets if an image has been loaded.
247 |      *
248 |      * \return Returns \c true if an image is loaded.
249 |      */
250 |     bool imageLoaded() const;
251 | 
252 |     /*!
253 |      * Sets the image dimensions. This enforces minimum dimensions of the
254 |      * component with respect to the border width.
255 |      *
256 |      * \param dimensions The image dimensions.
257 |      */
258 |     void setImageDimensions(QSize const& dimensions);
259 | signals:
260 |     /*!
261 |      * Fired as soon as the image has been changed.
262 |      *
263 |      * \param image The new image in its original state (unconverted).
264 |      */
265 |     void imageChanged(QImage const& image);
266 | 
267 |     /*!
268 |      * Fired as soon as the engraving pixmap changed.
269 |      *
270 |      * \param engravePixmap The pixmap representing the current image to engrave.
271 |      */
272 |     void engraveImageChanged(QImage const& engraveImage);
273 | 
274 |     /*!
275 |      * Fired as soon as the progress image changed.
276 |      *
277 |      * \param progressImage The image representing the current engraving progress.
278 |      */
279 |     void progressImageChanged(QImage const& progressImage);
280 | 
281 |     /*!
282 |      * Fired as soon as the conversion flags hav been changed.
283 |      *
284 |      * \param flags The newly applied conversion flags.
285 |      */
286 |     void conversionFlagsChanged(Qt::ImageConversionFlags const& flags);
287 | 
288 |     /*!
289 |      * Fired as soon as grayscale has been enabled or disabled.
290 |      *
291 |      * \param enabled \c true if grayscale has been enabled.
292 |      */
293 |     void grayscaleChanged(bool const& enabled);
294 | 
295 |     /*!
296 |      * Fired as soon as the layer of the grayscale image was changed.
297 |      *
298 |      * \param layer The currently selected layer.
299 |      */
300 |     void layerChanged(int const& layer);
301 | 
302 |     /*!
303 |      * Fired as soon as the layer the number of layers changed.
304 |      *
305 |      * \param layerCount The currently active number of layers.
306 |      */
307 |     void layerCountChanged(int const& layerCount);
308 | 
309 |     /*!
310 |      * Fired as soon as the keep aspect ratio setting flag changed.
311 |      *
312 |      * \param keepAspectRatio The currently active setting of the aspect ratio.
313 |      */
314 |     void keepAspectRatioChanged(bool const& keepAspectRatio);
315 | 
316 |     /*!
317 |      * Fired as soon as the image is flipped horizontally.
318 |      *
319 |      * \param flipHorizontally \c true if the image is flipped horizontally.
320 |      */
321 |     void flipHorizontallyChanged(bool const& flipHorizontally);
322 | 
323 |     /*!
324 |      * Fired as soon as the image is flipped vertically.
325 |      *
326 |      * \param flipVertically \c true if the image is flipped vertically.
327 |      */
328 |     void flipVerticallyChanged(bool const& flipVertically);
329 | 
330 |     /*!
331 |      * Fired as soon as the image is being transformed.
332 |      *
333 |      * \param transformed \c true if the image is being transformed.
334 |      */
335 |     void transformedChanged(bool const& transformed);
336 | 
337 |     /*!
338 |      * Fired as soon as the image scale changed.
339 |      *
340 |      * \param imageScale The current image scale. 1.0 equals to 100%.
341 |      */
342 |     void imageScaleChanged(float const& imageScale);
343 | 
344 |     /*!
345 |      * Fired as soon as the image rotation changed.
346 |      *
347 |      * \param imageRotation The current image rotation in degrees.
348 |      */
349 |     void imageRotationChanged(int const& imageRotation);
350 | 
351 |     /*!
352 |      * Fired as soon as an image has been loaded.
353 |      *
354 |      * \param imageLoaded \c true if an image is loaded.
355 |      */
356 |     void imageLoadedChanged(bool imageLoaded);
357 | private:
358 |     // The delay between refreshing the image.
359 |     // Used to reduce the stress on the UI when updating the progress.
360 |     // All other actions lead to an immediate update.
361 |     static int const ImageRefreshIntervalDelay{500};
362 |     QTimer _refreshTimer{};
363 | 
364 |     QImage _image{};
365 |     QImage _engraveImage{};
366 |     QImage _progressImage{};
367 | 
368 |     Qt::ImageConversionFlags _flags{Qt::DiffuseDither};
369 |     bool _grayscale{false};
370 |     int _layer{0};
371 |     int _layerCount{3};
372 | 
373 |     bool _keepAspectRatio{false};
374 |     bool _flipHorizontally{false};
375 |     bool _flipVertically{false};
376 | 
377 |     bool _transformed{false};
378 |     float _imageScale{1.0};
379 |     int _imageRotation{0};
380 | 
381 |     void _updateEngraveImage();
382 |     void _updateDisplayedImage();
383 |     QImage _createGrayscaleImage(QImage const& original) const;
384 |     QVector<QRgb> _createColorTable() const;
385 | };
386 | 
387 | #endif // IMAGELABEL_H
388 | 


--------------------------------------------------------------------------------
/EzGraverUi/mainwindow.cpp:
--------------------------------------------------------------------------------
  1 | #include "mainwindow.h"
  2 | #include "ui_mainwindow.h"
  3 | 
  4 | #include <QTimer>
  5 | #include <QMimeData>
  6 | #include <QFileDialog>
  7 | #include <QBitmap>
  8 | #include <QIcon>
  9 | #include <QThreadPool>
 10 | #include <QDebug>
 11 | #include <QImageReader>
 12 | #include <QFileInfo>
 13 | #include <QShortcut>
 14 | 
 15 | #include <stdexcept>
 16 | #include <algorithm>
 17 | #include <iterator>
 18 | 
 19 | #include "factory.h"
 20 | #include "specifications.h"
 21 | 
 22 | static QString const ProtocolSetting{"protocol"};
 23 | static QString const DirectorySetting{"directory"};
 24 | 
 25 | MainWindow::MainWindow(QWidget* parent) : QMainWindow{parent}, _ui{new Ui::MainWindow} {
 26 |     _ui->setupUi(this);
 27 |     setAcceptDrops(true);
 28 | 
 29 |     connect(&_portTimer, &QTimer::timeout, this, &MainWindow::updatePorts);
 30 |     _portTimer.start(PortUpdateDelay);
 31 | 
 32 |     _initBindings();
 33 |     _initConversionFlags();
 34 |     _initProtocols();
 35 |     _setConnected(false);
 36 | 
 37 |     _ui->image->setImageDimensions(QSize{Ez::Specifications::ImageWidth, Ez::Specifications::ImageHeight});
 38 | }
 39 | 
 40 | MainWindow::~MainWindow() {
 41 |     delete _ui;
 42 | }
 43 | 
 44 | void MainWindow::_initBindings() {
 45 |     _initUploadBindings();
 46 |     _initConnectionBindings();
 47 |     _initSetupBindings();
 48 |     _initTransformationBindings();
 49 |     _initLayerBindings();
 50 | 
 51 |     auto openImageShortcut = new QShortcut{QKeySequence{Qt::CTRL | Qt::Key_O}, this};
 52 |     connect(openImageShortcut, &QShortcut::activated, this, &MainWindow::on_image_clicked);
 53 | }
 54 | 
 55 | void MainWindow::_initConnectionBindings() {
 56 |     connect(this, &MainWindow::connectedChanged, _ui->ports, &QComboBox::setDisabled);
 57 |     connect(this, &MainWindow::connectedChanged, _ui->connect, &QPushButton::setDisabled);
 58 |     connect(this, &MainWindow::connectedChanged, _ui->disconnect, &QPushButton::setEnabled);
 59 | 
 60 |     connect(this, &MainWindow::connectedChanged, _ui->home, &QPushButton::setEnabled);
 61 |     connect(this, &MainWindow::connectedChanged, _ui->up, &QPushButton::setEnabled);
 62 |     connect(this, &MainWindow::connectedChanged, _ui->left, &QPushButton::setEnabled);
 63 |     connect(this, &MainWindow::connectedChanged, _ui->center, &QPushButton::setEnabled);
 64 |     connect(this, &MainWindow::connectedChanged, _ui->right, &QPushButton::setEnabled);
 65 |     connect(this, &MainWindow::connectedChanged, _ui->down, &QPushButton::setEnabled);
 66 |     connect(this, &MainWindow::connectedChanged, _ui->preview, &QPushButton::setEnabled);
 67 |     connect(this, &MainWindow::connectedChanged, _ui->start, &QPushButton::setEnabled);
 68 |     connect(this, &MainWindow::connectedChanged, _ui->pause, &QPushButton::setEnabled);
 69 |     connect(this, &MainWindow::connectedChanged, _ui->reset, &QPushButton::setEnabled);
 70 |     connect(this, &MainWindow::connectedChanged, _ui->reset, &QPushButton::setEnabled);
 71 | 
 72 |     connect(this, &MainWindow::connectedChanged, _ui->protocolVersion, &QComboBox::setDisabled);
 73 | }
 74 | 
 75 | void MainWindow::_initUploadBindings() {
 76 |     auto uploadEnabled = [this] {
 77 |         _ui->upload->setEnabled(_ui->image->imageLoaded() && _connected && (!_ui->layered->isChecked() || _ui->selectedLayer->value() > 0));
 78 |     };
 79 |     connect(this, &MainWindow::connectedChanged, uploadEnabled);
 80 |     connect(_ui->image, &ImageLabel::imageLoadedChanged, uploadEnabled);
 81 |     connect(_ui->layered, &QCheckBox::toggled, uploadEnabled);
 82 |     connect(_ui->selectedLayer, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged), uploadEnabled);
 83 | }
 84 | 
 85 | void MainWindow::_initSetupBindings() {
 86 |     connect(_ui->burnTime, &QSlider::valueChanged, [this](int const& v) { _ui->burnTimeLabel->setText(QString::number(v)); });
 87 |     connect(_ui->conversionFlags, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), [this](int const& index) {
 88 |         _ui->image->setConversionFlags(static_cast<Qt::ImageConversionFlags>(_ui->conversionFlags->itemData(index).toInt()));
 89 |     });
 90 | 
 91 |     connect(_ui->keepAspectRatio, &QCheckBox::toggled, _ui->image, &ImageLabel::setKeepAspectRatio);
 92 |     connect(_ui->flipHorizontally, &QCheckBox::toggled, _ui->image, &ImageLabel::setFlipHorizontally);
 93 |     connect(_ui->flipVertically, &QCheckBox::toggled, _ui->image, &ImageLabel::setFlipVertically);
 94 | }
 95 | 
 96 | void MainWindow::_initTransformationBindings() {
 97 |     connect(_ui->transformed, &QCheckBox::toggled, _ui->image, &ImageLabel::setTransformed);
 98 | 
 99 |     connect(_ui->transformed, &QCheckBox::toggled, _ui->imageScale, &QSlider::setEnabled);
100 |     connect(_ui->transformed, &QCheckBox::toggled, _ui->resetImageScale, &QSlider::setEnabled);
101 |     connect(_ui->imageScale, &QSlider::valueChanged, [this](int const& v) { _ui->imageScaleLabel->setText(QString::number(v)); });
102 |     connect(_ui->imageScale, &QSlider::valueChanged, [this](int const& v) { _ui->image->setImageScale(v / 100.0); });
103 |     connect(_ui->resetImageScale, &QPushButton::clicked, [this] { _ui->imageScale->setValue(100); });
104 | 
105 |     connect(_ui->transformed, &QCheckBox::toggled, _ui->imageRotation, &QSlider::setEnabled);
106 |     connect(_ui->transformed, &QCheckBox::toggled, _ui->resetImageRotation, &QSlider::setEnabled);
107 |     connect(_ui->imageRotation, &QSlider::valueChanged, [this](int const& v) { _ui->imageRotationLabel->setText(QString::number(v)); });
108 |     connect(_ui->imageRotation, &QSlider::valueChanged, _ui->image, &ImageLabel::setImageRotation);
109 |     connect(_ui->resetImageRotation, &QPushButton::clicked, [this] { _ui->imageRotation->setValue(0); });
110 | }
111 | 
112 | void MainWindow::_initLayerBindings() {
113 |     connect(_ui->layered, &QCheckBox::toggled, _ui->selectedLayer, &QSpinBox::setEnabled);
114 |     connect(_ui->layered, &QCheckBox::toggled, _ui->layerCount, &QSpinBox::setEnabled);
115 |     connect(_ui->layered, &QCheckBox::toggled, _ui->image, &ImageLabel::setGrayscale);
116 |     connect(_ui->layerCount, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged), _ui->image, &ImageLabel::setLayerCount);
117 |     connect(_ui->layerCount, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged), _ui->selectedLayer, &QSpinBox::setMaximum);
118 |     connect(_ui->selectedLayer, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged), _ui->image, &ImageLabel::setLayer);
119 | }
120 | 
121 | void MainWindow::_initConversionFlags() {
122 |     _ui->conversionFlags->addItem("DiffuseDither", Qt::DiffuseDither);
123 |     _ui->conversionFlags->addItem("OrderedDither", Qt::OrderedDither);
124 |     _ui->conversionFlags->addItem("ThresholdDither", Qt::ThresholdDither);
125 |     _ui->conversionFlags->setCurrentIndex(0);
126 | }
127 | 
128 | void MainWindow::_initProtocols() {
129 |     auto protocols = Ez::protocols();
130 |     for(auto protocol : protocols) {
131 |         _ui->protocolVersion->addItem(QString{"v%1"}.arg(protocol), protocol);
132 |     }
133 | 
134 |     auto selectedProtocol = _settings.value(ProtocolSetting, 1).toInt();
135 |     if(protocols.contains(selectedProtocol)) {
136 |         _ui->protocolVersion->setCurrentText(QString{"v%1"}.arg(selectedProtocol));
137 |     }
138 | }
139 | 
140 | void MainWindow::_printVerbose(QString const& verbose) {
141 |     _ui->verbose->appendPlainText(verbose);
142 | }
143 | 
144 | void MainWindow::updatePorts() {
145 |     QStringList ports{Ez::availablePorts()};
146 |     ports.insert(0, "");
147 | 
148 |     QString original{_ui->ports->currentText()};
149 |     _ui->ports->clear();
150 |     _ui->ports->addItems(ports);
151 | 
152 |     if(ports.contains(original)) {
153 |         _ui->ports->setCurrentText(original);
154 |     }
155 | }
156 | 
157 | void MainWindow::_loadImage(QString const& fileName) {
158 |     _printVerbose(QString{"loading image: %1"}.arg(fileName));
159 | 
160 |     QImage image{};
161 |     if(!image.load(fileName)) {
162 |         _printVerbose("failed to load image");
163 |         return;
164 |     }
165 | 
166 |     _ui->image->setImage(image);
167 | }
168 | 
169 | bool MainWindow::connected() const {
170 |     return _connected;
171 | }
172 | 
173 | void MainWindow::_setConnected(bool connected) {
174 |     _connected = connected;
175 |     emit connectedChanged(connected);
176 | }
177 | 
178 | void MainWindow::bytesWritten(qint64 bytes) {
179 |     _bytesWrittenProcessor(bytes);
180 | }
181 | 
182 | void MainWindow::updateProgress(qint64 bytes) {
183 |     qDebug() << "Bytes written:" << bytes;
184 |     auto progress = _ui->progress->value() + bytes;
185 |     _ui->progress->setValue(progress);
186 |     if(progress >= _ui->progress->maximum()) {
187 |         _printVerbose("upload completed");
188 |         _bytesWrittenProcessor = [](qint64){};
189 |     }
190 | }
191 | 
192 | void MainWindow::updateEngraveProgress() {
193 |     // Based on suggestion: https://github.com/camrein/EzGraver/issues/18#issuecomment-293070214
194 |     auto data = _ezGraver->serialPort()->read(16);
195 |     qDebug() << "received" << data.size() << "bytes:" << data.toHex();
196 | 
197 |     if((data.size() == 5) && (data[0] == (char)0xFF)) {
198 |         int x{data[1]*100 + data[2]};
199 |         int y{data[3]*100 + data[4]};
200 |         _ui->image->setPixelEngraved(QPoint{x, y});
201 |     }
202 | }
203 | 
204 | void MainWindow::on_connect_clicked() {
205 |     try {
206 |         auto protocol = _ui->protocolVersion->currentData().toInt();
207 |         _printVerbose(QString{"connecting to port %1 with protocol version %2"}.arg(_ui->ports->currentText()).arg(protocol));
208 |         _ezGraver = Ez::create(_ui->ports->currentText(), protocol);
209 |         _printVerbose("connection established successfully");
210 |         _setConnected(true);
211 | 
212 |         _settings.setValue(ProtocolSetting, protocol);
213 | 
214 |         connect(_ezGraver->serialPort().get(), &QSerialPort::bytesWritten, this, &MainWindow::bytesWritten);
215 |         connect(_ezGraver->serialPort().get(), &QSerialPort::readyRead, this, &MainWindow::updateEngraveProgress);
216 |     } catch(std::exception const& e) {
217 |         _printVerbose(QString{"Error: %1"}.arg(e.what()));
218 |     }
219 | }
220 | 
221 | void MainWindow::on_home_clicked() {
222 |     _printVerbose("moving to home");
223 |     _ezGraver->home();
224 | }
225 | 
226 | void MainWindow::on_up_clicked() {
227 |     _ezGraver->up();
228 | }
229 | 
230 | void MainWindow::on_left_clicked() {
231 |     _ezGraver->left();
232 | }
233 | 
234 | void MainWindow::on_center_clicked() {
235 |     _printVerbose("moving to center");
236 |     _ezGraver->center();
237 | }
238 | 
239 | void MainWindow::on_right_clicked() {
240 |     _ezGraver->right();
241 | }
242 | 
243 | void MainWindow::on_down_clicked() {
244 |     _ezGraver->down();
245 | }
246 | 
247 | void MainWindow::on_upload_clicked() {
248 |     _printVerbose("erasing EEPROM");
249 |     auto waitTimeMs = _ezGraver->erase();
250 | 
251 |     QImage image{_ui->image->engraveImage()};
252 |     QTimer* eraseProgressTimer{new QTimer{this}};
253 |     _ui->progress->setValue(0);
254 |     _ui->progress->setMaximum(waitTimeMs);
255 | 
256 |     auto eraseProgress = std::bind(&MainWindow::_eraseProgressed, this, eraseProgressTimer, image, waitTimeMs);
257 |     connect(eraseProgressTimer, &QTimer::timeout, eraseProgress);
258 |     eraseProgressTimer->start(EraseProgressDelay < waitTimeMs ? EraseProgressDelay : waitTimeMs);
259 | 
260 |     _ui->image->resetProgressImage();
261 | }
262 | 
263 | void MainWindow::_eraseProgressed(QTimer* eraseProgressTimer, QImage const& image, int const& waitTimeMs) {
264 |     auto value = _ui->progress->value() + EraseProgressDelay;
265 |     _ui->progress->setValue(value);
266 |     if(value < waitTimeMs) {
267 |         return;
268 |     }
269 |     eraseProgressTimer->stop();
270 | 
271 |     _uploadImage(image);
272 | }
273 | 
274 | void MainWindow::_uploadImage(QImage const& image) {
275 |     _bytesWrittenProcessor = std::bind(&MainWindow::updateProgress, this, std::placeholders::_1);
276 |     _printVerbose("uploading image to EEPROM");
277 |     auto bytes = _ezGraver->uploadImage(image);
278 |     _ui->progress->setValue(0);
279 |     _ui->progress->setMaximum(bytes);
280 | }
281 | 
282 | void MainWindow::on_preview_clicked() {
283 |     _printVerbose("drawing preview");
284 |     _ezGraver->preview();
285 | }
286 | 
287 | void MainWindow::on_start_clicked() {
288 |     _printVerbose(QString{"starting engrave process with burn time %1"}.arg(_ui->burnTime->value()));
289 |     _ezGraver->start(_ui->burnTime->value());
290 | }
291 | 
292 | void MainWindow::on_pause_clicked() {
293 |     _printVerbose("pausing engrave process");
294 |     _ezGraver->pause();
295 | }
296 | 
297 | void MainWindow::on_reset_clicked() {
298 |     _printVerbose("resetting engraver");
299 |     _ezGraver->reset();
300 |     _ui->image->resetProgressImage();
301 | }
302 | 
303 | void MainWindow::on_disconnect_clicked() {
304 |     _printVerbose("disconnecting");
305 |     _setConnected(false);
306 |     _ezGraver.reset();
307 |     _printVerbose("disconnected");
308 | }
309 | 
310 | void MainWindow::on_image_clicked() {
311 |     auto supportedFormats = QImageReader::supportedImageFormats();
312 |     QStringList fileExtensions{};
313 |     std::transform(supportedFormats.cbegin(), supportedFormats.cend(), std::back_inserter(fileExtensions), [](QByteArray const& format) {
314 |         return "*." + format;
315 |     });
316 | 
317 |     auto directory = _settings.value(DirectorySetting, "").toString();
318 |     if(!QFileInfo{directory}.isDir()) {
319 |         directory = "";
320 |     }
321 | 
322 |     auto fileName = QFileDialog::getOpenFileName(this, "Open Image", directory, QString{"Images (%1)"}.arg(fileExtensions.join(" ")));
323 |     if(!fileName.isNull()) {
324 |         _settings.setValue(DirectorySetting, QFileInfo{fileName}.absoluteDir().absolutePath());
325 |         _loadImage(fileName);
326 |     }
327 | }
328 | 
329 | void MainWindow::dragEnterEvent(QDragEnterEvent* event) {
330 |     if(event->mimeData()->hasUrls() && event->mimeData()->urls().count() == 1) {
331 |         event->acceptProposedAction();
332 |     }
333 | }
334 | 
335 | void MainWindow::dropEvent(QDropEvent* event) {
336 |     QString fileName{event->mimeData()->urls()[0].toLocalFile()};
337 |     _loadImage(fileName);
338 | }
339 | 
340 | 


--------------------------------------------------------------------------------
/EzGraverUi/mainwindow.ui:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <ui version="4.0">
  3 |  <class>MainWindow</class>
  4 |  <widget class="QMainWindow" name="MainWindow">
  5 |   <property name="geometry">
  6 |    <rect>
  7 |     <x>0</x>
  8 |     <y>0</y>
  9 |     <width>1090</width>
 10 |     <height>801</height>
 11 |    </rect>
 12 |   </property>
 13 |   <property name="windowTitle">
 14 |    <string>EzGraver</string>
 15 |   </property>
 16 |   <widget class="QWidget" name="centralWidget">
 17 |    <layout class="QHBoxLayout" name="horizontalLayout_2" stretch="0,1">
 18 |     <item>
 19 |      <layout class="QVBoxLayout" name="verticalLayout_3">
 20 |       <item>
 21 |        <widget class="ImageLabel" name="image">
 22 |         <property name="sizePolicy">
 23 |          <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
 24 |           <horstretch>0</horstretch>
 25 |           <verstretch>0</verstretch>
 26 |          </sizepolicy>
 27 |         </property>
 28 |         <property name="minimumSize">
 29 |          <size>
 30 |           <width>514</width>
 31 |           <height>514</height>
 32 |          </size>
 33 |         </property>
 34 |         <property name="frameShape">
 35 |          <enum>QFrame::StyledPanel</enum>
 36 |         </property>
 37 |         <property name="text">
 38 |          <string>No Image Loaded</string>
 39 |         </property>
 40 |         <property name="alignment">
 41 |          <set>Qt::AlignCenter</set>
 42 |         </property>
 43 |        </widget>
 44 |       </item>
 45 |       <item>
 46 |        <layout class="QGridLayout" name="gridLayout_2">
 47 |         <item row="10" column="0">
 48 |          <widget class="QCheckBox" name="layered">
 49 |           <property name="text">
 50 |            <string>Layered</string>
 51 |           </property>
 52 |          </widget>
 53 |         </item>
 54 |         <item row="0" column="0">
 55 |          <widget class="QLabel" name="label">
 56 |           <property name="text">
 57 |            <string>Conversion flags</string>
 58 |           </property>
 59 |          </widget>
 60 |         </item>
 61 |         <item row="6" column="0">
 62 |          <widget class="QCheckBox" name="transformed">
 63 |           <property name="text">
 64 |            <string>Transformed</string>
 65 |           </property>
 66 |          </widget>
 67 |         </item>
 68 |         <item row="1" column="0">
 69 |          <widget class="QLabel" name="label_2">
 70 |           <property name="text">
 71 |            <string>Burn time</string>
 72 |           </property>
 73 |          </widget>
 74 |         </item>
 75 |         <item row="6" column="2">
 76 |          <widget class="QSlider" name="imageRotation">
 77 |           <property name="enabled">
 78 |            <bool>false</bool>
 79 |           </property>
 80 |           <property name="maximum">
 81 |            <number>360</number>
 82 |           </property>
 83 |           <property name="orientation">
 84 |            <enum>Qt::Horizontal</enum>
 85 |           </property>
 86 |          </widget>
 87 |         </item>
 88 |         <item row="7" column="2">
 89 |          <widget class="QSlider" name="imageScale">
 90 |           <property name="enabled">
 91 |            <bool>false</bool>
 92 |           </property>
 93 |           <property name="minimum">
 94 |            <number>1</number>
 95 |           </property>
 96 |           <property name="maximum">
 97 |            <number>200</number>
 98 |           </property>
 99 |           <property name="value">
100 |            <number>100</number>
101 |           </property>
102 |           <property name="orientation">
103 |            <enum>Qt::Horizontal</enum>
104 |           </property>
105 |          </widget>
106 |         </item>
107 |         <item row="7" column="1">
108 |          <widget class="QLabel" name="label_6">
109 |           <property name="text">
110 |            <string>Scale</string>
111 |           </property>
112 |          </widget>
113 |         </item>
114 |         <item row="6" column="1">
115 |          <widget class="QLabel" name="label_4">
116 |           <property name="text">
117 |            <string>Rotation</string>
118 |           </property>
119 |          </widget>
120 |         </item>
121 |         <item row="6" column="3">
122 |          <widget class="QPushButton" name="resetImageRotation">
123 |           <property name="enabled">
124 |            <bool>false</bool>
125 |           </property>
126 |           <property name="text">
127 |            <string>Reset</string>
128 |           </property>
129 |          </widget>
130 |         </item>
131 |         <item row="7" column="3">
132 |          <widget class="QPushButton" name="resetImageScale">
133 |           <property name="enabled">
134 |            <bool>false</bool>
135 |           </property>
136 |           <property name="text">
137 |            <string>Reset</string>
138 |           </property>
139 |          </widget>
140 |         </item>
141 |         <item row="6" column="4">
142 |          <widget class="QLabel" name="imageRotationLabel">
143 |           <property name="text">
144 |            <string>0</string>
145 |           </property>
146 |           <property name="alignment">
147 |            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
148 |           </property>
149 |          </widget>
150 |         </item>
151 |         <item row="7" column="4">
152 |          <widget class="QLabel" name="imageScaleLabel">
153 |           <property name="text">
154 |            <string>100</string>
155 |           </property>
156 |           <property name="alignment">
157 |            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
158 |           </property>
159 |          </widget>
160 |         </item>
161 |         <item row="5" column="0" colspan="5">
162 |          <widget class="Line" name="line_2">
163 |           <property name="orientation">
164 |            <enum>Qt::Horizontal</enum>
165 |           </property>
166 |          </widget>
167 |         </item>
168 |         <item row="1" column="4">
169 |          <widget class="QLabel" name="burnTimeLabel">
170 |           <property name="sizePolicy">
171 |            <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
172 |             <horstretch>0</horstretch>
173 |             <verstretch>0</verstretch>
174 |            </sizepolicy>
175 |           </property>
176 |           <property name="minimumSize">
177 |            <size>
178 |             <width>25</width>
179 |             <height>0</height>
180 |            </size>
181 |           </property>
182 |           <property name="text">
183 |            <string>60</string>
184 |           </property>
185 |           <property name="alignment">
186 |            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
187 |           </property>
188 |          </widget>
189 |         </item>
190 |         <item row="1" column="1" colspan="3">
191 |          <widget class="QSlider" name="burnTime">
192 |           <property name="sizePolicy">
193 |            <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
194 |             <horstretch>0</horstretch>
195 |             <verstretch>0</verstretch>
196 |            </sizepolicy>
197 |           </property>
198 |           <property name="minimum">
199 |            <number>1</number>
200 |           </property>
201 |           <property name="maximum">
202 |            <number>240</number>
203 |           </property>
204 |           <property name="value">
205 |            <number>60</number>
206 |           </property>
207 |           <property name="orientation">
208 |            <enum>Qt::Horizontal</enum>
209 |           </property>
210 |          </widget>
211 |         </item>
212 |         <item row="10" column="1" colspan="4">
213 |          <layout class="QHBoxLayout" name="horizontalLayout">
214 |           <item>
215 |            <widget class="QLabel" name="label_5">
216 |             <property name="text">
217 |              <string>Layer Count</string>
218 |             </property>
219 |            </widget>
220 |           </item>
221 |           <item>
222 |            <widget class="QSpinBox" name="layerCount">
223 |             <property name="enabled">
224 |              <bool>false</bool>
225 |             </property>
226 |             <property name="minimum">
227 |              <number>2</number>
228 |             </property>
229 |             <property name="value">
230 |              <number>3</number>
231 |             </property>
232 |            </widget>
233 |           </item>
234 |           <item>
235 |            <widget class="QLabel" name="label_3">
236 |             <property name="text">
237 |              <string>Current Layer</string>
238 |             </property>
239 |            </widget>
240 |           </item>
241 |           <item>
242 |            <widget class="QSpinBox" name="selectedLayer">
243 |             <property name="enabled">
244 |              <bool>false</bool>
245 |             </property>
246 |             <property name="layoutDirection">
247 |              <enum>Qt::LeftToRight</enum>
248 |             </property>
249 |             <property name="minimum">
250 |              <number>0</number>
251 |             </property>
252 |             <property name="maximum">
253 |              <number>3</number>
254 |             </property>
255 |             <property name="value">
256 |              <number>0</number>
257 |             </property>
258 |            </widget>
259 |           </item>
260 |           <item>
261 |            <spacer name="horizontalSpacer_2">
262 |             <property name="orientation">
263 |              <enum>Qt::Horizontal</enum>
264 |             </property>
265 |             <property name="sizeHint" stdset="0">
266 |              <size>
267 |               <width>40</width>
268 |               <height>20</height>
269 |              </size>
270 |             </property>
271 |            </spacer>
272 |           </item>
273 |          </layout>
274 |         </item>
275 |         <item row="8" column="0" colspan="5">
276 |          <widget class="Line" name="line_3">
277 |           <property name="orientation">
278 |            <enum>Qt::Horizontal</enum>
279 |           </property>
280 |          </widget>
281 |         </item>
282 |         <item row="0" column="1" colspan="4">
283 |          <widget class="QComboBox" name="conversionFlags">
284 |           <property name="sizePolicy">
285 |            <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
286 |             <horstretch>0</horstretch>
287 |             <verstretch>0</verstretch>
288 |            </sizepolicy>
289 |           </property>
290 |          </widget>
291 |         </item>
292 |         <item row="2" column="1" colspan="4">
293 |          <layout class="QHBoxLayout" name="horizontalLayout_5">
294 |           <item>
295 |            <widget class="QCheckBox" name="keepAspectRatio">
296 |             <property name="text">
297 |              <string>Keep Aspect Ratio</string>
298 |             </property>
299 |            </widget>
300 |           </item>
301 |           <item>
302 |            <widget class="QCheckBox" name="flipHorizontally">
303 |             <property name="text">
304 |              <string>Flip Horizontally</string>
305 |             </property>
306 |            </widget>
307 |           </item>
308 |           <item>
309 |            <widget class="QCheckBox" name="flipVertically">
310 |             <property name="text">
311 |              <string>Flip Vertically</string>
312 |             </property>
313 |            </widget>
314 |           </item>
315 |           <item>
316 |            <spacer name="horizontalSpacer_3">
317 |             <property name="orientation">
318 |              <enum>Qt::Horizontal</enum>
319 |             </property>
320 |             <property name="sizeHint" stdset="0">
321 |              <size>
322 |               <width>40</width>
323 |               <height>20</height>
324 |              </size>
325 |             </property>
326 |            </spacer>
327 |           </item>
328 |          </layout>
329 |         </item>
330 |        </layout>
331 |       </item>
332 |       <item>
333 |        <spacer name="verticalSpacer_2">
334 |         <property name="orientation">
335 |          <enum>Qt::Vertical</enum>
336 |         </property>
337 |         <property name="sizeHint" stdset="0">
338 |          <size>
339 |           <width>20</width>
340 |           <height>40</height>
341 |          </size>
342 |         </property>
343 |        </spacer>
344 |       </item>
345 |      </layout>
346 |     </item>
347 |     <item>
348 |      <layout class="QVBoxLayout" name="verticalLayout_2">
349 |       <item>
350 |        <widget class="QPlainTextEdit" name="verbose">
351 |         <property name="readOnly">
352 |          <bool>true</bool>
353 |         </property>
354 |        </widget>
355 |       </item>
356 |       <item>
357 |        <layout class="QHBoxLayout" name="horizontalLayout_3">
358 |         <item>
359 |          <widget class="QComboBox" name="ports"/>
360 |         </item>
361 |         <item>
362 |          <widget class="QComboBox" name="protocolVersion">
363 |           <property name="sizePolicy">
364 |            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
365 |             <horstretch>0</horstretch>
366 |             <verstretch>0</verstretch>
367 |            </sizepolicy>
368 |           </property>
369 |          </widget>
370 |         </item>
371 |         <item>
372 |          <widget class="QPushButton" name="connect">
373 |           <property name="sizePolicy">
374 |            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
375 |             <horstretch>0</horstretch>
376 |             <verstretch>0</verstretch>
377 |            </sizepolicy>
378 |           </property>
379 |           <property name="text">
380 |            <string>Connect</string>
381 |           </property>
382 |          </widget>
383 |         </item>
384 |         <item>
385 |          <widget class="QPushButton" name="disconnect">
386 |           <property name="sizePolicy">
387 |            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
388 |             <horstretch>0</horstretch>
389 |             <verstretch>0</verstretch>
390 |            </sizepolicy>
391 |           </property>
392 |           <property name="text">
393 |            <string>Disconnect</string>
394 |           </property>
395 |          </widget>
396 |         </item>
397 |        </layout>
398 |       </item>
399 |       <item>
400 |        <widget class="QProgressBar" name="progress">
401 |         <property name="value">
402 |          <number>0</number>
403 |         </property>
404 |        </widget>
405 |       </item>
406 |       <item>
407 |        <layout class="QGridLayout" name="gridLayout_3">
408 |         <item row="1" column="0">
409 |          <widget class="QPushButton" name="left">
410 |           <property name="sizePolicy">
411 |            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
412 |             <horstretch>0</horstretch>
413 |             <verstretch>0</verstretch>
414 |            </sizepolicy>
415 |           </property>
416 |           <property name="minimumSize">
417 |            <size>
418 |             <width>75</width>
419 |             <height>75</height>
420 |            </size>
421 |           </property>
422 |           <property name="text">
423 |            <string>Left</string>
424 |           </property>
425 |           <property name="shortcut">
426 |            <string>Left</string>
427 |           </property>
428 |          </widget>
429 |         </item>
430 |         <item row="1" column="1">
431 |          <widget class="QPushButton" name="center">
432 |           <property name="sizePolicy">
433 |            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
434 |             <horstretch>0</horstretch>
435 |             <verstretch>0</verstretch>
436 |            </sizepolicy>
437 |           </property>
438 |           <property name="minimumSize">
439 |            <size>
440 |             <width>75</width>
441 |             <height>75</height>
442 |            </size>
443 |           </property>
444 |           <property name="text">
445 |            <string>Center</string>
446 |           </property>
447 |          </widget>
448 |         </item>
449 |         <item row="0" column="3" rowspan="3">
450 |          <widget class="Line" name="line">
451 |           <property name="orientation">
452 |            <enum>Qt::Vertical</enum>
453 |           </property>
454 |          </widget>
455 |         </item>
456 |         <item row="0" column="5">
457 |          <widget class="QPushButton" name="upload">
458 |           <property name="sizePolicy">
459 |            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
460 |             <horstretch>0</horstretch>
461 |             <verstretch>0</verstretch>
462 |            </sizepolicy>
463 |           </property>
464 |           <property name="minimumSize">
465 |            <size>
466 |             <width>75</width>
467 |             <height>75</height>
468 |            </size>
469 |           </property>
470 |           <property name="text">
471 |            <string>Upload</string>
472 |           </property>
473 |          </widget>
474 |         </item>
475 |         <item row="0" column="0">
476 |          <widget class="QPushButton" name="home">
477 |           <property name="sizePolicy">
478 |            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
479 |             <horstretch>0</horstretch>
480 |             <verstretch>0</verstretch>
481 |            </sizepolicy>
482 |           </property>
483 |           <property name="minimumSize">
484 |            <size>
485 |             <width>75</width>
486 |             <height>75</height>
487 |            </size>
488 |           </property>
489 |           <property name="text">
490 |            <string>Home</string>
491 |           </property>
492 |          </widget>
493 |         </item>
494 |         <item row="1" column="8">
495 |          <spacer name="horizontalSpacer">
496 |           <property name="orientation">
497 |            <enum>Qt::Horizontal</enum>
498 |           </property>
499 |           <property name="sizeHint" stdset="0">
500 |            <size>
501 |             <width>40</width>
502 |             <height>20</height>
503 |            </size>
504 |           </property>
505 |          </spacer>
506 |         </item>
507 |         <item row="0" column="1">
508 |          <widget class="QPushButton" name="up">
509 |           <property name="sizePolicy">
510 |            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
511 |             <horstretch>0</horstretch>
512 |             <verstretch>0</verstretch>
513 |            </sizepolicy>
514 |           </property>
515 |           <property name="minimumSize">
516 |            <size>
517 |             <width>75</width>
518 |             <height>75</height>
519 |            </size>
520 |           </property>
521 |           <property name="text">
522 |            <string>Up</string>
523 |           </property>
524 |           <property name="shortcut">
525 |            <string>Up</string>
526 |           </property>
527 |          </widget>
528 |         </item>
529 |         <item row="2" column="1">
530 |          <widget class="QPushButton" name="down">
531 |           <property name="sizePolicy">
532 |            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
533 |             <horstretch>0</horstretch>
534 |             <verstretch>0</verstretch>
535 |            </sizepolicy>
536 |           </property>
537 |           <property name="minimumSize">
538 |            <size>
539 |             <width>75</width>
540 |             <height>75</height>
541 |            </size>
542 |           </property>
543 |           <property name="text">
544 |            <string>Down</string>
545 |           </property>
546 |           <property name="shortcut">
547 |            <string>Down</string>
548 |           </property>
549 |          </widget>
550 |         </item>
551 |         <item row="1" column="2">
552 |          <widget class="QPushButton" name="right">
553 |           <property name="sizePolicy">
554 |            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
555 |             <horstretch>0</horstretch>
556 |             <verstretch>0</verstretch>
557 |            </sizepolicy>
558 |           </property>
559 |           <property name="minimumSize">
560 |            <size>
561 |             <width>75</width>
562 |             <height>75</height>
563 |            </size>
564 |           </property>
565 |           <property name="text">
566 |            <string>Right</string>
567 |           </property>
568 |           <property name="shortcut">
569 |            <string>Right</string>
570 |           </property>
571 |          </widget>
572 |         </item>
573 |         <item row="0" column="6">
574 |          <widget class="QPushButton" name="preview">
575 |           <property name="sizePolicy">
576 |            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
577 |             <horstretch>0</horstretch>
578 |             <verstretch>0</verstretch>
579 |            </sizepolicy>
580 |           </property>
581 |           <property name="minimumSize">
582 |            <size>
583 |             <width>75</width>
584 |             <height>75</height>
585 |            </size>
586 |           </property>
587 |           <property name="text">
588 |            <string>Preview</string>
589 |           </property>
590 |          </widget>
591 |         </item>
592 |         <item row="1" column="5">
593 |          <widget class="QPushButton" name="start">
594 |           <property name="sizePolicy">
595 |            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
596 |             <horstretch>0</horstretch>
597 |             <verstretch>0</verstretch>
598 |            </sizepolicy>
599 |           </property>
600 |           <property name="minimumSize">
601 |            <size>
602 |             <width>75</width>
603 |             <height>75</height>
604 |            </size>
605 |           </property>
606 |           <property name="text">
607 |            <string>Start</string>
608 |           </property>
609 |          </widget>
610 |         </item>
611 |         <item row="0" column="4">
612 |          <layout class="QGridLayout" name="gridLayout"/>
613 |         </item>
614 |         <item row="1" column="6">
615 |          <widget class="QPushButton" name="pause">
616 |           <property name="sizePolicy">
617 |            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
618 |             <horstretch>0</horstretch>
619 |             <verstretch>0</verstretch>
620 |            </sizepolicy>
621 |           </property>
622 |           <property name="minimumSize">
623 |            <size>
624 |             <width>75</width>
625 |             <height>75</height>
626 |            </size>
627 |           </property>
628 |           <property name="text">
629 |            <string>Pause</string>
630 |           </property>
631 |          </widget>
632 |         </item>
633 |         <item row="1" column="7">
634 |          <widget class="QPushButton" name="reset">
635 |           <property name="sizePolicy">
636 |            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
637 |             <horstretch>0</horstretch>
638 |             <verstretch>0</verstretch>
639 |            </sizepolicy>
640 |           </property>
641 |           <property name="minimumSize">
642 |            <size>
643 |             <width>75</width>
644 |             <height>75</height>
645 |            </size>
646 |           </property>
647 |           <property name="text">
648 |            <string>Reset</string>
649 |           </property>
650 |          </widget>
651 |         </item>
652 |        </layout>
653 |       </item>
654 |      </layout>
655 |     </item>
656 |    </layout>
657 |   </widget>
658 |   <widget class="QMenuBar" name="menuBar">
659 |    <property name="geometry">
660 |     <rect>
661 |      <x>0</x>
662 |      <y>0</y>
663 |      <width>1090</width>
664 |      <height>21</height>
665 |     </rect>
666 |    </property>
667 |   </widget>
668 |   <widget class="QStatusBar" name="statusBar"/>
669 |  </widget>
670 |  <layoutdefault spacing="6" margin="11"/>
671 |  <customwidgets>
672 |   <customwidget>
673 |    <class>ImageLabel</class>
674 |    <extends>QLabel</extends>
675 |    <header>imagelabel.h</header>
676 |   </customwidget>
677 |  </customwidgets>
678 |  <resources/>
679 |  <connections/>
680 | </ui>
681 | 


--------------------------------------------------------------------------------