dispatch.java

java与windows的com桥,可以用来操作所有的com程序如word或者excel等

	/*
	 * ============================================================ 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,
				VariantUtilities.objectsToVariants(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,
				VariantUtilities.objectsToVariants(args),
				new int[args.length]);
	}

	/**
	 * @param dispatchTarget
	 * @param name
	 * @param dispID
	 * @param lcid
	 * @param wFlags
	 * @param oArg
	 * @param uArgErr
	 * @return Variant 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,
				VariantUtilities.objectsToVariants(oArg), uArgErr);
	}

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

	/**
	 * @param dispatchTarget
	 * @param dispID
	 * @param wFlags
	 * @param oArg
	 * @param uArgErr
	 * @return Variant returned by invoke
	 */
	public static Variant invoke(Dispatch dispatchTarget, int dispID,
			int wFlags, Object[] oArg, int[] uArgErr) {
		throwIfUnattachedDispatch(dispatchTarget);
		return invokev(dispatchTarget, dispID, wFlags, VariantUtilities
				.objectsToVariants(oArg), uArgErr);
	}

	/*
	 * ============================================================ start of the
	 * callN section ===========================================================
	 */

	/**
	 * @param dispatchTarget
	 * @param name
	 * @return Variant returned 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 returned 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 returned 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 returned 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, 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 returned 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 returned 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 returned 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 returned 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 returned 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 returned 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 returned 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 returned 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 returned 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 returned 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 returned 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