sensible-cinema 0.28.0 → 0.28.1

data/vendor/rdp-win32screenshot-0.0.9/lib/enumerate.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require './lib/win32/screenshot'
+require 'pp'
+sleep 3
+p 'enumerating'
+pp Win32::Screenshot::Util.windows_hierarchy true

data/vendor/rdp-win32screenshot-0.0.9/lib/notes

@@ -0,0 +1,5 @@
+without aero
+Win32::Screenshot.window( /virtual/i, 0) {|h,w,bits| File.binwrite('1' +name, bits)}
+  was "cropped" and probably had to come to the front, but was full.
+  
+with aero, it didn't show everything [!] so I guess it's really just grabbing that window via hwnd.

data/vendor/rdp-win32screenshot-0.0.9/lib/snapshot.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require './win32/screenshot'
+require 'sane'
+#sleep 2
+p 'taking it'
+#p Win32::Screenshot::BitmapMaker.hwnd(/virtual/i).to_s(16)
+name = ARGV[0] || 'out.bmp'
+Win32::Screenshot::BitmapMaker.capture_area( Win32::Screenshot::BitmapMaker.hwnd(/virtual/i), 0,0,1000,1000) {|h,w,bits| File.binwrite(name, bits)}
+Win32::Screenshot.window( /virtual/i, 0) {|h,w,bits| File.binwrite('1' +name, bits)}
+p name

data/vendor/rdp-win32screenshot-0.0.9/lib/win32/screenshot.rb

@@ -0,0 +1,95 @@
+require File.dirname(__FILE__) + '/screenshot/bitmap_maker'
+require File.dirname(__FILE__) + '/util'
+
+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 = Util.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 = Util.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 validate_coordinates(hwnd, *coords)
+        specified_coordinates = coords.join(', ')
+        if coords.any? {|c| c < 0}
+          raise "specified coordinates (#{specified_coordinates}) are invalid - cannot be negative!"
+        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
+
+        max_width, max_height = Util.dimensions_for(hwnd)
+        if x2 > max_width || y2 > max_height
+          raise "specified coordinates (#{specified_coordinates}) are invalid - maximum are x2=#{max_width} and y2=#{max_height}!"
+        end
+      end
+    end
+
+  end
+end

data/vendor/rdp-win32screenshot-0.0.9/lib/win32/screenshot/bitmap_maker.rb

@@ -0,0 +1,200 @@
+require 'ffi'
+
+module Win32
+  class Screenshot
+    # internal methods
+    class BitmapMaker #:nodoc:all
+      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
+        attach_function :GetWindowThreadProcessId, [:ulong, :pointer], 
+                        :uint
+
+        # 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 = 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)
+          GetWindowThreadProcessId(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)
+        end
+
+        SRCCOPY = 0x00CC0020
+        CAPTUREBLT = 0x40000000 #0x40000000
+        DIB_RGB_COLORS = 0
+
+        def capture_area(hwnd, x1, y1, x2, y2) # block
+          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)
+        #  p (SRCCOPY|CAPTUREBLT).to_s(16), 'hello'
+          bit_blt(hmemDC, 0, 0, w, h, hScreenDC, x1, y1, SRCCOPY)
+          bitmap_size = w * h * 3 + w % 4 * h # assumes 24 bit, funky math LOL
+          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) # converts to 24 bit here...
+
+          bmFileHeader = [
+                  19778,
+                  bitmap_size + 40 + 14,
+                  0,
+                  0,
+                  54
+          ].pack('SLSSL')
+p 'header length', bmFileHeader.size, 'info length', bmInfo.size, 'data length', lpvpxldata.read_string(bitmap_size).length
+          bmp_data = bmFileHeader + bmInfo + lpvpxldata.read_string(bitmap_size)
+          p 'total', bmp_data.size
+          yield(w, h, bmp_data)
+        ensure
+          lpvpxldata.free
+          delete_object(hmemBM)
+          delete_dc(hmemDC)
+          release_dc(0, hScreenDC)
+        end
+      end
+    end
+  end
+end

data/vendor/rdp-win32screenshot-0.0.9/lib/win32/util.rb

@@ -0,0 +1,93 @@
+module Win32
+  class Screenshot
+    class Util
+      class << self
+
+        def all_desktop_windows
+          titles = []
+          window_callback = FFI::Function.new(:bool, [ :long, :pointer ], { :convention => :stdcall }) do |hwnd, param|
+            titles << [window_title(hwnd), hwnd]
+            true
+          end
+
+          BitmapMaker.enum_windows(window_callback, nil)
+          titles
+        end
+        
+        # just returns a long list of hwnd's...
+        # unless with_info is true
+        # then it will return all hwnds with full info about each window
+        def windows_hierarchy with_info = false          
+          all = {}
+          desktop_hwnd = BitmapMaker.desktop_window
+          root = {:hwnd => desktop_hwnd, :children => []}
+          root.merge!(get_info(desktop_hwnd)) if with_info
+          parents = []
+          parents << root
+          window_callback = FFI::Function.new(:bool, [ :long, :pointer ], { :convention => :stdcall }) do |hwnd, param|
+            # this is a child of the most recent parent
+            myself = {:hwnd => hwnd, :children => []}
+            myself.merge!(get_info(hwnd)) if with_info
+            parents[-1][:children] << myself
+            parents << myself
+            if !all[hwnd]
+              all[hwnd] = true
+              BitmapMaker.enum_child_windows(hwnd, window_callback, nil)
+            end
+            
+            parents.pop
+            true
+          end
+          BitmapMaker.enum_child_windows(desktop_hwnd, window_callback, nil)
+          root
+        end
+        
+        def get_info hwnd
+          {:title => window_title(hwnd), 
+          :class => window_class(hwnd), 
+          :dimensions => dimensions_for(hwnd), 
+          :starting_coordinates => location_of(hwnd)
+          }
+        end  
+        
+        def window_title hwnd
+          title_length = BitmapMaker.window_text_length(hwnd) + 1
+          title = FFI::MemoryPointer.new :char, title_length
+          BitmapMaker.window_text(hwnd, title, title_length)
+          title.read_string
+        end
+        
+        def window_class hwnd
+          title = FFI::MemoryPointer.new :char, 100
+          BitmapMaker.class_name(hwnd, title, 99)
+          title.read_string
+        end
+
+        def window_hwnd(title_query)
+          hwnd = BitmapMaker.hwnd(title_query)
+          raise "window with title '#{title_query}' was not found!" unless hwnd
+          hwnd
+        end
+        
+        def location_of(hwnd)
+          rect = [0, 0, 0, 0].pack('L4')
+          BitmapMaker.window_rect(hwnd, rect)
+          x, y, width, height = rect.unpack('L4')
+          return x, y
+        end
+
+        def dimensions_for(hwnd)
+          rect = [0, 0, 0, 0].pack('L4')
+          BitmapMaker.client_rect(hwnd, rect)
+          _, _, width, height = rect.unpack('L4')
+          return width, height
+        end
+        
+        def window_process_id(hwnd)
+          BitmapMaker.get_process_id_from_hwnd(hwnd)
+        end
+
+      end
+    end
+  end
+end

data/vendor/rdp-win32screenshot-0.0.9/spec/spec.opts

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

data/vendor/rdp-win32screenshot-0.0.9/spec/spec_helper.rb

@@ -0,0 +1,85 @@
+$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/)
+      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
+  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