vips 8.8.4 → 8.12.1

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