cairo 1.14.0-x64-mingw32

data/lib/cairo/constants.rb

@@ -0,0 +1,24 @@
+module Cairo
+  define_constants = Proc.new do |const_module, prefix, target|
+    target ||= self
+    const_module.constants.each do |const_name|
+      target.const_set([prefix, const_name].compact.join("_"),
+                       const_module.const_get(const_name))
+    end
+  end
+
+  %w(operator antialias fill_rule line_cap line_join font_slant
+     font_weight subpixel_order hint_style hint_metrics content
+     format extend filter).each do |name|
+    module_name = name.split(/_/).collect {|component| component.capitalize}.join
+    define_constants.call(const_get(module_name), name.upcase)
+  end
+
+  define_constants.call(PathDataType, "PATH")
+  define_constants.call(PathDataType, nil, Path)
+  define_constants.call(SVGVersion, nil, SVGSurface)
+  define_constants.call(SVGVersion, "SVG")
+  if const_defined?(:TextClusterFlag)
+    define_constants.call(TextClusterFlag, "TEXT_CLUSTER_FLAG")
+  end
+end

data/lib/cairo/context.rb

@@ -0,0 +1,29 @@
+require 'cairo/context/rectangle'
+require 'cairo/context/triangle'
+require 'cairo/context/circle'
+require 'cairo/context/path'
+require 'cairo/context/blur'
+require 'cairo/context/color'
+
+module Cairo
+  class Context
+    include Rectangle
+    include Triangle
+    include Circle
+    include Path
+    include Blur
+    include Color
+
+    def stroke_preserve(&block)
+      stroke(true, &block)
+    end
+
+    def fill_preserve(&block)
+      fill(true, &block)
+    end
+
+    def clip_preserve(&block)
+      clip(true, &block)
+    end
+  end
+end

data/lib/cairo/context/blur.rb

@@ -0,0 +1,45 @@
+module Cairo
+  class Context
+    module Blur
+      def pseudo_blur(radius=3, &block)
+        raise ArgumentError, "should specify block" if block.nil?
+        pattern = push_group(Cairo::CONTENT_COLOR_ALPHA, false, &block)
+
+        save do
+          set_source(pattern)
+          paint(0.5)
+        end
+
+        1.step(radius, 1) do |i|
+          opacity = 0.075 - 0.005 * i
+          next if opacity <= 0
+          5.downto(1) do |ratio|
+            r = i / ratio.to_f
+            r_13 = r / 3.0
+            r_23 = 2 * r_13
+            [
+             [-r, 0],
+             [-r_23, r_23],
+             [-r_23, r_13],
+             [0, r],
+             [r_13, r_23],
+             [r_23, r_23],
+             [r, 0],
+             [r_23, -r_13],
+             [r_23, -r_23],
+             [0, -r],
+             [-r_13, -r_23],
+             [-r_23, -r_23],
+            ].each do |x, y|
+              save do
+                translate(x, y)
+                set_source(pattern)
+                paint(opacity)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cairo/context/circle.rb

@@ -0,0 +1,9 @@
+module Cairo
+  class Context
+    module Circle
+      def circle(center_x, center_y, radius)
+        arc(center_x, center_y, radius, 0, 2 * Math::PI)
+      end
+    end
+  end
+end

data/lib/cairo/context/color.rb

@@ -0,0 +1,11 @@
+require 'cairo/color'
+
+module Cairo
+  class Context
+    module Color
+      def set_source_color(color)
+        set_source_rgba(*Cairo::Color.parse(color).to_rgb.to_a)
+      end
+    end
+  end
+end

data/lib/cairo/context/path.rb

@@ -0,0 +1,117 @@
+module Cairo
+  class Context
+    module Path
+      def transform_path(path, &block)
+        transformed_path = Cairo::Path.new
+        path.each do |type, points|
+          case type
+          when PATH_MOVE_TO
+            transformed_path.move_to(*points.collect(&block).flatten)
+          when PATH_LINE_TO
+            transformed_path.line_to(*points.collect(&block).flatten)
+          when PATH_CURVE_TO
+            transformed_path.curve_to(*points.collect(&block).flatten)
+          when PATH_CLOSE_PATH
+            transformed_path.close
+          end
+        end
+        transformed_path
+      end
+
+      def map_path_onto(path)
+        parameterized_path = parameterize_path(path)
+        transformed_path = transform_path(copy_path) do |x, y|
+          current_point = nil
+          d = x
+          i = -1
+          type = points = nil
+          path.each do |_type, _points|
+            type, points = _type, _points
+            i += 1
+            break if d < parameterized_path[i]
+            d -= parameterized_path[i]
+            case type
+            when PATH_MOVE_TO
+              current_point = points[0]
+            when PATH_LINE_TO
+              current_point = points[0]
+            when PATH_CURVE_TO
+              current_point = points[2]
+            when PATH_CLOSE_PATH
+            end
+          end
+
+          case type
+          when PATH_MOVE_TO
+            [x, y]
+          when PATH_LINE_TO
+            ratio = d / parameterized_path[i]
+            current_x, current_y = current_point
+            lx, ly = points[0]
+            new_x = current_x * (1 - ratio) + lx * ratio
+            new_y = current_y * (1 - ratio) + ly * ratio
+            dx = -(current_x - lx)
+            dy = -(current_y - ly)
+
+            ratio = y / parameterized_path[i]
+            [new_x + -dy * ratio, new_y + dx * ratio]
+          when PATH_CURVE_TO
+            ratio = d / parameterized_path[i]
+            current_x, current_y = current_point
+            cx0, cy0 = points[0]
+            cx1, cy1 = points[1]
+            cx2, cy2 = points[2]
+
+            new_x = current_x * (1 - ratio) * (1 - ratio) * (1 - ratio) +
+                    3 * cx0   * (1 - ratio) * (1 - ratio) * ratio +
+                    3 * cx1   * (1 - ratio) *      ratio  * ratio +
+                        cx2   *      ratio  *      ratio  * ratio
+            new_y = current_y * (1 - ratio) * (1 - ratio) * (1 - ratio) +
+                    3 * cy0   * (1 - ratio) * (1 - ratio) * ratio +
+                    3 * cy1   * (1 - ratio) *      ratio  * ratio +
+                        cy2   *      ratio  *      ratio  * ratio
+
+            dx = -3 * current_x * (1 - ratio) * (1 - ratio) +
+                  3 * cx0       * (1 - 4 * ratio + 3 * ratio * ratio) +
+                  3 * cx1       * (    2 * ratio - 3 * ratio * ratio) +
+                  3 * cx2       *      ratio  * ratio
+            dy = -3 * current_y * (1 - ratio) * (1 - ratio) +
+                  3 * cy0       * (1 - 4 * ratio + 3 * ratio * ratio) +
+                  3 * cy1       * (    2 * ratio - 3 * ratio * ratio) +
+                  3 * cy2       *      ratio  * ratio
+
+            ratio = y / Math.sqrt(dx ** 2 + dy ** 2)
+
+            [new_x + -dy * ratio, new_y + dx * ratio]
+          when PATH_CLOSE_PATH
+            [x, y]
+          end
+        end
+        new_path
+        append_path(transformed_path)
+      end
+
+      private
+      def parameterize_path(path)
+        current_point = nil
+        path.collect do |type, points|
+          result = 0
+          case type
+          when PATH_MOVE_TO
+            current_point = points[0]
+          when PATH_LINE_TO
+            result = current_point.distance(points[0])
+            current_point = points[0]
+          when PATH_CURVE_TO
+            result = current_point.distance(points[0])
+            result += points[0].distance(points[1])
+            result += points[1].distance(points[2])
+            current_point = points[2]
+          when PATH_CLOSE_PATH
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/cairo/context/rectangle.rb

@@ -0,0 +1,33 @@
+module Cairo
+  class Context
+    module Rectangle
+      def rounded_rectangle(x, y, width, height, x_radius, y_radius=nil)
+        x1 = x
+        x2 = x1 + width
+        y1 = y
+        y2 = y1 + height
+
+        y_radius ||= x_radius
+
+        x_radius = [x_radius, width / 2.0].min
+        y_radius = [y_radius, height / 2.0].min
+
+        xr1 = x_radius
+        xr2 = x_radius / 2.0
+        yr1 = y_radius
+        yr2 = y_radius / 2.0
+
+        move_to(x1 + xr1, y1)
+        line_to(x2 - xr1, y1)
+        curve_to(x2 - xr2, y1, x2, y1 + yr2, x2, y1 + yr1)
+        line_to(x2, y2 - yr1)
+        curve_to(x2, y2 - yr2, x2 - xr2, y2, x2 - xr1, y2)
+        line_to(x1 + xr1, y2)
+        curve_to(x1 + xr2, y2, x1, y2 - yr2, x1, y2 - yr1)
+        line_to(x1, y1 + yr1)
+        curve_to(x1, y1 + yr2, x1 + xr2, y1, x1 + xr1, y1)
+        close_path
+      end
+    end
+  end
+end

data/lib/cairo/context/triangle.rb

@@ -0,0 +1,12 @@
+module Cairo
+  class Context
+    module Triangle
+      def triangle(x1, y1, x2, y2, x3, y3)
+        move_to(x1, y1)
+        line_to(x2, y2)
+        line_to(x3, y3)
+        close_path
+      end
+    end
+  end
+end

data/lib/cairo/device.rb

@@ -0,0 +1,13 @@
+module Cairo
+  if const_defined?(:Device)
+    class Device
+      class << self
+        def supported?(type)
+          supported_predicate = "#{type.to_s.downcase}_supported?"
+          return false unless respond_to?(supported_predicate)
+          send(supported_predicate)
+        end
+      end
+    end
+  end
+end

data/lib/cairo/paper.rb

@@ -0,0 +1,183 @@
+module Cairo
+  class Paper
+    class ParseError < ArgumentError
+    end
+
+    class UnknownPaperName < ParseError
+      attr_reader :name
+      def initialize(name)
+        @name = name
+        super("unknown paper name: #{name}")
+      end
+    end
+
+    class UnknownUnit < ParseError
+      attr_reader :unit
+      def initialize(unit)
+        @unit = unit
+        super("unknown unit: #{unit}")
+      end
+    end
+
+    class UnrecognizedPaperDescription < ParseError
+      attr_reader :description
+      def initialize(description)
+        @description = description
+        super("unrecognized paper description: #{description.inspect}")
+      end
+    end
+
+    class << self
+      def parse(paper_description, robust=false)
+        case paper_description
+        when Paper
+          return paper_description.dup
+        when Symbol
+          paper = resolve_constant(paper_description)
+          return paper.dup if paper
+          raise UnknownPaperName.new(paper_description)
+        when String
+          paper = resolve_constant(paper_description)
+          paper ||= parse_size(paper_description)
+          return paper.dup if paper
+        when Array
+          return new(*paper_description)
+        end
+
+        raise UnrecognizedPaperDescription.new(paper_description) if robust
+        nil
+      end
+
+      @@default_unit = nil
+      def default_unit
+        @@default_unit
+      end
+
+      def default_unit=(unit)
+        @@default_unit = unit
+      end
+
+      @@unit_resolvers = {}
+      def register_unit_resolver(from_units, to_units, &resolver)
+        from_units = [from_units] unless from_units.is_a?(Array)
+        to_units = [to_units] unless to_units.is_a?(Array)
+        from_units.each do |from_unit|
+          @@unit_resolvers[from_unit] ||= []
+          to_units.each do |unit|
+            @@unit_resolvers[from_unit] << [unit, resolver]
+          end
+        end
+      end
+
+      def resolve_unit(size, from_unit, to_unit)
+        from_unit ||= default_unit
+        return size if from_unit == to_unit
+        from_units = @@unit_resolvers[from_unit] || []
+        raise UnknownUnit.new(from_unit) if from_units.empty?
+        from_units.each do |unit, resolver|
+          return resolver.call(size) if to_unit == unit
+        end
+        raise UnknownUnit.new(to_unit)
+      end
+
+      private
+      def resolve_constant(name)
+        name = name.to_s.upcase.gsub(/\s+|-/, '_')
+        if /\A[A-Z]/ =~ name and const_defined?(name)
+          const_get(name)
+        else
+          nil
+        end
+      end
+
+      def parse_size(size)
+        size_re = /(\d+(\.\d*)?)/
+        unit_re = /([a-zA-Z]+?)/
+        if /\A#{size_re}#{unit_re}?x#{size_re}#{unit_re}?(?:#(.*))?\z/ !~ size
+          return nil
+        end
+
+        width = $1
+        width_fractional = $2
+        width_unit = $3
+        height = $4
+        height_fractional = $5
+        height_unit = $6
+        name = $7
+        width = width_fractional ? Float(width) : Integer(width)
+        height = height_fractional ?  Float(height) : Integer(height)
+        new(resolve_unit(width, width_unit, "pt"),
+            resolve_unit(height, height_unit, "pt"),
+            nil, name)
+      end
+    end
+
+    self.default_unit = "pt"
+    register_unit_resolver("pt", ["in", "inch"]) {|size| size / 72.0}
+    register_unit_resolver(["in", "inch"], "pt") {|size| size * 72}
+    register_unit_resolver("pt", "mm") {|size| size * 25.4 / 72.0}
+    register_unit_resolver("mm", "pt") {|size| size / 25.4 * 72}
+    register_unit_resolver("pt", "cm") {|size| size * 2.54 / 72.0}
+    register_unit_resolver("cm", "pt") {|size| size / 2.54 * 72}
+    register_unit_resolver("pt", "m") {|size| size * 0.0254 / 72.0}
+    register_unit_resolver("m", "pt") {|size| size / 0.0254 * 72}
+
+    attr_reader :unit
+    attr_writer :width, :height
+    attr_accessor :name
+    def initialize(width, height, unit=nil, name=nil)
+      @width = width
+      @height = height
+      @unit = unit
+      @name = name
+    end
+
+    def unit=(unit)
+      if @unit != unit
+        @width = self.class.resolve_unit(width, @unit, unit)
+        @height = self.class.resolve_unit(height, @unit, unit)
+      end
+      @unit = unit
+    end
+
+    def width(unit=nil)
+      return @width if unit.nil?
+      self.class.resolve_unit(@width, @unit, unit)
+    end
+
+    def height(unit=nil)
+      return @height if unit.nil?
+      self.class.resolve_unit(@height, @unit, unit)
+    end
+
+    def size(unit=nil)
+      [width(unit), height(unit)]
+    end
+
+    def ==(other)
+      other.is_a?(self.class) and @name == other.name and
+        width_in_delta?(other.width(@unit)) and
+        height_in_delta?(other.height(@unit))
+    end
+
+    def to_s
+      string = "#{@width}#{@unit}x#{@height}#{@unit}"
+      string << "\##{@name}" if @name
+      string
+    end
+
+    private
+    def width_in_delta?(value, delta=nil)
+      in_delta?(@width, delta, value)
+    end
+
+    def height_in_delta?(value, delta=nil)
+      in_delta?(@height, delta, value)
+    end
+
+    def in_delta?(value, delta, other)
+      delta ||= 0.001
+      value - delta < other and other < value + delta
+    end
+  end
+end