zpl_render 0.1.0

data/lib/zpl_render/canvas.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ZplRender
+  # A 1-bit monochrome dot canvas at printer resolution.
+  # Pixel value 1 = black dot (ink), 0 = white. Stored one byte per pixel
+  # for fast random access via String#getbyte/#setbyte.
+  class Canvas
+    attr_reader :width, :height
+
+    ROTATIONS = %i[n r i b].freeze
+
+    def initialize(width, height)
+      raise ArgumentError, "canvas size must be positive (#{width}x#{height})" if width < 1 || height < 1
+
+      @width = width
+      @height = height
+      @bits = ("\x00" * (width * height)).b
+    end
+
+    def set(x, y, on = true)
+      return if x.negative? || y.negative? || x >= @width || y >= @height
+
+      @bits.setbyte(y * @width + x, on ? 1 : 0)
+    end
+
+    def toggle(x, y)
+      return if x.negative? || y.negative? || x >= @width || y >= @height
+
+      idx = y * @width + x
+      @bits.setbyte(idx, @bits.getbyte(idx) ^ 1)
+    end
+
+    def get(x, y)
+      return false if x.negative? || y.negative? || x >= @width || y >= @height
+
+      @bits.getbyte(y * @width + x) == 1
+    end
+
+    def fill_rect(x, y, w, h, color: :black, xor: false)
+      x0 = [x, 0].max
+      y0 = [y, 0].max
+      x1 = [x + w, @width].min
+      y1 = [y + h, @height].min
+      return if x0 >= x1 || y0 >= y1
+
+      value = color == :black ? 1 : 0
+      (y0...y1).each do |yy|
+        row = yy * @width
+        (x0...x1).each do |xx|
+          if xor
+            @bits.setbyte(row + xx, @bits.getbyte(row + xx) ^ 1)
+          else
+            @bits.setbyte(row + xx, value)
+          end
+        end
+      end
+    end
+
+    # Blit +src+ onto self with its (rotated) top-left corner at (x, y).
+    # Rotation is one of :n (0), :r (90 CW), :i (180), :b (270 CW).
+    # mode :paint  -> src ink paints black, src background is transparent
+    # mode :erase  -> src ink paints white (used for ^GB/^GC color W)
+    # mode :xor    -> src ink inverts the canvas (ZPL ^FR field reverse)
+    def blit(src, x, y, rotation: :n, mode: :paint)
+      sw = src.width
+      sh = src.height
+      (0...sh).each do |sy|
+        (0...sw).each do |sx|
+          next unless src.get(sx, sy)
+
+          tx, ty = case rotation
+                   when :n then [x + sx, y + sy]
+                   when :r then [x + (sh - 1 - sy), y + sx]
+                   when :i then [x + (sw - 1 - sx), y + (sh - 1 - sy)]
+                   when :b then [x + sy, y + (sw - 1 - sx)]
+                   else [x + sx, y + sy]
+                   end
+          case mode
+          when :xor then toggle(tx, ty)
+          when :erase then set(tx, ty, false)
+          else set(tx, ty, true)
+          end
+        end
+      end
+    end
+
+    # Dimensions of +src+ after rotation, as [w, h].
+    def self.rotated_size(w, h, rotation)
+      %i[r b].include?(rotation) ? [h, w] : [w, h]
+    end
+
+    # Packed rows, 8 pixels per byte, MSB first (for PNG/PDF encoders).
+    def packed_rows
+      Array.new(@height) do |y|
+        row_offset = y * @width
+        bytes = ("\x00" * ((@width + 7) / 8)).b
+        (0...@width).each do |x|
+          next unless @bits.getbyte(row_offset + x) == 1
+
+          bytes.setbyte(x >> 3, bytes.getbyte(x >> 3) | (0x80 >> (x & 7)))
+        end
+        bytes
+      end
+    end
+
+    def to_ascii(on: "#", off: ".")
+      Array.new(@height) do |y|
+        Array.new(@width) { |x| get(x, y) ? on : off }.join
+      end.join("\n")
+    end
+  end
+end

data/lib/zpl_render/font.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require_relative "font_data"
+require_relative "helvetica_metrics"
+require_relative "truetype"
+
+module ZplRender
+  # Text rendering with metrics and shapes matching Zebra output.
+  #
+  # Glyphs come from the bundled Liberation Sans Bold (SIL OFL), whose
+  # metrics match Arial/Helvetica Bold, rasterized by the pure-Ruby
+  # TrueType engine. Zebra's scalable font 0 is CG Triumvirate Bold
+  # Condensed; the calibration constants below (measured against Labelary
+  # reference renders) reproduce its geometry:
+  #
+  # - :scalable (font 0 and other scalable designators): proportional
+  #   advances = hmtx/upm * ADVANCE_SCALE * w; cap height = CAP_SCALE * h.
+  # - :bitmap (fonts A-H): fixed-pitch cells, advance = cell width, glyph
+  #   condensed to fit the cell. Font B is uppercase-only, like the
+  #   hardware. (Real bitmap fonts are chunky dot-matrix faces; we render
+  #   them with the vector face at cell metrics, like Labelary does.)
+  #
+  # If the bundled TTF cannot be loaded, an embedded public-domain 8x8
+  # bitmap font (font8x8, IBM VGA derived) is used as a fallback.
+  module Font
+    # designator => [base height, base width, inter-character gap] in dots
+    # (per the ZPL manual's bitmapped-fonts matrix table)
+    BASE_CELLS = {
+      "A" => [9, 5, 1], "B" => [11, 7, 2], "C" => [18, 10, 2],
+      "D" => [18, 10, 2], "E" => [28, 15, 5], "F" => [26, 13, 3],
+      "G" => [60, 40, 8], "H" => [21, 13, 6]
+    }.freeze
+    SCALABLE_BASE = [15, 12, 0].freeze
+
+    ADVANCE_SCALE = 0.86    # em width per ^A w unit, measured against Labelary
+    CAP_SCALE = 0.76        # cap height per ^A h unit, measured against Labelary
+    BITMAP_CAP_SCALE = 0.72 # matrix fonts reserve more cell for descenders
+
+    Face = Struct.new(:style, :char_h, :char_w, :gap, :upcase, keyword_init: true)
+
+    module_function
+
+    def vector
+      return @vector if defined?(@vector)
+
+      @vector = begin
+        TrueType.default
+      rescue StandardError
+        nil
+      end
+    end
+
+    def mono_vector
+      return @mono_vector if defined?(@mono_vector)
+
+      @mono_vector = begin
+        TrueType.mono
+      rescue StandardError
+        vector
+      end
+    end
+
+    def face_for(designator, height, width)
+      name = designator.to_s.upcase
+      name = "0" if name.empty?
+      style = BASE_CELLS.key?(name) ? :bitmap : :scalable
+      base_h, base_w, base_gap = BASE_CELLS[name] || SCALABLE_BASE
+
+      h = height && height.positive? ? height : nil
+      w = width && width.positive? ? width : nil
+      if style == :scalable
+        h ||= w || base_h
+        w ||= h
+        gap = 0
+      else
+        h ||= w ? (w * base_h / base_w) : base_h
+        w ||= (h * base_w.to_f / base_h).round
+        gap = [(base_gap.to_f * w / base_w).round, 1].max
+      end
+      Face.new(style: style, char_h: h.clamp(2, 32_000), char_w: w.clamp(2, 32_000),
+               gap: gap, upcase: name == "B")
+    end
+
+    # Pen advance for one character, in dots.
+    def advance(ch, face)
+      return face.char_w + face.gap if face.style == :bitmap
+
+      code = printable_code(ch)
+      if (tt = vector)
+        [(tt.advance(code) / tt.units_per_em.to_f * ADVANCE_SCALE * face.char_w).round, 1].max
+      else
+        afm = HELVETICA_WIDTHS[code - 32] || 556
+        [(afm / 1000.0 * ADVANCE_SCALE * face.char_w).round, 1].max
+      end
+    end
+
+    # Rendered width of a line of text, in dots.
+    def measure(text, face)
+      prepare(text, face).each_char.sum { |ch| advance(ch, face) }
+    end
+
+    # Height of one text line (canvas height and stacking step), in dots.
+    def line_height(face)
+      face.char_h
+    end
+
+    # Baseline offset from the top of the field, in dots.
+    def baseline(face)
+      scale = face.style == :bitmap ? BITMAP_CAP_SCALE : CAP_SCALE
+      (scale * face.char_h).round
+    end
+
+    def prepare(text, face)
+      face.upcase ? text.to_s.upcase : text.to_s
+    end
+
+    def printable_code(ch)
+      code = ch.ord
+      code < 32 || code == 127 ? "?".ord : code
+    end
+
+    # Render a single line of text into a fresh Canvas.
+    def render_line(text, face)
+      text = prepare(text, face)
+      width = [measure(text, face), 1].max
+      canvas = Canvas.new(width, [line_height(face), 1].max)
+      draw_line(canvas, 0, 0, text, face)
+      canvas
+    end
+
+    def draw_line(canvas, x, y, text, face)
+      pen = x
+      prepare(text, face).each_char do |ch|
+        adv = advance(ch, face)
+        draw_char(canvas, pen, y, ch, face, adv)
+        pen += adv
+      end
+      pen - x
+    end
+
+    def draw_char(canvas, x, y, ch, face, adv)
+      code = printable_code(ch)
+      tt = face.style == :bitmap ? mono_vector : vector
+      if tt
+        draw_vector_char(canvas, x, y, code, face, adv, tt)
+      else
+        draw_fallback_char(canvas, x, y, code, face, adv)
+      end
+    end
+
+    def draw_vector_char(canvas, x, y, code, face, adv, tt)
+      upm = tt.units_per_em.to_f
+      scale_y = baseline(face) / tt.cap_height.to_f
+      if face.style == :scalable
+        scale_x = ADVANCE_SCALE * face.char_w / upm
+        pen_x = x
+      else
+        # scale the mono advance to the matrix cell width, glyph centered
+        natural = tt.advance(code) / upm # em units
+        scale_x = face.char_w / natural / upm
+        glyph_adv = (tt.advance(code) * scale_x).round
+        pen_x = x + (adv - face.gap - glyph_adv) / 2
+      end
+      glyph = tt.glyph_bitmap(code, scale_x, scale_y)
+      return unless glyph
+
+      base_y = y + baseline(face)
+      canvas.blit(glyph.canvas, pen_x + glyph.left, base_y - glyph.top)
+    end
+
+    # ---- 8x8 bitmap fallback -------------------------------------------------
+
+    # Per-glyph [leftmost ink column, ink width in columns], nil for blank.
+    GLYPH_EXTENTS = FONT8X8.map do |glyph|
+      min = 8
+      max = -1
+      glyph.each do |row|
+        next if row.zero?
+
+        8.times do |bit|
+          next unless (row >> bit) & 1 == 1
+
+          min = bit if bit < min
+          max = bit if bit > max
+        end
+      end
+      max >= 0 ? [min, max - min + 1].freeze : nil
+    end.freeze
+
+    def draw_fallback_char(canvas, x, y, code, face, adv)
+      glyph = FONT8X8[code]
+      extents = GLYPH_EXTENTS[code]
+      return unless glyph && extents
+
+      cell_h = (face.char_h * 0.99).round
+      bearing = [(adv * 0.1).round, 1].max
+      target_w = [adv - 2 * bearing, 1].max
+      left, src_w = face.style == :bitmap ? [0, 8] : extents
+      (0...cell_h).each do |py|
+        row = glyph[py * 8 / cell_h]
+        next if row.zero?
+
+        (0...target_w).each do |px|
+          bit = left + px * src_w / target_w
+          canvas.set(x + bearing + px, y + py) if (row >> bit) & 1 == 1
+        end
+      end
+    end
+  end
+end

data/lib/zpl_render/font_data.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module ZplRender
+
+  # 8x8 monochrome bitmap font covering ASCII 0x00-0x7F.
+
+  # Derived from font8x8 by Daniel Hepper (public domain),
+
+  # based on public-domain IBM VGA fonts. Each glyph is 8 bytes,
+
+  # one per row, LSB = leftmost pixel.
+
+  FONT8X8 = [
+
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    # ^ 0x00-0x0f
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    # ^ 0x10-0x1f
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x18, 0x3C, 0x3C, 0x18, 0x18, 0x00, 0x18, 0x00],
+    [0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x36, 0x36, 0x7F, 0x36, 0x7F, 0x36, 0x36, 0x00],
+    [0x0C, 0x3E, 0x03, 0x1E, 0x30, 0x1F, 0x0C, 0x00],
+    [0x00, 0x63, 0x33, 0x18, 0x0C, 0x66, 0x63, 0x00],
+    [0x1C, 0x36, 0x1C, 0x6E, 0x3B, 0x33, 0x6E, 0x00],
+    [0x06, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x18, 0x0C, 0x06, 0x06, 0x06, 0x0C, 0x18, 0x00],
+    [0x06, 0x0C, 0x18, 0x18, 0x18, 0x0C, 0x06, 0x00],
+    [0x00, 0x66, 0x3C, 0xFF, 0x3C, 0x66, 0x00, 0x00],
+    [0x00, 0x0C, 0x0C, 0x3F, 0x0C, 0x0C, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x06],
+    [0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x00],
+    [0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x00],
+    # ^ 0x20-0x2f
+    [0x3E, 0x63, 0x73, 0x7B, 0x6F, 0x67, 0x3E, 0x00],
+    [0x0C, 0x0E, 0x0C, 0x0C, 0x0C, 0x0C, 0x3F, 0x00],
+    [0x1E, 0x33, 0x30, 0x1C, 0x06, 0x33, 0x3F, 0x00],
+    [0x1E, 0x33, 0x30, 0x1C, 0x30, 0x33, 0x1E, 0x00],
+    [0x38, 0x3C, 0x36, 0x33, 0x7F, 0x30, 0x78, 0x00],
+    [0x3F, 0x03, 0x1F, 0x30, 0x30, 0x33, 0x1E, 0x00],
+    [0x1C, 0x06, 0x03, 0x1F, 0x33, 0x33, 0x1E, 0x00],
+    [0x3F, 0x33, 0x30, 0x18, 0x0C, 0x0C, 0x0C, 0x00],
+    [0x1E, 0x33, 0x33, 0x1E, 0x33, 0x33, 0x1E, 0x00],
+    [0x1E, 0x33, 0x33, 0x3E, 0x30, 0x18, 0x0E, 0x00],
+    [0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x00],
+    [0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x06],
+    [0x18, 0x0C, 0x06, 0x03, 0x06, 0x0C, 0x18, 0x00],
+    [0x00, 0x00, 0x3F, 0x00, 0x00, 0x3F, 0x00, 0x00],
+    [0x06, 0x0C, 0x18, 0x30, 0x18, 0x0C, 0x06, 0x00],
+    [0x1E, 0x33, 0x30, 0x18, 0x0C, 0x00, 0x0C, 0x00],
+    # ^ 0x30-0x3f
+    [0x3E, 0x63, 0x7B, 0x7B, 0x7B, 0x03, 0x1E, 0x00],
+    [0x0C, 0x1E, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x00],
+    [0x3F, 0x66, 0x66, 0x3E, 0x66, 0x66, 0x3F, 0x00],
+    [0x3C, 0x66, 0x03, 0x03, 0x03, 0x66, 0x3C, 0x00],
+    [0x1F, 0x36, 0x66, 0x66, 0x66, 0x36, 0x1F, 0x00],
+    [0x7F, 0x46, 0x16, 0x1E, 0x16, 0x46, 0x7F, 0x00],
+    [0x7F, 0x46, 0x16, 0x1E, 0x16, 0x06, 0x0F, 0x00],
+    [0x3C, 0x66, 0x03, 0x03, 0x73, 0x66, 0x7C, 0x00],
+    [0x33, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x33, 0x00],
+    [0x1E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00],
+    [0x78, 0x30, 0x30, 0x30, 0x33, 0x33, 0x1E, 0x00],
+    [0x67, 0x66, 0x36, 0x1E, 0x36, 0x66, 0x67, 0x00],
+    [0x0F, 0x06, 0x06, 0x06, 0x46, 0x66, 0x7F, 0x00],
+    [0x63, 0x77, 0x7F, 0x7F, 0x6B, 0x63, 0x63, 0x00],
+    [0x63, 0x67, 0x6F, 0x7B, 0x73, 0x63, 0x63, 0x00],
+    [0x1C, 0x36, 0x63, 0x63, 0x63, 0x36, 0x1C, 0x00],
+    # ^ 0x40-0x4f
+    [0x3F, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x0F, 0x00],
+    [0x1E, 0x33, 0x33, 0x33, 0x3B, 0x1E, 0x38, 0x00],
+    [0x3F, 0x66, 0x66, 0x3E, 0x36, 0x66, 0x67, 0x00],
+    [0x1E, 0x33, 0x07, 0x0E, 0x38, 0x33, 0x1E, 0x00],
+    [0x3F, 0x2D, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00],
+    [0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, 0x00],
+    [0x33, 0x33, 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x00],
+    [0x63, 0x63, 0x63, 0x6B, 0x7F, 0x77, 0x63, 0x00],
+    [0x63, 0x63, 0x36, 0x1C, 0x1C, 0x36, 0x63, 0x00],
+    [0x33, 0x33, 0x33, 0x1E, 0x0C, 0x0C, 0x1E, 0x00],
+    [0x7F, 0x63, 0x31, 0x18, 0x4C, 0x66, 0x7F, 0x00],
+    [0x1E, 0x06, 0x06, 0x06, 0x06, 0x06, 0x1E, 0x00],
+    [0x03, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x40, 0x00],
+    [0x1E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1E, 0x00],
+    [0x08, 0x1C, 0x36, 0x63, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF],
+    # ^ 0x50-0x5f
+    [0x0C, 0x0C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x1E, 0x30, 0x3E, 0x33, 0x6E, 0x00],
+    [0x07, 0x06, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00],
+    [0x00, 0x00, 0x1E, 0x33, 0x03, 0x33, 0x1E, 0x00],
+    [0x38, 0x30, 0x30, 0x3e, 0x33, 0x33, 0x6E, 0x00],
+    [0x00, 0x00, 0x1E, 0x33, 0x3f, 0x03, 0x1E, 0x00],
+    [0x1C, 0x36, 0x06, 0x0f, 0x06, 0x06, 0x0F, 0x00],
+    [0x00, 0x00, 0x6E, 0x33, 0x33, 0x3E, 0x30, 0x1F],
+    [0x07, 0x06, 0x36, 0x6E, 0x66, 0x66, 0x67, 0x00],
+    [0x0C, 0x00, 0x0E, 0x0C, 0x0C, 0x0C, 0x1E, 0x00],
+    [0x30, 0x00, 0x30, 0x30, 0x30, 0x33, 0x33, 0x1E],
+    [0x07, 0x06, 0x66, 0x36, 0x1E, 0x36, 0x67, 0x00],
+    [0x0E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00],
+    [0x00, 0x00, 0x33, 0x7F, 0x7F, 0x6B, 0x63, 0x00],
+    [0x00, 0x00, 0x1F, 0x33, 0x33, 0x33, 0x33, 0x00],
+    [0x00, 0x00, 0x1E, 0x33, 0x33, 0x33, 0x1E, 0x00],
+    # ^ 0x60-0x6f
+    [0x00, 0x00, 0x3B, 0x66, 0x66, 0x3E, 0x06, 0x0F],
+    [0x00, 0x00, 0x6E, 0x33, 0x33, 0x3E, 0x30, 0x78],
+    [0x00, 0x00, 0x3B, 0x6E, 0x66, 0x06, 0x0F, 0x00],
+    [0x00, 0x00, 0x3E, 0x03, 0x1E, 0x30, 0x1F, 0x00],
+    [0x08, 0x0C, 0x3E, 0x0C, 0x0C, 0x2C, 0x18, 0x00],
+    [0x00, 0x00, 0x33, 0x33, 0x33, 0x33, 0x6E, 0x00],
+    [0x00, 0x00, 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x00],
+    [0x00, 0x00, 0x63, 0x6B, 0x7F, 0x7F, 0x36, 0x00],
+    [0x00, 0x00, 0x63, 0x36, 0x1C, 0x36, 0x63, 0x00],
+    [0x00, 0x00, 0x33, 0x33, 0x33, 0x3E, 0x30, 0x1F],
+    [0x00, 0x00, 0x3F, 0x19, 0x0C, 0x26, 0x3F, 0x00],
+    [0x38, 0x0C, 0x0C, 0x07, 0x0C, 0x0C, 0x38, 0x00],
+    [0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00],
+    [0x07, 0x0C, 0x0C, 0x38, 0x0C, 0x0C, 0x07, 0x00],
+    [0x6E, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+    # ^ 0x70-0x7f
+  ].each(&:freeze).freeze
+
+end

data/lib/zpl_render/fonts/LICENSE-LiberationSans.txt

@@ -0,0 +1,102 @@
+Digitized data copyright (c) 2010 Google Corporation
+	with Reserved Font Arimo, Tinos and Cousine.
+Copyright (c) 2012 Red Hat, Inc.
+	with Reserved Font Name Liberation.
+
+This Font Software is licensed under the SIL Open Font License,
+Version 1.1.
+
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+
+PREAMBLE The goals of the Open Font License (OFL) are to stimulate
+worldwide development of collaborative font projects, to support the font
+creation efforts of academic and linguistic communities, and to provide
+a free and open framework in which fonts may be shared and improved in
+partnership with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves.
+The fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works.  The fonts and derivatives,
+however, cannot be released under any other type of license.  The
+requirement for fonts to remain under this license does not apply to
+any document created using the fonts or their derivatives.
+
+ 
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such.
+This may include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components
+as distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting ? in part or in whole ?
+any of the components of the Original Version, by changing formats or
+by porting the Font Software to a new environment.
+
+"Author" refers to any designer, engineer, programmer, technical writer
+or other person who contributed to the Font Software.
+
+
+PERMISSION & CONDITIONS
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,in
+   Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+   redistributed and/or sold with any software, provided that each copy
+   contains the above copyright notice and this license. These can be
+   included either as stand-alone text files, human-readable headers or
+   in the appropriate machine-readable metadata fields within text or
+   binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+   Name(s) unless explicit written permission is granted by the
+   corresponding Copyright Holder. This restriction only applies to the
+   primary font name as presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+   Software shall not be used to promote, endorse or advertise any
+   Modified Version, except to acknowledge the contribution(s) of the
+   Copyright Holder(s) and the Author(s) or with their explicit written
+   permission.
+
+5) The Font Software, modified or unmodified, in part or in whole, must
+   be distributed entirely under this license, and must not be distributed
+   under any other license. The requirement for fonts to remain under
+   this license does not apply to any document created using the Font
+   Software.
+
+
+ 
+TERMINATION
+This license becomes null and void if any of the above conditions are not met.
+
+ 
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT.  IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER
+DEALINGS IN THE FONT SOFTWARE.
+

data/lib/zpl_render/graphic_field.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module ZplRender
+  # Decodes ZPL graphic data (^GF and ~DG) into a Canvas.
+  #
+  # Supports:
+  #  - ASCII hex data, including Zebra's run-length compression scheme
+  #    (G-Y repeat counts, g-z counts in multiples of 20, ',' zero-fill
+  #    to end of row, '!' one-fill to end of row, ':' repeat previous row)
+  #  - :B64: (base64) and :Z64: (base64 + zlib deflate) wrapped data
+  #  - raw binary data (^GFB)
+  module GraphicField
+    module_function
+
+    # bytes_per_row determines the pixel width (8 px per byte).
+    def decode(data, bytes_per_row, total_bytes)
+      return Canvas.new(1, 1) if bytes_per_row.to_i < 1 || total_bytes.to_i < 1
+
+      rows = (total_bytes.to_f / bytes_per_row).ceil
+      raw = if data =~ /\A:?([BZ])64:/
+              decode_b64_z64(data)
+            elsif data.encoding == Encoding::BINARY && data =~ /[^0-9A-Fa-f,:!\sG-Yg-z]/n
+              data # raw binary (^GFB)
+            else
+              decode_ascii_hex(data, bytes_per_row)
+            end
+      to_canvas(raw, bytes_per_row, rows)
+    end
+
+    def decode_b64_z64(data)
+      m = data.match(/\A:?([BZ])64:([A-Za-z0-9+\/=\s]*):?[0-9A-Fa-f]{0,4}\z/m)
+      return "" unless m
+
+      decoded = m[2].unpack1("m") # lenient base64, same as Base64.decode64
+      m[1] == "Z" ? Zlib::Inflate.inflate(decoded) : decoded
+    rescue Zlib::Error
+      ""
+    end
+
+    # Expand Zebra RLE ASCII hex into raw bytes.
+    def decode_ascii_hex(data, bytes_per_row)
+      nibbles_per_row = bytes_per_row * 2
+      out = []
+      row = []
+      prev_row = nil
+      count = 0
+      i = 0
+      flush = lambda do
+        row << 0 while row.length < nibbles_per_row
+        out.concat(row[0, nibbles_per_row])
+        prev_row = row[0, nibbles_per_row]
+        row = []
+      end
+
+      while i < data.length
+        ch = data[i]
+        i += 1
+        case ch
+        when /[0-9A-Fa-f]/
+          nib = ch.to_i(16)
+          (count.zero? ? 1 : count).times { row << nib }
+          count = 0
+          flush.call if row.length >= nibbles_per_row
+        when "G".."Y"
+          count += ch.ord - "G".ord + 1
+        when "g".."z"
+          count += (ch.ord - "g".ord + 1) * 20
+        when ","
+          row << 0 while row.length < nibbles_per_row
+          flush.call
+          count = 0
+        when "!"
+          row << 0xF while row.length < nibbles_per_row
+          flush.call
+          count = 0
+        when ":"
+          flush.call unless row.empty?
+          if prev_row
+            out.concat(prev_row)
+          else
+            out.concat(Array.new(nibbles_per_row, 0))
+          end
+          count = 0
+        end
+        # whitespace and anything else is ignored
+      end
+      flush.call unless row.empty?
+
+      bytes = +""
+      out.each_slice(2) { |hi, lo| bytes << ((hi << 4) | (lo || 0)).chr }
+      bytes.b
+    end
+
+    def to_canvas(raw, bytes_per_row, rows)
+      width = bytes_per_row * 8
+      canvas = Canvas.new(width, [rows, 1].max)
+      rows.times do |y|
+        bytes_per_row.times do |bx|
+          byte = raw.getbyte(y * bytes_per_row + bx)
+          next if byte.nil? || byte.zero?
+
+          8.times do |bit|
+            canvas.set(bx * 8 + bit, y) if (byte >> (7 - bit)) & 1 == 1
+          end
+        end
+      end
+      canvas
+    end
+  end
+end