tdiary-contrib 3.2.2.20130518

data/lib/exifparser/lib/exifparser/thumbnail.rb

@@ -0,0 +1,76 @@
+#
+#  exifparser/thumbnail.rb -
+#
+#  Copyright (C) 2002 Ryuichi Tamura (r-tam@fsinet.or.jp)
+#
+#  $Revision: 1.1.1.1 $
+#  $Date: 2002/12/16 07:59:00 $
+#
+
+module Exif
+
+  class Parser
+
+    alias orig_thumbnail thumbnail
+
+    #
+    # redefine method.
+    #
+    def thumbnail
+      Thumbnail.new(@result[:IFD1], @data)
+    end
+
+  end
+
+  #
+  # APIs are subject to change.
+  #
+  class Thumbnail
+
+    def initialize(ifd1, data)
+      @ifd1 = ifd1
+      @data = data
+    end
+
+    def size
+      @data.size
+    end
+
+    def write(dest)
+      dest << @data
+    end
+
+    def width
+      search_tag('ImageWidth')
+    end
+
+    def height
+      search_tag('ImageLength')
+    end
+    alias length height
+
+    def bits_per_sample
+      search_tag('BitsPerSample')
+    end
+
+    def compression
+      search_tag('Compression')
+    end
+
+    def photometric_interpretation
+      search_tag('PhotometricInterpretation')
+    end
+
+    def strip_offsets
+      search_tag('StripOffsets')
+    end
+
+    private
+
+    def search_tag(tag)
+      @ifd1.find { |t| t.name == tag }
+    end
+
+  end
+
+end

data/lib/exifparser/lib/exifparser/utils.rb

@@ -0,0 +1,88 @@
+#
+#   exifparser/utils.rb -
+#
+#   Copyright (C) 2002 Ryuichi Tamura (r-tam@fsinet.or.jp)
+#
+#    $Revision: 1.1.1.1 $
+#    $Date: 2002/12/16 07:59:00 $
+#
+
+module Exif
+
+  #
+  # utility module that will be included in some classes.
+  #
+  module Utils
+
+    module Decode
+
+      module Motorola
+
+        def byte_order
+          :motorola
+        end
+
+        def decode_ubytes(str)
+          str.unpack('C*')
+        end
+
+        def decode_ushort(str)
+          str[0,2].unpack('n').first
+        end
+
+        def decode_ulong(str)
+          str[0,4].unpack('N').first
+        end
+
+        def decode_sshort(str)
+          str[0,2].unpack('n').pack('s').unpack('s').first
+        end
+
+        def decode_slong(str)
+          str[0,4].unpack('N').pack('l').unpack('l').first
+        end
+
+        def parseTagID(str)
+          sprintf("0x%02x%02x", *(str.unpack("C*")))
+        end
+
+
+      end
+
+      module Intel
+
+        def byte_order
+          :intel
+        end
+
+        def decode_ubytes(str)
+          str.unpack('C*')
+        end
+
+        def decode_ushort(str)
+          str[0,2].unpack('v').first
+        end
+
+        def decode_ulong(str)
+          str[0,4].unpack('V').first
+        end
+
+        def decode_sshort(str)
+          str[0,2].unpack('s').first
+        end
+
+        def decode_slong(str)
+          str[0,4].unpack('l').first
+        end
+
+        def parseTagID(str)
+          "0x" + str.unpack("C*").reverse.collect{ |e| sprintf("%02x", e) }.join("")
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/exifparser/lib/exifparser.rb

@@ -0,0 +1,265 @@
+#
+#
+#=  exifparser.rb - Exif tag parser written in pure ruby
+#
+#Author:: Ryuchi Tamura (r-tam@fsinet.or.jp)
+#Copyright:: Copyright (C) 2002 Ryuichi Tamura.
+#
+# $Id: exifparser.rb,v 1.1.1.1 2002/12/16 07:59:00 tam Exp $
+#
+#== INTRODUCTION
+#
+#There are 2 classes you work with. ExifParser class is
+#the Exif tag parser that parses all tags defined EXIF-2.2 standard,
+#and many of extension tags uniquely defined by some digital equipment
+#manufacturers. Currently, part of tags defined by FujiFilm, and
+#Olympus is supported. After initialized with the path to image file
+#of EXIF format, ExifParser will provides which tags are available in
+#the image, and how you work with them.
+#
+#Tags availble from ExifParser is objects defined under Exif::Tag module,
+#with its name being the class name. For example if you get "Make" tag
+#from ExifParser, it is Exif::Tag::DateTime object. Inspecting it looks
+#following:
+#
+# #<Exif::Tag::TIFF::Make ID=0x010f, IFD="IFD0" Name="Make", Format="Ascii" Value="FUJIFILM">
+#
+#here, ID is Tag ID defined in EXIF-2.2 standard, IFD is the name of
+#Image File Directory, Name is String representation of tag ID, Format is
+#string that shows how the data is formatted, and Value is the value of
+#the tag. This is retrieved by Exif::Tag::Make#value.
+#
+#Another example. If you want to know whether flash was fired when the image
+#was generated, ExifParser returns Exif::Tag::Flash object:
+#
+# tag = exif['Flash']
+# p tag
+# => #<Exif::Tag::Exif::Flash ID=0x9209, IFD="Exif" Name="Flash", Format="Unsigned short" Value="1">
+# p tag.value
+# => 1
+#
+#It may happen that diffrent IFDs have the same tag name. In this case,
+#use Exif#tag(tagname, IFD)
+#
+#The value of the tag above, 1, is not clearly understood
+#(supposed to be 'true', though). Exif::Tag::Flash#to_s will provides
+#more human-readable form as String.
+#
+# tag.to_s #=> "Flash fired."
+#
+#many of these sentences are cited from Exif-2.2 standard.
+#
+#== USAGE
+# require 'exifparser'
+#
+# exif = ExifParser.new("fujifilm.jpg")
+#
+# 1. get a tag value by its name('Make') or its ID (0x010f)
+# exif['Make'] #=> 'FUJIFILM'
+# exif[0x010f] #=> 'FUJIFILM'
+#
+# if the specified tag is not found, nil is returned.
+#
+# 2. to see the image has the value of specified tag
+# exif.tag?('DateTime') #=> true
+# exif.tag?('CameraID') #=> false
+#
+# 3. get all the tags contained in the image.
+#
+# exif.tags
+#
+# or, if you want to know all the tags defined in specific IFD,
+#
+# exif.tags(:IFD0) # get all the tags defined in IFD0
+#
+# you can traverse each tag and work on it.
+#
+# exif.each do |tag|
+#   p tag.to_s
+# end
+#
+# # each tag in IFD0
+# exif.each(:IFD0) do |ifd0_tag|
+#  p ifd0_tag.to_s
+# end
+#
+# 4. extract thumbnail
+#
+# File.open("thumb.jpg") do |dest|
+#   exif.thumbnail dest
+# end
+#
+# dest object must respond to '<<'.
+#
+require 'exifparser/scan'
+
+module Exif
+
+  class Parser
+    #
+    # create a new object. fpath is String.
+    #
+    def initialize(fpath)
+      @fpath = fpath
+      @scanner = nil
+      File.open(fpath, "rb") do |f|
+        @scanner = Exif::Scanner.new(f)
+        @scanner.scan
+      end
+      @IFD0 = @scanner.result[:IFD0]
+      @IFD1 = @scanner.result[:IFD1]
+      @Exif = @scanner.result[:Exif]
+      @GPS  = @scanner.result[:GPS]
+      @Interoperability = @scanner.result[:Interoperability]
+      @MakerNote = @scanner.result[:MakerNote]
+      @thumbnail = @scanner.result[:Thumbnail]
+    end
+
+    def inspect
+      sprintf("#<%s filename=\"%s\" entries: IFD0(%d) IFD1(%d) Exif(%d) GPS(%d) Interoperability(%d) MakerNote(%d)>", self.class, @fpath, @IFD0.length, @IFD1.length, @Exif.length, @GPS.length, @Interoperability.length, @MakerNote.length)
+    end
+
+    #
+    # return true if specified tagid is defined or has some value.
+    #
+    def tag?(tagid)
+      search_tag(tagid) ? true : false
+    end
+
+    #
+    # search tag on the specific IFD
+    #
+    def tag(tagname, ifd=nil)
+      search_tag(tagname, ifd)
+    end
+
+    #
+    # search the specified tag values. return value is object of
+    # classes defined under Exif::Tag module.
+    #
+    def [](tagname)
+      self.tag(tagname)
+    end
+
+    #
+    # set the specified tag to the specified value.
+    # XXX NOT IMPLEMETED XXX
+    #
+    def []=(tag, value)
+      # not implemented
+    end
+
+    #
+    # extract the thumbnail image to dest. dest should respond to
+    # '<<' method.
+    #
+    def thumbnail(dest)
+      dest << @thumbnail
+    end
+
+    #
+    # return the size of the thumbnail image
+    #
+    def thumbnail_size
+      @thumbnail.size
+    end
+
+    #
+    # return all the tags in the image.
+    #
+    # if argument ifd is specified, every tags defined in the
+    # specified IFD are passed to block.
+    #
+    # return value is object of classes defined under Exif::Tag module.
+    #
+    # allowable arguments are:
+    # * :IFD0
+    # * :IFD1
+    # * :Exif
+    # * :GPS
+    # * :Interoperability
+    # * :MakerNote (if exist)
+    def tags(ifd=nil)
+      if ifd
+        @scanner.result[ifd]
+      else
+        [
+          @IFD0,
+          @IFD1,
+          @Exif,
+          @GPS,
+          @Interoperability,
+          @MakerNote
+        ].flatten
+      end
+    end
+
+    #
+    # execute given block with block argument being every tags defined
+    # in all the IFDs contained in the image.
+    #
+    # if argument ifd is specified, every tags defined in the
+    # specified IFD are passed to block.
+    #
+    # return value is object of classes defined under Exif::Tag module.
+    #
+    # allowable arguments are:
+    # * :IFD0
+    # * :IFD1
+    # * :Exif
+    # * :GPS
+    # * :Interoperability
+    # * :MakerNote
+    def each(ifd=nil)
+      if ifd
+        @scanner.result[ifd].each{ |tag| yield tag }
+      else
+        [
+          @IFD0,
+          @IFD1,
+          @Exif,
+          @GPS,
+          @Interoperability,
+          @MakerNote
+        ].flatten.each do |tag|
+          yield tag
+        end
+      end
+    end
+
+    private
+
+    def search_tag(tagID, ifd=nil)
+      if ifd
+        @scanner.result(ifd).find do |tag|
+          case tagID
+          when Fixnum
+            tag.tagID.hex == tagID
+          when String
+            tag.name == tagID
+          end
+        end
+      else
+        [
+          @IFD0,
+          @IFD1,
+          @Exif,
+          @GPS,
+          @Interoperability,
+          @MakerNote
+        ].flatten.find do |tag|
+          case tagID
+          when Fixnum
+            tag.tagID.hex == tagID
+          when String
+            tag.name == tagID
+          end
+        end
+      end
+    end
+
+  end # module Parser
+
+end # module Exif
+
+ExifParser = Exif::Parser

data/lib/exifparser/sample/exifview.rb

@@ -0,0 +1,279 @@
+#!/usr/bin/env ruby
+#
+#   exifview.rb - display EXIF information as well as EXIF image
+#
+#   Copyright (C) 2002 Ryuichi Tamura (r-tam@fsinet.or.jp)
+#
+#   $Revision: 1.3 $
+#   $Date: 2002/12/17 05:16:34 $
+#
+#   Requirements: gtk2
+#   
+require 'exifparser'
+require 'observer'
+require 'gtk2'
+
+module Exif
+
+  class Parser
+
+    def each_values
+      tags.each do |tag|
+        next if tag == Tag::Exif::MakerNote
+        yield tag.name, tag.tagID.to_s, tag.format, tag.IFD, tag.to_s
+      end
+    end
+
+  end
+
+end
+
+module ExifView
+
+  class SelectedFile
+    include Observable
+
+    def initialize
+      @fpath = nil
+    end
+    attr_reader :fpath
+    
+    def filename=(filename)
+      @fpath = File.expand_path(filename)
+      begin
+        exif = ExifParser.new(@fpath)
+        changed
+      rescue
+        changed(false)
+        raise
+      end
+      notify_observers(@fpath, exif)
+    end
+
+  end
+
+  DisplayImage = SelectedFile.new
+
+  #
+  # Error dialog
+  #
+  class ErrorDialog < ::Gtk::Dialog
+
+    def initialize(msg)
+      super()
+      self.set_default_size(200, 100)
+      self.set_title("ExifView: Error")
+      button = Gtk::Button.new("dismiss")
+      button.flags |= Gtk::Widget::CAN_DEFAULT
+      button.signal_connect("clicked") do destroy end
+      self.action_area.pack_start(button, 0)
+      button.grab_default
+      label = Gtk::Label.new(msg)
+      vbox.pack_start(label)
+      button.show
+      label.show
+    end
+
+  end
+
+  #
+  # File selection
+  #
+  class FileSelectionWidget < ::Gtk::FileSelection
+
+    def initialize
+      super('File selection')
+      history_pulldown
+      self.signal_connect('destroy') { destroy }
+      self.ok_button.signal_connect('clicked') {
+        catch(:read_error) {
+          begin
+            DisplayImage.filename = self.filename
+          rescue
+            ErrorDialog.new($!.message).show
+            throw :read_error
+          end
+          destroy
+        }
+      }
+      self.cancel_button.signal_connect('clicked') { destroy }
+    end
+
+  end
+
+  #
+  # MenuItem: Open
+  #
+  class OpenMenuItemWidget < ::Gtk::MenuItem
+
+    def initialize
+      super('Open')
+      @filesel = nil
+      self.signal_connect('activate') { 
+        @filesel = FileSelectionWidget.new
+        @filesel.show 
+      }
+    end
+    attr_reader :filesel
+
+  end
+
+  #
+  # MenuItem: Quit
+  #
+  class QuitMenuItemWidget < ::Gtk::MenuItem
+
+    def initialize
+      super('Quit')
+      self.signal_connect('activate') { Gtk.main_quit }
+    end
+
+  end
+  
+  #
+  # Menu Bar 
+  #
+  class MenuBarWidget < ::Gtk::MenuBar
+
+    def initialize
+      super()
+      @item_open =  OpenMenuItemWidget.new
+      @item_quit =  QuitMenuItemWidget.new
+      menu = Gtk::Menu.new
+      menu.append(@item_open)
+      menu.append(@item_quit)
+      filemenu = Gtk::MenuItem.new("File")
+      filemenu.set_submenu(menu)
+      self.append(filemenu)
+    end
+
+  end
+
+  class ImageWindow < ::Gtk::ScrolledWindow
+
+    def initialize
+      super(nil, nil)
+      DisplayImage.add_observer(self)
+      @filename = nil
+      @image = Gtk::Image.new
+      @vbox = Gtk::VBox.new(false, 0)
+      self.add_with_viewport(@vbox)
+      self.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC)
+      @vbox.pack_start(@image, false, false, 0)
+    end
+    attr_reader :filename
+    
+    def update(*args)
+      @filename, = *args
+      @image.set(filename)
+    end
+
+  end
+
+  class ExifDataWindow < ::Gtk::ScrolledWindow
+
+    def initialize
+      super(nil, nil)
+      DisplayImage.add_observer(self)
+      @model, @treeview = setup_columns()
+    end
+
+    def setup_columns
+      model = Gtk::ListStore.new(String, String, String, String, String)
+      # tagname, tag_id, ifd_name, value, respectedly
+      treeview = Gtk::TreeView.new(model)
+      cols = []; i = 0
+      [["Name", 0], ["Number", 1], ["Format", 2], 
+        ["IFD", 3], ["Value", 4]].each do |e|
+        treeview.insert_column(
+          Gtk::TreeViewColumn.new(e[0], Gtk::CellRendererText.new, 
+                                  {:text => e[1]}), e[1] )
+      end
+      treeview.selection.set_mode(Gtk::SELECTION_SINGLE)
+      self.add_with_viewport(treeview)
+      [model, treeview]
+    end
+    
+    def update(*args)
+      fpath, exif = *args
+      @model.clear
+      exif.each_values do |e| 
+        set_row(*e)
+      end
+    end
+
+    private
+
+    def set_row(tagname, tag_id, tag_format, ifd_name, value)
+      iter = @model.append
+      iter.set_value(0, tagname)
+      iter.set_value(1, tag_id)
+      iter.set_value(2, tag_format)
+      iter.set_value(3, ifd_name)
+      iter.set_value(4, value)
+    end
+
+  end
+
+  class MainWindow < ::Gtk::Window
+
+    def initialize(*args)
+      super(*args)
+      DisplayImage.add_observer(self)
+      # Components lower: Exif data
+      @exifdata = ExifDataWindow.new
+
+      # Components middle: Image
+      @image = ImageWindow.new
+
+      # Components upper: Menu bar
+      @menubar = MenuBarWidget.new
+
+      # VBox creation
+      @vbox = Gtk::VBox.new(false, 0)
+      
+      # signal connection for toplevel window
+      self.signal_connect('destroy') { exit }
+      self.signal_connect('delete_event') { exit }
+    end
+
+    def initialize_display 
+      set_appearance()
+      self.show_all
+    end
+
+    def update(*args)
+      filename, = *args
+      self.set_title("ExifView: #{filename}")
+    end
+
+    private
+
+    def set_appearance
+      # self
+      self.set_size_request(640,480)
+      self.set_title("ExifView #{@image.filename}")
+      self.add(@vbox)
+      # menubar
+      @vbox.pack_start(@menubar, false, false, 0)
+      # image display
+      @vbox.pack_start(@image, true, true, 0)
+      # exif data display
+      @vbox.pack_start(@exifdata, true, true, 0)
+    end
+
+  end
+
+end
+
+if $0 == __FILE__
+  Gtk.init
+  #
+  # Main
+  #
+  filename = ARGV.shift
+  window = ExifView::MainWindow.new(Gtk::Window::TOPLEVEL)
+  ExifView::DisplayImage.filename = filename if filename
+  window.initialize_display
+  Gtk.main
+end

data/lib/tdiary-contrib.rb

@@ -0,0 +1,19 @@
+module TDiary
+	class Contrib
+		def self.root
+			File.expand_path('../..', __FILE__)
+		end
+
+		class Assets
+			def self.setup(environment)
+				environment.append_path File.join(TDiary::Contrib.root, 'js')
+			end
+		end
+
+		class Plugin
+			def self.setup(sp_path)
+				sp_path << File.join(TDiary::Contrib.root, 'plugin')
+			end
+		end
+	end
+end