moritz/ptprnt
1
0
Fork 0
Code Issues Pull Requests Actions Projects Releases 1 Wiki Activity

cli-parser-cleanup (#15)
All checks were successful
Build ptprnt / build (push) Successful in 3m50s
Details

Browse Source 
Reviewed-on: moritz/ptouch-prnt#15
This commit was merged in pull request #15.
This commit is contained in:
Moritz Martinius
2025-10-13 19:23:27 +00:00
parent 78aab33fdb
commit 2d37f6fcfb
30 changed files with 760 additions and 367 deletions
Download Patch File Download Diff File Expand all files Collapse all files

352
src/PtouchPrint.cpp
View File

@@ -1,4 +1,4 @@
/*
/*
ptrnt - print labels on linux
Copyright (C) 2023-2025 Moritz Martinius
@@ -18,191 +18,159 @@
*/
#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 <functional>
#include <memory>
#include <unordered_set>
#include <vector>
#include "CLI/Option.hpp"
#include "PrinterDriverFactory.hpp"
#include "cli/CliParser.hpp"
#include "cli/interface/ICliParser.hpp"
#include "constants.hpp"
#include "core/PrinterDriverFactory.hpp"
#include "core/PrinterService.hpp"
#include "core/interface/IPrinterService.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 {
mApp.parse(argc, argv);
} catch (const CLI::ParseError& e) {
mApp.exit(e);
// Setup logging based on CLI flags
setupLogger();
// 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
if (mListDriversFlag) {
auto driverFactory = std::make_unique<PrinterDriverFactory>();
auto drivers = driverFactory->listAllDrivers();
const auto& options = mCliParser->getOptions();
fmt::print("Available printer drivers:\n");
for (const auto& driver : drivers) {
fmt::print(" - {}\n", driver);
}
fmt::print("\nUse with: -p <driver_name> or --printer <driver_name>\n");
return 0;
// Handle --list-all-drivers
if (options.listDrivers) {
return handleListDrivers() ? 0 : -1;
}
// Determine which printer to use
std::shared_ptr<IPrinterDriver> printer = nullptr;
// Handle printing
return handlePrinting() ? 0 : -1;
}
if (mPrinterSelection != "auto") {
// Explicit printer selection by name
auto driverFactory = std::make_unique<PrinterDriverFactory>();
printer = driverFactory->createByName(mPrinterSelection);
void PtouchPrint::setupLogger() {
const auto& options = mCliParser->getOptions();
if (!printer) {
spdlog::error("Failed to create printer driver '{}'", mPrinterSelection);
spdlog::info("Use --list-all-drivers to see available drivers");
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;
}
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();
fmt::print("Available printer drivers:\n");
for (const auto& driver : drivers) {
fmt::print(" - {}\n", driver);
}
fmt::print("\nUse with: -p <driver_name> or --printer <driver_name>\n");
return true;
}
bool PtouchPrint::handlePrinting() {
const auto& options = mCliParser->getOptions();
// Select printer
auto printer = mPrinterService->selectPrinter(options.printerSelection);
if (!printer) {
spdlog::error("Failed to select printer");
return false;
}
// 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 using LabelBuilder
graphics::LabelBuilder labelBuilder(printer->getPrinterInfo().pixelLines);
for (const auto& [cmd, value] : mCommands) {
switch (cmd) {
case CliCmdType::Text:
for (const auto& [cmdType, value] : options.commands) {
switch (cmdType) {
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!");
labelBuilder.setHAlign(HAlignPosition::UNKNOWN);
} else {
labelBuilder.setHAlign(hPos->second);
}
auto hPos = HALignPositionMap.find(value);
if (hPos == HALignPositionMap.end()) {
spdlog::warn("Invalid horizontal alignment specified!");
labelBuilder.setHAlign(HAlignPosition::UNKNOWN);
} 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!");
labelBuilder.setVAlign(VAlignPosition::UNKNOWN);
} else {
labelBuilder.setVAlign(vPos->second);
}
auto vPos = VALignPositionMap.find(value);
if (vPos == VALignPositionMap.end()) {
spdlog::warn("Invalid vertical alignment specified!");
labelBuilder.setVAlign(VAlignPosition::UNKNOWN);
} 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 +178,14 @@ int PtouchPrint::run() {
}
}
// Build and print the label
auto label = labelBuilder.build();
if (!printer->printLabel(std::move(label))) {
spdlog::error("An error occured while printing");
return -1;
if (!mPrinterService->printLabel(std::move(label))) {
spdlog::error("An error occurred while printing");
return false;
}
return 0;
return true;
}
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");
}
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);
}
// TODO: CLI parsing should be a seperate class/file
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
} // namespace ptprnt