252 lines
9.6 KiB
C++
252 lines
9.6 KiB
C++
/*
|
|
ptrnt - print labels on linux
|
|
Copyright (C) 2023 Moritz Martinius
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
#include "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 "graphics/Label.hpp"
|
|
#include "graphics/interface/ILabel.hpp"
|
|
#include "libusbwrap/UsbDeviceFactory.hpp"
|
|
|
|
namespace ptprnt {
|
|
|
|
PtouchPrint::PtouchPrint(const char* versionString) : mVersionString{versionString} {}
|
|
|
|
int PtouchPrint::init(int argc, char** argv) {
|
|
setupCliParser();
|
|
|
|
try {
|
|
mApp.parse(argc, argv);
|
|
} catch (const CLI::ParseError& e) {
|
|
mApp.exit(e);
|
|
return -1;
|
|
}
|
|
|
|
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);
|
|
SPDLOG_TRACE("testing trace");
|
|
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");
|
|
return -1;
|
|
} else if (numFoundPrinters > 1) {
|
|
spdlog::warn("Found more than one compatible printer. Currently not supported.");
|
|
return -1;
|
|
}
|
|
|
|
auto 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;
|
|
}
|
|
printer->attachUsbDevice(std::move(devices[0]));
|
|
auto status = printer->getPrinterStatus();
|
|
spdlog::info("Detected tape width is {}mm", status.tapeWidthMm);
|
|
|
|
if (0 == mCommands.size()) {
|
|
spdlog::warn("No command specified, nothing to do...");
|
|
return 0;
|
|
}
|
|
|
|
auto label = graphics::Label();
|
|
std::string labelText{};
|
|
|
|
for (const auto& [cmd, value] : mCommands) {
|
|
switch (cmd) {
|
|
case CliCmdType::Text:
|
|
if (labelText.empty()) {
|
|
labelText = value;
|
|
} else {
|
|
labelText = labelText + '\n' + value;
|
|
}
|
|
break;
|
|
case CliCmdType::Font:
|
|
spdlog::debug("Setting font to {}", value);
|
|
label.setFontFamily(value);
|
|
break;
|
|
case CliCmdType::FontSize:
|
|
spdlog::debug("Setting font size to {}", std::stod(value));
|
|
label.setFontSize(std::stod(value));
|
|
break;
|
|
case CliCmdType::HAlign:
|
|
spdlog::debug("Setting text horizontal alignment to {}", value);
|
|
{
|
|
auto hPos = HALignPositionMap.find(value);
|
|
if (hPos == HALignPositionMap.end()) {
|
|
spdlog::warn("Invalid horizontal alignment specified!");
|
|
label.setHAlign(HAlignPosition::UNKNOWN);
|
|
} else {
|
|
label.setHAlign(hPos->second);
|
|
}
|
|
}
|
|
break;
|
|
case CliCmdType::VAlign:
|
|
spdlog::debug("Setting text vertical alignment to {}", value);
|
|
{
|
|
auto vPos = VALignPositionMap.find(value);
|
|
if (vPos == VALignPositionMap.end()) {
|
|
spdlog::warn("Invalid verical alignment specified!");
|
|
label.setVAlign(VAlignPosition::UNKNOWN);
|
|
} else {
|
|
label.setVAlign(vPos->second);
|
|
}
|
|
}
|
|
break;
|
|
case CliCmdType::None:
|
|
[[fallthrough]];
|
|
default:
|
|
spdlog::warn("This command is currently not supported.");
|
|
break;
|
|
}
|
|
}
|
|
if (!printer->print()) {
|
|
spdlog::error("An error occured while printing");
|
|
return -1;
|
|
}
|
|
|
|
label.create(labelText, 128);
|
|
label.writeToPng("./testlabel.png");
|
|
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
|
|
consoleSink->set_pattern("%^%L:%$ %v (%s:%#)");
|
|
} 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);
|
|
}
|
|
|
|
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("-V,--version", printVersion, "Prints the ptprnt's version");
|
|
|
|
// 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::transform(in.begin(), in.end(), in.begin(), [](unsigned char c) { return std::tolower(c); });
|
|
if (validValignOptions.find(in) == validValignOptions.end()) {
|
|
return {""};
|
|
}
|
|
return in;
|
|
})
|
|
->each([this](std::string valign) { mCommands.emplace_back(CliCmdType::VAlign, valign); });
|
|
mApp.add_option("--halign", "Vertical alignment of the following text occurences")
|
|
->group("Text printing ")
|
|
->multi_option_policy(CLI::MultiOptionPolicy::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
|