squib 0.6.0 → 0.7.0

data/lib/squib/graphics/save_images.rb

@@ -1,33 +1,33 @@
-module Squib
-  class Card
-
-    # :nodoc:
-    # @api private
-    def save_png(i, dir, prefix, count_format, do_rotate, angle)
-      if [true, :clockwise, :counterclockwise].include?(do_rotate)
-        surface = rotated_image(angle)
-      else
-        surface = @cairo_surface
-      end
-      write_png(surface, i, dir, prefix, 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 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

data/lib/squib/graphics/shapes.rb

@@ -1,152 +1,119 @@
-module Squib
-  # @api private
-  class Card
-
-    # :nodoc:
-    # @api private
-    def rect(x, y, width, height, x_radius, y_radius, fill_color, stroke_color, stroke_width)
-      width  = @width   if width == :native
-      height = @height  if height == :native
-      use_cairo do |cc|
-        cc.rounded_rectangle(x, y, width, height, x_radius, y_radius)
-        cc.set_source_squibcolor(stroke_color)
-        cc.set_line_width(stroke_width)
-        cc.stroke
-        cc.rounded_rectangle(x, y, width, height, x_radius, y_radius)
-        cc.set_source_squibcolor(fill_color)
-        cc.fill
-      end
-    end
-
-    # :nodoc:
-    # @api private
-    def circle(x, y, radius, fill_color, stroke_color, stroke_width)
-      use_cairo do |cc|
-        cc.move_to(x + radius, y)
-        cc.circle(x, y, radius)
-        cc.set_source_squibcolor(stroke_color)
-        cc.set_line_width(stroke_width)
-        cc.stroke
-        cc.circle(x, y, radius)
-        cc.set_source_squibcolor(fill_color)
-        cc.fill
-      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(x, y, w, h, fill_color, stroke_color, stroke_width)
-      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.set_source_squibcolor(stroke_color)
-        cc.set_line_width(stroke_width)
-        cc.stroke_preserve
-        cc.set_source_squibcolor(fill_color)
-        cc.fill
-      end
-    end
-
-    # :nodoc:
-    # @api private
-    def triangle(x1, y1, x2, y2, x3, y3, fill_color, stroke_color, stroke_width)
-      use_cairo do |cc|
-        cc.triangle(x1, y1, x2, y2, x3, y3)
-        cc.set_source_squibcolor(stroke_color)
-        cc.set_line_width(stroke_width)
-        cc.stroke
-        cc.triangle(x1, y1, x2, y2, x3, y3)
-        cc.set_source_squibcolor(fill_color)
-        cc.fill
-      end
-    end
-
-    # :nodoc:
-    # @api private
-    def line(x1, y1, x2, y2, stroke_color, stroke_width)
-      use_cairo do |cc|
-        cc.move_to(x1, y1)
-        cc.line_to(x2, y2)
-        cc.set_source_squibcolor(stroke_color)
-        cc.set_line_width(stroke_width)
-        cc.stroke
-      end
-    end
-
-        # :nodoc:
-    # @api private
-    def curve(x1, y1, cx1, cy1, x2, y2, cx2, cy2, fill_color, stroke_color, stroke_width)
-      use_cairo do |cc|
-        cc.move_to(x1, y1)
-        cc.curve_to(cx1, cy1, cx2, cy2, x2, y2)
-        cc.set_line_width(stroke_width)
-        cc.set_source_squibcolor(stroke_color)
-        cc.stroke
-        cc.move_to(x1, y1)
-        cc.curve_to(cx1, cy1, cx2, cy2, x2, y2)
-        cc.set_source_squibcolor(fill_color)
-        cc.fill
-      end
-    end
-
-    # :nodoc:
-    # @api private
-    def star(x, y, n, angle, inner_radius, outer_radius, fill_color, stroke_color, stroke_width)
-      use_cairo do |cc|
-        cc.translate(x, y)
-        cc.rotate(angle)
-        cc.translate(-x, -y)
-        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.set_source_squibcolor(stroke_color)
-        cc.set_line_width(stroke_width)
-        cc.fill_preserve
-        cc.set_source_squibcolor(fill_color)
-        cc.stroke
-      end
-    end
-
-    # :nodoc:
-    # @api private
-    def polygon(x, y, n, angle, radius, fill_color, stroke_color, stroke_width)
-      use_cairo do |cc|
-        cc.translate(x, y)
-        cc.rotate(angle)
-        cc.translate(-x, -y)
-        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.set_source_squibcolor(stroke_color)
-        cc.set_line_width(stroke_width)
-        cc.fill_preserve
-        cc.set_source_squibcolor(fill_color)
-        cc.stroke
-      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 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
+

data/lib/squib/graphics/showcase.rb

@@ -1,88 +1,85 @@
-require 'squib/graphics/cairo_context_wrapper'
-
-module Squib
-  class Deck
-
-    # So the Cairo people have said over and over again that they won't support the 3x3 matrices that would handle perspective transforms.
-    # Since our perspective transform needs are a bit simpler, we can use a "striping method" that does the job for us.
-    # It's a little bit involved, but it works well enough for limited ranges of our parameters.
-    # These were also helpful:
-    #  http://kapo-cpp.blogspot.com/2008/01/perspective-effect-using-cairo.html
-    #  http://zetcode.com/gui/pygtk/drawingII/
-    # :nodoc:
-    # @api private
-    def render_showcase(range,
-                        trim, trim_radius, scale, offset, fill_color,
-                        reflect_offset, reflect_percent, reflect_strength, margin, face_right,
-                        dir, file_to_save)
-      out_width = range.size * ((@width - 2*trim) * scale * offset) + 2*margin
-      out_height = reflect_offset + (1.0 + reflect_percent) * (@height - 2*trim) + 2*margin
-      out_cc = Cairo::Context.new(Cairo::ImageSurface.new(out_width, out_height))
-      wrapper = Squib::Graphics::CairoContextWrapper.new(out_cc)
-      wrapper.set_source_squibcolor(fill_color)
-      wrapper.paint
-
-      cards = range.collect { |i| @cards[i] }
-      cards.each_with_index do |card, i|
-        trimmed = trim_rounded(card.cairo_surface, trim, trim_radius)
-        reflected = reflect(trimmed, reflect_offset, reflect_percent, reflect_strength)
-        perspectived = perspective(reflected, scale, face_right)
-        out_cc.set_source(perspectived, margin + i * perspectived.width * offset, margin)
-        out_cc.paint
-      end
-      out_cc.target.write_to_png("#{dir}/#{file_to_save}")
-    end
-
-    # :nodoc:
-    # @api private
-    def trim_rounded(src, trim, radius)
-      trim_cc = Cairo::Context.new(Cairo::ImageSurface.new(src.width-2.0*trim, src.height-2.0*trim))
-      trim_cc.rounded_rectangle(0, 0, trim_cc.target.width, trim_cc.target.height, radius, radius)
-      trim_cc.set_source(src, -1 * trim, -1 * trim)
-      trim_cc.clip
-      trim_cc.paint
-      return trim_cc.target
-    end
-
-    # :nodoc:
-    # @api private
-    def reflect(src, roffset, rpercent, rstrength)
-      tmp_cc = Cairo::Context.new(Cairo::ImageSurface.new(src.width, src.height * (1.0 + rpercent) + roffset))
-      tmp_cc.set_source(src, 0, 0)
-      tmp_cc.paint
-      # Flip affine magic from: http://cairographics.org/matrix_transform/
-      matrix = Cairo::Matrix.new(1, 0, 0, -1, 0, 2 * src.height + roffset)
-      tmp_cc.transform(matrix) # flips the coordinate system
-      top_y    = src.height    # top of the reflection
-      bottom_y = src.height * (1.0 - rpercent) + roffset # bottom of the reflection
-      gradient = Cairo::LinearPattern.new(0,top_y, 0,bottom_y)
-      gradient.add_color_stop_rgba(0.0, 0,0,0, rstrength) # start a little reflected
-      gradient.add_color_stop_rgba(1.0, 0,0,0, 0.0)       # fade to nothing
-      tmp_cc.set_source(src, 0, 0)
-      tmp_cc.mask(gradient)
-      return tmp_cc.target
-    end
-
-    # :nodoc:
-    # @api private
-    def perspective(src, scale, face_right)
-      dest_cxt = Cairo::Context.new(Cairo::ImageSurface.new(src.width * scale, src.height))
-      in_thickness = 1 # Take strip 1 pixel-width at a time
-      out_thickness = 3 # Scale it to 3 pixels wider to cover any gaps
-      (0..src.width).step(in_thickness) do |i|
-        percentage = i / src.width.to_f
-        i = src.width - i if face_right
-        factor = scale + (percentage * (1.0 - scale)) #linear interpolation
-        dest_cxt.save
-        dest_cxt.translate 0, src.height / 2.0 * (1.0 - factor)
-        dest_cxt.scale factor * scale, factor
-        dest_cxt.set_source src, 0, 0
-        dest_cxt.rounded_rectangle i, 0, out_thickness, src.height, 0,0
-        dest_cxt.fill
-        dest_cxt.restore
-      end
-      return dest_cxt.target
-    end
-
-  end
-end
+require 'squib/graphics/cairo_context_wrapper'
+
+module Squib
+  class Deck
+
+    # So the Cairo people have said over and over again that they won't support the 3x3 matrices that would handle perspective transforms.
+    # Since our perspective transform needs are a bit simpler, we can use a "striping method" that does the job for us.
+    # It's a little bit involved, but it works well enough for limited ranges of our parameters.
+    # These were also helpful:
+    #  http://kapo-cpp.blogspot.com/2008/01/perspective-effect-using-cairo.html
+    #  http://zetcode.com/gui/pygtk/drawingII/
+    # :nodoc:
+    # @api private
+    def render_showcase(range, sheet, showcase)
+      out_width = range.size * ((@width - 2*sheet.trim) * showcase.scale * showcase.offset) + 2*sheet.margin
+      out_height = showcase.reflect_offset + (1.0 + showcase.reflect_percent) * (@height - 2*sheet.trim) + 2*sheet.margin
+      out_cc = Cairo::Context.new(Cairo::ImageSurface.new(out_width, out_height))
+      wrapper = Squib::Graphics::CairoContextWrapper.new(out_cc)
+      wrapper.set_source_squibcolor(sheet.fill_color)
+      wrapper.paint
+
+      cards = range.collect { |i| @cards[i] }
+      cards.each_with_index do |card, i|
+        trimmed = trim_rounded(card.cairo_surface, sheet.trim, sheet.trim_radius)
+        reflected = reflect(trimmed, showcase.reflect_offset, showcase.reflect_percent, showcase.reflect_strength)
+        perspectived = perspective(reflected, showcase.scale, showcase.face_right?)
+        out_cc.set_source(perspectived, sheet.margin + i * perspectived.width * showcase.offset, sheet.margin)
+        out_cc.paint
+      end
+      out_cc.target.write_to_png("#{sheet.dir}/#{sheet.file}")
+    end
+
+    # :nodoc:
+    # @api private
+    def trim_rounded(src, trim, radius)
+      trim_cc = Cairo::Context.new(Cairo::ImageSurface.new(src.width-2.0*trim, src.height-2.0*trim))
+      trim_cc.rounded_rectangle(0, 0, trim_cc.target.width, trim_cc.target.height, radius, radius)
+      trim_cc.set_source(src, -1 * trim, -1 * trim)
+      trim_cc.clip
+      trim_cc.paint
+      return trim_cc.target
+    end
+
+    # :nodoc:
+    # @api private
+    def reflect(src, roffset, rpercent, rstrength)
+      tmp_cc = Cairo::Context.new(Cairo::ImageSurface.new(src.width, src.height * (1.0 + rpercent) + roffset))
+      tmp_cc.set_source(src, 0, 0)
+      tmp_cc.paint
+      # Flip affine magic from: http://cairographics.org/matrix_transform/
+      matrix = Cairo::Matrix.new(1, 0, 0, -1, 0, 2 * src.height + roffset)
+      tmp_cc.transform(matrix) # flips the coordinate system
+      top_y    = src.height    # top of the reflection
+      bottom_y = src.height * (1.0 - rpercent) + roffset # bottom of the reflection
+      gradient = Cairo::LinearPattern.new(0,top_y, 0,bottom_y)
+      gradient.add_color_stop_rgba(0.0, 0,0,0, rstrength) # start a little reflected
+      gradient.add_color_stop_rgba(1.0, 0,0,0, 0.0)       # fade to nothing
+      tmp_cc.set_source(src, 0, 0)
+      tmp_cc.mask(gradient)
+      return tmp_cc.target
+    end
+
+    # :nodoc:
+    # @api private
+    def perspective(src, scale, face_right)
+      dest_cxt = Cairo::Context.new(Cairo::ImageSurface.new(src.width * scale, src.height))
+      in_thickness = 1 # Take strip 1 pixel-width at a time
+      out_thickness = 3 # Scale it to 3 pixels wider to cover any gaps
+      (0..src.width).step(in_thickness) do |i|
+        percentage = i / src.width.to_f
+        i = src.width - i if face_right
+        factor = scale + (percentage * (1.0 - scale)) #linear interpolation
+        dest_cxt.save
+        dest_cxt.translate 0, src.height / 2.0 * (1.0 - factor)
+        dest_cxt.scale factor * scale, factor
+        dest_cxt.set_source src, 0, 0
+        dest_cxt.rounded_rectangle i, 0, out_thickness, src.height, 0,0
+        dest_cxt.fill
+        dest_cxt.restore
+      end
+      return dest_cxt.target
+    end
+
+  end
+end