squib 0.13.4 → 0.14.beta1

data/lib/squib/graphics/save_sprue.rb

@@ -0,0 +1,228 @@
+module Squib
+  module Graphics
+    # Helper class to generate templated sheet.
+    class SaveSprue
+      def initialize(deck, tmpl, outfile)
+        @deck = deck
+        @tmpl = tmpl
+        @page_number = 1
+        @outfile = outfile
+        @rotated_delta = (@tmpl.card_width - @deck.width).abs / 2
+        @overlay_lines = @tmpl.crop_lines.select do |line|
+          line['overlay_on_cards']
+        end
+      end
+
+      def render_sheet(range)
+        cc = init_cc
+        cc.set_source_color(:white) # white backdrop TODO make option
+        cc.paint
+        card_set = @tmpl.cards
+        per_sheet = card_set.size
+        default_angle = @tmpl.card_default_rotation
+        if default_angle.zero?
+          default_angle = check_card_orientation
+        end
+
+        draw_overlay_below_cards cc if range.size
+
+        track_progress(range) do |bar|
+          range.each do |i|
+            cc = next_page_if_needed(cc, i, per_sheet)
+
+            card = @deck.cards[i]
+            slot = card_set[i % per_sheet]
+            x = slot['x']
+            y = slot['y']
+            angle = slot['rotate'] != 0 ? slot['rotate'] : default_angle
+
+            if angle != 0
+              draw_rotated_card cc, card, x, y, angle
+            else
+              cc.set_source card.cairo_surface, x, y
+            end
+            cc.paint
+
+            bar.increment
+          end
+
+          draw_overlay_above_cards cc
+          cc = draw_page cc
+          cc.target.finish
+        end
+      end
+
+      protected
+
+      # Initialize the Cairo Context
+      def init_cc
+        raise NotImplementedError
+      end
+
+      def draw_page(cc)
+        raise NotImplementedError
+      end
+
+      def full_filename
+        raise NotImplementedError
+      end
+
+      private
+
+      def next_page_if_needed(cc, i, per_sheet)
+        return cc unless (i != 0) && (i % per_sheet).zero?
+
+        draw_overlay_above_cards cc
+        cc = draw_page cc
+        draw_overlay_below_cards cc
+        @page_number += 1
+        cc
+      end
+
+      def track_progress(range)
+        msg = "Saving templated sheet to #{full_filename}"
+        @deck.progress_bar.start(msg, range.size) { |bar| yield(bar) }
+      end
+
+      def draw_overlay_below_cards(cc)
+        if @tmpl.crop_line_overlay == :on_margin
+          add_margin_overlay_clip_mask cc
+          cc.clip
+          draw_crop_line cc, @tmpl.crop_lines
+          cc.reset_clip
+        elsif @tmpl.crop_line_overlay == :beneath_cards
+          draw_crop_line cc, @tmpl.crop_lines
+        end
+      end
+
+      def draw_overlay_above_cards(cc)
+        if @tmpl.crop_line_overlay == :overlay_on_cards
+          draw_crop_line cc, @tmpl.crop_lines
+        else
+          draw_crop_line cc, @overlay_lines
+        end
+      end
+
+      def add_margin_overlay_clip_mask(cc)
+        margin = @tmpl.margin
+        cc.new_path
+        cc.rectangle(
+          margin[:left], margin[:top],
+          margin[:right] - margin[:left],
+          margin[:bottom] - margin[:top]
+        )
+        cc.new_sub_path
+        cc.move_to @tmpl.sheet_width, 0
+        cc.line_to 0, 0
+        cc.line_to 0, @tmpl.sheet_height
+        cc.line_to @tmpl.sheet_width, @tmpl.sheet_height
+        cc.close_path
+      end
+
+      def draw_crop_line(cc, crop_lines)
+        crop_lines.each do |line|
+          cc.move_to line['line'].x1, line['line'].y1
+          cc.line_to line['line'].x2, line['line'].y2
+          cc.set_source_color line['color']
+          cc.set_line_width line['width']
+          cc.set_dash(line['style'].pattern) if line['style'].pattern
+          cc.stroke
+        end
+      end
+
+      def check_card_orientation
+        clockwise = 1.5 * Math::PI
+        if @deck.width <= @tmpl.card_width &&
+           @deck.height <= @tmpl.card_height
+          return 0
+        elsif (
+            @deck.width == @tmpl.card_height &&
+            @deck.height == @tmpl.card_width)
+          Squib.logger.warn {
+            'Rotating cards to match card orientation in template.'
+          }
+          return clockwise
+        end
+
+        Squib.logger.warn {
+          'Card size is larger than sprue\'s expected card size. '\
+          'Cards may overlap.'
+        }
+        return 0
+      end
+
+      def draw_rotated_card(cc, card, x, y, angle)
+        # Normalize the angles first
+        angle = angle % (2 * Math::PI)
+        angle = 2 * Math::PI - angle if angle < 0
+
+        # Determine what's the delta we need to translate our cards
+        delta_shift = @deck.width < @deck.height ? 1 : -1
+        if angle.zero? || angle == Math::PI
+          delta = 0
+        elsif angle < Math::PI
+          delta = -delta_shift * @rotated_delta
+        else
+          delta = delta_shift * @rotated_delta
+        end
+
+        # Perform the actual rotation and drawing
+        mat = cc.matrix # Save the transformation matrix to revert later
+        cc.translate x, y
+        cc.translate @deck.width / 2, @deck.height / 2
+        cc.rotate angle
+        cc.translate(-@deck.width / 2 + delta, -@deck.height / 2 + delta)
+        cc.set_source card.cairo_surface, 0, 0
+        cc.matrix = mat
+      end
+    end
+
+    # Templated sheet renderer in PDF format.
+    class SaveSpruePDF < SaveSprue
+      def init_cc
+        ratio = 72.0 / @deck.dpi
+
+        surface = Cairo::PDFSurface.new(
+          full_filename,
+          @tmpl.sheet_width * ratio,
+          @tmpl.sheet_height * ratio
+        )
+
+        cc = Cairo::Context.new(surface)
+        cc.scale(72.0 / @deck.dpi, 72.0 / @deck.dpi) # make it like pixels
+        cc
+      end
+
+      def draw_page(cc)
+        cc.show_page
+        cc.set_source_color(:white) # white backdrop TODO make option
+        cc.paint
+        cc
+      end
+
+      def full_filename
+        @outfile.full_filename
+      end
+    end
+
+    # Templated sheet renderer in PNG format.
+    class SaveSpruePNG < SaveSprue
+      def init_cc
+        surface = Cairo::ImageSurface.new @tmpl.sheet_width, @tmpl.sheet_height
+        Cairo::Context.new(surface)
+      end
+
+      def draw_page(cc)
+        cc.target.write_to_png(full_filename)
+        init_cc
+        cc.set_source_color(:white) # white backdrop TODO make option
+        cc.paint
+        cc
+      end
+
+      def full_filename
+        @outfile.full_filename @page_number
+      end
+    end
+  end
+end

data/lib/squib/graphics/shapes.rb

@@ -18,8 +18,14 @@ module Squib
     def circle(box, draw)
       x, y, r = box.x, box.y, box.radius
       use_cairo do |cc|
-        cc.move_to(x + r, y)
-        cc.circle(x, y, r)
+        if box.arc_direction == :clockwise
+          cc.arc(x, y, r, box.arc_start, box.arc_end)          
+        else
+          cc.arc_negative(x, y, r, box.arc_start, box.arc_end)
+        end
+        if box.arc_close
+          cc.close_path();
+        end
         cc.fill_n_stroke(draw)
       end
     end

data/lib/squib/graphics/text.rb

@@ -123,7 +123,7 @@ module Squib
 
     # :nodoc:
     # @api private
-    def text(embed, para, box, trans, draw)
+    def text(embed, para, box, trans, draw, dpi)
       Squib.logger.debug {"Rendering text with: \n#{para} \nat:\n #{box} \ndraw:\n #{draw} \ntransform: #{trans}"}
       extents = nil
       use_cairo do |cc|
@@ -136,10 +136,11 @@ module Squib
         font_desc.size = para.font_size * Pango::SCALE unless para.font_size.nil?
         layout         = cc.create_pango_layout
         layout.font_description = font_desc
-        layout.text = para.str
+        layout.text = para.str.to_s
+        layout.context.resolution = dpi
         if para.markup
           para.str = @deck.typographer.process(layout.text)
-          layout.markup = para.str
+          layout.markup = para.str.to_s
         end
 
         set_font_rendering_opts!(layout)

data/lib/squib/layout_parser.rb

@@ -34,7 +34,7 @@ module Squib
 
     # Determine the file path of the built-in layout file
     def builtin(file)
-      "#{File.dirname(__FILE__)}/layouts/#{file}"
+      "#{File.dirname(__FILE__)}/builtin/layouts/#{file}"
     end
 
     # Process the extends recursively
@@ -53,6 +53,10 @@ module Squib
             add_parent_child(parent_val, child_val)
           elsif child_val.to_s.strip.start_with?('-=')
             sub_parent_child(parent_val, child_val)
+          elsif child_val.to_s.strip.start_with?('*=')
+            mul_parent_child(parent_val, child_val)
+          elsif child_val.to_s.strip.start_with?('/=')
+            div_parent_child(parent_val, child_val)
           else
             child_val # child overrides parent when merging, no +=
           end
@@ -76,6 +80,18 @@ module Squib
       parent_pixels - child_pixels
     end
 
+    def mul_parent_child(parent, child)
+      parent_pixels = Args::UnitConversion.parse(parent, @dpi).to_f
+      child_float = child.sub('*=', '').to_f
+      parent_pixels * child_float
+    end
+
+    def div_parent_child(parent, child)
+      parent_pixels = Args::UnitConversion.parse(parent, @dpi).to_f
+      child_float = child.sub('/=', '').to_f
+      parent_pixels / child_float
+    end
+
     # Does this layout entry have an extends field?
     # i.e. is it a base-case or will it need recursion?
     # :nodoc:

data/lib/squib/sample_helpers.rb

@@ -24,7 +24,7 @@ module Squib
       text str: str, x: 460, y: @sample_y - 40,
            width: 540, height: 180,
            valign: 'middle', align: 'center',
-           font: 'Times New Roman,Serif 24'
+           font: 'Times New Roman,Serif 8'
       yield @sample_x, @sample_y
       @sample_y += 200
     end

data/lib/squib/sprues/crop_line.rb

@@ -0,0 +1,28 @@
+module Squib
+  module Sprues
+    class CropLine
+      attr_reader :x1, :y1, :x2, :y2
+
+      def initialize(type, position, sheet_width, sheet_height, dpi)
+        method = "parse_#{type}"
+        send method, position, sheet_width, sheet_height, dpi
+      end
+
+      def parse_horizontal(position, sheet_width, _, dpi)
+        position = Args::UnitConversion.parse(position, dpi)
+        @x1 = 0
+        @y1 = position
+        @x2 = sheet_width
+        @y2 = position
+      end
+
+      def parse_vertical(position, _, sheet_height, dpi)
+        position = Args::UnitConversion.parse(position, dpi)
+        @x1 = position
+        @y1 = 0
+        @x2 = position
+        @y2 = sheet_height
+      end
+    end
+  end
+end

data/lib/squib/sprues/crop_line_dash.rb

@@ -0,0 +1,35 @@
+module Squib
+  module Sprues
+    class CropLineDash
+      VALIDATION_REGEX = /%r{
+        ^(\d*[.])?\d+(in|cm|mm)
+        \s+
+        (\d*[.])?\d+(in|cm|mm)$
+      }x/
+
+      attr_reader :pattern
+
+      def initialize(value, dpi)
+        if value == :solid
+          @pattern = nil
+        elsif value == :dotted
+          @pattern = [
+            Args::UnitConversion.parse('0.2mm', dpi),
+            Args::UnitConversion.parse('0.5mm', dpi)
+          ]
+        elsif value == :dashed
+          @pattern = [
+            Args::UnitConversion.parse('2mm', dpi),
+            Args::UnitConversion.parse('2mm', dpi)
+          ]
+        elsif value.is_a? String
+          @pattern = value.split(' ').map do |val|
+            Args::UnitConversion.parse val, dpi
+          end
+        else
+          raise ArgumentError, 'Unsupported dash style'
+        end
+      end
+    end
+  end
+end

data/lib/squib/sprues/invalid_sprue_definition.rb

@@ -0,0 +1,9 @@
+module Squib
+  module Sprues
+    class InvalidSprueDefinition < StandardError
+      def initialize(file, error)
+        super("Invalid sprue definition in file: #{file}. #{error.message}")
+      end
+    end
+  end
+end

data/lib/squib/sprues/sprue.rb

@@ -0,0 +1,203 @@
+require 'yaml'
+require 'classy_hash'
+require_relative '../args/color_validator'
+require_relative '../args/unit_conversion'
+require_relative 'crop_line'
+require_relative 'crop_line_dash'
+require_relative 'invalid_sprue_definition'
+require_relative 'sprue_schema'
+
+module Squib
+  class Sprue
+    include Args::ColorValidator
+
+    # Defaults are set for poker sized deck on a A4 sheet, with no cards
+    DEFAULTS = {
+      'sheet_width' => nil,
+      'sheet_height' => nil,
+      'card_width' => nil,
+      'card_height' => nil,
+      'dpi' => 300,
+      'position_reference' => :topleft,
+      'rotate' => 0.0,
+      'crop_line' => {
+        'style' => :solid,
+        'width' => '0.02mm',
+        'color' => :black,
+        'overlay' => :on_margin,
+        'lines' => []
+      },
+      'cards' => []
+    }.freeze
+
+    attr_reader :dpi
+
+    def initialize(template_hash, dpi)
+      @template_hash = template_hash
+      @dpi = dpi
+      @crop_line_default = @template_hash['crop_line'].select do |k, _|
+        %w[style width color].include? k
+      end
+    end
+
+    # Load the template definition file
+    def self.load(file, dpi)
+      yaml = {}
+      thefile = file if File.exist?(file) # use custom first
+      thefile = builtin(file) if File.exist?(builtin(file)) # then builtin
+      unless File.exist?(thefile)
+        Squib::logger.error("Sprue not found: #{file}. Falling back to defaults.")
+      end
+      yaml = YAML.load_file(thefile) || {} if File.exist? thefile
+      # Bake the default values into our sprue
+      new_hash = DEFAULTS.merge(yaml)
+      new_hash['crop_line'] = DEFAULTS['crop_line'].
+                                merge(new_hash['crop_line'])
+      warn_unrecognized(yaml)
+
+      # Validate
+      begin
+        require 'benchmark'
+        ClassyHash.validate(new_hash, Sprues::SCHEMA)
+      rescue ClassyHash::SchemaViolationError => e
+        raise Sprues::InvalidSprueDefinition.new(thefile, e)
+      end
+      Sprue.new new_hash, dpi
+    end
+
+    def sheet_width
+      Args::UnitConversion.parse @template_hash['sheet_width'], @dpi
+    end
+
+    def sheet_height
+      Args::UnitConversion.parse @template_hash['sheet_height'], @dpi
+    end
+
+    def card_width
+      Args::UnitConversion.parse @template_hash['card_width'], @dpi
+    end
+
+    def card_height
+      Args::UnitConversion.parse @template_hash['card_height'], @dpi
+    end
+
+    def card_default_rotation
+      parse_rotate_param @template_hash['rotate']
+    end
+
+    def crop_line_overlay
+      @template_hash['crop_line']['overlay']
+    end
+
+    def crop_lines
+      lines = @template_hash['crop_line']['lines'].map(
+        &method(:parse_crop_line)
+      )
+      if block_given?
+        lines.each { |v| yield v }
+      else
+        lines
+      end
+    end
+
+    def cards
+      parsed_cards = @template_hash['cards'].map(&method(:parse_card))
+      if block_given?
+        parsed_cards.each { |v| yield v }
+      else
+        parsed_cards
+      end
+    end
+
+    def margin
+      # NOTE: There's a baseline of 0.25mm that we can 100% make sure that we
+      # can overlap really thin lines on the PDF
+      crop_line_width = [
+        Args::UnitConversion.parse(@template_hash['crop_line']['width'], @dpi),
+        Args::UnitConversion.parse('0.25mm', @dpi)
+      ].max
+
+      parsed_cards = cards
+      left, right = parsed_cards.minmax { |a, b| a['x'] <=> b['x'] }
+      top, bottom = parsed_cards.minmax { |a, b| a['y'] <=> b['y'] }
+
+      {
+        left: left['x'] - crop_line_width,
+        right: right['x'] + card_width + crop_line_width,
+        top: top['y'] - crop_line_width,
+        bottom: bottom['y'] + card_height + crop_line_width
+      }
+    end
+
+    # Warn unrecognized options in the template sheet
+    def self.warn_unrecognized(yaml)
+      unrec = yaml.keys - DEFAULTS.keys
+      return unless unrec.any?
+
+      Squib.logger.warn(
+        "Unrecognized configuration option(s): #{unrec.join(',')}"
+      )
+    end
+
+    private
+
+    # Return path for built-in sheet templates
+    def self.builtin(file)
+      "#{File.dirname(__FILE__)}/../builtin/sprues/#{file}"
+    end
+
+    # Parse crop line definitions from template.
+    def parse_crop_line(line)
+      new_line = @crop_line_default.merge line
+      new_line['width'] = Args::UnitConversion.parse(new_line['width'], @dpi)
+      new_line['color'] = colorify new_line['color']
+      new_line['style_desc'] = new_line['style']
+      new_line['style'] = Sprues::CropLineDash.new(new_line['style'], @dpi)
+      new_line['line'] = Sprues::CropLine.new(
+        new_line['type'], new_line['position'], sheet_width, sheet_height, @dpi
+      )
+      new_line
+    end
+
+    # Parse card definitions from template.
+    def parse_card(card)
+      new_card = card.clone
+
+      x = Args::UnitConversion.parse(card['x'], @dpi)
+      y = Args::UnitConversion.parse(card['y'], @dpi)
+      if @template_hash['position_reference'] == :center
+        # Normalize it to a top-left positional reference
+        x -= card_width / 2
+        y -= card_height / 2
+      end
+
+      new_card['x'] = x
+      new_card['y'] = y
+      new_card['rotate'] = parse_rotate_param(
+        card['rotate'] ? card['rotate'] : @template_hash['rotate'])
+      new_card
+    end
+
+    def parse_rotate_param(val)
+      if val == :clockwise
+        0.5 * Math::PI
+      elsif val == :counterclockwise
+        1.5 * Math::PI
+      elsif val == :turnaround
+        Math::PI
+      elsif val.is_a? String
+        if val.end_with? 'deg'
+          val.gsub(/deg$/, '').to_f / 180 * Math::PI
+        elsif val.end_with? 'rad'
+          val.gsub(/rad$/, '').to_f
+        else
+          val.to_f
+        end
+      elsif val.nil?
+        0.0
+      else
+        val.to_f
+      end
+    end
+  end
+end