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

Move source files

Browse Source
This commit is contained in:
Rik Veenboer
2014-11-23 17:05:14 +00:00
parent aeca6e8dc2
commit 458d614ee1
96 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
jni/ComThread.cpp
View File

@@ -1,47 +0,0 @@
/*
* 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();
}
}

48
jni/ComThread.h
View File

@@ -1,48 +0,0 @@
/*
* 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

589
jni/Dispatch.cpp
View File

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

95
jni/Dispatch.h
View File

@@ -1,95 +0,0 @@
/*
* 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

373
jni/DispatchEvents.cpp
View File

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

50
jni/DispatchEvents.h
View File

@@ -1,50 +0,0 @@
/*
* 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

106
jni/DispatchProxy.cpp
View File

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

55
jni/DispatchProxy.h
View File

@@ -1,55 +0,0 @@
/*
* 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

139
jni/EnumVariant.cpp
View File

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

63
jni/EnumVariant.h
View File

@@ -1,63 +0,0 @@
/*
* 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

876
jni/EventProxy.cpp
View File

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

102
jni/EventProxy.h
View File

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

63
jni/STA.cpp
View File

@@ -1,63 +0,0 @@
/*
* 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);
}
}

47
jni/STA.h
View File

@@ -1,47 +0,0 @@
/*
* 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

3177
jni/SafeArray.cpp
View File

File diff suppressed because it is too large Load Diff

940
jni/SafeArray.h
View File

@@ -1,940 +0,0 @@
/*
* 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

52
jni/StdAfx.h
View File

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

1284
jni/Variant.cpp
View File

File diff suppressed because it is too large Load Diff

605
jni/Variant.h
View File

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

75
jni/util.cpp
View File

@@ -1,75 +0,0 @@
/*
* 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;
}
}

29
jni/util.h
View File

@@ -1,29 +0,0 @@
/*
* 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);
}