ruby-vips 1.0.6 → 2.0.0

data/lib/vips/access.rb

@@ -6,9 +6,6 @@ module Vips
     # *   `:sequential` means requests will be top-to-bottom, but with some
     #     amount of buffering behind the read point for small non-local
     #     accesses. 
-    #
-    # *   `:sequential_unbuffered` means requests will be strictly
-    #     top-to-bottom with no read-behind. This can save some memory.
-    class Access
+    class Access < Symbol
     end
 end

data/lib/vips/align.rb

@@ -1,11 +1,11 @@
 module Vips
 
-    # Various types of alignment. See {Vips::Image.join}, for example.
+    # Various types of alignment. See {Image#join}, for example.
     #
     # * `:low` Align on the low coordinate edge
     # * `:centre` Align on the centre
     # * `:high` Align on the high coordinate edge
 
-    class Align
+    class Align < Symbol
     end
 end

data/lib/vips/angle.rb

@@ -1,12 +1,12 @@
 module Vips
 
-    # Various fixed 90 degree rotation angles. See {Vips::Image.rot}.
+    # Various fixed 90 degree rotation angles. See {Image#rot}.
     #
     # * `:d0` no rotate
     # * `:d90` 90 degrees clockwise
     # * `:d180` 180 degrees 
     # * `:d270` 90 degrees anti-clockwise
 
-    class Angle
+    class Angle < Symbol
     end
 end

data/lib/vips/angle45.rb

@@ -1,6 +1,6 @@
 module Vips
 
-    # Various fixed 45 degree rotation angles. See {Vips::Image.rot45}.
+    # Various fixed 45 degree rotation angles. See {Image#rot45}.
     #
     # * `:d0` no rotate
     # * `:d45` 45 degrees clockwise 
@@ -11,6 +11,6 @@ module Vips
     # * `:d270` 90 degrees anti-clockwise
     # * `:d315` 45 degrees anti-clockwise
 
-    class Angle45
+    class Angle45 < Symbol
     end
 end

data/lib/vips/bandformat.rb

@@ -14,7 +14,7 @@ module Vips
     # * `:complex` complex (two floats) format
     # * `:double` double float format
     # * `:dpcomplex` double complex (two double) format
-    class BandFormat
+    class BandFormat < Symbol
     end
 
 end

data/lib/vips/coding.rb

@@ -9,6 +9,6 @@ module Vips
     # * `:none` pixels are not coded
     # * `:labq` pixels encode 3 float CIELAB values as 4 uchar
     # * `:rad` pixels encode 3 float RGB as 4 uchar (Radiance coding)
-    class Coding
+    class Coding < Symbol
     end
 end

data/lib/vips/direction.rb

@@ -1,11 +1,11 @@
 module Vips
 
-    # Operations like {Vips::Image.flip} need to be told whether to flip 
+    # Operations like {Image#flip} need to be told whether to flip 
     # left-right or top-bottom. 
     #
     # *   `:horizontal` left-right 
     # *   `:vertical` top-bottom
 
-    class Direction
+    class Direction < Symbol
     end
 end

data/lib/vips/extend.rb

@@ -2,21 +2,16 @@ module Vips
 
     # When the edges of an image are extended, you can specify
     # how you want the extension done. 
-    # See {Vips::Image.embed}, {Vips::Image.conv}, {Vips::Image.affine} and 
+    # See {Image#embed}, {Image#conv}, {Image#affine} and 
     # so on.
     #
-    # *   `:black` new pixels are black, ie. all bits are zero. 
-    #
-    # *   `:copy` each new pixel takes the value of the nearest edge pixel
-    #
-    # *   `:repeat` the image is tiled to fill the new area
-    #
-    # *   `:mirror` the image is reflected and tiled to reduce hash edges
-    #
-    # *   `:white` new pixels are white, ie. all bits are set
-    #
-    # *   `:background` colour set from the @background property
+    # * `:black` new pixels are black, ie. all bits are zero. 
+    # * `:copy` each new pixel takes the value of the nearest edge pixel
+    # * `:repeat` the image is tiled to fill the new area
+    # * `:mirror` the image is reflected and tiled to reduce hash edges
+    # * `:white` new pixels are white, ie. all bits are set
+    # * `:background` colour set from the @background property
 
-    class Extend
+    class Extend < Symbol
     end
 end

data/lib/vips/gobject.rb

@@ -0,0 +1,121 @@
+# This module provides an interface to the top level bits of GObject
+# via ruby-ffi.
+#
+# Author::    John Cupitt  (mailto:jcupitt@gmail.com)
+# License::   MIT
+
+require 'ffi'
+require 'forwardable'
+
+module GObject
+
+    # we have a number of things we need to inherit in different ways:
+    #
+    # - we want to be able to subclass GObject in Ruby in a simple way
+    # - the layouts of the nested structs need to inherit
+    # - we need to be able to cast between structs which share a base struct
+    #   without creating new wrappers or messing up refcounting
+    # - we need automatic gobject refcounting
+    #
+    # the solution is to split the class into four areas which we treat
+    # differently:
+    #
+    # - we have a "wrapper" Ruby class to allow easy subclassing ... this has a
+    #   @struct member which holds the actual pointer
+    # - we use "forwardable" to forward the various ffi methods on to the
+    #   @struct member ... we arrange things so that subclasses do not need to
+    #   do the forwarding themselves
+    # - we have two versions of the struct: a plain one which we can use for
+    #   casting that will not change the refcounts
+    # - and a managed one with an unref which we just use for .new
+    # - we separate the struct layout into a separate module to avoid repeating
+    #   ourselves
+
+    class GObject
+        extend Forwardable
+        extend SingleForwardable
+
+        def_instance_delegators :@struct, :[], :to_ptr
+        def_single_delegators :ffi_struct, :ptr
+
+        # 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
+                end
+            end
+        end
+
+        # the struct with unref ... manage object lifetime with this
+        class ManagedStruct < FFI::ManagedStruct
+            include GObjectLayout
+
+            def self.release ptr
+                # Vips::log "GObject::GObject::ManagedStruct.release: " +
+                #     "unreffing #{ptr}"
+                GObject::g_object_unref ptr
+            end
+        end
+
+        # the plain struct ... cast with this
+        class Struct < FFI::Struct
+            include GObjectLayout
+
+        end
+
+        # don't allow ptr == nil, we never want to allocate a GObject struct
+        # ourselves, we just want to wrap GLib-allocated GObjects
+        #
+        # here we use ManagedStruct, not Struct, since this is the ref that will
+        # need the unref
+        def initialize ptr
+            # Vips::log "GObject::GObject.initialize: ptr = #{ptr}"
+            @struct = ffi_managed_struct.new ptr
+        end
+
+        # access to the casting struct for this class
+        def ffi_struct
+            self.class.ffi_struct
+        end
+
+        class << self
+            def ffi_struct
+                self.const_get :Struct
+            end
+        end
+
+        # access to the managed struct for this class
+        def ffi_managed_struct
+            self.class.ffi_managed_struct
+        end
+
+        class << self
+            def ffi_managed_struct
+                self.const_get :ManagedStruct
+            end
+        end
+
+    end
+
+    class GParamSpec < FFI::Struct
+        # the first few public fields
+        layout :g_type_instance, :pointer,
+               :name, :string,
+               :flags, :uint,
+               :value_type, :GType,
+               :owner_type, :GType
+    end
+
+    attach_function :g_param_spec_get_blurb, [GParamSpec.ptr], :string
+
+    attach_function :g_object_ref, [:pointer], :void
+    attach_function :g_object_unref, [:pointer], :void
+
+    class GParamSpecPtr < FFI::Struct
+        layout :value, GParamSpec.ptr
+    end
+
+end

data/lib/vips/gvalue.rb

@@ -0,0 +1,251 @@
+# This module provides an interface GValue via ruby-ffi.
+#
+# Author::    John Cupitt  (mailto:jcupitt@gmail.com)
+# License::   MIT
+
+require 'ffi'
+
+module GObject
+
+    # Represent a GValue. Example use:
+    #
+    # ```ruby
+    # gvalue = GValue::alloc
+    # gvalue.init GObject::GDOUBLE_TYPE
+    # gvalue.set 3.1415
+    # value = gvalue.get
+    # ```
+    #
+    # Lifetime is managed automatically. It doesn't know about all GType values,
+    # but it does know the ones that libvips uses. 
+
+    class GValue < FFI::ManagedStruct
+        layout :gtype, :GType, 
+               :data, [:ulong_long, 2]
+
+        def self.release ptr
+            # Vips::log "GObject::GValue::release ptr = #{ptr}"
+            ::GObject::g_value_unset ptr 
+        end
+
+        # Allocate memory for a GValue and return a class wrapper. Memory will
+        # be freed automatically when it goes out of scope. The GValue is inited
+        # to 0, use {GValue.init} to set a type.
+        #
+        # @return [GValue] a new gvalue set to 0
+        def self.alloc
+            # allocate memory
+            memory = FFI::MemoryPointer.new GValue
+
+            # make this alloc autorelease ... we mustn't release in 
+            # GValue::release, since we are used to wrap GValue pointers 
+            # made by other people
+            pointer = FFI::Pointer.new GValue, memory
+
+            # ... and wrap in a GValue
+            return 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
+        end
+
+        # Set the value of a GValue. The value is converted to the type of the
+        # GValue, if possible.
+        #
+        # @param value [Any] The value to set
+        def set value
+            # Vips::log "GObject::GValue.set: value = #{value.inspect[0..50]}"
+
+            gtype = self[:gtype]
+            fundamental = ::GObject::g_type_fundamental gtype
+
+            case gtype
+            when GBOOL_TYPE
+                ::GObject::g_value_set_boolean self, (value ? 1 : 0)
+
+            when GINT_TYPE
+                ::GObject::g_value_set_int self, value
+
+            when GDOUBLE_TYPE
+                ::GObject::g_value_set_double self, value
+
+            when GSTR_TYPE
+                # set_string takes a copy, no lifetime worries
+                ::GObject::g_value_set_string self, value
+
+            when Vips::ARRAY_INT_TYPE
+                value = [value] if not value.is_a? Array
+
+                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] if not value.is_a? Array
+
+                # this will allocate an array in the gvalue
+                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.write_array_of_double value
+
+            when Vips::ARRAY_IMAGE_TYPE
+                value = [value] if not value.is_a? Array
+
+                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}
+
+            when Vips::BLOB_TYPE
+                len = value.length
+                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
+
+                when GENUM_TYPE
+                    value = value.to_s if value.is_a? Symbol
+
+                    if value.is_a? String
+                        value = Vips::vips_enum_from_nick "ruby-vips", 
+                            self[:gtype], value
+                        if value == -1
+                            raise Vips::Error
+                        end
+                    end
+
+                    ::GObject::g_value_set_enum self, value
+
+                when GOBJECT_TYPE
+                    ::GObject::g_value_set_object self, value
+
+                else
+                    raise Vips::Error, "unimplemented gtype for set: #{gtype}"
+                end
+            end
+        end
+
+        # Get the value of a GValue. The value is converted to a Ruby type in
+        # the obvious way. 
+        #
+        # @return [Any] the value held by the GValue
+        def get
+            gtype = self[:gtype]
+            fundamental = ::GObject::g_type_fundamental gtype
+            result = nil
+
+            case gtype
+            when GBOOL_TYPE
+                result = ::GObject::g_value_get_boolean(self) != 0 ? true : false
+
+            when GINT_TYPE
+                result = ::GObject::g_value_get_int self
+
+            when GDOUBLE_TYPE
+                result = ::GObject::g_value_get_double self
+
+            when GSTR_TYPE
+                # FIXME do we need to strdup here?
+                result = ::GObject::g_value_get_string self
+
+            when Vips::ARRAY_INT_TYPE
+                len = Vips::IntStruct.new
+                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
+                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
+                result = array.get_array_of_pointer 0, len[:value]
+                result.map! do |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
+                result = array.get_bytes 0, len[:value]
+
+            else
+                case fundamental
+                when GFLAGS_TYPE
+                    result = ::GObject::g_value_get_flags self
+
+                when GENUM_TYPE
+                    enum_value = ::GObject::g_value_get_enum self
+                    # this returns a static string, no need to worry about 
+                    # lifetime
+                    enum_name = Vips::vips_enum_nick self[:gtype], enum_value
+                    if enum_name == nil
+                        raise Vips::Error
+                    end
+                    result = enum_name.to_sym
+
+                when GOBJECT_TYPE
+                    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
+                    result = Vips::Image.new obj
+
+                else
+                    raise Vips::Error, "unimplemented gtype for get: #{gtype}"
+
+                end
+            end
+
+            # Vips::log "GObject::GValue.get: result = #{result.inspect[0..50]}"
+
+            return result
+        end
+
+    end
+
+    attach_function :g_value_init, [GValue.ptr, :GType], :void
+
+    # we must use a plain :pointer here, since we call this from #release, which
+    # just gives us the unwrapped pointer, not the ruby class
+    attach_function :g_value_unset, [:pointer], :void
+
+    attach_function :g_value_set_boolean, [GValue.ptr, :int], :void
+    attach_function :g_value_set_int, [GValue.ptr, :int], :void
+    attach_function :g_value_set_double, [GValue.ptr, :double], :void
+    attach_function :g_value_set_enum, [GValue.ptr, :int], :void
+    attach_function :g_value_set_flags, [GValue.ptr, :uint], :void
+    attach_function :g_value_set_string, [GValue.ptr, :string], :void
+    attach_function :g_value_set_object, [GValue.ptr, :pointer], :void
+
+    attach_function :g_value_get_boolean, [GValue.ptr], :int
+    attach_function :g_value_get_int, [GValue.ptr], :int
+    attach_function :g_value_get_double, [GValue.ptr], :double
+    attach_function :g_value_get_enum, [GValue.ptr], :int
+    attach_function :g_value_get_flags, [GValue.ptr], :int
+    attach_function :g_value_get_string, [GValue.ptr], :string
+    attach_function :g_value_get_object, [GValue.ptr], :pointer
+
+    # use :pointer rather than GObject.ptr to avoid casting later
+    attach_function :g_object_set_property, 
+        [:pointer, :string, GValue.ptr], :void
+    attach_function :g_object_get_property, 
+        [:pointer, :string, GValue.ptr], :void
+
+end