Class: WIN32OLE_TYPELIB

Inherits:

Object

• Object
• WIN32OLE_TYPELIB

Defined in:

lib/win32ole-pr.rb

Direct Known Subclasses

P2::Library

Class Method Summary

• .make_version_str(major, minor) ⇒ Object
• .oletypelib_search_registry(obj, typelib) ⇒ Object
• .oletypelib_search_registry2(obj, args) ⇒ Object
• .reg_enum_key(hkey, i) ⇒ Object
• .reg_get_typelib_file_path(hkey) ⇒ Object
• .reg_get_val(hkey, subkey) ⇒ Object
• .reg_get_val2(hkey, subkey) ⇒ Object
• .reg_open_key(hkey, name, phkey) ⇒ Object
• .reg_open_vkey(hkey, key, phkey) ⇒ Object
• .typelib_file(ole) ⇒ Object
• .typelib_file_from_clsid(ole) ⇒ Object
• .typelib_file_from_typelib(ole) ⇒ Object
• .typelibs ⇒ Object

Instance Method Summary

• #guid ⇒ Object
• #initialize(*args) ⇒ WIN32OLE_TYPELIB constructor

  A new instance of WIN32OLE_TYPELIB.

• #inspect ⇒ Object
• #library_name ⇒ Object
• #major_version ⇒ Object
• #minor_version ⇒ Object
• #name ⇒ Object (also: #to_s)
• #ole_types ⇒ Object (also: #ole_classes)
• #oletypelib2itypelib(pptl) ⇒ Object
• #oletypelib_path(guid, version) ⇒ Object
• #oletypelib_set_member(name, guid, version) ⇒ Object
• #path ⇒ Object
• #version ⇒ Object
• #visible? ⇒ Boolean

Constructor Details

#initialize(*args) ⇒ WIN32OLE_TYPELIB

Returns a new instance of WIN32OLE_TYPELIB.

# File 'lib/win32ole-pr.rb', line 2641

def initialize(*args)
  WIN32OLE.ole_initialize()
  @pTypeInfo = nil
  typelib = args[0]
  if args.length>0
    if !typelib.is_a?(String)
      raise TypeError, "typelib is wrong type (expected String)"
    end

    found = WIN32OLE_TYPELIB.oletypelib_search_registry(self, typelib)
    if !found
      found = WIN32OLE_TYPELIB.oletypelib_search_registry2(self, args)
    end
    if !found
      buf = multi_to_wide(typelib)
      p = 0.chr * 4
      hr = LoadTypeLibEx(buf, REGKIND_NONE, p)
      if hr == S_OK
        pTypeLib = p.unpack('L').first
        retval = WIN32OLE.ole_typelib_from_itypelib(pTypeLib)
        WIN32OLE.ole_release(pTypeLib)
        if retval
          found = true
          oletypelib_set_member(retval.name, retval.guid, retval.version)
        end
      end
    end

    if !found
      raise WIN32OLERuntimeError, "not found type library `#{typelib}`"
    end
  end
  self
end

Class Method Details

.make_version_str(major, minor) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2507

def self.make_version_str(major, minor)
  return nil if major.nil?
  version = major.dup
  if minor
    version << '.' + minor
  end
  version
end

.oletypelib_search_registry(obj, typelib) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2577

def self.oletypelib_search_registry(obj, typelib)
  found = false
  htypelib = 0.chr * 4
  err = reg_open_key(HKEY_CLASSES_ROOT, "TypeLib", htypelib)
  if err != ERROR_SUCCESS
    return false
  end
  i = 0
  htypelib = htypelib.unpack('L').first
  while !found
    guid = reg_enum_key(htypelib, i)
    break if guid.nil?
    hguid = 0.chr * 4
    err = reg_open_vkey(htypelib, guid, hguid)
    if (err != ERROR_SUCCESS)
      i += 1
      next
    end
    j = 0
    hguid = hguid.unpack('L').first
    while !found
      ver = reg_enum_key(hguid, j)
      break if ver.nil?
      hversion = 0.chr * 4
      err = reg_open_vkey(hguid, ver, hversion)
      if err != ERROR_SUCCESS
        j += 1
        next
      end
      hversion = hversion.unpack('L').first
      tlib = reg_get_val(hversion, nil)
      if tlib.nil?
        RegCloseKey(hversion)
        j += 1
        next
      end
      if typelib == tlib
        obj.oletypelib_set_member(typelib, guid, ver)
        found = true
      end
      RegCloseKey(hversion)
      j += 1
    end
    RegCloseKey(hguid)
    i += 1
  end
  RegCloseKey(htypelib)
  found
end

.oletypelib_search_registry2(obj, args) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2516

def self.oletypelib_search_registry2(obj, args)
  found = false
  guid = args[0]

  version = make_version_str(args[1], args[2])

  htypelib = 0.chr * 4
  err = reg_open_key(HKEY_CLASSES_ROOT, "TypeLib", htypelib)
  return false if err != ERROR_SUCCESS
  hguid = 0.chr * 4
  err = reg_open_vkey(htypelib, guid, hguid)
  if err != ERROR_SUCCESS
    RegCloseKey(htypelib)
    return false
  end
  if version
    hversion = 0.chr * 4
    err = reg_open_vkey(hguid, version_str, hversion)
    if err == ERROR_SUCCESS
      tlib = reg_get_val(hversion, nil)
      if tlib
        typelib = tlib
      end
    end
    RegCloseKey(hversion)
  else
    fver = 0.0;
    j = 0
    while true
      ver = reg_enum_key(hguid, j)
      break if ver.nil?
      hversion = 0.chr * 4
      err = reg_open_vkey(hguid, ver, hversion)
      if err != ERROR_SUCCESS
        j += 1
        next
      end
      tlib = reg_get_val(hversion, nil)
      if tlib.nil?
        RegCloseKey(hversion)
        j += 1
        next
      end
      if fver < ver.to_f
        fver = ver.to_f
        version = ver.dup
        typelib = tlib.dup
      end
      RegCloseKey(hversion)
      j += 1
    end
  end
  RegCloseKey(hguid)
  RegCloseKey(htypelib)
  if typelib
    found = true
    obj.oletypelib_set_member(typelib, guid, version)
  end
  found
end

.reg_enum_key(hkey, i) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2335

def self.reg_enum_key(hkey, i)
  buf = 0.chr * 256
  size_buf = [256].pack('L')
  err = RegEnumKeyEx(hkey, i, buf, size_buf, nil, nil, nil, nil)
  if (err == ERROR_SUCCESS)
    return buf.strip
  end
  nil
end

.reg_get_typelib_file_path(hkey) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2627

def self.reg_get_typelib_file_path(hkey)
  path = reg_get_val2(hkey, "win32")
  if path.nil?
    path = reg_get_val2(hkey, "win16")
  end
  path
end

.reg_get_val(hkey, subkey) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2345

def self.reg_get_val(hkey, subkey)
  dwtype = 0.chr * 4
  size = 0.chr * 4
  val = nil
  err = RegQueryValueEx(hkey, subkey, nil, dwtype, nil, size)
  if (err == ERROR_SUCCESS)
    pbuf = 0.chr * (size.unpack('L').first + 1)
    err = RegQueryValueEx(hkey, subkey, nil, dwtype, pbuf, size)
    if (err == ERROR_SUCCESS)
      val = pbuf.strip
    end
  end
  val
end

.reg_get_val2(hkey, subkey) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2360

def self.reg_get_val2(hkey, subkey)
  val = nil
  hsubkey = 0.chr * 4
  err = RegOpenKeyEx(hkey, subkey, 0, KEY_READ, hsubkey)
  if (err == ERROR_SUCCESS)
    hsubkey = hsubkey.unpack('L').first
    val = reg_get_val(hsubkey, nil)
    RegCloseKey(hsubkey)
  end
  if val.nil?
    val = reg_get_val(hkey, subkey)
  end
  val
end

.reg_open_key(hkey, name, phkey) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2327

def self.reg_open_key(hkey, name, phkey)
  RegOpenKeyEx(hkey, name, 0, KEY_READ, phkey)
end

.reg_open_vkey(hkey, key, phkey) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2331

def self.reg_open_vkey(hkey, key, phkey)
  reg_open_key(hkey, key, phkey)
end

.typelib_file(ole) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2501

def self.typelib_file(ole)
  file = typelib_file_from_clsid(ole)
  return file if file
  typelib_file_from_typelib(ole)
end

.typelib_file_from_clsid(ole) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2413

def self.typelib_file_from_clsid(ole)
  path = 0.chr * 256
  hroot = 0.chr * 4
  err = reg_open_key(HKEY_CLASSES_ROOT, "CLSID", hroot)
  if err != ERROR_SUCCESS
    return nil
  end
  hclsid = 0.chr * 4
  hroot = hroot.unpack('L').first
  err = reg_open_key(hroot, ole, hclsid)
  if err != ERROR_SUCCESS
    RegCloseKey(hroot)
    return nil
  end
  typelib = reg_get_val2(hclsid, "InprocServer32")
  RegCloseKey(hroot)
  RegCloseKey(hclsid)
  if typelib
    ExpandEnvironmentStrings(typelib, path, 256)
    typelib = path.strip
  end
  typelib
end

.typelib_file_from_typelib(ole) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2437

def self.typelib_file_from_typelib(ole)
  found = false
  htypelib = 0.chr * 4
  err = reg_open_key(HKEY_CLASSES_ROOT, "TypeLib", htypelib)
  if err != ERROR_SUCCESS
    return nil
  end
  htypelib = htypelib.unpack('L').first
  i = 0
  while !found
    clsid = reg_enum_key(htypelib, i)
    break if clsid.nil?
    hclsid = 0.chr * 4
    err = reg_open_vkey(htypelib, clsid, hclsid)
    if err != ERROR_SUCCESS
      i += 1
      next
    end
    hclsid = hclsid.unpack('L').first
    fver = 0
    j = 0
    while !found
      ver = reg_enum_key(hclsid, j)
      break if ver.nil?
      hversion = 0.chr * 4
      err = reg_open_vkey(hclsid, ver, hversion)
      if err != ERROR_SUCCESS || fver > ver.to_f
        j += 1
        next
      end
      hversion = hversion.unpack('L').first
      fver = ver.to_f
      typelib = reg_get_val(hversion, nil)
      if typelib.nil?
        j += 1
        next
      end
      if typelib == ole
        k = 0
        while !found
          lang = reg_enum_key(hversion, k)
          break if lang.nil?
          hlang = 0.chr * 4
          err = reg_open_vkey(hversion, lang, hlang)
          if err == ERROR_SUCCESS
            hlang = hlang.unpack('L').first
            if (file = reg_get_typelib_file_path(hlang))
              found = true
            end
            RegCloseKey(hlang)
          end
          k += 1
        end
      end
      RegCloseKey(hversion)
      j += 1
    end
    RegCloseKey(hclsid)
    i += 1
  end
  RegCloseKey(htypelib)
  file
end

.typelibs ⇒ Object

# File 'lib/win32ole-pr.rb', line 2375

def self.typelibs
  typelibs = []
  typelib = nil
  htypelib = [0].pack('L')
  err = reg_open_key(HKEY_CLASSES_ROOT, "TypeLib", htypelib)
  return typelibs if err != ERROR_SUCCESS
  i = 0
  htypelib = htypelib.unpack('L').first
  while true
    guid = reg_enum_key(htypelib, i)
    break if guid.nil?
    hguid = 0.chr * 4
    err = reg_open_vkey(htypelib, guid, hguid)
    if err != ERROR_SUCCESS
      i += 1
      next
    end
    j = 0
    hguid = hguid.unpack('L').first
    while true
      version = reg_enum_key(hguid, j)
      break if version.nil?

      if (name = reg_get_val2(hguid, version))
        typelib = WIN32OLE_TYPELIB.new
        typelib.oletypelib_set_member(name, guid, version)
        typelibs.push(typelib)
      end

      j += 1
    end
    RegCloseKey(hguid)
    i += 1
  end
  RegCloseKey(htypelib)
  typelibs
end

Instance Method Details

#guid ⇒ Object

# File 'lib/win32ole-pr.rb', line 2676

def guid
  @guid
end

#inspect ⇒ Object

# File 'lib/win32ole-pr.rb', line 2805

def inspect
  "#<#{self.class}:#{self.to_s}>"
end

#library_name ⇒ Object

# File 'lib/win32ole-pr.rb', line 2781

def library_name
  p = 0.chr * 4
  oletypelib2itypelib(p)
  pTypeLib = p.unpack('L').first
  lpVtbl = 0.chr * 4
  table = 0.chr * 40
  memcpy(lpVtbl, pTypeLib, 4)
  memcpy(table, lpVtbl.unpack('L').first, 40)
  table = table.unpack('L*')
  getTypeInfoCount = Win32::API::Function.new(table[3], 'P', 'L')
  getTypeInfo = Win32::API::Function.new(table[4], 'PLP', 'L')
  getDocumentation = Win32::API::Function.new(table[9], 'PLPPPP', 'L')
  bstr = 0.chr * 4
  getDocumentation.call(pTypeLib, -1, bstr, nil, nil, nil)
  if hr != S_OK
    WIN32OLE.ole_release(pTypeLib)
    raise WIN32OLERuntimeError, "failed to get library name"
  end
  WIN32OLE.ole_release(pTypeLib)
  str = 0.chr * 256
  wcscpy(str, bstr.unpack('L').first)
  wide_to_multi(str)
end

#major_version ⇒ Object

# File 'lib/win32ole-pr.rb', line 2690

def major_version
  @version.split('.')[0]
end

#minor_version ⇒ Object

# File 'lib/win32ole-pr.rb', line 2694

def minor_version
  @version.split('.')[1]
end

#name ⇒ Object Also known as: to_s

# File 'lib/win32ole-pr.rb', line 2680

def name
  @name
end

#ole_types ⇒ Object Also known as: ole_classes

# File 'lib/win32ole-pr.rb', line 2739

def ole_types()
  classes = []
  p = 0.chr * 4
  oletypelib2itypelib(p)
  pTypeLib = p.unpack('L').first
  WIN32OLE.ole_types_from_typelib(pTypeLib, classes)
  WIN32OLE.ole_release(pTypeLib)
  classes
end

#oletypelib2itypelib(pptl) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2726

def oletypelib2itypelib(pptl)
  path = self.path
  if path
    pbuf = multi_to_wide(path)
    hr = LoadTypeLibEx(pbuf, REGKIND_NONE, pptl)
    if hr != S_OK
      raise WIN32OLERuntimeError, "failed to LoadTypeLibEx from `#{path}'"
    end
  else
    raise WIN32OLERuntimeError, "failed to get type library path"
  end
end

#oletypelib_path(guid, version) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2698

def oletypelib_path(guid, version)
  path = nil
  key = "TypeLib\\" + guid+ "\\" + version
  hkey = 0.chr * 4
  err = WIN32OLE_TYPELIB.reg_open_vkey(HKEY_CLASSES_ROOT, key, hkey)
  return nil if err != ERROR_SUCCESS
  hkey = hkey.unpack('L').first
  k = 0
  while path.nil?
    lang = WIN32OLE_TYPELIB.reg_enum_key(hkey, k)
    break if lang.nil?
    hlang = 0.chr * 4
    err = WIN32OLE_TYPELIB.reg_open_vkey(hkey, lang, hlang)
    hlang = hlang.unpack('L').first
    if err == ERROR_SUCCESS
      path = WIN32OLE_TYPELIB.reg_get_typelib_file_path(hlang)
      RegCloseKey(hlang)
    end
    k += 1
  end
  RegCloseKey(hkey)
  path
end

#oletypelib_set_member(name, guid, version) ⇒ Object

# File 'lib/win32ole-pr.rb', line 2635

def oletypelib_set_member(name, guid, version)
  @name = name
  @guid = guid
  @version = version
end

#path ⇒ Object

# File 'lib/win32ole-pr.rb', line 2722

def path
  oletypelib_path(@guid, @version)
end

#version ⇒ Object

# File 'lib/win32ole-pr.rb', line 2686

def version
  @version
end

#visible? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/win32ole-pr.rb', line 2751

def visible?
  visible = true
  p = 0.chr * 4
  oletypelib2itypelib(p)
  pTypeLib = p.unpack('L').first
  lpVtbl = 0.chr * 4
  table = 0.chr * 52
  memcpy(lpVtbl, pTypeInfo, 4)
  memcpy(table, lpVtbl.unpack('L').first, 52)
  table = table.unpack('L*')
  getLibAttr = Win32::API::Function.new(table[7], 'PP', 'L')
  releaseTLibAttr = Win32::API::Function.new(table[12], 'PP', 'L')
  p = 0.chr * 4
  getLibAttr.call(pTypeLib, p)
  if hr != S_OK
    WIN32OLE.ole_release(pTypeLib)
    raise WIN32OLERuntimeError, "failed to get TLIBATTR information"
  end
  pTLibAttr = p.unpack('L').first
  tLibAttr = 0.chr * 32
  memcpy(tLibAttr, pTLibAttr, 32)
  wLibFlags = tLibAttr[28, 2].unpack('S').first
  if wLibFlags == 0 || (wLibFlags & LIBFLAG_FRESTRICTED)!=0 || (wLibFlags & LIBFLAG_FHIDDEN)!=0
    visible = false
  end
  releaseTLibAttr.call(pTypeLib, pTLibAttr)
  WIN32OLE.ole_release(pTypeLib)
  visible
end