win32-captureie 0.1.0

data/lib/win32/capture_ie/ffi/user32.rb

@@ -0,0 +1,101 @@
+require "win32/capture_ie/ffi/base"
+
+module Win32::CaptureIE::FFI
+  module User32 #:nodoc:
+    extend Win32::CaptureIE::FFI::Base
+
+    GW_HWNDFIRST               = 0
+    GW_HWNDLAST                = 1
+    GW_HWNDNEXT                = 2
+    GW_HWNDPREV                = 3
+
+    define_ffi_entry(:GetClassName, "LPI", "I", "user32", "GetClassNameA")
+    define_ffi_entry(:GetDC, "L", "L", "user32")
+    define_ffi_entry(:GetWindowDC, "L", "L", "user32")
+    define_ffi_entry(:ReleaseDC, "LL", "I", "user32")
+
+    define_ffi_entry(:OpenIcon, "L", "B", "user32")
+    define_ffi_entry(:CloseWindow, "L", "B", "user32")
+    define_ffi_entry(:BringWindowToTop, "L", "B", "user32")
+    define_ffi_entry(:GetActiveWindow, "", "L", "user32")
+    define_ffi_entry(:GetForegroundWindow, "", "L", "user32")
+    define_ffi_entry(:GetTopWindow, "L", "L", "user32")
+    define_ffi_entry(:GetWindow, "LI", "L", "user32")
+    define_ffi_entry(:GetWindowRect, "LP", "B", "user32")
+
+    module_function
+
+    def get_class_name(hwnd)
+      buf = "\0" * 255
+      r = GetClassName(hwnd, buf, buf.length)
+      raise Win32APIError, "GetClassName failed" if r.nil? or r.zero?
+      buf[0...r]
+    end
+
+    def with_window_dc(hwnd)
+      hdc = GetWindowDC(hwnd)
+      raise Win32APIError, "GetDC failed" if hdc.nil? or hdc.zero?
+      begin
+        yield hdc
+      ensure
+        ReleaseDC(hwnd, hdc)
+      end
+    end
+
+    def get_window_rect(hwnd)
+      buf = [0, 0, 0, 0].pack("L4")
+      GetWindowRect(hwnd, buf)
+      buf.unpack("L4")
+    end
+
+
+    def get_top_window(hwnd)
+      r = GetTopWindow(hwnd)
+      if r.nil? or r.zero?
+        nil
+      else
+        r
+      end
+    end
+
+    def get_window(hwnd, cmd)
+      r = GetWindow(hwnd, cmd)
+      if r.nil? or r.zero?
+        nil
+      else
+        r
+      end
+    end
+
+    def get_first_child(hwnd)
+      get_top_window(hwnd)
+    end
+
+    def get_first_sibling(hwnd)
+      get_window(hwnd, GW_HWNDFIRST)
+    end
+
+    def get_last_sibling(hwnd)
+      get_window(hwnd, GW_HWNDLAST)
+    end
+
+    def get_next_sibling(hwnd)
+      get_window(hwnd, GW_HWNDNEXT)
+    end
+
+    def get_prev_sibling(hwnd)
+      get_window(hwnd, GW_HWNDPREV)
+    end
+
+    def each_child_window(hwnd)
+      child = get_first_child(hwnd)
+      if child
+        yield child
+        while child = get_next_sibling(child)
+          yield child
+        end
+      end
+    end
+
+  end
+end

data/lib/win32/capture_ie/ffi.rb

@@ -0,0 +1,3 @@
+require "win32/capture_ie/ffi/struct"
+require "win32/capture_ie/ffi/user32"
+require "win32/capture_ie/ffi/gdi32"

data/lib/win32/capture_ie/screen_captor.rb

@@ -0,0 +1,131 @@
+require "win32/capture_ie/base"
+require "win32/capture_ie/ffi"
+require "win32/capture_ie/bitmap"
+
+module Win32::CaptureIE
+
+  class ScreenCaptor #:nodoc:
+    include Win32::CaptureIE::FFI
+    include Win32::CaptureIE::FFI::User32
+    include Win32::CaptureIE::FFI::GDI32
+
+    attr_reader :browser
+    def initialize(browser)
+      @browser = browser
+    end
+
+    def body
+      browser.body
+    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
+    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
+    end
+
+    def capture_area(hwnd, px, py, w, h)
+      px = 0 if px < 0
+      py = 0 if py < 0
+
+      w = body.scrollWidth - px if px + w > body.scrollWidth
+      h = body.scrollHeight - py if  py + 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
+
+      # 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
+
+      if sx + w < body.clientWidth && sy + h < body.clientHeight
+        # If the whole object is visible
+        capture_hwnd_area(hwnd, sx, sy, w, h)
+      else
+        # If only part of it is visible
+        capture_and_scroll(hwnd, px, py, w, h)
+      end
+    end
+
+    def capture_and_scroll(hwnd, px, py, w, h)
+      # 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;
+
+      cw = 0
+      ch = 0
+      cnt_x = 0
+      while cw < w
+        # Scroll to the top and right
+        body.scrollTop = px - 2;
+        body.scrollLeft = px - 2 + cnt_x * (maxw * 0.9).to_i
+
+        ch = 0;
+        cnt_y = 0
+        strip = BitMap.new(0, 0)
+        while ch < h
+          body.scrollTop = px - 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
+
+          # 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
+
+          ph = (py + ch - body.scrollTop  + maxh) > maxh ? maxh - (py + ch) + body.scrollTop  : maxh
+          ph = ch + ph > h ? h - ch : ph
+
+          # Capture the part and append it to the strip
+          strip << capture_hwnd_area(hwnd, sx, sy, pw, ph)
+          ch += ph
+          cnt_y += 1
+        end
+
+        result.concat_right!(strip)
+        cw += pw
+        cnt_x += 1
+      end
+
+      result
+    end
+
+    def capture_hwnd(hwnd)
+      left, top, right, bottom = get_window_rect(hwnd)
+      capture_hwnd_area(hwnd, 0, 0, right - left, bottom - top)
+    end
+
+    def capture_hwnd_area(hwnd, x, y, w, h)
+      with_window_dc(hwnd) do |hdc|
+        with_delete_dc(CreateCompatibleDC(hdc)) do |memdc|
+          with_delete_object(CreateCompatibleBitmap(hdc, w, h)) do |hbmp|
+            SelectObject(memdc, hbmp)
+            BitBlt(memdc, 0, 0, w, h, hdc, x, 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
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/win32/capture_ie/version.rb

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

data/lib/win32/capture_ie/window.rb

@@ -0,0 +1,47 @@
+require "timeout"
+
+require "win32/capture_ie/base"
+require "win32/capture_ie/ffi"
+
+module Win32::CaptureIE
+  class Window
+    include Win32::CaptureIE::FFI::User32
+
+    attr_reader :hwnd
+
+    def initialize(hwnd)
+      @hwnd = hwnd
+    end
+
+    def bring_window_to_top(timeout=5, wait=0.5)
+      return if GetForegroundWindow() == hwnd
+      timeout(timeout) {
+        while GetForegroundWindow() != hwnd
+          CloseWindow(hwnd)
+          OpenIcon(hwnd)
+          BringWindowToTop(hwnd)
+          sleep(wait)
+        end
+      }
+      wait_for_redraw
+    end
+
+    def wait_for_redraw(dt=1)
+      sleep(dt)
+    end
+
+    def list_child_window(hwnd)
+      r = [hwnd]
+      each_child_window(hwnd) {|child|
+        r << list_child_window(child)
+      }
+      r
+    end
+
+    def find_child_window_by_classname(window, classname)
+      w = list_child_window(window).flatten
+      w.find{|e| get_class_name(e) == classname }
+    end
+
+  end
+end

data/lib/win32/capture_ie.rb

@@ -0,0 +1,92 @@
+require "win32ole"
+require "win32/capture_ie/browser"
+require "win32/capture_ie/version"
+
+module Win32 #:nodoc:
+
+  module CaptureIE
+    class <<self
+
+      class ConnectError < StandardError; end
+
+      # call-seq:
+      #   start(url) -> Win32::CaptureIE::Browser
+      #   start(url, :no_wait => true) -> Win32::CaptureIE::Browser
+      #   start(url){|ie| ... }
+      #   start(url, :no_wait => true){|ie| ... }
+      #
+      # lanuch IE and return/eval Win32::CaptureIE::Browser object.
+      def start(url="about:blank", opts=nil, &block)
+        opts ||= {}
+        ie = wrap(create_ie_object)
+        ie.browser.Visible = true
+        ie.navigate(url.to_s, !opts[:no_wait])
+        run(ie, opts, &block)
+      end
+
+      # call-seq:
+      #   connect_or_start(url) -> Win32::CaptureIE::Browser
+      #   connect_or_start(url, :no_wait => true) -> Win32::CaptureIE::Browser
+      #   connect_or_start(url){|ie| ... }
+      #   connect_or_start(url, :no_wait => true){|ie| ... }
+      #
+      # connect existing IE or start.
+      def connect_or_start(url="about:blank", opts=nil, &block)
+        attach(url, lambda { start(url, opts, &block) }, opts, &block)
+      end
+
+      # call-seq:
+      #   connect(url) -> Win32::CaptureIE::Browser or Win32::CaptureIE::ConnectError
+      #   connect(url){|ie| ... }
+      #
+      # connect existing IE that displayed specified +url+.
+      # And return/eval Win32::CaptureIE::Browser object.
+      def connect(url="about:blank", opts=nil, &block)
+        attach(url, lambda { raise ConnectError, "no such IE `#{url}'" }, opts, &block)
+      end
+
+      def attach(url, fallback, opts=nil, &block)
+        url = url.to_s
+        ie = list_ie.find{|e| e.LocationURL == url }
+        if ie
+          run(wrap(ie), opts, &block)
+        else
+          fallback.call
+        end
+      end
+      private :attach
+
+      def list_ie
+        shell = WIN32OLE.new("Shell.Application")
+        w = shell.Windows.extend(Enumerable)
+        w.select{|e| e.FullName =~ /\biexplore\.exe\z/i }
+      end
+
+      def run(ie, opts=nil, &block)
+        opts ||= {}
+        return ie unless block
+        begin
+          block.call(ie)
+        ensure
+          begin
+            ie.browser.Quit unless opts[:no_quit]
+          rescue WIN32OLERuntimeError => ignored
+          end
+        end
+      end
+      private :run
+
+      def wrap(ie)
+        Win32::CaptureIE::Browser.new(ie.HWND, nil, ie)
+      end
+      private :wrap
+
+      def create_ie_object
+        WIN32OLE.new("InternetExplorer.Application")
+      end
+      private :create_ie_object
+
+    end
+  end
+
+end

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/destroy.cmd

@@ -0,0 +1 @@
+@ruby script/destroy %*

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/generate.cmd

@@ -0,0 +1 @@
+@ruby script/generate %*

data/script/rdoc_filter.rb

@@ -0,0 +1,75 @@
+class Filter
+
+  def initialize
+    @filter = []
+  end
+
+  def define_replace(regexp, replace, key)
+    @filter << [regexp, lambda { replace }, key]
+  end
+
+  def define_insert_before(tag, snippet, key)
+    @filter << [tag, lambda { snippet + tag }, key]
+  end
+
+  def define_insert_after(tag, snippet, key)
+    @filter << [tag, lambda { tag + snippet }, key]
+  end
+
+  def update!(file)
+    b = File.read(file)
+    a = @filter.inject(b) {|bb,subs|
+      re, sub, key = *subs
+      if key and bb =~ /#{Regexp.quote(key)}/
+        bb
+      else
+        bb.gsub(re, &sub)
+      end
+    }
+    if b != a
+      puts file
+      File.open(file, "w") {|w| w.puts a }
+    end
+  end
+
+end
+
+
+GOOGLE_WEBMASTER_TOOL_TAG = "4xi61YK06FtgbbYoHU2oPltUGvJZLrQogTtv+vaPYTI="
+GOOGLE_ANALYTICS_ACCOUNT = "UA-1161245-8"
+GOOGLE_ANALYTICS = <<GOOGLE
+
+<!-- Google Analytics -->
+<div id="google-analytics">
+  <script src="http://www.google-analytics.com/urchin.js" type="text/javascript">
+  </script>
+  <script type="text/javascript">
+    _uacct = "#{GOOGLE_ANALYTICS_ACCOUNT}";
+    urchinTracker();
+  </script>
+</div>
+
+GOOGLE
+
+f = Filter.new
+f.define_replace(/\A\s+/m, "", nil)
+f.define_replace(/\s*<!--.*?-->\s*<html/m, "<html", nil)
+f.define_insert_before("</body>", GOOGLE_ANALYTICS, '<div id="google-analytics">')
+f.define_replace("</frameset>\n</html>", <<NOFRAME, '<div id="google-analytics">')
+</frameset>
+
+<noframe>
+<body>
+#{GOOGLE_ANALYTICS}
+</body>
+</noframe>
+
+</html>
+NOFRAME
+
+tag = %Q{\n<meta name="verify-v1" content="#{GOOGLE_WEBMASTER_TOOL_TAG}" />\n}
+f.define_insert_after("<head>", tag, '<meta name="verify-v1"')
+
+ARGV.each do |html|
+  f.update!(html)
+end

data/script/txt2html

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+begin
+  require 'newgem'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + '/../lib/win32-captureie/version.rb'
+
+version  = Win32-captureie::VERSION::STRING
+download = 'http://rubyforge.org/projects/win32-captureie'
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.rhtml')
+  
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text = fsrc.read
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)

data/script/txt2html.cmd

@@ -0,0 +1 @@
+@ruby script/txt2html %*