jruby-win32ole 0.8.0

data/lib/win32ole/win32ole_event.rb

@@ -0,0 +1,38 @@
+class WIN32OLE_EVENT
+  def initialize(ole, event_name=nil)
+    @event_handlers = {}
+
+    raise TypeError.new("1st parameter must be WIN32OLE object") if !ole.kind_of? WIN32OLE
+
+    if event_name.nil? # Default event name
+      # TODO: get default event
+    end
+
+    dispatch = ole.dispatch
+    DispatchEvents.new dispatch, RubyInvocationProxy.new(self), dispatch.program_id
+  end
+
+  def on_event(name=nil, &block)
+    if name
+      @event_handlers[name.to_s] = block
+    else
+      @default_handler = block
+    end
+  end
+
+  def method_missing(name, *args)
+    name = name.to_s
+    handler = @event_handlers[name]
+    if handler
+      handler.call *args
+    elsif @default_handler
+      @default_handler.call name, *args
+    end
+  end
+
+  # Almost noop this.  We don't because it get CPU hot when people put this
+  # in a hot loop!
+  def self.message_loop
+    DispatchEvents.message_loop
+  end
+end

data/lib/win32ole/win32ole_method.rb

@@ -0,0 +1,135 @@
+class WIN32OLE_METHOD
+  attr_accessor :oletype, :typeinfo
+
+  def initialize(*args)
+    # TODO: 2-arg missing currently unuised oletype ivar
+    if args.length == 6 # Internal initializer
+      @oletype,  @typeinfo, @owner_typeinfo, @desc, @docs, @index = *args
+    elsif args.length == 2 # Normal constructor
+      @oletype, name = WIN32OLE_TYPEValue(args[0]), SafeStringValue(args[1])
+      all_methods(@oletype.typeinfo) do |ti, oti, desc, docs, index|
+        if docs.name.downcase == name.downcase
+          @typeinfo, @owner_typeinfo, @desc, @docs, @index = ti, oti, desc, docs, index
+          break;
+        end
+      end
+      raise WIN32OLERuntimeError.new "not found: #{name}" if !@typeinfo
+    else # Error
+      raise ArgumentError.new("2 for #{args.length}")
+    end
+  end
+
+  def dispid
+    @desc.memid
+  end
+
+  def event?
+    return false if @owner_typeinfo.typekind != TypeInfo::TYPEKIND_COCLASS
+
+    @owner_typeinfo.impl_types_count.times do |i|
+      begin
+        flags = @owner_typeinfo.get_impl_type_flags(i)
+
+        if flags & TypeInfo::IMPLTYPEFLAG_FSOURCE
+          href = @owner_typeinfo.get_ref_type_of_impl_type(i)
+          ref_typeinfo = @owner_typeinfo.get_ref_type_info(href)
+          func_desc = ref_typeinfo.func_desc(@index)
+          documentation = ref_typeinfo.documentation(func_desc.memid)
+
+          return true if documentation.name == name
+        end
+      rescue ComFailException => e
+      end
+    end
+    false
+  end
+
+  def event_interface
+    return nil unless event?
+
+    typelib = @typeinfo.containing_type_lib
+    documentation = typelib.documentation(typelib.index)
+    documentation.name
+  end
+
+  def helpcontext
+    @docs.help_context
+  end
+
+  def helpstring
+    @docs.doc_string
+  end
+
+  def helpfile
+    @docs.help_file
+  end
+
+  def invkind
+    @desc.invkind
+  end
+
+  def invoke_kind
+    invkind = @desc.invkind
+    if invkind & Dispatch::Get && invkind & Dispatch::Put
+      return "PROPERTY"
+    elsif invkind & Dispatch::Get
+      return "PROPERTYGET"
+    elsif invkind & Dispatch::Put
+      return "PROPERTYPUT"
+    elsif invkind & Dispatch::PutRef
+      return "PROPERTYPUTREF"
+    elsif invkind & Dispatch::Method
+      return "FUNC"
+    else
+      return "UNKOWN"
+    end
+  end
+
+  def name
+    @docs.name
+  end
+  alias :to_s :name
+
+  def offset_vtbl
+    @desc.vtable_offset
+  end
+
+  def params
+    arr = []
+    @desc.parameters.to_a.each_with_index do |param, i|
+      arr << WIN32OLE_PARAM.new(self, i, param)
+    end
+    arr
+  end
+
+  def return_type
+    typedesc_value(@desc.return_type.vt)
+  end
+
+  def return_type_detail
+    typedesc_value(@desc.return_type.vt, [])
+  end
+
+  def return_vtype
+    @desc.return_type.vt
+  end
+
+  def size_opt_params
+    @desc.opt_params_count
+  end
+  
+  def size_params
+    @desc.params_count
+  end
+
+  def visible?
+    (@desc.flags & (FuncDesc::FUNCFLAG_FRESTRICTED | FuncDesc::FUNCFLAG_FHIDDEN |
+      FuncDesc::FUNCFLAG_FNONBROWSABLE)) == 0
+  end
+
+  def inspect
+    name
+  end
+
+  include WIN32OLE::Utils
+end

data/lib/win32ole/win32ole_param.rb

@@ -0,0 +1,45 @@
+class WIN32OLE_PARAM
+  attr_accessor :name
+  
+  def initialize(method, index, param_info=nil)
+    raise TypeError.new("1st parameter must be WIN32OLE object") if !method.kind_of? WIN32OLE_METHOD
+
+    @method, @index, @param = method, index, param_info
+  end
+
+  def default
+    @param.is_default_value ? RubyWIN32OLE.from_variant(JRuby.runtime, @param.get_default_value) : nil
+  end
+
+  def input?
+    @param.is_in
+  end
+
+  def name
+    @param.name
+  end
+  alias :to_s :name
+  alias :inspect :name
+
+  def ole_type
+    typedesc_value(@param.vt)
+  end
+
+  def ole_type_detail
+    typedesc_value(@param.vt, [])
+  end
+
+  def output?
+    @param.is_out
+  end
+
+  def optional?
+    @param.is_optional
+  end
+
+  def retval?
+    @param.is_return_value
+  end
+
+  include WIN32OLE::Utils
+end

data/lib/win32ole/win32ole_ruby.rb

@@ -0,0 +1,115 @@
+require 'win32ole/utils'
+require 'jruby'
+
+# Shorthand vocabulary:
+#  ti, oti - typeinfo or owner_typeinfo
+
+class WIN32OLE
+  CP_ACP = 0
+  CP_OEMCP = 1
+  CP_MACCP = 2
+  CP_THREAD_ACP = 3
+  CP_SYMBOL = 42
+  CP_UTF7 = 65000
+  CP_UTF8 = 65001
+
+  def ole_method(name)
+    all_methods(typeinfo_from_ole) do |*args|
+      return WIN32OLE_METHOD.new(nil, *args) if name == args[3].name
+      nil
+    end
+  end
+  alias :ole_method_help :ole_method
+
+  def ole_methods
+    members = []
+    all_methods(typeinfo_from_ole) do |*args|
+      members << WIN32OLE_METHOD.new(nil, *args)
+      nil
+    end
+    members
+  end
+
+  def ole_func_methods
+    methods_with_flag(Dispatch::Method)
+  end
+
+  def ole_get_methods
+    methods_with_flag(Dispatch::Get)
+  end
+
+  def ole_put_methods
+    methods_with_flag(Dispatch::Put|Dispatch::PutRef)
+  end
+
+  def ole_type
+    typelib = type_info.containing_type_lib
+    docs = typelib.documentation(typelib.index)
+    WIN32OLE_TYPE.new typelib, type_info, docs
+  end
+  alias :ole_obj_help :ole_type
+
+  def ole_typelib
+    typelib = type_info.containing_type_lib
+    WIN32OLE_TYPELIB.new typelib, nil
+  end
+
+  def type_info
+    dispatch.type_info
+  end
+
+  class << self
+    def codepage
+      @@codepage ||= CP_ACP
+    end
+
+    def codepage=(new_codepage)
+      @@codepage = new_codepage
+    end
+
+    def connect(id)
+      WIN32OLE.new to_progid(id)
+    end
+
+    def const_load(ole, a_class=WIN32OLE)
+      constants = {}
+      ole.type_info.containing_type_lib.type_info.to_a.each do |info|
+        info.vars_count.times do |i|
+          var_desc = info.get_var_desc(i)
+          # TODO: Missing some additional flag checks to limit no. of constants
+          if var_desc.constant
+            name = first_var_name(info, var_desc)
+            name = name[0].chr.upcase + name[1..-1] if name
+            if constant?(name)
+              a_class.const_set name, RubyWIN32OLE.from_variant(JRuby.runtime, var_desc.constant)
+            else # vars which don't start [A-Z]?
+              constants[name] = var_desc.constant
+            end
+          end
+        end
+      end
+      a_class.const_set 'CONSTANTS', constants
+      nil
+    end
+
+    def to_progid(id)
+      id =~ /^{(.*)}/ ? "clsid:#{$1}" : id
+    end
+
+    private
+
+    def constant?(name)
+      name =~ /^[A-Z]/
+    end
+
+    def first_var_name(type_info, var_desc)
+      type_info.get_names(var_desc.memid)[0]
+    rescue
+      nil
+    end
+  end
+
+  private
+
+  include WIN32OLE::Utils
+end

data/lib/win32ole/win32ole_type.rb

@@ -0,0 +1,148 @@
+class WIN32OLE_TYPE
+  attr_reader :typeinfo
+
+  def initialize(*args)
+    case args.length
+    when 2 then 
+      typelib_name, olename = SafeStringValue(args[0]), SafeStringValue(args[1])
+      @typelib = WIN32OLE_TYPELIB.new(typelib_name) # Internal call
+      find_all_typeinfo(@typelib.typelib) do |info, docs|
+        if (docs.name == olename)
+          @typeinfo, @docs = info, docs
+          break
+        end
+      end
+      raise WIN32OLERuntimeError.new("not found `#{olename}` in `#{typelib_name}") unless @typeinfo
+    when 3 then
+      @typelib, @typeinfo, @docs = *args
+    else
+      raise ArgumentError.new("wrong number of arguments (#{args.length} for 2)")
+    end
+  end
+
+  def guid
+    @typeinfo.guid
+  end
+
+  def helpcontext
+    @docs.help_context
+  end
+
+  def helpstring
+    @docs.doc_string
+  end
+
+  def helpfile
+    @docs.help_file
+  end
+
+  def name
+    @docs.name
+  end
+
+  def major_version
+    @typeinfo.major_version
+  end
+
+  def minor_version
+    @typeinfo.minor_version
+  end
+
+  def ole_methods
+    members = []
+    all_methods(@typeinfo) do |ti, oti, desc, docs, index|
+      members << WIN32OLE_METHOD.new(self, ti, oti, desc, docs, index)
+      nil
+    end
+    members
+  end
+
+  def ole_type
+    case typekind
+    when TypeInfo::TYPEKIND_ENUM then
+      "Enum"
+    when TypeInfo::TYPEKIND_RECORD then
+      "Record"
+    when TypeInfo::TYPEKIND_MODULE then
+      "Module"
+    when TypeInfo::TYPEKIND_INTERFACE then
+      "Interface"
+    when TypeInfo::TYPEKIND_DISPATCH then
+      "Dispatch"
+    when TypeInfo::TYPEKIND_COCLASS then
+      "Class"
+    when TypeInfo::TYPEKIND_ALIAS then
+      "Alias"
+    when TypeInfo::TYPEKIND_UNION then
+      "Union"
+    when TypeInfo::TYPEKIND_MAX then
+      "Max"
+    else
+      nil
+    end
+  end
+
+  def progid
+    @typeinfo.progid
+  end
+
+  def src_type
+    return nil if @typeinfo.typekind != TypeInfo::TYPEKIND_ALIAS
+
+    typedesc_value @typeinfo.alias_vt
+  end
+
+  def to_s
+    name
+  end
+  
+  def variables
+    variables = []
+    all_vars(@typeinfo) do |desc, name|
+      variables << WIN32OLE_VARIABLE.new(self, desc, name)
+    end
+    variables
+  end
+
+  def visible?
+    @typeinfo.flags & (TypeInfo::TYPEFLAG_FHIDDEN | TypeInfo::TYPEFLAG_FRESTRICTED) == 0
+  end
+
+  def typekind
+    @typeinfo.typekind
+  end
+
+  class << self
+    # This is obsolete, but easy to emulate
+    def typelibs
+      WIN32OLE_TYPELIB.typelibs.collect {|t| t.name }
+    end
+
+    def progids
+      array = []
+      Win32::Registry::HKEY_CLASSES_ROOT.open('CLSID') do |reg|
+        reg.each_key do |clsid, wtime|
+          reg.open(clsid) do |clsid_reg|
+            clsid_reg.each_key do |key, wtime|
+              name = nil
+              if key == "ProgID"
+                clsid_reg.open(key) {|key_reg| name = key_reg.read(nil)[1] }
+              end
+              if !name && key == "VersionIndependentProgID"
+                clsid_reg.open(key) {|key_reg| name = key_reg.read(nil)[1] }
+              end
+              array << name if name
+            end
+          end
+        end
+      end
+      array
+    end
+
+    def ole_classes(tlib)
+      WIN32OLE_TYPELIB.ole_classes(tlib)
+    end
+  end
+
+  include WIN32OLE::Utils
+end