dispatch.java

java 与COM组件的连接桥

     * @param objectToBeMadeIntoVariant
     * @return Variant that represents the object
     */
    protected static Variant obj2variant(Object objectToBeMadeIntoVariant) {
        if (objectToBeMadeIntoVariant == null)
            return new Variant();
        if (objectToBeMadeIntoVariant instanceof Variant)
        	// if a variant was passed in then be a slacker and just return it
            return (Variant) objectToBeMadeIntoVariant;
        if (   objectToBeMadeIntoVariant instanceof Integer 
    		|| objectToBeMadeIntoVariant instanceof Short
        	|| objectToBeMadeIntoVariant instanceof String
	        || objectToBeMadeIntoVariant instanceof Boolean
	        || objectToBeMadeIntoVariant instanceof Double
	        || objectToBeMadeIntoVariant instanceof Float
	        || objectToBeMadeIntoVariant instanceof SafeArray
	        || objectToBeMadeIntoVariant instanceof Date
	        || objectToBeMadeIntoVariant instanceof Dispatch)
            return new Variant(objectToBeMadeIntoVariant);

        // automatically convert arrays using reflection
        Class c1 = objectToBeMadeIntoVariant.getClass();
        SafeArray sa = null;
        if (c1.isArray()) {
            int len1 = Array.getLength(objectToBeMadeIntoVariant);
            Object first = Array.get(objectToBeMadeIntoVariant, 0);
            if (first.getClass().isArray()) {
                int max = 0;
                for (int i = 0; i < len1; i++) {
                    Object e1 = Array.get(objectToBeMadeIntoVariant, i);
                    int len2 = Array.getLength(e1);
                    if (max < len2) {
                        max = len2;
                    }
                }
                sa = new SafeArray(Variant.VariantVariant, len1, max);
                for (int i = 0; i < len1; i++) {
                    Object e1 = Array.get(objectToBeMadeIntoVariant, i);
                    for (int j = 0; j < Array.getLength(e1); j++) {
                        sa.setVariant(i, j, obj2variant(Array.get(e1, j)));
                    }
                }
            } else {
                sa = new SafeArray(Variant.VariantVariant, len1);
                for (int i = 0; i < len1; i++) {
                    sa.setVariant(i, obj2variant(Array.get(objectToBeMadeIntoVariant, i)));
                }
            }
            return new Variant(sa);
        }
        throw new ClassCastException("cannot convert to Variant");
    }

    /**
     * converts an array of objects into an array of Variants by
     * repeatedly calling obj2Variant(Object)
     * @param arrayOfObjectsToBeConverted
     * @return Variant[] 
     */
    protected static Variant[] obj2variant(Object[] arrayOfObjectsToBeConverted) {
        Variant vArg[] = new Variant[arrayOfObjectsToBeConverted.length];
        for (int i = 0; i < arrayOfObjectsToBeConverted.length; i++) {
            vArg[i] = obj2variant(arrayOfObjectsToBeConverted[i]);
        }
        return vArg;
    }


    /**
     *  now private so only this object can asccess
     *  was: call this to explicitly release the com object before gc
     * 
     */
    private native void release();

    /**
     * not implemented yet
     * @param dispatchTarget
     * @param name
     * @param val
     * @throws com.jacob.com.NotImplementedException
     */
    public static void put_Casesensitive(Dispatch dispatchTarget, String name, Object val) {
        throw new NotImplementedException("not implemented yet");
    }

    /*============================================================
     * start of the invokev section
     * ===========================================================
     */
    // eliminate _Guid arg
    /**
     * @param dispatchTarget
     * @param name
     * @param dispID
     * @param lcid
     * @param wFlags
     * @param vArg
     * @param uArgErr
     */
    public static void invokeSubv(Dispatch dispatchTarget, String name, int dispID,
            int lcid, int wFlags, Variant[] vArg, int[] uArgErr) {
    	throwIfUnattachedDispatch(dispatchTarget);
        invokev(dispatchTarget, name, dispID, lcid, wFlags, vArg, uArgErr);
    }

    /**
     * @param dispatchTarget
     * @param name
     * @param wFlags
     * @param vArg
     * @param uArgErr
     */
    public static void invokeSubv(Dispatch dispatchTarget, String name, int wFlags,
            Variant[] vArg, int[] uArgErr) {
    	throwIfUnattachedDispatch(dispatchTarget);
        invokev(dispatchTarget, name, 0, Dispatch.LOCALE_SYSTEM_DEFAULT, wFlags, vArg, uArgErr);
    }

    /**
     * @param dispatchTarget
     * @param dispID
     * @param wFlags
     * @param vArg
     * @param uArgErr
     */
    public static void invokeSubv(Dispatch dispatchTarget, int dispID, int wFlags,
            Variant[] vArg, int[] uArgErr) {
    	throwIfUnattachedDispatch(dispatchTarget);
        invokev(dispatchTarget, null, dispID, Dispatch.LOCALE_SYSTEM_DEFAULT, wFlags, vArg,
                uArgErr);
    }

    /**
     * not implemented yet
     * @param dispatchTarget
     * @param name
     * @param values
     * @return never returns anything because 
     * @throws com.jacob.com.NotImplementedException
     */
    public static Variant callN_CaseSensitive(Dispatch dispatchTarget, String name,
            Object[] values) {
        throw new NotImplementedException("not implemented yet");
    }

    /**
     * @param dispatchTarget
     * @param name
     * @param args an array of argument objects
     */
    public static void callSubN(Dispatch dispatchTarget, String name, Object[] args) {
    	throwIfUnattachedDispatch(dispatchTarget);
        invokeSubv(dispatchTarget, name, Dispatch.Method | Dispatch.Get, obj2variant(args),
                new int[args.length]);
    }

    /**
     * @param dispatchTarget
     * @param dispID
     * @param args an array of argument objects
     */
    public static void callSubN(Dispatch dispatchTarget, int dispID, Object[] args) {
    	throwIfUnattachedDispatch(dispatchTarget);
        invokeSubv(dispatchTarget, dispID, Dispatch.Method | Dispatch.Get, obj2variant(args),
                new int[args.length]);
    }

    /*============================================================
     * start of the getIdsOfNames section
     * ===========================================================
     */
    /**
     * @param dispatchTarget
     * @param name
     * @return int id for the passed in name
     */
    public static int getIDOfName(Dispatch dispatchTarget, String name) {
        int ids[] = getIDsOfNames(dispatchTarget, Dispatch.LOCALE_SYSTEM_DEFAULT,
                new String[] { name });
        return ids[0];
    }

    /**
     * @param dispatchTarget
     * @param lcid
     * @param names
     * @return int[] in id array for passed in names
     */
    // eliminated _Guid argument
    public static native int[] getIDsOfNames(Dispatch dispatchTarget, int lcid,
            String[] names);

    /**
     * @param dispatchTarget
     * @param names
     * @return int[] int id array for passed in names
     */
    // eliminated _Guid argument
    public static int[] getIDsOfNames(Dispatch dispatchTarget, String[] names) {
        return getIDsOfNames(dispatchTarget, 
                Dispatch.LOCALE_SYSTEM_DEFAULT, names);
    }

    /*============================================================
     * start of the invokev section
     * ===========================================================
     */
    /**
     * @param dispatchTarget
     * @param name
     * @param args
     * @return Variant returned by call
     */
    public static Variant callN(Dispatch dispatchTarget, String name, Object[] args) {
    	throwIfUnattachedDispatch(dispatchTarget);
        return invokev(dispatchTarget, name, 
                Dispatch.Method | Dispatch.Get, obj2variant(args),
                new int[args.length]);
    }

    /**
     * @param dispatchTarget
     * @param dispID
     * @param args
     * @return Variant returned by call
     */
    public static Variant callN(Dispatch dispatchTarget, int dispID, Object[] args) {
    	throwIfUnattachedDispatch(dispatchTarget);
        return invokev(dispatchTarget, dispID, 
                Dispatch.Method | Dispatch.Get, obj2variant(args),
                new int[args.length]);
    }

    /**
     * @param dispatchTarget
     * @param name
     * @param dispID
     * @param lcid
     * @param wFlags
     * @param oArg
     * @param uArgErr
     * @return Variuant returned by invoke
     */
    public static Variant invoke(Dispatch dispatchTarget, String name, int dispID,
            int lcid, int wFlags, Object[] oArg, int[] uArgErr) {
    	throwIfUnattachedDispatch(dispatchTarget);
        return invokev(dispatchTarget, name, dispID, lcid, wFlags, obj2variant(oArg),
                uArgErr);
    }

    /**
     * @param dispatchTarget
     * @param name
     * @param wFlags
     * @param oArg
     * @param uArgErr
     * @return Variuant returned by invoke
     */
    public static Variant invoke(Dispatch dispatchTarget, String name, int wFlags,
            Object[] oArg, int[] uArgErr) {
    	throwIfUnattachedDispatch(dispatchTarget);
        return invokev(dispatchTarget, name, wFlags, obj2variant(oArg), uArgErr);
    }

    /**
     * @param dispatchTarget
     * @param dispID
     * @param wFlags
     * @param oArg
     * @param uArgErr
     * @return Variuant returned by invoke
     */
    public static Variant invoke(Dispatch dispatchTarget, int dispID, int wFlags,
            Object[] oArg, int[] uArgErr) {
    	throwIfUnattachedDispatch(dispatchTarget);
        return invokev(dispatchTarget, dispID, wFlags, obj2variant(oArg), uArgErr);
    }
    
    /*============================================================
     * start of the callN section
     * ===========================================================
     */

    /**
     * @param dispatchTarget
     * @param name
     * @return Variant retuned by underlying callN
     */
    public static Variant call(Dispatch dispatchTarget, String name) {
    	throwIfUnattachedDispatch(dispatchTarget);
        return callN(dispatchTarget, name, NO_VARIANT_ARGS);
    }

    /**
     * @param dispatchTarget
     * @param name
     * @param a1
     * @return Variant retuned by underlying callN
     */
    public static Variant call(Dispatch dispatchTarget, String name, Object a1) {
    	throwIfUnattachedDispatch(dispatchTarget);
        return callN(dispatchTarget, name, new Object[] { a1 });
    }

    /**
     * @param dispatchTarget
     * @param name
     * @param a1
     * @param a2
     * @return Variant retuned by underlying callN
     */
    public static Variant call(Dispatch dispatchTarget, String name, Object a1, Object a2) {
    	throwIfUnattachedDispatch(dispatchTarget);
        return callN(dispatchTarget, name, new Object[] { a1, a2 });
    }

    /**
     * @param dispatchTarget
     * @param name
     * @param a1
     * @param a2
     * @param a3
     * @return Variant retuned by underlying callN
     */
    public static Variant call(Dispatch dispatchTarget, String name, Object a1, Object a2,
            Object a3) {
    	throwIfUnattachedDispatch(dispatchTarget);
        return callN(dispatchTarget, name, new Object[] { a1, a2, a3 });
    }

    /**
     * @param dispatchTarget
     * @param name
     * @param a1
     * @param a2
     * @param a3
     * @param a4
     * @return Variant retuned by underlying callN
     */
    public static Variant call(Dispatch dispatchTarget, String name, Object a1, Object a2,