ffi-gphoto2 0.2.0

data/lib/gphoto2/camera_abilities.rb

@@ -0,0 +1,44 @@
+module GPhoto2
+  class CameraAbilities
+    include FFI::GPhoto2
+
+    attr_reader :ptr
+
+    def self.find(model)
+      context = Context.new
+
+      camera_abilities_list = CameraAbilitiesList.new(context)
+      index = camera_abilities_list.lookup_model(model)
+      abilities = camera_abilities_list[index]
+
+      context.finalize
+
+      abilities
+    end
+
+    def initialize(camera_abilities_list, index)
+      @camera_abilities_list = camera_abilities_list
+      @index = index
+      get_abilities
+    end
+
+    def [](field)
+      ptr[field]
+    end
+
+    def to_ptr
+      @ptr
+    end
+
+    private
+
+    def get_abilities
+      ptr = FFI::GPhoto2::CameraAbilities.new
+      rc = gp_abilities_list_get_abilities(@camera_abilities_list.ptr,
+                                           @index,
+                                           ptr)
+      GPhoto2.check!(rc)
+      @ptr = ptr
+    end
+  end
+end

data/lib/gphoto2/camera_abilities_list.rb

@@ -0,0 +1,64 @@
+module GPhoto2
+  class CameraAbilitiesList
+    include FFI::GPhoto2
+
+    attr_reader :ptr
+
+    def initialize(context)
+      @context = context
+      new
+      load
+    end
+
+    def detect
+      _detect
+    end
+
+    def lookup_model(model)
+      _lookup_model(model)
+    end
+    alias_method :index, :lookup_model
+
+    def at(index)
+      CameraAbilities.new(self, index)
+    end
+    alias_method :[], :at
+
+    def to_ptr
+      @ptr
+    end
+
+    private
+
+    def new
+      ptr = FFI::MemoryPointer.new(FFI::GPhoto2::CameraAbilitiesList)
+      rc = gp_abilities_list_new(ptr)
+      GPhoto2.check!(rc)
+      @ptr = FFI::GPhoto2::CameraAbilitiesList.new(ptr.read_pointer)
+    end
+
+    def load
+      rc = gp_abilities_list_load(ptr, @context.ptr)
+      GPhoto2.check!(rc)
+    end
+
+    def _detect
+      port_info_list = PortInfoList.new
+      camera_list = CameraList.new
+
+      rc = gp_abilities_list_detect(ptr,
+                                    port_info_list.ptr,
+                                    camera_list.ptr,
+                                    @context.ptr)
+      GPhoto2.check!(rc)
+
+      camera_list
+    end
+
+    def _lookup_model(model)
+      index = rc = gp_abilities_list_lookup_model(ptr, model)
+      GPhoto2.check!(rc)
+      index
+    end
+  end
+end

data/lib/gphoto2/camera_file.rb

@@ -0,0 +1,69 @@
+module GPhoto2
+  class CameraFile
+    include FFI::GPhoto2
+
+    attr_reader :folder, :name, :ptr
+
+    def initialize(camera, folder = nil, name = nil)
+      @camera = camera
+      @folder, @name = folder, name
+      new
+    end
+
+    def preview?
+      @folder.nil? && @name.nil?
+    end
+
+    def save(pathname = default_filename)
+      File.binwrite(pathname, data)
+    end
+
+    def data
+      data_and_size.first
+    end
+
+    def size
+      data_and_size.last
+    end
+
+    def to_ptr
+      @ptr
+    end
+
+    private
+
+    def data_and_size
+      @data_and_size ||= begin
+        @camera.file(self) unless preview?
+        get_data_and_size
+      end
+    end
+
+    def default_filename
+      # previews are always jpg
+      preview? ? 'capture_preview.jpg' : @name
+    end
+
+    def new
+      ptr = FFI::MemoryPointer.new(FFI::GPhoto2::CameraFile)
+      rc = gp_file_new(ptr)
+      GPhoto2.check!(rc)
+      @ptr = FFI::GPhoto2::CameraFile.new(ptr.read_pointer)
+    end
+
+    def get_data_and_size
+      data = FFI::MemoryPointer.new(:uchar)
+      data_ptr = FFI::MemoryPointer.new(:pointer)
+      data_ptr.write_pointer(data)
+      size = FFI::MemoryPointer.new(:ulong)
+
+      rc = gp_file_get_data_and_size(ptr, data_ptr, size)
+      GPhoto2.check!(rc)
+
+      size = size.read_ulong
+      data = data_ptr.read_pointer.read_bytes(size)
+
+      [data, size]
+    end
+  end
+end

data/lib/gphoto2/camera_file_path.rb

@@ -0,0 +1,21 @@
+module GPhoto2
+  class CameraFilePath
+    attr_reader :ptr
+
+    def initialize
+      @ptr = FFI::GPhoto2::CameraFilePath.new
+    end
+
+    def name
+      ptr[:name].to_s
+    end
+
+    def folder
+      ptr[:folder].to_s
+    end
+
+    def to_ptr
+      @ptr
+    end
+  end
+end

data/lib/gphoto2/camera_folder.rb

@@ -0,0 +1,82 @@
+module GPhoto2
+  class CameraFolder
+    include FFI::GPhoto2
+
+    attr_reader :path
+
+    def initialize(camera, path = '/')
+      @camera = camera
+      @path = path
+    end
+
+    def root?
+      @path == '/'
+    end
+
+    def name
+      if root?
+        '/'
+      else
+        @path.rpartition('/').last
+      end
+    end
+
+    def folders
+      folder_list_folders
+    end
+
+    def files
+      folder_list_files
+    end
+
+    def cd(name)
+      case name
+      when '.'
+        self
+      when '..'
+        up
+      else
+        CameraFolder.new(@camera, File.join(@path, name))
+      end
+    end
+    alias_method :/, :cd
+
+    def open(name)
+      CameraFile.new(@camera, @path, name)
+    end
+
+    def up
+      if root?
+        self
+      else
+        parent = @path.rpartition('/').first
+        parent = '/' if parent.empty?
+        CameraFolder.new(@camera, parent)
+      end
+    end
+
+    def to_s
+      name
+    end
+
+    private
+
+    def folder_list_files
+      list = CameraList.new
+
+      rc = gp_camera_folder_list_files(@camera.ptr, @path, list.ptr, @camera.context.ptr)
+      GPhoto2.check!(rc)
+
+      list.to_a.map { |f| open(f.name) }
+    end
+
+    def folder_list_folders
+      list = CameraList.new
+
+      rc = gp_camera_folder_list_folders(@camera.ptr, @path, list.ptr, @camera.context.ptr)
+      GPhoto2.check!(rc)
+
+      list.to_a.map { |f| cd(f.name) }
+    end
+  end
+end

data/lib/gphoto2/camera_list.rb

@@ -0,0 +1,43 @@
+module GPhoto2
+  class CameraList
+    include FFI::GPhoto2
+
+    attr_reader :ptr
+
+    def initialize
+      new
+    end
+
+    def finalize
+      free
+    end
+
+    def size
+      count
+    end
+    alias_method :length, :size
+
+    def to_a
+      size.times.map { |i| Entry.new(self, i) }
+    end
+
+    def to_ptr
+      @ptr
+    end
+
+    private
+
+    def new
+      ptr = FFI::MemoryPointer.new(FFI::GPhoto2::CameraList)
+      rc = gp_list_new(ptr)
+      GPhoto2.check!(rc)
+      @ptr = FFI::GPhoto2::CameraList.new(ptr.read_pointer)
+    end
+
+    def count
+      rc = gp_list_count(ptr)
+      GPhoto2.check!(rc)
+      rc
+    end
+  end
+end

data/lib/gphoto2/camera_widgets/camera_widget.rb

@@ -0,0 +1,112 @@
+module GPhoto2
+  class CameraWidget
+    include FFI::GPhoto2
+
+    attr_reader :ptr
+
+    def self.factory(ptr, parent = nil)
+      # ptr fields are supposed to be private, but we ignore that here
+      type = ptr[:type].to_s.split('_').last.capitalize
+      klass = GPhoto2.const_get("#{type}CameraWidget")
+      klass.new(ptr, parent)
+    end
+
+    def initialize(ptr, parent = nil)
+      @ptr = ptr
+      @parent = parent
+    end
+
+    def finalize
+      free
+    end
+    alias_method :close, :finalize
+
+    def name
+      get_name
+    end
+
+    def value
+      get_value
+    end
+
+    def value=(value)
+      set_value(value)
+      value
+    end
+
+    def type
+      get_type
+    end
+
+    def children
+      count_children.times.map { |i| get_child(i) }
+    end
+    
+    def flatten(map = {})
+      case type
+      when :window, :section
+        children.each { |child| child.flatten(map) }
+      when :menu
+        # noop
+      else
+        map[name] = self
+      end
+
+      map
+    end
+
+    def to_s
+      value.to_s
+    end
+
+    def to_ptr
+      @ptr
+    end
+
+    private
+
+    def free
+      rc = gp_widget_free(ptr)
+      GPhoto2.check!(rc)
+    end
+
+    def get_name
+      str = FFI::MemoryPointer.new(:string)
+      str_ptr = FFI::MemoryPointer.new(:pointer)
+      str_ptr.write_pointer(str)
+      rc = gp_widget_get_name(ptr, str_ptr)
+      GPhoto2.check!(rc)
+      str_ptr.read_pointer.read_string
+    end
+
+    def get_value
+      raise NotImplementedError
+    end
+
+    def set_value(value)
+      raise NotImplementedError
+    end
+
+    def get_type
+      # assume CameraWidgetType is an int
+      type = FFI::MemoryPointer.new(:int)
+      rc = gp_widget_get_type(ptr, type)
+      GPhoto2.check!(rc)
+      CameraWidgetType[type.read_int]
+    end
+
+    def count_children
+      rc = gp_widget_count_children(ptr)
+      GPhoto2.check!(rc)
+      rc
+    end
+
+    def get_child(index)
+      widget_ptr = FFI::MemoryPointer.new(FFI::GPhoto2::CameraWidget)
+      rc = gp_widget_get_child(ptr, index, widget_ptr)
+      GPhoto2.check!(rc)
+      widget = FFI::GPhoto2::CameraWidget.new(widget_ptr.read_pointer)
+      CameraWidget.factory(widget, self)
+    end
+  end
+end

data/lib/gphoto2/camera_widgets/date_camera_widget.rb

@@ -0,0 +1,19 @@
+module GPhoto2
+  class DateCameraWidget < CameraWidget
+    protected
+
+    def get_value
+      val = FFI::MemoryPointer.new(:int)
+      rc = gp_widget_get_value(ptr, val)
+      GPhoto2.check!(rc)
+      Time.at(val.read_int).utc
+    end
+
+    def set_value(date)
+      val = FFI::MemoryPointer.new(:int)
+      val.write_int(date.to_i)
+      rc = gp_widget_set_value(ptr, val)
+      GPhoto2.check!(rc)
+    end
+  end
+end