squib 0.6.0 → 0.7.0

data/lib/squib/graphics/hand.rb

@@ -1,43 +1,42 @@
-require 'squib/graphics/cairo_context_wrapper'
-
-module Squib
-  class Deck
-
-    # Draw cards in a fan.
-    # @api private
-    def render_hand(range, radius, angle_range, trim, trim_radius, margin,
-                    fill_color, dir, file)
-      cards       = range.collect { |i| @cards[i] }
-      center_x    = width / 2.0
-      center_y    = radius + height
-      out_size    = 3.0 * center_y
-      angle_delta = (angle_range.last - angle_range.first) / cards.size
-      cxt = Cairo::Context.new(Cairo::RecordingSurface.new(0, 0, out_size, out_size))
-      cxt.translate(out_size / 2.0, out_size / 2.0)
-      cxt.rotate(angle_range.first)
-      cxt.translate(-width, -width)
-      cards.each_with_index do |card, i|
-        cxt.translate(center_x, center_y)
-        cxt.rotate(angle_delta)
-        cxt.translate(-center_x, -center_y)
-        card.use_cairo do |card_cxt|
-          cxt.rounded_rectangle(trim, trim,
-                                width - (2 * trim), height - (2 * trim),
-                                trim_radius, trim_radius)
-          cxt.clip
-          cxt.set_source(card_cxt.target)
-          cxt.paint
-          cxt.reset_clip
-        end
-      end
-      x, y, w, h = cxt.target.ink_extents # I love Ruby assignment ;)
-      png_cxt = Squib::Graphics::CairoContextWrapper.new(Cairo::Context.new(Cairo::ImageSurface.new(w + 2*margin, h + 2*margin)))
-      png_cxt.set_source_squibcolor(fill_color)
-      png_cxt.paint
-      png_cxt.translate(-x + margin, -y + margin)
-      png_cxt.set_source(cxt.target)
-      png_cxt.paint
-      png_cxt.target.write_to_png("#{dir}/#{file}")
-    end
-  end
-end
+require 'squib/graphics/cairo_context_wrapper'
+
+module Squib
+  class Deck
+
+    # Draw cards in a fan.
+    # @api private
+    def render_hand(range, sheet, hand)
+      cards       = range.collect { |i| @cards[i] }
+      center_x    = width / 2.0
+      center_y    = hand.radius + height
+      out_size    = 3.0 * center_y
+      angle_delta = (hand.angle_range.last - hand.angle_range.first) / cards.size
+      cxt = Cairo::Context.new(Cairo::RecordingSurface.new(0, 0, out_size, out_size))
+      cxt.translate(out_size / 2.0, out_size / 2.0)
+      cxt.rotate(hand.angle_range.first)
+      cxt.translate(-width, -width)
+      cards.each_with_index do |card, i|
+        cxt.translate(center_x, center_y)
+        cxt.rotate(angle_delta)
+        cxt.translate(-center_x, -center_y)
+        card.use_cairo do |card_cxt|
+          cxt.rounded_rectangle(sheet.trim, sheet.trim,
+                                width - (2 * sheet.trim), height - (2 * sheet.trim),
+                                sheet.trim_radius, sheet.trim_radius)
+          cxt.clip
+          cxt.set_source(card_cxt.target)
+          cxt.paint
+          cxt.reset_clip
+        end
+      end
+      x, y, w, h = cxt.target.ink_extents # I love Ruby assignment ;)
+      png_cxt = Squib::Graphics::CairoContextWrapper.new(Cairo::Context.new(Cairo::ImageSurface.new(w + 2*sheet.margin, h + 2*sheet.margin)))
+      png_cxt.set_source_squibcolor(sheet.fill_color)
+      png_cxt.paint
+      png_cxt.translate(-x + sheet.margin, -y + sheet.margin)
+      png_cxt.set_source(cxt.target)
+      png_cxt.paint
+      png_cxt.target.write_to_png sheet.full_filename
+    end
+  end
+end

data/lib/squib/graphics/image.rb

@@ -1,73 +1,76 @@
-module Squib
-
-  # Cache all pngs we've already loaded
-  #
-  # :nodoc:
-  # @api private
-  def cache_load_image(file)
-    @img_cache ||= {}
-    @img_cache[file] || @img_cache[file] = Cairo::ImageSurface.from_png(file)
-  end
-  module_function :cache_load_image
-
-  class Card
-
-    # :nodoc:
-    # @api private
-    def png(file, x, y, width, height, alpha, blend, angle, mask)
-      Squib.logger.debug {"Rendering: #{file} @#{x},#{y} #{width}x#{height}, alpha: #{alpha}, blend: #{blend}, angle: #{angle}, mask: #{mask}"}
-      return if file.nil? or file.eql? ''
-      png = Squib.cache_load_image(file)
-      use_cairo do |cc|
-        cc.translate(x, y)
-        if width != :native || height != :native
-          width  == :native && width  = png.width.to_f
-          height == :native && height = png.height.to_f
-          Squib.logger.warn "PNG scaling results in antialiasing."
-          cc.scale(width.to_f / png.width.to_f, height.to_f / png.height.to_f)
-        end
-        cc.rotate(angle)
-        cc.translate(-x, -y)
-        cc.set_source(png, x, y)
-        cc.operator = blend unless blend == :none
-        if mask.nil?
-          cc.paint(alpha)
-        else
-          cc.set_source_squibcolor(mask)
-          cc.mask(png, x, y)
-        end
-      end
-    end
-
-    # :nodoc:
-    # @api private
-    def svg(file, data, id, x, y, width, height, alpha, blend, angle, mask)
-      Squib.logger.debug {"Rendering: #{file}, id: #{id} @#{x},#{y} #{width}x#{height}, alpha: #{alpha}, blend: #{blend}, angle: #{angle}, mask: #{mask}"}
-      Squib.logger.warn 'Both an SVG file and SVG data were specified' unless file.to_s.empty? or data.to_s.empty?
-      return if (file.nil? or file.eql? '') and data.nil? # nothing specified
-      data = File.read(file) if data.to_s.empty?
-      svg          = RSVG::Handle.new_from_data(data)
-      width        = svg.width  if width == :native
-      height       = svg.height if height == :native
-      scale_width  = width.to_f / svg.width.to_f
-      scale_height = height.to_f / svg.height.to_f
-      use_cairo do |cc|
-        cc.translate(x, y)
-        cc.rotate(angle)
-        cc.scale(scale_width, scale_height)
-        cc.operator = blend unless blend == :none
-        #FIXME Alpha is no longer used since we are not using cc.paint anymore
-        if mask.nil?
-          cc.render_rsvg_handle(svg, id)
-        else
-          tmp = Cairo::ImageSurface.new(width / scale_width, height / scale_height)
-          tmp_cc = Cairo::Context.new(tmp)
-          tmp_cc.render_rsvg_handle(svg, id)
-          cc.set_source_squibcolor(mask)
-          cc.mask(tmp, 0, 0)
-        end
-      end
-    end
-
-  end
-end
+module Squib
+
+  # Cache all pngs we've already loaded
+  #
+  # :nodoc:
+  # @api private
+  def cache_load_image(file)
+    @img_cache ||= {}
+    @img_cache[file] || @img_cache[file] = Cairo::ImageSurface.from_png(file)
+  end
+  module_function :cache_load_image
+
+  class Card
+
+    # :nodoc:
+    # @api private
+    def png(file, box, paint, trans)
+      Squib.logger.debug {"RENDERING PNG: \n  file: #{file}\n  box: #{box}\n  paint: #{paint}\n  trans: #{trans}"}
+      return if file.nil? or file.eql? ''
+      png = Squib.cache_load_image(file)
+      use_cairo do |cc|
+        cc.translate(box.x, box.y)
+        if box.width != :native || box.height != :native
+          box.width  = png.width.to_f  if box.width  == :native
+          box.height = png.height.to_f if box.height == :native
+          box.width  = png.width.to_f * box.height.to_f / png.height.to_f if box.width == :scale
+          box.height = png.height.to_f * box.width.to_f / png.width.to_f  if box.height == :scale
+          Squib.logger.warn "PNG scaling results in aliasing."
+          cc.scale(box.width.to_f / png.width.to_f, box.height.to_f / png.height.to_f)
+        end
+        cc.rotate(trans.angle)
+        cc.translate(-box.x, -box.y)
+        cc.set_source(png, box.x, box.y)
+        cc.operator = paint.blend unless paint.blend == :none
+        if paint.mask.empty?
+          cc.paint(paint.alpha)
+        else
+          cc.set_source_squibcolor(paint.mask)
+          cc.mask(png, box.x, box.y)
+        end
+      end
+    end
+
+    # :nodoc:
+    # @api private
+    def svg(file, svg_args, box, paint, trans)
+      Squib.logger.debug {"Rendering: #{file}, id: #{id} @#{x},#{y} #{width}x#{height}, alpha: #{alpha}, blend: #{blend}, angle: #{angle}, mask: #{mask}"}
+      Squib.logger.warn 'Both an SVG file and SVG data were specified' unless file.to_s.empty? || svg_args.data.to_s.empty?
+      return if (file.nil? or file.eql? '') and svg_args.data.nil? # nothing specified TODO Move this out to arg validator
+      svg_args.data = File.read(file) if svg_args.data.to_s.empty?
+      svg          = RSVG::Handle.new_from_data(svg_args.data)
+      box.width    = svg.width  if box.width == :native
+      box.height   = svg.height if box.height == :native
+      box.width  = svg.width.to_f * box.height.to_f / svg.height.to_f if box.width == :scale
+      box.height = svg.height.to_f * box.width.to_f / svg.width.to_f  if box.height == :scale
+      scale_width  = box.width.to_f / svg.width.to_f
+      scale_height = box.height.to_f / svg.height.to_f
+      use_cairo do |cc|
+        cc.translate(box.x, box.y)
+        cc.rotate(trans.angle)
+        cc.scale(scale_width, scale_height)
+        cc.operator = paint.blend unless paint.blend == :none
+        if paint.mask.to_s.empty?
+          cc.render_rsvg_handle(svg, svg_args.id)
+        else
+          tmp = Cairo::ImageSurface.new(box.width / scale_width, box.height / scale_height)
+          tmp_cc = Cairo::Context.new(tmp)
+          tmp_cc.render_rsvg_handle(svg, svg_args.id)
+          cc.set_source_squibcolor(paint.mask)
+          cc.mask(tmp, 0, 0)
+        end
+      end
+    end
+
+  end
+end

data/lib/squib/graphics/save_doc.rb

@@ -1,137 +1,103 @@
-module Squib
-  class Deck
-
-    # Lays out the cards in range and renders a PDF
-    #
-    # @example
-    #   save_pdf file: 'deck.pdf', margin: 75, gap: 5, trim: 37
-    #
-    # @option opts file [String] the name of the PDF file to save. See {file:README.md#Specifying_Files Specifying Files}
-    # @option opts dir [String] (_output) the directory to save to. Created if it doesn't exist.
-    # @option opts width [Integer] (3300) the height of the page in pixels. Default is 11in * 300dpi. Supports unit conversion.
-    # @option opts height [Integer] (2550) the height of the page in pixels. Default is 8.5in * 300dpi. Supports unit conversion.
-    # @option opts margin [Integer] (75) the margin around the outside of the page. Supports unit conversion.
-    # @option opts gap [Integer] (0) the space in pixels between the cards. Supports unit conversion.
-    # @option opts trim [Integer] (0) the space around the edge of each card to trim (e.g. to cut off the bleed margin for print-and-play). Supports unit conversion.
-    # @return [nil]
-    # @api public
-    def save_pdf(opts = {})
-      opts   = {width: 3300, height: 2550}.merge(opts)
-      p      = needs(opts, [:range, :paper_width, :paper_height, :file_to_save,
-                          :creatable_dir, :margin, :gap, :trim])
-      paper_width  = p[:width]
-      paper_height = p[:height]
-      file         = "#{p[:dir]}/#{p[:file]}"
-      cc           = Cairo::Context.new(Cairo::PDFSurface.new(file, paper_width * 72.0 / @dpi, paper_height * 72.0 / @dpi))
-      cc.scale(72.0 / @dpi, 72.0 / @dpi) # for bug #62
-      x, y         = p[:margin], p[:margin]
-      card_width   = @width  - 2 * p[:trim]
-      card_height  = @height - 2 * p[:trim]
-      @progress_bar.start("Saving PDF to #{file}", p[:range].size) do |bar|
-        p[:range].each do |i|
-          card = @cards[i]
-          cc.translate(x,y)
-          cc.rectangle(p[:trim], p[:trim], card_width, card_height)
-          cc.clip
-          case card.backend.downcase.to_sym
-          when :memory
-            cc.set_source(card.cairo_surface, 0, 0)
-            cc.paint
-          when :svg
-            card.cairo_surface.finish
-            cc.save
-            cc.scale(0.8,0.8) # I really don't know why I needed to do this at all. But 0.8 is the magic number to get this to scale right
-            cc.render_rsvg_handle(RSVG::Handle.new_from_file(card.svgfile), nil)
-            cc.restore
-          else
-            abort "No such back end supported for save_pdf: #{backend}"
-          end
-          bar.increment
-          cc.reset_clip
-          cc.translate(-x,-y)
-          x += card.width + p[:gap] - 2*p[:trim]
-          if x > (paper_width - card_width - p[:margin])
-            x = p[:margin]
-            y += card.height + p[:gap] - 2*p[:trim]
-            if y > (paper_height - card_height - p[:margin])
-              cc.show_page # next page
-              x,y = p[:margin],p[:margin]
-            end
-          end
-        end
-      end
-    end
-
-    # Lays out the cards in range and renders a stitched PNG sheet
-    #
-    # @example
-    #   save_sheet prefix: 'sheet_', margin: 75, gap: 5, trim: 37
-    #
-    # @option opts [Enumerable] range (:all) the range of cards over which this will be rendered. See {file:README.md#Specifying_Ranges Specifying Ranges}
-    # @option opts colulmns [Integer] (5) the number of columns in the grid
-    # @option opts rows [Integer] (:infinite) the number of rows in the grid. When set to :infinite, the sheet scales to the rows needed. If there are more cards than rows*columns, new sheets are started.
-    # @option opts [String] prefix (card_) the prefix of the file name(s)
-    # @option opts [String] count_format (%02d) the format string used for formatting the card count (e.g. padding zeros). Uses a Ruby format string (see the Ruby doc for Kernel::sprintf for specifics)
-    # @option opts dir [String] (_output) the directory to save to. Created if it doesn't exist.
-    # @option opts margin [Integer] (0) the margin around the outside of the page.
-    # @option opts gap [Integer] (0) the space in pixels between the cards
-    # @option opts trim [Integer] (0) the space around the edge of each card to trim (e.g. to cut off the bleed margin for print-and-play)
-    # @return [nil]
-    # @api public
-    def save_sheet(opts = {})
-      opts = {margin: 0}.merge(opts) # overriding the non-system default
-      p = needs(opts, [:range, :prefix, :count_format, :creatable_dir, :margin, :gap, :trim, :rows, :columns])
-      # EXTRACT METHOD HERE
-      sheet_width = (p[:columns] * (@width + 2 * p[:gap] - 2 * p[:trim])) + (2 * p[:margin])
-      sheet_height = (p[:rows] * (@height + 2 * p[:gap] - 2 * p[:trim])) + (2 * p[:margin])
-      cc = Cairo::Context.new(Cairo::ImageSurface.new(sheet_width, sheet_height))
-      num_this_sheet = 0
-      sheet_num = 0
-      x, y = p[:margin], p[:margin]
-      @progress_bar.start("Saving PNG sheet to #{p[:dir]}/#{p[:prefix]}_*", @cards.size + 1) do |bar|
-        p[:range].each do |i|
-          if num_this_sheet >= (p[:columns] * p[:rows]) # new sheet
-            filename = "#{p[:dir]}/#{p[:prefix]}#{p[:count_format] % sheet_num}.png"
-            cc.target.write_to_png(filename)
-            new_sheet = false
-            num_this_sheet = 0
-            sheet_num += 1
-            x, y = p[:margin], p[:margin]
-            cc = Cairo::Context.new(Cairo::ImageSurface.new(sheet_width, sheet_height))
-          end
-          surface = trim(@cards[i].cairo_surface, p[:trim], @width, @height)
-          cc.set_source(surface, x, y)
-          cc.paint
-          num_this_sheet += 1
-          x += surface.width + p[:gap]
-          if num_this_sheet % p[:columns] == 0 # new row
-            x = p[:margin]
-            y += surface.height + p[:gap]
-          end
-          bar.increment
-        end
-        cc.target.write_to_png("#{p[:dir]}/#{p[:prefix]}#{p[:count_format] % sheet_num}.png")
-      end
-    end
-
-    # Return a new Cairo::ImageSurface that is trimmed from the original
-    #
-    # @param surface The surface to trim
-    # @param trim The number of pixels around the edge to trim
-    # @param width The width of the surface prior to the trim
-    # @param height The height of the surface prior to the trim
-    # :nodoc:
-    # @api private
-    def trim(surface, trim, width, height)
-      if trim > 0
-        tmp = Cairo::ImageSurface.new(width-2*trim, height-2*trim)
-        cc = Cairo::Context.new(tmp)
-        cc.set_source(surface,-1*trim, -1*trim)
-        cc.paint
-        surface = tmp
-      end
-      surface
-    end
-
-  end
-end
+module Squib
+  class Deck
+
+    # :nodoc:
+    # @api private
+    def render_pdf(range, sheet)
+      file         = "#{sheet.dir}/#{sheet.file}"
+      cc           = Cairo::Context.new(Cairo::PDFSurface.new(file, sheet.width * 72.0 / @dpi, sheet.height * 72.0 / @dpi))
+      cc.scale(72.0 / @dpi, 72.0 / @dpi) # for bug #62
+      x, y         = sheet.margin, sheet.margin
+      card_width   = @width  - 2 * sheet.trim
+      card_height  = @height - 2 * sheet.trim
+      @progress_bar.start("Saving PDF to #{file}", range.size) do |bar|
+        range.each do |i|
+          card = @cards[i]
+          cc.translate(x,y)
+          cc.rectangle(sheet.trim, sheet.trim, card_width, card_height)
+          cc.clip
+          case card.backend.downcase.to_sym
+          when :memory
+            cc.set_source(card.cairo_surface, 0, 0)
+            cc.paint
+          when :svg
+            card.cairo_surface.finish
+            cc.save
+            cc.scale(0.8,0.8) # I really don't know why I needed to do this at all. But 0.8 is the magic number to get this to scale right
+            cc.render_rsvg_handle(RSVG::Handle.new_from_file(card.svgfile), nil)
+            cc.restore
+          else
+            abort "No such back end supported for save_pdf: #{backend}"
+          end
+          bar.increment
+          cc.reset_clip
+          cc.translate(-x,-y)
+          x += card.width + sheet.gap - 2*sheet.trim
+          if x > (sheet.width - card_width - sheet.margin)
+            x = sheet.margin
+            y += card.height + sheet.gap - 2*sheet.trim
+            if y > (sheet.height - card_height - sheet.margin)
+              cc.show_page # next page
+              x,y = sheet.margin,sheet.margin
+            end
+          end
+        end
+      end
+    end
+
+    # :nodoc:
+    # @api private
+    def render_sheet(range, batch, sheet)
+      sheet_width = (sheet.columns * (@width + 2 * sheet.gap - 2 * sheet.trim)) + (2 * sheet.margin)
+      sheet_height = (sheet.rows * (@height + 2 * sheet.gap - 2 * sheet.trim)) + (2 * sheet.margin)
+      cc = Cairo::Context.new(Cairo::ImageSurface.new(sheet_width, sheet_height))
+      num_this_sheet = 0
+      sheet_num = 0
+      x, y = sheet.margin, sheet.margin
+      @progress_bar.start("Saving PNG sheet to #{batch.summary}", @cards.size + 1) do |bar|
+        range.each do |i|
+          if num_this_sheet >= (sheet.columns * sheet.rows) # new sheet
+            filename = batch.full_filename(sheet_num)
+            cc.target.write_to_png(filename)
+            new_sheet = false
+            num_this_sheet = 0
+            sheet_num += 1
+            x, y = sheet.margin, sheet.margin
+            cc = Cairo::Context.new(Cairo::ImageSurface.new(sheet_width, sheet_height))
+          end
+          surface = trim(@cards[i].cairo_surface, sheet.trim, @width, @height)
+          cc.set_source(surface, x, y)
+          cc.paint
+          num_this_sheet += 1
+          x += surface.width + sheet.gap
+          if num_this_sheet % sheet.columns == 0 # new row
+            x = sheet.margin
+            y += surface.height + sheet.gap
+          end
+          bar.increment
+        end
+        cc.target.write_to_png(batch.full_filename(sheet_num))
+      end
+    end
+
+    # Return a new Cairo::ImageSurface that is trimmed from the original
+    #
+    # @param surface The surface to trim
+    # @param trim The number of pixels around the edge to trim
+    # @param width The width of the surface prior to the trim
+    # @param height The height of the surface prior to the trim
+    # :nodoc:
+    # @api private
+    def trim(surface, trim, width, height)
+      if trim > 0
+        tmp = Cairo::ImageSurface.new(width-2*trim, height-2*trim)
+        cc = Cairo::Context.new(tmp)
+        cc.set_source(surface,-1*trim, -1*trim)
+        cc.paint
+        surface = tmp
+      end
+      surface
+    end
+
+  end
+end