Device dependent margins/config

src/labelle/gui/gui.py

@@ -63,7 +63,7 @@ def _init_elements(self) -> None:
         self._device_manager = DeviceManager()
         self._dymo_labeler = DymoLabeler()
         self._settings_toolbar.update_labeler_context(
-            supported_tape_sizes=self._dymo_labeler.SUPPORTED_TAPE_SIZES_MM,
+            supported_tape_sizes=self._dymo_labeler._deviceConfig.supportedTapeSizes,
             installed_tape_size=self._dymo_labeler.tape_size_mm,
             minimum_horizontal_margin_mm=self._dymo_labeler.minimum_horizontal_margin_mm,
         )

src/labelle/gui/q_settings_toolbar.py

@@ -57,7 +57,7 @@ def _init_elements(self) -> None:
 
     def update_labeler_context(
         self,
-        supported_tape_sizes: tuple[int, ...],
+        supported_tape_sizes: list[int],
         installed_tape_size: int,
         minimum_horizontal_margin_mm: float,
     ) -> None:

src/labelle/lib/constants.py

@@ -13,11 +13,12 @@
 # either sysfs is unavailable or unusable by this script for some reason.
 # Please beware that DEV_NODE must be set to None when not used, else you will
 # be bitten by the NameError exception.
-from enum import Enum
+from enum import Enum, IntEnum
 from pathlib import Path
 
 import labelle.resources.fonts
 import labelle.resources.icons
+from labelle.lib.devices.device_config import DeviceConfig
 
 try:
     from pyqrcode import QRCode
@@ -34,19 +35,130 @@
     "WARNING: This device is not confirmed to work with this software. Please "
     "report your experiences in https://github.com/labelle-org/labelle/issues/4"
 )
-SUPPORTED_PRODUCTS = {
-    0x0011: "DYMO LabelMANAGER PC",
-    0x0015: "LabelPoint 350",
-    0x1001: "LabelManager PnP (no mode switch)",
-    0x1002: "LabelManager PnP (mode switch)",
-    0x1003: f"LabelManager 420P (no mode switch) {UNCONFIRMED_MESSAGE}",
-    0x1004: f"LabelManager 420P (mode switch) {UNCONFIRMED_MESSAGE}",
-    0x1005: "LabelManager 280 (no mode switch)",
-    0x1006: "LabelManager 280 (no mode switch)",
-    0x1007: f"LabelManager Wireless PnP (no mode switch) {UNCONFIRMED_MESSAGE}",
-    0x1008: f"LabelManager Wireless PnP (mode switch) {UNCONFIRMED_MESSAGE}",
-    0x1009: f"MobileLabeler {UNCONFIRMED_MESSAGE}",
-}
+
+
+# Supported USB device ID enumeration
+class SUPPORTED_DEVICE_ID(IntEnum):
+    LABELMANAGER_PC = 0x0011
+    LABELPOINT_350 = 0x0015
+    LABELMANAGER_PC_II = 0x001C
+    LABELMANAGER_PNP_NO_MODE_SWITCH = 0x1001
+    LABELMANAGER_PNP_MODE_SWITCH = 0x1002
+    LABELMANAGER_420P_NO_MODE_SWITCH = 0x1003
+    LABELMANAGER_420P_MODE_SWITCH = 0x1004
+    LABELMANAGER_280P_NO_MODE_SWITCH = 0x1005
+    LABELMANAGER_280P_MODE_SWITCH = 0x1006
+    LABELMANAGER_WIRELESS_PNP_NO_MODE_SWITCH = 0x1007
+    LABELMANAGER_WIRELESS_PNP_MODE_SWITCH = 0x1008
+    MOBILE_LABELER = 0x1009
+
+
+# Create supported products list
+SUPPORTED_PRODUCTS = []
+
+# ---- Supported USB Devices configuration ----
+SUPPORTED_PRODUCTS.append(
+    DeviceConfig(
+        "DYMO LabelMANAGER PC",
+        [int(SUPPORTED_DEVICE_ID.LABELMANAGER_PC)],
+        # ToDo: Validate config!
+        128,
+        [6, 9, 12, 19],
+        {6: (44, 85), 9: (31, 94), 12: (38, 117), 19: (2, 127)},
+    )
+)
+SUPPORTED_PRODUCTS.append(
+    DeviceConfig(
+        "LabelPoint 350",
+        [int(SUPPORTED_DEVICE_ID.LABELPOINT_350)],
+        # ToDo: Validate config!
+        64,
+        [6, 9, 12],
+        {6: (44, 85), 9: (31, 94), 12: (38, 117)},
+    )
+)
+SUPPORTED_PRODUCTS.append(
+    DeviceConfig(
+        "DYMO LabelMANAGER PC II",
+        [int(SUPPORTED_DEVICE_ID.LABELMANAGER_PC_II)],
+        128,
+        [6, 9, 12, 19, 24],
+        {6: (44, 85), 9: (31, 94), 12: (38, 117), 19: (2, 127), 24: (2, 127)},
+    )
+)
+SUPPORTED_PRODUCTS.append(
+    DeviceConfig(
+        "LabelManager PnP",
+        [
+            int(SUPPORTED_DEVICE_ID.LABELMANAGER_PNP_NO_MODE_SWITCH),
+            int(SUPPORTED_DEVICE_ID.LABELMANAGER_PNP_MODE_SWITCH),
+        ],
+        # ToDo: Validate config!
+        64,
+        [6, 9, 12],
+        {6: (44, 85), 9: (31, 94), 12: (38, 117)},
+    )
+)
+SUPPORTED_PRODUCTS.append(
+    DeviceConfig(
+        f"LabelManager 420P {UNCONFIRMED_MESSAGE}",
+        [
+            int(SUPPORTED_DEVICE_ID.LABELMANAGER_420P_NO_MODE_SWITCH),
+            int(SUPPORTED_DEVICE_ID.LABELMANAGER_420P_MODE_SWITCH),
+        ],
+        # ToDo: Validate config!
+        64,
+        [6, 9, 12],
+        {6: (44, 85), 9: (31, 94), 12: (38, 117)},
+    )
+)
+SUPPORTED_PRODUCTS.append(
+    DeviceConfig(
+        "LabelManager 280",
+        [
+            int(SUPPORTED_DEVICE_ID.LABELMANAGER_280P_MODE_SWITCH),
+            int(SUPPORTED_DEVICE_ID.LABELMANAGER_280P_NO_MODE_SWITCH),
+        ],
+        # ToDo: Validate config!
+        64,
+        [6, 9, 12],
+        {6: (44, 85), 9: (31, 94), 12: (38, 117)},
+    )
+)
+SUPPORTED_PRODUCTS.append(
+    DeviceConfig(
+        f"LabelManager Wireless PnP {UNCONFIRMED_MESSAGE}",
+        [
+            int(SUPPORTED_DEVICE_ID.LABELMANAGER_WIRELESS_PNP_NO_MODE_SWITCH),
+            int(SUPPORTED_DEVICE_ID.LABELMANAGER_WIRELESS_PNP_MODE_SWITCH),
+        ],
+        # ToDo: Validate config!
+        64,
+        [6, 9, 12],
+        {6: (44, 85), 9: (31, 94), 12: (38, 117)},
+    )
+)
+SUPPORTED_PRODUCTS.append(
+    DeviceConfig(
+        f"MobileLabeler {UNCONFIRMED_MESSAGE}",
+        [int(SUPPORTED_DEVICE_ID.MOBILE_LABELER)],
+        # ToDo: Validate config!
+        64,
+        [6, 9, 12],
+        {6: (44, 85), 9: (31, 94), 12: (38, 117)},
+    )
+)
+
+# Simulator configuration
+SIMULATOR_CONFIG = DeviceConfig(
+    "Simulator",
+    [0],
+    128,
+    [6, 9, 12, 19, 24],
+    {6: (44, 85), 9: (31, 94), 12: (38, 117), 19: (2, 127), 24: (2, 127)},
+)
+
+
 DEV_VENDOR = 0x0922
 
 PRINTER_INTERFACE_CLASS = 0x07

src/labelle/lib/devices/device_config.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import logging
+from typing import Tuple
+
+LOG = logging.getLogger(__name__)
+
+
+class DeviceConfig:
+    """Configuration object for the capabilities of a label printer."""
+
+    name: str
+    """Name of this device"""
+
+    deviceIDs: list[int]
+    """List of USB Device ID's this device can identify as"""
+
+    printHeadSizePixels: int
+    """Size of the print head in pixels (use calibration routine to determine)"""
+
+    supportedTapeSizes: list[int]
+    """List of supported tape sizes in mm"""
+
+    marginsPerTape: dict[int, Tuple[int, int]]
+    """
+    Dictonary of print margins per tape size
+    Entry: TapeSizeMM : (topMarginInPx, bottomMarginInPx)
+    Use the calibration routine to determine these for each tape size
+    """
+
+    def __init__(
+        self,
+        name: str,
+        deviceIDs: list[int],
+        printHeadSizePixels: int,
+        supportedTapeSizes: list[int],
+        marginsPerTape: dict[int, Tuple[int, int]],
+    ):
+        """Initialize a Labeler config object."""
+        self.name = name
+        self.deviceIDs = deviceIDs
+        self.printHeadSizePixels = printHeadSizePixels
+        self.supportedTapeSizes = supportedTapeSizes
+        self.marginsPerTape = marginsPerTape
+
+    def matches_device_id(self, idValue: int) -> bool:
+        """Check if the a device ID matches this config."""
+        if idValue in self.deviceIDs:
+            return True
+        else:
+            return False
+
+    def get_tape_print_margins(self, tapeSizeMM: int) -> tuple[int, int]:
+        """Get print margins for a specific tape size.
+
+        :param tapeSizeMM: Tape size in mm
+        :return: Margins tuple, None if not supported
+        """
+        if tapeSizeMM in self.supportedTapeSizes:
+            if tapeSizeMM in self.marginsPerTape:
+                # Return specified margins
+                return self.marginsPerTape[tapeSizeMM]
+            else:
+                # No specific margins set, return default
+                return (0, 0)
+        else:
+            # Tape size not supported
+            raise ValueError(
+                f"Unsupported tape size {tapeSizeMM}mm. "
+                f"Supported sizes: {self.supportedTapeSizes}mm"
+            )

src/labelle/lib/devices/device_manager.py

@@ -5,9 +5,11 @@
 from usb.core import NoBackendError, USBError
 
 from labelle.lib.constants import (
+    SUPPORTED_DEVICE_ID,
     SUPPORTED_PRODUCTS,
     UNCONFIRMED_MESSAGE,
 )
+from labelle.lib.devices.device_config import DeviceConfig
 from labelle.lib.devices.usb_device import UsbDevice
 
 LOG = logging.getLogger(__name__)
@@ -80,8 +82,24 @@ def find_and_select_device(self, patterns: list[str] | None = None) -> UsbDevice
             LOG.debug(dev.device_info)
         dev = devices[0]
         if dev.is_supported:
-            msg = f"Recognized device as {SUPPORTED_PRODUCTS[dev.id_product]}"
+            msg = f"Recognized device as \
+                {SUPPORTED_PRODUCTS[SUPPORTED_DEVICE_ID(dev.id_product)]}"
         else:
             msg = f"Unrecognized device: {hex(dev.id_product)}. {UNCONFIRMED_MESSAGE}"
         LOG.debug(msg)
         return dev
+
+
+def get_device_config_by_id(idValue: int) -> DeviceConfig | None:
+    """Get a labeler device config with USB ID.
+
+    :param idValue: USB ID value
+    :return: Device config, None if not found
+    """
+    #
+    for device in SUPPORTED_PRODUCTS:
+        if device.matches_device_id(idValue) is True:
+            return device
+
+    # No device config found
+    return None

src/labelle/lib/devices/dymo_labeler.py

@@ -15,7 +15,9 @@
 from PIL import Image
 from usb.core import NoBackendError, USBError
 
-from labelle.lib.constants import ESC, SYN
+from labelle.lib.constants import ESC, SIMULATOR_CONFIG, SYN
+from labelle.lib.devices.device_config import DeviceConfig
+from labelle.lib.devices.device_manager import get_device_config_by_id
 from labelle.lib.devices.usb_device import UsbDevice, UsbDeviceError
 from labelle.lib.utils import mm_to_px
 
@@ -236,27 +238,39 @@ def _raw_print_label(self, lines: list[list[int]]):
 
 class DymoLabeler:
     _device: UsbDevice | None
+    _deviceConfig: DeviceConfig
     tape_size_mm: int
 
     LABELER_DISTANCE_BETWEEN_PRINT_HEAD_AND_CUTTER_MM = 8.1
     LABELER_PRINT_HEAD_HEIGHT_MM = 8.2
-    SUPPORTED_TAPE_SIZES_MM = (19, 12, 9, 6)
     DEFAULT_TAPE_SIZE_MM = 12
 
     def __init__(
         self,
         tape_size_mm: int | None = None,
         device: UsbDevice | None = None,
     ):
+        self._device = device
+
+        if self._device is not None:
+            # Retrieve device config
+            foundConfig = get_device_config_by_id(self._device.id_product)
+            if foundConfig is not None:
+                self._deviceConfig = foundConfig
+            else:
+                raise ValueError(f"Unsupported device type {self._device.id_product}")
+        else:
+            # Use simulator config
+            self._deviceConfig = SIMULATOR_CONFIG
+
         if tape_size_mm is None:
             tape_size_mm = self.DEFAULT_TAPE_SIZE_MM
-        if tape_size_mm not in self.SUPPORTED_TAPE_SIZES_MM:
+        if tape_size_mm not in self._deviceConfig.supportedTapeSizes:
             raise ValueError(
                 f"Unsupported tape size {tape_size_mm}mm. "
-                f"Supported sizes: {self.SUPPORTED_TAPE_SIZES_MM}"
+                f"Supported sizes: {self._deviceConfig.supportedTapeSizes}mm"
             )
         self.tape_size_mm = tape_size_mm
-        self._device = device
 
     @property
     def height_px(self):