ruby-vips 2.0.15 → 2.1.2

data/lib/vips/blend_mode.rb

@@ -1,31 +1,35 @@
 module Vips
   # Blend mode to use when compositing images. See {Image#composite}.
   #
-  # `:clear` - where the second object is drawn, the first is removed
-  # `:source` - the second object is drawn as if nothing were below
-  # `:over` - the image shows what you would expect if you held two semi-transparent slides on top of each other
-  # `:in` - the first object is removed completely, the second is only drawn where the first was
-  # `:out` - the second is drawn only where the first isn't
-  # `:atop` - this leaves the first object mostly intact, but mixes both objects in the overlapping area
-  # `:dest` - leaves the first object untouched, the second is discarded completely
-  # `:dest_over` - like `:over`, but swaps the arguments
-  # `:dest_in` - like `:in`, but swaps the arguments
-  # `:dest_out` - like `:out`, but swaps the arguments
-  # `:dest_atop` - like `:atop`, but swaps the arguments
-  # `:xor` - something like a difference operator
-  # `:add` - a bit like adding the two images
-  # `:saturate` - a bit like the darker of the two
-  # `:multiply` - at least as dark as the darker of the two inputs
-  # `:screen` - at least as light as the lighter of the inputs
-  # `:overlay` - multiplies or screens colors, depending on the lightness
-  # `:darken` - the darker of each component
-  # `:lighten` - the lighter of each component
-  # `:colour_dodge` - brighten first by a factor second
-  # `:colour_burn` - darken first by a factor of second
-  # `:hard_light` - multiply or screen, depending on lightness
-  # `:soft_light` - darken or lighten, depending on lightness
-  # `:difference` - difference of the two
-  # `:exclusion` - somewhat like `:difference`, but lower-contrast
+  # * `:clear` where the second object is drawn, the first is removed
+  # * `:source` the second object is drawn as if nothing were below
+  # * `:over` the image shows what you would expect if you held two
+  #    semi-transparent slides on top of each other
+  # * `:in` the first object is removed completely, the second is only
+  #    drawn where the first was
+  # * `:out` the second is drawn only where the first isn't
+  # * `:atop` this leaves the first object mostly intact, but mixes both
+  #    objects in the overlapping area
+  # * `:dest` leaves the first object untouched, the second is discarded
+  #    completely
+  # * `:dest_over` like `:over`, but swaps the arguments
+  # * `:dest_in` like `:in`, but swaps the arguments
+  # * `:dest_out` like `:out`, but swaps the arguments
+  # * `:dest_atop` like `:atop`, but swaps the arguments
+  # * `:xor` something like a difference operator
+  # * `:add` a bit like adding the two images
+  # * `:saturate` a bit like the darker of the two
+  # * `:multiply` at least as dark as the darker of the two inputs
+  # * `:screen` at least as light as the lighter of the inputs
+  # * `:overlay` multiplies or screens colors, depending on the lightness
+  # * `:darken` the darker of each component
+  # * `:lighten` the lighter of each component
+  # * `:colour_dodge` brighten first by a factor second
+  # * `:colour_burn` darken first by a factor of second
+  # * `:hard_light` multiply or screen, depending on lightness
+  # * `:soft_light` darken or lighten, depending on lightness
+  # * `:difference` difference of the two
+  # * `:exclusion` somewhat like `:difference`, but lower-contrast
 
   class BlendMode < Symbol
   end

data/lib/vips/connection.rb

@@ -0,0 +1,46 @@
+# This module provides an interface to the top level bits of libvips
+# via ruby-ffi.
+#
+# Author::    John Cupitt  (mailto:jcupitt@gmail.com)
+# License::   MIT
+
+require "ffi"
+
+module Vips
+  if Vips.at_least_libvips?(8, 9)
+    attach_function :vips_connection_filename, [:pointer], :string
+    attach_function :vips_connection_nick, [:pointer], :string
+  end
+
+  # Abstract base class for connections.
+  class Connection < Vips::Object
+    # The layout of the VipsRegion struct.
+    module ConnectionLayout
+      def self.included(base)
+        base.class_eval do
+          layout :parent, Vips::Object::Struct
+          # rest opaque
+        end
+      end
+    end
+
+    class Struct < Vips::Object::Struct
+      include ConnectionLayout
+    end
+
+    class ManagedStruct < Vips::Object::ManagedStruct
+      include ConnectionLayout
+    end
+
+    # Get any filename associated with a connection, or nil.
+    def filename
+      Vips.vips_connection_filename self
+    end
+
+    # Get a nickname (short description) of a connection that could be shown to
+    # the user.
+    def nick
+      Vips.vips_connection_nick self
+    end
+  end
+end

data/lib/vips/gobject.rb

@@ -4,8 +4,8 @@
 # Author::    John Cupitt  (mailto:jcupitt@gmail.com)
 # License::   MIT
 
-require 'ffi'
-require 'forwardable'
+require "ffi"
+require "forwardable"
 
 module GObject
   # we have a number of things we need to inherit in different ways:
@@ -37,13 +37,15 @@ module GObject
     def_instance_delegators :@struct, :[], :to_ptr
     def_single_delegators :ffi_struct, :ptr
 
+    attr_reader :references
+
     # the layout of the GObject struct
     module GObjectLayout
       def self.included base
         base.class_eval do
           layout :g_type_instance, :pointer,
-                 :ref_count, :uint,
-                 :qdata, :pointer
+            :ref_count, :uint,
+            :qdata, :pointer
         end
       end
     end
@@ -56,7 +58,7 @@ module GObject
         # GLib::logger.debug("GObject::GObject::ManagedStruct.release") {
         #     "unreffing #{ptr}"
         # }
-        ::GObject::g_object_unref ptr
+        ::GObject.g_object_unref ptr
       end
     end
 
@@ -72,7 +74,11 @@ module GObject
     # need the unref
     def initialize ptr
       # GLib::logger.debug("GObject::GObject.initialize") {"ptr = #{ptr}"}
+      @ptr = ptr
       @struct = ffi_managed_struct.new ptr
+
+      # sometimes we need to keep refs across C calls ... hide them here
+      @references = []
     end
 
     # access to the casting struct for this class
@@ -80,9 +86,13 @@ module GObject
       self.class.ffi_struct
     end
 
+    # get the pointer we were built from ... #to_ptr gets the pointer after we
+    # have wrapped it up with an auto unref
+    attr_reader :ptr
+
     class << self
       def ffi_struct
-        self.const_get :Struct
+        const_get :Struct
       end
     end
 
@@ -93,7 +103,7 @@ module GObject
 
     class << self
       def ffi_managed_struct
-        self.const_get :ManagedStruct
+        const_get :ManagedStruct
       end
     end
   end
@@ -101,18 +111,23 @@ module GObject
   class GParamSpec < FFI::Struct
     # the first few public fields
     layout :g_type_instance, :pointer,
-           :name, :string,
-           :flags, :uint,
-           :value_type, :GType,
-           :owner_type, :GType
+      :name, :string,
+      :flags, :uint,
+      :value_type, :GType,
+      :owner_type, :GType
   end
 
   class GParamSpecPtr < FFI::Struct
     layout :value, GParamSpec.ptr
   end
 
-  attach_function :g_param_spec_get_blurb, [GParamSpec.ptr], :string
+  attach_function :g_param_spec_get_blurb, [:pointer], :string
 
   attach_function :g_object_ref, [:pointer], :void
   attach_function :g_object_unref, [:pointer], :void
+
+  # we just use one gcallback type for every signal, hopefully this is OK
+  callback :gcallback, [:pointer], :void
+  attach_function :g_signal_connect_data,
+    [:pointer, :string, :gcallback, :pointer, :pointer, :int], :long
 end

data/lib/vips/gvalue.rb

@@ -3,7 +3,7 @@
 # Author::    John Cupitt  (mailto:jcupitt@gmail.com)
 # License::   MIT
 
-require 'ffi'
+require "ffi"
 
 module GObject
   # Represent a GValue. Example use:
@@ -13,6 +13,8 @@ module GObject
   # gvalue.init GObject::GDOUBLE_TYPE
   # gvalue.set 3.1415
   # value = gvalue.get
+  # # optional -- drop any ref the gvalue had
+  # gvalue.unset
   # ```
   #
   # Lifetime is managed automatically. It doesn't know about all GType values,
@@ -20,14 +22,16 @@ module GObject
 
   class GValue < FFI::ManagedStruct
     layout :gtype, :GType,
-           :data, [:ulong_long, 2]
+      :data, [:ulong_long, 2]
 
     # convert an enum value (str/symb/int) into an int ready for libvips
     def self.from_nick(gtype, value)
       value = value.to_s if value.is_a? Symbol
 
       if value.is_a? String
-        value = Vips::vips_enum_from_nick "ruby-vips", gtype, value
+        # libvips expects "-" as a separator in enum names, but "_" is more
+        # convenient for ruby, eg. :b_w
+        value = Vips.vips_enum_from_nick "ruby-vips", gtype, value.tr("_", "-")
         if value == -1
           raise Vips::Error
         end
@@ -38,8 +42,8 @@ module GObject
 
     # convert an int enum back into a symbol
     def self.to_nick(gtype, enum_value)
-      enum_name = Vips::vips_enum_nick gtype, enum_value
-      if enum_name == nil
+      enum_name = Vips.vips_enum_nick gtype, enum_value
+      if enum_name.nil?
         raise Vips::Error
       end
 
@@ -48,7 +52,7 @@ module GObject
 
     def self.release ptr
       # GLib::logger.debug("GObject::GValue::release") {"ptr = #{ptr}"}
-      ::GObject::g_value_unset ptr
+      ::GObject.g_value_unset ptr
     end
 
     # Allocate memory for a GValue and return a class wrapper. Memory will
@@ -66,14 +70,14 @@ module GObject
       pointer = FFI::Pointer.new GValue, memory
 
       # ... and wrap in a GValue
-      return GValue.new pointer
+      GValue.new pointer
     end
 
     # Set the type of thing a gvalue can hold.
     #
     # @param gtype [GType] the type of thing this GValue can hold.
     def init gtype
-      ::GObject::g_value_init self, gtype
+      ::GObject.g_value_init self, gtype
     end
 
     # Set the value of a GValue. The value is converted to the type of the
@@ -86,76 +90,76 @@ module GObject
       # }
 
       gtype = self[:gtype]
-      fundamental = ::GObject::g_type_fundamental gtype
+      fundamental = ::GObject.g_type_fundamental gtype
 
       case gtype
       when GBOOL_TYPE
-        ::GObject::g_value_set_boolean self, (value ? 1 : 0)
+        ::GObject.g_value_set_boolean self, (value ? 1 : 0)
 
       when GINT_TYPE
-        ::GObject::g_value_set_int self, value
+        ::GObject.g_value_set_int self, value
 
       when GUINT64_TYPE
-        ::GObject::g_value_set_uint64 self, value
+        ::GObject.g_value_set_uint64 self, value
 
       when GDOUBLE_TYPE
-        ::GObject::g_value_set_double self, value
+        ::GObject.g_value_set_double self, value
 
       when GSTR_TYPE
-        ::GObject::g_value_set_string self, value
+        ::GObject.g_value_set_string self, value
 
       when Vips::REFSTR_TYPE
-        ::Vips::vips_value_set_ref_string self, value
+        ::Vips.vips_value_set_ref_string self, value
 
       when Vips::ARRAY_INT_TYPE
         value = [value] unless value.is_a? Array
 
-        Vips::vips_value_set_array_int self, nil, value.length
-        ptr = Vips::vips_value_get_array_int self, nil
+        Vips.vips_value_set_array_int self, nil, value.length
+        ptr = Vips.vips_value_get_array_int self, nil
         ptr.write_array_of_int32 value
 
       when Vips::ARRAY_DOUBLE_TYPE
         value = [value] unless value.is_a? Array
 
         # this will allocate an array in the gvalue
-        Vips::vips_value_set_array_double self, nil, value.length
+        Vips.vips_value_set_array_double self, nil, value.length
 
         # pull the array out and fill it
-        ptr = Vips::vips_value_get_array_double self, nil
+        ptr = Vips.vips_value_get_array_double self, nil
 
         ptr.write_array_of_double value
 
       when Vips::ARRAY_IMAGE_TYPE
         value = [value] unless value.is_a? Array
 
-        Vips::vips_value_set_array_image self, value.length
-        ptr = Vips::vips_value_get_array_image self, nil
+        Vips.vips_value_set_array_image self, value.length
+        ptr = Vips.vips_value_get_array_image self, nil
         ptr.write_array_of_pointer value
 
         # the gvalue needs a ref on each of the images
-        value.each { |image| ::GObject::g_object_ref image }
+        value.each { |image| ::GObject.g_object_ref image }
 
       when Vips::BLOB_TYPE
         len = value.bytesize
-        ptr = GLib::g_malloc len
-        Vips::vips_value_set_blob self, GLib::G_FREE, ptr, len
+        ptr = GLib.g_malloc len
+        Vips.vips_value_set_blob self, GLib::G_FREE, ptr, len
         ptr.write_bytes value
 
       else
         case fundamental
         when GFLAGS_TYPE
-          ::GObject::g_value_set_flags self, value
+          ::GObject.g_value_set_flags self, value
 
         when GENUM_TYPE
           enum_value = GValue.from_nick(self[:gtype], value)
-          ::GObject::g_value_set_enum self, enum_value
+          ::GObject.g_value_set_enum self, enum_value
 
         when GOBJECT_TYPE
-          ::GObject::g_value_set_object self, value
+          ::GObject.g_value_set_object self, value
 
         else
-          raise Vips::Error, "unimplemented gtype for set: " +
-                             "#{::GObject::g_type_name gtype} (#{gtype})"
+          raise Vips::Error, "unimplemented gtype for set: " \
+            "#{::GObject.g_type_name gtype} (#{gtype})"
         end
       end
     end
@@ -166,72 +170,72 @@ module GObject
     # @return [Any] the value held by the GValue
     def get
       gtype = self[:gtype]
-      fundamental = ::GObject::g_type_fundamental gtype
+      fundamental = ::GObject.g_type_fundamental gtype
       result = nil
 
       case gtype
       when GBOOL_TYPE
-        result = ::GObject::g_value_get_boolean(self) != 0 ? true : false
+        result = ::GObject.g_value_get_boolean(self) != 0
 
       when GINT_TYPE
-        result = ::GObject::g_value_get_int self
+        result = ::GObject.g_value_get_int self
 
       when GUINT64_TYPE
-        result = ::GObject::g_value_get_uint64 self
+        result = ::GObject.g_value_get_uint64 self
 
       when GDOUBLE_TYPE
-        result = ::GObject::g_value_get_double self
+        result = ::GObject.g_value_get_double self
 
       when GSTR_TYPE
-        result = ::GObject::g_value_get_string self
+        result = ::GObject.g_value_get_string self
 
       when Vips::REFSTR_TYPE
         len = Vips::SizeStruct.new
-        result = ::Vips::vips_value_get_ref_string self, len
+        result = ::Vips.vips_value_get_ref_string self, len
 
       when Vips::ARRAY_INT_TYPE
         len = Vips::IntStruct.new
-        array = Vips::vips_value_get_array_int self, len
+        array = Vips.vips_value_get_array_int self, len
         result = array.get_array_of_int32 0, len[:value]
 
       when Vips::ARRAY_DOUBLE_TYPE
         len = Vips::IntStruct.new
-        array = Vips::vips_value_get_array_double self, len
+        array = Vips.vips_value_get_array_double self, len
         result = array.get_array_of_double 0, len[:value]
 
       when Vips::ARRAY_IMAGE_TYPE
         len = Vips::IntStruct.new
-        array = Vips::vips_value_get_array_image self, len
+        array = Vips.vips_value_get_array_image self, len
         result = array.get_array_of_pointer 0, len[:value]
         result.map! do |pointer|
-          ::GObject::g_object_ref pointer
+          ::GObject.g_object_ref pointer
           Vips::Image.new pointer
         end
 
       when Vips::BLOB_TYPE
         len = Vips::SizeStruct.new
-        array = Vips::vips_value_get_blob self, len
+        array = Vips.vips_value_get_blob self, len
         result = array.get_bytes 0, len[:value]
 
       else
         case fundamental
         when GFLAGS_TYPE
-          result = ::GObject::g_value_get_flags self
+          result = ::GObject.g_value_get_flags self
 
         when GENUM_TYPE
-          enum_value = ::GObject::g_value_get_enum(self)
+          enum_value = ::GObject.g_value_get_enum(self)
           result = GValue.to_nick self[:gtype], enum_value
 
         when GOBJECT_TYPE
-          obj = ::GObject::g_value_get_object self
+          obj = ::GObject.g_value_get_object self
           # g_value_get_object() does not add a ref ... we need to add
           # one to match the unref in gobject release
-          ::GObject::g_object_ref obj
+          ::GObject.g_object_ref obj
           result = Vips::Image.new obj
 
         else
-          raise Vips::Error, "unimplemented gtype for get: " +
-                             "#{::GObject::g_type_name gtype} (#{gtype})"
+          raise Vips::Error, "unimplemented gtype for get: " \
+            "#{::GObject.g_type_name gtype} (#{gtype})"
         end
       end
 
@@ -239,7 +243,15 @@ module GObject
       #     "result = #{result.inspect[0..50]}"
       # }
 
-      return result
+      result
+    end
+
+    # Clear the thing held by a GValue.
+    #
+    # This happens automatically when a GValue is GCed, but this method can be
+    # handy if you need to drop a reference explicitly for some reason.
+    def unset
+      ::GObject.g_value_unset self
     end
   end
 
@@ -269,7 +281,7 @@ module GObject
 
   # use :pointer rather than GObject.ptr to avoid casting later
   attach_function :g_object_set_property,
-      [:pointer, :string, GValue.ptr], :void
+    [:pointer, :string, GValue.ptr], :void
   attach_function :g_object_get_property,
-      [:pointer, :string, GValue.ptr], :void
+    [:pointer, :string, GValue.ptr], :void
 end