squib 0.8.0 → 0.9.0

data/lib/squib/graphics/save_doc.rb

@@ -1,103 +1,103 @@
-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
+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

data/lib/squib/graphics/save_images.rb

@@ -1,33 +1,39 @@
-module Squib
-  class Card
-
-    # :nodoc:
-    # @api private
-    def save_png(batch)
-      surface = if batch.rotate
-                  rotated_image(batch.angle)
-                else
-                  surface = @cairo_surface
-                end
-      write_png(surface, index, batch.dir, batch.prefix, batch.count_format)
-    end
-
-    # :nodoc:
-    # @api private
-    def rotated_image(angle)
-      rotated_cc = Cairo::Context.new(Cairo::ImageSurface.new(@height, @width) )
-      rotated_cc.translate(@height * 0.5, @width * 0.5)
-      rotated_cc.rotate(angle)
-      rotated_cc.translate(@width * -0.5, @height * -0.5)
-      rotated_cc.set_source(@cairo_surface)
-      rotated_cc.paint
-      rotated_cc.target
-    end
-    # :nodoc:
-    # @api private
-    def write_png(surface, i, dir, prefix, count_format)
-      surface.write_to_png("#{dir}/#{prefix}#{count_format % i}.png")
-    end
-
-  end
-end
+module Squib
+  class Card
+
+    # :nodoc:
+    # @api private
+    def save_png(batch)
+      surface = if preprocess_save?(batch)
+                  preprocessed_save(batch.angle, batch.trim, batch.trim_radius)
+                else
+                  @cairo_surface
+                end
+      write_png(surface, index, batch.dir, batch.prefix, batch.count_format)
+    end
+
+    # :nodoc:
+    # @api private
+    def preprocess_save?(batch)
+      batch.rotate || batch.trim > 0
+    end
+
+    def preprocessed_save(angle, trim, trim_radius)
+      new_width, new_height = @width - 2*trim, @height - 2*trim
+      new_cc = Cairo::Context.new(Cairo::ImageSurface.new(new_width, new_height))
+      new_cc.translate(new_width * 0.5, new_height * 0.5)
+      new_cc.rotate(angle)
+      new_cc.translate(new_width * -0.5, new_height * -0.5)
+      new_cc.set_source(@cairo_surface, -trim, -trim)
+      new_cc.rounded_rectangle(0, 0, new_width, new_height, trim_radius, trim_radius)
+      new_cc.clip
+      new_cc.paint
+      new_cc.target
+    end
+
+    def write_png(surface, i, dir, prefix, count_format)
+      surface.write_to_png("#{dir}/#{prefix}#{count_format % i}.png")
+    end
+
+  end
+end

data/lib/squib/graphics/shapes.rb

@@ -1,119 +1,135 @@
-module Squib
-  # @api private
-  class Card
-
-    # :nodoc:
-    # @api private
-    def rect(box, draw)
-      use_cairo do |cc|
-        cc.rounded_rectangle(box.x, box.y, box.width, box.height, box.x_radius, box.y_radius)
-        cc.fill_n_stroke(draw)
-      end
-    end
-
-    # :nodoc:
-    # @api private
-    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)
-        cc.fill_n_stroke(draw)
-      end
-    end
-
-    # Ellipse drawing taken from looking at the control points in Inkscape
-    # Think of it like a rectangle. Curves go from mid-points of the sides
-    # of the rectangle. Control points are at 1/4 and 3/4 of the side.
-    # :nodoc:
-    # @api private
-    def ellipse(box, draw)
-      x, y, w, h = box.x, box.y, box.width, box.height
-      use_cairo do |cc|
-        cc.move_to(x, y + 0.5*h)       # start west
-        cc.curve_to(x, y + 0.25*h,     # west to north
-                    x + 0.25*w, y,
-                    x +  0.5*w, y)
-        cc.curve_to(x + 0.75*w, y,     # north to east
-                    x + w, y + 0.25*h,
-                    x + w, y + 0.5*h)
-        cc.curve_to(x + w, y + 0.75*h, # east to south
-                    x + 0.75*w, y + h,
-                    x + 0.5*w, y + h)
-        cc.curve_to(x + 0.25*w, y + h, # south to west
-                    x, y + 0.75*h,
-                    x, y + 0.5*h)
-        cc.fill_n_stroke(draw)
-      end
-    end
-
-    # :nodoc:
-    # @api private
-    def triangle(tri, draw)
-      use_cairo do |cc|
-        cc.triangle(tri.x1, tri.y1, tri.x2, tri.y2, tri.x3, tri.y3)
-        cc.fill_n_stroke(draw)
-      end
-    end
-
-    # :nodoc:
-    # @api private
-    def line(coord, draw)
-      use_cairo do |cc|
-        cc.move_to(coord.x1, coord.y1)
-        cc.line_to(coord.x2, coord.y2)
-        cc.fill_n_stroke(draw)
-      end
-    end
-
-        # :nodoc:
-    # @api private
-    def curve(bez, draw)
-      x1, y1, cx1, cy1 = bez.x1, bez.y1, bez.cx1, bez.cy1
-      cx2, cy2, x2, y2 = bez.cx2, bez.cy2, bez.x2, bez.y2
-      use_cairo do |cc|
-        cc.move_to(x1, y1)
-        cc.curve_to(cx1, cy1, cx2, cy2, x2, y2)
-        cc.fill_n_stroke(draw)
-      end
-    end
-
-    # :nodoc:
-    # @api private
-    def star(poly, trans, draw)
-      x, y, n = poly.x, poly.y, poly.n
-      inner_radius, outer_radius = poly.inner_radius, poly.outer_radius
-      use_cairo do |cc|
-        cc.rotate_about(x, y, trans.angle)
-        cc.move_to(x + outer_radius, y) #i = 0, so cos(0)=1 and sin(0)=0
-        theta = Math::PI / n.to_f # i.e. (2*pi) / (2*n)
-        0.upto(2 * n) do |i|
-            radius = i.even? ? outer_radius : inner_radius
-            cc.line_to(x + radius * Math::cos(i * theta),
-                       y + radius * Math::sin(i * theta))
-        end
-        cc.close_path
-        cc.fill_n_stroke(draw)
-      end
-    end
-
-    # :nodoc:
-    # @api private
-    def polygon(poly, trans, draw)
-      x, y, n, radius = poly.x, poly.y, poly.n, poly.radius
-      use_cairo do |cc|
-        cc.rotate_about(x, y, trans.angle)
-        cc.move_to(x + radius, y) # i = 0, so cos(0)=1 and sin(0)=0
-        theta = (2 * Math::PI) / n.to_f
-        0.upto(n) do |i|
-            cc.line_to(x + radius * Math::cos(i * theta),
-                       y + radius * Math::sin(i * theta))
-        end
-        cc.close_path
-        cc.fill_n_stroke(draw)
-      end
-    end
-
-  end
-end
-
+module Squib
+  # @api private
+  class Card
+
+    # :nodoc:
+    # @api private
+    def rect(box, draw)
+      use_cairo do |cc|
+        cc.rounded_rectangle(box.x, box.y, box.width, box.height, box.x_radius, box.y_radius)
+        cc.fill_n_stroke(draw)
+      end
+    end
+
+    # :nodoc:
+    # @api private
+    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)
+        cc.fill_n_stroke(draw)
+      end
+    end
+
+    # Ellipse drawing taken from looking at the control points in Inkscape
+    # Think of it like a rectangle. Curves go from mid-points of the sides
+    # of the rectangle. Control points are at 1/4 and 3/4 of the side.
+    # :nodoc:
+    # @api private
+    def ellipse(box, draw)
+      x, y, w, h = box.x, box.y, box.width, box.height
+      use_cairo do |cc|
+        cc.move_to(x, y + 0.5*h)       # start west
+        cc.curve_to(x, y + 0.25*h,     # west to north
+                    x + 0.25*w, y,
+                    x +  0.5*w, y)
+        cc.curve_to(x + 0.75*w, y,     # north to east
+                    x + w, y + 0.25*h,
+                    x + w, y + 0.5*h)
+        cc.curve_to(x + w, y + 0.75*h, # east to south
+                    x + 0.75*w, y + h,
+                    x + 0.5*w, y + h)
+        cc.curve_to(x + 0.25*w, y + h, # south to west
+                    x, y + 0.75*h,
+                    x, y + 0.5*h)
+        cc.fill_n_stroke(draw)
+      end
+    end
+
+    # :nodoc:
+    # @api private
+    def grid(box, draw)
+      x, y, w, h = box.x, box.y, box.width, box.height
+      use_cairo do |cc|
+        (x..@width + w).step(w)  { |ix| line_xy( ix, y - @height, ix, @height + y, draw) }
+        (y..@height + h).step(h) { |iy| line_xy( x - @width, iy, @width + x, iy, draw) }
+      end
+    end
+
+    # :nodoc:
+    # @api private
+    def triangle(tri, draw)
+      use_cairo do |cc|
+        cc.triangle(tri.x1, tri.y1, tri.x2, tri.y2, tri.x3, tri.y3)
+        cc.fill_n_stroke(draw)
+      end
+    end
+
+    # :nodoc:
+    # @api private
+    def line(coord, draw)
+      line_xy(coord.x1, coord.y1, coord.x2, coord.y2, draw)
+    end
+
+    # :nodoc:
+    # @api private
+    def line_xy(x1, y1, x2, y2, draw)
+      use_cairo do |cc|
+        cc.move_to(x1, y1)
+        cc.line_to(x2, y2)
+        cc.fancy_stroke(draw)
+      end
+    end
+
+        # :nodoc:
+    # @api private
+    def curve(bez, draw)
+      x1, y1, cx1, cy1 = bez.x1, bez.y1, bez.cx1, bez.cy1
+      cx2, cy2, x2, y2 = bez.cx2, bez.cy2, bez.x2, bez.y2
+      use_cairo do |cc|
+        cc.move_to(x1, y1)
+        cc.curve_to(cx1, cy1, cx2, cy2, x2, y2)
+        cc.fill_n_stroke(draw)
+      end
+    end
+
+    # :nodoc:
+    # @api private
+    def star(poly, trans, draw)
+      x, y, n = poly.x, poly.y, poly.n
+      inner_radius, outer_radius = poly.inner_radius, poly.outer_radius
+      use_cairo do |cc|
+        cc.rotate_about(x, y, trans.angle)
+        cc.move_to(x + outer_radius, y) #i = 0, so cos(0)=1 and sin(0)=0
+        theta = Math::PI / n.to_f # i.e. (2*pi) / (2*n)
+        0.upto(2 * n) do |i|
+            radius = i.even? ? outer_radius : inner_radius
+            cc.line_to(x + radius * Math::cos(i * theta),
+                       y + radius * Math::sin(i * theta))
+        end
+        cc.close_path
+        cc.fill_n_stroke(draw)
+      end
+    end
+
+    # :nodoc:
+    # @api private
+    def polygon(poly, trans, draw)
+      x, y, n, radius = poly.x, poly.y, poly.n, poly.radius
+      use_cairo do |cc|
+        cc.rotate_about(x, y, trans.angle)
+        cc.move_to(x + radius, y) # i = 0, so cos(0)=1 and sin(0)=0
+        theta = (2 * Math::PI) / n.to_f
+        0.upto(n) do |i|
+            cc.line_to(x + radius * Math::cos(i * theta),
+                       y + radius * Math::sin(i * theta))
+        end
+        cc.close_path
+        cc.fill_n_stroke(draw)
+      end
+    end
+
+  end
+end
+