From 53ac2e4ffe70b12bc4052c244b77e932e38a9bfa Mon Sep 17 00:00:00 2001 From: Jean-Paul Saman Date: Fri, 13 Mar 2009 12:47:52 +0100 Subject: [PATCH] mozilla: Resolve files with conflicting licensing terms Renamed: npunix.c to npunix_old.c npwin.cpp to npwin_old.cpp Added new files from mozilla source code npunix.c npwin.cpp --- projects/mozilla/support/npunix.c | 426 ++++++-------- projects/mozilla/support/npunix_old.c | 752 +++++++++++++++++++++++++ projects/mozilla/support/npwin.cpp | 431 ++++---------- projects/mozilla/support/npwin_old.cpp | 573 +++++++++++++++++++ 4 files changed, 1618 insertions(+), 564 deletions(-) create mode 100644 projects/mozilla/support/npunix_old.c create mode 100644 projects/mozilla/support/npwin_old.cpp diff --git a/projects/mozilla/support/npunix.c b/projects/mozilla/support/npunix.c index 319c0e1574..ab959f2410 100644 --- a/projects/mozilla/support/npunix.c +++ b/projects/mozilla/support/npunix.c @@ -1,25 +1,41 @@ /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- * - * The contents of this file are subject to the Mozilla Public - * License Version 1.1 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.mozilla.org/MPL/ + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. * * The Original Code is mozilla.org code. * - * The Initial Developer of the Original Code is Netscape - * Communications Corporation. Portions created by Netscape are - * Copyright (C) 1998 Netscape Communications Corporation. All - * Rights Reserved. + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. * * Contributor(s): - * Stephen Mak - */ + * Stephen Mak + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ /* * npunix.c @@ -32,24 +48,14 @@ *---------------------------------------------------------------------- * PLUGIN DEVELOPERS: * YOU WILL NOT NEED TO EDIT THIS FILE. - * TO NETSCAPE DEVELOPERS: - * OF COURSE I WILL NEED TO EDIT THIS FILE, YOU BORKED IT ALL AROUND YOU - * IGNORANT FOOLS -- sam *---------------------------------------------------------------------- */ -#include "config.h" - #define XP_UNIX 1 -#define OJI 1 #include -#include -#ifdef HAVE_NPFUNCTIONS_H -#include -#else -#include -#endif +#include "npapi.h" +#include "npupp.h" /* * Define PLUGIN_TRACE to have the wrapper functions print @@ -63,6 +69,7 @@ #define PLUGINDEBUGSTR(msg) #endif + /*********************************************************************** * * Globals @@ -199,6 +206,7 @@ void NPN_ReloadPlugins(NPBool reloadPages) CallNPN_ReloadPluginsProc(gNetscapeFuncs.reloadplugins, reloadPages); } +#ifdef OJI JRIEnv* NPN_GetJavaEnv() { return CallNPN_GetJavaEnvProc(gNetscapeFuncs.getJavaEnv); @@ -209,6 +217,7 @@ jref NPN_GetJavaPeer(NPP instance) return CallNPN_GetJavaPeerProc(gNetscapeFuncs.getJavaPeer, instance); } +#endif void NPN_InvalidateRect(NPP instance, NPRect *invalidRect) @@ -230,190 +239,128 @@ NPN_ForceRedraw(NPP instance) CallNPN_ForceRedrawProc(gNetscapeFuncs.forceredraw, instance); } +void NPN_PushPopupsEnabledState(NPP instance, NPBool enabled) +{ + CallNPN_PushPopupsEnabledStateProc(gNetscapeFuncs.pushpopupsenabledstate, + instance, enabled); +} + +void NPN_PopPopupsEnabledState(NPP instance) +{ + CallNPN_PopPopupsEnabledStateProc(gNetscapeFuncs.poppopupsenabledstate, + instance); +} + NPIdentifier NPN_GetStringIdentifier(const NPUTF8 *name) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_GetStringIdentifierProc( gNetscapeFuncs.getstringidentifier, name); - } - return NULL; + return CallNPN_GetStringIdentifierProc(gNetscapeFuncs.getstringidentifier, + name); } -void NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount, NPIdentifier *identifiers) +void NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount, + NPIdentifier *identifiers) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - CallNPN_GetStringIdentifiersProc( gNetscapeFuncs.getstringidentifiers, names, nameCount, identifiers); - } + CallNPN_GetStringIdentifiersProc(gNetscapeFuncs.getstringidentifiers, + names, nameCount, identifiers); } NPIdentifier NPN_GetIntIdentifier(int32_t intid) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_GetIntIdentifierProc( gNetscapeFuncs.getintidentifier, intid); - } - return NULL; + return CallNPN_GetIntIdentifierProc(gNetscapeFuncs.getintidentifier, intid); } bool NPN_IdentifierIsString(NPIdentifier identifier) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_IdentifierIsStringProc( gNetscapeFuncs.identifierisstring, identifier); - } - return false; + return CallNPN_IdentifierIsStringProc(gNetscapeFuncs.identifierisstring, + identifier); } NPUTF8 *NPN_UTF8FromIdentifier(NPIdentifier identifier) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_UTF8FromIdentifierProc( gNetscapeFuncs.utf8fromidentifier, identifier); - } - return NULL; + return CallNPN_UTF8FromIdentifierProc(gNetscapeFuncs.utf8fromidentifier, + identifier); } int32_t NPN_IntFromIdentifier(NPIdentifier identifier) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_IntFromIdentifierProc( gNetscapeFuncs.intfromidentifier, identifier); - } - return 0; + return CallNPN_IntFromIdentifierProc(gNetscapeFuncs.intfromidentifier, + identifier); } -NPObject *NPN_CreateObject(NPP instance, NPClass *aClass) +NPObject *NPN_CreateObject(NPP npp, NPClass *aClass) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_CreateObjectProc( gNetscapeFuncs.createobject, instance, aClass); - } - return NULL; + return CallNPN_CreateObjectProc(gNetscapeFuncs.createobject, npp, aClass); } -NPObject *NPN_RetainObject(NPObject *npobj) +NPObject *NPN_RetainObject(NPObject *obj) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_RetainObjectProc( gNetscapeFuncs.retainobject, npobj); - } - return NULL; + return CallNPN_RetainObjectProc(gNetscapeFuncs.retainobject, obj); } -void NPN_ReleaseObject(NPObject *npobj) +void NPN_ReleaseObject(NPObject *obj) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - CallNPN_ReleaseObjectProc( gNetscapeFuncs.releaseobject, npobj); - } + CallNPN_ReleaseObjectProc(gNetscapeFuncs.releaseobject, obj); } -bool NPN_Invoke(NPP instance, NPObject *npobj, NPIdentifier methodName, const NPVariant *args, uint32_t argCount, NPVariant *result) +bool NPN_Invoke(NPP npp, NPObject* obj, NPIdentifier methodName, + const NPVariant *args, uint32_t argCount, NPVariant *result) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_InvokeProc( gNetscapeFuncs.invoke, instance, npobj, methodName, args, argCount, result); - } - return false; + return CallNPN_InvokeProc(gNetscapeFuncs.invoke, npp, obj, methodName, + args, argCount, result); } -bool NPN_InvokeDefault(NPP instance, NPObject *npobj, const NPVariant *args, uint32_t argCount, NPVariant *result) +bool NPN_InvokeDefault(NPP npp, NPObject* obj, const NPVariant *args, + uint32_t argCount, NPVariant *result) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_InvokeDefaultProc( gNetscapeFuncs.invokeDefault, instance, npobj, args, argCount, result); - } - return false; + return CallNPN_InvokeDefaultProc(gNetscapeFuncs.invokeDefault, npp, obj, + args, argCount, result); } -bool NPN_Evaluate(NPP instance, NPObject *npobj, NPString *script, NPVariant *result) +bool NPN_Evaluate(NPP npp, NPObject* obj, NPString *script, + NPVariant *result) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_EvaluateProc( gNetscapeFuncs.evaluate, instance, npobj, script, result); - } - return false; + return CallNPN_EvaluateProc(gNetscapeFuncs.evaluate, npp, obj, script, result); } -bool NPN_GetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, NPVariant *result) +bool NPN_GetProperty(NPP npp, NPObject* obj, NPIdentifier propertyName, + NPVariant *result) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_GetPropertyProc( gNetscapeFuncs.getproperty, instance, npobj, propertyName, result); - } - return false; + return CallNPN_GetPropertyProc(gNetscapeFuncs.getproperty, npp, obj, + propertyName, result); } -bool NPN_SetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, const NPVariant *value) +bool NPN_SetProperty(NPP npp, NPObject* obj, NPIdentifier propertyName, + const NPVariant *value) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_SetPropertyProc( gNetscapeFuncs.setproperty, instance, npobj, propertyName, value); - } - return false; + return CallNPN_SetPropertyProc(gNetscapeFuncs.setproperty, npp, obj, + propertyName, value); } -bool NPN_RemoveProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName) +bool NPN_RemoveProperty(NPP npp, NPObject* obj, NPIdentifier propertyName) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_RemovePropertyProc( gNetscapeFuncs.removeproperty, instance, npobj, propertyName); - } - return false; + return CallNPN_RemovePropertyProc(gNetscapeFuncs.removeproperty, npp, obj, + propertyName); } -bool NPN_HasProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName) +bool NPN_HasProperty(NPP npp, NPObject* obj, NPIdentifier propertyName) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_HasPropertyProc( gNetscapeFuncs.hasproperty, instance, npobj, propertyName); - } - return false; + return CallNPN_HasPropertyProc(gNetscapeFuncs.hasproperty, npp, obj, + propertyName); } -bool NPN_HasMethod(NPP instance, NPObject *npobj, NPIdentifier methodName) +bool NPN_HasMethod(NPP npp, NPObject* obj, NPIdentifier methodName) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - return CallNPN_HasMethodProc( gNetscapeFuncs.hasmethod, instance, npobj, methodName); - } - return false; + return CallNPN_HasMethodProc(gNetscapeFuncs.hasmethod, npp, obj, methodName); } void NPN_ReleaseVariantValue(NPVariant *variant) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - CallNPN_ReleaseVariantValueProc( gNetscapeFuncs.releasevariantvalue, variant); - } + CallNPN_ReleaseVariantValueProc(gNetscapeFuncs.releasevariantvalue, variant); } -void NPN_SetException(NPObject *npobj, const NPUTF8 *message) +void NPN_SetException(NPObject* obj, const NPUTF8 *message) { - int navMinorVers = gNetscapeFuncs.version & 0xFF; - if( navMinorVers >= 14 ) - { - CallNPN_SetExceptionProc( gNetscapeFuncs.setexception, npobj, message); - } + CallNPN_SetExceptionProc(gNetscapeFuncs.setexception, obj, message); } @@ -422,29 +369,11 @@ void NPN_SetException(NPObject *npobj, const NPUTF8 *message) * Wrapper functions : Netscape Navigator -> plugin * * These functions let the plugin developer just create the APIs - * as documented and defined in npapi.h, without needing to + * as documented and defined in npapi.h, without needing to * install those functions in the function table or worry about * setting up globals for 68K plugins. * ***********************************************************************/ -NPError Private_New(NPMIMEType pluginType, NPP instance, uint16 mode, - int16 argc, char* argn[], char* argv[], NPSavedData* saved); -NPError Private_Destroy(NPP instance, NPSavedData** save); -NPError Private_SetWindow(NPP instance, NPWindow* window); -NPError Private_NewStream(NPP instance, NPMIMEType type, NPStream* stream, - NPBool seekable, uint16* stype); -int32 Private_WriteReady(NPP instance, NPStream* stream); -int32 Private_Write(NPP instance, NPStream* stream, int32 offset, int32 len, - void* buffer); -void Private_StreamAsFile(NPP instance, NPStream* stream, const char* fname); -NPError Private_DestroyStream(NPP instance, NPStream* stream, NPError reason); -void Private_URLNotify(NPP instance, const char* url, NPReason reason, void* notifyData); -void Private_Print(NPP instance, NPPrint* platformPrint); -NPError Private_GetValue(NPP instance, NPPVariable variable, void *r_value); -NPError Private_SetValue(NPP instance, NPPVariable variable, void *r_value); -JRIGlobalRef Private_GetJavaClass(void); - -/* */ NPError Private_New(NPMIMEType pluginType, NPP instance, uint16 mode, @@ -453,7 +382,7 @@ Private_New(NPMIMEType pluginType, NPP instance, uint16 mode, NPError ret; PLUGINDEBUGSTR("New"); ret = NPP_New(pluginType, instance, mode, argc, argn, argv, saved); - return ret; + return ret; } NPError @@ -508,6 +437,7 @@ Private_StreamAsFile(NPP instance, NPStream* stream, const char* fname) NPP_StreamAsFile(instance, stream, fname); } + NPError Private_DestroyStream(NPP instance, NPStream* stream, NPError reason) { @@ -520,11 +450,14 @@ Private_DestroyStream(NPP instance, NPStream* stream, NPError reason) void Private_URLNotify(NPP instance, const char* url, NPReason reason, void* notifyData) + { PLUGINDEBUGSTR("URLNotify"); NPP_URLNotify(instance, url, reason, notifyData); } + + void Private_Print(NPP instance, NPPrint* platformPrint) { @@ -532,32 +465,20 @@ Private_Print(NPP instance, NPPrint* platformPrint) NPP_Print(instance, platformPrint); } -NPError -Private_GetValue(NPP instance, NPPVariable variable, void *r_value) -{ - PLUGINDEBUGSTR("GetValue"); - return NPP_GetValue(instance, variable, r_value); -} - -NPError -Private_SetValue(NPP instance, NPPVariable variable, void *r_value) -{ - PLUGINDEBUGSTR("SetValue"); - return NPP_SetValue(instance, variable, r_value); -} - +#ifdef OJI JRIGlobalRef Private_GetJavaClass(void) { jref clazz = NPP_GetJavaClass(); if (clazz) { - JRIEnv* env = NPN_GetJavaEnv(); - return JRI_NewGlobalRef(env, clazz); + JRIEnv* env = NPN_GetJavaEnv(); + return JRI_NewGlobalRef(env, clazz); } return NULL; } +#endif -/*********************************************************************** +/*********************************************************************** * * These functions are located automagically by netscape. * @@ -582,7 +503,7 @@ NP_GetMIMEDescription(void) * that the navigator needs. */ NPError -NP_GetValue(void *future, NPPVariable variable, void *value) +NP_GetValue(void* future, NPPVariable variable, void *value) { return NPP_GetValue(future, variable, value); } @@ -595,7 +516,7 @@ NP_GetValue(void *future, NPPVariable variable, void *value) * * PARAMETERS * nsTable - The netscape function table. If developers just use these - * wrappers, they dont need to worry about all these function + * wrappers, they don't need to worry about all these function * tables. * RETURN * pluginFuncs @@ -610,12 +531,12 @@ NP_Initialize(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs) NPError err = NPERR_NO_ERROR; PLUGINDEBUGSTR("NP_Initialize"); - + /* validate input parameters */ if ((nsTable == NULL) || (pluginFuncs == NULL)) err = NPERR_INVALID_FUNCTABLE_ERROR; - + /* * Check the major version passed in Netscape's function table. * We won't load if the major version is newer than what we expect. @@ -628,12 +549,13 @@ NP_Initialize(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs) if (err == NPERR_NO_ERROR) { if ((nsTable->version >> 8) > NP_VERSION_MAJOR) err = NPERR_INCOMPATIBLE_VERSION_ERROR; - if (nsTable->size < sizeof(NPNetscapeFuncs)) + if (nsTable->size < ((char *)&nsTable->posturlnotify - (char *)nsTable)) err = NPERR_INVALID_FUNCTABLE_ERROR; - if (pluginFuncs->size < sizeof(NPPluginFuncs)) + if (pluginFuncs->size < sizeof(NPPluginFuncs)) err = NPERR_INVALID_FUNCTABLE_ERROR; } - + + if (err == NPERR_NO_ERROR) { /* * Copy all the fields of Netscape function table into our @@ -642,12 +564,11 @@ NP_Initialize(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs) * the whole structure, because the Netscape function table * could actually be bigger than what we expect. */ - int navMinorVers = nsTable->version & 0xFF; - gNetscapeFuncs.version = nsTable->version; gNetscapeFuncs.size = nsTable->size; gNetscapeFuncs.posturl = nsTable->posturl; gNetscapeFuncs.geturl = nsTable->geturl; + gNetscapeFuncs.geturlnotify = nsTable->geturlnotify; gNetscapeFuncs.requestread = nsTable->requestread; gNetscapeFuncs.newstream = nsTable->newstream; gNetscapeFuncs.write = nsTable->write; @@ -658,43 +579,73 @@ NP_Initialize(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs) gNetscapeFuncs.memfree = nsTable->memfree; gNetscapeFuncs.memflush = nsTable->memflush; gNetscapeFuncs.reloadplugins = nsTable->reloadplugins; - if( navMinorVers >= NPVERS_HAS_LIVECONNECT ) +#ifdef OJI + gNetscapeFuncs.getJavaEnv = nsTable->getJavaEnv; + gNetscapeFuncs.getJavaPeer = nsTable->getJavaPeer; +#endif + gNetscapeFuncs.getvalue = nsTable->getvalue; + gNetscapeFuncs.setvalue = nsTable->setvalue; + gNetscapeFuncs.posturlnotify = nsTable->posturlnotify; + + if (nsTable->size >= ((char *)&nsTable->setexception - (char *)nsTable)) { - gNetscapeFuncs.getJavaEnv = nsTable->getJavaEnv; - gNetscapeFuncs.getJavaPeer = nsTable->getJavaPeer; + gNetscapeFuncs.invalidaterect = nsTable->invalidaterect; + gNetscapeFuncs.invalidateregion = nsTable->invalidateregion; + gNetscapeFuncs.forceredraw = nsTable->forceredraw; + gNetscapeFuncs.getstringidentifier = nsTable->getstringidentifier; + gNetscapeFuncs.getstringidentifiers = nsTable->getstringidentifiers; + gNetscapeFuncs.getintidentifier = nsTable->getintidentifier; + gNetscapeFuncs.identifierisstring = nsTable->identifierisstring; + gNetscapeFuncs.utf8fromidentifier = nsTable->utf8fromidentifier; + gNetscapeFuncs.intfromidentifier = nsTable->intfromidentifier; + gNetscapeFuncs.createobject = nsTable->createobject; + gNetscapeFuncs.retainobject = nsTable->retainobject; + gNetscapeFuncs.releaseobject = nsTable->releaseobject; + gNetscapeFuncs.invoke = nsTable->invoke; + gNetscapeFuncs.invokeDefault = nsTable->invokeDefault; + gNetscapeFuncs.evaluate = nsTable->evaluate; + gNetscapeFuncs.getproperty = nsTable->getproperty; + gNetscapeFuncs.setproperty = nsTable->setproperty; + gNetscapeFuncs.removeproperty = nsTable->removeproperty; + gNetscapeFuncs.hasproperty = nsTable->hasproperty; + gNetscapeFuncs.hasmethod = nsTable->hasmethod; + gNetscapeFuncs.releasevariantvalue = nsTable->releasevariantvalue; + gNetscapeFuncs.setexception = nsTable->setexception; } - if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) + else { - gNetscapeFuncs.geturlnotify = nsTable->geturlnotify; - gNetscapeFuncs.posturlnotify = nsTable->posturlnotify; + gNetscapeFuncs.invalidaterect = NULL; + gNetscapeFuncs.invalidateregion = NULL; + gNetscapeFuncs.forceredraw = NULL; + gNetscapeFuncs.getstringidentifier = NULL; + gNetscapeFuncs.getstringidentifiers = NULL; + gNetscapeFuncs.getintidentifier = NULL; + gNetscapeFuncs.identifierisstring = NULL; + gNetscapeFuncs.utf8fromidentifier = NULL; + gNetscapeFuncs.intfromidentifier = NULL; + gNetscapeFuncs.createobject = NULL; + gNetscapeFuncs.retainobject = NULL; + gNetscapeFuncs.releaseobject = NULL; + gNetscapeFuncs.invoke = NULL; + gNetscapeFuncs.invokeDefault = NULL; + gNetscapeFuncs.evaluate = NULL; + gNetscapeFuncs.getproperty = NULL; + gNetscapeFuncs.setproperty = NULL; + gNetscapeFuncs.removeproperty = NULL; + gNetscapeFuncs.hasproperty = NULL; + gNetscapeFuncs.releasevariantvalue = NULL; + gNetscapeFuncs.setexception = NULL; } - gNetscapeFuncs.getvalue = nsTable->getvalue; - gNetscapeFuncs.setvalue = nsTable->setvalue; - gNetscapeFuncs.invalidaterect = nsTable->invalidaterect; - gNetscapeFuncs.invalidateregion = nsTable->invalidateregion; - gNetscapeFuncs.forceredraw = nsTable->forceredraw; - if( navMinorVers >= 14 ) + if (nsTable->size >= + ((char *)&nsTable->poppopupsenabledstate - (char *)nsTable)) { - // NPRuntime support - gNetscapeFuncs.getstringidentifier = nsTable->getstringidentifier; - gNetscapeFuncs.getstringidentifiers = nsTable->getstringidentifiers; - gNetscapeFuncs.getintidentifier = nsTable->getintidentifier; - gNetscapeFuncs.identifierisstring = nsTable->identifierisstring; - gNetscapeFuncs.utf8fromidentifier = nsTable->utf8fromidentifier; - gNetscapeFuncs.intfromidentifier = nsTable->intfromidentifier; - gNetscapeFuncs.createobject = nsTable->createobject; - gNetscapeFuncs.retainobject = nsTable->retainobject; - gNetscapeFuncs.releaseobject = nsTable->releaseobject; - gNetscapeFuncs.invoke = nsTable->invoke; - gNetscapeFuncs.invokeDefault = nsTable->invokeDefault; - gNetscapeFuncs.evaluate = nsTable->evaluate; - gNetscapeFuncs.getproperty = nsTable->getproperty; - gNetscapeFuncs.setproperty = nsTable->setproperty; - gNetscapeFuncs.removeproperty = nsTable->removeproperty; - gNetscapeFuncs.hasproperty = nsTable->hasproperty; - gNetscapeFuncs.hasmethod = nsTable->hasmethod; - gNetscapeFuncs.releasevariantvalue = nsTable->releasevariantvalue; - gNetscapeFuncs.setexception = nsTable->setexception; + gNetscapeFuncs.pushpopupsenabledstate = nsTable->pushpopupsenabledstate; + gNetscapeFuncs.poppopupsenabledstate = nsTable->poppopupsenabledstate; + } + else + { + gNetscapeFuncs.pushpopupsenabledstate = NULL; + gNetscapeFuncs.poppopupsenabledstate = NULL; } /* @@ -714,25 +665,18 @@ NP_Initialize(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs) pluginFuncs->writeready = NewNPP_WriteReadyProc(Private_WriteReady); pluginFuncs->write = NewNPP_WriteProc(Private_Write); pluginFuncs->print = NewNPP_PrintProc(Private_Print); + pluginFuncs->urlnotify = NewNPP_URLNotifyProc(Private_URLNotify); pluginFuncs->event = NULL; - pluginFuncs->getvalue = NewNPP_GetValueProc(Private_GetValue); - pluginFuncs->setvalue = NewNPP_SetValueProc(Private_SetValue); - if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) - { - pluginFuncs->urlnotify = NewNPP_URLNotifyProc(Private_URLNotify); - } #ifdef OJI - if( navMinorVers >= NPVERS_HAS_LIVECONNECT ) - { - pluginFuncs->javaClass = (JRIGlobalRef) Private_GetJavaClass(); - } -#else - pluginFuncs->javaClass = NULL; + pluginFuncs->javaClass = Private_GetJavaClass(); #endif - + // This function is supposedly loaded magically, but that doesn't + // seem to be true. + pluginFuncs->getvalue = NewNPP_GetValueProc(NP_GetValue); + err = NPP_Initialize(); } - + return err; } diff --git a/projects/mozilla/support/npunix_old.c b/projects/mozilla/support/npunix_old.c new file mode 100644 index 0000000000..319c0e1574 --- /dev/null +++ b/projects/mozilla/support/npunix_old.c @@ -0,0 +1,752 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * The contents of this file are subject to the Mozilla Public + * License Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + * Stephen Mak + */ + +/* + * npunix.c + * + * Netscape Client Plugin API + * - Wrapper function to interface with the Netscape Navigator + * + * dp Suresh + * + *---------------------------------------------------------------------- + * PLUGIN DEVELOPERS: + * YOU WILL NOT NEED TO EDIT THIS FILE. + * TO NETSCAPE DEVELOPERS: + * OF COURSE I WILL NEED TO EDIT THIS FILE, YOU BORKED IT ALL AROUND YOU + * IGNORANT FOOLS -- sam + *---------------------------------------------------------------------- + */ + +#include "config.h" + +#define XP_UNIX 1 +#define OJI 1 + +#include +#include +#ifdef HAVE_NPFUNCTIONS_H +#include +#else +#include +#endif + +/* + * Define PLUGIN_TRACE to have the wrapper functions print + * messages to stderr whenever they are called. + */ + +#ifdef PLUGIN_TRACE +#include +#define PLUGINDEBUGSTR(msg) fprintf(stderr, "%s\n", msg) +#else +#define PLUGINDEBUGSTR(msg) +#endif + +/*********************************************************************** + * + * Globals + * + ***********************************************************************/ + +static NPNetscapeFuncs gNetscapeFuncs; /* Netscape Function table */ + + +/*********************************************************************** + * + * Wrapper functions : plugin calling Netscape Navigator + * + * These functions let the plugin developer just call the APIs + * as documented and defined in npapi.h, without needing to know + * about the function table and call macros in npupp.h. + * + ***********************************************************************/ + +void +NPN_Version(int* plugin_major, int* plugin_minor, + int* netscape_major, int* netscape_minor) +{ + *plugin_major = NP_VERSION_MAJOR; + *plugin_minor = NP_VERSION_MINOR; + + /* Major version is in high byte */ + *netscape_major = gNetscapeFuncs.version >> 8; + /* Minor version is in low byte */ + *netscape_minor = gNetscapeFuncs.version & 0xFF; +} + +NPError +NPN_GetValue(NPP instance, NPNVariable variable, void *r_value) +{ + return CallNPN_GetValueProc(gNetscapeFuncs.getvalue, + instance, variable, r_value); +} + +NPError +NPN_SetValue(NPP instance, NPPVariable variable, void *value) +{ + return CallNPN_SetValueProc(gNetscapeFuncs.setvalue, + instance, variable, value); +} + +NPError +NPN_GetURL(NPP instance, const char* url, const char* window) +{ + return CallNPN_GetURLProc(gNetscapeFuncs.geturl, instance, url, window); +} + +NPError +NPN_GetURLNotify(NPP instance, const char* url, const char* window, void* notifyData) +{ + return CallNPN_GetURLNotifyProc(gNetscapeFuncs.geturlnotify, instance, url, window, notifyData); +} + +NPError +NPN_PostURL(NPP instance, const char* url, const char* window, + uint32 len, const char* buf, NPBool file) +{ + return CallNPN_PostURLProc(gNetscapeFuncs.posturl, instance, + url, window, len, buf, file); +} + +NPError +NPN_PostURLNotify(NPP instance, const char* url, const char* window, uint32 len, + const char* buf, NPBool file, void* notifyData) +{ + return CallNPN_PostURLNotifyProc(gNetscapeFuncs.posturlnotify, + instance, url, window, len, buf, file, notifyData); +} + +NPError +NPN_RequestRead(NPStream* stream, NPByteRange* rangeList) +{ + return CallNPN_RequestReadProc(gNetscapeFuncs.requestread, + stream, rangeList); +} + +NPError +NPN_NewStream(NPP instance, NPMIMEType type, const char *window, + NPStream** stream_ptr) +{ + return CallNPN_NewStreamProc(gNetscapeFuncs.newstream, instance, + type, window, stream_ptr); +} + +int32 +NPN_Write(NPP instance, NPStream* stream, int32 len, void* buffer) +{ + return CallNPN_WriteProc(gNetscapeFuncs.write, instance, + stream, len, buffer); +} + +NPError +NPN_DestroyStream(NPP instance, NPStream* stream, NPError reason) +{ + return CallNPN_DestroyStreamProc(gNetscapeFuncs.destroystream, + instance, stream, reason); +} + +void +NPN_Status(NPP instance, const char* message) +{ + CallNPN_StatusProc(gNetscapeFuncs.status, instance, message); +} + +const char* +NPN_UserAgent(NPP instance) +{ + return CallNPN_UserAgentProc(gNetscapeFuncs.uagent, instance); +} + +void* +NPN_MemAlloc(uint32 size) +{ + return CallNPN_MemAllocProc(gNetscapeFuncs.memalloc, size); +} + +void NPN_MemFree(void* ptr) +{ + CallNPN_MemFreeProc(gNetscapeFuncs.memfree, ptr); +} + +uint32 NPN_MemFlush(uint32 size) +{ + return CallNPN_MemFlushProc(gNetscapeFuncs.memflush, size); +} + +void NPN_ReloadPlugins(NPBool reloadPages) +{ + CallNPN_ReloadPluginsProc(gNetscapeFuncs.reloadplugins, reloadPages); +} + +JRIEnv* NPN_GetJavaEnv() +{ + return CallNPN_GetJavaEnvProc(gNetscapeFuncs.getJavaEnv); +} + +jref NPN_GetJavaPeer(NPP instance) +{ + return CallNPN_GetJavaPeerProc(gNetscapeFuncs.getJavaPeer, + instance); +} + +void +NPN_InvalidateRect(NPP instance, NPRect *invalidRect) +{ + CallNPN_InvalidateRectProc(gNetscapeFuncs.invalidaterect, instance, + invalidRect); +} + +void +NPN_InvalidateRegion(NPP instance, NPRegion invalidRegion) +{ + CallNPN_InvalidateRegionProc(gNetscapeFuncs.invalidateregion, instance, + invalidRegion); +} + +void +NPN_ForceRedraw(NPP instance) +{ + CallNPN_ForceRedrawProc(gNetscapeFuncs.forceredraw, instance); +} + +NPIdentifier NPN_GetStringIdentifier(const NPUTF8 *name) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_GetStringIdentifierProc( gNetscapeFuncs.getstringidentifier, name); + } + return NULL; +} + +void NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount, NPIdentifier *identifiers) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + CallNPN_GetStringIdentifiersProc( gNetscapeFuncs.getstringidentifiers, names, nameCount, identifiers); + } +} + +NPIdentifier NPN_GetIntIdentifier(int32_t intid) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_GetIntIdentifierProc( gNetscapeFuncs.getintidentifier, intid); + } + return NULL; +} + +bool NPN_IdentifierIsString(NPIdentifier identifier) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_IdentifierIsStringProc( gNetscapeFuncs.identifierisstring, identifier); + } + return false; +} + +NPUTF8 *NPN_UTF8FromIdentifier(NPIdentifier identifier) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_UTF8FromIdentifierProc( gNetscapeFuncs.utf8fromidentifier, identifier); + } + return NULL; +} + +int32_t NPN_IntFromIdentifier(NPIdentifier identifier) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_IntFromIdentifierProc( gNetscapeFuncs.intfromidentifier, identifier); + } + return 0; +} + +NPObject *NPN_CreateObject(NPP instance, NPClass *aClass) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_CreateObjectProc( gNetscapeFuncs.createobject, instance, aClass); + } + return NULL; +} + +NPObject *NPN_RetainObject(NPObject *npobj) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_RetainObjectProc( gNetscapeFuncs.retainobject, npobj); + } + return NULL; +} + +void NPN_ReleaseObject(NPObject *npobj) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + CallNPN_ReleaseObjectProc( gNetscapeFuncs.releaseobject, npobj); + } +} + +bool NPN_Invoke(NPP instance, NPObject *npobj, NPIdentifier methodName, const NPVariant *args, uint32_t argCount, NPVariant *result) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_InvokeProc( gNetscapeFuncs.invoke, instance, npobj, methodName, args, argCount, result); + } + return false; +} + +bool NPN_InvokeDefault(NPP instance, NPObject *npobj, const NPVariant *args, uint32_t argCount, NPVariant *result) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_InvokeDefaultProc( gNetscapeFuncs.invokeDefault, instance, npobj, args, argCount, result); + } + return false; +} + +bool NPN_Evaluate(NPP instance, NPObject *npobj, NPString *script, NPVariant *result) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_EvaluateProc( gNetscapeFuncs.evaluate, instance, npobj, script, result); + } + return false; +} + +bool NPN_GetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, NPVariant *result) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_GetPropertyProc( gNetscapeFuncs.getproperty, instance, npobj, propertyName, result); + } + return false; +} + +bool NPN_SetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, const NPVariant *value) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_SetPropertyProc( gNetscapeFuncs.setproperty, instance, npobj, propertyName, value); + } + return false; +} + +bool NPN_RemoveProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_RemovePropertyProc( gNetscapeFuncs.removeproperty, instance, npobj, propertyName); + } + return false; +} + +bool NPN_HasProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_HasPropertyProc( gNetscapeFuncs.hasproperty, instance, npobj, propertyName); + } + return false; +} + +bool NPN_HasMethod(NPP instance, NPObject *npobj, NPIdentifier methodName) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + return CallNPN_HasMethodProc( gNetscapeFuncs.hasmethod, instance, npobj, methodName); + } + return false; +} + +void NPN_ReleaseVariantValue(NPVariant *variant) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + CallNPN_ReleaseVariantValueProc( gNetscapeFuncs.releasevariantvalue, variant); + } +} + +void NPN_SetException(NPObject *npobj, const NPUTF8 *message) +{ + int navMinorVers = gNetscapeFuncs.version & 0xFF; + if( navMinorVers >= 14 ) + { + CallNPN_SetExceptionProc( gNetscapeFuncs.setexception, npobj, message); + } +} + + +/*********************************************************************** + * + * Wrapper functions : Netscape Navigator -> plugin + * + * These functions let the plugin developer just create the APIs + * as documented and defined in npapi.h, without needing to + * install those functions in the function table or worry about + * setting up globals for 68K plugins. + * + ***********************************************************************/ +NPError Private_New(NPMIMEType pluginType, NPP instance, uint16 mode, + int16 argc, char* argn[], char* argv[], NPSavedData* saved); +NPError Private_Destroy(NPP instance, NPSavedData** save); +NPError Private_SetWindow(NPP instance, NPWindow* window); +NPError Private_NewStream(NPP instance, NPMIMEType type, NPStream* stream, + NPBool seekable, uint16* stype); +int32 Private_WriteReady(NPP instance, NPStream* stream); +int32 Private_Write(NPP instance, NPStream* stream, int32 offset, int32 len, + void* buffer); +void Private_StreamAsFile(NPP instance, NPStream* stream, const char* fname); +NPError Private_DestroyStream(NPP instance, NPStream* stream, NPError reason); +void Private_URLNotify(NPP instance, const char* url, NPReason reason, void* notifyData); +void Private_Print(NPP instance, NPPrint* platformPrint); +NPError Private_GetValue(NPP instance, NPPVariable variable, void *r_value); +NPError Private_SetValue(NPP instance, NPPVariable variable, void *r_value); +JRIGlobalRef Private_GetJavaClass(void); + +/* */ + +NPError +Private_New(NPMIMEType pluginType, NPP instance, uint16 mode, + int16 argc, char* argn[], char* argv[], NPSavedData* saved) +{ + NPError ret; + PLUGINDEBUGSTR("New"); + ret = NPP_New(pluginType, instance, mode, argc, argn, argv, saved); + return ret; +} + +NPError +Private_Destroy(NPP instance, NPSavedData** save) +{ + PLUGINDEBUGSTR("Destroy"); + return NPP_Destroy(instance, save); +} + +NPError +Private_SetWindow(NPP instance, NPWindow* window) +{ + NPError err; + PLUGINDEBUGSTR("SetWindow"); + err = NPP_SetWindow(instance, window); + return err; +} + +NPError +Private_NewStream(NPP instance, NPMIMEType type, NPStream* stream, + NPBool seekable, uint16* stype) +{ + NPError err; + PLUGINDEBUGSTR("NewStream"); + err = NPP_NewStream(instance, type, stream, seekable, stype); + return err; +} + +int32 +Private_WriteReady(NPP instance, NPStream* stream) +{ + unsigned int result; + PLUGINDEBUGSTR("WriteReady"); + result = NPP_WriteReady(instance, stream); + return result; +} + +int32 +Private_Write(NPP instance, NPStream* stream, int32 offset, int32 len, + void* buffer) +{ + unsigned int result; + PLUGINDEBUGSTR("Write"); + result = NPP_Write(instance, stream, offset, len, buffer); + return result; +} + +void +Private_StreamAsFile(NPP instance, NPStream* stream, const char* fname) +{ + PLUGINDEBUGSTR("StreamAsFile"); + NPP_StreamAsFile(instance, stream, fname); +} + +NPError +Private_DestroyStream(NPP instance, NPStream* stream, NPError reason) +{ + NPError err; + PLUGINDEBUGSTR("DestroyStream"); + err = NPP_DestroyStream(instance, stream, reason); + return err; +} + +void +Private_URLNotify(NPP instance, const char* url, + NPReason reason, void* notifyData) +{ + PLUGINDEBUGSTR("URLNotify"); + NPP_URLNotify(instance, url, reason, notifyData); +} + +void +Private_Print(NPP instance, NPPrint* platformPrint) +{ + PLUGINDEBUGSTR("Print"); + NPP_Print(instance, platformPrint); +} + +NPError +Private_GetValue(NPP instance, NPPVariable variable, void *r_value) +{ + PLUGINDEBUGSTR("GetValue"); + return NPP_GetValue(instance, variable, r_value); +} + +NPError +Private_SetValue(NPP instance, NPPVariable variable, void *r_value) +{ + PLUGINDEBUGSTR("SetValue"); + return NPP_SetValue(instance, variable, r_value); +} + +JRIGlobalRef +Private_GetJavaClass(void) +{ + jref clazz = NPP_GetJavaClass(); + if (clazz) { + JRIEnv* env = NPN_GetJavaEnv(); + return JRI_NewGlobalRef(env, clazz); + } + return NULL; +} + +/*********************************************************************** + * + * These functions are located automagically by netscape. + * + ***********************************************************************/ + +/* + * NP_GetMIMEDescription + * - Netscape needs to know about this symbol + * - Netscape uses the return value to identify when an object instance + * of this plugin should be created. + */ +char * +NP_GetMIMEDescription(void) +{ + return NPP_GetMIMEDescription(); +} + +/* + * NP_GetValue [optional] + * - Netscape needs to know about this symbol. + * - Interfaces with plugin to get values for predefined variables + * that the navigator needs. + */ +NPError +NP_GetValue(void *future, NPPVariable variable, void *value) +{ + return NPP_GetValue(future, variable, value); +} + +/* + * NP_Initialize + * - Netscape needs to know about this symbol. + * - It calls this function after looking up its symbol before it + * is about to create the first ever object of this kind. + * + * PARAMETERS + * nsTable - The netscape function table. If developers just use these + * wrappers, they dont need to worry about all these function + * tables. + * RETURN + * pluginFuncs + * - This functions needs to fill the plugin function table + * pluginFuncs and return it. Netscape Navigator plugin + * library will use this function table to call the plugin. + * + */ +NPError +NP_Initialize(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs) +{ + NPError err = NPERR_NO_ERROR; + + PLUGINDEBUGSTR("NP_Initialize"); + + /* validate input parameters */ + + if ((nsTable == NULL) || (pluginFuncs == NULL)) + err = NPERR_INVALID_FUNCTABLE_ERROR; + + /* + * Check the major version passed in Netscape's function table. + * We won't load if the major version is newer than what we expect. + * Also check that the function tables passed in are big enough for + * all the functions we need (they could be bigger, if Netscape added + * new APIs, but that's OK with us -- we'll just ignore them). + * + */ + + if (err == NPERR_NO_ERROR) { + if ((nsTable->version >> 8) > NP_VERSION_MAJOR) + err = NPERR_INCOMPATIBLE_VERSION_ERROR; + if (nsTable->size < sizeof(NPNetscapeFuncs)) + err = NPERR_INVALID_FUNCTABLE_ERROR; + if (pluginFuncs->size < sizeof(NPPluginFuncs)) + err = NPERR_INVALID_FUNCTABLE_ERROR; + } + + if (err == NPERR_NO_ERROR) { + /* + * Copy all the fields of Netscape function table into our + * copy so we can call back into Netscape later. Note that + * we need to copy the fields one by one, rather than assigning + * the whole structure, because the Netscape function table + * could actually be bigger than what we expect. + */ + int navMinorVers = nsTable->version & 0xFF; + + gNetscapeFuncs.version = nsTable->version; + gNetscapeFuncs.size = nsTable->size; + gNetscapeFuncs.posturl = nsTable->posturl; + gNetscapeFuncs.geturl = nsTable->geturl; + gNetscapeFuncs.requestread = nsTable->requestread; + gNetscapeFuncs.newstream = nsTable->newstream; + gNetscapeFuncs.write = nsTable->write; + gNetscapeFuncs.destroystream = nsTable->destroystream; + gNetscapeFuncs.status = nsTable->status; + gNetscapeFuncs.uagent = nsTable->uagent; + gNetscapeFuncs.memalloc = nsTable->memalloc; + gNetscapeFuncs.memfree = nsTable->memfree; + gNetscapeFuncs.memflush = nsTable->memflush; + gNetscapeFuncs.reloadplugins = nsTable->reloadplugins; + if( navMinorVers >= NPVERS_HAS_LIVECONNECT ) + { + gNetscapeFuncs.getJavaEnv = nsTable->getJavaEnv; + gNetscapeFuncs.getJavaPeer = nsTable->getJavaPeer; + } + if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) + { + gNetscapeFuncs.geturlnotify = nsTable->geturlnotify; + gNetscapeFuncs.posturlnotify = nsTable->posturlnotify; + } + gNetscapeFuncs.getvalue = nsTable->getvalue; + gNetscapeFuncs.setvalue = nsTable->setvalue; + gNetscapeFuncs.invalidaterect = nsTable->invalidaterect; + gNetscapeFuncs.invalidateregion = nsTable->invalidateregion; + gNetscapeFuncs.forceredraw = nsTable->forceredraw; + if( navMinorVers >= 14 ) + { + // NPRuntime support + gNetscapeFuncs.getstringidentifier = nsTable->getstringidentifier; + gNetscapeFuncs.getstringidentifiers = nsTable->getstringidentifiers; + gNetscapeFuncs.getintidentifier = nsTable->getintidentifier; + gNetscapeFuncs.identifierisstring = nsTable->identifierisstring; + gNetscapeFuncs.utf8fromidentifier = nsTable->utf8fromidentifier; + gNetscapeFuncs.intfromidentifier = nsTable->intfromidentifier; + gNetscapeFuncs.createobject = nsTable->createobject; + gNetscapeFuncs.retainobject = nsTable->retainobject; + gNetscapeFuncs.releaseobject = nsTable->releaseobject; + gNetscapeFuncs.invoke = nsTable->invoke; + gNetscapeFuncs.invokeDefault = nsTable->invokeDefault; + gNetscapeFuncs.evaluate = nsTable->evaluate; + gNetscapeFuncs.getproperty = nsTable->getproperty; + gNetscapeFuncs.setproperty = nsTable->setproperty; + gNetscapeFuncs.removeproperty = nsTable->removeproperty; + gNetscapeFuncs.hasproperty = nsTable->hasproperty; + gNetscapeFuncs.hasmethod = nsTable->hasmethod; + gNetscapeFuncs.releasevariantvalue = nsTable->releasevariantvalue; + gNetscapeFuncs.setexception = nsTable->setexception; + } + + /* + * Set up the plugin function table that Netscape will use to + * call us. Netscape needs to know about our version and size + * and have a UniversalProcPointer for every function we + * implement. + */ + pluginFuncs->version = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR; + pluginFuncs->size = sizeof(NPPluginFuncs); + pluginFuncs->newp = NewNPP_NewProc(Private_New); + pluginFuncs->destroy = NewNPP_DestroyProc(Private_Destroy); + pluginFuncs->setwindow = NewNPP_SetWindowProc(Private_SetWindow); + pluginFuncs->newstream = NewNPP_NewStreamProc(Private_NewStream); + pluginFuncs->destroystream = NewNPP_DestroyStreamProc(Private_DestroyStream); + pluginFuncs->asfile = NewNPP_StreamAsFileProc(Private_StreamAsFile); + pluginFuncs->writeready = NewNPP_WriteReadyProc(Private_WriteReady); + pluginFuncs->write = NewNPP_WriteProc(Private_Write); + pluginFuncs->print = NewNPP_PrintProc(Private_Print); + pluginFuncs->event = NULL; + pluginFuncs->getvalue = NewNPP_GetValueProc(Private_GetValue); + pluginFuncs->setvalue = NewNPP_SetValueProc(Private_SetValue); + if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) + { + pluginFuncs->urlnotify = NewNPP_URLNotifyProc(Private_URLNotify); + } +#ifdef OJI + if( navMinorVers >= NPVERS_HAS_LIVECONNECT ) + { + pluginFuncs->javaClass = (JRIGlobalRef) Private_GetJavaClass(); + } +#else + pluginFuncs->javaClass = NULL; +#endif + + err = NPP_Initialize(); + } + + return err; +} + +/* + * NP_Shutdown [optional] + * - Netscape needs to know about this symbol. + * - It calls this function after looking up its symbol after + * the last object of this kind has been destroyed. + * + */ +NPError +NP_Shutdown(void) +{ + PLUGINDEBUGSTR("NP_Shutdown"); + NPP_Shutdown(); + return NPERR_NO_ERROR; +} diff --git a/projects/mozilla/support/npwin.cpp b/projects/mozilla/support/npwin.cpp index d9a0a9cef2..9b6a3ef0b7 100644 --- a/projects/mozilla/support/npwin.cpp +++ b/projects/mozilla/support/npwin.cpp @@ -1,11 +1,11 @@ /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* ***** BEGIN LICENSE BLOCK ***** - * Version: NPL 1.1/GPL 2.0/LGPL 2.1 + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * - * The contents of this file are subject to the Netscape Public License - * Version 1.1 (the "License"); you may not use this file except in - * compliance with the License. You may obtain a copy of the License at - * http://www.mozilla.org/NPL/ + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License @@ -27,55 +27,52 @@ * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the NPL, indicate your + * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under - * the terms of any one of the NPL, the GPL or the LGPL. + * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ -#include "config.h" - -#ifdef HAVE_MOZILLA_CONFIG_H -# include -#endif - +#ifndef _NPAPI_H_ #include "npapi.h" -#ifdef HAVE_NPFUNCTIONS_H -#include "npfunctions.h" -#else +#endif +#ifndef _NPUPP_H_ #include "npupp.h" #endif +#include "nsDefaultPlugin.h" + //\\// DEFINE #define NP_EXPORT //\\// GLOBAL DATA NPNetscapeFuncs* g_pNavigatorFuncs = 0; +#ifdef OJI JRIGlobalRef Private_GetJavaClass(void); //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\. ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. // Private_GetJavaClass (global function) // -// Given a Java class reference (thru NPP_GetJavaClass) inform JRT -// of this class existence +// Given a Java class reference (thru NPP_GetJavaClass) inform JRT +// of this class existence // JRIGlobalRef Private_GetJavaClass(void) { jref clazz = NPP_GetJavaClass(); if (clazz) { - JRIEnv* env = NPN_GetJavaEnv(); - return JRI_NewGlobalRef(env, clazz); + JRIEnv* env = NPN_GetJavaEnv(); + return JRI_NewGlobalRef(env, clazz); } return NULL; } - +#endif /* OJI */ //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\. ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. -// PLUGIN DLL entry points +// PLUGIN DLL entry points // // These are the Windows specific DLL entry points. They must be exoprted // @@ -90,23 +87,19 @@ static NPPluginFuncs* g_pluginFuncs; ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. // NP_GetEntryPoints // -// fills in the func table used by Navigator to call entry points in +// fills in the func table used by Navigator to call entry points in // plugin DLL. Note that these entry points ensure that DS is loaded // by using the NP_LOADDS macro, when compiling for Win16 // -#ifdef __MINGW32__ -extern "C" __declspec(dllexport) NPError WINAPI -#else NPError WINAPI NP_EXPORT -#endif NP_GetEntryPoints(NPPluginFuncs* pFuncs) { - // trap a NULL ptr + // trap a NULL ptr if(pFuncs == NULL) return NPERR_INVALID_FUNCTABLE_ERROR; // if the plugin's function table is smaller than the plugin expects, - // then they are incompatible, and should return an error + // then they are incompatible, and should return an error pFuncs->version = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR; pFuncs->newp = NPP_New; @@ -118,11 +111,9 @@ NP_GetEntryPoints(NPPluginFuncs* pFuncs) pFuncs->writeready = NPP_WriteReady; pFuncs->write = NPP_Write; pFuncs->print = NPP_Print; - pFuncs->event = 0; /// reserved - pFuncs->getvalue = NPP_GetValue; - pFuncs->setvalue = NPP_SetValue; + pFuncs->event = 0; /// reserved - g_pluginFuncs = pFuncs; + g_pluginFuncs = pFuncs; return NPERR_NO_ERROR; } @@ -131,38 +122,34 @@ NP_GetEntryPoints(NPPluginFuncs* pFuncs) ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. // NP_Initialize // -// called immediately after the plugin DLL is loaded +// called immediately after the plugin DLL is loaded // -#ifdef __MINGW32__ -extern "C" __declspec(dllexport) NPError WINAPI -#else -NPError WINAPI NP_EXPORT -#endif +NPError WINAPI NP_EXPORT NP_Initialize(NPNetscapeFuncs* pFuncs) { - // trap a NULL ptr + // trap a NULL ptr if(pFuncs == NULL) return NPERR_INVALID_FUNCTABLE_ERROR; - g_pNavigatorFuncs = pFuncs; // save it for future reference + g_pNavigatorFuncs = pFuncs; // save it for future reference // if the plugin's major ver level is lower than the Navigator's, - // then they are incompatible, and should return an error + // then they are incompatible, and should return an error if(HIBYTE(pFuncs->version) > NP_VERSION_MAJOR) return NPERR_INCOMPATIBLE_VERSION_ERROR; - // We have to defer these assignments until g_pNavigatorFuncs is set + // We have to defer these assignments until g_pNavigatorFuncs is set int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) { - g_pluginFuncs->urlnotify = NPP_URLNotify; - } - - if( navMinorVers >= NPVERS_HAS_LIVECONNECT ) { - g_pluginFuncs->javaClass = Private_GetJavaClass(); - } - - // NPP_Initialize is a standard (cross-platform) initialize function. + if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) { + g_pluginFuncs->urlnotify = NPP_URLNotify; + } +#ifdef OJI + if( navMinorVers >= NPVERS_HAS_LIVECONNECT ) { + g_pluginFuncs->javaClass = Private_GetJavaClass(); + } +#endif + // NPP_Initialize is a standard (cross-platform) initialize function. return NPP_Initialize(); } @@ -170,15 +157,11 @@ NP_Initialize(NPNetscapeFuncs* pFuncs) ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. // NP_Shutdown // -// called immediately before the plugin DLL is unloaded. -// This functio shuold check for some ref count on the dll to see if it is -// unloadable or it needs to stay in memory. +// called immediately before the plugin DLL is unloaded. +// This function should check for some ref count on the dll to see if it is +// unloadable or it needs to stay in memory. // -#ifdef __MINGW32__ -extern "C" __declspec(dllexport) NPError WINAPI -#else -NPError WINAPI NP_EXPORT -#endif +NPError WINAPI NP_EXPORT NP_Shutdown() { NPP_Shutdown(); @@ -186,7 +169,13 @@ NP_Shutdown() return NPERR_NO_ERROR; } -// END - PLUGIN DLL entry points +char * NP_GetMIMEDescription() +{ + static char mimetype[] = NS_PLUGIN_DEFAULT_MIME_DESCRIPTION; + return mimetype; +} + +// END - PLUGIN DLL entry points ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\. @@ -210,20 +199,26 @@ void NPN_Version(int* plugin_major, int* plugin_minor, int* netscape_major, int* *netscape_minor = LOBYTE(g_pNavigatorFuncs->version); } +NPError NPN_GetValue(NPP instance, NPNVariable variable, void *result) +{ + return g_pNavigatorFuncs->getvalue(instance, variable, result); +} + + /* causes the specified URL to be fetched and streamed in */ NPError NPN_GetURLNotify(NPP instance, const char *url, const char *target, void* notifyData) { - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - NPError err; - if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) { - err = g_pNavigatorFuncs->geturlnotify(instance, url, target, notifyData); - } - else { - err = NPERR_INCOMPATIBLE_VERSION_ERROR; - } - return err; + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + NPError err; + if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) { + err = g_pNavigatorFuncs->geturlnotify(instance, url, target, notifyData); + } + else { + err = NPERR_INCOMPATIBLE_VERSION_ERROR; + } + return err; } @@ -234,15 +229,15 @@ NPError NPN_GetURL(NPP instance, const char *url, const char *target) NPError NPN_PostURLNotify(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file, void* notifyData) { - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - NPError err; - if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) { - err = g_pNavigatorFuncs->posturlnotify(instance, url, window, len, buf, file, notifyData); - } - else { - err = NPERR_INCOMPATIBLE_VERSION_ERROR; - } - return err; + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + NPError err; + if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) { + err = g_pNavigatorFuncs->posturlnotify(instance, url, window, len, buf, file, notifyData); + } + else { + err = NPERR_INCOMPATIBLE_VERSION_ERROR; + } + return err; } @@ -263,19 +258,19 @@ NPError NPN_RequestRead(NPStream* stream, NPByteRange* rangeList) /* Creates a new stream of data from the plug-in to be interpreted by Netscape in the current window. */ -NPError NPN_NewStream(NPP instance, NPMIMEType type, - const char* target, NPStream** stream) +NPError NPN_NewStream(NPP instance, NPMIMEType type, + const char* target, NPStream** stream) { - int navMinorVersion = g_pNavigatorFuncs->version & 0xFF; - NPError err; + int navMinorVersion = g_pNavigatorFuncs->version & 0xFF; + NPError err; - if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) { - err = g_pNavigatorFuncs->newstream(instance, type, target, stream); - } - else { - err = NPERR_INCOMPATIBLE_VERSION_ERROR; - } - return err; + if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) { + err = g_pNavigatorFuncs->newstream(instance, type, target, stream); + } + else { + err = NPERR_INCOMPATIBLE_VERSION_ERROR; + } + return err; } /* Provides len bytes of data. @@ -283,33 +278,33 @@ NPError NPN_NewStream(NPP instance, NPMIMEType type, int32 NPN_Write(NPP instance, NPStream *stream, int32 len, void *buffer) { - int navMinorVersion = g_pNavigatorFuncs->version & 0xFF; - int32 result; + int navMinorVersion = g_pNavigatorFuncs->version & 0xFF; + int32 result; - if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) { - result = g_pNavigatorFuncs->write(instance, stream, len, buffer); - } - else { - result = -1; - } - return result; + if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) { + result = g_pNavigatorFuncs->write(instance, stream, len, buffer); + } + else { + result = -1; + } + return result; } -/* Closes a stream object. +/* Closes a stream object. reason indicates why the stream was closed. */ NPError NPN_DestroyStream(NPP instance, NPStream* stream, NPError reason) { - int navMinorVersion = g_pNavigatorFuncs->version & 0xFF; - NPError err; + int navMinorVersion = g_pNavigatorFuncs->version & 0xFF; + NPError err; - if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) { - err = g_pNavigatorFuncs->destroystream(instance, stream, reason); - } - else { - err = NPERR_INCOMPATIBLE_VERSION_ERROR; - } - return err; + if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) { + err = g_pNavigatorFuncs->destroystream(instance, stream, reason); + } + else { + err = NPERR_INCOMPATIBLE_VERSION_ERROR; + } + return err; } /* Provides a text status message in the Netscape client user interface @@ -342,7 +337,7 @@ void NPN_MemFree(void* ptr) { g_pNavigatorFuncs->memfree(ptr); } - +#ifdef OJI /* private function to Netscape. do not use! */ void NPN_ReloadPlugins(NPBool reloadPages) @@ -352,222 +347,12 @@ void NPN_ReloadPlugins(NPBool reloadPages) JRIEnv* NPN_GetJavaEnv(void) { - return g_pNavigatorFuncs->getJavaEnv(); + return g_pNavigatorFuncs->getJavaEnv(); } jref NPN_GetJavaPeer(NPP instance) { - return g_pNavigatorFuncs->getJavaPeer(instance); -} - -NPError NPN_GetValue(NPP instance, NPNVariable variable, void *result) -{ - return g_pNavigatorFuncs->getvalue(instance, variable, result); -} - -NPError NPN_SetValue(NPP instance, NPPVariable variable, void *value) -{ - return g_pNavigatorFuncs->setvalue(instance, variable, value); -} - -void NPN_InvalidateRect(NPP instance, NPRect *rect) -{ - g_pNavigatorFuncs->invalidaterect(instance, rect); -} - -void NPN_InvalidateRegion(NPP instance, NPRegion region) -{ - g_pNavigatorFuncs->invalidateregion(instance, region); -} - -void NPN_ForceRedraw(NPP instance) -{ - g_pNavigatorFuncs->forceredraw(instance); -} - -NPIdentifier NPN_GetStringIdentifier(const NPUTF8 *name) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->getstringidentifier(name); - } - return NULL; -} - -void NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount, NPIdentifier *identifiers) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - g_pNavigatorFuncs->getstringidentifiers(names, nameCount, identifiers); - } -} - -NPIdentifier NPN_GetIntIdentifier(int32_t intid) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->getintidentifier(intid); - } - return NULL; -} - -bool NPN_IdentifierIsString(NPIdentifier identifier) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->identifierisstring(identifier); - } - return false; -} - -NPUTF8 *NPN_UTF8FromIdentifier(NPIdentifier identifier) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->utf8fromidentifier(identifier); - } - return NULL; -} - -int32_t NPN_IntFromIdentifier(NPIdentifier identifier) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->intfromidentifier(identifier); - } - return 0; -} - -NPObject *NPN_CreateObject(NPP instance, NPClass *aClass) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->createobject(instance, aClass); - } - return NULL; -} - -NPObject *NPN_RetainObject(NPObject *npobj) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->retainobject(npobj); - } - return NULL; -} - -void NPN_ReleaseObject(NPObject *npobj) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - g_pNavigatorFuncs->releaseobject(npobj); - } -} - -bool NPN_Invoke(NPP instance, NPObject *npobj, NPIdentifier methodName, const NPVariant *args, uint32_t argCount, NPVariant *result) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->invoke(instance, npobj, methodName, args, argCount, result); - } - return false; -} - -bool NPN_InvokeDefault(NPP instance, NPObject *npobj, const NPVariant *args, uint32_t argCount, NPVariant *result) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->invokeDefault(instance, npobj, args, argCount, result); - } - return false; -} - -bool NPN_Evaluate(NPP instance, NPObject *npobj, NPString *script, NPVariant *result) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->evaluate(instance, npobj, script, result); - } - return false; -} - -bool NPN_GetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, NPVariant *result) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->getproperty(instance, npobj, propertyName, result); - } - return false; -} - -bool NPN_SetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, const NPVariant *value) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->setproperty(instance, npobj, propertyName, value); - } - return false; -} - -bool NPN_RemoveProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->removeproperty(instance, npobj, propertyName); - } - return false; -} - -bool NPN_HasProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->hasproperty(instance, npobj, propertyName); - } - return false; -} - -bool NPN_HasMethod(NPP instance, NPObject *npobj, NPIdentifier methodName) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - return g_pNavigatorFuncs->hasmethod(instance, npobj, methodName); - } - return false; -} - -void NPN_ReleaseVariantValue(NPVariant *variant) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - g_pNavigatorFuncs->releasevariantvalue(variant); - } -} - -void NPN_SetException(NPObject *npobj, const NPUTF8 *message) -{ - int navMinorVers = g_pNavigatorFuncs->version & 0xFF; - if( navMinorVers >= 14 ) - { - g_pNavigatorFuncs->setexception(npobj, message); - } + return g_pNavigatorFuncs->getJavaPeer(instance); } +#endif diff --git a/projects/mozilla/support/npwin_old.cpp b/projects/mozilla/support/npwin_old.cpp new file mode 100644 index 0000000000..d9a0a9cef2 --- /dev/null +++ b/projects/mozilla/support/npwin_old.cpp @@ -0,0 +1,573 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: NPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Netscape Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Mozilla Communicator client code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the NPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the NPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#include "config.h" + +#ifdef HAVE_MOZILLA_CONFIG_H +# include +#endif + +#include "npapi.h" +#ifdef HAVE_NPFUNCTIONS_H +#include "npfunctions.h" +#else +#include "npupp.h" +#endif + +//\\// DEFINE +#define NP_EXPORT + +//\\// GLOBAL DATA +NPNetscapeFuncs* g_pNavigatorFuncs = 0; +JRIGlobalRef Private_GetJavaClass(void); + +//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\. +////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. +// Private_GetJavaClass (global function) +// +// Given a Java class reference (thru NPP_GetJavaClass) inform JRT +// of this class existence +// +JRIGlobalRef +Private_GetJavaClass(void) +{ + jref clazz = NPP_GetJavaClass(); + if (clazz) { + JRIEnv* env = NPN_GetJavaEnv(); + return JRI_NewGlobalRef(env, clazz); + } + return NULL; +} + +//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\. +////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. +// PLUGIN DLL entry points +// +// These are the Windows specific DLL entry points. They must be exoprted +// + +// we need these to be global since we have to fill one of its field +// with a data (class) which requires knowlwdge of the navigator +// jump-table. This jump table is known at Initialize time (NP_Initialize) +// which is called after NP_GetEntryPoint +static NPPluginFuncs* g_pluginFuncs; + +//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\. +////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. +// NP_GetEntryPoints +// +// fills in the func table used by Navigator to call entry points in +// plugin DLL. Note that these entry points ensure that DS is loaded +// by using the NP_LOADDS macro, when compiling for Win16 +// +#ifdef __MINGW32__ +extern "C" __declspec(dllexport) NPError WINAPI +#else +NPError WINAPI NP_EXPORT +#endif +NP_GetEntryPoints(NPPluginFuncs* pFuncs) +{ + // trap a NULL ptr + if(pFuncs == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + + // if the plugin's function table is smaller than the plugin expects, + // then they are incompatible, and should return an error + + pFuncs->version = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR; + pFuncs->newp = NPP_New; + pFuncs->destroy = NPP_Destroy; + pFuncs->setwindow = NPP_SetWindow; + pFuncs->newstream = NPP_NewStream; + pFuncs->destroystream = NPP_DestroyStream; + pFuncs->asfile = NPP_StreamAsFile; + pFuncs->writeready = NPP_WriteReady; + pFuncs->write = NPP_Write; + pFuncs->print = NPP_Print; + pFuncs->event = 0; /// reserved + pFuncs->getvalue = NPP_GetValue; + pFuncs->setvalue = NPP_SetValue; + + g_pluginFuncs = pFuncs; + + return NPERR_NO_ERROR; +} + +//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\. +////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. +// NP_Initialize +// +// called immediately after the plugin DLL is loaded +// +#ifdef __MINGW32__ +extern "C" __declspec(dllexport) NPError WINAPI +#else +NPError WINAPI NP_EXPORT +#endif +NP_Initialize(NPNetscapeFuncs* pFuncs) +{ + // trap a NULL ptr + if(pFuncs == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + + g_pNavigatorFuncs = pFuncs; // save it for future reference + + // if the plugin's major ver level is lower than the Navigator's, + // then they are incompatible, and should return an error + if(HIBYTE(pFuncs->version) > NP_VERSION_MAJOR) + return NPERR_INCOMPATIBLE_VERSION_ERROR; + + // We have to defer these assignments until g_pNavigatorFuncs is set + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + + if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) { + g_pluginFuncs->urlnotify = NPP_URLNotify; + } + + if( navMinorVers >= NPVERS_HAS_LIVECONNECT ) { + g_pluginFuncs->javaClass = Private_GetJavaClass(); + } + + // NPP_Initialize is a standard (cross-platform) initialize function. + return NPP_Initialize(); +} + +//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\. +////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. +// NP_Shutdown +// +// called immediately before the plugin DLL is unloaded. +// This functio shuold check for some ref count on the dll to see if it is +// unloadable or it needs to stay in memory. +// +#ifdef __MINGW32__ +extern "C" __declspec(dllexport) NPError WINAPI +#else +NPError WINAPI NP_EXPORT +#endif +NP_Shutdown() +{ + NPP_Shutdown(); + g_pNavigatorFuncs = NULL; + return NPERR_NO_ERROR; +} + +// END - PLUGIN DLL entry points +////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. +//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\. + +/* NAVIGATOR Entry points */ + +/* These entry points expect to be called from within the plugin. The + noteworthy assumption is that DS has already been set to point to the + plugin's DLL data segment. Don't call these functions from outside + the plugin without ensuring DS is set to the DLLs data segment first, + typically using the NP_LOADDS macro +*/ + +/* returns the major/minor version numbers of the Plugin API for the plugin + and the Navigator +*/ +void NPN_Version(int* plugin_major, int* plugin_minor, int* netscape_major, int* netscape_minor) +{ + *plugin_major = NP_VERSION_MAJOR; + *plugin_minor = NP_VERSION_MINOR; + *netscape_major = HIBYTE(g_pNavigatorFuncs->version); + *netscape_minor = LOBYTE(g_pNavigatorFuncs->version); +} + +/* causes the specified URL to be fetched and streamed in +*/ +NPError NPN_GetURLNotify(NPP instance, const char *url, const char *target, void* notifyData) + +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + NPError err; + if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) { + err = g_pNavigatorFuncs->geturlnotify(instance, url, target, notifyData); + } + else { + err = NPERR_INCOMPATIBLE_VERSION_ERROR; + } + return err; +} + + +NPError NPN_GetURL(NPP instance, const char *url, const char *target) +{ + return g_pNavigatorFuncs->geturl(instance, url, target); +} + +NPError NPN_PostURLNotify(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file, void* notifyData) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + NPError err; + if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) { + err = g_pNavigatorFuncs->posturlnotify(instance, url, window, len, buf, file, notifyData); + } + else { + err = NPERR_INCOMPATIBLE_VERSION_ERROR; + } + return err; +} + + +NPError NPN_PostURL(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file) +{ + return g_pNavigatorFuncs->posturl(instance, url, window, len, buf, file); +} + +/* Requests that a number of bytes be provided on a stream. Typically + this would be used if a stream was in "pull" mode. An optional + position can be provided for streams which are seekable. +*/ +NPError NPN_RequestRead(NPStream* stream, NPByteRange* rangeList) +{ + return g_pNavigatorFuncs->requestread(stream, rangeList); +} + +/* Creates a new stream of data from the plug-in to be interpreted + by Netscape in the current window. +*/ +NPError NPN_NewStream(NPP instance, NPMIMEType type, + const char* target, NPStream** stream) +{ + int navMinorVersion = g_pNavigatorFuncs->version & 0xFF; + NPError err; + + if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) { + err = g_pNavigatorFuncs->newstream(instance, type, target, stream); + } + else { + err = NPERR_INCOMPATIBLE_VERSION_ERROR; + } + return err; +} + +/* Provides len bytes of data. +*/ +int32 NPN_Write(NPP instance, NPStream *stream, + int32 len, void *buffer) +{ + int navMinorVersion = g_pNavigatorFuncs->version & 0xFF; + int32 result; + + if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) { + result = g_pNavigatorFuncs->write(instance, stream, len, buffer); + } + else { + result = -1; + } + return result; +} + +/* Closes a stream object. +reason indicates why the stream was closed. +*/ +NPError NPN_DestroyStream(NPP instance, NPStream* stream, NPError reason) +{ + int navMinorVersion = g_pNavigatorFuncs->version & 0xFF; + NPError err; + + if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT ) { + err = g_pNavigatorFuncs->destroystream(instance, stream, reason); + } + else { + err = NPERR_INCOMPATIBLE_VERSION_ERROR; + } + return err; +} + +/* Provides a text status message in the Netscape client user interface +*/ +void NPN_Status(NPP instance, const char *message) +{ + g_pNavigatorFuncs->status(instance, message); +} + +/* returns the user agent string of Navigator, which contains version info +*/ +const char* NPN_UserAgent(NPP instance) +{ + return g_pNavigatorFuncs->uagent(instance); +} + +/* allocates memory from the Navigator's memory space. Necessary so that + saved instance data may be freed by Navigator when exiting. +*/ + + +void* NPN_MemAlloc(uint32 size) +{ + return g_pNavigatorFuncs->memalloc(size); +} + +/* reciprocal of MemAlloc() above +*/ +void NPN_MemFree(void* ptr) +{ + g_pNavigatorFuncs->memfree(ptr); +} + +/* private function to Netscape. do not use! +*/ +void NPN_ReloadPlugins(NPBool reloadPages) +{ + g_pNavigatorFuncs->reloadplugins(reloadPages); +} + +JRIEnv* NPN_GetJavaEnv(void) +{ + return g_pNavigatorFuncs->getJavaEnv(); +} + +jref NPN_GetJavaPeer(NPP instance) +{ + return g_pNavigatorFuncs->getJavaPeer(instance); +} + +NPError NPN_GetValue(NPP instance, NPNVariable variable, void *result) +{ + return g_pNavigatorFuncs->getvalue(instance, variable, result); +} + +NPError NPN_SetValue(NPP instance, NPPVariable variable, void *value) +{ + return g_pNavigatorFuncs->setvalue(instance, variable, value); +} + +void NPN_InvalidateRect(NPP instance, NPRect *rect) +{ + g_pNavigatorFuncs->invalidaterect(instance, rect); +} + +void NPN_InvalidateRegion(NPP instance, NPRegion region) +{ + g_pNavigatorFuncs->invalidateregion(instance, region); +} + +void NPN_ForceRedraw(NPP instance) +{ + g_pNavigatorFuncs->forceredraw(instance); +} + +NPIdentifier NPN_GetStringIdentifier(const NPUTF8 *name) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->getstringidentifier(name); + } + return NULL; +} + +void NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount, NPIdentifier *identifiers) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + g_pNavigatorFuncs->getstringidentifiers(names, nameCount, identifiers); + } +} + +NPIdentifier NPN_GetIntIdentifier(int32_t intid) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->getintidentifier(intid); + } + return NULL; +} + +bool NPN_IdentifierIsString(NPIdentifier identifier) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->identifierisstring(identifier); + } + return false; +} + +NPUTF8 *NPN_UTF8FromIdentifier(NPIdentifier identifier) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->utf8fromidentifier(identifier); + } + return NULL; +} + +int32_t NPN_IntFromIdentifier(NPIdentifier identifier) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->intfromidentifier(identifier); + } + return 0; +} + +NPObject *NPN_CreateObject(NPP instance, NPClass *aClass) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->createobject(instance, aClass); + } + return NULL; +} + +NPObject *NPN_RetainObject(NPObject *npobj) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->retainobject(npobj); + } + return NULL; +} + +void NPN_ReleaseObject(NPObject *npobj) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + g_pNavigatorFuncs->releaseobject(npobj); + } +} + +bool NPN_Invoke(NPP instance, NPObject *npobj, NPIdentifier methodName, const NPVariant *args, uint32_t argCount, NPVariant *result) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->invoke(instance, npobj, methodName, args, argCount, result); + } + return false; +} + +bool NPN_InvokeDefault(NPP instance, NPObject *npobj, const NPVariant *args, uint32_t argCount, NPVariant *result) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->invokeDefault(instance, npobj, args, argCount, result); + } + return false; +} + +bool NPN_Evaluate(NPP instance, NPObject *npobj, NPString *script, NPVariant *result) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->evaluate(instance, npobj, script, result); + } + return false; +} + +bool NPN_GetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, NPVariant *result) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->getproperty(instance, npobj, propertyName, result); + } + return false; +} + +bool NPN_SetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, const NPVariant *value) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->setproperty(instance, npobj, propertyName, value); + } + return false; +} + +bool NPN_RemoveProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->removeproperty(instance, npobj, propertyName); + } + return false; +} + +bool NPN_HasProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->hasproperty(instance, npobj, propertyName); + } + return false; +} + +bool NPN_HasMethod(NPP instance, NPObject *npobj, NPIdentifier methodName) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + return g_pNavigatorFuncs->hasmethod(instance, npobj, methodName); + } + return false; +} + +void NPN_ReleaseVariantValue(NPVariant *variant) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + g_pNavigatorFuncs->releasevariantvalue(variant); + } +} + +void NPN_SetException(NPObject *npobj, const NPUTF8 *message) +{ + int navMinorVers = g_pNavigatorFuncs->version & 0xFF; + if( navMinorVers >= 14 ) + { + g_pNavigatorFuncs->setexception(npobj, message); + } +} + -- 2.39.2