rik/jlibcom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

javadoc

Browse Source
This commit is contained in:
clay_shooter
2005-01-09 04:08:00 +00:00
parent 8319fd4df9
commit 34210e20a7
1 changed files with 467 additions and 432 deletions
Download Patch File Download Diff File Expand all files Collapse all files

899
com/jacob/com/Dispatch.java
View File

@@ -37,7 +37,16 @@ import java.lang.reflect.Array;
*/ */
public class Dispatch extends JacobObject public class Dispatch extends JacobObject
{ {
public int m_pDispatch; /**
* why is this public?
* it could be protected and the Dispatch subclasses could still
* get it.
* This makes it hard to rename this thing
*/
public int m_pDispatch;
/** program Id passed in by ActiveX components in their constructor */
private String programId = null;
public static final int LOCALE_SYSTEM_DEFAULT = 2048; public static final int LOCALE_SYSTEM_DEFAULT = 2048;
public static final int Method = 1; public static final int Method = 1;
public static final int Get = 2; public static final int Get = 2;
@@ -111,440 +120,466 @@ public class Dispatch extends JacobObject
public static final int DISPID_AMBIENT_CHARSET = -727; public static final int DISPID_AMBIENT_CHARSET = -727;
public static final int DISPID_AMBIENT_TRANSFERPRIORITY = -728; public static final int DISPID_AMBIENT_TRANSFERPRIORITY = -728;
// map args based on msdn doc // map args based on msdn doc
protected static Variant obj2variant(Object o) protected static Variant obj2variant(Object o) {
{ if (o == null)
if (o == null) return new Variant();
return new Variant(); if (o instanceof Variant)
if (o instanceof Variant) return (Variant) o;
return (Variant)o; if (o instanceof Integer)
if (o instanceof Integer) return new Variant(((Integer) o).intValue());
return new Variant(((Integer)o).intValue()); if (o instanceof String)
if (o instanceof String) return new Variant((String) o);
return new Variant((String)o); if (o instanceof Boolean)
if (o instanceof Boolean) return new Variant(((Boolean) o).booleanValue());
return new Variant(((Boolean)o).booleanValue()); if (o instanceof Double)
if (o instanceof Double) return new Variant(((Double) o).doubleValue());
return new Variant(((Double)o).doubleValue()); if (o instanceof Float)
if (o instanceof Float) return new Variant(((Float) o).floatValue());
return new Variant(((Float)o).floatValue()); if (o instanceof SafeArray)
if (o instanceof SafeArray) return new Variant((SafeArray) o);
return new Variant((SafeArray)o); if (o instanceof Dispatch) {
if (o instanceof Dispatch) { Variant v = new Variant();
Variant v = new Variant(); v.putObject((Dispatch) o);
v.putObject((Dispatch)o); return v;
return v;
}
// automatically convert arrays using reflection
Class c1 = o.getClass();
SafeArray sa = null;
if (c1.isArray())
{
int len1 = Array.getLength(o);
Object first = Array.get(o, 0);
if (first.getClass().isArray())
{
int max = 0;
for (int i = 0; i < len1; i++)
{
Object e1 = Array.get(o, i);
int len2 = Array.getLength(e1);
if (max < len2)
{
max = len2;
}
} }
sa = new SafeArray(Variant.VariantVariant, len1, max); // automatically convert arrays using reflection
for (int i = 0; i < len1; i++) Class c1 = o.getClass();
{ SafeArray sa = null;
Object e1 = Array.get(o, i); if (c1.isArray()) {
for (int j = 0; j < Array.getLength(e1); j++) int len1 = Array.getLength(o);
{ Object first = Array.get(o, 0);
sa.setVariant(i, j, obj2variant(Array.get(e1, j))); if (first.getClass().isArray()) {
} int max = 0;
for (int i = 0; i < len1; i++) {
Object e1 = Array.get(o, 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(o, 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(o, i)));
}
}
return new Variant(sa);
} }
} else { throw new ClassCastException("cannot convert to Variant");
sa = new SafeArray(Variant.VariantVariant, len1);
for (int i = 0; i < len1; i++)
{
sa.setVariant(i, obj2variant(Array.get(o, i)));
}
}
return new Variant(sa);
} }
throw new ClassCastException("cannot convert to Variant");
}
// same as above, for an array /**
protected static Variant[] obj2variant(Object[] o) * same as above, for an array
{ * @param o
Variant vArg[] = new Variant[o.length]; * @return Variant[]
for(int i=0;i<o.length;i++) { */
vArg[i] = obj2variant(o[i]); protected static Variant[] obj2variant(Object[] o) {
Variant vArg[] = new Variant[o.length];
for (int i = 0; i < o.length; i++) {
vArg[i] = obj2variant(o[i]);
}
return vArg;
} }
return vArg;
} /**
* zero argument constructor that sets the dispatch pointer to 0
// constructors */
public Dispatch() { m_pDispatch = 0; } public Dispatch() {
public Dispatch(String progid) { createInstance(progid); } m_pDispatch = 0;
}
// return a different interface by IID string
public native Dispatch QueryInterface(String iid); /**
* Constructor that calls createInstance with progid. This is the
// this only gets called from JNI * constructor used by the ActiveXComponent
protected Dispatch(int pDisp) { m_pDispatch = pDisp; } *
* @param requestedProgramId
protected native void createInstance(String progid); */
public Dispatch(String requestedProgramId) {
// call this to explicitly release the com object before gc programId = requestedProgramId;
public native void release(); createInstance(requestedProgramId);
}
public static void put_Casesensitive(Object disp, String name, Object val)
{ /**
throw new ClassCastException("not implemented yet"); * return a different interface by IID string
} *
* @param iid
// eliminate _Guid arg * @return Dispatch a disptach that matches ??
public static void invokeSubv(Object disp, String name, int dispID, */
int lcid, int wFlags, Variant[] vArg, int[] uArgErr) public native Dispatch QueryInterface(String iid);
{
invokev(disp, name, dispID, lcid, wFlags, vArg, uArgErr); /**
} * Constructor that only gets called from JNI
*
public static void invokeSubv(Object disp, String name, int wFlags, Variant[] vArg, int[] uArgErr) * @param pDisp
{ */
invokev(disp, name, 0, LOCALE_SYSTEM_DEFAULT, wFlags, vArg, uArgErr); protected Dispatch(int pDisp) {
} m_pDispatch = pDisp;
}
public static void invokeSubv(Object disp, int dispID, int wFlags, Variant[] vArg, int[] uArgErr)
{ /**
invokev(disp, null, dispID, LOCALE_SYSTEM_DEFAULT, wFlags, vArg, uArgErr); * native call createIstnace only used by the constructor with the same parm
} * type could this be private?
*
public static Variant callN_CaseSensitive(Object disp, String name, Object[] values) * @param progid
{ */
throw new ClassCastException("not implemented yet"); protected native void createInstance(String progid);
}
public String getProgramId(){
public static void callSubN(Object disp, String name, Object[] args) return programId;
{ }
invokeSubv(disp, name, Method|Get, obj2variant(args), new int[args.length]);
} /**
* call this to explicitly release the com object before gc
public static void callSubN(Object disp, int dispID, Object[] args) */
{ public native void release();
invokeSubv(disp, dispID, Method|Get, obj2variant(args), new int[args.length]);
} /**
* not implemented yet
public static int getIDOfName(Object disp, String name) *
{ * @param disp
int ids[] = getIDsOfNames(disp, LOCALE_SYSTEM_DEFAULT, new String[] {name}); * @param name
return ids[0]; * @param val
} * @throws ClassCastException
* because???
// eliminated _Guid argument */
public static native int[] getIDsOfNames(Object disp, int lcid, String[] names); public static void put_Casesensitive(Object disp, String name, Object val) {
// eliminated _Guid argument throw new ClassCastException("not implemented yet");
public static int[] getIDsOfNames(Object disp, String[] names) }
{
return getIDsOfNames(disp, LOCALE_SYSTEM_DEFAULT, names); // eliminate _Guid arg
} public static void invokeSubv(Object disp, String name, int dispID,
int lcid, int wFlags, Variant[] vArg, int[] uArgErr) {
public static Variant callN(Object disp, String name, Object[] args) invokev(disp, name, dispID, lcid, wFlags, vArg, uArgErr);
{ }
return invokev(disp, name, Method|Get, obj2variant(args), new int[args.length]);
} public static void invokeSubv(Object disp, String name, int wFlags,
Variant[] vArg, int[] uArgErr) {
public static Variant callN(Object disp, int dispID, Object[] args) invokev(disp, name, 0, LOCALE_SYSTEM_DEFAULT, wFlags, vArg, uArgErr);
{ }
return invokev(disp, dispID, Method|Get, obj2variant(args), new int[args.length]);
} public static void invokeSubv(Object disp, int dispID, int wFlags,
Variant[] vArg, int[] uArgErr) {
public static Variant invoke(Object disp, String name, int dispID, int lcid, int wFlags, Object[] oArg, int[] uArgErr) invokev(disp, null, dispID, LOCALE_SYSTEM_DEFAULT, wFlags, vArg,
{ uArgErr);
return invokev(disp, name, dispID, lcid, wFlags, obj2variant(oArg), uArgErr); }
}
public static Variant callN_CaseSensitive(Object disp, String name,
public static Variant invoke(Object disp, String name, int wFlags, Object[] oArg, int[] uArgErr) Object[] values) {
{ throw new ClassCastException("not implemented yet");
return invokev(disp, name, wFlags, obj2variant(oArg), uArgErr); }
}
public static void callSubN(Object disp, String name, Object[] args) {
public static Variant invoke(Object disp, int dispID, int wFlags, Object[] oArg, int[] uArgErr) invokeSubv(disp, name, Method | Get, obj2variant(args),
{ new int[args.length]);
return invokev(disp, dispID, wFlags, obj2variant(oArg), uArgErr); }
}
public static void callSubN(Object disp, int dispID, Object[] args) {
public static Variant call(Object disp, String name) invokeSubv(disp, dispID, Method | Get, obj2variant(args),
{ new int[args.length]);
return callN(disp, name, new Variant[0]); }
}
public static int getIDOfName(Object disp, String name) {
public static Variant call(Object disp, String name, Object a1) int ids[] = getIDsOfNames(disp, LOCALE_SYSTEM_DEFAULT,
{ new String[] { name });
return callN(disp, name, new Object[] {a1}); return ids[0];
} }
public static Variant call(Object disp, String name, Object a1, Object a2) // eliminated _Guid argument
{ public static native int[] getIDsOfNames(Object disp, int lcid,
return callN(disp, name, new Object[] {a1, a2}); String[] names);
}
// eliminated _Guid argument
public static Variant call(Object disp, String name, Object a1, Object a2, Object a3) public static int[] getIDsOfNames(Object disp, String[] names) {
{ return getIDsOfNames(disp, LOCALE_SYSTEM_DEFAULT, names);
return callN(disp, name, new Object[] {a1, a2, a3}); }
}
public static Variant callN(Object disp, String name, Object[] args) {
public static Variant call(Object disp, String name, Object a1, Object a2, Object a3, Object a4) return invokev(disp, name, Method | Get, obj2variant(args),
{ new int[args.length]);
return callN(disp, name, new Object[] {a1, a2, a3, a4}); }
}
public static Variant callN(Object disp, int dispID, Object[] args) {
public static Variant call(Object disp, String name, Object a1, Object a2, Object a3, Object a4, Object a5) return invokev(disp, dispID, Method | Get, obj2variant(args),
{ new int[args.length]);
return callN(disp, name, new Object[] {a1, a2, a3, a4, a5}); }
}
public static Variant invoke(Object disp, String name, int dispID,
public static Variant call(Object disp, String name, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) int lcid, int wFlags, Object[] oArg, int[] uArgErr) {
{ return invokev(disp, name, dispID, lcid, wFlags, obj2variant(oArg),
return callN(disp, name, new Object[] {a1, a2, a3, a4, a5, a6}); uArgErr);
} }
public static Variant call(Object disp, String name, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) public static Variant invoke(Object disp, String name, int wFlags,
{ Object[] oArg, int[] uArgErr) {
return callN(disp, name, new Object[] {a1, a2, a3, a4, a5, a6, a7}); return invokev(disp, name, wFlags, obj2variant(oArg), uArgErr);
} }
public static Variant call(Object disp, String name, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) public static Variant invoke(Object disp, int dispID, int wFlags,
{ Object[] oArg, int[] uArgErr) {
return callN(disp, name, new Object[] {a1, a2, a3, a4, a5, a6, a7, a8}); return invokev(disp, dispID, wFlags, obj2variant(oArg), uArgErr);
} }
public static Variant call(Object disp, int dispid) public static Variant call(Object disp, String name) {
{ return callN(disp, name, new Variant[0]);
return callN(disp, dispid, new Variant[0]); }
}
public static Variant call(Object disp, String name, Object a1) {
public static Variant call(Object disp, int dispid, Object a1) return callN(disp, name, new Object[] { a1 });
{ }
return callN(disp, dispid, new Object[] {a1});
} public static Variant call(Object disp, String name, Object a1, Object a2) {
return callN(disp, name, new Object[] { a1, a2 });
public static Variant call(Object disp, int dispid, Object a1, Object a2) }
{
return callN(disp, dispid, new Object[] {a1, a2}); public static Variant call(Object disp, String name, Object a1, Object a2,
} Object a3) {
return callN(disp, name, new Object[] { a1, a2, a3 });
public static Variant call(Object disp, int dispid, Object a1, Object a2, Object a3) }
{
return callN(disp, dispid, new Object[] {a1, a2, a3}); public static Variant call(Object disp, String name, Object a1, Object a2,
} Object a3, Object a4) {
return callN(disp, name, new Object[] { a1, a2, a3, a4 });
public static Variant call(Object disp, int dispid, Object a1, Object a2, Object a3, Object a4) }
{
return callN(disp, dispid, new Object[] {a1, a2, a3, a4}); public static Variant call(Object disp, String name, Object a1, Object a2,
} Object a3, Object a4, Object a5) {
return callN(disp, name, new Object[] { a1, a2, a3, a4, a5 });
public static Variant call(Object disp, int dispid, Object a1, Object a2, Object a3, Object a4, Object a5) }
{
return callN(disp, dispid, new Object[] {a1, a2, a3, a4, a5}); public static Variant call(Object disp, String name, Object a1, Object a2,
} Object a3, Object a4, Object a5, Object a6) {
return callN(disp, name, new Object[] { a1, a2, a3, a4, a5, a6 });
public static Variant call(Object disp, int dispid, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) }
{
return callN(disp, dispid, new Object[] {a1, a2, a3, a4, a5, a6}); public static Variant call(Object disp, String name, Object a1, Object a2,
} Object a3, Object a4, Object a5, Object a6, Object a7) {
return callN(disp, name, new Object[] { a1, a2, a3, a4, a5, a6, a7 });
public static Variant call(Object disp, int dispid, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) }
{
return callN(disp, dispid, new Object[] {a1, a2, a3, a4, a5, a6, a7}); public static Variant call(Object disp, String name, Object a1, Object a2,
} Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) {
return callN(disp, name,
public static Variant call(Object disp, int dispid, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) new Object[] { a1, a2, a3, a4, a5, a6, a7, a8 });
{ }
return callN(disp, dispid, new Object[] {a1, a2, a3, a4, a5, a6, a7, a8});
} public static Variant call(Object disp, int dispid) {
return callN(disp, dispid, new Variant[0]);
public static void put(Object disp, String name, Object val) }
{
invoke(disp, name, Put, new Object[] {val}, new int[1]); public static Variant call(Object disp, int dispid, Object a1) {
} return callN(disp, dispid, new Object[] { a1 });
}
public static void put(Object disp, int dispid, Object val)
{ public static Variant call(Object disp, int dispid, Object a1, Object a2) {
invoke(disp, dispid, Put, new Object[] {val}, new int[1]); return callN(disp, dispid, new Object[] { a1, a2 });
} }
// removed _Guid argument public static Variant call(Object disp, int dispid, Object a1, Object a2,
public static native Variant invokev(Object disp, String name, Object a3) {
int dispID, int lcid, int wFlags, Variant[] vArg, int[] uArgErr); return callN(disp, dispid, new Object[] { a1, a2, a3 });
}
public static Variant invokev(Object disp, String name, int wFlags,
Variant[] vArg, int[] uArgErr) public static Variant call(Object disp, int dispid, Object a1, Object a2,
{ Object a3, Object a4) {
if (!(disp instanceof Dispatch)) return callN(disp, dispid, new Object[] { a1, a2, a3, a4 });
throw new ClassCastException("Dispatch object expected"); }
return invokev(disp, name, 0, LOCALE_SYSTEM_DEFAULT, wFlags, vArg, uArgErr);
} public static Variant call(Object disp, int dispid, Object a1, Object a2,
Object a3, Object a4, Object a5) {
public static Variant invokev(Object disp, String name, int wFlags, return callN(disp, dispid, new Object[] { a1, a2, a3, a4, a5 });
Variant[] vArg, int[] uArgErr, int wFlagsEx) }
{
if (!(disp instanceof Dispatch)) public static Variant call(Object disp, int dispid, Object a1, Object a2,
throw new ClassCastException("Dispatch object expected"); Object a3, Object a4, Object a5, Object a6) {
// do not implement IDispatchEx for now return callN(disp, dispid, new Object[] { a1, a2, a3, a4, a5, a6 });
return invokev(disp, name, 0, LOCALE_SYSTEM_DEFAULT, wFlags, vArg, uArgErr); }
}
public static Variant call(Object disp, int dispid, Object a1, Object a2,
public static Variant invokev(Object disp, int dispID, int wFlags, Variant[] vArg, int[] uArgErr) Object a3, Object a4, Object a5, Object a6, Object a7) {
{ return callN(disp, dispid, new Object[] { a1, a2, a3, a4, a5, a6, a7 });
if (!(disp instanceof Dispatch)) }
throw new ClassCastException("Dispatch object expected");
return invokev(disp, null, dispID, LOCALE_SYSTEM_DEFAULT, wFlags, vArg, uArgErr); public static Variant call(Object disp, int dispid, Object a1, Object a2,
} Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) {
return callN(disp, dispid, new Object[] { a1, a2, a3, a4, a5, a6, a7,
// removed _Guid argument a8 });
public static void invokeSub(Object disp, String name, int dispid, }
int lcid, int wFlags, Object[] oArg, int[] uArgErr)
{ public static void put(Object disp, String name, Object val) {
invokeSubv(disp, name, dispid, lcid, wFlags, obj2variant(oArg), uArgErr); invoke(disp, name, Put, new Object[] { val }, new int[1]);
} }
public static void invokeSub(Object disp, String name, int wFlags, Object[] oArg, int[] uArgErr) public static void put(Object disp, int dispid, Object val) {
{ invoke(disp, dispid, Put, new Object[] { val }, new int[1]);
invokeSub(disp, name, 0, LOCALE_SYSTEM_DEFAULT, wFlags, oArg, uArgErr); }
}
// removed _Guid argument
public static void invokeSub(Object disp, int dispid, int wFlags, Object[] oArg, int[] uArgErr) public static native Variant invokev(Object disp, String name, int dispID,
{ int lcid, int wFlags, Variant[] vArg, int[] uArgErr);
invokeSub(disp, null, dispid, LOCALE_SYSTEM_DEFAULT, wFlags, oArg, uArgErr);
} public static Variant invokev(Object disp, String name, int wFlags,
Variant[] vArg, int[] uArgErr) {
public static void callSub(Object disp, String name) if (!(disp instanceof Dispatch))
{ throw new ClassCastException("Dispatch object expected");
callSubN(disp, name, new Object[0]); return invokev(disp, name, 0, LOCALE_SYSTEM_DEFAULT, wFlags, vArg,
} uArgErr);
}
public static void callSub(Object disp, String name, Object a1)
{ public static Variant invokev(Object disp, String name, int wFlags,
callSubN(disp, name, new Object[] {a1}); Variant[] vArg, int[] uArgErr, int wFlagsEx) {
} if (!(disp instanceof Dispatch))
throw new ClassCastException("Dispatch object expected");
public static void callSub(Object disp, String name, Object a1, Object a2) // do not implement IDispatchEx for now
{ return invokev(disp, name, 0, LOCALE_SYSTEM_DEFAULT, wFlags, vArg,
callSubN(disp, name, new Object[] {a1, a2}); uArgErr);
} }
public static void callSub(Object disp, String name, Object a1, Object a2, Object a3) public static Variant invokev(Object disp, int dispID, int wFlags,
{ Variant[] vArg, int[] uArgErr) {
callSubN(disp, name, new Object[] {a1, a2, a3}); if (!(disp instanceof Dispatch))
} throw new ClassCastException("Dispatch object expected");
return invokev(disp, null, dispID, LOCALE_SYSTEM_DEFAULT, wFlags, vArg,
public static void callSub(Object disp, String name, Object a1, Object a2, Object a3, Object a4) uArgErr);
{ }
callSubN(disp, name, new Object[] {a1, a2, a3, a4});
} // removed _Guid argument
public static void invokeSub(Object disp, String name, int dispid,
public static void callSub(Object disp, String name, Object a1, Object a2, Object a3, Object a4, Object a5) int lcid, int wFlags, Object[] oArg, int[] uArgErr) {
{ invokeSubv(disp, name, dispid, lcid, wFlags, obj2variant(oArg), uArgErr);
callSubN(disp, name, new Object[] {a1, a2, a3, a4, a5}); }
}
public static void invokeSub(Object disp, String name, int wFlags,
public static void callSub(Object disp, String name, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) Object[] oArg, int[] uArgErr) {
{ invokeSub(disp, name, 0, LOCALE_SYSTEM_DEFAULT, wFlags, oArg, uArgErr);
callSubN(disp, name, new Object[] {a1, a2, a3, a4, a5, a6}); }
}
public static void invokeSub(Object disp, int dispid, int wFlags,
public static void callSub(Object disp, String name, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) Object[] oArg, int[] uArgErr) {
{ invokeSub(disp, null, dispid, LOCALE_SYSTEM_DEFAULT, wFlags, oArg,
callSubN(disp, name, new Object[] {a1, a2, a3, a4, a5, a6, a7}); uArgErr);
} }
public static void callSub(Object disp, String name, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) public static void callSub(Object disp, String name) {
{ callSubN(disp, name, new Object[0]);
callSubN(disp, name, new Object[] {a1, a2, a3, a4, a5, a6, a7, a8}); }
}
public static void callSub(Object disp, String name, Object a1) {
public static void callSub(Object disp, int dispid) callSubN(disp, name, new Object[] { a1 });
{ }
callSubN(disp, dispid, new Object[0]);
} public static void callSub(Object disp, String name, Object a1, Object a2) {
callSubN(disp, name, new Object[] { a1, a2 });
public static void callSub(Object disp, int dispid, Object a1) }
{
callSubN(disp, dispid, new Object[] {a1}); public static void callSub(Object disp, String name, Object a1, Object a2,
} Object a3) {
callSubN(disp, name, new Object[] { a1, a2, a3 });
public static void callSub(Object disp, int dispid, Object a1, Object a2) }
{
callSubN(disp, dispid, new Object[] {a1, a2}); public static void callSub(Object disp, String name, Object a1, Object a2,
} Object a3, Object a4) {
callSubN(disp, name, new Object[] { a1, a2, a3, a4 });
public static void callSub(Object disp, int dispid, Object a1, Object a2, Object a3) }
{
callSubN(disp, dispid, new Object[] {a1, a2, a3}); public static void callSub(Object disp, String name, Object a1, Object a2,
} Object a3, Object a4, Object a5) {
callSubN(disp, name, new Object[] { a1, a2, a3, a4, a5 });
public static void callSub(Object disp, int dispid, Object a1, Object a2, Object a3, Object a4) }
{
callSubN(disp, dispid, new Object[] {a1, a2, a3, a4}); public static void callSub(Object disp, String name, Object a1, Object a2,
} Object a3, Object a4, Object a5, Object a6) {
callSubN(disp, name, new Object[] { a1, a2, a3, a4, a5, a6 });
public static void callSub(Object disp, int dispid, Object a1, Object a2, Object a3, Object a4, Object a5) }
{
callSubN(disp, dispid, new Object[] {a1, a2, a3, a4, a5}); public static void callSub(Object disp, String name, Object a1, Object a2,
} Object a3, Object a4, Object a5, Object a6, Object a7) {
callSubN(disp, name, new Object[] { a1, a2, a3, a4, a5, a6, a7 });
public static void callSub(Object disp, int dispid, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) }
{
callSubN(disp, dispid, new Object[] {a1, a2, a3, a4, a5, a6}); public static void callSub(Object disp, String name, Object a1, Object a2,
} Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) {
callSubN(disp, name, new Object[] { a1, a2, a3, a4, a5, a6, a7, a8 });
public static void callSub(Object disp, int dispid, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) }
{
callSubN(disp, dispid, new Object[] {a1, a2, a3, a4, a5, a6, a7}); public static void callSub(Object disp, int dispid) {
} callSubN(disp, dispid, new Object[0]);
}
public static void callSub(Object disp, int dispid, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8)
{ public static void callSub(Object disp, int dispid, Object a1) {
callSubN(disp, dispid, new Object[] {a1, a2, a3, a4, a5, a6, a7, a8}); callSubN(disp, dispid, new Object[] { a1 });
} }
public static Variant get(Object disp, String name) public static void callSub(Object disp, int dispid, Object a1, Object a2) {
{ callSubN(disp, dispid, new Object[] { a1, a2 });
return invokev(disp, name, Get, new Variant[0], new int[0]); }
}
public static void callSub(Object disp, int dispid, Object a1, Object a2,
public static Variant get(Object disp, int dispid) Object a3) {
{ callSubN(disp, dispid, new Object[] { a1, a2, a3 });
return invokev(disp, dispid, Get, new Variant[0], new int[0]); }
}
public static void callSub(Object disp, int dispid, Object a1, Object a2,
Object a3, Object a4) {
public static void putRef(Object disp, String name, Object val) callSubN(disp, dispid, new Object[] { a1, a2, a3, a4 });
{ }
invoke(disp, name, PutRef, new Object[] {val}, new int[1]);
} public static void callSub(Object disp, int dispid, Object a1, Object a2,
Object a3, Object a4, Object a5) {
public static void putRef(Object disp, int dispid, Object val) callSubN(disp, dispid, new Object[] { a1, a2, a3, a4, a5 });
{ }
invoke(disp, dispid, PutRef, new Object[] {val}, new int[1]);
} public static void callSub(Object disp, int dispid, Object a1, Object a2,
Object a3, Object a4, Object a5, Object a6) {
public static Variant get_CaseSensitive(Object disp, String name) callSubN(disp, dispid, new Object[] { a1, a2, a3, a4, a5, a6 });
{ }
throw new ClassCastException("not implemented yet");
} public static void callSub(Object disp, int dispid, Object a1, Object a2,
Object a3, Object a4, Object a5, Object a6, Object a7) {
static { callSubN(disp, dispid, new Object[] { a1, a2, a3, a4, a5, a6, a7 });
System.loadLibrary("jacob"); }
}
public static void callSub(Object disp, int dispid, Object a1, Object a2,
protected void finalize() Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) {
{ callSubN(disp, dispid, new Object[] { a1, a2, a3, a4, a5, a6, a7, a8 });
//System.out.println("Dispatch finalize start"); }
if (m_pDispatch != 0) release();
//System.out.println("Dispatch finalize end"); public static Variant get(Object disp, String name) {
} return invokev(disp, name, Get, new Variant[0], new int[0]);
} }
public static Variant get(Object disp, int dispid) {
return invokev(disp, dispid, Get, new Variant[0], new int[0]);
}
public static void putRef(Object disp, String name, Object val) {
invoke(disp, name, PutRef, new Object[] { val }, new int[1]);
}
public static void putRef(Object disp, int dispid, Object val) {
invoke(disp, dispid, PutRef, new Object[] { val }, new int[1]);
}
public static Variant get_CaseSensitive(Object disp, String name) {
throw new ClassCastException("not implemented yet");
}
static {
System.loadLibrary("jacob");
}
protected void finalize() {
//System.out.println("Dispatch finalize start");
if (m_pDispatch != 0)
release();
//System.out.println("Dispatch finalize end");
}
}