Class: WIN32OLE

Inherits:

Object

Object
WIN32OLE

show all

Defined in:: lib/win32ole-pr.rb

Defined Under Namespace

Modules: VARIANT Classes: ComVtbl, Win32OLEIDispatch

Constant Summary collapse

VERSION =

"1.3.9"

ARGV =

[]

CP_ACP =

Windows::Unicode::CP_ACP

CP_OEMCP =

Windows::Unicode::CP_OEMCP

CP_MACCP =

Windows::Unicode::CP_MACCP

CP_THREAD_ACP =

Windows::Unicode::CP_THREAD_ACP

CP_SYMBOL =

Windows::Unicode::CP_SYMBOL

CP_UTF7 =

Windows::Unicode::CP_UTF7

CP_UTF8 =

Windows::Unicode::CP_UTF8

LOCALE_SYSTEM_DEFAULT =

Windows::National::LOCALE_SYSTEM_DEFAULT

LOCALE_USER_DEFAULT =

Windows::National::LOCALE_USER_DEFAULT

LCID_INSTALLED =

0x00000001

CP_INSTALLED =

0x00000001

IID_IDispatch =

[0x00020400, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46].pack('LSSC8')

IID_IUnknown =

[0x00000000, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46].pack('LSSC8')

IID_NULL =

[0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00].pack('LSSC8')

IID_IEnumVARIANT =

[0x00020404, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46].pack('LSSC8')

IID_IPersistMemory =

[0xBD1AE5E0, 0xA6AE, 0xBD37, 0xBD, 0x37, 0x50, 0x42, 0x00, 0xC1, 0x00, 0x00].pack('LSSC8')

IID_IConnectionPointContainer =

[0xB196B284, 0xBAB4, 0x101A, 0xB6, 0x9C, 0x00, 0xAA, 0x00, 0x34, 0x1D, 0x07].pack('LSSC8')

IID_IProvideClassInfo =

[0xB196B283, 0xBAB4, 0x101A, 0xB6, 0x9C, 0x00, 0xAA, 0x00, 0x34, 0x1D, 0x07].pack('LSSC8')

IID_IProvideClassInfo2 =

[0xA6BC3AC0, 0xDBAA, 0x11CE, 0x9D, 0xE3, 0x00, 0xAA, 0x00, 0x4B, 0xB8, 0x51].pack('LSSC8')

@@ole_initialized =

false

@@lcid =

LOCALE_SYSTEM_DEFAULT

@@cp =

CP_ACP

@@nil_to =

VT_ERROR

@@com_hash =

{}

@@QueryInterface =

Win32::API::Callback.new('PPP', 'L', &lambda { |p, riid, ppv|
  if riid == IID_IUnknown || riid == IID_IDispatch
    refcount = 0.chr * 4
    memcpy(refcount, p+4, 4)
    refcount = [refcount.unpack('L').first + 1].pack('L')
    memcpy(p+4, refcount, 4)
    ppv[0, 4] = [p].pack('L')
    return S_OK
  end
  E_NOINTERFACE
})

@@AddRef =

Win32::API::Callback.new('P', 'L') { |p|
  refcount = 0.chr * 4
  memcpy(refcount, p+4, 4)
  refcount = [refcount.unpack('L').first + 1].pack('L')
  memcpy(p+4, refcount, 4)
}

@@Release =

Win32::API::Callback.new('P', 'L') { |p|
  dispatch = 0.chr * 12
  memcpy(dispatch, p, 12)
  _, refcount, obj = dispatch.unpack('L*')
  refcount -= 1
  memcpy(p+4, [refcount].pack('L'), 4)
  u = refcount
  if u == 0
    key = ObjectSpace._id2ref(obj)
    @@com_hash.delete(key)
  end
  u
}

@@Invoke =

Win32::API::Callback.new('PLPLLPPPP', 'L') { |p, dispid, riid, lcid, wFlags, pdispparams, pvarResult, pexceptinfo, puArgErr|
  obj = 0.chr * 4
  memcpy(obj, p+8, 4)
  obj = ObjectSpace._id2ref(obj.unpack('L').first)
  dispparam = 0.chr * 16
  memcpy(dispparam, pdispparams, 16)
  args = dispparam[8, 4].unpack('L').first
  parg = []
  for i in 0 ... args
    var = 0.chr * 16
    memcpy(var, dispparam[0, 4].unpack('L').first + (args-i-1)*16, 16)
    parg[i] = ole_variant2val(var)
  end
  if dispid == DISPID_VALUE
    if wFlags == DISPATCH_METHOD
      dispid = :call
    elsif (wFlags & DISPATCH_PROPERTYGET) != 0
      dispid = :value
    end
  else
    dispid = ObjectSpace._id2ref(dispid)
  end
  v = obj.send(dispid, *parg)
  p = 0.chr * 16
  WIN32OLE.ole_val2variant(v, p)
  pvarResult[0, 16] = p
  S_OK
}

@@GetIDsOfNames =

Win32::API::Callback.new('PPLLLP', 'L') { |p, riid, sznames, cNames, lcid, pDispID|
  str = 0.chr * 256
  wcscpy(str, sznames)
  pDispID[0, 4] = [wide_to_mult(str).to_sym.object_id].pack('L')
  S_OK
}

@@GetTypeInfoCount =

Win32::API::Callback.new('PP', 'L') { |p, pct|
  E_NOTIMPL
}

@@GetTypeInfo =

Win32::API::Callback.new('PLLP', 'L') { |p, info, lcid, pInfo|
  E_NOTIMPL
}

@@installed_lcid_proc =

Win32::API::Callback.new('L', 'L', &lambda { |ptr|
  str = 0.chr * 8
  strcpy(str, ptr)
  if str == @lcid
    @installed = true
    return 0
  end
  1
})

@@installed_code_page_proc =

Win32::API::Callback.new('L', 'L', &lambda { |ptr|
  str = 0.chr * 10
  strcpy(str, ptr)
  if str.to_i == @cp
    @installed = true
    return 0
  end
  1
})

@@com_vtbl =

ComVtbl.new(@@QueryInterface, @@AddRef, @@Release, @@GetTypeInfoCount, @@GetTypeInfo, @@GetIDsOfNames, @@Invoke).to_a.map { |x| x.address }.pack('L*')

Instance Attribute Summary collapse

#pDispatch ⇒ Object

Returns the value of attribute pDispatch.

Class Method Summary collapse

._ole_free(dispatch) ⇒ Object
.ary_len_of_dim(ary, dim) ⇒ Object
.ary_new_dim(myary, pid, plb, dim) ⇒ Object
.ary_store_dim(myary, pid, plb, dim, val) ⇒ Object
.attach(dispatch) ⇒ Object
.codepage ⇒ Object

Returns the current code page.
.codepage=(cp) ⇒ Object

Sets the current code page.
.connect(server) ⇒ Object
.const_load(ole, mod = WIN32OLE) ⇒ Object

Defines a constant of an OLE Automation server as a mod constant.
.create_guid ⇒ Object
.dimension(val) ⇒ Object
.get_control_from_hwnd(hnd) ⇒ Object
.get_ptr_of_variant(pvar) ⇒ Object
.is_all_index_under(pid, pub, dim) ⇒ Object
.lcid_installed(lcid) ⇒ Object
.locale ⇒ Object
.locale=(lcid) ⇒ Object
.ole_addref(dispatch) ⇒ Object
.ole_ary_m_entry(val, pid) ⇒ Object
.ole_bind_obj(moniker) ⇒ Object
.ole_const_load(pTypeLib, mod) ⇒ Object
.ole_cp2encoding(cp) ⇒ Object
.ole_free(obj) ⇒ Object

Invokes the Release() method of the Dispatch interface of the WIN32OLE object.
.ole_initialize ⇒ Object
.ole_methods_from_typeinfo(pTypeInfo, mask) ⇒ Object
.ole_methods_sub(pOwnerTypeInfo, pTypeInfo, methods, mask) ⇒ Object
.ole_reference_count(obj) ⇒ Object

Returns the reference counter of the Dispatch interface of the WIN32OLE object.
.ole_release(dispatch) ⇒ Object
.ole_set_safe_array(n, psa, pid, pub, val, dim, vt) ⇒ Object
.ole_show_help(info, helpcontext = nil) ⇒ Object
.ole_type_from_itypeinfo(pTypeInfo) ⇒ Object
.ole_typelib_from_itypeinfo(pTypeInfo) ⇒ Object
.ole_typelib_from_itypelib(pTypeLib) ⇒ Object
.ole_types_from_typelib(pTypeLib, classes) ⇒ Object
.ole_uninitialize ⇒ Object
.ole_val2variant(val, var) ⇒ Object
.ole_val2variant2(val, var) ⇒ Object
.ole_val2variant_ex(val, var, vt) ⇒ Object
.ole_val_ary2variant_ary(val, var, vt) ⇒ Object
.ole_variant2val(pvar) ⇒ Object
.oleclass_from_typelib(obj, pTypeLib, oleclass) ⇒ Object
.time_object2date(tm) ⇒ Object
.val2variant_ptr(val, var, vt) ⇒ Object

Instance Method Summary collapse

Constructor Details

#initialize(server = nil, host = nil) ⇒ `WIN32OLE`

Creates a new Win32::OLE server object on host, or the localhost if no host is specified. The server can be either a Program ID or a Class ID.

Examples:

# Program ID (Excel)
ole = Win32::OLE.new('Excel.Application')

# Class ID (Excel)
ole = Win32::OLE.new('{00024500-0000-0000-C000-000000000046}')

– TODO: explain numeric server and host behavior.

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

def initialize(server=nil, host=nil)
  WIN32OLE.ole_initialize()

  @pDispatch = nil

  return self if server.nil?

  if server.is_a?(Numeric)
    ole_set_member(server)
    return self
  end

  if host
    return ole_create_dcom(server, host)
  end

  clsid = 0.chr * 16
  serverw = multi_to_wide(server)

  hr = CLSIDFromProgID(serverw, clsid)

  if hr != S_OK
    hr = CLSIDFromString(serverw, clsid)
  end

  if hr != S_OK
    raise WIN32OLERuntimeError, "unknown OLE server: '#{server}'"
  end

  ptr = 0.chr * 4

  hr = CoCreateInstance(
      clsid,
      nil,
      CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
      IID_IDispatch,
      ptr
  )

  if hr != S_OK
    error = "failed to create WIN32OLE object from '#{server}'"
    raise WIN32OLERuntimeError, error
  end

  ole_set_member(ptr.unpack('L').first)

  self
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(id, *args) ⇒ `Object`

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

def method_missing(id, *args)
  method = id.to_s
  if method[-1] == ?=
    method = method[0..-2]
    return ole_propertyput(method, args.first)
  else
    return ole_invoke(method, args, DISPATCH_METHOD|DISPATCH_PROPERTYGET, false)
  end
end

Instance Attribute Details

#pDispatch ⇒ `Object`

Returns the value of attribute pDispatch.



161
162
163

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

def pDispatch
  @pDispatch
end

Class Method Details

._ole_free(dispatch) ⇒ `Object`

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

def self._ole_free(dispatch)
  if @@ole_initialized
    if dispatch
      WIN32OLE.ole_release(dispatch)
    end
  end
  nil
end

.ary_len_of_dim(ary, dim) ⇒ `Object`

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

def self.ary_len_of_dim(ary, dim)
  ary_len = 0
  if dim == 0
    if ary.is_a?(Array)
      ary_len = ary.length
    end
  else
    if ary.is_a?(Array)
      ary.each do |x|
        ary_len1 = ary_len_of_dim(x, dim-1)
        ary_len = ary_len1 if ary_len < ary_len1
      end
    end
  end
  ary_len
end

.ary_new_dim(myary, pid, plb, dim) ⇒ `Object`

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

def self.ary_new_dim(myary, pid, plb, dim)
  ids = Array.new(dim)
  for i in 0 ... dim
    ids[i] = pid[i] - plb[i]
  end
  obj = myary
  pobj = myary
  for i in 0 ... (dim-1)
    obj = pobj[ids[i]]
    if obj.nil?
      pboj[ids[i]] = []
    end
    obj = pobj[ids[i]]
    pobj = pbj
  end
  obj
end

.ary_store_dim(myary, pid, plb, dim, val) ⇒ `Object`

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

def self.ary_store_dim(myary, pid, plb, dim, val)
  id = pid[dim-1] - plb[dim-1]
  obj = ary_new_dim(myary, pid, plb, dim)
  obj[id] = val
end

.attach(dispatch) ⇒ `Object`



291
292
293

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

def self.attach(dispatch)
  obj = self.new.ole_set_member(dispatch)
end

.codepage ⇒ `Object`

Returns the current code page.

Example:

WIN32OLE.codepage # => WIN32OLE::CP_ACP



1292
1293
1294

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

def self.codepage
  @@cp
end

.codepage=(cp) ⇒ `Object`

Sets the current code page. The code page must be an installed code page or one of the following values:

WIN32OLE::CP_ACP WIN32OLE::CP_OEMCP WIN32OLE::CP_MACCP WIN32OLE::CP_THREAD_ACP WIN32OLE::CP_SYMBOL WIN32OLE::CP_UTF7 WIN32OLE::CP_UTF8

Example:

WIN32OLE.codepage = WIN32OLE::CP_UTF8

– TODO: What is load_conv_function51932?

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

def self.codepage=(cp)
  if code_page_installed(cp)
    @@cp = cp
  else
    case cp
      when CP_ACP, CP_OEMCP, CP_MACCP, CP_THREAD_ACP,
          CP_SYMBOL, CP_UTF7, CP_UTF8, 51932
      then
        @@cp = cp
        if cp == 51932
          load_conv_function51932()
        end
      else
        msg = "codepage should be WIN32OLE::CP_ACP, WIN32OLE::CP_OEMCP, "
        msg << "WIN32OLE::CP_MACCP, WIN32OLE::CP_THREAD_ACP, "
        msg << "WIN32OLE::CP_SYMBOL, WIN32OLE::CP_UTF7, WIN32OLE::CP_UTF8"
        raise WIN32OLERuntimeError, msg
    end
  end
  @@enc = ole_cp2encoding(@@cp)
  nil
end

.connect(server) ⇒ `Object`

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

def self.connect(server)
  ole_initialize()
  clsid = 0.chr * 16
  serverw = Windows::Unicode::multi_to_wide(server)
  hr = CLSIDFromProgID(serverw, clsid)
  if hr != S_OK
    hr = CLSIDFromString(serverw, clsid)
  end
  if hr != S_OK
    return ole_bind_obj(server)
  end

  pUnknown = 0.chr * 4
  hr = GetActiveObject(clsid, nil, pUnknown)
  if hr != S_OK
    raise WIN32OLERuntimeError, "OLE server `#{server}' not running"
  end
  pUnknown = pUnknown.unpack('L').first
  lpVtbl = 0.chr * 4
  table = 0.chr * 28
  memcpy(lpVtbl, pUnknown, 4)
  memcpy(table, lpVtbl.unpack('L').first, 28)
  table = table.unpack('L*')
  queryInterface = Win32::API::Function.new(table[0], 'PPP', 'L')
  p = 0.chr * 4
  hr = queryInterface.call(pUnknown, IID_IDispatch, p)
  if hr != S_OK
    WIN32OLE.ole_release(pUnknown)
    raise WIN32OLERuntimeError, "failed to create WIN32OLE server `#{server}'"
  end
  pDispatch = p.unpack('L').first
  WIN32OLE.ole_release(pUnknown)
  self.attach(pDispatch)
end

.const_load(ole, mod = WIN32OLE) ⇒ `Object`

Defines a constant of an OLE Automation server as a mod constant.

The +ole+ argument is WIN32OLE object or type library name. The
+mod+ argument is a class or module name, which defaults to WIN32OLE
if omitted.

The first letter of a Ruby constant is always upper case. Therefore,
a constant name of WIN32OLE object is capitalized. For example, the
'xlTop' constant of Excel is changed to 'XlTop' in WIN32OLE.

If the first letter of an OLE constant is not in the A-Z range, then
the constant must be referenced via the CONSTANTS hash variable.

Example:

   module EXCEL_CONST; end

   excel = WIN32OLE.new('Excel.Application')

   WIN32OLE.const_load(excel, EXCEL_CONST)

   puts EXCEL_CONST::XlTop # => -4160
   puts EXCEL_CONST::CONSTANTS['_xlDialogChartSourceData'] # => 541

   WIN32OLE.const_load(excel)
   puts WIN32OLE::XlTop # => -4160

   module MSO; end

   WIN32OLE.const_load('Microsoft Office 9.0 Object Library', MSO)
   puts MSO::MsoLineSingle # => 1

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

def self.const_load(ole, mod=WIN32OLE)
  unless [Class, Module].include?(mod.class)
    raise TypeError, '2nd parameter must be Class or Module'
  end

  if ole.is_a?(WIN32OLE)
    pDispatch = ole.pDispatch
    lpVtbl = 0.chr * 4
    table = 0.chr * 28

    memcpy(lpVtbl, pDispatch, 4)
    memcpy(table, lpVtbl.unpack('L').first, 28)

    table = table.unpack('L*')

    ptr = 0.chr * 4

    getTypeInfo = Win32::API::Function.new(table[4], 'PLLP', 'L')
    hr = getTypeInfo.call(pDispatch, 0, @@lcid, ptr)

    if hr != S_OK
      raise RuntimeError, 'failed to GetTypeInfo'
    end

    pTypeInfo = ptr.unpack('L').first
    lpVtbl = 0.chr * 4
    table = 0.chr * 88

    memcpy(lpVtbl, pTypeInfo, 4)
    memcpy(table, lpVtbl.unpack('L').first, 88)

    table = table.unpack('L*')
    getContainingTypeLib = Win32::API::Function.new(table[18], 'PPP', 'L')

    ptr = 0.chr * 4
    index = 0.chr * 4
    hr = getContainingTypeLib.call(pTypeInfo, ptr, index)

    if hr != S_OK
      WIN32OLE.ole_release(pTypeInfo)
      raise RuntimeError, 'failed to GetContainingTypeLib'
    end

    pTypeLib = ptr.unpack('L').first
    WIN32OLE.ole_release(pTypeInfo)
    ole_const_load(pTypeLib, mod)
    WIN32OLE.ole_release(pTypeLib)
  elsif ole.is_a?(String)
    file = WIN32OLE_TYPELIB.typelib_file(ole)
    file = ole if file.nil?

    buf = multi_to_wide(file)
    p = 0.chr * 4

    hr = LoadTypeLibEx.call(buf, REGKIND_NONE, p)
    pTypeLib = p.unpack('L').first

    if hr != S_OK
      raise WIN32OLERuntimeError, "failed to LoadTypeLibEx"
    end

    if mod
      ole_const_load(pTypeLib, mod)
    else
      ole_const_load(pTypeLib, WIN32OLE)
    end

    WIN32OLE.ole_release(pTypeLib)
  else
    raise TypeError, "1st parameter must be WIN32OLE instance"
  end

  nil
end

.create_guid ⇒ `Object`

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

def self.create_guid
  guid = 0.chr * 16
  hr = CoCreateGuid(guid)
  if hr != S_OK
    raise = WIN32OLERuntimeError, "failed to create GUID"
  end
  bstr = 0.chr * 160
  len = StringFromGUID2(guid, bstr, 80)
  if len == 0
    raise RuntimeError, "failed to create GUID(buffer over)"
  end
  wide_to_multi(bstr)
end

.dimension(val) ⇒ `Object`

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

def self.dimension(val)
  dim = 0
  if val.is_a?(Array)
    val.each do |x|
      dim1 = dimension(x)
      dim = dim1 if dim < dim1
    end
    dim += 1
  end
  dim
end

.get_control_from_hwnd(hnd) ⇒ `Object`

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

def self.get_control_from_hwnd(hnd)
  CoInitialize(0)
  reg_msg = RegisterWindowMessage("WM_HTML_GETOBJECT")

  iid =[0x626FC520, 0xA41E, 0x11CF, 0xA7, 0x31, 0x00, 0xA0, 0xC9, 0x08, 0x26, 0x37].pack('LSSC8')

  result = 0.chr*4
  hnd = hnd.hex if hnd.is_a?(String)
  SendMessageTimeout(hnd, reg_msg, 0, 0, SMTO_ABORTIFHUNG, 1000, result)

  result = result.unpack('L')[0]
  idisp = 0.chr * 4
  r = ObjectFromLresult(result, iid, 0, idisp)
  if r == 0
    idisp = idisp.unpack('L').first
    self.attach(idisp)
  else
    nil
  end
end

.get_ptr_of_variant(pvar) ⇒ `Object`

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

def self.get_ptr_of_variant(pvar)
  case pvar[0, 2].unpack('S').first
    when VT_UI1, VT_I2, VT_UI2, VT_I4, VT_UI4, VT_R4, VT_R8, VT_I8, VT_UI8, VT_INT, VT_UINT, VT_CY, VT_DATE,
        VT_ERROR, VT_BOOK, VT_ARRAY
      return [pvar].pack('P').unpack('L').first + 8
    when VT_BSTR, VT_DISPATCH, VT_UNKNOWN
      return pvar[8, 4].unpack('L').first
    else
      return 0
  end
end

.is_all_index_under(pid, pub, dim) ⇒ `Object`

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

def self.is_all_index_under(pid, pub, dim)
  for i in 0 ... dim
    return false if pid[i] > pub[i]
  end
  true
end

.lcid_installed(lcid) ⇒ `Object`

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

def self.lcid_installed(lcid)
  @installed = false
  @lcid = "%08x" % lcid
  EnumSystemLocales(@@installed_lcid_proc, LCID_INSTALLED)
  @installed
end

.locale ⇒ `Object`



1341
1342
1343

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

def self.locale
  @@lcid
end

.locale=(lcid) ⇒ `Object`

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

def self.locale=(lcid)
  if lcid_installed(lcid)
    @@lcid = lcid
  else
    case lcid
      when LOCALE_SYSTEM_DEFAULT, LOCALE_USER_DEFAULT
        @@lcid = lcid
      else
        raise WIN32OLERuntimeError, "not installed locale: #{lcid}"
    end
  end
  nil
end

.ole_addref(dispatch) ⇒ `Object`

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

def self.ole_addref(dispatch)
  lpVtbl = 0.chr * 4
  table = 0.chr * 28
  memcpy(lpVtbl, dispatch, 4)
  memcpy(table, lpVtbl.unpack('L').first, 28)
  table = table.unpack('L*')
  addRef = Win32::API::Function.new(table[1], 'P', 'L')
  addRef.call(dispatch)
end

.ole_ary_m_entry(val, pid) ⇒ `Object`

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

def self.ole_ary_m_entry(val, pid)
  obj = val
  i = 0
  while obj.is_a?(Array)
    obj = obj[pid[i]]
    i += 1
  end
  obj
end

.ole_bind_obj(moniker) ⇒ `Object`

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

def self.ole_bind_obj(moniker)
  pBindCtx = 0.chr * 4
  hr = CreateBindCtx(0, pBindCtx)

  if hr != S_OK
    raise WIN32OLERuntimeError, "failed to create bind context"
  end

  pBindCtx = pBindCtx.unpack('L').first
  monikerw = multi_to_wide(moniker)

  pMoniker = 0.chr * 4
  eaten = 0.chr * 4

  hr = MkParseDisplayName(pBindCtx, monikerw, eaten, pMoniker)

  if hr != S_OK
    WIN32OLE.ole_release(pBindCtx)
    raise WIN32OLERuntimeError, "failed to parse display name of moniker '#{moniker}'"
  end

  pMoniker = pMoniker.unpack('L').first
  lpVtbl = 0.chr * 4
  table = 0.chr * 4 * 23

  memcpy(lpVtbl, pMoniker, 4)
  memcpy(table, lpVtbl.unpack('L').first, 92)

  table = table.unpack('L*')
  ptr = 0.chr * 4

  bindToObject = Win32::API::Function.new(table[8], 'PPPPP', 'L')

  hr = bindToObject.call(pMoniker, pBindCtx, nil, IID_IDispatch, ptr)

  pDispatch = ptr.unpack('L').first
  WIN32OLE.ole_release(pMoniker)
  WIN32OLE.ole_release(pBindCtx)

  if hr != S_OK
    raise WIN32OLERuntimeError, "failed to bind moniker '#{moniker}'"
  end

  self.attach(pDispatch)
end

.ole_const_load(pTypeLib, mod) ⇒ `Object`

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

def self.ole_const_load(pTypeLib, mod)
  constant = {}
  lpVtbl = 0.chr * 4
  table = 0.chr * 28
  memcpy(lpVtbl, pTypeLib, 4)
  memcpy(table, lpVtbl.unpack('L').first, 28)
  table = table.unpack('L*')
  getTypeInfoCount = Win32::API::Function.new(table[3], 'P', 'L')
  getTypeInfo = Win32::API::Function.new(table[4], 'PLP', 'L')
  count = getTypeInfoCount.call(pTypeLib)
  for index in 0 ... count
    p = 0.chr * 4
    hr = getTypeInfo.call(pTypeLib, index, p)
    next if hr != S_OK
    pTypeInfo = p.unpack('L').first
    lpVtbl = 0.chr * 4
    table = 0.chr * 88
    memcpy(lpVtbl, pTypeInfo, 4)
    memcpy(table, lpVtbl.unpack('L').first, 88)
    table = table.unpack('L*')
    getTypeAttr = Win32::API::Function.new(table[3], 'PP', 'L')
    getVarDesc = Win32::API::Function.new(table[6], 'PLP', 'L')
    getNames = Win32::API::Function.new(table[7], 'PLPLP', 'L')
    releaseTypeAttr = Win32::API::Function.new(table[19], 'PP', 'L')
    releaseVarDesc = Win32::API::Function.new(table[21], 'PP', 'L')
    p = 0.chr * 4
    hr = getTypeAttr.call(pTypeInfo, p)
    if hr != S_OK
      WIN32OLE.ole_release(pTypeInfo)
      next
    end
    pTypeAttr = p.unpack('L').first
    typeAttr = 0.chr * 76
    memcpy(typeAttr, pTypeAttr, 76)
    for iVar in 0 ... typeAttr[46, 2].unpack('S').first
      p = 0.chr * 4
      getVarDesc.call(pTypeInfo, iVar, p)
      pVarDesc = p.unpack('L').first
      next if hr != S_OK
      varDesc = 0.chr * 36
      memcpy(varDesc, pVarDesc, 36)
      if varDesc[32, 4].unpack('L').first == VAR_CONST &&
          (varDesc[28, 2].unpack('S').first & (VARFLAG_FHIDDEN |
              VARFLAG_FRESTRICTED | VARFLAG_FNONBROWSABLE))==0
        len = 0.chr * 4
        bstr = 0.chr * 4
        hr = getNames.call(pTypeInfo, varDesc[0, 4].unpack('L').first, bstr, 1, len)
        if hr != S_OK || len.unpack('L').first == 0 ||
            bstr.unpack('L').first == 0
          next
        end
        bstr = bstr.unpack('L').first
        str = 0.chr * 256
        wcscpy(str, bstr)
        SysFreeString(bstr)
        pName = wide_to_multi(str)
        pName[0, 1] = pName[0, 1].upcase
        var = 0.chr * 16
        memcpy(var, varDesc[8, 4].unpack('L').first, 16)
        val = ole_variant2val(var)
        if pName[0, 1].between?('A', 'Z')
          mod.const_set(pName.to_sym, val)
        else
          constant[pName] = val
        end
      end
      releaseVarDesc.call(pTypeInfo, pVarDesc)
    end
    releaseTypeAttr.call(pTypeInfo, pTypeAttr)
    WIN32OLE.ole_release(pTypeInfo)
  end
  mod.const_set("CONSTANTS", constant)
end

.ole_cp2encoding(cp) ⇒ `Object`

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

def self.ole_cp2encoding(cp)
  # TODO
  nil
end

.ole_free(obj) ⇒ `Object`

Invokes the Release() method of the Dispatch interface of the WIN32OLE object. It returns the reference counter of the OLE object.

This method is used for debugging only.

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

def self.ole_free(obj)
  if obj.pDispatch
    if ole_reference_count(obj) > 0
      n = WIN32OLE.ole_release(obj.pDispatch)
    end
  end

  n
end

.ole_initialize ⇒ `Object`

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

def self.ole_initialize
  if !@@ole_initialized
    hr = OleInitialize.call()
    if hr != S_OK
      raise RuntimeError, "fail: OLE initialize"
    end
    @@ole_initialized = true
    at_exit { ole_uninitialize }
  end
end

.ole_methods_from_typeinfo(pTypeInfo, mask) ⇒ `Object`

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

def self.ole_methods_from_typeinfo(pTypeInfo, mask)
  methods = []
  lpVtbl = 0.chr * 4
  table = 0.chr * 80
  memcpy(lpVtbl, pTypeInfo, 4)
  memcpy(table, lpVtbl.unpack('L').first, 80)
  table = table.unpack('L*')
  getTypeAttr = Win32::API::Function.new(table[3], 'PP', 'L')
  getRefTypeOfImplType = Win32::API::Function.new(table[8], 'PLP', 'L')
  getRefTypeInfo = Win32::API::Function.new(table[14], 'PLP', 'L')
  getFuncDesc = Win32::API::Function.new(table[5], 'PLP', 'L')
  getDocumentation = Win32::API::Function.new(table[12], 'PLPPPP', 'L')
  releaseTypeAttr = Win32::API::Function.new(table[19], 'PP', 'L')
  p = 0.chr * 4
  hr = getTypeAttr.call(pTypeInfo, p)
  if hr != S_OK
    raise WIN32OLERuntimeError, "failed to GetTypeAttr"
  end
  ole_methods_sub(0, pTypeInfo, methods, mask)
  pTypeAttr = p.unpack('L').first
  typeAttr = 0.chr * 76
  memcpy(typeAttr, pTypeAttr, 76)
  for i in 0 ... typeAttr[48, 2].unpack('S').first
    p = 0.chr * 4
    hr = getRefTypeOfImplType.call(pTypeInfo, i, p)
    next if hr != S_OK
    href = p.unpack('L').first
    p = 0.chr * 4
    hr = getRefTypeInfo.call(pTypeInfo, href, p)
    next if hr != S_OK
    pRefTypeInfo = p.unpack('L').first
    ole_methods_sub(pTypeInfo, pRefTypeInfo, methods, mask)
    ole_release(pRefTypeInfo)
  end
  releaseTypeAttr.call(pTypeInfo, pTypeAttr)
  methods
end

.ole_methods_sub(pOwnerTypeInfo, pTypeInfo, methods, mask) ⇒ `Object`

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

def self.ole_methods_sub(pOwnerTypeInfo, pTypeInfo, methods, mask)
  lpVtbl = 0.chr * 4
  table = 0.chr * 88
  memcpy(lpVtbl, pTypeInfo, 4)
  memcpy(table, lpVtbl.unpack('L').first, 88)
  table = table.unpack('L*')
  getTypeAttr = Win32::API::Function.new(table[3], 'PP', 'L')
  getFuncDesc = Win32::API::Function.new(table[5], 'PLP', 'L')
  getNames = Win32::API::Function.new(table[7], 'PLPLP', 'L')
  getDocumentation = Win32::API::Function.new(table[12], 'PLPPPP', 'L')
  releaseTypeAttr = Win32::API::Function.new(table[19], 'PP', 'L')
  releaseFuncDesc = Win32::API::Function.new(table[20], 'PP', 'L')
  p = 0.chr * 4
  hr = getTypeAttr.call(pTypeInfo, p)
  if hr != S_OK
    raise WIN32OLERuntimeError, "failed to GetTypeAttr"
  end
  pTypeAttr = p.unpack('L').first
  typeAttr = 0.chr * 76
  memcpy(typeAttr, pTypeAttr, 76)
  for i in 0 .. typeAttr[44, 2].unpack('S').first
    p = 0.chr * 4
    hr = getFuncDesc.call(pTypeInfo, i, p)
    next if hr != S_OK
    pFuncDesc = p.unpack('L').first
    funcDesc = 0.chr * 52
    memcpy(funcDesc, pFuncDesc, 52)
    memid = funcDesc[0, 4].unpack('L').first
    bstr = 0.chr * 4
    hr = getDocumentation.call(pTypeInfo, memid, bstr, nil, nil, nil)
    if hr != S_OK
      releaseFuncDesc.call(pTypeInfo, pFuncDesc)
      next
    end
    if (funcDesc[16, 4].unpack('L').first & mask) != 0
      str = 0.chr * 256
      wcscpy(str, bstr.unpack('L').first)
      method = WIN32OLE_METHOD.new
      method.olemethod_set_member(pTypeInfo, pOwnerTypeInfo, i, wide_to_multi(str))
      methods.push(method)
    end
    releaseFuncDesc.call(pTypeInfo, pFuncDesc)
    pFuncDesc = nil
  end
  releaseTypeAttr.call(pTypeInfo, pTypeAttr)
  methods
end

.ole_reference_count(obj) ⇒ `Object`

Returns the reference counter of the Dispatch interface of the WIN32OLE object.

This method is used for debugging only.

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

def self.ole_reference_count(obj)
  n = 0

  if obj.pDispatch
    ole_addref(obj.pDispatch)
    n = ole_release(obj.pDispatch)
  end

  n
end

.ole_release(dispatch) ⇒ `Object`

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

def self.ole_release(dispatch)
  lpVtbl = 0.chr * 4
  table = 0.chr * 28
  memcpy(lpVtbl, dispatch, 4)
  memcpy(table, lpVtbl.unpack('L').first, 28)
  table = table.unpack('L*')
  release = Win32::API::Function.new(table[2], 'P', 'L')
  release.call(dispatch)
end

.ole_set_safe_array(n, psa, pid, pub, val, dim, vt) ⇒ `Object`

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

def self.ole_set_safe_array(n, psa, pid, pub, val, dim, vt)
  var = 0.chr * 16
  i = n
  while i >= 0
    val1 = ole_ary_m_entry(val, pid)
    VariantInit(var)
    p = val2variant_ptr(val1, var, vt)
    if is_all_index_under(pid, pub, dim) == true
      vvt = var[0, 2].unpack('S').first
      dispatch = var[8, 4].unpack('L').first
      if (vvt == VT_DISPATCH || vvt == VT_UNKNOWN) && dispatch == 0
        raise WIN32OLERuntimeError, "element of array does not have IDispatch or IUnknown Interface"
      end
      hr = SafeArrayPutElement(psa, pid.pack('L*'), p)
    end
    if hr != S_OK
      raise RuntimeError, "failed to SafeArrayPutElement"
    end
    pid[i] += 1
    if pid[i] > pub[i]
      pid[i] = 0
      i -= 1
    else
      i = dim - 1
    end
  end
end

.ole_show_help(info, helpcontext = nil) ⇒ `Object`

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

def self.ole_show_help(info, helpcontext=nil)
  if info.is_a?(WIN32OLE_TYPE) || info.is_a?(WIN32OLE_METHOD)
    helpfile = info.helpfile

    if helpfile == ''
      name = info.name
      raise RuntimeError, "no helpfile of '#{name}'"
    end

    helpcontext = info.helpcontext
  else
    helpfile = info
  end

  unless helpfile.is_a?(String)
    raise TypeError, "1st parameter must be (String|WIN32OLE_TYPE|WIN32OLE_METHOD)"
  end

  hwnd = 0

  begin
    htmlHelpA = Win32::API.new('HtmlHelpA', 'LPLL', 'L', 'HHCtrl.ocx')
    hwnd = htmlHelpA.call(GetDesktopWindow(), helpfile, 0xF, helpcontext)
    if hwnd == 0
      hwnd = htmlHelpA.call(GetDesktopWindow(), helpfile, 0, helpcontext)
    end
  rescue Win32::API::LoadLibraryError
  end

  if hwnd == 0
    raise RuntimeError, "failed to open help file `#{helpfile}'"
  end

  nil
end

.ole_type_from_itypeinfo(pTypeInfo) ⇒ `Object`

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

def self.ole_type_from_itypeinfo(pTypeInfo)
  memcpy(lpVtbl, pTypeInfo, 4)
  memcpy(table, lpVtbl.unpack('L').first, 88)
  table = table.unpack('L*')
  pTypeInfo = 0.chr * 4
  getContainingTypeLib = Win32::API::Function.new(table[18], 'PPP', 'L')
  getDocumentation = Win32::API::Function.new(table[12], 'PLPPPP', 'L')
  p = 0.chr * 4
  i = 0.chr * 4
  getContainingTypeLib.call(pTypeInfo, p, i)
  return nil if hr != S_OK
  pTypeLib = p.unpack('L').first
  index = i.unpack('L').first
  bstr = 0.chr * 4
  hr = getDocumentation.call(pTypeLib, index, bstr, nil, nil, nil)
  WIN32OLE.ole_release(pTypeLib)
  return nil if hr != S_OK
  str = 0.chr * 256
  wcscpy(str, bstr.unpack('L').first)
  type = WIN32OLE_TYPE.new
  type.oletype_set_member(pTypeInfo, wide_to_multi(str))
  type
end

.ole_typelib_from_itypeinfo(pTypeInfo) ⇒ `Object`

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

def self.ole_typelib_from_itypeinfo(pTypeInfo)
  lpVtbl = 0.chr * 4
  table = 0.chr * 88
  memcpy(lpVtbl, pTypeInfo, 4)
  memcpy(table, lpVtbl.unpack('L').first, 88)
  table = table.unpack('L*')
  getContainingTypeLib = Win32::API::Function.new(table[18], 'PPP', 'L')
  p = 0.chr * 4
  index = 0.chr * 4
  getContainingTypeLib.call(pTypeInfo, p, index)
  return nil if hr != S_OK
  pTypeLib = p.unpack('L').first
  retval = WIN32OLE.ole_typelib_from_itypelib(pTypeLib)
  WIN32OLE.ole_release(pTypeLib)
  retval
end

.ole_typelib_from_itypelib(pTypeLib) ⇒ `Object`

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

def self.ole_typelib_from_itypelib(pTypeLib)
  guid = nil
  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
  hr = getLibAttr.call(pTypeLib, p)
  return nil if hr != S_OK
  pTLibAttr = p.unpack('L').first
  tLibAttr = 0.chr * 32
  bstr = 0.chr * 160
  memcpy(tLibAttr, pTLibAttr, 32)
  len = StringFromGUID2(pTLibAttr, bstr, 80)
  if len > 3
    guid = wide_to_multi(bstr)
  end
  major, minor = tLibAttr[24, 4].unpack('SS')
  releaseTLibAttr.call(pTypeLib, pTLibAttr)
  return nil if guid.nil?
  WIN32OLE_TYPELIB.new(guid, major, minor)
end

.ole_types_from_typelib(pTypeLib, classes) ⇒ `Object`

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

def self.ole_types_from_typelib(pTypeLib, classes)
  lpVtbl = 0.chr * 4
  table = 0.chr * 56
  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')
  count = getTypeInfoCount.call(pTypeLib)
  for i in 0 ... count
    bstr = 0.chr * 4
    hr = getDocumentation.call(pTypeLib, i, bstr, nil, nil, nil)
    next if hr != S_OK

    p = 0.chr * 4
    hr = getTypeInfo.call(pTypeLib, i, p)
    next if hr != S_OK

    pTypeInfo = p.unpack('L').first
    type = WIN32OLE_TYPE.new
    str = 0.chr * 256
    wcscpy(str, bstr.unpack('L').first)
    type.oletype_set_member(pTypeInfo, wide_to_multi(str))
    classes.push(type)
    ole_release(pTypeInfo)
  end
  classes
end

.ole_uninitialize ⇒ `Object`

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

def self.ole_uninitialize
  OleUninitialize()
  @@ole_initialized = false
end

.ole_val2variant(val, var) ⇒ `Object`

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

def self.ole_val2variant(val, var)
  if val.is_a?(WIN32OLE)
    ole_addref(val.pDispatch)
    var[0, 2] = [VT_DISPATCH].pack('S')
    var[8, 4] = [val.pDispatch].pack('L')
    return
  end
  if val.is_a?(WIN32OLE_VARIANT)
    VariantCopy(var, val.var)
    return
  end

  if val.is_a?(Time)
    var[0, 2] = [VT_DATE].pack('S')
    var[8, 8] = [time_object2date(val)].pack('d')
    return
  end

  case val
    when Array
      ole_val_ary2variant_ary(val, var, VT_VARIANT|VT_ARRAY)
    when String
      var[0, 2] = [VT_BSTR].pack('S')
      var[8, 4] = [SysAllocString(multi_to_wide(val, WIN32OLE.codepage))].pack('L')
    when Fixnum
      var[0, 2] = [VT_I4].pack('S')
      var[8, 4] = [val].pack('L')
    when Bignum
      var[0, 2] = [VT_R8].pack('S')
      var[8, 8] = [val].pack('d')
    when Float
      var[0, 2] = [VT_R8].pack('S')
      var[8, 8] = [val].pack('d')
    when TrueClass
      var[0, 2] = [VT_BOOL].pack('S')
      var[8, 2] = [VARIANT_TRUE].pack('S')
    when FalseClass
      var[0, 2] = [VT_BOOL].pack('S')
      var[8, 2] = [VARIANT_FALSE].pack('S')
    when NilClass
      if @@nil_to == VT_ERROR
        var[0, 2] = [VT_ERROR].pack('S')
        var[8, 4] = [DISP_E_PARAMNOTFOUND].pack('L')
      else
        var[0, 2] = [VT_EMPTY].pack('S')
      end
    else
      var[0, 2] = [VT_DISPATCH].pack('S')
      var[8, 4] = [val2dispatch(val)].pack('L')
  end
end

.ole_val2variant2(val, var) ⇒ `Object`

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

def self.ole_val2variant2(val, var)
  @@nil_to = VT_EMPTY
  ole_val2variant(val, var)
  @@nil_to = VT_ERROR
end

.ole_val2variant_ex(val, var, vt) ⇒ `Object`

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

def self.ole_val2variant_ex(val, var, vt)
  if val.nil?
    if vt == VT_VARIANT
      ole_val2variant2(val, var)
    else
      var[0, 2] = [vt & ~VT_BYREF].pack('S')
      if vt & ~VT_BYREF == VT_DISPATCH
        var[8, 4] = [0].pack('L')
      elsif vt & ~VT_BYREF == VT_UNKNOWN
        var[8, 4] = [0].pack('L')
      end
    end
    return
  end
  case vt & ~VT_BYREF
    when VT_I8
      var[0, 2] = [VT_I8].pack('S')
      var[8, 8] = [val].pack('q')
    when VT_UI8
      var[0, 2] = [VT_UI8].pack('S')
      var[8, 8] = [val].pack('Q')
    else
      ole_val2variant2(val, var)
  end
end

.ole_val_ary2variant_ary(val, var, vt) ⇒ `Object`

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

def self.ole_val_ary2variant_ary(val, var, vt)
  unless val.is_a?(Array)
    raise TypeError, "1st parameter must be Array"
  end

  dim = dimension(val)
  psab = 0.chr * 8 * dim
  pub = Array.new(dim)
  pid = Array.new(dim)

  for i in 0 ... dim
    psab[i*8, 4] = [ary_len_of_dim(val, i)].pack('L')
    psab[i*8+4, 4] = 0.chr * 4
    pub[i] = psab[i*8, 4].unpack('L').first - 1
    pid[i] = 0
  end

  if (vt & ~VT_BYREF) == VT_ARRAY
    vt = (vt | VT_VARIANT)
  end
  psa = SafeArrayCreate(vt & VT_TYPEMASK, dim, psab)
  if psa == 0
    hr = E_OUTOFMEMORY
  else
    hr = SafeArrayLock(psa)
  end
  if hr == S_OK
    ole_set_safe_array(dim-1, psa, pid, pub, val, dim, vt & VT_TYPEMASK)
    hr = SafeArrayUnlock(psa)
  end
  if hr == S_OK
    var[0, 2] = [vt].pack('S')
    var[8, 4] = [psa].pack('L')
  else
    if psa != 0
      SafeArrayDestroy(psa)
    end
  end
  hr
end

.ole_variant2val(pvar) ⇒ `Object`

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

def self.ole_variant2val(pvar)
  val = nil
  var = 0.chr * 16
  memcpy(var, pvar, 16)
  var = var.unpack('SSSSLL')
  while var[0]== (VT_BYREF | VT_VARIANT)
    pvar = var[4]
    var = 0.chr * 16
    memcpy(var, pvar, 16)
    var = var.unpack('SSSSLL')
  end
  if (var[0] & VT_ARRAY) != 0
    if (var[0] & VT_BYREF) != 0
      ptr = 0.chr * 4
      memcpy(ptr, var[4], 4)
      psa = ptr.unpack('L').first
    else
      psa = var[4]
    end
    return val if psa == 0

    dim = SafeArrayGetDim(psa)
    variant = 0.chr * 16
    VariantInit(variant)
    variant[0, 2] = (var[0] & ~VT_ARRAY) | VT_BYREF
    pid = Array.new(dim)
    plb = Array.new(dim)
    pub = Array.new(dim)

    for i in 0 ... dim
      v = 0.chr * 4
      SafeArrayGetLBound(psa, i+1, v)
      plb[i] = v.unpack('L').first
      v = 0.chr * 4
      SafeArrayGetLBound(psa, i+1, v)
      pid[i] = v.unpack('L').first
      v = 0.chr * 4
      SafeArrayGetUBound(psa, i+1, v)
      pub[i] = v.unpack('L').first
    end
    hr = SafeArrayLock(psa)
    if hr == S_OK
      val = []
      i = 0
      while i < dim
        ary_new_dim(val, pid, plb, dim)
        ref = 0.chr * 4
        hr = SafeArrayPtrOfIndex(psa, pid, ref)
        variant[4, 4] = ref
        if hr == S_OK
          v = ole_variant2val([variant].pack('P').unpack('L').first)
          ary_store_dim(val, pid, plb, dim, v)
        end
        for i in 0 ... dim
          pid[i] += 1
          break if pid[i] <= pub[i]
          pid[i] = plb[i]
        end
      end
      SafeArrayUnlock(psa)
    end
    return val
  end

  case var[0] & ~VT_BYREF
    when VT_EMPTY, VT_NULL
      val = nil
    when VT_I1
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 4
        memcpy(ptr, var[4], 4)
        val = ptr.unpack('c').first
      else
        val = [var[4]].pack('L').unpack('c').first
      end
    when VT_UI1
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 4
        memcpy(ptr, var[4], 4)
        val = ptr.unpack('C').first
      else
        val = [var[4]].pack('L').unpack('C').first
      end
    when VT_I2
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 4
        memcpy(ptr, var[4], 4)
        val = ptr.unpack('s').first
      else
        val = [var[4]].pack('L').unpack('s').first
      end
    when VT_UI2
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 4
        memcpy(ptr, var[4], 4)
        val = ptr.unpack('S').first
      else
        val = [var[4]].pack('L').unpack('S').first
      end
    when VT_I4
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 4
        memcpy(ptr, var[4], 4)
        val = ptr.unpack('i').first
      else
        val = [var[4]].pack('L').unpack('i').first
      end
    when VT_UI4
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 4
        memcpy(ptr, var[4], 4)
        val = ptr.unpack('L').first
      else
        val = var[4]
      end
    when VT_INT
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 4
        memcpy(ptr, var[4], 4)
        val = ptr.unpack('i').first
      else
        val = [var[4]].pack('L').unpack('i').first
      end
    when VT_UINT
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 4
        memcpy(ptr, var[4], 4)
        val = ptr.unpack('L').first
      else
        val = var[4]
      end
    when VT_I8
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 8
        memcpy(ptr, var[4], 8)
        val = ptr.unpack('q').first
      else
        val = [var[4], var[5]].pack('LL').unpack('q').first
      end
    when VT_UI8
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 8
        memcpy(ptr, var[4], 8)
        val = ptr.unpack('Q').first
      else
        val = [var[4], var[5]].pack('LL').unpack('Q').first
      end
    when VT_R4
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 4
        memcpy(ptr, var[4], 4)
        val = ptr.unpack('f').first
      else
        val = [var[4]].pack('L').unpack('f').first
      end
    when VT_R8
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 8
        memcpy(ptr, var[4], 8)
        val = ptr.unpack('d').first
      else
        val = [var[4], var[5]].pack('LL').unpack('d').first
      end
    when VT_BSTR
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 4
        memcpy(ptr, var[4], 4)
        ptr.unpack('L').first
        str = 0.chr * 256
        wcscpy(str, ptr.unpack('L').first)
        val = wide_to_multi(str, WIN32OLE.codepage)
      else
        str = 0.chr * 256
        wcscpy(str, var[4])
        val = wide_to_multi(str, WIN32OLE.codepage)
      end
    when VT_ERROR
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 4
        memcpy(ptr, var[4], 4)
        val = ptr.unpack('L').first
      else
        val = var[4]
      end
    when VT_BOOL
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 4
        memcpy(ptr, var[4], 4)
        val = ptr.unpack('S').first != 0
      else
        val = [var[4]].pack('L').unpack('S').first != 0
      end
    when VT_DISPATCH
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 4
        memcpy(ptr, var[4], 4)
        pDispatch = ptr.unpack('L').first
      else
        pDispatch = var[4]
      end
      if pDispatch != 0
        ole_addref(pDispatch)
        val = WIN32OLE.new(pDispatch)
      end
    when VT_UNKNOWN
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 4
        memcpy(ptr, var[4], 4)
        punk = ptr.unpack('L').first
      else
        punk = var[4]
      end
      if punk != 0
        lpVtbl = 0.chr * 4
        table = 0.chr * 28
        memcpy(lpVtbl, punk, 4)
        memcpy(table, lpVtbl.unpack('L').first, 28)
        table = table.unpack('L*')
        p = 0.chr * 4
        queryInterface = Win32::API::Function.new(table[0], 'PPP', 'L')
        hr = queryInterface.call(punk, IID_IDispatch, p)
        if hr == S_OK
          pDispatch = p.unpack('L').first
          val = WIN32OLE.new(pDispatch)
        end
      end
    when VT_DATE
      if (var[0] & VT_BYREF) != 0
        ptr = 0.chr * 8
        memcpy(ptr, var[4], 8)
        date = ptr.unpack('d').first
      else
        date = [var[4], var[5]].pack('LL').unpack('d').first
      end
      d = date.to_i
      t = date - d
      yy, mm, dd = Date.jd_to_civil(2415019+d)
      hh, mi, ss = Date.day_fraction_to_time(t)
      val = "%04d/%02d/%02d %02d:%02d:%02d" % [yy, mm, dd, hh, mi, ss]
    else
      variant = 0.chr * 16
      VariantInit(variant)
      hr = VariantChangeTypeEx(variant, var, @@lcid, 0, VT_BSTR)
      var = variant.unpack('SSSSLL')
      if hr == S_OK && var[0] == VT_BSTR
        str = 0.chr * 256
        wcscpy(str, var[4])
        val = wide_to_multi(str)
      end
      VariantClear(variant)
  end

  val
end

.oleclass_from_typelib(obj, pTypeLib, oleclass) ⇒ `Object`

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

def self.oleclass_from_typelib(obj, pTypeLib, oleclass)
  found = false
  lpVtbl = 0.chr * 4
  table = 0.chr * 56
  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')
  count = getTypeInfoCount.call(pTypeLib)
  for i in 0 ... count
    break if found
    p = 0.chr * 4
    hr = getTypeInfo.call(pTypeLib, i, p)
    next if hr != S_OK
    pTypeInfo = p.unpack('L').first
    bstr = 0.chr * 4
    hr = getDocumentation.call(pTypeLib, i, bstr, nil, nil, nil)
    next if hr != S_OK
    str = 0.chr * 256
    wcscpy(str, bstr.unpack('L').first)
    typelib = wide_to_multi(str)
    if oleclass == typelib
      obj.oletype_set_member(pTypeInfo, typelib)
      found = true
    end
    ole_release(pTypeInfo)
  end
  found
end

.time_object2date(tm) ⇒ `Object`

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

def self.time_object2date(tm)
  jd = Date.civil_to_jd(tm.year, tm.month, tm.mday)
  t = Date.time_to_day_fraction(tm.hour, tm.min, tm.sec).to_f
  t + jd - 2415019
end

.val2variant_ptr(val, var, vt) ⇒ `Object`

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

def self.val2variant_ptr(val, var, vt)
  ole_val2variant_ex(val, var, vt)
  if (vt & ~VT_BYREF) == VT_VARIANT
    p = var
  else
    if (vt & ~VT_BYREF) != var[0, 2].unpack('S').first
      hr = VariantChangeTypeEx(var, var,
                               @@lcid, 0, vt & ~VT_BYREF)
      if hr != S_OK
        raise RuntimeError, "failed to change type"
      end
    end
    p = get_ptr_of_variant(var)
  end
  if p.nil?
    raise RuntimeError, "failed to get pointer of variant"
  end
  p
end

Instance Method Details

#[](method, *args) ⇒ `Object`

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

def [](method, *args)
  #ole_invoke(method,args,DISPATCH_PROPERTYGET, true)
  ole_invoke(method, args, DISPATCH_PROPERTYGET, false)
end

#[]=(method, *args) ⇒ `Object`

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

def []=(method, *args)
  #ole_invoke(method, args, DISPATCH_PROPERTYPUT, true)
  ole_invoke(method, args, DISPATCH_PROPERTYPUT, false)
end

#_getproperty(dispid, args, types) ⇒ `Object`



1828
1829
1830

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

def _getproperty(dispid, args, types)
  ole_invoke2(dispid, args, types, DISPATCH_PROPERTYGET)
end

#_invoke(dispid, args, types) ⇒ `Object`



1824
1825
1826

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

def _invoke(dispid, args, types)
  ole_invoke2(dispid, args, types, DISPATCH_METHOD)
end

#_ole_methods(mask) ⇒ `Object`

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

def _ole_methods(mask)
  methods = []
  p = 0.chr * 4
  hr = typeinfo_from_ole(p)
  pTypeInfo = p.unpack('L').first
  if hr != S_OK
    return methods
  end
  methods.concat(WIN32OLE.ole_methods_from_typeinfo(pTypeInfo, mask))
  WIN32OLE.ole_release(pTypeInfo)
  methods
end

#_setproperty(dispid, args, types) ⇒ `Object`



1832
1833
1834

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

def _setproperty(dispid, args, types)
  ole_invoke2(dispid, args, types, DISPATCH_PROPERTYPUT)
end

#clsid_from_remote(host, server, clsid) ⇒ `Object`

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

def clsid_from_remote(host, server, clsid)
  hr = S_OK
  hlm = 0.chr * 4
  err = RegConnectRegistry(host, HKEY_LOCAL_MACHINE, hlm)
  if err != ERROR_SUCCESS
    return HRESULT_FROM_WIN32(err)
  end
  subkey = "SOFTWARE\\Classes\\" + server + "\\CLSID"
  hpid = 0.chr * 4
  err = RegOpenKeyEx(hlm, subkey, 0, KEY_READ, hpid)
  if err != ERROR_SUCCESS
    return HRESULT_FROM_WIN32(err)
  else
    len = clsid.length.pack('L')
    dwtype = 0.chr * 4
    clsid2 = 0.chr * 100
    err = RegQueryValueEx(hpid, "", nil, dwtype, clsid2, len)
    if err == ERROR_SUCCESS && dwtype.unpack('L').first == REG_SZ
      hr = CLSIDFromString(multi_to_wide(clsid2), clsid)
    else
      hr = HRESULT_FROM_WIN32(err)
    end
    RegCloseKey(hpid)
  end
  RegCloseKey(hlm)
  hr
end

#each(&blk) ⇒ `Object`

Raises:

(ArgumentError)

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

def each(&blk)
  raise ArgumentError, "no block" unless block_given?
  result = 0.chr * 16
  dispParams = 0.chr * 16
  excepinfo = 0.chr * 32
  lpVtbl = 0.chr * 4
  table = 0.chr * 28
  argErr = 0.chr * 4
  memcpy(lpVtbl, @pDispatch, 4)
  memcpy(table, lpVtbl.unpack('L').first, 28)
  table = table.unpack('L*')
  invoke = Win32::API::Function.new(table[6], 'PLPLLPPPP', 'L')
  hr = invoke.call(@pDispatch, DISPID_NEWENUM, IID_NULL, @@lcid, DISPATCH_METHOD | DISPATCH_PROPERTYGET, dispParams, result, excepinfo, argErr)
  if hr != S_OK
    VariantClear(result)
    raise WIN32OLERuntimeError, "failed to get IEnum Interface"
  end
  if [VT_UNKNOWN, VT_DISPATCH].include?(result[0, 2].unpack('S').first)
    pUnknown = result[8, 4].unpack('L').first
    lpVtbl = 0.chr * 4
    table = 0.chr * 28
    memcpy(lpVtbl, pUnknown, 4)
    memcpy(table, lpVtbl.unpack('L').first, 28)
    table = table.unpack('L*')
    p = 0.chr * 4
    queryInterface = Win32::API::Function.new(table[0], 'PPP', 'L')
    hr = queryInterface.call(pUnknown, IID_IEnumVARIANT, p)
    pEnum = p.unpack('L').first
  end
  if hr != S_OK || pEnum == 0
    VariantClear(result)
    raise RuntimeError, "failed to get IEnum Interface"
  end

  VariantClear(result)
  begin
    variant = 0.chr * 16
    VariantInit(variant)
    lpVtbl = 0.chr * 4
    table = 0.chr * 16
    memcpy(lpVtbl, pEnum, 4)
    memcpy(table, lpVtbl.unpack('L').first, 16)
    table = table.unpack('L*')
    next_ = Win32::API::Function.new(table[3], 'PLPP', 'L')
    while next_.call(pEnum, 1, variant, nil) == S_OK
      obj = WIN32OLE.ole_variant2val(variant)
      VariantClear(variant)
      VariantInit(variant)
      yield obj
    end
  ensure
    WIN32OLE.ole_release(pEnum)
  end
  nil
end

#invoke(method, *args) ⇒ `Object`



1815
1816
1817

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

def invoke(method, *args)
  ole_invoke(method, args, DISPATCH_METHOD|DISPATCH_PROPERTYGET, false)
end

#ole_activex_initialize ⇒ `Object`

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

def ole_activex_initialize
  lpVtbl = 0.chr * 4
  table = 0.chr * 28
  memcpy(lpVtbl, @pDispatch, 4)
  memcpy(table, lpVtbl.unpack('L').first, 28)
  table = table.unpack('L*')
  queryInterface = Win32::API::Function.new(table[0], 'PPP', 'L')
  p = 0.chr * 4
  hr = queryInterface.call(pUnknown, IID_IPersistMemory, p)
  pPersistMemory = p.unpack('L').first
  if hr == S_OK
    lpVtbl = 0.chr * 4
    table = 0.chr * 36
    memcpy(lpVtbl, @pDispatch, 4)
    memcpy(table, lpVtbl.unpack('L').first, 36)
    table = table.unpack('L*')
    initNew = Win32::API::Function.new(table[8], 'P', 'L')
    hr = initNew.call(pPersistMemory)
    WIN32OLE.ole_release(pPersistMemory)
    return nil if hr == S_OK
  end
  if hr != S_OK
    raise WIN32OLERuntimeError, "fail to initialize ActiveX control"
  end
  nil
end

#ole_create_dcom(server, host) ⇒ `Object`

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

def ole_create_dcom(server, host)
  clsid = 0.chr * 16
  serverw = multi_to_wide(server)
  hostw = multi_to_wide(host)
  hr = CLSIDFromProgID(serverw, clsid)
  if hr != S_OK
    hr = clsid_from_remote(host, server, clsid)
  end
  if hr != S_OK
    hr = CLSIDFromString(serverw, clsid)
  end
  if hr != S_OK
    raise WIN32OLERuntimeError, "unknown OLE server: `#{server}'"
  end
  serverinfo = 0.chr * 16
  serverinfo[4, 4] = [hostw].pack('P')
  multi_qi = 0.chr * 12
  multi_qi[0, 4] = [IID_IDispatch].pack('P')
  hr = CoCreateInstanceEx(clsid, nil, CLSCTX_REMOTE_SERVER, serverinfo, 1, multi_qi)
  if hr != S_OK
    raise WIN32OLERuntimeError, "failed to create DCOM server `#{server}' in `#{host}'"
  end
  ole_set_member(multi_qi[4, 4].unpack('L').first)
  self
end

#ole_excepinfo2msg(execinfo) ⇒ `Object`

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

def ole_excepinfo2msg(execinfo)
  source = nil
  description = nil
  code, _, src, desc, helpfile, helpconext, _, fillin, scode = execinfo.unpack('SSLLLLLLL')
  if fillin != 0
    fnDeferredFillIn = Win32::API::Function.new(fillin, 'P', 'L')
    fnDeferredFillIn.call(execinfo)
  end
  if src != 0
    str = 0.chr * 256
    wcscpy(str, src)
    source = wide_to_multi(str)
  end
  if desc != 0
    str = 0.chr * 256
    wcscpy(str, desc)
    description = wide_to_multi(str)
  end
  if code == 0
    error_msg = "\n    OLE error code:%X in " % scode
  else
    error_msg = "\n    OLE error code:%u in " % code
  end
  if source
    error_msg << source
  else
    error_msg << "<Unknown>"
  end
  error_msg << "\n      "
  if description
    error_msg << description
  else
    error_msg << "<No Description>"
  end
  error_msg
end

#ole_free ⇒ `Object`

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

def ole_free
  WIN32OLE._ole_free(@pDispatch)
  @pDispatch = nil
  nil
end

#ole_func_methods ⇒ `Object`



2090
2091
2092

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

def ole_func_methods
  _ole_methods(INVOKE_FUNC)
end

#ole_get_methods ⇒ `Object`



2082
2083
2084

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

def ole_get_methods
  _ole_methods(INVOKE_PROPERTYGET)
end

#ole_invoke(method, args, flags, is_bracket) ⇒ `Object`

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

def ole_invoke(method, args, flags, is_bracket)
  excepinfo = 0.chr * 32
  result = 0.chr * 16
  VariantInit(result)
  dp = 0.chr * 16
  argErr = 0.chr * 4
  if !method.is_a?(String) && !method.is_a?(Symbol) && !is_bracket
    raise TypeError, "method is wrong type (expected String or Symbol)"
  end
  if method.is_a?(Symbol)
    method = method.to_s
  end
  if @pDispatch.nil?
    raise RuntimeError, "failed to get dispatch interface"
  end
  if is_bracket
    dispid = DISPID_VALUE
    args.unshift(method)
  else
    wcmdname = multi_to_wide(method)
    lpVtbl = 0.chr * 4
    table = 0.chr * 28
    memcpy(lpVtbl, @pDispatch, 4)
    memcpy(table, lpVtbl.unpack('L').first, 28)
    table = table.unpack('L*')
    getIDsOfNames = Win32::API::Function.new(table[5], 'PPPLLP', 'L')
    p = 0.chr * 4
    hr = getIDsOfNames.call(@pDispatch, IID_NULL, [wcmdname].pack('P'), 1, @@lcid, p)
    dispid = p.unpack('L').first
    if hr != S_OK
      raise WIN32OLERuntimeError, "unknown property or method: `#{method}'"
    end
  end

  param = args[-1]
  dp[12, 4] = [0].pack('L')
  if param.is_a?(Hash)
    cNamedArgs = param.length
    cArgs = cNamedArgs + args.length - 1
    rgvarg = 0.chr * 16 * cArgs
    dp[8, 4] = [cArgs].pack('L')
    pNamedArgs = 0.chr * 4 * (cNamedArgs+1)
    index = 0
    param.each do |key, val|
      if !key.is_a?(String) && !key.is_a?(Symbol)
        for i in 1 .. index
          VariantClear(rgvarg[i*4, 4].unpack('L').first)
        end
        raise TypeError, "wrong argument type (expected String or Symbol)"
      end
      if key.is_a?(Symbol)
        key = key.to_s
      end
      pNamedArgs[(index+1)*4, 4] = [multi_to_wide(key)].pack('P')
      p = rgvarg[index*16, 16]
      VariantInit(p)
      rgvarg[index*16, 16] = p
      p = rgvarg[index*16, 16]
      WIN32OLE.ole_val2variant(val, p)
      rgvarg[index*16, 16] = p
      index += 1
    end
    dp[12, 4] = [index].pack('L')
    pDispID = 0.chr * 4 * (cNamedArgs+1)
    pNamedArgs[0, 4] = [multi_to_wide(method)].pack('P')
    hr = getIDsOfNames.call(@pDispatch, IID_NULL, pNamedArgs, cNamedArgs+1, @@lcid, pDispID)
    if hr != S_OK
      for i in 0 ... cArgs
        p = rgvarg[i*16, 16]
        VariantClear(p)
        rgvarg[i*16, 16] = p
      end
      raise WIN32OLERuntimeError, "failed to get named argument info: `#{method}'"
    end
    dp[4, 4] = [[pDispID].pack('P').unpack('L').first + 4].pack('L')
  else
    cNamedArgs = 0
    cArgs = args.length
    dp[8, 4] = [cArgs].pack('L')
    pNamedArgs = 0.chr * 4 * (cNamedArgs + 1)
    if cArgs > 0
      rgvarg = 0.chr * 16 * cArgs
    end
  end
  if cArgs > cNamedArgs
    realargs = 0.chr * 16 * (cArgs - cNamedArgs + 1)
    for i in cNamedArgs ... cArgs
      n = cArgs - i + cNamedArgs - 1
      p = realargs[n*16, 16]
      VariantInit(p)
      realargs[n*16, 16] = p
      p = rgvarg[n*16, 16]
      VariantInit(p)
      rgvarg[n*16, 16] = p
      param = args[i-cNamedArgs]
      if param.is_a?(WIN32OLE_VARIANT)
        p = rgvarg[n*16, 16]
        VariantCopy(p, param.var)
        rgvarg[n*16, 16] = p
      else
        p = realargs[n*16, 16]
        WIN32OLE.ole_val2variant(param, p)
        realargs[n*16, 16] = p
        rgvarg[n*16, 2] = [VT_VARIANT | VT_BYREF].pack('S')
        rgvarg[n*16+8, 4] = [[realargs].pack('P').unpack('L').first + n*16].pack('L')
        rgvarg[n*16, 16] = p
      end
    end
  end
  dp[0, 4] = [rgvarg].pack('P')
  if (flags & DISPATCH_PROPERTYPUT) != 0
    if cArgs == 0
      raise WIN32OLERuntimeError, "argument error"
    end
    dp[12, 4] = [1].pack('L')
    rgdispidNamedArgs = [DISPID_PROPERTYPUT].pack('L')
    dp[4, 4] = [rgdispidNamedArgs].pack('P')
  end
  lpVtbl = 0.chr * 4
  table = 0.chr * 28
  memcpy(lpVtbl, @pDispatch, 4)
  memcpy(table, lpVtbl.unpack('L').first, 28)
  table = table.unpack('L*')
  invoke = Win32::API::Function.new(table[6], 'PLPLLPPPP', 'L')
  hr = invoke.call(@pDispatch, dispid, IID_NULL, @@lcid, flags, dp, result, excepinfo, argErr)
  if hr != S_OK
    cArgs = dp[8, 4].unpack('L').first
    if cArgs >= cNamedArgs
      for i in cNamedArgs ... cArgs
        n = cArgs - i + cNamedArgs - 1
        param = args[i-cNamedArgs]
        p = rgvarg[n*16, 16]
        WIN32OLE.ole_val2variant(param, p)
        rgvarg[n*16, 16] = p
      end
      dp[0, 4] = [rgvarg].pack('P')
      excepinfo = 0.chr * 32
      VariantInit(result)
      hr = invoke.call(@pDispatch, dispid, IID_NULL, @@lcid, flags, dp, result, excepinfo, argErr)
      if (hr & DISP_E_EXCEPTION == DISP_E_EXCEPTION || hr & DISP_E_MEMBERNOTFOUND == DISP_E_MEMBERNOTFOUND) && dispid > 0x8000
        excepinfo = 0.chr * 32
        hr = invoke.call(@pDispatch, dispid, IID_NULL, @@lcid, flags, dp, nil, excepinfo, argErr)
      end
      cArgs = dp[8, 4].unpack('L').first
      for i in cNamedArgs ... cArgs
        n = cArgs - i + cNamedArgs - 1
        p = rgvarg[n*16, 16]
        VariantClear(p)
        rgvarg[n*16, 16] = p
      end
    end
    if hr != S_OK
      if cArgs > cNamedArgs
        for i in cNamedArgs ... cArgs
          n = cArgs - i + cNamedArgs - 1
          param = args[i-cNamedArgs]
          p = rgvarg[n*16, 16]
          WIN32OLE.ole_val2variant2(param, p)
          rgvarg[n*16, 16] = p
        end
        dp[0, 4] = [rgvarg].pack('P')
        excepinfo = 0.chr * 32
        VariantInit(result)
        hr = invoke.call(@pDispatch, dispid, IID_NULL, @@lcid, flags, dp, result, excepinfo, argErr)
        cArgs = dp[8, 4].unpack('L').first
        for i in cNamedArgs ... cArgs
          n = cArgs - i + cNamedArgs - 1
          p = rgvarg[n*16, 16]
          VariantClear(p)
          rgvarg[n*16, 16] = p
        end
      end
    end
  end

  if cArgs > cNamedArgs
    for i in cNamedArgs ... cArgs
      n = cArgs - i + cNamedArgs - 1
      param = args[i-cNamedArgs]
      if param.is_a?(WIN32OLE_VARIANT)
        p = realargs[n*16, 16]
        WIN32OLE.ole_val2variant(param, p)
        realargs[n*16, 16] = p
      end
    end
    set_argv(realargs, cNamedArgs, cArgs)
  else
    for i in 0 ... cArgs
      p = rgvarg[i*16, 16]
      VariantClear(p)
      rgvarg[i*16, 16] = p
    end
  end

  if hr != S_OK
    v = ole_excepinfo2msg(excepinfo)
    raise WIN32OLERuntimeError, "(in OLE method `#{method}': #{v})"
  end
  obj = WIN32OLE.ole_variant2val(result)
  VariantClear(result)
  obj
end

#ole_invoke2(dispid, args, types, dispkind) ⇒ `Object`

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

def ole_invoke2(dispid, args, types, dispkind)
  unless args.is_a?(Array)
    raise TypeError, "wrong argument type #{args.class} (excepted Array)"
  end
  unless types.is_a?(Array)
    raise TypeError, "wrong argument type #{types.class} (excepted Array)"
  end
  result = 0.chr * 16
  excepinfo = 0.chr * 32
  dispParams = 0.chr * 16
  VariantInit(result)
  dispParams[8, 4] = [args.length].pack('L')
  rgvarg = 0.chr * 16 * args.length
  dispParams[0, 4] = [rgvarg].pack('P')
  realargs = 0.chr * 16 * args.length
  j = args.length
  for i in 0 ... args.length
    j-=1
    p = realargs[i*16, 16]
    VariantInit(p)
    realargs[i*16, 16] = p
    p = rgvarg[i*16, 16]
    VariantInit(p)
    rgvarg[i*16, 16] = p
    vt = types[j]
    rgvarg[i*16, 2] = [vt].pack('S')
    param = args[j]
    if param.nil?
      rgvarg[i*16, 2] = realargs[i*16, 2] = [VT_ERROR].pack('S')
      rgvarg[i*16+8, 4] = realargs[i*16+8, 4] = [DISP_E_PARAMNOTFOUND].pack('L')
    else
      if (vt & VT_ARRAY) != 0
        unless param.is_a?(Array)
          raise TypeError, "wrong argument type #{param.class} (excepted Array)"
        end
        rgsabound = [param.length, 0].pack('LL')
        v = vt & ~(VT_ARRAY | VT_BYREF)
        realargs[i*16+8, 4] = [SafeArrayCreate(v, 1, rgsabound)].pack('L')
        realargs[i*16, 2] = [VT_ARRAY | v].pack('S')
        SafeArrayLock(realargs[i*16+8, 4].unpack('L').first)
        arr = 0.chr * 12
        memcpy(arr, realargs[i*16+8, 4].unpack('L').first, 12)
        pb = arr[12, 4].unpack('L').first
        for ent in 0 ... param.length
          velem = 0.chr * 16
          elem = param[ent]
          WIN32OLE.ole_val2variant(elem, velem)
          if v != VT_VARIANT
            VariantChangeTypeEx(velem, velem, @@lcid, 0, v)
          end
          case v
            when VT_VARIANT
              memcpy(pb, velem, 16)
              pb += 16
            when VT_R8, VT_CY, VT_DATE
              memcpy(pb, velem[8, 8], 8)
              pb += 8
            when VT_BOOL, VT_I2, VT_UI2
              memcpy(pb, velem[8, 2], 2)
              pb += 2
            when VT_UI1, VT_I1
              memcpy(pb, vleme[8, 1], 1)
              pb += 1
            else
              memcpy(pb, vleme[8, 4], 4)
              pb += 4
          end
        end
        SafeArrayUnlock(realargs[i*16+8, 4].unpack('L').first)
      else
        p = realargs[i*16, 16]
        WIN32OLE.ole_val2variant(param, p)
        realargs[i*16, 16] = p
        if vt & ~VT_BYREF != VT_VARIANT
          p = realargs[i*16, 16]
          hr = VariantChangeTypeEx(p, p, @@lcid, 0, vt & ~VT_BYREF)
          realargs[i*16, 16] = p
          if hr != S_OK
            raise TypeError, "not valid value"
          end
        end
      end
      if (vt & VT_BYREF) != 0 || vt == VT_VARIANT
        if vt == VT_VARIANT
          rgvarg[i*16, 2] = [VT_VARIANT | VT_BYREF].pack('S')
        end
        case vt & ~VT_BYREF
          when VT_VARIANT
            rgvarg[i*16+8, 4] = [realargs[i*16, 16]].pack('P')
          when VT_R8, VT_CY, VT_DATE
            rgvarg[i*16+8, 4] = [realargs[i*16+8, 8]].pack('P')
          when VT_BOOL, VT_I2, VT_UI2
            rgvarg[i*16+8, 4] = [realargs[i*16+8, 4]].pack('P')
          when VT_UI1, VT_I1
            rgvarg[i*16+8, 4] = [realargs[i*16+8, 1]].pack('P')
          else
            rgvarg[i*16+8, 4] = [realargs[i*16+8, 4]].pack('P')
        end
      else
        rgvarg[i*16+8, 4] = [realargs[i*16+8, 8]].pack('P')
      end
    end
  end
  dispParams[0, 4] = [rgvarg].pack('P')

  if (dispkind & DISPATCH_PROPERTYPUT) != 0
    dispParams[12, 4] = [1].pack('L')
    dispParams[4, 4] = [DISPID_PROPERTYPUT].pack('L')
  end

  lpVtbl = 0.chr * 4
  table = 0.chr * 28
  memcpy(lpVtbl, @pDispatch, 4)
  memcpy(table, lpVtbl.unpack('L').first, 28)
  table = table.unpack('L*')
  invoke = Win32::API::Function.new(table[6], 'PLPLLPPPP', 'L')
  argErr = 0.chr * 4
  hr = invoke.call(@pDispatch, dispid, IID_NULL, @@lcid, dispkind, dispParams, result, excepinfo, argErr)
  if hr != S_OK
    v = ole_excepinfo2msg(excepinfo)
    raise WIN32OLERuntimeError, "(in OLE method `<dispatch id:#{dispid}>': #{v})"
  end
  cArgs = dispParams[8, 4].unpack('L').first
  if cArgs > 0
    set_argv(realargs, 0, cArgs)
  end

  obj = WIN32OLE.ole_variant2val(result)
  VariantClear(result)
  obj
end

#ole_method(cmdname) ⇒ `Object` Also known as: ole_method_help

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

def ole_method(cmdname)
  unless cmdname.is_a?(String)
    raise TypeError, "1st parameter must be String"
  end
  p = 0.chr * 4
  hr = typeinfo_from_ole(p)
  if hr != S_OK
    rasie RuntimeError, "failed to get ITypeInfo"
  end
  pTypeInfo = p.unpack('L').first
  method = WIN32OLE_METHOD.new
  obj = method.olemethod_from_typeinfo(pTypeInfo, cmdname)
  WIN32OLE.ole_release(pTypeInfo)
  if obj.nil?
    raise WIN32OLERuntimeError, "not found #{cmdname}"
  end
  obj
end

#ole_methods ⇒ `Object`



2078
2079
2080

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

def ole_methods
  _ole_methods(INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF)
end

#ole_propertyput(property, value) ⇒ `Object`

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

def ole_propertyput(property, value)
  dispIDParam = [DISPID_PROPERTYPUT].pack('L')
  wFlags = DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF
  dispParams = 0.chr * 16
  propertyValue = 0.chr * 32
  argErr = 0.chr * 4

  p = propertyValue[0, 16]
  VariantInit(p)
  propertyValue[0, 16] = p
  p = propertyValue[16, 16]
  VariantInit(p)
  propertyValue[16, 16] = p
  excepinfo = 0.chr * 32

  wproperty = multi_to_wide(property)
  lpVtbl = 0.chr * 4
  table = 0.chr * 28
  memcpy(lpVtbl, @pDispatch, 4)
  memcpy(table, lpVtbl.unpack('L').first, 28)
  table = table.unpack('L*')
  getIDsOfNames = Win32::API::Function.new(table[5], 'PPPLLP', 'L')
  invoke = Win32::API::Function.new(table[6], 'PLPLLPPPP', 'L')
  p = 0.chr * 4
  hr = getIDsOfNames.call(@pDispatch, IID_NULL, [wproperty].pack('P'), 1, @@lcid, p)
  dispid = p.unpack('L').first
  if hr != S_OK
    raise WIN32OLERuntimeError, "unknown property or method: `#{property}'"
  end

  p = propertyValue[0, 16]
  WIN32OLE.ole_val2variant(value, p)
  propertyValue[0, 16] = p
  dispParams[4, 4] = [dispIDParam].pack('P')
  dispParams[0, 4] = [propertyValue].pack('P')
  dispParams[8, 4] = [1].pack('L')
  dispParams[12, 4] = [1].pack('L')
  hr = invoke.call(@pDispatch, dispid, IID_NULL, @@lcid, wFlags, dispParams, nil, excepinfo, argErr)
  cArgs = dispParams[8, 4].unpack('L').first
  for index in 0 ... cArgs
    p = propertyValue[index*16, 16]
    VariantClear(p)
    propertyValue[index*16, 16] = p
  end
  if hr != S_OK
    v = ole_excepinfo2msg(excepinfo)
    raise WIN32OLERuntimeError, "(in setting property `#{property}': )#{v}"
  end
  nil
end

#ole_put_methods ⇒ `Object`



2086
2087
2088

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

def ole_put_methods
  _ole_methods(INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF)
end

#ole_query_interface(iid) ⇒ `Object`

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

def ole_query_interface(iid)
  pBuf = multi_to_wide(iid)
  id = 0.chr * 16
  hr = CLSIDFromString(pBuf, id)
  if hr != S_OK
    raise WIN32OLERuntimeError, "invalid iid: `#{iid}'"
  end
  if @pDispatch.nil?
    raise RuntimeError, "failed to get dispatch interface"
  end
  lpVtbl = 0.chr * 4
  table = 0.chr * 28
  memcpy(lpVtbl, @pDispatch, 4)
  memcpy(table, lpVtbl.unpack('L').first, 28)
  table = table.unpack('L*')
  queryInterface = Win32::API::Function.new(table[0], 'PPP', 'L')
  p = 0.chr * 4
  hr = queryInterface.call(@pDispatch, id, p)
  if hr != S_OK
    raise WIN32OLERuntimeError, "failed to get interface `#{iid}'"
  end
  pDispatch = p.unpack('L').first
  WIN32OLE.new(pDispatch)
end

#ole_respond_to?(method) ⇒ `Boolean`

Returns:

(Boolean)

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

def ole_respond_to?(method)
  if !method.is_a?(String) && !method.is_a?(Symbol)
    raise TypeError, "wrong argument type (expected String or Symbol)"
  end
  method = method.to_s if method.is_a?(Symbol)
  wcmdname = multi_to_wide(method)
  lpVtbl = 0.chr * 4
  table = 0.chr * 28
  memcpy(lpVtbl, @pDispatch, 4)
  memcpy(table, lpVtbl.unpack('L').first, 28)
  table = table.unpack('L*')
  getIDsOfNames = Win32::API::Function.new(table[5], 'PPPLLP', 'L')
  p = 0.chr * 4
  hr = getIDsOfNames.call(@pDispatch, IID_NULL, [wcmdname].pack('P'), 1, @@lcid, p)
  hr == S_OK
end

#ole_set_member(dispatch) ⇒ `Object`

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

def ole_set_member(dispatch)
  if @pDispatch
    WIN32OLE.ole_release(@pDispatch)
  end
  @pDispatch = dispatch
  self
end

#ole_type ⇒ `Object` Also known as: ole_obj_help

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

def ole_type
  lpVtbl = 0.chr * 4
  table = 0.chr * 28
  memcpy(lpVtbl, @pDispatch, 4)
  memcpy(table, lpVtbl.unpack('L').first, 28)
  table = table.unpack('L*')
  pTypeInfo = 0.chr * 4
  getTypeInfo = Win32::API::Function.new(table[4], 'PLLP', 'L')
  hr = getTypeInfo.call(pDispatch, 0, @lcid, pTypeInfo)
  if hr != S_OK
    raise RuntimeError, "failed to GetTypeInfo"
  end
  pTypeInfo = pTypeInfo.unpack('L').first
  type = ole_type_from_itypeinfo(pTypeInfo)
  WIN32OLE.ole_release(pTypeInfo)
  if type.nil?
    riase RuntimeError, "failed to create WIN32OLE_TYPE obj from ITypeInfo"
  end
  type
end

#ole_typelib ⇒ `Object`

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

def ole_typelib
  lpVtbl = 0.chr * 4
  table = 0.chr * 28
  memcpy(lpVtbl, @pDispatch, 4)
  memcpy(table, lpVtbl.unpack('L').first, 28)
  table = table.unpack('L*')
  getTypeInfo = Win32::API::Function.new(table[4], 'PLLP', 'L')
  p = 0.chr * 4
  hr = getTypeInfo.call(pDispatch, 0, @lcid, p)
  if hr != S_OK
    raise RuntimeError, "failed to GetTypeInfo"
  end
  pTypeInfo = p.unpack('L').first
  vtlib = ole_typelib_from_itypeinfo(pTypeInfo)
  WIN32OLE.ole_release(pTypeInfo)
  if vtlib.nil?
    raise RuntimeError, "failed to get type library info."
  end
  vtlib
end

#set_argv(realargs, st, ed) ⇒ `Object`

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

def set_argv(realargs, st, ed)
  argv = WIN32OLE::ARGV
  argv.clear
  while (ed-=1) > st
    argv.push(WIN32OLE.ole_variant2val(realargs[ed*16, 16]))
    p = realargs[ed*16, 16]
    VariantClear(p)
    realargs[ed*16, 16] = p
  end
  argv
end

#setproperty(property, *args) ⇒ `Object`



1913
1914
1915

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

def setproperty(property, *args)
  ole_invoke(property, args, DISPATCH_PROPERTYPUT, false)
end

#typeinfo_from_ole(ppti) ⇒ `Object`

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

def typeinfo_from_ole(ppti)
  lpVtbl = 0.chr * 4
  table = 0.chr * 28
  memcpy(lpVtbl, @pDispatch, 4)
  memcpy(table, lpVtbl.unpack('L').first, 28)
  table = table.unpack('L*')
  getTypeInfo = Win32::API::Function.new(table[4], 'PLLP', 'L')
  p = 0.chr * 4
  hr = getTypeInfo.call(@pDispatch, 0, @@lcid, p)
  if hr != S_OK
    raise rb_eRuntimeError, "failed to GetTypeInfo"
  end
  pTypeInfo = p.unpack('L').first
  lpVtbl = 0.chr * 4
  table = 0.chr * 80
  memcpy(lpVtbl, pTypeInfo, 4)
  memcpy(table, lpVtbl.unpack('L').first, 80)
  table = table.unpack('L*')
  getDocumentation = Win32::API::Function.new(table[12], 'PLPPPP', 'L')
  getContainingTypeLib = Win32::API::Function.new(table[18], 'PPP', 'L')
  bstr = 0.chr * 4
  hr = getDocumentation.call(pTypeInfo, -1, bstr, nil, nil, nil)
  str = 0.chr * 256
  wcscpy(str, bstr.unpack('L').first)
  type = wide_to_multi(str)
  p = 0.chr * 4
  i = 0.chr * 4
  hr = getContainingTypeLib.call(pTypeInfo, p, i)
  WIN32OLE.ole_release(pTypeInfo)
  if hr != S_OK
    raise RuntimeError, "failed to GetContainingTypeLib"
  end
  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')
  count = getTypeInfoCount.call(pTypeLib)
  for i in 0 ... count
    bstr = 0.chr * 4
    hr = getDocumentation.call(pTypeLib, i, bstr, nil, nil, nil)
    if hr == S_OK
      str = 0.chr * 256
      wcscpy(str, bstr.unpack('L').first)
      if wide_to_multi(str) == type
        p = 0.chr * 4
        hr = getTypeInfo.call(pTypeLib, i, p)
        if hr == S_OK
          ppti[0, 4] = p
          break
        end
      end
    end
  end
  WIN32OLE.ole_release(pTypeLib)
  hr
end

#val2dispatch(val) ⇒ `Object`

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

def val2dispatch(val)
  if (pdisp = @@com_hash[val])
    refcount = data[4, 4].unpack('L').first
    pdisp[4, 4] = [refcount+1].pack('L')
  else
    pdisp = [@@com_vtbl].pack('P') + [1, val.object_id].pack('L*')
    @@com_hash[val] = pdisp
  end
  [pdisp].unpack('P').unpack('L').first
end

Class: WIN32OLE

Defined Under Namespace

Constant Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(server = nil, host = nil) ⇒ WIN32OLE

Dynamic Method Handling

#method_missing(id, *args) ⇒ Object

Instance Attribute Details

#pDispatch ⇒ Object

Class Method Details

._ole_free(dispatch) ⇒ Object

.ary_len_of_dim(ary, dim) ⇒ Object

.ary_new_dim(myary, pid, plb, dim) ⇒ Object

.ary_store_dim(myary, pid, plb, dim, val) ⇒ Object

.attach(dispatch) ⇒ Object

.codepage ⇒ Object

.codepage=(cp) ⇒ Object

.connect(server) ⇒ Object

.const_load(ole, mod = WIN32OLE) ⇒ Object

.create_guid ⇒ Object

.dimension(val) ⇒ Object

.get_control_from_hwnd(hnd) ⇒ Object

.get_ptr_of_variant(pvar) ⇒ Object

.is_all_index_under(pid, pub, dim) ⇒ Object

.lcid_installed(lcid) ⇒ Object

.locale ⇒ Object

.locale=(lcid) ⇒ Object

.ole_addref(dispatch) ⇒ Object

.ole_ary_m_entry(val, pid) ⇒ Object

.ole_bind_obj(moniker) ⇒ Object

.ole_const_load(pTypeLib, mod) ⇒ Object

.ole_cp2encoding(cp) ⇒ Object

.ole_free(obj) ⇒ Object

.ole_initialize ⇒ Object

.ole_methods_from_typeinfo(pTypeInfo, mask) ⇒ Object

.ole_methods_sub(pOwnerTypeInfo, pTypeInfo, methods, mask) ⇒ Object

.ole_reference_count(obj) ⇒ Object

.ole_release(dispatch) ⇒ Object

.ole_set_safe_array(n, psa, pid, pub, val, dim, vt) ⇒ Object

.ole_show_help(info, helpcontext = nil) ⇒ Object

.ole_type_from_itypeinfo(pTypeInfo) ⇒ Object

.ole_typelib_from_itypeinfo(pTypeInfo) ⇒ Object

.ole_typelib_from_itypelib(pTypeLib) ⇒ Object

.ole_types_from_typelib(pTypeLib, classes) ⇒ Object

.ole_uninitialize ⇒ Object

.ole_val2variant(val, var) ⇒ Object

.ole_val2variant2(val, var) ⇒ Object

.ole_val2variant_ex(val, var, vt) ⇒ Object

.ole_val_ary2variant_ary(val, var, vt) ⇒ Object

.ole_variant2val(pvar) ⇒ Object

.oleclass_from_typelib(obj, pTypeLib, oleclass) ⇒ Object

.time_object2date(tm) ⇒ Object

.val2variant_ptr(val, var, vt) ⇒ Object