dispatch.java

Very Nice library for using ActiveX controls directly from java without heavy knowledge of JNI, simp

	 * @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, 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