Remove unused includes

Reviewed-on: moritz/ptouch-prnt#16

.vscode/settings.json

@@ -88,6 +88,14 @@
   },
   "clangd.onConfigChanged": "restart",
   "cSpell.words": [
-    "ptrnt"
+    "fakelabel",
+    "fontsize",
+    "gboolean",
+    "gint",
+    "gobject",
+    "halign",
+    "libusb",
+    "ptrnt",
+    "strv"
   ],
 }

hooks/README.md

@@ -0,0 +1,43 @@
+# Git Hooks
+
+This directory contains git hooks for the ptouch-prnt repository.
+
+## Installation
+
+To install the hooks, run:
+
+```bash
+./hooks/install_hooks.sh
+```
+
+This will copy all hooks from this directory to `.git/hooks/` and make them executable.
+
+## Available Hooks
+
+### pre-commit
+
+The pre-commit hook automatically updates copyright headers in source files before each commit.
+
+**What it does:**
+- Runs `scripts/update_copyright.sh` to update copyright years in source files
+- Automatically re-stages any modified files
+- Ensures copyright headers are always up-to-date
+
+**Requirements:**
+- `scripts/update_copyright.sh` must exist and be executable
+
+## Skipping Hooks
+
+If you need to skip the pre-commit hook for a specific commit (not recommended), use:
+
+```bash
+git commit --no-verify
+```
+
+## Uninstalling
+
+To remove a hook, simply delete it from `.git/hooks/`:
+
+```bash
+rm .git/hooks/pre-commit
+```

hooks/install_hooks.sh

@@ -0,0 +1,96 @@
+#!/bin/bash
+# Install git hooks for ptouch-prnt repository
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Get the root directory of the git repository
+ROOT_DIR=$(git rev-parse --show-toplevel 2>/dev/null)
+
+if [ -z "$ROOT_DIR" ]; then
+    echo -e "${RED}Error: Not in a git repository${NC}"
+    exit 1
+fi
+
+HOOKS_SOURCE_DIR="$ROOT_DIR/hooks"
+HOOKS_TARGET_DIR="$ROOT_DIR/.git/hooks"
+
+echo "Installing git hooks..."
+echo "  Source: $HOOKS_SOURCE_DIR"
+echo "  Target: $HOOKS_TARGET_DIR"
+echo ""
+
+# Check if hooks directory exists
+if [ ! -d "$HOOKS_SOURCE_DIR" ]; then
+    echo -e "${RED}Error: Hooks source directory not found: $HOOKS_SOURCE_DIR${NC}"
+    exit 1
+fi
+
+# Check if .git/hooks directory exists
+if [ ! -d "$HOOKS_TARGET_DIR" ]; then
+    echo -e "${RED}Error: Git hooks directory not found: $HOOKS_TARGET_DIR${NC}"
+    exit 1
+fi
+
+# Install each hook
+installed_count=0
+for hook_file in "$HOOKS_SOURCE_DIR"/*; do
+    # Skip the install script itself
+    if [[ "$(basename "$hook_file")" == "install_hooks.sh" ]]; then
+        continue
+    fi
+
+    # Skip if not a file
+    if [ ! -f "$hook_file" ]; then
+        continue
+    fi
+
+    hook_name=$(basename "$hook_file")
+    target_file="$HOOKS_TARGET_DIR/$hook_name"
+
+    # Check if hook already exists
+    if [ -f "$target_file" ]; then
+        echo -e "${YELLOW}Warning: Hook already exists: $hook_name${NC}"
+        read -p "  Overwrite? (y/N) " -n 1 -r
+        echo
+        if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+            echo "  Skipped: $hook_name"
+            continue
+        fi
+    fi
+
+    # Copy and make executable
+    cp "$hook_file" "$target_file"
+    chmod +x "$target_file"
+    echo -e "${GREEN}✓${NC} Installed: $hook_name"
+    ((installed_count++))
+done
+
+echo ""
+if [ $installed_count -eq 0 ]; then
+    echo -e "${YELLOW}No hooks were installed${NC}"
+else
+    echo -e "${GREEN}Successfully installed $installed_count hook(s)${NC}"
+fi
+
+# Verify update_copyright.sh exists and is executable
+if [ -f "$ROOT_DIR/scripts/update_copyright.sh" ]; then
+    if [ ! -x "$ROOT_DIR/scripts/update_copyright.sh" ]; then
+        echo ""
+        echo -e "${YELLOW}Making update_copyright.sh executable...${NC}"
+        chmod +x "$ROOT_DIR/scripts/update_copyright.sh"
+        echo -e "${GREEN}✓${NC} update_copyright.sh is now executable"
+    fi
+else
+    echo ""
+    echo -e "${YELLOW}Warning: scripts/update_copyright.sh not found${NC}"
+    echo "  The pre-commit hook requires this script to function properly"
+fi
+
+echo ""
+echo "Hook installation complete!"

hooks/pre-commit

@@ -0,0 +1,43 @@
+#!/bin/bash
+# Pre-commit hook to update copyright headers
+
+# Get the root directory of the git repository
+ROOT_DIR=$(git rev-parse --show-toplevel)
+
+# Check if update_copyright.sh exists and is executable
+if [ ! -x "$ROOT_DIR/scripts/update_copyright.sh" ]; then
+    echo "Warning: scripts/update_copyright.sh not found or not executable"
+    exit 1
+fi
+
+# Get list of staged C++ source files
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(cpp|hpp|h|c|cc)$' || true)
+
+if [ -z "$STAGED_FILES" ]; then
+    # No C++ files staged, nothing to do
+    exit 0
+fi
+
+echo "Updating copyright headers for staged files..."
+
+# Update copyright for each staged file
+updated=0
+for file in $STAGED_FILES; do
+    if [ -f "$ROOT_DIR/$file" ]; then
+        # Run update_copyright.sh on the file
+        if "$ROOT_DIR/scripts/update_copyright.sh" "$ROOT_DIR/$file" > /dev/null 2>&1; then
+            # Re-stage the file if it was modified
+            git add "$ROOT_DIR/$file"
+            echo "  ✓ Updated: $file"
+            ((updated++))
+        fi
+    fi
+done
+
+if [ $updated -gt 0 ]; then
+    echo "Updated copyright headers in $updated file(s)"
+else
+    echo "No copyright headers needed updating"
+fi
+
+exit 0

meson.build

@@ -57,9 +57,10 @@ ptprnt_exe = executable(
 
 ### Unit tests
 
-# GTest
+# GTest and GMock
 gtest_proj = subproject('gtest')
 gtest_dep = gtest_proj.get_variable('gtest_main_dep')
+gmock_dep = gtest_proj.get_variable('gmock_main_dep')
 if not gtest_dep.found()
     error('MESON_SKIP_TEST: gtest not installed.')
 endif

src/PtouchPrint.cpp

@@ -18,64 +18,89 @@
  */
 #include "PtouchPrint.hpp"
 
-#include <CLI/App.hpp>
-#include <algorithm>
 #include <fmt/core.h>
-#include <spdlog/common.h>
-#include <spdlog/details/synchronous_factory.h>
-#include <spdlog/logger.h>
-#include <spdlog/sinks/base_sink.h>
 #include <spdlog/sinks/basic_file_sink.h>
 #include <spdlog/sinks/stdout_color_sinks.h>
 #include <spdlog/spdlog.h>
 
-#include <cctype>
+#include "cli/CliParser.hpp"
-#include <functional>
+#include "cli/interface/ICliParser.hpp"
-#include <memory>
+#include "constants.hpp"
-#include <unordered_set>
+#include "core/PrinterDriverFactory.hpp"
-#include <vector>
+#include "core/PrinterService.hpp"
-
+#include "core/interface/IPrinterService.hpp"
-#include "CLI/Option.hpp"
-#include "PrinterDriverFactory.hpp"
 #include "graphics/LabelBuilder.hpp"
-#include "graphics/interface/ILabel.hpp"
-#include "libusbwrap/UsbDeviceFactory.hpp"
 
 namespace ptprnt {
 
-PtouchPrint::PtouchPrint(const char* versionString) : mVersionString{versionString} {}
+PtouchPrint::PtouchPrint(const char* versionString)
+    : PtouchPrint(versionString, std::make_unique<cli::CliParser>(ptprnt::APP_DESC, versionString),
+                  std::make_unique<core::PrinterService>()) {}
+
+PtouchPrint::PtouchPrint(const char* versionString, std::unique_ptr<cli::ICliParser> cliParser,
+                         std::unique_ptr<core::IPrinterService> printerService)
+    : mVersionString(versionString), mCliParser(std::move(cliParser)), mPrinterService(std::move(printerService)) {}
+
+PtouchPrint::~PtouchPrint() = default;
 
 int PtouchPrint::init(int argc, char** argv) {
-    setupCliParser();
+    // Parse CLI arguments
+    int parseResult = mCliParser->parse(argc, argv);
+    if (parseResult != 0) {
+        // Pass through: positive = clean exit (help/version), negative = error
+        return parseResult;
+    }
 
-    try {
+    // Setup logging based on CLI flags
-        mApp.parse(argc, argv);
+    setupLogger();
-    } catch (const CLI::ParseError& e) {
+
-        mApp.exit(e);
+    // Initialize printer service
+    if (!mPrinterService->initialize()) {
         return -1;
     }
 
-    // Set log level based on flags
-    if (mTraceFlag) {
-        setupLogger(spdlog::level::trace);
-    } else if (mVerboseFlag) {
-        setupLogger(spdlog::level::debug);
-    } else {
-        setupLogger(spdlog::level::warn);
-    }
-
-    if (!mUsbDeviceFactory.init()) {
-        spdlog::error("Could not initialize libusb");
-        return -1;
-    }
     return 0;
 }
 
 int PtouchPrint::run() {
     spdlog::info("ptprnt version {}", mVersionString);
 
-    // Handle --list-all-drivers flag
+    const auto& options = mCliParser->getOptions();
-    if (mListDriversFlag) {
+
+    // Handle --list-all-drivers
+    if (options.listDrivers) {
+        return handleListDrivers() ? 0 : -1;
+    }
+
+    // Handle printing
+    return handlePrinting() ? 0 : -1;
+}
+
+void PtouchPrint::setupLogger() {
+    const auto& options = mCliParser->getOptions();
+
+    spdlog::level::level_enum level = spdlog::level::warn;
+    if (options.trace) {
+        level = spdlog::level::trace;
+    } else if (options.verbose) {
+        level = spdlog::level::debug;
+    }
+
+    auto consoleSink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
+    consoleSink->set_level(level);
+    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);
+    fileSink->set_pattern("%Y-%m-%d %H:%m:%S:%e [pid:%P tid:%t] [%^%l%$] %v (%@)");
+
+    std::vector<spdlog::sink_ptr> sinks{consoleSink, fileSink};
+    auto logger = std::make_shared<spdlog::logger>("default_logger", sinks.begin(), sinks.end());
+    logger->set_level(spdlog::level::trace);
+    spdlog::set_default_logger(logger);
+}
+
+bool PtouchPrint::handleListDrivers() {
     auto driverFactory = std::make_unique<PrinterDriverFactory>();
     auto drivers       = driverFactory->listAllDrivers();
 
@@ -84,103 +109,82 @@ int PtouchPrint::run() {
         fmt::print("  - {}\n", driver);
     }
     fmt::print("\nUse with: -p <driver_name> or --printer <driver_name>\n");
-        return 0;
+    return true;
 }
 
-    // Determine which printer to use
+bool PtouchPrint::handlePrinting() {
-    std::shared_ptr<IPrinterDriver> printer = nullptr;
+    const auto& options = mCliParser->getOptions();
-
-    if (mPrinterSelection != "auto") {
-        // Explicit printer selection by name
-        auto driverFactory = std::make_unique<PrinterDriverFactory>();
-        printer            = driverFactory->createByName(mPrinterSelection);
 
+    // Select printer
+    auto printer = mPrinterService->selectPrinter(options.printerSelection);
     if (!printer) {
-            spdlog::error("Failed to create printer driver '{}'", mPrinterSelection);
+        spdlog::error("Failed to select printer");
-            spdlog::info("Use --list-all-drivers to see available drivers");
+        return false;
-            return -1;
-        }
-
-        spdlog::info("Using explicitly selected printer: {}", mPrinterSelection);
-
-        // FakePrinter doesn't need USB device attachment
-        if (mPrinterSelection == "FakePrinter" || mPrinterSelection == "fake") {
-            printer->attachUsbDevice(nullptr);
-        } else {
-            // Real printer needs USB device
-            const auto printerUsbId = printer->getUsbId();
-            auto devices            = mUsbDeviceFactory.findDevices(printerUsbId.first, printerUsbId.second);
-
-            if (devices.empty()) {
-                spdlog::error("No USB device found for printer {}. Is it connected and powered on?", mPrinterSelection);
-                return -1;
-            }
-
-            if (devices.size() > 1) {
-                spdlog::warn("Found more than one device of the same printer on bus. Using first one.");
-            }
-
-            if (!printer->attachUsbDevice(std::move(devices[0]))) {
-                spdlog::error("Failed to attach USB device to printer");
-                return -1;
-            }
-        }
-    } else {
-        // Auto-detect printer from USB devices
-        mDetectedPrinters     = getCompatiblePrinters();
-        auto numFoundPrinters = mDetectedPrinters.size();
-
-        if (numFoundPrinters == 0) {
-            spdlog::error("No compatible printers found, please make sure that they are turned on and connected");
-            spdlog::info("Tip: Use -p FakePrinter for testing without hardware");
-            return -1;
-        } else if (numFoundPrinters > 1) {
-            spdlog::warn("Found more than one compatible printer. Use -p to select explicitly.");
-            return -1;
-        }
-
-        printer                 = mDetectedPrinters[0];
-        const auto printerUsbId = printer->getUsbId();
-        auto devices            = mUsbDeviceFactory.findDevices(printerUsbId.first, printerUsbId.second);
-
-        if (devices.size() != 1) {
-            spdlog::warn("Found more than one device of the same printer on bus. Currently not supported");
-            return -1;
-        }
-
-        if (!printer->attachUsbDevice(std::move(devices[0]))) {
-            spdlog::error("Failed to attach USB device to printer");
-            return -1;
-        }
     }
 
+    // Get printer status
     auto status = printer->getPrinterStatus();
     spdlog::info("Detected tape width is {}mm", status.tapeWidthMm);
 
-    if (0 == mCommands.size()) {
+    // Check if there are any commands
+    if (options.commands.empty()) {
         spdlog::warn("No command specified, nothing to do...");
-        return 0;
+        return true;
     }
 
-    // Use LabelBuilder to construct the label
+    // Build label incrementally, appending when --new is encountered
     graphics::LabelBuilder labelBuilder(printer->getPrinterInfo().pixelLines);
+    std::unique_ptr<graphics::ILabel> finalLabel = nullptr;
 
-    for (const auto& [cmd, value] : mCommands) {
+    // Debug: print command sequence
-        switch (cmd) {
+    spdlog::debug("Processing {} commands:", options.commands.size());
-            case CliCmdType::Text:
+    for (size_t i = 0; i < options.commands.size(); ++i) {
+        const auto& [cmdType, value] = options.commands[i];
+        spdlog::debug("  Command {}: type={}, value='{}'", i, static_cast<int>(cmdType), value);
+    }
+
+    for (const auto& [cmdType, value] : options.commands) {
+        switch (cmdType) {
+            case cli::CommandType::NewLabel: {
+                // Finish current label and append to final label
+                spdlog::debug("Encountered --new, finishing current label segment");
+                auto currentLabel = labelBuilder.build();
+                if (!finalLabel) {
+                    // First label becomes the base
+                    finalLabel = std::move(currentLabel);
+                } else {
+                    // If finalLabel is empty (width=0), replace it instead of appending
+                    if (finalLabel->getWidth() == 0) {
+                        spdlog::debug("Final label is empty, replacing instead of appending");
+                        finalLabel = std::move(currentLabel);
+                    } else if (currentLabel->getWidth() == 0) {
+                        // Current label is empty, skip appending
+                        spdlog::debug("Current label is empty, skipping append");
+                    } else {
+                        // Both labels have content, append
+                        if (!finalLabel->append(*currentLabel)) {
+                            spdlog::error("Failed to append label");
+                            return false;
+                        }
+                    }
+                }
+                // Reset builder for next label
+                labelBuilder = graphics::LabelBuilder(printer->getPrinterInfo().pixelLines);
+                break;
+            }
+            case cli::CommandType::Text:
                 labelBuilder.addText(value);
                 break;
-            case CliCmdType::Font:
+            case cli::CommandType::Font:
                 spdlog::debug("Setting font to {}", value);
                 labelBuilder.setFontFamily(value);
                 break;
-            case CliCmdType::FontSize:
+            case cli::CommandType::FontSize:
                 spdlog::debug("Setting font size to {}", std::stod(value));
                 labelBuilder.setFontSize(std::stod(value));
                 break;
-            case CliCmdType::HAlign:
+            case cli::CommandType::HAlign: {
                 spdlog::debug("Setting text horizontal alignment to {}", value);
-                {
                 auto hPos = HALignPositionMap.find(value);
                 if (hPos == HALignPositionMap.end()) {
                     spdlog::warn("Invalid horizontal alignment specified!");
@@ -188,11 +192,10 @@ int PtouchPrint::run() {
                 } else {
                     labelBuilder.setHAlign(hPos->second);
                 }
-                }
                 break;
-            case CliCmdType::VAlign:
+            }
+            case cli::CommandType::VAlign: {
                 spdlog::debug("Setting text vertical alignment to {}", value);
-                {
                 auto vPos = VALignPositionMap.find(value);
                 if (vPos == VALignPositionMap.end()) {
                     spdlog::warn("Invalid vertical alignment specified!");
@@ -200,9 +203,9 @@ int PtouchPrint::run() {
                 } else {
                     labelBuilder.setVAlign(vPos->second);
                 }
-                }
                 break;
-            case CliCmdType::None:
+            }
+            case cli::CommandType::None:
                 [[fallthrough]];
             default:
                 spdlog::warn("This command is currently not supported.");
@@ -210,114 +213,36 @@ int PtouchPrint::run() {
         }
     }
 
-    auto label = labelBuilder.build();
+    // Build and append final label segment
-    if (!printer->printLabel(std::move(label))) {
+    auto lastLabel = labelBuilder.build();
-        spdlog::error("An error occured while printing");
+    if (!finalLabel) {
-        return -1;
+        // Only one label, no --new was used
-    }
+        finalLabel = std::move(lastLabel);
-
-    return 0;
-}
-
-std::vector<std::shared_ptr<IPrinterDriver>> PtouchPrint::getCompatiblePrinters() {
-
-    auto usbDevs       = mUsbDeviceFactory.findAllDevices();
-    auto driverFactory = std::make_unique<PrinterDriverFactory>();
-    std::vector<std::shared_ptr<IPrinterDriver>> foundPrinterDrivers{};
-
-    for (auto& usbDev : usbDevs) {
-        auto driver = driverFactory->create(usbDev->getUsbId());
-        if (driver != nullptr) {
-            foundPrinterDrivers.push_back(driver);
-        }
-    }
-    return foundPrinterDrivers;
-}
-
-void PtouchPrint::setupLogger(spdlog::level::level_enum lvl) {
-    auto consoleSink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-    consoleSink->set_level(lvl);
-    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");
+        // Handle empty labels
+        if (finalLabel->getWidth() == 0) {
+            // Final label is empty, replace it
+            spdlog::debug("Final label is empty, replacing with last segment");
+            finalLabel = std::move(lastLabel);
+        } else if (lastLabel->getWidth() == 0) {
+            // Last segment is empty, skip appending
+            spdlog::debug("Last label segment is empty, skipping append");
+        } else {
+            // Both have content, append
+            if (!finalLabel->append(*lastLabel)) {
+                spdlog::error("Failed to append final label segment");
+                return false;
+            }
+        }
     }
 
-    auto fileSink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("ptprnt.log", true);
+    // Print the final label
-    fileSink->set_level(spdlog::level::trace);
+    if (!mPrinterService->printLabel(std::move(finalLabel))) {
-    fileSink->set_pattern("%Y-%m-%d %H:%m:%S:%e [pid:%P tid:%t] [%^%l%$] %v (%@)");
+        spdlog::error("An error occurred while printing");
-    std::vector<spdlog::sink_ptr> sinks{consoleSink, fileSink};
+        return false;
-    auto logger = std::make_shared<spdlog::logger>("default_logger", sinks.begin(), sinks.end());
-    logger->set_level(spdlog::level::trace);
-    spdlog::set_default_logger(logger);
     }
 
-// TODO: CLI parsing should be a seperate class/file
+    return true;
-void PtouchPrint::setupCliParser() {
-    auto printVersion = [this](std::size_t) {
-        fmt::print("ptprnt version: {}\n", mVersionString);
-    };
-
-    // General options
-    mApp.add_flag("-v,--verbose", mVerboseFlag, "Enable verbose output");
-    mApp.add_flag("--trace", mTraceFlag, "Enable trace output (shows USB communication)");
-    mApp.add_flag("-V,--version", printVersion, "Prints the ptprnt's version");
-
-    // Printer selection
-    mApp.add_option("-p,--printer", mPrinterSelection,
-                    "Select printer driver (default: auto). Use --list-all-drivers to see available options")
-        ->default_val("auto");
-
-    mApp.add_flag("--list-all-drivers", mListDriversFlag, "List all available printer drivers and exit");
-
-    // Text printing options
-    mApp.add_option("-t,--text",
-                    "Text to print (can be used multple times, use formatting options before to "
-                    "influence text layout)")
-        ->group("Printing")
-        ->multi_option_policy(CLI::MultiOptionPolicy::TakeAll)
-        ->trigger_on_parse()
-        ->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::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::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::TakeFirst)
-        ->trigger_on_parse()
-        ->transform([](std::string in) -> std::string {
-            std::unordered_set<std::string> validValignOptions{"top", "middle", "bottom"};
-            std::ranges::transform(in, 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::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 ")->group("Image printing");
-}
 }  // namespace ptprnt

src/PtouchPrint.hpp

@@ -19,49 +19,80 @@
 
 #pragma once
 
-#include <CLI/CLI.hpp>
+#include <memory>
-#include <spdlog/common.h>
+#include <string>
-#include <spdlog/spdlog.h>
+#include <vector>
 
-#include "constants.hpp"
+namespace ptprnt::cli {
-#include "interface/IPrinterDriver.hpp"
+class ICliParser;
-#include "libusbwrap/UsbDeviceFactory.hpp"
+}
+
+namespace ptprnt::core {
+class IPrinterService;
+}
+
+namespace ptprnt::graphics {
+class ILabel;
+}
 
 namespace ptprnt {
-enum class CliCmdType { None = 0, Text = 1, FontSize = 2, Font = 3, VAlign = 4, HAlign = 5 };
-using CliCmd = std::pair<CliCmdType, std::string>;
 
+/**
+ * @brief Main application class for ptprnt
+ *
+ * Acts as a thin glue layer coordinating CLI parsing and core printer functionality.
+ * Separates CLI frontend concerns from the core library.
+ *
+ * Uses interfaces (ICliParser, IPrinterService) to enable dependency injection
+ * and facilitate unit testing with mocks.
+ */
 class PtouchPrint {
    public:
+    /**
+     * @brief Construct the application with default implementations
+     * @param versionString Version string to display
+     */
     PtouchPrint(const char* versionString);
-    ~PtouchPrint() = default;
 
-    // This is basically a singelton application class, no need to copy or move
+    /**
+     * @brief Construct with custom implementations (for testing)
+     * @param versionString Version string to display
+     * @param cliParser Custom CLI parser implementation
+     * @param printerService Custom printer service implementation
+     */
+    PtouchPrint(const char* versionString, std::unique_ptr<cli::ICliParser> cliParser,
+                std::unique_ptr<core::IPrinterService> printerService);
+
+    ~PtouchPrint();  // Must be defined in .cpp where complete types are visible
+
+    // This is basically a singleton application class, no need to copy or move
     PtouchPrint(const PtouchPrint&)            = delete;
     PtouchPrint& operator=(const PtouchPrint&) = delete;
     PtouchPrint(PtouchPrint&&)                 = delete;
     PtouchPrint& operator=(PtouchPrint&&)      = delete;
 
+    /**
+     * @brief Initialize the application
+     * @param argc Argument count
+     * @param argv Argument values
+     * @return 0 on success, non-zero on error
+     */
     int init(int argc, char** argv);
+
+    /**
+     * @brief Run the application
+     * @return 0 on success, non-zero on error
+     */
     int run();
 
    private:
-    // methods
+    void setupLogger();
-    void setupLogger(spdlog::level::level_enum lvl);
+    bool handleListDrivers();
-    void setupCliParser();
+    bool handlePrinting();
-    std::vector<std::shared_ptr<IPrinterDriver>> getCompatiblePrinters();
 
-    // member variables
+    std::string mVersionString;
-    CLI::App mApp{ptprnt::APP_DESC};
+    std::unique_ptr<cli::ICliParser> mCliParser;
-    libusbwrap::UsbDeviceFactory mUsbDeviceFactory{};
+    std::unique_ptr<core::IPrinterService> mPrinterService;
-    std::vector<std::shared_ptr<IPrinterDriver>> mDetectedPrinters{};
-    std::vector<CliCmd> mCommands{};
-    std::string mVersionString = "";
-
-    // CLI flags and options
-    bool mVerboseFlag = false;
-    bool mTraceFlag = false;
-    std::string mPrinterSelection = "auto";
-    bool mListDriversFlag = false;
 };
+
 }  // namespace ptprnt

src/cli/CliParser.cpp

@@ -0,0 +1,143 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  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 "CliParser.hpp"
+
+#include <fmt/core.h>
+
+namespace ptprnt::cli {
+
+CliParser::CliParser(std::string appDescription, std::string versionString)
+    : mApp(std::move(appDescription)), mVersionString(std::move(versionString)) {
+    setupParser();
+}
+
+int CliParser::parse(int argc, char** argv) {
+    try {
+        mApp.parse(argc, argv);
+    } catch (const CLI::CallForHelp& e) {
+        // User requested help - display it and signal clean exit
+        mApp.exit(e);
+        return 1;  // Signal: exit cleanly
+    } catch (const CLI::CallForVersion&) {
+        // User requested version - already displayed by callback
+        return 1;  // Signal: exit cleanly
+    } catch (const CLI::ParseError& e) {
+        // Parse error - display error message
+        mApp.exit(e);
+        return -1;  // Signal: error
+    }
+
+    // Post-process: Re-order commands based on actual command line order
+    // This is needed because CLI11 groups options by type
+    reorderCommandsByArgv(argc, argv);
+
+    return 0;
+}
+
+void CliParser::reorderCommandsByArgv(int argc, char** argv) {
+    std::vector<Command> reorderedCommands;
+
+    // Parse argv to determine the actual order
+    for (int i = 1; i < argc; ++i) {
+        std::string arg = argv[i];
+
+        if (arg == "--new") {
+            reorderedCommands.emplace_back(CommandType::NewLabel, "");
+        } else if (arg == "-t" || arg == "--text") {
+            if (i + 1 < argc) {
+                reorderedCommands.emplace_back(CommandType::Text, argv[++i]);
+            }
+        } else if (arg == "-f" || arg == "--font") {
+            if (i + 1 < argc) {
+                reorderedCommands.emplace_back(CommandType::Font, argv[++i]);
+            }
+        } else if (arg == "-s" || arg == "--fontsize") {
+            if (i + 1 < argc) {
+                reorderedCommands.emplace_back(CommandType::FontSize, argv[++i]);
+            }
+        } else if (arg == "--valign") {
+            if (i + 1 < argc) {
+                reorderedCommands.emplace_back(CommandType::VAlign, argv[++i]);
+            }
+        } else if (arg == "--halign") {
+            if (i + 1 < argc) {
+                reorderedCommands.emplace_back(CommandType::HAlign, argv[++i]);
+            }
+        }
+    }
+
+    // Only replace if we found relevant commands
+    if (!reorderedCommands.empty()) {
+        mOptions.commands = std::move(reorderedCommands);
+    }
+}
+
+void CliParser::setupParser() {
+    // Version callback
+    auto printVersion = [this](std::size_t) {
+        fmt::print("ptprnt version: {}\n", mVersionString);
+        throw CLI::CallForVersion();
+    };
+
+    // General options
+    mApp.add_flag("-v,--verbose", mOptions.verbose, "Enable verbose output");
+    mApp.add_flag("--trace", mOptions.trace, "Enable trace output (shows USB communication)");
+    mApp.add_flag("-V,--version", printVersion, "Prints the ptprnt's version");
+
+    // Printer selection
+    mApp.add_option("-p,--printer", mOptions.printerSelection,
+                    "Select printer driver (default: auto). Use --list-all-drivers to see available options")
+        ->default_val("auto");
+
+    mApp.add_flag("--list-all-drivers", mOptions.listDrivers, "List all available printer drivers and exit");
+
+    // Text printing options
+    // Note: CLI11 options are processed in order when using ->each() with callbacks
+    mApp.add_option(
+            "-t,--text",
+            "Text to print (can be used multiple times, use formatting options before to influence text layout)")
+        ->multi_option_policy(CLI::MultiOptionPolicy::TakeAll)
+        ->each([this](const std::string& text) { mOptions.commands.emplace_back(CommandType::Text, text); });
+
+    // Text formatting options
+    mApp.add_option("-f,--font", "Font used for the following text occurrences")
+        ->multi_option_policy(CLI::MultiOptionPolicy::TakeAll)
+        ->each([this](const std::string& font) { mOptions.commands.emplace_back(CommandType::Font, font); });
+
+    mApp.add_option("-s,--fontsize", "Font size of the following text occurrences")
+        ->multi_option_policy(CLI::MultiOptionPolicy::TakeAll)
+        ->each([this](const std::string& size) { mOptions.commands.emplace_back(CommandType::FontSize, size); });
+
+    mApp.add_option("--valign", "Vertical alignment of the following text occurrences")
+        ->multi_option_policy(CLI::MultiOptionPolicy::TakeAll)
+        ->each([this](const std::string& align) { mOptions.commands.emplace_back(CommandType::VAlign, align); });
+
+    mApp.add_option("--halign", "Horizontal alignment of the following text occurrences")
+        ->multi_option_policy(CLI::MultiOptionPolicy::TakeAll)
+        ->each([this](const std::string& align) { mOptions.commands.emplace_back(CommandType::HAlign, align); });
+
+    // Label separator - use an option with multi_option_policy to maintain parse order
+    // We need to use a dummy string parameter since .each() expects a string callback
+    mApp.add_flag("--new", "Start a new label (multiple labels will be stitched together)")
+        ->multi_option_policy(CLI::MultiOptionPolicy::TakeAll)
+        ->each([this](const std::string&) { mOptions.commands.emplace_back(CommandType::NewLabel, ""); });
+}
+
+}  // namespace ptprnt::cli

src/cli/CliParser.hpp

@@ -0,0 +1,76 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  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 <CLI/CLI.hpp>
+
+#include <string>
+
+#include "interface/ICliParser.hpp"
+
+namespace ptprnt::cli {
+
+/**
+ * @brief CLI argument parser for ptprnt
+ *
+ * Concrete implementation of ICliParser using CLI11.
+ * Handles all command-line argument parsing.
+ * Separates CLI concerns from core library functionality.
+ */
+class CliParser : public ICliParser {
+   public:
+    /**
+     * @brief Construct a CLI parser
+     * @param appDescription Application description for help text
+     * @param versionString Version string to display
+     */
+    CliParser(std::string appDescription, std::string versionString);
+
+    ~CliParser() override = default;
+
+    CliParser(const CliParser&)            = delete;
+    CliParser& operator=(const CliParser&) = delete;
+    CliParser(CliParser&&)                 = delete;
+    CliParser& operator=(CliParser&&)      = delete;
+
+    /**
+     * @brief Parse command line arguments
+     * @param argc Argument count
+     * @param argv Argument values
+     * @return 0 on success, positive value if should exit immediately (help/version), negative on error
+     */
+    int parse(int argc, char** argv) override;
+
+    /**
+     * @brief Get the parsed options
+     * @return Reference to parsed options
+     */
+    [[nodiscard]] const CliOptions& getOptions() const override { return mOptions; }
+
+   private:
+    void setupParser();
+    void reorderCommandsByArgv(int argc, char** argv);
+
+    CLI::App mApp;
+    std::string mVersionString;
+    CliOptions mOptions;
+};
+
+}  // namespace ptprnt::cli

src/cli/interface/ICliParser.hpp

@@ -0,0 +1,79 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  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 <string>
+#include <vector>
+
+namespace ptprnt::cli {
+
+/**
+ * @brief Types of CLI commands that can be issued
+ */
+enum class CommandType { None = 0, Text = 1, FontSize = 2, Font = 3, VAlign = 4, HAlign = 5, NewLabel = 6 };
+
+/**
+ * @brief A command with its type and value
+ */
+using Command = std::pair<CommandType, std::string>;
+
+/**
+ * @brief Parsed CLI options and commands
+ */
+struct CliOptions {
+    bool verbose{false};
+    bool trace{false};
+    bool listDrivers{false};
+    std::string printerSelection{"auto"};
+    std::vector<Command> commands{};
+};
+
+/**
+ * @brief Interface for CLI argument parsing
+ *
+ * This interface allows for mocking CLI parsing in unit tests
+ * and provides a clear contract for CLI parser implementations.
+ */
+class ICliParser {
+   public:
+    virtual ~ICliParser() = default;
+
+    ICliParser()                                   = default;
+    ICliParser(const ICliParser&)                  = default;
+    ICliParser& operator=(const ICliParser&)       = default;
+    ICliParser(ICliParser&&) noexcept              = default;
+    ICliParser& operator=(ICliParser&&) noexcept   = default;
+
+    /**
+     * @brief Parse command line arguments
+     * @param argc Argument count
+     * @param argv Argument values
+     * @return 0 on success, positive value if should exit immediately (help/version), negative on error
+     */
+    virtual int parse(int argc, char** argv) = 0;
+
+    /**
+     * @brief Get the parsed options
+     * @return Reference to parsed options
+     */
+    [[nodiscard]] virtual const CliOptions& getOptions() const = 0;
+};
+
+}  // namespace ptprnt::cli

src/core/PrinterDriverFactory.cpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2024-2025  Moritz Martinius
+    Copyright (C) 2025  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

src/core/PrinterDriverFactory.hpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2024-2025  Moritz Martinius
+    Copyright (C) 2025  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
@@ -21,7 +21,7 @@
 #include <string>
 #include <vector>
 
-#include "interface/IPrinterDriver.hpp"
+#include "printers/interface/IPrinterDriver.hpp"
 #include "libusbwrap/LibUsbTypes.hpp"
 
 namespace ptprnt {

src/core/PrinterService.cpp

@@ -0,0 +1,106 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  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 "PrinterService.hpp"
+
+#include <spdlog/spdlog.h>
+
+#include "core/PrinterDriverFactory.hpp"
+
+namespace ptprnt::core {
+
+PrinterService::PrinterService() = default;
+
+bool PrinterService::initialize() {
+    if (!mUsbDeviceFactory.init()) {
+        spdlog::error("Could not initialize libusb");
+        return false;
+    }
+    return true;
+}
+
+std::vector<std::shared_ptr<IPrinterDriver>> PrinterService::detectPrinters() {
+    spdlog::debug("Detecting printers...");
+
+    auto usbDevs       = mUsbDeviceFactory.findAllDevices();
+    auto driverFactory = std::make_unique<PrinterDriverFactory>();
+    mDetectedPrinters.clear();
+
+    for (auto& usbDev : usbDevs) {
+        auto driver = driverFactory->create(usbDev->getUsbId());
+        if (driver != nullptr) {
+            // Attach the USB device to the printer driver
+            // Convert unique_ptr to shared_ptr for attachment
+            std::shared_ptr<libusbwrap::IUsbDevice> sharedUsbDev = std::move(usbDev);
+            if (driver->attachUsbDevice(sharedUsbDev)) {
+                mDetectedPrinters.push_back(driver);
+                spdlog::debug("Successfully attached USB device to printer driver: {}", driver->getName());
+            } else {
+                spdlog::warn("Failed to attach USB device to printer driver: {}", driver->getName());
+            }
+        }
+    }
+
+    spdlog::debug("Found {} compatible printer(s)", mDetectedPrinters.size());
+    return mDetectedPrinters;
+}
+
+std::shared_ptr<IPrinterDriver> PrinterService::selectPrinter(const std::string& printerName) {
+    // If a specific printer is requested by name (not "auto"), try to create it directly
+    if (printerName != "auto") {
+        auto driverFactory = std::make_unique<PrinterDriverFactory>();
+        auto printer       = driverFactory->createByName(printerName);
+        if (printer) {
+            // For virtual/fake printers, call attachUsbDevice with nullptr to initialize
+            // For real printers selected explicitly, they would need actual USB device
+            printer->attachUsbDevice(nullptr);
+            mCurrentPrinter = printer;
+            spdlog::info("Using explicitly selected printer: {}", printerName);
+            return mCurrentPrinter;
+        }
+        spdlog::error("Printer driver '{}' not found", printerName);
+        return nullptr;
+    }
+
+    // Auto mode: detect USB printers
+    if (mDetectedPrinters.empty()) {
+        detectPrinters();
+    }
+
+    if (mDetectedPrinters.empty()) {
+        spdlog::error("No compatible printers detected");
+        return nullptr;
+    }
+
+    // Auto-select first detected printer
+    mCurrentPrinter = mDetectedPrinters.front();
+    spdlog::info("Auto-selected printer: {}", mCurrentPrinter->getName());
+    return mCurrentPrinter;
+}
+
+bool PrinterService::printLabel(std::unique_ptr<graphics::ILabel> label) {
+    if (!mCurrentPrinter) {
+        spdlog::error("No printer selected");
+        return false;
+    }
+
+    return mCurrentPrinter->printLabel(std::move(label));
+}
+
+}  // namespace ptprnt::core

src/core/PrinterService.hpp

@@ -0,0 +1,89 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  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 <memory>
+#include <string>
+#include <vector>
+
+#include "interface/IPrinterService.hpp"
+#include "libusbwrap/UsbDeviceFactory.hpp"
+#include "printers/interface/IPrinterDriver.hpp"
+
+namespace ptprnt::core {
+
+/**
+ * @brief Core service for printer operations
+ *
+ * Concrete implementation of IPrinterService.
+ * Provides the core library functionality for:
+ * - Detecting printers
+ * - Selecting printers
+ * - Building and printing labels
+ */
+class PrinterService : public IPrinterService {
+   public:
+    PrinterService();
+    ~PrinterService() override = default;
+
+    PrinterService(const PrinterService&)            = delete;
+    PrinterService& operator=(const PrinterService&) = delete;
+    PrinterService(PrinterService&&)                 = delete;
+    PrinterService& operator=(PrinterService&&)      = delete;
+
+    /**
+     * @brief Initialize USB device factory
+     * @return true on success, false on failure
+     */
+    bool initialize() override;
+
+    /**
+     * @brief Detect all compatible printers
+     * @return Vector of detected printers
+     */
+    std::vector<std::shared_ptr<IPrinterDriver>> detectPrinters() override;
+
+    /**
+     * @brief Select a printer by name or auto-detect
+     * @param printerName Printer driver name, or "auto" for first detected
+     * @return Printer driver, or nullptr if not found
+     */
+    std::shared_ptr<IPrinterDriver> selectPrinter(const std::string& printerName) override;
+
+    /**
+     * @brief Get the currently selected printer
+     * @return Current printer, or nullptr if none selected
+     */
+    [[nodiscard]] std::shared_ptr<IPrinterDriver> getCurrentPrinter() const override { return mCurrentPrinter; }
+
+    /**
+     * @brief Print a label
+     * @param label The label to print
+     * @return true on success, false on failure
+     */
+    bool printLabel(std::unique_ptr<graphics::ILabel> label) override;
+
+   private:
+    libusbwrap::UsbDeviceFactory mUsbDeviceFactory;
+    std::vector<std::shared_ptr<IPrinterDriver>> mDetectedPrinters;
+    std::shared_ptr<IPrinterDriver> mCurrentPrinter;
+};
+
+}  // namespace ptprnt::core

src/core/interface/IPrinterService.hpp

@@ -0,0 +1,74 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  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 <memory>
+#include <string>
+#include <vector>
+
+#include "graphics/interface/ILabel.hpp"
+#include "printers/interface/IPrinterDriver.hpp"
+
+namespace ptprnt::core {
+
+/**
+ * @brief Interface for core printer service operations
+ *
+ * This interface allows for mocking printer operations in unit tests
+ * and provides a clear contract for printer service implementations.
+ */
+class IPrinterService {
+   public:
+    virtual ~IPrinterService() = default;
+
+    /**
+     * @brief Initialize the printer service
+     * @return true on success, false on failure
+     */
+    virtual bool initialize() = 0;
+
+    /**
+     * @brief Detect all compatible printers
+     * @return Vector of detected printers
+     */
+    virtual std::vector<std::shared_ptr<IPrinterDriver>> detectPrinters() = 0;
+
+    /**
+     * @brief Select a printer by name or auto-detect
+     * @param printerName Printer driver name, or "auto" for first detected
+     * @return Printer driver, or nullptr if not found
+     */
+    virtual std::shared_ptr<IPrinterDriver> selectPrinter(const std::string& printerName) = 0;
+
+    /**
+     * @brief Get the currently selected printer
+     * @return Current printer, or nullptr if none selected
+     */
+    [[nodiscard]] virtual std::shared_ptr<IPrinterDriver> getCurrentPrinter() const = 0;
+
+    /**
+     * @brief Print a label
+     * @param label The label to print
+     * @return true on success, false on failure
+     */
+    virtual bool printLabel(std::unique_ptr<graphics::ILabel> label) = 0;
+};
+
+}  // namespace ptprnt::core

src/graphics/Bitmap.hpp

@@ -20,8 +20,6 @@
 #pragma once
 
 #include <cstdint>
-#include <memory>
-#include <span>
 #include <vector>
 
 namespace ptprnt::graphics {

src/graphics/CairoWrapper.hpp

@@ -0,0 +1,139 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  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 "graphics/interface/ICairoWrapper.hpp"
+
+namespace ptprnt::graphics {
+
+/**
+ * @brief Real implementation of ICairoWrapper that forwards to actual Cairo/Pango C API
+ *
+ * This class simply forwards all calls to the real Cairo and Pango library functions.
+ * It's used as the default implementation in production code.
+ */
+class CairoWrapper : public ICairoWrapper {
+   public:
+    ~CairoWrapper() override = default;
+
+    // Cairo image surface functions
+    cairo_surface_t* cairo_image_surface_create(cairo_format_t format, int width, int height) override {
+        return ::cairo_image_surface_create(format, width, height);
+    }
+
+    void cairo_surface_destroy(cairo_surface_t* surface) override { ::cairo_surface_destroy(surface); }
+
+    void cairo_surface_flush(cairo_surface_t* surface) override { ::cairo_surface_flush(surface); }
+
+    void cairo_surface_mark_dirty(cairo_surface_t* surface) override { ::cairo_surface_mark_dirty(surface); }
+
+    cairo_status_t cairo_surface_status(cairo_surface_t* surface) override { return ::cairo_surface_status(surface); }
+
+    cairo_format_t cairo_image_surface_get_format(cairo_surface_t* surface) override {
+        return ::cairo_image_surface_get_format(surface);
+    }
+
+    int cairo_image_surface_get_width(cairo_surface_t* surface) override {
+        return ::cairo_image_surface_get_width(surface);
+    }
+
+    int cairo_image_surface_get_height(cairo_surface_t* surface) override {
+        return ::cairo_image_surface_get_height(surface);
+    }
+
+    int cairo_image_surface_get_stride(cairo_surface_t* surface) override {
+        return ::cairo_image_surface_get_stride(surface);
+    }
+
+    unsigned char* cairo_image_surface_get_data(cairo_surface_t* surface) override {
+        return ::cairo_image_surface_get_data(surface);
+    }
+
+    cairo_status_t cairo_surface_write_to_png(cairo_surface_t* surface, const char* filename) override {
+        return ::cairo_surface_write_to_png(surface, filename);
+    }
+
+    // Cairo context functions
+    cairo_t* cairo_create(cairo_surface_t* surface) override { return ::cairo_create(surface); }
+
+    void cairo_destroy(cairo_t* cr) override { ::cairo_destroy(cr); }
+
+    void cairo_move_to(cairo_t* cr, double x, double y) override { ::cairo_move_to(cr, x, y); }
+
+    void cairo_set_source_rgb(cairo_t* cr, double red, double green, double blue) override {
+        ::cairo_set_source_rgb(cr, red, green, blue);
+    }
+
+    // Pango-Cairo functions
+    PangoFontMap* pango_cairo_font_map_new() override { return ::pango_cairo_font_map_new(); }
+
+    PangoContext* pango_cairo_create_context(cairo_t* cr) override { return ::pango_cairo_create_context(cr); }
+
+    void pango_cairo_show_layout(cairo_t* cr, PangoLayout* layout) override { ::pango_cairo_show_layout(cr, layout); }
+
+    // Pango layout functions
+    PangoLayout* pango_layout_new(PangoContext* context) override { return ::pango_layout_new(context); }
+
+    void pango_layout_set_font_description(PangoLayout* layout, const PangoFontDescription* desc) override {
+        ::pango_layout_set_font_description(layout, desc);
+    }
+
+    void pango_layout_set_text(PangoLayout* layout, const char* text, int length) override {
+        ::pango_layout_set_text(layout, text, length);
+    }
+
+    void pango_layout_set_height(PangoLayout* layout, int height) override {
+        ::pango_layout_set_height(layout, height);
+    }
+
+    void pango_layout_set_alignment(PangoLayout* layout, PangoAlignment alignment) override {
+        ::pango_layout_set_alignment(layout, alignment);
+    }
+
+    void pango_layout_set_justify(PangoLayout* layout, gboolean justify) override {
+        ::pango_layout_set_justify(layout, justify);
+    }
+
+#if PANGO_VERSION_MAJOR >= 1 && PANGO_VERSION_MINOR >= 50
+    void pango_layout_set_justify_last_line(PangoLayout* layout, gboolean justify) override {
+        ::pango_layout_set_justify_last_line(layout, justify);
+    }
+#endif
+
+    void pango_layout_get_size(PangoLayout* layout, int* width, int* height) override {
+        ::pango_layout_get_size(layout, width, height);
+    }
+
+    // Pango font description functions
+    PangoFontDescription* pango_font_description_new() override { return ::pango_font_description_new(); }
+
+    void pango_font_description_set_size(PangoFontDescription* desc, gint size) override {
+        ::pango_font_description_set_size(desc, size);
+    }
+
+    void pango_font_description_set_family(PangoFontDescription* desc, const char* family) override {
+        ::pango_font_description_set_family(desc, family);
+    }
+
+    // GObject reference counting
+    void g_object_unref(gpointer object) override { ::g_object_unref(object); }
+};
+
+}  // namespace ptprnt::graphics

src/graphics/Label.cpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2023-2025  Moritz Martinius
+    Copyright (C) 2025  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
@@ -25,37 +25,63 @@
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "cairo.h"
+#include "graphics/CairoWrapper.hpp"
+#include "graphics/interface/ICairoWrapper.hpp"
 #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)
+
-    : mPrinterHeight(heightPixel) {
+// Deleter implementations
-    // Initialize resources in correct order with RAII
+void CairoSurfaceDeleter::operator()(cairo_surface_t* surface) const {
-    mFontMap.reset(pango_cairo_font_map_new());
+    if (surface && wrapper)
+        wrapper->cairo_surface_destroy(surface);
 }
 
-std::vector<uint8_t> Label::getRaw() {
+void CairoDeleter::operator()(cairo_t* cr) const {
+    if (cr && wrapper)
+        wrapper->cairo_destroy(cr);
+}
+
+void GObjectDeleter::operator()(gpointer obj) const {
+    if (obj && wrapper)
+        wrapper->g_object_unref(obj);
+}
+
+// Default constructor - creates real Cairo/Pango wrapper
+Label::Label(const uint16_t heightPixel) : Label(heightPixel, std::make_shared<CairoWrapper>()) {}
+
+// Constructor with dependency injection
+Label::Label(const uint16_t heightPixel, std::shared_ptr<ICairoWrapper> cairoWrapper)
+    : mCairoWrapper(std::move(cairoWrapper)), mPrinterHeight(heightPixel) {
+    // Initialize resources in correct order with RAII
+    // Pass wrapper to deleter so cleanup uses the wrapper
+    GObjectDeleter deleter;
+    deleter.wrapper = mCairoWrapper;
+    mFontMap        = std::unique_ptr<PangoFontMap, GObjectDeleter>(mCairoWrapper->pango_cairo_font_map_new(), deleter);
+}
+
+std::vector<uint8_t> Label::getRaw() const {
     assert(mSurface != nullptr);
     auto* surface = mSurface.get();
 
-    cairo_surface_flush(surface);
+    mCairoWrapper->cairo_surface_flush(surface);
-    assert(cairo_image_surface_get_format(surface) == CAIRO_FORMAT_A8);
+    assert(mCairoWrapper->cairo_image_surface_get_format(surface) == CAIRO_FORMAT_A8);
 
-    int width = cairo_image_surface_get_width(surface);
+    int width  = mCairoWrapper->cairo_image_surface_get_width(surface);
-    int height = cairo_image_surface_get_height(surface);
+    int height = mCairoWrapper->cairo_image_surface_get_height(surface);
-    int stride = cairo_image_surface_get_stride(surface);
+    int stride = mCairoWrapper->cairo_image_surface_get_stride(surface);
 
     spdlog::debug("Cairo Surface data: W: {}; H: {}; S:{}", width, height, stride);
 
-    auto data = cairo_image_surface_get_data(surface);
+    auto data = mCairoWrapper->cairo_image_surface_get_data(surface);
 
     // If stride equals width, we can return data directly
     if (stride == width) {
@@ -80,41 +106,41 @@ uint8_t Label::getNumLines(std::string_view strv) {
     return std::count(strv.begin(), strv.end(), '\n');
 }
 
-int Label::getWidth() {
+int Label::getWidth() const {
     // Return the actual Cairo surface width (which is the layout width)
     return mLayoutWidth;
 }
 
-int Label::getHeight() {
+int Label::getHeight() const {
     // Return the actual Cairo surface height (which is the printer height)
     return mPrinterHeight;
 }
 
 void Label::configureLayout(PangoLayout* layout, const std::string& text, PangoFontDescription* fontDesc) {
-    pango_layout_set_font_description(layout, fontDesc);
+    mCairoWrapper->pango_layout_set_font_description(layout, fontDesc);
-    pango_layout_set_text(layout, text.c_str(), static_cast<int>(text.length()));
+    mCairoWrapper->pango_layout_set_text(layout, text.c_str(), static_cast<int>(text.length()));
-    pango_layout_set_height(layout, getNumLines(text) * -1);
+    mCairoWrapper->pango_layout_set_height(layout, getNumLines(text) * -1);
 }
 
 void Label::applyHorizontalAlignment(PangoLayout* layout) {
     switch (mHAlign) {
         case HAlignPosition::LEFT:
-            pango_layout_set_alignment(layout, PANGO_ALIGN_LEFT);
+            mCairoWrapper->pango_layout_set_alignment(layout, PANGO_ALIGN_LEFT);
             break;
         case HAlignPosition::RIGHT:
-            pango_layout_set_alignment(layout, PANGO_ALIGN_RIGHT);
+            mCairoWrapper->pango_layout_set_alignment(layout, PANGO_ALIGN_RIGHT);
             break;
         case HAlignPosition::JUSTIFY:
-            pango_layout_set_alignment(layout, PANGO_ALIGN_LEFT);
+            mCairoWrapper->pango_layout_set_alignment(layout, PANGO_ALIGN_LEFT);
-            pango_layout_set_justify(layout, true);
+            mCairoWrapper->pango_layout_set_justify(layout, true);
 #if PANGO_VERSION_MAJOR >= 1 && PANGO_VERSION_MINOR >= 50
-            pango_layout_set_justify_last_line(layout, true);
+            mCairoWrapper->pango_layout_set_justify_last_line(layout, true);
 #endif
             break;
         case HAlignPosition::CENTER:
             [[fallthrough]];
         default:
-            pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
+            mCairoWrapper->pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
             break;
     }
 }
@@ -133,40 +159,49 @@ bool Label::create(const std::string& labelText) {
     // see: https://gist.github.com/CallumDev/7c66b3f9cf7a876ef75f
 
     // Create a temporary surface for layout size calculations
-    auto* tempSurface = cairo_image_surface_create(CAIRO_FORMAT_A8, 1, 1);
+    auto* tempSurface  = mCairoWrapper->cairo_image_surface_create(CAIRO_FORMAT_A8, 1, 1);
-    auto* tempCr = cairo_create(tempSurface);
+    auto* tempCr       = mCairoWrapper->cairo_create(tempSurface);
-    auto* tempPangoCtx = pango_cairo_create_context(tempCr);
+    auto* tempPangoCtx = mCairoWrapper->pango_cairo_create_context(tempCr);
-    auto* tempPangoLyt = pango_layout_new(tempPangoCtx);
+    auto* tempPangoLyt = mCairoWrapper->pango_layout_new(tempPangoCtx);
 
-    PangoFontDescription* regularFont = pango_font_description_new();
+    PangoFontDescription* regularFont = mCairoWrapper->pango_font_description_new();
-    pango_font_description_set_size(regularFont, static_cast<int>(mFontSize * PANGO_SCALE));
+    mCairoWrapper->pango_font_description_set_size(regularFont, static_cast<int>(mFontSize * PANGO_SCALE));
-    pango_font_description_set_family(regularFont, mFontFamily.c_str());
+    mCairoWrapper->pango_font_description_set_family(regularFont, mFontFamily.c_str());
 
     // Configure temporary layout for size calculation
     configureLayout(tempPangoLyt, labelText, regularFont);
     applyHorizontalAlignment(tempPangoLyt);
 
     // Calculate label size from temporary layout
-    pango_layout_get_size(tempPangoLyt, &mLayoutWidth, &mLayoutHeight);
+    mCairoWrapper->pango_layout_get_size(tempPangoLyt, &mLayoutWidth, &mLayoutHeight);
     mLayoutWidth /= PANGO_SCALE;
     mLayoutHeight /= PANGO_SCALE;
 
     spdlog::debug("Layout width: {}, height: {}", mLayoutWidth, mLayoutHeight);
-    //auto alignedWidth = mLayoutWidth + (8 - (mLayoutWidth % 8));
-    //spdlog::debug("Aligned Layout width: {}, height: {}", alignedWidth, mLayoutHeight);
 
     // Clean up temporary resources
-    g_object_unref(tempPangoLyt);
+    mCairoWrapper->g_object_unref(tempPangoLyt);
-    g_object_unref(tempPangoCtx);
+    mCairoWrapper->g_object_unref(tempPangoCtx);
-    cairo_destroy(tempCr);
+    mCairoWrapper->cairo_destroy(tempCr);
-    cairo_surface_destroy(tempSurface);
+    mCairoWrapper->cairo_surface_destroy(tempSurface);
 
     // Now create the final surface and Pango context for actual rendering
-    mSurface.reset(cairo_image_surface_create(CAIRO_FORMAT_A8, mLayoutWidth, mPrinterHeight));
+    // Create deleters with wrapper reference
-    cairo_t* cr = cairo_create(mSurface.get());
+    CairoSurfaceDeleter surfaceDeleter;
-    mCairoCtx.reset(cr);
+    surfaceDeleter.wrapper = mCairoWrapper;
-    mPangoCtx.reset(pango_cairo_create_context(cr));
+    CairoDeleter cairoDeleter;
-    mPangoLyt.reset(pango_layout_new(mPangoCtx.get()));
+    cairoDeleter.wrapper = mCairoWrapper;
+    GObjectDeleter gobjectDeleter;
+    gobjectDeleter.wrapper = mCairoWrapper;
+
+    mSurface = std::unique_ptr<cairo_surface_t, CairoSurfaceDeleter>(
+        mCairoWrapper->cairo_image_surface_create(CAIRO_FORMAT_A8, mLayoutWidth, mPrinterHeight), surfaceDeleter);
+    cairo_t* cr = mCairoWrapper->cairo_create(mSurface.get());
+    mCairoCtx   = std::unique_ptr<cairo_t, CairoDeleter>(cr, cairoDeleter);
+    mPangoCtx =
+        std::unique_ptr<PangoContext, GObjectDeleter>(mCairoWrapper->pango_cairo_create_context(cr), gobjectDeleter);
+    mPangoLyt =
+        std::unique_ptr<PangoLayout, GObjectDeleter>(mCairoWrapper->pango_layout_new(mPangoCtx.get()), gobjectDeleter);
 
     // Configure final layout with same settings
     configureLayout(mPangoLyt.get(), labelText, regularFont);
@@ -177,31 +212,104 @@ bool Label::create(const std::string& labelText) {
         case VAlignPosition::TOP:
             break;
         case VAlignPosition::BOTTOM:
-            cairo_move_to(mCairoCtx.get(), 0.0, mPrinterHeight - mLayoutHeight);
+            mCairoWrapper->cairo_move_to(mCairoCtx.get(), 0.0, mPrinterHeight - mLayoutHeight);
             break;
         case VAlignPosition::MIDDLE:
-            cairo_move_to(mCairoCtx.get(), 0.0, (mPrinterHeight - mLayoutHeight) / 2);
+            mCairoWrapper->cairo_move_to(mCairoCtx.get(), 0.0, (mPrinterHeight - mLayoutHeight) / 2);
             break;
         default:
             break;
     }
 
     // Finally show the layout on the Cairo surface
-    pango_cairo_show_layout(mCairoCtx.get(), mPangoLyt.get());
+    mCairoWrapper->pango_cairo_show_layout(mCairoCtx.get(), mPangoLyt.get());
 
-    cairo_set_source_rgb(mCairoCtx.get(), 0.0, 0.0, 0.0);
+    mCairoWrapper->cairo_set_source_rgb(mCairoCtx.get(), 0.0, 0.0, 0.0);
-    cairo_surface_flush(mSurface.get());
+    mCairoWrapper->cairo_surface_flush(mSurface.get());
     // mCairoCtx smart pointer will handle cleanup
     return true;
 }
 
 void Label::writeToPng(const std::string& file) {
     if (mSurface) {
-        cairo_surface_flush(mSurface.get());
+        mCairoWrapper->cairo_surface_flush(mSurface.get());
-        cairo_surface_write_to_png(mSurface.get(), file.c_str());
+        mCairoWrapper->cairo_surface_write_to_png(mSurface.get(), file.c_str());
     }
 }
 
+bool Label::append(const ILabel& other, uint32_t spacingPx) {
+    // Check that heights match
+    if (getHeight() != other.getHeight()) {
+        spdlog::error("Cannot append labels with different heights: {} vs {}", getHeight(), other.getHeight());
+        return false;
+    }
+
+    int currentWidth = getWidth();
+    int otherWidth   = other.getWidth();
+    int height       = getHeight();
+    int spacing      = static_cast<int>(spacingPx);
+    int newWidth     = currentWidth + spacing + otherWidth;
+
+    spdlog::debug("Appending label: current={}x{}, other={}x{}, spacing={}, new={}x{}", currentWidth, height,
+                  otherWidth, height, spacing, newWidth, height);
+
+    // Get current and other label data
+    auto currentData = getRaw();
+    auto otherData   = other.getRaw();
+
+    // Create new surface with extended width
+    CairoSurfaceDeleter surfaceDeleter;
+    surfaceDeleter.wrapper = mCairoWrapper;
+    auto newSurface        = std::unique_ptr<cairo_surface_t, CairoSurfaceDeleter>(
+        mCairoWrapper->cairo_image_surface_create(CAIRO_FORMAT_A8, newWidth, height), surfaceDeleter);
+
+    if (mCairoWrapper->cairo_surface_status(newSurface.get()) != CAIRO_STATUS_SUCCESS) {
+        spdlog::error("Failed to create new surface for appended label");
+        return false;
+    }
+
+    // Get data pointer and stride
+    mCairoWrapper->cairo_surface_flush(newSurface.get());
+    unsigned char* newData = mCairoWrapper->cairo_image_surface_get_data(newSurface.get());
+    int newStride          = mCairoWrapper->cairo_image_surface_get_stride(newSurface.get());
+
+    // Clear the new surface (set to transparent/white)
+    std::memset(newData, 0x00, newStride * height);
+
+    // Copy current label data
+    for (int y = 0; y < height; ++y) {
+        for (int x = 0; x < currentWidth; ++x) {
+            size_t srcIdx = y * currentWidth + x;
+            size_t dstIdx = y * newStride + x;
+            if (srcIdx < currentData.size()) {
+                newData[dstIdx] = currentData[srcIdx];
+            }
+        }
+    }
+
+    // Copy other label data (with spacing offset)
+    int xOffset = currentWidth + spacing;
+    for (int y = 0; y < height; ++y) {
+        for (int x = 0; x < otherWidth; ++x) {
+            size_t srcIdx = y * otherWidth + x;
+            size_t dstIdx = y * newStride + (xOffset + x);
+            if (srcIdx < otherData.size()) {
+                newData[dstIdx] = otherData[srcIdx];
+            }
+        }
+    }
+
+    mCairoWrapper->cairo_surface_mark_dirty(newSurface.get());
+
+    // Replace current surface with new one
+    mSurface = std::move(newSurface);
+
+    // Update layout dimensions
+    mLayoutWidth = newWidth;
+
+    return true;
+}
+
 void Label::setFontSize(const double fontSize) {
     mFontSize = fontSize;
 }

src/graphics/Label.hpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2023-2025  Moritz Martinius
+    Copyright (C) 2025  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
@@ -32,31 +32,34 @@
 
 namespace ptprnt::graphics {
 
-// Custom deleters for Cairo/Pango resources
+// Forward declaration
+class ICairoWrapper;
+
+// Custom deleters for Cairo/Pango resources that use the wrapper
+// Implementation in Label.cpp to avoid incomplete type issues
 struct CairoSurfaceDeleter {
-    void operator()(cairo_surface_t* surface) const {
+    std::shared_ptr<ICairoWrapper> wrapper;
-        if (surface)
+    void operator()(cairo_surface_t* surface) const;
-            cairo_surface_destroy(surface);
-    }
 };
 
 struct CairoDeleter {
-    void operator()(cairo_t* cr) const {
+    std::shared_ptr<ICairoWrapper> wrapper;
-        if (cr)
+    void operator()(cairo_t* cr) const;
-            cairo_destroy(cr);
-    }
 };
 
 struct GObjectDeleter {
-    void operator()(gpointer obj) const {
+    std::shared_ptr<ICairoWrapper> wrapper;
-        if (obj)
+    void operator()(gpointer obj) const;
-            g_object_unref(obj);
-    }
 };
 
 class Label : public ILabel {
    public:
-    Label(const uint16_t heightPixel);
+    // Default constructor using real Cairo/Pango implementation
+    explicit Label(uint16_t heightPixel);
+
+    // Constructor for dependency injection (testing)
+    Label(uint16_t heightPixel, std::shared_ptr<ICairoWrapper> cairoWrapper);
+
     ~Label() override;
 
     Label(const Label&)            = delete;
@@ -67,9 +70,9 @@ class Label : public ILabel {
     bool create(PrintableText printableText) override;
     bool create(const std::string& labelText) override;
     void writeToPng(const std::string& file);
-    [[nodiscard]] int getWidth() override;
+    [[nodiscard]] int getWidth() const override;
-    [[nodiscard]] int getHeight() override;
+    [[nodiscard]] int getHeight() const override;
-    [[nodiscard]] std::vector<uint8_t> getRaw() override;
+    [[nodiscard]] std::vector<uint8_t> getRaw() const override;
     void setFontSize(const double fontSize) override;
     void setFontFamily(const std::string& fontFamily) override;
 
@@ -77,6 +80,8 @@ class Label : public ILabel {
     void setHAlign(HAlignPosition hpos) override;
     void setVAlign(VAlignPosition vpos) override;
 
+    bool append(const ILabel& other, uint32_t spacingPx = 60) override;
+
    private:
     // methods
     [[nodiscard]] uint8_t getNumLines(std::string_view str);
@@ -84,6 +89,9 @@ class Label : public ILabel {
     void configureLayout(PangoLayout* layout, const std::string& text, PangoFontDescription* fontDesc);
     void applyHorizontalAlignment(PangoLayout* layout);
 
+    // Cairo/Pango wrapper for dependency injection
+    std::shared_ptr<ICairoWrapper> mCairoWrapper;
+
     std::unique_ptr<cairo_surface_t, CairoSurfaceDeleter> mSurface{nullptr};
     std::unique_ptr<cairo_t, CairoDeleter> mCairoCtx{nullptr};
     std::unique_ptr<PangoContext, GObjectDeleter> mPangoCtx{nullptr};

src/graphics/interface/ICairoWrapper.hpp

@@ -0,0 +1,83 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  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 <cairo.h>
+#include <pango/pango.h>
+#include <pango/pangocairo.h>
+
+namespace ptprnt::graphics {
+
+/**
+ * @brief Interface wrapper for Cairo and Pango C API functions
+ *
+ * This interface allows for dependency injection and mocking of Cairo/Pango
+ * functionality in unit tests, making the Label class fully testable.
+ */
+class ICairoWrapper {
+   public:
+    virtual ~ICairoWrapper() = default;
+
+    // Cairo image surface functions
+    virtual cairo_surface_t* cairo_image_surface_create(cairo_format_t format, int width, int height) = 0;
+    virtual void cairo_surface_destroy(cairo_surface_t* surface)                                      = 0;
+    virtual void cairo_surface_flush(cairo_surface_t* surface)                                        = 0;
+    virtual void cairo_surface_mark_dirty(cairo_surface_t* surface)                                   = 0;
+    virtual cairo_status_t cairo_surface_status(cairo_surface_t* surface)                             = 0;
+    virtual cairo_format_t cairo_image_surface_get_format(cairo_surface_t* surface)                   = 0;
+    virtual int cairo_image_surface_get_width(cairo_surface_t* surface)                               = 0;
+    virtual int cairo_image_surface_get_height(cairo_surface_t* surface)                              = 0;
+    virtual int cairo_image_surface_get_stride(cairo_surface_t* surface)                              = 0;
+    virtual unsigned char* cairo_image_surface_get_data(cairo_surface_t* surface)                     = 0;
+    virtual cairo_status_t cairo_surface_write_to_png(cairo_surface_t* surface, const char* filename) = 0;
+
+    // Cairo context functions
+    virtual cairo_t* cairo_create(cairo_surface_t* surface)                               = 0;
+    virtual void cairo_destroy(cairo_t* cr)                                               = 0;
+    virtual void cairo_move_to(cairo_t* cr, double x, double y)                           = 0;
+    virtual void cairo_set_source_rgb(cairo_t* cr, double red, double green, double blue) = 0;
+
+    // Pango-Cairo functions
+    virtual PangoFontMap* pango_cairo_font_map_new()                       = 0;
+    virtual PangoContext* pango_cairo_create_context(cairo_t* cr)          = 0;
+    virtual void pango_cairo_show_layout(cairo_t* cr, PangoLayout* layout) = 0;
+
+    // Pango layout functions
+    virtual PangoLayout* pango_layout_new(PangoContext* context)                                          = 0;
+    virtual void pango_layout_set_font_description(PangoLayout* layout, const PangoFontDescription* desc) = 0;
+    virtual void pango_layout_set_text(PangoLayout* layout, const char* text, int length)                 = 0;
+    virtual void pango_layout_set_height(PangoLayout* layout, int height)                                 = 0;
+    virtual void pango_layout_set_alignment(PangoLayout* layout, PangoAlignment alignment)                = 0;
+    virtual void pango_layout_set_justify(PangoLayout* layout, gboolean justify)                          = 0;
+#if PANGO_VERSION_MAJOR >= 1 && PANGO_VERSION_MINOR >= 50
+    virtual void pango_layout_set_justify_last_line(PangoLayout* layout, gboolean justify) = 0;
+#endif
+    virtual void pango_layout_get_size(PangoLayout* layout, int* width, int* height) = 0;
+
+    // Pango font description functions
+    virtual PangoFontDescription* pango_font_description_new()                                     = 0;
+    virtual void pango_font_description_set_size(PangoFontDescription* desc, gint size)            = 0;
+    virtual void pango_font_description_set_family(PangoFontDescription* desc, const char* family) = 0;
+
+    // GObject reference counting
+    virtual void g_object_unref(gpointer object) = 0;
+};
+
+}  // namespace ptprnt::graphics

src/graphics/interface/ILabel.hpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2024-2025  Moritz Martinius
+    Copyright (C) 2025  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
@@ -67,14 +67,22 @@ class ILabel {
 
     virtual bool create(PrintableText printableText)     = 0;
     virtual bool create(const std::string& labelText)    = 0;
-    virtual std::vector<uint8_t> getRaw()             = 0;
+    virtual std::vector<uint8_t> getRaw() const          = 0;
-    virtual int getWidth()                            = 0;
+    virtual int getWidth() const                         = 0;
-    virtual int getHeight()                           = 0;
+    virtual int getHeight() const                        = 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;
+
+    /**
+     * @brief Append another label horizontally with spacing
+     * @param other The label to append
+     * @param spacingPx Spacing between labels in pixels (default: 60px ~5mm at 300dpi)
+     * @return true on success, false if heights don't match
+     */
+    virtual bool append(const ILabel& other, uint32_t spacingPx = 60) = 0;
 };
 }  // namespace ptprnt::graphics

src/libusbwrap/LibUsbTypes.hpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2023-2024  Moritz Martinius
+    Copyright (C) 2023-2025  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

src/libusbwrap/UsbDevice.cpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2023-2024  Moritz Martinius
+    Copyright (C) 2023-2025  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

src/libusbwrap/UsbDevice.hpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2023-2024  Moritz Martinius
+    Copyright (C) 2023-2025  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

src/libusbwrap/UsbDeviceFactory.hpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2023  Moritz Martinius
+    Copyright (C) 2023-2025  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

src/libusbwrap/interface/IUsbDevice.hpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2023-2024  Moritz Martinius
+    Copyright (C) 2023-2025  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
@@ -22,7 +22,6 @@
 #include <sys/types.h>
 
 #include <cstdint>
-#include <optional>
 #include <string>
 #include <vector>
 
@@ -44,6 +43,7 @@ enum class Speed {
 class IUsbDevice {
    public:
     virtual ~IUsbDevice() = default;
+
     virtual bool open()  = 0;
     virtual void close() = 0;
 

src/libusbwrap/interface/IUsbDeviceFactory.hpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2023  Moritz Martinius
+    Copyright (C) 2023-2025  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

src/main.cpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2022-2023  Moritz Martinius
+    Copyright (C) 2022-2025  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
@@ -22,7 +22,10 @@ int main(int argc, char** argv) {
     ptprnt::PtouchPrint ptouchprnt(PROJ_VERSION);
     int ret = ptouchprnt.init(argc, argv);
     if (ret != 0) {
-        return ret;
+        // Non-zero from init means don't continue
+        // Positive values = clean exit (help/version)
+        // Negative values = error
+        return ret > 0 ? 0 : ret;
     }
     return ptouchprnt.run();
 }

src/meson.build

@@ -1,30 +1,34 @@
 ptprnt_hpps = files(
-    'libusbwrap/interface/IUsbDeviceFactory.hpp',
+    'cli/CliParser.hpp',
-    'libusbwrap/interface/IUsbDevice.hpp',
+    'core/PrinterDriverFactory.hpp',
-    'libusbwrap/UsbDeviceFactory.hpp',
+    'core/PrinterService.hpp',
-    'libusbwrap/LibUsbTypes.hpp',
-    'libusbwrap/UsbDevice.hpp',
-    'interface/IPrinterDriver.hpp',
-    'interface/IPrinterTypes.hpp',
-    'printers/P700Printer.hpp',
-    'printers/FakePrinter.hpp',
-    'PtouchPrint.hpp',
-    'PrinterDriverFactory.hpp',
     'graphics/Bitmap.hpp',
     'graphics/Label.hpp',
     'graphics/LabelBuilder.hpp',
-    'graphics/Monochrome.hpp'
+    'graphics/Monochrome.hpp',
+    'libusbwrap/LibUsbTypes.hpp',
+    'libusbwrap/UsbDevice.hpp',
+    'libusbwrap/UsbDeviceFactory.hpp',
+    'libusbwrap/interface/IUsbDevice.hpp',
+    'libusbwrap/interface/IUsbDeviceFactory.hpp',
+    'printers/FakePrinter.hpp',
+    'printers/P700Printer.hpp',
+    'printers/interface/IPrinterDriver.hpp',
+    'printers/interface/IPrinterTypes.hpp',
+    'PtouchPrint.hpp',
 )
 
 ptprnt_srcs = files(
-    'PtouchPrint.cpp',
+    'cli/CliParser.cpp',
-    'PrinterDriverFactory.cpp',
+    'core/PrinterDriverFactory.cpp',
-    'printers/P700Printer.cpp',
+    'core/PrinterService.cpp',
-    'printers/FakePrinter.cpp',
+    'graphics/Bitmap.cpp',
     'graphics/Label.cpp',
     'graphics/LabelBuilder.cpp',
-    'graphics/Bitmap.cpp',
     'graphics/Monochrome.cpp',
-    'libusbwrap/UsbDeviceFactory.cpp',
     'libusbwrap/UsbDevice.cpp',
+    'libusbwrap/UsbDeviceFactory.cpp',
+    'printers/FakePrinter.cpp',
+    'printers/P700Printer.cpp',
+    'PtouchPrint.cpp',
 )

src/printers/FakePrinter.cpp

@@ -19,49 +19,50 @@
 
 #include "FakePrinter.hpp"
 
-#include <spdlog/spdlog.h>
 #include <cairo.h>
+#include <spdlog/spdlog.h>
 
-#include <cstdint>
-#include <stdexcept>
-#include <vector>
 #include <chrono>
+#include <cstdint>
 #include <iomanip>
 #include <sstream>
+#include <stdexcept>
+#include <vector>
 
-#include "../graphics/Monochrome.hpp"
+#include "graphics/Monochrome.hpp"
 
 namespace ptprnt::printer {
 
-const PrinterInfo FakePrinter::mInfo = {
+const PrinterInfo FakePrinter::mInfo = {.driverName = "FakePrinter",
-    .driverName = "FakePrinter",
                                         .name       = "Virtual Test Printer",
                                         .version    = "v1.0",
                                         .usbId{0x0000, 0x0000},  // No USB ID - virtual printer created explicitly
-    .pixelLines = 128
+                                        .pixelLines = 128};
-};
 
-const std::string_view FakePrinter::getDriverName() {
+std::string_view FakePrinter::getDriverName() {
     return mInfo.driverName;
 }
 
-const std::string_view FakePrinter::getName() {
+std::string_view FakePrinter::getName() {
     return mInfo.name;
 }
 
-const std::string_view FakePrinter::getVersion() {
+std::string_view FakePrinter::getVersion() {
     return mInfo.version;
 }
 
-const PrinterInfo FakePrinter::getPrinterInfo() {
+PrinterInfo FakePrinter::getPrinterInfo() {
     return mInfo;
 }
 
-const PrinterStatus FakePrinter::getPrinterStatus() {
+PrinterStatus FakePrinter::getPrinterStatus() {
+    if (!mHasAttachedDevice) {
+        return {};
+    }
     return mStatus;
 }
 
-const libusbwrap::usbId FakePrinter::getUsbId() {
+libusbwrap::usbId FakePrinter::getUsbId() {
     return mInfo.usbId;
 }
 
@@ -88,14 +89,17 @@ bool FakePrinter::printBitmap(const graphics::Bitmap<graphics::ALPHA8>& bitmap)
 }
 
 bool FakePrinter::printMonochromeData(const graphics::MonochromeData& data) {
+    if (!mHasAttachedDevice) {
+        return false;
+    }
     spdlog::debug("FakePrinter: Simulating printing of {}x{} bitmap", data.width, data.height);
 
     // Simulate the printing process by reconstructing the bitmap
     auto printed = simulatePrinting(data);
     mLastPrint   = std::make_unique<graphics::Bitmap<graphics::ALPHA8>>(std::move(printed));
 
-    spdlog::info("FakePrinter: Successfully 'printed' label ({}x{} pixels)",
+    spdlog::info("FakePrinter: Successfully 'printed' label ({}x{} pixels)", mLastPrint->getWidth(),
-                 mLastPrint->getWidth(), mLastPrint->getHeight());
+                 mLastPrint->getHeight());
 
     // Save to timestamped PNG file
     std::string filename = generateTimestampedFilename();
@@ -120,12 +124,16 @@ bool FakePrinter::printLabel(const std::unique_ptr<graphics::ILabel> label) {
     // Transform to portrait orientation for printing
     monoData.transformTo(graphics::Orientation::PORTRAIT);
 
-    spdlog::debug("FakePrinter: Label surface is {}x{}, transformed to portrait", label->getWidth(), label->getHeight());
+    spdlog::debug("FakePrinter: Label surface is {}x{}, transformed to portrait", label->getWidth(),
+                  label->getHeight());
 
     return printMonochromeData(monoData);
 }
 
 bool FakePrinter::print() {
+    if (!mHasAttachedDevice) {
+        return false;
+    }
     spdlog::debug("FakePrinter: Print command (no-op for virtual printer)");
     return true;
 }
@@ -177,8 +185,8 @@ graphics::Bitmap<graphics::ALPHA8> FakePrinter::simulatePrinting(const graphics:
     // Set the pixels in the result bitmap
     result.setPixels(pixels);
 
-    spdlog::debug("FakePrinter: Simulation complete, reconstructed {}x{} bitmap",
+    spdlog::debug("FakePrinter: Simulation complete, reconstructed {}x{} bitmap", result.getWidth(),
-                  result.getWidth(), result.getHeight());
+                  result.getHeight());
 
     return result;
 }
@@ -218,13 +226,8 @@ bool FakePrinter::saveBitmapToPng(const graphics::Bitmap<graphics::ALPHA8>& bitm
 
     // Create Cairo surface
     int stride               = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
-    cairo_surface_t* surface = cairo_image_surface_create_for_data(
+    cairo_surface_t* surface = cairo_image_surface_create_for_data(reinterpret_cast<unsigned char*>(argbPixels.data()),
-        reinterpret_cast<unsigned char*>(argbPixels.data()),
+                                                                   CAIRO_FORMAT_ARGB32, width, height, stride);
-        CAIRO_FORMAT_ARGB32,
-        width,
-        height,
-        stride
-    );
 
     if (cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {
         spdlog::error("FakePrinter: Failed to create Cairo surface: {}",
@@ -253,9 +256,7 @@ std::string FakePrinter::generateTimestampedFilename() const {
 
     // Format: fakelabel_YYYYMMDD_HHMMSS.png
     std::stringstream ss;
-    ss << "fakelabel_"
+    ss << "fakelabel_" << std::put_time(std::localtime(&time), "%Y%m%d_%H%M%S") << ".png";
-       << std::put_time(std::localtime(&time), "%Y%m%d_%H%M%S")
-       << ".png";
 
     return ss.str();
 }

src/printers/FakePrinter.hpp

@@ -19,15 +19,15 @@
 
 #pragma once
 
+#include <cstdint>
 #include <memory>
 #include <vector>
-#include <cstdint>
 
-#include "../interface/IPrinterDriver.hpp"
+#include "graphics/Bitmap.hpp"
-#include "../interface/IPrinterTypes.hpp"
+#include "interface/IPrinterDriver.hpp"
-#include "../libusbwrap/LibUsbTypes.hpp"
+#include "interface/IPrinterTypes.hpp"
-#include "../libusbwrap/interface/IUsbDevice.hpp"
+#include "libusbwrap/LibUsbTypes.hpp"
-#include "../graphics/Bitmap.hpp"
+#include "libusbwrap/interface/IUsbDevice.hpp"
 
 namespace ptprnt::printer {
 
@@ -52,12 +52,12 @@ class FakePrinter : public ::ptprnt::IPrinterDriver {
     static const PrinterInfo mInfo;
 
     // IPrinterDriver interface
-    [[nodiscard]] const std::string_view getDriverName() override;
+    [[nodiscard]] std::string_view getDriverName() override;
-    [[nodiscard]] const std::string_view getName() override;
+    [[nodiscard]] std::string_view getName() override;
-    [[nodiscard]] const libusbwrap::usbId getUsbId() override;
+    [[nodiscard]] libusbwrap::usbId getUsbId() override;
-    [[nodiscard]] const std::string_view getVersion() override;
+    [[nodiscard]] std::string_view getVersion() override;
-    [[nodiscard]] const PrinterInfo getPrinterInfo() override;
+    [[nodiscard]] PrinterInfo getPrinterInfo() override;
-    [[nodiscard]] const PrinterStatus getPrinterStatus() override;
+    [[nodiscard]] PrinterStatus getPrinterStatus() override;
     bool attachUsbDevice(std::shared_ptr<libusbwrap::IUsbDevice> usbHndl) override;
     bool detachUsbDevice() override;
     bool printBitmap(const graphics::Bitmap<graphics::ALPHA8>& bitmap) override;

src/printers/P700Printer.cpp

@@ -28,9 +28,9 @@
 #include <thread>
 #include <vector>
 
-#include "../graphics/Bitmap.hpp"
+#include "graphics/Bitmap.hpp"
-#include "../graphics/Monochrome.hpp"
+#include "graphics/Monochrome.hpp"
-#include "../libusbwrap/LibUsbTypes.hpp"
+#include "libusbwrap/LibUsbTypes.hpp"
 #include "spdlog/fmt/bin_to_hex.h"
 
 namespace ptprnt::printer {
@@ -48,24 +48,30 @@ P700Printer::~P700Printer() {
     }
 }
 
-const std::string_view P700Printer::getDriverName() {
+std::string_view P700Printer::getDriverName() {
     return mInfo.driverName;
 }
 
-const std::string_view P700Printer::getName() {
+std::string_view P700Printer::getName() {
     return mInfo.name;
 }
 
-const std::string_view P700Printer::getVersion() {
+std::string_view P700Printer::getVersion() {
     return mInfo.version;
 }
 
-const PrinterInfo P700Printer::getPrinterInfo() {
+PrinterInfo P700Printer::getPrinterInfo() {
     return mInfo;
 }
 
-const PrinterStatus P700Printer::getPrinterStatus() {
+PrinterStatus P700Printer::getPrinterStatus() {
     using namespace std::chrono_literals;
+
+    if (!mUsbHndl) {
+        spdlog::error("USB Handle is invalid!");
+        return {};
+    }
+
     send(p700::commands::GET_STATUS);
 
     int tx    = 0;
@@ -79,7 +85,7 @@ const PrinterStatus P700Printer::getPrinterStatus() {
     return PrinterStatus{.tapeWidthMm = recvBuf[10]};
 }
 
-const libusbwrap::usbId P700Printer::getUsbId() {
+libusbwrap::usbId P700Printer::getUsbId() {
     return mInfo.usbId;
 }
 

src/printers/P700Printer.hpp

@@ -17,6 +17,8 @@
 
  */
 
+#pragma once
+
 #include <spdlog/spdlog.h>
 #include <sys/types.h>
 
@@ -28,8 +30,6 @@
 #include "libusbwrap/LibUsbTypes.hpp"
 #include "libusbwrap/interface/IUsbDevice.hpp"
 
-#pragma once
-
 namespace ptprnt::printer {
 namespace p700::commands {
 const cmd_T INITIALIZE{0x1b, 0x40};                // ESC @ - Initialize
@@ -66,12 +66,12 @@ class P700Printer : public ::ptprnt::IPrinterDriver {
     static const PrinterInfo mInfo;
 
     // IPrinterDriver
-    [[nodiscard]] const std::string_view getDriverName() override;
+    [[nodiscard]] std::string_view getDriverName() override;
-    [[nodiscard]] const std::string_view getName() override;
+    [[nodiscard]] std::string_view getName() override;
-    [[nodiscard]] const libusbwrap::usbId getUsbId() override;
+    [[nodiscard]] libusbwrap::usbId getUsbId() override;
-    [[nodiscard]] const std::string_view getVersion() override;
+    [[nodiscard]] std::string_view getVersion() override;
-    [[nodiscard]] const PrinterInfo getPrinterInfo() override;
+    [[nodiscard]] PrinterInfo getPrinterInfo() override;
-    [[nodiscard]] const PrinterStatus getPrinterStatus() override;
+    [[nodiscard]] PrinterStatus getPrinterStatus() override;
     bool attachUsbDevice(std::shared_ptr<libusbwrap::IUsbDevice> usbHndl) override;
     bool detachUsbDevice() override;
     bool printBitmap(const graphics::Bitmap<graphics::ALPHA8>& bitmap) override;

src/printers/interface/IPrinterDriver.hpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2023-2025  Moritz Martinius
+    Copyright (C) 2025  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
@@ -22,22 +22,22 @@
 #include <memory>
 #include <string_view>
 
+#include "IPrinterTypes.hpp"
 #include "graphics/Bitmap.hpp"
 #include "graphics/Monochrome.hpp"
 #include "graphics/interface/ILabel.hpp"
-#include "interface/IPrinterTypes.hpp"
 #include "libusbwrap/interface/IUsbDevice.hpp"
 
 namespace ptprnt {
 class IPrinterDriver {
    public:
     virtual ~IPrinterDriver()                                                     = default;
-    [[nodiscard]] virtual const std::string_view getDriverName()                  = 0;
+    [[nodiscard]] virtual std::string_view getDriverName()                        = 0;
-    [[nodiscard]] virtual const std::string_view getName()                        = 0;
+    [[nodiscard]] virtual std::string_view getName()                              = 0;
-    [[nodiscard]] virtual const std::string_view getVersion()                     = 0;
+    [[nodiscard]] virtual std::string_view getVersion()                           = 0;
-    [[nodiscard]] virtual const libusbwrap::usbId getUsbId()                      = 0;
+    [[nodiscard]] virtual libusbwrap::usbId getUsbId()                            = 0;
-    [[nodiscard]] virtual const PrinterInfo getPrinterInfo()                      = 0;
+    [[nodiscard]] virtual PrinterInfo getPrinterInfo()                            = 0;
-    [[nodiscard]] virtual const PrinterStatus getPrinterStatus()                  = 0;
+    [[nodiscard]] virtual PrinterStatus getPrinterStatus()                        = 0;
     virtual bool attachUsbDevice(std::shared_ptr<libusbwrap::IUsbDevice> usbHndl) = 0;
     virtual bool detachUsbDevice()                                                = 0;
     virtual bool printBitmap(const graphics::Bitmap<graphics::ALPHA8>& bitmap)    = 0;

src/printers/interface/IPrinterTypes.hpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2023-2024  Moritz Martinius
+    Copyright (C) 2025  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
@@ -20,7 +20,6 @@
 #pragma once
 
 #include <cstdint>
-#include <string>
 #include <string_view>
 #include <vector>
 

subprojects/cli11.wrap

@@ -1,9 +1,10 @@
 [wrap-file]
-directory = CLI11-2.3.2
+directory = CLI11-2.5.0
-source_url = https://github.com/CLIUtils/CLI11/archive/refs/tags/v2.3.2.tar.gz
+source_url = https://github.com/CLIUtils/CLI11/archive/refs/tags/v2.5.0.tar.gz
-source_filename = CLI11-2.3.2.tar.gz
+source_filename = CLI11-2.5.0.tar.gz
-source_hash = aac0ab42108131ac5d3344a9db0fdf25c4db652296641955720a4fbe52334e22
+source_hash = 17e02b4cddc2fa348e5dbdbb582c59a3486fa2b2433e70a0c3bacb871334fd55
-wrapdb_version = 2.3.2-1
+source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/cli11_2.5.0-2/CLI11-2.5.0.tar.gz
+wrapdb_version = 2.5.0-2
 
 [provide]
-cli11 = CLI11_dep
+dependency_names = CLI11

subprojects/gtest.wrap

@@ -1,13 +1,13 @@
 [wrap-file]
-directory = googletest-1.14.0
+directory = googletest-1.17.0
-source_url = https://github.com/google/googletest/archive/refs/tags/v1.14.0.tar.gz
+source_url = https://github.com/google/googletest/archive/refs/tags/v1.17.0.tar.gz
-source_filename = gtest-1.14.0.tar.gz
+source_filename = googletest-1.17.0.tar.gz
-source_hash = 8ad598c73ad796e0d8280b082cebd82a630d73e73cd3c70057938a6501bba5d7
+source_hash = 65fab701d9829d38cb77c14acdc431d2108bfdbf8979e40eb8ae567edf10b27c
-patch_filename = gtest_1.14.0-1_patch.zip
+patch_filename = gtest_1.17.0-4_patch.zip
-patch_url = https://wrapdb.mesonbuild.com/v2/gtest_1.14.0-1/get_patch
+patch_url = https://wrapdb.mesonbuild.com/v2/gtest_1.17.0-4/get_patch
-patch_hash = 2e693c7d3f9370a7aa6dac802bada0874d3198ad4cfdf75647b818f691182b50
+patch_hash = 3abf7662d09db706453a5b064a1e914678c74b9d9b0b19382747ca561d0d8750
-source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/gtest_1.14.0-1/gtest-1.14.0.tar.gz
+source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/gtest_1.17.0-4/googletest-1.17.0.tar.gz
-wrapdb_version = 1.14.0-1
+wrapdb_version = 1.17.0-4
 
 [provide]
 gtest = gtest_dep

test_copyright.cpp

@@ -0,0 +1 @@
+# Test file

tests/bitmap_test/bitmap_test.cpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2023  Moritz Martinius
+    Copyright (C) 2023-2025  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

tests/label_test/label_test.cpp

@@ -1,6 +1,6 @@
 /*
     ptrnt - print labels on linux
-    Copyright (C) 2023  Moritz Martinius
+    Copyright (C) 2025  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
@@ -19,8 +19,244 @@
 
 #include "graphics/Label.hpp"
 
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-TEST(basic_test, Label_smokeTest_succeeds) {
+#include <memory>
-    auto im = ptprnt::graphics::Label(4711);
+#include <vector>
+
+#include "../../tests/mocks/MockCairoWrapper.hpp"
+#include "graphics/interface/ILabel.hpp"
+
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::NiceMock;
+using ::testing::Return;
+using ::testing::SetArgPointee;
+
+namespace ptprnt::graphics {
+
+// Test fixture for Label tests with comprehensive mock setup
+class LabelTest : public ::testing::Test {
+   protected:
+    void SetUp() override {
+        mockWrapper = std::make_shared<NiceMock<MockCairoWrapper>>();
+
+        // Mock pointers for temporary surface (used in size calculation)
+        mockTempSurface = reinterpret_cast<cairo_surface_t*>(0x2000);
+        mockTempCr      = reinterpret_cast<cairo_t*>(0x2001);
+        mockTempCtx     = reinterpret_cast<PangoContext*>(0x2002);
+        mockTempLayout  = reinterpret_cast<PangoLayout*>(0x2003);
+
+        // Mock pointers for final surface (used in rendering)
+        mockFinalSurface = reinterpret_cast<cairo_surface_t*>(0x3000);
+        mockFinalCr      = reinterpret_cast<cairo_t*>(0x3001);
+        mockFinalCtx     = reinterpret_cast<PangoContext*>(0x3002);
+        mockFinalLayout  = reinterpret_cast<PangoLayout*>(0x3003);
+
+        // Mock font description
+        mockFontDesc = reinterpret_cast<PangoFontDescription*>(0x2004);
+
+        // Default layout size: 100x30 pixels (in PANGO_SCALE units)
+        defaultLayoutWidth  = 100;
+        defaultLayoutHeight = 30;
+
+        SetupDefaultBehaviors();
     }
+
+    void SetupDefaultBehaviors() {
+        // Font map
+        ON_CALL(*mockWrapper, pango_cairo_font_map_new())
+            .WillByDefault(Return(reinterpret_cast<PangoFontMap*>(0x1000)));
+
+        // Temporary surface creation (for size calculation)
+        ON_CALL(*mockWrapper, cairo_image_surface_create(CAIRO_FORMAT_A8, 1, 1)).WillByDefault(Return(mockTempSurface));
+        ON_CALL(*mockWrapper, cairo_create(mockTempSurface)).WillByDefault(Return(mockTempCr));
+        ON_CALL(*mockWrapper, pango_cairo_create_context(mockTempCr)).WillByDefault(Return(mockTempCtx));
+        ON_CALL(*mockWrapper, pango_layout_new(mockTempCtx)).WillByDefault(Return(mockTempLayout));
+
+        // Final surface creation (for rendering) - use _ for width since it varies
+        ON_CALL(*mockWrapper, cairo_image_surface_create(CAIRO_FORMAT_A8, _, _))
+            .WillByDefault(Return(mockFinalSurface));
+        ON_CALL(*mockWrapper, cairo_create(mockFinalSurface)).WillByDefault(Return(mockFinalCr));
+        ON_CALL(*mockWrapper, pango_cairo_create_context(mockFinalCr)).WillByDefault(Return(mockFinalCtx));
+        ON_CALL(*mockWrapper, pango_layout_new(mockFinalCtx)).WillByDefault(Return(mockFinalLayout));
+
+        // Font description
+        ON_CALL(*mockWrapper, pango_font_description_new()).WillByDefault(Return(mockFontDesc));
+
+        // Layout size - return default dimensions
+        ON_CALL(*mockWrapper, pango_layout_get_size(_, _, _))
+            .WillByDefault(DoAll(SetArgPointee<1>(defaultLayoutWidth * PANGO_SCALE),
+                                 SetArgPointee<2>(defaultLayoutHeight * PANGO_SCALE)));
+
+        // Surface status - always success
+        ON_CALL(*mockWrapper, cairo_surface_status(_)).WillByDefault(Return(CAIRO_STATUS_SUCCESS));
+
+        // Surface properties for getRaw()
+        ON_CALL(*mockWrapper, cairo_image_surface_get_format(_)).WillByDefault(Return(CAIRO_FORMAT_A8));
+        ON_CALL(*mockWrapper, cairo_image_surface_get_width(_)).WillByDefault(Return(defaultLayoutWidth));
+        ON_CALL(*mockWrapper, cairo_image_surface_get_height(_)).WillByDefault(Return(128));
+        ON_CALL(*mockWrapper, cairo_image_surface_get_stride(_)).WillByDefault(Return(defaultLayoutWidth));
+
+        // Mock data pointer
+        mockSurfaceData.resize(defaultLayoutWidth * 128, 0xFF);
+        ON_CALL(*mockWrapper, cairo_image_surface_get_data(_)).WillByDefault(Return(mockSurfaceData.data()));
+    }
+
+    // Helper method to set custom layout dimensions
+    void SetLayoutSize(int width, int height) {
+        defaultLayoutWidth  = width;
+        defaultLayoutHeight = height;
+
+        // Update the mock to return new dimensions
+        ON_CALL(*mockWrapper, pango_layout_get_size(_, _, _))
+            .WillByDefault(DoAll(SetArgPointee<1>(width * PANGO_SCALE), SetArgPointee<2>(height * PANGO_SCALE)));
+
+        ON_CALL(*mockWrapper, cairo_image_surface_get_width(_)).WillByDefault(Return(width));
+        ON_CALL(*mockWrapper, cairo_image_surface_get_stride(_)).WillByDefault(Return(width));
+
+        // Resize mock data
+        mockSurfaceData.resize(width * 128, 0xFF);
+        ON_CALL(*mockWrapper, cairo_image_surface_get_data(_)).WillByDefault(Return(mockSurfaceData.data()));
+    }
+
+    std::shared_ptr<NiceMock<MockCairoWrapper>> mockWrapper;
+
+    // Mock pointers
+    cairo_surface_t* mockTempSurface;
+    cairo_t* mockTempCr;
+    PangoContext* mockTempCtx;
+    PangoLayout* mockTempLayout;
+
+    cairo_surface_t* mockFinalSurface;
+    cairo_t* mockFinalCr;
+    PangoContext* mockFinalCtx;
+    PangoLayout* mockFinalLayout;
+
+    PangoFontDescription* mockFontDesc;
+
+    // Default layout dimensions
+    int defaultLayoutWidth;
+    int defaultLayoutHeight;
+
+    // Mock surface data
+    std::vector<unsigned char> mockSurfaceData;
+};
+
+// Smoke test with real Cairo/Pango
+TEST(basic_test, Label_smokeTest_succeeds) {
+    auto label = Label(128);
+    EXPECT_EQ(label.getHeight(), 128);
+    EXPECT_EQ(label.getWidth(), 0);  // No label created yet
+}
+
+// Constructor test with mock
+TEST_F(LabelTest, Constructor_InitializesFontMap) {
+    EXPECT_CALL(*mockWrapper, pango_cairo_font_map_new()).Times(1);
+
+    auto label = Label(128, mockWrapper);
+
+    EXPECT_EQ(label.getHeight(), 128);
+    EXPECT_EQ(label.getWidth(), 0);
+}
+
+// Test getters before label creation
+TEST_F(LabelTest, Getters_BeforeCreate_ReturnDefaults) {
+    auto label = Label(256, mockWrapper);
+
+    EXPECT_EQ(label.getHeight(), 256);
+    EXPECT_EQ(label.getWidth(), 0);
+}
+
+// Test setters
+TEST_F(LabelTest, Setters_ModifyProperties) {
+    auto label = Label(128, mockWrapper);
+
+    label.setFontSize(24.0);
+    label.setFontFamily("Arial");
+    label.setText("Test");
+    label.setHAlign(HAlignPosition::CENTER);
+    label.setVAlign(VAlignPosition::BOTTOM);
+
+    // Properties are set (no way to verify without create, but no crash is good)
+    SUCCEED();
+}
+
+// Test create() - basic functionality with simplified setup
+TEST_F(LabelTest, Create_WithText_Succeeds) {
+    auto label = Label(128, mockWrapper);
+    label.setFontSize(12.0);
+    label.setFontFamily("Sans");
+
+    bool result = label.create("Hello");
+
+    EXPECT_TRUE(result);
+    EXPECT_EQ(label.getWidth(), defaultLayoutWidth);
+    EXPECT_EQ(label.getHeight(), 128);
+}
+
+// Test horizontal alignment - RIGHT
+TEST_F(LabelTest, Create_WithRightAlignment_SetsCorrectPangoAlignment) {
+    auto label = Label(128, mockWrapper);
+    label.setHAlign(HAlignPosition::RIGHT);
+
+    // Verify RIGHT alignment is set (temp + final layout)
+    EXPECT_CALL(*mockWrapper, pango_layout_set_alignment(_, PANGO_ALIGN_RIGHT)).Times(2);
+
+    label.create("Right");
+}
+
+// Test horizontal alignment - JUSTIFY
+TEST_F(LabelTest, Create_WithJustifyAlignment_SetsJustifyAndAlignment) {
+    auto label = Label(128, mockWrapper);
+    label.setHAlign(HAlignPosition::JUSTIFY);
+
+    // Verify JUSTIFY requires LEFT alignment + justify flag
+    EXPECT_CALL(*mockWrapper, pango_layout_set_alignment(_, PANGO_ALIGN_LEFT)).Times(2);
+    EXPECT_CALL(*mockWrapper, pango_layout_set_justify(_, true)).Times(2);
+#if PANGO_VERSION_MAJOR >= 1 && PANGO_VERSION_MINOR >= 50
+    EXPECT_CALL(*mockWrapper, pango_layout_set_justify_last_line(_, true)).Times(2);
+#endif
+
+    label.create("Justify");
+}
+
+// Test vertical alignment - TOP (no cairo_move_to)
+TEST_F(LabelTest, Create_WithTopAlignment_NoMoveToCall) {
+    auto label = Label(128, mockWrapper);
+    label.setVAlign(VAlignPosition::TOP);
+
+    // TOP alignment should NOT call cairo_move_to
+    EXPECT_CALL(*mockWrapper, cairo_move_to(_, _, _)).Times(0);
+
+    label.create("Top");
+}
+
+// Test vertical alignment - BOTTOM
+TEST_F(LabelTest, Create_WithBottomAlignment_CallsMoveToWithCorrectOffset) {
+    auto label = Label(128, mockWrapper);
+    label.setVAlign(VAlignPosition::BOTTOM);
+
+    SetLayoutSize(50, 20);  // Use helper to set custom size
+
+    // BOTTOM alignment: offset = printerHeight - layoutHeight = 128 - 20 = 108
+    EXPECT_CALL(*mockWrapper, cairo_move_to(mockFinalCr, 0.0, 108.0)).Times(1);
+
+    label.create("Bottom");
+}
+
+// Test vertical alignment - MIDDLE
+TEST_F(LabelTest, Create_WithMiddleAlignment_CallsMoveToWithCenteredOffset) {
+    auto label = Label(128, mockWrapper);
+    label.setVAlign(VAlignPosition::MIDDLE);
+
+    SetLayoutSize(50, 20);  // Use helper to set custom size
+
+    // MIDDLE alignment: offset = (printerHeight - layoutHeight) / 2 = (128 - 20) / 2 = 54
+    EXPECT_CALL(*mockWrapper, cairo_move_to(mockFinalCr, 0.0, 54.0)).Times(1);
+
+    label.create("Middle");
+}
+
+}  // namespace ptprnt::graphics

tests/meson.build

@@ -4,11 +4,6 @@ tests = [
         'bitmap_test_exe',
         ['../src/graphics/Bitmap.cpp', 'bitmap_test/bitmap_test.cpp'],
     ],
-    [
-        'label_test',
-        'label_test_exe',
-        ['../src/graphics/Label.cpp', 'label_test/label_test.cpp'],
-    ],
     [
         'monochrome_test',
         'monochrome_test_exe',
@@ -37,4 +32,20 @@ foreach test : tests
     )
 endforeach
 
-
+# Label test requires GMock for mocking Cairo/Pango
+test(
+    'label_test',
+    executable(
+        'label_test_exe',
+        sources: ['../src/graphics/Label.cpp', 'label_test/label_test.cpp'],
+        include_directories: incdir,
+        dependencies: [
+            gmock_dep,
+            gtest_dep,
+            usb_dep,
+            log_dep,
+            pangocairo_dep,
+            cli11_dep,
+        ],
+    ),
+)

tests/mocks/MockCairoWrapper.hpp

@@ -0,0 +1,84 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  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 <gmock/gmock.h>
+#include "graphics/interface/ICairoWrapper.hpp"
+
+namespace ptprnt::graphics {
+
+/**
+ * @brief GMock implementation of ICairoWrapper for unit testing
+ *
+ * This mock allows tests to verify that the Label class correctly interacts
+ * with the Cairo/Pango API without requiring actual graphics rendering.
+ */
+class MockCairoWrapper : public ICairoWrapper {
+   public:
+    // Cairo image surface functions
+    MOCK_METHOD(cairo_surface_t*, cairo_image_surface_create, (cairo_format_t format, int width, int height),
+                (override));
+    MOCK_METHOD(void, cairo_surface_destroy, (cairo_surface_t * surface), (override));
+    MOCK_METHOD(void, cairo_surface_flush, (cairo_surface_t * surface), (override));
+    MOCK_METHOD(void, cairo_surface_mark_dirty, (cairo_surface_t * surface), (override));
+    MOCK_METHOD(cairo_status_t, cairo_surface_status, (cairo_surface_t * surface), (override));
+    MOCK_METHOD(cairo_format_t, cairo_image_surface_get_format, (cairo_surface_t * surface), (override));
+    MOCK_METHOD(int, cairo_image_surface_get_width, (cairo_surface_t * surface), (override));
+    MOCK_METHOD(int, cairo_image_surface_get_height, (cairo_surface_t * surface), (override));
+    MOCK_METHOD(int, cairo_image_surface_get_stride, (cairo_surface_t * surface), (override));
+    MOCK_METHOD(unsigned char*, cairo_image_surface_get_data, (cairo_surface_t * surface), (override));
+    MOCK_METHOD(cairo_status_t, cairo_surface_write_to_png, (cairo_surface_t * surface, const char* filename),
+                (override));
+
+    // Cairo context functions
+    MOCK_METHOD(cairo_t*, cairo_create, (cairo_surface_t * surface), (override));
+    MOCK_METHOD(void, cairo_destroy, (cairo_t * cr), (override));
+    MOCK_METHOD(void, cairo_move_to, (cairo_t * cr, double x, double y), (override));
+    MOCK_METHOD(void, cairo_set_source_rgb, (cairo_t * cr, double red, double green, double blue), (override));
+
+    // Pango-Cairo functions
+    MOCK_METHOD(PangoFontMap*, pango_cairo_font_map_new, (), (override));
+    MOCK_METHOD(PangoContext*, pango_cairo_create_context, (cairo_t * cr), (override));
+    MOCK_METHOD(void, pango_cairo_show_layout, (cairo_t * cr, PangoLayout* layout), (override));
+
+    // Pango layout functions
+    MOCK_METHOD(PangoLayout*, pango_layout_new, (PangoContext * context), (override));
+    MOCK_METHOD(void, pango_layout_set_font_description, (PangoLayout * layout, const PangoFontDescription* desc),
+                (override));
+    MOCK_METHOD(void, pango_layout_set_text, (PangoLayout * layout, const char* text, int length), (override));
+    MOCK_METHOD(void, pango_layout_set_height, (PangoLayout * layout, int height), (override));
+    MOCK_METHOD(void, pango_layout_set_alignment, (PangoLayout * layout, PangoAlignment alignment), (override));
+    MOCK_METHOD(void, pango_layout_set_justify, (PangoLayout * layout, gboolean justify), (override));
+#if PANGO_VERSION_MAJOR >= 1 && PANGO_VERSION_MINOR >= 50
+    MOCK_METHOD(void, pango_layout_set_justify_last_line, (PangoLayout * layout, gboolean justify), (override));
+#endif
+    MOCK_METHOD(void, pango_layout_get_size, (PangoLayout * layout, int* width, int* height), (override));
+
+    // Pango font description functions
+    MOCK_METHOD(PangoFontDescription*, pango_font_description_new, (), (override));
+    MOCK_METHOD(void, pango_font_description_set_size, (PangoFontDescription * desc, gint size), (override));
+    MOCK_METHOD(void, pango_font_description_set_family, (PangoFontDescription * desc, const char* family),
+                (override));
+
+    // GObject reference counting
+    MOCK_METHOD(void, g_object_unref, (gpointer object), (override));
+};
+
+}  // namespace ptprnt::graphics

tests/monochrome_test/monochrome_test.cpp

@@ -1,6 +1,6 @@
 /* 
     ptrnt - print labels on linux
-    Copyright (C) 2023  Moritz Martinius
+    Copyright (C) 2023-2025  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