Fix for the old dependency code in the CI

.clang-format

@@ -41,7 +41,7 @@ BreakBeforeBinaryOperators: None
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializers: BeforeColon
 BreakInheritanceList: BeforeColon
-ColumnLimit: 100
+ColumnLimit: 120
 CompactNamespaces: false
 ContinuationIndentWidth: 4
 Cpp11BracedListStyle: true

.gitea/workflows/build.yaml

@@ -15,40 +15,13 @@ jobs:
         run: apt-get -yq install meson
       - name: Install build dependencies
         run: apt-get -yq install libusb-1.0-0-dev libspdlog-dev libfmt-dev libpango1.0-dev libcairo2-dev gcovr
-      - name: get build environment versions
-        run: |
-          echo "=== Start meson version ==="
-          gcc --version
-          echo "=== End meson version ==="
-          echo "=== Start supported c/cpp standards: ==="
-          gcc -v --help 2> /dev/null | sed -n '/^ *-std=\([^<][^ ]\+\).*/ {s//\1/p}'
-          echo "=== End supported c/cpp standards ==="
-          echo "=== Start meson version ==="
-          meson --version
-          echo "=== End meson version ==="
-          echo "=== Start ninja version ==="
-          ninja --version
-          echo "=== End ninja version ==="
-          echo "=== Start dependency package version ==="
-          apt-cache policy libpango1.0-dev
-          apt-cache policy libcairo2-dev
-          apt-cache policy libfmt-dev 
-          apt-cache policy libspdlog-dev
-          apt-cache policy libusb-1.0-0-dev
-          echo "=== End dependency package version ==="
       - name: setup builddir
         run: meson setup builddir -Db_coverage=true
-      - name: build and test dist package
+      - name: build all targets
-        run: ninja -C builddir dist
+        run: ninja -C builddir
       - name: run unit tests
         run: ninja -C builddir test
       - name: calculate coverage
         run: ninja -C builddir coverage-text
       - name: Coverage report
         run: cat ./builddir/meson-logs/coverage.txt
-      - name: upload dist package
-        uses: actions/upload-artifact@v3
-        with:
-          name: ptprnt-dist
-          path: ./builddir/meson-dist/*
-          if-no-files-found: error

.vscode/launch.json

@@ -6,13 +6,22 @@
   "configurations": [
     {
       "name": "ptprnt_debug",
-      "type": "lldb",
+      "type": "cppdbg",
       "request": "launch",
       "program": "${workspaceFolder}/builddir/ptprnt",
-      "args": [
+      "args": ["-t Hello"],
-        "-t Hello"
+      "stopAtEntry": false,
-      ],
       "cwd": "${fileDirname}",
+      "environment": [],
+      "externalConsole": false,
+      "MIMode": "gdb",
+      "setupCommands": [
+        {
+          "description": "Automatische Strukturierung und Einrückung für \"gdb\" aktivieren",
+          "text": "-enable-pretty-printing",
+          "ignoreFailures": true
+        }
+      ]
     }
   ]
 }

.vscode/settings.json

@@ -86,5 +86,8 @@
   "clang-tidy.buildPath": "builddir/",
   "clangd.onConfigChanged": "restart",
   "C_Cpp.default.compileCommands": "/home/moritz/src/ptouch-prnt/builddir/compile_commands.json",
+  "gcovViewer.buildDirectories": [
+    "/home/moritz/Projekte/ptouch-prnt/builddir"
+  ],
   "C_Cpp.default.configurationProvider": "mesonbuild.mesonbuild"
 }

generate_coverage.sh

@@ -2,6 +2,7 @@
 
 SCRIPT_PATH="$( cd -- "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )"
 HTML_COV_PATH="coverageReport/html"
+XML_COV_PATH="coverageReport/xml"
 HTML_START_FILE="index.html"
 
 echo "Generating Coverage report for ptouch-prnt"
@@ -12,6 +13,9 @@ ninja -C builddir test
 mkdir -p ${HTML_COV_PATH}
 gcovr --html --html-details --html-syntax-highlighting --filter src --output ${HTML_COV_PATH}/${HTML_START_FILE}
 
+mkdir -p ${XML_COV_PATH}
+gcovr --xml-pretty --filter src --output ${XML_COV_PATH}/cov.xml
+
 if [ $? ] 
 then
   echo "Coverage report successful generated!"
@@ -19,3 +23,5 @@ then
 else
   echo "Error generating coverage report!"
 fi
+
+rm *.gcov

meson.build

@@ -1,7 +1,7 @@
 project('ptprnt', 'cpp',
     version: 'v0.1.0-'+run_command('git', 'rev-parse',  '--short', 'HEAD', check: true).stdout().strip(),
     license: 'GPLv3',
-    default_options : ['c_std=c11', 'cpp_std=c++17']    
+    default_options : ['c_std=c11', 'cpp_std=c++2a', 'b_sanitize=none', 'b_lto=true', 'b_lto_mode=thin', 'b_thinlto_cache=true']    
 )
 
 usb_dep = dependency('libusb-1.0')

src/P700Printer.cpp

@@ -19,32 +19,29 @@
 
 #include "P700Printer.hpp"
 
-#include <algorithm>
 #include <spdlog/spdlog.h>
 
 #include <cstdint>
-#include <iostream>
 #include <iterator>
-#include <ratio>
+#include <memory>
 #include <thread>
 #include <vector>
 
 #include "graphics/Bitmap.hpp"
-#include "graphics/Image.hpp"
 #include "graphics/Monochrome.hpp"
-#include "libusb.h"
 #include "libusbwrap/LibUsbTypes.hpp"
 #include "spdlog/fmt/bin_to_hex.h"
 
 // as long as DRYRUN is defined, no data is actually send to the printer, we need to save some tape ;)
-//#define DRYRUN
+#define DRYRUN
 
 namespace ptprnt::printer {
 
 const PrinterInfo P700Printer::mInfo = {.driverName = "P700",
                                         .name       = "Brother P-touch P700",
                                         .version    = "v1.0",
-                                        .usbId{0x04f9, 0x2061}};
+                                        .usbId{0x04f9, 0x2061},
+                                        .pixelLines = 128};
 
 P700Printer::~P700Printer() {
     detachUsbDevice();
@@ -71,15 +68,14 @@ const PrinterInfo P700Printer::getPrinterInfo() {
 
 const PrinterStatus P700Printer::getPrinterStatus() {
     using namespace std::chrono_literals;
-    std::vector<uint8_t> getStatusCmd({0x1b, 0x69, 0x53});  // status info request
+    send(p700::commands::GET_STATUS);
-    send(getStatusCmd);
 
     int tx    = 0;
     int tries = 0;
     std::vector<uint8_t> recvBuf(32);
     while (tries++ < MAX_TRIES_GET_STATUS) {
         std::this_thread::sleep_for(100ms);
-        mUsbHndl->bulkTransfer(commands["printerinfo"][0], recvBuf, &tx, 0);
+        mUsbHndl->bulkTransfer(p700::commands::PRINTER_INFO[0], recvBuf, &tx, 0);
     }
 
     return PrinterStatus{.tapeWidthMm = recvBuf[10]};
@@ -123,21 +119,23 @@ bool P700Printer::detachUsbDevice() {
 }
 
 bool P700Printer::printBitmap(const graphics::Bitmap<graphics::ALPHA8>& bitmap) {
-    auto bm = graphics::Bitmap<graphics::ALPHA8>(512, 128);
+#ifdef DRYRUN
-    {
+    spdlog::debug("DRYRUN enabled");
-        auto img = graphics::Image();
+    for (unsigned int lineNo = 0; lineNo < bitmap.getHeight(); lineNo++) {
-        bm.setPixels(std::vector<uint8_t>(img.getRaw(), img.getRaw() + 512 * 128));
+        auto line     = bitmap.getLine(lineNo);
+        auto monoLine = graphics::Monochrome(*line);
+        monoLine.visualize();
     }
+#endif
 
-    send(commands["rasterstart"]);
+    send(p700::commands::RASTER_START);
-
     std::vector<uint8_t> rastercmd(4);
     rastercmd[0] = 0x47;
     rastercmd[1] = 0x00;  // size +1
     rastercmd[2] = 0x00;
     rastercmd[3] = 0x00;  // size -1
-    for (unsigned int i = 0; i < bm.getWidth(); i++) {
+    for (unsigned int i = 0; i < bitmap.getWidth(); i++) {
-        auto bmcol = bm.getCol(i);
+        auto bmcol = bitmap.getCol(i);
         if (!bmcol) {
             spdlog::error("Out of bounds bitmap access");
             break;
@@ -152,42 +150,32 @@ bool P700Printer::printBitmap(const graphics::Bitmap<graphics::ALPHA8>& bitmap)
         buf[1] = col.size() + 1;
         buf[3] = col.size() - 1;
         if (!send(buf)) {
+            spdlog::error("Error sending buffer to printer");
             break;
         };
     }
 
-    send(commands["eject"]);
+    send(p700::commands::EJECT);
     return true;
 }
 
-bool P700Printer::setText(const std::string& text) {
+bool P700Printer::printLabel(std::unique_ptr<graphics::ILabel> label) {
-    return true;
+    // not quite sure if I should stack allocate Bitmap, but data is held on the heap anyway (std::vector).
-};
+    auto bm = graphics::Bitmap<graphics::ALPHA8>(label->getWidth(), label->getHeight());
-
+    spdlog::debug("Label has {}x{}px size", label->getWidth(), label->getHeight());
-bool P700Printer::setFont(const std::string& text) {
+    bm.setPixels(label->getRaw());
-    return true;
+    printBitmap(bm);
-};
-
-bool P700Printer::setFontSize(uint8_t fontSize) {
-    return true;
-};
-
-bool P700Printer::setHAlign(HAlignPosition hpos) {
-    return true;
-};
-
-bool P700Printer::setVAlign(VAlignPosition vpos) {
     return true;
 }
 
 bool P700Printer::print() {
-    send(commands["lf"]);
+    send(p700::commands::LF);
-    send(commands["ff"]);
+    send(p700::commands::FF);
-    send(commands["eject"]);
+    send(p700::commands::EJECT);
     return true;
 }
 
-bool P700Printer::send(std::vector<uint8_t>& data) {
+bool P700Printer::send(const std::vector<uint8_t>& data) {
 
     if (mUsbHndl == nullptr || data.size() > 128) {
         spdlog::error("Invalid device handle or invalid data.");
@@ -203,12 +191,11 @@ bool P700Printer::send(std::vector<uint8_t>& data) {
     }
 #else
     tx = data.size();
-    spdlog::debug("USB raw data(len {}): {}", data.size(), spdlog::to_hex(data));
+    spdlog::trace("USB raw data(len {}): {}", data.size(), spdlog::to_hex(data));
 #endif
 
     if (tx != static_cast<int>(data.size())) {
-        spdlog::error("Could not transfer all data via USB bulk transfer. Only send {} of {} bytes",
+        spdlog::error("Could not transfer all data via USB bulk transfer. Only sent {} of {} bytes", tx, data.size());
-                      tx, data.size());
         return false;
     }
 

src/P700Printer.hpp

@@ -17,9 +17,9 @@
 
  */
 
+#include <spdlog/spdlog.h>
 #include <sys/types.h>
 
-#include <map>
 #include <memory>
 #include <vector>
 
@@ -31,13 +31,26 @@
 #pragma once
 
 namespace ptprnt::printer {
+namespace p700::commands {
+const cmd_T GET_STATUS{0x1b, 0x69, 0x53};
+const cmd_T RASTER_START{0x1b, 0x69, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+const cmd_T INFO{0x1b, 0x69, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+const cmd_T PACKBITSON{0x02};
+const cmd_T LF{0x5a};
+const cmd_T FF{0x0c};
+const cmd_T EJECT{0x1a};
+const cmd_T PRINTER_INFO{0x81};
+}  // namespace p700::commands
 
 constexpr uint8_t MAX_TRIES_GET_STATUS = 10;
 
+// TODO:
+// Remove Text-layout specific parts, add them to label
+
 class P700Printer : public ::ptprnt::IPrinterDriver {
    public:
     P700Printer() = default;
-    ~P700Printer();
+    ~P700Printer() override;
 
     // delete copy ctor and assignment
     P700Printer(const P700Printer&)            = default;
@@ -57,29 +70,14 @@ class P700Printer : public ::ptprnt::IPrinterDriver {
     [[nodiscard]] const PrinterStatus getPrinterStatus() override;
     bool attachUsbDevice(std::shared_ptr<libusbwrap::IUsbDevice> usbHndl) override;
     bool detachUsbDevice() override;
-    bool setText(const std::string& text) override;
-    bool setFont(const std::string& text) override;
-    bool setFontSize(uint8_t fontSize) override;
-    bool setHAlign(HAlignPosition hpos) override;
-    bool setVAlign(VAlignPosition vpos) override;
     bool printBitmap(const graphics::Bitmap<graphics::ALPHA8>& bitmap) override;
+    bool printLabel(const std::unique_ptr<graphics::ILabel> label) override;
     bool print() override;
 
    private:
-    bool send(std::vector<uint8_t>& data);
+    bool send(const std::vector<uint8_t>& data);
     bool init();
 
     std::shared_ptr<libusbwrap::IUsbDevice> mUsbHndl{nullptr};
-    std::map<std::string, std::vector<uint8_t>> commands{
-        {"rasterstart",
-         {0x1b, 0x69, 0x61,
-          0x01}},  // unique for P700, other printers have the 2 byte set to 0x52 instead of 0x61
-        {"info", {0x1b, 0x69, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
-        {"packbitson", {0x02}},
-        {"lf", {0x5a}},
-        {"ff", {0x0c}},
-        {"eject", {0x1a}},
-        {"printerinfo", {0x81}}};
 };
-
 }  // namespace ptprnt::printer

src/PtouchPrint.cpp

@@ -16,12 +16,10 @@
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
  */
-#include <cstdint>
+#include "PtouchPrint.hpp"
-#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_TRACE
-#define SPDLOG_DEBUG_ON
-#define SPDLOG_TRACE_ON
 
 #include <CLI/App.hpp>
+#include <algorithm>
 #include <fmt/core.h>
 #include <spdlog/common.h>
 #include <spdlog/details/synchronous_factory.h>
@@ -31,14 +29,16 @@
 #include <spdlog/sinks/stdout_color_sinks.h>
 #include <spdlog/spdlog.h>
 
+#include <cctype>
 #include <functional>
 #include <memory>
+#include <unordered_set>
 #include <vector>
 
 #include "CLI/Option.hpp"
 #include "PrinterDriverFactory.hpp"
-#include "PtouchPrint.hpp"
+#include "graphics/Label.hpp"
-#include "graphics/Bitmap.hpp"
+#include "graphics/interface/ILabel.hpp"
 #include "libusbwrap/UsbDeviceFactory.hpp"
 
 namespace ptprnt {
@@ -58,7 +58,7 @@ int PtouchPrint::init(int argc, char** argv) {
     if (mVerboseFlag) {
         setupLogger(spdlog::level::debug);
     } else {
-        setupLogger(spdlog::level::err);
+        setupLogger(spdlog::level::warn);
     }
 
     if (!mUsbDeviceFactory.init()) {
@@ -74,8 +74,7 @@ int PtouchPrint::run() {
     mDetectedPrinters     = getCompatiblePrinters();
     auto numFoundPrinters = mDetectedPrinters.size();
     if (numFoundPrinters == 0) {
-        spdlog::error(
+        spdlog::error("No compatible printers found, please make sure that they are turned on and connected");
-            "No compatible printers found, please make sure that they are turned on and connected");
         return -1;
     } else if (numFoundPrinters > 1) {
         spdlog::warn("Found more than one compatible printer. Currently not supported.");
@@ -84,52 +83,78 @@ int PtouchPrint::run() {
 
     auto printer            = mDetectedPrinters[0];
     const auto printerUsbId = printer->getUsbId();
-    auto devices = mUsbDeviceFactory.findDevices(printerUsbId.first, printerUsbId.second);
+    auto devices            = mUsbDeviceFactory.findDevices(printerUsbId.first, printerUsbId.second);
     if (devices.size() != 1) {
-        spdlog::warn(
+        spdlog::warn("Found more than one device of the same printer on bus. Currently not supported");
-            "Found more than one device of the same printer on bus. Currently not supported");
         return -1;
     }
-    printer->attachUsbDevice(devices[0]);
+    printer->attachUsbDevice(std::move(devices[0]));
     auto status = printer->getPrinterStatus();
     spdlog::info("Detected tape width is {}mm", status.tapeWidthMm);
-    auto bm = ptprnt::graphics::Bitmap<ptprnt::graphics::ALPHA8>(512, 128);
-    //printer->printBitmap(bm);
-    //printer->printText("wurst", 1);
 
-    for (auto& cmd : mCommands) {
+    if (0 == mCommands.size()) {
-        switch (cmd.first) {
+        spdlog::warn("No command specified, nothing to do...");
+        return 0;
+    }
+
+    auto label = std::make_unique<graphics::Label>(printer->getPrinterInfo().pixelLines);
+    std::string labelText{};
+    // TODO: refactor
+    for (const auto& [cmd, value] : mCommands) {
+        switch (cmd) {
             case CliCmdType::Text:
-                spdlog::debug("Setting text to {}", cmd.second);
+                if (labelText.empty()) {
-                printer->setText(cmd.second);
+                    labelText = value;
+                } else {
+                    labelText = labelText + '\n' + value;
+                }
                 break;
-            case CliCmdType::Font:;
+            case CliCmdType::Font:
-                spdlog::debug("Setting font to {}", cmd.second);
+                spdlog::debug("Setting font to {}", value);
-                printer->setFont(cmd.second);
+                label->setFontFamily(value);
                 break;
-            case CliCmdType::FontSize:;
+            case CliCmdType::FontSize:
-                spdlog::debug("Setting font size to {}", cmd.second);
+                spdlog::debug("Setting font size to {}", std::stod(value));
-                printer->setFontSize(static_cast<uint8_t>(std::atoi(cmd.second.c_str())));
+                label->setFontSize(std::stod(value));
                 break;
-            case CliCmdType::HAlign:;
+            case CliCmdType::HAlign:
-                spdlog::debug("[Not implemented] Setting text horizontal alignment to {}",
+                spdlog::debug("Setting text horizontal alignment to {}", value);
-                              cmd.second);
+                {
+                    auto hPos = HALignPositionMap.find(value);
+                    if (hPos == HALignPositionMap.end()) {
+                        spdlog::warn("Invalid horizontal alignment specified!");
+                        label->setHAlign(HAlignPosition::UNKNOWN);
+                    } else {
+                        label->setHAlign(hPos->second);
+                    }
+                }
                 break;
-            case CliCmdType::VAlign:;
+            case CliCmdType::VAlign:
-                spdlog::debug("[Not implemented] Setting text vertical alignment to {}",
+                spdlog::debug("Setting text vertical alignment to {}", value);
-                              cmd.second);
+                {
+                    auto vPos = VALignPositionMap.find(value);
+                    if (vPos == VALignPositionMap.end()) {
+                        spdlog::warn("Invalid verical alignment specified!");
+                        label->setVAlign(VAlignPosition::UNKNOWN);
+                    } else {
+                        label->setVAlign(vPos->second);
+                    }
+                }
                 break;
-            case CliCmdType::None:;
+            case CliCmdType::None:
                 [[fallthrough]];
             default:
                 spdlog::warn("This command is currently not supported.");
                 break;
         }
     }
-    if (!printer->print()) {
+    label->create(labelText);
+    label->writeToPng("./testlabel.png");
+    if (!printer->printLabel(std::move(label))) {
         spdlog::error("An error occured while printing");
         return -1;
     }
+
     return 0;
 }
 
@@ -139,7 +164,7 @@ std::vector<std::shared_ptr<IPrinterDriver>> PtouchPrint::getCompatiblePrinters(
     auto driverFactory = std::make_unique<PrinterDriverFactory>();
     std::vector<std::shared_ptr<IPrinterDriver>> foundPrinterDrivers{};
 
-    for (auto usbDev : usbDevs) {
+    for (auto& usbDev : usbDevs) {
         auto driver = driverFactory->create(usbDev->getUsbId());
         if (driver != nullptr) {
             foundPrinterDrivers.push_back(driver);
@@ -151,7 +176,13 @@ std::vector<std::shared_ptr<IPrinterDriver>> PtouchPrint::getCompatiblePrinters(
 void PtouchPrint::setupLogger(spdlog::level::level_enum lvl) {
     auto consoleSink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
     consoleSink->set_level(lvl);
-    consoleSink->set_pattern("%^%L:%$ %v");
+    if (spdlog::level::level_enum::debug == lvl || spdlog::level::level_enum::trace == lvl) {
+        // This will enable file and line number for debug and trace macros
+        // TODO: line number and functions only work with macros
+        consoleSink->set_pattern("%^%L:%$ %v");
+    } else {
+        consoleSink->set_pattern("%^%L:%$ %v");
+    }
 
     auto fileSink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("ptprnt.log", true);
     fileSink->set_level(spdlog::level::trace);
@@ -162,6 +193,7 @@ void PtouchPrint::setupLogger(spdlog::level::level_enum lvl) {
     spdlog::set_default_logger(logger);
 }
 
+// TODO: CLI parsing should be a seperate class/file
 void PtouchPrint::setupCliParser() {
     auto printVersion = [this](std::size_t) {
         fmt::print("ptprnt version: {}\n", mVersionString);
@@ -181,27 +213,42 @@ void PtouchPrint::setupCliParser() {
         ->each([this](std::string text) { mCommands.emplace_back(CliCmdType::Text, text); });
     mApp.add_option("-f,--font", "Font used for the following text occurences")
         ->group("Text printing ")
-        ->multi_option_policy(CLI::MultiOptionPolicy::TakeAll)
+        ->multi_option_policy(CLI::MultiOptionPolicy::TakeFirst)
         ->trigger_on_parse()
         ->each([this](std::string font) { mCommands.emplace_back(CliCmdType::Font, font); });
     mApp.add_option("-s,--fontsize", "Font size of the following text occurences")
         ->group("Text printing ")
-        ->multi_option_policy(CLI::MultiOptionPolicy::TakeAll)
+        ->multi_option_policy(CLI::MultiOptionPolicy::TakeFirst)
         ->trigger_on_parse()
         ->each([this](std::string size) { mCommands.emplace_back(CliCmdType::FontSize, size); });
     mApp.add_option("--valign", "Vertical alignment of the following text occurences")
         ->group("Text printing ")
-        ->multi_option_policy(CLI::MultiOptionPolicy::TakeAll)
+        ->multi_option_policy(CLI::MultiOptionPolicy::TakeFirst)
         ->trigger_on_parse()
+        ->transform([](std::string in) -> std::string {
+            std::unordered_set<std::string> validValignOptions{"top", "middle", "bottom"};
+            std::transform(in.begin(), in.end(), in.begin(), [](unsigned char c) { return std::tolower(c); });
+            if (validValignOptions.find(in) == validValignOptions.end()) {
+                return {""};
+            }
+            return in;
+        })
         ->each([this](std::string valign) { mCommands.emplace_back(CliCmdType::VAlign, valign); });
     mApp.add_option("--halign", "Vertical alignment of the following text occurences")
         ->group("Text printing ")
-        ->multi_option_policy(CLI::MultiOptionPolicy::TakeAll)
+        ->multi_option_policy(CLI::MultiOptionPolicy::TakeFirst)
         ->trigger_on_parse()
+        ->transform([](std::string in) -> std::string {
+            std::unordered_set<std::string> validValignOptions{"left", "center", "right", "justify"};
+            std::transform(in.begin(), in.end(), in.begin(), [](unsigned char c) { return std::tolower(c); });
+            if (validValignOptions.find(in) == validValignOptions.end()) {
+                return {""};
+            }
+            return in;
+        })
         ->each([this](std::string halign) { mCommands.emplace_back(CliCmdType::HAlign, halign); });
 
     // Image options
-    mApp.add_option("-i,--image", "Image to print. Excludes all text printing ")
+    mApp.add_option("-i,--image", "Image to print. Excludes all text printing ")->group("Image printing");
-        ->group("Image printing");
 }
 }  // namespace ptprnt

src/graphics/Bitmap.cpp

@@ -19,7 +19,6 @@
 
 #include "Bitmap.hpp"
 
-#include <algorithm>
 #include <spdlog/spdlog.h>
 
 #include <iterator>
@@ -28,23 +27,22 @@
 
 namespace ptprnt::graphics {
 template <class T>
-Bitmap<T>::Bitmap(uint16_t width, uint16_t height)
+Bitmap<T>::Bitmap(uint16_t width, uint16_t height) : mWidth{width}, mHeight{height}, mPixels(width * height) {}
-    : mWidth{width}, mHeight{height}, mPixels(width * height) {}
 
 template <class T>
-uint16_t Bitmap<T>::getWidth() {
+[[nodiscard]] uint16_t Bitmap<T>::getWidth() const {
     return mWidth;
 }
 
 template <class T>
-uint16_t Bitmap<T>::getHeight() {
+[[nodiscard]] uint16_t Bitmap<T>::getHeight() const {
     return mHeight;
 }
 
 template <class T>
 bool Bitmap<T>::setPixels(const std::vector<T>& pixels) {
     if (pixels.size() != mPixels.size()) {
-        spdlog::error("Invalid pixel buffer size.");
+        spdlog::error("Invalid pixel buffer size (got {} vs. {} bitmap size).", pixels.size(), mPixels.size());
         return false;
     }
 
@@ -53,12 +51,12 @@ bool Bitmap<T>::setPixels(const std::vector<T>& pixels) {
 }
 
 template <class T>
-std::vector<T> Bitmap<T>::getPixelsCpy() {
+[[nodiscard]] std::vector<T> Bitmap<T>::getPixelsCpy() const {
     return mPixels;
 }
 
 template <class T>
-std::optional<std::vector<T>> Bitmap<T>::getLine(uint16_t line) {
+[[nodiscard]] std::optional<std::vector<T>> Bitmap<T>::getLine(uint16_t line) const {
     if (line >= mHeight) {
         // out of bound
         return std::nullopt;
@@ -69,8 +67,9 @@ std::optional<std::vector<T>> Bitmap<T>::getLine(uint16_t line) {
     return std::vector<T>(lineStart, lineEnd);
 }
 
+// TODO: I guess this is borked
 template <class T>
-std::optional<std::vector<T>> Bitmap<T>::getCol(uint16_t col) {
+[[nodiscard]] std::optional<std::vector<T>> Bitmap<T>::getCol(uint16_t col) const {
     if (col >= mWidth) {
         // out of bound
         return std::nullopt;

src/graphics/Bitmap.hpp

@@ -39,12 +39,18 @@ class Bitmap {
     Bitmap(uint16_t width, uint16_t height);
     ~Bitmap() = default;
 
-    uint16_t getWidth();
+    Bitmap(const Bitmap&)            = default;
-    uint16_t getHeight();
+    Bitmap& operator=(const Bitmap&) = default;
+    Bitmap(Bitmap&&)                 = default;
+    Bitmap& operator=(Bitmap&&)      = default;
+
+    [[nodiscard]] uint16_t getWidth() const;
+    [[nodiscard]] uint16_t getHeight() const;
     bool setPixels(const std::vector<T>& pixels);
-    std::vector<T> getPixelsCpy();
+    [[nodiscard]] std::vector<T> getPixelsCpy() const;
-    std::optional<std::vector<T>> getLine(uint16_t line);
+    [[nodiscard]] std::optional<std::vector<T>> getLine(uint16_t line) const;
-    std::optional<std::vector<T>> getCol(uint16_t col);
+    [[nodiscard]] std::optional<std::vector<T>> getCol(uint16_t col) const;
+    void visualize() const;
 
    private:
     uint16_t mWidth;

src/graphics/Image.cpp

@@ -1,57 +0,0 @@
-/* 
-    ptrnt - print labels on linux
-    Copyright (C) 2023  Moritz Martinius
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
- */
-
-#include "Image.hpp"
-
-#include <string>
-
-#include "pango/pango-font.h"
-
-namespace ptprnt::graphics {
-Image::Image() {
-    mSurface         = cairo_image_surface_create(CAIRO_FORMAT_A8, 512, 128);
-    cairo_t* cr      = cairo_create(mSurface);
-    mFontDescription = pango_font_description_new();
-    pango_font_description_set_family(mFontDescription, "sans");
-    pango_font_description_set_weight(mFontDescription, PANGO_WEIGHT_SEMIBOLD);
-    pango_font_description_set_size(mFontDescription, 60 * PANGO_SCALE);
-
-    std::string printThis("Mist 💩");
-
-    mLayout = pango_cairo_create_layout(cr);
-    pango_layout_set_font_description(mLayout, mFontDescription);
-    pango_layout_set_text(mLayout, printThis.c_str(), -1);
-
-    cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
-    cairo_move_to(cr, 0.0, 94.0);
-    pango_cairo_show_layout_line(cr, pango_layout_get_line(mLayout, 0));
-
-    cairo_surface_write_to_png(mSurface, "hello.png");
-}
-
-uint8_t* Image::getRaw() {
-    cairo_surface_flush(mSurface);
-    return cairo_image_surface_get_data(mSurface);
-}
-
-Image::~Image() {
-    g_object_unref(mLayout);
-    pango_font_description_free(mFontDescription);
-}
-}  // namespace ptprnt::graphics

src/graphics/Image.hpp

@@ -1,38 +0,0 @@
-/* 
-    ptrnt - print labels on linux
-    Copyright (C) 2023  Moritz Martinius
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
- */
-
-#pragma once
-
-#include <pango/pangocairo.h>
-
-#include <cstdint>
-
-namespace ptprnt::graphics {
-class Image {
-   public:
-    Image();
-    ~Image();
-    uint8_t* getRaw();
-
-   private:
-    PangoLayout* mLayout;
-    PangoFontDescription* mFontDescription;
-    cairo_surface_t* mSurface;
-};
-}  // namespace ptprnt::graphics

src/graphics/Label.cpp

@@ -0,0 +1,186 @@
+/* 
+    ptrnt - print labels on linux
+    Copyright (C) 2023  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#include "graphics/Label.hpp"
+
+#include <algorithm>
+#include <spdlog/spdlog.h>
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "cairo.h"
+#include "graphics/interface/ILabel.hpp"
+#include "pango/pango-font.h"
+#include "pango/pango-layout.h"
+#include "pango/pango-types.h"
+#include "pango/pangocairo.h"
+
+namespace ptprnt::graphics {
+Label::Label(const uint16_t heightPixel)
+    : mCairoCtx(cairo_create(mSurface)),
+      mPangoCtx(pango_cairo_create_context(mCairoCtx)),
+      mPangoLyt(pango_layout_new(mPangoCtx)),
+      mFontMap(pango_cairo_font_map_new()),
+      mPrinterHeight(heightPixel) {}
+
+std::vector<uint8_t> Label::getRaw() {
+    assert(mSurface != nullptr);
+    size_t len = mPrinterHeight * mLayoutWidth;
+
+    cairo_surface_flush(mSurface);
+    auto data = cairo_image_surface_get_data(mSurface);
+    return {data, data + len};
+}
+
+uint8_t Label::getNumLines(std::string_view strv) {
+    return std::count(strv.begin(), strv.end(), '\n');
+}
+
+int Label::getWidth() {
+    return mPrinterHeight;
+}
+
+int Label::getHeight() {
+    return getLayoutWidth();
+}
+
+int Label::getLayoutHeight() {
+    return mLayoutHeight;
+}
+
+int Label::getLayoutWidth() {
+    return mLayoutWidth;
+}
+
+bool Label::create(PrintableText printableText) {
+    setFontFamily(printableText.fontFamily);
+    setFontSize(printableText.fontSize);
+
+    return create(printableText.text);
+}
+
+bool Label::create(const std::string& labelText) {
+    // TODO: we need to create a custom fontconfig here so that Noto Emoji does not load the systems default
+    // fontconfig here. For this, we need to create a PangoFcFontMap and a custom FcConfig
+    // see: https://docs.gtk.org/PangoFc/method.FontMap.set_config.html
+    // see: https://gist.github.com/CallumDev/7c66b3f9cf7a876ef75f
+    PangoFontDescription* regularFont = pango_font_description_new();
+    pango_font_description_set_size(regularFont, static_cast<int>(mFontSize * PANGO_SCALE));
+    pango_font_description_set_family(regularFont, mFontFamily.c_str());
+    //pango_layout_set_single_paragraph_mode(mPangoLyt, true); // this will force a single line in the label width width -1
+    pango_layout_set_height(mPangoLyt, getNumLines(labelText) * -1);
+    pango_layout_set_font_description(mPangoLyt, regularFont);
+    pango_layout_set_text(mPangoLyt, labelText.c_str(), static_cast<int>(labelText.length()));
+
+    // Set horizontal alignment
+    switch (mHAlign) {
+        case HAlignPosition::LEFT:
+            pango_layout_set_alignment(mPangoLyt, PANGO_ALIGN_LEFT);
+            break;
+        case HAlignPosition::RIGHT:
+            pango_layout_set_alignment(mPangoLyt, PANGO_ALIGN_RIGHT);
+            break;
+        case HAlignPosition::JUSTIFY:
+            pango_layout_set_alignment(mPangoLyt, PANGO_ALIGN_LEFT);  // not sure if needed
+            pango_layout_set_justify(mPangoLyt, true);
+// only enabled in pango 1.50 and greater
+#if PANGO_VERSION_MAJOR >= 1 && PANGO_VERSION_MINOR >= 50
+            pango_layout_set_justify_last_line(mPangoLyt, true);
+#endif
+            break;
+        case HAlignPosition::CENTER:
+            [[fallthrough]];
+        default:
+            pango_layout_set_alignment(mPangoLyt, PANGO_ALIGN_CENTER);
+            break;
+    }
+
+    // calculate label size for Cairo surface creation
+    pango_layout_get_size(mPangoLyt, &mLayoutWidth, &mLayoutHeight);
+    mLayoutWidth /= PANGO_SCALE;
+    mLayoutHeight /= PANGO_SCALE;
+
+    spdlog::debug("Layout width: {}, height: {}", mLayoutWidth, mLayoutHeight);
+    auto alignedWidth = mLayoutWidth + (8 - (mLayoutWidth % 8));
+
+    mSurface    = cairo_image_surface_create(CAIRO_FORMAT_A8, alignedWidth, mPrinterHeight);
+    cairo_t* cr = cairo_create(mSurface);
+
+    // Adjust Cairo cursor position to respect the vertical alignment
+    switch (mVAlign) {
+        case VAlignPosition::TOP:
+            break;
+        case VAlignPosition::BOTTOM:
+            cairo_move_to(cr, 0.0, mPrinterHeight - mLayoutHeight);
+            break;
+        case VAlignPosition::MIDDLE:
+            cairo_move_to(cr, 0.0, (mPrinterHeight - mLayoutHeight) / 2);
+            [[fallthrough]];
+        default:
+            break;
+    }
+
+    // Finally show the layout on the Cairo surface
+    pango_cairo_show_layout(cr, mPangoLyt);
+
+    cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
+    cairo_surface_flush(mSurface);
+    cairo_destroy(cr);
+    return true;
+}
+
+void Label::writeToPng(const std::string& file) {
+    if (mSurface) {
+        cairo_surface_flush(mSurface);
+        cairo_surface_write_to_png(mSurface, file.c_str());
+    }
+}
+
+void Label::setFontSize(const double fontSize) {
+    mFontSize = fontSize;
+}
+
+void Label::setFontFamily(const std::string& fontFamily) {
+    mFontFamily = fontFamily;
+}
+
+void Label::setHAlign(HAlignPosition hAlign) {
+    mHAlign = hAlign;
+}
+
+void Label::setVAlign(VAlignPosition vAlign) {
+    mVAlign = vAlign;
+}
+
+void Label::setText(const std::string& text) {
+    mText = text;
+}
+
+Label::~Label() {
+    spdlog::debug("Image dtor...");
+    g_object_unref(mPangoCtx);
+    g_object_unref(mPangoLyt);
+    g_object_unref(mFontMap);
+    cairo_surface_destroy(mSurface);
+}
+}  // namespace ptprnt::graphics

src/graphics/Label.hpp

@@ -0,0 +1,78 @@
+/* 
+    ptrnt - print labels on linux
+    Copyright (C) 2023  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#pragma once
+
+#include <pango/pangocairo.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "cairo.h"
+#include "graphics/interface/ILabel.hpp"
+#include "pango/pango-types.h"
+
+namespace ptprnt::graphics {
+
+class Label : public ILabel {
+   public:
+    Label(const uint16_t heightPixel);
+    ~Label() override;
+
+    Label(const Label&)            = delete;
+    Label& operator=(const Label&) = delete;
+    Label(Label&&)                 = delete;
+    Label& operator=(Label&&)      = delete;
+
+    bool create(PrintableText printableText) override;
+    bool create(const std::string& labelText) override;
+    void writeToPng(const std::string& file);
+    [[nodiscard]] int getWidth() override;
+    [[nodiscard]] int getHeight() override;
+    [[nodiscard]] int getLayoutWidth() override;
+    [[nodiscard]] int getLayoutHeight() override;
+    [[nodiscard]] std::vector<uint8_t> getRaw() override;
+    void setFontSize(const double fontSize) override;
+    void setFontFamily(const std::string& fontFamily) override;
+
+    void setText(const std::string& text) override;
+    void setHAlign(HAlignPosition hpos) override;
+    void setVAlign(VAlignPosition vpos) override;
+
+   private:
+    // methods
+    [[nodiscard]] uint8_t getNumLines(std::string_view str);
+    [[nodiscard]] PangoFontMap* createCustomFontMap();
+    // members
+    // TODO: convert raw pointers here into std::unique_ptr with custom deleters, calling g_object_unref()
+    cairo_surface_t* mSurface{nullptr};
+    cairo_t* mCairoCtx{nullptr};
+    PangoContext* mPangoCtx{nullptr};
+    PangoLayout* mPangoLyt{nullptr};
+    PangoFontMap* mFontMap{nullptr};
+    double mFontSize{DEFAULT_FONT_SIZE};
+    std::string mFontFamily{DEFAULT_FONT_FAMILY};
+    HAlignPosition mHAlign = HAlignPosition::LEFT;
+    VAlignPosition mVAlign = VAlignPosition::MIDDLE;
+    std::string mText{""};
+    int mLayoutWidth = 0, mLayoutHeight = 0;
+    int mPrinterHeight = 0;
+};
+}  // namespace ptprnt::graphics

src/graphics/Monochrome.cpp

@@ -21,7 +21,7 @@
 
 #include <cmath>
 
-#include <cstdint>
+#include <iostream>
 #include <vector>
 
 namespace ptprnt::graphics {
@@ -38,12 +38,11 @@ void Monochrome::invert(bool shouldInvert) {
 std::vector<uint8_t> Monochrome::get() {
     std::vector<uint8_t> outPixels(
         (static_cast<unsigned int>((mPixels.size() / 8)) + (std::floor(mPixels.size() % 8 + 0.9))));
-
     unsigned int outIndex = 0;
 
-    for (unsigned int byteNum = 0; byteNum < mPixels.size(); byteNum += 8) {
+    for (unsigned int byteNo = 0; byteNo < mPixels.size(); byteNo += 8) {
-        for (unsigned int bitNo = 0; bitNo < 8; bitNo++) {
+        for (unsigned int bitNo = 0; bitNo <= 7 && (byteNo + bitNo < mPixels.size()); bitNo++) {
-            if (mPixels[byteNum + bitNo] > mThreshhold) {
+            if (mPixels[byteNo + bitNo] > mThreshhold) {
                 outPixels[outIndex] |= (1 << (7 - bitNo));
             } else {
                 outPixels[outIndex] &= ~(1 << (7 - bitNo));
@@ -56,4 +55,20 @@ std::vector<uint8_t> Monochrome::get() {
     }
     return outPixels;
 }
+
+void Monochrome::visualize() {
+    auto mono = get();
+    for (unsigned char pix : mono) {
+        std::cout << ((pix & (1 << 7)) == 0 ? "." : "x");
+        std::cout << ((pix & (1 << 6)) == 0 ? "." : "x");
+        std::cout << ((pix & (1 << 5)) == 0 ? "." : "x");
+        std::cout << ((pix & (1 << 4)) == 0 ? "." : "x");
+        std::cout << ((pix & (1 << 3)) == 0 ? "." : "x");
+        std::cout << ((pix & (1 << 2)) == 0 ? "." : "x");
+        std::cout << ((pix & (1 << 1)) == 0 ? "." : "x");
+        std::cout << ((pix & (1 << 0)) == 0 ? "." : "x");
+    }
+    std::cout << std::endl;
+}
+
 }  // namespace ptprnt::graphics

src/graphics/Monochrome.hpp

@@ -31,11 +31,12 @@ class Monochrome {
 
     void setThreshold(uint8_t);
     void invert(bool shouldInvert);
+    void visualize();
     std::vector<uint8_t> get();
 
    private:
     const std::vector<uint8_t>& mPixels;
-    uint8_t mThreshhold = 127;
+    uint8_t mThreshhold = UINT8_MAX / 2;
     bool mShouldInvert  = false;
 };
 }  // namespace ptprnt::graphics

src/graphics/interface/ILabel.hpp

@@ -0,0 +1,82 @@
+/* 
+    ptrnt - print labels on linux
+    Copyright (C) 2023  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <map>
+#include <string>
+#include <vector>
+
+constexpr const char* DEFAULT_FONT_FAMILY = "sans";
+constexpr const double DEFAULT_FONT_SIZE  = 32.0;
+
+enum class HAlignPosition {
+    UNKNOWN = 0,
+    LEFT    = 1,
+    CENTER  = 2,
+    RIGHT   = 3,
+    JUSTIFY = 4,
+};
+const std::map<std::string, HAlignPosition> HALignPositionMap{{"", HAlignPosition::UNKNOWN},
+                                                              {"left", HAlignPosition::LEFT},
+                                                              {"center", HAlignPosition::CENTER},
+                                                              {"right", HAlignPosition::RIGHT},
+                                                              {"justify", HAlignPosition::JUSTIFY}};
+
+enum class VAlignPosition {
+    UNKNOWN = 0,
+    TOP     = 1,
+    MIDDLE  = 2,
+    BOTTOM  = 3,
+};
+
+const std::map<std::string, VAlignPosition> VALignPositionMap{{"", VAlignPosition::UNKNOWN},
+                                                              {"top", VAlignPosition::TOP},
+                                                              {"middle", VAlignPosition::MIDDLE},
+                                                              {"bottom", VAlignPosition::BOTTOM}};
+
+struct PrintableText {
+    std::string text{""};
+    std::string fontFamily{DEFAULT_FONT_FAMILY};
+    double fontSize{DEFAULT_FONT_SIZE};
+    HAlignPosition hAlign{HAlignPosition::LEFT};
+    VAlignPosition vAlign{VAlignPosition::MIDDLE};
+};
+
+namespace ptprnt::graphics {
+class ILabel {
+   public:
+    virtual ~ILabel() = default;
+
+    virtual bool create(PrintableText printableText)  = 0;
+    virtual bool create(const std::string& labelText) = 0;
+    virtual std::vector<uint8_t> getRaw()             = 0;
+    virtual int getWidth()                            = 0;
+    virtual int getHeight()                           = 0;
+    virtual int getLayoutWidth()                      = 0;
+    virtual int getLayoutHeight()                     = 0;
+
+    virtual void setText(const std::string& text)             = 0;
+    virtual void setFontSize(const double fontSize)           = 0;
+    virtual void setFontFamily(const std::string& fontFamily) = 0;
+    virtual void setHAlign(HAlignPosition hpos)               = 0;
+    virtual void setVAlign(VAlignPosition vpos)               = 0;
+};
+}  // namespace ptprnt::graphics

src/hello.txt

@@ -0,0 +1,7 @@
+{
+  "text" : " Hello",
+  "font" : "FreeSans 32",
+  "single-paragraph" : true,
+  "alignment" : "center",
+  "height" : 0
+}

src/interface/IPrinterDriver.hpp

@@ -19,16 +19,15 @@
 
 #pragma once
 
-#include <cstdint>
 #include <memory>
 #include <string_view>
 
 #include "graphics/Bitmap.hpp"
+#include "graphics/interface/ILabel.hpp"
 #include "interface/IPrinterTypes.hpp"
 #include "libusbwrap/interface/IUsbDevice.hpp"
 
 namespace ptprnt {
-
 class IPrinterDriver {
    public:
     virtual ~IPrinterDriver()                                                     = default;
@@ -40,12 +39,8 @@ class IPrinterDriver {
     [[nodiscard]] virtual const PrinterStatus getPrinterStatus()                  = 0;
     virtual bool attachUsbDevice(std::shared_ptr<libusbwrap::IUsbDevice> usbHndl) = 0;
     virtual bool detachUsbDevice()                                                = 0;
-    virtual bool setText(const std::string& text)                                 = 0;
-    virtual bool setFont(const std::string& text)                                 = 0;
-    virtual bool setFontSize(uint8_t fontSize)                                    = 0;
-    virtual bool setHAlign(HAlignPosition hpos)                                   = 0;
-    virtual bool setVAlign(VAlignPosition vpos)                                   = 0;
     virtual bool printBitmap(const graphics::Bitmap<graphics::ALPHA8>& bitmap)    = 0;
+    virtual bool printLabel(const std::unique_ptr<graphics::ILabel> label)        = 0;
     virtual bool print()                                                          = 0;
 };
 

src/interface/IPrinterTypes.hpp

@@ -22,6 +22,7 @@
 #include <cstdint>
 #include <string>
 #include <string_view>
+#include <vector>
 
 #include "libusbwrap/LibUsbTypes.hpp"
 
@@ -32,6 +33,7 @@ struct PrinterInfo {
     std::string_view name       = "";
     std::string_view version    = "";
     libusbwrap::usbId usbId{0x00, 0x00};
+    uint16_t pixelLines = 0;
 };
 
 struct PrinterStatus {
@@ -39,27 +41,6 @@ struct PrinterStatus {
     unsigned int tapeWidthMm    = 0.0;
 };
 
-enum class HAlignPosition {
+using cmd_T = std::vector<uint8_t>;
-    UNKNOWN = 0,
-    LEFT    = 1,
-    CENTER  = 2,
-    RIGHT   = 3,
-    JUSTIFY = 4,
-};
-
-enum class VAlignPosition {
-    UNKNOWN = 0,
-    TOP     = 1,
-    MIDDLE  = 2,
-    BOTTOM  = 3,
-};
-
-struct PrintableText {
-    std::string text{""};
-    std::string font{"Noto"};
-    uint8_t fontSize{0};
-    HAlignPosition hAlign{HAlignPosition::LEFT};
-    VAlignPosition vAlign{VAlignPosition::MIDDLE};
-};
 
 }  // namespace ptprnt

src/libusbwrap/UsbDevice.cpp

@@ -27,12 +27,12 @@
 #include "libusbwrap/interface/IUsbDevice.hpp"
 
 namespace libusbwrap {
-UsbDevice::UsbDevice(libusb_context* ctx, libusb_device* dev) : mLibusbCtx(ctx), mLibusbDev(dev) {
+UsbDevice::UsbDevice(libusb_context* ctx, usbDevice_ptr dev) : mLibusbCtx(ctx), mLibusbDev(std::move(dev)) {
     if (mLibusbCtx == nullptr || mLibusbDev == nullptr) {
         throw std::invalid_argument("ctx or device are nullptr");
     }
 
-    libusb_get_device_descriptor(dev, &mLibusbDevDesc);
+    libusb_get_device_descriptor(mLibusbDev.get(), &mLibusbDevDesc);
 }
 
 UsbDevice::~UsbDevice() {
@@ -44,7 +44,7 @@ UsbDevice::~UsbDevice() {
 }
 
 bool UsbDevice::open() {
-    int openStatus = libusb_open(mLibusbDev, &mLibusbDevHandle);
+    int openStatus = libusb_open(mLibusbDev.get(), &mLibusbDevHandle);
     if (openStatus != 0) {
         mLastError = static_cast<Error>(openStatus);
         return false;
@@ -90,13 +90,12 @@ bool UsbDevice::releaseInterface(int interfaceNo) {
     return true;
 }
 
-bool UsbDevice::bulkTransfer(uint8_t endpoint, std::vector<uint8_t>& data, int* tx,
+bool UsbDevice::bulkTransfer(uint8_t endpoint, const std::vector<uint8_t>& data, int* tx, unsigned int timeout) {
-                             unsigned int timeout) {
     // TODO: implement error handling for incomplete transactions (tx length != data length)
     int bulkTransferStatus = 0;
 
-    bulkTransferStatus =
+    bulkTransferStatus = libusb_bulk_transfer(mLibusbDevHandle, endpoint, const_cast<unsigned char*>(data.data()),
-        libusb_bulk_transfer(mLibusbDevHandle, endpoint, data.data(), data.size(), tx, timeout);
+                                              data.size(), tx, timeout);
     if (bulkTransferStatus != 0) {
         mLastError = static_cast<Error>(bulkTransferStatus);
         return false;
@@ -109,15 +108,15 @@ const usbId UsbDevice::getUsbId() {
 }
 
 const device::Speed UsbDevice::getSpeed() {
-    return static_cast<device::Speed>(libusb_get_device_speed(mLibusbDev));
+    return static_cast<device::Speed>(libusb_get_device_speed(mLibusbDev.get()));
 }
 
 const uint8_t UsbDevice::getBusNumber() {
-    return libusb_get_bus_number(mLibusbDev);
+    return libusb_get_bus_number(mLibusbDev.get());
 }
 
 const uint8_t UsbDevice::getPortNumber() {
-    return libusb_get_port_number(mLibusbDev);
+    return libusb_get_port_number(mLibusbDev.get());
 }
 
 const Error UsbDevice::getLastError() {

src/libusbwrap/UsbDevice.hpp

@@ -20,21 +20,34 @@
 #pragma once
 
 #include <atomic>
-#include <cstddef>
+#include <memory>
 
 #include "libusb.h"
 #include "libusbwrap/LibUsbTypes.hpp"
 #include "libusbwrap/interface/IUsbDevice.hpp"
 
 namespace libusbwrap {
+
+struct usbDevice_deleter {
+    void operator()(libusb_device* dev_ptr) const {
+        if (nullptr != dev_ptr) {
+            libusb_unref_device(dev_ptr);
+        }
+    }
+};
+
+using usbDevice_ptr = std::unique_ptr<libusb_device, usbDevice_deleter>;
+
 class UsbDevice : public IUsbDevice {
    public:
-    explicit UsbDevice(libusb_context* ctx, libusb_device* dev);
+    explicit UsbDevice(libusb_context* ctx, usbDevice_ptr dev);
     ~UsbDevice() override;
 
     // delete copy ctor and assignment
-    UsbDevice(const UsbDevice&)      = delete;
+    UsbDevice(const UsbDevice&)            = delete;
-    UsbDevice& operator=(UsbDevice&) = delete;
+    UsbDevice& operator=(const UsbDevice&) = delete;
+    UsbDevice(UsbDevice&&)                 = delete;
+    UsbDevice& operator=(UsbDevice&&)      = delete;
 
     bool open() override;
     void close() override;
@@ -43,8 +56,7 @@ class UsbDevice : public IUsbDevice {
     bool detachKernelDriver(int interfaceNo) override;
     bool claimInterface(int interfaceNo) override;
     bool releaseInterface(int interfaceNo) override;
-    bool bulkTransfer(uint8_t endpoint, std::vector<uint8_t>& data, int* tx,
+    bool bulkTransfer(uint8_t endpoint, const std::vector<uint8_t>& data, int* tx, unsigned int timeout) override;
-                      unsigned int timeout) override;
 
     // getters
     const usbId getUsbId() override;
@@ -58,9 +70,9 @@ class UsbDevice : public IUsbDevice {
 
    private:
     libusb_context* mLibusbCtx{nullptr};
-    libusb_device* mLibusbDev{nullptr};
+    usbDevice_ptr mLibusbDev{nullptr};
     libusb_device_handle* mLibusbDevHandle{nullptr};
-    libusb_device_descriptor mLibusbDevDesc;
+    libusb_device_descriptor mLibusbDevDesc{0};
     std::atomic<bool> mIsOpen = false;
     Error mLastError          = Error::SUCCESS;
 };

src/libusbwrap/UsbDeviceFactory.cpp

@@ -20,9 +20,11 @@
 #include "libusbwrap/UsbDeviceFactory.hpp"
 
 #include <spdlog/spdlog.h>
+#include <sys/types.h>
 
 #include <memory>
 #include <optional>
+#include <vector>
 
 #include "libusb.h"
 #include "libusbwrap/UsbDevice.hpp"
@@ -31,49 +33,56 @@
 namespace libusbwrap {
 
 UsbDeviceFactory::~UsbDeviceFactory() {
-    if (mDeviceListInitialized) {
+    if (mLibusbCtx) {
-        libusb_free_device_list(mLibusbDeviceList, 1);
+        libusb_exit(mLibusbCtx);
     }
-}
+};
 
-std::vector<std::shared_ptr<IUsbDevice>> UsbDeviceFactory::findAllDevices() {
+std::vector<std::unique_ptr<IUsbDevice>> UsbDeviceFactory::findAllDevices() {
     refreshDeviceList();
     return buildMaskedDeviceVector(0x0, 0x0, 0x0, 0x0);
 }
 
-std::vector<std::shared_ptr<IUsbDevice>> UsbDeviceFactory::findDevices(uint16_t vid, uint16_t pid) {
+std::vector<std::unique_ptr<IUsbDevice>> UsbDeviceFactory::findDevices(uint16_t vid, uint16_t pid) {
     refreshDeviceList();
-    return buildMaskedDeviceVector(0xffff, 0xffff, vid, pid);
+    return buildMaskedDeviceVector(LIBUSB_BITMASK_ALL, LIBUSB_BITMASK_ALL, vid, pid);
 }
 
-int UsbDeviceFactory::refreshDeviceList() {
+ssize_t UsbDeviceFactory::refreshDeviceList() {
-    int ret = libusb_get_device_list(mLibusbCtx, &mLibusbDeviceList);
+    libusb_device** list{nullptr};
+
+    ssize_t ret = libusb_get_device_list(mLibusbCtx, &list);
+    mLibusbDeviceList.clear();
     if (ret < 0) {
         spdlog::error("Error enumarating USB devices");
     } else if (ret == 0) {
         spdlog::warn("No USB devices found");
     }
-    mDeviceListInitialized = true;
+
+    for (ssize_t i = 0; i < ret; i++) {
+        mLibusbDeviceList.emplace_back(list[i]);
+    }
+
+    libusb_free_device_list(list, false);
     return ret;
 }
 
-std::vector<std::shared_ptr<IUsbDevice>> UsbDeviceFactory::buildMaskedDeviceVector(uint16_t vidMask,
+std::vector<std::unique_ptr<IUsbDevice>> UsbDeviceFactory::buildMaskedDeviceVector(uint16_t vidMask,
                                                                                    uint16_t pidMask,
                                                                                    uint16_t vid,
                                                                                    uint16_t pid) {
-    std::vector<std::shared_ptr<IUsbDevice>> matchedDevices;
+    std::vector<std::unique_ptr<IUsbDevice>> matchedDevices;
     // see libusb/examples/listdevs.c
-    int i                  = 0;
+    for (auto& currDev : mLibusbDeviceList) {
-    libusb_device* currDev = nullptr;
+        struct libusb_device_descriptor currDevDesc {};
-    while ((currDev = mLibusbDeviceList[i++]) != nullptr) {
+
-        struct libusb_device_descriptor currDevDesc;
+        int ret = libusb_get_device_descriptor(currDev.get(), &currDevDesc);
-        int ret = libusb_get_device_descriptor(currDev, &currDevDesc);
         if (ret < 0) {
             continue;
         }
         if (((currDevDesc.idVendor & vidMask) == vid) &&
             ((currDevDesc.idProduct & pidMask) == pid)) {
-            matchedDevices.push_back(std::make_shared<UsbDevice>(mLibusbCtx, currDev));
+            matchedDevices.push_back(std::make_unique<UsbDevice>(mLibusbCtx, std::move(currDev)));
         }
     }
     return matchedDevices;

src/libusbwrap/UsbDeviceFactory.hpp

@@ -19,9 +19,16 @@
 
 #pragma once
 
+#include <cstdint>
+
+#include "libusb.h"
+#include "libusbwrap/UsbDevice.hpp"
 #include "libusbwrap/interface/IUsbDeviceFactory.hpp"
 
 namespace libusbwrap {
+
+constexpr const uint16_t LIBUSB_BITMASK_ALL = 0xffff;
+
 class UsbDeviceFactory : public IUsbDeviceFactory {
    public:
     UsbDeviceFactory() = default;
@@ -39,7 +46,7 @@ class UsbDeviceFactory : public IUsbDeviceFactory {
      * 
      * @return std::vector<std::shared_ptr<IUsbDevice>> Vector of all detected USB devices
      */
-    std::vector<std::shared_ptr<IUsbDevice>> findAllDevices() override;
+    std::vector<std::unique_ptr<IUsbDevice>> findAllDevices() override;
     /**
      * @brief Gets all devices with certain vid/pid combination. 
      *        If only one device of certain type is connected, vector is usually only one element
@@ -48,17 +55,17 @@ class UsbDeviceFactory : public IUsbDeviceFactory {
      * @param pid ProductId of the devices to find
      * @return std::vector<std::shared_ptr<IUsbDevice>> Vector of detected USB devices based on vid/pid
      */
-    std::vector<std::shared_ptr<IUsbDevice>> findDevices(uint16_t vid, uint16_t pid) override;
+    std::vector<std::unique_ptr<IUsbDevice>> findDevices(uint16_t vid, uint16_t pid) override;
 
    private:
     // methods
-    int refreshDeviceList();
+    ssize_t refreshDeviceList();
-    std::vector<std::shared_ptr<IUsbDevice>> buildMaskedDeviceVector(uint16_t vidMask,
+    std::vector<std::unique_ptr<IUsbDevice>> buildMaskedDeviceVector(uint16_t vidMask,
                                                                      uint16_t pidMask, uint16_t vid,
                                                                      uint16_t pid);
     // members
     libusb_context* mLibusbCtx{nullptr};
-    libusb_device** mLibusbDeviceList{};
+    std::vector<usbDevice_ptr> mLibusbDeviceList{};
     bool mDeviceListInitialized = false;
 };
 }  // namespace libusbwrap

src/libusbwrap/interface/IUsbDevice.hpp

@@ -29,11 +29,10 @@ class IUsbDevice {
     virtual void close()  = 0;
 
     // libusb wrappers
-    virtual bool detachKernelDriver(int interfaceNo) = 0;
+    virtual bool detachKernelDriver(int interfaceNo)                                                             = 0;
-    virtual bool claimInterface(int interfaceNo)     = 0;
+    virtual bool claimInterface(int interfaceNo)                                                                 = 0;
-    virtual bool releaseInterface(int interfaceNo)   = 0;
+    virtual bool releaseInterface(int interfaceNo)                                                               = 0;
-    virtual bool bulkTransfer(uint8_t endpoint, std::vector<uint8_t>& data, int* tx,
+    virtual bool bulkTransfer(uint8_t endpoint, const std::vector<uint8_t>& data, int* tx, unsigned int timeout) = 0;
-                              unsigned int timeout)  = 0;
 
     // getters
     virtual const usbId getUsbId()         = 0;

src/libusbwrap/interface/IUsbDeviceFactory.hpp

@@ -10,7 +10,7 @@ namespace libusbwrap {
 class IUsbDeviceFactory {
    public:
     virtual ~IUsbDeviceFactory()                                      = default;
-    virtual std::vector<std::shared_ptr<IUsbDevice>> findAllDevices() = 0;
+    virtual std::vector<std::unique_ptr<IUsbDevice>> findAllDevices() = 0;
-    virtual std::vector<std::shared_ptr<IUsbDevice>> findDevices(uint16_t vid, uint16_t pid) = 0;
+    virtual std::vector<std::unique_ptr<IUsbDevice>> findDevices(uint16_t vid, uint16_t pid) = 0;
 };
 }  // namespace libusbwrap

src/meson.build

@@ -10,7 +10,7 @@ ptprnt_hpps = files (
     'PtouchPrint.hpp',
     'PrinterDriverFactory.hpp',
     'graphics/Bitmap.hpp',
-    'graphics/Image.hpp',
+    'graphics/Label.hpp',
     'graphics/Monochrome.hpp'
 )
 
@@ -18,7 +18,7 @@ ptprnt_srcs = files (
     'PtouchPrint.cpp',
     'PrinterDriverFactory.cpp',
     'P700Printer.cpp',
-    'graphics/Image.cpp',
+    'graphics/Label.cpp',
     'graphics/Bitmap.cpp',
     'graphics/Monochrome.cpp',
     'libusbwrap/UsbDeviceFactory.cpp',

tests/label_test/label_test.cpp

@@ -17,10 +17,10 @@
 
  */
 
-#include "graphics/Image.hpp"
+#include "graphics/Label.hpp"
 
 #include <gtest/gtest.h>
 
-TEST(basic_test, Image_smokeTest_succeeds) {
+TEST(basic_test, Label_smokeTest_succeeds) {
-    auto im = ptprnt::graphics::Image();
+    auto im = ptprnt::graphics::Label(4711);
 }

tests/meson.build

@@ -5,9 +5,9 @@ tests = [
         ['../src/graphics/Bitmap.cpp', 'bitmap_test/bitmap_test.cpp'],
     ],
     [
-        'image_test',
+        'label_test',
-        'image_test_exe',
+        'label_test_exe',
-        ['../src/graphics/Image.cpp', 'image_test/image_test.cpp'],
+        ['../src/graphics/Label.cpp', 'label_test/label_test.cpp'],
     ],
     [
         'monochrome_test',
@@ -36,3 +36,5 @@ foreach test : tests
         ),
     )
 endforeach
+
+