Move source files

src/main/cpp/ComThread.cpp

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "stdafx.h"
+#include <objbase.h>
+#include "ComThread.h"
+// Win32 support for Ole Automation
+#include <wchar.h>
+#include <string.h>
+#include <atlbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+#include "util.h"
+
+extern "C" 
+{
+
+JNIEXPORT void JNICALL Java_com_jacob_com_ComThread_doCoInitialize
+  (JNIEnv *env, jclass cls, jint mode)
+{
+  int threadModel = mode;
+  CoInitializeEx(NULL, threadModel);
+}
+
+JNIEXPORT void JNICALL Java_com_jacob_com_ComThread_doCoUninitialize
+  (JNIEnv *env, jclass cls)
+{
+  CoUninitialize();
+}
+
+}

src/main/cpp/Dispatch.cpp

@@ -0,0 +1,589 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "stdafx.h"
+#include <objbase.h>
+#include "Dispatch.h"
+// Win32 support for Ole Automation
+#include <wchar.h>
+#include <string.h>
+#include <atlbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+#include "util.h"
+
+extern "C" 
+{
+
+#define DISP_FLD "m_pDispatch"
+
+// extract a IDispatch from a jobject
+IDispatch *extractDispatch(JNIEnv *env, jobject arg)
+{
+  jclass argClass = env->GetObjectClass(arg);
+  jfieldID ajf = env->GetFieldID( argClass, DISP_FLD, "J");
+  jlong anum = env->GetLongField(arg, ajf);
+  IDispatch *v = (IDispatch *)anum;
+  return v;
+}
+
+/**
+ * This method finds an interface rooted on the passed in dispatch object.
+ * This creates a new Dispatch object so it is NOT reliable 
+ * in the event callback thread of a JWS client where the root class loader
+ * does not have com.jacob.com.Dispatch in its classpath
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Dispatch_QueryInterface
+  (JNIEnv *env, jobject _this, jstring _iid)
+{
+  // get the current IDispatch
+  IDispatch *pIDispatch = extractDispatch(env, _this);
+  if (!pIDispatch) return NULL;
+  // if we used env->GetStringChars() would that let us drop the conversion?
+  const char *siid = env->GetStringUTFChars(_iid, NULL);
+  USES_CONVERSION;
+  LPOLESTR bsIID = A2W(siid);
+  env->ReleaseStringUTFChars(_iid, siid);
+  IID iid;
+  HRESULT hr = IIDFromString(bsIID, &iid);
+  if (FAILED(hr)) {
+    ThrowComFail(env, "Can't get IID from String", hr);
+    return NULL;
+  }
+
+  // try to call QI on the passed IID
+  IDispatch *disp;
+  hr = pIDispatch->QueryInterface(iid, (void **)&disp);
+  if (FAILED(hr)) {
+    ThrowComFail(env, "QI on IID from String Failed", hr);
+    return NULL;
+  }
+
+  jclass autoClass = env->FindClass("com/jacob/com/Dispatch");
+  jmethodID autoCons = env->GetMethodID(autoClass, "<init>", "(J)V");
+  // construct a Dispatch object to return
+  // I am copying the pointer to java
+  // jacob-msg 1817 - SF 1053871 :  QueryInterface already called AddRef!!
+  //if (disp) disp->AddRef();
+  jobject newAuto = env->NewObject(autoClass, autoCons, disp);
+  return newAuto;
+}
+
+/**
+ * starts up a new instance of the requested program (progId)
+ * and connects to it.  does special code if the progid 
+ * is of the alternate format (with ":")
+ **/
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_createInstanceNative
+  (JNIEnv *env, jobject _this, jstring _progid)
+{
+  jclass clazz = env->GetObjectClass(_this);
+  jfieldID jf = env->GetFieldID( clazz, DISP_FLD, "J");
+
+  // if we used env->GetStringChars() would that let us drop the conversion?
+  const char *progid = env->GetStringUTFChars(_progid, NULL);
+  CLSID clsid;
+  HRESULT hr;
+  IUnknown *punk = NULL;
+  IDispatch *pIDispatch;
+  USES_CONVERSION;
+  LPOLESTR bsProgId = A2W(progid);
+  if (strchr(progid,':')) 
+  {
+     env->ReleaseStringUTFChars(_progid, progid);
+     // it's a moniker
+     hr = CoGetObject(bsProgId, NULL, IID_IUnknown, (LPVOID *)&punk);
+     if (FAILED(hr)) {
+       ThrowComFail(env, "Can't find moniker", hr);
+       return;
+     }
+     IClassFactory *pIClass;
+     // if it was a clsid moniker, I may have a class factory
+     hr = punk->QueryInterface(IID_IClassFactory, (void **)&pIClass);
+     if (!SUCCEEDED(hr)) goto doDisp;
+     punk->Release();
+     // try to create an instance
+     hr = pIClass->CreateInstance(NULL, IID_IUnknown, (void **)&punk);
+     if (FAILED(hr)) {
+       ThrowComFail(env, "Can't create moniker class instance", hr);
+       return;
+     }
+     pIClass->Release();
+     goto doDisp;
+  }
+  env->ReleaseStringUTFChars(_progid, progid);
+  // Now, try to find an IDispatch interface for progid
+  hr = CLSIDFromProgID(bsProgId, &clsid);
+  if (FAILED(hr)) {
+    ThrowComFail(env, "Can't get object clsid from progid", hr);
+    return;
+  }
+  // standard creation
+  hr = CoCreateInstance(clsid,NULL,CLSCTX_LOCAL_SERVER|CLSCTX_INPROC_SERVER,IID_IUnknown, (void **)&punk);
+  if (!SUCCEEDED(hr)) {
+     ThrowComFail(env, "Can't co-create object", hr);
+     return;
+  }
+doDisp:
+
+  // now get an IDispatch pointer from the IUnknown
+  hr = punk->QueryInterface(IID_IDispatch, (void **)&pIDispatch);
+  if (!SUCCEEDED(hr)) {
+    ThrowComFail(env, "Can't QI object for IDispatch", hr);
+    return;
+  }
+  // CoCreateInstance called AddRef
+  punk->Release();
+  env->SetLongField(_this, jf, (jlong)pIDispatch);
+}
+
+/**
+ * attempts to connect to an running instance of the requested program
+ * This exists solely for the factory method connectToActiveInstance.
+ **/
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_getActiveInstanceNative
+  (JNIEnv *env, jobject _this, jstring _progid)
+{
+  jclass clazz = env->GetObjectClass(_this);
+  jfieldID jf = env->GetFieldID( clazz, DISP_FLD, "J");
+
+  // if we used env->GetStringChars() would that let us drop the conversion?
+  const char *progid = env->GetStringUTFChars(_progid, NULL);
+  CLSID clsid;
+  HRESULT hr;
+  IUnknown *punk = NULL;
+  IDispatch *pIDispatch;
+  USES_CONVERSION;
+  LPOLESTR bsProgId = A2W(progid);
+  env->ReleaseStringUTFChars(_progid, progid);
+  // Now, try to find an IDispatch interface for progid
+  hr = CLSIDFromProgID(bsProgId, &clsid);
+  if (FAILED(hr)) {
+    ThrowComFail(env, "Can't get object clsid from progid", hr);
+    return;
+  }
+  // standard connection
+  //printf("trying to connect to running %ls\n",bsProgId);
+  hr = GetActiveObject(clsid,NULL, &punk);
+  if (!SUCCEEDED(hr)) {
+     ThrowComFail(env, "Can't get active object", hr);
+     return;
+  }
+  // now get an IDispatch pointer from the IUnknown
+  hr = punk->QueryInterface(IID_IDispatch, (void **)&pIDispatch);
+  if (!SUCCEEDED(hr)) {
+    ThrowComFail(env, "Can't QI object for IDispatch", hr);
+    return;
+  }
+  // GetActiveObject called AddRef
+  punk->Release();
+  env->SetLongField(_this, jf, (jlong)pIDispatch);
+}
+
+/**
+ * starts up a new instance of the requested program (progId).  
+ * This exists solely for the factory method connectToActiveInstance.
+ **/
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_coCreateInstanceNative
+  (JNIEnv *env, jobject _this, jstring _progid)
+{
+  jclass clazz = env->GetObjectClass(_this);
+  jfieldID jf = env->GetFieldID( clazz, DISP_FLD, "J");
+
+  // if we used env->GetStringChars() would that let us drop the conversion?
+  const char *progid = env->GetStringUTFChars(_progid, NULL);
+  CLSID clsid;
+  HRESULT hr;
+  IUnknown *punk = NULL;
+  IDispatch *pIDispatch;
+  USES_CONVERSION;
+  LPOLESTR bsProgId = A2W(progid);
+  env->ReleaseStringUTFChars(_progid, progid);
+  // Now, try to find an IDispatch interface for progid
+  hr = CLSIDFromProgID(bsProgId, &clsid);
+  if (FAILED(hr)) {
+    ThrowComFail(env, "Can't get object clsid from progid", hr);
+    return;
+  }
+  // standard creation
+  hr = CoCreateInstance(clsid,NULL,CLSCTX_LOCAL_SERVER|CLSCTX_INPROC_SERVER,IID_IUnknown, (void **)&punk);
+  if (!SUCCEEDED(hr)) {
+     ThrowComFail(env, "Can't co-create object", hr);
+     return;
+  }
+  // now get an IDispatch pointer from the IUnknown
+  hr = punk->QueryInterface(IID_IDispatch, (void **)&pIDispatch);
+  if (!SUCCEEDED(hr)) {
+    ThrowComFail(env, "Can't QI object for IDispatch", hr);
+    return;
+  }
+  // CoCreateInstance called AddRef
+  punk->Release();
+  env->SetLongField(_this, jf, (jlong)pIDispatch);
+}
+
+/**
+ * release method
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_release
+  (JNIEnv *env, jobject _this)
+{
+  jclass clazz = env->GetObjectClass(_this);
+  jfieldID jf = env->GetFieldID( clazz, DISP_FLD, "J");
+  jlong num = env->GetLongField(_this, jf);
+
+  IDispatch *disp = (IDispatch *)num;
+  if (disp) {
+    disp->Release();
+    env->SetLongField(_this, jf, 0ll);
+  }
+}
+
+static HRESULT
+name2ID(IDispatch *pIDispatch, const char *prop, DISPID *dispid, long lcid)
+{
+  HRESULT     hresult;
+  USES_CONVERSION;
+  LPOLESTR propOle = A2W(prop);
+  hresult = pIDispatch->GetIDsOfNames(IID_NULL,(LPOLESTR*)&propOle,1,lcid,dispid);
+  return hresult;
+}
+
+JNIEXPORT jintArray JNICALL Java_com_jacob_com_Dispatch_getIDsOfNames
+  (JNIEnv *env, jclass clazz, jobject disp, jint lcid, jobjectArray names)
+{
+  IDispatch *pIDispatch = extractDispatch(env, disp);
+  if (!pIDispatch) return NULL;
+
+  int l = env->GetArrayLength(names);
+  int i;
+  LPOLESTR *lps = (LPOLESTR *)CoTaskMemAlloc(l * sizeof(LPOLESTR));
+  DISPID *dispid = (DISPID *)CoTaskMemAlloc(l * sizeof(DISPID));
+  for(i=0;i<l;i++) 
+  {
+    USES_CONVERSION;
+    jstring s = (jstring)env->GetObjectArrayElement(names, i);
+	// if we used env->GetStringChars() would that let us drop the conversion?
+    const char *nm = env->GetStringUTFChars(s, NULL);
+    LPOLESTR nmos = A2W(nm);
+    env->ReleaseStringUTFChars(s, nm);
+    lps[i] = nmos;
+    env->DeleteLocalRef(s);
+  }
+  HRESULT hr = pIDispatch->GetIDsOfNames(IID_NULL,lps,l,lcid,dispid);
+  if (FAILED(hr)) {
+    CoTaskMemFree(lps);
+    CoTaskMemFree(dispid);
+    char buf[1024];
+    strcpy_s(buf, "Can't map names to dispid:");
+    for(i=0;i<l;i++) 
+    {
+      USES_CONVERSION;
+      jstring s = (jstring)env->GetObjectArrayElement(names, i);
+      const char *nm = env->GetStringUTFChars(s, NULL);
+      strcat_s(buf, nm);
+      env->ReleaseStringUTFChars(s, nm);
+      env->DeleteLocalRef(s);
+    }
+    ThrowComFail(env, buf, hr);
+    return NULL;
+  }
+  jintArray iarr = env->NewIntArray(l);
+  // SF 1511033 -- the 2nd parameter should be 0 and not i!
+  env->SetIntArrayRegion(iarr, 0, l, dispid);
+  CoTaskMemFree(lps);
+  CoTaskMemFree(dispid);
+  return iarr;
+}
+
+static char* BasicToCharString(const BSTR inBasicString)
+{
+    char* charString = NULL;
+    const size_t charStrSize = ::SysStringLen(inBasicString) + 1;
+    if (charStrSize > 1)
+    {
+        charString = new char[charStrSize];
+		size_t convertedSize;
+		::wcstombs_s(&convertedSize, charString, charStrSize, inBasicString, charStrSize);
+    }
+    else 
+    {
+        charString = ::_strdup("");
+    }
+    return charString;
+}
+
+static wchar_t* CreateErrorMsgFromResult(HRESULT inResult)
+{
+  wchar_t* msg = NULL;
+  ::FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+      FORMAT_MESSAGE_FROM_SYSTEM, NULL, inResult,MAKELANGID(LANG_NEUTRAL,
+      SUBLANG_DEFAULT), (LPWSTR) &msg, 0, NULL);
+  if (msg == NULL)
+  {
+    const wchar_t* message_text = L"An unknown COM error has occured.";
+    size_t bufferLength = (wcslen(message_text) + 1) * sizeof(wchar_t);
+    msg = (wchar_t*) ::LocalAlloc(LPTR, bufferLength);
+    wcscpy_s(msg, bufferLength, message_text);
+  }
+  // SF 3435567 add HRESULT to error message
+  size_t bufferLength = (wcslen(msg) + 100) * sizeof(wchar_t);
+  wchar_t* plus = (wchar_t*) ::LocalAlloc(LPTR, bufferLength);
+  // Had to force this to wide/unicode. We must be missing a macro or setting somewhere
+  wsprintfW(plus, L"%x / %s", inResult, msg);
+
+  ::LocalFree(msg);
+
+  return plus;
+}
+
+static wchar_t* CreateErrorMsgFromInfo(HRESULT inResult, EXCEPINFO* ioInfo,
+ const char* methName)
+{
+  wchar_t* msg = NULL;
+  size_t methNameWSize = 0;
+
+  mbstowcs_s(&methNameWSize, NULL, 0, methName, _TRUNCATE);
+
+  wchar_t* methNameW = new wchar_t[methNameWSize];
+
+  mbstowcs_s(NULL, methNameW, methNameWSize, methName, _TRUNCATE);
+
+  // If this is a dispatch exception (triggered by an Invoke message),
+  // then we have to take some additional steps to process the error
+  // message.
+  if  (inResult == DISP_E_EXCEPTION)
+  {
+    // Check to see if the server deferred filling in the exception
+    // information.  If so, make the call to populate the structure.
+    if (ioInfo->pfnDeferredFillIn != NULL)
+        (*(ioInfo->pfnDeferredFillIn))(ioInfo);
+
+    // Build the error message from exception information content.
+    int sourceLen = SysStringLen(ioInfo->bstrSource);
+    int descLen = SysStringLen(ioInfo->bstrDescription);
+    const size_t MSG_LEN = ::wcslen(methNameW) + sourceLen + descLen + 128;
+    msg = new wchar_t[MSG_LEN];
+    ::wcsncpy_s(msg, MSG_LEN, L"Invoke of: ", wcslen(L"Invoke of: "));
+    ::wcsncat_s(msg, MSG_LEN, methNameW, wcslen(methNameW));
+    ::wcsncat_s(msg, MSG_LEN, L"\nSource: ", wcslen(L"\nSource: "));
+    ::wcsncat_s(msg, MSG_LEN, ioInfo->bstrSource, sourceLen);
+    ::wcsncat_s(msg, MSG_LEN, L"\nDescription: ", wcslen(L"\nDescription: "));
+    ::wcsncat_s(msg, MSG_LEN, ioInfo->bstrDescription, descLen);
+    ::wcsncat_s(msg, MSG_LEN, L"\n", wcslen(L"\n"));
+  }
+  else
+  {
+    wchar_t* msg2 = CreateErrorMsgFromResult(inResult);
+    const size_t MSG_LEN = ::wcslen(methNameW) + ::wcslen(msg2) + 256;
+    msg = new wchar_t[MSG_LEN];
+    ::wcsncpy_s(msg, MSG_LEN, 
+		L"A COM exception has been encountered:\nAt Invoke of: ", 
+		wcslen(L"A COM exception has been encountered:\nAt Invoke of: "));
+    ::wcsncat_s(msg, MSG_LEN, methNameW, wcslen(methNameW));
+    ::wcsncat_s(msg, MSG_LEN, L"\nDescription: ", wcslen(L"\nDescription: "));
+    ::wcsncat_s(msg, MSG_LEN, msg2, wcslen(msg2));
+    // jacob-msg 1075 - SF 1053872 : Documentation says "use LocalFree"!! 
+    //delete msg2;
+	LocalFree(msg2); 
+  }
+  delete methNameW;
+  return msg;
+}
+
+
+#define SETDISPPARAMS(dp, numArgs, pvArgs, numNamed, pNamed) \
+        {\
+           (dp).cArgs  = numArgs; \
+           (dp).rgvarg = pvArgs; \
+           (dp).cNamedArgs = numNamed; \
+           (dp).rgdispidNamedArgs = pNamed; \
+        }
+
+#define SETNOPARAMS(dp) SETDISPPARAMS(dp, 0, NULL, 0, NULL)
+
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Dispatch_invokev
+  (JNIEnv *env, jclass clazz,
+  jobject disp, jstring name, jint dispid,
+  jint lcid, jint wFlags, jobjectArray vArg, jintArray uArgErr)
+{
+  DISPPARAMS  dispparams;
+  EXCEPINFO   excepInfo;
+  // Sourceforge Bug Tracker 2935662 uninitialized data can be not NULL with bad results
+  excepInfo.pfnDeferredFillIn = NULL;
+
+  IDispatch *pIDispatch = extractDispatch(env, disp);
+  if (!pIDispatch) return NULL;
+
+  int dispID = dispid;
+  if (name != NULL) 
+  {
+    const char *nm = env->GetStringUTFChars(name, NULL);
+    HRESULT hr;
+    if (FAILED(hr = name2ID(pIDispatch, nm, (long *)&dispID, lcid))) {
+      char buf[1024];
+      sprintf_s(buf, 1024, "Can't map name to dispid: %s", nm);
+      ThrowComFail(env, buf, -1);
+      return NULL;
+    }
+    env->ReleaseStringUTFChars(name, nm);
+  }
+
+  int num_args = env->GetArrayLength(vArg);
+  int i, j;
+  VARIANT *varr = NULL;
+  if (num_args) 
+  {
+    varr = (VARIANT *)CoTaskMemAlloc(num_args*sizeof(VARIANT));
+    /* reverse args for dispatch */
+    for(i=num_args-1,j=0;0<=i;i--,j++) 
+    {
+      VariantInit(&varr[j]);
+      jobject arg = env->GetObjectArrayElement(vArg, i);
+      VARIANT *v = extractVariant(env, arg);
+      // no escape from copy?
+      VariantCopy(&varr[j], v);
+      env->DeleteLocalRef(arg);
+    }
+  }
+  // prepare a new return value
+  jclass variantClass = env->FindClass("com/jacob/com/Variant");
+  jmethodID variantCons = 
+      env->GetMethodID(variantClass, "<init>", "()V");
+  // construct a variant to return
+  jobject newVariant = env->NewObject(variantClass, variantCons);
+  // get the VARIANT from the newVariant
+  VARIANT *v = extractVariant(env, newVariant);
+  DISPID  dispidPropertyPut = DISPID_PROPERTYPUT;
+
+  // determine how to dispatch
+  switch (wFlags) 
+  {
+    case DISPATCH_PROPERTYGET: // GET
+    case DISPATCH_METHOD: // METHOD
+    case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
+      {
+        SETDISPPARAMS(dispparams, num_args, varr, 0, NULL);
+        break;
+      }
+    case DISPATCH_PROPERTYPUT:
+    case DISPATCH_PROPERTYPUTREF: // jacob-msg 1075 - SF 1053872
+      {
+        SETDISPPARAMS(dispparams, num_args, varr, 1, &dispidPropertyPut);
+        break;
+      }
+  }
+
+  HRESULT hr = 0;
+  jint count = env->GetArrayLength(uArgErr);
+  if ( count != 0 )
+  {
+	  jint *uAE = env->GetIntArrayElements(uArgErr, NULL);
+	  hr = pIDispatch->Invoke(dispID,IID_NULL,
+		lcid,(WORD)wFlags,&dispparams,v,&excepInfo,(unsigned int *)uAE); // SF 1689061
+	  env->ReleaseIntArrayElements(uArgErr, uAE, 0);
+  }
+  else
+  {
+	  hr = pIDispatch->Invoke(dispID,IID_NULL,
+		lcid,(WORD)wFlags,&dispparams,v,&excepInfo, NULL); // SF 1689061
+  }
+  if (num_args) 
+  {
+    // to account for inouts, I need to copy the inputs back to
+    // the java array after the method returns
+    // this occurs, for example, in the ADO wrappers
+    for(i=num_args-1,j=0;0<=i;i--,j++) 
+    {
+      jobject arg = env->GetObjectArrayElement(vArg, i);
+      VARIANT *v = extractVariant(env, arg);
+      // reverse copy
+      VariantCopy(v, &varr[j]);
+      // clear out the temporary variant
+      VariantClear(&varr[j]);
+      env->DeleteLocalRef(arg);
+    }
+  }
+
+  if (varr) CoTaskMemFree(varr);
+
+  // check for error and display a somewhat verbose error message
+  if (!SUCCEEDED(hr)) {
+    // two buffers that may have to be freed later
+    wchar_t *buf = NULL;
+    char *dispIdAsName = NULL;
+    // this method can get called with a name or a dispatch id
+    // we need to handle both SF 1114159 
+    if (name != NULL){
+	    const char *nm = env->GetStringUTFChars(name, NULL);
+	    buf = CreateErrorMsgFromInfo(hr, &excepInfo, nm);
+	    env->ReleaseStringUTFChars(name, nm);
+    } else {
+		dispIdAsName = new char[256];
+		// get the id string
+		_itoa_s (dispID, dispIdAsName, 256,10);
+		//continue on mostly as before
+		buf = CreateErrorMsgFromInfo(hr,&excepInfo,dispIdAsName); 
+    }
+    
+    // jacob-msg 3696 - SF 1053866
+	if(hr == DISP_E_EXCEPTION)
+	{
+		if(excepInfo.scode != 0)
+		{
+			hr = excepInfo.scode;
+		}
+		else
+		{
+			hr = _com_error::WCodeToHRESULT(excepInfo.wCode);
+		}
+	}
+	
+    ThrowComFailUnicode(env, buf, hr);
+    if (buf) delete buf;
+    if (dispIdAsName) delete dispIdAsName;
+    return NULL;
+  }
+
+  return newVariant;
+}
+
+/*
+ * Wait method added so folks could wait until a com server terminated
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_Dispatch_hasExited
+		(JNIEnv *env,jclass clazz, jobject disp, jint dispid, jint lcid) {
+	IDispatch *pIDispatch = extractDispatch(env, disp);
+	if (!pIDispatch) {
+		// should we return 0?
+		return NULL;
+	}
+	ITypeInfo *v;
+	HRESULT hr = pIDispatch->GetTypeInfo(dispid, lcid, &v);
+	if (hr == RPC_E_SERVERCALL_RETRYLATER || hr == RPC_E_CALL_REJECTED || hr
+			== 0) {
+		return 0;
+	} else {
+		return 1;
+	}
+}
+
+}
+
+

src/main/cpp/DispatchEvents.cpp

@@ -0,0 +1,373 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "DispatchEvents.h"
+#include "EventProxy.h"
+// Win32 support for Ole Automation
+#include <wchar.h>
+#include <string.h>
+#include <atlbase.h>
+#include <objbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+
+#include "util.h"
+
+extern "C"
+{
+
+#define PROXY_FLD "m_pConnPtProxy"
+
+// defined below
+BOOL GetEventIID(IUnknown*, IID*, CComBSTR **, DISPID **, int *,LPOLESTR);
+BOOL GetEventIIDForTypeLib(BSTR, IID*, CComBSTR **, DISPID **, int *,LPOLESTR);
+BOOL getClassInfoFromProgId(LPOLESTR bsProgId,LPTYPEINFO *pClassInfo);
+BOOL MapEventIIDs(IID*, CComBSTR **, DISPID **, int *, LPOLESTR , LPTYPEINFO );
+
+// extract a EventProxy* from a jobject
+EventProxy *extractProxy(JNIEnv *env, jobject arg)
+{
+  jclass argClass = env->GetObjectClass(arg);
+  jfieldID ajf = env->GetFieldID( argClass, PROXY_FLD, "J");
+  jlong anum = env->GetLongField(arg, ajf);
+  EventProxy *v = (EventProxy *)anum;
+  return v;
+}
+
+/*
+ * pushes the EventProxy (*ep) into tje jobject in the PROXY_FLD location
+ */
+void putProxy(JNIEnv *env, jobject arg, EventProxy *ep)
+{
+  jclass argClass = env->GetObjectClass(arg);
+  jfieldID ajf = env->GetFieldID( argClass, PROXY_FLD, "J");
+  jlong anum = env->GetLongField(arg, ajf);
+  env->SetLongField(arg, ajf, (jlong)ep);
+}
+
+
+/*
+ * Class:     com_jacob_com_DispatchEvents
+ * Method:    init3
+ * Signature: (Lcom/jacob/com/Dispatch;Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchEvents_init3
+   (JNIEnv *env,
+    jobject _this, jobject src,
+    jobject sink, 
+    jstring _progid, 
+    jstring _typelib)
+{
+	USES_CONVERSION;
+
+  if (_typelib != NULL && _progid == NULL){
+  	// both are required if typelib exists
+  	ThrowComFail(env,"TypeLib was specified but no program id was",-1);
+  	return;
+  }
+  
+  BSTR typeLib = NULL;
+  if (_typelib != NULL){
+  	  // why is this UTF instead of unicode? Then we could probably drop the A2W
+	  const char *typelib = env->GetStringUTFChars(_typelib, NULL);
+	  typeLib = A2W(typelib);
+	  // should we call env->ReleaseStringUTFChars(,) to free the memory like we do everywhere lese?
+	  
+	  //printf("we have a type lib %ls\n",typeLib);
+  }
+
+  // find progid if any
+  LPOLESTR bsProgId = NULL;
+  if (_progid!=NULL) {
+    	// why is this UTF instead of unicode?  Then we could probably drop the A2W
+    	const char *progid = env->GetStringUTFChars(_progid, NULL);
+		bsProgId = A2W(progid);
+	  // should we call env->ReleaseStringUTFChars(,) to free the memory like we do everywhere lese?
+		//printf("we have an applicaton %ls\n",bsProgId);
+  }
+  
+  // get the IDispatch for the source object
+  IDispatch *pDisp = extractDispatch(env, src);
+  CComQIPtr<IUnknown, &IID_IUnknown> pUnk(pDisp);
+  // see if it implements connection points
+  CComQIPtr<IConnectionPointContainer, &IID_IConnectionPointContainer> pCPC(pUnk);
+  if (!pCPC)
+  {
+    // no events, throw something
+    ThrowComFail(env, "Can't find IConnectionPointContainer", -1);
+    return;
+  }
+   
+  IID eventIID;
+  CComBSTR *mNames;
+  DISPID *mIDs;
+  int n_EventMethods;
+  if (_typelib == NULL){
+	  if (!GetEventIID(pUnk, &eventIID, &mNames, &mIDs, &n_EventMethods,bsProgId)) {
+    	ThrowComFail(env, "Can't find event iid", -1);
+	    return;
+	  }
+  } else {
+	  if (!GetEventIIDForTypeLib(typeLib, &eventIID, &mNames, &mIDs, &n_EventMethods,bsProgId)) {
+    	ThrowComFail(env, "Can't find event iid for type lib", -1);
+	    return;
+	  }
+  }
+
+  // hook up to the default source iid
+  CComPtr<IConnectionPoint> pCP;
+  HRESULT hr = pCPC->FindConnectionPoint(eventIID, &pCP);
+  if (SUCCEEDED(hr))
+  {
+    EventProxy *ep = new EventProxy(env, sink, pCP, eventIID, mNames, mIDs, n_EventMethods);
+    // need to store ep on _this, in case it gets collected
+    putProxy(env, _this, ep);
+  } else {
+    ThrowComFail(env, "Can't FindConnectionPoint", hr);
+  }
+}
+
+/*
+ * Class:     DispatchEvents
+ * Method:    release
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchEvents_release
+  (JNIEnv *env, jobject _this)
+{
+  EventProxy *ep = extractProxy(env, _this);
+  if (ep) {
+	// Disconnect must be called to reduce the ref count to the EventProxy otherwise
+	// the destructor will never be called (to actually do the disconnect)
+	ep->Disconnect(); // SF 3412922
+  	// this is the line that blows up in IETest
+    ep->Release();
+    putProxy(env, _this, NULL);
+  }
+}
+
+/*
+ * I need a reverse map from the event interface's dispids to
+ * function names so that we can reflect them to java
+ */
+void
+LoadNameCache(LPTYPEINFO pTypeInfo, LPTYPEATTR pta,
+   CComBSTR **mNames, DISPID **mIDs, int *nmeth)
+{
+  CComBSTR *names = NULL;
+  DISPID   *ids = NULL;
+  int m_nCount;
+
+  m_nCount = pta->cFuncs;
+  *nmeth = m_nCount;
+  names = m_nCount == 0 ? NULL : new CComBSTR[m_nCount];
+  ids = m_nCount == 0 ? NULL : new DISPID[m_nCount];
+  for (int i=0; i<m_nCount; i++)
+  {
+    FUNCDESC* pfd;
+    if (SUCCEEDED(pTypeInfo->GetFuncDesc(i, &pfd)))
+    {
+      CComBSTR bstrName;
+      if (SUCCEEDED(pTypeInfo->GetDocumentation(pfd->memid, &bstrName, NULL, NULL, NULL)))
+      {
+        names[i].Attach(bstrName.Detach());
+        ids[i] = pfd->memid;
+        /*
+        USES_CONVERSION;
+        printf("map:%d -> %s\n", ids[i], W2A((OLECHAR *)names[i]));
+        */
+      }
+      pTypeInfo->ReleaseFuncDesc(pfd);
+    }
+  }
+  *mNames = names;
+  *mIDs = ids;
+}
+
+#define IMPLTYPE_MASK \
+  (IMPLTYPEFLAG_FDEFAULT | IMPLTYPEFLAG_FSOURCE | IMPLTYPEFLAG_FRESTRICTED)
+
+#define IMPLTYPE_DEFAULTSOURCE \
+  (IMPLTYPEFLAG_FDEFAULT | IMPLTYPEFLAG_FSOURCE)
+
+BOOL GetEventIID(IUnknown *m_pObject, IID* piid,
+     CComBSTR **mNames, DISPID **mIDs, int *nmeth,LPOLESTR bsProgId)
+{
+  *piid = GUID_NULL;
+  ATLASSERT(m_pObject != NULL);
+  // I Always use IProvideClassInfo rather than IProvideClassInfo2
+  // since I also need to create a mapping from dispid to name
+  LPPROVIDECLASSINFO pPCI = NULL;
+  LPTYPEINFO pClassInfo = NULL;
+  if (SUCCEEDED(m_pObject->QueryInterface(IID_IProvideClassInfo, (LPVOID*)&pPCI)))
+  {
+    //printf("got IProvideClassInfo\n");
+    ATLASSERT(pPCI != NULL);
+		HRESULT hr = pPCI->GetClassInfo(&pClassInfo);
+    pPCI->Release();
+    if (!SUCCEEDED(hr)) return false;
+  }
+  else if (getClassInfoFromProgId(bsProgId,&pClassInfo)) {
+	}
+	else  {
+    printf("GetEventIID: couldn't get IProvideClassInfo\n");
+		return false;
+  }
+
+  return MapEventIIDs(piid, mNames, mIDs, nmeth, bsProgId, pClassInfo);
+}
+
+BOOL MapEventIIDs(IID* piid,
+     CComBSTR **mNames, DISPID **mIDs, int *nmeth, LPOLESTR bsProgId, LPTYPEINFO pClassInfo)
+{
+      ATLASSERT(pClassInfo != NULL);
+      //printf("MapEventIIDs: got past ClassInfo assert\n");
+      LPTYPEATTR pClassAttr;
+      if (SUCCEEDED(pClassInfo->GetTypeAttr(&pClassAttr)))
+      {
+        //printf("MapEventIIDs: got TypeAttr\n");
+        ATLASSERT(pClassAttr != NULL);
+        ATLASSERT(pClassAttr->typekind == TKIND_COCLASS);
+
+        // Search for typeinfo of the default events interface.
+        int nFlags;
+        HREFTYPE hRefType;
+
+		//printf("MapEventIIDs: looking at %d class attribute impl types \n");
+        for (unsigned int i = 0; i < pClassAttr->cImplTypes; i++)
+        {
+          if (SUCCEEDED(pClassInfo->GetImplTypeFlags(i, &nFlags)) &&
+            ((nFlags & IMPLTYPE_MASK) == IMPLTYPE_DEFAULTSOURCE))
+          {
+            // Found it.  Now look at its attributes to get IID.
+            LPTYPEINFO pEventInfo = NULL;
+            if (SUCCEEDED(pClassInfo->GetRefTypeOfImplType(i,
+                &hRefType)) &&
+              SUCCEEDED(pClassInfo->GetRefTypeInfo(hRefType,
+                &pEventInfo)))
+            {
+              ATLASSERT(pEventInfo != NULL);
+              LPTYPEATTR pEventAttr;
+              if (SUCCEEDED(pEventInfo->GetTypeAttr(&pEventAttr)))
+              {
+                ATLASSERT(pEventAttr != NULL);
+
+                // create a mapping from dispid to string
+                LoadNameCache(pEventInfo, pEventAttr,
+                              mNames, mIDs, nmeth);
+
+                *piid = pEventAttr->guid;
+                pEventInfo->ReleaseTypeAttr(pEventAttr);
+              }
+              pEventInfo->Release();
+            }
+            break;
+          }
+        }
+        pClassInfo->ReleaseTypeAttr(pClassAttr);
+      }
+      pClassInfo->Release();
+
+  return (!IsEqualIID(*piid, GUID_NULL));
+}
+
+BOOL getClassInfoFromProgId(LPOLESTR bsProgId,LPTYPEINFO *pClassInfo)
+{
+  USES_CONVERSION;
+  CLSID clsid;
+  GUID libid;
+  if (FAILED(CLSIDFromProgID(bsProgId, &clsid))) return false;
+  if (FAILED(StringFromCLSID(clsid,&bsProgId))) return false;
+  HKEY keySoftware, keyClasses, keyCLSID, keyXXXX, keyTypeLib;
+  DWORD dwType, dwCountData=50;
+  BYTE abData[50];
+  LONG lVal;
+  lVal = RegOpenKeyEx(HKEY_LOCAL_MACHINE,_T("SOFTWARE"),0,KEY_READ,&keySoftware);
+  if (lVal==ERROR_SUCCESS) {
+		lVal = RegOpenKeyEx(keySoftware,_T("Classes"),0,KEY_READ,&keyClasses);
+		if (lVal==ERROR_SUCCESS) {
+			lVal = RegOpenKeyEx(keyClasses,_T("CLSID"),0,KEY_READ,&keyCLSID);
+			if (lVal==ERROR_SUCCESS) {
+				_TCHAR *tsProgId = W2T(bsProgId);
+				lVal = RegOpenKeyEx(keyCLSID,tsProgId,0,KEY_READ,&keyXXXX);
+				if (lVal==ERROR_SUCCESS) {
+					lVal = RegOpenKeyEx(keyXXXX,_T("TypeLib"),0,KEY_READ,&keyTypeLib);
+					if (lVal==ERROR_SUCCESS) {
+						lVal = RegQueryValueExA(keyTypeLib,NULL,NULL,&dwType,abData,&dwCountData);
+						RegCloseKey(keyTypeLib);
+				  }
+					RegCloseKey(keyXXXX);
+			  }
+				RegCloseKey(keyCLSID);
+			}
+			RegCloseKey(keyClasses);
+		}
+		RegCloseKey(keySoftware);
+  }
+  if (lVal!=ERROR_SUCCESS) return false;
+  BSTR bsLibId = A2BSTR((char*)abData);
+  if (FAILED(CLSIDFromString(bsLibId,&libid))) return false;
+  //Try loading from registry information.
+  ITypeLib* pITypeLib;
+  if (FAILED(LoadRegTypeLib(libid,1,0, LANG_NEUTRAL, &pITypeLib))) return false;
+  //Find ITypeInfo for coclass.
+  pITypeLib->GetTypeInfoOfGuid(clsid, pClassInfo);
+  pITypeLib->Release();
+  return true;
+}
+
+/*
+ * Get the class info from the progId using the given typeLib.
+ */
+BOOL getClassInfoFromProgIdTypeLib(BSTR typeLib, LPOLESTR bsProgId, LPTYPEINFO *pClassInfo)
+{
+  USES_CONVERSION;
+  CLSID clsid;
+
+  if (FAILED(CLSIDFromProgID(bsProgId, &clsid))) return false;
+  if (FAILED(StringFromCLSID(clsid,&bsProgId))) return false;
+
+  ITypeLib* pITypeLib;
+  if (FAILED(LoadTypeLib(typeLib, &pITypeLib)))	return false;
+
+  //Find ITypeInfo for coclass.
+  pITypeLib->GetTypeInfoOfGuid(clsid, pClassInfo);
+  pITypeLib->Release();
+  return true;
+}
+
+BOOL GetEventIIDForTypeLib(BSTR typeLib, IID* piid,
+     CComBSTR **mNames, DISPID **mIDs, int *nmeth,LPOLESTR bsProgId)
+{
+  LPTYPEINFO pClassInfo = NULL;
+  if(getClassInfoFromProgIdTypeLib(typeLib, bsProgId,&pClassInfo))
+  {
+  	if (pClassInfo == NULL){
+  		printf("we had a successful return but pClassInfo is null\n");
+  	}
+    return MapEventIIDs(piid, mNames, mIDs, nmeth, bsProgId, pClassInfo);
+  }
+  else
+  {
+    printf("GetEventIIDForTypeLib: couldn't get IProvideClassInfo\n");
+    return false;
+  }
+}
+
+}

src/main/cpp/DispatchProxy.cpp

@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "stdafx.h"
+#include <objbase.h>
+#include "ComThread.h"
+// Win32 support for Ole Automation
+#include <wchar.h>
+#include <string.h>
+#include <atlbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+#include "util.h"
+
+extern "C" 
+{
+
+// extract a IStream from a jobject
+IStream *extractStream(JNIEnv *env, jobject arg)
+{
+  jclass argClass = env->GetObjectClass(arg);
+  jfieldID ajf = env->GetFieldID( argClass, "m_pStream", "J");
+  jlong anum = env->GetLongField(arg, ajf);
+  IStream *v = (IStream *)anum;
+  return v;
+}
+
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchProxy_MarshalIntoStream
+  (JNIEnv *env, jobject _this, jobject disp)
+{
+  IDispatch *pIDispatch = extractDispatch(env, disp);
+  if (!pIDispatch) return;
+  IStream *ps; // this is the stream we will marshall into
+  HRESULT hr = CoMarshalInterThreadInterfaceInStream(
+                 IID_IDispatch, pIDispatch, &ps);
+  if (!SUCCEEDED(hr))
+  {
+    ThrowComFail(env, "Could not Marshal Dispatch into IStream", hr);
+    return;
+  }
+  // store the stream pointer on the object
+  jclass argClass = env->GetObjectClass(_this);
+  jfieldID ajf = env->GetFieldID( argClass, "m_pStream", "J");
+  env->SetLongField(_this, ajf, (jlong)ps);
+}
+
+JNIEXPORT jobject JNICALL Java_com_jacob_com_DispatchProxy_MarshalFromStream
+  (JNIEnv *env, jobject _this)
+{
+  IStream *ps = extractStream(env, _this);
+  if (!ps) 
+  {
+    ThrowComFail(env, "Could not get IStream from DispatchProxy", -1);
+    return NULL;
+  }
+  IDispatch *pD;
+  HRESULT hr = CoGetInterfaceAndReleaseStream(ps, IID_IDispatch, (void **)&pD);
+  // zero out the stream pointer on the object
+  // since the stream can only be read once
+  jclass argClass = env->GetObjectClass(_this);
+  jfieldID ajf = env->GetFieldID( argClass, "m_pStream", "J");
+  env->SetLongField(_this, ajf, 0ll);
+
+  if (!SUCCEEDED(hr))
+  {
+    ThrowComFail(env, "Could not Marshal Dispatch from IStream", hr);
+    return NULL;
+  }
+  jclass autoClass = env->FindClass("com/jacob/com/Dispatch");
+  jmethodID autoCons = env->GetMethodID(autoClass, "<init>", "(J)V");
+  // construct a Dispatch object to return
+  // I am copying the pointer to java
+  if (pD) pD->AddRef();
+  jobject newAuto = env->NewObject(autoClass, autoCons, pD);
+  return newAuto;
+}
+
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchProxy_release
+  (JNIEnv *env, jobject _this)
+{
+  IStream *ps =  extractStream(env, _this);
+  if (ps) {
+    ps->Release();
+		jclass argClass = env->GetObjectClass(_this);
+    jfieldID ajf = env->GetFieldID( argClass, "m_pStream", "J");
+    env->SetLongField(_this, ajf, 0ll);
+  }
+}
+
+}

src/main/cpp/EnumVariant.cpp

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "stdafx.h"
+#include <objbase.h>
+#include "Dispatch.h"
+// Win32 support for Ole Automation
+#include <wchar.h>
+#include <string.h>
+#include <atlbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+#include "util.h"
+
+/**
+ * An implementation of IEnumVariant based on code submitted by
+ * Thomas Hallgren (mailto:Thomas.Hallgren@eoncompany.com)
+ */
+extern "C"
+{
+
+// extract a IDispatch from a jobject
+IEnumVARIANT* extractEnumVariant(JNIEnv* env, jobject arg)
+{
+  jfieldID FID_pIEnumVARIANT = 0;
+  jclass clazz = env->GetObjectClass(arg);
+  FID_pIEnumVARIANT = env->GetFieldID(clazz, "m_pIEnumVARIANT", "J");
+  return (IEnumVARIANT*)env->GetLongField(arg, FID_pIEnumVARIANT);
+}
+
+JNIEXPORT jint JNICALL
+Java_com_jacob_com_EnumVariant_Next(JNIEnv* env, jobject _this, jobjectArray vars)
+{
+  IEnumVARIANT* self = extractEnumVariant(env, _this);
+	//printf("self=%x\n", self);
+  if(self == NULL)
+    return 0;
+
+  ULONG count = (ULONG)env->GetArrayLength(vars);
+  if(count == 0)
+    return 0;
+
+  VARIANT* sink = (VARIANT*)CoTaskMemAlloc(count * sizeof(VARIANT));
+  // SF 3377279
+  // Added initializing Variant used to retrieve the next value from IEnum
+  // because some implemenations call VariantClear on it before setting a new value
+  for (ULONG i = 0; i < count; ++i)
+  {
+    VariantInit(sink + i);
+  }
+
+  ULONG fetchCount = 0;
+
+  HRESULT hr = self->Next(count, sink, &fetchCount);
+  if(FAILED(hr))
+  {
+    CoTaskMemFree(sink);
+    ThrowComFail(env, "IEnumVARIANT::Next", hr);
+    return 0;
+  }
+
+  // prepare a new return value array
+  //
+  jclass    clazz = env->FindClass("com/jacob/com/Variant");
+  jmethodID ctor  = env->GetMethodID(clazz, "<init>", "()V");
+
+  for(ULONG idx = 0; idx < fetchCount; ++idx)
+  {
+    // construct a variant to return
+    //
+    jobject newVariant = env->NewObject(clazz, ctor);
+    VARIANT* v = extractVariant(env, newVariant);
+    VariantCopy(v, sink + idx);
+    env->SetObjectArrayElement(vars, idx, newVariant);
+    env->DeleteLocalRef(newVariant);
+    //Sourceforge-1674179 fix memory leak
+    // Variants received while iterating IEnumVARIANT must be cleared when no longer needed
+    // The variant has been copied so no longer needed
+    VariantClear(sink);
+  }
+  CoTaskMemFree(sink);
+  return (jint)fetchCount;
+}
+
+JNIEXPORT void JNICALL
+Java_com_jacob_com_EnumVariant_release(JNIEnv* env, jobject _this)
+{
+  IEnumVARIANT* self = extractEnumVariant(env, _this);
+  if(self != NULL)
+  {
+    self->Release();
+    jfieldID FID_pIEnumVARIANT = 0;
+    jclass clazz = env->GetObjectClass(_this);
+    FID_pIEnumVARIANT = env->GetFieldID(clazz, "m_pIEnumVARIANT", "J");
+    env->SetLongField(_this, FID_pIEnumVARIANT, 0ll);
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_jacob_com_EnumVariant_Reset(JNIEnv* env, jobject _this)
+{
+  IEnumVARIANT* self = extractEnumVariant(env, _this);
+  if(self == NULL)
+    return;
+
+  HRESULT hr = self->Reset();
+  if(FAILED(hr))
+    ThrowComFail(env, "IEnumVARIANT::Reset", hr);
+}
+
+JNIEXPORT void JNICALL
+Java_com_jacob_com_EnumVariant_Skip(JNIEnv* env, jobject _this, jint count)
+{
+  IEnumVARIANT* self = extractEnumVariant(env, _this);
+  if(self == NULL)
+    return;
+
+  HRESULT hr = self->Skip((ULONG)count);
+  if(FAILED(hr))
+    ThrowComFail(env, "IEnumVARIANT::Skip", hr);
+}
+
+}

src/main/cpp/EventProxy.cpp

@@ -0,0 +1,876 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "EventProxy.h"
+#include "Variant.h"
+
+// hook myself up as a listener for delegate
+EventProxy::EventProxy(JNIEnv *env, 
+		jobject aSinkObj, 
+        CComPtr<IConnectionPoint> pConn,
+        IID eid, 
+        CComBSTR mName[], 
+        DISPID mID[], 
+        int mNum) :
+   // initialize some variables
+   m_cRef(0), pCP(pConn), 
+   eventIID(eid), MethNum(mNum), MethName(mName), 
+   MethID(mID)
+{
+	// keep a pointer to the sink
+	javaSinkObj = env->NewGlobalRef(aSinkObj);
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+
+	// we need this to attach to the event invocation thread
+	env->GetJavaVM(&jvm);
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+	AddRef();
+    Connect(env);
+}
+
+void EventProxy::Connect(JNIEnv *env) {
+  HRESULT hr = pCP->Advise(this, &dwEventCookie);
+  if (SUCCEEDED(hr)) {
+        connected = 1;
+  } else {
+        connected = 0;
+        // SF 3435567 added debug info to advise failed message
+        char tmp[256];
+        sprintf_s( tmp, 256, "Advise failed with %x (CONNECT_E_ADVISELIMIT is %x)", (int)hr, (int)(CONNECT_E_ADVISELIMIT) );
+        ThrowComFail(env, tmp, hr);
+  }
+}
+
+// unhook myself up as a listener and get rid of delegate
+EventProxy::~EventProxy()
+{
+	JNIEnv *env;
+    Disconnect();
+    jint vmConnectionStatus = JNI_EVERSION ;
+    jint attachReturnStatus = -1; // AttachCurrentThread return status.. negative numbers are failure return codes.
+    
+	// attach to the current running thread -- JDK 1.4 jni.h has two param cover for 3 param call
+    vmConnectionStatus = jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
+		if ((env != NULL)&& env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+   	if (vmConnectionStatus == JNI_EDETACHED){
+		//printf("Unhook: Attaching to current thread using JNI Version 1.2 (%d)\n",vmConnectionStatus);
+		JavaVMAttachArgs attachmentArgs; 
+        attachmentArgs.version = JNI_VERSION_1_2;  
+        attachmentArgs.name = NULL; 
+        attachmentArgs.group = NULL; 
+        attachReturnStatus = jvm->AttachCurrentThread((void **)&env, &attachmentArgs); 
+		if ((env != NULL) && env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+   	} else {
+   		// should really look for JNI_OK versus an error because it could have been JNI_EVERSION
+   		// started method with thread hooked to VM so no need to attach again
+   		//printf("Unhook:  No need to attach because already attached %d\n",vmConnectionStatus);
+   	}
+
+   	// we should always have an env by this point but lets be paranoid and check
+	if (env != NULL){
+		env->DeleteGlobalRef(javaSinkObj);
+			if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+	}
+	if (MethNum) {
+	    delete [] MethName;
+	    delete [] MethID;
+	}
+	// detach from thread only if we attached to it in this function
+	if (attachReturnStatus == 0){
+		jvm->DetachCurrentThread();
+		//printf("Unhook: Detached\n");
+	} else {
+		//printf("Unhook: No need to detatch because attached prior to method\n");
+	}
+  	//fflush(stdout);
+}
+
+void EventProxy::Disconnect() {
+    if (connected) {
+        // insure we don't call Unadvise twice
+        connected = 0;
+        pCP->Unadvise(dwEventCookie);
+    }
+}
+
+// I only support the eventIID interface which was passed in
+// by the DispatchEvent wrapper who looked it up as the
+// source object's default source interface
+STDMETHODIMP EventProxy::QueryInterface(REFIID rid, void **ppv)
+{
+  if (rid == IID_IUnknown || rid == eventIID || rid == IID_IDispatch) 
+  {
+    *ppv = this;
+    AddRef();
+    return S_OK;
+  }
+  return E_NOINTERFACE;
+}
+
+// This should never get called - the event source fires events
+// by dispid's, not by name
+STDMETHODIMP EventProxy::GetIDsOfNames(REFIID riid,
+    OLECHAR **rgszNames, UINT cNames, LCID lcid, DISPID *rgDispID)
+{
+  return E_UNEXPECTED;
+}
+
+// The actual callback from the connection point arrives here
+STDMETHODIMP EventProxy::Invoke(DISPID dispID, REFIID riid,
+    LCID lcid, unsigned short wFlags, DISPPARAMS *pDispParams,
+    VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
+{
+  	const char 	*eventMethodName = NULL; //Sourceforge report 1394001 
+  	JNIEnv      *env = NULL;
+
+  // map dispID to jmethodID
+  for(int i=0;i<MethNum;i++) 
+  {
+    if (MethID[i] == dispID) { 
+		USES_CONVERSION;
+		eventMethodName = W2A((OLECHAR *)MethName[i]);
+    	}
+  }
+  // added 1.12
+  if (!eventMethodName) {
+  	// just bail if can't find signature.  no need to attach
+	// printf("Invoke: didn't find method name for dispatch id %d\n",dispID);
+   	return S_OK;
+  }
+  if (DISPATCH_METHOD & wFlags) 
+  {
+        
+    // attach to the current running thread
+	//printf("Invoke: Attaching to current thread using JNI Version 1.2\n");
+		JavaVMAttachArgs attachmentArgs; 
+        attachmentArgs.version = JNI_VERSION_1_2;  
+        attachmentArgs.name = NULL; 
+        attachmentArgs.group = NULL; 
+        jvm->AttachCurrentThread((void **)&env, &attachmentArgs); 
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+
+	if (!eventMethodName) 
+  	{
+	    // could not find this signature in list
+  		// printf("Invoke: didn't find method name for dispatch id %d\n",dispID);
+  		// this probably leaves a native thread attached to the vm when we don't want it
+  		ThrowComFail(env, "Event method received was not defined as part of callback interface", -1);
+  		
+  		// should we detatch before returning?? We probably never get here if we ThrowComFail()
+	    // jvm->DetachCurrentThread();
+    	return S_OK;
+	  }
+
+	// find the class of the InvocationHandler
+   	jclass javaSinkClass = env->GetObjectClass(javaSinkObj);
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+	//printf("Invoke: Got sink class\n");
+    jmethodID invokeMethod;
+    invokeMethod = env->GetMethodID(javaSinkClass, "invoke", "(Ljava/lang/String;[Lcom/jacob/com/Variant;)Lcom/jacob/com/Variant;");
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+    jstring eventMethodNameAsString = env->NewStringUTF(eventMethodName);
+	//printf("Invoke: Got method name\n");
+	// now do what we need for the variant
+    jmethodID getVariantMethod = env->GetMethodID(javaSinkClass, "getVariant", "()Lcom/jacob/com/Variant;");
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+	//printf("Invoke: Found way too getVariant\n");
+    jobject aVariantObj = env->CallObjectMethod(javaSinkObj, getVariantMethod); 
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+	//printf("Invoke: Made Variant\n");
+   	jclass variantClass = env->GetObjectClass(aVariantObj);
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+
+	// create the variant parameter array
+    // how many params
+    int numVariantParams = pDispParams->cArgs;
+    // make an array of them
+    jobjectArray varr = env->NewObjectArray(numVariantParams, variantClass, 0);
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+	//printf("Invoke: Created Array\n");
+    int i,j;
+    for(i=numVariantParams-1,j=0;i>=0;i--,j++) 
+    {
+      // construct a java variant holder
+	  jobject arg = env->CallObjectMethod(javaSinkObj, getVariantMethod); 
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+      // get the empty variant from it
+      VARIANT *va = extractVariant(env, arg);
+      // copy the value
+      VariantCopy(va, &pDispParams->rgvarg[i]);
+      // put it in the array
+      env->SetObjectArrayElement(varr, j, arg);
+	  env->DeleteLocalRef(arg);
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+    }
+	//printf("Invoke: Filled Array\n");
+    // Set up the return value
+    jobject ret;
+
+    ret = env->CallObjectMethod(javaSinkObj, invokeMethod, 
+		eventMethodNameAsString, varr); 
+	//printf("Invoke: Invoked callback\n");
+    if (!env->ExceptionOccurred() && ret != NULL) {
+        VariantCopy(pVarResult, extractVariant(env,ret));
+    }
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+	// don't need the first variant we created to get the class
+	// SF 1689061 change not accepted but put in as comment for later reminder
+    //Java_com_jacob_com_Variant_release(env, aVariantObj);
+	env->DeleteLocalRef(aVariantObj);
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+
+    // Begin code from Jiffie team that copies parameters back from java to COM
+    for(i=numVariantParams-1,j=0;i>=0;i--,j++) 
+    {
+		jobject arg = env->GetObjectArrayElement(varr, j);
+		VARIANT *java = extractVariant(env, arg);
+		VARIANT *com = &pDispParams->rgvarg[i];
+		convertJavaVariant(java, com);
+		// SF 1689061 change not accepted but put in as comment for later reminder
+		// note that a related fix has been submitted in SF 3435567 to do this in zeroVariant() method
+		//Java_com_jacob_com_Variant_release(env, arg);
+		zeroVariant(env, arg);
+		env->DeleteLocalRef(arg);
+    }
+    // End code from Jiffie team that copies parameters back from java to COM
+    // detach from thread
+	//printf("Invoke: Detatching\n");
+	jvm->DetachCurrentThread();
+  	//fflush(stdout);
+    return S_OK;
+  }
+  return E_NOINTERFACE;
+}
+
+void EventProxy::convertJavaVariant(VARIANT *java, VARIANT *com) {
+
+	  switch (com->vt)
+	  {	  
+		case VT_DISPATCH:
+		{
+			switch (java->vt)
+			{
+				case VT_DISPATCH:
+				{
+					V_DISPATCH(com) = V_DISPATCH(java);
+					break;
+				}
+
+				case VT_DISPATCH | VT_BYREF:
+				{
+					V_DISPATCH(com) = *V_DISPATCHREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_DISPATCH | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_DISPATCH:
+				{
+					*V_DISPATCHREF(com) = V_DISPATCH(java);
+					break;
+				}
+
+				case VT_DISPATCH | VT_BYREF:
+				{
+					*V_DISPATCHREF(com) = *V_DISPATCHREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_BOOL:
+		{
+			switch (java->vt)
+			{
+				case VT_BOOL:
+				{
+					V_BOOL(com) = V_BOOL(java);
+					break;
+				}
+
+				case VT_BOOL | VT_BYREF:
+				{
+					V_BOOL(com) = *V_BOOLREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_BOOL | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_BOOL:
+				{
+					*V_BOOLREF(com) = V_BOOL(java);
+					break;
+				}
+
+				case VT_BOOL | VT_BYREF:
+				{
+					*V_BOOLREF(com) = *V_BOOLREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_UI1:
+		{
+			switch (java->vt)
+			{
+				case VT_UI1:
+				{
+					V_UI1(com) = V_UI1(java);
+					break;
+				}
+
+				case VT_UI1 | VT_BYREF:
+				{
+					V_UI1(com) = *V_UI1REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_UI1 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_UI1:
+				{
+					*V_UI1REF(com) = V_UI1(java);
+					break;
+				}
+
+				case VT_UI1 | VT_BYREF:
+				{
+					*V_UI1REF(com) = *V_UI1REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+
+		case VT_I2:
+		{
+			switch (java->vt)
+			{
+				case VT_I2:
+				{
+					V_I2(com) = V_I2(java);
+					break;
+				}
+
+				case VT_I2 | VT_BYREF:
+				{
+					V_I2(com) = *V_I2REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_I2 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_I2:
+				{
+					*V_I2REF(com) = V_I2(java);
+					break;
+				}
+
+				case VT_I2 | VT_BYREF:
+				{
+					*V_I2REF(com) = *V_I2REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_I4:
+		{
+			switch (java->vt)
+			{
+				case VT_I4:
+				{
+					V_I4(com) = V_I4(java);
+					break;
+				}
+
+				case VT_I4 | VT_BYREF:
+				{
+					V_I4(com) = *V_I4REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_I4 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_I4:
+				{
+					*V_I4REF(com) = V_I4(java);
+					break;
+				}
+
+				case VT_I4 | VT_BYREF:
+				{
+					*V_I4REF(com) = *V_I4REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_R4:
+		{
+			switch (java->vt)
+			{
+				case VT_R4:
+				{
+					V_R4(com) = V_R4(java);
+					break;
+				}
+
+				case VT_R4 | VT_BYREF:
+				{
+					V_R4(com) = *V_R4REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_R4 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_R4:
+				{
+					*V_R4REF(com) = V_R4(java);
+					break;
+				}
+
+				case VT_R4 | VT_BYREF:
+				{
+					*V_R4REF(com) = *V_R4REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_R8:
+		{
+			switch (java->vt)
+			{
+				case VT_R8:
+				{
+					V_R8(com) = V_R8(java);
+					break;
+				}
+
+				case VT_R8 | VT_BYREF:
+				{
+					V_R8(com) = *V_R8REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_R8 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_R8:
+				{
+					*V_R8REF(com) = V_R8(java);
+					break;
+				}
+
+				case VT_R8 | VT_BYREF:
+				{
+					*V_R8REF(com) = *V_R8REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_I1:
+		{
+			switch (java->vt)
+			{
+				case VT_I1:
+				{
+					V_I1(com) = V_I1(java);
+					break;
+				}
+
+				case VT_I1 | VT_BYREF:
+				{
+					V_I1(com) = *V_I1REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_I1 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_I1:
+				{
+					*V_I1REF(com) = V_I1(java);
+					break;
+				}
+
+				case VT_I1 | VT_BYREF:
+				{
+					*V_I1REF(com) = *V_I1REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_UI2:
+		{
+			switch (java->vt)
+			{
+				case VT_UI2:
+				{
+					V_UI2(com) = V_UI2(java);
+					break;
+				}
+
+				case VT_UI2 | VT_BYREF:
+				{
+					V_UI2(com) = *V_UI2REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_UI2 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_UI2:
+				{
+					*V_UI2REF(com) = V_UI2(java);
+					break;
+				}
+
+				case VT_UI2 | VT_BYREF:
+				{
+					*V_UI2REF(com) = *V_UI2REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_UI4:
+		{
+			switch (java->vt)
+			{
+				case VT_UI4:
+				{
+					V_UI4(com) = V_UI4(java);
+					break;
+				}
+
+				case VT_UI4 | VT_BYREF:
+				{
+					V_UI4(com) = *V_UI4REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_UI4 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_UI4:
+				{
+					*V_UI4REF(com) = V_UI4(java);
+					break;
+				}
+
+				case VT_UI4 | VT_BYREF:
+				{
+					*V_UI4REF(com) = *V_UI4REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_INT:
+		{
+			switch (java->vt)
+			{
+				case VT_INT:
+				{
+					V_INT(com) = V_INT(java);
+					break;
+				}
+
+				case VT_INT | VT_BYREF:
+				{
+					V_INT(com) = *V_INTREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_INT | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_INT:
+				{
+					*V_INTREF(com) = V_INT(java);
+					break;
+				}
+
+				case VT_INT | VT_BYREF:
+				{
+					*V_INTREF(com) = *V_INTREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_UINT:
+		{
+			switch (java->vt)
+			{
+				case VT_UINT:
+				{
+					V_UINT(com) = V_UINT(java);
+					break;
+				}
+
+				case VT_UINT | VT_BYREF:
+				{
+					V_UINT(com) = *V_UINTREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_UINT | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_UINT:
+				{
+					*V_UINTREF(com) = V_UINT(java);
+					break;
+				}
+
+				case VT_UINT | VT_BYREF:
+				{
+					*V_UINTREF(com) = *V_UINTREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_CY:
+		{
+			switch (java->vt)
+			{
+				case VT_CY:
+				{
+					V_CY(com) = V_CY(java);
+					break;
+				}
+
+				case VT_CY | VT_BYREF:
+				{
+					V_CY(com) = *V_CYREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_CY | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_CY:
+				{
+					*V_CYREF(com) = V_CY(java);
+					break;
+				}
+
+				case VT_CY | VT_BYREF:
+				{
+					*V_CYREF(com) = *V_CYREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_DATE:
+		{
+			switch (java->vt)
+			{
+				case VT_DATE:
+				{
+					V_DATE(com) = V_DATE(java);
+					break;
+				}
+
+				case VT_DATE | VT_BYREF:
+				{
+					V_DATE(com) = *V_DATEREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_DATE | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_DATE:
+				{
+					*V_DATEREF(com) = V_DATE(java);
+					break;
+				}
+
+				case VT_DATE | VT_BYREF:
+				{
+					*V_DATEREF(com) = *V_DATEREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_BSTR:
+		{
+			switch (java->vt)
+			{
+				case VT_BSTR:
+				{
+					V_BSTR(com) = V_BSTR(java);
+					break;
+				}
+
+				case VT_BSTR | VT_BYREF:
+				{
+					V_BSTR(com) = *V_BSTRREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_BSTR | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_BSTR:
+				{
+					*V_BSTRREF(com) = V_BSTR(java);
+					break;
+				}
+
+				case VT_BSTR | VT_BYREF:
+				{
+					*V_BSTRREF(com) = *V_BSTRREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_DECIMAL:
+		{
+			switch (java->vt)
+			{
+				case VT_DECIMAL:
+				{
+					V_DECIMAL(com) = V_DECIMAL(java);
+					break;
+				}
+
+				case VT_DECIMAL | VT_BYREF:
+				{
+					V_DECIMAL(com) = *V_DECIMALREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_DECIMAL | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_DECIMAL:
+				{
+					*V_DECIMALREF(com) = V_DECIMAL(java);
+					break;
+				}
+
+				case VT_DECIMAL | VT_BYREF:
+				{
+					*V_DECIMALREF(com) = *V_DECIMALREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+
+    }
+}

src/main/cpp/STA.cpp

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "stdafx.h"
+#include <objbase.h>
+#include "ComThread.h"
+// Win32 support for Ole Automation
+#include <wchar.h>
+#include <string.h>
+#include <atlbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+#include "util.h"
+
+extern "C" 
+{
+
+JNIEXPORT void JNICALL Java_com_jacob_com_STA_doMessagePump
+  (JNIEnv *env, jobject obj)
+{
+  // store the current thread id so we can kill it
+  jclass argClass = env->GetObjectClass(obj);
+  jfieldID ajf = env->GetFieldID( argClass, "threadID", "I");
+  jint threadID = (jint)GetCurrentThreadId();
+  env->SetIntField(obj, ajf, threadID);
+
+  MSG msg;
+
+  ZeroMemory(&msg, sizeof(msg));
+  msg.wParam = S_OK;
+
+  while (GetMessage(&msg, NULL, 0, 0))
+  {
+    DispatchMessage(&msg);
+  }
+}
+
+JNIEXPORT void JNICALL Java_com_jacob_com_STA_quitMessagePump
+  (JNIEnv *env, jobject obj)
+{
+  jclass argClass = env->GetObjectClass(obj);
+  jfieldID ajf = env->GetFieldID( argClass, "threadID", "I");
+  jint threadID = env->GetIntField(obj, ajf);
+  PostThreadMessage((DWORD)threadID, WM_QUIT, 0, 0);
+}
+
+}

src/main/cpp/util.cpp

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "Dispatch.h"
+// Win32 support for Ole Automation
+#include <wchar.h>
+#include <string.h>
+#include <atlbase.h>
+#include <objbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+#include "util.h"
+
+extern "C" 
+{
+
+void ThrowComFail(JNIEnv *env, const char* desc, jint hr)
+{
+  jclass failClass = env->FindClass("com/jacob/com/ComFailException");
+  // call the constructor that takes hr and message
+  jmethodID failCons = 
+     env->GetMethodID(failClass, "<init>", "(ILjava/lang/String;)V");
+  if (!desc) {
+	  desc = "Java/COM Error";
+  }
+  jstring js = env->NewStringUTF(desc);
+  jthrowable fail = (jthrowable)env->NewObject(failClass, failCons, hr, js);
+  env->Throw(fail);
+}
+
+void ThrowComFailUnicode(JNIEnv *env, const wchar_t* desc, jint hr)
+{
+  if (!desc) {
+	  ThrowComFail(env, "Java/COM Error", hr);
+  }
+  jclass failClass = env->FindClass("com/jacob/com/ComFailException");
+  // call the constructor that takes hr and message
+  jmethodID failCons = 
+     env->GetMethodID(failClass, "<init>", "(ILjava/lang/String;)V");
+  jstring js = env->NewString((const jchar *) desc, wcslen(desc));
+  jthrowable fail = (jthrowable)env->NewObject(failClass, failCons, hr, js);
+  env->Throw(fail);
+}
+
+// if env's are different throw on the 1st env
+int CheckEnv(JNIEnv *env1, JNIEnv *env2)
+{
+  if (env1 != env2) {
+    jclass failClass = env1->FindClass("com/jacob/com/WrongThreadException");
+    // call the constructor that takes hr and message
+    jmethodID failCons = 
+       env1->GetMethodID(failClass, "<init>", "()V");
+    env1->ThrowNew(failClass, "Wrong Thread");
+		return 0;
+  }
+	return 1;
+}
+
+}

src/main/headers/ComThread.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+/* Header for class com_jacob_com_ComThread */
+
+#ifndef _Included_com_jacob_com_ComThread
+#define _Included_com_jacob_com_ComThread
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_jacob_com_ComThread
+ * Method:    doCoInitialize
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_ComThread_doCoInitialize
+  (JNIEnv *, jclass, jint);
+
+/*
+ * Class:     com_jacob_com_ComThread
+ * Method:    doCoUninitialize
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_ComThread_doCoUninitialize
+  (JNIEnv *, jclass);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif

src/main/headers/Dispatch.h

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+/* Header for class Dispatch */
+
+#ifndef _Included_Dispatch
+#define _Included_Dispatch
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_jacob_com_Dispatch
+ * Method:    QueryInterface
+ * Signature: (Ljava/lang/String;)Lcom/jacob/com/Dispatch;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Dispatch_QueryInterface
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     Dispatch
+ * Method:    createInstance
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_createInstanceNative
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     Dispatch
+ * Method:    getActiveInstance
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_getActiveInstanceNative
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     Dispatch
+ * Method:    coCreateInstance
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_coCreateInstanceNative
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     Dispatch
+ * Method:    release
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_release
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     Dispatch
+ * Method:    getIDsOfNames
+ * Signature: (Ljava/lang/Object;I[Ljava/lang/String;)[I
+ */
+JNIEXPORT jintArray JNICALL Java_com_jacob_com_Dispatch_getIDsOfNames
+  (JNIEnv *, jclass, jobject, jint, jobjectArray);
+
+/*
+ * Class:     Dispatch
+ * Method:    invokev
+ * Signature: (Ljava/lang/Object;Ljava/lang/String;III[LVariant;[I)LVariant;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Dispatch_invokev
+  (JNIEnv *, jclass, jobject, jstring, jint, jint, jint, jobjectArray, jintArray);
+
+/*
+ * Class:     Dispatch
+ * Method:    wait
+ * Signature: (Ljava/lang/Object;I;)I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_Dispatch_hasExited
+	(JNIEnv *, jclass, jobject, jint, jint);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

src/main/headers/DispatchEvents.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+/* Header for class DispatchEvents */
+
+#ifndef _Included_DispatchEvents
+#define _Included_DispatchEvents
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Class:     com_jacob_com_DispatchEvents
+ * Method:    init3
+ * Signature: (Lcom/jacob/com/Dispatch;Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchEvents_init3
+  (JNIEnv *, jobject, jobject, jobject, jstring, jstring);
+
+/*
+ * Class:     DispatchEvents
+ * Method:    release
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchEvents_release
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+

src/main/headers/DispatchProxy.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+/* Header for class com_jacob_com_DispatchProxy */
+
+#ifndef _Included_com_jacob_com_DispatchProxy
+#define _Included_com_jacob_com_DispatchProxy
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_jacob_com_DispatchProxy
+ * Method:    MarshalIntoStream
+ * Signature: (Lcom/jacob/com/Dispatch;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchProxy_MarshalIntoStream
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_jacob_com_DispatchProxy
+ * Method:    MarshalFromStream
+ * Signature: ()Lcom/jacob/com/Dispatch;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_DispatchProxy_MarshalFromStream
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_DispatchProxy
+ * Method:    release
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchProxy_release
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

src/main/headers/EnumVariant.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef _Included_EnumVariant
+#define _Included_EnumVariant
+
+#include <jni.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_jacob_com_EnumVariant
+ * Method:    Next
+ * Signature: ([Lcom/jacob/com/Variant;)I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_EnumVariant_Next
+  (JNIEnv *, jobject, jobjectArray);
+
+/*
+ * Class:     com_jacob_com_EnumVariant
+ * Method:    Release
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_EnumVariant_release
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_EnumVariant
+ * Method:    Reset
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_EnumVariant_Reset
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_EnumVariant
+ * Method:    Skip
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_EnumVariant_Skip
+  (JNIEnv *, jobject, jint);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

src/main/headers/EventProxy.h

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+#include <objbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+#include "stdafx.h"
+#include "util.h"
+
+/*
+ * An instance of this class stands between a connection point
+ * and a java object. When it gets invoked from the cp, it reflects
+ * the call into the java object dynamically. The eventIID is passed
+ * in as are the valid dispids and the corresponding names. A map
+ * is created between the dispids and the java object's method in
+ * the constructor. For now, all the java event methods have to have
+ * the same signature: <name>(Variant[])
+ */
+class EventProxy : public IDispatch
+{
+private:
+  int     connected;
+  LONG    m_cRef;		// a reference counter
+  CComPtr<IConnectionPoint> pCP; // the connection point
+  DWORD   dwEventCookie; // connection point cookie
+  jobject javaSinkObj;   // the java object to delegate calls
+
+  IID     eventIID;      // the interface iid passed in
+  int     MethNum;		// number of methods in the callback interface
+  CComBSTR *MethName;   // Array of method names
+  DISPID   *MethID;     // Array of method ids, used to match invokations to method names
+  JavaVM   *jvm;        // The java vm we are running
+  void convertJavaVariant(VARIANT *java, VARIANT *com);
+  void Connect(JNIEnv *env);
+public:
+  // constuct with a global JNI ref to a sink object
+  // to which we will delegate event callbacks
+  EventProxy(JNIEnv *jenv, 
+  		jobject aSinkObj, 
+        CComPtr<IConnectionPoint> pConn, 
+        IID eventIID, 
+        CComBSTR *mName, 
+        DISPID *mID, 
+        int mNum);
+  ~EventProxy();
+
+  // IUnknown methods
+  STDMETHODIMP_(ULONG) AddRef(void) 
+  {
+    LONG res = InterlockedIncrement(&m_cRef);
+    return res;
+  }
+
+  STDMETHODIMP_(ULONG) Release(void)
+  {
+    LONG res = InterlockedDecrement(&m_cRef);
+    if (res == 0) {
+    	delete this;
+    }
+    return res;
+    
+  }
+
+  STDMETHODIMP QueryInterface(REFIID rid, void **ppv);
+   
+  // IDispatch methods
+  STDMETHODIMP GetTypeInfoCount(UINT *num) 
+  {
+    *num = 0;
+    return S_OK;
+  }
+
+  STDMETHODIMP GetTypeInfo(UINT, LCID, ITypeInfo **pptInfo)
+  {
+    *pptInfo=NULL;
+    return E_NOTIMPL;
+  }
+
+  // These are the actual supported methods
+  STDMETHODIMP GetIDsOfNames(REFIID, OLECHAR **, UINT, LCID , DISPID *);
+  STDMETHODIMP Invoke(DISPID, REFIID, LCID, WORD , DISPPARAMS *, VARIANT *, EXCEPINFO *, UINT *);
+  // SF 3412922 make public to support cleanup from DispatchEvents
+  void Disconnect();
+
+};

src/main/headers/STA.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+/* Header for class STA */
+
+#ifndef _Included_com_jacob_com_STA
+#define _Included_com_jacob_com_STA
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_jacob_com_STA
+ * Method:    doMessagePump
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_STA_doMessagePump
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_STA
+ * Method:    quitMessagePump
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_STA_quitMessagePump
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

src/main/headers/SafeArray.h

@@ -0,0 +1,940 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+/* Header for class com_jacob_com_SafeArray */
+
+#ifndef _Included_com_jacob_com_SafeArray
+#define _Included_com_jacob_com_SafeArray
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* Inaccessible static: buildVersion */
+/* Inaccessible static: buildDate */
+/* Inaccessible static: DEBUG */
+/* Inaccessible static: class_00024com_00024jacob_00024com_00024JacobObject */
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    init
+ * Signature: (I[I[I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_init
+  (JNIEnv *, jobject, jint, jintArray, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    clone
+ * Signature: ()Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_SafeArray_clone
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    destroy
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_destroy
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getvt
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getvt
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    reinit
+ * Signature: (Lcom/jacob/com/SafeArray;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_reinit
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    reinterpretType
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_reinterpretType
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getLBound
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getLBound__
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getLBound
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getLBound__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getUBound
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getUBound__
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getUBound
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getUBound__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getNumDim
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getNumDim
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getFeatures
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getFeatures
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getElemSize
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getElemSize
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromCharArray
+ * Signature: ([C)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromCharArray
+  (JNIEnv *, jobject, jcharArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromIntArray
+ * Signature: ([I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromIntArray
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromLongArray
+ * Signature: ([L)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromLongArray
+  (JNIEnv *, jobject, jlongArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromShortArray
+ * Signature: ([S)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromShortArray
+  (JNIEnv *, jobject, jshortArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromDoubleArray
+ * Signature: ([D)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromDoubleArray
+  (JNIEnv *, jobject, jdoubleArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromStringArray
+ * Signature: ([Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromStringArray
+  (JNIEnv *, jobject, jobjectArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromByteArray
+ * Signature: ([B)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromByteArray
+  (JNIEnv *, jobject, jbyteArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromFloatArray
+ * Signature: ([F)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromFloatArray
+  (JNIEnv *, jobject, jfloatArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromBooleanArray
+ * Signature: ([Z)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromBooleanArray
+  (JNIEnv *, jobject, jbooleanArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromVariantArray
+ * Signature: ([Lcom/jacob/com/Variant;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromVariantArray
+  (JNIEnv *, jobject, jobjectArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toCharArray
+ * Signature: ()[C
+ */
+JNIEXPORT jcharArray JNICALL Java_com_jacob_com_SafeArray_toCharArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toIntArray
+ * Signature: ()[I
+ */
+JNIEXPORT jintArray JNICALL Java_com_jacob_com_SafeArray_toIntArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toLongArray
+ * Signature: ()[L
+ */
+JNIEXPORT jlongArray JNICALL Java_com_jacob_com_SafeArray_toLongArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toShortArray
+ * Signature: ()[S
+ */
+JNIEXPORT jshortArray JNICALL Java_com_jacob_com_SafeArray_toShortArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toDoubleArray
+ * Signature: ()[D
+ */
+JNIEXPORT jdoubleArray JNICALL Java_com_jacob_com_SafeArray_toDoubleArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toStringArray
+ * Signature: ()[Ljava/lang/String;
+ */
+JNIEXPORT jobjectArray JNICALL Java_com_jacob_com_SafeArray_toStringArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toByteArray
+ * Signature: ()[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_com_jacob_com_SafeArray_toByteArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toFloatArray
+ * Signature: ()[F
+ */
+JNIEXPORT jfloatArray JNICALL Java_com_jacob_com_SafeArray_toFloatArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toBooleanArray
+ * Signature: ()[Z
+ */
+JNIEXPORT jbooleanArray JNICALL Java_com_jacob_com_SafeArray_toBooleanArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toVariantArray
+ * Signature: ()[Lcom/jacob/com/Variant;
+ */
+JNIEXPORT jobjectArray JNICALL Java_com_jacob_com_SafeArray_toVariantArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getChar
+ * Signature: (I)C
+ */
+JNIEXPORT jchar JNICALL Java_com_jacob_com_SafeArray_getChar__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getChar
+ * Signature: (II)C
+ */
+JNIEXPORT jchar JNICALL Java_com_jacob_com_SafeArray_getChar__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setChar
+ * Signature: (IC)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setChar__IC
+  (JNIEnv *, jobject, jint, jchar);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setChar
+ * Signature: (IIC)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setChar__IIC
+  (JNIEnv *, jobject, jint, jint, jchar);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getChars
+ * Signature: (II[CI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getChars
+  (JNIEnv *, jobject, jint, jint, jcharArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setChars
+ * Signature: (II[CI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setChars
+  (JNIEnv *, jobject, jint, jint, jcharArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getInt
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getInt__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getInt
+ * Signature: (II)I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getInt__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setInt
+ * Signature: (II)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setInt__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setInt
+ * Signature: (III)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setInt__III
+  (JNIEnv *, jobject, jint, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getInts
+ * Signature: (II[II)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getInts
+  (JNIEnv *, jobject, jint, jint, jintArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setInts
+ * Signature: (II[II)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setInts
+  (JNIEnv *, jobject, jint, jint, jintArray, jint);
+
+/*
+ * Class:     SafeArray
+ * Method:    getLong
+ * Signature: (I)J
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_SafeArray_getLong__I
+  (JNIEnv *env, jobject _this, jint idx);
+
+/*
+ * Class:     SafeArray
+ * Method:    getLong
+ * Signature: (II)J
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_SafeArray_getLong__II
+  (JNIEnv *env, jobject _this, jint i, jint j);
+
+/*
+ * Class:     SafeArray
+ * Method:    setLong
+ * Signature: (IJ)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setLong__IJ
+  (JNIEnv *env, jobject _this, jint idx, jlong c);
+
+/*
+ * Class:     SafeArray
+ * Method:    setLong
+ * Signature: (IIJ)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setLong__IIJ
+  (JNIEnv *env, jobject _this, jint i, jint j, jlong c);
+
+/*
+ * Class:     SafeArray
+ * Method:    getLongs
+ * Signature: (II[JI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getLongs
+  (JNIEnv *env, jobject _this, jint idx, jint nelem, jlongArray ja, jint ja_start);
+
+/*
+ * Class:     SafeArray
+ * Method:    setLongs
+ * Signature: (II[JI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setLongs
+  (JNIEnv *env, jobject _this, jint idx, jint nelem, jlongArray ja, jint ja_start);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getShort
+ * Signature: (I)S
+ */
+JNIEXPORT jshort JNICALL Java_com_jacob_com_SafeArray_getShort__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getShort
+ * Signature: (II)S
+ */
+JNIEXPORT jshort JNICALL Java_com_jacob_com_SafeArray_getShort__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setShort
+ * Signature: (IS)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setShort__IS
+  (JNIEnv *, jobject, jint, jshort);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setShort
+ * Signature: (IIS)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setShort__IIS
+  (JNIEnv *, jobject, jint, jint, jshort);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getShorts
+ * Signature: (II[SI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getShorts
+  (JNIEnv *, jobject, jint, jint, jshortArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setShorts
+ * Signature: (II[SI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setShorts
+  (JNIEnv *, jobject, jint, jint, jshortArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getDouble
+ * Signature: (I)D
+ */
+JNIEXPORT jdouble JNICALL Java_com_jacob_com_SafeArray_getDouble__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getDouble
+ * Signature: (II)D
+ */
+JNIEXPORT jdouble JNICALL Java_com_jacob_com_SafeArray_getDouble__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setDouble
+ * Signature: (ID)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setDouble__ID
+  (JNIEnv *, jobject, jint, jdouble);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setDouble
+ * Signature: (IID)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setDouble__IID
+  (JNIEnv *, jobject, jint, jint, jdouble);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getDoubles
+ * Signature: (II[DI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getDoubles
+  (JNIEnv *, jobject, jint, jint, jdoubleArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setDoubles
+ * Signature: (II[DI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setDoubles
+  (JNIEnv *, jobject, jint, jint, jdoubleArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getString
+ * Signature: (I)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_jacob_com_SafeArray_getString__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getString
+ * Signature: (II)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_jacob_com_SafeArray_getString__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setString
+ * Signature: (ILjava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setString__ILjava_lang_String_2
+  (JNIEnv *, jobject, jint, jstring);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setString
+ * Signature: (IILjava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setString__IILjava_lang_String_2
+  (JNIEnv *, jobject, jint, jint, jstring);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getStrings
+ * Signature: (II[Ljava/lang/String;I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getStrings
+  (JNIEnv *, jobject, jint, jint, jobjectArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setStrings
+ * Signature: (II[Ljava/lang/String;I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setStrings
+  (JNIEnv *, jobject, jint, jint, jobjectArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getByte
+ * Signature: (I)B
+ */
+JNIEXPORT jbyte JNICALL Java_com_jacob_com_SafeArray_getByte__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getByte
+ * Signature: (II)B
+ */
+JNIEXPORT jbyte JNICALL Java_com_jacob_com_SafeArray_getByte__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setByte
+ * Signature: (IB)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setByte__IB
+  (JNIEnv *, jobject, jint, jbyte);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setByte
+ * Signature: (IIB)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setByte__IIB
+  (JNIEnv *, jobject, jint, jint, jbyte);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getBytes
+ * Signature: (II[BI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getBytes
+  (JNIEnv *, jobject, jint, jint, jbyteArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setBytes
+ * Signature: (II[BI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBytes
+  (JNIEnv *, jobject, jint, jint, jbyteArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getFloat
+ * Signature: (I)F
+ */
+JNIEXPORT jfloat JNICALL Java_com_jacob_com_SafeArray_getFloat__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getFloat
+ * Signature: (II)F
+ */
+JNIEXPORT jfloat JNICALL Java_com_jacob_com_SafeArray_getFloat__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setFloat
+ * Signature: (IF)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setFloat__IF
+  (JNIEnv *, jobject, jint, jfloat);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setFloat
+ * Signature: (IIF)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setFloat__IIF
+  (JNIEnv *, jobject, jint, jint, jfloat);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getFloats
+ * Signature: (II[FI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getFloats
+  (JNIEnv *, jobject, jint, jint, jfloatArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setFloats
+ * Signature: (II[FI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setFloats
+  (JNIEnv *, jobject, jint, jint, jfloatArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getBoolean
+ * Signature: (I)Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_jacob_com_SafeArray_getBoolean__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getBoolean
+ * Signature: (II)Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_jacob_com_SafeArray_getBoolean__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setBoolean
+ * Signature: (IZ)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBoolean__IZ
+  (JNIEnv *, jobject, jint, jboolean);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setBoolean
+ * Signature: (IIZ)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBoolean__IIZ
+  (JNIEnv *, jobject, jint, jint, jboolean);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getBooleans
+ * Signature: (II[ZI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getBooleans
+  (JNIEnv *, jobject, jint, jint, jbooleanArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setBooleans
+ * Signature: (II[ZI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBooleans
+  (JNIEnv *, jobject, jint, jint, jbooleanArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getVariant
+ * Signature: (I)Lcom/jacob/com/Variant;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_SafeArray_getVariant__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getVariant
+ * Signature: (II)Lcom/jacob/com/Variant;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_SafeArray_getVariant__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setVariant
+ * Signature: (ILcom/jacob/com/Variant;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setVariant__ILcom_jacob_com_Variant_2
+  (JNIEnv *, jobject, jint, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setVariant
+ * Signature: (IILcom/jacob/com/Variant;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setVariant__IILcom_jacob_com_Variant_2
+  (JNIEnv *, jobject, jint, jint, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getVariants
+ * Signature: (II[Lcom/jacob/com/Variant;I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getVariants
+  (JNIEnv *, jobject, jint, jint, jobjectArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setVariants
+ * Signature: (II[Lcom/jacob/com/Variant;I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setVariants
+  (JNIEnv *, jobject, jint, jint, jobjectArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getVariant
+ * Signature: ([I)Lcom/jacob/com/Variant;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_SafeArray_getVariant___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setVariant
+ * Signature: ([ILcom/jacob/com/Variant;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setVariant___3ILcom_jacob_com_Variant_2
+  (JNIEnv *, jobject, jintArray, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getChar
+ * Signature: ([I)C
+ */
+JNIEXPORT jchar JNICALL Java_com_jacob_com_SafeArray_getChar___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setChar
+ * Signature: ([IC)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setChar___3IC
+  (JNIEnv *, jobject, jintArray, jchar);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getInt
+ * Signature: ([I)I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getInt___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setInt
+ * Signature: ([II)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setInt___3II
+  (JNIEnv *, jobject, jintArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getLong
+ * Signature: ([I)J
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_SafeArray_getLong___3I
+  (JNIEnv *env, jobject _this, jintArray indices);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setLong
+ * Signature: ([IJ)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setLong___3IJ
+  (JNIEnv *env, jobject _this, jintArray indices, jlong c);
+
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getShort
+ * Signature: ([I)S
+ */
+JNIEXPORT jshort JNICALL Java_com_jacob_com_SafeArray_getShort___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setShort
+ * Signature: ([IS)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setShort___3IS
+  (JNIEnv *, jobject, jintArray, jshort);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getDouble
+ * Signature: ([I)D
+ */
+JNIEXPORT jdouble JNICALL Java_com_jacob_com_SafeArray_getDouble___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setDouble
+ * Signature: ([ID)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setDouble___3ID
+  (JNIEnv *, jobject, jintArray, jdouble);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getString
+ * Signature: ([I)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_jacob_com_SafeArray_getString___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setString
+ * Signature: ([ILjava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setString___3ILjava_lang_String_2
+  (JNIEnv *, jobject, jintArray, jstring);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getByte
+ * Signature: ([I)B
+ */
+JNIEXPORT jbyte JNICALL Java_com_jacob_com_SafeArray_getByte___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setByte
+ * Signature: ([IB)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setByte___3IB
+  (JNIEnv *, jobject, jintArray, jbyte);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getFloat
+ * Signature: ([I)F
+ */
+JNIEXPORT jfloat JNICALL Java_com_jacob_com_SafeArray_getFloat___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setFloat
+ * Signature: ([IF)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setFloat___3IF
+  (JNIEnv *, jobject, jintArray, jfloat);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getBoolean
+ * Signature: ([I)Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_jacob_com_SafeArray_getBoolean___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setBoolean
+ * Signature: ([IZ)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBoolean___3IZ
+  (JNIEnv *, jobject, jintArray, jboolean);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

src/main/headers/StdAfx.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+// stdafx.h : include file for standard system include files,
+//      or project specific include files that are used frequently,
+//      but are changed infrequently
+
+#if !defined(AFX_STDAFX_H__9988E984_6789_11D3_A646_000000000000__INCLUDED_)
+#define AFX_STDAFX_H__9988E984_6789_11D3_A646_000000000000__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+#ifndef STRICT
+#define STRICT
+#endif
+// SF 3377279 Changed _WIN32_WINNT to 0x0500 to fix build with VS2010
+// 0x400 is NT or later 0x500 is windows 2000 or later. we could go higher
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0500
+#endif
+//#define _ATL_APARTMENT_THREADED
+#include <comdef.h>
+#include <comutil.h>
+#include <atlbase.h>
+//You may derive a class from CComModule and use it if you want to override
+//something, but do not change the name of _Module
+extern CComModule _Module;
+//#include <atlcom.h>
+
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_STDAFX_H__9988E984_6789_11D3_A646_000000000000__INCLUDED)

src/main/headers/Variant.h

@@ -0,0 +1,605 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+/* Header for class com_jacob_com_Variant */
+
+#ifndef _Included_com_jacob_com_Variant
+#define _Included_com_jacob_com_Variant
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    toEnumVariant
+ * Signature: ()Lcom/jacob/com/EnumVariant;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Variant_toEnumVariant
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantNull
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantNull
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    cloneIndirect
+ * Signature: ()Lcom_jacob_com_Variant;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Variant_cloneIndirect
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantShortRef
+ * Signature: (S)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantShortRef
+  (JNIEnv *, jobject, jshort);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantIntRef
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantIntRef
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantDoubleRef
+ * Signature: (D)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantDoubleRef
+  (JNIEnv *, jobject, jdouble);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantDateRef
+ * Signature: (D)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantDateRef
+  (JNIEnv *, jobject, jdouble);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantStringRef
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantStringRef
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantShortRef
+ * Signature: ()S
+ */
+JNIEXPORT jshort JNICALL Java_com_jacob_com_Variant_getVariantShortRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantIntRef
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_Variant_getVariantIntRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantShort
+ * Signature: (S)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantShort
+  (JNIEnv *, jobject, jshort);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantShort
+ * Signature: ()S
+ */
+JNIEXPORT jshort JNICALL Java_com_jacob_com_Variant_getVariantShort
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantDoubleRef
+ * Signature: ()D
+ */
+JNIEXPORT jdouble JNICALL Java_com_jacob_com_Variant_getVariantDoubleRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantDateRef
+ * Signature: ()D
+ */
+JNIEXPORT jdouble JNICALL Java_com_jacob_com_Variant_getVariantDateRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getStringRef
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_jacob_com_Variant_getVariantStringRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    com_jacob_com_VariantClear
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_VariantClear
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    toDispatch
+ * Signature: ()LDispatch;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Variant_toVariantDispatch
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    clone
+ * Signature: ()Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Variant_clone
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantInt
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_Variant_getVariantInt
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantDate
+ * Signature: ()D
+ */
+JNIEXPORT jdouble JNICALL Java_com_jacob_com_Variant_getVariantDate
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantInt
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantInt
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantDate
+ * Signature: (D)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantDate
+  (JNIEnv *, jobject, jdouble);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantBoolean
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_jacob_com_Variant_getVariantBoolean
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantByte
+ * Signature: ()B
+ */
+JNIEXPORT jbyte JNICALL Java_com_jacob_com_Variant_getVariantByte
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantBoolean
+ * Signature: (Z)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantBoolean
+  (JNIEnv *, jobject, jboolean);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantByte
+ * Signature: (B)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantByte
+  (JNIEnv *, jobject, jbyte);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantEmpty
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantEmpty
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantNothing
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantNothing
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantError
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_Variant_getVariantError
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantError
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantError
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantDouble
+ * Signature: ()D
+ */
+JNIEXPORT jdouble JNICALL Java_com_jacob_com_Variant_getVariantDouble
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantCurrency
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantCurrency
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantLong
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantLong
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantDispatch
+ * Signature: (Ljava/lang/Object;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantDispatch
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantDouble
+ * Signature: (D)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantDouble
+  (JNIEnv *, jobject, jdouble);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantCurrency
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_Variant_getVariantCurrency
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantLong
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_Variant_getVariantLong
+  (JNIEnv *, jobject);
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantFloatRef
+ * Signature: (F)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantFloatRef
+  (JNIEnv *, jobject, jfloat);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantCurrencyRef
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantCurrencyRef
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantLongRef
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantLongRef
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantErrorRef
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantErrorRef
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantBooleanRef
+ * Signature: (Z)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantBooleanRef
+  (JNIEnv *, jobject, jboolean);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putObjectRef
+ * Signature: (Ljava/lang/Object;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putObjectRef
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantByteRef
+ * Signature: (B)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantByteRef
+  (JNIEnv *, jobject, jbyte);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getString
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_jacob_com_Variant_getVariantString
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantString
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantString
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantFloatRef
+ * Signature: ()F
+ */
+JNIEXPORT jfloat JNICALL Java_com_jacob_com_Variant_getVariantFloatRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantCurrencyRef
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_Variant_getVariantCurrencyRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantLongRef
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_Variant_getVariantLongRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantErrorRef
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_Variant_getVariantErrorRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantBooleanRef
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_jacob_com_Variant_getVariantBooleanRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantByteRef
+ * Signature: ()B
+ */
+JNIEXPORT jbyte JNICALL Java_com_jacob_com_Variant_getVariantByteRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    toVariantSafeArray
+ * Signature: (Z)Lcom/jacob/com/SafeArray;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Variant_toVariantSafeArray
+  (JNIEnv *, jobject, jboolean);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantSafeArrayRef
+ * Signature: (LSafeArray;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantSafeArrayRef
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantSafeArray
+ * Signature: (LSafeArray;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantSafeArray
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantNoParam
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantNoParam
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantFloat
+ * Signature: ()F
+ */
+JNIEXPORT jfloat JNICALL Java_com_jacob_com_Variant_getVariantFloat
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantFloat
+ * Signature: (F)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantFloat
+  (JNIEnv *, jobject, jfloat);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    changeVariantType
+ * Signature: (S)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_changeVariantType
+  (JNIEnv *, jobject, jshort);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantType
+ * Signature: ()S
+ */
+JNIEXPORT jshort JNICALL Java_com_jacob_com_Variant_getVariantType
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    release
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_release
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    init
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_init
+  (JNIEnv *, jobject);
+
+JNIEXPORT jbyteArray JNICALL Java_com_jacob_com_Variant_SerializationWriteToBytes
+  (JNIEnv *, jobject);
+
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_SerializationReadFromBytes
+  (JNIEnv *, jobject, jbyteArray);
+  
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantVariant
+ * Signature: (Lcom/jacob/com/Variant;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantVariant
+  (JNIEnv *, jobject, jobject);
+
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantVariant
+ * Signature: ()I
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_Variant_getVariantVariant
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantDecRef
+ * Signature: (Ljava.math.BigDecimal;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantDecRef
+  (JNIEnv *env, jobject _this, jint signum, jbyte scale, jint lo, jint mid, jint hi);
+
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantDec
+ * Signature: (Ljava.math.BigDecimal;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantDec
+  (JNIEnv *env, jobject _this, jint signum, jbyte scale, jint lo, jint mid, jint hi);
+
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantDecRef
+ * Signature: ()Ljava.math.BigDecimal
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Variant_getVariantDecRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantDec
+ * Signature: ()Ljava.math.BigDecimal
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Variant_getVariantDec
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    isVariantConsideredNull
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_jacob_com_Variant_isVariantConsideredNull
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    zeroVariant
+ * Signature: ()V
+ *
+ * This should only be used on variant objects created by the
+ * com layer as part of a call through EventProxy.
+ * This zeros out the variant pointer in the Variant object
+ * so that the calling COM program can free the memory.
+ * instead of both the COM program and the Java GC doing it.
+ */
+void zeroVariant (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

src/main/headers/util.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <objbase.h>
+extern "C" {
+  VARIANT *extractVariant(JNIEnv *env, jobject arg);
+  void ThrowComFail(JNIEnv *env, const char* desc, jint hr);
+  void ThrowComFailUnicode(JNIEnv *env, const wchar_t* desc, jint hr);
+  IDispatch *extractDispatch(JNIEnv *env, jobject arg);
+  SAFEARRAY *extractSA(JNIEnv *env, jobject arg);
+  void setSA(JNIEnv *env, jobject arg, SAFEARRAY *sa, int copy);
+  SAFEARRAY *copySA(SAFEARRAY *psa);
+}

src/main/java/com/jacob/activeX/.cvsignore

@@ -0,0 +1,2 @@
+*.class
+

src/main/java/com/jacob/activeX/ActiveXComponent.java

@@ -0,0 +1,479 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.activeX;
+
+import com.jacob.com.Dispatch;
+import com.jacob.com.JacobObject;
+import com.jacob.com.Variant;
+
+/**
+ * This class provides a higher level, more object like, wrapper for top of the
+ * Dispatch object. The Dispatch class's method essentially directly map to
+ * Microsoft C API including the first parameter that is almost always the
+ * target of the message. ActiveXComponent assumes the target of every message
+ * is the MS COM object behind the ActiveXComponent. This removes the need to
+ * pass the Dispatch object into every method.
+ * <p>
+ * It is really up to the developer as to whether they want to use the Dispatch
+ * interface or the ActiveXComponent interface.
+ * <p>
+ * This class simulates com.ms.activeX.ActiveXComponent only in the sense that
+ * it is used for creating Dispatch objects
+ */
+public class ActiveXComponent extends Dispatch {
+
+	/**
+	 * Normally used to create a new connection to a microsoft application. The
+	 * passed in parameter is the name of the program as registered in the
+	 * registry. It can also be the object name.
+	 * <p>
+	 * This constructor causes a new Windows object of the requested type to be
+	 * created. The windows CoCreate() function gets called to create the
+	 * underlying windows object.
+	 * 
+	 * <pre>
+	 * new ActiveXComponent(&quot;ScriptControl&quot;);
+	 * </pre>
+	 * 
+	 * @param programId
+	 */
+	public ActiveXComponent(String programId) {
+		super(programId);
+	}
+
+	/**
+	 * Creates an active X component that is built on top of the COM pointers
+	 * held in the passed in dispatch. This widens the Dispatch object to pick
+	 * up the ActiveXComponent API
+	 * 
+	 * @param dispatchToBeWrapped
+	 */
+	public ActiveXComponent(Dispatch dispatchToBeWrapped) {
+		super(dispatchToBeWrapped);
+	}
+
+	/**
+	 * only used by the factories
+	 * 
+	 */
+	private ActiveXComponent() {
+		super();
+	}
+
+	/**
+	 * Probably was a cover for something else in the past. Should be
+	 * deprecated.
+	 * 
+	 * @return Now it actually returns this exact same object.
+	 */
+	public Dispatch getObject() {
+		return this;
+	}
+
+	/**
+	 * Most code should use the standard ActiveXComponent(String) contructor and
+	 * not this factory method. This method exists for applications that need
+	 * special behavior. <B>Experimental in release 1.9.2.</B>
+	 * <p>
+	 * Factory that returns a Dispatch object wrapped around the result of a
+	 * CoCreate() call. This differs from the standard constructor in that it
+	 * throws no exceptions and returns null on failure.
+	 * <p>
+	 * This will fail for any prog id with a ":" in it.
+	 * 
+	 * @param pRequestedProgramId
+	 * @return Dispatch pointer to the COM object or null if couldn't create
+	 */
+	public static ActiveXComponent createNewInstance(String pRequestedProgramId) {
+		ActiveXComponent mCreatedDispatch = null;
+		try {
+			mCreatedDispatch = new ActiveXComponent();
+			mCreatedDispatch.coCreateInstance(pRequestedProgramId);
+		} catch (Exception e) {
+			mCreatedDispatch = null;
+			if (JacobObject.isDebugEnabled()) {
+				JacobObject.debug("Unable to co-create instance of "
+						+ pRequestedProgramId);
+			}
+		}
+		return mCreatedDispatch;
+	}
+
+	/**
+	 * Most code should use the standard ActiveXComponent(String) constructor
+	 * and not this factory method. This method exists for applications that
+	 * need special behavior. <B>Experimental in release 1.9.2.</B>
+	 * <p>
+	 * Factory that returns a Dispatch wrapped around the result of a
+	 * getActiveObject() call. This differs from the standard constructor in
+	 * that it throws no exceptions and returns null on failure.
+	 * <p>
+	 * This will fail for any prog id with a ":" in it
+	 * 
+	 * @param pRequestedProgramId
+	 * @return Dispatch pointer to a COM object or null if wasn't already
+	 *         running
+	 */
+	public static ActiveXComponent connectToActiveInstance(
+			String pRequestedProgramId) {
+		ActiveXComponent mCreatedDispatch = null;
+		try {
+			mCreatedDispatch = new ActiveXComponent();
+			mCreatedDispatch.getActiveInstance(pRequestedProgramId);
+		} catch (Exception e) {
+			mCreatedDispatch = null;
+			if (JacobObject.isDebugEnabled()) {
+				JacobObject.debug("Unable to attach to running instance of "
+						+ pRequestedProgramId);
+			}
+		}
+		return mCreatedDispatch;
+	}
+
+	/**
+	 * @see com.jacob.com.Dispatch#finalize()
+	 */
+	@Override
+	protected void finalize() {
+		super.finalize();
+	}
+
+	/*
+	 * ============================================================
+	 * 
+	 * start of instance based calls to the COM layer
+	 * ===========================================================
+	 */
+
+	/**
+	 * retrieves a property and returns it as a Variant
+	 * 
+	 * @param propertyName
+	 * @return variant value of property
+	 */
+	public Variant getProperty(String propertyName) {
+		return Dispatch.get(this, propertyName);
+	}
+
+	/**
+	 * retrieves a property and returns it as an ActiveX component
+	 * 
+	 * @param propertyName
+	 * @return Dispatch representing the object under the property name
+	 */
+	public ActiveXComponent getPropertyAsComponent(String propertyName) {
+		return new ActiveXComponent(Dispatch.get(this, propertyName)
+				.toDispatch());
+
+	}
+
+	/**
+	 * retrieves a property and returns it as a Boolean
+	 * 
+	 * @param propertyName
+	 *            property we are looking up
+	 * @return boolean value of property
+	 */
+	public boolean getPropertyAsBoolean(String propertyName) {
+		return Dispatch.get(this, propertyName).getBoolean();
+	}
+
+	/**
+	 * retrieves a property and returns it as a byte
+	 * 
+	 * @param propertyName
+	 *            property we are looking up
+	 * @return byte value of property
+	 */
+	public byte getPropertyAsByte(String propertyName) {
+		return Dispatch.get(this, propertyName).getByte();
+	}
+
+	/**
+	 * retrieves a property and returns it as a String
+	 * 
+	 * @param propertyName
+	 * @return String value of property
+	 */
+	public String getPropertyAsString(String propertyName) {
+		return Dispatch.get(this, propertyName).getString();
+
+	}
+
+	/**
+	 * retrieves a property and returns it as a int
+	 * 
+	 * @param propertyName
+	 * @return the property value as an int
+	 */
+	public int getPropertyAsInt(String propertyName) {
+		return Dispatch.get(this, propertyName).getInt();
+	}
+
+	/**
+	 * sets a property on this object
+	 * 
+	 * @param propertyName
+	 *            property name
+	 * @param arg
+	 *            variant value to be set
+	 */
+	public void setProperty(String propertyName, Variant arg) {
+		Dispatch.put(this, propertyName, arg);
+	}
+
+	/**
+	 * sets a property on this object
+	 * 
+	 * @param propertyName
+	 *            property name
+	 * @param arg
+	 *            variant value to be set
+	 */
+	public void setProperty(String propertyName, Dispatch arg) {
+		Dispatch.put(this, propertyName, arg);
+	}
+
+	/**
+	 * sets a property to be the value of the string
+	 * 
+	 * @param propertyName
+	 * @param propertyValue
+	 */
+	public void setProperty(String propertyName, String propertyValue) {
+		this.setProperty(propertyName, new Variant(propertyValue));
+	}
+
+	/**
+	 * sets a property as a boolean value
+	 * 
+	 * @param propertyName
+	 * @param propValue
+	 *            the boolean value we want the prop set to
+	 */
+	public void setProperty(String propertyName, boolean propValue) {
+		this.setProperty(propertyName, new Variant(propValue));
+	}
+
+	/**
+	 * sets a property as a boolean value
+	 * 
+	 * @param propertyName
+	 * @param propValue
+	 *            the boolean value we want the prop set to
+	 */
+	public void setProperty(String propertyName, byte propValue) {
+		this.setProperty(propertyName, new Variant(propValue));
+	}
+
+	/**
+	 * sets the property as an int value
+	 * 
+	 * @param propertyName
+	 * @param propValue
+	 *            the int value we want the prop to be set to.
+	 */
+	public void setProperty(String propertyName, int propValue) {
+		this.setProperty(propertyName, new Variant(propValue));
+	}
+
+	/*-------------------------------------------------------
+	 * Listener logging helpers
+	 *-------------------------------------------------------
+	 */
+
+	/**
+	 * This boolean determines if callback events should be logged
+	 */
+	public static boolean shouldLogEvents = false;
+
+	/**
+	 * used by the doc and application listeners to get intelligent logging
+	 * 
+	 * @param description
+	 *            event description
+	 * @param args
+	 *            args passed in (variants)
+	 * 
+	 */
+	public void logCallbackEvent(String description, Variant[] args) {
+		String argString = "";
+		if (args != null && ActiveXComponent.shouldLogEvents) {
+			if (args.length > 0) {
+				argString += " args: ";
+			}
+			for (int i = 0; i < args.length; i++) {
+				short argType = args[i].getvt();
+				argString += ",[" + i + "]";
+				// break out the byref bits if they are on this
+				if ((argType & Variant.VariantByref) == Variant.VariantByref) {
+					// show the type and the fact that its byref
+					argString += "("
+							+ (args[i].getvt() & ~Variant.VariantByref) + "/"
+							+ Variant.VariantByref + ")";
+				} else {
+					// show the type
+					argString += "(" + argType + ")";
+				}
+				argString += "=";
+				if (argType == Variant.VariantDispatch) {
+					Dispatch foo = (args[i].getDispatch());
+					argString += foo;
+				} else if ((argType & Variant.VariantBoolean) == Variant.VariantBoolean) {
+					// do the boolean thing
+					if ((argType & Variant.VariantByref) == Variant.VariantByref) {
+						// boolean by ref
+						argString += args[i].getBooleanRef();
+					} else {
+						// boolean by value
+						argString += args[i].getBoolean();
+					}
+				} else if ((argType & Variant.VariantString) == Variant.VariantString) {
+					// do the string thing
+					if ((argType & Variant.VariantByref) == Variant.VariantByref) {
+						// string by ref
+						argString += args[i].getStringRef();
+					} else {
+						// string by value
+						argString += args[i].getString();
+					}
+				} else {
+					argString += args[i].toString();
+				}
+			}
+			System.out.println(description + argString);
+		}
+	}
+
+	/*
+	 * ==============================================================
+	 * 
+	 * covers for dispatch call methods
+	 * =============================================================
+	 */
+
+	/**
+	 * makes a dispatch call for the passed in action and no parameter
+	 * 
+	 * @param callAction
+	 * @return ActiveXComponent representing the results of the call
+	 */
+	public ActiveXComponent invokeGetComponent(String callAction) {
+		return new ActiveXComponent(invoke(callAction).toDispatch());
+	}
+
+	/**
+	 * makes a dispatch call for the passed in action and single parameter
+	 * 
+	 * @param callAction
+	 * @param parameters
+	 * @return ActiveXComponent representing the results of the call
+	 */
+	public ActiveXComponent invokeGetComponent(String callAction,
+			Variant... parameters) {
+		return new ActiveXComponent(invoke(callAction, parameters).toDispatch());
+	}
+
+	/**
+	 * invokes a single parameter call on this dispatch that returns no value
+	 * 
+	 * @param actionCommand
+	 * @param parameter
+	 * @return a Variant but that may be null for some calls
+	 */
+	public Variant invoke(String actionCommand, String parameter) {
+		return Dispatch.call(this, actionCommand, parameter);
+	}
+
+	/**
+	 * makes a dispatch call to the passed in action with a single boolean
+	 * parameter
+	 * 
+	 * @param actionCommand
+	 * @param parameter
+	 * @return Variant result
+	 */
+	public Variant invoke(String actionCommand, boolean parameter) {
+		return Dispatch.call(this, actionCommand, new Variant(parameter));
+	}
+
+	/**
+	 * makes a dispatch call to the passed in action with a single int parameter
+	 * 
+	 * @param actionCommand
+	 * @param parameter
+	 * @return Variant result of the invoke (Dispatch.call)
+	 */
+	public Variant invoke(String actionCommand, int parameter) {
+		return Dispatch.call(this, actionCommand, new Variant(parameter));
+	}
+
+	/**
+	 * makes a dispatch call to the passed in action with a string and integer
+	 * parameter (this was put in for some application)
+	 * 
+	 * @param actionCommand
+	 * @param parameter1
+	 * @param parameter2
+	 * @return Variant result
+	 */
+	public Variant invoke(String actionCommand, String parameter1,
+			int parameter2) {
+		return Dispatch.call(this, actionCommand, parameter1, new Variant(
+				parameter2));
+	}
+
+	/**
+	 * makes a dispatch call to the passed in action with two integer parameters
+	 * (this was put in for some application)
+	 * 
+	 * @param actionCommand
+	 * @param parameter1
+	 * @param parameter2
+	 * @return a Variant but that may be null for some calls
+	 */
+	public Variant invoke(String actionCommand, int parameter1, int parameter2) {
+		return Dispatch.call(this, actionCommand, new Variant(parameter1),
+				new Variant(parameter2));
+	}
+
+	/**
+	 * makes a dispatch call for the passed in action and no parameter
+	 * 
+	 * @param callAction
+	 * @return a Variant but that may be null for some calls
+	 */
+	public Variant invoke(String callAction) {
+		return Dispatch.call(this, callAction);
+	}
+
+	/**
+	 * This is really a cover for call(String,Variant[]) that should be
+	 * eliminated call with a variable number of args mainly used for quit.
+	 * 
+	 * @param name
+	 * @param args
+	 * @return Variant returned by the invoke (Dispatch.callN)
+	 */
+	public Variant invoke(String name, Variant... args) {
+		return Dispatch.callN(this, name, args);
+	}
+
+}

src/main/java/com/jacob/activeX/ActiveXDispatchEvents.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.activeX;
+
+import com.jacob.com.Dispatch;
+import com.jacob.com.DispatchEvents;
+import com.jacob.com.InvocationProxy;
+
+/**
+ * RELEASE 1.12 EXPERIMENTAL.
+ * <p>
+ * Use this exactly like the DispatchEvents class. This class plugs in an
+ * ActiveXInvocationProxy instead of an InvocationProxy. It is the
+ * ActiveXInvocationProxy that implements the reflection calls and invoke the
+ * found java event callbacks. See ActiveXInvocationProxy for details.
+ * 
+ * 
+ */
+public class ActiveXDispatchEvents extends DispatchEvents {
+
+	/**
+	 * This is the most commonly used constructor.
+	 * <p>
+	 * Creates the event callback linkage between the the MS program represented
+	 * by the Dispatch object and the Java object that will receive the
+	 * callback.
+	 * 
+	 * @param sourceOfEvent
+	 *            Dispatch object who's MS app will generate callbacks
+	 * @param eventSink
+	 *            Java object that wants to receive the events
+	 */
+	public ActiveXDispatchEvents(Dispatch sourceOfEvent, Object eventSink) {
+		super(sourceOfEvent, eventSink, null);
+	}
+
+	/**
+	 * None of the samples use this constructor.
+	 * <p>
+	 * Creates the event callback linkage between the the MS program represented
+	 * by the Dispatch object and the Java object that will receive the
+	 * callback.
+	 * 
+	 * @param sourceOfEvent
+	 *            Dispatch object who's MS app will generate callbacks
+	 * @param eventSink
+	 *            Java object that wants to receive the events
+	 * @param progId
+	 *            ???
+	 */
+	public ActiveXDispatchEvents(Dispatch sourceOfEvent, Object eventSink,
+			String progId) {
+		super(sourceOfEvent, eventSink, progId, null);
+	}
+
+	/**
+	 * Creates the event callback linkage between the the MS program represented
+	 * by the Dispatch object and the Java object that will receive the
+	 * callback.
+	 * 
+	 * <pre>
+	 * &gt;ActiveXDispatchEvents de = 
+	 * 			new ActiveXDispatchEvents(someDispatch,someEventHAndler,
+	 * 				&quot;Excel.Application&quot;,
+	 * 				&quot;C:\\Program Files\\Microsoft Office\\OFFICE11\\EXCEL.EXE&quot;);
+	 * 
+	 * @param sourceOfEvent Dispatch object who's MS app will generate callbacks
+	 * @param eventSink Java object that wants to receive the events
+	 * @param progId , mandatory if the typelib is specified
+	 * @param typeLib The location of the typelib to use
+	 * 
+	 */
+	public ActiveXDispatchEvents(Dispatch sourceOfEvent, Object eventSink,
+			String progId, String typeLib) {
+		super(sourceOfEvent, eventSink, progId, typeLib);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.jacob.com.DispatchEvents#getInvocationProxy(java.lang.Object)
+	 */
+	protected InvocationProxy getInvocationProxy(Object pTargetObject) {
+		InvocationProxy newProxy = new ActiveXInvocationProxy();
+		newProxy.setTarget(pTargetObject);
+		return newProxy;
+	}
+
+}

src/main/java/com/jacob/activeX/ActiveXInvocationProxy.java

@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.activeX;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import com.jacob.com.InvocationProxy;
+import com.jacob.com.NotImplementedException;
+import com.jacob.com.Variant;
+
+/**
+ * RELEASE 1.12 EXPERIMENTAL.
+ * <p>
+ * This class that lets event handlers receive events with all java objects as
+ * parameters. The standard Jacob event methods all accept an array of Variant
+ * objects. When using this class, you can set up your event methods as regular
+ * java methods with the correct number of parameters of the correct java type.
+ * This does NOT work for any event that wishes to accept a call back and modify
+ * the calling parameters to tell windows what to do. An example is when an
+ * event lets the receiver cancel the action by setting a boolean flag to false.
+ * The java objects cannot be modified and their values will not be passed back
+ * into the originating Variants even if they could be modified.
+ * <p>
+ * This class acts as a proxy between the windows event callback mechanism and
+ * the Java classes that are looking for events. It assumes that all of the Java
+ * classes that are looking for events implement methods with the same names as
+ * the windows events and that the implemented methods native java objects of
+ * the type and order that match the windows documentation. The methods can
+ * return void or a Variant that will be returned to the calling layer. All
+ * Event methods that will be recognized by InvocationProxyAllEvents have the
+ * signature
+ * 
+ * <code> void eventMethodName(Object,Object...)</code> or
+ * <code> Object eventMethodName(Object,Object...)</code>
+ */
+public class ActiveXInvocationProxy extends InvocationProxy {
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.jacob.com.InvocationProxy#invoke(java.lang.String,
+	 *      com.jacob.com.Variant[])
+	 */
+	@SuppressWarnings("unchecked")
+	public Variant invoke(String methodName, Variant targetParameters[]) {
+		Variant mVariantToBeReturned = null;
+		if (mTargetObject == null) {
+			// structured programming guidlines say this return should not be up
+			// here
+			return null;
+		}
+		Class targetClass = mTargetObject.getClass();
+		if (methodName == null) {
+			throw new IllegalArgumentException(
+					"InvocationProxy: missing method name");
+		}
+		if (targetParameters == null) {
+			throw new IllegalArgumentException(
+					"InvocationProxy: missing Variant parameters");
+		}
+		try {
+			Method targetMethod;
+			Object parametersAsJavaObjects[] = getParametersAsJavaObjects(targetParameters);
+			Class parametersAsJavaClasses[] = getParametersAsJavaClasses(parametersAsJavaObjects);
+			targetMethod = targetClass.getMethod(methodName,
+					parametersAsJavaClasses);
+			if (targetMethod != null) {
+				// protected classes can't be invoked against even if they
+				// let you grab the method. you could do
+				// targetMethod.setAccessible(true);
+				// but that should be stopped by the security manager
+				Object mReturnedByInvocation = null;
+				mReturnedByInvocation = targetMethod.invoke(mTargetObject,
+						parametersAsJavaObjects);
+				if (mReturnedByInvocation == null) {
+					mVariantToBeReturned = null;
+				} else if (!(mReturnedByInvocation instanceof Variant)) {
+					mVariantToBeReturned = new Variant(mReturnedByInvocation);
+				} else {
+					mVariantToBeReturned = (Variant) mReturnedByInvocation;
+				}
+			}
+		} catch (SecurityException e) {
+			// what causes this exception?
+			e.printStackTrace();
+		} catch (NoSuchMethodException e) {
+			// this happens whenever the listener doesn't implement all the
+			// methods
+		} catch (IllegalArgumentException e) {
+			// we can throw these inside the catch block so need to re-throw it
+			Exception oneWeShouldToss = new IllegalArgumentException(
+					"Unable to map parameters for method " + methodName + ": "
+							+ e.toString());
+			oneWeShouldToss.printStackTrace();
+		} catch (IllegalAccessException e) {
+			// can't access the method on the target instance for some reason
+			e.printStackTrace();
+		} catch (InvocationTargetException e) {
+			// invocation of target method failed
+			e.printStackTrace();
+		}
+		return mVariantToBeReturned;
+
+	}
+
+	/**
+	 * creates a method signature compatible array of classes from an array of
+	 * parameters
+	 * 
+	 * @param parametersAsJavaObjects
+	 * @return
+	 */
+	@SuppressWarnings("unchecked")
+	private Class[] getParametersAsJavaClasses(Object[] parametersAsJavaObjects) {
+		if (parametersAsJavaObjects == null) {
+			throw new IllegalArgumentException(
+					"This only works with an array of parameters");
+		}
+		int numParameters = parametersAsJavaObjects.length;
+		Class parametersAsJavaClasses[] = new Class[numParameters];
+		for (int parameterIndex = 0; parameterIndex < numParameters; parameterIndex++) {
+			Object oneParameterObject = parametersAsJavaObjects[parameterIndex];
+			if (oneParameterObject == null) {
+				parametersAsJavaClasses[parameterIndex] = null;
+			} else {
+				Class oneParameterClass = oneParameterObject.getClass();
+				parametersAsJavaClasses[parameterIndex] = oneParameterClass;
+			}
+		}
+		return parametersAsJavaClasses;
+	}
+
+	/**
+	 * converts an array of Variants to their associated Java types
+	 * 
+	 * @param targetParameters
+	 * @return
+	 */
+	private Object[] getParametersAsJavaObjects(Variant[] targetParameters) {
+		if (targetParameters == null) {
+			throw new IllegalArgumentException(
+					"This only works with an array of parameters");
+		}
+		int numParameters = targetParameters.length;
+		Object parametersAsJavaObjects[] = new Object[numParameters];
+		for (int parameterIndex = 0; parameterIndex < numParameters; parameterIndex++) {
+			Variant oneParameterObject = targetParameters[parameterIndex];
+			if (oneParameterObject == null) {
+				parametersAsJavaObjects[parameterIndex] = null;
+			} else {
+				try {
+					parametersAsJavaObjects[parameterIndex] = oneParameterObject
+							.toJavaObject();
+				} catch (NotImplementedException nie) {
+					throw new IllegalArgumentException(
+							"Can't convert parameter " + parameterIndex
+									+ " type " + oneParameterObject.getvt()
+									+ " to java object: " + nie.getMessage());
+				}
+			}
+		}
+		return parametersAsJavaObjects;
+	}
+
+}

src/main/java/com/jacob/com/.cvsignore

@@ -0,0 +1,2 @@
+*.class
+

src/main/java/com/jacob/com/ComException.java

@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+/**
+ * Standard exception thrown by com jni code when there is a problem
+ */
+public abstract class ComException extends JacobException {
+
+	/**
+	 * COM code initializes this filed with an appropriate return code that was
+	 * returned by the underlying com code
+	 */
+	protected int hr;
+	/**
+	 * No documentation is available at this time. Someone should document this
+	 * field
+	 */
+	protected int m_helpContext;
+	/**
+	 * No documentation is available at this time. Someone should document this
+	 * field
+	 */
+	protected String m_helpFile;
+	/**
+	 * No documentation is available at this time. Someone should document this
+	 * field
+	 */
+	protected String m_source;
+
+	/**
+	 * constructor
+	 * 
+	 */
+	public ComException() {
+		super();
+	}
+
+	/**
+	 * constructor with error code?
+	 * 
+	 * @param newHr ??
+	 */
+	public ComException(int newHr) {
+		super();
+		this.hr = newHr;
+	}
+
+	/**
+	 * @param newHr
+	 * @param description
+	 */
+	public ComException(int newHr, String description) {
+		super(description);
+		this.hr = newHr;
+	}
+
+	/**
+	 * @param newHr
+	 * @param source
+	 * @param helpFile
+	 * @param helpContext
+	 */
+	public ComException(int newHr, String source, String helpFile,
+			int helpContext) {
+		super();
+		this.hr = newHr;
+		m_source = source;
+		m_helpFile = helpFile;
+		m_helpContext = helpContext;
+	}
+
+	/**
+	 * @param newHr
+	 * @param description
+	 * @param source
+	 * @param helpFile
+	 * @param helpContext
+	 */
+	public ComException(int newHr, String description, String source,
+			String helpFile, int helpContext) {
+		super(description);
+		this.hr = newHr;
+		m_source = source;
+		m_helpFile = helpFile;
+		m_helpContext = helpContext;
+	}
+
+	/**
+	 * @param description
+	 */
+	public ComException(String description) {
+		super(description);
+	}
+
+	/**
+	 * @return int representation of the help context
+	 */
+	// Methods
+	public int getHelpContext() {
+		return m_helpContext;
+	}
+
+	/**
+	 * @return String ??? help file
+	 */
+	public String getHelpFile() {
+		return m_helpFile;
+	}
+
+	/**
+	 * @return int hr result ??
+	 */
+	public int getHResult() {
+		return hr;
+	}
+
+	/**
+	 * @return String source ??
+	 */
+	public String getSource() {
+		return m_source;
+	}
+}

src/main/java/com/jacob/com/ComFailException.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+/**
+ * COM Fail Exception class raised when there is a problem
+ */
+public class ComFailException extends ComException {
+	/**
+	 * eclipse generated to get rid of a wanring
+	 */
+	private static final long serialVersionUID = -266047261992987700L;
+
+	/**
+	 * Constructor
+	 * 
+	 * @param hrNew
+	 */
+	public ComFailException(int hrNew) {
+		super(hrNew);
+	}
+
+	/**
+	 * Constructor
+	 * 
+	 * @param hrNew
+	 * @param message
+	 */
+	public ComFailException(int hrNew, String message) {
+		super(hrNew, message);
+	}
+
+	/**
+	 * @param hrNew
+	 * @param source
+	 * @param helpFile
+	 * @param helpContext
+	 */
+	public ComFailException(int hrNew, String source, String helpFile,
+			int helpContext) {
+		super(hrNew, source, helpFile, helpContext);
+	}
+
+	/**
+	 * Constructor
+	 * 
+	 * @param hrNew
+	 * @param description
+	 * @param source
+	 * @param helpFile
+	 * @param helpContext
+	 */
+	public ComFailException(int hrNew, String description, String source,
+			String helpFile, int helpContext) {
+		super(hrNew, description, source, helpFile, helpContext);
+	}
+
+	/**
+	 * No argument Constructor
+	 */
+	public ComFailException() {
+		super();
+	}
+
+	/**
+	 * @param message
+	 */
+	public ComFailException(String message) {
+		super(message);
+	}
+}

src/main/java/com/jacob/com/ComThread.java

@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+/**
+ * Represents a COM level thread This is an abstract class because all the
+ * methods are static and no instances are ever created.
+ */
+public abstract class ComThread {
+	private static final int MTA = 0x0;
+
+	private static final int STA = 0x2;
+
+	/**
+	 * Comment for <code>haveSTA</code>
+	 */
+	public static boolean haveSTA = false;
+
+	/**
+	 * Comment for <code>mainSTA</code>
+	 */
+	public static MainSTA mainSTA = null;
+
+	/**
+	 * Initialize the current java thread to be part of the Multi-threaded COM
+	 * Apartment
+	 */
+	public static synchronized void InitMTA() {
+		InitMTA(false);
+	}
+
+	/**
+	 * Initialize the current java thread to be an STA
+	 */
+	public static synchronized void InitSTA() {
+		InitSTA(false);
+	}
+
+	/**
+	 * Initialize the current java thread to be part of the Multi-threaded COM
+	 * Apartment, if createMainSTA is true, create a separate MainSTA thread
+	 * that will house all Apartment Threaded components
+	 * 
+	 * @param createMainSTA
+	 */
+	public static synchronized void InitMTA(boolean createMainSTA) {
+		Init(createMainSTA, MTA);
+	}
+
+	/**
+	 * Initialize the current java thread to be an STA COM Apartment, if
+	 * createMainSTA is true, create a separate MainSTA thread that will house
+	 * all Apartment Threaded components
+	 * 
+	 * @param createMainSTA
+	 */
+	public static synchronized void InitSTA(boolean createMainSTA) {
+		Init(createMainSTA, STA);
+	}
+
+	/**
+	 * 
+	 */
+	public static synchronized void startMainSTA() {
+		mainSTA = new MainSTA();
+		haveSTA = true;
+	}
+
+	/**
+	 * 
+	 */
+	public static synchronized void quitMainSTA() {
+		if (mainSTA != null)
+			mainSTA.quit();
+	}
+
+	/**
+	 * Initialize the current java thread to be part of the MTA/STA COM
+	 * Apartment
+	 * 
+	 * @param createMainSTA
+	 * @param mode
+	 */
+	public static synchronized void Init(boolean createMainSTA, int mode) {
+		if (createMainSTA && !haveSTA) {
+			// if the current thread is going to be in the MTA and there
+			// is no STA thread yet, then create a main STA thread
+			// to avoid COM creating its own
+			startMainSTA();
+		}
+		if (JacobObject.isDebugEnabled()) {
+			JacobObject.debug("ComThread: before Init: " + mode);
+		}
+		doCoInitialize(mode);
+		if (JacobObject.isDebugEnabled()) {
+			JacobObject.debug("ComThread: after Init: " + mode);
+		}
+		ROT.addThread();
+		if (JacobObject.isDebugEnabled()) {
+			JacobObject.debug("ComThread: after ROT.addThread: " + mode);
+		}
+	}
+
+	/**
+	 * Call CoUninitialize to release this java thread from COM
+	 */
+	public static synchronized void Release() {
+		if (JacobObject.isDebugEnabled()) {
+			JacobObject.debug("ComThread: before clearObjects");
+		}
+		ROT.clearObjects();
+		if (JacobObject.isDebugEnabled()) {
+			JacobObject.debug("ComThread: before UnInit");
+		}
+		doCoUninitialize();
+		if (JacobObject.isDebugEnabled()) {
+			JacobObject.debug("ComThread: after UnInit");
+		}
+	}
+
+	/**
+	 * @deprecated the java model leave the responsibility of clearing up
+	 *             objects to the Garbage Collector. Our programming model
+	 *             should not require that the user specifically remove object
+	 *             from the thread.
+	 * 
+	 * This will remove an object from the ROT
+	 * @param o
+	 */
+	@Deprecated
+	public static synchronized void RemoveObject(JacobObject o) {
+		ROT.removeObject(o);
+	}
+
+	/**
+	 * @param threadModel
+	 */
+	public static native void doCoInitialize(int threadModel);
+
+	/**
+	 * 
+	 */
+	public static native void doCoUninitialize();
+
+	/**
+	 * load the Jacob DLL. We do this in case COMThread is called before any
+	 * other reference to one of the JacboObject subclasses is made.
+	 */
+	static {
+		LibraryLoader.loadJacobLibrary();
+	}
+}

src/main/java/com/jacob/com/Currency.java

@@ -0,0 +1,91 @@
+package com.jacob.com;
+
+/**
+ * Most COM bridges use java.lang.Long as their Java data type for COM Currency
+ * data. This is because COM currency is a 64 bit number where the last 4 digits
+ * represent the milli-cents. We wanted to support 64 bit Long values for x64
+ * platforms so that meant we wanted to map Java.LONG to COM.LONG even though it
+ * only works for 64 bit platforms. The end result was we needed a new
+ * representation for Money so we have this.
+ * <p>
+ * In the future, this should convert to and from BigDecimal or Double
+ */
+public class Currency {
+	Long embeddedValue = null;
+
+	/**
+	 * constructor that takes a long already in COM representation
+	 * 
+	 * @param newValue
+	 */
+	public Currency(long newValue) {
+		embeddedValue = new Long(newValue);
+	}
+
+	/**
+	 * constructor that takes a String already in COM representation
+	 * 
+	 * @param newValue
+	 */
+	public Currency(String newValue) {
+		embeddedValue = new Long(newValue);
+	}
+
+	/**
+	 * 
+	 * @return the currency as a primitive long
+	 */
+	public long longValue() {
+		return embeddedValue.longValue();
+	}
+
+	/**
+	 * getter to the inner storage so that cmpareTo can work
+	 * 
+	 * @return the embedded long value
+	 */
+	protected Long getLongValue() {
+		return embeddedValue;
+	}
+
+	/**
+	 * compares the values of two currencies
+	 * 
+	 * @param anotherCurrency
+	 * @return the usual compareTo results
+	 */
+	public int compareTo(Currency anotherCurrency) {
+		return embeddedValue.compareTo(anotherCurrency.getLongValue());
+	}
+
+	/**
+	 * standard comparison
+	 * 
+	 * @param o
+	 *            must be Currency or Long
+	 * @return the usual compareTo results
+	 */
+	public int compareTo(Object o) {
+		if (o instanceof Currency) {
+			return compareTo((Currency) o);
+		} else if (o instanceof Long) {
+			return embeddedValue.compareTo((Long) o);
+		} else
+			throw new IllegalArgumentException(
+					"Can only compare to Long and Currency not "
+							+ o.getClass().getName());
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public boolean equals(Object o) {
+		if (o == null) {
+			return false;
+		} else if (compareTo(o) == 0) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+}

src/main/java/com/jacob/com/DateUtilities.java

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+import java.util.Calendar;
+import java.util.Date;
+
+/**
+ * java / windows date conversion utilities
+ * 
+ * @author joe
+ * 
+ */
+public class DateUtilities {
+
+	/**
+	 * converts a windows time to a Java Date Object
+	 * 
+	 * @param comTime
+	 * @return Date object representing the windows time as specified in comTime
+	 */
+	static public Date convertWindowsTimeToDate(double comTime) {
+		return new Date(convertWindowsTimeToMilliseconds(comTime));
+	}
+
+	/**
+	 * Convert a COM time from functions Date(), Time(), Now() to a Java time
+	 * (milliseconds). Visual Basic time values are based to 30.12.1899, Java
+	 * time values are based to 1.1.1970 (= 0 milliseconds). The difference is
+	 * added to the Visual Basic value to get the corresponding Java value. The
+	 * Visual Basic double value reads: <day count delta since 30.12.1899>.<1
+	 * day percentage fraction>, e.g. "38100.6453" means: 38100 days since
+	 * 30.12.1899 plus (24 hours * 0.6453). Example usage:
+	 * <code>Date javaDate = new Date(toMilliseconds (vbDate));</code>.
+	 * 
+	 * @param comTime
+	 *            COM time.
+	 * @return Java time.
+	 */
+	static public long convertWindowsTimeToMilliseconds(double comTime) {
+		long result = 0;
+
+		// code from jacobgen:
+		comTime = comTime - 25569D;
+		Calendar cal = Calendar.getInstance();
+		result = Math.round(86400000L * comTime)
+				- cal.get(Calendar.ZONE_OFFSET);
+		cal.setTime(new Date(result));
+		result -= cal.get(Calendar.DST_OFFSET);
+
+		return result;
+	}// convertWindowsTimeToMilliseconds()
+
+	/**
+	 * converts a java date to a windows time object (is this timezone safe?)
+	 * 
+	 * @param javaDate
+	 *            the java date to be converted to windows time
+	 * @return the double representing the date in a form windows understands
+	 */
+	static public double convertDateToWindowsTime(Date javaDate) {
+		if (javaDate == null) {
+			throw new IllegalArgumentException(
+					"cannot convert null to windows time");
+		}
+		return convertMillisecondsToWindowsTime(javaDate.getTime());
+	}
+
+	/**
+	 * Convert a Java time to a COM time.
+	 * 
+	 * @param milliseconds
+	 *            Java time.
+	 * @return COM time.
+	 */
+	static public double convertMillisecondsToWindowsTime(long milliseconds) {
+		double result = 0.0;
+
+		// code from jacobgen:
+		Calendar cal = Calendar.getInstance();
+		cal.setTimeInMillis(milliseconds);
+		milliseconds += (cal.get(Calendar.ZONE_OFFSET) + cal
+				.get(Calendar.DST_OFFSET)); // add GMT offset
+		result = (milliseconds / 86400000D) + 25569D;
+
+		return result;
+	}// convertMillisecondsToWindowsTime()
+}

src/main/java/com/jacob/com/Dispatch.java

@@ -0,0 +1,872 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project. All rights reserved. Originator: Dan Adler
+ * (http://danadler.com). Get more information about JACOB at
+ * http://sourceforge.net/projects/jacob-project
+ * 
+ * This library is free software; you can redistribute it and/or modify it under the terms of the
+ * GNU Lesser General Public License as published by the Free Software Foundation; either version
+ * 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+ * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License along with this library;
+ * if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+package com.jacob.com;
+
+/**
+ * Object represents MS level dispatch object. Each instance of this points at
+ * some data structure on the MS windows side.
+ * 
+ * 
+ * <p>
+ * You're going to live here a lot
+ */
+public class Dispatch extends JacobObject {
+
+	/**
+	 * Used to set the locale in a call. The user locale is another option
+	 */
+	public static final int LOCALE_SYSTEM_DEFAULT = 2048;
+	/** used by callN() and callSubN() */
+	public static final int Method = 1;
+	/** used by callN() and callSubN() */
+	public static final int Get = 2;
+	/** used by put() */
+	public static final int Put = 4;
+	/** not used, probably intended for putRef() */
+	public static final int PutRef = 8;
+	/**
+	 * One of legal values for GetDispId. Not used in this layer and probably
+	 * not needed.
+	 */
+	public static final int fdexNameCaseSensitive = 1;
+
+	/**
+	 * This is public because Dispatch.cpp knows its name and accesses it
+	 * directly to get the dispatch id. You really can't rename it or make it
+	 * private
+	 */
+	public long m_pDispatch;
+
+	/** program Id passed in by ActiveX components in their constructor */
+	private String programId = null;
+
+	private static int NOT_ATTACHED = 0;
+
+	/**
+	 * Dummy empty array used one doesn't have to be created on every invocation
+	 */
+	private final static Object[] NO_OBJECT_ARGS = new Object[0];
+	/**
+	 * Dummy empty array used one doesn't have to be created on every invocation
+	 */
+	private final static Variant[] NO_VARIANT_ARGS = new Variant[0];
+	/**
+	 * Dummy empty array used one doesn't have to be created on every invocation
+	 */
+	private final static int[] NO_INT_ARGS = new int[0];
+
+	/**
+	 * zero argument constructor that sets the dispatch pointer to 0 This is the
+	 * only way to create a Dispatch without a value in the pointer field.
+	 */
+	public Dispatch() {
+		m_pDispatch = NOT_ATTACHED;
+	}
+
+	/**
+	 * This constructor calls createInstance with progid. This is the
+	 * constructor used by the ActiveXComponent or by programs that don't like
+	 * the activeX interface but wish to create new connections to windows
+	 * programs.
+	 * <p>
+	 * This constructor always creates a new windows/program object because it
+	 * is based on the CoCreate() windows function.
+	 * <p>
+	 * 
+	 * @param requestedProgramId
+	 * @throws IllegalArgumentException
+	 *             if null is passed in as the program id
+	 *             <p>
+	 */
+	public Dispatch(String requestedProgramId) {
+		programId = requestedProgramId;
+		if (programId != null && !"".equals(programId)) {
+			createInstanceNative(requestedProgramId);
+		} else {
+			throw new IllegalArgumentException(
+					"Dispatch(String) does not accept null or an empty string as a parameter");
+		}
+	}
+
+	/**
+	 * native call createInstance only used by the constructor with the same
+	 * parm type. This probably should be private. It is the wrapper for the
+	 * Windows CoCreate() call
+	 * <P>
+	 * This ends up calling CoCreate down in the JNI layer
+	 * <p>
+	 * The behavior is different if a ":" character exists in the progId. In
+	 * that case CoGetObject and CreateInstance (someone needs to describe this
+	 * better)
+	 * 
+	 * @param progid
+	 */
+	private native void createInstanceNative(String progid);
+
+	/**
+	 * native call getActiveInstance only used by the constructor with the same
+	 * parm type. This probably should be private. It is the wrapper for the
+	 * Windows GetActiveObject() call
+	 * <P>
+	 * This ends up calling GetActiveObject down in the JNI layer
+	 * <p>
+	 * This does not have the special behavior for program ids with ":" in them
+	 * that createInstance has.
+	 * 
+	 * @param progid
+	 */
+	private native void getActiveInstanceNative(String progid);
+
+	/**
+	 * Wrapper around the native method
+	 * 
+	 * @param pProgramIdentifier
+	 *            name of the program you wish to connect to
+	 */
+	protected void getActiveInstance(String pProgramIdentifier) {
+		if (pProgramIdentifier == null || "".equals(pProgramIdentifier)) {
+			throw new IllegalArgumentException("program id is required");
+		}
+		this.programId = pProgramIdentifier;
+		getActiveInstanceNative(pProgramIdentifier);
+	}
+
+	/**
+	 * native call coCreateInstance only used by the constructor with the same
+	 * parm type. This probably should be private. It is the wrapper for the
+	 * Windows CoCreate() call
+	 * <P>
+	 * This ends up calling CoCreate down in the JNI layer
+	 * <p>
+	 * This does not have the special behavior for program ids with ":" in them
+	 * that createInstance has.
+	 * 
+	 * @param progid
+	 */
+	private native void coCreateInstanceNative(String progid);
+
+	/**
+	 * Wrapper around the native method
+	 * 
+	 * @param pProgramIdentifier
+	 */
+	protected void coCreateInstance(String pProgramIdentifier) {
+		if (pProgramIdentifier == null || "".equals(pProgramIdentifier)) {
+			throw new IllegalArgumentException("program id is required");
+		}
+		this.programId = pProgramIdentifier;
+		coCreateInstanceNative(pProgramIdentifier);
+	}
+
+	/**
+	 * Return a different interface by IID string.
+	 * <p>
+	 * Once you have a Dispatch object, you can navigate to the other interfaces
+	 * of a COM object by calling QueryInterafce. The argument is an IID string
+	 * in the format: "{9BF24410-B2E0-11D4-A695-00104BFF3241}". You typically
+	 * get this string from the idl file (it's called uuid in there). Any
+	 * interface you try to use must be derived from IDispatch. T The atl
+	 * example uses this.
+	 * <p>
+	 * The Dispatch instance resulting from this query is instanciated in the
+	 * JNI code.
+	 * 
+	 * @param iid
+	 * @return Dispatch a disptach that matches ??
+	 */
+	public native Dispatch QueryInterface(String iid);
+
+	/**
+	 * Constructor that only gets called from JNI QueryInterface calls JNI code
+	 * that looks up the object for the key passed in. The JNI CODE then creates
+	 * a new dispatch object using this constructor
+	 * 
+	 * @param pDisp
+	 */
+	protected Dispatch(long pDisp) {
+		m_pDispatch = pDisp;
+	}
+
+	/**
+	 * Constructor to be used by subclass that want to swap themselves in for
+	 * the default Dispatch class. Usually you will have a class like
+	 * WordDocument that is a subclass of Dispatch and it will have a
+	 * constructor public WordDocument(Dispatch). That constructor should just
+	 * call this constructor as super(Dispatch)
+	 * 
+	 * @param dispatchToBeDisplaced
+	 */
+	public Dispatch(Dispatch dispatchToBeDisplaced) {
+		// TAKE OVER THE IDispatch POINTER
+		this.m_pDispatch = dispatchToBeDisplaced.m_pDispatch;
+		// NULL OUT THE INPUT POINTER
+		dispatchToBeDisplaced.m_pDispatch = NOT_ATTACHED;
+	}
+
+	/**
+	 * returns the program id if an activeX component created this otherwise it
+	 * returns null. This was added to aid in debugging
+	 * 
+	 * @return the program id an activeX component was created against
+	 */
+	public String getProgramId() {
+		return programId;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#finalize()
+	 */
+	@Override
+	protected void finalize() {
+		safeRelease();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.jacob.com.JacobObject#safeRelease()
+	 */
+	@Override
+	public void safeRelease() {
+		super.safeRelease();
+		if (isAttached()) {
+			release();
+			m_pDispatch = NOT_ATTACHED;
+		} else {
+			// looks like a double release
+			if (isDebugEnabled()) {
+				debug(this.getClass().getName() + ":" + this.hashCode()
+						+ " double release");
+			}
+		}
+	}
+
+	/**
+	 * 
+	 * @return true if there is an underlying windows dispatch object
+	 */
+	protected boolean isAttached() {
+		if (m_pDispatch == NOT_ATTACHED) {
+			return false;
+		} else {
+			return true;
+		}
+	}
+
+	/**
+	 * @param theOneInQuestion
+	 *            dispatch being tested
+	 * @throws IllegalStateException
+	 *             if this dispatch isn't hooked up
+	 * @throws IllegalArgumentException
+	 *             if null the dispatch under test is null
+	 */
+	private static void throwIfUnattachedDispatch(Dispatch theOneInQuestion) {
+		if (theOneInQuestion == null) {
+			throw new IllegalArgumentException(
+					"Can't pass in null Dispatch object");
+		} else if (theOneInQuestion.isAttached()) {
+			return;
+		} else {
+			throw new IllegalStateException(
+					"Dispatch not hooked to windows memory");
+		}
+	}
+
+	/**
+	 * now private so only this object can access 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,
+				VariantUtilities.objectsToVariants(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,
+				VariantUtilities.objectsToVariants(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,
+				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 attributes
+	 * @return Variant returned by underlying callN
+	 */
+	public static Variant call(Dispatch dispatchTarget, String name,
+			Object... attributes) {
+		throwIfUnattachedDispatch(dispatchTarget);
+		return callN(dispatchTarget, name, attributes);
+	}
+
+	/**
+	 * @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 attributes
+	 *            var arg list of attributes that will be passed to the
+	 *            underlying function
+	 * @return Variant returned by underlying callN
+	 */
+	public static Variant call(Dispatch dispatchTarget, int dispid,
+			Object... attributes) {
+		throwIfUnattachedDispatch(dispatchTarget);
+		return callN(dispatchTarget, dispid, attributes);
+	}
+
+	/*
+	 * ============================================================ 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, VariantUtilities
+				.objectsToVariants(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
+	 * @param oArg
+	 * @param uArgErr
+	 */
+	public static void invokeSub(Dispatch dispatchTarget, int dispid,
+			int wFlags, Object[] oArg, int[] uArgErr) {
+		throwIfUnattachedDispatch(dispatchTarget);
+		invokeSub(dispatchTarget, null, dispid, Dispatch.LOCALE_SYSTEM_DEFAULT,
+				wFlags, oArg, uArgErr);
+	}
+
+	/*
+	 * ============================================================ start of the
+	 * callSubN section
+	 * ===========================================================
+	 */
+	/**
+	 * makes call to native callSubN
+	 * 
+	 * @param dispatchTarget
+	 * @param name
+	 */
+	public static void callSub(Dispatch dispatchTarget, String name) {
+		throwIfUnattachedDispatch(dispatchTarget);
+		callSubN(dispatchTarget, name, NO_OBJECT_ARGS);
+	}
+
+	/**
+	 * makes call to native callSubN
+	 * 
+	 * @param dispatchTarget
+	 * @param name
+	 * @param attributes
+	 *            var args list of attributes to be passed to underlying
+	 *            functions
+	 */
+	public static void callSub(Dispatch dispatchTarget, String name,
+			Object... attributes) {
+		throwIfUnattachedDispatch(dispatchTarget);
+		callSubN(dispatchTarget, name, attributes);
+	}
+
+	/**
+	 * makes call to native callSubN
+	 * 
+	 * @param dispatchTarget
+	 * @param dispid
+	 */
+	public static void callSub(Dispatch dispatchTarget, int dispid) {
+		throwIfUnattachedDispatch(dispatchTarget);
+		callSubN(dispatchTarget, dispid, NO_OBJECT_ARGS);
+	}
+
+	/**
+	 * makes call to native callSubN
+	 * 
+	 * @param dispatchTarget
+	 * @param dispid
+	 * @param attributes
+	 *            var args list of attributes to be passed to underlying
+	 *            function
+	 */
+	public static void callSub(Dispatch dispatchTarget, int dispid,
+			Object... attributes) {
+		throwIfUnattachedDispatch(dispatchTarget);
+		callSubN(dispatchTarget, dispid, attributes);
+	}
+
+	/*
+	 * ============================================================ start of the
+	 * invokev section
+	 * ===========================================================
+	 */
+	/**
+	 * Cover for call to underlying invokev()
+	 * 
+	 * @param dispatchTarget
+	 * @param name
+	 * @return Variant returned by the request for retrieval of parameter
+	 */
+	public static Variant get(Dispatch dispatchTarget, String name) {
+		throwIfUnattachedDispatch(dispatchTarget);
+		return invokev(dispatchTarget, name, Dispatch.Get, NO_VARIANT_ARGS,
+				NO_INT_ARGS);
+	}
+
+	/**
+	 * Cover for call to underlying invokev()
+	 * 
+	 * @param dispatchTarget
+	 * @param dispid
+	 * @return Variant returned by the request for retrieval of parameter
+	 */
+	public static Variant get(Dispatch dispatchTarget, int dispid) {
+		throwIfUnattachedDispatch(dispatchTarget);
+		return invokev(dispatchTarget, dispid, Dispatch.Get, NO_VARIANT_ARGS,
+				NO_INT_ARGS);
+	}
+
+	/*
+	 * ============================================================ start of the
+	 * invoke section
+	 * ===========================================================
+	 */
+	/**
+	 * cover for underlying call to invoke
+	 * 
+	 * @param dispatchTarget
+	 * @param name
+	 * @param val
+	 */
+	public static void putRef(Dispatch dispatchTarget, String name, Object val) {
+		throwIfUnattachedDispatch(dispatchTarget);
+		invoke(dispatchTarget, name, Dispatch.PutRef, new Object[] { val },
+				new int[1]);
+	}
+
+	/**
+	 * cover for underlying call to invoke
+	 * 
+	 * @param dispatchTarget
+	 * @param dispid
+	 * @param val
+	 */
+	public static void putRef(Dispatch dispatchTarget, int dispid, Object val) {
+		throwIfUnattachedDispatch(dispatchTarget);
+		invoke(dispatchTarget, dispid, Dispatch.PutRef, new Object[] { val },
+				new int[1]);
+	}
+
+	/**
+	 * not implemented yet
+	 * 
+	 * @param dispatchTarget
+	 * @param name
+	 * @return Variant never returned
+	 * @throws com.jacob.com.NotImplementedException
+	 */
+	public static Variant get_CaseSensitive(Dispatch dispatchTarget, String name) {
+		throw new NotImplementedException("not implemented yet");
+	}
+
+	/**
+	 * Cover for native method
+	 * 
+	 * @param disp
+	 * @param dispid
+	 * @param lcid
+	 * @return 0 if the dispatch is still active and 1 if it has exited
+	 */
+	public static native int hasExited(Dispatch disp, int dispid, int lcid);
+
+	/**
+	 * The method is used to poll until it returns 1, indicating that the COM
+	 * server in gone.
+	 * <p>
+	 * Sourceforge feature request 2927058
+	 * 
+	 * @param dispatchTarget
+	 * @return 0 if the dispatch is still active and 1 if it has exited
+	 */
+	public static int hasExited(Dispatch dispatchTarget) {
+		throwIfUnattachedDispatch(dispatchTarget);
+		return hasExited(dispatchTarget, 0, LOCALE_SYSTEM_DEFAULT);
+	}
+
+}

src/main/java/com/jacob/com/DispatchEvents.java

@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+/**
+ * This class creates the scaffolding for event callbacks. Every instance of tis
+ * acts as a wrapper around some java object that wants callbacks from the
+ * microsoft side. It represents the connection between Java and COM for
+ * callbacks.
+ * <p>
+ * The callback mechanism will take any event that it receives and try and find
+ * a java method with the same name that accepts the Variant... as a parameter.
+ * It will then wrap the call back data in the Variant array and call the java
+ * method of the object that this DispatchEvents object was initialized with.
+ * <p>
+ * Instances of this class are created with "sink object" that will receive the
+ * event messages. The sink object is wrapped in an Invocation handler that
+ * actually receives the messages and then forwards them on to the "sink
+ * object". The constructors recognize when an instance of InvocationProxy is
+ * passed in and do not create a new InvocationProxy as a wrapper. They instead
+ * use the passed in InvocationProxy.
+ * 
+ */
+public class DispatchEvents extends JacobObject {
+
+	/**
+	 * pointer to an MS data struct. The COM layer knows the name of this
+	 * variable and puts the windows memory pointer here.
+	 */
+	long m_pConnPtProxy = 0;
+
+	/**
+	 * the wrapper for the event sink. This object is the one that will be sent
+	 * a message when an event occurs in the MS layer. Normally, the
+	 * InvocationProxy will forward the messages to a wrapped object that it
+	 * contains.
+	 */
+	InvocationProxy mInvocationProxy = null;
+
+	/**
+	 * This is the most commonly used constructor.
+	 * <p>
+	 * Creates the event callback linkage between the the MS program represented
+	 * by the Dispatch object and the Java object that will receive the
+	 * callback.
+	 * <p>
+	 * Can be used on any object that implements IProvideClassInfo.
+	 * 
+	 * @param sourceOfEvent
+	 *            Dispatch object who's MS app will generate callbacks
+	 * @param eventSink
+	 *            Java object that wants to receive the events
+	 */
+	public DispatchEvents(Dispatch sourceOfEvent, Object eventSink) {
+		this(sourceOfEvent, eventSink, null);
+	}
+
+	/**
+	 * None of the samples use this constructor.
+	 * <p>
+	 * Creates the event callback linkage between the the MS program represented
+	 * by the Dispatch object and the Java object that will receive the
+	 * callback.
+	 * <p>
+	 * Used when the program doesn't implement IProvideClassInfo. It provides a
+	 * way to find the TypeLib in the registry based on the programId. The
+	 * TypeLib is looked up in the registry on the path
+	 * HKEY_LOCAL_MACHINE/SOFTWARE/Classes/CLSID/(CLID drived from
+	 * progid)/ProgID/Typelib
+	 * 
+	 * @param sourceOfEvent
+	 *            Dispatch object who's MS app will generate callbacks
+	 * @param eventSink
+	 *            Java object that wants to receive the events
+	 * @param progId
+	 *            program id in the registry that has a TypeLib subkey. The
+	 *            progrId is mapped to a CLSID that is they used to look up the
+	 *            key to the Typelib
+	 */
+	public DispatchEvents(Dispatch sourceOfEvent, Object eventSink,
+			String progId) {
+		this(sourceOfEvent, eventSink, progId, null);
+	}
+
+	/**
+	 * Creates the event callback linkage between the the MS program represented
+	 * by the Dispatch object and the Java object that will receive the
+	 * callback.
+	 * <p>
+	 * This method was added because Excel doesn't implement IProvideClassInfo
+	 * and the registry entry for Excel.Application doesn't include a typelib
+	 * key.
+	 * 
+	 * <pre>
+	 * DispatchEvents de = new DispatchEvents(someDispatch, someEventHAndler,
+	 * 		&quot;Excel.Application&quot;,
+	 * 		&quot;C:\\Program Files\\Microsoft Office\\OFFICE11\\EXCEL.EXE&quot;);
+	 * </pre>
+	 * 
+	 * @param sourceOfEvent
+	 *            Dispatch object who's MS app will generate callbacks
+	 * @param eventSink
+	 *            Java object that wants to receive the events
+	 * @param progId
+	 *            , mandatory if the typelib is specified
+	 * @param typeLib
+	 *            The location of the typelib to use
+	 */
+	public DispatchEvents(Dispatch sourceOfEvent, Object eventSink,
+			String progId, String typeLib) {
+		if (JacobObject.isDebugEnabled()) {
+			System.out.println("DispatchEvents: Registering " + eventSink
+					+ "for events ");
+		}
+		if (eventSink instanceof InvocationProxy) {
+			mInvocationProxy = (InvocationProxy) eventSink;
+		} else {
+			mInvocationProxy = getInvocationProxy(eventSink);
+		}
+		if (mInvocationProxy != null) {
+			init3(sourceOfEvent, mInvocationProxy, progId, typeLib);
+		} else {
+			if (JacobObject.isDebugEnabled()) {
+				JacobObject.debug("Cannot register null event sink for events");
+			}
+			throw new IllegalArgumentException(
+					"Cannot register null event sink for events");
+		}
+	}
+
+	/**
+	 * Returns an instance of the proxy configured with pTargetObject as its
+	 * target
+	 * 
+	 * @param pTargetObject
+	 * @return InvocationProxy an instance of the proxy this DispatchEvents will
+	 *         send to the COM layer
+	 */
+	protected InvocationProxy getInvocationProxy(Object pTargetObject) {
+		InvocationProxy newProxy = new InvocationProxyAllVariants();
+		newProxy.setTarget(pTargetObject);
+		return newProxy;
+	}
+
+	/**
+	 * hooks up a connection point proxy by progId event methods on the sink
+	 * object will be called by name with a signature of <name>(Variant[] args)
+	 * 
+	 * You must specify the location of the typeLib.
+	 * 
+	 * @param src
+	 *            dispatch that is the source of the messages
+	 * @param sink
+	 *            the object that will receive the messages
+	 * @param progId
+	 *            optional program id. most folks don't need this either
+	 * @param typeLib
+	 *            optional parameter for those programs that don't register
+	 *            their type libs (like Excel)
+	 */
+	private native void init3(Dispatch src, Object sink, String progId,
+			String typeLib);
+
+	/**
+	 * now private so only this object can asccess was: call this to explicitly
+	 * release the com object before gc
+	 * 
+	 */
+	private native void release();
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#finalize()
+	 */
+	@Override
+	protected void finalize() {
+		safeRelease();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.jacob.com.JacobObject#safeRelease()
+	 */
+	@Override
+	public void safeRelease() {
+		if (mInvocationProxy != null) {
+			mInvocationProxy.setTarget(null);
+		}
+		mInvocationProxy = null;
+		super.safeRelease();
+		if (m_pConnPtProxy != 0) {
+			release();
+			m_pConnPtProxy = 0;
+		} else {
+			// looks like a double release
+			if (isDebugEnabled()) {
+				debug("DispatchEvents:" + this.hashCode() + " double release");
+			}
+		}
+	}
+
+}

src/main/java/com/jacob/com/DispatchIdentifier.java

@@ -0,0 +1,82 @@
+/**
+ * 
+ */
+package com.jacob.com;
+
+/**
+ * A bunch of DispatchIds that were pulled out of the Dispatch class for version
+ * 1.14.
+ */
+public class DispatchIdentifier {
+
+	private DispatchIdentifier() {
+		// This is utility class so there is no constructor.
+	}
+
+	public static final int DISPID_UNKNOWN = -1;
+	public static final int DISPID_VALUE = 0;
+	public static final int DISPID_PROPERTYPUT = -3;
+	public static final int DISPID_NEWENUM = -4;
+	public static final int DISPID_EVALUATE = -5;
+	public static final int DISPID_CONSTRUCTOR = -6;
+	public static final int DISPID_DESTRUCTOR = -7;
+	public static final int DISPID_COLLECT = -8;
+	public static final int DISPID_AUTOSIZE = -500;
+	public static final int DISPID_BACKCOLOR = -501;
+	public static final int DISPID_BACKSTYLE = -502;
+	public static final int DISPID_BORDERCOLOR = -503;
+	public static final int DISPID_BORDERSTYLE = -504;
+	public static final int DISPID_BORDERWIDTH = -505;
+	public static final int DISPID_DRAWMODE = -507;
+	public static final int DISPID_DRAWSTYLE = -508;
+	public static final int DISPID_DRAWWIDTH = -509;
+	public static final int DISPID_FILLCOLOR = -510;
+	public static final int DISPID_FILLSTYLE = -511;
+	public static final int DISPID_FONT = -512;
+	public static final int DISPID_FORECOLOR = -513;
+	public static final int DISPID_ENABLED = -514;
+	public static final int DISPID_HWND = -515;
+	public static final int DISPID_TABSTOP = -516;
+	public static final int DISPID_TEXT = -517;
+	public static final int DISPID_CAPTION = -518;
+	public static final int DISPID_BORDERVISIBLE = -519;
+	public static final int DISPID_APPEARANCE = -520;
+	public static final int DISPID_MOUSEPOINTER = -521;
+	public static final int DISPID_MOUSEICON = -522;
+	public static final int DISPID_PICTURE = -523;
+	public static final int DISPID_VALID = -524;
+	public static final int DISPID_READYSTATE = -525;
+	public static final int DISPID_REFRESH = -550;
+	public static final int DISPID_DOCLICK = -551;
+	public static final int DISPID_ABOUTBOX = -552;
+	public static final int DISPID_CLICK = -600;
+	public static final int DISPID_DBLCLICK = -601;
+	public static final int DISPID_KEYDOWN = -602;
+	public static final int DISPID_KEYPRESS = -603;
+	public static final int DISPID_KEYUP = -604;
+	public static final int DISPID_MOUSEDOWN = -605;
+	public static final int DISPID_MOUSEMOVE = -606;
+	public static final int DISPID_MOUSEUP = -607;
+	public static final int DISPID_ERROREVENT = -608;
+	public static final int DISPID_READYSTATECHANGE = -609;
+	public static final int DISPID_AMBIENT_BACKCOLOR = -701;
+	public static final int DISPID_AMBIENT_DISPLAYNAME = -702;
+	public static final int DISPID_AMBIENT_FONT = -703;
+	public static final int DISPID_AMBIENT_FORECOLOR = -704;
+	public static final int DISPID_AMBIENT_LOCALEID = -705;
+	public static final int DISPID_AMBIENT_MESSAGEREFLECT = -706;
+	public static final int DISPID_AMBIENT_SCALEUNITS = -707;
+	public static final int DISPID_AMBIENT_TEXTALIGN = -708;
+	public static final int DISPID_AMBIENT_USERMODE = -709;
+	public static final int DISPID_AMBIENT_UIDEAD = -710;
+	public static final int DISPID_AMBIENT_SHOWGRABHANDLES = -711;
+	public static final int DISPID_AMBIENT_SHOWHATCHING = -712;
+	public static final int DISPID_AMBIENT_DISPLAYASDEFAULT = -713;
+	public static final int DISPID_AMBIENT_SUPPORTSMNEMONICS = -714;
+	public static final int DISPID_AMBIENT_AUTOCLIP = -715;
+	public static final int DISPID_AMBIENT_APPEARANCE = -716;
+	public static final int DISPID_AMBIENT_CODEPAGE = -725;
+	public static final int DISPID_AMBIENT_PALETTE = -726;
+	public static final int DISPID_AMBIENT_CHARSET = -727;
+	public static final int DISPID_AMBIENT_TRANSFERPRIORITY = -728;
+}

src/main/java/com/jacob/com/DispatchProxy.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+/**
+ * If you need to pass a COM Dispatch object between STA threads, you have to
+ * marshall the interface. This class is used as follows: the STA that creates
+ * the Dispatch object must construct an instance of this class. Another thread
+ * can then call toDispatch() on that instance and get a Dispatch pointer which
+ * has been marshalled. WARNING: You can only call toDispatch() once! If you
+ * need to call it multiple times (or from multiple threads) you need to
+ * construct a separate DispatchProxy instance for each such case!
+ */
+public class DispatchProxy extends JacobObject {
+	/**
+	 * Comment for <code>m_pStream</code>
+	 */
+	public long m_pStream;
+
+	/**
+	 * Marshals the passed in dispatch into the stream
+	 * 
+	 * @param localDispatch
+	 */
+	public DispatchProxy(Dispatch localDispatch) {
+		MarshalIntoStream(localDispatch);
+	}
+
+	/**
+	 * 
+	 * @return Dispatch the dispatch retrieved from the stream
+	 */
+	public Dispatch toDispatch() {
+		return MarshalFromStream();
+	}
+
+	private native void MarshalIntoStream(Dispatch d);
+
+	private native Dispatch MarshalFromStream();
+
+	/**
+	 * now private so only this object can access was: call this to explicitly
+	 * release the com object before gc
+	 * 
+	 */
+	private native void release();
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#finalize()
+	 */
+	@Override
+	public void finalize() {
+		safeRelease();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.jacob.com.JacobObject#safeRelease()
+	 */
+	@Override
+	public void safeRelease() {
+		super.safeRelease();
+		if (m_pStream != 0) {
+			release();
+			m_pStream = 0;
+		} else {
+			// looks like a double release
+			if (isDebugEnabled()) {
+				debug(this.getClass().getName() + ":" + this.hashCode()
+						+ " double release");
+			}
+		}
+	}
+}

src/main/java/com/jacob/com/EnumVariant.java

@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+/**
+ * An implementation of IEnumVariant based on code submitted by Thomas Hallgren
+ * (mailto:Thomas.Hallgren@eoncompany.com)
+ */
+public class EnumVariant extends JacobObject implements
+		java.util.Enumeration<Variant> {
+	/** pointer to windows memory */
+	private long m_pIEnumVARIANT;
+
+	private final Variant[] m_recBuf = new Variant[1];
+
+	// this only gets called from JNI
+	//
+	protected EnumVariant(long pIEnumVARIANT) {
+		m_pIEnumVARIANT = pIEnumVARIANT;
+	}
+
+	/**
+	 * @param disp
+	 */
+	public EnumVariant(Dispatch disp) {
+		int[] hres = new int[1];
+		// SF 3377279
+		// Added Dispatch.Method to the invoke flags to call _NewEnum. There are
+		// some
+		// non-conforming legacy implementations that expose _NewEnum as a
+		// method.
+		Variant evv = Dispatch.invokev(disp, DispatchIdentifier.DISPID_NEWENUM,
+				Dispatch.Get | Dispatch.Method, new Variant[0], hres);
+		if (evv.getvt() != Variant.VariantObject)
+			// The DISPID_NEWENUM did not result in a valid object
+			throw new ComFailException("Can't obtain EnumVARIANT");
+
+		EnumVariant tmp = evv.toEnumVariant();
+		m_pIEnumVARIANT = tmp.m_pIEnumVARIANT;
+		tmp.m_pIEnumVARIANT = 0;
+	}
+
+	/**
+	 * Implements java.util.Enumeration
+	 * 
+	 * @return boolean true if there are more elements in this enumeration
+	 */
+	public boolean hasMoreElements() {
+		{
+			if (m_recBuf[0] == null) {
+				if (this.Next(m_recBuf) <= 0)
+					return false;
+			}
+			return true;
+		}
+	}
+
+	/**
+	 * Implements java.util.Enumeration
+	 * 
+	 * @return next element in the enumeration
+	 */
+	public Variant nextElement() {
+		Variant last = m_recBuf[0];
+		if (last == null) {
+			if (this.Next(m_recBuf) <= 0)
+				throw new java.util.NoSuchElementException();
+			last = m_recBuf[0];
+		}
+		m_recBuf[0] = null;
+		return last;
+	}
+
+	/**
+	 * Get next element in collection or null if at end
+	 * 
+	 * @return Variant that is next in the collection
+	 * @deprecated use nextElement() instead
+	 */
+	@Deprecated
+	public Variant Next() {
+		if (hasMoreElements())
+			return nextElement();
+		return null;
+	}
+
+	/**
+	 * This should be private and wrapped to protect JNI layer.
+	 * 
+	 * @param receiverArray
+	 * @return Returns the next variant object pointer as an int from windows
+	 *         layer
+	 */
+	public native int Next(Variant[] receiverArray);
+
+	/**
+	 * This should be private and wrapped to protect JNI layer.
+	 * 
+	 * @param count
+	 *            number to skip
+	 */
+	public native void Skip(int count);
+
+	/**
+	 * This should be private and wrapped to protect JNI layer
+	 */
+	public native void Reset();
+
+	/**
+	 * now private so only this object can access was: call this to explicitly
+	 * release the com object before gc
+	 * 
+	 */
+	private native void release();
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#finalize()
+	 */
+	@Override
+	protected void finalize() {
+		safeRelease();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.jacob.com.JacobObject#safeRelease()
+	 */
+	@Override
+	public void safeRelease() {
+		super.safeRelease();
+		if (m_pIEnumVARIANT != 0) {
+			this.release();
+			m_pIEnumVARIANT = 0;
+		} else {
+			// looks like a double release
+			if (isDebugEnabled()) {
+				debug(this.getClass().getName() + ":" + this.hashCode()
+						+ " double release");
+			}
+		}
+	}
+}

src/main/java/com/jacob/com/InvocationProxy.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+/**
+ * @version $Id$
+ * @author joe
+ * 
+ * DispatchEvents wraps this class around any event handlers before making the
+ * JNI call that sets up the link with EventProxy. This means that
+ * EventProxy.cpp just calls invoke(String,Variant[]) against the instance of
+ * this class. Then this class does reflection against the event listener to
+ * call the actual event methods. The event methods can return void or return a
+ * Variant. Any value returned will be passed back to the calling windows module
+ * by the Jacob JNI layer.
+ * <p>
+ * 
+ * The void returning signature is the standard legacy signature. The Variant
+ * returning signature was added in 1.10 to support event handlers returning
+ * values.
+ * 
+ */
+public abstract class InvocationProxy {
+
+	/**
+	 * the object we will try and forward to.
+	 */
+	protected Object mTargetObject = null;
+
+	/**
+	 * dummy constructor for subclasses that don't actually wrap anything and
+	 * just want to override the invoke() method
+	 */
+	protected InvocationProxy() {
+		super();
+	}
+
+	/**
+	 * The method actually invoked by EventProxy.cpp. The method name is
+	 * calculated by the underlying JNI code from the MS windows Callback
+	 * function name. The method is assumed to take an array of Variant objects.
+	 * The method may return a Variant or be a void. Those are the only two
+	 * options that will not blow up.
+	 * <p>
+	 * Subclasses that override this should make sure mTargetObject is not null
+	 * before processing.
+	 * 
+	 * @param methodName
+	 *            name of method in mTargetObject we will invoke
+	 * @param targetParameters
+	 *            Variant[] that is the single parameter to the method
+	 * @return an object that will be returned to the com event caller
+	 */
+	public abstract Variant invoke(String methodName,
+			Variant targetParameters[]);
+
+	/**
+	 * used by EventProxy.cpp to create variant objects in the right thread
+	 * 
+	 * @return Variant object that will be used by the COM layer
+	 */
+	public Variant getVariant() {
+		return new VariantViaEvent();
+	}
+
+	/**
+	 * Sets the target for this InvocationProxy.
+	 * 
+	 * @param pTargetObject
+	 * @throws IllegalArgumentException
+	 *             if target is not publicly accessible
+	 */
+	public void setTarget(Object pTargetObject) {
+		if (JacobObject.isDebugEnabled()) {
+			JacobObject.debug("InvocationProxy: setting target "
+					+ pTargetObject);
+		}
+		if (pTargetObject != null) {
+			// JNI code apparently bypasses this check and could operate against
+			// protected classes. This seems like a security issue...
+			// maybe it was because JNI code isn't in a package?
+			if (!java.lang.reflect.Modifier.isPublic(pTargetObject.getClass()
+					.getModifiers())) {
+				throw new IllegalArgumentException(
+						"InvocationProxy only public classes can receive event notifications");
+			}
+		}
+		mTargetObject = pTargetObject;
+	}
+
+}

src/main/java/com/jacob/com/InvocationProxyAllVariants.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * This class acts as a proxy between the windows event callback mechanism and
+ * the Java classes that are looking for events. It assumes that all of the Java
+ * classes that are looking for events implement methods with the same names as
+ * the windows events and that the implemented methods accept an array of
+ * variant objects. The methods can return void or a Variant that will be
+ * returned to the calling layer. All Event methods that will be recognized by
+ * InvocationProxyAllEvents have the signature
+ * 
+ * <code> void eventMethodName(Variant[])</code> or
+ * <code> Variant eventMethodName(Variant[])</code>
+ */
+public class InvocationProxyAllVariants extends InvocationProxy {
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.jacob.com.InvocationProxy#invoke(java.lang.String,
+	 *      com.jacob.com.Variant[])
+	 */
+	@SuppressWarnings("unchecked")
+	public Variant invoke(String methodName, Variant targetParameters[]) {
+		Variant mVariantToBeReturned = null;
+		if (mTargetObject == null) {
+			if (JacobObject.isDebugEnabled()) {
+				JacobObject.debug("InvocationProxy: received notification ("
+						+ methodName + ") with no target set");
+			}
+			// structured programming guidlines say this return should not be up
+			// here
+			return null;
+		}
+		Class targetClass = mTargetObject.getClass();
+		if (methodName == null) {
+			throw new IllegalArgumentException(
+					"InvocationProxy: missing method name");
+		}
+		if (targetParameters == null) {
+			throw new IllegalArgumentException(
+					"InvocationProxy: missing Variant parameters");
+		}
+		try {
+			if (JacobObject.isDebugEnabled()) {
+				JacobObject.debug("InvocationProxy: trying to invoke "
+						+ methodName + " on " + mTargetObject);
+			}
+			Method targetMethod;
+			targetMethod = targetClass.getMethod(methodName,
+					new Class[] { Variant[].class });
+			if (targetMethod != null) {
+				// protected classes can't be invoked against even if they
+				// let you grab the method. you could do
+				// targetMethod.setAccessible(true);
+				// but that should be stopped by the security manager
+				Object mReturnedByInvocation = null;
+				mReturnedByInvocation = targetMethod.invoke(mTargetObject,
+						new Object[] { targetParameters });
+				if (mReturnedByInvocation == null) {
+					mVariantToBeReturned = null;
+				} else if (!(mReturnedByInvocation instanceof Variant)) {
+					// could try and convert to Variant here.
+					throw new IllegalArgumentException(
+							"InvocationProxy: invokation of target method returned "
+									+ "non-null non-variant object: "
+									+ mReturnedByInvocation);
+				} else {
+					mVariantToBeReturned = (Variant) mReturnedByInvocation;
+				}
+			}
+		} catch (SecurityException e) {
+			// what causes this exception?
+			e.printStackTrace();
+		} catch (NoSuchMethodException e) {
+			// this happens whenever the listener doesn't implement all the
+			// methods
+			if (JacobObject.isDebugEnabled()) {
+				JacobObject.debug("InvocationProxy: listener (" + mTargetObject
+						+ ") doesn't implement " + methodName);
+			}
+		} catch (IllegalArgumentException e) {
+			e.printStackTrace();
+			// we can throw these inside the catch block so need to re-throw it
+			throw e;
+		} catch (IllegalAccessException e) {
+			// can't access the method on the target instance for some reason
+			if (JacobObject.isDebugEnabled()) {
+				JacobObject
+						.debug("InvocationProxy: probably tried to access public method on non public class"
+								+ methodName);
+			}
+			e.printStackTrace();
+		} catch (InvocationTargetException e) {
+			// invocation of target method failed
+			e.printStackTrace();
+		}
+		return mVariantToBeReturned;
+
+	}
+}

src/main/java/com/jacob/com/JacobException.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+/**
+ * The parent class of all Jacob exceptions. They all used to be based off of
+ * RuntimeException or ComException but it was decided to base them all off of
+ * one owned by this project.
+ */
+public class JacobException extends RuntimeException {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -1637125318746002715L;
+
+	/**
+	 * Default constructor. Calls super with a "No Message Provided" string
+	 */
+	public JacobException() {
+		super("No Message Provided");
+	}
+
+	/**
+	 * standard constructor
+	 * 
+	 * @param message
+	 */
+	public JacobException(String message) {
+		super(message);
+	}
+}

src/main/java/com/jacob/com/JacobObject.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+/**
+ * The superclass of all Jacob objects. It is used to create a standard API
+ * framework and to facilitate memory management for Java and COM memory
+ * elements.
+ * <p>
+ * All instances of this class and subclasses are automatically managed by the
+ * ROT. This means the ROT cannot be a subclass of JacobObject.
+ * <p>
+ * All COM object created by JACOB extend this class so that we can
+ * automatically release them when the thread is detached from COM - if we leave
+ * it to the finalizer it will call the release from another thread, which may
+ * result in a segmentation violation.
+ */
+public class JacobObject {
+
+	/**
+	 * Standard constructor that adds this JacobObject to the memory management
+	 * pool.
+	 */
+	public JacobObject() {
+		ROT.addObject(this);
+	}
+
+	/**
+	 * Finalizers call this method. This method should release any COM data
+	 * structures in a way that it can be called multiple times. This can happen
+	 * if someone manually calls this and then a finalizer calls it.
+	 */
+	public void safeRelease() {
+		// currently does nothing - subclasses may do something
+		if (isDebugEnabled()) {
+			// this used to do a toString() but that is bad for SafeArray
+			debug("SafeRelease: " + this.getClass().getName());
+		}
+	}
+
+	/**
+	 * When things go wrong, it is useful to be able to debug the ROT.
+	 */
+	private static final boolean DEBUG =
+	// true;
+	"true".equalsIgnoreCase(System.getProperty("com.jacob.debug"));
+
+	protected static boolean isDebugEnabled() {
+		return DEBUG;
+	}
+
+	/**
+	 * Loads JacobVersion.Properties and returns the value of version in it
+	 * 
+	 * @deprecated use JacobReleaseInfo.getBuildDate() instead.
+	 * @return String value of version in JacobVersion.Properties or "" if none
+	 */
+	@Deprecated
+	public static String getBuildDate() {
+		return JacobReleaseInfo.getBuildDate();
+	}
+
+	/**
+	 * Loads JacobVersion.Properties and returns the value of version in it
+	 * 
+	 * @deprecated use JacobReleaseInfo.getBuildVersion() instead.
+	 * @return String value of version in JacobVersion.Properties or "" if none
+	 */
+	@Deprecated
+	public static String getBuildVersion() {
+		return JacobReleaseInfo.getBuildVersion();
+	}
+
+	/**
+	 * Very basic debugging function.
+	 * 
+	 * @param istrMessage
+	 */
+	protected static void debug(String istrMessage) {
+		if (isDebugEnabled()) {
+			System.out.println(Thread.currentThread().getName() + ": "
+					+ istrMessage);
+		}
+	}
+
+	/**
+	 * force the jacob DLL to be loaded whenever this class is referenced
+	 */
+	static {
+		LibraryLoader.loadJacobLibrary();
+	}
+
+}

src/main/java/com/jacob/com/JacobReleaseInfo.java

@@ -0,0 +1,96 @@
+package com.jacob.com;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Properties;
+
+/**
+ * An interface to the version properties file. This code was removed from
+ * JacobObject because it doesn't belong there.
+ * 
+ */
+public class JacobReleaseInfo {
+
+	/**
+	 * holds the build version as retrieved from the version properties file
+	 * that exists in the JAR. This can be retrieved by calling the static
+	 * method getBuildVersion()
+	 * 
+	 * @see #getBuildVersion()
+	 */
+	private static String buildVersion = "";
+	/**
+	 * holds the build date as retrieved from the version properties file that
+	 * exists in the JAR This can be retrieved by calling the static method
+	 * getBuildDate()
+	 * 
+	 * @see #getBuildDate()
+	 */
+	private static String buildDate = "";
+	/** the name of the jacob version properties file */
+	private static final String PROPERTY_FILE_NAME = "META-INF/JacobVersion.properties";
+
+	/**
+	 * Loads version information from PROPERTY_FILE_NAME that was built as part
+	 * of this release.
+	 * 
+	 * @throws IllegalStateException
+	 *             when it can't find the version properties file
+	 */
+	private static void loadVersionProperties() {
+		Properties versionProps = new Properties();
+		// can't use system class loader cause won't work in JavaWebStart
+		InputStream stream = JacobReleaseInfo.class.getClassLoader()
+				.getResourceAsStream(PROPERTY_FILE_NAME);
+		// This should never happen. This is an attempt to make something work
+		// for WebSphere. They may be using some kind of Servlet loader that
+		// needs an absolute path based search
+		if (stream == null) {
+			stream = JacobReleaseInfo.class.getClassLoader()
+					.getResourceAsStream("/" + PROPERTY_FILE_NAME);
+		}
+		// A report came in that WebSphere had trouble finding the file
+		// so lets trap it. Plus, it's a good idea anyway.
+		if (stream == null) {
+			throw new IllegalStateException(
+					"Can't find "
+							+ PROPERTY_FILE_NAME
+							+ " using JacobReleaseInfo.class.getClassLoader().getResourceAsStream()");
+		} else {
+			try {
+				versionProps.load(stream);
+				stream.close();
+				buildVersion = (String) versionProps.get("version");
+				buildDate = (String) versionProps.get("build.date");
+			} catch (IOException ioe) {
+				ioe.printStackTrace();
+				System.err.println("Warning! Couldn't load props " + ioe);
+			}
+		}
+	}
+
+	/**
+	 * loads PROPERT_FILE_NAME and returns the value of version in it
+	 * 
+	 * @return String value of version in PROPERT_FILE_NAME or "" if none
+	 */
+	public static String getBuildDate() {
+		if (buildDate.equals("")) {
+			loadVersionProperties();
+		}
+		return buildDate;
+	}
+
+	/**
+	 * loads PROPERT_FILE_NAME and returns the value of version in it
+	 * 
+	 * @return String value of version in PROPERT_FILE_NAME or "" if none
+	 */
+	public static String getBuildVersion() {
+		if (buildVersion.equals("")) {
+			loadVersionProperties();
+		}
+		return buildVersion;
+	}
+
+}

src/main/java/com/jacob/com/LibraryLoader.java

@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) 1999-2007 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+import java.util.Set;
+
+/**
+ * Utility class to centralize the way in which the jacob JNI library is loaded.
+ * <p>
+ * 
+ * This supports defining the path or library name using system properties or a
+ * custom resource file. If desired, jacob can auto-detect the correct version
+ * of the DLL for 32 or 64 bit windows, as long as you have named them
+ * differently.
+ * 
+ * <ol>
+ * <li> If system property {@link #JACOB_DLL_PATH} is defined, the file located
+ * there will be loaded as the jacob dll using System.load(). </li>
+ * 
+ * <li> If system property {@link #JACOB_DLL_NAME} is defined, the file located
+ * there will be loaded as the jacob dll. </li>
+ * <li> If system property {@link #JACOB_DLL_NAME_X86} and
+ * {@link #JACOB_DLL_NAME_X64} are defined, the file located there will be
+ * loaded as the jacob dll, depending on the version of Windows. </li>
+ * 
+ * <li> If {@link #JACOB_DLL_NAME} is defined in the
+ * {@code com.jacob.com.JacobLibraryLoader} resource file, the specified dll
+ * will be loaded from the {@code java.library.path}. </li>
+ * <li> If {@link #JACOB_DLL_NAME_X86} and {@link #JACOB_DLL_NAME_X64} are
+ * defined in the {@code com.jacob.com.JacobLibraryLoader} resource file, the
+ * specified dll will be loaded from the {@code java.library.path}, depending
+ * on the version of Windows. </li>
+ * 
+ * <li> If none of the above are true, the default is to load the library named
+ * "jacob-&lt;version&gt;-&lt;arch&gt" (or
+ * "jacob-&lt;version&gt;-&lt;arch&rt;.dll") from the {@code java.library.path}.
+ * </li>
+ * </ol>
+ * 
+ * The standard behavior for most applications is that {@code LoadLibrary()}
+ * will be called to load the dll. {@code LoadLibary()} searches directories
+ * specified in the variable {@code java.library.path}. This is why most test
+ * cases specify -Djava.library.path in their command line arguments.
+ * <p>
+ * JACOB_DLL_PATH submitted sourceforge ticket 1493647 Added 1.11 <br>
+ * JACOB_DLL_NAME, JACOB_DLL_NAME_32, JACOB_DLL_NAME_64 submitted sourceforge
+ * ticket 1845039 Added 1.14M7
+ * 
+ * @author Scott Dickerson (sjd78)
+ * @author Jason Smith
+ */
+public final class LibraryLoader {
+	/**
+	 * Name of system property (currently <tt>jacob.dll.path</tt>) that may
+	 * contain an absolute path to the JNI library.
+	 */
+	public static final String JACOB_DLL_PATH = "jacob.dll.path";
+
+	/**
+	 * Name of system property (currently <tt>jacob.dll.name</tt>) that may
+	 * contain an alternate name for the JNI library (default is 'jacob').
+	 */
+	public static final String JACOB_DLL_NAME = "jacob.dll.name";
+
+	/**
+	 * Name of system property (currently <tt>jacob.dll.name</tt>) that may
+	 * contain an alternate name for the JNI library (default is 'jacob'), 32
+	 * bit windows.
+	 */
+	public static final String JACOB_DLL_NAME_X86 = "jacob.dll.name.x86";
+
+	/**
+	 * Name of system property (currently <tt>jacob.dll.name</tt>) that may
+	 * contain an alternate name for the JNI library (default is 'jacob'), 64
+	 * bit windows.
+	 */
+	public static final String JACOB_DLL_NAME_X64 = "jacob.dll.name.x64";
+
+	/**
+	 * Appended to "jacob" when building DLL name This string must EXACTLY match
+	 * the string in the build.xml file
+	 */
+	public static final String DLL_NAME_MODIFIER_32_BIT = "x86";
+	/**
+	 * Appended to "jacob" when building DLL name This string must EXACTLY match
+	 * the string in the build.xml file
+	 */
+	public static final String DLL_NAME_MODIFIER_64_BIT = "x64";
+
+	/**
+	 * Load the jacob dll either from an absolute path or by a library name,
+	 * both of which may be defined in various ways.
+	 * 
+	 * @throws UnsatisfiedLinkError
+	 *             if the library does not exist.
+	 */
+	public static void loadJacobLibrary() {
+		// In some cases, a library that uses Jacob won't be able to set system
+		// properties
+		// prior to Jacob being loaded. The resource bundle provides an
+		// alternate way to
+		// override DLL name or path that will be loaded with Jacob regardless
+		// of other
+		// initialization order.
+		ResourceBundle resources = null;
+		Set<String> keys = new HashSet<String>();
+		try {
+			resources = ResourceBundle.getBundle(LibraryLoader.class.getName(),
+					Locale.getDefault(), LibraryLoader.class.getClassLoader());
+			for (Enumeration<String> i = resources.getKeys(); i
+					.hasMoreElements();) {
+				String key = i.nextElement();
+				keys.add(key);
+			}
+		} catch (MissingResourceException e) {
+			// Do nothing. Expected.
+		}
+
+		// First, check for a defined PATH. System property overrides resource
+		// bundle.
+		String path = System.getProperty(JACOB_DLL_PATH);
+		if (path == null && resources != null && keys.contains(JACOB_DLL_PATH)) {
+			path = (String) resources.getObject(JACOB_DLL_PATH);
+		}
+
+		if (path != null) {
+			JacobObject.debug("Loading library " + path
+					+ " using System.loadLibrary ");
+			System.load(path);
+		} else {
+			// Path was not defined, so use the OS mechanism for loading
+			// libraries.
+			// Check for a defined NAME. System property overrides resource
+			// bundle.
+			String name = null;
+
+			if (System.getProperty(JACOB_DLL_NAME) != null) {
+				name = System.getProperty(JACOB_DLL_NAME);
+			} else if (System.getProperty(JACOB_DLL_NAME_X86) != null
+					&& shouldLoad32Bit()) {
+				name = System.getProperty(JACOB_DLL_NAME_X86);
+			} else if (System.getProperty(JACOB_DLL_NAME_X64) != null
+					&& !shouldLoad32Bit()) {
+				name = System.getProperty(JACOB_DLL_NAME_X64);
+			} else if (resources != null && keys.contains(JACOB_DLL_NAME)) {
+				name = resources.getString(JACOB_DLL_NAME);
+			} else if (resources != null && keys.contains(JACOB_DLL_NAME_X86)
+					&& shouldLoad32Bit()) {
+				name = resources.getString(JACOB_DLL_NAME_X86);
+			} else if (resources != null && keys.contains(JACOB_DLL_NAME_X64)
+					&& !shouldLoad32Bit()) {
+				name = resources.getString(JACOB_DLL_NAME_X64);
+			} else {
+				// No alternate NAME or PATH was defined, so use the default.
+				// We will almost always end up here.
+				name = getPreferredDLLName();
+			}
+
+			JacobObject.debug("Loading library " + name
+					+ " using System.loadLibrary ");
+			// System.out.println("Loading " + name);
+			System.loadLibrary(name);
+		}
+	}
+
+	/**
+	 * Developer note: This method MUST be synchronized with the DLL names
+	 * created as part of the build process in build.xml
+	 * <p>
+	 * The DLL name is "jacob\<PLATFORM\>.release"
+	 * 
+	 * @return the preferred name of the DLL adjusted for this platform and
+	 *         version without the ".dll" extension
+	 */
+	public static String getPreferredDLLName() {
+		if (shouldLoad32Bit()) {
+			return "jacob" + "-" + JacobReleaseInfo.getBuildVersion() + "-"
+					+ DLL_NAME_MODIFIER_32_BIT;
+		} else {
+			return "jacob" + "-" + JacobReleaseInfo.getBuildVersion() + "-"
+					+ DLL_NAME_MODIFIER_64_BIT;
+		}
+	}
+
+	/**
+	 * Detects whether this is a 32-bit JVM.
+	 * 
+	 * @return {@code true} if this is a 32-bit JVM.
+	 */
+	protected static boolean shouldLoad32Bit() {
+		// This guesses whether we are running 32 or 64 bit Java.
+		// This works for Sun and IBM JVMs version 5.0 or later.
+		// May need to be adjusted for non-Sun JVMs.
+
+		String bits = System.getProperty("sun.arch.data.model", "?");
+		if (bits.equals("32"))
+			return true;
+		else if (bits.equals("64"))
+			return false;
+
+		// this works for jRocket
+		String arch = System.getProperty("java.vm.name", "?");
+		if (arch.toLowerCase().indexOf("64-bit") >= 0)
+			return false;
+
+		return true;
+	}
+} // LibraryLoader

src/main/java/com/jacob/com/MainSTA.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+/**
+ * We provide our own main sta thread to avoid COM tagging a random thread as
+ * the main STA - this is the thread in which all Apartment threaded components
+ * will be created if the client chooses an MTA threading model for the java
+ * side of the app.
+ */
+public class MainSTA extends STA {
+}

src/main/java/com/jacob/com/NotImplementedException.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+/**
+ * Thrown by java APIs that are not implemented either because they were never
+ * implemented or because they are being deprecated This is a subclass of
+ * ComException so callers can still just catch ComException.
+ */
+public class NotImplementedException extends JacobException {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -9169900832852356445L;
+
+	/**
+	 * @param description
+	 */
+	public NotImplementedException(String description) {
+		super(description);
+	}
+
+}

src/main/java/com/jacob/com/ROT.java

@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+/**
+ * The Running Object Table (ROT) maps each thread to a collection of all the
+ * JacobObjects that were created in that thread. It always operates on the
+ * current thread so all the methods are static and they implicitly get the
+ * current thread.
+ * <p>
+ * The clearObjects method is used to release all the COM objects created by
+ * Jacob in the current thread prior to uninitializing COM for that thread.
+ * <p>
+ * Prior to 1.9, manual garbage collection was the only option in Jacob, but
+ * from 1.9 onward, setting the com.jacob.autogc system property allows the
+ * objects referenced by the ROT to be automatically GCed. Automatic GC may be
+ * preferable in systems with heavy event callbacks.
+ * <p>
+ * Is [ 1116101 ] jacob-msg 0284 relevant???
+ */
+public abstract class ROT {
+	/**
+	 * Manual garbage collection was the only option pre 1.9 Can staticly cache
+	 * the results because only one value and we don't let it change during a
+	 * run
+	 */
+	protected static final boolean USE_AUTOMATIC_GARBAGE_COLLECTION = "true"
+			.equalsIgnoreCase(System.getProperty("com.jacob.autogc"));
+
+	/**
+	 * If the code is ran from an applet that is called from javascript the Java
+	 * Plugin does not give full permissions to the code and thus System
+	 * properties cannot be accessed. They can be accessed at class
+	 * initialization time.
+	 * 
+	 * The default behavior is to include all classes in the ROT, setting a
+	 * boolean here to indicate this prevents a call to System.getProperty as
+	 * part of the general call flow.
+	 */
+	protected static final Boolean INCLUDE_ALL_CLASSES_IN_ROT = Boolean
+			.valueOf(System.getProperty("com.jacob.includeAllClassesInROT",
+					"true"));
+
+	/**
+	 * Suffix added to class name to make up property name that determines if
+	 * this object should be stored in the ROT. This 1.13 "feature" makes it
+	 * possible to cause VariantViaEvent objects to not be added to the ROT in
+	 * event callbacks.
+	 * <p>
+	 * We don't have a static for the actual property because there is a
+	 * different property for each class that may make use of this feature.
+	 */
+	protected static String PUT_IN_ROT_SUFFIX = ".PutInROT";
+
+	/**
+	 * ThreadLocal with the com objects created in that thread
+	 */
+	private static ThreadLocal<Map<JacobObject, String>> rot = new ThreadLocal<Map<JacobObject, String>>();
+
+	/**
+	 * adds a new thread storage area to rot
+	 * 
+	 * @return Map corresponding to the thread that this call was made in
+	 */
+	protected synchronized static Map<JacobObject, String> addThread() {
+		Map<JacobObject, String> tab = rot.get();
+		if (tab == null) {
+			if (JacobObject.isDebugEnabled()) {
+				JacobObject.debug("ROT: Automatic GC flag == "
+						+ USE_AUTOMATIC_GARBAGE_COLLECTION);
+			}
+			if (!USE_AUTOMATIC_GARBAGE_COLLECTION) {
+				tab = new HashMap<JacobObject, String>();
+			} else {
+				tab = new WeakHashMap<JacobObject, String>();
+			}
+			rot.set(tab);
+		}
+		return tab;
+	}
+
+	/**
+	 * Returns the pool for this thread if it exists. can create a new one if
+	 * you wish by passing in TRUE
+	 * 
+	 * @param createIfDoesNotExist
+	 * @return Map the collection that holds the objects created in the current
+	 *         thread
+	 */
+	protected synchronized static Map<JacobObject, String> getThreadObjects(
+			boolean createIfDoesNotExist) {
+		Map<JacobObject, String> tab = rot.get();
+		if (tab == null && createIfDoesNotExist) {
+			tab = addThread();
+		}
+		return tab;
+	}
+
+	/**
+	 * Iterates across all of the entries in the Hashmap in the rot that
+	 * corresponds to this thread. This calls safeRelease() on each entry and
+	 * then clears the map when done and removes it from the rot. All traces of
+	 * this thread's objects will disappear. This is called by COMThread in the
+	 * tear down and provides a synchronous way of releasing memory
+	 */
+	protected static void clearObjects() {
+		Map<JacobObject, String> tab = getThreadObjects(false);
+		if (tab != null) {
+			if (JacobObject.isDebugEnabled()) {
+				JacobObject.debug("ROT: " + tab.keySet().size()
+						+ " objects to clear in this thread's ROT ");
+			}
+			// walk the values
+			Iterator<JacobObject> it = tab.keySet().iterator();
+			while (it.hasNext()) {
+				JacobObject o = it.next();
+				if (o != null
+				// can't use this cause creates a Variant if calling SafeAray
+				// and we get an exception modifying the collection while
+				// iterating
+				// && o.toString() != null
+				) {
+					if (JacobObject.isDebugEnabled()) {
+						if (o instanceof SafeArray) {
+							// SafeArray create more objects when calling
+							// toString()
+							// which causes a concurrent modification exception
+							// in HashMap
+							JacobObject.debug("ROT: removing "
+									+ o.getClass().getName());
+						} else {
+							// Variant toString() is probably always bad in here
+							JacobObject.debug("ROT: removing " + o.hashCode()
+									+ "->" + o.getClass().getName());
+						}
+					}
+					o.safeRelease();
+				}
+			}
+			// empty the collection
+			tab.clear();
+			// remove the collection from rot
+			ROT.removeThread();
+			if (JacobObject.isDebugEnabled()) {
+				JacobObject.debug("ROT: thread table cleared and removed");
+			}
+		} else {
+			if (JacobObject.isDebugEnabled()) {
+				JacobObject.debug("ROT: nothing to clear!");
+			}
+		}
+	}
+
+	/**
+	 * Removes the map from the rot that is associated with the current thread.
+	 */
+	private synchronized static void removeThread() {
+		rot.remove();
+	}
+
+	/**
+	 * @deprecated the java model leave the responsibility of clearing up
+	 *             objects to the Garbage Collector. Our programming model
+	 *             should not require that the user specifically remove object
+	 *             from the thread. <br>
+	 *             This will remove an object from the ROT <br>
+	 *             This does not need to be synchronized because only the rot
+	 *             modification related methods need to synchronized. Each
+	 *             individual map is only modified in a single thread.
+	 * @param o
+	 */
+	@Deprecated
+	protected static void removeObject(JacobObject o) {
+		Map<JacobObject, String> tab = ROT.getThreadObjects(false);
+		if (tab != null) {
+			tab.remove(o);
+		}
+		o.safeRelease();
+	}
+
+	/**
+	 * Adds an object to the HashMap for the current thread. <br>
+	 * <p>
+	 * This method does not need to be threaded because the only concurrent
+	 * modification risk is on the hash map that contains all of the thread
+	 * related hash maps. The individual thread related maps are only used on a
+	 * per thread basis so there isn't a locking issue.
+	 * <p>
+	 * In addition, this method cannot be threaded because it calls
+	 * ComThread.InitMTA. The ComThread object has some methods that call ROT so
+	 * we could end up deadlocked. This method should be safe without the
+	 * synchronization because the ROT works on per thread basis and the methods
+	 * that add threads and remove thread related entries are all synchronized
+	 * 
+	 * 
+	 * @param o
+	 */
+	protected static void addObject(JacobObject o) {
+		String shouldIncludeClassInROT = "true";
+		// only call System.getProperty if we are not including all classes in
+		// the ROT. This lets us run with standard Jacob behavior in Applets
+		// without the security exception raised by System.getProperty in the
+		// flow
+		if (!ROT.INCLUDE_ALL_CLASSES_IN_ROT) {
+			shouldIncludeClassInROT = System.getProperty(o.getClass().getName()
+					+ PUT_IN_ROT_SUFFIX, "true");
+		}
+		if (shouldIncludeClassInROT.equalsIgnoreCase("false")) {
+			if (JacobObject.isDebugEnabled()) {
+				JacobObject.debug("JacobObject: New instance of "
+						+ o.getClass().getName() + " not added to ROT");
+			}
+		} else {
+			// first see if we have a table for this thread
+			Map<JacobObject, String> tab = getThreadObjects(false);
+			if (tab == null) {
+				// this thread has not been initialized as a COM thread
+				// so make it part of MTA for backwards compatibility
+				ComThread.InitMTA(false);
+				// don't really need the "true" because the InitMTA will have
+				// called back to the ROT to create a table for this thread
+				tab = getThreadObjects(true);
+			}
+			if (JacobObject.isDebugEnabled()) {
+				JacobObject.debug("ROT: adding " + o + "->"
+						+ o.getClass().getName()
+						+ " table size prior to addition:" + tab.size());
+			}
+			// add the object to the table that is specific to this thread
+			if (tab != null) {
+				tab.put(o, null);
+			}
+		}
+	}
+
+	/**
+	 * ROT can't be a subclass of JacobObject because of the way ROT pools are
+	 * managed so we force a DLL load here by referencing JacobObject
+	 */
+	static {
+		LibraryLoader.loadJacobLibrary();
+	}
+
+}

src/main/java/com/jacob/com/STA.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+/**
+ * A class that implements a Single Threaded Apartment. Users will subclass this
+ * and override OnInit() and OnQuit() where they will create and destroy a COM
+ * component that wants to run in an STA other than the main STA.
+ */
+public class STA extends Thread {
+	/**
+	 * referenced by STA.cpp
+	 */
+	public int threadID;
+
+	/**
+	 * constructor for STA
+	 */
+	public STA() {
+		start(); // start the thread
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Thread#run()
+	 */
+	public void run() {
+		// init COM
+		ComThread.InitSTA();
+		if (OnInit()) {
+			// this call blocks in the win32 message loop
+			// until quitMessagePump is called
+			doMessagePump();
+		}
+		OnQuit();
+		// uninit COM
+		ComThread.Release();
+	}
+
+	/**
+	 * Override this method to create and initialize any COM component that you
+	 * want to run in this thread. If anything fails, return false to terminate
+	 * the thread.
+	 * 
+	 * @return always returns true
+	 */
+	public boolean OnInit() {
+		return true;
+	}
+
+	/**
+	 * Override this method to destroy any resource before the thread exits and
+	 * COM in uninitialized
+	 */
+	public void OnQuit() {
+		// there is nothing to see here
+	}
+
+	/**
+	 * calls quitMessagePump
+	 */
+	public void quit() {
+		quitMessagePump();
+	}
+
+	/**
+	 * run a message pump for the main STA
+	 */
+	public native void doMessagePump();
+
+	/**
+	 * quit message pump for the main STA
+	 */
+	public native void quitMessagePump();
+
+	/**
+	 * STA isn't a subclass of JacobObject so a reference to it doesn't load the
+	 * DLL without this
+	 */
+	static {
+		LibraryLoader.loadJacobLibrary();
+	}
+}

src/main/java/com/jacob/com/VariantUtilities.java

@@ -0,0 +1,502 @@
+/**
+ * 
+ */
+package com.jacob.com;
+
+import java.lang.reflect.Array;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.math.MathContext;
+import java.util.Date;
+
+/**
+ * A utility class used to convert between Java objects and Variants
+ */
+public final class VariantUtilities {
+	private VariantUtilities() {
+		// utility class with only static methods don't need constructors
+	}
+
+	/**
+	 * Populates a variant object from a java object. This method attempts to
+	 * figure out the appropriate Variant type
+	 * 
+	 * @param targetVariant
+	 * @param pValueObject
+	 * @param fByRef
+	 */
+	protected static void populateVariant(Variant targetVariant,
+			Object pValueObject, boolean fByRef) {
+		if (pValueObject == null) {
+			targetVariant.putEmpty();
+		} else if (pValueObject instanceof Integer) {
+			if (fByRef) {
+				targetVariant.putIntRef(((Integer) pValueObject).intValue());
+			} else {
+				targetVariant.putInt(((Integer) pValueObject).intValue());
+			}
+		} else if (pValueObject instanceof Short) {
+			if (fByRef) {
+				targetVariant.putShortRef(((Short) pValueObject).shortValue());
+			} else {
+				targetVariant.putShort(((Short) pValueObject).shortValue());
+			}
+		} else if (pValueObject instanceof String) {
+			if (fByRef) {
+				targetVariant.putStringRef((String) pValueObject);
+			} else {
+				targetVariant.putString((String) pValueObject);
+			}
+		} else if (pValueObject instanceof Boolean) {
+			if (fByRef) {
+				targetVariant.putBooleanRef(((Boolean) pValueObject)
+						.booleanValue());
+			} else {
+				targetVariant.putBoolean(((Boolean) pValueObject)
+						.booleanValue());
+			}
+		} else if (pValueObject instanceof Double) {
+			if (fByRef) {
+				targetVariant.putDoubleRef(((Double) pValueObject)
+						.doubleValue());
+			} else {
+				targetVariant.putDouble(((Double) pValueObject).doubleValue());
+			}
+		} else if (pValueObject instanceof Float) {
+			if (fByRef) {
+				targetVariant.putFloatRef(((Float) pValueObject).floatValue());
+			} else {
+				targetVariant.putFloat(((Float) pValueObject).floatValue());
+			}
+		} else if (pValueObject instanceof BigDecimal) {
+			if (fByRef) {
+				targetVariant.putDecimalRef(((BigDecimal) pValueObject));
+			} else {
+				targetVariant.putDecimal(((BigDecimal) pValueObject));
+			}
+		} else if (pValueObject instanceof Byte) {
+			if (fByRef) {
+				targetVariant.putByteRef(((Byte) pValueObject).byteValue());
+			} else {
+				targetVariant.putByte(((Byte) pValueObject).byteValue());
+			}
+		} else if (pValueObject instanceof Date) {
+			if (fByRef) {
+				targetVariant.putDateRef((Date) pValueObject);
+			} else {
+				targetVariant.putDate((Date) pValueObject);
+			}
+		} else if (pValueObject instanceof Long) {
+			if (fByRef) {
+				targetVariant.putLongRef(((Long) pValueObject).longValue());
+			} else {
+				targetVariant.putLong(((Long) pValueObject).longValue());
+			}
+		} else if (pValueObject instanceof Currency) {
+			if (fByRef) {
+				targetVariant.putCurrencyRef(((Currency) pValueObject));
+			} else {
+				targetVariant.putCurrency(((Currency) pValueObject));
+			}
+		} else if (pValueObject instanceof SafeArray) {
+			if (fByRef) {
+				targetVariant.putSafeArrayRef((SafeArray) pValueObject);
+			} else {
+				targetVariant.putSafeArray((SafeArray) pValueObject);
+			}
+		} else if (pValueObject instanceof Dispatch) {
+			if (fByRef) {
+				targetVariant.putDispatchRef((Dispatch) pValueObject);
+			} else {
+				targetVariant.putDispatch((Dispatch) pValueObject);
+			}
+		} else if (pValueObject instanceof Variant) {
+			// newly added 1.12-pre6 to support VT_VARIANT
+			targetVariant.putVariant(pValueObject);
+		} else {
+			// sourceforge patch 2171967
+			// used to rely on coercion but sometimes crashed VM
+			throw new NotImplementedException(
+					"populateVariant() not implemented for "
+							+ pValueObject.getClass());
+		}
+	}
+
+	/**
+	 * Map arguments based on msdn documentation. This method relies on the
+	 * variant constructor except for arrays.
+	 * 
+	 * @param objectToBeMadeIntoVariant
+	 * @return Variant that represents the object
+	 */
+	protected static Variant objectToVariant(Object objectToBeMadeIntoVariant) {
+		if (objectToBeMadeIntoVariant == null) {
+			return new Variant();
+		} else if (objectToBeMadeIntoVariant instanceof Variant) {
+			// if a variant was passed in then be a slacker and just return it
+			return (Variant) objectToBeMadeIntoVariant;
+		} else if (objectToBeMadeIntoVariant.getClass().isArray()) {
+			// automatically convert arrays using reflection
+			// handle it differently based on the type of array
+			// added primitive support sourceforge 2762275
+			SafeArray sa = null;
+			int len1 = Array.getLength(objectToBeMadeIntoVariant);
+			Class componentType = objectToBeMadeIntoVariant.getClass()
+					.getComponentType();
+
+			if (componentType.isArray()) { // array of arrays
+				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, objectToVariant(Array.get(e1, j)));
+					}
+				}
+			} else if (byte.class.equals(componentType)) {
+				byte[] arr = (byte[]) objectToBeMadeIntoVariant;
+				sa = new SafeArray(Variant.VariantByte, len1);
+				for (int i = 0; i < len1; i++) {
+					sa.setByte(i, arr[i]);
+				}
+			} else if (int.class.equals(componentType)) {
+				int[] arr = (int[]) objectToBeMadeIntoVariant;
+				sa = new SafeArray(Variant.VariantInt, len1);
+				for (int i = 0; i < len1; i++) {
+					sa.setInt(i, arr[i]);
+				}
+			} else if (double.class.equals(componentType)) {
+				double[] arr = (double[]) objectToBeMadeIntoVariant;
+				sa = new SafeArray(Variant.VariantDouble, len1);
+				for (int i = 0; i < len1; i++) {
+					sa.setDouble(i, arr[i]);
+				}
+			} else if (long.class.equals(componentType)) {
+				long[] arr = (long[]) objectToBeMadeIntoVariant;
+				sa = new SafeArray(Variant.VariantLongInt, len1);
+				for (int i = 0; i < len1; i++) {
+					sa.setLong(i, arr[i]);
+				}
+			} else {
+				// array of object
+				sa = new SafeArray(Variant.VariantVariant, len1);
+				for (int i = 0; i < len1; i++) {
+					sa.setVariant(i, objectToVariant(Array.get(
+							objectToBeMadeIntoVariant, i)));
+				}
+			}
+			Variant returnVariant = new Variant();
+			populateVariant(returnVariant, sa, false);
+			return returnVariant;
+		} else {
+			// rely on populateVariant to throw an exception if its an
+			// invalid type
+			Variant returnVariant = new Variant();
+			populateVariant(returnVariant, objectToBeMadeIntoVariant, false);
+			return returnVariant;
+		}
+	}
+
+	/**
+	 * converts an array of objects into an array of Variants by repeatedly
+	 * calling obj2Variant(Object)
+	 * 
+	 * @param arrayOfObjectsToBeConverted
+	 * @return Variant[]
+	 */
+	protected static Variant[] objectsToVariants(
+			Object[] arrayOfObjectsToBeConverted) {
+		if (arrayOfObjectsToBeConverted instanceof Variant[]) {
+			// just return the passed in array if it is a Variant array
+			return (Variant[]) arrayOfObjectsToBeConverted;
+		} else {
+			Variant vArg[] = new Variant[arrayOfObjectsToBeConverted.length];
+			for (int i = 0; i < arrayOfObjectsToBeConverted.length; i++) {
+				vArg[i] = objectToVariant(arrayOfObjectsToBeConverted[i]);
+			}
+			return vArg;
+		}
+	}
+
+	/**
+	 * Convert a JACOB Variant value to a Java object (type conversions).
+	 * provided in Sourceforge feature request 959381. A fix was done to handle
+	 * byRef bug report 1607878.
+	 * <p>
+	 * Unlike other toXXX() methods, it does not do a type conversion except for
+	 * special data types (it shouldn't do any!)
+	 * <p>
+	 * Converts Variant.VariantArray types to SafeArrays
+	 * 
+	 * @return Corresponding Java object of the type matching the Variant type.
+	 * @throws IllegalStateException
+	 *             if no underlying windows data structure
+	 * @throws NotImplementedException
+	 *             if unsupported conversion is requested
+	 * @throws JacobException
+	 *             if the calculated result was a JacobObject usually as a
+	 *             result of error
+	 */
+	protected static Object variantToObject(Variant sourceData) {
+		Object result = null;
+
+		short type = sourceData.getvt(); // variant type
+
+		if ((type & Variant.VariantArray) == Variant.VariantArray) { // array
+			// returned?
+			SafeArray array = null;
+			type = (short) (type - Variant.VariantArray);
+			// From SF Bug 1840487
+			// This did call toSafeArray(false) but that meant
+			// this was the only variantToObject() that didn't have its own
+			// copy of the data so you would end up with weird run time
+			// errors after some GC. So now we just get stupid about it and
+			// always make a copy just like toSafeArray() does.
+			array = sourceData.toSafeArray();
+			result = array;
+		} else { // non-array object returned
+			switch (type) {
+			case Variant.VariantEmpty: // 0
+			case Variant.VariantNull: // 1
+				break;
+			case Variant.VariantShort: // 2
+				result = new Short(sourceData.getShort());
+				break;
+			case Variant.VariantShort | Variant.VariantByref: // 2
+				result = new Short(sourceData.getShortRef());
+				break;
+			case Variant.VariantInt: // 3
+				result = new Integer(sourceData.getInt());
+				break;
+			case Variant.VariantInt | Variant.VariantByref: // 3
+				result = new Integer(sourceData.getIntRef());
+				break;
+			case Variant.VariantFloat: // 4
+				result = new Float(sourceData.getFloat());
+				break;
+			case Variant.VariantFloat | Variant.VariantByref: // 4
+				result = new Float(sourceData.getFloatRef());
+				break;
+			case Variant.VariantDouble: // 5
+				result = new Double(sourceData.getDouble());
+				break;
+			case Variant.VariantDouble | Variant.VariantByref: // 5
+				result = new Double(sourceData.getDoubleRef());
+				break;
+			case Variant.VariantCurrency: // 6
+				result = sourceData.getCurrency();
+				break;
+			case Variant.VariantCurrency | Variant.VariantByref: // 6
+				result = sourceData.getCurrencyRef();
+				break;
+			case Variant.VariantDate: // 7
+				result = sourceData.getJavaDate();
+				break;
+			case Variant.VariantDate | Variant.VariantByref: // 7
+				result = sourceData.getJavaDateRef();
+				break;
+			case Variant.VariantString: // 8
+				result = sourceData.getString();
+				break;
+			case Variant.VariantString | Variant.VariantByref: // 8
+				result = sourceData.getStringRef();
+				break;
+			case Variant.VariantDispatch: // 9
+				result = sourceData.getDispatch();
+				break;
+			case Variant.VariantDispatch | Variant.VariantByref: // 9
+				result = sourceData.getDispatchRef(); // Can dispatches even
+				// be byRef?
+				break;
+			case Variant.VariantError: // 10
+				result = new NotImplementedException(
+						"toJavaObject() Not implemented for VariantError");
+				break;
+			case Variant.VariantBoolean: // 11
+				result = new Boolean(sourceData.getBoolean());
+				break;
+			case Variant.VariantBoolean | Variant.VariantByref: // 11
+				result = new Boolean(sourceData.getBooleanRef());
+				break;
+			case Variant.VariantVariant: // 12 they are always by ref
+				result = new NotImplementedException(
+						"toJavaObject() Not implemented for VariantVariant without ByRef");
+				break;
+			case Variant.VariantVariant | Variant.VariantByref: // 12
+				result = sourceData.getVariant();
+				break;
+			case Variant.VariantObject: // 13
+				result = new NotImplementedException(
+						"toJavaObject() Not implemented for VariantObject");
+				break;
+			case Variant.VariantDecimal: // 14
+				result = sourceData.getDecimal();
+				break;
+			case Variant.VariantDecimal | Variant.VariantByref: // 14
+				result = sourceData.getDecimalRef();
+				break;
+			case Variant.VariantByte: // 17
+				result = new Byte(sourceData.getByte());
+				break;
+			case Variant.VariantByte | Variant.VariantByref: // 17
+				result = new Byte(sourceData.getByteRef());
+				break;
+			case Variant.VariantLongInt: // 20
+				result = new Long(sourceData.getLong());
+				break;
+			case Variant.VariantLongInt | Variant.VariantByref: // 20
+				result = new Long(sourceData.getLongRef());
+				break;
+			case Variant.VariantTypeMask: // 4095
+				result = new NotImplementedException(
+						"toJavaObject() Not implemented for VariantBstrBlob/VariantTypeMask");
+				break;
+			case Variant.VariantArray: // 8192
+				result = new NotImplementedException(
+						"toJavaObject() Not implemented for VariantArray");
+				break;
+			case Variant.VariantByref: // 16384
+				result = new NotImplementedException(
+						"toJavaObject() Not implemented for VariantByref");
+				break;
+			default:
+				result = new NotImplementedException("Unknown return type: "
+						+ type);
+				// there was a "return result" here that caused defect 1602118
+				// so it was removed
+				break;
+			}// switch (type)
+
+			if (result instanceof JacobException) {
+				throw (JacobException) result;
+			}
+		}
+
+		return result;
+	}// toJava()
+
+	/**
+	 * Verifies that we have a scale 0 <= x <= 28 and now more than 96 bits of
+	 * data. The roundToMSDecimal method will attempt to adjust a BigDecimal to
+	 * pass this set of tests
+	 * 
+	 * @param in
+	 * @throws IllegalArgumentException
+	 *             if out of bounds
+	 */
+	protected static void validateDecimalScaleAndBits(BigDecimal in) {
+		BigInteger allWordBigInt = in.unscaledValue();
+		if (in.scale() > 28) {
+			// should this cast to a string and call putStringRef()?
+			throw new IllegalArgumentException(
+					"VT_DECIMAL only supports a maximum scale of 28 and the passed"
+							+ " in value has a scale of " + in.scale());
+		} else if (in.scale() < 0) {
+			// should this cast to a string and call putStringRef()?
+			throw new IllegalArgumentException(
+					"VT_DECIMAL only supports a minimum scale of 0 and the passed"
+							+ " in value has a scale of " + in.scale());
+		} else if (allWordBigInt.bitLength() > 12 * 8) {
+			throw new IllegalArgumentException(
+					"VT_DECIMAL supports a maximum of "
+							+ 12
+							* 8
+							+ " bits not counting scale and the number passed in has "
+							+ allWordBigInt.bitLength());
+
+		} else {
+			// no bounds problem to be handled
+		}
+
+	}
+
+	/**
+	 * Largest possible number with scale set to 0
+	 */
+	private static final BigDecimal LARGEST_DECIMAL = new BigDecimal(
+			new BigInteger("ffffffffffffffffffffffff", 16));
+	/**
+	 * Smallest possible number with scale set to 0. MS doesn't support negative
+	 * scales like BigDecimal.
+	 */
+	private static final BigDecimal SMALLEST_DECIMAL = new BigDecimal(
+			new BigInteger("ffffffffffffffffffffffff", 16).negate());
+
+	/**
+	 * Does any validation that couldn't have been fixed by rounding or scale
+	 * modification.
+	 * 
+	 * @param in
+	 *            The BigDecimal to be validated
+	 * @throws IllegalArgumentException
+	 *             if the number is too large or too small or null
+	 */
+	protected static void validateDecimalMinMax(BigDecimal in) {
+		if (in == null) {
+			throw new IllegalArgumentException(
+					"null is not a supported Decimal value.");
+		} else if (LARGEST_DECIMAL.compareTo(in) < 0) {
+			throw new IllegalArgumentException(
+					"Value too large for VT_DECIMAL data type:" + in.toString()
+							+ " integer: " + in.toBigInteger().toString(16)
+							+ " scale: " + in.scale());
+		} else if (SMALLEST_DECIMAL.compareTo(in) > 0) {
+			throw new IllegalArgumentException(
+					"Value too small for VT_DECIMAL data type:" + in.toString()
+							+ " integer: " + in.toBigInteger().toString(16)
+							+ " scale: " + in.scale());
+		}
+
+	}
+
+	/**
+	 * Rounds the scale and bit length so that it will pass
+	 * validateDecimalScaleBits(). Developers should call this method if they
+	 * really want MS Decimal and don't want to lose precision.
+	 * <p>
+	 * Changing the scale on a number that can fit in an MS Decimal can change
+	 * the number's representation enough that it will round to a number too
+	 * large to be represented by an MS VT_DECIMAL
+	 * 
+	 * @param sourceDecimal
+	 * @return BigDecimal a new big decimal that was rounded to fit in an MS
+	 *         VT_DECIMAL
+	 */
+	public static BigDecimal roundToMSDecimal(BigDecimal sourceDecimal) {
+		BigInteger sourceDecimalIntComponent = sourceDecimal.unscaledValue();
+		BigDecimal destinationDecimal = new BigDecimal(
+				sourceDecimalIntComponent, sourceDecimal.scale());
+		int roundingModel = BigDecimal.ROUND_HALF_UP;
+		validateDecimalMinMax(destinationDecimal);
+		// First limit the number of digits and then the precision.
+		// Try and round to 29 digits because we can sometimes do that
+		BigInteger allWordBigInt;
+		allWordBigInt = destinationDecimal.unscaledValue();
+		if (allWordBigInt.bitLength() > 96) {
+			destinationDecimal = destinationDecimal.round(new MathContext(29));
+			// see if 29 digits uses more than 96 bits
+			if (allWordBigInt.bitLength() > 96) {
+				// Dang. It was over 97 bits so shorten it one more digit to
+				// stay <= 96 bits
+				destinationDecimal = destinationDecimal.round(new MathContext(
+						28));
+			}
+		}
+		// the bit manipulations above may change the scale so do it afterwards
+		// round the scale to the max MS can support
+		if (destinationDecimal.scale() > 28) {
+			destinationDecimal = destinationDecimal.setScale(28, roundingModel);
+		}
+		if (destinationDecimal.scale() < 0) {
+			destinationDecimal = destinationDecimal.setScale(0, roundingModel);
+		}
+		return destinationDecimal;
+	}
+}

src/main/java/com/jacob/com/VariantViaEvent.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+/**
+ * a public class to variant that is used to track which variant objects are
+ * created by event callbacks This is solely used for that purpose.
+ */
+public class VariantViaEvent extends Variant {
+
+	/**
+	 * Standard constructor used by JNI event handling layer
+	 */
+	public VariantViaEvent() {
+		super();
+	}
+}

src/main/java/com/jacob/com/WrongThreadException.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.jacob.com;
+
+/**
+ * thrown in util.cpp
+ */
+public class WrongThreadException extends JacobException {
+	/**
+	 * identifier generated by Eclipse
+	 */
+	private static final long serialVersionUID = 6308780364980228692L;
+
+	/**
+	 * standard 0 arg constructor with no message
+	 * 
+	 */
+	public WrongThreadException() {
+		super("No Message Provided.");
+	}
+
+	/**
+	 * standard constructor with a string message
+	 * 
+	 * @param s
+	 */
+	public WrongThreadException(String s) {
+		super(s);
+	}
+}