ruby-vips 2.0.17 → 2.1.0

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

@@ -4,10 +4,10 @@
 # Author::    John Cupitt  (mailto:jcupitt@gmail.com)
 # License::   MIT
 
-require 'ffi'
+require "ffi"
 
 module Vips
-  if Vips::at_least_libvips?(8, 9)
+  if Vips.at_least_libvips?(8, 9)
     attach_function :vips_connection_filename, [:pointer], :string
     attach_function :vips_connection_nick, [:pointer], :string
   end
@@ -34,13 +34,13 @@ module Vips
 
     # Get any filename associated with a connection, or nil.
     def filename
-      Vips::vips_connection_filename self
+      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
+      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,6 +74,7 @@ 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
@@ -83,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
 
@@ -96,7 +103,7 @@ module GObject
 
     class << self
       def ffi_managed_struct
-        self.const_get :ManagedStruct
+        const_get :ManagedStruct
       end
     end
   end
@@ -104,10 +111,10 @@ 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

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:
@@ -22,7 +22,7 @@ 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)
@@ -31,7 +31,7 @@ module GObject
       if value.is_a? String
         # 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("_", "-")
+        value = Vips.vips_enum_from_nick "ruby-vips", gtype, value.tr("_", "-")
         if value == -1
           raise Vips::Error
         end
@@ -42,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
 
@@ -52,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
@@ -70,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
@@ -90,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
@@ -170,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
 
@@ -243,15 +243,15 @@ module GObject
       #     "result = #{result.inspect[0..50]}"
       # }
 
-      return result
+      result
     end
 
-    # Clear the thing held by a GValue. 
+    # Clear the thing held by a GValue.
     #
-    # This happens automatically when a GValue is GCed, but this method can be 
+    # 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
+    def unset
+      ::GObject.g_value_unset self
     end
   end
 
@@ -281,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