sleipnir-api 0.3.0 → 0.4.0

data/lib/sleipnir_api/ffi/kernel32.rb

@@ -0,0 +1,20 @@
+require "sleipnir_api/ffi/base"
+
+module SleipnirAPI::FFI
+  module Kernel32 #:nodoc:
+    extend SleipnirAPI::FFI::Base
+
+    define_ffi_entry(:GetLongPathName, "PPL", "L", "kernel32", "GetLongPathNameA")
+    define_ffi_entry(:RtlZeroMemory, "PL", "L", "kernel32")
+    define_ffi_entry(:GetLastError, "V", "L", "kernel32")
+
+    module_function
+
+    def get_long_path_name(short_path)
+      buf = "\0" * 1024
+      len = GetLongPathName(short_path, buf, buf.length)
+      buf[0...len]
+    end
+
+  end
+end

data/lib/sleipnir_api/ffi/struct.rb

@@ -0,0 +1,246 @@
+require "sleipnir_api/ffi/base"
+
+module SleipnirAPI::FFI
+
+  class Type #:nodoc:
+    attr_reader :name
+    def initialize(name)
+      @name = name
+    end
+  end
+
+  class PrimitiveType < Type #:nodoc:
+    BASE_TYPES = {
+      :int8    => ["c", 1],
+      :uint8   => ["C", 1],
+      :int16   => ["s", 2],
+      :uint16  => ["S", 2],
+      :int32   => ["l", 4],
+      :uint32  => ["L", 4],
+      :float   => ["f", 4],
+      :double  => ["d", 8],
+      :string  => ["p", 4],
+      :pointer => ["P", 4],
+    }
+
+    attr_reader :size, :format
+    def initialize(name, size=guess_size(name), format=guess_format(name))
+      super(name)
+      @size = size
+      @format = format
+    end
+
+    def pack(value)
+      [value].pack(format)
+    end
+
+    def guess_format(name)
+      BASE_TYPES[name][0]
+    end
+    private :guess_format
+
+    def guess_size(name)
+      BASE_TYPES[name][1]
+    end
+    private :guess_size
+  end
+
+  class StructureType < Type #:nodoc:
+    PACKING_ALIGN = 4
+
+    attr_reader :name, :size, :ruby_class, :fields
+    def initialize(name, size=nil)
+      super(name)
+      @ruby_class = nil
+      @fields = []
+      @size = size
+    end
+
+    def calc_offsets
+      offset = 0
+      @fields.each do |f|
+        align = [f.type.size, PACKING_ALIGN].min
+        offset = (offset.to_f / align).ceil * align
+        size = f.size
+        if f.offset.nil?
+          f.offset = offset
+          offset += size
+        else
+          offset = f.offset
+          offset += size
+        end
+      end
+    end
+
+    def calc_size
+      return @size if @size
+      if @fields.empty?
+        @size = 0
+        return
+      end
+      align = [@fields.first.type.size, PACKING_ALIGN].min
+      offset = @fields.last.offset + @fields.last.size
+      @size = (offset.to_f / align).ceil * align
+    end
+
+    def pack(value)
+      packed = @fields.zip(value.values).map{|f,v| [f.offset, f.pack(v)] }
+      r = ""
+      packed.each do |offset,c|
+        align!(r, offset)
+        r << c
+      end
+      align!(r, size)
+      r
+    end
+
+    def align!(r, offset)
+      if offset < r.length
+        raise "buffer over flow: expected offset #{offset}, but was #{r.length}"
+      end
+      if r.length < offset
+        r << "\0" * (offset - r.length)
+      end
+    end
+
+    def define!(ns)
+      calc_offsets
+      calc_size
+      define_ruby_class(ns)
+    end
+
+    def define_ruby_class(ns)
+      types = self
+      name = @name
+      clazz = Class.new
+      clazz.instance_eval {
+        types.fields.each {|f|
+          attr_accessor f.name
+        }
+        define_method(:initialize) {|*args|
+          types.fields.zip(args).each {|f,arg|
+            instance_variable_set(f.var, arg || f.init)
+          }
+        }
+        define_method(:pack) {
+          types.pack(self)
+        }
+      }
+      clazz.class_eval %Q{
+        def names
+          [#{types.fields.map{|f| ":#{f.name}"} * ','}]
+        end
+        def values
+          [#{types.fields.map{|f| f.var} * ','}]
+        end
+      }
+      (class <<clazz; self; end).instance_eval {
+        define_method(:packed_size) {
+          CStruct.sizeof(name)
+        }
+        define_method(:c_type) {
+          CStruct.c_type(name)
+        }
+      }
+      @ruby_class = clazz
+      ns.const_set(@name, clazz)
+    end
+  end
+
+  class Field #:nodoc:
+    attr_reader :type, :name, :count, :var
+    attr_accessor :offset
+    def initialize(type, name, opts=nil)
+      @type = type
+      @name = name
+      @var = "@#{name}".to_sym
+      @opts = opts || {}
+      @offset = @opts[:offset] || nil
+      @count = @opts[:dim] || 1
+    end
+
+    def array?
+      count > 0
+    end
+
+    def init
+      if array?
+        init_one
+      else
+        (0...count).map{ init_one }
+      end
+    end
+
+    def size
+      @type.size * count
+    end
+
+    def pack(value)
+      if count == 1
+        @type.pack(value)
+      else
+        raise "hoge" unless Array === value
+        raise "foo" unless value.length == count
+        value.map{|e| @type.pack(e) }.join
+      end
+    end
+
+    def init_one
+      if PrimitiveType === @type
+        0
+      else
+        @type.ruby_class.new
+      end
+    end
+    private :init_one
+  end
+
+  module CStruct #:nodoc:
+    TYPES = PrimitiveType::BASE_TYPES.inject({}){|h,t|
+      h[t[0]] = PrimitiveType.new(t[0])
+      h
+    }
+
+    def define_c_struct(name, size=nil, &block)
+      define_c_struct_under(self, name, size, &block)
+    end
+
+    module_function
+
+    def define_c_struct_under(ns, name, size=nil, &block)
+      dsl = DSL.new(name, size)
+      dsl.instance_eval(&block)
+      dsl.struct.define!(ns)
+      TYPES[name] = dsl.struct
+      dsl.struct
+    end
+
+    def sizeof(type)
+      c_type(type).size
+    end
+
+    def c_type(type)
+      TYPES[type]
+    end
+
+    def define_c_type(type, decl)
+      TYPES[decl] = TYPES[type]
+    end
+
+    class DSL #:nodoc:
+      attr_reader :struct
+
+      def initialize(name, size)
+        @struct = StructureType.new(name, size)
+      end
+
+      def method_missing(name, *args)
+        type = CStruct.c_type(name)
+        raise "unknown type: #{name}" unless type
+        name = args.shift
+        @struct.fields << Field.new(type, name, *args)
+      end
+    end
+  end
+
+end

data/lib/sleipnir_api/ffi/user32.rb

@@ -0,0 +1,116 @@
+require "sleipnir_api/ffi/base"
+
+module SleipnirAPI::FFI
+  module User32 #:nodoc:
+    extend SleipnirAPI::FFI::Base
+
+    GW_HWNDFIRST               = 0
+    GW_HWNDLAST                = 1
+    GW_HWNDNEXT                = 2
+    GW_HWNDPREV                = 3
+
+    define_ffi_entry(:GetWindowThreadProcessId, "LP", "L", "user32")
+    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_window_thread_process_id(hwnd)
+      n = "\0" * 4
+      th = GetWindowThreadProcessId.call(hwnd, n)
+      return [th, n.unpack("L")[0]]
+    end
+
+    def get_window_thread_id(hwnd)
+      get_window_thread_process_id(hwnd)[0]
+    end
+
+    def get_window_process_id(hwnd)
+      get_window_thread_process_id(hwnd)[1]
+    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
+
+    def list_window(hwnd)
+      r = [hwnd]
+      each_child_window(hwnd) {|child|
+        r << list_window(child)
+      }
+      r
+    end
+
+  end
+end

data/lib/sleipnir_api/process.rb

@@ -6,8 +6,9 @@ require "sleipnir_api/registry"
 module SleipnirAPI
   class Process # :nodoc:
     class <<self
-
       include SleipnirAPI::Registry
+      include SleipnirAPI::FFI::User32
+      include SleipnirAPI::FFI::Kernel32
 
       @@wbem = nil
 
@@ -37,13 +38,15 @@ module SleipnirAPI
       end
 
       def raise_create_error(msg)
-        raise Sleipnir::ProcessError, "Failed to create Sleipnir process: #{msg}."
+        raise SleipnirAPI::ProcessError, "Failed to create Sleipnir process: #{msg}."
       end
 
       def terminate!(handle)
+        proc_id = get_window_process_id(handle)
         query_sleipnir.each do |obj|
-          obj.Terminate
+          return obj.Terminate if obj.ProcessId == proc_id
         end
+        nil
       end
 
       def query_sleipnir

data/lib/sleipnir_api/profile.rb

@@ -68,7 +68,10 @@ module SleipnirAPI
     include DataUtil
 
     # SleipnirAPI::Sleipnir object
-    attr_reader :sleipnir, :default_opts
+    attr_reader :sleipnir
+
+    # default options
+    attr_reader :default_opts
 
     def initialize(sleipnir, default_opts = nil)
       @sleipnir = sleipnir
@@ -262,7 +265,7 @@ module SleipnirAPI
       expand_user_path("script.ini")
     end
 
-    # 指定された ini ファイルを操作する Sleipnir::Profile::Ini オブジェクトを返します。
+    # 指定された ini ファイルを操作する SleipnirAPI::Profile::Ini オブジェクトを返します。
     #
     #   pnir = SleipnirAPI.connect
     #   proxy = pnir.profile.ini("Proxy.ini", :default => 123)
@@ -273,7 +276,7 @@ module SleipnirAPI
       Ini.new(self, str(name), options(opts))
     end
 
-    # メソッド名を ini ファイル名とみなして Sleipnir::Profile::Ini オブジェクトを返します。
+    # メソッド名を ini ファイル名とみなして SleipnirAPI::Profile::Ini オブジェクトを返します。
     #
     #   pnir = SleipnirAPI.connect
     #   proxy = pnir.profile.Proxy(:default => 123)

data/lib/sleipnir_api/profile/ini.rb

@@ -147,7 +147,7 @@ module SleipnirAPI
         not script_ini?
       end
 
-      # 指定されたセクションを操作する Sleipnir::Profile::Section オブジェクトを返します。
+      # 指定されたセクションを操作する SleipnirAPI::Profile::Section オブジェクトを返します。
       #
       #   pnir = SleipnirAPI.connect
       #   proxy = pnir.profile.ini("Proxy.ini", :default => 123)
@@ -159,7 +159,7 @@ module SleipnirAPI
         Section.new(self, str(name), options(opts))
       end
 
-      # メソッド名をセクション名とみなして Sleipnir::Profile::Section オブジェクトを返します。
+      # メソッド名をセクション名とみなして SleipnirAPI::Profile::Section オブジェクトを返します。
       #
       #   pnir = SleipnirAPI.connect
       #   proxy = pnir.profile.Proxy(:default => 123)