rgd2-ffij 0.0.3

data/lib/gd2/color.rb

@@ -0,0 +1,240 @@
+#
+# Ruby/GD2 -- Ruby binding for gd 2 graphics library
+#
+# Copyright © 2005 Robert Leslie, 2010 J Smith
+#
+# This file is part of Ruby/GD2.
+#
+# Ruby/GD2 is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free
+# Software Foundation; either version 2 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+module GD2
+  #
+  # = Description
+  #
+  # Color objects hold the red, green, blue, and alpha components for a pixel
+  # color. Color objects may also be linked to a particular palette index
+  # associated with an image.
+  #
+  # == Creating
+  #
+  # Color objects are created by specifying the individual components:
+  #
+  #   red   = Color[1.0, 0.0, 0.0]
+  #   green = Color[0.0, 1.0, 0.0]
+  #   blue  = Color[0.0, 0.0, 1.0]
+  #
+  #   transparent_yellow = Color[1.0, 1.0, 0.0, 0.5]
+  #
+  # The components may be specified as a percentage, as an explicit value
+  # between 0..RGB_MAX or 0..ALPHA_MAX, or as another color from which the
+  # associated component will be extracted.
+  #
+  class Color
+    attr_reader :rgba   #:nodoc:
+
+    # The palette index of this color, if associated with an image palette
+    attr_reader :index
+
+    # The palette of this color, if associated with an image palette
+    attr_reader :palette
+
+    alias to_i rgba
+
+    def self.normalize(value, max, component = nil)   #:nodoc:
+      case value
+      when Integer
+        (value < 0) ? 0 : (value > max) ? max : value
+      when Float
+        normalize((value * max).round, max, component)
+      when Color
+        value.send(component)
+      else
+        return normalize(value.to_i, max) if value.respond_to?(:to_i)
+        raise TypeError
+      end
+    end
+
+    def self.pack(r, g, b, a)   #:nodoc:
+      r = r.read_int if r.is_a?(FFI::Pointer)
+      g = g.read_int if g.is_a?(FFI::Pointer)
+      b = b.read_int if b.is_a?(FFI::Pointer)
+      a = a.read_int if a.is_a?(FFI::Pointer)
+      (a << 24) + (r << 16) + (g << 8) + b
+    end
+
+    class << self
+      alias [] new
+    end
+
+    # Create a new Color object with the given component values.
+    def initialize(r, g, b, a = ALPHA_OPAQUE)
+      r = self.class.normalize(r, RGB_MAX, :red)
+      g = self.class.normalize(g, RGB_MAX, :green)
+      b = self.class.normalize(b, RGB_MAX, :blue)
+      a = self.class.normalize(a, ALPHA_MAX, :alpha)
+
+      init_with_rgba(self.class.pack(r, g, b, a))
+    end
+
+    def self.new_from_rgba(rgba)  #:nodoc:
+      allocate.init_with_rgba(rgba)
+    end
+
+    def self.new_from_palette(r, g, b, a, index, palette)   #:nodoc:
+      allocate.init_with_rgba(pack(r, g, b, a), index, palette)
+    end
+
+    def init_with_rgba(rgba, index = nil, palette = nil)  #:nodoc:
+      @rgba = rgba
+      @index = index
+      @palette = palette
+      self
+    end
+
+    BLACK       = Color[0.0, 0.0, 0.0].freeze
+    WHITE       = Color[1.0, 1.0, 1.0].freeze
+    TRANSPARENT = Color[0.0, 0.0, 0.0, ALPHA_TRANSPARENT].freeze
+
+    # Return *true* if this color is associated with the specified palette,
+    # or with any palette if *nil* is given.
+    def from_palette?(palette = nil)
+      @palette && @index && (palette.nil? || palette.equal?(@palette))
+    end
+
+    # Return a string description of this color.
+    def to_s
+      s  = 'RGB'
+      s += "A" if alpha != ALPHA_OPAQUE
+      s += "[#{@index}]" if @index
+      s += '#' + [red, green, blue].map { |e| '%02X' % e }.join('')
+      s += '%02X' % alpha if alpha != ALPHA_OPAQUE
+      s
+    end
+
+    def inspect   #:nodoc:
+      "<#{to_s}>"
+    end
+
+    # Compare this color with another color. Returns *true* if the associated
+    # red, green, blue, and alpha components are identical.
+    def ==(other)
+      other.kind_of?(Color) && rgba == other.rgba
+    end
+
+    # Return *true* if this color is visually identical to another color.
+    def ===(other)
+      self == other || (self.transparent? && other.transparent?)
+    end
+
+    # Compare this color with another color in a manner that takes into account
+    # palette identities.
+    def eql?(other)
+      self == other &&
+        (palette.nil? || other.palette.nil? ||
+          (palette == other.palette && index == other.index))
+    end
+
+    def hash  #:nodoc:
+      rgba.hash
+    end
+
+    def rgba=(value)  #:nodoc:
+      @rgba = value
+      @palette[@index] = self if from_palette?
+    end
+
+    # Return the red component of this color (0..RGB_MAX).
+    def red
+      (rgba & 0xFF0000) >> 16
+    end
+    alias r red
+
+    # Modify the red component of this color. If this color is associated
+    # with a palette entry, this also modifies the palette.
+    def red=(value)
+      self.rgba = (rgba & ~0xFF0000) |
+        (self.class.normalize(value, RGB_MAX, :red) << 16)
+    end
+    alias r= red=
+
+    # Return the green component of this color (0..RGB_MAX).
+    def green
+      (rgba & 0x00FF00) >> 8
+    end
+    alias g green
+
+    # Modify the green component of this color. If this color is associated
+    # with a palette entry, this also modifies the palette.
+    def green=(value)
+      self.rgba = (rgba & ~0x00FF00) |
+        (self.class.normalize(value, RGB_MAX, :green) << 8)
+    end
+    alias g= green=
+
+    # Return the blue component of this color (0..RGB_MAX).
+    def blue
+      rgba & 0x0000FF
+    end
+    alias b blue
+
+    # Modify the blue component of this color. If this color is associated
+    # with a palette entry, this also modifies the palette.
+    def blue=(value)
+      self.rgba = (rgba & ~0x0000FF) |
+        self.class.normalize(value, RGB_MAX, :blue)
+    end
+    alias b= blue=
+
+    # Return the alpha component of this color (0..ALPHA_MAX).
+    def alpha
+      (rgba & 0x7F000000) >> 24
+    end
+    alias a alpha
+
+    # Modify the alpha component of this color. If this color is associated
+    # with a palette entry, this also modifies the palette.
+    def alpha=(value)
+      self.rgba = (rgba & ~0xFF000000) |
+        (self.class.normalize(value, ALPHA_MAX, :alpha) << 24)
+    end
+    alias a= alpha=
+
+    # Alpha blend this color with the given color. If this color is associated
+    # with a palette entry, this also modifies the palette.
+    def alpha_blend!(other)
+      self.rgba = GD2FFI.send(:gdAlphaBlend, rgba.to_i, other.rgba.to_i)
+      self
+    end
+    alias << alpha_blend!
+
+    # Like Color#alpha_blend! except returns a new Color without modifying
+    # the receiver.
+    def alpha_blend(other)
+      dup.alpha_blend!(other)
+    end
+
+    # Return *true* if the alpha channel of this color is completely
+    # transparent.
+    def transparent?
+      alpha == ALPHA_TRANSPARENT
+    end
+
+    # Return *true* if the alpha channel of this color is completely opaque.
+    def opaque?
+      alpha == ALPHA_OPAQUE
+    end
+  end
+end

data/lib/gd2/ffi_struct.rb

@@ -0,0 +1,76 @@
+#
+# Ruby/GD2 -- Ruby binding for gd 2 graphics library
+#
+# Copyright � 2010 J Smith
+#
+# This file is part of Ruby/GD2.
+#
+# Ruby/GD2 is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free
+# Software Foundation; either version 2 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+module GD2::FFIStruct
+  class FTStringExtraPtr < FFI::Struct
+    layout(
+      :flags,       :int,
+      :linespacing, :double,
+      :charmap,     :int,
+      :hdpi,        :int,
+      :vdpi,        :int,
+      :xshow,       :pointer, # char*
+      :fontpath,    :pointer  # char*
+    )
+  end
+
+  class ImagePtr < FFI::ManagedStruct
+    layout(
+      :pixels,            :pointer, # unsigned char**
+      :sx,                :int,
+      :sy,                :int,
+      :colorsTotal,       :int,
+      :red,               [ :int, 256 ],
+      :green,             [ :int, 256 ],
+      :blue,              [ :int, 256 ],
+      :open,              [ :int, 256 ],
+      :transparent,       :int,
+      :polyInts,          :pointer, # int*
+      :polyAllocated,     :int,
+      :brush,             :pointer, # gdImageStruct*
+      :tile,              :pointer, # gdImageStruct*
+      :brushColorMap,     [ :int, 256 ],
+      :tileColorMap,      [ :int, 256 ],
+      :styleLength,       :int,
+      :stylePos,          :int,
+      :style,             :pointer, # int*,
+      :interlace,         :int,
+      :thick,             :int,
+      :alpha,             [ :int, 256 ],
+      :trueColor,         :int,
+      :tpixels,           :pointer, # int**
+      :alphaBlendingFlag, :int,
+      :saveAlphaFlag,     :int,
+      :aa,                :int,
+      :aa_color,          :int,
+      :aa_dont_blend,     :int,
+      :cx1,               :int,
+      :cy1,               :int,
+      :cx2,               :int,
+      :cy2,               :int
+    )
+
+    def self.release(ptr)
+      GD2FFI.gdImageDestroy(ptr)
+    end
+  end
+end

data/lib/gd2/font.rb

@@ -0,0 +1,343 @@
+#
+# Ruby/GD2 -- Ruby binding for gd 2 graphics library
+#
+# Copyright © 2005 Robert Leslie, 2010 J Smith
+#
+# This file is part of Ruby/GD2.
+#
+# Ruby/GD2 is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free
+# Software Foundation; either version 2 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+module GD2
+  #
+  # = Description
+  #
+  # Font objects represent a particular font in a particular size.
+  #
+  # == Built-in Fonts
+  #
+  # The following font classes may be used without further instantiation:
+  #
+  #   Font::Tiny
+  #   Font::Small
+  #   Font::MediumBold
+  #   Font::Large
+  #   Font::Giant
+  #
+  # == TrueType Fonts
+  #
+  # To use a TrueType font, first instantiate the font at a particular size:
+  #
+  #   font = Font::TrueType[fontname, ptsize]
+  #
+  # Here +fontname+ may be a path to a TrueType font, or a fontconfig pattern
+  # if fontconfig support is enabled (see Font::TrueType.fontconfig).
+  #
+  # See Font::TrueType.new for further options.
+  class Font
+    private_class_method :new
+
+    def self.font_ptr   #:nodoc:
+      GD2FFI.send(font_sym)
+    end
+
+    def self.draw(image_ptr, x, y, angle, string, fg)   #:nodoc:
+      raise ArgumentError, "Angle #{angle} not supported for #{self}" unless
+        angle == 0.degrees || angle == 90.degrees
+
+      GD2FFI.send(angle > 0 ? :gdImageStringUp : :gdImageString, image_ptr,
+        font_ptr, x.to_i, y.to_i, string, fg.to_i)
+      nil
+    end
+  end
+
+  class Font::Small < Font
+    def self.font_sym   #:nodoc:
+      :gdFontGetSmall
+    end
+  end
+
+  class Font::Large < Font
+    def self.font_sym   #:nodoc:
+      :gdFontGetLarge
+    end
+  end
+
+  class Font::MediumBold < Font
+    def self.font_sym   #:nodoc:
+      :gdFontGetMediumBold
+    end
+  end
+
+  class Font::Giant < Font
+    def self.font_sym   #:nodoc:
+      :gdFontGetGiant
+    end
+  end
+
+  class Font::Tiny < Font
+    def self.font_sym   #:nodoc:
+      :gdFontGetTiny
+    end
+  end
+
+  class Font::TrueType
+    class FontconfigError < StandardError; end
+    class FreeTypeError < StandardError; end
+
+    CHARMAP_UNICODE           =   0
+    CHARMAP_SHIFT_JIS         =   1
+    CHARMAP_BIG5              =   2
+
+    FTEX_LINESPACE            =   1
+    FTEX_CHARMAP              =   2
+    FTEX_RESOLUTION           =   4
+    FTEX_DISABLE_KERNING      =   8
+    FTEX_XSHOW                =  16
+    FTEX_FONTPATHNAME         =  32
+    FTEX_FONTCONFIG           =  64
+    FTEX_RETURNFONTPATHNAME   = 128
+
+    @@fontcount = 0
+    @@fontconfig = false
+
+    def self.register(font)   #:nodoc:
+      Thread.exclusive do
+        count = @@fontcount
+        @@fontcount += 1
+
+        if count.zero?
+          raise FreeTypeError, 'FreeType library failed to initialize' unless
+            GD2FFI.send(:gdFontCacheSetup).zero?
+        end
+
+        ObjectSpace.define_finalizer(font, font_finalizer)
+      end
+    end
+
+    def self.font_finalizer
+      proc { unregister }
+    end
+
+    def self.unregister
+      Thread.exclusive do
+        @@fontcount -= 1
+        GD2FFI.send(:gdFontCacheShutdown) if @@fontcount.zero?
+      end
+    end
+
+    private_class_method :font_finalizer, :unregister
+
+    def self.fontconfig   #:nodoc:
+      @@fontconfig
+    end
+
+    # Return a boolean indicating whether fontconfig support has been enabled.
+    # The default is *false*.
+    def self.fontconfig?
+      fontconfig
+    end
+
+    # Set whether fontconfig support should be enabled. To use this, the GD
+    # library must have been built with fontconfig support. Raises an error if
+    # fontconfig support is unavailable.
+    def self.fontconfig=(want)
+      avail = !GD2FFI.send(:gdFTUseFontConfig, want ? 1 : 0).zero?
+      raise FontconfigError, 'Fontconfig not available' if want && !avail
+      @@fontconfig = want
+    end
+
+    class << self
+      alias [] new
+    end
+
+    # The effective path to this TrueType font
+    attr_reader :fontpath
+
+    # The chosen linespacing
+    attr_reader :linespacing
+
+    # The chosen charmap
+    attr_reader :charmap
+
+    # The chosen horizontal resolution hint
+    attr_reader :hdpi
+
+    # The chosen vertical resolution hint
+    attr_reader :vdpi
+
+    # Whether kerning is desired
+    attr_reader :kerning
+
+    # Instantiate a TrueType font given by +fontname+ (either a pathname or a
+    # fontconfig pattern if fontconfig is enabled) and +ptsize+ (a point size
+    # given as a floating point number).
+    #
+    # The possible +options+ are:
+    #
+    # - :linespacing => The desired line spacing for multiline text, expressed as
+    #   a multiple of the font height. A line spacing of 1.0 is the minimum to
+    #   guarantee that lines of text do not collide. The default according to GD
+    #   is 1.05.
+    #
+    # - :charmap => Specify a preference for Unicode, Shift_JIS, or Big5
+    #   character encoding. Use one of the constants
+    #   Font::TrueType::CHARMAP_UNICODE, Font::TrueType::CHARMAP_SHIFT_JIS, or
+    #   Font::TrueType::CHARMAP_BIG5.
+    #
+    # - :hdpi => The horizontal resolution hint for the rendering engine. The
+    #   default according to GD is 96 dpi.
+    #
+    # - :vdpi => The vertical resolution hint for the rendering engine. The
+    #   default according to GD is 96 dpi.
+    #
+    # - :dpi => A shortcut to specify both :hdpi and :vdpi.
+    #
+    # - :kerning => A boolean to specify whether kerning tables should be used,
+    #   if fontconfig is available. The default is *true*.
+    #
+    def initialize(fontname, ptsize, options = {})
+      @fontname, @ptsize = fontname, ptsize.to_f
+      @linespacing = options.delete(:linespacing)
+      @linespacing = @linespacing.to_f if @linespacing
+      @charmap = options.delete(:charmap)
+      @hdpi = options.delete(:hdpi)
+      @vdpi = options.delete(:vdpi)
+      if dpi = options.delete(:dpi)
+        @hdpi ||= dpi
+        @vdpi ||= dpi
+      end
+      @kerning = options.delete(:kerning)
+      @kerning = true if @kerning.nil?
+
+      self.class.register(self)
+
+      # Get the font path (and verify existence of file)
+
+      strex = strex(false, true)
+      args = [ nil, nil, 0, @fontname, @ptsize, 0.0, 0, 0, '', strex ]
+      r = GD2FFI.send(:gdImageStringFTEx, *args)
+
+      raise FreeTypeError.new(r.read_string) unless r.null?
+      @fontpath = strex[:fontpath].read_string
+    ensure
+      GD2FFI.send(:gdFree, strex[:fontpath])
+    end
+
+    def inspect   #:nodoc:
+      result  = "#<#{self.class} #{@fontpath.inspect}, #{@ptsize}"
+      result += ", :linespacing => #{@linespacing}" if @linespacing
+      result += ", :charmap => #{@charmap}" if @charmap
+      result += ", :hdpi => #{@hdpi}" if @hdpi
+      result += ", :vdpi => #{@vdpi}" if @vdpi
+      result += ", :kerning => #{@kerning}" unless @kerning
+      result += '>'
+    end
+
+    def draw(image_ptr, x, y, angle, string, fg)  #:nodoc:
+      brect = FFI::MemoryPointer.new(:int, 8)
+      strex = strex(true)
+      args = [ image_ptr, brect, fg, @fontname, @ptsize, angle.to_f, x.to_i, y.to_i, string.gsub('&', '&amp;'), strex ]
+
+      r = GD2FFI.send(:gdImageStringFTEx, *args)
+      raise FreeTypeError.new(r.read_string) unless r.null?
+      brect = brect.read_array_of_int(8)
+
+      if !strex[:xshow].null? && (xshow = strex[:xshow])
+        begin
+          xshow = xshow.read_string.split(' ').map { |e| e.to_f }
+        ensure
+          GD2FFI.send(:gdFree, strex[:xshow])
+        end
+      else
+        xshow = []
+      end
+
+      sum = 0.0
+      position = Array.new(xshow.length + 1)
+      xshow.each_with_index do |advance, i|
+        position[i] = sum
+        sum += advance
+      end
+      position[-1] = sum
+
+      { :lower_left   => [brect[0], brect[1]],
+        :lower_right  => [brect[2], brect[3]],
+        :upper_right  => [brect[4], brect[5]],
+        :upper_left   => [brect[6], brect[7]],
+        :position     => position
+      }
+    end
+
+    def draw_circle(
+      image_ptr, cx, cy, radius, text_radius, fill_portion,
+      top, bottom, fgcolor
+    ) #:nodoc:
+      r = GD2FFI.send(
+        :gdImageStringFTCircle, image_ptr, cx.to_i, cy.to_i,
+        radius.to_f, text_radius.to_f, fill_portion.to_f, @fontname, @ptsize,
+        top || '', bottom || '', fgcolor.to_i
+      )
+      raise FreeTypeError.new(r.read_string) unless r.null?
+      nil
+    end
+
+    # Return a hash describing the rectangle that would enclose the given
+    # string rendered in this font at the given angle. The returned hash
+    # contains the following keys:
+    #
+    # - :lower_left => The [x, y] coordinates of the lower left corner.
+    # - :lower_right => The [x, y] coordinates of the lower right corner.
+    # - :upper_right => The [x, y] coordinates of the upper right corner.
+    # - :upper_left => The [x, y] coordinates of the upper left corner.
+    # - :position => An array of floating point character position offsets for
+    #   each character of the +string+, beginning with 0.0. The array also
+    #   includes a final position indicating where the last character ends.
+    #
+    # The _upper_, _lower_, _left_, and _right_ references are relative to the
+    # text of the +string+, regardless of the +angle+.
+    def bounding_rectangle(string, angle = 0.0)
+      data = draw(nil, 0, 0, angle, string, 0)
+
+      if string.length == 1
+        # gd annoyingly fails to provide xshow data for strings of length 1
+        position = draw(nil, 0, 0, angle, string + ' ', 0)[:position]
+        data[:position] = position[0...-1]
+      end
+
+      data
+    end
+
+    private
+
+    def strex(xshow = false, returnfontpathname = false)
+      flags = 0
+      flags |= FTEX_LINESPACE           if @linespacing
+      flags |= FTEX_CHARMAP             if @charmap
+      flags |= FTEX_RESOLUTION          if @hdpi || @vdpi
+      flags |= FTEX_DISABLE_KERNING     unless @kerning
+      flags |= FTEX_XSHOW               if xshow
+      flags |= FTEX_RETURNFONTPATHNAME  if returnfontpathname
+
+      strex = FFIStruct::FTStringExtraPtr.new
+      strex[:flags] = flags
+      strex[:linespacing] = @linespacing || 0.0
+      strex[:charmap] = @charmap ? @charmap : 0
+      strex[:hdpi] = @hdpi || @vdpi || 0
+      strex[:vdpi] = @vdpi || @hdpi || 0
+      strex
+    end
+  end
+end