Update copyright

Reviewed-on: moritz/ptouch-prnt#14

.clang-format

@@ -5,7 +5,7 @@ Language: Cpp
 BasedOnStyle: Google
 AccessModifierOffset: -1
 AlignAfterOpenBracket: Align
-AlignConsecutiveAssignments: None
+AlignConsecutiveAssignments: Consecutive
 AlignOperands: Align
 AllowAllArgumentsOnNextLine: true
 AllowAllConstructorInitializersOnNextLine: true
@@ -41,16 +41,16 @@ BreakBeforeBinaryOperators: None
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializers: BeforeColon
 BreakInheritanceList: BeforeColon
-ColumnLimit: 80
+ColumnLimit: 120
 CompactNamespaces: false
 ContinuationIndentWidth: 4
 Cpp11BracedListStyle: true
 DerivePointerAlignment: false
 EmptyLineBeforeAccessModifier: LogicalBlock
 FixNamespaceComments: true
-IncludeBlocks: Preserve
 IndentCaseLabels: true
 IndentPPDirectives: None
+IndentAccessModifiers: false
 IndentWidth: 4
 KeepEmptyLinesAtTheStartOfBlocks: true
 MaxEmptyLinesToKeep: 1
@@ -80,3 +80,17 @@ SpacesInSquareBrackets: false
 Standard: c++17
 TabWidth: 4
 UseTab: Never
+QualifierAlignment: Left
+SortIncludes: true
+IncludeBlocks: Regroup
+IncludeCategories:
+  # Classes own header is always priority 0
+  # System C/C++ headers in <> with extension.
+  - Regex: '<([A-Za-z0-9.\Q/-_\E])+.h.*>'
+    Priority: 1
+  # System Headers in <> without extension.
+  - Regex: '<([A-Za-z0-9.\Q/-_\E])+>'
+    Priority: 2
+  # c Headers in "" with extension.
+  - Regex: '"([A-Za-z0-9.\Q/-_\E])+"'
+    Priority: 3

.clang-format-include

@@ -1,2 +1,2 @@
-inc/*
 src/*
+tests/*

.clang-tidy

@@ -0,0 +1,34 @@
+---
+Checks: "clang-diagnostic-*,clang-analyzer-*,cppcoreguidelines-*,modernize-*,-modernize-use-trailing-return-type"
+WarningsAsErrors: true
+HeaderFilterRegex: ""
+FormatStyle: google
+CheckOptions:
+  - key: cert-dcl16-c.NewSuffixes
+    value: "L;LL;LU;LLU"
+  - key: cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField
+    value: "0"
+  - key: cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors
+    value: "1"
+  - key: cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
+    value: "1"
+  - key: google-readability-braces-around-statements.ShortStatementLines
+    value: "1"
+  - key: google-readability-function-size.StatementThreshold
+    value: "800"
+  - key: google-readability-namespace-comments.ShortNamespaceLines
+    value: "10"
+  - key: google-readability-namespace-comments.SpacesBeforeComments
+    value: "2"
+  - key: modernize-loop-convert.MaxCopySize
+    value: "16"
+  - key: modernize-loop-convert.MinConfidence
+    value: reasonable
+  - key: modernize-loop-convert.NamingStyle
+    value: CamelCase
+  - key: modernize-pass-by-value.IncludeStyle
+    value: llvm
+  - key: modernize-replace-auto-ptr.IncludeStyle
+    value: llvm
+  - key: modernize-use-nullptr.NullMacros
+    value: "NULL"

.gitea/workflows/build.yaml

@@ -0,0 +1,54 @@
+name: Build ptprnt
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Starting action...
+        run: echo "Branch ${{ gitea.ref }} will be built for project ${{ gitea.repository }}."
+      - name: Checkout branch
+        uses: actions/checkout@v3
+      - name: Update package cache
+        run: apt-get update
+      - name: install meson
+        run: apt-get -yq install meson
+      - name: Install build dependencies
+        run: apt-get -yq install libusb-1.0-0-dev libspdlog-dev libfmt-dev libpango1.0-dev libcairo2-dev gcovr
+      - name: get build environment versions
+        run: |
+          echo "=== Start meson version ==="
+          gcc --version
+          echo "=== End meson version ==="
+          echo "=== Start supported c/cpp standards: ==="
+          gcc -v --help 2> /dev/null | sed -n '/^ *-std=\([^<][^ ]\+\).*/ {s//\1/p}'
+          echo "=== End supported c/cpp standards ==="
+          echo "=== Start meson version ==="
+          meson --version
+          echo "=== End meson version ==="
+          echo "=== Start ninja version ==="
+          ninja --version
+          echo "=== End ninja version ==="
+          echo "=== Start dependency package version ==="
+          apt-cache policy libpango1.0-dev
+          apt-cache policy libcairo2-dev
+          apt-cache policy libfmt-dev 
+          apt-cache policy libspdlog-dev
+          apt-cache policy libusb-1.0-0-dev
+          echo "=== End dependency package version ==="
+      - name: setup builddir
+        run: meson setup builddir -Db_coverage=true
+      - name: build and test dist package
+        run: ninja -C builddir dist
+      - name: run unit tests
+        run: ninja -C builddir test
+      - name: calculate coverage
+        run: ninja -C builddir coverage-text
+      - name: Coverage report
+        run: cat ./builddir/meson-logs/coverage.txt
+      - name: upload dist package
+        uses: actions/upload-artifact@v3
+        with:
+          name: ptprnt-dist
+          path: ./builddir/meson-dist/*
+          if-no-files-found: error

.gitignore

@@ -1,5 +1,13 @@
+# Folder
 builddir/
+ptouch-print/
+subprojects/*
 .cache/
+coverageReport/
+
+# Files
+ptprnt.log
+!subprojects/*.wrap
 .vscode/*
 !.vscode/c_cpp_properties.json
 !.vscode/settings.json

.vscode/c_cpp_properties.json

@@ -1,15 +1,15 @@
 {
-    "configurations": [
+  "configurations": [
-      {
+    {
-        "name": "Linux",
+      "name": "Linux",
-        "compilerPath": "/usr/bin/clang",
+      "compilerPath": "/usr/bin/clang",
-        "cStandard": "c11",
+      "cStandard": "c11",
-        "cppStandard": "c++17",
+      "cppStandard": "c++20",
-        "compileCommands": "${workspaceFolder}/builddir/compile_commands.json",
+      "compileCommands": "${workspaceFolder}/builddir/compile_commands.json",
-        "browse": {
+      "browse": {
-          "path": ["${workspaceFolder}"]
+        "path": ["${workspaceFolder}"]
-        }
       }
-    ],
+    }
-    "version": 4
+  ],
+  "version": 4
 }

.vscode/launch.json

@@ -1,27 +1,30 @@
 {
-    // Verwendet IntelliSense zum Ermitteln möglicher Attribute.
+  // Verwendet IntelliSense zum Ermitteln möglicher Attribute.
-    // Zeigen Sie auf vorhandene Attribute, um die zugehörigen Beschreibungen anzuzeigen.
+  // Zeigen Sie auf vorhandene Attribute, um die zugehörigen Beschreibungen anzuzeigen.
-    // Weitere Informationen finden Sie unter https://go.microsoft.com/fwlink/?linkid=830387
+  // Weitere Informationen finden Sie unter https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
+  "version": "0.2.0",
-    "configurations": [
+  "configurations": [
+    {
+      "name": "ptprnt_debug",
+      "type": "lldb",
+      "request": "launch",
+      "program": "${workspaceFolder}/builddir/ptprnt",
+      "args": [
+        "-t i"
+      ],
+      "stopAtEntry": false,
+      "cwd": "${workspaceFolder}",
+      "environment": [],
+      "externalConsole": false,
+      "MIMode": "gdb",
+      "miDebuggerPath": "/usr/bin/gdb",
+      "setupCommands": [
         {
-            "name": "(gdb) Starten",
+          "description": "Automatische Strukturierung und Einrückung für \"gdb\" aktivieren",
-            "type": "cppdbg",
+          "text": "-enable-pretty-printing",
-            "request": "launch",
+          "ignoreFailures": true
-            "program": "${workspaceFolder}/builddir/ptprnt",
-            "args": [],
-            "stopAtEntry": false,
-            "cwd": "${fileDirname}",
-            "environment": [],
-            "externalConsole": false,
-            "MIMode": "gdb",
-            "setupCommands": [
-                {
-                    "description": "Automatische Strukturierung und Einrückung für \"gdb\" aktivieren",
-                    "text": "-enable-pretty-printing",
-                    "ignoreFailures": true
-                }
-            ]
         }
-    ]
+      ]
+    }
+  ]
 }

.vscode/settings.json

@@ -1,87 +1,96 @@
 {
-    "clangd.arguments": [   "-log=verbose", 
+  "clangd.arguments": [
-                            "-pretty", 
+    "-background-index",
-                            "--background-index", 
+    "-compile-commands-dir=builddir/"
-                            "--compile-commands-dir=${workspaceFolder}/builddir"
+  ],
-                        ],
+  "editor.formatOnType": false,
-    "files.associations": {
+  "editor.formatOnSave": true,
-        "cctype": "cpp",
+  "files.associations": {
-        "clocale": "cpp",
+    "cctype": "cpp",
-        "cmath": "cpp",
+    "clocale": "cpp",
-        "cstdarg": "cpp",
+    "cmath": "cpp",
-        "cstddef": "cpp",
+    "cstdarg": "cpp",
-        "cstdio": "cpp",
+    "cstddef": "cpp",
-        "cstdlib": "cpp",
+    "cstdio": "cpp",
-        "cstring": "cpp",
+    "cstdlib": "cpp",
-        "ctime": "cpp",
+    "cstring": "cpp",
-        "cwchar": "cpp",
+    "ctime": "cpp",
-        "cwctype": "cpp",
+    "cwchar": "cpp",
-        "array": "cpp",
+    "cwctype": "cpp",
-        "atomic": "cpp",
+    "array": "cpp",
-        "strstream": "cpp",
+    "atomic": "cpp",
-        "bit": "cpp",
+    "strstream": "cpp",
-        "*.tcc": "cpp",
+    "bit": "cpp",
-        "bitset": "cpp",
+    "*.tcc": "cpp",
-        "cfenv": "cpp",
+    "bitset": "cpp",
-        "chrono": "cpp",
+    "cfenv": "cpp",
-        "codecvt": "cpp",
+    "chrono": "cpp",
-        "compare": "cpp",
+    "codecvt": "cpp",
-        "complex": "cpp",
+    "compare": "cpp",
-        "concepts": "cpp",
+    "complex": "cpp",
-        "condition_variable": "cpp",
+    "concepts": "cpp",
-        "cstdint": "cpp",
+    "condition_variable": "cpp",
-        "deque": "cpp",
+    "cstdint": "cpp",
-        "forward_list": "cpp",
+    "deque": "cpp",
-        "list": "cpp",
+    "forward_list": "cpp",
-        "map": "cpp",
+    "list": "cpp",
-        "set": "cpp",
+    "map": "cpp",
-        "string": "cpp",
+    "set": "cpp",
-        "unordered_map": "cpp",
+    "string": "cpp",
-        "unordered_set": "cpp",
+    "unordered_map": "cpp",
-        "vector": "cpp",
+    "unordered_set": "cpp",
-        "exception": "cpp",
+    "vector": "cpp",
-        "algorithm": "cpp",
+    "exception": "cpp",
-        "functional": "cpp",
+    "algorithm": "cpp",
-        "iterator": "cpp",
+    "functional": "cpp",
-        "memory": "cpp",
+    "iterator": "cpp",
-        "memory_resource": "cpp",
+    "memory": "cpp",
-        "numeric": "cpp",
+    "memory_resource": "cpp",
-        "optional": "cpp",
+    "numeric": "cpp",
-        "random": "cpp",
+    "optional": "cpp",
-        "ratio": "cpp",
+    "random": "cpp",
-        "source_location": "cpp",
+    "ratio": "cpp",
-        "string_view": "cpp",
+    "source_location": "cpp",
-        "system_error": "cpp",
+    "string_view": "cpp",
-        "tuple": "cpp",
+    "system_error": "cpp",
-        "type_traits": "cpp",
+    "tuple": "cpp",
-        "utility": "cpp",
+    "type_traits": "cpp",
-        "fstream": "cpp",
+    "utility": "cpp",
-        "initializer_list": "cpp",
+    "fstream": "cpp",
-        "iomanip": "cpp",
+    "initializer_list": "cpp",
-        "iosfwd": "cpp",
+    "iomanip": "cpp",
-        "iostream": "cpp",
+    "iosfwd": "cpp",
-        "istream": "cpp",
+    "iostream": "cpp",
-        "limits": "cpp",
+    "istream": "cpp",
-        "mutex": "cpp",
+    "limits": "cpp",
-        "new": "cpp",
+    "mutex": "cpp",
-        "numbers": "cpp",
+    "new": "cpp",
-        "ostream": "cpp",
+    "numbers": "cpp",
-        "semaphore": "cpp",
+    "ostream": "cpp",
-        "shared_mutex": "cpp",
+    "semaphore": "cpp",
-        "sstream": "cpp",
+    "shared_mutex": "cpp",
-        "stdexcept": "cpp",
+    "sstream": "cpp",
-        "stop_token": "cpp",
+    "stdexcept": "cpp",
-        "streambuf": "cpp",
+    "stop_token": "cpp",
-        "thread": "cpp",
+    "streambuf": "cpp",
-        "cinttypes": "cpp",
+    "thread": "cpp",
-        "typeindex": "cpp",
+    "cinttypes": "cpp",
-        "typeinfo": "cpp",
+    "typeindex": "cpp",
-        "valarray": "cpp",
+    "typeinfo": "cpp",
-        "variant": "cpp",
+    "valarray": "cpp",
-        "csignal": "cpp",
+    "variant": "cpp",
-        "any": "cpp",
+    "csignal": "cpp",
-        "regex": "cpp",
+    "any": "cpp",
-        "future": "cpp",
+    "regex": "cpp",
-        "charconv": "cpp"
+    "future": "cpp",
-    }
+    "charconv": "cpp",
+    "*.ipp": "cpp"
+  },
+  "clangd.onConfigChanged": "restart",
+  "cSpell.words": [
+    "fontsize",
+    "halign",
+    "libusb",
+    "ptrnt"
+  ],
 }

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -0,0 +1,61 @@
+# ptprnt
+
+This is a rewrite of [ptouch-print](https://git.familie-radermacher.ch/linux/ptouch-print.git) as a toy project for my personal amusement. The currently available solutions are good enough for generating labels, but i wanted to explore libusb and maybe improve the functionality of my label printer. All credits for reverse engineering the USB commands to Dominic Rademacher.
+
+## Dependencies
+This project requires:
+- spdlog
+- libusb
+- pango
+- cairo
+- meson
+- gtest (optional, for testing, will be installed by meson)
+- gcov (optional, for coverage reports)
+
+Install dependencies on Arch Linux
+``` bash
+pacman -S libusb spdlog pango cairo meson gcovr
+```
+
+Install dependencies on Debian/Ubuntu
+``` bash
+apt-get install libusb-1.0-0-dev libspdlog-dev libfmt-dev libpango1.0-dev libcairo2-dev meson gcovr
+```
+
+## Build
+
+Clone the repository and simply let meson do the heavy lifting.
+
+```bash
+meson setup builddir 
+```
+If you want to generate coverage reports, enable them via the command line switch
+```bash 
+meson setup builddir -Db_coverage=true
+```
+
+Rebuild by simply invoking ninja
+```bash
+ninja -C builddir
+```
+
+## Run
+Run the binary from your builddir
+```bash 
+builddir/ptprnt
+```
+
+## Test
+Testing is done via gtest. To run your test simply invoke ninja with the "test" target.
+```bash
+ninja -C builddir test   
+```
+
+Coverage reports can be generated via gcov if you enabled them (see Build section) by building the `coverage-text` target.
+
+## License
+
+GPLv3, see [LICENSE](./LICENSE)
+
+## Author
+Moritz Martinius <moritz@admiralackbar.de>

generate_coverage.sh

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

inc/Bitmap.hpp

@@ -1,11 +0,0 @@
-#include <vector>
-
-#pragma once
-
-namespace ptprnt::bitmap {
-
-struct Bitmap {
-    std::vector<std::vector<int>> map;
-};
-
-}  // namespace ptprnt::bitmap

inc/DriverTypes.hpp

@@ -1,12 +0,0 @@
-#include <string>
-
-#pragma once
-
-namespace ptprnt::driver {
-
-struct info {
-    std::string name{""};
-    std::string version{""};
-};
-
-}  // namespace ptprnt::driver

inc/IDriver.hpp

@@ -1,44 +0,0 @@
-
-#include "DriverTypes.hpp"
-
-#pragma once
-
-namespace ptprnt::driver {
-
-class IDriver {
-   public:
-    virtual ~IDriver(){};
-
-    /**
-     * @brief Get Information struct about this driver
-     * 
-     * @return driver::info 
-     */
-    virtual driver::info getInfo() = 0;
-
-    /**
-     * @brief opens up the device specified 
-     * 
-     * @return true successfully open up device
-     * @return false failed to open device
-     */
-    virtual bool open() = 0;
-
-    /**
-    * @brief close the device
-    * 
-    * @return true successfully closed device
-    * @return false  failed to close device
-    */
-    virtual bool close() = 0;
-
-    /**
-     * @brief Send a command to device
-     * 
-     * @return true successfully sent command to device
-     * @return false error sending command
-     */
-    virtual bool command() = 0;
-};
-
-}  // namespace ptprnt::driver

inc/IPrinter.hpp

@@ -1,43 +0,0 @@
-
-#include "PrinterTypes.hpp"
-
-#include <memory>
-
-#include "Bitmap.hpp"
-
-#pragma once
-
-namespace ptprnt::printer {
-
-class IPrinter {
-   public:
-    virtual ~IPrinter(){};
-
-    /**
-     * @brief Get Information struct about the printer
-     * 
-     * @return driver::info 
-     */
-    virtual printer::info getInfo() = 0;
-
-    /**
-     * @brief Prints text immediatly
-     * 
-     * @param text Text to print
-     * @param fontSize Size of the text to print
-     * @return true Printing succeeded
-     * @return false Printing failed
-     */
-    virtual bool printText(std::string_view text, uint32_t fontSize) = 0;
-
-    /**
-     * @brief Prints supplied bitmap immediatly
-     * 
-     * @param bm Bitmap to print
-     * @return true Printing succeeded
-     * @return false Printing failed
-     */
-    virtual bool printBitmap(std::shared_ptr<bitmap::Bitmap> bm) = 0;
-};
-
-}  // namespace ptprnt::printer

inc/IUsb.hpp

@@ -1,17 +0,0 @@
-#include "UsbTypes.hpp"
-
-#include <vector>
-#include <optional>
-
-#pragma once
-
-namespace ptprnt::driver {
-
-class IUsb {
-   public:
-    virtual ~IUsb() = default;
-
-    virtual std::optional<std::vector<UsbDevice>> getDevices() = 0;
-};
-
-}  // namespace ptprnt::driver

inc/P700Driver.hpp

@@ -1,29 +0,0 @@
-#include "IDriver.hpp"
-
-#include <cstdint>
-#include <memory>
-
-#include "Usb.hpp"
-
-#pragma once
-
-namespace ptprnt::driver {
-
-class P700Driver : public IDriver {
- public:
-    P700Driver(std::shared_ptr<Usb> usbDriver, uint16_t usbDevVendor = 0x04f9, uint16_t usbDevId = 0x2061);
-    ~P700Driver() override;
-
-    driver::info getInfo() override;
-    bool open() override;
-    bool close() override;
-    bool command() override;
-
- private:
-    std::shared_ptr<Usb> mUsbDriver{0};
-    UsbDevice mUsbDev{0};
-
-    bool init();
-};
-
-}  // namespace ptprnt::driver

inc/P700Printer.hpp

@@ -1,25 +0,0 @@
-#include "IPrinter.hpp"
-
-#include <memory>
-
-#include "P700Driver.hpp"
-
-#pragma once
-
-namespace ptprnt::printer {
-
-class P700Printer : public IPrinter {
-   public:
-    P700Printer(std::unique_ptr<driver::P700Driver> driver);
-    ~P700Printer() override;
-
-    printer::info getInfo() override;
-    bool printText(std::string_view text, uint32_t fontSize) override;
-    bool printBitmap(std::shared_ptr<bitmap::Bitmap> bm) override;
-
-   private:
-    static info mPrinterInfo;
-    std::unique_ptr<driver::P700Driver> mDriver;
-};
-
-}  // namespace ptprnt::printer

inc/PrinterTypes.hpp

@@ -1,21 +0,0 @@
-#include <string>
-
-#pragma once
-
-namespace ptprnt::printer {
-
-enum class colorMode {
-    monochrome = 0,
-    color = 0,
-};
-
-struct info {
-    std::string name{""};
-    std::string revision{""};
-    uint32_t xres = {0};
-    uint32_t yres = {0};
-    colorMode color = {colorMode::monochrome};
-    bool cutter = {false};
-};
-
-}  // namespace ptprnt::printer

inc/Usb.hpp

@@ -1,21 +0,0 @@
-#include "IUsb.hpp"
-#include "UsbTypes.hpp"
-
-#include <libusb-1.0/libusb.h>
-
-#pragma once
-
-namespace ptprnt::driver {
-
-class Usb : public IUsb {
- public:
-    Usb();
-    ~Usb() override;
-
-    std::optional<std::vector<UsbDevice>> getDevices() override;
-
- private: 
-    std::vector<UsbDevice> mDevices{};
-};
-
-}  // namespace ptprnt::driver

inc/UsbTypes.hpp

@@ -1,15 +0,0 @@
-
-#include <libusb-1.0/libusb.h>
-
-#pragma once
-
-namespace ptprnt::driver {
-
-struct UsbDevice {
-    uint16_t vendorId{0};
-    uint16_t productId{0};
-    libusb_device* dev{nullptr};
-    libusb_device_handle* hndl{nullptr};
-};
-
-}  // namespace ptprnt::driver

meson.build

@@ -1,25 +1,67 @@
-project('ptprnt', 'cpp',
+project(
-    version: 'v0.1.0-'+run_command('git', 'rev-parse',  '--short', 'HEAD').stdout().strip(),
-    license: 'GPLv3',
-    default_options : ['c_std=c11', 'cpp_std=c++17']
-)
-
-usbdep = dependency('libusb-1.0')
-logdep = dependency('spdlog')
-
-incdir = include_directories('inc')
-
-srcs = [
-    'src/main.cpp',
-    'src/P700Driver.cpp',
-    'src/P700Printer.cpp',
-    'src/Usb.cpp'
-]
-
-executable(
     'ptprnt',
-    srcs,
+    'cpp',
-    include_directories : incdir,
+    version: 'v0.1.0-' + run_command(
-    dependencies : [usbdep, logdep],
+        'git',
-    cpp_args : ['-DPROJ_VERSION="'+meson.project_version()+'"']
+        'rev-parse',
+        '--short',
+        'HEAD',
+        check: true,
+    ).stdout().strip(),
+    license: 'GPLv3',
+    default_options: [
+        'c_std=c11',
+        'cpp_std=c++20',
+        'b_sanitize=none',
+        'b_lto=true',
+        'b_lto_mode=thin',
+        'b_thinlto_cache=true',
+    ],
 )
+
+usb_dep = dependency('libusb-1.0')
+log_dep = dependency('spdlog')
+fmt_dep = dependency('fmt')
+pangocairo_dep = dependency('pangocairo')
+
+# CLI11 
+cli11_proj = subproject('cli11')
+cli11_dep = cli11_proj.get_variable('CLI11_dep')
+if not cli11_dep.found()
+    error('CLI11 not found, can not proceed')
+endif
+
+incdir = include_directories('src')
+
+subdir('src')
+
+# Build arguments
+cpp_args = ['-DPROJ_VERSION="' + meson.project_version() + '"']
+
+# USB trace mode option (for debugging without sending to hardware)
+if get_option('usb_trace_only')
+    cpp_args += ['-DUSB_TRACE_ONLY']
+    message('USB_TRACE_ONLY enabled: USB data will be logged but not sent to device')
+endif
+
+ptprnt_exe = executable(
+    'ptprnt',
+    'src/main.cpp',
+    install: true,
+    dependencies: [usb_dep, log_dep, fmt_dep, pangocairo_dep, cli11_dep],
+    include_directories: incdir,
+    sources: [ptprnt_srcs],
+    cpp_args: cpp_args,
+)
+
+
+### Unit tests
+
+# GTest
+gtest_proj = subproject('gtest')
+gtest_dep = gtest_proj.get_variable('gtest_main_dep')
+if not gtest_dep.found()
+    error('MESON_SKIP_TEST: gtest not installed.')
+endif
+
+subdir('tests')

meson_options.txt

@@ -0,0 +1,4 @@
+option('usb_trace_only',
+  type: 'boolean',
+  value: false,
+  description: 'Enable USB trace mode: log USB data without sending to device (saves label tape during debugging)')

src/P700Driver.cpp

@@ -1,66 +0,0 @@
-#include "P700Driver.hpp"
-
-#include <iostream>
-#include <stdexcept>
-
-#include <spdlog/spdlog.h>
-
-namespace ptprnt::driver {
-
-P700Driver::P700Driver(std::shared_ptr<Usb> usbDriver, uint16_t usbDevVendor, uint16_t usbProductId)
-    : mUsbDriver{std::move(usbDriver)}
-    , mUsbDev{.vendorId = usbDevVendor, .productId = usbProductId}
-
-{
-    spdlog::debug("P700Driver constructing");
-    if(!init()) {
-        spdlog::error("Could not find any P700 Printers.");
-    }
-    else {
-        spdlog::info("Found P700 Printer :-).");
-    }
-}
-
-P700Driver::~P700Driver() {
-    spdlog::debug("P700Driver destructing");
-}
-
-driver::info P700Driver::getInfo() {
-    return driver::info{};
-}
-
-bool P700Driver::open() {
-    return false;
-}
-
-bool P700Driver::close() {
-    return false;
-}
-
-bool P700Driver::command() {
-    return false;
-}
-
-bool P700Driver::init() {
-    auto devs = mUsbDriver->getDevices();
-
-    if(!devs.has_value()) {
-        spdlog::error("No USB devices found");
-        return false;
-    }
-    
-    auto devIt = std::find_if(devs.value().begin(), devs.value().end(), 
-        [=] (auto dev) { return mUsbDev.vendorId == dev.vendorId && mUsbDev.productId == dev.productId;}
-    );
-
-    if(devIt == devs.value().end()) {
-        spdlog::error("No device with {0:04X}:{1:04X}", mUsbDev.vendorId, mUsbDev.productId);
-        return false;
-    }
-
-    mUsbDev = *devIt;
-
-    return true;
-}
-
-}  // namespace ptprnt::driver

src/P700Printer.cpp

@@ -1,32 +0,0 @@
-#include "P700Printer.hpp"
-
-#include <iostream>
-#include <stdexcept>
-
-namespace ptprnt::printer {
-
-P700Printer::P700Printer(std::unique_ptr<driver::P700Driver> driver) {
-    if (!driver->open()) {
-        throw std::invalid_argument("Could not open driver!");
-    }
-}
-
-P700Printer::~P700Printer() {
-    if (!mDriver->close()) {
-        std::cerr << "Could not close driver properly!" << std::endl;
-    }
-}
-
-printer::info P700Printer::getInfo() {
-    return printer::info{};
-}
-
-bool P700Printer::printText(std::string_view text, uint32_t fontSize) {
-    return false;
-}
-
-bool P700Printer::printBitmap(std::shared_ptr<bitmap::Bitmap> bm) {
-    return false;
-}
-
-}  // namespace ptprnt::printer

src/PtouchPrint.cpp

@@ -0,0 +1,191 @@
+/*
+    ptrnt - print labels on linux
+    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
+    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 <fmt/core.h>
+#include <spdlog/sinks/basic_file_sink.h>
+#include <spdlog/sinks/stdout_color_sinks.h>
+#include <spdlog/spdlog.h>
+
+#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"
+
+namespace ptprnt {
+
+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) {
+    // Parse CLI arguments
+    int parseResult = mCliParser->parse(argc, argv);
+    if (parseResult != 0) {
+        // Pass through: positive = clean exit (help/version), negative = error
+        return parseResult;
+    }
+
+    // Setup logging based on CLI flags
+    setupLogger();
+
+    // Initialize printer service
+    if (!mPrinterService->initialize()) {
+        return -1;
+    }
+
+    return 0;
+}
+
+int PtouchPrint::run() {
+    spdlog::info("ptprnt version {}", mVersionString);
+
+    const auto& options = mCliParser->getOptions();
+
+    // 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();
+
+    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);
+
+    // Check if there are any commands
+    if (options.commands.empty()) {
+        spdlog::warn("No command specified, nothing to do...");
+        return true;
+    }
+
+    // Build label using LabelBuilder
+    graphics::LabelBuilder labelBuilder(printer->getPrinterInfo().pixelLines);
+
+    for (const auto& [cmdType, value] : options.commands) {
+        switch (cmdType) {
+            case cli::CommandType::Text:
+                labelBuilder.addText(value);
+                break;
+            case cli::CommandType::Font:
+                spdlog::debug("Setting font to {}", value);
+                labelBuilder.setFontFamily(value);
+                break;
+            case cli::CommandType::FontSize:
+                spdlog::debug("Setting font size to {}", std::stod(value));
+                labelBuilder.setFontSize(std::stod(value));
+                break;
+            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);
+                }
+                break;
+            }
+            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);
+                }
+                break;
+            }
+            case cli::CommandType::None:
+                [[fallthrough]];
+            default:
+                spdlog::warn("This command is currently not supported.");
+                break;
+        }
+    }
+
+    // Build and print the label
+    auto label = labelBuilder.build();
+    if (!mPrinterService->printLabel(std::move(label))) {
+        spdlog::error("An error occurred while printing");
+        return false;
+    }
+
+    return true;
+}
+
+}  // namespace ptprnt

src/PtouchPrint.hpp

@@ -0,0 +1,93 @@
+/*
+    ptrnt - print labels on linux
+    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
+    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>
+
+namespace ptprnt::cli {
+class ICliParser;
+}
+
+namespace ptprnt::core {
+class IPrinterService;
+}
+
+namespace ptprnt {
+
+/**
+ * @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);
+
+    /**
+     * @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:
+    void setupLogger();
+    bool handleListDrivers();
+    bool handlePrinting();
+
+    std::string mVersionString;
+    std::unique_ptr<cli::ICliParser> mCliParser;
+    std::unique_ptr<core::IPrinterService> mPrinterService;
+};
+
+}  // namespace ptprnt

src/Usb.cpp

@@ -1,46 +0,0 @@
-#include "Usb.hpp"
-
-#include <iostream>
-#include <iomanip>
-#include <optional>
-#include <spdlog/spdlog.h>
-
-namespace ptprnt::driver {
-
-Usb::Usb() {
-    spdlog::debug("Usb constructing");
-    libusb_init(NULL);
-}
-Usb::~Usb() {
-    spdlog::debug("Usb destructing");
-}
-
-std::optional<std::vector<UsbDevice>> Usb::getDevices() {
-    libusb_device ** devs;
-    libusb_device *dev;
-    struct libusb_device_descriptor desc;
-    int r,i=0;
-
-    mDevices.clear();
-
-    libusb_get_device_list(NULL, &devs);
-
-    while ((dev=devs[i++]) != NULL) {
-        UsbDevice newDev;
-
-		if ((r=libusb_get_device_descriptor(dev, &desc)) < 0) {
-			spdlog::error("failed to open device");
-			libusb_free_device_list(devs, 1);
-            return std::nullopt;
-		}
-
-        newDev.vendorId = desc.idVendor;
-        newDev.productId = desc.idProduct;
-
-        mDevices.push_back(newDev);
-    }
-
-    return mDevices;
-}
-
-}  // namespace ptprnt::driver

src/cli/CliParser.cpp

@@ -0,0 +1,94 @@
+/*
+    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
+    }
+    return 0;
+}
+
+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); });
+}
+
+}  // namespace ptprnt::cli

src/cli/CliParser.hpp

@@ -0,0 +1,75 @@
+/*
+    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();
+
+    CLI::App mApp;
+    std::string mVersionString;
+    CliOptions mOptions;
+};
+
+}  // namespace ptprnt::cli

src/cli/interface/ICliParser.hpp

@@ -0,0 +1,73 @@
+/*
+    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 };
+
+/**
+ * @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;
+
+    /**
+     * @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/constants.hpp

@@ -0,0 +1,26 @@
+/* 
+    ptrnt - print labels on linux
+    Copyright (C) 2023  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#pragma once
+
+namespace ptprnt {
+constexpr const char* const APP_NAME = "ptprnt";
+constexpr const char* const APP_DESC =
+    "ptprnt - a userspace driver for Brother P-touch label printer";
+}  // namespace ptprnt

src/core/PrinterDriverFactory.cpp

@@ -0,0 +1,69 @@
+/* 
+    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 "PrinterDriverFactory.hpp"
+
+#include <algorithm>
+#include <spdlog/spdlog.h>
+
+#include <memory>
+
+#include "libusbwrap/LibUsbTypes.hpp"
+#include "printers/FakePrinter.hpp"
+#include "printers/P700Printer.hpp"
+
+namespace ptprnt {
+
+std::shared_ptr<IPrinterDriver> PrinterDriverFactory::create(libusbwrap::usbId id) {
+
+    if (printer::P700Printer::mInfo.usbId == id) {
+        spdlog::info("Found printer P700!");
+        return std::make_shared<printer::P700Printer>();
+    } else {
+        spdlog::trace("{:04x}:{:04x} is not a compatible printer", id.first, id.second);
+    }
+    return nullptr;
+}
+
+std::shared_ptr<IPrinterDriver> PrinterDriverFactory::createFakePrinter() {
+    spdlog::info("Creating FakePrinter (virtual test printer)");
+    return std::make_shared<printer::FakePrinter>();
+}
+
+std::shared_ptr<IPrinterDriver> PrinterDriverFactory::createByName(const std::string& driverName) {
+    // Convert to lowercase for case-insensitive comparison
+    std::string nameLower = driverName;
+    std::ranges::transform(nameLower, nameLower.begin(), [](unsigned char c) { return std::tolower(c); });
+
+    if (nameLower == "p700" || nameLower == "p700printer") {
+        spdlog::info("Creating P700 printer driver by name");
+        return std::make_shared<printer::P700Printer>();
+    } else if (nameLower == "fakeprinter" || nameLower == "fake") {
+        return createFakePrinter();
+    }
+
+    spdlog::warn("Unknown printer driver name: {}", driverName);
+    return nullptr;
+}
+
+std::vector<std::string> PrinterDriverFactory::listAllDrivers() const {
+    return {std::string(printer::P700Printer::mInfo.driverName), std::string(printer::FakePrinter::mInfo.driverName)};
+}
+
+}  // namespace ptprnt

src/core/PrinterDriverFactory.hpp

@@ -0,0 +1,68 @@
+/* 
+    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 <memory>
+#include <string>
+#include <vector>
+
+#include "printers/interface/IPrinterDriver.hpp"
+#include "libusbwrap/LibUsbTypes.hpp"
+
+namespace ptprnt {
+
+class PrinterDriverFactory {
+   public:
+    PrinterDriverFactory()  = default;
+    ~PrinterDriverFactory() = default;
+
+    PrinterDriverFactory(const PrinterDriverFactory&)            = delete;
+    PrinterDriverFactory& operator=(const PrinterDriverFactory&) = delete;
+    PrinterDriverFactory(PrinterDriverFactory&&)                 = delete;
+    PrinterDriverFactory& operator=(PrinterDriverFactory&&)      = delete;
+
+    /**
+     * @brief Create a printer driver based on USB ID
+     * @param id USB vendor and product ID
+     * @return Printer driver instance or nullptr if no match
+     */
+    std::shared_ptr<IPrinterDriver> create(libusbwrap::usbId id);
+
+    /**
+     * @brief Create a virtual FakePrinter for testing without hardware
+     * @return FakePrinter instance
+     */
+    std::shared_ptr<IPrinterDriver> createFakePrinter();
+
+    /**
+     * @brief Create a printer driver by name
+     * @param driverName Name of the driver (from PrinterInfo.driverName)
+     * @return Printer driver instance or nullptr if no match
+     */
+    std::shared_ptr<IPrinterDriver> createByName(const std::string& driverName);
+
+    /**
+     * @brief Get list of all available printer driver names
+     * @return Vector of driver names
+     */
+    std::vector<std::string> listAllDrivers() const;
+
+   private:
+};
+
+}  // namespace ptprnt

src/core/PrinterService.cpp

@@ -0,0 +1,95 @@
+/*
+    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) {
+            mDetectedPrinters.push_back(driver);
+        }
+    }
+
+    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) {
+            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.cpp

@@ -0,0 +1,84 @@
+/* 
+    ptrnt - print labels on linux
+    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
+    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 "Bitmap.hpp"
+
+#include <spdlog/spdlog.h>
+
+#include <ranges>
+#include <stdexcept>
+#include <vector>
+
+namespace ptprnt::graphics {
+template <class T>
+Bitmap<T>::Bitmap(uint16_t width, uint16_t height) : mWidth{width}, mHeight{height}, mPixels(width * height) {}
+
+template <class T>
+[[nodiscard]] uint16_t Bitmap<T>::getWidth() const {
+    return mWidth;
+}
+
+template <class T>
+[[nodiscard]] uint16_t Bitmap<T>::getHeight() const {
+    return mHeight;
+}
+
+template <class T>
+bool Bitmap<T>::setPixels(const std::vector<T>& pixels) {
+    if (pixels.size() != mPixels.size()) {
+        spdlog::error("Invalid pixel buffer size (got {} vs. {} bitmap size).", pixels.size(), mPixels.size());
+        return false;
+    }
+
+    mPixels = pixels;
+    return true;
+}
+
+template <class T>
+[[nodiscard]] std::vector<T> Bitmap<T>::getPixelsCpy() const {
+    return mPixels;
+}
+
+template <class T>
+[[nodiscard]] std::vector<T> Bitmap<T>::getLine(const uint16_t lineNo) const {
+    if (lineNo >= mHeight) {
+        throw(std::out_of_range("Line is out of range!"));
+    }
+    auto lineStart = mPixels.begin() + (lineNo * mWidth);
+    auto lineEnd   = mPixels.begin() + ((lineNo + 1) * mWidth);
+    return std::vector<T>(lineStart, lineEnd);
+}
+
+// TODO: I guess this is borked
+template <class T>
+[[nodiscard]] std::vector<T> Bitmap<T>::getCol(const uint16_t colNo) const {
+    if (colNo >= mWidth) {
+        throw(std::out_of_range("Col is out of range!"));
+    }
+
+    std::vector<T> col{};
+    col.reserve(mHeight);
+    for (size_t i{0}; i <= mPixels.size(); i++) {
+        if (i % mWidth == colNo) {
+            col.push_back(mPixels[i]);
+        }
+    }
+    return col;
+}
+}  // namespace ptprnt::graphics

src/graphics/Bitmap.hpp

@@ -0,0 +1,63 @@
+/* 
+    ptrnt - print labels on linux
+    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
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <span>
+#include <vector>
+
+namespace ptprnt::graphics {
+
+using ALPHA8 = std::uint8_t;   // Alpha only, 8 bit per pixel
+using RGBX8  = std::uint32_t;  // RGB, least significant byte unused, 8 bit per channel
+using RGBA8  = std::uint32_t;  // RGB, least significant byte alpha, 8 bit per channel
+using ARGB8  = std::uint32_t;  // RGB, most significant byte alpha, 8 bit per channel
+
+template <class T>
+class Bitmap {
+   public:
+    Bitmap(uint16_t width, uint16_t height);
+    ~Bitmap() = default;
+
+    Bitmap(const Bitmap&)            = default;
+    Bitmap& operator=(const Bitmap&) = default;
+    Bitmap(Bitmap&&)                 = default;
+    Bitmap& operator=(Bitmap&&)      = default;
+
+    [[nodiscard]] uint16_t getWidth() const;
+    [[nodiscard]] uint16_t getHeight() const;
+    bool setPixels(const std::vector<T>& pixels);
+    [[nodiscard]] std::vector<T> getPixelsCpy() const;
+    [[nodiscard]] std::vector<T> getLine(uint16_t line) const;
+    [[nodiscard]] std::vector<T> getCol(uint16_t col) const;
+    void visualize() const;
+
+   private:
+    uint16_t mWidth;
+    uint16_t mHeight;
+    std::vector<T> mPixels;
+};
+
+// force compiler to generate class for type ALPHA8 and RGBX8
+template class Bitmap<ALPHA8>;
+template class Bitmap<RGBX8>;
+
+}  // namespace ptprnt::graphics

src/graphics/Label.cpp

@@ -0,0 +1,229 @@
+/* 
+    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 "graphics/Label.hpp"
+
+#include <algorithm>
+#include <spdlog/spdlog.h>
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "cairo.h"
+#include "graphics/interface/ILabel.hpp"
+#include "pango/pango-font.h"
+#include "pango/pango-layout.h"
+#include "pango/pango-types.h"
+#include "pango/pangocairo.h"
+
+namespace ptprnt::graphics {
+Label::Label(const uint16_t heightPixel)
+    : mPrinterHeight(heightPixel) {
+    // Initialize resources in correct order with RAII
+    mFontMap.reset(pango_cairo_font_map_new());
+}
+
+std::vector<uint8_t> Label::getRaw() {
+    assert(mSurface != nullptr);
+    auto* surface = mSurface.get();
+
+    cairo_surface_flush(surface);
+    assert(cairo_image_surface_get_format(surface) == CAIRO_FORMAT_A8);
+
+    int width = cairo_image_surface_get_width(surface);
+    int height = cairo_image_surface_get_height(surface);
+    int stride = 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);
+
+    // If stride equals width, we can return data directly
+    if (stride == width) {
+        size_t len = height * stride;
+        return {data, data + len};
+    }
+
+    // Otherwise, we need to copy row by row, removing stride padding
+    std::vector<uint8_t> result;
+    result.reserve(width * height);
+
+    for (int y = 0; y < height; ++y) {
+        uint8_t* row_start = data + (y * stride);
+        result.insert(result.end(), row_start, row_start + width);
+    }
+
+    spdlog::debug("getRaw: Removed stride padding, returning {} bytes ({}x{})", result.size(), width, height);
+    return result;
+}
+
+uint8_t Label::getNumLines(std::string_view strv) {
+    return std::count(strv.begin(), strv.end(), '\n');
+}
+
+int Label::getWidth() {
+    // Return the actual Cairo surface width (which is the layout width)
+    return mLayoutWidth;
+}
+
+int Label::getHeight() {
+    // 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);
+    pango_layout_set_text(layout, text.c_str(), static_cast<int>(text.length()));
+    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);
+            break;
+        case HAlignPosition::RIGHT:
+            pango_layout_set_alignment(layout, PANGO_ALIGN_RIGHT);
+            break;
+        case HAlignPosition::JUSTIFY:
+            pango_layout_set_alignment(layout, PANGO_ALIGN_LEFT);
+            pango_layout_set_justify(layout, true);
+#if PANGO_VERSION_MAJOR >= 1 && PANGO_VERSION_MINOR >= 50
+            pango_layout_set_justify_last_line(layout, true);
+#endif
+            break;
+        case HAlignPosition::CENTER:
+            [[fallthrough]];
+        default:
+            pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
+            break;
+    }
+}
+
+bool Label::create(PrintableText printableText) {
+    setFontFamily(printableText.fontFamily);
+    setFontSize(printableText.fontSize);
+
+    return create(printableText.text);
+}
+
+bool Label::create(const std::string& labelText) {
+    // TODO: we need to create a custom font config here so that Noto Emoji does not load the systems default
+    // font config here. For this, we need to create a PangoFcFontMap and a custom FcConfig
+    // see: https://docs.gtk.org/PangoFc/method.FontMap.set_config.html
+    // see: https://gist.github.com/CallumDev/7c66b3f9cf7a876ef75f
+
+    // Create a temporary surface for layout size calculations
+    auto* tempSurface = cairo_image_surface_create(CAIRO_FORMAT_A8, 1, 1);
+    auto* tempCr = cairo_create(tempSurface);
+    auto* tempPangoCtx = pango_cairo_create_context(tempCr);
+    auto* tempPangoLyt = pango_layout_new(tempPangoCtx);
+
+    PangoFontDescription* regularFont = pango_font_description_new();
+    pango_font_description_set_size(regularFont, static_cast<int>(mFontSize * PANGO_SCALE));
+    pango_font_description_set_family(regularFont, mFontFamily.c_str());
+
+    // 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);
+    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);
+    g_object_unref(tempPangoCtx);
+    cairo_destroy(tempCr);
+    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));
+    cairo_t* cr = cairo_create(mSurface.get());
+    mCairoCtx.reset(cr);
+    mPangoCtx.reset(pango_cairo_create_context(cr));
+    mPangoLyt.reset(pango_layout_new(mPangoCtx.get()));
+
+    // Configure final layout with same settings
+    configureLayout(mPangoLyt.get(), labelText, regularFont);
+    applyHorizontalAlignment(mPangoLyt.get());
+
+    // Adjust Cairo cursor position to respect the vertical alignment
+    switch (mVAlign) {
+        case VAlignPosition::TOP:
+            break;
+        case VAlignPosition::BOTTOM:
+            cairo_move_to(mCairoCtx.get(), 0.0, mPrinterHeight - mLayoutHeight);
+            break;
+        case VAlignPosition::MIDDLE:
+            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());
+
+    cairo_set_source_rgb(mCairoCtx.get(), 0.0, 0.0, 0.0);
+    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());
+        cairo_surface_write_to_png(mSurface.get(), file.c_str());
+    }
+}
+
+void Label::setFontSize(const double fontSize) {
+    mFontSize = fontSize;
+}
+
+void Label::setFontFamily(const std::string& fontFamily) {
+    mFontFamily = fontFamily;
+}
+
+void Label::setHAlign(HAlignPosition hAlign) {
+    mHAlign = hAlign;
+}
+
+void Label::setVAlign(VAlignPosition vAlign) {
+    mVAlign = vAlign;
+}
+
+void Label::setText(const std::string& text) {
+    mText = text;
+}
+
+Label::~Label() {
+    spdlog::debug("Image dtor...");
+    // RAII smart pointers handle cleanup automatically
+}
+}  // namespace ptprnt::graphics

src/graphics/Label.hpp

@@ -0,0 +1,100 @@
+/* 
+    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 <pango/pangocairo.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "cairo.h"
+#include "graphics/interface/ILabel.hpp"
+#include "pango/pango-types.h"
+
+namespace ptprnt::graphics {
+
+// Custom deleters for Cairo/Pango resources
+struct CairoSurfaceDeleter {
+    void operator()(cairo_surface_t* surface) const {
+        if (surface)
+            cairo_surface_destroy(surface);
+    }
+};
+
+struct CairoDeleter {
+    void operator()(cairo_t* cr) const {
+        if (cr)
+            cairo_destroy(cr);
+    }
+};
+
+struct GObjectDeleter {
+    void operator()(gpointer obj) const {
+        if (obj)
+            g_object_unref(obj);
+    }
+};
+
+class Label : public ILabel {
+   public:
+    Label(const uint16_t heightPixel);
+    ~Label() override;
+
+    Label(const Label&)            = delete;
+    Label& operator=(const Label&) = delete;
+    Label(Label&&)                 = delete;
+    Label& operator=(Label&&)      = delete;
+
+    bool create(PrintableText printableText) override;
+    bool create(const std::string& labelText) override;
+    void writeToPng(const std::string& file);
+    [[nodiscard]] int getWidth() override;
+    [[nodiscard]] int getHeight() override;
+    [[nodiscard]] std::vector<uint8_t> getRaw() override;
+    void setFontSize(const double fontSize) override;
+    void setFontFamily(const std::string& fontFamily) override;
+
+    void setText(const std::string& text) override;
+    void setHAlign(HAlignPosition hpos) override;
+    void setVAlign(VAlignPosition vpos) override;
+
+   private:
+    // methods
+    [[nodiscard]] uint8_t getNumLines(std::string_view str);
+    [[nodiscard]] PangoFontMap* createCustomFontMap();
+    void configureLayout(PangoLayout* layout, const std::string& text, PangoFontDescription* fontDesc);
+    void applyHorizontalAlignment(PangoLayout* layout);
+
+    std::unique_ptr<cairo_surface_t, CairoSurfaceDeleter> mSurface{nullptr};
+    std::unique_ptr<cairo_t, CairoDeleter> mCairoCtx{nullptr};
+    std::unique_ptr<PangoContext, GObjectDeleter> mPangoCtx{nullptr};
+    std::unique_ptr<PangoLayout, GObjectDeleter> mPangoLyt{nullptr};
+    std::unique_ptr<PangoFontMap, GObjectDeleter> mFontMap{nullptr};
+    double mFontSize{DEFAULT_FONT_SIZE};
+    std::string mFontFamily{DEFAULT_FONT_FAMILY};
+    HAlignPosition mHAlign = HAlignPosition::LEFT;
+    VAlignPosition mVAlign = VAlignPosition::MIDDLE;
+    std::string mText{""};
+    int mLayoutWidth = 0, mLayoutHeight = 0;
+    int mPrinterHeight = 0;
+};
+}  // namespace ptprnt::graphics

src/graphics/LabelBuilder.cpp

@@ -0,0 +1,95 @@
+/*
+    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 "LabelBuilder.hpp"
+
+#include <spdlog/spdlog.h>
+
+#include "Label.hpp"
+
+namespace ptprnt::graphics {
+
+LabelBuilder::LabelBuilder(int printerHeight) : mPrinterHeight(printerHeight) {
+    reset();
+}
+
+ILabelBuilder& LabelBuilder::addText(const std::string& text) {
+    if (!text.empty()) {
+        if (!mAccumulatedText.empty()) {
+            // Add a newline if the label already has some text accumulated
+            mAccumulatedText += '\n';
+        }
+        mAccumulatedText += text;
+        spdlog::debug("LabelBuilder: Added text '{}', total length: {}", text, mAccumulatedText.length());
+    }
+    return *this;
+}
+
+ILabelBuilder& LabelBuilder::setFontFamily(const std::string& fontFamily) {
+    mCurrentFontFamily = fontFamily;
+    spdlog::debug("LabelBuilder: Set font family to '{}'", fontFamily);
+    return *this;
+}
+
+ILabelBuilder& LabelBuilder::setFontSize(double fontSize) {
+    mCurrentFontSize = fontSize;
+    spdlog::debug("LabelBuilder: Set font size to {}", fontSize);
+    return *this;
+}
+
+ILabelBuilder& LabelBuilder::setHAlign(HAlignPosition hAlign) {
+    mCurrentHAlign = hAlign;
+    spdlog::debug("LabelBuilder: Set horizontal alignment to {}", static_cast<int>(hAlign));
+    return *this;
+}
+
+ILabelBuilder& LabelBuilder::setVAlign(VAlignPosition vAlign) {
+    mCurrentVAlign = vAlign;
+    spdlog::debug("LabelBuilder: Set vertical alignment to {}", static_cast<int>(vAlign));
+    return *this;
+}
+
+std::unique_ptr<ILabel> LabelBuilder::build() {
+    spdlog::debug("LabelBuilder: Building label with text: '{}'", mAccumulatedText);
+
+    auto label = std::make_unique<Label>(mPrinterHeight);
+
+    // Apply current formatting settings
+    label->setFontFamily(mCurrentFontFamily);
+    label->setFontSize(mCurrentFontSize);
+    label->setHAlign(mCurrentHAlign);
+    label->setVAlign(mCurrentVAlign);
+
+    // Create the label with accumulated text
+    label->create(mAccumulatedText);
+
+    return label;
+}
+
+ILabelBuilder& LabelBuilder::reset() {
+    mAccumulatedText.clear();
+    mCurrentFontFamily = DEFAULT_FONT_FAMILY;
+    mCurrentFontSize   = DEFAULT_FONT_SIZE;
+    mCurrentHAlign     = HAlignPosition::LEFT;
+    mCurrentVAlign     = VAlignPosition::MIDDLE;
+    spdlog::debug("LabelBuilder: Reset to default state");
+    return *this;
+}
+
+}  // namespace ptprnt::graphics

src/graphics/LabelBuilder.hpp

@@ -0,0 +1,64 @@
+/*
+    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/ILabel.hpp"
+#include "interface/ILabelBuilder.hpp"
+
+namespace ptprnt::graphics {
+
+/**
+ * @brief Concrete implementation of ILabelBuilder
+ *
+ * Builds labels by accumulating text segments with formatting options,
+ * then creates a Label instance with all the collected content.
+ */
+class LabelBuilder : public ILabelBuilder {
+   public:
+    /**
+     * @brief Construct a LabelBuilder for a specific printer height
+     * @param printerHeight Height of the printer in pixels (tape width)
+     */
+    explicit LabelBuilder(int printerHeight);
+
+    ~LabelBuilder() override = default;
+
+    ILabelBuilder& addText(const std::string& text) override;
+    ILabelBuilder& setFontFamily(const std::string& fontFamily) override;
+    ILabelBuilder& setFontSize(double fontSize) override;
+    ILabelBuilder& setHAlign(HAlignPosition hAlign) override;
+    ILabelBuilder& setVAlign(VAlignPosition vAlign) override;
+    std::unique_ptr<ILabel> build() override;
+    ILabelBuilder& reset() override;
+
+   private:
+    int mPrinterHeight;
+    std::string mAccumulatedText;
+    std::string mCurrentFontFamily{DEFAULT_FONT_FAMILY};
+    double mCurrentFontSize{DEFAULT_FONT_SIZE};
+    HAlignPosition mCurrentHAlign{HAlignPosition::LEFT};
+    VAlignPosition mCurrentVAlign{VAlignPosition::MIDDLE};
+};
+
+}  // namespace ptprnt::graphics

src/graphics/Monochrome.cpp

@@ -0,0 +1,259 @@
+/* 
+    ptrnt - print labels on linux
+    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
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#include "graphics/Monochrome.hpp"
+
+#include <cmath>
+
+#include <iostream>
+#include <vector>
+
+namespace ptprnt::graphics {
+// Constructor from grayscale data
+MonochromeData::MonochromeData(const std::vector<uint8_t>& grayscale, uint32_t width, uint32_t height, 
+                               Orientation orient)
+    : stride(0),
+      orientation(orient),
+      width(width),
+      height(height),
+      mPixels(grayscale),
+      mIsProcessed(false) {}
+
+MonochromeData::MonochromeData(const std::span<uint8_t> grayscale, uint32_t width, uint32_t height,
+                               Orientation orient)
+    : stride(0),
+      orientation(orient),
+      width(width),
+      height(height),
+      mPixels(grayscale.begin(), grayscale.end()),
+      mIsProcessed(false) {}
+
+void MonochromeData::setThreshold(uint8_t threshold) {
+    mThreshold   = threshold;
+    mIsProcessed = false;  // Mark as needing reprocessing
+}
+
+void MonochromeData::invert(bool shouldInvert) {
+    mShouldInvert = shouldInvert;
+    mIsProcessed  = false;  // Mark as needing reprocessing
+}
+
+MonochromeData MonochromeData::get() {
+    if (!mIsProcessed) {
+        processGrayscaleToMonochrome();
+        mIsProcessed = true;
+    }
+
+    // Return a copy of the processed data
+    MonochromeData result;
+    result.bytes        = bytes;
+    result.stride       = stride;
+    result.orientation  = orientation;
+    result.width        = width;
+    result.height       = height;
+    result.mIsProcessed = true;
+    return result;
+}
+
+void MonochromeData::processGrayscaleToMonochrome() {
+    // Calculate stride based on packed monochrome data (1 bit per pixel, 8 pixels per byte)
+    stride = static_cast<uint32_t>((width + 7) / 8);
+
+    // Create the monochrome byte array
+    bytes.clear();
+    bytes.resize(stride * height, 0);
+
+    // Convert grayscale to monochrome
+    for (uint32_t y = 0; y < height; ++y) {
+        for (uint32_t x = 0; x < width; ++x) {
+            uint32_t pixelIndex = y * width + x;
+            if (pixelIndex < mPixels.size()) {
+                uint8_t pixelValue = mPixels[pixelIndex];
+
+                // Apply threshold
+                bool isSet = pixelValue >= mThreshold;
+
+                // Apply inversion if needed
+                if (mShouldInvert) {
+                    isSet = !isSet;
+                }
+
+                // Set the bit in the monochrome data
+                if (isSet) {
+                    setBit(x, y, true);
+                }
+            }
+        }
+    }
+}
+
+// Transformation methods implementation
+void MonochromeData::transformTo(Orientation targetOrientation) {
+    if (orientation == targetOrientation) {
+        return;  // No transformation needed
+    }
+
+    auto rotatedData = createRotatedData(targetOrientation);
+    bytes            = std::move(rotatedData);
+
+    // Update dimensions and stride based on rotation
+    switch (targetOrientation) {
+        case Orientation::PORTRAIT:
+        case Orientation::PORTRAIT_FLIPPED:
+            // Swap width and height for portrait orientations
+            std::swap(width, height);
+            stride = (width + 7) / 8;  // Recalculate stride for new width
+            break;
+        case Orientation::LANDSCAPE:
+        case Orientation::LANDSCAPE_FLIPPED:
+            // Keep original stride calculation
+            stride = (width + 7) / 8;
+            break;
+    }
+
+    orientation = targetOrientation;
+}
+
+bool MonochromeData::getBit(uint32_t x, uint32_t y) const {
+    if (x >= width || y >= height) {
+        return false;
+    }
+
+    uint32_t byteIndex = y * stride + x / 8;
+    uint32_t bitIndex  = 7 - (x % 8);  // MSB first
+
+    if (byteIndex >= bytes.size()) {
+        return false;
+    }
+
+    return (bytes[byteIndex] >> bitIndex) & 1;
+}
+
+void MonochromeData::setBit(uint32_t x, uint32_t y, bool value) {
+    if (x >= width || y >= height) {
+        return;
+    }
+
+    uint32_t byteIndex = y * stride + x / 8;
+    uint32_t bitIndex  = 7 - (x % 8);  // MSB first
+
+    if (byteIndex >= bytes.size()) {
+        return;
+    }
+
+    if (value) {
+        bytes[byteIndex] |= (1 << bitIndex);
+    } else {
+        bytes[byteIndex] &= ~(1 << bitIndex);
+    }
+}
+
+std::vector<uint8_t> MonochromeData::createRotatedData(Orientation targetOrientation) const {
+    uint32_t newWidth = 0, newHeight = 0;
+
+    // Determine new dimensions
+    switch (targetOrientation) {
+        case Orientation::PORTRAIT:
+        case Orientation::PORTRAIT_FLIPPED:
+            newWidth  = height;
+            newHeight = width;
+            break;
+        case Orientation::LANDSCAPE:
+        case Orientation::LANDSCAPE_FLIPPED:
+        default:
+            newWidth  = width;
+            newHeight = height;
+            break;
+    }
+
+    uint32_t newStride = (newWidth + 7) / 8;
+    std::vector<uint8_t> newBytes(newStride * newHeight, 0);
+
+    // Create a temporary MonochromeData for the new image
+    MonochromeData tempData;
+    tempData.bytes       = std::move(newBytes);
+    tempData.stride      = newStride;
+    tempData.width       = newWidth;
+    tempData.height      = newHeight;
+    tempData.orientation = targetOrientation;
+
+    // Copy pixels with appropriate transformation
+    for (uint32_t y = 0; y < height; ++y) {
+        for (uint32_t x = 0; x < width; ++x) {
+            bool pixel    = getBit(x, y);
+            uint32_t newX = 0, newY = 0;
+
+            switch (targetOrientation) {
+                case Orientation::LANDSCAPE:
+                    newX = x;
+                    newY = y;
+                    break;
+                case Orientation::PORTRAIT:  // 90 degrees clockwise
+                    newX = height - 1 - y;
+                    newY = x;
+                    break;
+                case Orientation::LANDSCAPE_FLIPPED:  // 180 degrees
+                    newX = width - 1 - x;
+                    newY = height - 1 - y;
+                    break;
+                case Orientation::PORTRAIT_FLIPPED:  // 270 degrees clockwise
+                    newX = y;
+                    newY = width - 1 - x;
+                    break;
+            }
+
+            tempData.setBit(newX, newY, pixel);
+        }
+    }
+
+    return std::move(tempData.bytes);
+}
+
+void MonochromeData::visualize() const {
+    std::cout << "MonochromeData visualization (" << width << "x" << height << ", orientation: ";
+
+    switch (orientation) {
+        case Orientation::LANDSCAPE:
+            std::cout << "LANDSCAPE";
+            break;
+        case Orientation::PORTRAIT:
+            std::cout << "PORTRAIT";
+            break;
+        case Orientation::LANDSCAPE_FLIPPED:
+            std::cout << "LANDSCAPE_FLIPPED";
+            break;
+        case Orientation::PORTRAIT_FLIPPED:
+            std::cout << "PORTRAIT_FLIPPED";
+            break;
+    }
+
+    std::cout << "):" << std::endl;
+
+    // Print the image row by row
+    for (uint32_t y = 0; y < height; ++y) {
+        for (uint32_t x = 0; x < width; ++x) {
+            bool pixel = getBit(x, y);
+            std::cout << (pixel ? "█" : ".");
+        }
+        std::cout << std::endl;
+    }
+    std::cout << std::endl;
+}
+
+}  // namespace ptprnt::graphics

src/graphics/Monochrome.hpp

@@ -0,0 +1,100 @@
+/* 
+    ptrnt - print labels on linux
+    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
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <span>
+#include <vector>
+
+#include "graphics/Bitmap.hpp"
+
+namespace ptprnt::graphics {
+
+enum class Orientation {
+    LANDSCAPE         = 0,  // 0 degrees
+    PORTRAIT          = 1,  // 90 degrees clockwise
+    LANDSCAPE_FLIPPED = 2,  // 180 degrees
+    PORTRAIT_FLIPPED  = 3   // 270 degrees clockwise (90 counter-clockwise)
+};
+
+class MonochromeData {
+   public:
+    // Constructors
+    MonochromeData() : stride(0), orientation(Orientation::LANDSCAPE), width(0), height(0) {}
+
+    MonochromeData(std::vector<uint8_t> data, uint32_t stride_bytes, Orientation orient = Orientation::LANDSCAPE,
+                   uint32_t w = 0, uint32_t h = 0)
+        : bytes(std::move(data)), stride(stride_bytes), orientation(orient), width(w), height(h) {}
+
+    // Constructor from grayscale data (replaces old Monochrome class)
+    MonochromeData(const std::vector<uint8_t>& grayscale, uint32_t width, uint32_t height,
+                   Orientation orient = Orientation::LANDSCAPE);
+    MonochromeData(const std::span<uint8_t> grayscale, uint32_t width, uint32_t height,
+                   Orientation orient = Orientation::LANDSCAPE);
+
+    ~MonochromeData() = default;
+
+    // Copy constructor and assignment
+    MonochromeData(const MonochromeData&)            = default;
+    MonochromeData& operator=(const MonochromeData&) = default;
+
+    // Move constructor and assignment
+    MonochromeData(MonochromeData&&)            = default;
+    MonochromeData& operator=(MonochromeData&&) = default;
+
+    // Configuration methods
+    void setThreshold(uint8_t threshold);
+    void invert(bool shouldInvert);
+
+    // Get processed monochrome data
+    MonochromeData get();
+
+    // Transform the image data to the target orientation
+    void transformTo(Orientation targetOrientation);
+
+    // Visualize the monochrome data on stdout
+    void visualize() const;
+
+    // Helper methods for orientation transformations
+    [[nodiscard]] bool getBit(uint32_t x, uint32_t y) const;
+    void setBit(uint32_t x, uint32_t y, bool value);
+    [[nodiscard]] std::vector<uint8_t> createRotatedData(Orientation targetOrientation) const;
+
+    // Public member access for backward compatibility
+    std::vector<uint8_t> bytes;
+    uint32_t stride;
+    Orientation orientation;
+    uint32_t width;   // Width in pixels
+    uint32_t height;  // Height in pixels
+
+   private:
+    // Processing parameters (for old Monochrome class compatibility)
+    std::vector<uint8_t> mPixels;  // Original grayscale pixels
+    uint8_t mThreshold = UINT8_MAX / 2;
+    bool mShouldInvert = false;
+    bool mIsProcessed  = false;  // Flag to indicate if conversion has been done
+
+    // Helper method to convert grayscale to monochrome
+    void processGrayscaleToMonochrome();
+};
+
+// For backward compatibility, create a type alias
+using Monochrome = MonochromeData;
+}  // namespace ptprnt::graphics

src/graphics/interface/ILabel.hpp

@@ -0,0 +1,80 @@
+/* 
+    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 <cstdint>
+#include <map>
+#include <string>
+#include <vector>
+
+constexpr const char* DEFAULT_FONT_FAMILY = "sans";
+constexpr const double DEFAULT_FONT_SIZE  = 32.0;
+
+enum class HAlignPosition {
+    UNKNOWN = 0,
+    LEFT    = 1,
+    CENTER  = 2,
+    RIGHT   = 3,
+    JUSTIFY = 4,
+};
+const std::map<std::string, HAlignPosition> HALignPositionMap{{"", HAlignPosition::UNKNOWN},
+                                                              {"left", HAlignPosition::LEFT},
+                                                              {"center", HAlignPosition::CENTER},
+                                                              {"right", HAlignPosition::RIGHT},
+                                                              {"justify", HAlignPosition::JUSTIFY}};
+
+enum class VAlignPosition {
+    UNKNOWN = 0,
+    TOP     = 1,
+    MIDDLE  = 2,
+    BOTTOM  = 3,
+};
+
+const std::map<std::string, VAlignPosition> VALignPositionMap{{"", VAlignPosition::UNKNOWN},
+                                                              {"top", VAlignPosition::TOP},
+                                                              {"middle", VAlignPosition::MIDDLE},
+                                                              {"bottom", VAlignPosition::BOTTOM}};
+
+struct PrintableText {
+    std::string text{""};
+    std::string fontFamily{DEFAULT_FONT_FAMILY};
+    double fontSize{DEFAULT_FONT_SIZE};
+    HAlignPosition hAlign{HAlignPosition::LEFT};
+    VAlignPosition vAlign{VAlignPosition::MIDDLE};
+};
+
+namespace ptprnt::graphics {
+class ILabel {
+   public:
+    virtual ~ILabel() = default;
+
+    virtual bool create(PrintableText printableText)  = 0;
+    virtual bool create(const std::string& labelText) = 0;
+    virtual std::vector<uint8_t> getRaw()             = 0;
+    virtual int getWidth()                            = 0;
+    virtual int getHeight()                           = 0;
+
+    virtual void setText(const std::string& text)             = 0;
+    virtual void setFontSize(const double fontSize)           = 0;
+    virtual void setFontFamily(const std::string& fontFamily) = 0;
+    virtual void setHAlign(HAlignPosition hpos)               = 0;
+    virtual void setVAlign(VAlignPosition vpos)               = 0;
+};
+}  // namespace ptprnt::graphics

src/graphics/interface/ILabelBuilder.hpp

@@ -0,0 +1,88 @@
+/*
+    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 "ILabel.hpp"
+
+namespace ptprnt::graphics {
+
+/**
+ * @brief Builder interface for creating labels with text and formatting options
+ *
+ * The LabelBuilder provides a fluent API for constructing labels with various
+ * text elements, fonts, sizes, and alignment options. It separates the construction
+ * logic from the label rendering logic, making it easier to test and maintain.
+ */
+class ILabelBuilder {
+   public:
+    virtual ~ILabelBuilder() = default;
+
+    /**
+     * @brief Add text to the label with current formatting settings
+     * @param text The text to add
+     * @return Reference to this builder for method chaining
+     */
+    virtual ILabelBuilder& addText(const std::string& text) = 0;
+
+    /**
+     * @brief Set the font family for subsequent text additions
+     * @param fontFamily Font family name (e.g., "sans", "serif", "monospace")
+     * @return Reference to this builder for method chaining
+     */
+    virtual ILabelBuilder& setFontFamily(const std::string& fontFamily) = 0;
+
+    /**
+     * @brief Set the font size for subsequent text additions
+     * @param fontSize Font size in points
+     * @return Reference to this builder for method chaining
+     */
+    virtual ILabelBuilder& setFontSize(double fontSize) = 0;
+
+    /**
+     * @brief Set horizontal alignment for subsequent text additions
+     * @param hAlign Horizontal alignment position
+     * @return Reference to this builder for method chaining
+     */
+    virtual ILabelBuilder& setHAlign(HAlignPosition hAlign) = 0;
+
+    /**
+     * @brief Set vertical alignment for subsequent text additions
+     * @param vAlign Vertical alignment position
+     * @return Reference to this builder for method chaining
+     */
+    virtual ILabelBuilder& setVAlign(VAlignPosition vAlign) = 0;
+
+    /**
+     * @brief Build and return the label with all added content
+     * @return Unique pointer to the constructed label
+     */
+    virtual std::unique_ptr<ILabel> build() = 0;
+
+    /**
+     * @brief Reset the builder to initial state
+     * @return Reference to this builder for method chaining
+     */
+    virtual ILabelBuilder& reset() = 0;
+};
+
+}  // namespace ptprnt::graphics

src/libusbwrap/LibUsbTypes.hpp

@@ -0,0 +1,46 @@
+/* 
+    ptrnt - print labels on linux
+    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
+    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 <utility>
+
+#include "libusb.h"
+
+namespace libusbwrap {
+enum class Error {
+    SUCCESS       = LIBUSB_SUCCESS,
+    IO            = LIBUSB_ERROR_IO,
+    INVALID_PARAM = LIBUSB_ERROR_INVALID_PARAM,
+    ACCESS        = LIBUSB_ERROR_ACCESS,
+    NO_DEVICE     = LIBUSB_ERROR_NO_DEVICE,
+    NOT_FOUND     = LIBUSB_ERROR_NOT_FOUND,
+    BUSY          = LIBUSB_ERROR_BUSY,
+    TIMEOUT       = LIBUSB_ERROR_TIMEOUT,
+    OVERFLOW      = LIBUSB_ERROR_OVERFLOW,
+    PIPE          = LIBUSB_ERROR_PIPE,
+    INTERRUPTED   = LIBUSB_ERROR_INTERRUPTED,
+    NO_MEM        = LIBUSB_ERROR_NO_MEM,
+    NOT_SUPPORTED = LIBUSB_ERROR_NOT_SUPPORTED,
+    OTHER         = LIBUSB_ERROR_OTHER
+};
+
+using usbId = std::pair<uint16_t, uint16_t>;
+
+}  // namespace libusbwrap

src/libusbwrap/UsbDevice.cpp

@@ -0,0 +1,129 @@
+/* 
+    ptrnt - print labels on linux
+    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
+    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 "libusbwrap/UsbDevice.hpp"
+
+#include <cstdint>
+#include <stdexcept>
+
+#include "libusb.h"
+#include "libusbwrap/LibUsbTypes.hpp"
+#include "libusbwrap/interface/IUsbDevice.hpp"
+
+namespace libusbwrap {
+UsbDevice::UsbDevice(libusb_context* ctx, usbDevice_ptr dev) : mLibusbCtx(ctx), mLibusbDev(std::move(dev)) {
+    if (mLibusbCtx == nullptr || mLibusbDev == nullptr) {
+        throw std::invalid_argument("ctx or device are nullptr");
+    }
+
+    libusb_get_device_descriptor(mLibusbDev.get(), &mLibusbDevDesc);
+}
+
+UsbDevice::~UsbDevice() {
+    // only free the device, not the context, which is shared between every device
+    // the UsbDeviceFactory will take care of that
+    if (mIsOpen) {
+        close();
+    }
+}
+
+bool UsbDevice::open() {
+    int openStatus = libusb_open(mLibusbDev.get(), &mLibusbDevHandle);
+    if (openStatus != 0) {
+        mLastError = static_cast<Error>(openStatus);
+        return false;
+    }
+
+    return true;
+}
+
+void UsbDevice::close() {
+    libusb_close(mLibusbDevHandle);
+}
+
+bool UsbDevice::detachKernelDriver(int interfaceNo) {
+    // TODO: cover the other status codes that can be returned
+    int kernelDriverStatus = libusb_kernel_driver_active(mLibusbDevHandle, interfaceNo);
+    if (kernelDriverStatus == 1) {  // kernel driver is active, we have to detach to continue...
+        int detachStatus = libusb_detach_kernel_driver(mLibusbDevHandle, interfaceNo);
+        if (detachStatus != 0) {
+            mLastError = static_cast<Error>(detachStatus);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool UsbDevice::claimInterface(int interfaceNo) {
+    // TODO: cover the other status codes that can be returned
+    int claimInterfaceStatus = libusb_claim_interface(mLibusbDevHandle, interfaceNo);
+    if (claimInterfaceStatus != 0) {
+        mLastError = static_cast<Error>(claimInterfaceStatus);
+        return false;
+    }
+    return true;
+}
+
+bool UsbDevice::releaseInterface(int interfaceNo) {
+    int releaseInterfaceStatus = libusb_release_interface(mLibusbDevHandle, interfaceNo);
+    if (releaseInterfaceStatus != 0) {
+        mLastError = static_cast<Error>(releaseInterfaceStatus);
+        return false;
+    }
+    return true;
+}
+
+bool UsbDevice::bulkTransfer(uint8_t endpoint, const std::vector<uint8_t>& data, int* tx, unsigned int timeout) {
+    // TODO: implement error handling for incomplete transactions (tx length != data length)
+    int bulkTransferStatus = 0;
+
+    bulkTransferStatus = libusb_bulk_transfer(mLibusbDevHandle, endpoint, const_cast<unsigned char*>(data.data()),
+                                              data.size(), tx, timeout);
+    if (bulkTransferStatus != 0) {
+        mLastError = static_cast<Error>(bulkTransferStatus);
+        return false;
+    }
+    return true;
+}
+
+const usbId UsbDevice::getUsbId() {
+    return {mLibusbDevDesc.idVendor, mLibusbDevDesc.idProduct};
+}
+
+const device::Speed UsbDevice::getSpeed() {
+    return static_cast<device::Speed>(libusb_get_device_speed(mLibusbDev.get()));
+}
+
+const uint8_t UsbDevice::getBusNumber() {
+    return libusb_get_bus_number(mLibusbDev.get());
+}
+
+const uint8_t UsbDevice::getPortNumber() {
+    return libusb_get_port_number(mLibusbDev.get());
+}
+
+const Error UsbDevice::getLastError() {
+    return mLastError;
+}
+
+const std::string UsbDevice::getLastErrorString() {
+    return std::string(libusb_error_name(static_cast<int>(mLastError)));
+}
+}  // namespace libusbwrap

src/libusbwrap/UsbDevice.hpp

@@ -0,0 +1,79 @@
+/* 
+    ptrnt - print labels on linux
+    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
+    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 <atomic>
+#include <memory>
+
+#include "libusb.h"
+#include "libusbwrap/LibUsbTypes.hpp"
+#include "libusbwrap/interface/IUsbDevice.hpp"
+
+namespace libusbwrap {
+
+struct usbDevice_deleter {
+    void operator()(libusb_device* dev_ptr) const {
+        if (nullptr != dev_ptr) {
+            libusb_unref_device(dev_ptr);
+        }
+    }
+};
+
+using usbDevice_ptr = std::unique_ptr<libusb_device, usbDevice_deleter>;
+
+class UsbDevice : public IUsbDevice {
+   public:
+    explicit UsbDevice(libusb_context* ctx, usbDevice_ptr dev);
+    ~UsbDevice() override;
+
+    // delete copy ctor and assignment
+    UsbDevice(const UsbDevice&)            = delete;
+    UsbDevice& operator=(const UsbDevice&) = delete;
+    UsbDevice(UsbDevice&&)                 = delete;
+    UsbDevice& operator=(UsbDevice&&)      = delete;
+
+    bool open() override;
+    void close() override;
+
+    // libusb wrappers
+    bool detachKernelDriver(int interfaceNo) override;
+    bool claimInterface(int interfaceNo) override;
+    bool releaseInterface(int interfaceNo) override;
+    bool bulkTransfer(uint8_t endpoint, const std::vector<uint8_t>& data, int* tx, unsigned int timeout) override;
+
+    // getters
+    const usbId getUsbId() override;
+    const device::Speed getSpeed() override;
+    const uint8_t getBusNumber() override;
+    const uint8_t getPortNumber() override;
+
+    // errors
+    const Error getLastError() override;
+    const std::string getLastErrorString() override;
+
+   private:
+    libusb_context* mLibusbCtx{nullptr};
+    usbDevice_ptr mLibusbDev{nullptr};
+    libusb_device_handle* mLibusbDevHandle{nullptr};
+    libusb_device_descriptor mLibusbDevDesc{0};
+    std::atomic<bool> mIsOpen = false;
+    Error mLastError          = Error::SUCCESS;
+};
+}  // namespace libusbwrap

src/libusbwrap/UsbDeviceFactory.cpp

@@ -0,0 +1,99 @@
+/* 
+    ptrnt - print labels on linux
+    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
+    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 "libusbwrap/UsbDeviceFactory.hpp"
+
+#include <spdlog/spdlog.h>
+#include <sys/types.h>
+
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include "libusb.h"
+#include "libusbwrap/UsbDevice.hpp"
+#include "libusbwrap/interface/IUsbDevice.hpp"
+
+namespace libusbwrap {
+
+UsbDeviceFactory::~UsbDeviceFactory() {
+    if (mLibusbCtx) {
+        libusb_exit(mLibusbCtx);
+    }
+};
+
+std::vector<std::unique_ptr<IUsbDevice>> UsbDeviceFactory::findAllDevices() {
+    refreshDeviceList();
+    return buildMaskedDeviceVector(0x0, 0x0, 0x0, 0x0);
+}
+
+std::vector<std::unique_ptr<IUsbDevice>> UsbDeviceFactory::findDevices(uint16_t vid, uint16_t pid) {
+    refreshDeviceList();
+    return buildMaskedDeviceVector(LIBUSB_BITMASK_ALL, LIBUSB_BITMASK_ALL, vid, pid);
+}
+
+ssize_t UsbDeviceFactory::refreshDeviceList() {
+    libusb_device** list{nullptr};
+
+    ssize_t ret = libusb_get_device_list(mLibusbCtx, &list);
+    mLibusbDeviceList.clear();
+    if (ret < 0) {
+        spdlog::error("Error enumarating USB devices");
+    } else if (ret == 0) {
+        spdlog::warn("No USB devices found");
+    }
+
+    for (ssize_t i = 0; i < ret; i++) {
+        mLibusbDeviceList.emplace_back(list[i]);
+    }
+
+    libusb_free_device_list(list, false);
+    return ret;
+}
+
+std::vector<std::unique_ptr<IUsbDevice>> UsbDeviceFactory::buildMaskedDeviceVector(uint16_t vidMask, uint16_t pidMask,
+                                                                                   uint16_t vid, uint16_t pid) {
+    std::vector<std::unique_ptr<IUsbDevice>> matchedDevices;
+    // see libusb/examples/listdevs.c
+    for (auto& currDev : mLibusbDeviceList) {
+        struct libusb_device_descriptor currDevDesc{};
+
+        int ret = libusb_get_device_descriptor(currDev.get(), &currDevDesc);
+        spdlog::trace("Detected Device {:04x}:{:04x} ", currDevDesc.idVendor, currDevDesc.idProduct);
+        if (ret < 0) {
+            continue;
+        }
+        if (((currDevDesc.idVendor & vidMask) == vid) && ((currDevDesc.idProduct & pidMask) == pid)) {
+            matchedDevices.push_back(std::make_unique<UsbDevice>(mLibusbCtx, std::move(currDev)));
+        }
+    }
+    return matchedDevices;
+}
+
+bool UsbDeviceFactory::init() {
+    auto err = libusb_init(&mLibusbCtx);
+
+    if (err != (int)Error::SUCCESS) {
+        spdlog::error("Could not intialize libusb");
+        return false;
+    }
+
+    return true;
+}
+}  // namespace libusbwrap

src/libusbwrap/UsbDeviceFactory.hpp

@@ -0,0 +1,71 @@
+/* 
+    ptrnt - print labels on linux
+    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
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#pragma once
+
+#include <cstdint>
+
+#include "libusb.h"
+#include "libusbwrap/UsbDevice.hpp"
+#include "libusbwrap/interface/IUsbDeviceFactory.hpp"
+
+namespace libusbwrap {
+
+constexpr const uint16_t LIBUSB_BITMASK_ALL = 0xffff;
+
+class UsbDeviceFactory : public IUsbDeviceFactory {
+   public:
+    UsbDeviceFactory() = default;
+    virtual ~UsbDeviceFactory();
+
+    // delete copy ctor and assignment
+    UsbDeviceFactory(const UsbDeviceFactory&)       = delete;
+    UsbDeviceFactory& operator=(UsbDeviceFactory&)  = delete;
+    UsbDeviceFactory(UsbDeviceFactory&&)            = delete;
+    UsbDeviceFactory& operator=(UsbDeviceFactory&&) = delete;
+
+    bool init();
+    /**
+     * @brief Gets all devices that are detected by libusb. Will allocate a shared_ptr for each Device
+     * 
+     * @return std::vector<std::shared_ptr<IUsbDevice>> Vector of all detected USB devices
+     */
+    std::vector<std::unique_ptr<IUsbDevice>> findAllDevices() override;
+    /**
+     * @brief Gets all devices with certain vid/pid combination. 
+     *        If only one device of certain type is connected, vector is usually only one element
+     * 
+     * @param vid VendorId of the devices to find
+     * @param pid ProductId of the devices to find
+     * @return std::vector<std::shared_ptr<IUsbDevice>> Vector of detected USB devices based on vid/pid
+     */
+    std::vector<std::unique_ptr<IUsbDevice>> findDevices(uint16_t vid, uint16_t pid) override;
+
+   private:
+    // methods
+    ssize_t refreshDeviceList();
+    std::vector<std::unique_ptr<IUsbDevice>> buildMaskedDeviceVector(uint16_t vidMask,
+                                                                     uint16_t pidMask, uint16_t vid,
+                                                                     uint16_t pid);
+    // members
+    libusb_context* mLibusbCtx{nullptr};
+    std::vector<usbDevice_ptr> mLibusbDeviceList{};
+    bool mDeviceListInitialized = false;
+};
+}  // namespace libusbwrap

src/libusbwrap/interface/IUsbDevice.hpp

@@ -0,0 +1,66 @@
+/* 
+    ptrnt - print labels on linux
+    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
+    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 <sys/types.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "libusb.h"
+#include "libusbwrap/LibUsbTypes.hpp"
+
+namespace libusbwrap {
+namespace device {
+enum class Speed {
+    UNKNOWN    = LIBUSB_SPEED_UNKNOWN,
+    LOW        = LIBUSB_SPEED_LOW,
+    FULL       = LIBUSB_SPEED_FULL,
+    HIGH       = LIBUSB_SPEED_HIGH,
+    SUPER      = LIBUSB_SPEED_SUPER,
+    SUPER_PLUS = LIBUSB_SPEED_SUPER_PLUS
+};
+}  // namespace device
+
+class IUsbDevice {
+   public:
+    virtual ~IUsbDevice() = default;
+
+    virtual bool open()  = 0;
+    virtual void close() = 0;
+
+    // libusb wrappers
+    virtual bool detachKernelDriver(int interfaceNo)                                                             = 0;
+    virtual bool claimInterface(int interfaceNo)                                                                 = 0;
+    virtual bool releaseInterface(int interfaceNo)                                                               = 0;
+    virtual bool bulkTransfer(uint8_t endpoint, const std::vector<uint8_t>& data, int* tx, unsigned int timeout) = 0;
+
+    // getters
+    virtual const usbId getUsbId()         = 0;
+    virtual const device::Speed getSpeed() = 0;
+    virtual const uint8_t getBusNumber()   = 0;
+    virtual const uint8_t getPortNumber()  = 0;
+
+    // errors
+    virtual const Error getLastError()             = 0;
+    virtual const std::string getLastErrorString() = 0;
+};
+}  // namespace libusbwrap

src/libusbwrap/interface/IUsbDeviceFactory.hpp

@@ -0,0 +1,35 @@
+/* 
+    ptrnt - print labels on linux
+    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
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include "libusbwrap/interface/IUsbDevice.hpp"
+
+namespace libusbwrap {
+class IUsbDeviceFactory {
+   public:
+    virtual ~IUsbDeviceFactory()                                                             = default;
+    virtual std::vector<std::unique_ptr<IUsbDevice>> findAllDevices()                        = 0;
+    virtual std::vector<std::unique_ptr<IUsbDevice>> findDevices(uint16_t vid, uint16_t pid) = 0;
+};
+}  // namespace libusbwrap

src/main.cpp

@@ -1,37 +1,31 @@
-#include <iostream>
+/* 
-#include <memory>
+    ptrnt - print labels on linux
+    Copyright (C) 2022-2025  Moritz Martinius
 
-#include "IPrinter.hpp"
+    This program is free software: you can redistribute it and/or modify
-#include "P700Printer.hpp"
+    it under the terms of the GNU General Public License as published by
-#include "Usb.hpp"
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
 
-#include <libusb-1.0/libusb.h>
+    This program is distributed in the hope that it will be useful,
-#include <spdlog/spdlog.h>
+    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.
 
-using namespace ptprnt;
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-void setupLogger() {
+ */
-    spdlog::set_level(spdlog::level::debug); 
+#include "PtouchPrint.hpp"
-    spdlog::info("Starting ptprnt {}", PROJ_VERSION);
-
-}
 
 int main(int argc, char** argv) {
-    setupLogger();
+    ptprnt::PtouchPrint ptouchprnt(PROJ_VERSION);
-
+    int ret = ptouchprnt.init(argc, argv);
-    auto usb = std::make_shared<driver::Usb>();
+    if (ret != 0) {
-    auto maybeDevs = usb->getDevices();
+        // Non-zero from init means don't continue
-    if(!maybeDevs.has_value()) {
+        // Positive values = clean exit (help/version)
-        spdlog::error("No USB devices found");
+        // Negative values = error
-        return -1;
+        return ret > 0 ? 0 : ret;
     }
-
+    return ptouchprnt.run();
-    auto driver = std::make_unique<driver::P700Driver>(usb);
-    //auto printer = std::make_unique<printer::P700Printer>(std::move(driver));
-    //printer::info info = printer->getInfo();
-
-    return 0;
 }
-
-
-

src/meson.build

@@ -0,0 +1,34 @@
+ptprnt_hpps = files(
+    'cli/CliParser.hpp',
+    'core/PrinterDriverFactory.hpp',
+    'core/PrinterService.hpp',
+    'graphics/Bitmap.hpp',
+    'graphics/Label.hpp',
+    'graphics/LabelBuilder.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(
+    'cli/CliParser.cpp',
+    'core/PrinterDriverFactory.cpp',
+    'core/PrinterService.cpp',
+    'graphics/Bitmap.cpp',
+    'graphics/Label.cpp',
+    'graphics/LabelBuilder.cpp',
+    'graphics/Monochrome.cpp',
+    'libusbwrap/UsbDevice.cpp',
+    'libusbwrap/UsbDeviceFactory.cpp',
+    'printers/FakePrinter.cpp',
+    'printers/P700Printer.cpp',
+    'PtouchPrint.cpp',
+)

src/printers/FakePrinter.cpp

@@ -0,0 +1,255 @@
+/*
+    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 "FakePrinter.hpp"
+
+#include <cairo.h>
+#include <spdlog/spdlog.h>
+
+#include <chrono>
+#include <cstdint>
+#include <iomanip>
+#include <sstream>
+#include <stdexcept>
+#include <vector>
+
+#include "graphics/Monochrome.hpp"
+
+namespace ptprnt::printer {
+
+const PrinterInfo FakePrinter::mInfo = {.driverName = "FakePrinter",
+                                        .name       = "Virtual Test Printer",
+                                        .version    = "v1.0",
+                                        .usbId{0x0000, 0x0000},  // No USB ID - virtual printer created explicitly
+                                        .pixelLines = 128};
+
+const std::string_view FakePrinter::getDriverName() {
+    return mInfo.driverName;
+}
+
+const std::string_view FakePrinter::getName() {
+    return mInfo.name;
+}
+
+const std::string_view FakePrinter::getVersion() {
+    return mInfo.version;
+}
+
+const PrinterInfo FakePrinter::getPrinterInfo() {
+    return mInfo;
+}
+
+const PrinterStatus FakePrinter::getPrinterStatus() {
+    return mStatus;
+}
+
+const libusbwrap::usbId FakePrinter::getUsbId() {
+    return mInfo.usbId;
+}
+
+bool FakePrinter::attachUsbDevice(std::shared_ptr<libusbwrap::IUsbDevice> usbHndl) {
+    // FakePrinter doesn't need a real USB device
+    mHasAttachedDevice = true;
+    spdlog::debug("FakePrinter: Simulated USB device attachment");
+    return true;
+}
+
+bool FakePrinter::detachUsbDevice() {
+    mHasAttachedDevice = false;
+    spdlog::debug("FakePrinter: Simulated USB device detachment");
+    return true;
+}
+
+bool FakePrinter::printBitmap(const graphics::Bitmap<graphics::ALPHA8>& bitmap) {
+    // Convert bitmap to MonochromeData and delegate
+    auto pixels   = bitmap.getPixelsCpy();
+    auto mono     = graphics::Monochrome(pixels, bitmap.getWidth(), bitmap.getHeight());
+    auto monoData = mono.get();
+
+    return printMonochromeData(monoData);
+}
+
+bool FakePrinter::printMonochromeData(const graphics::MonochromeData& data) {
+    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)", mLastPrint->getWidth(),
+                 mLastPrint->getHeight());
+
+    // Save to timestamped PNG file
+    std::string filename = generateTimestampedFilename();
+    if (saveBitmapToPng(*mLastPrint, filename)) {
+        spdlog::info("FakePrinter: Saved output to {}", filename);
+    } else {
+        spdlog::error("FakePrinter: Failed to save output to {}", filename);
+    }
+
+    return true;
+}
+
+bool FakePrinter::printLabel(const std::unique_ptr<graphics::ILabel> label) {
+    // Convert label directly to MonochromeData
+    // getRaw() returns data in Cairo surface coordinates matching getWidth() × getHeight()
+    auto pixels = label->getRaw();
+
+    // Create monochrome data in landscape orientation (as stored in Cairo surface)
+    auto mono = graphics::Monochrome(pixels, label->getWidth(), label->getHeight(), graphics::Orientation::LANDSCAPE);
+    auto monoData = mono.get();
+
+    // 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());
+
+    return printMonochromeData(monoData);
+}
+
+bool FakePrinter::print() {
+    spdlog::debug("FakePrinter: Print command (no-op for virtual printer)");
+    return true;
+}
+
+graphics::Bitmap<graphics::ALPHA8> FakePrinter::simulatePrinting(const graphics::MonochromeData& data) {
+    spdlog::debug("FakePrinter: Simulating column-by-column printing like real hardware");
+
+    // Create output bitmap with same dimensions
+    graphics::Bitmap<graphics::ALPHA8> result(data.width, data.height);
+    std::vector<uint8_t> pixels(data.width * data.height, 0);
+
+    // Simulate printer behavior: process column by column
+    // This mimics how label printers physically print one vertical line at a time
+    for (uint32_t col = 0; col < data.width; col++) {
+        spdlog::trace("FakePrinter: Processing column {}/{}", col + 1, data.width);
+
+        // Extract column data bit by bit (simulating what would be sent to printer)
+        std::vector<uint8_t> columnBytes;
+
+        for (uint32_t row = 0; row < data.height; row += 8) {
+            uint8_t byte = 0;
+
+            // Pack 8 vertical pixels into one byte (printer data format)
+            for (int bit = 0; bit < 8 && (row + bit) < data.height; bit++) {
+                if (data.getBit(col, row + bit)) {
+                    byte |= (1 << (7 - bit));
+                }
+            }
+
+            columnBytes.push_back(byte);
+        }
+
+        // Now "print" this column by unpacking the bytes back to pixels
+        for (size_t byteIdx = 0; byteIdx < columnBytes.size(); byteIdx++) {
+            uint8_t byte     = columnBytes[byteIdx];
+            uint32_t baseRow = byteIdx * 8;
+
+            for (int bit = 0; bit < 8 && (baseRow + bit) < data.height; bit++) {
+                bool pixelOn = (byte & (1 << (7 - bit))) != 0;
+                uint32_t row = baseRow + bit;
+
+                // Write to output bitmap
+                size_t pixelIdx  = row * data.width + col;
+                pixels[pixelIdx] = pixelOn ? 255 : 0;  // 255 = black, 0 = white
+            }
+        }
+    }
+
+    // Set the pixels in the result bitmap
+    result.setPixels(pixels);
+
+    spdlog::debug("FakePrinter: Simulation complete, reconstructed {}x{} bitmap", result.getWidth(),
+                  result.getHeight());
+
+    return result;
+}
+
+const graphics::Bitmap<graphics::ALPHA8>& FakePrinter::getLastPrint() const {
+    if (!mLastPrint) {
+        throw std::runtime_error("FakePrinter: No print data available");
+    }
+    return *mLastPrint;
+}
+
+bool FakePrinter::saveLastPrintToPng(const std::string& filename) const {
+    if (!mLastPrint || mLastPrint->getWidth() == 0 || mLastPrint->getHeight() == 0) {
+        spdlog::error("FakePrinter: No print data available to save");
+        return false;
+    }
+
+    return saveBitmapToPng(*mLastPrint, filename);
+}
+
+bool FakePrinter::saveBitmapToPng(const graphics::Bitmap<graphics::ALPHA8>& bitmap, const std::string& filename) const {
+    // Create Cairo surface from bitmap data
+    auto pixels     = bitmap.getPixelsCpy();
+    uint16_t width  = bitmap.getWidth();
+    uint16_t height = bitmap.getHeight();
+
+    // Cairo expects ARGB32 format, but we have ALPHA8
+    // Convert ALPHA8 (grayscale) to ARGB32
+    std::vector<uint32_t> argbPixels(width * height);
+
+    for (size_t i = 0; i < pixels.size(); i++) {
+        uint8_t gray = pixels[i];
+        // ARGB32 format: 0xAARRGGBB
+        // For grayscale: use gray value for R, G, B and 255 for alpha
+        argbPixels[i] = 0xFF000000 | (gray << 16) | (gray << 8) | gray;
+    }
+
+    // Create Cairo surface
+    int stride               = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
+    cairo_surface_t* surface = cairo_image_surface_create_for_data(reinterpret_cast<unsigned char*>(argbPixels.data()),
+                                                                   CAIRO_FORMAT_ARGB32, width, height, stride);
+
+    if (cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {
+        spdlog::error("FakePrinter: Failed to create Cairo surface: {}",
+                      cairo_status_to_string(cairo_surface_status(surface)));
+        cairo_surface_destroy(surface);
+        return false;
+    }
+
+    // Write to PNG file
+    cairo_status_t status = cairo_surface_write_to_png(surface, filename.c_str());
+
+    cairo_surface_destroy(surface);
+
+    if (status != CAIRO_STATUS_SUCCESS) {
+        spdlog::error("FakePrinter: Failed to write PNG file: {}", cairo_status_to_string(status));
+        return false;
+    }
+
+    return true;
+}
+
+std::string FakePrinter::generateTimestampedFilename() const {
+    // Get current time
+    auto now  = std::chrono::system_clock::now();
+    auto time = std::chrono::system_clock::to_time_t(now);
+
+    // Format: fakelabel_YYYYMMDD_HHMMSS.png
+    std::stringstream ss;
+    ss << "fakelabel_" << std::put_time(std::localtime(&time), "%Y%m%d_%H%M%S") << ".png";
+
+    return ss.str();
+}
+
+}  // namespace ptprnt::printer

src/printers/FakePrinter.hpp

@@ -0,0 +1,108 @@
+/*
+    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 <cstdint>
+#include <memory>
+#include <vector>
+
+#include "graphics/Bitmap.hpp"
+#include "interface/IPrinterDriver.hpp"
+#include "interface/IPrinterTypes.hpp"
+#include "libusbwrap/LibUsbTypes.hpp"
+#include "libusbwrap/interface/IUsbDevice.hpp"
+
+namespace ptprnt::printer {
+
+/**
+ * @brief Virtual printer driver for testing without hardware
+ *
+ * FakePrinter simulates a real label printer by processing bitmap data
+ * column by column and reconstructing it into a new bitmap, mimicking
+ * the physical printing process of label printers.
+ */
+class FakePrinter : public ::ptprnt::IPrinterDriver {
+   public:
+    FakePrinter()           = default;
+    ~FakePrinter() override = default;
+
+    FakePrinter(const FakePrinter&)            = delete;
+    FakePrinter& operator=(const FakePrinter&) = delete;
+    FakePrinter(FakePrinter&&)                 = default;
+    FakePrinter& operator=(FakePrinter&&)      = default;
+
+    // Printer info - static to be accessed without instantiation
+    static const PrinterInfo mInfo;
+
+    // IPrinterDriver interface
+    [[nodiscard]] const std::string_view getDriverName() override;
+    [[nodiscard]] const std::string_view getName() override;
+    [[nodiscard]] const libusbwrap::usbId getUsbId() override;
+    [[nodiscard]] const std::string_view getVersion() override;
+    [[nodiscard]] const PrinterInfo getPrinterInfo() override;
+    [[nodiscard]] const PrinterStatus getPrinterStatus() override;
+    bool attachUsbDevice(std::shared_ptr<libusbwrap::IUsbDevice> usbHndl) override;
+    bool detachUsbDevice() override;
+    bool printBitmap(const graphics::Bitmap<graphics::ALPHA8>& bitmap) override;
+    bool printMonochromeData(const graphics::MonochromeData& data) override;
+    bool printLabel(const std::unique_ptr<graphics::ILabel> label) override;
+    bool print() override;
+
+    /**
+     * @brief Get the last printed bitmap
+     * @return The reconstructed bitmap from simulated printing
+     */
+    [[nodiscard]] const graphics::Bitmap<graphics::ALPHA8>& getLastPrint() const;
+
+    /**
+     * @brief Save the last print to a PNG file
+     * @param filename Path to save the PNG
+     * @return true if successful
+     */
+    bool saveLastPrintToPng(const std::string& filename) const;
+
+   private:
+    /**
+     * @brief Simulate printing by reconstructing bitmap column by column
+     * @param data Monochrome data to "print"
+     * @return Reconstructed bitmap
+     */
+    graphics::Bitmap<graphics::ALPHA8> simulatePrinting(const graphics::MonochromeData& data);
+
+    /**
+     * @brief Save bitmap to PNG file using Cairo
+     * @param bitmap The bitmap to save
+     * @param filename Output filename
+     * @return true if successful
+     */
+    bool saveBitmapToPng(const graphics::Bitmap<graphics::ALPHA8>& bitmap, const std::string& filename) const;
+
+    /**
+     * @brief Generate timestamped filename for fake label output
+     * @return Filename like "fakelabel_20231011_123456.png"
+     */
+    std::string generateTimestampedFilename() const;
+
+    std::unique_ptr<graphics::Bitmap<graphics::ALPHA8>> mLastPrint;
+    bool mHasAttachedDevice = false;
+    PrinterStatus mStatus{.tapeWidthMm = 12};  // Default to 12mm tape
+};
+
+}  // namespace ptprnt::printer

src/printers/P700Printer.cpp

@@ -0,0 +1,238 @@
+/*
+    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 "P700Printer.hpp"
+
+#include <spdlog/spdlog.h>
+
+#include <cassert>
+#include <cstdint>
+#include <iterator>
+#include <memory>
+#include <thread>
+#include <vector>
+
+#include "graphics/Bitmap.hpp"
+#include "graphics/Monochrome.hpp"
+#include "libusbwrap/LibUsbTypes.hpp"
+#include "spdlog/fmt/bin_to_hex.h"
+
+namespace ptprnt::printer {
+
+const PrinterInfo P700Printer::mInfo = {.driverName = "P700",
+                                        .name       = "Brother P-touch P700",
+                                        .version    = "v1.0",
+                                        .usbId{0x04f9, 0x2061},
+                                        .pixelLines = 128};
+
+P700Printer::~P700Printer() {
+    P700Printer::detachUsbDevice();
+    if (mUsbHndl) {
+        mUsbHndl->close();
+    }
+}
+
+const std::string_view P700Printer::getDriverName() {
+    return mInfo.driverName;
+}
+
+const std::string_view P700Printer::getName() {
+    return mInfo.name;
+}
+
+const std::string_view P700Printer::getVersion() {
+    return mInfo.version;
+}
+
+const PrinterInfo P700Printer::getPrinterInfo() {
+    return mInfo;
+}
+
+const PrinterStatus P700Printer::getPrinterStatus() {
+    using namespace std::chrono_literals;
+    send(p700::commands::GET_STATUS);
+
+    int tx    = 0;
+    int tries = 0;
+    std::vector<uint8_t> recvBuf(32);
+    while (tries++ < MAX_TRIES_GET_STATUS) {
+        std::this_thread::sleep_for(100ms);
+        mUsbHndl->bulkTransfer(p700::commands::PRINTER_INFO[0], recvBuf, &tx, 0);
+    }
+
+    return PrinterStatus{.tapeWidthMm = recvBuf[10]};
+}
+
+const libusbwrap::usbId P700Printer::getUsbId() {
+    return mInfo.usbId;
+}
+
+bool P700Printer::attachUsbDevice(std::shared_ptr<libusbwrap::IUsbDevice> usbHndl) {
+    if (!usbHndl->open()) {
+        spdlog::error("Unable to open USB device: {}", usbHndl->getLastErrorString());
+        return false;
+    }
+
+    if (!usbHndl->detachKernelDriver(0)) {
+
+        spdlog::error("Device is already in use or couldn't be detached from kernel: {}",
+                      usbHndl->getLastErrorString());
+        return false;
+    }
+
+    if (!usbHndl->claimInterface(0)) {
+        spdlog::error("Could not claim interface 0: {}", usbHndl->getLastErrorString());
+        return false;
+    }
+
+    mUsbHndl = std::move(usbHndl);
+    return true;
+}
+
+bool P700Printer::detachUsbDevice() {
+    if (!mUsbHndl) {
+        spdlog::warn("No device to detach...");
+        return true;
+    }
+    if (!mUsbHndl->releaseInterface(0)) {
+        spdlog::error("Could not release interface 0: {}", mUsbHndl->getLastErrorString());
+        return false;
+    }
+    return true;
+}
+
+bool P700Printer::printBitmap(const graphics::Bitmap<graphics::ALPHA8>& bitmap) {
+    // Convert bitmap to MonochromeData and delegate to printMonochromeData
+    auto pixels   = bitmap.getPixelsCpy();
+    auto mono     = graphics::Monochrome(pixels, bitmap.getWidth(), bitmap.getHeight());
+    auto monoData = mono.get();
+
+    return printMonochromeData(monoData);
+}
+
+bool P700Printer::printMonochromeData(const graphics::MonochromeData& data) {
+    // Send initialization sequence
+    // The INITIALIZE command needs to be sent as a 128-byte packet with ESC @ at the end
+    std::vector<uint8_t> initCmd(128, 0x00);
+    initCmd[126] = p700::commands::INITIALIZE[0];  // ESC
+    initCmd[127] = p700::commands::INITIALIZE[1];  // @
+    send(initCmd);
+
+    // Status is already queried in getPrinterStatus()
+    send(p700::commands::PRINT_MODE);
+    send(p700::commands::AUTO_STATUS);
+    send(p700::commands::MODE_SETTING);
+
+    // Send raster data row by row in reverse order (bottom to top)
+    // The printer feeds tape as it prints, so first row sent appears at the end
+    for (int row = data.height - 1; row >= 0; row--) {
+        std::vector<uint8_t> rowData;
+
+        // Extract row data byte by byte
+        for (uint32_t col = 0; col < data.width; col += 8) {
+            uint8_t byte = 0;
+            for (int bit = 0; bit < 8 && (col + bit) < data.width; bit++) {
+                if (data.getBit(col + bit, row)) {
+                    byte |= (1 << (7 - bit));
+                }
+            }
+            rowData.push_back(byte);
+        }
+
+        // Build raster line command: G + length_high + 0x00 + length_low + data
+        std::vector<uint8_t> buf;
+        buf.push_back(0x47);                         // 'G' command
+        buf.push_back((rowData.size() + 1) & 0xFF);  // length + 1 (low byte)
+        buf.push_back(0x00);                         // high byte (always 0 for our data size)
+        buf.push_back((rowData.size() - 1) & 0xFF);  // length - 1
+        buf.insert(buf.end(), rowData.begin(), rowData.end());
+
+        if (!send(buf)) {
+            spdlog::error("Error sending raster line {} to printer", row);
+            return false;
+        }
+    }
+
+    // Send print finalization commands
+    send(p700::commands::EJECT);
+
+    return true;
+}
+
+bool P700Printer::printLabel(std::unique_ptr<graphics::ILabel> label) {
+    // Convert label directly to MonochromeData
+    // getRaw() returns data in Cairo surface coordinates matching getWidth() × getHeight()
+    auto pixels = label->getRaw();
+
+    // Create monochrome data in landscape orientation (as stored in Cairo surface)
+    auto mono = graphics::Monochrome(pixels, label->getWidth(), label->getHeight(), graphics::Orientation::LANDSCAPE);
+    auto monoData = mono.get();
+
+    // Transform to portrait orientation for printing
+    monoData.transformTo(graphics::Orientation::PORTRAIT);
+
+    spdlog::debug("Label surface was {}x{}, after transform to portrait: {}x{}", label->getWidth(), label->getHeight(),
+                  monoData.width, monoData.height);
+
+    return printMonochromeData(monoData);
+}
+
+bool P700Printer::print() {
+    send(p700::commands::LF);
+    send(p700::commands::FF);
+    send(p700::commands::EJECT);
+    return true;
+}
+
+bool P700Printer::send(const std::vector<uint8_t>& data) {
+
+    if (mUsbHndl == nullptr || data.size() > 128) {
+        spdlog::error("Invalid device handle or invalid data.");
+        return false;
+    }
+
+    spdlog::trace("USB Tx → 0x02 {:03d} bytes: {:Xn}", data.size(), spdlog::to_hex(data));
+#ifdef USB_TRACE_ONLY
+    // Trace mode: Log the data that would be sent without actually sending it
+    return true;
+#else
+    int tx = 0;
+
+    if (!mUsbHndl->bulkTransfer(0x02, data, &tx, 0)) {
+        spdlog::error("Error writing command to Printer: {}", mUsbHndl->getLastErrorString());
+        return false;
+    }
+
+    assert(tx > 0);
+    if (static_cast<std::uint32_t>(tx) != data.size()) {
+        spdlog::error("Could not transfer all data via USB bulk transfer. Only sent {} of {} bytes", tx, data.size());
+        return false;
+    }
+
+    return true;
+#endif
+}
+
+bool P700Printer::init() {
+    std::vector<uint8_t> cmd(102);
+    cmd[100] = 0x1b; /* ESC */
+    cmd[101] = 0x40; /* @ */
+    return send(cmd);
+}
+}  // namespace ptprnt::printer

src/printers/P700Printer.hpp

@@ -0,0 +1,88 @@
+/* 
+    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 <spdlog/spdlog.h>
+#include <sys/types.h>
+
+#include <memory>
+#include <vector>
+
+#include "interface/IPrinterDriver.hpp"
+#include "interface/IPrinterTypes.hpp"
+#include "libusbwrap/LibUsbTypes.hpp"
+#include "libusbwrap/interface/IUsbDevice.hpp"
+
+namespace ptprnt::printer {
+namespace p700::commands {
+const cmd_T INITIALIZE{0x1b, 0x40};                // ESC @ - Initialize
+const cmd_T GET_STATUS{0x1b, 0x69, 0x53};          // ESC i S - Status query
+const cmd_T PRINT_MODE{0x4d, 0x02};                // M 0x02 - Print mode
+const cmd_T AUTO_STATUS{0x1b, 0x69, 0x61, 0x01};   // ESC i a - Auto status
+const cmd_T MODE_SETTING{0x1b, 0x69, 0x4d, 0x40};  // ESC i M @ - Advanced mode
+const cmd_T RASTER_START{0x1b, 0x69, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+const cmd_T INFO{0x1b, 0x69, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+const cmd_T PACKBITSON{0x02};
+const cmd_T LF{0x5a};
+const cmd_T FF{0x0c};
+const cmd_T EJECT{0x1a};
+const cmd_T PRINTER_INFO{0x81};
+}  // namespace p700::commands
+
+constexpr uint8_t MAX_TRIES_GET_STATUS = 10;
+
+// TODO:
+// Remove Text-layout specific parts, add them to label
+
+class P700Printer : public ::ptprnt::IPrinterDriver {
+   public:
+    P700Printer() = default;
+    ~P700Printer() override;
+
+    // delete copy ctor and assignment
+    P700Printer(const P700Printer&)            = default;
+    P700Printer& operator=(const P700Printer&) = default;
+    P700Printer(P700Printer&&)                 = default;
+    P700Printer& operator=(P700Printer&&)      = default;
+
+    // Printer info has to be static to be accessed without instantiation
+    static const PrinterInfo mInfo;
+
+    // IPrinterDriver
+    [[nodiscard]] const std::string_view getDriverName() override;
+    [[nodiscard]] const std::string_view getName() override;
+    [[nodiscard]] const libusbwrap::usbId getUsbId() override;
+    [[nodiscard]] const std::string_view getVersion() override;
+    [[nodiscard]] const PrinterInfo getPrinterInfo() override;
+    [[nodiscard]] const PrinterStatus getPrinterStatus() override;
+    bool attachUsbDevice(std::shared_ptr<libusbwrap::IUsbDevice> usbHndl) override;
+    bool detachUsbDevice() override;
+    bool printBitmap(const graphics::Bitmap<graphics::ALPHA8>& bitmap) override;
+    bool printMonochromeData(const graphics::MonochromeData& data) override;
+    bool printLabel(const std::unique_ptr<graphics::ILabel> label) override;
+    bool print() override;
+
+   private:
+    bool send(const std::vector<uint8_t>& data);
+    bool init();
+
+    std::shared_ptr<libusbwrap::IUsbDevice> mUsbHndl{nullptr};
+};
+}  // namespace ptprnt::printer

src/printers/interface/IPrinterDriver.hpp

@@ -0,0 +1,49 @@
+/* 
+    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_view>
+
+#include "IPrinterTypes.hpp"
+#include "graphics/Bitmap.hpp"
+#include "graphics/Monochrome.hpp"
+#include "graphics/interface/ILabel.hpp"
+#include "libusbwrap/interface/IUsbDevice.hpp"
+
+namespace ptprnt {
+class IPrinterDriver {
+   public:
+    virtual ~IPrinterDriver()                                                     = default;
+    [[nodiscard]] virtual const std::string_view getDriverName()                  = 0;
+    [[nodiscard]] virtual const std::string_view getName()                        = 0;
+    [[nodiscard]] virtual const std::string_view getVersion()                     = 0;
+    [[nodiscard]] virtual const libusbwrap::usbId getUsbId()                      = 0;
+    [[nodiscard]] virtual const PrinterInfo getPrinterInfo()                      = 0;
+    [[nodiscard]] virtual const 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;
+    virtual bool printMonochromeData(const graphics::MonochromeData& data)        = 0;
+    virtual bool printLabel(const std::unique_ptr<graphics::ILabel> label)        = 0;
+    virtual bool print()                                                          = 0;
+};
+
+}  // namespace ptprnt

src/printers/interface/IPrinterTypes.hpp

@@ -0,0 +1,45 @@
+/* 
+    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 <cstdint>
+#include <string_view>
+#include <vector>
+
+#include "libusbwrap/LibUsbTypes.hpp"
+
+namespace ptprnt {
+
+struct PrinterInfo {
+    std::string_view driverName = "";
+    std::string_view name       = "";
+    std::string_view version    = "";
+    libusbwrap::usbId usbId{0x00, 0x00};
+    uint16_t pixelLines = 0;
+};
+
+struct PrinterStatus {
+    unsigned int tapeWidthPixel = 0;
+    unsigned int tapeWidthMm    = 0.0;
+};
+
+using cmd_T = std::vector<uint8_t>;
+
+}  // namespace ptprnt

subprojects/cli11.wrap

@@ -0,0 +1,9 @@
+[wrap-file]
+directory = CLI11-2.3.2
+source_url = https://github.com/CLIUtils/CLI11/archive/refs/tags/v2.3.2.tar.gz
+source_filename = CLI11-2.3.2.tar.gz
+source_hash = aac0ab42108131ac5d3344a9db0fdf25c4db652296641955720a4fbe52334e22
+wrapdb_version = 2.3.2-1
+
+[provide]
+cli11 = CLI11_dep

subprojects/gtest.wrap

@@ -0,0 +1,16 @@
+[wrap-file]
+directory = googletest-1.14.0
+source_url = https://github.com/google/googletest/archive/refs/tags/v1.14.0.tar.gz
+source_filename = gtest-1.14.0.tar.gz
+source_hash = 8ad598c73ad796e0d8280b082cebd82a630d73e73cd3c70057938a6501bba5d7
+patch_filename = gtest_1.14.0-1_patch.zip
+patch_url = https://wrapdb.mesonbuild.com/v2/gtest_1.14.0-1/get_patch
+patch_hash = 2e693c7d3f9370a7aa6dac802bada0874d3198ad4cfdf75647b818f691182b50
+source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/gtest_1.14.0-1/gtest-1.14.0.tar.gz
+wrapdb_version = 1.14.0-1
+
+[provide]
+gtest = gtest_dep
+gtest_main = gtest_main_dep
+gmock = gmock_dep
+gmock_main = gmock_main_dep

tests/bitmap_test/bitmap_test.cpp

@@ -0,0 +1,94 @@
+/* 
+    ptrnt - print labels on linux
+    Copyright (C) 2023  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#include "graphics/Bitmap.hpp"
+
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <vector>
+
+TEST(basic_test, Bitmap_createBitmapWithCertainSize_yieldsSpecifiedSize) {
+    auto bm     = ptprnt::graphics::Bitmap<ptprnt::graphics::ALPHA8>(16, 8);
+    auto width  = bm.getWidth();
+    auto height = bm.getHeight();
+    ASSERT_EQ(width, 16);
+    ASSERT_EQ(height, 8);
+}
+
+TEST(basic_test, Bitmap_getBitmapLineOutsideOfImage_yieldsNullopt) {
+    auto bm = ptprnt::graphics::Bitmap<ptprnt::graphics::ALPHA8>(16, 8);
+    // line 8 is out of bounds, count begins with 0
+    EXPECT_ANY_THROW(auto outOfBoundsLine = bm.getLine(8));
+}
+
+TEST(basic_test, Bitmap_getBitmapLineInsideOfImage_yieldsValidLineSize) {
+    auto bm       = ptprnt::graphics::Bitmap<ptprnt::graphics::ALPHA8>(16, 8);
+    auto line     = bm.getLine(7);
+    auto lineSize = line.size();
+    ASSERT_EQ(16, lineSize);
+}
+
+TEST(basic_test, Bitmap_getBitmapColOutsideOfImage_yieldsNullopt) {
+    auto bm = ptprnt::graphics::Bitmap<ptprnt::graphics::ALPHA8>(16, 8);
+    // col 16 is out of bounds, count begins with 0
+
+    EXPECT_ANY_THROW(auto outOfBoundsCol = bm.getCol(16));
+}
+
+TEST(basic_test, Bitmap_getBitmapColInsideOfImage_yieldsValidColSize) {
+    auto bm  = ptprnt::graphics::Bitmap<ptprnt::graphics::ALPHA8>(16, 8);
+    auto col = bm.getCol(15);
+
+    auto colSize = col.size();
+    ASSERT_EQ(8, colSize);
+}
+
+TEST(basic_test, Bitmap_setPixels_setsGivenPixels) {
+    auto bm = ptprnt::graphics::Bitmap<ptprnt::graphics::ALPHA8>(16, 8);
+    std::vector<uint8_t> pix(16 * 8);
+
+    bm.setPixels(pix);
+    auto pixCpy = bm.getPixelsCpy();
+
+    ASSERT_EQ(pix, pixCpy);
+}
+
+TEST(basic_test, Bitmap_setPixels_isSuccessfulWithValidPixels) {
+    auto bm = ptprnt::graphics::Bitmap<ptprnt::graphics::ALPHA8>(16, 8);
+    std::vector<uint8_t> pix(16 * 8);
+
+    ASSERT_TRUE(bm.setPixels(pix));
+}
+
+TEST(basic_test, Bitmap_setPixels_yieldsSamePixelsBack) {
+    auto bm = ptprnt::graphics::Bitmap<ptprnt::graphics::ALPHA8>(16, 8);
+    std::vector<uint8_t> pix(16 * 8);
+
+    bm.setPixels(pix);
+    auto pixCpy = bm.getPixelsCpy();
+    ASSERT_EQ(pix, pixCpy);
+}
+
+TEST(basic_test, Bitmap_setPixelsWithWrongSize_isFailing) {
+    auto bm = ptprnt::graphics::Bitmap<ptprnt::graphics::ALPHA8>(5, 8);
+    std::vector<uint8_t> pix(16 * 8);
+
+    ASSERT_FALSE(bm.setPixels(pix));
+}

tests/label_test/label_test.cpp

@@ -0,0 +1,26 @@
+/* 
+    ptrnt - print labels on linux
+    Copyright (C) 2023  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#include "graphics/Label.hpp"
+
+#include <gtest/gtest.h>
+
+TEST(basic_test, Label_smokeTest_succeeds) {
+    auto im = ptprnt::graphics::Label(4711);
+}

tests/meson.build

@@ -0,0 +1,38 @@
+tests = [
+    [
+        'bitmap_test',
+        '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',
+        [
+            '../src/graphics/Monochrome.cpp',
+            'monochrome_test/monochrome_test.cpp',
+        ],
+    ],
+]
+
+foreach test : tests
+    test(
+        test.get(0),
+        executable(
+            test.get(1),
+            sources: test.get(2),
+            include_directories: incdir,
+            dependencies: [
+                gtest_dep,
+                usb_dep,
+                log_dep,
+                pangocairo_dep,
+                cli11_dep,
+            ],
+        ),
+    )
+endforeach

tests/monochrome_test/monochrome_test.cpp

@@ -0,0 +1,163 @@
+/* 
+    ptrnt - print labels on linux
+    Copyright (C) 2023  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#include "graphics/Monochrome.hpp"
+
+#include <gtest/gtest.h>
+
+TEST(basic_test, Monochrome_convertGrayscale_yieldsMonochrome) {
+    const std::vector<uint8_t> pixels(
+        {0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00});
+
+    const std::vector<uint8_t> expected({0b10101010, 0b10101010});
+    auto mono = ptprnt::graphics::Monochrome(pixels, 16, 1);
+    auto out  = mono.get();
+
+    EXPECT_EQ(out.bytes, expected);
+}
+
+TEST(basic_test, Monochrome_convertInvertedGrayscale_yieldsInvertedMonochrome) {
+    const std::vector<uint8_t> pixels(
+        {0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00});
+
+    const std::vector<uint8_t> expected({0b01010101, 0b01010101});
+    auto mono = ptprnt::graphics::Monochrome(pixels, 16, 1);
+    mono.invert(true);
+    auto out = mono.get();
+
+    EXPECT_EQ(out.bytes, expected);
+}
+
+TEST(basic_test, Monochrome_convertWithCustomThreshhold_yieldsMonochromeRespectingThreshhold) {
+    const std::vector<uint8_t> pixels(
+        {0x0F, 0x11, 0x0F, 0x11, 0x0F, 0x11, 0x0F, 0x11, 0x0F, 0x11, 0x0F, 0x11, 0x0F, 0x11, 0x0F, 0x11});
+
+    const std::vector<uint8_t> expected({0b01010101, 0b01010101});
+    auto mono = ptprnt::graphics::Monochrome(pixels, 16, 1);
+    mono.setThreshold(16);
+    auto out = mono.get();
+
+    EXPECT_EQ(out.bytes, expected);
+}
+
+TEST(basic_test, Monochrome_convertNonAlignedPixels_spillsOverIntoNewByte) {
+    // TODO: We need to find to access the vector without the possiblity of out-of-bounds access
+    // Ideas: constexpr? compile time check?
+    GTEST_SKIP() << "Skipping this test, as ASAN will halt as this is an out-of-bounds access";
+    const std::vector<uint8_t> pixels(
+        {0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF});
+
+    const std::vector<uint8_t> expected({0b10101010, 0b10101010, 0b10000000});
+    auto mono = ptprnt::graphics::Monochrome(pixels, 17, 1);
+    auto out  = mono.get();
+
+    EXPECT_EQ(out.bytes, expected);
+}
+
+TEST(MonochromeData_test, MonochromeData_getMonochromeData_returnsStructWithCorrectData) {
+    const std::vector<uint8_t> pixels({0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00});
+
+    auto mono     = ptprnt::graphics::Monochrome(pixels, 8, 1);
+    auto monoData = mono.get();
+
+    EXPECT_EQ(monoData.bytes.size(), 1);
+    EXPECT_EQ(monoData.bytes[0], 0b10101010);
+    EXPECT_EQ(monoData.width, 8);
+    EXPECT_EQ(monoData.height, 1);
+    EXPECT_EQ(monoData.stride, 1);
+    EXPECT_EQ(monoData.orientation, ptprnt::graphics::Orientation::LANDSCAPE);
+}
+
+TEST(MonochromeData_test, MonochromeData2x2_transformToPortrait_rotatesCorrectly) {
+    // Create a 2x2 image with a specific pattern
+    // Pixels are laid out row-major: row0_col0, row0_col1, row1_col0, ...
+    const std::vector<uint8_t> pixels({0xFF, 0x00, 0x00, 0xFF});
+
+    auto mono     = ptprnt::graphics::Monochrome(pixels, 2, 2);
+    auto monoData = mono.get();
+
+    monoData.transformTo(ptprnt::graphics::Orientation::PORTRAIT);
+
+    // After 90° clockwise rotation:
+    // Original:  █ .    ->   Rotated:  . █
+    //            . █                   █ .
+    EXPECT_EQ(monoData.width, 2);
+    EXPECT_EQ(monoData.height, 2);
+    EXPECT_EQ(monoData.orientation, ptprnt::graphics::Orientation::PORTRAIT);
+
+    // check pixel data ...................................... x,y = value
+    EXPECT_EQ(monoData.getBit(0, 0), false);  // 0,0 = white
+    EXPECT_EQ(monoData.getBit(1, 0), true);   // 0,1 = black
+    EXPECT_EQ(monoData.getBit(0, 1), true);   // 1,0 = black
+    EXPECT_EQ(monoData.getBit(1, 1), false);  // 1,1 = white
+}
+
+TEST(MonochromeData_test, MonochromeData3x2_transformToPortrait_rotatesCorrectly) {
+    // Create a 2x3 image with a specific pattern
+    // Pixels are laid out row-major: row0_col0, row0_col1, row0_col2, row1_col0, ...
+    const std::vector<uint8_t> pixels({0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF});
+
+    auto mono     = ptprnt::graphics::Monochrome(pixels, 3, 2);
+    auto monoData = mono.get();
+
+    monoData.transformTo(ptprnt::graphics::Orientation::PORTRAIT);
+
+    // After 90° clockwise rotation:
+    // Original:  █ . .    ->   Rotated: █ █
+    //            █ . █                  . .
+    //                                   █ .
+    EXPECT_EQ(monoData.width, 2);
+    EXPECT_EQ(monoData.height, 3);
+    EXPECT_EQ(monoData.orientation, ptprnt::graphics::Orientation::PORTRAIT);
+
+    // check pixel data ...................................... x,y = value
+    EXPECT_EQ(monoData.getBit(0, 0), true);   // 1,1 = black
+    EXPECT_EQ(monoData.getBit(1, 0), true);   // 1,2 = black
+    EXPECT_EQ(monoData.getBit(0, 1), false);  // 2,1 = white
+    EXPECT_EQ(monoData.getBit(1, 1), false);  // 2,2 = white
+    EXPECT_EQ(monoData.getBit(0, 2), true);   // 3,1 = black
+    EXPECT_EQ(monoData.getBit(1, 2), false);  // 3,2 = white
+}
+
+TEST(MonochromeData_test, MonochromeData3x2_transformToPortrait_rotatesCorrectlyCounterclockwise) {
+    // Create a 2x3 image with a specific pattern
+    // Pixels are laid out row-major: row0_col0, row0_col1, row0_col2, row1_col0, ...
+    const std::vector<uint8_t> pixels({0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF});
+
+    auto mono     = ptprnt::graphics::Monochrome(pixels, 3, 2);
+    auto monoData = mono.get();
+
+    monoData.transformTo(ptprnt::graphics::Orientation::PORTRAIT_FLIPPED);
+
+    // After 90° anti-clockwise rotation:
+    // Original:  █ . .    ->   Rotated: . █
+    //            █ . █                  . .
+    //                                   █ █
+    EXPECT_EQ(monoData.width, 2);
+    EXPECT_EQ(monoData.height, 3);
+    EXPECT_EQ(monoData.orientation, ptprnt::graphics::Orientation::PORTRAIT_FLIPPED);
+
+    // check pixel data ...................................... x,y = value
+    EXPECT_EQ(monoData.getBit(0, 0), false);  // 1,1 = white
+    EXPECT_EQ(monoData.getBit(1, 0), true);   // 1,2 = black
+    EXPECT_EQ(monoData.getBit(0, 1), false);  // 2,1 = white
+    EXPECT_EQ(monoData.getBit(1, 1), false);  // 2,2 = white
+    EXPECT_EQ(monoData.getBit(0, 2), true);   // 3,1 = black
+    EXPECT_EQ(monoData.getBit(1, 2), true);   // 3,2 = black
+}

update_copyright.sh

@@ -0,0 +1,115 @@
+#!/bin/bash
+
+# update_copyright.sh
+# Updates copyright year ranges in a source file based on git history
+#
+# Usage: ./update_copyright.sh [--dry-run] <file>
+#
+# Examples:
+#   # Update a single file
+#   ./update_copyright.sh src/main.cpp
+#
+#   # Dry-run on a single file
+#   ./update_copyright.sh --dry-run src/main.cpp
+#
+#   # Update all C++ files using find -exec
+#   find src \( -name "*.cpp" -o -name "*.hpp" \) -exec ./update_copyright.sh {} \;
+#
+#   # Dry-run on all C++ files
+#   find src \( -name "*.cpp" -o -name "*.hpp" \) -exec ./update_copyright.sh --dry-run {} \;
+
+set -e
+
+# Check for dry-run flag
+DRY_RUN=false
+FILE=""
+
+if [ "$1" = "--dry-run" ]; then
+    DRY_RUN=true
+    FILE="$2"
+elif [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
+    grep "^#" "$0" | sed 's/^# \?//'
+    exit 0
+else
+    FILE="$1"
+fi
+
+# Check if file argument provided
+if [ -z "$FILE" ]; then
+    echo "Error: No file specified"
+    echo "Usage: $0 [--dry-run] <file>"
+    echo "Run '$0 --help' for more information"
+    exit 1
+fi
+
+# Check if file exists
+if [ ! -f "$FILE" ]; then
+    echo "Error: File not found: $FILE"
+    exit 1
+fi
+
+# Get the repository root
+REPO_ROOT=$(git rev-parse --show-toplevel)
+cd "$REPO_ROOT"
+
+# Copyright holder name
+COPYRIGHT_HOLDER="Moritz Martinius"
+
+# Function to get first and last commit years for a file
+get_years_for_file() {
+    local file="$1"
+
+    # Get the year of the first commit that touched this file
+    first_year=$(git log --follow --format=%ad --date=format:%Y --reverse "$file" 2>/dev/null | head -1)
+
+    # Get the year of the last commit that touched this file
+    last_year=$(git log --follow --format=%ad --date=format:%Y -1 "$file" 2>/dev/null)
+
+    # If file is not in git, use current year
+    if [ -z "$first_year" ]; then
+        first_year=$(date +%Y)
+        last_year=$(date +%Y)
+    fi
+
+    echo "$first_year $last_year"
+}
+
+# Get years from git history
+read -r first_year last_year <<< "$(get_years_for_file "$FILE")"
+
+# Determine the copyright year string
+if [ "$first_year" = "$last_year" ]; then
+    year_string="$first_year"
+else
+    year_string="$first_year-$last_year"
+fi
+
+# Check if file has a copyright notice
+if ! grep -q "Copyright (C)" "$FILE"; then
+    echo "No copyright notice found in $FILE, skipping"
+    exit 0
+fi
+
+if [ "$DRY_RUN" = true ]; then
+    # Just show what would be changed
+    current_year=$(grep "Copyright (C)" "$FILE" | sed -n 's/.*Copyright (C) \([0-9]\{4\}\(-[0-9]\{4\}\)\?\).*/\1/p' | head -1)
+    if [ "$current_year" != "$year_string" ]; then
+        echo "Would update $FILE: $current_year → $year_string"
+    else
+        echo "No change needed for $FILE (already $year_string)"
+    fi
+else
+    # Update the copyright line
+    # Matches patterns like "Copyright (C) 2023 Moritz Martinius" or "Copyright (C) 2023-2024 Moritz Martinius"
+    # Handle variable whitespace between year and name
+
+    # Get current year from file for comparison
+    current_year=$(grep "Copyright (C)" "$FILE" | sed -n 's/.*Copyright (C) \([0-9]\{4\}\(-[0-9]\{4\}\)\?\).*/\1/p' | head -1)
+
+    if [ "$current_year" = "$year_string" ]; then
+        echo "No changes needed for $FILE (already $year_string)"
+    else
+        sed -i "s/Copyright (C) [0-9]\{4\}\(-[0-9]\{4\}\)\? \+$COPYRIGHT_HOLDER/Copyright (C) $year_string  $COPYRIGHT_HOLDER/" "$FILE"
+        echo "✓ Updated $FILE: $current_year → $year_string"
+    fi
+fi