Class: WIN32OLE_VARIANT

Inherits:

Object

• Object
• WIN32OLE_VARIANT

Defined in:

lib/win32ole-pr.rb

Constant Summary

Empty =

WIN32OLE_VARIANT.new(WIN32OLE::VARIANT::VT_EMPTY)

Null =

WIN32OLE_VARIANT.new(WIN32OLE::VARIANT::VT_NULL)

Nothing =

WIN32OLE_VARIANT.new(WIN32OLE::VARIANT::VT_DISPATCH)

Class Method Summary

• .array(ary, vt) ⇒ Object
• .ole_val2olevariantdata(val, vt) ⇒ Object

Instance Method Summary

• #[](*args) ⇒ Object
• #[]=(*args) ⇒ Object
• #ary2safe_array_index(ary, psa) ⇒ Object
• #get_locked_safe_array ⇒ Object
• #initialize(val = nil, vartype = nil) ⇒ WIN32OLE_VARIANT constructor

  A new instance of WIN32OLE_VARIANT.

• #unlock_safe_array(psa) ⇒ Object
• #value ⇒ Object
• #value=(val) ⇒ Object
• #vartype ⇒ Object

Constructor Details

#initialize(val = nil, vartype = nil) ⇒ WIN32OLE_VARIANT

Returns a new instance of WIN32OLE_VARIANT.

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

def initialize(val=nil, vartype=nil)
   WIN32OLE.ole_initialize    
   @var = 0.chr * 16
   @realvar = 0.chr * 16
   return self if val.nil?
   if !val.is_a?(WIN32OLE) && !val.is_a?(WIN32OLE_VARIANT) && !val.is_a?(Time)
      case val
      when Array,String,Fixnum,Bignum,TrueClass,FalseClass,NilClass
      else
         raise TypeError, "can not convert WIN32OLE_VARIANT from type #{val.class}"
      end
   end
   if vartype.nil?
      WIN32OLE.ole_val2variant(val,@var)
   else
      WIN32OLE_VARIANT.ole_val2olevariantdata(val,vartype)
   end
end

Class Method Details

.array(ary, vt) ⇒ Object

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

def self.array(ary,vt)
    obj = nil
   dim = 0
   i = 0

   WIN32OLE.ole_initialize()

   vt = (vt | VT_ARRAY)
   unless ary.is_a?(Array)
      raise TypeError, "1st parameter must be Array"
   end
   obj = WIN32OLE_VARIANT.new

   dim = ary.length

   psab = 0.chr * 8 * dim

   for i in 0 ... dim
      psab[i*8,4] = [ary[i]].pack('L')
      psab[i*8+4,4] = [0].pack('L')
   end

   psa = SafeArrayCreate((vt & VT_TYPEMASK), dim, psab)
   if psa == 0
      raise RuntimeError, "memory allocation error(SafeArrayCreate)"
   end

   @var[0,2] = [vt].pack('S')
   if (vt & VT_BYREF) != 0
      @realvar[0,2] = [vt & ~VT_BYREF].pack('S')
      @realvar[8,4] = [psa].pack('P')
      @var[8,4] = [@realvar.unpack('P')].pack('P')
   else
      @var[8,4] = [psa].pack('P')
   end
   obj
end

.ole_val2olevariantdata(val, vt) ⇒ Object

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

def self.ole_val2olevariantdata(val,vt)
   hr = S_OK

   if (vt & ~VT_BYREF) ==  (VT_ARRAY | VT_UI1) && val.class == String
      len = val.length
      psa = SafeArrayCreateVector(VT_UI1, 0, len)
      if psa == 0
         raise RuntimeError, "fail to SafeArrayCreateVector"
      end
      pdest = 0.chr * 4
      hr = SafeArrayAccessData(psa, pdest)
      if hr == S_OK
         memcpy(pdest.unpack('L').first, val, len)
         SafeArrayUnaccessData(psa)
         @realvar[0,2] = [(vt & ~VT_BYREF)].pack('S')
         p = @realvar[8,4].unpack('L').first
         if p != 0
            SafeArrayDestroy(p)
         end
         @realvar[8,4] = [psa].pack('L')
         if (vt & VT_BYREF) != 0
            @var[0,2] = [vt].pack('S')
            @var[8,4] = [[@realvar].pack('P')].pack('L')
          else 
            hr = VariantCopy(@var, @realvar)
         end
      else 
         if psa != 0
            SafeArrayDestroy(psa)
         end
      end
    elsif (vt & VT_ARRAY) != 0
      if val.nil?
         @var[0,2] = [vt].pack('S')
         if (vt & VT_BYREF) != 0
            @var[8,4] = [[@realvar].pack('P')].pack('L')
         end
      else 
         hr = ole_val_ary2variant_ary(val, @realvar, (vt & ~VT_BYREF))
         if hr == S_OK
            if (vt & VT_BYREF) != 0
               @var[0,2] = [vt].pack('S')
               @var[8,4] = [[@realvar].pack('P')].pack('L')
            else 
               hr = VariantCopy(@var,@realvar)
            end 
         end         
      end
    elsif  (vt & ~VT_BYREF) == VT_I8 || (vt & ~VT_BYREF) == VT_UI8 
      ole_val2variant_ex(val, @realvar, (vt & ~VT_BYREF))
      ole_val2variant_ex(val, @var, (vt & ~VT_BYREF))
      @var[0,2] = [vt].pack('S')
      if (vt & VT_BYREF) != 0
         ole_set_byref(@realvar, @var, vt)
      end
    else 
      if val.nil?
         @var[0,2] = [vt].pack('S')
         if (vt == (VT_BYREF | VT_VARIANT)) 
            ole_set_byref(@realvar, @var, vt)
         else 
            @realvar[0,2] = [vt & ~VT_BYREF].pack('S')
            if (vt & VT_BYREF) != 0
               ole_set_byref(@realvar, @var, vt)
            end
         end
      else 
         ole_val2variant_ex(val, @realvar, (vt & ~VT_BYREF))
         if (vt == (VT_BYREF | VT_VARIANT)) 
            ole_set_byref(@realvar, @var, vt)
         elsif (vt & VT_BYREF) != 0
            if  (vt & ~VT_BYREF) != @realvar[0,2].unpack('S').first 
               hr = VariantChangeTypeEx(@realvar, @realvar, 
                     WIN32OLE.locale, 0, (vt & ~VT_BYREF))
            end
            if hr == S_OK
               ole_set_byref(@realvar, @var, vt)
            end
         else 
            if vt == @realvar[0,2].unpack('S').first 
               hr = VariantCopy(@var, @realvar)
            else 
               hr = VariantChangeTypeEx(@var, @realvar, 
                     WIN32OLE.locale, 0, vt)
            end
         end   
      end   
   end   
   
   if hr != S_OK
      raise WIN32OLERuntimeError, "failed to change type"
   end

end

Instance Method Details

#[](*args) ⇒ Object

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

def [](*args)
   val = nil
   if (@var[0,2].unpack('S').first & VT_ARRAY) != 0
      raise WIN32OLERuntimeError, "`[]' is not available for this variant type object"
   end
   psa = get_locked_safe_array()
   return val if psa==0
   
   pid = ary2safe_array_index(args, psa)
   variant = 0.chr*16
   VariantInit(variant)
   variant[0,2] = [(@var[0,2].unpack('S').first & ~VT_ARRAY) | VT_BYREF].pack('S')
   hr = SafeArrayPtrOfIndex(psa, pid, variant[8,4])
   if hr != S_OK
      raise WIN32OLERuntimeError, "failed to SafeArrayPtrOfIndex"
   end
   val = WIN32OLE.ole_variant2val(variant)

   unlock_safe_array(psa)
   val      
end

#[]=(*args) ⇒ Object

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

def []=(*args)
   if (@var[0,2].unpack('S').first & VT_ARRAY) != 0
      raise WIN32OLERuntimeError, "`[]' is not available for this variant type object"
   end
   psa = get_locked_safe_array()
   if psa == 0
      raise RuntimeError, "failed to get SafeArray pointer"
   end
   pid = ary2safe_array_index(args[0..-2], psa)
   var = 0.chr * 16
   VariantInit(var)
   vt = @var[0,2].unpack('S').first & ~VT_ARRAY
   p = val2variant_ptr(args[-1], var, vt)
   if (var[0,2].unpack('S').first == VT_DISPATCH || var[0,2].unpack('S').first == VT_UNKNOWN) && var[8,4].unpack('L').first == 0
      raise WIN32OLERuntimeError, "argument does not have IDispatch or IUnknown Interface"
   end
   hr = SafeArrayPutElement(psa, pid, p)
   if hr != S_OK
      raise WIN32OLERuntimeError, "failed to SafeArrayPutElement"
   end

   unlock_safe_array(psa)
   args[1]
end

#ary2safe_array_index(ary, psa) ⇒ Object

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

def ary2safe_array_index(ary,psa)
   dim = SafeArrayGetDim(psa)
   if dim != ary.length
      raise ArgError, "unmatch number of indices"        
   end
   pid = 0.chr * 4 * dim
   for i in 0 ... dim
      pid[i*4,4] = [ary[i]].pack('L')
   end
   pid
end

#get_locked_safe_array ⇒ Object

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

def get_locked_safe_array
   if (@var[0,2].unpack('S').first & VT_ARRAY) != 0
      raise TypeError, "variant type is not VT_ARRAY."
   end
   if (@var[0,2].unpack('S').first & VT_BYREF) != 0
      ref = 0.chr * 16
      memcpy(ref,@var[8,4].unpack('L').first,16)
      pas = ref[8,4].unpack('L').first
   else
      psa = @var[8,4].unpack('L').first
   end
   return psa if psa == 0
   hr = SafeArrayLock(psa)
   if hr != S_OK
      raise eRuntimeError, "failed to SafeArrayLock"
   end
   psa
end

#unlock_safe_array(psa) ⇒ Object

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

def unlock_safe_array(psa)
   hr = SafeArrayUnlock(psa)
   if hr != S_OK
      raise RuntimeError, "failed to SafeArrayUnlock"
   end
end

#value ⇒ Object

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

def value
   val = WIN32OLE.ole_variant2val(@var)
   vt = @var[0,2].unpack('S').first

   if (vt & ~VT_BYREF) == (VT_UI1|VT_ARRAY)
      if (vt & VT_BYREF) != 0
         memcpy(ref,@var[8,4].unpack('L').first,16)            
         psa = ref[8,4].unpack('L').first
      else 
         psa = @var[8,4].unpack('L').first
      end
      if psa == 0
         return val
      end
      dim = SafeArrayGetDim(psa)
      if dim == 1
         val = val.pack('C*')
      end
   end
   val
end

#value=(val) ⇒ Object

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

def value=(val)
   vt = @var[0,2].unpack('S').first
   if (vt & VT_ARRAY) != 0 && ((vt & ~VT_BYREF) != (VT_UI1|VT_ARRAY) || val.class != String)
      raise WIN32OLERuntimeError, "`value=' is not available for this variant type object"
   end
   WIN32OLE_VARIANT.ole_val2olevariantdata(val, vt)
   nil
end

#vartype ⇒ Object

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

def vartype
   @var.unpack('S').first
end