dispatch.java

java 与COM组件的连接桥

            Object a3, Object a4) {
    	throwIfUnattachedDispatch(dispatchTarget);
        return callN(dispatchTarget, name, new Object[] { a1, a2, a3, a4 });
    }

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @param dispatchTarget
     * @param dispid
     * @param a1
     * @param a2
     * @param a3
     * @param a4
     * @param a5
     * @param a6
     * @param a7
     * @return Variant retuned by underlying callN
     */
    public static Variant call(Dispatch dispatchTarget, int dispid, Object a1, Object a2,
            Object a3, Object a4, Object a5, Object a6, Object a7) {
    	throwIfUnattachedDispatch(dispatchTarget);
        return callN(dispatchTarget, dispid, new Object[] { a1, a2, a3, a4, a5, a6, a7 });
    }

    /**
     * @param dispatchTarget
     * @param dispid
     * @param a1
     * @param a2
     * @param a3
     * @param a4
     * @param a5
     * @param a6
     * @param a7
     * @param a8
     * @return Variant retuned by underlying callN
     */
    public static Variant call(Dispatch dispatchTarget, int dispid, Object a1, Object a2,
            Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) {
    	throwIfUnattachedDispatch(dispatchTarget);
        return callN(dispatchTarget, dispid, new Object[] { a1, a2, a3, a4, a5, a6, a7,
                a8 });
    }

    /*============================================================
     * start of the invoke section
     * ===========================================================
     */
    /**
     * @param dispatchTarget
     * @param name
     * @param val
     */
    public static void put(Dispatch dispatchTarget, String name, Object val) {
    	throwIfUnattachedDispatch(dispatchTarget);
        invoke(dispatchTarget, name, Dispatch.Put, new Object[] { val }, new int[1]);
    }

    /**
     * @param dispatchTarget
     * @param dispid
     * @param val
     */
    public static void put(Dispatch dispatchTarget, int dispid, Object val) {
    	throwIfUnattachedDispatch(dispatchTarget);
        invoke(dispatchTarget, dispid, Dispatch.Put, new Object[] { val }, new int[1]);
    }

    /*============================================================
     * start of the invokev section
     * ===========================================================
     */
    // removed _Guid argument
    /**
     * @param dispatchTarget
     * @param name
     * @param dispID
     * @param lcid
     * @param wFlags
     * @param vArg
     * @param uArgErr
     * @return Variant returned by underlying invokev
     */
    public static native Variant invokev(Dispatch dispatchTarget, String name, int dispID,
            int lcid, int wFlags, Variant[] vArg, int[] uArgErr);

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

    /**
     * @param dispatchTarget
     * @param name
     * @param wFlags
     * @param vArg
     * @param uArgErr
     * @param wFlagsEx
     * @return Variant returned by underlying invokev
     */
    public static Variant invokev(Dispatch dispatchTarget, String name, int wFlags,
            Variant[] vArg, int[] uArgErr, int wFlagsEx) {
    	throwIfUnattachedDispatch(dispatchTarget);
        // do not implement IDispatchEx for now
        return invokev(dispatchTarget, name, 0, Dispatch.LOCALE_SYSTEM_DEFAULT, wFlags, vArg,
                uArgErr);
    }

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

    /*============================================================
     * start of the invokeSubv section
     * ===========================================================
     */
    
    // removed _Guid argument
    /**
     * @param dispatchTarget
     * @param name
     * @param dispid
     * @param lcid
     * @param wFlags
     * @param oArg
     * @param uArgErr
     */
    public static void invokeSub(Dispatch dispatchTarget, String name, int dispid,
            int lcid, int wFlags, Object[] oArg, int[] uArgErr) {
    	throwIfUnattachedDispatch(dispatchTarget);
        invokeSubv(dispatchTarget, name, dispid, lcid, wFlags, obj2variant(oArg), uArgErr);
    }

    /*============================================================
     * start of the invokeSub section
     * ===========================================================
     */
    /**
     * @param dispatchTarget
     * @param name
     * @param wFlags
     * @param oArg
     * @param uArgErr
     */
    public static void invokeSub(Dispatch dispatchTarget, String name, int wFlags,
            Object[] oArg, int[] uArgErr) {
    	throwIfUnattachedDispatch(dispatchTarget);
        invokeSub(dispatchTarget, name, 0, Dispatch.LOCALE_SYSTEM_DEFAULT, wFlags, oArg, uArgErr);
    }

    /**
     * @param dispatchTarget
     * @param dispid
     * @param wFlags