rdp-win32screenshot 0.0.6

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+coverage
+rdoc
+pkg
+.idea
+spec/tmp

data/History.rdoc

@@ -0,0 +1,40 @@
+= 0.0.6 2010-XX-XX
+* Trying to bring window to the foreground more aggressively (Roger Pack)
+
+= 0.0.5 2010-07-07
+* Added method window_area for capturing specified area of the window instead of full window (Jarmo Pertman)
+  Usage: Win32::Screenshot.window_area(title, x1, y1, x2, y2) {|width, height, bmp|}
+* Added method foreground_area for capturing area of the foreground (Jarmo Pertman)
+  Usage: Win32::Screenshot.foreground_area(x1, y1, x2, y2) {|width, height, bmp|}
+* Added method desktop_area for capturing area of the visible view (Jarmo Pertman)
+  Usage: Win32::Screenshot.desktop_area(x1, y1, x2, y2) {|width, height, bmp|}
+* Added method hwnd_area for capturing area of the window with specified handle (Jarmo Pertman)
+  Usage: Win32::Screenshot.hwnd_area(hwnd, x1, y1, x2, y2) {|width, height, bmp|}
+
+== Internal changes
+* Removed usage of ShowWindow with parameter SW_SHOW when trying to bring window to front due it's behaviour of resizing window if it was maximized (Jarmo Pertman)
+* Using FFI::Struct when searching window handle (Roger Pack)
+
+= 0.0.4 2010-05-27 - A Complete Overhaul
+* Fixed a bug where taking of screenshots failed on some sizes of windows (thanks for the tip from Tony Popiel)
+* Blocks should be used when taking screenshots for cleaning up resources after usage (Aslak Hellesøy)
+* Changed library structure - it is now needed to require 'win32/screenshot' (Aslak Hellesøy)
+* Replaced Ruby::DL with Ruby-FFI for better VM support and less segfaults (Jarmo Pertman)
+* Added Ruby 1.9.1 support (Jarmo Pertman)
+* Win32::Screenshot.window restores window if it's minimized before taking screenshots and brings it to the foreground (Jarmo Pertman)
+* Changed some internal method names (Jarmo Pertman)
+* Replaced Test::Unit with RSpec and made specs more robust (Jarmo Pertman)
+
+PS! This version is not backwards compatible due to different method names and usage, but upgrading should be relatively easy nevertheless.
+
+= 0.0.3 2007-01-18
+* Fixed bug with too many callbacks
+* Added get_hwnd(Regexp)
+
+= 0.0.2 2006-12-02 
+* Added desktop method (patch from Ryan Schuft)
+* Added HTTP server example (patch from Ryan Schuft)
+* Added window(regexp) method
+
+= 0.0.1 2006-11-29
+* First release

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jarmo Pertman, Aslak Hellesøy
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,76 @@
+= Win32::Screenshot (old name win32screenshot)
+
+* http://github.com/jarmo/win32screenshot
+
+== DESCRIPTION
+
+Capture Screenshots on Windows with Ruby. This library captures
+screenshots in bmp format, but you may use RMagick to convert these to some
+other formats like png.
+
+== SYNOPSIS
+
+  require 'win32/screenshot'
+ 
+  # take a screenshot of the foreground window
+  Win32::Screenshot.foreground do |width, height, bmp|
+    File.open("picture1.bmp", "wb") {|file| file.puts bmp}
+  end
+
+  # take a screenshot of the area of the foreground where upper left x and y
+  # coordinates are 0 and 10, width is 100 and height is 200
+  Win32::Screenshot.foreground_area(0, 10, 100, 200) do |width, height, bmp|
+    File.open("picture2.bmp", "wb") {|file| file.puts bmp}
+  end
+
+  # take a screenshot of the screen
+  Win32::Screenshot.desktop do |width, height, bmp|
+    File.open("picture3.bmp", "wb") {|file| file.puts bmp}
+  end
+
+  # take a screenshot of the area of the desktop where upper left x and y
+  # coordinates are 0 and 10, width is 100 and height is 200
+  Win32::Screenshot.desktop_area(0, 10, 100, 200) do |width, height, bmp|
+    File.open("picture4.bmp", "wb") {|file| file.puts bmp}
+  end
+  
+  # take a screenshot of the window, which has a text part of it's title
+  Win32::Screenshot.window("Internet Explorer") do |width, height, bmp|
+    File.open("picture5.bmp", "wb") {|file| file.puts bmp}
+  end
+  
+  # take a screenshot of the window, which matches regexp against it's title
+  Win32::Screenshot.window(/Internet Explorer/) do |width, height, bmp|
+    File.open("picture6.bmp", "wb") {|file| file.puts bmp}
+  end
+
+  # take a screenshot of the area of the window where upper left x and y
+  # coordinates are 0 and 10, width is 100 and height is 200
+  Win32::Screenshot.window_area("Internet Explorer", 0, 10, 100, 200) do |width, height, bmp|
+    File.open("picture7.bmp", "wb") {|file| file.puts bmp}
+  end
+  
+  # take a screenshot of the window with specified window handle
+  Win32::Screenshot.hwnd(window_handle) do |width, height, bmp|
+    File.open("picture8.bmp", "wb") {|file| file.puts bmp}
+  end
+
+  # take a screenshot of the area of the window with a window handle
+  # where upper left x and y
+  # coordinates are 0 and 10, width is 100 and height is 200
+  Win32::Screenshot.hwnd_area(window_handle, 0, 10, 100, 200) do |width, height, bmp|
+    File.open("picture9.bmp", "wb") {|file| file.puts bmp}
+  end
+
+  # convert a screenshot to the png format with RMagick
+  require 'rmagick'
+  
+  Win32::Screenshot.hwnd(window_handle) do |width, height, bmp|
+    img = Magick::Image.from_blob(bmp)
+    png = img[0].to_blob {self.format = 'PNG'}
+    File.open("picture10.png", "wb") {|file| file.puts png}
+  end
+
+== Copyright
+
+Copyright (c) 2010 Jarmo Pertman, Aslak Hellesøy. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,63 @@
+# coding: utf-8
+
+require 'rubygems'
+require 'rake'
+require 'os'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rdp-win32screenshot"
+    gem.summary = %Q{Capture Screenshots on Windows with Ruby}
+    gem.description = %Q{Capture Screenshots on Windows with Ruby}
+    gem.email = ["jarmo.p@gmail.com", "aslak.hellesoy@gmail.com"]
+    gem.homepage = "http://github.com/jarmo/win32screenshot"
+    gem.authors = ["Jarmo Pertman", "Aslak Hellesøy"]
+
+    gem.rdoc_options = ["--main", "README.rdoc"]
+
+    gem.add_dependency "ffi"
+
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency 'os'
+    if OS.java?
+      gem.add_development_dependency "rmagick4j"
+    else
+      gem.add_development_dependency "rmagick"
+    end
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Win32::Screenshot #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Remove all temporary files"
+task :clobber => [:clobber_rdoc, :clobber_rcov] do
+  rm_r "spec/tmp"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.6

data/lib/win32/screenshot.rb

@@ -0,0 +1,100 @@
+require 'win32/screenshot/bitmap_maker'
+
+module Win32
+  # Captures screenshots with Ruby on Windows
+  class Screenshot
+    class << self
+
+      # captures foreground
+      def foreground(&proc)
+        hwnd = BitmapMaker.foreground_window
+        BitmapMaker.capture_all(hwnd, &proc)
+      end
+
+      # captures area of the foreground
+      # where *x1* and *y1* are 0 in the upper left corner and
+      # *x2* specifies the width and *y2* the height of the area to be captured
+      def foreground_area(x1, y1, x2, y2, &proc)
+        hwnd = BitmapMaker.foreground_window
+        validate_coordinates(hwnd, x1, y1, x2, y2)
+        BitmapMaker.capture_area(hwnd, x1, y1, x2, y2, &proc)
+      end
+
+      # captures visible view of the screen
+      #
+      # to make screenshot of the real desktop, all
+      # windows must be minimized before
+      def desktop(&proc)
+        hwnd = BitmapMaker.desktop_window
+        BitmapMaker.capture_all(hwnd, &proc)
+      end
+
+      # captures area of the visible view of the screen
+      # where *x1* and *y1* are 0 in the upper left corner and
+      # *x2* specifies the width and *y2* the height of the area to be captured
+      #
+      # to make screenshot of the real desktop, all
+      # windows must be minimized before
+      def desktop_area(x1, y1, x2, y2, &proc)
+        hwnd = BitmapMaker.desktop_window
+        validate_coordinates(hwnd, x1, y1, x2, y2)
+        BitmapMaker.capture_area(hwnd, x1, y1, x2, y2, &proc)
+      end
+
+      # captures window with a *title_query* and waits *pause* (by default is 0.5)
+      # seconds after trying to set window to the foreground
+      def window(title_query, pause=0.5, &proc)
+        hwnd = window_hwnd(title_query)
+        hwnd(hwnd, pause, &proc)
+      end
+
+      # captures area of the window with a *title_query*
+      # where *x1* and *y1* are 0 in the upper left corner and
+      # *x2* specifies the width and *y2* the height of the area to be captured
+      def window_area(title_query, x1, y1, x2, y2, pause=0.5, &proc)
+        hwnd = window_hwnd(title_query)
+        hwnd_area(hwnd, x1, y1, x2, y2, pause, &proc)
+      end
+
+      # captures by window handle
+      def hwnd(hwnd, pause=0.5, &proc)
+        BitmapMaker.prepare_window(hwnd, pause)
+        BitmapMaker.capture_all(hwnd, &proc)
+      end
+
+      # captures area of the window with a handle of *hwnd*
+      # where *x1* and *y1* are 0 in the upper left corner and
+      # *x2* specifies the width and *y2* the height of the area to be captured
+      def hwnd_area(hwnd, x1, y1, x2, y2, pause=0.5, &proc)
+        validate_coordinates(hwnd, x1, y1, x2, y2)
+        BitmapMaker.prepare_window(hwnd, pause)
+        BitmapMaker.capture_area(hwnd, x1, y1, x2, y2, &proc)
+      end
+
+      private
+
+      def window_hwnd(title_query)
+        hwnd = BitmapMaker.hwnd(title_query)
+        raise "window with title '#{title_query}' was not found!" unless hwnd
+        hwnd
+      end
+
+      def validate_coordinates(hwnd, *coords)
+        specified_coordinates = coords.join(', ')
+        if coords.any? {|c| c < 0}
+          raise "specified coordinates (#{specified_coordinates}) are invalid! cannot have any less than zero"
+        end
+        x1, y1, x2, y2 = *coords
+        if x1 >= x2 || y1 >= y2
+          raise "specified coordinates (#{specified_coordinates}) are invalid! cannot have x1 > x2 or y1 > y2"
+        end
+
+        x1_always_zero, y1_always_zero, max_x2, max_y2 = BitmapMaker.dimensions_for(hwnd)
+        if x2 > max_x2 || y2 > max_y2
+          raise "specified coordinates (#{specified_coordinates}) are invalid! max is #{max_x2},#{max_y2}"
+        end
+      end
+    end
+
+  end
+end

data/lib/win32/screenshot/bitmap_maker.rb

@@ -0,0 +1,172 @@
+require 'ffi'
+
+module Win32
+  class Screenshot
+    # internal methods
+    module BitmapMaker #:nodoc:all
+      extend FFI::Library
+
+      ffi_lib 'user32', 'gdi32'
+      ffi_convention :stdcall
+
+      callback :enum_callback, [:long, :pointer], :bool
+
+      # user32.dll
+      attach_function :enum_windows, :EnumWindows,
+                      [:enum_callback, :pointer], :long
+      attach_function :window_text, :GetWindowTextA,
+                      [:long, :pointer, :int], :int
+      attach_function :window_text_length, :GetWindowTextLengthA,
+                      [:long], :int
+      attach_function :window_visible, :IsWindowVisible,
+                      [:long], :bool
+      attach_function :dc, :GetDC,
+                      [:long], :long
+      attach_function :client_rect, :GetClientRect,
+                      [:long, :pointer], :bool
+      attach_function :minimized, :IsIconic,
+                      [:long], :bool
+      attach_function :show_window, :ShowWindow,
+                      [:long, :int], :bool
+      attach_function :foreground_window, :GetForegroundWindow,
+                      [], :long
+      attach_function :desktop_window, :GetDesktopWindow,
+                      [], :long
+      attach_function :window_thread_process_id, :GetWindowThreadProcessId,
+                      [:long, :pointer], :long
+      attach_function :attach_thread_input, :AttachThreadInput,
+                      [:long, :long, :bool], :bool
+      attach_function :set_foreground_window, :SetForegroundWindow,
+                      [:long], :bool
+      attach_function :bring_window_to_top, :BringWindowToTop, 
+                       [:long], :bool                
+      attach_function :set_active_window, :SetActiveWindow, 
+                       [:long], :long
+      
+
+      # gdi32.dll
+      attach_function :create_compatible_dc, :CreateCompatibleDC,
+                      [:long], :long
+      attach_function :create_compatible_bitmap, :CreateCompatibleBitmap,
+                      [:long, :int, :int], :long
+      attach_function :select_object, :SelectObject,
+                      [:long, :long], :long
+      attach_function :bit_blt, :BitBlt,
+                      [:long, :int, :int, :int, :int, :long, :int, :int, :long], :bool
+      attach_function :di_bits, :GetDIBits,
+                      [:long, :long, :int, :int, :pointer, :pointer, :int], :int
+      attach_function :delete_object, :DeleteObject,
+                      [:long], :bool
+      attach_function :delete_dc, :DeleteDC,
+                      [:long], :bool
+      attach_function :release_dc, :ReleaseDC,
+                      [:long, :long], :int
+
+
+      EnumWindowCallback = Proc.new do |hwnd, param|
+        searched_window = WindowStruct.new param
+        title_length = window_text_length(hwnd) + 1
+        title = FFI::MemoryPointer.new :char, title_length
+        window_text(hwnd, title, title_length)
+        title = title.read_string
+        if title =~ Regexp.new(searched_window[:title].read_string) && window_visible(hwnd)
+          searched_window[:hwnd] = hwnd
+          false
+        else
+          true
+        end
+      end
+
+      module_function
+
+      class WindowStruct < FFI::Struct
+        layout :title, :pointer,
+               :hwnd, :long
+      end
+
+      def hwnd(window_title)
+        window = WindowStruct.new
+        window_title = FFI::MemoryPointer.from_string(window_title.to_s)
+        window[:title] = window_title
+        enum_windows(EnumWindowCallback, window.to_ptr)
+        window[:hwnd] == 0 ? nil : window[:hwnd] 
+      end
+
+      def prepare_window(hwnd, pause)
+        restore(hwnd) if minimized(hwnd)
+        set_foreground(hwnd)
+        sleep pause
+      end
+
+      SW_RESTORE = 9
+
+      def restore(hwnd)
+        show_window(hwnd, SW_RESTORE)
+      end
+
+      def set_foreground(hwnd)
+        if foreground_window != hwnd
+          set_foreground_window(hwnd)
+          set_active_window(hwnd)
+          bring_window_to_top(hwnd)
+          # and just in case...
+          foreground_thread = window_thread_process_id(foreground_window, nil)
+          other_thread = window_thread_process_id(hwnd, nil)          
+          attach_thread_input(foreground_thread, other_thread, true) unless other_thread == foreground_thread
+          set_foreground_window(hwnd)
+          set_active_window(hwnd)
+          bring_window_to_top(hwnd)
+          attach_thread_input(foreground_thread, other_thread, false) unless other_thread == foreground_thread
+        end
+      end
+
+      def dimensions_for(hwnd)
+        rect = [0, 0, 0, 0].pack('L4')
+        client_rect(hwnd, rect)
+        x1, y1, x2, y2 = rect.unpack('L4')
+      end
+
+      def capture_all(hwnd, &proc)
+        x1, y1, x2, y2 = dimensions_for(hwnd)
+        capture_area(hwnd, x1, y1, x2, y2, &proc)
+      end
+
+      SRCCOPY = 0x00CC0020
+      DIB_RGB_COLORS = 0
+
+      def capture_area(hwnd, x1, y1, x2, y2, &proc)
+        hScreenDC = dc(hwnd)
+        w = x2-x1
+        h = y2-y1
+
+        hmemDC = create_compatible_dc(hScreenDC)
+        hmemBM = create_compatible_bitmap(hScreenDC, w, h)
+        select_object(hmemDC, hmemBM)
+        bit_blt(hmemDC, 0, 0, w, h, hScreenDC, x1, y1, SRCCOPY)
+        bitmap_size = w * h * 3 + w % 4 * h
+        lpvpxldata = FFI::MemoryPointer.new(bitmap_size)
+
+        # Bitmap header
+        # http://www.fortunecity.com/skyscraper/windows/364/bmpffrmt.html
+        bmInfo = [40, w, h, 1, 24, 0, 0, 0, 0, 0, 0, 0].pack('L3S2L6')
+        di_bits(hmemDC, hmemBM, 0, h, lpvpxldata, bmInfo, DIB_RGB_COLORS)
+
+        bmFileHeader = [
+                19778,
+                bitmap_size + 40 + 14,
+                0,
+                0,
+                54
+        ].pack('SLSSL')
+
+        bmp_data = bmFileHeader + bmInfo + lpvpxldata.read_string(bitmap_size)
+        proc.call(w, h, bmp_data)
+      ensure
+        lpvpxldata.free
+        delete_object(hmemBM)
+        delete_dc(hmemDC)
+        release_dc(0, hScreenDC)
+      end
+    end
+  end
+end

data/lib/win32screenshot.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+Kernel.warn %q(DEPRECATION: use "require 'win32/screenshot'" instead of "require 'win32screenshot'")
+require "win32/screenshot"

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,76 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'win32/screenshot'
+require 'rubygems'
+require 'spec'
+require 'spec/autorun'
+require 'RMagick'
+require 'fileutils'
+
+module SpecHelper
+  SW_MAXIMIZE = 3
+  SW_MINIMIZE = 6
+  HWND_TOPMOST = -1
+  HWND_NOTOPMOST = -2
+  SWP_NOSIZE = 1
+  SWP_NOMOVE = 2
+  SWP_SHOWWINDOW = 40
+
+  extend FFI::Library
+  ffi_lib 'user32'
+  ffi_convention :stdcall
+
+  # user32.dll
+  attach_function :set_window_pos, :SetWindowPos,
+                  [:long, :long, :int, :int, :int, :int, :int], :bool
+
+  def cleanup
+    FileUtils.rm Dir.glob(File.join(File.dirname(__FILE__), "tmp/*"))
+  end  
+  
+  def check_image(bmp, file=nil)
+    temp_dir = File.join(File.dirname(__FILE__), 'tmp')
+    FileUtils.mkdir temp_dir unless File.exists?(temp_dir)
+    File.open(File.join(temp_dir, "#{file}.bmp"), "wb") {|io| io.write(bmp)} unless file.nil?
+    bmp[0..1].should == 'BM'
+    img = Magick::Image.from_blob(bmp)
+    png = img[0].to_blob {self.format = 'PNG'}
+    png[0..3].should == "\211PNG"
+    File.open(File.join(temp_dir, "#{file}.png"), "wb") {|io| io.puts(png)} unless file.nil?
+  end
+
+  def wait_for_programs_to_open
+    until Win32::Screenshot::BitmapMaker.hwnd(/Internet Explorer/) &&
+            Win32::Screenshot::BitmapMaker.hwnd(/Notepad/) &&
+            Win32::Screenshot::BitmapMaker.hwnd(/Calculator/)
+      sleep 0.1
+    end
+    # just in case of slow PC
+    sleep 10
+  end
+
+  def maximize title
+    Win32::Screenshot::BitmapMaker.show_window(Win32::Screenshot::BitmapMaker.hwnd(title),
+                                               SW_MAXIMIZE)
+    sleep 1
+  end
+
+  def minimize title
+    Win32::Screenshot::BitmapMaker.show_window(Win32::Screenshot::BitmapMaker.hwnd(title),
+                                               SW_MINIMIZE)
+    sleep 1
+  end
+
+  def resize title
+    hwnd = Win32::Screenshot::BitmapMaker.hwnd(title)
+    set_window_pos(hwnd,
+                   HWND_TOPMOST,
+                   0, 0, 150, 238,
+                   SWP_NOMOVE)
+    set_window_pos(hwnd,
+                   HWND_NOTOPMOST,
+                   0, 0, 0, 0,
+                   SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE)
+    sleep 1
+  end
+end

data/spec/win32_screenshot_spec.rb

@@ -0,0 +1,184 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "win32-screenshot" do
+  include SpecHelper    
+  
+  before :all do
+    cleanup
+    PROGRAM_FILES = "c:/program files/"
+    @notepad = IO.popen("notepad").pid
+    @iexplore = IO.popen(File.join(PROGRAM_FILES, "Internet Explorer", "iexplore about:blank")).pid
+    @calc = IO.popen("calc").pid
+    wait_for_programs_to_open
+  end
+
+  it "captures foreground" do
+    Win32::Screenshot.foreground do |width, height, bmp|
+      check_image(bmp, 'foreground')
+      hwnd = Win32::Screenshot::BitmapMaker.foreground_window
+      dimensions = Win32::Screenshot::BitmapMaker.dimensions_for(hwnd)
+      width.should == dimensions[2]
+      height.should == dimensions[3]
+    end
+  end
+
+  it "captures area of the foreground" do
+    Win32::Screenshot.foreground_area(30, 30, 100, 150) do |width, height, bmp|
+      check_image(bmp, 'foreground_area')
+      width.should == 70
+      height.should == 120
+    end
+  end
+
+  it "doesn't allow to capture area of the foreground with invalid coordinates" do
+    lambda {Win32::Screenshot.foreground_area(0, 0, -1, 100) {|width, height, bmp| check_image('foreground2')}}.
+            should raise_exception("specified coordinates (0, 0, -1, 100) are invalid! cannot have any less than zero")
+  end
+
+  it "captures desktop" do
+    Win32::Screenshot.desktop do |width, height, bmp|
+      check_image(bmp, 'desktop')
+      hwnd = Win32::Screenshot::BitmapMaker.desktop_window
+      dimensions = Win32::Screenshot::BitmapMaker.dimensions_for(hwnd)
+      width.should == dimensions[2]
+      height.should == dimensions[3]
+    end
+  end
+
+  it "captures area of the desktop" do
+    Win32::Screenshot.desktop_area(30, 30, 100, 150) do |width, height, bmp|
+      check_image(bmp, 'desktop_area')
+      width.should == 70
+      height.should == 120
+    end
+  end
+
+  it "doesn't allow to capture area of the desktop with invalid coordinates" do
+    lambda {Win32::Screenshot.desktop_area(0, 0, -1, 100) {|width, height, bmp| check_image('desktop2')}}.
+            should raise_exception("specified coordinates (0, 0, -1, 100) are invalid! cannot have any less than zero")
+  end
+
+  it "captures maximized window by window title" do
+    title = "Internet Explorer"
+    maximize(title)
+    Win32::Screenshot.window(title) do |width, height, bmp|
+      check_image(bmp, 'iexplore')
+      hwnd = Win32::Screenshot::BitmapMaker.hwnd(title)
+      dimensions = Win32::Screenshot::BitmapMaker.dimensions_for(hwnd)
+      width.should == dimensions[2]
+      height.should == dimensions[3]
+    end
+  end
+
+  it "captures minimized window by window title as a regexp" do
+    title = /calculator/i
+    minimize(title)
+    Win32::Screenshot.window(title) do |width, height, bmp|
+      check_image(bmp, 'calc')
+      hwnd = Win32::Screenshot::BitmapMaker.hwnd(title)
+      dimensions = Win32::Screenshot::BitmapMaker.dimensions_for(hwnd)
+      width.should == dimensions[2]
+      height.should == dimensions[3]
+    end
+  end
+
+  it "captures small windows" do
+    title = /Notepad/
+    resize(title)
+    Win32::Screenshot.window(title) do |width, height, bmp|
+      check_image(bmp, 'notepad')
+      # we should get the size of the picture because
+      # screenshot doesn't include titlebar and the size
+      # varies between different themes and Windows versions
+      hwnd = Win32::Screenshot::BitmapMaker.hwnd(title)
+      dimensions = Win32::Screenshot::BitmapMaker.dimensions_for(hwnd)
+      width.should == dimensions[2]
+      height.should == dimensions[3]
+    end
+  end
+
+  it "captures area of the window" do
+    title = /calculator/i
+    Win32::Screenshot.window_area(title, 30, 30, 100, 150) do |width, height, bmp|
+      check_image(bmp, 'calc_area')
+      width.should == 70
+      height.should == 120
+    end
+  end
+
+  it "captures whole window if window size is specified as coordinates" do
+    title = /calculator/i
+    hwnd = Win32::Screenshot::BitmapMaker.hwnd(title)
+    dimensions = Win32::Screenshot::BitmapMaker.dimensions_for(hwnd)
+    Win32::Screenshot.window_area(title, 0, 0, dimensions[2], dimensions[3]) do |width, height, bmp|
+      check_image(bmp, 'calc_area_full_window')
+      width.should == dimensions[2]
+      height.should == dimensions[3]
+    end
+  end
+
+  it "doesn't allow to capture area of the window with negative coordinates" do
+    title = /calculator/i
+    lambda {Win32::Screenshot.window_area(title, 0, 0, -1, 100) {|width, height, bmp| check_image('calc2')}}.
+            should raise_exception("specified coordinates (0, 0, -1, 100) are invalid! cannot have any less than zero")
+  end
+
+  it "doesn't allow to capture area of the window if coordinates are the same" do
+    title = /calculator/i
+    lambda {Win32::Screenshot.window_area(title, 10, 0, 10, 20) {|width, height, bmp| check_image('calc4')}}.
+            should raise_exception("specified coordinates (10, 0, 10, 20) are invalid! cannot have x1 > x2 or y1 > y2")
+  end
+
+  it "doesn't allow to capture area of the window if second coordinate is smaller than first one" do
+    title = /calculator/i
+    lambda {Win32::Screenshot.window_area(title, 0, 10, 10, 9) {|width, height, bmp| check_image('calc5')}}.
+            should raise_exception("specified coordinates (0, 10, 10, 9) are invalid! cannot have x1 > x2 or y1 > y2")
+  end
+
+  it "doesn't allow to capture area of the window with too big coordinates" do
+    title = /calculator/i
+    lambda {Win32::Screenshot.window_area(title, 0, 0, 10, 10000) {|width, height, bmp| check_image('calc3')}}.
+            should raise_exception("specified coordinates (0, 0, 10, 10000) are invalid! max is 212,264")
+  end
+
+  it "captures by window with handle" do
+    title = /calculator/i
+    hwnd = Win32::Screenshot::BitmapMaker.hwnd(title)
+    Win32::Screenshot.hwnd(hwnd) do |width, height, bmp|
+      check_image(bmp, 'calc_hwnd')
+      dimensions = Win32::Screenshot::BitmapMaker.dimensions_for(hwnd)
+      width.should == dimensions[2]
+      height.should == dimensions[3]
+    end
+  end
+
+  it "captures area of the window with handle" do
+    hwnd = Win32::Screenshot::BitmapMaker.hwnd(/calculator/i)
+    Win32::Screenshot.hwnd_area(hwnd, 30, 30, 100, 150) do |width, height, bmp|
+      check_image(bmp, 'calc_hwnd_area')
+      width.should == 70
+      height.should == 120
+    end
+  end
+
+  it "doesn't allow to capture area of the window with handle with invalid coordinates" do
+    hwnd = Win32::Screenshot::BitmapMaker.hwnd(/calculator/i)
+    lambda {Win32::Screenshot.hwnd_area(hwnd, 0, 0, -1, 100) {|width, height, bmp| check_image('desktop2')}}.
+            should raise_exception("specified coordinates (0, 0, -1, 100) are invalid! cannot have any less than zero")
+  end
+  
+  it "captures based on coordinates" do
+    hwnd = Win32::Screenshot::BitmapMaker.hwnd(/calculator/i)
+    bmp1 = bmp2 = nil
+    Win32::Screenshot.hwnd_area(hwnd, 100, 100, 170, 220) do |width, height, bmp|; bmp1 = bmp; end
+    Win32::Screenshot.hwnd_area(hwnd, 0, 0, 70, 120) do |width, height, bmp|; bmp2 = bmp; end
+    bmp1.length.should == bmp2.length
+    bmp1.should_not == bmp2
+  end
+
+  after :all do
+    Process.kill 9, @notepad
+    Process.kill 9, @iexplore rescue nil # allow for a pre-existing IE to have been used.
+    Process.kill 9, @calc
+  end
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification 
+name: rdp-win32screenshot
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 6
+  version: 0.0.6
+platform: ruby
+authors: 
+- Jarmo Pertman
+- "Aslak Helles\xC3\xB8y"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-14 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: os
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rmagick
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Capture Screenshots on Windows with Ruby
+email: 
+- jarmo.p@gmail.com
+- aslak.hellesoy@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- History.rdoc
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/win32/screenshot.rb
+- lib/win32/screenshot/bitmap_maker.rb
+- lib/win32screenshot.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/win32_screenshot_spec.rb
+has_rdoc: true
+homepage: http://github.com/jarmo/win32screenshot
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Capture Screenshots on Windows with Ruby
+test_files: 
+- spec/spec_helper.rb
+- spec/win32_screenshot_spec.rb