win32-captureie 0.1.0 → 0.2.0

data/History.txt

@@ -1,3 +1,29 @@
+== 0.2.0 / 2007-12-09
+
+* Win32::CaptureIE.each
+  * Enumerate existing IE window.
+
+* Capture web page as BLOB.
+  * Win32::CaptureIE::Browser#capture_browser_image
+  * Win32::CaptureIE::Browser#capture_page_image
+  * Win32::CaptureIE::Browser#capture_elements_image
+
+* Support capture DOM elements.
+  * Win32::CaptureIE::Browser#capture_elements:
+    * CaptureIE specified DOM elements.
+
+* Support RMagick.
+  * Win32::CaptureIE::Browser#capture_page:
+    * Converts the bitmap image to the format specified by the filename if RMagick available.
+    * If filename has ".bmp" extension, RMagick are optional.
+  * Win32::CaptureIE::Browser#capture_browser:
+    * ditto.
+  * Win32::CaptureIE.rmagick_available?
+  * Win32::CaptureIE.rmagick_enable?
+  * Win32::CaptureIE.enable_rmagick
+  * Win32::CaptureIE.disable_rmagick
+
+
 == 0.1.0 / 2007-11-23
 
 * Initial release

data/Manifest.txt

@@ -7,7 +7,11 @@ TODO.txt
 bin/prtie
 config/hoe.rb
 config/requirements.rb
+examples/capture-ruby-lang.rb
+examples/each_ie.rb
+examples/hilight-id.rb
 lib/win32/capture_ie.rb
+lib/win32/capture_ie/area.rb
 lib/win32/capture_ie/base.rb
 lib/win32/capture_ie/bitmap.rb
 lib/win32/capture_ie/browser.rb
@@ -15,12 +19,14 @@ lib/win32/capture_ie/cli/base.rb
 lib/win32/capture_ie/cli/prt_ie.rb
 lib/win32/capture_ie/commands/base.rb
 lib/win32/capture_ie/commands/prt_ie.rb
+lib/win32/capture_ie/feature.rb
 lib/win32/capture_ie/ffi.rb
 lib/win32/capture_ie/ffi/base.rb
 lib/win32/capture_ie/ffi/gdi32.rb
 lib/win32/capture_ie/ffi/struct.rb
 lib/win32/capture_ie/ffi/user32.rb
 lib/win32/capture_ie/screen_captor.rb
+lib/win32/capture_ie/util.rb
 lib/win32/capture_ie/version.rb
 lib/win32/capture_ie/window.rb
 script/destroy
@@ -31,8 +37,10 @@ script/rdoc_filter.rb
 script/txt2html
 script/txt2html.cmd
 setup.rb
+spec/dsl/behaviour_eval.rb
 spec/spec.opts
 spec/spec_helper.rb
+spec/win32/capture_ie/area_spec.rb
 spec/win32/capture_ie_spec.rb
 tasks/deployment.rake
 tasks/deployment2.rake
@@ -42,4 +50,3 @@ tasks/helper/rake.rb
 tasks/helper/rake_sh_filter.rb
 tasks/helper/util.rb
 tasks/rspec.rake
-tasks/website.rake

data/README.txt

@@ -6,9 +6,29 @@
   require "win32/capture_ie"
 
   Win32::CaptureIE.start("http://www.ruby-lang.org/") do |ie|
-    ie.capture_page("ruby-lang-whole-page.bmp")
     ie.capture_browser("ruby-lang-browser.bmp")
     ie.capture_browser("ruby-lang-onepage.bmp", :only_drawing_area => true)
+    open("ruby-lang-wholepage.bmp", "wb") do |w|
+      ie.capture_page(w)
+    end
+
+    # require RMagick
+    ie.capture_page($stdout, :format => "jpg")
+    ie.capture_browser("ruby-lang-browser.png")
+  end
+
+
+  require "cgi"
+  Win32::CaptureIE.each do |ie|
+    url = ie.document.location.href
+    ie.capture_page("#{CGI.escape(url)}.png") do |image|
+      gc = Magick::Draw.new
+      gc.stroke = "white"
+      gc.text_undercolor("blue")
+      gc.text(5, ie.body_area.height - 5, url)
+      gc.draw(image)
+      image
+    end
   end
 
 
@@ -24,6 +44,13 @@ For more details, please see {prtie}[link:files/bin/prtie.html] document.
   gem install win32-captureie
 
 
+=== REQUIREMENTS
+
+* Internet Explorer
+* win32ole (standard library)
+* RMagick[http://rubyforge.org/projects/rmagick] (optional)
+
+
 === ACKNOWLEDGMENTS
 
 Thanks to P.Smejkal author for his Perl's <tt>Win32-CaptureIE</tt>,

data/TODO.txt

@@ -2,11 +2,15 @@
 
 === lib
 
-* RMagick
-  * png, jpg, ...
-* capture_element
 * capture_page(1)
+* rcairo
+* frame
 * filter, effect
+* xxx_image block
+* animation gif
+* offline mode
+* font size / page encoding
+
 
 === bin/capture-ie
 
@@ -15,7 +19,6 @@
 
    Usage: capture-ie [options ...] URL [ [options ...] URL ]...
 
-   -T, --type
    -o, --output
        --stdout
    -N  --worker=1

data/bin/prtie

@@ -24,6 +24,9 @@
 #         -w, --wait=SECONDS               wait SECONDS between retrievals
 #         -d, --output-directory=DIRECTORY save capture to DIRECTORY/...
 #         -o, --output=FILE                save capture to FILE
+#         -T, --output-type=TYPE           save capture as image TYPE
+#                                          Default: PNG (RMagick available)
+#                                                or BMP (not available)
 #         -D, --output-digest=ALGORITHM    use output filename as hex-encoded version
 #                                          of a given URL
 #                                          ALGORITHM: MD5, SHA1, SHA512 ...

data/config/hoe.rb

@@ -48,7 +48,7 @@ end
 
 # Generate all the Rake tasks
 # Run 'rake -T' to see list of generated tasks (from gem root directory)
-hoe = Hoe.new(GEM_NAME, VERS) do |p|
+HOE = Hoe.new(GEM_NAME, VERS) do |p|
   p.author = AUTHOR 
   p.description = DESCRIPTION
   p.email = EMAIL
@@ -61,12 +61,13 @@ hoe = Hoe.new(GEM_NAME, VERS) do |p|
   # == Optional
   p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
   #p.extra_deps = []     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
-  
   #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
-  
+
+  p.need_zip = true
+  p.need_tar = false
 end
 
-CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\n\n")
+CHANGES = HOE.paragraphs_of('History.txt', 0..1).join("\n\n")
 PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
-hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
-hoe.rsync_args = '-av --delete --ignore-errors'
+HOE.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+HOE.rsync_args = '-av --delete --ignore-errors'

data/examples/capture-ruby-lang.rb

@@ -0,0 +1,23 @@
+require "fileutils"
+require "pathname"
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), "../lib")
+require "win32/capture_ie"
+
+
+outdir = Pathname.new(__FILE__).basename(".*")
+FileUtils.mkdir_p(outdir)
+
+Win32::CaptureIE.start("http://www.ruby-lang.org/") do |ie|
+  ie.capture_browser(outdir + "ruby-lang-browser.bmp")
+  ie.capture_browser(outdir + "ruby-lang-onepage.bmp", :only_drawing_area => true)
+  open(outdir + "ruby-lang-wholepage.bmp", "wb") do |w|
+    ie.capture_page(w)
+  end
+
+  # require RMagick
+  ie.capture_browser(outdir + "ruby-lang-browser.png")
+  open(outdir + "ruby-lang-wholepage.png", "wb") do |w|
+    ie.capture_page(w, :format => "png")
+  end
+end

data/examples/each_ie.rb

@@ -0,0 +1,28 @@
+require "digest/md5"
+require "fileutils"
+require "pathname"
+require "time"
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), "../lib")
+require "win32/capture_ie"
+
+outdir = Pathname.new(__FILE__).basename(".*")
+FileUtils.mkdir_p(outdir)
+
+Win32::CaptureIE.reject {|ie| ie.load_error? }.each do |ie|
+  url = ie.document.location.href
+  digest = Digest::MD5.hexdigest(url)
+  output = outdir + "#{digest}.png"
+
+  puts url
+  text = "#{url} - #{Time.now.iso8601}"
+  ie.capture_page(output) do |image|
+    gc = Magick::Draw.new
+    gc.stroke = "white"
+    gc.text_undercolor("blue")
+    gc.text(5, ie.body_area.height - 5, text)
+    gc.draw(image)
+    image
+  end
+  puts "  => #{output}"
+end

data/examples/hilight-id.rb

@@ -0,0 +1,47 @@
+require "digest/md5"
+require "fileutils"
+require "pathname"
+require "time"
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), "../lib")
+require "win32/capture_ie"
+
+if ARGV.size < 2
+  $stderr.puts "Usage: #{$0} URL ID..."
+  exit 2
+end
+
+uri = ARGV.shift
+hilight_ids = ARGV
+colors = %w(red green blue)
+
+outdir = Pathname.new(__FILE__).basename(".*")
+digest = Digest::MD5.hexdigest(uri)
+output = outdir + "#{digest}.png"
+FileUtils.mkdir_p(outdir)
+
+FileUtils.mkdir_p(File.dirname(output))
+Win32::CaptureIE.start(uri) do |b|
+  b.capture_page(output) do |image|
+    hilight_ids.each_with_index do |id, i|
+      color = colors[i % colors.length]
+      area = b.abs_element_area(id)
+      gc = Magick::Draw.new
+      gc.stroke = color
+      gc.fill = color
+      gc.stroke_width = 4
+      gc.stroke_opacity(0.5)
+      gc.fill_opacity(0.2)
+      gc.rectangle(*area.rect)
+      gc.draw(image)
+
+      gc = Magick::Draw.new
+      gc.stroke_width = 1
+      gc.stroke = "white"
+      gc.text_undercolor(color)
+      gc.text(area.x1, area.y1 + 10, id)
+      gc.draw(image)
+    end
+    image
+  end
+end

data/lib/win32/capture_ie.rb

@@ -1,13 +1,75 @@
 require "win32ole"
+
+require "win32/capture_ie/feature"
 require "win32/capture_ie/browser"
 require "win32/capture_ie/version"
 
+
 module Win32 #:nodoc:
 
+  #
+  # Ex)
+  #
+  #   require "rubygems"
+  #   require "win32/capture_ie"
+  #
+  #   Win32::CaptureIE.start do |ie|
+  #     ie.navigate("http://www.ruby-lang.org/")
+  #     ie.capture_browser("ruby-lang.bmp")
+  #   end
+  #
+  #   ie = Win32::CaptureIE.start
+  #   begin
+  #     ie.navigate("http://rubyforge.org/")
+  #     ie.capture_browser("rubyforge.bmp")
+  #   ensure
+  #     ie.quit
+  #   end
+  #
   module CaptureIE
+    # see Win32::CaptureIE#connect
+    class ConnectError < StandardError; end
+
     class <<self
+      include Enumerable
+      include Win32::CaptureIE::Feature
+
+      # Do not load/use RMagick even if RMagick is installed.
+      #
+      #   Win32::CaptureIE.connect_or_start(url) do |b|
+      #     Win32::CaptureIE.disable_rmagick
+      #     b.capture_browser("foo.png") #=> Win32::CaptureIE::Feature::DisabledError
+      #     b.capture_browser("foo.bmp") #=> ok
+      #     Win32::CaptureIE.enable_rmagick
+      #     b.capture_browser("foo.png") #=> ok and load RMagick automatically.
+      #     Win32::CaptureIE.disable_rmagick
+      #     b.capture_browser("foo.png") #=> Win32::CaptureIE::Feature::DisabledError
+      #   end
+      #
+      def disable_rmagick
+        disable_feature("RMagick")
+      end
 
-      class ConnectError < StandardError; end
+      # enable RMagick.
+      #
+      # see disable_rmagick for more details.
+      def enable_rmagick
+        enable_feature("RMagick")
+      end
+
+      # RMagick is enabled?
+      #
+      # see disable_rmagick for more details.
+      def rmagick_enable?
+        feature_enable?("RMagick")
+      end
+
+      # RMagick is installed and enabled?
+      #
+      # This method will load RMagick (and rubygems) automatically.
+      def rmagick_available?
+        feature_available?("RMagick")
+      end
 
       # call-seq:
       #   start(url) -> Win32::CaptureIE::Browser
@@ -45,9 +107,16 @@ module Win32 #:nodoc:
         attach(url, lambda { raise ConnectError, "no such IE `#{url}'" }, opts, &block)
       end
 
+      # Calls +block+ for each IE window,
+      # passing Win32::CaptureIE::Browser object to the supplied +block+.
+      def each
+        each_ie {|ie| yield wrap(ie) }
+      end
+
+
       def attach(url, fallback, opts=nil, &block)
         url = url.to_s
-        ie = list_ie.find{|e| e.LocationURL == url }
+        ie = each_ie {|ie| break ie if ie.LocationURL == url }
         if ie
           run(wrap(ie), opts, &block)
         else
@@ -56,11 +125,14 @@ module Win32 #:nodoc:
       end
       private :attach
 
-      def list_ie
+      def each_ie
         shell = WIN32OLE.new("Shell.Application")
-        w = shell.Windows.extend(Enumerable)
-        w.select{|e| e.FullName =~ /\biexplore\.exe\z/i }
+        w = shell.Windows
+        w.each do |ie|
+          yield ie if ie.FullName =~ /\biexplore\.exe\z/i
+        end
       end
+      private :each_ie
 
       def run(ie, opts=nil, &block)
         opts ||= {}
@@ -68,10 +140,7 @@ module Win32 #:nodoc:
         begin
           block.call(ie)
         ensure
-          begin
-            ie.browser.Quit unless opts[:no_quit]
-          rescue WIN32OLERuntimeError => ignored
-          end
+          ie.quit unless opts[:no_quit]
         end
       end
       private :run

data/lib/win32/capture_ie/area.rb

@@ -0,0 +1,56 @@
+require "win32/capture_ie/base"
+
+module Win32::CaptureIE
+
+  class Area #:nodoc:
+
+    attr_accessor :x, :y, :w, :h
+    alias x1 x
+    alias y1 y
+    alias width w
+    alias height h
+
+    def initialize(x, y, w, h)
+      @x, @y, @w, @h = x, y, w, h
+    end
+
+    def x2
+      x + w
+    end
+
+    def y2
+      y + h
+    end
+
+    def top_left
+      [x1, y1]
+    end
+
+    def top_right
+      [x2, y1]
+    end
+
+    def bottom_left
+      [x1, y2]
+    end
+
+    def bottom_right
+      [x2, y2]
+    end
+
+    def rect
+      [x1, y1, x2, y2]
+    end
+
+    def +(other)
+      tl = top_left.zip(other.top_left).map{|e| e.min }
+      br = bottom_right.zip(other.bottom_right).map{|e| e.max }
+      self.class.new(tl[0], tl[1], br[0] - tl[0], br[1] - tl[1])
+    end
+
+    def to_s
+      "[(%d, %d), (%d, %d)]" % rect
+    end
+  end
+
+end

data/lib/win32/capture_ie/bitmap.rb

@@ -1,6 +1,9 @@
 require "win32/capture_ie/base"
+require "win32/capture_ie/util"
+require "win32/capture_ie/feature"
 require "win32/capture_ie/ffi"
 
+
 module Win32::CaptureIE
 
   class BitMapSizeError < StandardError #:nodoc:
@@ -8,6 +11,8 @@ module Win32::CaptureIE
 
   class BitMap #:nodoc:
     include Win32::CaptureIE::FFI::GDI32
+    include Win32::CaptureIE::Util
+    include Win32::CaptureIE::Feature
 
     attr_reader :width, :height
     def initialize(width, height)
@@ -89,16 +94,60 @@ module Win32::CaptureIE
     end
     alias info create_bitmapinfo
 
-    def save(filename)
-      open(filename, "wb") do |w|
-        pack {|data|
+    def save(writable, format=nil, &rmagick_filter)
+      format ||= guess_format(writable)
+      begin
+        load_depended_library("RMagick", "save `#{format}' format")
+        save_magick(writable, format, &rmagick_filter)
+      rescue DisabledError, LoadError => e
+        raise e unless format == "bmp"
+        if rmagick_filter and $VERBOSE
+          at = eval("[__FILE__, __LINE__]", rmagick_filter.binding)
+          warn "Ignore block argument at %s:%d because RMagick is not available." % at
+        end
+        save_bmp(writable)
+      end
+    end
+
+    def save_magick(writable, format, &rmagick_filter)
+      img = to_magick(format)
+      img = run_filter(img, rmagick_filter) if rmagick_filter
+      with_output_stream(writable) do |w|
+        w.write img.to_blob
+      end
+      nil
+    end
+    private :save_magick
+
+    def save_bmp(writable)
+      with_output_stream(writable) do |w|
+        to_blob {|data|
           w.write data
         }
       end
       nil
     end
+    private :save_bmp
+
+    def to_image(format=nil)
+      format ||= "bmp"
+      begin
+        to_magick(format)
+      rescue DisabledError, LoadError => e
+        raise e unless format == "bmp"
+        to_blob
+      end
+    end
 
-    def pack(&block)
+    def to_magick(format=nil)
+      load_depended_library("RMagick", "create Magick::ImageList")
+      r = Magick::ImageList.new.from_blob(to_blob)
+      r.format = format if format
+      r
+    end
+    private :to_magick
+
+    def to_blob(&block)
       v = [create_bitmapfileheader.pack, create_bitmapinfo.bmiHeader.pack, @data]
       if block
         v.each(&block)
@@ -106,6 +155,19 @@ module Win32::CaptureIE
         v.join
       end
     end
+    private :to_blob
+
+    def run_filter(image, *filters)
+      filters.inject(image){|image,filter|
+        r = filter.call(image) || image
+        if not [Magick::ImageList, Magick::Image].any?{|k| k === r }
+          raise ArgumentError, "filter `#{filter.inspect}' should return " +
+            "Magick::ImageList, Magick::Image or nil. but was `#{r.inspect}' (#{r.class})."
+        end
+        r
+      }
+    end
+    private :run_filter
 
     def inspect
       "#<%s:0x%x @width=%d @height=%d @data=...>" % [self.class, self.object_id << 1, @height, @width]

data/lib/win32/capture_ie/browser.rb

@@ -1,8 +1,10 @@
 require "win32/capture_ie/base"
 require "win32/capture_ie/ffi"
 require "win32/capture_ie/window"
+require "win32/capture_ie/area"
 require "win32/capture_ie/screen_captor"
 
+
 module Win32::CaptureIE
   class Browser < Window
     module ReadyState
@@ -30,6 +32,14 @@ module Win32::CaptureIE
       @embedding_ie_hwnd = nil
     end
 
+    def quit(ignore_error = true)
+      begin
+        browser.Quit
+      rescue WIN32OLERuntimeError => e
+        raise e unless ignore_error
+      end
+    end
+
     def document
       @document ||= browser.document rescue nil if browser
     end
@@ -51,6 +61,46 @@ module Win32::CaptureIE
     end
     private :body0
 
+    def body_area
+      Area.new(0, 0, body.scrollWidth, body.scrollHeight) if body
+    end
+
+    def get_element(id, parent=document)
+      r = parent.getElementById(id)
+      raise ArgumentError, "unknown element `##{id}'" unless r
+      r
+    end
+
+    def to_element(id_or_element)
+      case id_or_element
+      when WIN32OLE
+        id_or_element
+      when String
+        get_element(id_or_element)
+      else
+        raise ArgumentError, "Invalid argument #{id_or_element.inspect}:#{id_or_element.class}," +
+          " expected String or WIN32OLE."
+      end
+    end
+
+    def abs_element_area(id_or_element)
+      # Let's calculate the absolute position of the object on the page
+      elem = to_element(id_or_element)
+      x = y = 0
+      p = elem
+      while p
+        x += p.offsetLeft
+        y += p.offsetTop
+        p = p.offsetParent
+      end
+
+      # This is the size of the object including its border
+      w = elem.offsetWidth
+      h = elem.offsetHeight
+
+      Area.new(x, y, w, h)
+    end
+
     def compatible_mode?
       v = document.compatMode rescue nil
       return (v.nil? or v == "BackCompat")
@@ -79,28 +129,163 @@ module Win32::CaptureIE
     end
     private :find_embedding_ie_hwnd
 
+    # save window scroll position.
     def save_excursion
       top, left = body.scrollTop, body.scrollLeft
       begin
         yield
       ensure
-        body.scrollTop, body.scrollLeft = top, left
+        begin
+          body.scrollTop, body.scrollLeft = top, left
+        rescue => ignored
+        end
       end
     end
 
     # call-seq:
-    #   capture_browser(filename)
-    #   capture_browser(filename, :only_drawing_area => true)
+    #   capture_browser(writable, :format => "bmp")
+    #   capture_browser(writable, :format => "bmp", :only_drawing_area => true)
+    #   capture_browser(writable, :format => "bmp") {|image| ... }
+    #   capture_browser(writable, :format => "bmp", :only_drawing_area => true) {|image| ... }
+    #
+    # capture IE window and write to +writable+.
+    #
+    # * +writable+ is String, Pathname or object that implemented #write method (Such as IO stream).
+    # * +format+ is image format, "GIF" or "JPG" for example.
+    # * You can specify optional block argument to filter Magick::ImageList.
+    #   If RMagick is not installed, block argument will ignore.
+    #
+    # ex):
+    #
+    #   Win32::CaptureIE.start do |b|
+    #     b.capture_browser("browser.bmp")
+    #     b.capture_browser("browser.png", :only_drawing_area => true)
+    #     open("browser.jpg", "wb") do |w|
+    #       b.capture_browser(w, :format => "jpg")
+    #     end
+    #   end
+    #
+    # RMagick example:
     #
-    # capture IE window to +filename+.
-    def capture_browser(filename, opts=nil)
-      captor.capture_browser(opts).save(filename)
+    #   url = "http://win32-captureie.rubyforge.org/html/files/README_txt.html"
+    #   Win32::CaptureIE.start(url) do |b|
+    #     b.capture_page("readme.jpg") do |image|
+    #       area = b.abs_element_area("description")
+    #       gc = Magick::Draw.new
+    #       gc.stroke = "red"
+    #       gc.fill = "red"
+    #       gc.stroke_width = 4
+    #       gc.stroke_opacity(0.6)
+    #       gc.fill_opacity(0.3)
+    #       gc.rectangle(*area.rect)
+    #       gc.draw(image)
+    #       image
+    #     end
+    #   end
+    #
+    def capture_browser(writable, opts=nil, &rmagick_filter)
+      opts = parse_opts_for_capture_xxx(opts)
+      captor.capture_browser(opts).save(writable, opts[:format], &rmagick_filter)
     end
 
-    # capture whole web page to +filename+.
-    def capture_page(filename)
-      captor.capture_page.save(filename)
+    # call-seq:
+    #   capture_browser_image(:format => "bmp")
+    #   capture_browser_image(:format => "bmp", :only_drawing_area => true)
+    #
+    # capture IE window and return Magick::ImageList or BitMap blob as String.
+    #
+    # * +format+ is image format, "GIF" or "JPG" for example.
+    #
+    # ex):
+    #
+    #   Win32::CaptureIE.start do |b|
+    #     b.capture_browser_image.write("foo.bmp")
+    #     b.capture_browser_image(:format => "png").write("foo.png")
+    #   end
+    #
+    def capture_browser_image(opts=nil)
+      opts = parse_opts_for_capture_xxx_image(opts)
+      captor.capture_browser(opts).to_image(opts[:format])
+    end
+
+    # call-seq:
+    #   capture_page(writable, :format => "bmp")
+    #   capture_page(writable, :format => "bmp") {|image| ... }
+    #
+    # capture whole web page and write to +writable+.
+    #
+    # see #capture_browser for more detail.
+    def capture_page(writable, opts=nil, &rmagick_filter)
+      opts = parse_opts_for_capture_xxx(opts)
+      captor.capture_page.save(writable, opts[:format], &rmagick_filter)
+    end
+
+    # capture whole web page and return Magick::ImageList or BitMap blob as String.
+    #
+    # see #capture_browser_image for more detail.
+    def capture_page_image(opts=nil)
+      opts = parse_opts_for_capture_xxx_image(opts)
+      captor.capture_page.to_image(opts[:format])
+    end
+
+    # call-seq:
+    #   capture_elements(writable, ["id", "id2"], :format => "bmp")
+    #   capture_elements(writable, ["id", "id2"], :format => "bmp") {|image| ... }
+    #
+    # Captures specified elements (outer bounding box of all elements)
+    # and write to +writable+.
+    #
+    # * +id_or_elements+ is ID of DOM element or WIN32OLE object.
+    #
+    # see #capture_browser for more detail.
+    def capture_elements(writable, id_or_elements, opts=nil, &rmagick_filter)
+      opts = parse_opts_for_capture_xxx(opts)
+      captor.capture_elements(*id_or_elements).save(writable, opts[:format], &rmagick_filter)
+    end
+
+    # capture specified elements and return Magick::ImageList or BitMap blob as String.
+    #
+    # see #capture_browser_image for more detail.
+    def capture_elements_image(id_or_elements, opts=nil)
+      opts = parse_opts_for_capture_xxx_image(opts)
+      captor.capture_elements(*id_or_elements).to_image(opts[:format])
+    end
+
+
+    def parse_opts_for_capture_xxx(opts)
+      r = parse_opts(opts, String => :format)
+      r[:format] = guess_format(r[:format])
+      r
+    end
+    private :parse_opts_for_capture_xxx
+
+    def parse_opts_for_capture_xxx_image(opts)
+      r = parse_opts(opts, String => :filename)
+      r[:format] = guess_format(r.delete(:filename))
+      r
+    end
+    private :parse_opts_for_capture_xxx_image
+
+    def parse_opts(opts, fallback)
+      opts ||= {}
+      return opts if Hash === opts
+      if key = fallback[opts.class]
+        return { key => opts }
+      end
+      raise ArgumentError, "Invalid options `#{opts.inspect}:#{opts.class}' (expected Hash)."
+    end
+    private :parse_opts
+
+    def guess_format(filename_or_format)
+      return nil if filename_or_format.nil? or filename_or_format == ""
+      ext = File.extname(filename_or_format)
+      if ext == ""
+        filename_or_format
+      else
+        ext.sub(/\A\./, "") # arrow :format => File.basename("foo.png")
+      end
     end
+    private :guess_format
 
     def captor
       Win32::CaptureIE::ScreenCaptor.new(self)

data/lib/win32/capture_ie/cli/prt_ie.rb

@@ -58,6 +58,12 @@ module Win32::CaptureIE::CLI
         parser.on("-o", "--output=FILE", "save capture to FILE") {|v|
           opt.output = v
         }
+        parser.on("-T", "--output-type=TYPE",
+                  "save capture as image TYPE",
+                  "Default: PNG (RMagick available)",
+                  "      or BMP (not available)") {|v|
+          opt.output_type = v
+        }
         parser.on("-D", "--output-digest=ALGORITHM",
                   "use output filename as hex-encoded version",
                   "of a given URL",

data/lib/win32/capture_ie/commands/prt_ie.rb

@@ -9,13 +9,8 @@ module Win32::CaptureIE::Commands
   module PrtIE #:nodoc:
 
     class Option < OptionBase #:nodoc:
-      global_option :outdir, :wait, :output_digest
+      global_option :outdir, :wait, :output_type, :output_digest
       local_option :output, :url
-      attr_reader :ext
-
-      def initialize
-        @ext = "bmp"
-      end
 
       def check_options
         raise_arg_error(url, "missing url argument")
@@ -39,10 +34,11 @@ module Win32::CaptureIE::Commands
 
       def fixup!
         self.wait = 0 if wait.nil? or wait < 0
+        self.output_type ||= Win32::CaptureIE.rmagick_available? ? "png" : "bmp"
       end
 
       def outfile
-        base = output || "#{digest_url}.#{ext}"
+        base = output || "#{digest_url}.#{output_type}"
         r = File.expand_path(base, outdir)
         dir = File.dirname(r)
         ::FileUtils.mkdir_p(dir) unless File.exist?(dir)

data/lib/win32/capture_ie/feature.rb

@@ -0,0 +1,63 @@
+require "win32/capture_ie/base"
+
+module Win32::CaptureIE
+  module Feature #:nodoc:
+
+    # see Win32::CaptureIE.disable_rmagick
+    class DisabledError < StandardError; end
+
+    DISABLED_FEATURE = []
+
+    module_function
+
+    def disable_feature(feature)
+      DISABLED_FEATURE << feature if feature_enable?(feature)
+      nil
+    end
+
+    def enable_feature(feature)
+      DISABLED_FEATURE.delete(feature)
+      nil
+    end
+
+    def feature_enable?(feature)
+      not DISABLED_FEATURE.include?(feature)
+    end
+
+    def feature_available?(feature)
+      begin
+        load_depended_library(feature, "test")
+        true
+      rescue LoadError, DisabledError => ignored
+        false
+      end
+    end
+
+    def raise_if_disabled(feature, function)
+      if DISABLED_FEATURE.include?(feature)
+        raise DisabledError, "`#{feature}' is disabled. " +
+          "Please enable `#{feature}' to #{function}."
+      end
+    end
+
+    def load_feature(feature, function)
+      raise_if_disabled(feature, function)
+      require feature
+    end
+
+    def load_depended_library(feature, function)
+      begin
+        load_feature feature, function
+      rescue LoadError
+        begin
+          load_feature "rubygems", function
+          load_feature feature, function
+        rescue LoadError
+          raise LoadError, "no such file to load -- `#{feature}'. " +
+            "Please install `#{feature}' to #{function}."
+        end
+      end
+    end
+
+  end
+end

data/lib/win32/capture_ie/screen_captor.rb

@@ -1,6 +1,7 @@
 require "win32/capture_ie/base"
 require "win32/capture_ie/ffi"
 require "win32/capture_ie/bitmap"
+require "win32/capture_ie/area"
 
 module Win32::CaptureIE
 
@@ -19,80 +20,92 @@ module Win32::CaptureIE
     end
 
     def capture_browser(opts=nil)
-      browser.save_excursion do
-        opts ||= {}
-        h = opts[:only_drawing_area] ? browser.embedding_ie_hwnd : browser.hwnd
-        browser.bring_window_to_top
-        capture_hwnd(h)
-      end
+      opts ||= {}
+      hwnd = opts[:only_drawing_area] ? browser.embedding_ie_hwnd : browser.hwnd
+      browser.bring_window_to_top
+      capture_hwnd(hwnd)
     end
 
     def capture_page
-      browser.save_excursion do
-        browser.bring_window_to_top
-        capture_area(browser.embedding_ie_hwnd, 0, 0, body.scrollWidth, body.scrollHeight)
-      end
+      browser.bring_window_to_top
+      capture_area(browser.embedding_ie_hwnd, browser.body_area)
+    end
+
+    def capture_elements(*id_or_elements)
+      elems = id_or_elements.map{|e| [e, browser.to_element(e)] }
+      return capture_page if elems.find{|id, e| e.tagName.downcase == "body" }
+
+      area = elems.map {|id, e|
+        r = browser.abs_element_area(e)
+        if r.w.zero? or r.h.zero?
+          raise ArgumentError, "Invalid element: `#{id}' has no content. #{r}."
+        end
+        r
+      }.inject{|a,b| a + b }
+
+      browser.bring_window_to_top
+      capture_area(browser.embedding_ie_hwnd, area)
     end
 
-    def capture_area(hwnd, px, py, w, h)
-      px = 0 if px < 0
-      py = 0 if py < 0
+    def capture_area(hwnd, area)
+      area.x = 0 if area.x < 0
+      area.y = 0 if area.y < 0
 
-      w = body.scrollWidth - px if px + w > body.scrollWidth
-      h = body.scrollHeight - py if  py + h > body.scrollHeight
+      area.w = body.scrollWidth  - area.x if area.x + area.w > body.scrollWidth
+      area.h = body.scrollHeight - area.y if area.y + area.h > body.scrollHeight
 
       # Scrolls the page so that top of the object is visible at the top of the window.
-      body.scrollTop = py - 2
-      body.scrollLeft = px - 2
+      body.scrollLeft = area.x - 2
+      body.scrollTop  = area.y - 2
 
       # The position on the screen is different due to page scrolling and Body border
-      sx = px - body.scrollLeft + body.clientLeft
-      sy = py - body.scrollTop + body.clientTop
+      sx = area.x - body.scrollLeft + body.clientLeft
+      sy = area.y - body.scrollTop  + body.clientTop
 
-      if sx + w < body.clientWidth && sy + h < body.clientHeight
+      if sx + area.w < body.clientWidth && sy + area.h < body.clientHeight
         # If the whole object is visible
-        capture_hwnd_area(hwnd, sx, sy, w, h)
+        capture_hwnd_area(hwnd, Area.new(sx, sy, area.w, area.h))
       else
         # If only part of it is visible
-        capture_and_scroll(hwnd, px, py, w, h)
+        capture_and_scroll(hwnd, area)
       end
     end
 
-    def capture_and_scroll(hwnd, px, py, w, h)
+    def capture_and_scroll(hwnd, area)
       # Captured area
       result = BitMap.new(0, 0)
 
       # We will do the screen capturing in more steps by areas of maximum dimensions maxw x maxh
-      maxw = body.clientWidth;
-      maxh = body.clientHeight;
+      maxw = body.clientWidth
+      maxh = body.clientHeight
 
       cw = 0
       ch = 0
       cnt_x = 0
-      while cw < w
+      while cw < area.w
         # Scroll to the top and right
-        body.scrollTop = px - 2;
-        body.scrollLeft = px - 2 + cnt_x * (maxw * 0.9).to_i
+        body.scrollTop  = area.x - 2
+        body.scrollLeft = area.x - 2 + cnt_x * (maxw * 0.9).to_i
 
-        ch = 0;
+        ch = 0
         cnt_y = 0
         strip = BitMap.new(0, 0)
-        while ch < h
-          body.scrollTop = px - 2 + cnt_y * (maxh * 0.9).to_i
+        while ch < area.h
+          body.scrollTop = area.x - 2 + cnt_y * (maxh * 0.9).to_i
 
           # Recalculate the position on the screen
-          sx = px - body.scrollLeft + body.clientLeft + cw
-          sy = py - body.scrollTop  + body.clientTop  + ch
+          sx = area.x - body.scrollLeft + body.clientLeft + cw
+          sy = area.y - body.scrollTop  + body.clientTop  + ch
 
           # Calculate the dimensions of the part to be captured
-          pw = (px + cw - body.scrollLeft + maxw) > maxw ? maxw - (px + cw) + body.scrollLeft : maxw
-          pw = cw + pw > w ? w - cw : pw
+          pw = (area.x + cw - body.scrollLeft + maxw) > maxw ? maxw - (area.x + cw) + body.scrollLeft : maxw
+          pw = cw + pw > area.w ? area.w - cw : pw
 
-          ph = (py + ch - body.scrollTop  + maxh) > maxh ? maxh - (py + ch) + body.scrollTop  : maxh
-          ph = ch + ph > h ? h - ch : ph
+          ph = (area.y + ch - body.scrollTop  + maxh) > maxh ? maxh - (area.y + ch) + body.scrollTop  : maxh
+          ph = ch + ph > area.h ? area.h - ch : ph
 
           # Capture the part and append it to the strip
-          strip << capture_hwnd_area(hwnd, sx, sy, pw, ph)
+          strip << capture_hwnd_area(hwnd, Area.new(sx, sy, pw, ph))
           ch += ph
           cnt_y += 1
         end
@@ -107,19 +120,19 @@ module Win32::CaptureIE
 
     def capture_hwnd(hwnd)
       left, top, right, bottom = get_window_rect(hwnd)
-      capture_hwnd_area(hwnd, 0, 0, right - left, bottom - top)
+      capture_hwnd_area(hwnd, Area.new(0, 0, right - left, bottom - top))
     end
 
-    def capture_hwnd_area(hwnd, x, y, w, h)
+    def capture_hwnd_area(hwnd, area)
       with_window_dc(hwnd) do |hdc|
         with_delete_dc(CreateCompatibleDC(hdc)) do |memdc|
-          with_delete_object(CreateCompatibleBitmap(hdc, w, h)) do |hbmp|
+          with_delete_object(CreateCompatibleBitmap(hdc, area.w, area.h)) do |hbmp|
             SelectObject(memdc, hbmp)
-            BitBlt(memdc, 0, 0, w, h, hdc, x, y, SRCCOPY)
+            BitBlt(memdc, 0, 0, area.w, area.h, hdc, area.x, area.y, SRCCOPY)
 
-            bmp = BitMap.new(w, h)
-            r = GetDIBits(memdc, hbmp, 0, h, bmp.data, bmp.info.pack, DIB_RGB_COLORS)
-            raise Win32APIError, "GetDIBits failed: #{r}" if r.nil? or r.zero?
+            bmp = BitMap.new(area.w, area.h)
+            r = GetDIBits(memdc, hbmp, 0, area.h, bmp.data, bmp.info.pack, DIB_RGB_COLORS)
+            raise Win32APIError, "GetDIBits failed: #{r}: #{[hwnd, area].inspect}" if r.nil? or r.zero?
 
             bmp
           end

data/lib/win32/capture_ie/util.rb

@@ -0,0 +1,45 @@
+module Win32::CaptureIE
+  module Util #:nodoc:
+
+    module_function
+
+    def maybe_enable_binmode(obj)
+      obj.binmode if obj.respond_to?(:binmode)
+    end
+
+    def filename_type
+      r = []
+      r << ::String
+      r << ::Pathname if defined?(::Pathname)
+      r
+    end
+
+    def with_filename_or_writable(duck, opts)
+      if filename_type.any?{|t| t === duck }
+        maybe_enable_binmode(duck)
+        opts[:if_filename].call(duck)
+      elsif duck.respond_to?(:write)
+        opts[:if_writable].call(duck)
+      else
+        raise ArgumentError, "`#{duck.inspect}' (#{duck.class}) " +
+          "should be writable object or filename (String or Pathname)."
+      end
+    end
+
+    def guess_format(writable, default="bmp")
+      r = with_filename_or_writable(writable, {
+        :if_writable => lambda { "" },
+        :if_filename => lambda { File.extname(writable).downcase.sub(/\A\./, "") },
+      })
+      (r == "") ? default : r
+    end
+
+    def with_output_stream(duck, &block)
+      with_filename_or_writable(duck, {
+        :if_writable => lambda { block.call(duck) },
+        :if_filename => lambda { open(duck, "wb", &block) },
+      })
+    end
+
+  end
+end

data/lib/win32/capture_ie/version.rb

@@ -3,7 +3,7 @@ require "win32/capture_ie/base"
 module Win32::CaptureIE
   module VERSION
     MAJOR = 0
-    MINOR = 1
+    MINOR = 2
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/spec/dsl/behaviour_eval.rb

@@ -0,0 +1,5 @@
+module Spec::DSL::BehaviourEval::ModuleMethods
+  def sit(description=:__generate_description, opts={}, &block)
+    puts "skip: #{description}"
+  end
+end

data/spec/spec.opts

@@ -1 +0,0 @@
---colour

data/spec/spec_helper.rb

@@ -1,7 +1,8 @@
-begin
-  require 'spec'
-rescue LoadError
-  require 'rubygems'
-  gem 'rspec'
-  require 'spec'
-end
+$LOAD_PATH << File.join(File.dirname(__FILE__), "../lib")
+require "win32/capture_ie"
+
+require "rubygems"
+require "spec"
+
+$LOAD_PATH << File.join(File.dirname(__FILE__))
+require "dsl/behaviour_eval"

data/spec/win32/capture_ie/area_spec.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper.rb")
+require "win32/capture_ie/area"
+
+describe Win32::CaptureIE::Area do
+
+  it "#bottom_right" do
+    area = Win32::CaptureIE::Area.new(200, 300, 10, 20)
+    area.bottom_right == [200, 200, 210, 320]
+  end
+
+  it "#+" do
+    area1 = Win32::CaptureIE::Area.new(0, 0, 100, 100)
+    area2 = Win32::CaptureIE::Area.new(200, 200, 10, 10)
+    area3 = area1 + area2
+    area3.top_left.should == [0, 0]
+    area3.bottom_right.should == [210, 210]
+  end
+
+end

data/spec/win32/capture_ie_spec.rb

@@ -1,11 +0,0 @@
-require File.dirname(__FILE__) + '../spec_helper.rb'
-
-# Time to add your specs!
-# http://rspec.rubyforge.org/
-describe "Place your specs here" do
-  
-  it "find this spec in spec directory" do
-    violated "Be sure to write your specs"
-  end
-  
-end

data/tasks/deployment.rake

@@ -1,5 +1,5 @@
 desc 'Release the website and new gem version'
-task :deploy => [:check_version, :website, :release] do
+task :deploy => [:check_version, :publish_docs, :release] do
   puts "Remember to create SVN tag:"
   puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
     "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "

data/tasks/deployment2.rake

@@ -67,8 +67,9 @@ if ENV["SCP"] and ENV["SCP"] != "scp"
 end
 
 
+NEWS_FILE = "news.txt"
 task :create_news do
-  subject, title, body, urls = hoe.announcement
+  subject, title, body, urls = HOE.announcement
   open(NEWS_FILE, "w") do |w|
     w.puts subject
     w.puts "#{title}\n\n#{body}\n\n"

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: win32-captureie
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2007-11-23 00:00:00 +09:00
+  version: 0.2.0
+date: 2007-12-09 00:00:00 +09:00
 summary: Win32::CaptureIE - Capture web pages using Internet Explorer
 require_paths: 
 - lib
@@ -38,7 +38,11 @@ files:
 - bin/prtie
 - config/hoe.rb
 - config/requirements.rb
+- examples/capture-ruby-lang.rb
+- examples/each_ie.rb
+- examples/hilight-id.rb
 - lib/win32/capture_ie.rb
+- lib/win32/capture_ie/area.rb
 - lib/win32/capture_ie/base.rb
 - lib/win32/capture_ie/bitmap.rb
 - lib/win32/capture_ie/browser.rb
@@ -46,12 +50,14 @@ files:
 - lib/win32/capture_ie/cli/prt_ie.rb
 - lib/win32/capture_ie/commands/base.rb
 - lib/win32/capture_ie/commands/prt_ie.rb
+- lib/win32/capture_ie/feature.rb
 - lib/win32/capture_ie/ffi.rb
 - lib/win32/capture_ie/ffi/base.rb
 - lib/win32/capture_ie/ffi/gdi32.rb
 - lib/win32/capture_ie/ffi/struct.rb
 - lib/win32/capture_ie/ffi/user32.rb
 - lib/win32/capture_ie/screen_captor.rb
+- lib/win32/capture_ie/util.rb
 - lib/win32/capture_ie/version.rb
 - lib/win32/capture_ie/window.rb
 - script/destroy
@@ -62,8 +68,10 @@ files:
 - script/txt2html
 - script/txt2html.cmd
 - setup.rb
+- spec/dsl/behaviour_eval.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/win32/capture_ie/area_spec.rb
 - spec/win32/capture_ie_spec.rb
 - tasks/deployment.rake
 - tasks/deployment2.rake
@@ -73,7 +81,6 @@ files:
 - tasks/helper/rake_sh_filter.rb
 - tasks/helper/util.rb
 - tasks/rspec.rake
-- tasks/website.rake
 test_files: []
 
 rdoc_options: 

data/tasks/website.rake

@@ -1,17 +0,0 @@
-desc 'Generate website files'
-task :website_generate => :ruby_env do
-  (Dir['website/**/*.txt'] - Dir['website/version*.txt']).each do |txt|
-    sh %{ #{RUBY_APP} script/txt2html #{txt} > #{txt.gsub(/txt$/,'html')} }
-  end
-end
-
-desc 'Upload website files to rubyforge'
-task :website_upload do
-  host = "#{rubyforge_username}@rubyforge.org"
-  remote_dir = "/var/www/gforge-projects/#{PATH}/"
-  local_dir = 'website'
-  sh %{rsync -aCv #{local_dir}/ #{host}:#{remote_dir}}
-end
-
-desc 'Generate and upload website files'
-task :website => [:website_generate, :website_upload, :publish_docs]