Attachment 143762 Details for Bug 68194 – this file have the changes which we require to get a safearray of IDispatch interface from OLE.

this file have the changes which we require to get a safearray of IDispatch interface from OLE.

Variant.java (text/plain), 37.01 KB, created by padamev297

on 2009-08-07 07:04:10 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: padamev297

Created: 2009-08-07 07:04:10 EDT

Size: 37.01 KB

patch

obsolete

>/*******************************************************************************
> * Copyright (c) 2000, 2008 IBM Corporation and others.
> * All rights reserved. This program and the accompanying materials
> * are made available under the terms of the Eclipse Public License v1.0
> * which accompanies this distribution, and is available at
> * http://www.eclipse.org/legal/epl-v10.html
> *
> * Contributors:
> * IBM Corporation - initial API and implementation
> *******************************************************************************/
>package org.eclipse.swt.ole.win32;
>
>import org.eclipse.swt.*;
>import org.eclipse.swt.internal.ole.win32.*;
>import org.eclipse.swt.internal.win32.*;
>/**
> *
> * A Variant is a generic OLE mechanism for passing data of different types via a common interface.
> *
> * It is used within the OleAutomation object for getting a property, setting a property or invoking
> * a method on an OLE Control or OLE Document.
> *
> */
>
>	
>public final class Variant {
>	/**
>	* The size in bytes of a native VARIANT struct.
>	*/
>	public static final int sizeof = VARIANT.sizeof;
>	
>	static int CodePage = OS.GetACP();
>
>	private short type; // OLE.VT_* type
>	private boolean booleanData;
>	private byte byteData;
>	private short shortData;
>	private char charData;
>	private int intData;
>	private long longData;
>	private float floatData;
>	private double doubleData;
>	private String stringData;
>	private int /*long*/ byRefPtr;
>	private IDispatch dispatchData;
>	private IUnknown unknownData;
>	private static IDispatch[] dispatchDataArr;
>
>/**	 
> * Invokes platform specific functionality to copy a variant
> * into operating system memory.
> * 
> * IMPORTANT: This method is not part of the public
> * API for <code>Variant</code>. It is marked public only so that it
> * can be shared within the packages provided by SWT. It is not
> * available on all platforms, and should never be called from
> * application code.
> * 
> *
> * @param pVarDest destination pointer to a variant
> * @param varSrc source <code>Variant</code>
> *
> * @since 3.3
> */
>public static void win32_copy (int /*long*/ pVarDest, Variant varSrc) {
>	varSrc.getData (pVarDest);
>}
>
>/**	 
> * Invokes platform specific functionality to wrap a variant
> * that was allocated in operating system memory.
> * 
> * IMPORTANT: This method is not part of the public
> * API for <code>Variant</code>. It is marked public only so that it
> * can be shared within the packages provided by SWT. It is not
> * available on all platforms, and should never be called from
> * application code.
> * 
> *
> * @param pVariant pointer to a variant
> *
> * @return a new <code>Variant</code>
> *
> * @since 3.3
> */
>public static Variant win32_new (int /*long*/ pVariant) {
>	Variant variant = new Variant ();
>	variant.setData (pVariant);
>	return variant;
>}
>
>/**
> * Create an empty Variant object with type VT_EMPTY.
> * 
> * @since 2.0
> */	
>public Variant(){
>	type = COM.VT_EMPTY;
>}
>/**
> * Create a Variant object which represents a Java float as a VT_R4.
> *
> * @param val the Java float value that this Variant represents
> *
> */
>public Variant(float val) {
>	type = COM.VT_R4;
>	floatData = val;
>	
>}
>/**
> * Create a Variant object which represents a Java double as a VT_R8.
> *
> * @param val the Java double value that this Variant represents
> *
> * @since 3.2
> */
>public Variant(double val) {
>	type = COM.VT_R8;
>	doubleData = val;
>}
>/**
> * Create a Variant object which represents a Java int as a VT_I4.
> *
> * @param val the Java int value that this Variant represents
> *
> */
> public Variant(int val) {
>	type = COM.VT_I4;
>	intData = val;
>}
>/**
> * Create a Variant object which contains a reference to the data being transferred.
> *
> * When creating a VT_BYREF Variant, you must give the full Variant type 
> * including VT_BYREF such as
> * 
> * <pre><code>short byRefType = OLE.VT_BSTR | OLE.VT_BYREF</code></pre>.
> *
> * @param ptr a pointer to the data being transferred.
> * @param byRefType the type of the data being transferred such as OLE.VT_BSTR | OLE.VT_BYREF
> *
> */
>public Variant(int /*long*/ ptr, short byRefType) {
>	type = byRefType;
>	byRefPtr = ptr;
>}
>/**
> * Create a Variant object which represents an IDispatch interface as a VT_Dispatch.
> *
> * @param automation the OleAutomation object that this Variant represents
> * 
> */
>public Variant(OleAutomation automation) {
>	type = COM.VT_DISPATCH;
>	dispatchData = new IDispatch(automation.getAddress());
>}
>/**
> * Create a Variant object which represents an IDispatch interface as a VT_Dispatch.
> * The caller is expected to have appropriately invoked unknown.AddRef() before creating 
> * this Variant.
> * 
> * @since 2.0
> * 
> * @param idispatch the IDispatch object that this Variant represents
> * 
> */
>public Variant(IDispatch idispatch) {
>	type = COM.VT_DISPATCH;
>	dispatchData = idispatch;
>}
>/**
> * Create a Variant object which represents an IUnknown interface as a VT_UNKNOWN.
> *
> * The caller is expected to have appropriately invoked unknown.AddRef() before creating 
> * this Variant.
> *
> * @param unknown the IUnknown object that this Variant represents
> *
> */
>public Variant(IUnknown unknown) {
>	type = COM.VT_UNKNOWN;
>	unknownData = unknown;
>}
>/**
> * Create a Variant object which represents a Java long as a VT_I8.
> *
> * @param val the Java long value that this Variant represents
> *
> * @since 3.2
> */
> public Variant(long val) {
>	type = COM.VT_I8;
>	longData = val;
>}
>/**
> * Create a Variant object which represents a Java String as a VT_BSTR.
> *
> * @param string the Java String value that this Variant represents
> *
> */
>public Variant(String string) {
>	type = COM.VT_BSTR;
>	stringData = string;
>}
>/**
> * Create a Variant object which represents a Java short as a VT_I2.
> *
> * @param val the Java short value that this Variant represents
> *
> */
>public Variant(short val) {
>	type = COM.VT_I2;
>	shortData = val;
>}
>/**
> * Create a Variant object which represents a Java boolean as a VT_BOOL.
> *
> * @param val the Java boolean value that this Variant represents
> *
> */
>public Variant(boolean val) {
>	type = COM.VT_BOOL;
>	booleanData = val;
>}
>
>/**
> * Calling dispose will release resources associated with this Variant.
> * If the resource is an IDispatch or IUnknown interface, Release will be called.
> * If the resource is a ByRef pointer, nothing is released.
> * 
> * @since 2.1
> */
>public void dispose() {
>	if ((type & COM.VT_BYREF) == COM.VT_BYREF) {
>		return;
>	}
>		
>	switch (type) {
>		case COM.VT_DISPATCH :
>			dispatchData.Release();
>			break;
>		case COM.VT_UNKNOWN :
>			unknownData.Release();
>			break;
>	}
>	
>}
>/**
> * Returns the OleAutomation object represented by this Variant.
> *
> * If this Variant does not contain an OleAutomation object, an attempt is made to
> * coerce the Variant type into an OleAutomation object. If this fails, an error is
> * thrown. Note that OleAutomation objects must be disposed when no longer
> * needed.
> *
> * @return the OleAutomation object represented by this Variant
> *
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant can not be coerced into an OleAutomation object</li>
> * </ul>
> */
>public OleAutomation getAutomation() {
>	if (type == COM.VT_EMPTY) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, -1);
>	}
>	if (type == COM.VT_DISPATCH) {
>		return new OleAutomation(dispatchData);
>	}
>	// try to coerce the value to the desired type
>	int /*long*/ oldPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	int /*long*/ newPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	try {
>		getData(oldPtr);
>		int result = COM.VariantChangeType(newPtr, oldPtr, (short) 0, COM.VT_DISPATCH);
>		if (result != COM.S_OK)
>			OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, result);
>		Variant autoVar = new Variant();
>		autoVar.setData(newPtr);
>		return autoVar.getAutomation();
>	} finally {
>		COM.VariantClear(oldPtr);
>		OS.GlobalFree(oldPtr);
>		COM.VariantClear(newPtr); // Note: This must absolutely be done AFTER the 
>		 // OleAutomation object is created as Variant Clear 
>		 // will result in a Release being performed on the 
>		 // Dispatch object
>		OS.GlobalFree(newPtr);
>	}
>}
>/**
> * Returns the IDispatch object represented by this Variant.
> *
> * If this Variant does not contain an IDispatch object, an attempt is made to
> * coerce the Variant type into an IDIspatch object. If this fails, an error is
> * thrown.
> *
> * @since 2.0
> * 
> * @return the IDispatch object represented by this Variant
> *
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant can not be coerced into an IDispatch object</li>
> * </ul>
> */
>public IDispatch getDispatch() {
>	if (type == COM.VT_EMPTY) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, -1);
>	}
>	if (type == COM.VT_DISPATCH) {
>		return dispatchData;
>	}
>	// try to coerce the value to the desired type
>	int /*long*/ oldPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	int /*long*/ newPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	try {
>		getData(oldPtr);
>		int result = COM.VariantChangeType(newPtr, oldPtr, (short) 0, COM.VT_DISPATCH);
>		if (result != COM.S_OK)
>			OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, result);
>		Variant autoVar = new Variant();
>		autoVar.setData(newPtr);
>		return autoVar.getDispatch();
>	} finally {
>		COM.VariantClear(oldPtr);
>		OS.GlobalFree(oldPtr);
>		COM.VariantClear(newPtr); // Note: This must absolutely be done AFTER the 
>		 // OleAutomation object is created as Variant Clear 
>		 // will result in a Release being performed on the 
>		 // Dispatch object
>		OS.GlobalFree(newPtr);
>	}
>}
>
>public IDispatch[] getDispatcharr() {
>	if (type == COM.VT_EMPTY) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, -1);
>	}
>	if (type == (OLE.VT_ARRAY|COM.VT_DISPATCH)) {
>		return dispatchDataArr;
>	}
>	return null;
>	
>}
>/**
> * Returns the Java boolean represented by this Variant.
> *
> * If this Variant does not contain a Java boolean, an attempt is made to
> * coerce the Variant type into a Java boolean. If this fails, an error is thrown.
> *
> * @return the Java boolean represented by this Variant
> *
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant can not be coerced into a boolean</li>
> * </ul>
> *
> */
>public boolean getBoolean() {
>	if (type == COM.VT_EMPTY) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, -1);
>	}
>	if (type == COM.VT_BOOL) {
>		return booleanData;
>	}
>
>	// try to coerce the value to the desired type
>	int /*long*/ oldPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	int /*long*/ newPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	try {
>		getData(oldPtr);
>		int result = COM.VariantChangeType(newPtr, oldPtr, (short) 0, COM.VT_BOOL);
>		if (result != COM.S_OK)
>			OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, result);
>		Variant boolVar = new Variant();
>		boolVar.setData(newPtr);
>		return boolVar.getBoolean();
>	} finally {
>		COM.VariantClear(oldPtr);
>		OS.GlobalFree(oldPtr);
>		COM.VariantClear(newPtr);
>		OS.GlobalFree(newPtr);
>	}
>}
>/**
> * Returns a pointer to the referenced data represented by this Variant.
> *
> * If this Variant does not contain a reference to data, zero is returned.
> *
> * @return a pointer to the referenced data represented by this Variant or 0
> *
> */
>public int /*long*/ getByRef() {
>	if (type == COM.VT_EMPTY) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, -1);
>	}
>	if ((type & COM.VT_BYREF)== COM.VT_BYREF) {
>		return byRefPtr;
>	}
>		
>	return 0;
>}
>/**
> * Returns the Java byte represented by this Variant.
> *
> * If this Variant does not contain a Java byte, an attempt is made to
> * coerce the Variant type into a Java byte. If this fails, an error is thrown.
> *
> * @return the Java byte represented by this Variant
> *
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant can not be coerced into a byte</li>
> * </ul>
> * 
> * @since 3.3
> */
>public byte getByte() {
>	if (type == COM.VT_EMPTY) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, -1);
>	}
>	if (type == COM.VT_I1) {
>		return byteData;
>	}
>		
>	// try to coerce the value to the desired type
>	int /*long*/ oldPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	int /*long*/ newPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	try {
>		getData(oldPtr);
>		int result = COM.VariantChangeType(newPtr, oldPtr, (short) 0, COM.VT_I1);
>		if (result != COM.S_OK)
>			OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, result);
>		Variant byteVar = new Variant();
>		byteVar.setData(newPtr);
>		return byteVar.getByte();
>	} finally {
>		COM.VariantClear(oldPtr);
>		OS.GlobalFree(oldPtr);
>		COM.VariantClear(newPtr);
>		OS.GlobalFree(newPtr);
>	}
>}
>/**
> * Returns the Java char represented by this Variant.
> *
> * If this Variant does not contain a Java char, an attempt is made to
> * coerce the Variant type into a Java char. If this fails, an error is thrown.
> *
> * @return the Java char represented by this Variant
> *
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant can not be coerced into a char</li>
> * </ul>
> * 
> * @since 3.3
> */
>public char getChar() {
>	if (type == COM.VT_EMPTY) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, -1);
>	}
>	if (type == COM.VT_UI2) {
>		return charData;
>	}
>		
>	// try to coerce the value to the desired type
>	int /*long*/ oldPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	int /*long*/ newPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	try {
>		getData(oldPtr);
>		int result = COM.VariantChangeType(newPtr, oldPtr, (short) 0, COM.VT_UI2);
>		if (result != COM.S_OK)
>			OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, result);
>		Variant charVar = new Variant();
>		charVar.setData(newPtr);
>		return charVar.getChar();
>	} finally {
>		COM.VariantClear(oldPtr);
>		OS.GlobalFree(oldPtr);
>		COM.VariantClear(newPtr);
>		OS.GlobalFree(newPtr);
>	}
>}
>void getData(int /*long*/ pData){
>	if (pData == 0) OLE.error(OLE.ERROR_OUT_OF_MEMORY);
>	
>	COM.VariantInit(pData);
>
>	if ((type & COM.VT_BYREF) == COM.VT_BYREF) {
>		//TODO - use VARIANT structure
>		COM.MoveMemory(pData, new short[] {type}, 2);
>		COM.MoveMemory(pData + 8, new int /*long*/[]{byRefPtr}, OS.PTR_SIZEOF);
>		return;
>	}
>
>	switch (type) {
>		case COM.VT_EMPTY :
>		case COM.VT_NULL :
> COM.MoveMemory(pData, new short[] {type}, 2);
>			break;
>		case COM.VT_BOOL :
>			COM.MoveMemory(pData, new short[] {type}, 2);
>			COM.MoveMemory(pData + 8, new short[]{(booleanData) ? COM.VARIANT_TRUE : COM.VARIANT_FALSE}, 2);
>			break;
>		case COM.VT_I1 :
>			COM.MoveMemory(pData, new short[] {type}, 2);
>			COM.MoveMemory(pData + 8, new byte[]{byteData}, 1);
>			break;
>		case COM.VT_I2 :
>			COM.MoveMemory(pData, new short[] {type}, 2);
>			COM.MoveMemory(pData + 8, new short[]{shortData}, 2);
>			break;
>		case COM.VT_UI2 :
>			COM.MoveMemory(pData, new short[] {type}, 2);
>			COM.MoveMemory(pData + 8, new char[]{charData}, 2);
>			break;
>		case COM.VT_I4 :
>			COM.MoveMemory(pData, new short[] {type}, 2);
>			COM.MoveMemory(pData + 8, new int[]{intData}, 4);
>			break;
>		case COM.VT_I8 :
>			COM.MoveMemory(pData, new short[] {type}, 2);
>			COM.MoveMemory(pData + 8, new long[]{longData}, 8);
>			break;
>		case COM.VT_R4 :
>			COM.MoveMemory(pData, new short[] {type}, 2);
>			COM.MoveMemory(pData + 8, new float[]{floatData}, 4);
>			break;
>		case COM.VT_R8 :
>			COM.MoveMemory(pData, new short[] {type}, 2);
>			COM.MoveMemory(pData + 8, new double[]{doubleData}, 8);
>			break;
>		case COM.VT_DISPATCH :
>			dispatchData.AddRef();
>			COM.MoveMemory(pData, new short[] {type}, 2);
>			COM.MoveMemory(pData + 8, new int /*long*/[]{dispatchData.getAddress()}, OS.PTR_SIZEOF);
>			break;
>		case COM.VT_UNKNOWN :
>			unknownData.AddRef();
>			COM.MoveMemory(pData, new short[] {type}, 2);
>			COM.MoveMemory(pData + 8, new int /*long*/[]{unknownData.getAddress()}, OS.PTR_SIZEOF);
>			break;
>		case COM.VT_BSTR :
>			COM.MoveMemory(pData, new short[] {type}, 2);
>			char[] data = (stringData+"\0").toCharArray();
>			int /*long*/ ptr = COM.SysAllocString(data);
>			COM.MoveMemory(pData + 8, new int /*long*/[] {ptr}, OS.PTR_SIZEOF);
>			break;
>	
>		default :
>			OLE.error(SWT.ERROR_NOT_IMPLEMENTED);
>	}
>}
>/**
> * Returns the Java double represented by this Variant.
> *
> * If this Variant does not contain a Java double, an attempt is made to
> * coerce the Variant type into a Java double. If this fails, an error is thrown.
> *
> * @return the Java double represented by this Variant
> *
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant can not be coerced into a double</li>
> * </ul>
> * 
> * @since 3.2
> */
>public double getDouble() {
> if (type == COM.VT_EMPTY) {
> OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, -1);
> }
> if (type == COM.VT_R8) {
> return doubleData;
> }
> 
> // try to coerce the value to the desired type
> int /*long*/ oldPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
> int /*long*/ newPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
> try {
> getData(oldPtr);
> int result = COM.VariantChangeType(newPtr, oldPtr, (short) 0, COM.VT_R8);
> if (result != COM.S_OK)
> OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, result);
> Variant doubleVar = new Variant();
> doubleVar.setData(newPtr);
> return doubleVar.getDouble();
> } finally {
> COM.VariantClear(oldPtr);
> OS.GlobalFree(oldPtr);
> COM.VariantClear(newPtr);
> OS.GlobalFree(newPtr);
> } 
>}
>
>/**
> * Returns the Java float represented by this Variant.
> *
> * If this Variant does not contain a Java float, an attempt is made to
> * coerce the Variant type into a Java float. If this fails, an error is thrown.
> *
> * @return the Java float represented by this Variant
> *
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant can not be coerced into a float</li>
> * </ul>
> */
>public float getFloat() {
>	if (type == COM.VT_EMPTY) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, -1);
>	}
>	if (type == COM.VT_R4) {
>		return floatData;
>	}
>
>	// try to coerce the value to the desired type
>	int /*long*/ oldPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	int /*long*/ newPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	try {
>		getData(oldPtr);
>		int result = COM.VariantChangeType(newPtr, oldPtr, (short) 0, COM.VT_R4);
>		if (result != COM.S_OK)
>			OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, result);
>		Variant floatVar = new Variant();
>		floatVar.setData(newPtr);
>		return floatVar.getFloat();
>	} finally {
>		COM.VariantClear(oldPtr);
>		OS.GlobalFree(oldPtr);
>		COM.VariantClear(newPtr);
>		OS.GlobalFree(newPtr);
>	}
>	
>}
>/**
> * Returns the Java int represented by this Variant.
> *
> * If this Variant does not contain a Java int, an attempt is made to
> * coerce the Variant type into a Java int. If this fails, an error is thrown.
> *
> * @return the Java int represented by this Variant
> *
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant can not be coerced into a int</li>
> * </ul>
> */
>public int getInt() {
>	if (type == COM.VT_EMPTY) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, -1);
>	}
>	if (type == COM.VT_I4) {
>		return intData;
>	}
>		
>	// try to coerce the value to the desired type
>	int /*long*/ oldPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	int /*long*/ newPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	try {
>		getData(oldPtr);
>		int result = COM.VariantChangeType(newPtr, oldPtr, (short) 0, COM.VT_I4);
>		if (result != COM.S_OK)
>			OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, result);
>		Variant intVar = new Variant();
>		intVar.setData(newPtr);
>		return intVar.getInt();
>	} finally {
>		COM.VariantClear(oldPtr);
>		OS.GlobalFree(oldPtr);
>		COM.VariantClear(newPtr);
>		OS.GlobalFree(newPtr);
>	}
>}
>/**
> * Returns the Java long represented by this Variant.
> *
> * If this Variant does not contain a Java long, an attempt is made to
> * coerce the Variant type into a Java long. If this fails, an error is thrown.
> *
> * @return the Java long represented by this Variant
> *
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant can not be coerced into a long</li>
> * </ul>
> *
> * @since 3.2
> */
>public long getLong() {
>	if (type == COM.VT_EMPTY) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, -1);
>	}
>	if (type == COM.VT_I8) {
>		return longData;
>	}
>		
>	// try to coerce the value to the desired type
>	int /*long*/ oldPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	int /*long*/ newPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	try {
>		getData(oldPtr);
>		int result = COM.VariantChangeType(newPtr, oldPtr, (short) 0, COM.VT_I8);
>		if (result != COM.S_OK)
>			OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, result);
>		Variant longVar = new Variant();
>		longVar.setData(newPtr);
>		return longVar.getLong();
>	} finally {
>		COM.VariantClear(oldPtr);
>		OS.GlobalFree(oldPtr);
>		COM.VariantClear(newPtr);
>		OS.GlobalFree(newPtr);
>	}
>}
>/**
> * Returns the Java short represented by this Variant.
> *
> * If this Variant does not contain a Java short, an attempt is made to
> * coerce the Variant type into a Java short. If this fails, an error is thrown.
> *
> * @return the Java short represented by this Variant
> *
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant can not be coerced into a short</li>
> * </ul>
> */
>public short getShort() {
>	if (type == COM.VT_EMPTY) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, -1);
>	}
>	if (type == COM.VT_I2) {
>		return shortData;
>	}
>		
>	// try to coerce the value to the desired type
>	int /*long*/ oldPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	int /*long*/ newPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	try {
>		getData(oldPtr);
>		int result = COM.VariantChangeType(newPtr, oldPtr, (short) 0, COM.VT_I2);
>		if (result != COM.S_OK)
>			OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, result);
>		Variant shortVar = new Variant();
>		shortVar.setData(newPtr);
>		return shortVar.getShort();
>	} finally {
>		COM.VariantClear(oldPtr);
>		OS.GlobalFree(oldPtr);
>		COM.VariantClear(newPtr);
>		OS.GlobalFree(newPtr);
>	}
>	
>}
>/**
> * Returns the Java String represented by this Variant.
> *
> * If this Variant does not contain a Java String, an attempt is made to
> * coerce the Variant type into a Java String. If this fails, an error is thrown.
> *
> * @return the Java String represented by this Variant
> *
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant can not be coerced into a String</li>
> * </ul>
> */
>public String getString() {
>	if (type == COM.VT_EMPTY) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, -1);
>	}
>	if (type == COM.VT_BSTR) {
>		return stringData;
>	}
>
>	// try to coerce the value to the desired type
>	int /*long*/ oldPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	int /*long*/ newPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	try {
>		getData(oldPtr);
>		int result = COM.VariantChangeType(newPtr, oldPtr, (short) 0, COM.VT_BSTR);
>		if (result != COM.S_OK)
>			OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, result);
>
>		Variant stringVar = new Variant();
>		stringVar.setData(newPtr);
>		return stringVar.getString();
>			
>	} finally {
>		COM.VariantClear(oldPtr);
>		OS.GlobalFree(oldPtr);
>		COM.VariantClear(newPtr);
>		OS.GlobalFree(newPtr);
>	}
>}
>/**
> * Returns the type of the variant type. This will be an OLE.VT_* value or
> * a bitwise combination of OLE.VT_* values as in the case of 
> * OLE.VT_BSTR | OLE.VT_BYREF.
> * 
> * @return the type of the variant data
> * 
> * @since 2.0
> */
>public short getType() {
>	return type;
>}
>/**
> * Returns the IUnknown object represented by this Variant.
> *
> * If this Variant does not contain an IUnknown object, an attempt is made to
> * coerce the Variant type into an IUnknown object. If this fails, an error is
> * thrown.
> *
> * @return the IUnknown object represented by this Variant
> *
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant can not be coerced into 
> *			an IUnknown object</li>
> * </ul>
> */
>public IUnknown getUnknown() {
>	if (type == COM.VT_EMPTY) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, -1);
>	}
>	if (type == COM.VT_UNKNOWN) {
>		return unknownData;
>	}
>
>	// try to coerce the value to the desired type
>	int /*long*/ oldPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	int /*long*/ newPtr = OS.GlobalAlloc(COM.GMEM_FIXED | COM.GMEM_ZEROINIT, sizeof);
>	try {
>		getData(oldPtr);
>		int result = COM.VariantChangeType(newPtr, oldPtr, (short) 0, COM.VT_UNKNOWN);
>		if (result != COM.S_OK)
>			OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE, result);
>		Variant unknownVar = new Variant();
>		unknownVar.setData(newPtr);
>		return unknownVar.getUnknown();
>	} finally {
>		COM.VariantClear(oldPtr);
>		OS.GlobalFree(oldPtr);
>		COM.VariantClear(newPtr); // Note: This must absolutely be done AFTER the 
>		 // IUnknown object is created as Variant Clear 
>		 // will result in a Release being performed on the 
>		 // Dispatch object
>		OS.GlobalFree(newPtr);
>	}
>}
>/**
> * Update the by reference value of this variant with a new boolean value.
> * 
> * @param val the new boolean value
> * 
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant is not 
> *			a (VT_BYREF | VT_BOOL) object</li>
> * </ul>
> *
> * @since 2.1
> */
>public void setByRef(boolean val) {
>	if ((type & COM.VT_BYREF) == 0 || (type & COM.VT_BOOL) == 0) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE);
>	}
>	COM.MoveMemory(byRefPtr, new short[]{val ? COM.VARIANT_TRUE : COM.VARIANT_FALSE}, 2);
>}
>/**
> * Update the by reference value of this variant with a new float value.
> * 
> * @param val the new float value
> * 
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant is not 
> *			a (VT_BYREF | VT_R4) object</li>
> * </ul>
> *
> * @since 2.1
> */
>public void setByRef(float val) {
>	if ((type & COM.VT_BYREF) == 0 || (type & COM.VT_R4) == 0) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE);
>	}
>	COM.MoveMemory(byRefPtr, new float[]{val}, 4);	
>}
>/**
> * Update the by reference value of this variant with a new integer value.
> * 
> * @param val the new integer value
> * 
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant is not a (VT_BYREF | VT_I4) object</li>
> * </ul>
> *
> * @since 2.1
> */
>public void setByRef(int /*long*/ val) {
>	if ((type & COM.VT_BYREF) == 0 || (type & COM.VT_I4) == 0) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE);
>	}
>	COM.MoveMemory(byRefPtr, new int /*long*/[]{val}, OS.PTR_SIZEOF);
>}
>/**
> * Update the by reference value of this variant with a new short value.
> * 
> * @param val the new short value
> * 
> * @exception SWTException <ul>
> * <li>ERROR_CANNOT_CHANGE_VARIANT_TYPE when type of Variant is not a (VT_BYREF | VT_I2) object
> * </ul>
> *
> * @since 2.1
> */
>public void setByRef(short val) {
>	if ((type & COM.VT_BYREF) == 0 || (type & COM.VT_I2) == 0) {
>		OLE.error(OLE.ERROR_CANNOT_CHANGE_VARIANT_TYPE);
>	}
>	COM.MoveMemory(byRefPtr, new short[]{val}, 2);
>}
>
>void setData(int /*long*/ pData){
>	if (pData == 0) OLE.error(OLE.ERROR_INVALID_ARGUMENT);
>	//TODO - use VARIANT structure
>	short[] dataType = new short[1];
>	COM.MoveMemory(dataType, pData, 2);
>	type = dataType[0];
>
>	if ((type & COM.VT_BYREF) == COM.VT_BYREF) {
>		int /*long*/[] newByRefPtr = new int /*long*/[1];
>		OS.MoveMemory(newByRefPtr, pData + 8, OS.PTR_SIZEOF);
>		byRefPtr = newByRefPtr[0];
>		return;
>	}
>	if (((type & OLE.VT_ARRAY) == OLE.VT_ARRAY)&& (((type & COM.VT_DISPATCH) == COM.VT_DISPATCH)) ) {
>		readSafeArray(pData);
>		type = OLE.VT_ARRAY|COM.VT_DISPATCH;
>		return;
>	}
>	
>	
>	switch (type) {
>		case COM.VT_EMPTY :
>		case COM.VT_NULL :
>			break;
>		case COM.VT_BOOL :
>			short[] newBooleanData = new short[1];
>			COM.MoveMemory(newBooleanData, pData + 8, 2);
>			booleanData = (newBooleanData[0] != COM.VARIANT_FALSE);
>			break;
>		case COM.VT_I1 :
>			byte[] newByteData = new byte[1];
>			COM.MoveMemory(newByteData, pData + 8, 1);
>			byteData = newByteData[0];
>			break;
>		case COM.VT_I2 :
>			short[] newShortData = new short[1];
>			COM.MoveMemory(newShortData, pData + 8, 2);
>			shortData = newShortData[0];
>			break;
>		case COM.VT_UI2 :
>			char[] newCharData = new char[1];
>			COM.MoveMemory(newCharData, pData + 8, 2);
>			charData = newCharData[0];
>			break;
>		case COM.VT_I4 :
>			int[] newIntData = new int[1];
>			OS.MoveMemory(newIntData, pData + 8, 4);
>			intData = newIntData[0];
>			break;
>		case COM.VT_I8 :
>			long[] newLongData = new long[1];
>			OS.MoveMemory(newLongData, pData + 8, 8);
>			longData = newLongData[0];
>			break;
>		case COM.VT_R4 :
>			float[] newFloatData = new float[1];
>			COM.MoveMemory(newFloatData, pData + 8, 4);
>			floatData = newFloatData[0];
>			break;
>		case COM.VT_R8 :
>			double[] newDoubleData = new double[1];
>			COM.MoveMemory(newDoubleData, pData + 8, 8);
> 			doubleData = newDoubleData[0];
>			break;
>		case COM.VT_DISPATCH : {
>			int /*long*/[] ppvObject = new int /*long*/[1];
>			OS.MoveMemory(ppvObject, pData + 8, OS.PTR_SIZEOF);
>			if (ppvObject[0] == 0) {
>				type = COM.VT_EMPTY;
>				break;
>			}
>			dispatchData = new IDispatch(ppvObject[0]);
>			dispatchData.AddRef();
>			break;
>		}
>		case COM.VT_UNKNOWN : {
>			
>			
>			int /*long*/[] ppvObject = new int /*long*/[1];
>			OS.MoveMemory(ppvObject, pData + 8, OS.PTR_SIZEOF);
>			if (ppvObject[0] == 0) {
>				type = COM.VT_EMPTY;
>				break;
>			}
>			unknownData = new IUnknown(ppvObject[0]);
>			unknownData.AddRef();
>			break;
>		}
>		case COM.VT_BSTR :
>			// get the address of the memory in which the string resides
>			int /*long*/[] hMem = new int /*long*/[1];
>			OS.MoveMemory(hMem, pData + 8, OS.PTR_SIZEOF);
>			if (hMem[0] == 0) {
>				type = COM.VT_EMPTY;
>				break;
>			}
>			// Get the size of the string from the OS - the size is expressed in number
>			// of bytes - each unicode character is 2 bytes.
>			int size = COM.SysStringByteLen(hMem[0]);
>			if (size > 0){
>				// get the unicode character array from the global memory and create a String
>				char[] buffer = new char[(size + 1) /2]; // add one to avoid rounding errors
>				COM.MoveMemory(buffer, hMem[0], size);
>				stringData = new String(buffer);
>			} else {
>				stringData = ""; //$NON-NLS-1$
>			}
>			break;
>	
>		default :
>			// try coercing it into one of the known forms
>			int /*long*/ newPData = OS.GlobalAlloc(OS.GMEM_FIXED | OS.GMEM_ZEROINIT, sizeof);
>			if (COM.VariantChangeType(newPData, pData, (short) 0, COM.VT_R4) == COM.S_OK) {
>				setData(newPData);
>			} else if (COM.VariantChangeType(newPData, pData, (short) 0, COM.VT_I4) == COM.S_OK) {
>				setData(newPData);
>			} else if (COM.VariantChangeType(newPData, pData, (short) 0, COM.VT_BSTR) == COM.S_OK) {
>				setData(newPData);
>			}
>			COM.VariantClear(newPData);
>			OS.GlobalFree(newPData);
>			break;
>	}
>}
>
>/**
> * Returns a string containing a concise, human-readable
> * description of the receiver.
> *
> * @return a string representation of the Variant
> */
>public String toString () {
> switch (type) {
>	 case COM.VT_BOOL :
>	 return "VT_BOOL{"+booleanData+"}";
>	 case COM.VT_I1 :
>	 return "VT_I1{"+byteData+"}";
>	 case COM.VT_I2 :
>	 return "VT_I2{"+shortData+"}";
>	 case COM.VT_UI2 :
>	 return "VT_UI2{"+charData+"}";
>	 case COM.VT_I4 :
>	 return "VT_I4{"+intData+"}";
>	 case COM.VT_I8 :
>	 return "VT_I8{"+longData+"}";
>	 case COM.VT_R4 :
>	 return "VT_R4{"+floatData+"}";
> 	 case COM.VT_R8 :
>	 return "VT_R8{"+doubleData+"}";
>	 case COM.VT_BSTR :
>	 return "VT_BSTR{"+stringData+"}";
>	 case COM.VT_DISPATCH :
>	 return "VT_DISPATCH{"+(dispatchData == null ? 0 : dispatchData.getAddress())+"}";
>	 case COM.VT_UNKNOWN :
>	 return "VT_UNKNOWN{"+(unknownData == null ? 0 : unknownData.getAddress())+"}";
>	 case COM.VT_EMPTY :
>	 return "VT_EMPTY";
>	 case COM.VT_NULL :
>	 return "VT_NULL";
>	 }
> if ((type & COM.VT_BYREF) != 0) {
> return "VT_BYREF|"+(type & ~COM.VT_BYREF)+"{"+byRefPtr+"}";
> }
> return "Unsupported Type "+type;
>}
>
>public static Variant writeSafeArray (String string) {
>	// Here I create a one dimensional safearray containing two VT_UI1 values
>	// where VT_UI1 is an unsigned char
>	
>	// SAFEARRAY looks like this:
>	// short cDims // Count of dimensions in this array
>	// short fFeatures // Flags used by the SafeArray
>	// int cbElements // Size of an element of the array
>	// int cLocks // Number of times the array has been locked without corresponding unlock
>	// int pvData // Pointer to the data
>	// SAFEARRAYBOUND[] rgsabound // One bound for each dimension
>	// SAFEARRAYBOUND looks like this:
>	// int cElements // the number of elements in the dimension
>	// int lLbound // the lower bound of the dimension 
>	
>	//step 1 - define cDims, fFeatures and cbElements
>	short cDims = 1;
>	short FADF_FIXEDSIZE = 0x10;
>	short FADF_HAVEVARTYPE = 0x80;
>	short fFeatures = (short)(FADF_FIXEDSIZE | FADF_HAVEVARTYPE);
>	int cbElements = 1;
>	//create a pointer and copy the data into it
>	int count = string.length();
>	char[] chars = new char[count + 1];
>	string.getChars(0, count, chars, 0);
>	int cchMultiByte = OS.WideCharToMultiByte(CodePage, 0, chars, -1, null, 0, null, null);
>	if (cchMultiByte == 0) return null;
>	int pvData = OS.GlobalAlloc(OS.GMEM_FIXED | OS.GMEM_ZEROINIT, cchMultiByte);
>	OS.WideCharToMultiByte(CodePage, 0, chars, -1, pvData, cchMultiByte, null, null);
>	int cElements1 = cchMultiByte;
>	int lLbound1 = 0;
>	//step 3 - create a safearray in memory
>	// 12 bytes for cDims, fFeatures and cbElements + 4 bytes for pvData + number of dimensions * (size of safearraybound)
>	int sizeofSafeArray = 12 + 4 + 1*8;
>	int pSafeArray = OS.GlobalAlloc(OS.GMEM_FIXED | OS.GMEM_ZEROINIT, sizeofSafeArray);
>	//step 4 copy all the data into the safe array
>	int offset = 0;
>	OS.MoveMemory(pSafeArray + offset, new short[] {cDims}, 2); offset += 2;
>	OS.MoveMemory(pSafeArray + offset, new short[] {fFeatures}, 2); offset += 2;
>	OS.MoveMemory(pSafeArray + offset, new int[] {cbElements}, 4); offset += 4;
>	OS.MoveMemory(pSafeArray + offset, new int[] {0}, 4); offset += 4;
>	OS.MoveMemory(pSafeArray + offset, new int[] {pvData}, 4); offset += 4;
>	OS.MoveMemory(pSafeArray + offset, new int[] {cElements1}, 4); offset += 4;
>	OS.MoveMemory(pSafeArray + offset, new int[] {lLbound1}, 4); offset += 4;
>	//step 5 create a variant in memory to hold the safearray
>	// VARIANT looks like this:
>	// short vt
>	// short wReserved1
>	// short wReserved2
>	// short wReserved3
>	// int parray
>	int pVariant = OS.GlobalAlloc(OS.GMEM_FIXED | OS.GMEM_ZEROINIT, Variant.sizeof);
>	short vt = (short)(OLE.VT_ARRAY | OLE.VT_UI1);
>	OS.MoveMemory(pVariant, new short[] {vt}, 2);
>	OS.MoveMemory(pVariant + 8, new int[]{pSafeArray}, 4);
>	//step 6 create a by ref variant
>	Variant variantByRef = new Variant(pVariant, (short)(OLE.VT_BYREF | OLE.VT_VARIANT));
>	return variantByRef;
>}
>
>public static void readSafeArray(int pPostData) {
>	
>	int[] pVariant = new int[1];
> OS.MoveMemory(pVariant, pPostData + 8, 4);
> 
> int[] pSafearray = new int[1];
> OS.MoveMemory(pSafearray, pVariant[0], 4);
> short[] cDims = new short[1];
> OS.MoveMemory(cDims, pVariant[0], 2);
> System.out.println("dimension of array is "+cDims[0]);
> 
> int[] pvData = new int[1];
> OS.MoveMemory(pvData, pVariant[0] + 12, 4);
> int offset = 0;
> int safearrayboundOffset = 0;
> 
> for (int i = 0; i < cDims[0]; i++) {
> int[] cElements = new int[1];
> OS.MoveMemory(cElements, pVariant[0] + 16 +safearrayboundOffset, 4);
> safearrayboundOffset += 8;
> System.out.println("element count for dimension "+i+" is "+ cElements[0]);
> dispatchDataArr=new IDispatch[cElements[0]];
> for (int j = 0; j < cElements[0]; j++) {
> int[] int_data = new int[1];
> OS.MoveMemory(int_data, pvData[0]+offset, OS.PTR_SIZEOF);
> dispatchDataArr[j] = new IDispatch(int_data[0]);
> System.out.println("data at "+j+" is "+int_data[0]);
> offset += OS.PTR_SIZEOF;
> }
> }
> 
> return ;
>}
>}

Actions: View

Attachments on bug 68194: 12661 | 54838 | 143762 | 143763 | 144248