win32screenshot 0.0.8 → 1.0.0

data/lib/win32/screenshot/bitmap_maker.rb

@@ -1,53 +1,25 @@
-require 'ffi'
-
 module Win32
-  class Screenshot
-    # internal methods
-    class BitmapMaker #:nodoc:all
+  module Screenshot
+    # @private
+    # This is an internal class for taking the actual screenshots and not part of a public API.
+    class BitmapMaker
       class << self
         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], :int
-        attach_function :enum_child_windows, :EnumChildWindows,
-                        [:long, :enum_callback, :pointer], :int
-        attach_function :window_text, :GetWindowTextA,
-                        [:long, :pointer, :int], :int
-        attach_function :window_text_length, :GetWindowTextLengthA,
-                        [:long], :int
-        attach_function :class_name, :GetClassNameA,
-                         [:long, :pointer, :int], :int
-        attach_function :window_visible, :IsWindowVisible,
-                        [:long], :bool
         attach_function :dc, :GetDC,
                         [:long], :long
         attach_function :client_rect, :GetClientRect,
                         [:long, :pointer], :bool
         attach_function :window_rect, :GetWindowRect,
                         [: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,
@@ -67,96 +39,15 @@ module Win32
         attach_function :release_dc, :ReleaseDC,
                         [:long, :long], :int
 
-
-        EnumWindowCallback = FFI::Function.new(:bool, [ :long, :pointer ], { :convention => :stdcall }) do |hwnd, param|
-          searched_window = WindowStruct.new param
-          if(searched_window[:search_class] != 0)
-            title = Util.window_class(hwnd)
-          else
-            title = Util.window_title(hwnd)
-          end
-          if title =~ Regexp.new(searched_window[:title].read_string) && window_visible(hwnd)
-            searched_window[:hwnd] = hwnd
-            false
-          else
-            if(searched_window[:search_class] != 0)
-              # if they're searching for a classname, enumerate children, too
-              enum_child_windows(hwnd, EnumWindowCallback, param)
-              if searched_window[:hwnd] != 0
-                # return early if already discovered
-                false 
-              else
-               true
-              end
-            else
-              true
-            end
-          end
-        end
-
-        class WindowStruct < FFI::Struct
-          layout :title, :pointer,
-                 :hwnd, :long,
-                 :search_class, :char # boolean
-        end
-
-        def hwnd(window_title, search_class = false)
-          window = WindowStruct.new
-          unless window_title.is_a?(Regexp)
-            window_title = Regexp.escape(window_title.to_s)
-          else
-            window_title = window_title.to_s
-          end
-          window_title = FFI::MemoryPointer.from_string(window_title)
-          window[:title] = window_title
-          window[:search_class] = search_class ? 1 : 0
-          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 get_process_id_from_hwnd hwnd
-          out = FFI::MemoryPointer.new(:uint)
-          window_thread_process_id(hwnd, out)
-          out.get_uint32(0) # read_uint
-        end
-
-        def capture_all(hwnd, &proc)
-          width, height = Util.dimensions_for(hwnd)
-          capture_area(hwnd, 0, 0, width, height, &proc)
+        def capture_all(hwnd)
+          width, height = dimensions_for(hwnd)
+          capture_area(hwnd, 0, 0, width, height)
         end
 
         SRCCOPY = 0x00CC0020
         DIB_RGB_COLORS = 0
 
-        def capture_area(hwnd, x1, y1, x2, y2) # block
+        def capture_area(hwnd, x1, y1, x2, y2)
           hScreenDC = dc(hwnd)
           w = x2-x1
           h = y2-y1
@@ -181,14 +72,21 @@ module Win32
                   54
           ].pack('SLSSL')
 
-          bmp_data = bmFileHeader + bmInfo + lpvpxldata.read_string(bitmap_size)
-          yield(w, h, bmp_data)
+          Image.new(bmFileHeader + bmInfo + lpvpxldata.read_string(bitmap_size), w, h)
         ensure
           lpvpxldata.free
           delete_object(hmemBM)
           delete_dc(hmemDC)
           release_dc(0, hScreenDC)
         end
+
+        def dimensions_for(hwnd)
+          rect = [0, 0, 0, 0].pack('L4')
+          BitmapMaker.client_rect(hwnd.to_i, rect)
+          _, _, width, height = rect.unpack('L4')
+          [width, height]
+        end
+
       end
     end
   end

data/lib/win32/screenshot/extensions/rautomation/adapter/ffi/functions.rb

@@ -0,0 +1,12 @@
+module RAutomation
+  module Adapter
+    module Ffi
+      # @private
+      module Functions
+        class << self
+          alias_method :child_hwnd, :control_hwnd
+        end
+      end
+    end
+  end
+end

data/lib/win32/screenshot/extensions/rautomation/adapter/ffi/window.rb

@@ -0,0 +1,17 @@
+module RAutomation
+  module Adapter
+    module Ffi
+      # Extensions for RAutomation Ffi adapter
+      class Window
+
+        # Searches for the child window of the current window
+        # @param {Window} locators locators for the child window
+        # @return {Window} child window object
+        def child(locators)
+          self.class.new :hwnd => Functions.child_hwnd(hwnd, locators)
+        end
+
+      end
+    end
+  end
+end

data/lib/win32/screenshot/image.rb

@@ -0,0 +1,43 @@
+module Win32
+  module Screenshot
+    # Holds the bitmap data and writes it to the disk
+    class Image
+      # [String] raw bitmap blob
+      attr_reader :bitmap
+
+      # [String] bitmap width
+      attr_reader :width
+
+      # [String] bitmap height
+      attr_reader :height
+
+      # Supported output formats
+      FORMATS = %w{bmp gif jpg png}
+
+      # @private
+      def initialize(blob, width, height)
+        @bitmap = blob
+        @width = width
+        @height = height
+      end
+
+      # Writes image to the disk.
+      # @param [String] file_path writes image to the specified path.
+      # @raise [RuntimeError] when _file_path_ already exists.
+      # @raise [RuntimeError] when _file_path_ is not with the supported output {FORMATS} extension.
+      def write(file_path)
+        raise "File already exists: #{file_path}!" if File.exists? file_path
+        ext = File.extname(file_path)[1..-1]
+        raise "File '#{file_path}' has to have one of the following extensions: #{FORMATS.join(", ")}" unless ext && FORMATS.include?(ext.downcase)
+
+        if ext.downcase == "bmp"
+          File.open(file_path, "wb") {|io| io.write @bitmap}
+        else
+          image = ::MiniMagick::Image.read @bitmap
+          image.format ext
+          image.write file_path
+        end
+      end
+    end
+  end
+end

data/lib/win32/screenshot/take.rb

@@ -0,0 +1,102 @@
+module Win32
+  module Screenshot
+    # Capture Screenshots on Windows with Ruby
+    class Take
+
+      class << self
+        # Takes a screenshot of the specified object or it's area.
+        #
+        # @example Take a screenshot of the window with the specified title
+        #   Win32::Screenshot::Take.of(:window, :title => "Windows Internet Explorer")
+        #
+        # @example Take a screenshot of the foreground
+        #   Win32::Screenshot::Take.of(:foreground)
+        #
+        # @example Take a screenshot of the specified window's top-left corner's area
+        #   Win32::Screenshot::Take.of(:window, :title => /internet/i, :area => [10, 10, 20, 20])
+        #
+        # @example Take a screenshot of the window with the specified handle
+        #   Win32::Screenshot::Take.of(:window, :hwnd => 123456)
+        #
+        # @example Take a screenshot of the child window with the specified internal class name
+        #   Win32::Screenshot::Take.of(:rautomation, RAutomation::Window.new(:hwnd => 123456).child(:class => "Internet Explorer_Server"))
+        #
+        # @param [Symbol] what the type of the object to take a screenshot of,
+        #   possible values are _:foreground_, _:desktop_ and _:window_.
+        # @param [Hash] opts options only needed if _what_ is a _:window_ and/or
+        #   only an _:area_ is needed to take as a screenshot. It is possible to specify as many
+        #   options as are needed for searching for the unique window. By default first window with
+        #   matching identifiers will be taken screenshot of. It is possible to use in addition
+        #   to other options a 0-based _:index_ option to search for other windows if multiple
+        #   windows match the specified criteria.
+        # @option opts [String, Regexp] :title Title of the window
+        # @option opts [String, Regexp] :text Visible text of the window
+        # @option opts [String, Regexp] :class Internal class name of the window
+        # @option opts [String, Fixnum] :hwnd Window handle in decimal format
+        # @option opts [String, Fixnum] :pid Window process ID (PID)
+        # @option opts [String, Fixnum] :index 0-based index to specify n-th window to take a screenshot of if
+        #   all other criteria match
+        # @option opts [RAutomation::Window] :rautomation RAutomation::Window object to take a screenshot of. Useful for
+        #   taking screenshots of the child windows
+        # @return [Image] the {Image} of the specified object
+        def of(what, opts = {})
+          valid_whats = [:foreground, :desktop, :window]
+          raise "It is not possible to take a screenshot of '#{what}', possible values are #{valid_whats.join(", ")}" unless valid_whats.include?(what)
+
+          self.send(what, opts)
+        end
+
+        alias_method :new, :of
+
+        private
+
+        def foreground(opts)
+          hwnd = BitmapMaker.foreground_window
+          take_screenshot(hwnd, opts)
+        end
+
+        def desktop(opts)
+          hwnd = BitmapMaker.desktop_window
+          take_screenshot(hwnd, opts)
+        end
+
+        def window(opts)
+          area = {:area => opts.delete(:area)}
+          win = opts[:rautomation] || RAutomation::Window.new(opts)
+          timeout = Time.now + 60
+          until win.active?
+            raise "Failed to set window into focus, unable to take a screenshot!" if Time.now >= timeout
+            win.activate
+          end
+          take_screenshot(win.hwnd, opts.merge(area || {}))
+        end
+
+        def take_screenshot(hwnd, opts)
+          if opts[:area]
+            validate_coordinates(hwnd, *opts[:area])
+            BitmapMaker.capture_area(hwnd, *opts[:area])
+          else
+            BitmapMaker.capture_all(hwnd)
+          end
+        end
+
+        def validate_coordinates(hwnd, x1, y1, x2, y2)
+          specified_coordinates = "x1: #{x1}, y1: #{y1}, x2: #{x2}, y2: #{y2}"
+          if [x1, y1, x2, y2].any? {|c| c < 0}
+            raise "specified coordinates (#{specified_coordinates}) are invalid - cannot be negative!"
+          end
+
+          if x1 >= x2 || y1 >= y2
+            raise "specified coordinates (#{specified_coordinates}) are invalid - cannot be x1 >= x2 or y1 >= y2!"
+          end
+
+          max_width, max_height = BitmapMaker.dimensions_for(hwnd)
+          if x2 > max_width || y2 > max_height
+            raise "specified coordinates (#{specified_coordinates}) are invalid - maximum x2: #{max_width} and y2: #{max_height}!"
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -2,14 +2,10 @@ $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 'rspec'
 require 'fileutils'
 
 module SpecHelper
-  SW_MAXIMIZE = 3
-  SW_MINIMIZE = 6
   HWND_TOPMOST = -1
   HWND_NOTOPMOST = -2
   SWP_NOSIZE = 1
@@ -23,55 +19,16 @@ module SpecHelper
   # 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/)
-      sleep 0.1
-    end
-    wait_for_calculator_to_open
-
-    # just in case of slow PC
-    sleep 8
-  end
-
-  def wait_for_calculator_to_open
-    until Win32::Screenshot::BitmapMaker.hwnd(/Calculator/)
-      sleep 0.1
-    end
-    # just in case of slow PC
-    sleep 2
-  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
+  def save_and_verify_image(img, file=nil)
+    FileUtils.mkdir @temp_dir unless File.exists?(@temp_dir)
+    file_name = File.join @temp_dir, "#{file}.bmp"
+    img.write file_name
+    img.bitmap[0..1].should == 'BM'
   end
 
   def resize title
-    hwnd = Win32::Screenshot::BitmapMaker.hwnd(title)
+    hwnd = RAutomation::Window.new(:title => title).hwnd
     set_window_pos(hwnd,
                    HWND_TOPMOST,
                    0, 0, 150, 238,
@@ -83,3 +40,9 @@ module SpecHelper
     sleep 1
   end
 end
+
+RSpec.configure do |config|
+  config.include(SpecHelper)
+  config.before(:suite) {FileUtils.rm Dir.glob(File.join(File.dirname(__FILE__), "tmp/*"))}
+  config.before(:all) {@temp_dir = File.join(File.dirname(__FILE__), 'tmp')}
+end