c/jacob/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();
+}
+
+}

c/jacob/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

c/jacob/Dispatch.cpp

@@ -0,0 +1,582 @@
+/*
+ * 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, "I");
+  jint anum = env->GetIntField(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>", "(I)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, "I");
+
+  // 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->SetIntField(_this, jf, (unsigned int)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, "I");
+
+  // 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->SetIntField(_this, jf, (unsigned int)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, "I");
+
+  // 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->SetIntField(_this, jf, (unsigned int)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, "I");
+  jint num = env->GetIntField(_this, jf);
+
+  IDispatch *disp = (IDispatch *)num;
+  if (disp) {
+    disp->Release();
+    env->SetIntField(_this, jf, (unsigned int)0);
+  }
+}
+
+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);
+  }
+
+  return msg;
+}
+
+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;
+	}
+}
+
+}
+
+

c/jacob/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

c/jacob/DispatchEvents.cpp

@@ -0,0 +1,370 @@
+/*
+ * 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, "I");
+  jint anum = env->GetIntField(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, "I");
+  jint anum = env->GetIntField(arg, ajf);
+  env->SetIntField(arg, ajf, (jint)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) {
+  	// 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;
+  }
+}
+
+}

c/jacob/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
+
+

c/jacob/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", "I");
+  jint anum = env->GetIntField(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", "I");
+  env->SetIntField(_this, ajf, (jint)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", "I");
+  env->SetIntField(_this, ajf, (unsigned int)0);
+
+  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>", "(I)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", "I");
+    env->SetIntField(_this, ajf, (unsigned int)0);
+  }
+}
+
+}

c/jacob/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

c/jacob/EnumVariant.cpp

@@ -0,0 +1,131 @@
+/*
+ * 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", "I");
+  return (IEnumVARIANT*)env->GetIntField(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));
+  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", "I");
+    env->SetIntField(_this, FID_pIEnumVARIANT, (unsigned int)0);
+  }
+}
+
+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);
+}
+
+}

c/jacob/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

c/jacob/EventProxy.cpp

@@ -0,0 +1,870 @@
+/*
+ * 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;
+    ThrowComFail(env, "Advise failed", 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) {
+        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
+		//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;
+		}
+
+
+    }
+}

c/jacob/EventProxy.h

@@ -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
+ */
+#include <jni.h>
+#include <windows.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);
+  void Disconnect();
+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 *);
+};

c/jacob/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);
+}
+
+}

c/jacob/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

c/jacob/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

c/jacob/StdAfx.h

@@ -0,0 +1,51 @@
+/*
+ * 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
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0400
+#endif
+//#define _ATL_APARTMENT_THREADED
+#include <windows.h>
+#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)

c/jacob/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 jint 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

c/jacob/include/atlalloc.h

@@ -0,0 +1,764 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the
+// Active Template Library product.
+
+#pragma once
+#ifndef __ATLALLOC_H__
+#define __ATLALLOC_H__
+#endif
+
+#include <windows.h>
+#include <ole2.h>
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+
+/* 
+This is	more than a	little unsatisfying. /Wp64 warns when we convert a size_t to an	int
+because	it knows such a	conversion won't port. 
+But, when we have overloaded templates,	there may well exist both conversions and we need 
+to fool	the	warning	into not firing	on 32 bit builds
+*/
+#if !defined(_ATL_W64)
+#if !defined(__midl) &&	(defined(_X86_)	|| defined(_M_IX86))
+#define	_ATL_W64 __w64
+#else
+#define	_ATL_W64
+#endif
+#endif
+
+/* Can't use ::std::numeric_limits<T> here because we don't want to introduce a new	
+   deprendency of this code on SCL
+*/
+
+template<typename T>
+class AtlLimits;
+
+template<>
+class AtlLimits<int _ATL_W64>
+{
+public:
+	static const int _Min=INT_MIN;
+	static const int _Max=INT_MAX;
+};
+
+template<>
+class AtlLimits<unsigned int _ATL_W64>
+{
+public:
+	static const unsigned int _Min=0;
+	static const unsigned int _Max=UINT_MAX;
+};
+
+template<>
+class AtlLimits<long _ATL_W64>
+{
+public:
+	static const long _Min=LONG_MIN;
+	static const long _Max=LONG_MAX;
+};
+
+template<>
+class AtlLimits<unsigned long _ATL_W64>
+{
+public:
+	static const unsigned long _Min=0;
+	static const unsigned long _Max=ULONG_MAX;
+};
+
+template<>
+class AtlLimits<long long>
+{
+public:
+	static const long long _Min=LLONG_MIN;
+	static const long long _Max=LLONG_MAX;
+};
+
+template<>
+class AtlLimits<unsigned long long>
+{
+public:
+	static const unsigned long long _Min=0;
+	static const unsigned long long _Max=ULLONG_MAX;
+};
+
+/* generic version */
+template<typename T>
+inline HRESULT AtlAdd(T* ptResult, T tLeft, T tRight)
+{
+	if(::ATL::AtlLimits<T>::_Max-tLeft < tRight)
+	{
+		return E_INVALIDARG;
+	}
+	*ptResult= tLeft + tRight;
+	return S_OK;
+}
+
+/* generic but compariatively slow version */
+template<typename T>
+inline HRESULT AtlMultiply(T* ptResult,	T tLeft, T tRight)
+{
+	/* avoid divide 0 */
+	if(tLeft==0)
+	{
+		*ptResult=0;
+		return S_OK;
+	}
+	if(::ATL::AtlLimits<T>::_Max/tLeft < tRight)
+	{
+		return E_INVALIDARG;
+	}
+	*ptResult= tLeft * tRight;
+	return S_OK;
+}
+
+/* fast	version	for	32 bit integers	*/
+template<>
+inline HRESULT AtlMultiply(int _ATL_W64	*piResult, int _ATL_W64	iLeft, int _ATL_W64 iRight)
+{
+	__int64 i64Result=static_cast<__int64>(iLeft) * static_cast<__int64>(iRight);
+	if(i64Result>INT_MAX || i64Result < INT_MIN)
+	{
+		return E_INVALIDARG;
+	}
+	*piResult=static_cast<int _ATL_W64>(i64Result);
+	return S_OK;
+}
+
+template<>
+inline HRESULT AtlMultiply(unsigned int	_ATL_W64 *piResult, unsigned int _ATL_W64 iLeft, unsigned int _ATL_W64 iRight)
+{
+	unsigned __int64 i64Result=static_cast<unsigned __int64>(iLeft) * static_cast<unsigned __int64>(iRight);
+	if(i64Result>UINT_MAX)
+	{
+		return E_INVALIDARG;
+	}
+	*piResult=static_cast<unsigned int _ATL_W64>(i64Result);
+	return S_OK;
+}
+
+template<>
+inline HRESULT AtlMultiply(long	_ATL_W64 *piResult, long _ATL_W64 iLeft, long _ATL_W64 iRight)
+{
+	__int64 i64Result=static_cast<__int64>(iLeft) * static_cast<__int64>(iRight);
+	if(i64Result>LONG_MAX || i64Result < LONG_MIN)
+	{
+		return E_INVALIDARG;
+	}
+	*piResult=static_cast<long _ATL_W64>(i64Result);
+	return S_OK;
+}
+
+template<>
+inline HRESULT AtlMultiply(unsigned long _ATL_W64 *piResult, unsigned long _ATL_W64 iLeft, unsigned long _ATL_W64 iRight)
+{
+	unsigned __int64 i64Result=static_cast<unsigned __int64>(iLeft) * static_cast<unsigned __int64>(iRight);
+	if(i64Result>ULONG_MAX)
+	{
+		return E_INVALIDARG;
+	}
+	*piResult=static_cast<unsigned long _ATL_W64>(i64Result);
+	return S_OK;
+}
+
+template <typename T>
+inline T AtlMultiplyThrow(T tLeft, T tRight)
+{
+	T tResult;
+	HRESULT hr=AtlMultiply(&tResult, tLeft, tRight);
+	if(FAILED(hr))
+	{
+		AtlThrow(hr);
+	}
+	return tResult;
+}
+
+template <typename T>
+inline T AtlAddThrow(T tLeft, T	tRight)
+{
+	T tResult;
+	HRESULT hr=AtlAdd(&tResult, tLeft, tRight);
+	if(FAILED(hr))
+	{
+		AtlThrow(hr);
+	}
+	return tResult;
+}
+
+inline LPVOID AtlCoTaskMemCAlloc(ULONG nCount, ULONG nSize)
+{
+	HRESULT hr;
+	ULONG nBytes=0;
+	if( FAILED(hr=::ATL::AtlMultiply(&nBytes, nCount, nSize)))
+	{
+		return NULL;
+	}
+	return ::CoTaskMemAlloc(nBytes);
+}
+
+inline LPVOID AtlCoTaskMemRecalloc(void	*pvMemory, ULONG nCount, ULONG nSize)
+{
+	HRESULT hr;
+	ULONG nBytes=0;
+	if( FAILED(hr=::ATL::AtlMultiply(&nBytes, nCount, nSize)))
+	{
+		return NULL;
+	}
+	return ::CoTaskMemRealloc(pvMemory, nBytes);
+}
+
+}	// namespace ATL
+#pragma pack(pop)
+
+#pragma pack(push,8)
+namespace ATL
+{
+// forward declaration of Checked::memcpy_s
+
+namespace Checked
+{
+    void __cdecl memcpy_s(__out_bcount_part(s1max,n) void *s1, __in size_t s1max, __in_bcount(n) const void *s2, __in size_t n);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Allocation helpers
+
+class CCRTAllocator 
+{
+public:
+	static void* Reallocate(void* p, size_t nBytes) throw()
+	{
+		return realloc(p, nBytes);
+	}
+
+	static void* Allocate(size_t nBytes) throw()
+	{
+		return malloc(nBytes);
+	}
+
+	static void Free(void* p) throw()
+	{
+		free(p);
+	}
+};
+
+class CLocalAllocator
+{
+public:
+	static void* Allocate(size_t nBytes) throw()
+	{
+		return ::LocalAlloc(LMEM_FIXED, nBytes);
+	}
+	static void* Reallocate(void* p, size_t nBytes) throw()
+	{
+		if (p==NULL){
+			return ( Allocate(nBytes) );
+		
+		}
+		if (nBytes==0){
+			Free(p);
+			return NULL;
+		}
+			return ::LocalReAlloc(p, nBytes, 0);
+		 
+	}
+	static void Free(void* p) throw()
+	{
+		::LocalFree(p);
+	}
+};
+
+class CGlobalAllocator
+{
+public:
+	static void* Allocate(size_t nBytes) throw()
+	{
+		return ::GlobalAlloc(GMEM_FIXED, nBytes);
+	}
+	static void* Reallocate(void* p, size_t nBytes) throw()
+	{
+		if (p==NULL){
+			return ( Allocate(nBytes) );
+		
+		}
+		if (nBytes==0){
+			Free(p);
+			return NULL;
+		}
+		return ( ::GlobalReAlloc(p, nBytes, 0) );
+	}
+	static void Free(void* p) throw()
+	{
+		::GlobalFree(p);
+	}
+};
+
+template <class T, class Allocator = CCRTAllocator>
+class CHeapPtrBase
+{
+protected:
+	CHeapPtrBase() throw() :
+		m_pData(NULL)
+	{
+	}
+	CHeapPtrBase(CHeapPtrBase<T, Allocator>& p) throw()
+	{
+		m_pData = p.Detach();  // Transfer ownership
+	}
+	explicit CHeapPtrBase(T* pData) throw() :
+		m_pData(pData)
+	{
+	}
+
+public:
+	~CHeapPtrBase() throw()
+	{
+		Free();
+	}
+
+protected:
+	CHeapPtrBase<T, Allocator>& operator=(CHeapPtrBase<T, Allocator>& p) throw()
+	{
+		if(m_pData != p.m_pData)
+			Attach(p.Detach());  // Transfer ownership
+		return *this;
+	}
+
+public:
+	operator T*() const throw()
+	{
+		return m_pData;
+	}
+
+	T* operator->() const throw()
+	{
+		ATLASSERT(m_pData != NULL);
+		return m_pData;
+	}
+
+	T** operator&() throw()
+	{
+#if defined(ATLASSUME)
+		ATLASSUME(m_pData == NULL);
+#endif
+		return &m_pData;
+	}
+
+	// Allocate a buffer with the given number of bytes
+	bool AllocateBytes(size_t nBytes) throw()
+	{
+		ATLASSERT(m_pData == NULL);
+		m_pData = static_cast<T*>(Allocator::Allocate(nBytes));
+		if (m_pData == NULL)
+			return false;
+
+		return true;
+	}
+
+	// Attach to an existing pointer (takes ownership)
+	void Attach(T* pData) throw()
+	{
+		Allocator::Free(m_pData);
+		m_pData = pData;
+	}
+
+	// Detach the pointer (releases ownership)
+	T* Detach() throw() 
+	{
+		T* pTemp = m_pData;
+		m_pData = NULL;
+		return pTemp;
+	}
+
+	// Free the memory pointed to, and set the pointer to NULL
+	void Free() throw()
+	{
+		Allocator::Free(m_pData);
+		m_pData = NULL;
+	}
+
+	// Reallocate the buffer to hold a given number of bytes
+	bool ReallocateBytes(size_t nBytes) throw()
+	{
+		T* pNew;
+
+		pNew = static_cast<T*>(Allocator::Reallocate(m_pData, nBytes));
+		if (pNew == NULL)
+			return false;
+		m_pData = pNew;
+
+		return true;
+	}
+
+public:
+	T* m_pData;
+};
+
+template <typename T, class Allocator = CCRTAllocator>
+class CHeapPtr :
+	public CHeapPtrBase<T, Allocator>
+{
+public:
+	CHeapPtr() throw()
+	{
+	}
+	CHeapPtr(CHeapPtr<T, Allocator>& p) throw() :
+		CHeapPtrBase<T, Allocator>(p)
+	{
+	}
+	explicit CHeapPtr(T* p) throw() :
+		CHeapPtrBase<T, Allocator>(p)
+	{
+	}
+
+	CHeapPtr<T, Allocator>& operator=(CHeapPtr<T, Allocator>& p) throw()
+	{
+		CHeapPtrBase<T, Allocator>::operator=(p);
+
+		return *this;
+	}
+
+	// Allocate a buffer with the given number of elements
+	bool Allocate(size_t nElements = 1) throw()
+	{
+		size_t nBytes=0;
+		if(FAILED(::ATL::AtlMultiply(&nBytes, nElements, sizeof(T))))
+		{
+			return false;
+		}
+		return AllocateBytes(nBytes);
+	}
+
+	// Reallocate the buffer to hold a given number of elements
+	bool Reallocate(size_t nElements) throw()
+	{
+		size_t nBytes=0;
+		if(FAILED(::ATL::AtlMultiply(&nBytes, nElements, sizeof(T))))
+		{
+			return false;
+		}
+		return ReallocateBytes(nBytes);
+	}
+};
+
+template< typename T, int t_nFixedBytes = 128, class Allocator = CCRTAllocator >
+class CTempBuffer
+{
+public:
+	CTempBuffer() throw() :
+		m_p( NULL )
+	{
+	}
+	CTempBuffer( size_t nElements ) throw( ... ) :
+		m_p( NULL )
+	{
+		Allocate( nElements );
+	}
+
+	~CTempBuffer() throw()
+	{
+		if( m_p != reinterpret_cast< T* >( m_abFixedBuffer ) )
+		{
+			FreeHeap();
+		}
+	}
+
+	operator T*() const throw()
+	{
+		return( m_p );
+	}
+	T* operator->() const throw()
+	{
+		ATLASSERT( m_p != NULL );
+		return( m_p );
+	}
+
+	T* Allocate( size_t nElements ) throw( ... )
+	{
+		return( AllocateBytes( ::ATL::AtlMultiplyThrow(nElements,sizeof( T )) ) );
+	}
+
+	T* Reallocate( size_t nElements ) throw( ... )
+	{
+		ATLENSURE(nElements < size_t(-1)/sizeof(T) );		
+		size_t nNewSize = nElements*sizeof( T ) ;
+				
+		if (m_p == NULL)
+			return AllocateBytes(nNewSize);
+
+		if (nNewSize > t_nFixedBytes)
+		{
+			if( m_p == reinterpret_cast< T* >( m_abFixedBuffer ) )
+			{
+				// We have to allocate from the heap and copy the contents into the new buffer
+				AllocateHeap(nNewSize);
+				Checked::memcpy_s(m_p, nNewSize, m_abFixedBuffer, t_nFixedBytes);
+			}
+			else
+			{
+				ReAllocateHeap( nNewSize );
+			}
+		}
+		else
+		{
+			m_p = reinterpret_cast< T* >( m_abFixedBuffer );
+		}
+
+		return m_p;
+	}
+
+	T* AllocateBytes( size_t nBytes )
+	{
+		ATLASSERT( m_p == NULL );
+		if( nBytes > t_nFixedBytes )
+		{
+			AllocateHeap( nBytes );
+		}
+		else
+		{
+			m_p = reinterpret_cast< T* >( m_abFixedBuffer );
+		}
+
+		return( m_p );
+	}
+
+private:
+	ATL_NOINLINE void AllocateHeap( size_t nBytes )
+	{
+		T* p = static_cast< T* >( Allocator::Allocate( nBytes ) );
+		if( p == NULL )
+		{
+			AtlThrow( E_OUTOFMEMORY );
+		}
+		m_p = p;
+	}
+ 
+	ATL_NOINLINE void ReAllocateHeap( size_t nNewSize)
+	{
+		T* p = static_cast< T* >( Allocator::Reallocate(m_p, nNewSize) );
+		if ( p == NULL )
+		{
+			AtlThrow( E_OUTOFMEMORY );
+		}
+		m_p = p;
+	}
+
+	ATL_NOINLINE void FreeHeap() throw()
+	{
+		Allocator::Free( m_p );
+	}
+
+private:
+	T* m_p;
+	BYTE m_abFixedBuffer[t_nFixedBytes];
+};
+
+
+// Allocating memory on the stack without causing stack overflow.
+// Only use these through the _ATL_SAFE_ALLOCA_* macros
+namespace _ATL_SAFE_ALLOCA_IMPL
+{
+
+#ifndef _ATL_STACK_MARGIN
+#if defined(_M_IX86)
+#define _ATL_STACK_MARGIN	0x2000	// Minimum stack available after call to _ATL_SAFE_ALLOCA
+#else //_M_AMD64 _M_IA64
+#define _ATL_STACK_MARGIN	0x4000
+#endif
+#endif //_ATL_STACK_MARGIN
+
+//Verifies if sufficient space is available on the stack.
+//Note: This function should never be inlined, because the stack allocation
+//may not be freed until the end of the calling function (instead of the end of _AtlVerifyStackAvailable).
+//The use of __try/__except preverts inlining in this case.
+#if (_ATL_VER > 0x0301)
+inline bool _AtlVerifyStackAvailable(SIZE_T Size)
+{
+    bool bStackAvailable = true;
+
+    __try
+    {
+		SIZE_T size=0;
+		HRESULT hrAdd=::ATL::AtlAdd(&size, Size, static_cast<SIZE_T>(_ATL_STACK_MARGIN));
+		if(FAILED(hrAdd))
+		{
+			ATLASSERT(FALSE);
+			bStackAvailable = false;
+		}
+		else
+		{
+			PVOID p = _alloca(size);
+			if (p)
+			{
+				(p);
+			}
+		}
+    }
+    __except ((EXCEPTION_STACK_OVERFLOW == GetExceptionCode()) ?
+                   EXCEPTION_EXECUTE_HANDLER :
+                   EXCEPTION_CONTINUE_SEARCH)
+    {
+        bStackAvailable = false;
+        _resetstkoflw();
+    }
+    return bStackAvailable;
+}
+
+
+// Helper Classes to manage heap buffers for _ATL_SAFE_ALLOCA
+template < class Allocator>
+class CAtlSafeAllocBufferManager
+{
+private :
+	struct CAtlSafeAllocBufferNode
+	{
+		CAtlSafeAllocBufferNode* m_pNext;
+#if defined(_M_IX86)
+		BYTE _pad[4];
+#elif defined(_M_IA64)
+		BYTE _pad[8];
+#elif defined(_M_AMD64)
+		BYTE _pad[8];
+#else
+	#error Only supported for X86, AMD64 and IA64
+#endif
+		void* GetData()
+		{
+			return (this + 1);
+		}
+	};
+
+	CAtlSafeAllocBufferNode* m_pHead;
+public :
+	
+	CAtlSafeAllocBufferManager() : m_pHead(NULL) {};
+	void* Allocate(SIZE_T nRequestedSize)
+	{
+		CAtlSafeAllocBufferNode *p = (CAtlSafeAllocBufferNode*)Allocator::Allocate(::ATL::AtlAddThrow(nRequestedSize, static_cast<SIZE_T>(sizeof(CAtlSafeAllocBufferNode))));
+		if (p == NULL)
+			return NULL;
+		
+		// Add buffer to the list
+		p->m_pNext = m_pHead;
+		m_pHead = p;
+		
+		return p->GetData();
+	}
+	~CAtlSafeAllocBufferManager()
+	{
+		// Walk the list and free the buffers
+		while (m_pHead != NULL)
+		{
+			CAtlSafeAllocBufferNode* p = m_pHead;
+			m_pHead = m_pHead->m_pNext;
+			Allocator::Free(p);
+		}
+	}
+};
+#endif
+
+}	// namespace _ATL_SAFE_ALLOCA_IMPL
+
+}	// namespace ATL
+ #pragma pack(pop)
+
+// Use one of the following macros before using _ATL_SAFE_ALLOCA
+// EX version allows specifying a different heap allocator
+#define USES_ATL_SAFE_ALLOCA_EX(x)    ATL::_ATL_SAFE_ALLOCA_IMPL::CAtlSafeAllocBufferManager<x> _AtlSafeAllocaManager
+
+#ifndef USES_ATL_SAFE_ALLOCA
+#define USES_ATL_SAFE_ALLOCA		USES_ATL_SAFE_ALLOCA_EX(ATL::CCRTAllocator)
+#endif
+
+// nRequestedSize - requested size in bytes 
+// nThreshold - size in bytes beyond which memory is allocated from the heap.
+
+#if (_ATL_VER > 0x0301)
+
+// Defining _ATL_SAFE_ALLOCA_ALWAYS_ALLOCATE_THRESHOLD_SIZE always allocates the size specified
+// for threshold if the stack space is available irrespective of requested size.
+// This available for testing purposes. It will help determine the max stack usage due to _alloca's
+// Disable _alloca not within try-except prefast warning since we verify stack space is available before.
+#ifdef _ATL_SAFE_ALLOCA_ALWAYS_ALLOCATE_THRESHOLD_SIZE
+#define _ATL_SAFE_ALLOCA(nRequestedSize, nThreshold)	\
+	__pragma(warning(push))\
+	__pragma(warning(disable:4616))\
+	__pragma(warning(disable:6255))\
+	((nRequestedSize <= nThreshold && ATL::_ATL_SAFE_ALLOCA_IMPL::_AtlVerifyStackAvailable(nThreshold) ) ?	\
+		_alloca(nThreshold) :	\
+		((ATL::_ATL_SAFE_ALLOCA_IMPL::_AtlVerifyStackAvailable(nThreshold)) ? _alloca(nThreshold) : 0),	\
+			_AtlSafeAllocaManager.Allocate(nRequestedSize))\
+	__pragma(warning(pop))
+#else
+#define _ATL_SAFE_ALLOCA(nRequestedSize, nThreshold)	\
+	__pragma(warning(push))\
+	__pragma(warning(disable:4616))\
+	__pragma(warning(disable:6255))\
+	((nRequestedSize <= nThreshold && ATL::_ATL_SAFE_ALLOCA_IMPL::_AtlVerifyStackAvailable(nRequestedSize) ) ?	\
+		_alloca(nRequestedSize) :	\
+		_AtlSafeAllocaManager.Allocate(nRequestedSize))\
+	__pragma(warning(pop))
+#endif
+
+#endif
+
+// Use 1024 bytes as the default threshold in ATL
+#ifndef _ATL_SAFE_ALLOCA_DEF_THRESHOLD
+#define _ATL_SAFE_ALLOCA_DEF_THRESHOLD	1024
+#endif
+
+#if (_ATL_VER <= 0x0301) // from atlbase.h
+
+class CComAllocator 
+{
+public:
+	static void* Reallocate(void* p, size_t nBytes) throw()
+	{
+#ifdef _WIN64
+		if( nBytes > INT_MAX )
+		{
+			return( NULL );
+		}
+#endif
+		return ::CoTaskMemRealloc(p, ULONG(nBytes));
+	}
+	static void* Allocate(size_t nBytes) throw()
+	{
+#ifdef _WIN64
+		if( nBytes > INT_MAX )
+		{
+			return( NULL );
+		}
+#endif
+		return ::CoTaskMemAlloc(ULONG(nBytes));
+	}
+	static void Free(void* p) throw()
+	{
+		::CoTaskMemFree(p);
+	}
+};
+
+template <typename T>
+class CComHeapPtr :
+	public CHeapPtr<T, CComAllocator>
+{
+public:
+	CComHeapPtr() throw()
+	{
+	}
+
+	explicit CComHeapPtr(T* pData) throw() :
+		CHeapPtr<T, CComAllocator>(pData)
+	{
+	}
+};
+
+#endif
+

c/jacob/include/atlbase.inl

@@ -0,0 +1,428 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the	
+// Active Template Library product.
+
+#ifndef __ATLBASE_INL__
+#define __ATLBASE_INL__
+
+#pragma once
+
+#ifndef __ATLBASE_H__
+	#error atlbase.inl requires atlbase.h to be included first
+#endif
+#pragma warning(push)
+#pragma warning(disable:4571) //catch(...) blocks compiled with /EHs do NOT catch or re-throw Structured Exceptions
+namespace ATL
+{
+
+/////////////////////////////////////////////////////////////////////////////
+// Connection Point Helpers
+
+ATLINLINE ATLAPI AtlAdvise(IUnknown* pUnkCP, IUnknown* pUnk, const IID& iid, LPDWORD pdw)
+{
+	if(pUnkCP == NULL)
+		return E_INVALIDARG;
+		
+	CComPtr<IConnectionPointContainer> pCPC;
+	CComPtr<IConnectionPoint> pCP;
+	HRESULT hRes = pUnkCP->QueryInterface(__uuidof(IConnectionPointContainer), (void**)&pCPC);
+	if (SUCCEEDED(hRes))
+		hRes = pCPC->FindConnectionPoint(iid, &pCP);
+	if (SUCCEEDED(hRes))
+		hRes = pCP->Advise(pUnk, pdw);
+	return hRes;
+}
+
+ATLINLINE ATLAPI AtlUnadvise(IUnknown* pUnkCP, const IID& iid, DWORD dw)
+{
+	if(pUnkCP == NULL)
+		return E_INVALIDARG;
+		
+	CComPtr<IConnectionPointContainer> pCPC;
+	CComPtr<IConnectionPoint> pCP;
+	HRESULT hRes = pUnkCP->QueryInterface(__uuidof(IConnectionPointContainer), (void**)&pCPC);
+	if (SUCCEEDED(hRes))
+		hRes = pCPC->FindConnectionPoint(iid, &pCP);
+	if (SUCCEEDED(hRes))
+		hRes = pCP->Unadvise(dw);
+	return hRes;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Inproc Marshaling helpers
+
+//This API should be called from the same thread that called
+//AtlMarshalPtrInProc
+ATLINLINE ATLAPI AtlFreeMarshalStream(IStream* pStream)
+{
+	HRESULT hRes=S_OK;
+	if (pStream != NULL)
+	{
+		LARGE_INTEGER l;
+		l.QuadPart = 0;
+		pStream->Seek(l, STREAM_SEEK_SET, NULL);
+		hRes=CoReleaseMarshalData(pStream);
+		pStream->Release();
+	}
+	return hRes;
+}
+
+ATLINLINE ATLAPI AtlMarshalPtrInProc(IUnknown* pUnk, const IID& iid, IStream** ppStream)
+{
+	ATLASSERT(ppStream != NULL);
+	if (ppStream == NULL)
+		return E_POINTER;
+		
+	HRESULT hRes = CreateStreamOnHGlobal(NULL, TRUE, ppStream);
+	if (SUCCEEDED(hRes))
+	{
+		hRes = CoMarshalInterface(*ppStream, iid,
+			pUnk, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLESTRONG);
+		if (FAILED(hRes))
+		{
+			(*ppStream)->Release();
+			*ppStream = NULL;
+		}
+	}
+	return hRes;
+}
+
+ATLINLINE ATLAPI AtlUnmarshalPtr(IStream* pStream, const IID& iid, IUnknown** ppUnk)
+{
+	ATLASSERT(ppUnk != NULL);
+	if (ppUnk == NULL)
+		return E_POINTER;
+
+	*ppUnk = NULL;
+	HRESULT hRes = E_INVALIDARG;
+	if (pStream != NULL)
+	{
+		LARGE_INTEGER l;
+		l.QuadPart = 0;
+		pStream->Seek(l, STREAM_SEEK_SET, NULL);
+		hRes = CoUnmarshalInterface(pStream, iid, (void**)ppUnk);
+	}
+	return hRes;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Module
+
+ATLINLINE ATLAPI AtlComModuleGetClassObject(_ATL_COM_MODULE* pComModule, REFCLSID rclsid, REFIID riid, LPVOID* ppv)
+{
+	ATLASSERT(pComModule != NULL);
+	if (pComModule == NULL)
+		return E_INVALIDARG;
+	if (pComModule->cbSize == 0)  // Module hasn't been initialized
+		return E_UNEXPECTED;
+
+	if (ppv == NULL)
+		return E_POINTER;
+	*ppv = NULL;
+
+	HRESULT hr = S_OK;
+
+	for (_ATL_OBJMAP_ENTRY** ppEntry = pComModule->m_ppAutoObjMapFirst; ppEntry < pComModule->m_ppAutoObjMapLast; ppEntry++)
+	{
+		if (*ppEntry != NULL)
+		{
+			_ATL_OBJMAP_ENTRY* pEntry = *ppEntry;
+			if ((pEntry->pfnGetClassObject != NULL) && InlineIsEqualGUID(rclsid, *pEntry->pclsid))
+			{
+				if (pEntry->pCF == NULL)
+				{
+					CComCritSecLock<CComCriticalSection> lock(pComModule->m_csObjMap, false);
+					hr = lock.Lock();
+					if (FAILED(hr))
+					{
+						ATLTRACE(atlTraceCOM, 0, _T("ERROR : Unable to lock critical section in AtlComModuleGetClassObject\n"));
+						ATLASSERT(0);
+						break;
+					}
+					if (pEntry->pCF == NULL)
+						hr = pEntry->pfnGetClassObject(pEntry->pfnCreateInstance, __uuidof(IUnknown), (LPVOID*)&pEntry->pCF);
+				}
+				if (pEntry->pCF != NULL)
+					hr = pEntry->pCF->QueryInterface(riid, ppv);
+				break;
+			}
+		}
+	}
+
+	if (*ppv == NULL && hr == S_OK)
+		hr = CLASS_E_CLASSNOTAVAILABLE;
+	return hr;
+}
+
+ATLINLINE ATLAPI AtlComModuleRegisterClassObjects(_ATL_COM_MODULE* pComModule, DWORD dwClsContext, DWORD dwFlags)
+{
+	ATLASSERT(pComModule != NULL);
+	if (pComModule == NULL)
+		return E_INVALIDARG;
+
+	HRESULT hr = S_FALSE;
+	for (_ATL_OBJMAP_ENTRY** ppEntry = pComModule->m_ppAutoObjMapFirst; ppEntry < pComModule->m_ppAutoObjMapLast && SUCCEEDED(hr); ppEntry++)
+	{
+		if (*ppEntry != NULL)
+			hr = (*ppEntry)->RegisterClassObject(dwClsContext, dwFlags);
+	}
+	return hr;
+}
+
+ATLINLINE ATLAPI AtlComModuleRevokeClassObjects(_ATL_COM_MODULE* pComModule)
+{
+	ATLASSERT(pComModule != NULL);
+	if (pComModule == NULL)
+		return E_INVALIDARG;
+
+	HRESULT hr = S_OK;
+	for (_ATL_OBJMAP_ENTRY** ppEntry = pComModule->m_ppAutoObjMapFirst; ppEntry < pComModule->m_ppAutoObjMapLast && hr == S_OK; ppEntry++)
+	{
+		if (*ppEntry != NULL)
+			hr = (*ppEntry)->RevokeClassObject();
+	}
+	return hr;
+}
+
+ATLINLINE ATLAPI_(BOOL) AtlWaitWithMessageLoop(HANDLE hEvent)
+{
+	DWORD dwRet;
+	MSG msg;
+
+	while(1)
+	{
+		dwRet = MsgWaitForMultipleObjects(1, &hEvent, FALSE, INFINITE, QS_ALLINPUT);
+
+		if (dwRet == WAIT_OBJECT_0)
+			return TRUE;    // The event was signaled
+
+		if (dwRet != WAIT_OBJECT_0 + 1)
+			break;          // Something else happened
+
+		// There is one or more window message available. Dispatch them
+		while(PeekMessage(&msg,0,0,0,PM_NOREMOVE))
+		{
+			// check for unicode window so we call the appropriate functions
+			BOOL bUnicode = ::IsWindowUnicode(msg.hwnd);
+			BOOL bRet;
+
+			if (bUnicode)
+				bRet = ::GetMessageW(&msg, NULL, 0, 0);
+			else
+				bRet = ::GetMessageA(&msg, NULL, 0, 0);
+
+			if (bRet > 0)
+			{
+				::TranslateMessage(&msg);
+
+				if (bUnicode)
+					::DispatchMessageW(&msg);
+				else
+					::DispatchMessageA(&msg);
+			}
+
+			if (WaitForSingleObject(hEvent, 0) == WAIT_OBJECT_0)
+				return TRUE; // Event is now signaled.
+		}
+	}
+	return FALSE;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// QI support
+
+ATLINLINE ATLAPI AtlInternalQueryInterface(void* pThis,
+	const _ATL_INTMAP_ENTRY* pEntries, REFIID iid, void** ppvObject)
+{
+	ATLASSERT(pThis != NULL);
+	ATLASSERT(pEntries!= NULL);
+	
+	if(pThis == NULL || pEntries == NULL)
+		return E_INVALIDARG ;
+		
+	// First entry in the com map should be a simple map entry
+	ATLASSERT(pEntries->pFunc == _ATL_SIMPLEMAPENTRY);
+	if (ppvObject == NULL)
+		return E_POINTER;
+	*ppvObject = NULL;
+	if (InlineIsEqualUnknown(iid)) // use first interface
+	{
+			IUnknown* pUnk = (IUnknown*)((INT_PTR)pThis+pEntries->dw);
+			pUnk->AddRef();
+			*ppvObject = pUnk;
+			return S_OK;
+	}
+	while (pEntries->pFunc != NULL)
+	{
+		BOOL bBlind = (pEntries->piid == NULL);
+		if (bBlind || InlineIsEqualGUID(*(pEntries->piid), iid))
+		{
+			if (pEntries->pFunc == _ATL_SIMPLEMAPENTRY) //offset
+			{
+				ATLASSERT(!bBlind);
+				IUnknown* pUnk = (IUnknown*)((INT_PTR)pThis+pEntries->dw);
+				pUnk->AddRef();
+				*ppvObject = pUnk;
+				return S_OK;
+			}
+			else //actual function call
+			{
+				HRESULT hRes = pEntries->pFunc(pThis,
+					iid, ppvObject, pEntries->dw);
+				if (hRes == S_OK || (!bBlind && FAILED(hRes)))
+					return hRes;
+			}
+		}
+		pEntries++;
+	}
+	return E_NOINTERFACE;
+}
+
+ATLINLINE ATLAPI_(DWORD) AtlGetVersion(void* /* pReserved */)
+{
+	return _ATL_VER;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Windowing
+
+ATLINLINE ATLAPI_(void) AtlWinModuleAddCreateWndData(_ATL_WIN_MODULE* pWinModule, _AtlCreateWndData* pData, void* pObject)
+{
+	if (pWinModule == NULL)
+		_AtlRaiseException((DWORD)EXCEPTION_ACCESS_VIOLATION);
+
+	ATLASSERT(pData != NULL && pObject != NULL);
+	if(pData == NULL || pObject == NULL)
+		_AtlRaiseException((DWORD)EXCEPTION_ACCESS_VIOLATION);
+		
+	pData->m_pThis = pObject;
+	pData->m_dwThreadID = ::GetCurrentThreadId();
+	CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, false);
+	if (FAILED(lock.Lock()))
+	{
+		ATLTRACE(atlTraceWindowing, 0, _T("ERROR : Unable to lock critical section in AtlWinModuleAddCreateWndData\n"));
+		ATLASSERT(0);
+		return;
+	}
+	pData->m_pNext = pWinModule->m_pCreateWndList;
+	pWinModule->m_pCreateWndList = pData;
+}
+
+ATLINLINE ATLAPI_(void*) AtlWinModuleExtractCreateWndData(_ATL_WIN_MODULE* pWinModule)
+{
+	if (pWinModule == NULL)
+		return NULL;
+
+	void* pv = NULL;
+	CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, false);
+	if (FAILED(lock.Lock()))
+	{
+		ATLTRACE(atlTraceWindowing, 0, _T("ERROR : Unable to lock critical section in AtlWinModuleExtractCreateWndData\n"));
+		ATLASSERT(0);
+		return pv;
+	}
+	_AtlCreateWndData* pEntry = pWinModule->m_pCreateWndList;
+	if(pEntry != NULL)
+	{
+		DWORD dwThreadID = ::GetCurrentThreadId();
+		_AtlCreateWndData* pPrev = NULL;
+		while(pEntry != NULL)
+		{
+			if(pEntry->m_dwThreadID == dwThreadID)
+			{
+				if(pPrev == NULL)
+					pWinModule->m_pCreateWndList = pEntry->m_pNext;
+				else
+					pPrev->m_pNext = pEntry->m_pNext;
+				pv = pEntry->m_pThis;
+				break;
+			}
+			pPrev = pEntry;
+			pEntry = pEntry->m_pNext;
+		}
+	}
+	return pv;
+}
+
+
+ATLINLINE ATLAPI AtlWinModuleInit(_ATL_WIN_MODULE* pWinModule)
+{
+	if (pWinModule == NULL)
+		return E_INVALIDARG;
+		
+	// check only in the DLL
+	if (pWinModule->cbSize != sizeof(_ATL_WIN_MODULE))
+		return E_INVALIDARG;
+
+	pWinModule->m_pCreateWndList = NULL;
+
+	HRESULT hr = pWinModule->m_csWindowCreate.Init();
+	if (FAILED(hr))
+	{
+		ATLTRACE(atlTraceWindowing, 0, _T("ERROR : Unable to initialize critical section in AtlWinModuleInit\n"));
+		ATLASSERT(0);
+	}
+	return hr;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Module
+
+ATLINLINE ATLAPI AtlModuleAddTermFunc(_ATL_MODULE* pModule, _ATL_TERMFUNC* pFunc, DWORD_PTR dw)
+{
+	if (pModule == NULL)
+		return E_INVALIDARG;
+		
+	HRESULT hr = S_OK;
+	_ATL_TERMFUNC_ELEM* pNew = NULL;
+	ATLTRY(pNew = new _ATL_TERMFUNC_ELEM);
+	if (pNew == NULL)
+		hr = E_OUTOFMEMORY;
+	else
+	{
+		pNew->pFunc = pFunc;
+		pNew->dw = dw;
+		CComCritSecLock<CComCriticalSection> lock(pModule->m_csStaticDataInitAndTypeInfo, false);
+		hr = lock.Lock();
+		if (SUCCEEDED(hr))
+		{
+			pNew->pNext = pModule->m_pTermFuncs;
+			pModule->m_pTermFuncs = pNew;
+		}
+		else
+		{
+			delete pNew;
+			ATLTRACE(atlTraceGeneral, 0, _T("ERROR : Unable to lock critical section in AtlModuleAddTermFunc\n"));
+			ATLASSERT(0);
+		}
+	}
+	return hr;
+}
+
+ATLINLINE ATLAPI_(void) AtlCallTermFunc(_ATL_MODULE* pModule)
+{
+	if (pModule == NULL)
+		_AtlRaiseException((DWORD)EXCEPTION_ACCESS_VIOLATION);
+		
+	_ATL_TERMFUNC_ELEM* pElem = pModule->m_pTermFuncs;
+	_ATL_TERMFUNC_ELEM* pNext = NULL;
+	while (pElem != NULL)
+	{
+		pElem->pFunc(pElem->dw);
+		pNext = pElem->pNext;
+		delete pElem;
+		pElem = pNext;
+	}
+	pModule->m_pTermFuncs = NULL;
+}
+
+} // namespace ATL
+#pragma warning(pop)
+#endif // __ATLBASE_INL__
+

c/jacob/include/atlchecked.h

@@ -0,0 +1,605 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the
+// Active Template Library product.
+
+#ifndef __ATLCHECKED_H__
+#define __ATLCHECKED_H__
+
+#pragma once
+
+#include <atldef.h>
+#include <atlexcept.h>
+#include <malloc.h>
+#include <string.h>
+#include <mbstring.h>
+#include <wchar.h>
+#include <tchar.h>
+#include <stdlib.h>
+#pragma warning(push)
+#pragma warning(disable:4127)
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+
+inline errno_t AtlCrtErrorCheck(errno_t nError)
+{
+	switch(nError)
+	{
+	case ENOMEM:
+		AtlThrow(E_OUTOFMEMORY);
+		break;
+	case EINVAL:
+	case ERANGE:
+		AtlThrow(E_INVALIDARG);
+		break;
+	case 0:
+	case STRUNCATE:
+		break;
+	default:
+		AtlThrow(E_FAIL);
+		break;
+	}
+	return nError;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Secure (Checked) CRT functions
+
+namespace Checked
+{
+
+#if _SECURE_ATL
+
+#ifdef _AFX
+#define ATLMFC_CRT_ERRORCHECK(expr) AFX_CRT_ERRORCHECK(expr)
+#else
+#define ATLMFC_CRT_ERRORCHECK(expr) ATL_CRT_ERRORCHECK(expr)
+#endif
+
+inline void __cdecl memcpy_s(__out_bcount_part(_S1max,_N)  void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, __in size_t _N)
+{
+	ATLMFC_CRT_ERRORCHECK(::memcpy_s(_S1, _S1max, _S2, _N));
+}
+
+inline void __cdecl wmemcpy_s(__out_ecount_part(_N1,_N) wchar_t *_S1, __in size_t _N1, __in_ecount(_N) const wchar_t *_S2, __in size_t _N)
+{
+	ATLMFC_CRT_ERRORCHECK(::wmemcpy_s(_S1, _N1, _S2, _N));
+}
+
+inline void __cdecl memmove_s(__out_bcount_part(_S1max,_N) void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, size_t _N)
+{
+	ATLMFC_CRT_ERRORCHECK(::memmove_s(_S1, _S1max, _S2, _N));
+}
+
+inline void __cdecl strcpy_s(__out_ecount(_S1max) char *_S1, __in size_t _S1max, __in_z const char *_S2)
+{
+	ATLMFC_CRT_ERRORCHECK(::strcpy_s(_S1, _S1max, _S2));
+}
+
+inline void __cdecl wcscpy_s(__out_ecount(_S1max) wchar_t *_S1, __in size_t _S1max, __in_z const wchar_t *_S2)
+{
+	ATLMFC_CRT_ERRORCHECK(::wcscpy_s(_S1, _S1max, _S2));
+}
+
+inline void __cdecl tcscpy_s(__out_ecount(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
+{
+#ifndef _ATL_MIN_CRT
+	ATLMFC_CRT_ERRORCHECK(::_tcscpy_s(_Dst, _SizeInChars, _Src));
+#else
+#ifdef UNICODE
+	ATLMFC_CRT_ERRORCHECK(::wcscpy_s(_Dst, _SizeInChars, _Src));
+#else
+	ATLMFC_CRT_ERRORCHECK(::strcpy_s(_Dst, _SizeInChars, _Src));
+#endif
+#endif
+}
+
+inline errno_t __cdecl strncpy_s(__out_ecount(_SizeInChars) char *_Dest, __in size_t _SizeInChars, __in_z const char *_Source, __in size_t _Count)
+{
+	return ATLMFC_CRT_ERRORCHECK(::strncpy_s(_Dest, _SizeInChars, _Source,_Count));	
+}
+
+inline errno_t __cdecl wcsncpy_s(__out_ecount(_SizeInChars) wchar_t *_Dest, __in size_t _SizeInChars, __in_z const wchar_t *_Source, __in size_t _Count)
+{
+	return ATLMFC_CRT_ERRORCHECK(::wcsncpy_s(_Dest, _SizeInChars, _Source,_Count));	
+}
+
+inline errno_t __cdecl tcsncpy_s(__out_ecount(_SizeInChars) TCHAR *_Dest, __in size_t _SizeInChars, __in_z const TCHAR *_Source, __in size_t _Count)
+{
+#ifndef _ATL_MIN_CRT
+	return ATLMFC_CRT_ERRORCHECK(::_tcsncpy_s(_Dest, _SizeInChars, _Source,_Count));	
+#else
+#ifdef UNICODE
+	return ATLMFC_CRT_ERRORCHECK(::wcsncpy_s(_Dest, _SizeInChars, _Source,_Count));	
+#else
+	return ATLMFC_CRT_ERRORCHECK(::strncpy_s(_Dest, _SizeInChars, _Source,_Count));	
+#endif
+#endif
+}
+
+inline void __cdecl strcat_s(__inout_ecount_z(_SizeInChars) char * _Dst, __in size_t _SizeInChars, __in_z const char * _Src)
+{
+	ATLMFC_CRT_ERRORCHECK(::strcat_s(_Dst, _SizeInChars, _Src));
+}
+
+inline void __cdecl wcscat_s(__inout_ecount_z(_SizeInChars) wchar_t * _Dst, __in size_t _SizeInChars, __in_z const wchar_t * _Src)
+{
+	ATLMFC_CRT_ERRORCHECK(::wcscat_s(_Dst, _SizeInChars, _Src));
+}
+
+inline void __cdecl tcscat_s(__inout_ecount_z(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
+{
+#ifndef _ATL_MIN_CRT
+	ATLMFC_CRT_ERRORCHECK(::_tcscat_s(_Dst, _SizeInChars, _Src));
+#else
+#ifdef UNICODE
+	ATLMFC_CRT_ERRORCHECK(::wcscat_s(_Dst, _SizeInChars, _Src));
+#else
+	ATLMFC_CRT_ERRORCHECK(::strcat_s(_Dst, _SizeInChars, _Src));
+#endif
+#endif
+}
+
+inline void __cdecl strlwr_s(__inout_ecount_z(_SizeInChars) char * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_strlwr_s(_Str, _SizeInChars));	
+}
+
+inline void __cdecl wcslwr_s(__inout_ecount_z(_SizeInChars) wchar_t * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_wcslwr_s(_Str, _SizeInChars));	
+}
+
+#if !defined(_MANAGED)
+inline void __cdecl mbslwr_s(__inout_bcount_z(_SizeInChars) unsigned char * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_mbslwr_s(_Str, _SizeInChars));	
+}
+#endif
+
+inline void __cdecl tcslwr_s(__inout_ecount_z(_SizeInChars) TCHAR * _Str, __in size_t _SizeInChars)
+{
+#ifndef _ATL_MIN_CRT
+	ATLMFC_CRT_ERRORCHECK(::_tcslwr_s(_Str, _SizeInChars));	
+#else
+#ifdef UNICODE
+	ATLMFC_CRT_ERRORCHECK(::_wcslwr_s(_Str, _SizeInChars));	
+#else
+	ATLMFC_CRT_ERRORCHECK(::_strlwr_s(_Str, _SizeInChars));	
+#endif
+#endif
+}
+
+inline void __cdecl strupr_s(__inout_ecount_z(_SizeInChars) char * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_strupr_s(_Str, _SizeInChars));	
+}
+
+inline void __cdecl wcsupr_s(__inout_ecount_z(_SizeInChars) wchar_t * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_wcsupr_s(_Str, _SizeInChars));	
+}
+
+#if !defined(_MANAGED)
+inline void __cdecl mbsupr_s(__inout_bcount_z(_SizeInChars) unsigned char * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_mbsupr_s(_Str, _SizeInChars));	
+}
+#endif
+
+inline void __cdecl tcsupr_s(__inout_ecount_z(_SizeInChars) TCHAR * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_tcsupr_s(_Str, _SizeInChars));	
+}
+
+inline void __cdecl itoa_s(__in int _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_itoa_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl itot_s(__in int _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_itot_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl ltoa_s(__in long _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_ltoa_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl ltot_s(__in long _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_ltot_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl ultoa_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_ultoa_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl ultow_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_ultow_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl ultot_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_ultot_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl i64toa_s(__in __int64 _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_i64toa_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl i64tow_s(__in __int64 _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_i64tow_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl ui64toa_s(__in unsigned __int64 _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_ui64toa_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl ui64tow_s(__in unsigned __int64 _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_ui64tow_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl gcvt_s(__out_ecount_z(_SizeInChars) char *_Buffer, __in size_t _SizeInChars, __in double _Value, __in int _Ndec)
+{
+	ATLMFC_CRT_ERRORCHECK(::_gcvt_s(_Buffer, _SizeInChars, _Value, _Ndec));
+}
+
+inline void __cdecl tsplitpath_s(__in_z const TCHAR *_Path, __out_ecount_z_opt(_Drive_len) TCHAR *_Drive, __in size_t _Drive_len, 
+	__out_ecount_z_opt(_Dir_len) TCHAR *_Dir, __in size_t _Dir_len, 
+	__out_ecount_z_opt(_Fname_len) TCHAR *_Fname, __in size_t _Fname_len, 
+	__out_ecount_z_opt(_Ext_len) TCHAR *_Ext, __in size_t _Ext_len)
+{
+	ATLMFC_CRT_ERRORCHECK(::_tsplitpath_s(_Path, _Drive, _Drive_len, _Dir, _Dir_len, _Fname, _Fname_len, _Ext, _Ext_len));
+}
+
+inline void __cdecl tmakepath_s(__out_ecount_z(_SizeInChars) TCHAR *_Path, __in size_t _SizeInChars, __in_z const TCHAR *_Drive, 
+	__in_z const TCHAR *_Dir, __in_z const TCHAR *_Fname, __in_z const TCHAR *_Ext)
+{
+	ATLMFC_CRT_ERRORCHECK(::_tmakepath_s(_Path, _SizeInChars, _Drive, _Dir, _Fname, _Ext));
+}
+
+inline size_t __cdecl strnlen(__in_ecount(_Maxsize) const char *_Str, __in size_t _Maxsize)
+{
+	return ::strnlen(_Str, _Maxsize);
+}
+
+inline size_t __cdecl wcsnlen(__in_ecount(_Maxsize) const wchar_t *_Wcs, __in size_t _Maxsize)
+{
+	return ::wcsnlen(_Wcs, _Maxsize);
+}
+
+inline size_t __cdecl tcsnlen(__in_ecount(_Maxsize) const TCHAR *_Str, __in size_t _Maxsize)
+{
+	return ::_tcsnlen(_Str, _Maxsize);
+}
+
+inline int get_errno()
+{
+	int nErrNo;
+	ATLMFC_CRT_ERRORCHECK(::_get_errno(&nErrNo));
+	return nErrNo;
+}
+
+inline void set_errno(__in int _Value)
+{
+	ATLMFC_CRT_ERRORCHECK(::_set_errno(_Value));
+}
+
+#else // !_SECURE_ATL
+
+#define ATLMFC_CRT_ERRORCHECK(expr) do { expr; } while (0)
+
+inline void __cdecl memcpy_s(__out_bcount(_S1max) void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, size_t _N)
+{
+	(_S1max);
+	memcpy(_S1, _S2, _N);
+}
+
+inline void __cdecl wmemcpy_s(__out_ecount(_N1) wchar_t *_S1, __in size_t _N1, __in_ecount(_N) const wchar_t *_S2, __in size_t _N)
+{
+	(_N1);
+	::wmemcpy(_S1, _S2, _N);
+}
+
+inline void __cdecl memmove_s(__out_bcount(_S1max) void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, __in size_t _N)
+{
+	(_S1max);
+	memmove(_S1, _S2, _N);
+}
+
+inline void __cdecl strcpy_s(__out_ecount_z(_S1max) char *_S1, __in size_t _S1max, __in_z const char *_S2)
+{
+	(_S1max);
+	::strcpy(_S1, _S2);
+}
+
+inline void __cdecl wcscpy_s(__out_ecount_z(_S1max) wchar_t *_S1, __in size_t _S1max, __in_z const wchar_t *_S2)
+{
+	(_S1max);
+	::wcscpy(_S1, _S2);
+}
+
+inline void __cdecl tcscpy_s(__out_ecount_z(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
+{
+	(_SizeInChars);
+#ifndef _ATL_MIN_CRT
+	::_tcscpy(_Dst, _Src);
+#else
+#ifdef UNICODE
+	::wcscpy(_Dst, _Src);
+#else
+	::strcpy(_Dst, _Src);
+#endif
+#endif
+}
+
+/* ensure that strncpy_s null-terminate the dest string */
+inline errno_t __cdecl strncpy_s(__out_ecount_z(_SizeInChars) char *_Dest, __in size_t _SizeInChars, __in_z const char *_Source,__in size_t _Count)
+{
+	if (_Count == _TRUNCATE)
+	{
+		_Count = _SizeInChars - 1;
+	}
+	while (_Count > 0 && *_Source != 0)
+	{
+		*_Dest++ = *_Source++;
+		--_Count;
+	}
+	*_Dest = 0;
+
+	return (*_Source!=0) ? STRUNCATE : 0;
+}
+
+inline errno_t __cdecl wcsncpy_s(__out_ecount_z(_SizeInChars) wchar_t *_Dest, __in size_t _SizeInChars, __in_z const wchar_t *_Source, __in size_t _Count)
+{
+	if (_Count == _TRUNCATE)
+	{
+		_Count = _SizeInChars - 1;
+	}
+	while (_Count > 0 && *_Source != 0)
+	{
+		*_Dest++ = *_Source++;
+		--_Count;
+	}
+	*_Dest = 0;
+
+	return (*_Source!=0) ? STRUNCATE : 0;
+}
+
+inline errno_t __cdecl tcsncpy_s(__out_ecount_z(_SizeInChars) TCHAR *_Dest, __in size_t _SizeInChars, __in_z const TCHAR *_Source,__in size_t _Count)
+{
+	if (_Count == _TRUNCATE)
+	{
+		if(_SizeInChars>0)
+		{
+			_Count = _SizeInChars - 1;
+		}
+		else
+		{
+			_Count =0;
+		}
+	}
+
+#ifndef _ATL_MIN_CRT
+#pragma warning(push)
+#pragma warning(disable: 6535)
+	::_tcsncpy(_Dest,_Source,_Count);
+#pragma warning(pop)
+	if(_SizeInChars>0)
+	{
+		size_t nulCount = __min(_SizeInChars-1, _Count);
+		_Dest[nulCount] = 0;
+	}
+#else
+	while (_Count > 0 && *_Source != 0)
+	{
+		*_Dest++ = *_Source++;
+		--_Count;
+	}
+	*_Dest = 0;
+#endif
+
+	return (*_Source!=0) ? STRUNCATE : 0;
+}
+
+inline void __cdecl strcat_s(__inout_ecount_z(_SizeInChars) char * _Dst, __in size_t _SizeInChars, __in_z const char * _Src)
+{
+	(_SizeInChars);
+	::strcat(_Dst, _Src);
+}
+
+inline void __cdecl wcscat_s(__inout_ecount_z(_SizeInChars) wchar_t * _Dst, __in size_t _SizeInChars, __in_z const wchar_t * _Src)
+{
+	(_SizeInChars);
+	::wcscat(_Dst, _Src);
+}
+
+inline void __cdecl tcscat_s(__inout_ecount_z(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
+{
+	(_SizeInChars);
+#ifndef _ATL_MIN_CRT
+	::_tcscat(_Dst, _Src);
+#else
+#ifdef UNICODE
+	::wcscat(_Dst, _Src);
+#else
+	::strcat(_Dst, _Src);
+#endif
+#endif
+}
+
+inline void __cdecl strlwr_s(__inout_ecount_z(_SizeInChars) char * _Str, size_t _SizeInChars)
+{
+	(_SizeInChars);
+	::_strlwr(_Str);	
+}
+
+inline void __cdecl wcslwr_s(__inout_ecount_z(_SizeInChars) wchar_t * _Str, size_t _SizeInChars)
+{
+	(_SizeInChars);
+	::_wcslwr(_Str);	
+}
+
+inline void __cdecl mbslwr_s(__inout_bcount_z(_SizeInChars) unsigned char * _Str, size_t _SizeInChars)
+{
+	(_SizeInChars);
+	::_mbslwr(_Str);
+}
+
+inline void __cdecl tcslwr_s(__inout_ecount_z(_SizeInChars) TCHAR * _Str, size_t _SizeInChars)
+{
+	(_SizeInChars);
+#ifndef _ATL_MIN_CRT
+	::_tcslwr(_Str);
+#else
+#ifdef UNICODE
+	::_wcslwr(_Str);
+#else
+	::_strlwr(_Str);
+#endif
+#endif
+}
+
+inline void __cdecl itoa_s(__in int _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_itoa_s(_Val, _Buf, _SizeInChars, _Radix);
+}
+
+inline void __cdecl itot_s(__in int _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_itot(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ltoa_s(__in long _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ltoa(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ltot_s(__in long _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ltot(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ultoa_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ultoa(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ultow_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ultow(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ultot_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ultot(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl i64toa_s(__in __int64 _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_i64toa(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl i64tow_s(__in __int64 _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_i64tow(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ui64toa_s(__in unsigned __int64 _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ui64toa(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ui64tow_s(__in unsigned __int64 _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ui64tow(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl gcvt_s(__out_ecount_z(_SizeInChars) char *_Buffer, __in size_t _SizeInChars, __in double _Value, __in int _Ndec)
+{
+	(_SizeInChars);
+	::_gcvt(_Value, _Ndec, _Buffer);
+}
+
+inline void __cdecl tsplitpath_s(__in_z const TCHAR *_Path, __out_ecount_z_opt(_Drive_len) TCHAR *_Drive, __in size_t _Drive_len, 
+	__out_ecount_z_opt(_Dir_len) TCHAR *_Dir, __in size_t _Dir_len, 
+	__out_ecount_z_opt(_Fname_ext) TCHAR *_Fname, __in size_t _Fname_len, 
+	__out_ecount_z_opt(_Ext_len) TCHAR *_Ext, __in size_t _Ext_len)
+{
+	(_Drive_len, _Dir_len, _Fname_len, _Ext_len);
+	::_tsplitpath(_Path, _Drive, _Dir, _Fname, _Ext);
+}
+
+inline void __cdecl tmakepath_s(__out_ecount_z(_SizeInChars) TCHAR *_Path, __in size_t _SizeInChars, __in_z const TCHAR *_Drive, 
+	__in_z const TCHAR *_Dir, __in_z const TCHAR *_Fname, __in_z const TCHAR *_Ext)
+{
+	(_SizeInChars);
+	::_tmakepath(_Path, _Drive, _Dir, _Fname, _Ext);
+}
+
+inline size_t __cdecl strnlen(__in_ecount(_Maxsize) const char *_Str, __in size_t _Maxsize)
+{
+	(_Maxsize);
+	return ::strlen(_Str);
+}
+
+inline size_t __cdecl wcsnlen(__in_ecount(_Maxsize) const wchar_t *_Wcs, __in size_t _Maxsize)
+{
+	(_Maxsize);
+	return ::wcslen(_Wcs);
+}
+
+inline size_t __cdecl tcsnlen(__in_ecount(_Maxsize) const TCHAR *_Str, __in size_t _Maxsize)
+{
+	(_Maxsize);
+	return ::_tcslen(_Str);
+}
+
+inline int get_errno()
+{
+	return errno;
+}
+
+inline void set_errno(__in int _Value)
+{
+	errno = _Value;
+}
+
+#endif // _SECURE_ATL
+
+} // namespace Checked
+
+} // namespace ATL
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // __ATLCHECKED_H__
+
+/////////////////////////////////////////////////////////////////////////////
+

c/jacob/include/atlcore.h

@@ -0,0 +1,554 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the	
+// Active Template Library product.
+
+#ifndef __ATLCORE_H__
+#define __ATLCORE_H__
+
+#pragma once
+
+#ifdef _ATL_ALL_WARNINGS
+#pragma warning( push )
+#endif
+
+#pragma warning(disable: 4786) // identifier was truncated in the debug information
+#pragma warning(disable: 4127) // constant expression
+
+#include <atldef.h>
+#include <windows.h>
+#include <ole2.h>
+
+#include <limits.h>
+#include <tchar.h>
+#include <mbstring.h>
+
+#include <atlchecked.h>
+#include <atlsimpcoll.h>
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+/////////////////////////////////////////////////////////////////////////////
+// Verify that a null-terminated string points to valid memory
+inline BOOL AtlIsValidString(LPCWSTR psz, size_t nMaxLength = INT_MAX)
+{
+	(nMaxLength);
+	return (psz != NULL);
+}
+
+// Verify that a null-terminated string points to valid memory
+inline BOOL AtlIsValidString(LPCSTR psz, size_t nMaxLength = UINT_MAX)
+{
+	(nMaxLength);
+	return (psz != NULL);
+}
+
+// Verify that a pointer points to valid memory
+inline BOOL AtlIsValidAddress(const void* p, size_t nBytes,
+	BOOL bReadWrite = TRUE)
+{
+	(bReadWrite);
+	(nBytes);
+	return (p != NULL);
+}
+
+template<typename T>
+inline void AtlAssertValidObject(const T *pOb)
+{
+	ATLASSERT(pOb);
+	ATLASSERT(AtlIsValidAddress(pOb, sizeof(T)));
+	if(pOb)
+		pOb->AssertValid();
+}
+#ifdef _DEBUG
+#define ATLASSERT_VALID(x) ATL::AtlAssertValidObject(x)
+#else
+#define ATLASSERT_VALID(x) __noop;
+#endif
+
+// COM Sync Classes
+class CComCriticalSection
+{
+public:
+	CComCriticalSection() throw()
+	{
+		memset(&m_sec, 0, sizeof(CRITICAL_SECTION));
+	}
+	~CComCriticalSection()
+	{
+	}
+	HRESULT Lock() throw()
+	{
+		EnterCriticalSection(&m_sec);
+		return S_OK;
+	}
+	HRESULT Unlock() throw()
+	{
+		LeaveCriticalSection(&m_sec);
+		return S_OK;
+	}
+	HRESULT Init() throw()
+	{
+		HRESULT hRes = E_FAIL;
+		__try
+		{
+			InitializeCriticalSection(&m_sec);
+			hRes = S_OK;
+		}
+		// structured exception may be raised in low memory situations
+		__except(STATUS_NO_MEMORY == GetExceptionCode())
+		{			
+			hRes = E_OUTOFMEMORY;		
+		}
+		return hRes;
+	}
+
+	HRESULT Term() throw()
+	{
+		DeleteCriticalSection(&m_sec);
+		return S_OK;
+	}	
+	CRITICAL_SECTION m_sec;
+};
+
+class CComAutoCriticalSection : public CComCriticalSection
+{
+public:
+	CComAutoCriticalSection()
+	{
+		HRESULT hr = CComCriticalSection::Init();
+		if (FAILED(hr))
+			AtlThrow(hr);
+	}
+	~CComAutoCriticalSection() throw()
+	{
+		CComCriticalSection::Term();
+	}
+private :
+	HRESULT Init(); // Not implemented. CComAutoCriticalSection::Init should never be called
+	HRESULT Term(); // Not implemented. CComAutoCriticalSection::Term should never be called
+};
+
+class CComSafeDeleteCriticalSection : public CComCriticalSection
+{
+public:
+	CComSafeDeleteCriticalSection(): m_bInitialized(false) 
+	{
+	}
+
+	~CComSafeDeleteCriticalSection() throw()
+	{
+		if (!m_bInitialized)
+		{
+			return;
+		}
+		m_bInitialized = false;
+		CComCriticalSection::Term();
+	}
+
+	HRESULT Init() throw()
+	{
+		ATLASSERT( !m_bInitialized );
+		HRESULT hr = CComCriticalSection::Init();
+		if (SUCCEEDED(hr))
+		{
+			m_bInitialized = true;
+		}
+		return hr;
+	}
+
+	HRESULT Term() throw()
+	{
+		if (!m_bInitialized)
+		{
+			return S_OK;
+		}
+		m_bInitialized = false;
+		return CComCriticalSection::Term();
+	}
+
+	HRESULT Lock()
+	{
+		// CComSafeDeleteCriticalSection::Init or CComAutoDeleteCriticalSection::Init
+		// not called or failed.
+		// m_critsec member of CComObjectRootEx is now of type 
+		// CComAutoDeleteCriticalSection. It has to be initialized
+		// by calling CComObjectRootEx::_AtlInitialConstruct
+		ATLASSUME(m_bInitialized);
+		return CComCriticalSection::Lock();
+	}
+
+private:
+	bool m_bInitialized;
+};
+
+class CComAutoDeleteCriticalSection : public CComSafeDeleteCriticalSection
+{
+private:
+	// CComAutoDeleteCriticalSection::Term should never be called
+	HRESULT Term() throw();
+};
+
+class CComFakeCriticalSection
+{
+public:
+	HRESULT Lock() throw() { return S_OK; }
+	HRESULT Unlock() throw() { return S_OK; }
+	HRESULT Init() throw() { return S_OK; }
+	HRESULT Term() throw() { return S_OK; }
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// Module 
+
+// Used by any project that uses ATL
+struct _ATL_BASE_MODULE70
+{
+	UINT cbSize;
+	HINSTANCE m_hInst;
+	HINSTANCE m_hInstResource;
+	bool m_bNT5orWin98;
+	DWORD dwAtlBuildVer;
+	const GUID* pguidVer;
+	CComCriticalSection m_csResource;
+	CSimpleArray<HINSTANCE> m_rgResourceInstance;
+};
+typedef _ATL_BASE_MODULE70 _ATL_BASE_MODULE;
+
+class CAtlBaseModule : public _ATL_BASE_MODULE
+{
+public :
+	static bool m_bInitFailed;
+	CAtlBaseModule() throw();
+	~CAtlBaseModule() throw ();
+
+	HINSTANCE GetModuleInstance() throw()
+	{
+		return m_hInst;
+	}
+	HINSTANCE GetResourceInstance() throw()
+	{
+		return m_hInstResource;
+	}
+	HINSTANCE SetResourceInstance(HINSTANCE hInst) throw()
+	{
+		return static_cast< HINSTANCE >(InterlockedExchangePointer((void**)&m_hInstResource, hInst));
+	}
+
+	bool AddResourceInstance(HINSTANCE hInst) throw();
+	bool RemoveResourceInstance(HINSTANCE hInst) throw();
+	HINSTANCE GetHInstanceAt(int i) throw();
+};
+
+__declspec(selectany) bool CAtlBaseModule::m_bInitFailed = false;
+extern CAtlBaseModule _AtlBaseModule;
+
+/////////////////////////////////////////////////////////////////////////////
+// String resource helpers
+
+#pragma warning(push)
+#pragma warning(disable: 4200)
+	struct ATLSTRINGRESOURCEIMAGE
+	{
+		WORD nLength;
+		__field_ecount(nLength) WCHAR achString[];
+	};
+#pragma warning(pop)	// C4200
+
+inline const ATLSTRINGRESOURCEIMAGE* _AtlGetStringResourceImage( HINSTANCE hInstance, HRSRC hResource, UINT id ) throw()
+{
+	const ATLSTRINGRESOURCEIMAGE* pImage;
+	const ATLSTRINGRESOURCEIMAGE* pImageEnd;
+	ULONG nResourceSize;
+	HGLOBAL hGlobal;
+	UINT iIndex;
+
+	hGlobal = ::LoadResource( hInstance, hResource );
+	if( hGlobal == NULL )
+	{
+		return( NULL );
+	}
+
+	pImage = (const ATLSTRINGRESOURCEIMAGE*)::LockResource( hGlobal );
+	if( pImage == NULL )
+	{
+		return( NULL );
+	}
+
+	nResourceSize = ::SizeofResource( hInstance, hResource );
+	pImageEnd = (const ATLSTRINGRESOURCEIMAGE*)(LPBYTE( pImage )+nResourceSize);
+	iIndex = id&0x000f;
+
+	while( (iIndex > 0) && (pImage < pImageEnd) )
+	{
+		pImage = (const ATLSTRINGRESOURCEIMAGE*)(LPBYTE( pImage )+(sizeof( ATLSTRINGRESOURCEIMAGE )+(pImage->nLength*sizeof( WCHAR ))));
+		iIndex--;
+	}
+	if( pImage >= pImageEnd )
+	{
+		return( NULL );
+	}
+	if( pImage->nLength == 0 )
+	{
+		return( NULL );
+	}
+
+	return( pImage );
+}
+
+inline const ATLSTRINGRESOURCEIMAGE* AtlGetStringResourceImage( HINSTANCE hInstance, UINT id ) throw()
+{
+	HRSRC hResource;
+
+	hResource = ::FindResource( hInstance, MAKEINTRESOURCE( ((id>>4)+1) ), RT_STRING );
+	if( hResource == NULL )
+	{
+		return( NULL );
+	}
+
+	return _AtlGetStringResourceImage( hInstance, hResource, id );
+}
+
+inline const ATLSTRINGRESOURCEIMAGE* AtlGetStringResourceImage( HINSTANCE hInstance, UINT id, WORD wLanguage ) throw()
+{
+	HRSRC hResource;
+
+	hResource = ::FindResourceEx( hInstance, RT_STRING, MAKEINTRESOURCE( ((id>>4)+1) ), wLanguage );
+	if( hResource == NULL )
+	{
+		return( NULL );
+	}
+
+	return _AtlGetStringResourceImage( hInstance, hResource, id );
+}
+
+inline const ATLSTRINGRESOURCEIMAGE* AtlGetStringResourceImage( UINT id ) throw()
+{
+	const ATLSTRINGRESOURCEIMAGE* p = NULL;
+	HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
+
+	for (int i = 1; hInst != NULL && p == NULL; hInst = _AtlBaseModule.GetHInstanceAt(i++))
+	{
+		p = AtlGetStringResourceImage(hInst, id);
+	}
+	return p;
+}
+
+inline const ATLSTRINGRESOURCEIMAGE* AtlGetStringResourceImage( UINT id, WORD wLanguage ) throw()
+{
+	const ATLSTRINGRESOURCEIMAGE* p = NULL;
+	HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
+
+	for (int i = 1; hInst != NULL && p == NULL; hInst = _AtlBaseModule.GetHInstanceAt(i++))
+	{
+		p = AtlGetStringResourceImage(hInst, id, wLanguage);
+	}
+	return p;
+}
+
+inline int AtlLoadString(__in UINT nID, __out_ecount_part_z(nBufferMax, return + 1) LPTSTR lpBuffer, __in int nBufferMax) throw()
+{
+	HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
+	int nRet = 0;
+
+	for (int i = 1; hInst != NULL && nRet == 0; hInst = _AtlBaseModule.GetHInstanceAt(i++))
+	{
+		nRet = LoadString(hInst, nID, lpBuffer, nBufferMax);
+	}
+	return nRet;
+}
+
+inline HINSTANCE AtlFindResourceInstance(LPCTSTR lpName, LPCTSTR lpType, WORD wLanguage = 0) throw()
+{
+	ATLASSERT(lpType != RT_STRING);	// Call AtlFindStringResourceInstance to find the string
+	if (lpType == RT_STRING)
+		return NULL;
+
+	if (ATL_IS_INTRESOURCE(lpType))
+	{
+		/* Prefast false warnings caused by bad-shaped definition of MAKEINTRESOURCE macro from PSDK */
+		if (lpType == ATL_RT_ICON)
+		{
+			lpType = ATL_RT_GROUP_ICON;
+		}
+		else if (lpType == ATL_RT_CURSOR)
+		{
+			lpType = ATL_RT_GROUP_CURSOR;
+		}
+	}
+
+	HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
+	HRSRC hResource = NULL;
+
+	for (int i = 1; hInst != NULL; hInst = _AtlBaseModule.GetHInstanceAt(i++))
+	{
+		hResource = ::FindResourceEx(hInst, lpType, lpName, wLanguage);
+		if (hResource != NULL)
+		{
+			return hInst;
+		}
+	}
+
+	return NULL;
+}
+
+inline HINSTANCE AtlFindResourceInstance(UINT nID, LPCTSTR lpType, WORD wLanguage = 0) throw()
+{
+	return AtlFindResourceInstance(MAKEINTRESOURCE(nID), lpType, wLanguage);
+}
+
+inline HINSTANCE AtlFindStringResourceInstance(UINT nID, WORD wLanguage = 0) throw()
+{
+	const ATLSTRINGRESOURCEIMAGE* p = NULL;
+	HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
+
+	for (int i = 1; hInst != NULL && p == NULL; hInst = _AtlBaseModule.GetHInstanceAt(i++))
+	{
+		p = AtlGetStringResourceImage(hInst, nID, wLanguage);
+		if (p != NULL)
+			return hInst;
+	}
+
+	return NULL;
+}
+
+/* 
+Needed by both atlcomcli and atlsafe, so needs to be in here 
+*/
+inline HRESULT AtlSafeArrayGetActualVartype
+(
+    SAFEARRAY *psaArray,
+    VARTYPE *pvtType
+)
+{
+    HRESULT hrSystem=::SafeArrayGetVartype(psaArray, pvtType);
+
+    if(FAILED(hrSystem))
+    {
+        return hrSystem;
+    }
+
+    /* 
+    When Windows has a SAFEARRAY of type VT_DISPATCH with FADF_HAVEIID,
+    it returns VT_UNKNOWN instead of VT_DISPATCH. We patch the value to be correct
+    */
+    if(pvtType && *pvtType==VT_UNKNOWN)
+    {
+        if(psaArray && ((psaArray->fFeatures & FADF_HAVEIID)!=0))
+        {
+            if(psaArray->fFeatures & FADF_DISPATCH)
+            {
+                *pvtType=VT_DISPATCH;
+            }
+        }
+    }
+
+    return hrSystem;
+}
+template <typename _CharType>
+inline _CharType* AtlCharNext(const _CharType* p) throw()
+{
+	ATLASSUME(p != NULL);	// Too expensive to check separately here 
+	if (*p == '\0')  // ::CharNextA won't increment if we're at a \0 already
+		return const_cast<_CharType*>(p+1);
+	else
+		return ::CharNextA(p);
+}
+
+template <>
+inline wchar_t* AtlCharNext<wchar_t>(const wchar_t* p) throw()
+{
+	return const_cast< wchar_t* >( p+1 );
+}
+template<typename CharType>
+inline const CharType* AtlstrchrT(const CharType* p, CharType ch) throw()
+{
+	ATLASSERT(p != NULL);	
+	if(p==NULL)
+	{
+		return NULL;
+	}
+	while( *p != 0 )
+	{
+		if (*p == ch)
+		{
+			return p;
+		}
+		p = AtlCharNext(p);
+	}
+	//strchr for '\0' should succeed - the while loop terminates 
+	//*p == 0, but ch also == 0, so NULL terminator address is returned
+	return (*p == ch) ? p : NULL;
+}
+//Ansi and Unicode versions of printf, used with templated CharType trait classes.
+#pragma warning(push)
+#pragma warning(disable : 4793)
+template<typename CharType>
+inline int AtlprintfT(const CharType* pszFormat,... ) throw()
+{
+	int retval=0;
+	va_list argList;
+	va_start( argList, pszFormat );
+	retval=vprintf(pszFormat,argList);
+	va_end( argList );
+	return retval;
+}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+template<>
+inline int AtlprintfT(const wchar_t* pszFormat,... ) throw()
+{
+	int retval=0;
+	va_list argList;
+	va_start( argList, pszFormat );
+	retval=vwprintf(pszFormat,	argList);
+	va_end( argList );
+	return retval;
+}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4068 28110)
+
+inline BOOL AtlConvertSystemTimeToVariantTime(const SYSTEMTIME& systimeSrc,double* pVarDtTm)
+{
+	ATLENSURE(pVarDtTm!=NULL);
+	//Convert using ::SystemTimeToVariantTime and store the result in pVarDtTm then
+	//convert variant time back to system time and compare to original system time.	
+
+	BOOL ok = ::SystemTimeToVariantTime(const_cast<SYSTEMTIME*>(&systimeSrc), pVarDtTm);
+
+	SYSTEMTIME sysTime;
+	::ZeroMemory(&sysTime, sizeof(SYSTEMTIME));
+
+	ok = ok && ::VariantTimeToSystemTime(*pVarDtTm, &sysTime);
+	ok = ok && (systimeSrc.wYear == sysTime.wYear &&
+			systimeSrc.wMonth == sysTime.wMonth &&
+			systimeSrc.wDay == sysTime.wDay &&
+			systimeSrc.wHour == sysTime.wHour &&
+			systimeSrc.wMinute == sysTime.wMinute && 
+			systimeSrc.wSecond == sysTime.wSecond);
+
+	return ok;
+}
+#pragma warning(pop)
+
+/////////////////////////////////////////////////////////////////////////////
+
+}	// namespace ATL
+#pragma pack(pop)
+
+#ifdef _ATL_ALL_WARNINGS
+#pragma warning( pop )
+#endif
+
+#endif	// __ATLCORE_H__
+

c/jacob/include/atldef.h

@@ -0,0 +1,668 @@
+
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the
+// Active Template Library product.
+
+#ifndef __ATLDEF_H__
+#define __ATLDEF_H__
+
+#pragma once
+
+#pragma warning(disable : 4619)	// there is no warning number
+
+#include <atlrc.h>
+#include <errno.h>
+#include <sal.h>
+
+#ifndef RC_INVOKED
+
+#ifndef __cplusplus
+	#error ATL requires C++ compilation (use a .cpp suffix)
+#endif
+
+#ifdef UNDER_CE
+	#error This version of ATL is not currently supported for CE. Look for the CE specific version.
+#endif
+
+// If you are mixing compilation units that are built as
+// native code with those that are built /clr, you must define
+// the symbol '_ATL_MIXED'. _ATL_MIXED must be defined for all 
+// compilation units in an executable or it must be defined for none of them.
+#if !defined(_ATL_MIXED)
+namespace Inconsistent_definition_of_symbol__ATL_MIXED
+{
+	struct _Please_define_it_the_same_throughout_your_project { };
+}
+#else
+namespace Inconsistent_definition_of_symbol__ATL_MIXED
+{
+#ifdef _M_IX86
+#pragma comment(linker, "/include:??3@YAXPAX@Z")
+#else
+#pragma comment(linker, "/include:??3@YAXPEAX@Z")
+#endif
+	struct _Please_define_it_the_same_throughout_your_project { virtual void one(){} };
+}
+#endif
+namespace Inconsistent_definition_of_symbol__ATL_MIXED
+{
+	__declspec(selectany) _Please_define_it_the_same_throughout_your_project clash = _Please_define_it_the_same_throughout_your_project ();
+}
+
+#if !defined(_ATL_MIXED)
+namespace Define_the_symbol__ATL_MIXED
+{
+#if defined(_M_CEE)
+	struct Thank_you { };
+#else
+#ifdef _M_IX86
+#pragma comment(linker, "/include:??3@YAXPAX@Z")
+#else
+#pragma comment(linker, "/include:??3@YAXPEAX@Z")
+#endif
+	struct Thank_you { virtual void one(){} };
+#endif
+	__declspec(selectany) Thank_you clash = Thank_you();
+}
+#endif
+
+#if defined(_ATL_MIXED)
+#define _ATL_NATIVE_INITIALIZATION
+#endif
+
+#if !defined(_M_CEE)
+#define _ATL_NATIVE_INITIALIZATION
+#endif
+
+#ifdef _UNICODE
+#ifndef UNICODE
+#define UNICODE         // UNICODE is used by Windows headers
+#endif
+#endif
+
+#ifdef UNICODE
+#ifndef _UNICODE
+#define _UNICODE        // _UNICODE is used by C-runtime/MFC headers
+#endif
+#endif
+
+#ifdef _DEBUG
+#ifndef DEBUG
+#define DEBUG
+#endif
+#endif
+
+#ifdef _WIN64
+#define _ATL_SUPPORT_VT_I8  // Always support VT_I8 on Win64.
+#endif
+
+#if !defined(UNALIGNED)
+#if defined(_M_IA64) || defined(_M_AMD64)
+#define UNALIGNED __unaligned
+#else
+#define UNALIGNED
+#endif
+#endif
+
+#if !defined(_countof)
+#if !defined(__cplusplus)
+#define _countof(_Array) (sizeof(_Array) / sizeof(_Array[0]))
+#else
+extern "C++"
+{
+template <typename _CountofType, size_t _SizeOfArray>
+char (*__countof_helper(UNALIGNED _CountofType (&_Array)[_SizeOfArray]))[_SizeOfArray];
+#define _countof(_Array) sizeof(*__countof_helper(_Array))
+}
+#endif
+#endif
+
+#ifndef AtlThrow
+#ifndef _ATL_CUSTOM_THROW
+#define AtlThrow ATL::AtlThrowImpl
+#endif
+#endif // AtlThrow
+
+#ifndef ATLASSERT
+#define ATLASSERT(expr) _ASSERTE(expr)
+#endif // ATLASSERT
+
+/* 
+Why does ATLASSUME exist?
+
+ATL 8 has two existing validation models
+
+ATLASSERT/ATLVERIFY - These are used to make sure a debug build reports a problem with the expression/invariant
+ATLENSURE - Debug is the same as ATLVERIFY, retail throws a C++ exception
+
+We added ATLENSURE because there were too many unreported error paths in ATL and we wanted to bail out of more
+error conditions rather than just trying to continue in retail.
+
+There might be a case for changing 'lots' of ATLASSERT to ATLENSURE, but we chose an incremental approach and only
+changed over where we saw a problem with code reported from a customer or test case. This reduces code churn in our
+code for this version.
+
+In general, our approach is to try to make sure that when something goes wrong
+- the client does not continue to run, because we report an error condition
+- debug builds see an assertion about the problem
+
+Sometimes we have code like
+
+HRESULT ComMethod(void)
+{
+	ATLASSUME(m_pFoo);
+	return m_pFoo->Method();
+}
+
+We could add
+	if(!m_pFoo) return E_POINTER;
+
+But this is very unlikely to help, since it removes the ability of the developer to debug this problem if it's seen in a retail
+build of the application. 
+
+We could try something more severe
+
+	if(!m_pFoo) terminate(); // or your favourite shutdown function
+
+This would ensure good reporting (because VC8 terminate generates a Windows Error Report and crash dump), but hardly seems a big win 
+over the previous crash.
+
+ATLENSURE might seem slightly better. It is debuggable and consistent with ATL in general. In fact, many parts of ATL do just this. 
+But in this specific context, it doesn't look like a great choice. COM methods should not in general be emitting native C++ exceptions 
+as an error reporting strategy. 
+
+So we find ourselves in a quandry. For these kinds of methods, the traditional code (ATLASSERT followed by a crash), seems be the most 
+debuggable thing to do in this situation. At least for VS8, we have decided to stick with this shape.
+
+---
+
+Now consider the impact of cl /analyze. We want cl /analyze to not warn about our potential dereferences when they refer to member variables
+whose state was previously validated by another method. But we do want to see the impact of function contracts on the parameters of the
+function. 
+
+So we've done a broad replace of all the member-related ATLASSERT to ATLASSUME. 
+
+*/
+
+#ifndef ATLASSUME
+#define ATLASSUME(expr) do { ATLASSERT(expr); __analysis_assume(!!(expr)); } while(0)
+#endif // ATLASSERT
+
+#ifndef ATLVERIFY
+#ifdef _DEBUG
+#define ATLVERIFY(expr) ATLASSERT(expr)
+#else
+#define ATLVERIFY(expr) (expr)
+#endif // DEBUG
+#endif // ATLVERIFY
+
+#ifndef ATLENSURE_THROW
+#define ATLENSURE_THROW(expr, hr)          \
+do {                                       \
+	int __atl_condVal=!!(expr);            \
+	ATLASSERT(__atl_condVal);              \
+	if(!(__atl_condVal)) AtlThrow(hr);     \
+} while (0)
+#endif // ATLENSURE
+
+#ifndef ATLENSURE
+#define ATLENSURE(expr) ATLENSURE_THROW(expr, E_FAIL)
+#endif // ATLENSURE
+
+#ifndef ATLENSURE_SUCCEEDED
+#define ATLENSURE_SUCCEEDED(hr) ATLENSURE_THROW(SUCCEEDED(hr), hr)
+#endif // ATLENSURE
+
+/* Used inside COM methods that do not want to throw */
+#ifndef ATLENSURE_RETURN_HR
+#define ATLENSURE_RETURN_HR(expr, hr)          \
+do {                                           \
+	int __atl_condVal=!!(expr);                \
+	ATLASSERT(__atl_condVal);                  \
+	if(!(__atl_condVal)) return hr;            \
+} while (0) 
+#endif 
+
+/* Used inside COM methods that do not want to throw */
+#ifndef ATLENSURE_RETURN
+#define ATLENSURE_RETURN(expr) ATLENSURE_RETURN_HR(expr, E_FAIL)
+#endif
+
+/* generic version that returns 2nd expr if 1st is false; no implication of HRESULT */
+#ifndef ATLENSURE_RETURN_VAL
+#define ATLENSURE_RETURN_VAL ATLENSURE_RETURN_HR
+#endif
+
+#if defined(_SECURE_ATL)
+#error Do not define _SECURE_ATL.
+#undef _SECURE_ATL
+#endif
+#define _SECURE_ATL 1
+
+#if _SECURE_ATL
+
+#ifndef ATL_CRT_ERRORCHECK
+#define ATL_CRT_ERRORCHECK(expr) AtlCrtErrorCheck(expr)
+#endif // ATL_CRT_ERRORCHECK
+
+#ifndef ATL_CRT_ERRORCHECK_SPRINTF
+#define ATL_CRT_ERRORCHECK_SPRINTF(expr) \
+do { \
+	errno_t _saveErrno = errno; \
+	errno = 0; \
+	(expr); \
+	if(0 != errno) \
+	{ \
+		AtlCrtErrorCheck(errno); \
+	} \
+	else \
+	{ \
+		errno = _saveErrno; \
+	} \
+} while (0)
+#endif // ATL_CRT_ERRORCHECK_SPRINTF
+
+#else // !_SECURE_ATL
+
+#define ATL_CRT_ERRORCHECK(expr) do { expr; } while (0)
+#define ATL_CRT_ERRORCHECK_SPRINTF(expr) do { expr; } while (0)
+
+#endif // _SECURE_ATL
+
+///////////////////////////////////////////////////////////////////////////////
+// __declspec(novtable) is used on a class declaration to prevent the vtable
+// pointer from being initialized in the constructor and destructor for the
+// class.  This has many benefits because the linker can now eliminate the
+// vtable and all the functions pointed to by the vtable.  Also, the actual
+// constructor and destructor code are now smaller.
+///////////////////////////////////////////////////////////////////////////////
+// This should only be used on a class that is not directly createable but is
+// rather only used as a base class.  Additionally, the constructor and
+// destructor (if provided by the user) should not call anything that may cause
+// a virtual function call to occur back on the object.
+///////////////////////////////////////////////////////////////////////////////
+// By default, the wizards will generate new ATL object classes with this
+// attribute (through the ATL_NO_VTABLE macro).  This is normally safe as long
+// the restriction mentioned above is followed.  It is always safe to remove
+// this macro from your class, so if in doubt, remove it.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef _ATL_DISABLE_NO_VTABLE
+#define ATL_NO_VTABLE
+#else
+#define ATL_NO_VTABLE __declspec(novtable)
+#endif
+
+#ifdef _ATL_DISABLE_NOTHROW
+#define ATL_NOTHROW
+#else
+#define ATL_NOTHROW __declspec(nothrow)
+#endif
+
+#ifdef _ATL_DISABLE_FORCEINLINE
+#define ATL_FORCEINLINE
+#else
+#define ATL_FORCEINLINE __forceinline
+#endif
+
+#ifdef _ATL_DISABLE_NOINLINE
+#define ATL_NOINLINE
+#else
+#define ATL_NOINLINE __declspec( noinline )
+#endif
+
+#if defined(_ATL_DISABLE_DEPRECATED) || (defined(_PREFAST_) && (_MSC_VER < 1400))
+#define ATL_DEPRECATED(_Message)
+#else
+#define ATL_DEPRECATED(_Message) __declspec( deprecated(_Message) )
+#endif
+
+// If ATL80.DLL is being used then _ATL_STATIC_REGISTRY doesn't really make sense
+#ifdef _ATL_DLL
+#undef _ATL_STATIC_REGISTRY
+#else
+// If not linking to ATL80.DLL, use the static registrar and not building atl.dll
+#ifndef _ATL_DLL_IMPL
+#ifndef _ATL_STATIC_REGISTRY
+#define _ATL_STATIC_REGISTRY
+#endif
+#endif
+#endif
+
+#ifdef _ATL_DEBUG_REFCOUNT
+#ifndef _ATL_DEBUG_INTERFACES
+#define _ATL_DEBUG_INTERFACES
+#endif
+#endif
+
+#ifdef _DEBUG
+#ifndef _ATL_DEBUG
+#define _ATL_DEBUG
+#endif // _ATL_DEBUG
+#endif // _DEBUG
+
+#ifdef _ATL_DEBUG_INTERFACES
+#ifndef _ATL_DEBUG
+#define _ATL_DEBUG
+#endif // _ATL_DEBUG
+#endif // _ATL_DEBUG_INTERFACES
+
+#ifndef _ATL_HEAPFLAGS
+#ifdef _MALLOC_ZEROINIT
+#define _ATL_HEAPFLAGS HEAP_ZERO_MEMORY
+#else
+#define _ATL_HEAPFLAGS 0
+#endif
+#endif
+
+#ifndef _ATL_PACKING
+#define _ATL_PACKING 8
+#endif
+
+#if defined(_ATL_DLL)
+	#define ATLAPI extern "C" HRESULT __declspec(dllimport) __stdcall
+	#define ATLAPI_(x) extern "C" __declspec(dllimport) x __stdcall
+	#define ATLINLINE
+	#define ATLAPIINL extern "C" inline HRESULT __stdcall
+	#define ATLAPIINL_(x) extern "C" inline x __stdcall
+#elif defined(_ATL_DLL_IMPL)
+	#define ATLAPI extern "C" inline HRESULT __stdcall
+	#define ATLAPI_(x) extern "C" inline x __stdcall
+	#define ATLAPIINL ATLAPI
+	#define ATLAPIINL_(x) ATLAPI_(x)
+	#define ATLINLINE
+#else
+	#define ATLAPI __declspec(nothrow) HRESULT __stdcall
+	#define ATLAPI_(x) __declspec(nothrow) x __stdcall
+	#define ATLAPIINL ATLAPI
+	#define ATLAPIINL_(x) ATLAPI_(x)
+	#define ATLINLINE inline
+#endif
+
+#ifdef _ATL_NO_EXCEPTIONS
+	#ifdef _AFX
+	#error MFC projects cannot define _ATL_NO_EXCEPTIONS
+	#endif
+#else
+	#ifndef _CPPUNWIND
+	#define _ATL_NO_EXCEPTIONS
+	#endif
+#endif
+
+#ifdef _CPPUNWIND
+
+#ifndef ATLTRYALLOC
+
+#ifdef _AFX
+#define ATLTRYALLOC(x) try{x;} catch(CException* e){e->Delete();}
+#else
+/* prefast noise VSW 489981 */
+#define ATLTRYALLOC(x) __pragma(warning(push)) __pragma(warning(disable: 4571)) try{x;} catch(...) {} __pragma(warning(pop))
+#endif	//__AFX
+
+#endif	//ATLTRYALLOC
+
+// If you define _ATLTRY before including this file, then
+// you should define _ATLCATCH and _ATLRETHROW as well.
+#ifndef _ATLTRY
+#define _ATLTRY try
+#ifdef _AFX
+#define _ATLCATCH( e ) catch( CException* e )
+#else
+#define _ATLCATCH( e ) catch( CAtlException e )
+#endif
+
+#define _ATLCATCHALL() __pragma(warning(push)) __pragma(warning(disable: 4571)) catch( ... ) __pragma(warning(pop))
+
+#ifdef _AFX
+#define _ATLDELETEEXCEPTION(e) e->Delete();
+#else
+#define _ATLDELETEEXCEPTION(e) e;
+#endif
+
+#define _ATLRETHROW throw
+#endif	// _ATLTRY
+
+/* 
+COM functions should not throw. Which means we should protect their callers from C++ exceptions leaking out. These macros
+can help with that, though they have not yet been applied to the whole of ATL, which uses a variety of patterns to achieve
+this end
+*/
+ 
+#ifndef _ATL_COM_BEGIN 
+#define _ATL_COM_BEGIN \
+	HRESULT __hrAtlComMethod=S_OK; \
+	try \
+	{
+#endif
+
+#ifdef _AFX
+/* Nice to do something more complex here in future to translate an MFC exception to a better HR */
+#define _AFX_COM_END_PART \
+	catch(CException *e) \
+	{ \
+		if(e) \
+		{ \
+			e->Delete(); \
+		} \
+		__hrAtlComMethod=E_FAIL; \
+	}
+#else
+#define _AFX_COM_END_PART \
+	catch(CAtlException e) \
+	{ \
+		__hrAtlComMethod=e.m_hr; \
+	}
+#endif
+
+#ifndef _ATL_COM_END 
+#define _ATL_COM_END \
+	_AFX_COM_END_PART \
+	catch(...) \
+	{ \
+		__hrAtlComMethod=E_FAIL; \
+	} \
+	return hr; 
+#endif
+
+
+
+#else //_CPPUNWIND
+
+#ifndef ATLTRYALLOC
+#define ATLTRYALLOC(x) x;
+#endif	//ATLTRYALLOC
+
+// if _ATLTRY is defined before including this file then 
+// _ATLCATCH and _ATLRETHROW should be defined as well.
+#ifndef _ATLTRY
+#define _ATLTRY
+#define _ATLCATCH( e ) __pragma(warning(push)) __pragma(warning(disable: 4127)) if( false ) __pragma(warning(pop))
+#define _ATLCATCHALL() __pragma(warning(push)) __pragma(warning(disable: 4127)) if( false ) __pragma(warning(pop))
+#define _ATLDELETEEXCEPTION(e)
+#define _ATLRETHROW
+#endif	// _ATLTRY
+
+#endif	//_CPPUNWIND
+
+#ifndef ATLTRY
+#define ATLTRY(x) ATLTRYALLOC(x)
+#endif	//ATLTRY
+
+#define offsetofclass(base, derived) ((DWORD_PTR)(static_cast<base*>((derived*)_ATL_PACKING))-_ATL_PACKING)
+
+/////////////////////////////////////////////////////////////////////////////
+// Master version numbers
+
+#define _ATL     1      // Active Template Library
+#define _ATL_VER 0x0800 // Active Template Library version 8.00
+
+/////////////////////////////////////////////////////////////////////////////
+// Threading
+
+#ifndef _ATL_SINGLE_THREADED
+#ifndef _ATL_APARTMENT_THREADED
+#ifndef _ATL_FREE_THREADED
+#define _ATL_FREE_THREADED
+#endif
+#endif
+#endif
+
+// UUIDOF
+#ifndef _ATL_NO_UUIDOF
+#define _ATL_IIDOF(x) __uuidof(x)
+#else
+#define _ATL_IIDOF(x) IID_##x
+#endif
+
+// Lean and mean
+#ifndef ATL_NO_LEAN_AND_MEAN
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#ifndef NOMCX
+#define NOMCX
+#endif
+#endif	// ATL_NO_LEAN_AND_MEAN
+
+#ifdef NOSERVICE
+#ifndef _ATL_NO_SERVICE
+#define _ATL_NO_SERVICE
+#endif	// _ATL_NO_SERVICE
+#else
+#ifdef _ATL_NO_SERVICE
+#ifndef NOSERVICE
+#define NOSERVICE
+#endif	// NOSERVICE
+#endif	// _ATL_NO_SERVICE
+#endif	// NOSERVICE
+
+#include <malloc.h>
+#ifdef _DEBUG
+#include <stdlib.h>
+#endif
+#ifndef _ATL_NO_DEBUG_CRT
+// Warning: if you define the above symbol, you will have
+// to provide your own definition of the ATLASSERT(x) macro
+// in order to compile ATL
+	#include <crtdbg.h>
+#endif
+
+#endif // RC_INVOKED
+
+#define ATLAXWIN_CLASS	"AtlAxWin80"
+#define ATLAXWINLIC_CLASS "AtlAxWinLic80"
+
+// _ATL_INSECURE_DEPRECATE define
+#ifndef _ATL_INSECURE_DEPRECATE
+#if defined(_ATL_SECURE_NO_DEPRECATE) || (defined(_PREFAST_) && (_MSC_VER < 1400))
+#define _ATL_INSECURE_DEPRECATE(_Message)
+#else
+#define _ATL_INSECURE_DEPRECATE(_Message) __declspec(deprecated(_Message))
+#endif // _ATL_SECURE_NO_DEPRECATE
+#endif // _ATL_INSECURE_DEPRECATE
+
+/*
+This is called when something really bad happens -- so bad
+that we consider it dangerous to even throw an exception
+*/
+#ifndef _ATL_FATAL_SHUTDOWN
+#define _ATL_FATAL_SHUTDOWN do { ::TerminateProcess(::GetCurrentProcess(), 0); } while(0);
+#endif
+
+//ATL/MFC code should use standard pointer to member standard syntax &MyClass::MyMethod, instead
+//of the legacy non-standard syntax - MyMethod.
+#ifdef _ATL_ENABLE_PTM_WARNING
+#define PTM_WARNING_DISABLE
+#define PTM_WARNING_RESTORE
+#else
+#define PTM_WARNING_DISABLE \
+	__pragma(warning( push )) \
+	__pragma(warning( disable : 4867 ))
+#define PTM_WARNING_RESTORE \
+	__pragma(warning( pop ))
+#endif //_ATL_ENABLE_PTM_WARNING
+
+/* we have to define our own versions of MAKEINTRESOURCE and IS_INTRESOURCE to 
+ * fix warning 6268. At least until those macros are not cleanend in PSDK.
+   Same comes true for those definitions of constants which use the above macros
+*/
+#define ATL_MAKEINTRESOURCEA(i) ((LPSTR)((ULONG_PTR)((WORD)(i))))
+#define ATL_MAKEINTRESOURCEW(i) ((LPWSTR)((ULONG_PTR)((WORD)(i))))
+#ifdef UNICODE
+#define ATL_MAKEINTRESOURCE  ATL_MAKEINTRESOURCEW
+#else
+#define ATL_MAKEINTRESOURCE  ATL_MAKEINTRESOURCEA
+#endif // !UNICODE
+#define ATL_IS_INTRESOURCE(_r) ((((ULONG_PTR)(_r)) >> 16) == 0)
+
+/*
+ * Predefined Resource Types
+ */
+#define ATL_RT_CURSOR           ATL_MAKEINTRESOURCE(1)
+#define ATL_RT_BITMAP           ATL_MAKEINTRESOURCE(2)
+#define ATL_RT_ICON             ATL_MAKEINTRESOURCE(3)
+#define ATL_RT_MENU             ATL_MAKEINTRESOURCE(4)
+#define ATL_RT_DIALOG           ATL_MAKEINTRESOURCE(5)
+#define ATL_RT_STRING           ATL_MAKEINTRESOURCE(6)
+#define ATL_RT_FONTDIR          ATL_MAKEINTRESOURCE(7)
+#define ATL_RT_FONT             ATL_MAKEINTRESOURCE(8)
+#define ATL_RT_ACCELERATOR      ATL_MAKEINTRESOURCE(9)
+#define ATL_RT_RCDATA           ATL_MAKEINTRESOURCE(10)
+#define ATL_RT_MESSAGETABLE     ATL_MAKEINTRESOURCE(11)
+
+#define ATL_DIFFERENCE     11
+#define ATL_RT_GROUP_CURSOR ATL_MAKEINTRESOURCE((ULONG_PTR)ATL_RT_CURSOR + ATL_DIFFERENCE)
+#define ATL_RT_GROUP_ICON   ATL_MAKEINTRESOURCE((ULONG_PTR)ATL_RT_ICON + ATL_DIFFERENCE)
+#define ATL_RT_VERSION      ATL_MAKEINTRESOURCE(16)
+#define ATL_RT_DLGINCLUDE   ATL_MAKEINTRESOURCE(17)
+#if(WINVER >= 0x0400)
+#define ATL_RT_PLUGPLAY     ATL_MAKEINTRESOURCE(19)
+#define ATL_RT_VXD          ATL_MAKEINTRESOURCE(20)
+#define ATL_RT_ANICURSOR    ATL_MAKEINTRESOURCE(21)
+#define ATL_RT_ANIICON      ATL_MAKEINTRESOURCE(22)
+#endif /* WINVER >= 0x0400 */
+#define ATL_RT_HTML         ATL_MAKEINTRESOURCE(23)
+#ifdef RC_INVOKED
+#define ATL_RT_MANIFEST                        24
+#define ATL_CREATEPROCESS_MANIFEST_RESOURCE_ID  1
+#define ATL_ISOLATIONAWARE_MANIFEST_RESOURCE_ID 2
+#define ATL_ISOLATIONAWARE_NOSTATICIMPORT_MANIFEST_RESOURCE_ID 3
+#define ATL_MINIMUM_RESERVED_MANIFEST_RESOURCE_ID 1   /* inclusive */
+#define ATL_MAXIMUM_RESERVED_MANIFEST_RESOURCE_ID 16  /* inclusive */
+#else  /* RC_INVOKED */
+#define ATL_RT_MANIFEST                        ATL_MAKEINTRESOURCE(24)
+#define ATL_CREATEPROCESS_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE( 1)
+#define ATL_ISOLATIONAWARE_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE(2)
+#define ATL_ISOLATIONAWARE_NOSTATICIMPORT_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE(3)
+#define ATL_MINIMUM_RESERVED_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE( 1 /*inclusive*/)
+#define ATL_MAXIMUM_RESERVED_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE(16 /*inclusive*/)
+#endif /* RC_INVOKED */
+
+/* sal.h stuff that is not in the current LKG */
+#ifndef __out_ecount_part_z
+#define __out_ecount_part_z(size,length)                        __out_ecount_part(size,length) __post __nullterminated
+#endif
+
+#ifndef __out_ecount_part_z_opt
+#define __out_ecount_part_z_opt(size,length)                    __out_ecount_part_opt(size,length) __post __nullterminated
+#endif
+
+#ifndef __deref_opt_out_z
+#define __deref_opt_out_z                                       __deref_opt_out __post __deref __nullterminated
+#endif
+
+#ifndef __out_bcount_part_z
+#define __out_bcount_part_z(size,length)                        __out_bcount_part(size,length) __post __nullterminated
+#endif
+
+#endif // __ATLDEF_H__
+
+/////////////////////////////////////////////////////////////////////////////
+

c/jacob/include/atlexcept.h

@@ -0,0 +1,123 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the
+// Active Template Library product.
+
+#ifndef __ATLEXCEPT_H__
+#define __ATLEXCEPT_H__
+
+#pragma once
+
+#include <atldef.h>
+#include <atltrace.h>
+
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+
+/////////////////////////////////////////////////////////////////////////////
+// Exception raise (for functions that cannot return an error code)
+
+inline void __declspec(noreturn) _AtlRaiseException( DWORD dwExceptionCode, DWORD dwExceptionFlags = EXCEPTION_NONCONTINUABLE )
+{
+	RaiseException( dwExceptionCode, dwExceptionFlags, 0, NULL );
+}
+
+class CAtlException
+{
+public:
+	CAtlException() throw() :
+		m_hr( E_FAIL )
+	{
+	}
+
+	CAtlException( HRESULT hr ) throw() :
+		m_hr( hr )
+	{
+	}
+
+	operator HRESULT() const throw()
+	{
+		return( m_hr );
+	}
+
+public:
+	HRESULT m_hr;
+};
+
+#ifndef _ATL_NO_EXCEPTIONS
+
+// Throw a CAtlException with the given HRESULT
+#if defined( _ATL_CUSTOM_THROW )  // You can define your own AtlThrow to throw a custom exception.
+#ifdef _AFX
+#error MFC projects must use default implementation of AtlThrow()
+#endif
+#else
+ATL_NOINLINE __declspec(noreturn) inline void WINAPI AtlThrowImpl( HRESULT hr )
+{
+	ATLTRACE(atlTraceException, 0, _T("AtlThrow: hr = 0x%x\n"), hr );
+#ifdef _AFX
+	if( hr == E_OUTOFMEMORY )
+	{
+		AfxThrowMemoryException();
+	}
+	else
+	{
+		AfxThrowOleException( hr );
+	}
+#else
+	throw CAtlException( hr );
+#endif
+};
+#endif
+
+// Throw a CAtlException corresponding to the result of ::GetLastError
+ATL_NOINLINE __declspec(noreturn) inline void WINAPI AtlThrowLastWin32()
+{
+	DWORD dwError = ::GetLastError();
+	AtlThrow( HRESULT_FROM_WIN32( dwError ) );
+}
+
+#else  // no exception handling
+
+// Throw a CAtlException with the given HRESULT
+#if !defined( _ATL_CUSTOM_THROW )  // You can define your own AtlThrow
+
+ATL_NOINLINE inline void WINAPI AtlThrowImpl( HRESULT hr )
+{
+	ATLTRACE(atlTraceException, 0, _T("AtlThrow: hr = 0x%x\n"), hr );
+	ATLASSERT( false );
+	DWORD dwExceptionCode;
+	switch(hr)
+	{
+	case E_OUTOFMEMORY:
+		dwExceptionCode = DWORD(STATUS_NO_MEMORY);
+		break;
+	default:
+		dwExceptionCode = DWORD(EXCEPTION_ILLEGAL_INSTRUCTION);
+		break;
+	}
+	_AtlRaiseException(dwExceptionCode);
+}
+#endif
+
+// Throw a CAtlException corresponding to the result of ::GetLastError
+ATL_NOINLINE inline void WINAPI AtlThrowLastWin32()
+{
+	DWORD dwError = ::GetLastError();
+	AtlThrow( HRESULT_FROM_WIN32( dwError ) );
+}
+
+#endif  // no exception handling
+
+};  // namespace ATL
+#pragma pack(pop)
+
+#endif  // __ATLEXCEPT_H__
+

c/jacob/include/atlrc.h

@@ -0,0 +1,28 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the
+// Active Template Library product.
+
+#pragma once
+
+#ifndef __ATLRC_H__
+
+#define ATL_RESID_BASE						0xD800
+#define ATL_STRING_BASE						ATL_RESID_BASE
+
+#define ATL_IDS_DATETIME_INVALID			(ATL_STRING_BASE + 0)
+#define ATL_IDS_DATETIMESPAN_INVALID		(ATL_STRING_BASE + 1)
+
+#define ATL_SERVICE_MANAGER_OPEN_ERROR		(ATL_STRING_BASE + 10)
+#define ATL_SERVICE_START_ERROR				(ATL_STRING_BASE + 11)
+#define ATL_SERVICE_OPEN_ERROR				(ATL_STRING_BASE + 12)
+#define ATL_SERVICE_DELETE_ERROR			(ATL_STRING_BASE + 13)
+#define ATL_SERVICE_STOP_ERROR				(ATL_STRING_BASE + 14)
+
+#endif	// __ATLRC_H__
+

c/jacob/include/atlsimpcoll.h

@@ -0,0 +1,489 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the
+// Active Template Library product.
+
+#ifndef __ATLSIMPCOLL_H__
+#define __ATLSIMPCOLL_H__
+
+#pragma once
+
+#include <atldef.h>
+#include <atlchecked.h>
+#include <wchar.h>
+
+#pragma push_macro("malloc")
+#undef malloc
+#pragma push_macro("calloc")
+#undef calloc
+#pragma push_macro("realloc")
+#undef realloc
+#pragma push_macro("_recalloc")
+#undef _recalloc
+#pragma push_macro("free")
+#undef free
+
+#pragma warning(push)
+#pragma warning(disable: 4800) // forcing 'int' value to bool
+
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+
+#pragma push_macro("new")
+#undef new
+
+/////////////////////////////////////////////////////////////////////////////
+// Collection helpers - CSimpleArray & CSimpleMap
+
+// template class helpers with functions for comparing elements
+// override if using complex types without operator==
+template <class T>
+class CSimpleArrayEqualHelper
+{
+public:
+	static bool IsEqual(const T& t1, const T& t2)
+	{
+		return (t1 == t2);
+	}
+};
+
+template <class T>
+class CSimpleArrayEqualHelperFalse
+{
+public:
+	static bool IsEqual(const T&, const T&)
+	{
+		ATLASSERT(false);
+		return false;
+	}
+};
+
+template <class TKey, class TVal>
+class CSimpleMapEqualHelper
+{
+public:
+	static bool IsEqualKey(const TKey& k1, const TKey& k2)
+	{
+		return CSimpleArrayEqualHelper<TKey>::IsEqual(k1, k2);
+	}
+
+	static bool IsEqualValue(const TVal& v1, const TVal& v2)
+	{
+		return CSimpleArrayEqualHelper<TVal>::IsEqual(v1, v2);
+	}
+};
+
+template <class TKey, class TVal>
+class CSimpleMapEqualHelperFalse
+{
+public:
+	static bool IsEqualKey(const TKey& k1, const TKey& k2)
+	{
+		return CSimpleArrayEqualHelper<TKey>::IsEqual(k1, k2);
+	}
+
+	static bool IsEqualValue(const TVal&, const TVal&)
+	{
+		ATLASSERT(FALSE);
+		return false;
+	}
+};
+
+template <class T, class TEqual = CSimpleArrayEqualHelper< T > >
+class CSimpleArray
+{
+public:
+// Construction/destruction
+	CSimpleArray() : m_aT(NULL), m_nSize(0), m_nAllocSize(0)
+	{ }
+
+	~CSimpleArray();
+
+	CSimpleArray(const CSimpleArray< T, TEqual >& src) : m_aT(NULL), m_nSize(0), m_nAllocSize(0)
+	{
+        if (src.GetSize())
+        {
+			m_aT = (T*)calloc(src.GetSize(), sizeof(T));
+			if (m_aT != NULL)
+			{
+				m_nAllocSize = src.GetSize();
+				for (int i=0; i<src.GetSize(); i++)
+					Add(src[i]);
+			}
+		}
+	}
+	CSimpleArray< T, TEqual >& operator=(const CSimpleArray< T, TEqual >& src)
+	{
+		if (GetSize() != src.GetSize())
+		{
+			RemoveAll();
+			m_aT = (T*)calloc(src.GetSize(), sizeof(T));
+			if (m_aT != NULL)
+				m_nAllocSize = src.GetSize();
+		}
+		else
+		{
+			for (int i = GetSize(); i > 0; i--)
+				RemoveAt(i - 1);
+		}
+		for (int i=0; i<src.GetSize(); i++)
+			Add(src[i]);
+		return *this;
+	}
+
+// Operations
+	int GetSize() const
+	{
+		return m_nSize;
+		}
+		BOOL Add(const T& t)
+		{
+			if(m_nSize == m_nAllocSize)
+			{
+				T* aT;
+				int nNewAllocSize = (m_nAllocSize == 0) ? 1 : (m_nSize * 2);
+
+	  
+   				if (nNewAllocSize<0||nNewAllocSize>INT_MAX/sizeof(T))
+				{
+			 
+
+						return FALSE;
+			
+				}
+
+			 
+		
+				aT = (T*)_recalloc(m_aT, nNewAllocSize, sizeof(T));
+				if(aT == NULL)
+					return FALSE;
+				m_nAllocSize = nNewAllocSize;
+				m_aT = aT;
+						
+			}
+			InternalSetAtIndex(m_nSize, t);
+			m_nSize++;
+			return TRUE;
+		}
+	BOOL Remove(const T& t)
+	{
+		int nIndex = Find(t);
+		if(nIndex == -1)
+			return FALSE;
+		return RemoveAt(nIndex);
+	}
+	BOOL RemoveAt(int nIndex)
+	{
+		ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+		if (nIndex < 0 || nIndex >= m_nSize)
+			return FALSE;
+		m_aT[nIndex].~T();
+		if(nIndex != (m_nSize - 1))
+			Checked::memmove_s((void*)(m_aT + nIndex), (m_nSize - nIndex) * sizeof(T), (void*)(m_aT + nIndex + 1), (m_nSize - (nIndex + 1)) * sizeof(T));
+		m_nSize--;
+		return TRUE;
+	}
+	void RemoveAll()
+	{
+		if(m_aT != NULL)
+		{
+			for(int i = 0; i < m_nSize; i++)
+				m_aT[i].~T();
+			free(m_aT);
+			m_aT = NULL;
+		}
+		m_nSize = 0;
+		m_nAllocSize = 0;
+    }   
+	const T& operator[] (int nIndex) const
+	{
+		ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+		if(nIndex < 0 || nIndex >= m_nSize)
+		{
+			_AtlRaiseException((DWORD)EXCEPTION_ARRAY_BOUNDS_EXCEEDED);					
+		}
+		return m_aT[nIndex];
+	}
+	T& operator[] (int nIndex)
+	{
+		ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+		if(nIndex < 0 || nIndex >= m_nSize)
+		{
+			_AtlRaiseException((DWORD)EXCEPTION_ARRAY_BOUNDS_EXCEEDED);					
+		}
+		return m_aT[nIndex];
+	}
+	T* GetData() const
+	{
+		return m_aT;
+	}
+
+	int Find(const T& t) const
+	{
+		for(int i = 0; i < m_nSize; i++)
+		{
+			if(TEqual::IsEqual(m_aT[i], t))
+				return i;
+		}
+		return -1;  // not found
+	}
+
+	BOOL SetAtIndex(int nIndex, const T& t)
+	{
+		if (nIndex < 0 || nIndex >= m_nSize)
+			return FALSE;
+		InternalSetAtIndex(nIndex, t);
+		return TRUE;
+	}
+
+// Implementation
+	class Wrapper
+	{
+	public:
+		Wrapper(const T& _t) : t(_t)
+		{
+		}
+		template <class _Ty>
+		void * __cdecl operator new(size_t, _Ty* p)
+		{
+			return p;
+		}
+		template <class _Ty>
+		void __cdecl operator delete(void* /* pv */, _Ty* /* p */)
+		{
+		}
+		T t;
+	};
+
+// Implementation
+	void InternalSetAtIndex(int nIndex, const T& t)
+	{
+		new(m_aT + nIndex) Wrapper(t);
+	}
+
+	typedef T _ArrayElementType;
+	T* m_aT;
+	int m_nSize;
+	int m_nAllocSize;
+
+};
+
+#define CSimpleValArray CSimpleArray 
+
+	template <class T, class TEqual> inline  CSimpleArray<T, TEqual>::~CSimpleArray()
+	{
+		RemoveAll();
+	}
+
+// intended for small number of simple types or pointers
+template <class TKey, class TVal, class TEqual = CSimpleMapEqualHelper< TKey, TVal > >
+class CSimpleMap
+{
+public:
+	TKey* m_aKey;
+	TVal* m_aVal;
+	int m_nSize;
+
+	typedef TKey _ArrayKeyType;
+	typedef TVal _ArrayElementType;
+
+// Construction/destruction
+	CSimpleMap() : m_aKey(NULL), m_aVal(NULL), m_nSize(0)
+	{ }
+
+	~CSimpleMap()
+	{
+		RemoveAll();	
+	}
+
+// Operations
+	int GetSize() const
+	{
+		return m_nSize;
+	}
+	BOOL Add(const TKey& key, const TVal& val)
+	{
+		TKey* pKey;
+		pKey = (TKey*)_recalloc(m_aKey, (m_nSize + 1), sizeof(TKey));
+		if(pKey == NULL)
+			return FALSE;
+		m_aKey = pKey;
+		TVal* pVal;
+		pVal = (TVal*)_recalloc(m_aVal, (m_nSize + 1), sizeof(TVal));
+		if(pVal == NULL)
+			return FALSE;
+		m_aVal = pVal;
+		InternalSetAtIndex(m_nSize, key, val);
+		m_nSize++;
+		return TRUE;
+	}
+	BOOL Remove(const TKey& key)
+	{
+		int nIndex = FindKey(key);
+		if(nIndex == -1)
+			return FALSE;
+		return RemoveAt(nIndex);
+	}
+	BOOL RemoveAt(int nIndex)
+	{
+		ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+		if (nIndex < 0 || nIndex >= m_nSize)
+			return FALSE;
+		m_aKey[nIndex].~TKey();
+		m_aVal[nIndex].~TVal();
+		if(nIndex != (m_nSize - 1))
+		{
+			Checked::memmove_s((void*)(m_aKey + nIndex), (m_nSize - nIndex) * sizeof(TKey), (void*)(m_aKey + nIndex + 1), (m_nSize - (nIndex + 1)) * sizeof(TKey));
+			Checked::memmove_s((void*)(m_aVal + nIndex), (m_nSize - nIndex) * sizeof(TVal), (void*)(m_aVal + nIndex + 1), (m_nSize - (nIndex + 1)) * sizeof(TVal));
+		}
+		TKey* pKey;
+		pKey = (TKey*)_recalloc(m_aKey, (m_nSize - 1), sizeof(TKey));
+		if(pKey != NULL || m_nSize == 1)
+			m_aKey = pKey;
+		TVal* pVal;
+		pVal = (TVal*)_recalloc(m_aVal, (m_nSize - 1), sizeof(TVal));
+		if(pVal != NULL || m_nSize == 1)
+			m_aVal = pVal;
+		m_nSize--;
+		return TRUE;
+	}
+	void RemoveAll()
+	{
+		if(m_aKey != NULL)
+		{
+			for(int i = 0; i < m_nSize; i++)
+			{
+				m_aKey[i].~TKey();
+				m_aVal[i].~TVal();
+			}
+			free(m_aKey);
+			m_aKey = NULL;
+		}
+		if(m_aVal != NULL)
+		{
+			free(m_aVal);
+			m_aVal = NULL;
+		}
+
+		m_nSize = 0;
+	}
+	BOOL SetAt(const TKey& key, const TVal& val)
+	{
+		int nIndex = FindKey(key);
+		if(nIndex == -1)
+			return FALSE;
+		ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+		m_aKey[nIndex].~TKey();
+		m_aVal[nIndex].~TVal();
+		InternalSetAtIndex(nIndex, key, val);
+		return TRUE;
+	}
+	TVal Lookup(const TKey& key) const
+	{
+		int nIndex = FindKey(key);
+		if(nIndex == -1)
+			return NULL;    // must be able to convert
+		return GetValueAt(nIndex);
+	}
+	TKey ReverseLookup(const TVal& val) const
+	{
+		int nIndex = FindVal(val);
+		if(nIndex == -1)
+			return NULL;    // must be able to convert
+		return GetKeyAt(nIndex);
+	}
+	TKey& GetKeyAt(int nIndex) const
+	{
+		ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+		if(nIndex < 0 || nIndex >= m_nSize)
+			_AtlRaiseException((DWORD)EXCEPTION_ARRAY_BOUNDS_EXCEEDED);
+			
+		return m_aKey[nIndex];
+	}
+	TVal& GetValueAt(int nIndex) const
+	{
+		ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+		if(nIndex < 0 || nIndex >= m_nSize)
+			_AtlRaiseException((DWORD)EXCEPTION_ARRAY_BOUNDS_EXCEEDED);	
+			
+		return m_aVal[nIndex];
+	}
+
+	int FindKey(const TKey& key) const
+	{
+		for(int i = 0; i < m_nSize; i++)
+		{
+			if(TEqual::IsEqualKey(m_aKey[i], key))
+				return i;
+		}
+		return -1;  // not found
+	}
+	int FindVal(const TVal& val) const
+	{
+		for(int i = 0; i < m_nSize; i++)
+		{
+			if(TEqual::IsEqualValue(m_aVal[i], val))
+				return i;
+		}
+		return -1;  // not found
+	}
+
+	BOOL SetAtIndex(int nIndex, const TKey& key, const TVal& val)
+	{
+		if (nIndex < 0 || nIndex >= m_nSize)
+			return FALSE;
+		InternalSetAtIndex(nIndex, key, val);
+		return TRUE;
+	}
+
+
+// Implementation
+
+	template <typename T>
+	class Wrapper
+	{
+	public:
+		Wrapper(const T& _t) : t(_t)
+		{
+		}
+		template <class _Ty>
+		void *operator new(size_t, _Ty* p)
+		{
+			return p;
+		}
+		template <class _Ty>
+		void operator delete(void* /* pv */, _Ty* /* p */)
+		{
+		}
+		T t;
+	};
+	void InternalSetAtIndex(int nIndex, const TKey& key, const TVal& val)
+	{
+		new(m_aKey + nIndex) Wrapper<TKey>(key);
+		new(m_aVal + nIndex) Wrapper<TVal>(val);
+	}
+};
+
+#pragma pop_macro("new")
+
+};  // namespace ATL
+#pragma pack(pop)
+
+#pragma warning(pop)
+
+#pragma pop_macro("free")
+#pragma pop_macro("realloc")
+#pragma pop_macro("_recalloc")
+#pragma pop_macro("malloc")
+#pragma pop_macro("calloc")
+
+
+#endif  // __ATLSIMPCOLL_H__
+

c/jacob/include/atltrace.h

@@ -0,0 +1,450 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the	
+// Active Template Library product.
+
+#ifndef __ATLTRACE_H__
+#define __ATLTRACE_H__
+
+#pragma once
+
+#include <atldef.h>
+#include <atlconv.h>
+
+#ifdef _DEBUG
+#include <stdio.h>
+#include <stdarg.h>
+#endif
+
+#ifdef _DEBUG
+#include <atldebugapi.h>
+
+extern "C" IMAGE_DOS_HEADER __ImageBase;
+#endif  // _DEBUG
+ 
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+
+// Declare a global instance of this class to automatically register a custom trace category at startup
+class CTraceCategory
+{
+public:
+	explicit CTraceCategory( LPCTSTR pszCategoryName, UINT nStartingLevel = 0 ) throw();
+
+#ifdef _DEBUG
+	UINT GetLevel() const throw();
+	void SetLevel( UINT nLevel ) throw();
+	ATLTRACESTATUS GetStatus() const throw();
+	void SetStatus( ATLTRACESTATUS eStatus) throw();
+#endif
+
+	operator DWORD_PTR() const throw();
+
+public:
+#ifdef _DEBUG
+	DWORD_PTR m_dwCategory;
+#endif
+};
+
+#ifdef _DEBUG
+
+class CTrace
+{
+public:
+	typedef int (__cdecl *fnCrtDbgReport_t)(int,const char *,int,const char *,const char *,...);
+
+private:
+	CTrace(
+#ifdef _ATL_NO_DEBUG_CRT
+		fnCrtDbgReport_t pfnCrtDbgReport = NULL)
+#else
+		fnCrtDbgReport_t pfnCrtDbgReport = _CrtDbgReport)
+#endif
+		: m_hInst(reinterpret_cast<HINSTANCE>(&__ImageBase)),
+			m_dwModule( 0 )
+	{
+		m_dwModule = AtlTraceRegister(m_hInst, pfnCrtDbgReport);
+	}
+
+	~CTrace()
+	{
+		AtlTraceUnregister(m_dwModule);
+	}
+
+public:
+	bool ChangeCategory(DWORD_PTR dwCategory, UINT nLevel, ATLTRACESTATUS eStatus)
+	{
+		return 0 !=
+			AtlTraceModifyCategory(0, dwCategory, nLevel, eStatus);
+	}
+
+	bool GetCategory(DWORD_PTR dwCategory, UINT *pnLevel, ATLTRACESTATUS *peStatus)
+	{
+		ATLASSERT(pnLevel && peStatus);
+		return 0 != AtlTraceGetCategory(0, dwCategory, pnLevel, peStatus);
+	}
+	UINT GetLevel()
+	{
+		ATLTRACESTATUS eStatus;
+		UINT nLevel;
+		AtlTraceGetModule(0, m_dwModule, &nLevel, &eStatus);
+
+		return nLevel;
+	}
+	void SetLevel(UINT nLevel)
+	{
+		AtlTraceModifyModule(0, m_dwModule, nLevel, ATLTRACESTATUS_ENABLED);
+	}
+	ATLTRACESTATUS GetStatus()
+	{
+		ATLTRACESTATUS eStatus;
+		UINT nLevel;
+		AtlTraceGetModule(0, m_dwModule, &nLevel, &eStatus);
+
+		return eStatus;
+	}
+	void SetStatus(ATLTRACESTATUS eStatus)
+	{
+		ATLTRACESTATUS eOldStatus;
+		UINT nLevel;
+		AtlTraceGetModule(0, m_dwModule, &nLevel, &eOldStatus);
+		AtlTraceModifyModule(0, m_dwModule, nLevel, eStatus);
+	}
+	void __cdecl TraceV(const char *pszFileName, int nLine,
+		DWORD_PTR dwCategory, UINT nLevel, LPCSTR pszFmt, va_list args) const;
+	void __cdecl TraceV(const char *pszFileName, int nLine,
+		DWORD_PTR dwCategory, UINT nLevel, LPCWSTR pszFmt, va_list args) const;
+
+	DWORD_PTR RegisterCategory(LPCSTR pszCategory)
+		{return(AtlTraceRegisterCategoryA(m_dwModule, pszCategory));}
+#ifdef _UNICODE
+	DWORD_PTR RegisterCategory(LPCWSTR pszCategory)
+		{return(AtlTraceRegisterCategoryU(m_dwModule, pszCategory));}
+#endif
+
+	bool LoadSettings(LPCTSTR pszFileName = NULL) const
+		{return 0 != AtlTraceLoadSettings(pszFileName);}
+	void SaveSettings(LPCTSTR pszFileName = NULL) const
+		{AtlTraceSaveSettings(pszFileName);}
+
+public:
+	static CTrace s_trace;
+
+protected:
+	HINSTANCE m_hInst;
+	DWORD_PTR m_dwModule;
+};
+
+    inline void __cdecl CTrace::TraceV(const char *pszFileName, int nLine,
+		DWORD_PTR dwCategory, UINT nLevel, LPCSTR pszFmt, va_list args) const
+	{
+		AtlTraceVA(m_dwModule, pszFileName, nLine, dwCategory, nLevel, pszFmt, args);
+	}
+	inline void __cdecl CTrace::TraceV(const char *pszFileName, int nLine,
+		DWORD_PTR dwCategory, UINT nLevel, LPCWSTR pszFmt, va_list args) const
+	{
+		AtlTraceVU(m_dwModule, pszFileName, nLine, dwCategory, nLevel, pszFmt, args);
+	}
+
+extern CTraceCategory atlTraceGeneral;
+
+class CTraceFileAndLineInfo
+{
+public:
+	CTraceFileAndLineInfo(const char *pszFileName, int nLineNo)
+		: m_pszFileName(pszFileName), m_nLineNo(nLineNo)
+	{}
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+	void __cdecl operator()(DWORD_PTR dwCategory, UINT nLevel, const char *pszFmt, ...) const
+	{
+		va_list ptr; va_start(ptr, pszFmt);
+		ATL::CTrace::s_trace.TraceV(m_pszFileName, m_nLineNo, dwCategory, nLevel, pszFmt, ptr);
+		va_end(ptr);
+	}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+	void __cdecl operator()(DWORD_PTR dwCategory, UINT nLevel, const wchar_t *pszFmt, ...) const
+	{
+		va_list ptr; va_start(ptr, pszFmt);
+		ATL::CTrace::s_trace.TraceV(m_pszFileName, m_nLineNo, dwCategory, nLevel, pszFmt, ptr);
+		va_end(ptr);
+	}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+	void __cdecl operator()(const char *pszFmt, ...) const
+	{
+		va_list ptr; va_start(ptr, pszFmt);
+		ATL::CTrace::s_trace.TraceV(m_pszFileName, m_nLineNo, atlTraceGeneral, 0, pszFmt, ptr);
+		va_end(ptr);
+	}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+	void __cdecl operator()(const wchar_t *pszFmt, ...) const
+	{
+		va_list ptr; va_start(ptr, pszFmt);
+		ATL::CTrace::s_trace.TraceV(m_pszFileName, m_nLineNo, atlTraceGeneral, 0, pszFmt, ptr);
+		va_end(ptr);
+	}
+#pragma warning(pop)
+
+private:
+	/* unimplemented */
+	CTraceFileAndLineInfo &__cdecl operator=(const CTraceFileAndLineInfo &right);
+
+	const char *const m_pszFileName;
+	const int m_nLineNo;
+};
+
+#endif  // _DEBUG
+
+#ifdef _DEBUG
+
+inline CTraceCategory::CTraceCategory( LPCTSTR pszCategoryName, UINT nStartingLevel ) throw() :
+	m_dwCategory( 0 )
+{
+	m_dwCategory = ATL::CTrace::s_trace.RegisterCategory( pszCategoryName );
+	ATL::CTrace::s_trace.ChangeCategory( m_dwCategory, nStartingLevel, ATLTRACESTATUS_INHERIT);
+}
+
+inline CTraceCategory::operator DWORD_PTR() const throw()
+{
+	return( m_dwCategory );
+}
+
+inline UINT CTraceCategory::GetLevel() const throw()
+{
+	UINT nLevel;
+	ATLTRACESTATUS eStatus;
+	ATL::CTrace::s_trace.GetCategory( m_dwCategory, &nLevel, &eStatus );
+
+	return( nLevel );
+}
+
+inline void CTraceCategory::SetLevel( UINT nLevel ) throw()
+{
+	ATL::CTrace::s_trace.ChangeCategory( m_dwCategory, nLevel, ATLTRACESTATUS_ENABLED );
+}
+
+inline ATLTRACESTATUS CTraceCategory::GetStatus() const throw()
+{
+	UINT nLevel;
+	ATLTRACESTATUS eStatus;
+	ATL::CTrace::s_trace.GetCategory( m_dwCategory, &nLevel, &eStatus );
+
+	return( eStatus );
+}
+
+inline void CTraceCategory::SetStatus( ATLTRACESTATUS eStatus ) throw()
+{
+	UINT nLevel;
+	ATLTRACESTATUS eOldStatus;
+	ATL::CTrace::s_trace.GetCategory( m_dwCategory, &nLevel, &eOldStatus );
+	ATL::CTrace::s_trace.ChangeCategory( m_dwCategory, nLevel, eStatus );
+}
+
+#else  // !_DEBUG
+
+inline CTraceCategory::CTraceCategory( LPCTSTR pszCategoryName, UINT nStartingLevel ) throw()
+{
+	(void)pszCategoryName;
+	(void)nStartingLevel;
+}
+
+inline CTraceCategory::operator DWORD_PTR() const throw()
+{
+	return( 0 );
+}
+
+#endif  // _DEBUG
+
+}  // namespace ATL
+ 
+namespace ATL
+{
+
+#ifdef _DEBUG
+#define DECLARE_TRACE_CATEGORY( name ) extern ATL::CTraceCategory name;
+#else
+#define DECLARE_TRACE_CATEGORY( name ) const DWORD_PTR name = 0;
+#endif
+
+DECLARE_TRACE_CATEGORY( atlTraceGeneral )
+DECLARE_TRACE_CATEGORY( atlTraceCOM )  
+DECLARE_TRACE_CATEGORY( atlTraceQI )	
+DECLARE_TRACE_CATEGORY( atlTraceRegistrar )
+DECLARE_TRACE_CATEGORY( atlTraceRefcount )
+DECLARE_TRACE_CATEGORY( atlTraceWindowing )
+DECLARE_TRACE_CATEGORY( atlTraceControls )
+DECLARE_TRACE_CATEGORY( atlTraceHosting ) 
+DECLARE_TRACE_CATEGORY( atlTraceDBClient )  
+DECLARE_TRACE_CATEGORY( atlTraceDBProvider )
+DECLARE_TRACE_CATEGORY( atlTraceSnapin )
+DECLARE_TRACE_CATEGORY( atlTraceNotImpl )   
+DECLARE_TRACE_CATEGORY( atlTraceAllocation )
+DECLARE_TRACE_CATEGORY( atlTraceException )
+DECLARE_TRACE_CATEGORY( atlTraceTime )
+DECLARE_TRACE_CATEGORY( atlTraceCache )		
+DECLARE_TRACE_CATEGORY( atlTraceStencil )
+DECLARE_TRACE_CATEGORY( atlTraceString )
+DECLARE_TRACE_CATEGORY( atlTraceMap )	
+DECLARE_TRACE_CATEGORY( atlTraceUtil )		
+DECLARE_TRACE_CATEGORY( atlTraceSecurity )
+DECLARE_TRACE_CATEGORY( atlTraceSync )
+DECLARE_TRACE_CATEGORY( atlTraceISAPI )		
+
+// atlTraceUser categories are no longer needed.  Just declare your own trace category using CTraceCategory.
+DECLARE_TRACE_CATEGORY( atlTraceUser )
+DECLARE_TRACE_CATEGORY( atlTraceUser2 )
+DECLARE_TRACE_CATEGORY( atlTraceUser3 )
+DECLARE_TRACE_CATEGORY( atlTraceUser4 )
+
+#pragma deprecated( atlTraceUser )
+#pragma deprecated( atlTraceUser2 )
+#pragma deprecated( atlTraceUser3 )
+#pragma deprecated( atlTraceUser4 )
+
+#ifdef _DEBUG
+
+#ifndef _ATL_NO_DEBUG_CRT
+class CNoUIAssertHook
+{
+public:
+	CNoUIAssertHook()
+	{
+		ATLASSERT( s_pfnPrevHook == NULL );
+		s_pfnPrevHook = _CrtSetReportHook(CrtHookProc);
+	}
+	~CNoUIAssertHook()
+	{
+		_CrtSetReportHook(s_pfnPrevHook);
+		s_pfnPrevHook = NULL;
+	}
+
+private:
+	static int __cdecl CrtHookProc(__in int eReportType, __in_z char* pszMessage, __out int* pnRetVal)
+	{
+		
+		if (eReportType == _CRT_ASSERT)
+		{
+			::OutputDebugStringA( "ASSERTION FAILED\n" );
+			::OutputDebugStringA( pszMessage );
+			//If caller doesn't want retVal, so be it.
+			if (pnRetVal != NULL)
+			{
+				*pnRetVal = 1;
+			}
+			return TRUE;
+		}
+
+		if (s_pfnPrevHook != NULL)
+		{
+			return s_pfnPrevHook(eReportType, pszMessage, pnRetVal);
+		}
+		else
+		{
+			return FALSE;
+		}
+	}
+
+private:
+	static _CRT_REPORT_HOOK s_pfnPrevHook;
+};
+
+__declspec( selectany ) _CRT_REPORT_HOOK CNoUIAssertHook::s_pfnPrevHook = NULL;
+
+#define DECLARE_NOUIASSERT() ATL::CNoUIAssertHook _g_NoUIAssertHook;
+
+#endif  // _ATL_NO_DEBUG_CRT
+
+#ifndef ATLTRACE
+#define ATLTRACE ATL::CTraceFileAndLineInfo(__FILE__, __LINE__)
+#define ATLTRACE2 ATLTRACE
+#endif
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTrace(LPCSTR pszFormat, ...)
+{
+	va_list ptr;
+	va_start(ptr, pszFormat);
+	ATL::CTrace::s_trace.TraceV(NULL, -1, atlTraceGeneral, 0, pszFormat, ptr);
+	va_end(ptr);
+}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTrace(LPCWSTR pszFormat, ...)
+{
+	va_list ptr;
+	va_start(ptr, pszFormat);
+	ATL::CTrace::s_trace.TraceV(NULL, -1, atlTraceGeneral, 0, pszFormat, ptr);
+	va_end(ptr);
+}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTrace2(DWORD_PTR dwCategory, UINT nLevel, LPCSTR pszFormat, ...)
+{
+	va_list ptr;
+	va_start(ptr, pszFormat);
+	ATL::CTrace::s_trace.TraceV(NULL, -1, dwCategory, nLevel, pszFormat, ptr);
+	va_end(ptr);
+}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTrace2(DWORD_PTR dwCategory, UINT nLevel, LPCWSTR pszFormat, ...)
+{
+	va_list ptr;
+	va_start(ptr, pszFormat);
+	ATL::CTrace::s_trace.TraceV(NULL, -1, dwCategory, nLevel, pszFormat, ptr);
+	va_end(ptr);
+}
+#pragma warning(pop)
+
+#define ATLTRACENOTIMPL(funcname)  do { ATLTRACE(ATL::atlTraceNotImpl, 0, _T("ATL: %s not implemented.\n"), funcname); return E_NOTIMPL; } while(0)
+
+#else // !DEBUG
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTraceNull(...){}
+inline void __cdecl AtlTrace(LPCSTR , ...){}
+inline void __cdecl AtlTrace2(DWORD_PTR, UINT, LPCSTR , ...){}
+inline void __cdecl AtlTrace(LPCWSTR , ...){}
+inline void __cdecl AtlTrace2(DWORD_PTR, UINT, LPCWSTR , ...){}
+#pragma warning(pop)
+
+#ifndef ATLTRACE
+
+#define ATLTRACE            __noop
+#define ATLTRACE2           __noop
+#endif //ATLTRACE
+#define ATLTRACENOTIMPL(funcname)   return E_NOTIMPL
+#define DECLARE_NOUIASSERT()
+
+#endif //!_DEBUG
+
+};  // namespace ATL
+#pragma pack(pop)
+
+#endif  // __ATLTRACE_H__
+

c/jacob/msvc/copy.bat

@@ -0,0 +1 @@
+copy Release\jacob.dll ..\..\..\java\native\

c/jacob/msvc/jacob.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual C++ Express 2010
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "jacob", "jacob.vcxproj", "{745CA8EA-176E-46A7-B2A5-55260DF5639B}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{745CA8EA-176E-46A7-B2A5-55260DF5639B}.Debug|Win32.ActiveCfg = Debug|Win32
+		{745CA8EA-176E-46A7-B2A5-55260DF5639B}.Debug|Win32.Build.0 = Debug|Win32
+		{745CA8EA-176E-46A7-B2A5-55260DF5639B}.Release|Win32.ActiveCfg = Release|Win32
+		{745CA8EA-176E-46A7-B2A5-55260DF5639B}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

c/jacob/msvc/jacob.vcxproj

@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{745CA8EA-176E-46A7-B2A5-55260DF5639B}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>jacob</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>..\include;C:\Program Files %28x86%29\Java\jdk1.6.0_23\include;C:\Program Files %28x86%29\Java\jdk1.6.0_23\include\win32;$(IncludePath)</IncludePath>
+    <LibraryPath>..\lib;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;JACOB_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;JACOB_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\ComThread.h" />
+    <ClInclude Include="..\Dispatch.h" />
+    <ClInclude Include="..\DispatchEvents.h" />
+    <ClInclude Include="..\DispatchProxy.h" />
+    <ClInclude Include="..\EnumVariant.h" />
+    <ClInclude Include="..\EventProxy.h" />
+    <ClInclude Include="..\SafeArray.h" />
+    <ClInclude Include="..\STA.h" />
+    <ClInclude Include="..\StdAfx.h" />
+    <ClInclude Include="..\util.h" />
+    <ClInclude Include="..\Variant.h" />
+    <ClInclude Include="targetver.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\ComThread.cpp" />
+    <ClCompile Include="..\Dispatch.cpp" />
+    <ClCompile Include="..\DispatchEvents.cpp" />
+    <ClCompile Include="..\DispatchProxy.cpp" />
+    <ClCompile Include="..\EnumVariant.cpp" />
+    <ClCompile Include="..\EventProxy.cpp" />
+    <ClCompile Include="..\SafeArray.cpp" />
+    <ClCompile Include="..\STA.cpp" />
+    <ClCompile Include="..\util.cpp" />
+    <ClCompile Include="..\Variant.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

c/jacob/msvc/jacob.vcxproj.filters

@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="targetver.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\SafeArray.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\STA.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\StdAfx.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\util.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Variant.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\ComThread.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Dispatch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\DispatchEvents.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\DispatchProxy.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\EnumVariant.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\EventProxy.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\ComThread.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Dispatch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\DispatchEvents.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\DispatchProxy.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\EnumVariant.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\EventProxy.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\SafeArray.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\STA.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\util.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Variant.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>

c/jacob/msvc/jacob.vcxproj.user

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+</Project>

c/jacob/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;
+}
+
+}

c/jacob/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);
+}

java/src/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);
+	}
+
+}

java/src/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;
+	}
+
+}

java/src/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;
+	}
+
+}

java/src/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;
+	}
+}

java/src/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);
+	}
+}

java/src/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();
+	}
+}

java/src/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;
+		}
+	}
+}

java/src/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()
+}

java/src/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 int 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(int 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);
+	}
+
+}

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

@@ -0,0 +1,219 @@
+/*
+ * 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.
+	 */
+	int 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()
+	 */
+	protected void finalize() {
+		safeRelease();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.jacob.com.JacobObject#safeRelease()
+	 */
+	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");
+			}
+		}
+	}
+
+}

java/src/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;
+}

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

@@ -0,0 +1,92 @@
+/*
+ * 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 int 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()
+	 */
+	public void finalize() {
+		safeRelease();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.jacob.com.JacobObject#safeRelease()
+	 */
+	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");
+			}
+		}
+	}
+}

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

@@ -0,0 +1,156 @@
+/*
+ * 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> {
+	private int m_pIEnumVARIANT;
+
+	private final Variant[] m_recBuf = new Variant[1];
+
+	// this only gets called from JNI
+	//
+	protected EnumVariant(int pIEnumVARIANT) {
+		m_pIEnumVARIANT = pIEnumVARIANT;
+	}
+
+	/**
+	 * @param disp
+	 */
+	public EnumVariant(Dispatch disp) {
+		int[] hres = new int[1];
+		Variant evv = Dispatch.invokev(disp, DispatchIdentifier.DISPID_NEWENUM,
+				Dispatch.Get, 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()
+	 */
+	protected void finalize() {
+		safeRelease();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.jacob.com.JacobObject#safeRelease()
+	 */
+	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");
+			}
+		}
+	}
+}

java/src/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;
+	}
+
+}

java/src/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;
+
+	}
+}

java/src/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);
+	}
+}

java/src/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();
+	}
+
+}

java/src/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;
+	}
+
+}

java/src/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

java/src/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 {
+}

java/src/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);
+	}
+
+}

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

@@ -0,0 +1,279 @@
+/*
+ * 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";
+
+	/**
+	 * A hash table where each element is another HashMap that represents a
+	 * thread. Each thread HashMap contains the com objects created in that
+	 * thread
+	 */
+	private static HashMap<String, Map<JacobObject, String>> rot = new HashMap<String, 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() {
+		// should use the id here instead of the name because the name can be
+		// changed
+		String t_name = Thread.currentThread().getName();
+		if (rot.containsKey(t_name)) {
+			// nothing to do
+		} else {
+			Map<JacobObject, String> 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.put(t_name, tab);
+		}
+		return getThreadObjects(false);
+	}
+
+	/**
+	 * 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) {
+		String t_name = Thread.currentThread().getName();
+		if (!rot.containsKey(t_name) && createIfDoesNotExist) {
+			addThread();
+		}
+		return rot.get(t_name);
+	}
+
+	/**
+	 * 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() {
+		if (JacobObject.isDebugEnabled()) {
+			JacobObject.debug("ROT: " + rot.keySet().size()
+					+ " thread tables exist");
+		}
+
+		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() {
+		// should this see if it exists first?
+		rot.remove(Thread.currentThread().getName());
+	}
+
+	/**
+	 * @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();
+	}
+
+}

java/src/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();
+	}
+}

java/src/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;
+	}
+}

java/src/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();
+	}
+}

java/src/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);
+	}
+}