diff options
Diffstat (limited to 'nsplugins')
45 files changed, 15223 insertions, 0 deletions
diff --git a/nsplugins/CMakeLists.txt b/nsplugins/CMakeLists.txt new file mode 100644 index 000000000..278ac1f88 --- /dev/null +++ b/nsplugins/CMakeLists.txt @@ -0,0 +1,66 @@ +################################################# +# +# (C) 2010-2011 Serghei Amelian +# serghei (DOT) amelian (AT) gmail.com +# +# Improvements and feedback are welcome +# +# This file is released under GPL >= 2 +# +################################################# + +add_subdirectory( viewer ) + +include_directories( + ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_BINARY_DIR} + ${TDE_INCLUDE_DIR} + ${TQT_INCLUDE_DIRS} +) + +link_directories( + ${TQT_LIBRARY_DIRS} +) + + +##### other data ################################ + +install( FILES tdehtml_plugins.desktop DESTINATION ${XDG_APPS_INSTALL_DIR} ) +install( FILES nspluginpart.rc DESTINATION ${DATA_INSTALL_DIR}/plugin ) + + +##### libnsplugin (module) ###################### + +tde_add_kpart( libnsplugin AUTOMOC + SOURCES + viewer/NSPluginClassIface.stub + NSPluginCallbackIface.skel + plugin_part.cpp nspluginloader.cpp + LINK tdeparts-shared + DESTINATION ${PLUGIN_INSTALL_DIR} +) + + +##### kcm_nsplugins (module) #################### + +tde_add_kpart( kcm_nsplugins AUTOMOC + SOURCES kcm_nsplugins.cpp + LINK pluginpaths-static tdecore-shared + DESTINATION ${PLUGIN_INSTALL_DIR} +) + + +##### nspluginscan (executable) ################# + +tde_add_executable( nspluginscan AUTOMOC + SOURCES pluginscan.cpp + LINK pluginpaths-static tdeio-shared Xt + DESTINATION ${BIN_INSTALL_DIR} +) + + +##### pluginpaths (static) ###################### + +tde_add_library( pluginpaths STATIC_PIC + SOURCES plugin_paths.cpp +) diff --git a/nsplugins/HOWTO.DEBUG b/nsplugins/HOWTO.DEBUG new file mode 100644 index 000000000..94b43cfd5 --- /dev/null +++ b/nsplugins/HOWTO.DEBUG @@ -0,0 +1,22 @@ +Want to run nspluginviewer in valgrind? It's not easy. Here's how: + +- Trigger the plugin you want in konqueror without valgrind running. +- ps awwww | grep nspluginviewer +- Record the commandline, then kill -11 the process +- close drkonqi +- in a konsole, export ARTSDSP_MMAP=1 + - run LD_PRELOAD=$TDEDIR/lib/libartsdsp.so.0:$TDEDIR/lib/libartsc.so.0 valgrind -v --num-callers=15 --error-limit=no nspluginviewer <commandline that you saved> + +- WAIT for four lines to be printed to the screen that start with: +5 ............ +6 ............ +7 ............ +8 ............ + +- QUICKLY go back to konqi, reload the plugin page. +- You should see the valgrind konsole start to scroll lots of debug output. If + it does not, then it probably not picking up the new nspluginviewer. Try + again. +- As long as you don't close this konqueror window, you should be able to keep + rerunning valgrinded nspluginviewer without much trouble. + diff --git a/nsplugins/Makefile.am b/nsplugins/Makefile.am new file mode 100644 index 000000000..acb8be792 --- /dev/null +++ b/nsplugins/Makefile.am @@ -0,0 +1,37 @@ +SUBDIRS = viewer test +INCLUDES = -I$(top_srcdir)/libltdl $(all_includes) +METASOURCES = AUTO +noinst_HEADERS = nspluginloader.h + +NSPluginClassIface_DIR = $(srcdir)/viewer + +kde_module_LTLIBRARIES = libnsplugin.la kcm_nsplugins.la +libnsplugin_la_SOURCES = plugin_part.cpp nspluginloader.cpp \ + NSPluginClassIface.stub \ + NSPluginCallbackIface.skel + +libnsplugin_la_LDFLAGS = $(all_libraries) -avoid-version -module $(KDE_PLUGIN) -no-undefined +libnsplugin_la_LIBADD = -ltdeparts + +bin_PROGRAMS = nspluginscan +nspluginscan_SOURCES = pluginscan.cpp +nspluginscan_LDFLAGS = $(KDE_RPATH) $(all_libraries) -export-dynamic +nspluginscan_LDADD = $(LIB_TDEUI) $(LIB_TDESYCOCA) -lXt libpluginpaths.la + +kcm_nsplugins_la_SOURCES = kcm_nsplugins.cpp +kcm_nsplugins_la_LDFLAGS = $(all_libraries) -module -avoid-version -no-undefined +kcm_nsplugins_la_LIBADD = $(LIB_TDECORE) libpluginpaths.la + +noinst_LTLIBRARIES = libpluginpaths.la +libpluginpaths_la_SOURCES = plugin_paths.cpp + +xdg_apps_DATA = tdehtml_plugins.desktop + +partrcdir = $(kde_datadir)/plugin +partrc_DATA = nspluginpart.rc + +messages: rc.cpp +# $(EXTRACTRC) `find . -name "*.ui"` >> rc.cpp + $(EXTRACTRC) `find . -name "*.rc"` >> rc.cpp + $(XGETTEXT) *.cpp viewer/*.cpp -o $(podir)/nsplugin.pot + diff --git a/nsplugins/NSPluginCallbackIface.h b/nsplugins/NSPluginCallbackIface.h new file mode 100644 index 000000000..6b23e87a9 --- /dev/null +++ b/nsplugins/NSPluginCallbackIface.h @@ -0,0 +1,46 @@ +/* + + Copyright (c) 2000 Matthias Hoelzer-Kluepfel <mhk@caldera.de> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ + + + +#ifndef __NSPluginCallbackIface_h__ +#define __NSPluginCallbackIface_h__ + + +#include <tqcstring.h> +#include <dcopobject.h> + + +class NSPluginCallbackIface : virtual public DCOPObject +{ + K_DCOP + +k_dcop: + + virtual ASYNC requestURL(TQString url, TQString target) = 0; + virtual ASYNC postURL(TQString url, TQString target, TQByteArray data, TQString mime) = 0; + virtual ASYNC statusMessage( TQString msg ) = 0; + virtual ASYNC evalJavaScript( TQ_INT32 id, TQString script ) = 0; + +}; + + +#endif + diff --git a/nsplugins/README b/nsplugins/README new file mode 100644 index 000000000..f1afff610 --- /dev/null +++ b/nsplugins/README @@ -0,0 +1,255 @@ +nsplugins +========= + +The 'nsplugins' directory contains various tools used to utilize Netscape(R) +browser plugins in KDE applications. + + - ./ - common headers and utilities + + - viewer/ - provides means to embed a Netscape(R) browser plugin + into a KDE application. + + - sdk/ - headers from the Netscape(R) browser plugin SDK. + + - control/ - TDE Control Center applet for managing plugins + + - test/ - simple applications to test nsplugin + + - wrapper/ - currently unused. + + +At the time of writing, nsplugins supports Navigator 4 API plugins +and doesn't support new Mozilla XPCOM components. + +Parts +===== + +The Netscape(R) browser plugin support consists of 3 parts: +- "PluginPart" KPart which is embedded into TDEHTML pages + (alone, it looks no different than a gray rectangle) +- "nspluginviewer", a separate application which is capable of + actually loading and playing the various Netscape(R) plugins. +- "pluginscan", a small utility to scan predefined directories + for Netscape(R) browser plugins. + +PluginPart's responsibility is to run "nspluginviewer" and instruct +it to display the plugin inside its' rectangle. + +* KParts is KDE's standard for embeddable objects, much like + Microsoft's OLE. + +PluginPart / nspluginviewer separation +====================================== + +Plugins contain 3rd-party code which might crash if badly written +(especially inside our "Netscape emulation" environment). +The PluginPart runs inside the memory space of the embedding application, +making the embedding application susceptible to a crash in the PluginPart. +In our case, the "embedding application" would be the browser, and having +the whole browser shut down just because some plugin crashed is bad. +By loading and talking to the plugin is a separate process +("nspluginviewer"), we prevent such crashes from taking +the browser down with them -- the worst that could happen +is the plugin suddenly disappearing from the page, revealing +PluginPart's gray background. + +nspluginviewer to PluginPart communications +=========================================== + +The communications between the PluginPart and nspluginviewer +are done via DCOP. Messages which nspluginviewer could send +to PluginPart include: +- requestURL(url, target) - make the browser load a URL +- statusMessage(msg) - change the status bar in the + embedding application + +(For an updated list of messages, see NSPluginCallbackIface.h) + +When received, those messages are mapped to functions in +NSPluginCallback, which in turn calls PluginPart functions. + +* DCOP is KDE's standard for RPC, typically used by local + processes to pass messages. + +PluginPart to nspluginviewer communications +=========================================== + +nspluginviewer's window is, all in all, a simple X11 window, +it can be resized, focused and unfocused with standard X11 functions +as long as we know its' window ID. + +PluginPart gets a NSPluginInstance (from NSPluginLoader::newInstance), +which it sees as a regular QWidget. e.g. it can resize the QWidget and +nspluginviewer's window will resize. + +This magic happens thanks to KJavaEmbed which NSPluginInstance inherits. +KJavaEmbed inherits QWidget and hooks up to QWidget's events, mapping +those events to the appropriate X11 window operations. +Resizing, focusing in and out is about all PluginPart could ever do +with the nspluginviewer. + +How does KJavaEmbed know the window ID of the nspluginviewer window? +NSPluginInstance retrieves it from nspluginviewer with a DCOP call +("int winId()") and gives it to KJavaEmbed. + +Main classes +============ + +- PluginPart class (plugin_part.h, plugin_part.cpp) + + A KParts::ReadOnlyPart. + +- PluginFactory class (plugin_part.h, plugin_part.cpp) + + Creates PluginPart objects. + +- NSPluginInstance class (nspluginloader.h, nspluginloader.cpp) + + PluginPart's "looking glass" to "nspluginviewer". + +- NSPluginLoader class (nspluginloader.h, nspluginloader.cpp) + + Responsible for starting a new independant process of the + plugin viewer and initiating DCOP communications with it. + +- NSPluginCallbackIface (NSPluginCallbackIface.h) + + Defines functions which the nspluginviewer can call in the PluginPart. + Those function calls would be transfered over DCOP and implemented + in PluginPart's NSPluginCallback class. + + +Plugin Scanner +============== + +Implemented in: pluginscan.cpp + +Utility which scans for Netscape(R) browser plugins in pre-defined +directories (according to KDE's configuration) and writes down +information about the located plugins into the plugin information +cache. To locate all the plugins, it doesn't limit itself to files +with .so extension. A forking mechanism is implemented to prevent +faulty .so's from crashing the scanning process. + +This utility is usually not invoked standalone, but used by the +TDE Control Center applet which invokes it on: +- explicit request (ie. pressing "Scan for new plugins" button) +- KDE startup (in the applet's initialization code) +- first time the applet is ran + + +Viewer +====== + +Implemented in: viewer/ + +The viewer is a KDE component used to embed Netscape(R) plugins +into KDE applications (such as TDEHTML / Konqueror). To the plugin, it +emulates a Netscape(R) browser, while outside - it offers a standard KParts +object. + +NSPluginCallbackIface.h + + Defines functions which the nspluginviewer can call in the PluginPart. + Those function calls would be transfered over DCOP and implemented + in PluginPart's NSPluginCallback class. + +kxt.h, kxt.cpp + + ... + +resolve.h + + Some macros to resolve symbols. + +nsplugin.h, nsplugin.cpp + + The implementation of the interface between KDE and the Netscape(R) + browser plugin as a KParts object. + + Note: This file implements its own NSPluginInstance, which should + not be confused with PluginPart's NSPluginInstance. + + It implements: + - The Netscape(R) emulation side: + g_NPN_* functions, which implement Netscape(R) browser + plugin API NPN_* C methods accordingly. Our emulation + of a Netscape(R) browser is as good as those functions are. + + By definition, all functions are passed with an NPN ("plugin + instance") struct, and each NPN has an 'ndata' pointer member. + That's good news to us, since we now can use it to point to + our NSPluginInstance object. + + Those functions contain the minimum necessary code to + call the NSPluginInstance function for the requested operation + + - The KDE side: + NSPluginInstance implements functions for various g_NPN_* + operations. Typically those operations will be passed via DCOP + to the PluginPart -- e.g. a operation which changes the window's + status bar. + +viewer.cpp + + A standalone application that executes Netscape plugins. + +Control Center applet +===================== + +The Control Center applet allows the user to: +- Add additional directories which "pluginscan" would scan for + Netscape(R) plugins. +- See which plugins "pluginscan" found (by reading the plugin cache). +- Force a "pluginscan" rescan. + +The TDE Control Center API is well documented in the KDE SDK. + +Compatibility notes +=================== + +Although nsplugins strive for full compatibility with the Netscape(R) +browser plugin execution environment, it still lacks the following features: + +- LiveConnect (Netscape Navigator 3.0) Java / JavaScript connectivity + + Support for LiveConnect (for JavaScript support) requires: + - Reimplementation of Netscape's JRI functions (see sdk/jri.h) + to communicate back (via DCOP?) with the PluginPart, which'll + signal them to TDEHTML's KJS interpretor. KParts::BrowserExtension + should be extended to support those signals. Of course, only + JRI calls in the "netscape.javascript" namespace should be handled. + - Implementation of g_NPN_GetJavaEnv and g_NPN_GetJavaPeer + (currently they're empty placeholders). + - Implementing g_NPN_GetValue(NPNVjavascriptEnabledBool, ...) + (currently always returns "false"). + Should involve adding a slot to KParts::BrowserExtension + and making TDEHTML signal it whenever JS gets enabled or disabled. + + LiveConnect will probably never be supported due to JRE ABI issues, and + the fact that we need to have a JRE with JNI inside the nspluginviewer. + LiveConnect is almost obsolete as well. XPConnect will not be integrated + either. + +The current support is enough to run common plugins such as Macromedia(R) +Flash(R) and RealPlayer(R), but some of their functionality might be missing. +For instance, Flash(R) animations cannot call user-defined JavaScript +routines nor can the user control the Flash(R) animation via JavaScript. + +Additional documentation +======================== + +Additional documentation on the Netscape(R) plugin API is available at: + +- http://developer.netscape.com/docs/manuals/plugins.html +- http://www.mozilla.org/docs/plugin.html + +Author +====== + +This README was authored Ilya Konstantinov <kde-devel@future.shiny.co.il>. +Thanks go to Matthias Hoelzer-Kluepfel and Stefan Schimanski for writing +the actual code and making it all possible. + +Present maintainer of the nsplugin code is George Staikos <staikos@kde.org> + diff --git a/nsplugins/TESTCASES b/nsplugins/TESTCASES new file mode 100644 index 000000000..f846cd220 --- /dev/null +++ b/nsplugins/TESTCASES @@ -0,0 +1,40 @@ + +When making changes to nsplugin.cpp or related areas, please try to test as +many, if not all of the following plugins before and after the changes. It +is also useful to test in embedded mode in TDEHTML, as well as with kfmclient +loading it into a clean konqueror pane. + +LiveConnect is not particularily supported, and probably never will be. Most +unimplemented functions are documented with // FIXME in nsplugin.cpp. + + +Working Plugins: +Macromedia Flash Player +SWFDEC Mozilla Plugin (also flash) +Crossover (commercial from codeweavers) + - Test Windows Media Player, QuickTime, iPIX at least. +RealPlayer Plugin +TclPlugin +DjVU +Acrobat Plugin +mplayerplug-in +plugger + + +Non-working plugins: +CoPyCat (http://www.cartesianinc.com) - Bad plugin? +Java Plugin from SUN (Well, more like untested since KJava beats us to it) + + + +Good test sites: +http://www.shockwave.com/ +http://www.apple.com/trailers/ +http://www.djvuzone.org/ +http://www.tcl.tk/software/plugin/ +http://examples.macromedia.com/petmarket/flashstore.html +http://www.spiegel.de/video/0,4916,557,00.html <-- Real Video +http://www.bacardidj.com/ +http://fredrik.hubbe.net/plugger/test.html + + diff --git a/nsplugins/TODO b/nsplugins/TODO new file mode 100644 index 000000000..136948d69 --- /dev/null +++ b/nsplugins/TODO @@ -0,0 +1,2 @@ +- asynchronous integration with konqi (no freezing!) +- implement the new plugin schema diff --git a/nsplugins/kcm_nsplugins.cpp b/nsplugins/kcm_nsplugins.cpp new file mode 100644 index 000000000..037798cb2 --- /dev/null +++ b/nsplugins/kcm_nsplugins.cpp @@ -0,0 +1,130 @@ +/* + Copyright (c) 2003 Dirk Mueller <mueller@kde.org> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +*/ + +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> + +#include <tqregexp.h> +#include <tqlayout.h> +#include <kstandarddirs.h> +#include <tdelocale.h> +#include <kiconloader.h> +#include <tdefiledialog.h> +#include <kurlrequester.h> + +#include <tqwhatsthis.h> +#include <tqvgroupbox.h> +#include <kdebug.h> + +#include <tdeapplication.h> +#include <dcopclient.h> +#include <kprocio.h> + +#include "plugin_paths.h" + +static TQDateTime lastChanged( TQString dir ) +{ + TQDateTime t = TQFileInfo( dir ).lastModified(); + if( t.isNull()) + return t; + TQStringList subdirs = TQDir( dir ).entryList(); + for( TQStringList::ConstIterator it = subdirs.begin(); + it != subdirs.end(); + ++it ) + { + if( *it == "." || *it == ".." ) + continue; + TQDateTime t2 = lastChanged( *it ); + if( !t2.isNull() && t2 > t ) + t = t2; + } + return t; +} + +static bool checkSearchPathTimestamps( TQStringList paths, TQStringList timestamps ) +{ + TQStringList currentTimestamps; + bool changed = false; + TQStringList::ConstIterator t = timestamps.begin(); + for( TQStringList::ConstIterator it = paths.begin(); + it != paths.end(); + ++it, ++t ) + { + TQDateTime current = lastChanged( *it ); + // store non-existent directory as "N" string rather than empty string, TDEConfig + // has a bug with storing a list of empty items + if( *t == "N" ? !current.isNull() : current != TQDateTime::fromString( *t, Qt::ISODate )) + changed = true; + currentTimestamps.append( current.isNull() ? "N" : current.toString( Qt::ISODate )); + } + if( changed ) + { + TDEConfig config("kcmnspluginrc"); + config.setGroup("Misc"); + config.writeEntry( "lastSearchPaths", paths ); + config.writeEntry( "lastSearchTimestamps", currentTimestamps ); + return true; + } + return false; +} + +extern "C" +{ + KDE_EXPORT void init_nsplugin() + { + TDEConfig *config = new TDEConfig("kcmnspluginrc", true /* readonly */, false /* no globals*/); + config->setGroup("Misc"); + bool scan = config->readBoolEntry( "starttdeScan", false ); + bool firstTime = config->readBoolEntry( "firstTime", true ); + + if( !scan ) + { + // check if plugins have changed, as just ignoring everything and requiring the user + // to trigger the check manually is not reasonable - that probably actually obsoletes + // both options + TQStringList searchPaths = getSearchPaths(); + TQStringList lastSearchPaths = config->readListEntry( "lastSearchPaths" ); + TQStringList lastTimestamps = config->readListEntry ( "lastSearchTimestamps" ); + if( searchPaths != lastSearchPaths || lastTimestamps.count() != lastSearchPaths.count()) + { // count changed, set empty timestamps, still call checkSearchPathTimestamps() + // in order to save the current timestamps for the next time + lastSearchPaths = searchPaths; + lastTimestamps.clear(); + lastTimestamps.insert( lastTimestamps.end(), searchPaths.count(), "N" ); + scan = true; + } + if( checkSearchPathTimestamps( lastSearchPaths, lastTimestamps )) + scan = true; + } + delete config; + + if ( scan || firstTime ) + { + TDEApplication::tdeinitExec("nspluginscan"); + } + + if (firstTime) { + config= new TDEConfig("kcmnspluginrc", false); + config->setGroup("Misc"); + config->writeEntry( "firstTime", false ); + config->sync(); + delete config; + } + } +} diff --git a/nsplugins/nspluginloader.cpp b/nsplugins/nspluginloader.cpp new file mode 100644 index 000000000..8c9e6fe2c --- /dev/null +++ b/nsplugins/nspluginloader.cpp @@ -0,0 +1,528 @@ +/* + + This is an encapsulation of the Netscape plugin API. + + + Copyright (c) 2000 Matthias Hoelzer-Kluepfel <hoelzer@kde.org> + Stefan Schimanski <1Stein@gmx.de> + Copyright (c) 2002-2005 George Staikos <staikos@kde.org> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ + + +#include <tqdir.h> + + +#include <tdeapplication.h> +#include <kprocess.h> +#include <kdebug.h> +#include <tdeglobal.h> +#include <tdelocale.h> +#include <kstandarddirs.h> +#include <tdeconfig.h> +#include <dcopclient.h> +#include <dcopstub.h> +#include <tqlayout.h> +#include <tqobject.h> +#include <tqpushbutton.h> +#include <qxembed.h> +#include <tqtextstream.h> +#include <tqtimer.h> +#include <tqregexp.h> + +#include "nspluginloader.h" +#include "nspluginloader.moc" + +#include "NSPluginClassIface_stub.h" + +#include <config.h> + +NSPluginLoader *NSPluginLoader::s_instance = 0; +int NSPluginLoader::s_refCount = 0; + + +NSPluginInstance::NSPluginInstance(TQWidget *parent) + : EMBEDCLASS(parent), _loader( NULL ), shown( false ), inited( false ), resize_count( 0 ), stub( NULL ) +{ +} + +void NSPluginInstance::init(const TQCString& app, const TQCString& obj) +{ + stub = new NSPluginInstanceIface_stub( app, obj ); + TQGridLayout *_layout = new TQGridLayout(this, 1, 1); + TDEConfig cfg("kcmnspluginrc", false); + cfg.setGroup("Misc"); + if (cfg.readBoolEntry("demandLoad", false)) { + _button = new TQPushButton(i18n("Start Plugin"), dynamic_cast<EMBEDCLASS*>(this)); + _layout->addWidget(_button, 0, 0); + connect(_button, TQT_SIGNAL(clicked()), this, TQT_SLOT(loadPlugin())); + show(); + } else { + _button = 0L; + // Protection against repeated NPSetWindow() - Flash v9,0,115,0 doesn't handle + // repeated NPSetWindow() calls properly, which happens when NSPluginInstance is first + // shown and then resized. Which is what happens with TDEHTML. Therefore use 'shown' + // to detect whether the widget is shown and drop all resize events before that, + // and use 'resize_count' to wait for that one more resize to come (plus a timer + // for a possible timeout). Only then flash is actually initialized ('inited' is true). + resize_count = 1; + TQTimer::singleShot( 1000, this, TQT_SLOT( doLoadPlugin())); + } +} + +void NSPluginInstance::loadPlugin() +{ + delete _button; + _button = 0; + doLoadPlugin(); +} + +void NSPluginInstance::doLoadPlugin() { + if (!inited && !_button) { + _loader = NSPluginLoader::instance(); + setBackgroundMode(TQWidget::NoBackground); + WId winid = stub->winId(); + if( winid != 0 ) { + setProtocol(QXEmbed::XPLAIN); + embed( winid ); + } else { + setProtocol(QXEmbed::XEMBED); + } + // resize before showing, some plugins are stupid and can't handle repeated + // NPSetWindow() calls very well (viewer will avoid the call if not shown yet) + resizePlugin(width(), height()); + displayPlugin(); + show(); + inited = true; + } +} + + +NSPluginInstance::~NSPluginInstance() +{ + kdDebug() << "-> NSPluginInstance::~NSPluginInstance" << endl; + if( inited ) + shutdown(); + kdDebug() << "release" << endl; + if(_loader) + _loader->release(); + kdDebug() << "<- NSPluginInstance::~NSPluginInstance" << endl; + delete stub; +} + + +void NSPluginInstance::windowChanged(WId w) +{ + setBackgroundMode(w == 0 ? TQWidget::PaletteBackground : TQWidget::NoBackground); + if (w == 0) { + // FIXME: Put a notice here to tell the user that it crashed. + repaint(); + } +} + + +void NSPluginInstance::resizeEvent(TQResizeEvent *event) +{ + if (shown == false) // ignore all resizes before being shown + return; + if( !inited && resize_count > 0 ) { + if( --resize_count == 0 ) + doLoadPlugin(); + else + return; + } + EMBEDCLASS::resizeEvent(event); + if (isVisible()) { + resizePlugin(width(), height()); + } + kdDebug() << "NSPluginInstance(client)::resizeEvent" << endl; +} + +void NSPluginInstance::showEvent(TQShowEvent *event) +{ + EMBEDCLASS::showEvent(event); + shown = true; + if(!inited && resize_count == 0 ) + doLoadPlugin(); + if(inited) + resizePlugin(width(), height()); +} + +void NSPluginInstance::focusInEvent( TQFocusEvent* event ) +{ + stub->gotFocusIn(); +} + +void NSPluginInstance::focusOutEvent( TQFocusEvent* event ) +{ + stub->gotFocusOut(); +} + +void NSPluginInstance::displayPlugin() +{ + tqApp->syncX(); // process pending X commands + stub->displayPlugin(); +} + +void NSPluginInstance::resizePlugin( int w, int h ) +{ + tqApp->syncX(); + stub->resizePlugin( w, h ); +} + +void NSPluginInstance::shutdown() +{ + if( stub ) + stub->shutdown(); +} + +/*******************************************************************************/ + + +NSPluginLoader::NSPluginLoader() + : TQObject(), _mapping(7, false), _viewer(0) +{ + scanPlugins(); + _mapping.setAutoDelete( true ); + _filetype.setAutoDelete(true); + + // trap dcop register events + kapp->dcopClient()->setNotifications(true); + TQObject::connect(kapp->dcopClient(), + TQT_SIGNAL(applicationRegistered(const TQCString&)), + this, TQT_SLOT(applicationRegistered(const TQCString&))); + + // load configuration + TDEConfig cfg("kcmnspluginrc", false); + cfg.setGroup("Misc"); + _useArtsdsp = cfg.readBoolEntry( "useArtsdsp", false ); +} + + +NSPluginLoader *NSPluginLoader::instance() +{ + if (!s_instance) + s_instance = new NSPluginLoader; + + s_refCount++; + kdDebug() << "NSPluginLoader::instance -> " << s_refCount << endl; + + return s_instance; +} + + +void NSPluginLoader::release() +{ + s_refCount--; + kdDebug() << "NSPluginLoader::release -> " << s_refCount << endl; + + if (s_refCount==0) + { + delete s_instance; + s_instance = 0; + } +} + + +NSPluginLoader::~NSPluginLoader() +{ + kdDebug() << "-> NSPluginLoader::~NSPluginLoader" << endl; + unloadViewer(); + kdDebug() << "<- NSPluginLoader::~NSPluginLoader" << endl; +} + + +void NSPluginLoader::scanPlugins() +{ + TQRegExp version(";version=[^:]*:"); + + // open the cache file + TQFile cachef(locate("data", "nsplugins/cache")); + if (!cachef.open(IO_ReadOnly)) { + kdDebug() << "Could not load plugin cache file!" << endl; + return; + } + + TQTextStream cache(&cachef); + + // read in cache + TQString line, plugin; + while (!cache.atEnd()) { + line = cache.readLine(); + if (line.isEmpty() || (line.left(1) == "#")) + continue; + + if (line.left(1) == "[") + { + plugin = line.mid(1,line.length()-2); + continue; + } + + TQStringList desc = TQStringList::split(':', line, TRUE); + TQString mime = desc[0].stripWhiteSpace(); + TQStringList suffixes = TQStringList::split(',', desc[1].stripWhiteSpace()); + if (!mime.isEmpty()) + { + // insert the mimetype -> plugin mapping + _mapping.insert(mime, new TQString(plugin)); + + // insert the suffix -> mimetype mapping + TQStringList::Iterator suffix; + for (suffix = suffixes.begin(); suffix != suffixes.end(); ++suffix) { + + // strip whitspaces and any preceding '.' + TQString stripped = (*suffix).stripWhiteSpace(); + + unsigned p=0; + for ( ; p<stripped.length() && stripped[p]=='.'; p++ ); + stripped = stripped.right( stripped.length()-p ); + + // add filetype to list + if ( !stripped.isEmpty() && !_filetype.find(stripped) ) + _filetype.insert( stripped, new TQString(mime)); + } + } + } +} + + +TQString NSPluginLoader::lookupMimeType(const TQString &url) +{ + TQDictIterator<TQString> dit2(_filetype); + while (dit2.current()) + { + TQString ext = TQString(".")+dit2.currentKey(); + if (url.right(ext.length()) == ext) + return *dit2.current(); + ++dit2; + } + return TQString::null; +} + + +TQString NSPluginLoader::lookup(const TQString &mimeType) +{ + TQString plugin; + if ( _mapping[mimeType] ) + plugin = *_mapping[mimeType]; + + kdDebug() << "Looking up plugin for mimetype " << mimeType << ": " << plugin << endl; + + return plugin; +} + + +bool NSPluginLoader::loadViewer(const TQString &mimeType) +{ + kdDebug() << "NSPluginLoader::loadViewer" << endl; + + _running = false; + _process = new TDEProcess; + + // get the dcop app id + int pid = (int)getpid(); + _dcopid.sprintf("nspluginviewer-%d", pid); + + connect( _process, TQT_SIGNAL(processExited(TDEProcess*)), + this, TQT_SLOT(processTerminated(TDEProcess*)) ); + + // find the external viewer process + TQString viewer = TDEGlobal::dirs()->findExe("nspluginviewer"); + if (!viewer) + { + kdDebug() << "can't find nspluginviewer" << endl; + delete _process; + return false; + } + + // find the external artsdsp process + if( _useArtsdsp && mimeType != "application/pdf" ) { + kdDebug() << "trying to use artsdsp" << endl; + TQString artsdsp = TDEGlobal::dirs()->findExe("artsdsp"); + if (!artsdsp) + { + kdDebug() << "can't find artsdsp" << endl; + } else + { + kdDebug() << artsdsp << endl; + *_process << artsdsp; + } + } else + kdDebug() << "don't using artsdsp" << endl; + + *_process << viewer; + + // tell the process it's parameters + *_process << "-dcopid"; + *_process << _dcopid; + + // run the process + kdDebug() << "Running nspluginviewer" << endl; + _process->start(); + + // wait for the process to run + int cnt = 0; + while (!kapp->dcopClient()->isApplicationRegistered(_dcopid)) + { + //kapp->processEvents(); // would lead to recursive calls in tdehtml +#ifdef HAVE_USLEEP + usleep( 50*1000 ); +#else + sleep(1); kdDebug() << "sleep" << endl; +#endif + cnt++; +#ifdef HAVE_USLEEP + if (cnt >= 100) +#else + if (cnt >= 10) +#endif + { + kdDebug() << "timeout" << endl; + delete _process; + return false; + } + + if (!_process->isRunning()) + { + kdDebug() << "nspluginviewer terminated" << endl; + delete _process; + return false; + } + } + + // get viewer dcop interface + _viewer = new NSPluginViewerIface_stub( _dcopid, "viewer" ); + + return _viewer!=0; +} + + +void NSPluginLoader::unloadViewer() +{ + kdDebug() << "-> NSPluginLoader::unloadViewer" << endl; + + if ( _viewer ) + { + _viewer->shutdown(); + kdDebug() << "Shutdown viewer" << endl; + delete _viewer; + delete _process; + _viewer = 0; + _process = 0; + } + + kdDebug() << "<- NSPluginLoader::unloadViewer" << endl; +} + + +void NSPluginLoader::applicationRegistered( const TQCString& appId ) +{ + kdDebug() << "DCOP application " << appId.data() << " just registered!" << endl; + + if ( _dcopid==appId ) + { + _running = true; + kdDebug() << "plugin now running" << endl; + } +} + + +void NSPluginLoader::processTerminated(TDEProcess *proc) +{ + if ( _process == proc) + { + kdDebug() << "Viewer process terminated" << endl; + delete _viewer; + delete _process; + _viewer = 0; + _process = 0; + } +} + + +NSPluginInstance *NSPluginLoader::newInstance(TQWidget *parent, TQString url, + TQString mimeType, bool embed, + TQStringList argn, TQStringList argv, + TQString appId, TQString callbackId, bool reload, bool doPost, TQByteArray postData) +{ + kdDebug() << "-> NSPluginLoader::NewInstance( parent=" << (void*)parent << ", url=" << url << ", mime=" << mimeType << ", ...)" << endl; + + if ( !_viewer ) + { + // load plugin viewer process + loadViewer(mimeType); + + if ( !_viewer ) + { + kdDebug() << "No viewer dcop stub found" << endl; + return 0; + } + } + + // check the mime type + TQString mime = mimeType; + if (mime.isEmpty()) + { + mime = lookupMimeType( url ); + argn << "MIME"; + argv << mime; + } + if (mime.isEmpty()) + { + kdDebug() << "Unknown MimeType" << endl; + return 0; + } + + // lookup plugin for mime type + TQString plugin_name = lookup(mime); + if (plugin_name.isEmpty()) + { + kdDebug() << "No suitable plugin" << endl; + return 0; + } + + // get plugin class object + DCOPRef cls_ref = _viewer->newClass( plugin_name ); + if ( cls_ref.isNull() ) + { + kdDebug() << "Couldn't create plugin class" << endl; + return 0; + } + NSPluginClassIface_stub *cls = new NSPluginClassIface_stub( cls_ref.app(), cls_ref.object() ); + + // handle special plugin cases + if ( mime=="application/x-shockwave-flash" ) + embed = true; // flash doesn't work in full mode :( + + NSPluginInstance *plugin = new NSPluginInstance( parent ); + kdDebug() << "<- NSPluginLoader::NewInstance = " << (void*)plugin << endl; + + // get plugin instance + DCOPRef inst_ref = cls->newInstance( url, mime, embed, argn, argv, appId, callbackId, reload, doPost, postData, plugin->winId()); + if ( inst_ref.isNull() ) + { + kdDebug() << "Couldn't create plugin instance" << endl; + delete plugin; + return 0; + } + + plugin->init( inst_ref.app(), inst_ref.object() ); + + return plugin; +} + +// vim: ts=4 sw=4 et diff --git a/nsplugins/nspluginloader.h b/nsplugins/nspluginloader.h new file mode 100644 index 000000000..988697848 --- /dev/null +++ b/nsplugins/nspluginloader.h @@ -0,0 +1,126 @@ +/* + + This is an encapsulation of the Netscape plugin API. + + + Copyright (c) 2000 Matthias Hoelzer-Kluepfel <hoelzer@kde.org> + Stefan Schimanski <1Stein@gmx.de> + Copyright (c) 2002-2005 George Staikos <staikos@kde.org> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ + + +#ifndef __NS_PLUGINLOADER_H__ +#define __NS_PLUGINLOADER_H__ + + +#include <tqstring.h> +#include <tqstringlist.h> +#include <tqdict.h> +#include <tqobject.h> +#include <tqwidget.h> +#include <qxembed.h> + +#include "NSPluginClassIface_stub.h" + +#define EMBEDCLASS QXEmbed + +class TDEProcess; +class TQPushButton; +class TQGridLayout; + +class NSPluginInstance : public EMBEDCLASS +{ + Q_OBJECT + +public: + NSPluginInstance(TQWidget *parent); + void init( const TQCString& app, const TQCString& obj ); + ~NSPluginInstance(); +public: // wrappers + void javascriptResult( int id, TQString result ) { stub->javascriptResult( id, result ); } + +private slots: + void loadPlugin(); + void doLoadPlugin(); + +protected: + void resizeEvent(TQResizeEvent *event); + void showEvent (TQShowEvent *); + void windowChanged(WId w); + virtual void focusInEvent( TQFocusEvent* event ); + virtual void focusOutEvent( TQFocusEvent* event ); + class NSPluginLoader *_loader; + bool shown; + bool inited; + int resize_count; + TQPushButton *_button; + TQGridLayout *_layout; + NSPluginInstanceIface_stub* stub; +private: // wrappers + void displayPlugin(); + void resizePlugin( int w, int h ); + void shutdown(); +}; + + +class NSPluginLoader : public TQObject +{ + Q_OBJECT + +public: + NSPluginLoader(); + ~NSPluginLoader(); + + NSPluginInstance *newInstance(TQWidget *parent, + TQString url, TQString mimeType, bool embed, + TQStringList argn, TQStringList argv, + TQString appId, TQString callbackId, bool reload, + bool doPost, TQByteArray postData); + + static NSPluginLoader *instance(); + void release(); + +protected: + void scanPlugins(); + + TQString lookup(const TQString &mimeType); + TQString lookupMimeType(const TQString &url); + + bool loadViewer(const TQString &mimeType); + void unloadViewer(); + +protected slots: + void applicationRegistered( const TQCString& appId ); + void processTerminated( TDEProcess *proc ); + +private: + TQStringList _searchPaths; + TQDict<TQString> _mapping, _filetype; + + TDEProcess *_process; + bool _running; + TQCString _dcopid; + NSPluginViewerIface_stub *_viewer; + bool _useArtsdsp; + + static NSPluginLoader *s_instance; + static int s_refCount; +}; + + +#endif diff --git a/nsplugins/nspluginpart.rc b/nsplugins/nspluginpart.rc new file mode 100644 index 000000000..14790318b --- /dev/null +++ b/nsplugins/nspluginpart.rc @@ -0,0 +1,9 @@ +<!DOCTYPE kpartgui> +<kpartgui name="nspluginpart" version="1"> +<MenuBar> + <Menu name="file"><text>&File</text> + <Action name="saveDocument"/> + </Menu> +</MenuBar> +</kpartgui> + diff --git a/nsplugins/plugin_part.cpp b/nsplugins/plugin_part.cpp new file mode 100644 index 000000000..99cbc780f --- /dev/null +++ b/nsplugins/plugin_part.cpp @@ -0,0 +1,419 @@ +/* + Netscape Plugin Loader KPart + + Copyright (c) 2000 Matthias Hoelzer-Kluepfel <hoelzer@kde.org> + Stefan Schimanski <1Stein@gmx.de> + Copyright (c) 2002-2005 George Staikos <staikos@kde.org> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +*/ + +#include <dcopclient.h> +#include <tdeaboutdata.h> +#include <tdeaction.h> +#include <tdeapplication.h> +#include <kdebug.h> +#include <tdefiledialog.h> +#include <tdeio/netaccess.h> +#include <tdelocale.h> +#include <tdeparts/browserinterface.h> +#include <tdeparts/browserextension.h> + +#include <tqlabel.h> + +#include "nspluginloader.h" +#include "plugin_part.h" + + +class PluginBrowserExtension : public KParts::BrowserExtension +{ + friend class PluginPart; +public: + PluginBrowserExtension( KParts::ReadOnlyPart *parent, + const char *name = 0L ) + : KParts::BrowserExtension( parent, name ) {} + ~PluginBrowserExtension() {} + + // ATTENTION: you -CANNOT- add data members here +}; + + +PluginLiveConnectExtension::PluginLiveConnectExtension(PluginPart* part) +: KParts::LiveConnectExtension(part), _part(part), _retval(0L) { +} + +PluginLiveConnectExtension::~PluginLiveConnectExtension() { +} + +bool PluginLiveConnectExtension::get(const unsigned long, const TQString &field, Type &type, unsigned long &retobj, TQString &value) { +Q_UNUSED(type); +Q_UNUSED(retobj); +Q_UNUSED(value); + kdDebug(1432) << "PLUGIN:LiveConnect::get " << field << endl; + return false; +} + +bool PluginLiveConnectExtension::call(const unsigned long, const TQString &func, const TQStringList &args, Type &type, unsigned long &retobjid, TQString &value) { +Q_UNUSED(type); +Q_UNUSED(retobjid); +Q_UNUSED(value); + kdDebug(1432) << "PLUGIN:LiveConnect::call " << func << " args: " << args << endl; + return false; +} + +bool PluginLiveConnectExtension::put( const unsigned long, const TQString &field, const TQString &value) { + kdDebug(1432) << "PLUGIN:LiveConnect::put " << field << " " << value << endl; + if (_retval && field == "__nsplugin") { + *_retval = value; + return true; + } else if (field.lower() == "src") { + _part->changeSrc(value); + return true; + } + return false; +} + +TQString PluginLiveConnectExtension::evalJavaScript( const TQString & script ) +{ + kdDebug(1432) << "PLUGIN:LiveConnect::evalJavaScript " << script << endl; + ArgList args; + TQString jscode; + jscode.sprintf("this.__nsplugin=eval(\"%s\")", TQString(script).replace('\\', "\\\\").replace('"', "\\\"").latin1()); + //kdDebug(1432) << "String is [" << jscode << "]" << endl; + args.push_back(qMakePair(KParts::LiveConnectExtension::TypeString, jscode)); + TQString nsplugin("Undefined"); + _retval = &nsplugin; + emit partEvent(0, "eval", args); + _retval = 0L; + return nsplugin; +} + +extern "C" +{ + /** + * This function is the 'main' function of this part. It takes + * the form 'void *init_lib<library name>() It always returns a + * new factory object + */ + + K_EXPORT_COMPONENT_FACTORY(libnsplugin,PluginFactory) +} + + +NSPluginCallback::NSPluginCallback(PluginPart *part) + : DCOPObject() +{ + _part = part; +} + + +void NSPluginCallback::postURL(TQString url, TQString target, TQByteArray data, TQString mime) +{ + _part->postURL( url, target, data, mime ); +} + + +void NSPluginCallback::requestURL(TQString url, TQString target) +{ + _part->requestURL( url, target ); +} + + +void NSPluginCallback::statusMessage( TQString msg ) +{ + _part->statusMessage( msg ); +} + + +void NSPluginCallback::evalJavaScript( int id, TQString script ) +{ + _part->evalJavaScript( id, script ); +} +/** + * We need one static instance of the factory for our C 'main' + * function + */ +TDEInstance *PluginFactory::s_instance = 0L; + + +PluginFactory::PluginFactory() +{ + kdDebug(1432) << "PluginFactory::PluginFactory" << endl; + s_instance = 0; + + // preload plugin loader + _loader = NSPluginLoader::instance(); +} + + +PluginFactory::~PluginFactory() +{ + kdDebug(1432) << "PluginFactory::~PluginFactory" << endl; + + _loader->release(); + + if ( s_instance ) { + delete s_instance->aboutData(); + delete s_instance; + } + s_instance = 0; +} + +KParts::Part * PluginFactory::createPartObject(TQWidget *parentWidget, const char *widgetName, + TQObject *parent, const char *name, + const char *classname, const TQStringList &args) +{ + Q_UNUSED(classname) + kdDebug(1432) << "PluginFactory::create" << endl; + KParts::Part *obj = new PluginPart(parentWidget, widgetName, parent, name, args); + return obj; +} + + +TDEInstance *PluginFactory::instance() +{ + kdDebug(1432) << "PluginFactory::instance" << endl; + + if ( !s_instance ) + s_instance = new TDEInstance( aboutData() ); + return s_instance; +} + +TDEAboutData *PluginFactory::aboutData() +{ + TDEAboutData *about = new TDEAboutData("plugin", I18N_NOOP("plugin"), "1.99"); + return about; +} + + +/**************************************************************************/ + + +PluginPart::PluginPart(TQWidget *parentWidget, const char *widgetName, TQObject *parent, + const char *name, const TQStringList &args) + : KParts::ReadOnlyPart(parent, name), _widget(0), _args(args), + _destructed(0L) +{ + setInstance(PluginFactory::instance()); + kdDebug(1432) << "PluginPart::PluginPart" << endl; + + // we have to keep the class name of KParts::PluginBrowserExtension + // to let tdehtml find it + _extension = static_cast<PluginBrowserExtension*>(new KParts::BrowserExtension(this)); + _liveconnect = new PluginLiveConnectExtension(this); + + // Only create this if we have no parent since the parent part is + // responsible for "Save As" then + if (!parent || !parent->inherits("Part")) { + new TDEAction(i18n("&Save As..."), CTRL+Key_S, this, TQT_SLOT(saveAs()), actionCollection(), "saveDocument"); + setXMLFile("nspluginpart.rc"); + } + + // create + _loader = NSPluginLoader::instance(); + _callback = new NSPluginCallback(this); + + // create a canvas to insert our widget + _canvas = new PluginCanvasWidget( parentWidget, widgetName ); + //_canvas->setFocusPolicy( TQWidget::ClickFocus ); + _canvas->setFocusPolicy( TQ_WheelFocus ); + _canvas->setBackgroundMode( TQWidget::NoBackground ); + setWidget(_canvas); + _canvas->show(); + TQObject::connect( _canvas, TQT_SIGNAL(resized(int,int)), + this, TQT_SLOT(pluginResized(int,int)) ); +} + + +PluginPart::~PluginPart() +{ + kdDebug(1432) << "PluginPart::~PluginPart" << endl; + + delete _callback; + _loader->release(); + if (_destructed) + *_destructed = true; +} + + +bool PluginPart::openURL(const KURL &url) +{ + closeURL(); + kdDebug(1432) << "-> PluginPart::openURL" << endl; + + m_url = url; + TQString surl = url.url(); + TQString smime = _extension->urlArgs().serviceType; + bool reload = _extension->urlArgs().reload; + bool embed = false; + bool post = _extension->urlArgs().doPost(); + + // handle arguments + TQStringList argn, argv; + + TQStringList::Iterator it = _args.begin(); + for ( ; it != _args.end(); ) { + + int equalPos = (*it).find("="); + if (equalPos>0) { + + TQString name = (*it).left(equalPos).upper(); + TQString value = (*it).mid(equalPos+1); + if (value[0] == '"' && value[value.length()-1] == '"') + value = value.mid(1, value.length()-2); + + kdDebug(1432) << "name=" << name << " value=" << value << endl; + + if (!name.isEmpty()) { + // hack to pass view mode from tdehtml + if ( name=="__TDEHTML__PLUGINEMBED" ) { + embed = true; + kdDebug(1432) << "__TDEHTML__PLUGINEMBED found" << endl; + } else { + argn << name; + argv << value; + } + } + } + + it++; + } + + if (surl.isEmpty()) { + kdDebug(1432) << "<- PluginPart::openURL - false (no url passed to nsplugin)" << endl; + return false; + } + + // status messages + emit setWindowCaption( url.prettyURL() ); + emit setStatusBarText( i18n("Loading Netscape plugin for %1").arg(url.prettyURL()) ); + + // create plugin widget + NSPluginInstance *inst = _loader->newInstance(_canvas, surl, smime, embed, argn, argv, kapp->dcopClient()->appId(), _callback->objId(), reload, post, _extension->urlArgs().postData); + + if ( inst ) { + _widget = inst; + } else { + TQLabel *label = new TQLabel( i18n("Unable to load Netscape plugin for %1").arg(url.url()), _canvas ); + label->setAlignment( AlignCenter | WordBreak ); + _widget = label; + } + + _widget->resize(_canvas->width(), _canvas->height()); + _widget->show(); + + kdDebug(1432) << "<- PluginPart::openURL = " << (inst!=0) << endl; + return inst != 0L; +} + + +bool PluginPart::closeURL() +{ + kdDebug(1432) << "PluginPart::closeURL" << endl; + delete _widget; + _widget = 0; + return true; +} + + +void PluginPart::reloadPage() +{ + kdDebug(1432) << "PluginPart::reloadPage()" << endl; + _extension->browserInterface()->callMethod("goHistory(int)", 0); +} + +void PluginPart::postURL(const TQString& url, const TQString& target, const TQByteArray& data, const TQString& mime) +{ + kdDebug(1432) << "PluginPart::postURL( url=" << url + << ", target=" << target << endl; + + KURL new_url(this->url(), url); + KParts::URLArgs args; + args.setDoPost(true); + args.frameName = target; + args.postData = data; + args.setContentType(mime); + + emit _extension->openURLRequest(new_url, args); +} + +void PluginPart::requestURL(const TQString& url, const TQString& target) +{ + kdDebug(1432) << "PluginPart::requestURL( url=" << url + << ", target=" << target << endl; + + KURL new_url(this->url(), url); + KParts::URLArgs args; + args.frameName = target; + args.setDoPost(false); + + emit _extension->openURLRequest(new_url, args); +} + +void PluginPart::evalJavaScript(int id, const TQString & script) +{ + kdDebug(1432) <<"evalJavascript: before widget check"<<endl; + if (_widget) { + bool destructed = false; + _destructed = &destructed; + kdDebug(1432) <<"evalJavascript: there is a widget" <<endl; + TQString rc = _liveconnect->evalJavaScript(script); + if (destructed) + return; + _destructed = 0L; + kdDebug(1432) << "Liveconnect: script [" << script << "] evaluated to [" << rc << "]" << endl; + NSPluginInstance *ni = dynamic_cast<NSPluginInstance*>(_widget.operator->()); + if (ni) + ni->javascriptResult(id, rc); + } +} + +void PluginPart::statusMessage(TQString msg) +{ + kdDebug(1422) << "PluginPart::statusMessage " << msg << endl; + emit setStatusBarText(msg); +} + + +void PluginPart::pluginResized(int w, int h) +{ + kdDebug(1432) << "PluginPart::pluginResized()" << endl; + + if (_widget) { + _widget->resize(w, h); + } +} + + +void PluginPart::changeSrc(const TQString& url) { + closeURL(); + openURL(KURL( url )); +} + + +void PluginPart::saveAs() { + KURL savefile = KFileDialog::getSaveURL(TQString::null, TQString::null, _widget); + TDEIO::NetAccess::copy(m_url, savefile, _widget); +} + + +void PluginCanvasWidget::resizeEvent(TQResizeEvent *ev) +{ + TQWidget::resizeEvent(ev); + emit resized(width(), height()); +} + + +#include "plugin_part.moc" diff --git a/nsplugins/plugin_part.h b/nsplugins/plugin_part.h new file mode 100644 index 000000000..f3fa68984 --- /dev/null +++ b/nsplugins/plugin_part.h @@ -0,0 +1,159 @@ +/* + Netscape Plugin Loader KPart + + Copyright (c) 2000 Matthias Hoelzer-Kluepfel <hoelzer@kde.org> + Stefan Schimanski <1Stein@gmx.de> + Copyright (c) 2002-2005 George Staikos <staikos@kde.org> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +*/ + + +#ifndef __plugin_part_h__ +#define __plugin_part_h__ + +#include <tdeparts/browserextension.h> +#include <tdeparts/factory.h> +#include <tdeparts/part.h> +#include <klibloader.h> +#include <tqwidget.h> +#include <tqguardedptr.h> + +class TDEAboutData; +class TDEInstance; +class PluginBrowserExtension; +class PluginLiveConnectExtension; +class TQLabel; +class NSPluginInstance; +class PluginPart; + + +#include "NSPluginCallbackIface.h" + + +class NSPluginCallback : public NSPluginCallbackIface +{ +public: + NSPluginCallback(PluginPart *part); + + ASYNC reloadPage(); + ASYNC requestURL(TQString url, TQString target); + ASYNC postURL(TQString url, TQString target, TQByteArray data, TQString mime); + ASYNC statusMessage( TQString msg ); + ASYNC evalJavaScript( int id, TQString script ); + +private: + PluginPart *_part; +}; + + +class PluginFactory : public KParts::Factory +{ + Q_OBJECT + +public: + PluginFactory(); + virtual ~PluginFactory(); + + virtual KParts::Part * createPartObject(TQWidget *parentWidget = 0, const char *widgetName = 0, + TQObject *parent = 0, const char *name = 0, + const char *classname = "KParts::Part", + const TQStringList &args = TQStringList()); + + static TDEInstance *instance(); + static TDEAboutData *aboutData(); + +private: + + static TDEInstance *s_instance; + class NSPluginLoader *_loader; +}; + + +class PluginCanvasWidget : public TQWidget +{ + Q_OBJECT +public: + + PluginCanvasWidget(TQWidget *parent=0, const char *name=0) + : TQWidget(parent,name) {} + +protected: + void resizeEvent(TQResizeEvent *e); + +signals: + void resized(int,int); +}; + + +class PluginPart: public KParts::ReadOnlyPart +{ + Q_OBJECT +public: + PluginPart(TQWidget *parentWidget, const char *widgetName, TQObject *parent, + const char *name, const TQStringList &args = TQStringList()); + virtual ~PluginPart(); + + void postURL(const TQString& url, const TQString& target, const TQByteArray& data, const TQString& mime); + void requestURL(const TQString& url, const TQString& target); + void statusMessage( TQString msg ); + void evalJavaScript( int id, const TQString& script ); + void reloadPage(); + + void changeSrc(const TQString& url); + +protected: + virtual bool openURL(const KURL &url); + virtual bool closeURL(); + virtual bool openFile() { return false; }; + +protected slots: + void pluginResized(int,int); + void saveAs(); + +private: + TQGuardedPtr<TQWidget> _widget; + PluginCanvasWidget *_canvas; + PluginBrowserExtension *_extension; + PluginLiveConnectExtension *_liveconnect; + NSPluginCallback *_callback; + TQStringList _args; + class NSPluginLoader *_loader; + bool *_destructed; +}; + + +class PluginLiveConnectExtension : public KParts::LiveConnectExtension +{ +Q_OBJECT +public: + PluginLiveConnectExtension(PluginPart* part); + virtual ~PluginLiveConnectExtension(); + virtual bool put(const unsigned long, const TQString &field, const TQString &value); + virtual bool get(const unsigned long, const TQString&, Type&, unsigned long&, TQString&); + virtual bool call(const unsigned long, const TQString&, const TQStringList&, Type&, unsigned long&, TQString&); + + TQString evalJavaScript( const TQString & script ); + +signals: + virtual void partEvent( const unsigned long objid, const TQString & event, const KParts::LiveConnectExtension::ArgList & args ); + +private: + PluginPart *_part; + TQString *_retval; +}; + + +#endif diff --git a/nsplugins/plugin_paths.cpp b/nsplugins/plugin_paths.cpp new file mode 100644 index 000000000..905d90551 --- /dev/null +++ b/nsplugins/plugin_paths.cpp @@ -0,0 +1,76 @@ +/* + + This application scans for Netscape plugins and create a cache and + the necessary mimelnk and service files. + + + Copyright (c) 2000 Matthias Hoelzer-Kluepfel <hoelzer@kde.org> + Stefan Schimanski <1Stein@gmx.de> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ + +#include "plugin_paths.h" + +#include <tdeconfig.h> +#include <stdlib.h> + +TQStringList getSearchPaths() +{ + TQStringList searchPaths; + + TDEConfig *config = new TDEConfig("kcmnspluginrc", false); + config->setGroup("Misc"); + + // setup default paths + if ( !config->hasKey("scanPaths") ) { + TQStringList paths; + // keep sync with tdebase/kcontrol/konqhtml + paths.append("$HOME/.mozilla/plugins"); + paths.append("$HOME/.netscape/plugins"); + paths.append("/usr/lib/iceweasel/plugins"); + paths.append("/usr/lib/iceape/plugins"); + paths.append("/usr/lib/firefox/plugins"); + paths.append("/usr/lib64/browser-plugins"); + paths.append("/usr/lib/browser-plugins"); + paths.append("/usr/local/netscape/plugins"); + paths.append("/opt/mozilla/plugins"); + paths.append("/opt/mozilla/lib/plugins"); + paths.append("/opt/netscape/plugins"); + paths.append("/opt/netscape/communicator/plugins"); + paths.append("/usr/lib/netscape/plugins"); + paths.append("/usr/lib/netscape/plugins-libc5"); + paths.append("/usr/lib/netscape/plugins-libc6"); + paths.append("/usr/lib/mozilla/plugins"); + paths.append("/usr/lib64/netscape/plugins"); + paths.append("/usr/lib64/mozilla/plugins"); + paths.append("$MOZILLA_HOME/plugins"); + config->writeEntry( "scanPaths", paths ); + } + + // read paths + config->setDollarExpansion( true ); + searchPaths = config->readListEntry( "scanPaths" ); + delete config; + + // append environment variable NPX_PLUGIN_PATH + TQStringList envs = TQStringList::split(':', getenv("NPX_PLUGIN_PATH")); + TQStringList::Iterator it; + for (it = envs.begin(); it != envs.end(); ++it) + searchPaths.append(*it); + + return searchPaths; +} diff --git a/nsplugins/plugin_paths.h b/nsplugins/plugin_paths.h new file mode 100644 index 000000000..126d65665 --- /dev/null +++ b/nsplugins/plugin_paths.h @@ -0,0 +1,8 @@ +#ifndef PLUGIN_PATHS_H +#define PLUGIN_PATHS_H + +#include <tqstringlist.h> + +extern TQStringList getSearchPaths(); + +#endif diff --git a/nsplugins/pluginscan.cpp b/nsplugins/pluginscan.cpp new file mode 100644 index 000000000..0b6855c42 --- /dev/null +++ b/nsplugins/pluginscan.cpp @@ -0,0 +1,661 @@ +/* + + This application scans for Netscape plugins and create a cache and + the necessary mimelnk and service files. + + + Copyright (c) 2000 Matthias Hoelzer-Kluepfel <hoelzer@kde.org> + Stefan Schimanski <1Stein@gmx.de> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ + +#include <config.h> + +#include <sys/types.h> +#include <sys/wait.h> + +#include <errno.h> +#include <signal.h> +#include <unistd.h> + +#include <tqdir.h> +#include <tqfile.h> +#include <tqtextstream.h> +#include <tqregexp.h> +#include <tqbuffer.h> + +#include <dcopclient.h> + +#include <tdeapplication.h> +#include <kdebug.h> +#include <tdeglobal.h> +#include <kstandarddirs.h> +#include <klibloader.h> +#include <tdeconfig.h> +#include <kcrash.h> +#include <kdesktopfile.h> +#include <kservicetype.h> +#include <kmimetype.h> +#include <tdecmdlineargs.h> +#include <tdeaboutdata.h> +#include <tdelocale.h> + +#include "sdk/npupp.h" +#include <X11/Intrinsic.h> + +#include "plugin_paths.h" + +static int showProgress=0; + +// provide these symbols when compiling with gcc 3.x + +#if defined(__GNUC__) && defined(__GNUC_MINOR__) +#define KDE_GNUC_PREREQ(maj,min) \ + ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) +#else +#define KDE_GNUC_PREREQ(maj,min) 0 +#endif + +#if defined(__GNUC__) && KDE_GNUC_PREREQ(3,0) +extern "C" void* __builtin_new(size_t s) +{ + return operator new(s); +} + +extern "C" void __builtin_delete(void* p) +{ + operator delete(p); +} + +extern "C" void* __builtin_vec_new(size_t s) +{ + return operator new[](s); +} + +extern "C" void __builtin_vec_delete(void* p) +{ + operator delete[](p); +} + +extern "C" void __pure_virtual() +{ + abort(); +} +#endif + +// The only purpose of this function is just to pull in libXt. +// Using --enable-new-ldflags makes the linker use --as-needed and since +// otherwise nspluginscan wouldn't actually use libXt it wouldn't be really +// linked against it. However some plugins are not linked against libXt +// yet expect to have it available in the hosting application. +void pullInXt() +{ + XtFree( NULL ); +} + +TDEConfig *infoConfig = 0; + + +bool isPluginMimeType( TQString fname ) +{ + KDesktopFile cfg( fname, true ); + cfg.setDesktopGroup(); + return cfg.hasKey( "X-TDE-nsplugin" ); +} + + +void deletePluginMimeTypes() +{ + // iterate through local mime type directories + TQString dir = TDEGlobal::dirs()->saveLocation( "mime" ); + kdDebug(1433) << "Removing nsplugin MIME types in " << dir << endl; + TQDir dirs( dir, TQString::null, TQDir::Name|TQDir::IgnoreCase, TQDir::Dirs ); + if ( !dirs.exists() ) { + kdDebug(1433) << "Directory not found" << endl; + return; + } + + for ( unsigned int i=0; i<dirs.count(); i++ ) { + if ( !dirs[i].contains(".") ) { + + // check all mime types for X-TDE-nsplugin flag + kdDebug(1433) << " - Looking in " << dirs[i] << endl; + TQDir files( dirs.absFilePath(dirs[i]), TQString::null, + TQDir::Name|TQDir::IgnoreCase, TQDir::Files ); + if ( files.exists( dir ) ) { + + for (unsigned int i=0; i<files.count(); i++) { + + // check .desktop file + kdDebug(1433) << " - Checking " << files[i] << endl; + if ( isPluginMimeType(files.absFilePath(files[i])) ) { + kdDebug(1433) << " - Removing " << files[i] << endl; + files.remove( files[i] ); + } + + } + } + + } + } +} + + +void generateMimeType( TQString mime, TQString extensions, TQString pluginName, TQString description ) +{ + kdDebug(1433) << "-> generateMimeType mime=" << mime << " ext="<< extensions << endl; + + // get directory from mime string + TQString dir; + TQString name; + int pos = mime.findRev('/'); + if ( pos<0 ) { + kdDebug(1433) << "Invalid MIME type " << mime << endl; + kdDebug(1433) << "<- generateMimeType" << endl; + return; + } + dir = TDEGlobal::dirs()->saveLocation( "mime", mime.left(pos) ); + name = mime.mid(pos); + + // create mimelnk file + TQFile f( dir + name + ".desktop" ); + if ( f.open(IO_WriteOnly) ) { + + // write .desktop file + TQTextStream ts(&f); + + ts << "[Desktop Entry]" << endl; + ts << "Type=MimeType" << endl; + ts << "MimeType=" << mime << endl; + ts << "Icon=netscape_doc" << endl; + ts << "Comment=Netscape " << pluginName << endl; + ts << "X-TDE-AutoEmbed=true" << endl; + ts << "X-TDE-nsplugin=true" << endl; + + if (!extensions.isEmpty()) { + TQStringList exts = TQStringList::split(",", extensions); + TQStringList patterns; + for (TQStringList::Iterator it=exts.begin(); it != exts.end(); ++it) + patterns.append( "*." + (*it).stripWhiteSpace() ); + + ts << "Patterns=" << patterns.join( ";" ) << endl; + } + + if (!description.isEmpty()) + ts << "Name=" << description << endl; + else + ts << "Name=" << i18n("Netscape plugin mimeinfo") << endl; + + f.close(); + } + + kdDebug(1433) << "<- generateMimeType" << endl; +} + + +void registerPlugin( const TQString &name, const TQString &description, + const TQString &file, const TQString &mimeInfo ) +{ + // global stuff + infoConfig->setGroup( TQString::null ); + int num = infoConfig->readNumEntry( "number", 0 ); + infoConfig->writeEntry( "number", num+1 ); + + // create plugin info + infoConfig->setGroup( TQString::number(num) ); + infoConfig->writeEntry( "name", name ); + infoConfig->writeEntry( "description", description ); + infoConfig->writeEntry( "file", file ); + infoConfig->writeEntry( "mime", mimeInfo ); +} + +static void segv_handler(int) +{ + _exit(255); +} + +int tryCheck(int write_fd, const TQString &absFile) +{ + KLibrary *_handle = KLibLoader::self()->library( TQFile::encodeName(absFile) ); + if (!_handle) { + kdDebug(1433) << " - open failed with message " << + KLibLoader::self()->lastErrorMessage() << ", skipping " << endl; + return 1; + } + + // ask for name and description + TQString name = i18n("Unnamed plugin"); + TQString description; + + NPError (*func_GetValue)(void *, NPPVariable, void *) = + (NPError(*)(void *, NPPVariable, void *)) + _handle->symbol("NP_GetValue"); + if ( func_GetValue ) { + + // get name + char *buf = 0; + NPError err = func_GetValue( 0, NPPVpluginNameString, + (void*)&buf ); + if ( err==NPERR_NO_ERROR ) + name = TQString::fromLatin1( buf ); + kdDebug() << "name = " << name << endl; + + // get name + NPError nperr = func_GetValue( 0, NPPVpluginDescriptionString, + (void*)&buf ); + if ( nperr==NPERR_NO_ERROR ) + description = TQString::fromLatin1( buf ); + kdDebug() << "description = " << description << endl; + } + else + kdWarning() << "Plugin doesn't implement NP_GetValue" << endl; + + // get mime description function pointer + char* (*func_GetMIMEDescription)() = + (char *(*)())_handle->symbol("NP_GetMIMEDescription"); + if ( !func_GetMIMEDescription ) { + kdDebug(1433) << " - no GetMIMEDescription, skipping" << endl; + KLibLoader::self()->unloadLibrary( TQFile::encodeName(absFile) ); + return 1; + } + + // ask for mime information + TQString mimeInfo = func_GetMIMEDescription(); + if ( mimeInfo.isEmpty() ) { + kdDebug(1433) << " - no mime info returned, skipping" << endl; + KLibLoader::self()->unloadLibrary( TQFile::encodeName(absFile) ); + return 1; + } + + // remove version info, as it is not used at the moment + TQRegExp versionRegExp(";version=[^:]*:"); + mimeInfo.replace( versionRegExp, ":"); + + // unload plugin lib + kdDebug(1433) << " - unloading plugin" << endl; + KLibLoader::self()->unloadLibrary( TQFile::encodeName(absFile) ); + + // create a TQDataStream for our IPC pipe (to send plugin info back to the parent) + FILE *write_pipe = fdopen(write_fd, "w"); + TQFile stream_file; + stream_file.open(IO_WriteOnly, write_pipe); + TQDataStream stream(&stream_file); + + // return the gathered info to the parent + stream << name; + stream << description; + stream << mimeInfo; + + return 0; +} + +void scanDirectory( TQString dir, TQStringList &mimeInfoList, + TQTextStream &cache ) +{ + kdDebug(1433) << "-> scanDirectory dir=" << dir << endl; + + // iterate over all files + TQDir files( dir, TQString::null, TQDir::Name|TQDir::IgnoreCase, TQDir::Files ); + if ( !files.exists( dir ) ) { + kdDebug(1433) << "No files found" << endl; + kdDebug(1433) << "<- scanDirectory dir=" << dir << endl; + return; + } + + for (unsigned int i=0; i<files.count(); i++) { + TQString extension; + int j = files[i].findRev('.'); + if (j > 0) + extension = files[i].mid(j+1); + + // ignore crashing libs + if ( files[i]=="librvplayer.so" || // RealPlayer 5 + files[i]=="libnullplugin.so" || // Netscape Default Plugin + files[i]=="cult3dplugin.so" || // Cult 3d plugin + extension == "jar" || // Java archive + extension == "zip" || // Zip file (for classes) + extension == "class" || // Java class + extension == "png" || // PNG Image + extension == "jpg" || // JPEG image + extension == "gif" || // GIF image + extension == "bak" || // .so.bak-up files + extension == "tmp" || // tmp files + extension == "xpt" || // XPConnect + extension.startsWith("htm") // HTML + ) + continue; + + // get absolute file path + TQString absFile = files.absFilePath( files[i] ); + kdDebug(1433) << "Checking library " << absFile << endl; + + // open the library and ask for the mimetype + kdDebug(1433) << " - opening " << absFile << endl; + + cache.device()->flush(); + // fork, so that a crash in the plugin won't stop the scanning of other plugins + int pipes[2]; + if (pipe(pipes) != 0) continue; + int loader_pid = fork(); + + if (loader_pid == -1) { + // unable to fork + continue; + } else if (loader_pid == 0) { + // inside the child + close(pipes[0]); + TDECrash::setCrashHandler(segv_handler); + _exit(tryCheck(pipes[1], absFile)); + } else { + close(pipes[1]); + + TQBuffer m_buffer; + m_buffer.open(IO_WriteOnly); + + FILE *read_pipe = fdopen(pipes[0], "r"); + TQFile q_read_pipe; + q_read_pipe.open(IO_ReadOnly, read_pipe); + + char *data = (char *)malloc(4096); + if (!data) continue; + + // when the child closes, we'll get an EOF (size == 0) + while (int size = q_read_pipe.readBlock(data, 4096)) { + if (size > 0) + m_buffer.writeBlock(data, size); + } + free(data); + + close(pipes[0]); // we no longer need the pipe's reading end + + // close the buffer and open for reading (from the start) + m_buffer.close(); + m_buffer.open(IO_ReadOnly); + + // create a TQDataStream for our buffer + TQDataStream stream(&m_buffer); + + if (stream.atEnd()) continue; + + TQString name, description, mimeInfo; + stream >> name; + stream >> description; + stream >> mimeInfo; + + bool actuallyUsing = false; + + // get mime types from string + TQStringList types = TQStringList::split( ';', mimeInfo ); + TQStringList::Iterator type; + for ( type=types.begin(); type!=types.end(); ++type ) { + + kdDebug(1433) << " - type=" << *type << endl; + name = name.replace( ':', "%3A" ); + + TQString entry = name + ":" + *type; + if ( !mimeInfoList.contains( entry ) ) { + if (!actuallyUsing) { + // note the plugin name + cache << "[" << absFile << "]" << endl; + actuallyUsing = true; + } + + // write into type cache + TQStringList tokens = TQStringList::split(':', *type, TRUE); + TQStringList::Iterator token; + token = tokens.begin(); + cache << (*token).lower(); + ++token; + for ( ; token!=tokens.end(); ++token ) + cache << ":" << *token; + cache << endl; + + // append type to MIME type list + mimeInfoList.append( entry ); + } + } + + // register plugin for javascript + registerPlugin( name, description, files[i], mimeInfo ); + } + } + + // iterate over all sub directories + // NOTE: Mozilla doesn't iterate over subdirectories of the plugin dir. + // We still do (as Netscape 4 did). + TQDir dirs( dir, TQString::null, TQDir::Name|TQDir::IgnoreCase, TQDir::Dirs ); + if ( !dirs.exists() ) + return; + + static int depth = 0; // avoid recursion because of symlink circles + depth++; + for ( unsigned int i=0; i<dirs.count(); i++ ) { + if ( depth<8 && !dirs[i].contains(".") ) + scanDirectory( dirs.absFilePath(dirs[i]), mimeInfoList, cache ); + } + depth--; + + kdDebug() << "<- scanDirectory dir=" << dir << endl; +} + + +void writeServicesFile( TQStringList mimeTypes ) +{ + TQString fname = TDEGlobal::dirs()->saveLocation("services", "") + + "/nsplugin.desktop"; + kdDebug(1433) << "Creating services file " << fname << endl; + + TQFile f(fname); + if ( f.open(IO_WriteOnly) ) { + + TQTextStream ts(&f); + + ts << "[Desktop Entry]" << endl; + ts << "Name=" << i18n("Netscape plugin viewer") << endl; + ts << "Type=Service" << endl; + ts << "Icon=netscape" << endl; + ts << "Comment=" << i18n("Netscape plugin viewer") << endl; + ts << "X-TDE-Library=libnsplugin" << endl; + ts << "InitialPreference=7" << endl; + ts << "ServiceTypes=KParts/ReadOnlyPart,Browser/View" << endl; + ts << "X-TDE-BrowserView-PluginsInfo=nsplugins/pluginsinfo" << endl; + + if (mimeTypes.count() > 0) + ts << "MimeType=" << mimeTypes.join(";") << endl; + + f.close(); + } else + kdDebug(1433) << "Failed to open file " << fname << endl; +} + + +void removeExistingExtensions( TQString &extension ) +{ + TQStringList filtered; + TQStringList exts = TQStringList::split( ",", extension ); + for ( TQStringList::Iterator it=exts.begin(); it!=exts.end(); ++it ) { + TQString ext = (*it).stripWhiteSpace(); + if ( ext == "*" ) // some plugins have that, but we don't want to associate a mimetype with *.*! + continue; + + KMimeType::Ptr mime = KMimeType::findByURL( KURL("file:///foo."+ext ), + 0, true, true ); + if( mime->name()=="application/octet-stream" || + mime->comment().left(8)=="Netscape" ) { + kdDebug() << "accepted" << endl; + filtered.append( ext ); + } + } + + extension = filtered.join( "," ); +} + +void sigChildHandler(int) +{ + // since waitpid and write change errno, we have to save it and restore it + // (Richard Stevens, Advanced programming in the Unix Environment) + int saved_errno = errno; + + while (waitpid(-1, 0, WNOHANG) == 0) + ; + + errno = saved_errno; +} + +static TDECmdLineOptions options[] = +{ + { "verbose", I18N_NOOP("Show progress output for GUI"), 0 }, + TDECmdLineLastOption +}; + + +int main( int argc, char **argv ) +{ + TDEAboutData aboutData( "nspluginscan", I18N_NOOP("nspluginscan"), + "0.3", "nspluginscan", TDEAboutData::License_GPL, + "(c) 2000,2001 by Stefan Schimanski" ); + + TDELocale::setMainCatalogue("nsplugin"); + TDECmdLineArgs::init( argc, argv, &aboutData ); + TDECmdLineArgs::addCmdLineOptions( options ); + TDECmdLineArgs *args = TDECmdLineArgs::parsedArgs(); + + showProgress = args->isSet("verbose"); + if (showProgress) { + printf("10\n"); fflush(stdout); + } + + TDEApplication app(false, false); + + // Set up SIGCHLD handler + struct sigaction act; + act.sa_handler=sigChildHandler; + sigemptyset(&(act.sa_mask)); + sigaddset(&(act.sa_mask), SIGCHLD); + // Make sure we don't block this signal. gdb tends to do that :-( + sigprocmask(SIG_UNBLOCK, &(act.sa_mask), 0); + + act.sa_flags = SA_NOCLDSTOP; + + // CC: take care of SunOS which automatically restarts interrupted system + // calls (and thus does not have SA_RESTART) + +#ifdef SA_RESTART + act.sa_flags |= SA_RESTART; +#endif + + sigaction( SIGCHLD, &act, 0 ); + + pullInXt(); + + // set up the paths used to look for plugins + TQStringList searchPaths = getSearchPaths(); + TQStringList mimeInfoList; + + infoConfig = new TDEConfig( TDEGlobal::dirs()->saveLocation("data", "nsplugins") + + "/pluginsinfo" ); + infoConfig->writeEntry( "number", 0 ); + + // open the cache file for the mime information + TQString cacheName = TDEGlobal::dirs()->saveLocation("data", "nsplugins")+"/cache"; + kdDebug(1433) << "Creating MIME cache file " << cacheName << endl; + TQFile cachef(cacheName); + if (!cachef.open(IO_WriteOnly)) + return -1; + TQTextStream cache(&cachef); + if (showProgress) { + printf("20\n"); fflush(stdout); + } + + // read in the plugins mime information + kdDebug(1433) << "Scanning directories" << endl; + int count = searchPaths.count(); + int i = 0; + for ( TQStringList::Iterator it = searchPaths.begin(); + it != searchPaths.end(); ++it, ++i) + { + scanDirectory( *it, mimeInfoList, cache ); + if (showProgress) { + printf("%d\n", 25 + (50*i) / count ); fflush(stdout); + } + } + + if (showProgress) { + printf("75\n"); fflush(stdout); + } + // delete old mime types + kdDebug(1433) << "Removing old mimetypes" << endl; + deletePluginMimeTypes(); + if (showProgress) { + printf("80\n"); fflush(stdout); + } + + // write mimetype files + kdDebug(1433) << "Creating MIME type descriptions" << endl; + TQStringList mimeTypes; + for ( TQStringList::Iterator it=mimeInfoList.begin(); + it!=mimeInfoList.end(); ++it) { + + kdDebug(1433) << "Handling MIME type " << *it << endl; + + TQStringList info = TQStringList::split(":", *it, true); + if ( info.count()==4 ) { + TQString pluginName = info[0]; + TQString type = info[1].lower(); + TQString extension = info[2]; + TQString desc = info[3]; + + // append to global mime type list + if ( !mimeTypes.contains(type) ) { + kdDebug(1433) << " - mimeType=" << type << endl; + mimeTypes.append( type ); + + // check mimelnk file + TQString fname = TDEGlobal::dirs()->findResource("mime", type+".desktop"); + if ( fname.isEmpty() || isPluginMimeType(fname) ) { + kdDebug(1433) << " - creating MIME type description" << endl; + removeExistingExtensions( extension ); + generateMimeType( type, extension, pluginName, desc ); + } else { + kdDebug(1433) << " - already existant" << endl; + } + } + } + } + if (showProgress) { + printf("85\n"); fflush(stdout); + } + + // close files + kdDebug(1433) << "Closing cache file" << endl; + cachef.close(); + + infoConfig->sync(); + delete infoConfig; + + // write plugin lib service file + writeServicesFile( mimeTypes ); + if (showProgress) { + printf("90\n"); fflush(stdout); + } + + DCOPClient *dcc = kapp->dcopClient(); + if ( !dcc->isAttached() ) + dcc->attach(); + // Tel kded to update sycoca database. + dcc->send("kded", "tdebuildsycoca", "recreate()", TQByteArray()); +} diff --git a/nsplugins/sdk/jni.h b/nsplugins/sdk/jni.h new file mode 100644 index 000000000..863075afa --- /dev/null +++ b/nsplugins/sdk/jni.h @@ -0,0 +1,1810 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * 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 the Java Runtime Interface. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation and Sun Microsystems, Inc. + * Portions created by the Initial Developer are Copyright (C) 1993-1996 + * 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 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 ***** */ + +#ifndef JNI_H +#define JNI_H + +#include <stdio.h> +#include <stdarg.h> + +/* jni_md.h contains the machine-dependent typedefs for jbyte, jint + and jlong */ + +#include "jni_md.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * JNI Types + */ + +typedef unsigned char jboolean; +typedef unsigned short jchar; +typedef short jshort; +typedef float jfloat; +typedef double jdouble; + +typedef jint jsize; + +#ifdef __cplusplus + +class _jobject {}; +class _jclass : public _jobject {}; +class _jthrowable : public _jobject {}; +class _jstring : public _jobject {}; +class _jarray : public _jobject {}; +class _jbooleanArray : public _jarray {}; +class _jbyteArray : public _jarray {}; +class _jcharArray : public _jarray {}; +class _jshortArray : public _jarray {}; +class _jintArray : public _jarray {}; +class _jlongArray : public _jarray {}; +class _jfloatArray : public _jarray {}; +class _jdoubleArray : public _jarray {}; +class _jobjectArray : public _jarray {}; + +typedef _jobject *jobject; +typedef _jclass *jclass; +typedef _jthrowable *jthrowable; +typedef _jstring *jstring; +typedef _jarray *jarray; +typedef _jbooleanArray *jbooleanArray; +typedef _jbyteArray *jbyteArray; +typedef _jcharArray *jcharArray; +typedef _jshortArray *jshortArray; +typedef _jintArray *jintArray; +typedef _jlongArray *jlongArray; +typedef _jfloatArray *jfloatArray; +typedef _jdoubleArray *jdoubleArray; +typedef _jobjectArray *jobjectArray; + +#else + +struct _jobject; + +typedef struct _jobject *jobject; +typedef jobject jclass; +typedef jobject jthrowable; +typedef jobject jstring; +typedef jobject jarray; +typedef jarray jbooleanArray; +typedef jarray jbyteArray; +typedef jarray jcharArray; +typedef jarray jshortArray; +typedef jarray jintArray; +typedef jarray jlongArray; +typedef jarray jfloatArray; +typedef jarray jdoubleArray; +typedef jarray jobjectArray; + +#endif + +#if 0 /* moved to jri_md.h */ +typedef jobject jref; /* For transition---not meant to be part of public + API anymore.*/ +#endif + +typedef union jvalue { + jboolean z; + jbyte b; + jchar c; + jshort s; + jint i; + jlong j; + jfloat f; + jdouble d; + jobject l; +} jvalue; + +struct _jfieldID; +typedef struct _jfieldID *jfieldID; + +struct _jmethodID; +typedef struct _jmethodID *jmethodID; + +/* + * jboolean constants + */ + +#define JNI_FALSE 0 +#define JNI_TRUE 1 + +/* + * possible return values for JNI functions. + */ + +#define JNI_OK 0 +#define JNI_ERR (-1) + +/* + * used in ReleaseScalarArrayElements + */ + +#define JNI_COMMIT 1 +#define JNI_ABORT 2 + +/* + * used in RegisterNatives to describe native method name, signature, + * and function pointer. + */ + +typedef struct { + char *name; + char *signature; + void *fnPtr; +} JNINativeMethod; + +/* + * JNI Native Method Interface. + */ + +struct JNINativeInterface_; + +struct JNIEnv_; + +#ifdef __cplusplus +typedef JNIEnv_ JNIEnv; +#else +typedef const struct JNINativeInterface_ *JNIEnv; +#endif + +/* + * JNI Invocation Interface. + */ + +struct JNIInvokeInterface_; + +struct JavaVM_; + +#ifdef __cplusplus +typedef JavaVM_ JavaVM; +#else +typedef const struct JNIInvokeInterface_ *JavaVM; +#endif + +struct JNINativeInterface_ { + void *reserved0; + void *reserved1; + void *reserved2; + + void *reserved3; + jint (JNICALL *GetVersion)(JNIEnv *env); + + jclass (JNICALL *DefineClass) + (JNIEnv *env, const char *name, jobject loader, const jbyte *buf, + jsize len); + jclass (JNICALL *FindClass) + (JNIEnv *env, const char *name); + + void *reserved4; + void *reserved5; + void *reserved6; + + jclass (JNICALL *GetSuperclass) + (JNIEnv *env, jclass sub); + jboolean (JNICALL *IsAssignableFrom) + (JNIEnv *env, jclass sub, jclass sup); + void *reserved7; + + + jint (JNICALL *Throw) + (JNIEnv *env, jthrowable obj); + jint (JNICALL *ThrowNew) + (JNIEnv *env, jclass clazz, const char *msg); + jthrowable (JNICALL *ExceptionOccurred) + (JNIEnv *env); + void (JNICALL *ExceptionDescribe) + (JNIEnv *env); + void (JNICALL *ExceptionClear) + (JNIEnv *env); + void (JNICALL *FatalError) + (JNIEnv *env, const char *msg); + void *reserved8; + void *reserved9; + + jobject (JNICALL *NewGlobalRef) + (JNIEnv *env, jobject lobj); + void (JNICALL *DeleteGlobalRef) + (JNIEnv *env, jobject gref); + void (JNICALL *DeleteLocalRef) + (JNIEnv *env, jobject obj); + jboolean (JNICALL *IsSameObject) + (JNIEnv *env, jobject obj1, jobject obj2); + void *reserved10; + void *reserved11; + + jobject (JNICALL *AllocObject) + (JNIEnv *env, jclass clazz); + jobject (JNICALL *NewObject) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jobject (JNICALL *NewObjectV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jobject (JNICALL *NewObjectA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jclass (JNICALL *GetObjectClass) + (JNIEnv *env, jobject obj); + jboolean (JNICALL *IsInstanceOf) + (JNIEnv *env, jobject obj, jclass clazz); + + jmethodID (JNICALL *GetMethodID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + + jobject (JNICALL *CallObjectMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jobject (JNICALL *CallObjectMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jobject (JNICALL *CallObjectMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args); + + jboolean (JNICALL *CallBooleanMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jboolean (JNICALL *CallBooleanMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jboolean (JNICALL *CallBooleanMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args); + + jbyte (JNICALL *CallByteMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jbyte (JNICALL *CallByteMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jbyte (JNICALL *CallByteMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args); + + jchar (JNICALL *CallCharMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jchar (JNICALL *CallCharMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jchar (JNICALL *CallCharMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args); + + jshort (JNICALL *CallShortMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jshort (JNICALL *CallShortMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jshort (JNICALL *CallShortMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args); + + jint (JNICALL *CallIntMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jint (JNICALL *CallIntMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jint (JNICALL *CallIntMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args); + + jlong (JNICALL *CallLongMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jlong (JNICALL *CallLongMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jlong (JNICALL *CallLongMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args); + + jfloat (JNICALL *CallFloatMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jfloat (JNICALL *CallFloatMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jfloat (JNICALL *CallFloatMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args); + + jdouble (JNICALL *CallDoubleMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jdouble (JNICALL *CallDoubleMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jdouble (JNICALL *CallDoubleMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args); + + void (JNICALL *CallVoidMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + void (JNICALL *CallVoidMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + void (JNICALL *CallVoidMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args); + + jobject (JNICALL *CallNonvirtualObjectMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jobject (JNICALL *CallNonvirtualObjectMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jobject (JNICALL *CallNonvirtualObjectMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue * args); + + jboolean (JNICALL *CallNonvirtualBooleanMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jboolean (JNICALL *CallNonvirtualBooleanMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jboolean (JNICALL *CallNonvirtualBooleanMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue * args); + + jbyte (JNICALL *CallNonvirtualByteMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jbyte (JNICALL *CallNonvirtualByteMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jbyte (JNICALL *CallNonvirtualByteMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue *args); + + jchar (JNICALL *CallNonvirtualCharMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jchar (JNICALL *CallNonvirtualCharMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jchar (JNICALL *CallNonvirtualCharMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue *args); + + jshort (JNICALL *CallNonvirtualShortMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jshort (JNICALL *CallNonvirtualShortMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jshort (JNICALL *CallNonvirtualShortMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue *args); + + jint (JNICALL *CallNonvirtualIntMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jint (JNICALL *CallNonvirtualIntMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jint (JNICALL *CallNonvirtualIntMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue *args); + + jlong (JNICALL *CallNonvirtualLongMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jlong (JNICALL *CallNonvirtualLongMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jlong (JNICALL *CallNonvirtualLongMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue *args); + + jfloat (JNICALL *CallNonvirtualFloatMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jfloat (JNICALL *CallNonvirtualFloatMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jfloat (JNICALL *CallNonvirtualFloatMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue *args); + + jdouble (JNICALL *CallNonvirtualDoubleMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jdouble (JNICALL *CallNonvirtualDoubleMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jdouble (JNICALL *CallNonvirtualDoubleMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue *args); + + void (JNICALL *CallNonvirtualVoidMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + void (JNICALL *CallNonvirtualVoidMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + void (JNICALL *CallNonvirtualVoidMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue * args); + + jfieldID (JNICALL *GetFieldID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + + jobject (JNICALL *GetObjectField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jboolean (JNICALL *GetBooleanField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jbyte (JNICALL *GetByteField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jchar (JNICALL *GetCharField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jshort (JNICALL *GetShortField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jint (JNICALL *GetIntField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jlong (JNICALL *GetLongField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jfloat (JNICALL *GetFloatField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jdouble (JNICALL *GetDoubleField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + + void (JNICALL *SetObjectField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val); + void (JNICALL *SetBooleanField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val); + void (JNICALL *SetByteField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val); + void (JNICALL *SetCharField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val); + void (JNICALL *SetShortField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val); + void (JNICALL *SetIntField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jint val); + void (JNICALL *SetLongField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val); + void (JNICALL *SetFloatField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val); + void (JNICALL *SetDoubleField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val); + + jmethodID (JNICALL *GetStaticMethodID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + + jobject (JNICALL *CallStaticObjectMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jobject (JNICALL *CallStaticObjectMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jobject (JNICALL *CallStaticObjectMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jboolean (JNICALL *CallStaticBooleanMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jboolean (JNICALL *CallStaticBooleanMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jboolean (JNICALL *CallStaticBooleanMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jbyte (JNICALL *CallStaticByteMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jbyte (JNICALL *CallStaticByteMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jbyte (JNICALL *CallStaticByteMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jchar (JNICALL *CallStaticCharMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jchar (JNICALL *CallStaticCharMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jchar (JNICALL *CallStaticCharMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jshort (JNICALL *CallStaticShortMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jshort (JNICALL *CallStaticShortMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jshort (JNICALL *CallStaticShortMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jint (JNICALL *CallStaticIntMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jint (JNICALL *CallStaticIntMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jint (JNICALL *CallStaticIntMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jlong (JNICALL *CallStaticLongMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jlong (JNICALL *CallStaticLongMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jlong (JNICALL *CallStaticLongMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jfloat (JNICALL *CallStaticFloatMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jfloat (JNICALL *CallStaticFloatMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jfloat (JNICALL *CallStaticFloatMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jdouble (JNICALL *CallStaticDoubleMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jdouble (JNICALL *CallStaticDoubleMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jdouble (JNICALL *CallStaticDoubleMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + void (JNICALL *CallStaticVoidMethod) + (JNIEnv *env, jclass cls, jmethodID methodID, ...); + void (JNICALL *CallStaticVoidMethodV) + (JNIEnv *env, jclass cls, jmethodID methodID, va_list args); + void (JNICALL *CallStaticVoidMethodA) + (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args); + + jfieldID (JNICALL *GetStaticFieldID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + jobject (JNICALL *GetStaticObjectField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jboolean (JNICALL *GetStaticBooleanField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jbyte (JNICALL *GetStaticByteField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jchar (JNICALL *GetStaticCharField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jshort (JNICALL *GetStaticShortField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jint (JNICALL *GetStaticIntField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jlong (JNICALL *GetStaticLongField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jfloat (JNICALL *GetStaticFloatField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jdouble (JNICALL *GetStaticDoubleField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + + void (JNICALL *SetStaticObjectField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value); + void (JNICALL *SetStaticBooleanField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value); + void (JNICALL *SetStaticByteField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value); + void (JNICALL *SetStaticCharField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value); + void (JNICALL *SetStaticShortField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value); + void (JNICALL *SetStaticIntField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value); + void (JNICALL *SetStaticLongField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value); + void (JNICALL *SetStaticFloatField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value); + void (JNICALL *SetStaticDoubleField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value); + + jstring (JNICALL *NewString) + (JNIEnv *env, const jchar *unicode, jsize len); + jsize (JNICALL *GetStringLength) + (JNIEnv *env, jstring str); + const jchar *(JNICALL *GetStringChars) + (JNIEnv *env, jstring str, jboolean *isCopy); + void (JNICALL *ReleaseStringChars) + (JNIEnv *env, jstring str, const jchar *chars); + + jstring (JNICALL *NewStringUTF) + (JNIEnv *env, const char *utf); + jsize (JNICALL *GetStringUTFLength) + (JNIEnv *env, jstring str); + const char* (JNICALL *GetStringUTFChars) + (JNIEnv *env, jstring str, jboolean *isCopy); + void (JNICALL *ReleaseStringUTFChars) + (JNIEnv *env, jstring str, const char* chars); + + + jsize (JNICALL *GetArrayLength) + (JNIEnv *env, jarray array); + + jobjectArray (JNICALL *NewObjectArray) + (JNIEnv *env, jsize len, jclass clazz, jobject init); + jobject (JNICALL *GetObjectArrayElement) + (JNIEnv *env, jobjectArray array, jsize index); + void (JNICALL *SetObjectArrayElement) + (JNIEnv *env, jobjectArray array, jsize index, jobject val); + + jbooleanArray (JNICALL *NewBooleanArray) + (JNIEnv *env, jsize len); + jbyteArray (JNICALL *NewByteArray) + (JNIEnv *env, jsize len); + jcharArray (JNICALL *NewCharArray) + (JNIEnv *env, jsize len); + jshortArray (JNICALL *NewShortArray) + (JNIEnv *env, jsize len); + jintArray (JNICALL *NewIntArray) + (JNIEnv *env, jsize len); + jlongArray (JNICALL *NewLongArray) + (JNIEnv *env, jsize len); + jfloatArray (JNICALL *NewFloatArray) + (JNIEnv *env, jsize len); + jdoubleArray (JNICALL *NewDoubleArray) + (JNIEnv *env, jsize len); + + jboolean * (JNICALL *GetBooleanArrayElements) + (JNIEnv *env, jbooleanArray array, jboolean *isCopy); + jbyte * (JNICALL *GetByteArrayElements) + (JNIEnv *env, jbyteArray array, jboolean *isCopy); + jchar * (JNICALL *GetCharArrayElements) + (JNIEnv *env, jcharArray array, jboolean *isCopy); + jshort * (JNICALL *GetShortArrayElements) + (JNIEnv *env, jshortArray array, jboolean *isCopy); + jint * (JNICALL *GetIntArrayElements) + (JNIEnv *env, jintArray array, jboolean *isCopy); + jlong * (JNICALL *GetLongArrayElements) + (JNIEnv *env, jlongArray array, jboolean *isCopy); + jfloat * (JNICALL *GetFloatArrayElements) + (JNIEnv *env, jfloatArray array, jboolean *isCopy); + jdouble * (JNICALL *GetDoubleArrayElements) + (JNIEnv *env, jdoubleArray array, jboolean *isCopy); + + void (JNICALL *ReleaseBooleanArrayElements) + (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode); + void (JNICALL *ReleaseByteArrayElements) + (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode); + void (JNICALL *ReleaseCharArrayElements) + (JNIEnv *env, jcharArray array, jchar *elems, jint mode); + void (JNICALL *ReleaseShortArrayElements) + (JNIEnv *env, jshortArray array, jshort *elems, jint mode); + void (JNICALL *ReleaseIntArrayElements) + (JNIEnv *env, jintArray array, jint *elems, jint mode); + void (JNICALL *ReleaseLongArrayElements) + (JNIEnv *env, jlongArray array, jlong *elems, jint mode); + void (JNICALL *ReleaseFloatArrayElements) + (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode); + void (JNICALL *ReleaseDoubleArrayElements) + (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode); + + void (JNICALL *GetBooleanArrayRegion) + (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf); + void (JNICALL *GetByteArrayRegion) + (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf); + void (JNICALL *GetCharArrayRegion) + (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf); + void (JNICALL *GetShortArrayRegion) + (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf); + void (JNICALL *GetIntArrayRegion) + (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf); + void (JNICALL *GetLongArrayRegion) + (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf); + void (JNICALL *GetFloatArrayRegion) + (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf); + void (JNICALL *GetDoubleArrayRegion) + (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf); + + void (JNICALL *SetBooleanArrayRegion) + (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf); + void (JNICALL *SetByteArrayRegion) + (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf); + void (JNICALL *SetCharArrayRegion) + (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf); + void (JNICALL *SetShortArrayRegion) + (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf); + void (JNICALL *SetIntArrayRegion) + (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf); + void (JNICALL *SetLongArrayRegion) + (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf); + void (JNICALL *SetFloatArrayRegion) + (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf); + void (JNICALL *SetDoubleArrayRegion) + (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf); + + jint (JNICALL *RegisterNatives) + (JNIEnv *env, jclass clazz, const JNINativeMethod *methods, + jint nMethods); + jint (JNICALL *UnregisterNatives) + (JNIEnv *env, jclass clazz); + + jint (JNICALL *MonitorEnter) + (JNIEnv *env, jobject obj); + jint (JNICALL *MonitorExit) + (JNIEnv *env, jobject obj); + + jint (JNICALL *GetJavaVM) + (JNIEnv *env, JavaVM **vm); +}; + +/* + * We use inlined functions for C++ so that programmers can write: + * + * env->FindClass("java/lang/String") + * + * in C++ rather than: + * + * (*env)->FindClass(env, "java/lang/String") + * + * in C. + */ + +struct JNIEnv_ { + const struct JNINativeInterface_ *functions; + void *reserved0; + void *reserved1[6]; +#ifdef __cplusplus + + jint GetVersion() { + return functions->GetVersion(this); + } + jclass DefineClass(const char *name, jobject loader, const jbyte *buf, + jsize len) { + return functions->DefineClass(this, name, loader, buf, len); + } + jclass FindClass(const char *name) { + return functions->FindClass(this, name); + } + jclass GetSuperclass(jclass sub) { + return functions->GetSuperclass(this, sub); + } + jboolean IsAssignableFrom(jclass sub, jclass sup) { + return functions->IsAssignableFrom(this, sub, sup); + } + + jint Throw(jthrowable obj) { + return functions->Throw(this, obj); + } + jint ThrowNew(jclass clazz, const char *msg) { + return functions->ThrowNew(this, clazz, msg); + } + jthrowable ExceptionOccurred() { + return functions->ExceptionOccurred(this); + } + void ExceptionDescribe() { + functions->ExceptionDescribe(this); + } + void ExceptionClear() { + functions->ExceptionClear(this); + } + void FatalError(const char *msg) { + functions->FatalError(this, msg); + } + + jobject NewGlobalRef(jobject lobj) { + return functions->NewGlobalRef(this,lobj); + } + void DeleteGlobalRef(jobject gref) { + functions->DeleteGlobalRef(this,gref); + } + void DeleteLocalRef(jobject obj) { + functions->DeleteLocalRef(this, obj); + } + + jboolean IsSameObject(jobject obj1, jobject obj2) { + return functions->IsSameObject(this,obj1,obj2); + } + + jobject AllocObject(jclass clazz) { + return functions->AllocObject(this,clazz); + } + jobject NewObject(jclass clazz, jmethodID methodID, ...) { + va_list args; + jobject result; + va_start(args, methodID); + result = functions->NewObjectV(this,clazz,methodID,args); + va_end(args); + return result; + } + jobject NewObjectV(jclass clazz, jmethodID methodID, + va_list args) { + return functions->NewObjectV(this,clazz,methodID,args); + } + jobject NewObjectA(jclass clazz, jmethodID methodID, + jvalue *args) { + return functions->NewObjectA(this,clazz,methodID,args); + } + + jclass GetObjectClass(jobject obj) { + return functions->GetObjectClass(this,obj); + } + jboolean IsInstanceOf(jobject obj, jclass clazz) { + return functions->IsInstanceOf(this,obj,clazz); + } + + jmethodID GetMethodID(jclass clazz, const char *name, + const char *sig) { + return functions->GetMethodID(this,clazz,name,sig); + } + + jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jobject result; + va_start(args,methodID); + result = functions->CallObjectMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jobject CallObjectMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallObjectMethodV(this,obj,methodID,args); + } + jobject CallObjectMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallObjectMethodA(this,obj,methodID,args); + } + + jboolean CallBooleanMethod(jobject obj, + jmethodID methodID, ...) { + va_list args; + jboolean result; + va_start(args,methodID); + result = functions->CallBooleanMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jboolean CallBooleanMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallBooleanMethodV(this,obj,methodID,args); + } + jboolean CallBooleanMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallBooleanMethodA(this,obj,methodID, args); + } + + jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jbyte result; + va_start(args,methodID); + result = functions->CallByteMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jbyte CallByteMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallByteMethodV(this,obj,methodID,args); + } + jbyte CallByteMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallByteMethodA(this,obj,methodID,args); + } + + jchar CallCharMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jchar result; + va_start(args,methodID); + result = functions->CallCharMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jchar CallCharMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallCharMethodV(this,obj,methodID,args); + } + jchar CallCharMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallCharMethodA(this,obj,methodID,args); + } + + jshort CallShortMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jshort result; + va_start(args,methodID); + result = functions->CallShortMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jshort CallShortMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallShortMethodV(this,obj,methodID,args); + } + jshort CallShortMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallShortMethodA(this,obj,methodID,args); + } + + jint CallIntMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jint result; + va_start(args,methodID); + result = functions->CallIntMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jint CallIntMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallIntMethodV(this,obj,methodID,args); + } + jint CallIntMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallIntMethodA(this,obj,methodID,args); + } + + jlong CallLongMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jlong result; + va_start(args,methodID); + result = functions->CallLongMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jlong CallLongMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallLongMethodV(this,obj,methodID,args); + } + jlong CallLongMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallLongMethodA(this,obj,methodID,args); + } + + jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jfloat result; + va_start(args,methodID); + result = functions->CallFloatMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jfloat CallFloatMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallFloatMethodV(this,obj,methodID,args); + } + jfloat CallFloatMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallFloatMethodA(this,obj,methodID,args); + } + + jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jdouble result; + va_start(args,methodID); + result = functions->CallDoubleMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jdouble CallDoubleMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallDoubleMethodV(this,obj,methodID,args); + } + jdouble CallDoubleMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallDoubleMethodA(this,obj,methodID,args); + } + + void CallVoidMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + va_start(args,methodID); + functions->CallVoidMethodV(this,obj,methodID,args); + va_end(args); + } + void CallVoidMethodV(jobject obj, jmethodID methodID, + va_list args) { + functions->CallVoidMethodV(this,obj,methodID,args); + } + void CallVoidMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + functions->CallVoidMethodA(this,obj,methodID,args); + } + + jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jobject result; + va_start(args,methodID); + result = functions->CallNonvirtualObjectMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualObjectMethodV(this,obj,clazz, + methodID,args); + } + jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) { + return functions->CallNonvirtualObjectMethodA(this,obj,clazz, + methodID,args); + } + + jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jboolean result; + va_start(args,methodID); + result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualBooleanMethodV(this,obj,clazz, + methodID,args); + } + jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) { + return functions->CallNonvirtualBooleanMethodA(this,obj,clazz, + methodID, args); + } + + jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jbyte result; + va_start(args,methodID); + result = functions->CallNonvirtualByteMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualByteMethodV(this,obj,clazz, + methodID,args); + } + jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) { + return functions->CallNonvirtualByteMethodA(this,obj,clazz, + methodID,args); + } + + jchar CallNonvirtualCharMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jchar result; + va_start(args,methodID); + result = functions->CallNonvirtualCharMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualCharMethodV(this,obj,clazz, + methodID,args); + } + jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) { + return functions->CallNonvirtualCharMethodA(this,obj,clazz, + methodID,args); + } + + jshort CallNonvirtualShortMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jshort result; + va_start(args,methodID); + result = functions->CallNonvirtualShortMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualShortMethodV(this,obj,clazz, + methodID,args); + } + jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) { + return functions->CallNonvirtualShortMethodA(this,obj,clazz, + methodID,args); + } + + jint CallNonvirtualIntMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jint result; + va_start(args,methodID); + result = functions->CallNonvirtualIntMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jint CallNonvirtualIntMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualIntMethodV(this,obj,clazz, + methodID,args); + } + jint CallNonvirtualIntMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) { + return functions->CallNonvirtualIntMethodA(this,obj,clazz, + methodID,args); + } + + jlong CallNonvirtualLongMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jlong result; + va_start(args,methodID); + result = functions->CallNonvirtualLongMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualLongMethodV(this,obj,clazz, + methodID,args); + } + jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) { + return functions->CallNonvirtualLongMethodA(this,obj,clazz, + methodID,args); + } + + jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jfloat result; + va_start(args,methodID); + result = functions->CallNonvirtualFloatMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz, + jmethodID methodID, + va_list args) { + return functions->CallNonvirtualFloatMethodV(this,obj,clazz, + methodID,args); + } + jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz, + jmethodID methodID, + jvalue * args) { + return functions->CallNonvirtualFloatMethodA(this,obj,clazz, + methodID,args); + } + + jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jdouble result; + va_start(args,methodID); + result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz, + jmethodID methodID, + va_list args) { + return functions->CallNonvirtualDoubleMethodV(this,obj,clazz, + methodID,args); + } + jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz, + jmethodID methodID, + jvalue * args) { + return functions->CallNonvirtualDoubleMethodA(this,obj,clazz, + methodID,args); + } + + void CallNonvirtualVoidMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + va_start(args,methodID); + functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); + va_end(args); + } + void CallNonvirtualVoidMethodV(jobject obj, jclass clazz, + jmethodID methodID, + va_list args) { + functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); + } + void CallNonvirtualVoidMethodA(jobject obj, jclass clazz, + jmethodID methodID, + jvalue * args) { + functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args); + } + + jfieldID GetFieldID(jclass clazz, const char *name, + const char *sig) { + return functions->GetFieldID(this,clazz,name,sig); + } + + jobject GetObjectField(jobject obj, jfieldID fieldID) { + return functions->GetObjectField(this,obj,fieldID); + } + jboolean GetBooleanField(jobject obj, jfieldID fieldID) { + return functions->GetBooleanField(this,obj,fieldID); + } + jbyte GetByteField(jobject obj, jfieldID fieldID) { + return functions->GetByteField(this,obj,fieldID); + } + jchar GetCharField(jobject obj, jfieldID fieldID) { + return functions->GetCharField(this,obj,fieldID); + } + jshort GetShortField(jobject obj, jfieldID fieldID) { + return functions->GetShortField(this,obj,fieldID); + } + jint GetIntField(jobject obj, jfieldID fieldID) { + return functions->GetIntField(this,obj,fieldID); + } + jlong GetLongField(jobject obj, jfieldID fieldID) { + return functions->GetLongField(this,obj,fieldID); + } + jfloat GetFloatField(jobject obj, jfieldID fieldID) { + return functions->GetFloatField(this,obj,fieldID); + } + jdouble GetDoubleField(jobject obj, jfieldID fieldID) { + return functions->GetDoubleField(this,obj,fieldID); + } + + void SetObjectField(jobject obj, jfieldID fieldID, jobject val) { + functions->SetObjectField(this,obj,fieldID,val); + } + void SetBooleanField(jobject obj, jfieldID fieldID, + jboolean val) { + functions->SetBooleanField(this,obj,fieldID,val); + } + void SetByteField(jobject obj, jfieldID fieldID, + jbyte val) { + functions->SetByteField(this,obj,fieldID,val); + } + void SetCharField(jobject obj, jfieldID fieldID, + jchar val) { + functions->SetCharField(this,obj,fieldID,val); + } + void SetShortField(jobject obj, jfieldID fieldID, + jshort val) { + functions->SetShortField(this,obj,fieldID,val); + } + void SetIntField(jobject obj, jfieldID fieldID, + jint val) { + functions->SetIntField(this,obj,fieldID,val); + } + void SetLongField(jobject obj, jfieldID fieldID, + jlong val) { + functions->SetLongField(this,obj,fieldID,val); + } + void SetFloatField(jobject obj, jfieldID fieldID, + jfloat val) { + functions->SetFloatField(this,obj,fieldID,val); + } + void SetDoubleField(jobject obj, jfieldID fieldID, + jdouble val) { + functions->SetDoubleField(this,obj,fieldID,val); + } + + jmethodID GetStaticMethodID(jclass clazz, const char *name, + const char *sig) { + return functions->GetStaticMethodID(this,clazz,name,sig); + } + + jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID, + ...) { + va_list args; + jobject result; + va_start(args,methodID); + result = functions->CallStaticObjectMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID, + va_list args) { + return functions->CallStaticObjectMethodV(this,clazz,methodID,args); + } + jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID, + jvalue *args) { + return functions->CallStaticObjectMethodA(this,clazz,methodID,args); + } + + jboolean CallStaticBooleanMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jboolean result; + va_start(args,methodID); + result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jboolean CallStaticBooleanMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticBooleanMethodV(this,clazz,methodID,args); + } + jboolean CallStaticBooleanMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticBooleanMethodA(this,clazz,methodID,args); + } + + jbyte CallStaticByteMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jbyte result; + va_start(args,methodID); + result = functions->CallStaticByteMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jbyte CallStaticByteMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticByteMethodV(this,clazz,methodID,args); + } + jbyte CallStaticByteMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticByteMethodA(this,clazz,methodID,args); + } + + jchar CallStaticCharMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jchar result; + va_start(args,methodID); + result = functions->CallStaticCharMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jchar CallStaticCharMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticCharMethodV(this,clazz,methodID,args); + } + jchar CallStaticCharMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticCharMethodA(this,clazz,methodID,args); + } + + jshort CallStaticShortMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jshort result; + va_start(args,methodID); + result = functions->CallStaticShortMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jshort CallStaticShortMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticShortMethodV(this,clazz,methodID,args); + } + jshort CallStaticShortMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticShortMethodA(this,clazz,methodID,args); + } + + jint CallStaticIntMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jint result; + va_start(args,methodID); + result = functions->CallStaticIntMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jint CallStaticIntMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticIntMethodV(this,clazz,methodID,args); + } + jint CallStaticIntMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticIntMethodA(this,clazz,methodID,args); + } + + jlong CallStaticLongMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jlong result; + va_start(args,methodID); + result = functions->CallStaticLongMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jlong CallStaticLongMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticLongMethodV(this,clazz,methodID,args); + } + jlong CallStaticLongMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticLongMethodA(this,clazz,methodID,args); + } + + jfloat CallStaticFloatMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jfloat result; + va_start(args,methodID); + result = functions->CallStaticFloatMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jfloat CallStaticFloatMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticFloatMethodV(this,clazz,methodID,args); + } + jfloat CallStaticFloatMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticFloatMethodA(this,clazz,methodID,args); + } + + jdouble CallStaticDoubleMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jdouble result; + va_start(args,methodID); + result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jdouble CallStaticDoubleMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticDoubleMethodV(this,clazz,methodID,args); + } + jdouble CallStaticDoubleMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticDoubleMethodA(this,clazz,methodID,args); + } + + void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) { + va_list args; + va_start(args,methodID); + functions->CallStaticVoidMethodV(this,cls,methodID,args); + va_end(args); + } + void CallStaticVoidMethodV(jclass cls, jmethodID methodID, + va_list args) { + functions->CallStaticVoidMethodV(this,cls,methodID,args); + } + void CallStaticVoidMethodA(jclass cls, jmethodID methodID, + jvalue * args) { + functions->CallStaticVoidMethodA(this,cls,methodID,args); + } + + jfieldID GetStaticFieldID(jclass clazz, const char *name, + const char *sig) { + return functions->GetStaticFieldID(this,clazz,name,sig); + } + jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticObjectField(this,clazz,fieldID); + } + jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticBooleanField(this,clazz,fieldID); + } + jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticByteField(this,clazz,fieldID); + } + jchar GetStaticCharField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticCharField(this,clazz,fieldID); + } + jshort GetStaticShortField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticShortField(this,clazz,fieldID); + } + jint GetStaticIntField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticIntField(this,clazz,fieldID); + } + jlong GetStaticLongField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticLongField(this,clazz,fieldID); + } + jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticFloatField(this,clazz,fieldID); + } + jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticDoubleField(this,clazz,fieldID); + } + + void SetStaticObjectField(jclass clazz, jfieldID fieldID, + jobject value) { + functions->SetStaticObjectField(this,clazz,fieldID,value); + } + void SetStaticBooleanField(jclass clazz, jfieldID fieldID, + jboolean value) { + functions->SetStaticBooleanField(this,clazz,fieldID,value); + } + void SetStaticByteField(jclass clazz, jfieldID fieldID, + jbyte value) { + functions->SetStaticByteField(this,clazz,fieldID,value); + } + void SetStaticCharField(jclass clazz, jfieldID fieldID, + jchar value) { + functions->SetStaticCharField(this,clazz,fieldID,value); + } + void SetStaticShortField(jclass clazz, jfieldID fieldID, + jshort value) { + functions->SetStaticShortField(this,clazz,fieldID,value); + } + void SetStaticIntField(jclass clazz, jfieldID fieldID, + jint value) { + functions->SetStaticIntField(this,clazz,fieldID,value); + } + void SetStaticLongField(jclass clazz, jfieldID fieldID, + jlong value) { + functions->SetStaticLongField(this,clazz,fieldID,value); + } + void SetStaticFloatField(jclass clazz, jfieldID fieldID, + jfloat value) { + functions->SetStaticFloatField(this,clazz,fieldID,value); + } + void SetStaticDoubleField(jclass clazz, jfieldID fieldID, + jdouble value) { + functions->SetStaticDoubleField(this,clazz,fieldID,value); + } + + jstring NewString(const jchar *unicode, jsize len) { + return functions->NewString(this,unicode,len); + } + jsize GetStringLength(jstring str) { + return functions->GetStringLength(this,str); + } + const jchar *GetStringChars(jstring str, jboolean *isCopy) { + return functions->GetStringChars(this,str,isCopy); + } + void ReleaseStringChars(jstring str, const jchar *chars) { + functions->ReleaseStringChars(this,str,chars); + } + + jstring NewStringUTF(const char *utf) { + return functions->NewStringUTF(this,utf); + } + jsize GetStringUTFLength(jstring str) { + return functions->GetStringUTFLength(this,str); + } + const char* GetStringUTFChars(jstring str, jboolean *isCopy) { + return functions->GetStringUTFChars(this,str,isCopy); + } + void ReleaseStringUTFChars(jstring str, const char* chars) { + functions->ReleaseStringUTFChars(this,str,chars); + } + + jsize GetArrayLength(jarray array) { + return functions->GetArrayLength(this,array); + } + + jobjectArray NewObjectArray(jsize len, jclass clazz, + jobject init) { + return functions->NewObjectArray(this,len,clazz,init); + } + jobject GetObjectArrayElement(jobjectArray array, jsize index) { + return functions->GetObjectArrayElement(this,array,index); + } + void SetObjectArrayElement(jobjectArray array, jsize index, + jobject val) { + functions->SetObjectArrayElement(this,array,index,val); + } + + jbooleanArray NewBooleanArray(jsize len) { + return functions->NewBooleanArray(this,len); + } + jbyteArray NewByteArray(jsize len) { + return functions->NewByteArray(this,len); + } + jcharArray NewCharArray(jsize len) { + return functions->NewCharArray(this,len); + } + jshortArray NewShortArray(jsize len) { + return functions->NewShortArray(this,len); + } + jintArray NewIntArray(jsize len) { + return functions->NewIntArray(this,len); + } + jlongArray NewLongArray(jsize len) { + return functions->NewLongArray(this,len); + } + jfloatArray NewFloatArray(jsize len) { + return functions->NewFloatArray(this,len); + } + jdoubleArray NewDoubleArray(jsize len) { + return functions->NewDoubleArray(this,len); + } + + jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) { + return functions->GetBooleanArrayElements(this,array,isCopy); + } + jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) { + return functions->GetByteArrayElements(this,array,isCopy); + } + jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) { + return functions->GetCharArrayElements(this,array,isCopy); + } + jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) { + return functions->GetShortArrayElements(this,array,isCopy); + } + jint * GetIntArrayElements(jintArray array, jboolean *isCopy) { + return functions->GetIntArrayElements(this,array,isCopy); + } + jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) { + return functions->GetLongArrayElements(this,array,isCopy); + } + jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) { + return functions->GetFloatArrayElements(this,array,isCopy); + } + jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) { + return functions->GetDoubleArrayElements(this,array,isCopy); + } + + void ReleaseBooleanArrayElements(jbooleanArray array, + jboolean *elems, + jint mode) { + functions->ReleaseBooleanArrayElements(this,array,elems,mode); + } + void ReleaseByteArrayElements(jbyteArray array, + jbyte *elems, + jint mode) { + functions->ReleaseByteArrayElements(this,array,elems,mode); + } + void ReleaseCharArrayElements(jcharArray array, + jchar *elems, + jint mode) { + functions->ReleaseCharArrayElements(this,array,elems,mode); + } + void ReleaseShortArrayElements(jshortArray array, + jshort *elems, + jint mode) { + functions->ReleaseShortArrayElements(this,array,elems,mode); + } + void ReleaseIntArrayElements(jintArray array, + jint *elems, + jint mode) { + functions->ReleaseIntArrayElements(this,array,elems,mode); + } + void ReleaseLongArrayElements(jlongArray array, + jlong *elems, + jint mode) { + functions->ReleaseLongArrayElements(this,array,elems,mode); + } + void ReleaseFloatArrayElements(jfloatArray array, + jfloat *elems, + jint mode) { + functions->ReleaseFloatArrayElements(this,array,elems,mode); + } + void ReleaseDoubleArrayElements(jdoubleArray array, + jdouble *elems, + jint mode) { + functions->ReleaseDoubleArrayElements(this,array,elems,mode); + } + + void GetBooleanArrayRegion(jbooleanArray array, + jsize start, jsize len, jboolean *buf) { + functions->GetBooleanArrayRegion(this,array,start,len,buf); + } + void GetByteArrayRegion(jbyteArray array, + jsize start, jsize len, jbyte *buf) { + functions->GetByteArrayRegion(this,array,start,len,buf); + } + void GetCharArrayRegion(jcharArray array, + jsize start, jsize len, jchar *buf) { + functions->GetCharArrayRegion(this,array,start,len,buf); + } + void GetShortArrayRegion(jshortArray array, + jsize start, jsize len, jshort *buf) { + functions->GetShortArrayRegion(this,array,start,len,buf); + } + void GetIntArrayRegion(jintArray array, + jsize start, jsize len, jint *buf) { + functions->GetIntArrayRegion(this,array,start,len,buf); + } + void GetLongArrayRegion(jlongArray array, + jsize start, jsize len, jlong *buf) { + functions->GetLongArrayRegion(this,array,start,len,buf); + } + void GetFloatArrayRegion(jfloatArray array, + jsize start, jsize len, jfloat *buf) { + functions->GetFloatArrayRegion(this,array,start,len,buf); + } + void GetDoubleArrayRegion(jdoubleArray array, + jsize start, jsize len, jdouble *buf) { + functions->GetDoubleArrayRegion(this,array,start,len,buf); + } + + void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, + jboolean *buf) { + functions->SetBooleanArrayRegion(this,array,start,len,buf); + } + void SetByteArrayRegion(jbyteArray array, jsize start, jsize len, + jbyte *buf) { + functions->SetByteArrayRegion(this,array,start,len,buf); + } + void SetCharArrayRegion(jcharArray array, jsize start, jsize len, + jchar *buf) { + functions->SetCharArrayRegion(this,array,start,len,buf); + } + void SetShortArrayRegion(jshortArray array, jsize start, jsize len, + jshort *buf) { + functions->SetShortArrayRegion(this,array,start,len,buf); + } + void SetIntArrayRegion(jintArray array, jsize start, jsize len, + jint *buf) { + functions->SetIntArrayRegion(this,array,start,len,buf); + } + void SetLongArrayRegion(jlongArray array, jsize start, jsize len, + jlong *buf) { + functions->SetLongArrayRegion(this,array,start,len,buf); + } + void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, + jfloat *buf) { + functions->SetFloatArrayRegion(this,array,start,len,buf); + } + void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, + jdouble *buf) { + functions->SetDoubleArrayRegion(this,array,start,len,buf); + } + + jint RegisterNatives(jclass clazz, const JNINativeMethod *methods, + jint nMethods) { + return functions->RegisterNatives(this,clazz,methods,nMethods); + } + jint UnregisterNatives(jclass clazz) { + return functions->UnregisterNatives(this,clazz); + } + + jint MonitorEnter(jobject obj) { + return functions->MonitorEnter(this,obj); + } + jint MonitorExit(jobject obj) { + return functions->MonitorExit(this,obj); + } + + jint GetJavaVM(JavaVM **vm) { + return functions->GetJavaVM(this,vm); + } + +#endif /* __cplusplus */ +}; + +/* These structures will be VM-specific. */ + +typedef struct JDK1_1InitArgs { + jint version; + + char **properties; + jint checkSource; + jint nativeStackSize; + jint javaStackSize; + jint minHeapSize; + jint maxHeapSize; + jint verifyMode; + char *classpath; + + jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args); + void (JNICALL *exit)(jint code); + void (JNICALL *abort)(); + + jint enableClassGC; + jint enableVerboseGC; + jint disableAsyncGC; + jint verbose; + jboolean debugging; + jint debugPort; +} JDK1_1InitArgs; + +typedef struct JDK1_1AttachArgs { + void * __padding; /* C compilers don't allow empty structures. */ +} JDK1_1AttachArgs; + +/* End VM-specific. */ + +struct JNIInvokeInterface_ { + void *reserved0; + void *reserved1; + void *reserved2; + + jint (JNICALL *DestroyJavaVM)(JavaVM *vm); + + jint (JNICALL *AttachCurrentThread) + (JavaVM *vm, JNIEnv **penv, void *args); + + jint (JNICALL *DetachCurrentThread)(JavaVM *vm); +}; + +struct JavaVM_ { + const struct JNIInvokeInterface_ *functions; + void *reserved0; + void *reserved1; + void *reserved2; +#ifdef __cplusplus + + jint DestroyJavaVM() { + return functions->DestroyJavaVM(this); + } + jint AttachCurrentThread(JNIEnv **penv, void *args) { + return functions->AttachCurrentThread(this, penv, args); + } + jint DetachCurrentThread() { + return functions->DetachCurrentThread(this); + } + +#endif +}; + +JNI_PUBLIC_API(void) JNI_GetDefaultJavaVMInitArgs(void *); + +JNI_PUBLIC_API(jint) JNI_CreateJavaVM(JavaVM **, JNIEnv **, void *); + +JNI_PUBLIC_API(jint) JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *); +JNI_PUBLIC_API(jref) JNI_MakeLocalRef(JNIEnv *pJNIEnv, void *pHObject); + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ + +#endif /* JNI_H */ + + diff --git a/nsplugins/sdk/jni_md.h b/nsplugins/sdk/jni_md.h new file mode 100644 index 000000000..c0aa11159 --- /dev/null +++ b/nsplugins/sdk/jni_md.h @@ -0,0 +1,199 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * 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 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 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 ***** + * + * + * This Original Code has been modified by IBM Corporation. + * Modifications made by IBM described herein are + * Copyright (c) International Business Machines + * Corporation, 2000 + * + * Modifications to Mozilla code or documentation + * identified per MPL Section 3.3 + * + * Date Modified by Description of modification + * 03/27/2000 IBM Corp. Set JNICALL to Optlink for + * use in OS2 + */ + +/******************************************************************************* + * Netscape version of jni_md.h -- depends on jri_md.h + ******************************************************************************/ + +#ifndef JNI_MD_H +#define JNI_MD_H + +#include "prtypes.h" /* needed for _declspec */ + +/******************************************************************************* + * WHAT'S UP WITH THIS FILE? + * + * This is where we define the mystical JNI_PUBLIC_API macro that works on all + * platforms. If you're running with Visual C++, Symantec C, or Borland's + * development environment on the PC, you're all set. Or if you're on the Mac + * with Metrowerks, Symantec or MPW with SC you're ok too. For UNIX it shouldn't + * matter. + + * Changes by sailesh on 9/26 + + * There are two symbols used in the declaration of the JNI functions + * and native code that uses the JNI: + * JNICALL - specifies the calling convention + * JNIEXPORT - specifies export status of the function + * + * The syntax to specify calling conventions is different in Win16 and + * Win32 - the brains at Micro$oft at work here. JavaSoft in their + * infinite wisdom cares for no platform other than Win32, and so they + * just define these two symbols as: + + #define JNIEXPORT __declspec(dllexport) + #define JNICALL __stdcall + + * We deal with this, in the way JRI defines the JRI_PUBLIC_API, by + * defining a macro called JNI_PUBLIC_API. Any of our developers who + * wish to use code for Win16 and Win32, _must_ use JNI_PUBLIC_API to + * be able to export functions properly. + + * Since we must also maintain compatibility with JavaSoft, we + * continue to define the symbol JNIEXPORT. However, use of this + * internally is deprecated, since it will cause a mess on Win16. + + * We _do not_ need a new symbol called JNICALL. Instead we + * redefine JNICALL in the same way JRI_CALLBACK was defined. + + ******************************************************************************/ + +/* DLL Entry modifiers... */ +#if defined(XP_OS2) +# ifdef XP_OS2_VACPP +# define JNI_PUBLIC_API(ResultType) ResultType _System +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNICALL _Optlink +# define JNIEXPORT +# else +# define JNI_PUBLIC_API(ResultType) ResultType +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNICALL +# define JNIEXPORT +# endif +/* Win32 */ +#elif defined(XP_WIN) || defined(_WINDOWS) || defined(WIN32) || defined(_WIN32) +# include <windows.h> +# if defined(_MSC_VER) || defined(__GNUC__) +# if defined(WIN32) || defined(_WIN32) +# define JNI_PUBLIC_API(ResultType) _declspec(dllexport) ResultType __stdcall +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNI_NATIVE_STUB(ResultType) _declspec(dllexport) ResultType +# define JNICALL __stdcall +# else /* !_WIN32 */ +# if defined(_WINDLL) +# define JNI_PUBLIC_API(ResultType) ResultType __cdecl __export __loadds +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNI_NATIVE_STUB(ResultType) ResultType __cdecl __loadds +# define JNICALL __loadds +# else /* !WINDLL */ +# define JNI_PUBLIC_API(ResultType) ResultType __cdecl __export +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNI_NATIVE_STUB(ResultType) ResultType __cdecl __export +# define JNICALL __export +# endif /* !WINDLL */ +# endif /* !_WIN32 */ +# elif defined(__BORLANDC__) +# if defined(WIN32) || defined(_WIN32) +# define JNI_PUBLIC_API(ResultType) __export ResultType +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNI_NATIVE_STUB(ResultType) __export ResultType +# define JNICALL +# else /* !_WIN32 */ +# define JNI_PUBLIC_API(ResultType) ResultType _cdecl _export _loadds +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNI_NATIVE_STUB(ResultType) ResultType _cdecl _loadds +# define JNICALL _loadds +# endif +# else +# error Unsupported PC development environment. +# endif +# ifndef IS_LITTLE_ENDIAN +# define IS_LITTLE_ENDIAN +# endif + /* This is the stuff inherited from JavaSoft .. */ +# define JNIEXPORT __declspec(dllexport) + + +/* Mac */ +#elif defined(macintosh) || defined(Macintosh) || defined(THINK_C) +# if defined(__MWERKS__) /* Metrowerks */ +# if !__option(enumsalwaysint) +# error You need to define 'Enums Always Int' for your project. +# endif +# if defined(TARGET_CPU_68K) && !TARGET_RT_MAC_CFM +# if !__option(fourbyteints) +# error You need to define 'Struct Alignment: 68k' for your project. +# endif +# endif /* !GENERATINGCFM */ +# define JNI_PUBLIC_API(ResultType) __declspec(export) ResultType +# define JNI_PUBLIC_VAR(VarType) JNI_PUBLIC_API(VarType) +# define JNI_NATIVE_STUB(ResultType) JNI_PUBLIC_API(ResultType) +# elif defined(__SC__) /* Symantec */ +# error What are the Symantec defines? (warren@netscape.com) +# elif macintosh && applec /* MPW */ +# error Please upgrade to the latest MPW compiler (SC). +# else +# error Unsupported Mac development environment. +# endif +# define JNICALL + /* This is the stuff inherited from JavaSoft .. */ +# define JNIEXPORT + +/* Unix or else */ +#else +# define JNI_PUBLIC_API(ResultType) ResultType +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNI_NATIVE_STUB(ResultType) ResultType +# define JNICALL + /* This is the stuff inherited from JavaSoft .. */ +# define JNIEXPORT +#endif + +#ifndef FAR /* for non-Win16 */ +#define FAR +#endif + +/* Get the rest of the stuff from jri_md.h */ +#include "jri_md.h" + +#endif /* JNI_MD_H */ diff --git a/nsplugins/sdk/jri.h b/nsplugins/sdk/jri.h new file mode 100644 index 000000000..f29945b94 --- /dev/null +++ b/nsplugins/sdk/jri.h @@ -0,0 +1,689 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** 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.org 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 ***** */ + +/******************************************************************************* + * Java Runtime Interface + ******************************************************************************/ + +#ifndef JRI_H +#define JRI_H + +#include "jritypes.h" + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/******************************************************************************* + * JRIEnv + ******************************************************************************/ + +/* The type of the JRIEnv interface. */ +typedef struct JRIEnvInterface JRIEnvInterface; + +/* The type of a JRIEnv instance. */ +typedef const JRIEnvInterface* JRIEnv; + +/******************************************************************************* + * JRIEnv Operations + ******************************************************************************/ + +#define JRI_DefineClass(env, classLoader, buf, bufLen) \ + (((*(env))->DefineClass)(env, JRI_DefineClass_op, classLoader, buf, bufLen)) + +#define JRI_FindClass(env, name) \ + (((*(env))->FindClass)(env, JRI_FindClass_op, name)) + +#define JRI_Throw(env, obj) \ + (((*(env))->Throw)(env, JRI_Throw_op, obj)) + +#define JRI_ThrowNew(env, clazz, message) \ + (((*(env))->ThrowNew)(env, JRI_ThrowNew_op, clazz, message)) + +#define JRI_ExceptionOccurred(env) \ + (((*(env))->ExceptionOccurred)(env, JRI_ExceptionOccurred_op)) + +#define JRI_ExceptionDescribe(env) \ + (((*(env))->ExceptionDescribe)(env, JRI_ExceptionDescribe_op)) + +#define JRI_ExceptionClear(env) \ + (((*(env))->ExceptionClear)(env, JRI_ExceptionClear_op)) + +#define JRI_NewGlobalRef(env, ref) \ + (((*(env))->NewGlobalRef)(env, JRI_NewGlobalRef_op, ref)) + +#define JRI_DisposeGlobalRef(env, gref) \ + (((*(env))->DisposeGlobalRef)(env, JRI_DisposeGlobalRef_op, gref)) + +#define JRI_GetGlobalRef(env, gref) \ + (((*(env))->GetGlobalRef)(env, JRI_GetGlobalRef_op, gref)) + +#define JRI_SetGlobalRef(env, gref, ref) \ + (((*(env))->SetGlobalRef)(env, JRI_SetGlobalRef_op, gref, ref)) + +#define JRI_IsSameObject(env, a, b) \ + (((*(env))->IsSameObject)(env, JRI_IsSameObject_op, a, b)) + +#define JRI_NewObject(env) ((*(env))->NewObject) +#define JRI_NewObjectV(env, clazz, methodID, args) \ + (((*(env))->NewObjectV)(env, JRI_NewObject_op_va_list, clazz, methodID, args)) +#define JRI_NewObjectA(env, clazz, method, args) \ + (((*(env))->NewObjectA)(env, JRI_NewObject_op_array, clazz, methodID, args)) + +#define JRI_GetObjectClass(env, obj) \ + (((*(env))->GetObjectClass)(env, JRI_GetObjectClass_op, obj)) + +#define JRI_IsInstanceOf(env, obj, clazz) \ + (((*(env))->IsInstanceOf)(env, JRI_IsInstanceOf_op, obj, clazz)) + +#define JRI_GetMethodID(env, clazz, name, sig) \ + (((*(env))->GetMethodID)(env, JRI_GetMethodID_op, clazz, name, sig)) + +#define JRI_CallMethod(env) ((*(env))->CallMethod) +#define JRI_CallMethodV(env, obj, methodID, args) \ + (((*(env))->CallMethodV)(env, JRI_CallMethod_op_va_list, obj, methodID, args)) +#define JRI_CallMethodA(env, obj, methodID, args) \ + (((*(env))->CallMethodA)(env, JRI_CallMethod_op_array, obj, methodID, args)) + +#define JRI_CallMethodBoolean(env) ((*(env))->CallMethodBoolean) +#define JRI_CallMethodBooleanV(env, obj, methodID, args) \ + (((*(env))->CallMethodBooleanV)(env, JRI_CallMethodBoolean_op_va_list, obj, methodID, args)) +#define JRI_CallMethodBooleanA(env, obj, methodID, args) \ + (((*(env))->CallMethodBooleanA)(env, JRI_CallMethodBoolean_op_array, obj, methodID, args)) + +#define JRI_CallMethodByte(env) ((*(env))->CallMethodByte) +#define JRI_CallMethodByteV(env, obj, methodID, args) \ + (((*(env))->CallMethodByteV)(env, JRI_CallMethodByte_op_va_list, obj, methodID, args)) +#define JRI_CallMethodByteA(env, obj, methodID, args) \ + (((*(env))->CallMethodByteA)(env, JRI_CallMethodByte_op_array, obj, methodID, args)) + +#define JRI_CallMethodChar(env) ((*(env))->CallMethodChar) +#define JRI_CallMethodCharV(env, obj, methodID, args) \ + (((*(env))->CallMethodCharV)(env, JRI_CallMethodChar_op_va_list, obj, methodID, args)) +#define JRI_CallMethodCharA(env, obj, methodID, args) \ + (((*(env))->CallMethodCharA)(env, JRI_CallMethodChar_op_array, obj, methodID, args)) + +#define JRI_CallMethodShort(env) ((*(env))->CallMethodShort) +#define JRI_CallMethodShortV(env, obj, methodID, args) \ + (((*(env))->CallMethodShortV)(env, JRI_CallMethodShort_op_va_list, obj, methodID, args)) +#define JRI_CallMethodShortA(env, obj, methodID, args) \ + (((*(env))->CallMethodShortA)(env, JRI_CallMethodShort_op_array, obj, methodID, args)) + +#define JRI_CallMethodInt(env) ((*(env))->CallMethodInt) +#define JRI_CallMethodIntV(env, obj, methodID, args) \ + (((*(env))->CallMethodIntV)(env, JRI_CallMethodInt_op_va_list, obj, methodID, args)) +#define JRI_CallMethodIntA(env, obj, methodID, args) \ + (((*(env))->CallMethodIntA)(env, JRI_CallMethodInt_op_array, obj, methodID, args)) + +#define JRI_CallMethodLong(env) ((*(env))->CallMethodLong) +#define JRI_CallMethodLongV(env, obj, methodID, args) \ + (((*(env))->CallMethodLongV)(env, JRI_CallMethodLong_op_va_list, obj, methodID, args)) +#define JRI_CallMethodLongA(env, obj, methodID, args) \ + (((*(env))->CallMethodLongA)(env, JRI_CallMethodLong_op_array, obj, methodID, args)) + +#define JRI_CallMethodFloat(env) ((*(env))->CallMethodFloat) +#define JRI_CallMethodFloatV(env, obj, methodID, args) \ + (((*(env))->CallMethodFloatV)(env, JRI_CallMethodFloat_op_va_list, obj, methodID, args)) +#define JRI_CallMethodFloatA(env, obj, methodID, args) \ + (((*(env))->CallMethodFloatA)(env, JRI_CallMethodFloat_op_array, obj, methodID, args)) + +#define JRI_CallMethodDouble(env) ((*(env))->CallMethodDouble) +#define JRI_CallMethodDoubleV(env, obj, methodID, args) \ + (((*(env))->CallMethodDoubleV)(env, JRI_CallMethodDouble_op_va_list, obj, methodID, args)) +#define JRI_CallMethodDoubleA(env, obj, methodID, args) \ + (((*(env))->CallMethodDoubleA)(env, JRI_CallMethodDouble_op_array, obj, methodID, args)) + +#define JRI_GetFieldID(env, clazz, name, sig) \ + (((*(env))->GetFieldID)(env, JRI_GetFieldID_op, clazz, name, sig)) + +#define JRI_GetField(env, obj, fieldID) \ + (((*(env))->GetField)(env, JRI_GetField_op, obj, fieldID)) + +#define JRI_GetFieldBoolean(env, obj, fieldID) \ + (((*(env))->GetFieldBoolean)(env, JRI_GetFieldBoolean_op, obj, fieldID)) + +#define JRI_GetFieldByte(env, obj, fieldID) \ + (((*(env))->GetFieldByte)(env, JRI_GetFieldByte_op, obj, fieldID)) + +#define JRI_GetFieldChar(env, obj, fieldID) \ + (((*(env))->GetFieldChar)(env, JRI_GetFieldChar_op, obj, fieldID)) + +#define JRI_GetFieldShort(env, obj, fieldID) \ + (((*(env))->GetFieldShort)(env, JRI_GetFieldShort_op, obj, fieldID)) + +#define JRI_GetFieldInt(env, obj, fieldID) \ + (((*(env))->GetFieldInt)(env, JRI_GetFieldInt_op, obj, fieldID)) + +#define JRI_GetFieldLong(env, obj, fieldID) \ + (((*(env))->GetFieldLong)(env, JRI_GetFieldLong_op, obj, fieldID)) + +#define JRI_GetFieldFloat(env, obj, fieldID) \ + (((*(env))->GetFieldFloat)(env, JRI_GetFieldFloat_op, obj, fieldID)) + +#define JRI_GetFieldDouble(env, obj, fieldID) \ + (((*(env))->GetFieldDouble)(env, JRI_GetFieldDouble_op, obj, fieldID)) + +#define JRI_SetField(env, obj, fieldID, value) \ + (((*(env))->SetField)(env, JRI_SetField_op, obj, fieldID, value)) + +#define JRI_SetFieldBoolean(env, obj, fieldID, value) \ + (((*(env))->SetFieldBoolean)(env, JRI_SetFieldBoolean_op, obj, fieldID, value)) + +#define JRI_SetFieldByte(env, obj, fieldID, value) \ + (((*(env))->SetFieldByte)(env, JRI_SetFieldByte_op, obj, fieldID, value)) + +#define JRI_SetFieldChar(env, obj, fieldID, value) \ + (((*(env))->SetFieldChar)(env, JRI_SetFieldChar_op, obj, fieldID, value)) + +#define JRI_SetFieldShort(env, obj, fieldID, value) \ + (((*(env))->SetFieldShort)(env, JRI_SetFieldShort_op, obj, fieldID, value)) + +#define JRI_SetFieldInt(env, obj, fieldID, value) \ + (((*(env))->SetFieldInt)(env, JRI_SetFieldInt_op, obj, fieldID, value)) + +#define JRI_SetFieldLong(env, obj, fieldID, value) \ + (((*(env))->SetFieldLong)(env, JRI_SetFieldLong_op, obj, fieldID, value)) + +#define JRI_SetFieldFloat(env, obj, fieldID, value) \ + (((*(env))->SetFieldFloat)(env, JRI_SetFieldFloat_op, obj, fieldID, value)) + +#define JRI_SetFieldDouble(env, obj, fieldID, value) \ + (((*(env))->SetFieldDouble)(env, JRI_SetFieldDouble_op, obj, fieldID, value)) + +#define JRI_IsSubclassOf(env, a, b) \ + (((*(env))->IsSubclassOf)(env, JRI_IsSubclassOf_op, a, b)) + +#define JRI_GetStaticMethodID(env, clazz, name, sig) \ + (((*(env))->GetStaticMethodID)(env, JRI_GetStaticMethodID_op, clazz, name, sig)) + +#define JRI_CallStaticMethod(env) ((*(env))->CallStaticMethod) +#define JRI_CallStaticMethodV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodV)(env, JRI_CallStaticMethod_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodA)(env, JRI_CallStaticMethod_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodBoolean(env) ((*(env))->CallStaticMethodBoolean) +#define JRI_CallStaticMethodBooleanV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodBooleanV)(env, JRI_CallStaticMethodBoolean_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodBooleanA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodBooleanA)(env, JRI_CallStaticMethodBoolean_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodByte(env) ((*(env))->CallStaticMethodByte) +#define JRI_CallStaticMethodByteV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodByteV)(env, JRI_CallStaticMethodByte_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodByteA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodByteA)(env, JRI_CallStaticMethodByte_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodChar(env) ((*(env))->CallStaticMethodChar) +#define JRI_CallStaticMethodCharV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodCharV)(env, JRI_CallStaticMethodChar_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodCharA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodCharA)(env, JRI_CallStaticMethodChar_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodShort(env) ((*(env))->CallStaticMethodShort) +#define JRI_CallStaticMethodShortV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodShortV)(env, JRI_CallStaticMethodShort_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodShortA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodShortA)(env, JRI_CallStaticMethodShort_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodInt(env) ((*(env))->CallStaticMethodInt) +#define JRI_CallStaticMethodIntV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodIntV)(env, JRI_CallStaticMethodInt_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodIntA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodIntA)(env, JRI_CallStaticMethodInt_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodLong(env) ((*(env))->CallStaticMethodLong) +#define JRI_CallStaticMethodLongV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodLongV)(env, JRI_CallStaticMethodLong_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodLongA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodLongA)(env, JRI_CallStaticMethodLong_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodFloat(env) ((*(env))->CallStaticMethodFloat) +#define JRI_CallStaticMethodFloatV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodFloatV)(env, JRI_CallStaticMethodFloat_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodFloatA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodFloatA)(env, JRI_CallStaticMethodFloat_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodDouble(env) ((*(env))->CallStaticMethodDouble) +#define JRI_CallStaticMethodDoubleV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodDoubleV)(env, JRI_CallStaticMethodDouble_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodDoubleA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodDoubleA)(env, JRI_CallStaticMethodDouble_op_array, clazz, methodID, args)) + +#define JRI_GetStaticFieldID(env, clazz, name, sig) \ + (((*(env))->GetStaticFieldID)(env, JRI_GetStaticFieldID_op, clazz, name, sig)) + +#define JRI_GetStaticField(env, clazz, fieldID) \ + (((*(env))->GetStaticField)(env, JRI_GetStaticField_op, clazz, fieldID)) + +#define JRI_GetStaticFieldBoolean(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldBoolean)(env, JRI_GetStaticFieldBoolean_op, clazz, fieldID)) + +#define JRI_GetStaticFieldByte(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldByte)(env, JRI_GetStaticFieldByte_op, clazz, fieldID)) + +#define JRI_GetStaticFieldChar(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldChar)(env, JRI_GetStaticFieldChar_op, clazz, fieldID)) + +#define JRI_GetStaticFieldShort(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldShort)(env, JRI_GetStaticFieldShort_op, clazz, fieldID)) + +#define JRI_GetStaticFieldInt(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldInt)(env, JRI_GetStaticFieldInt_op, clazz, fieldID)) + +#define JRI_GetStaticFieldLong(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldLong)(env, JRI_GetStaticFieldLong_op, clazz, fieldID)) + +#define JRI_GetStaticFieldFloat(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldFloat)(env, JRI_GetStaticFieldFloat_op, clazz, fieldID)) + +#define JRI_GetStaticFieldDouble(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldDouble)(env, JRI_GetStaticFieldDouble_op, clazz, fieldID)) + +#define JRI_SetStaticField(env, clazz, fieldID, value) \ + (((*(env))->SetStaticField)(env, JRI_SetStaticField_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldBoolean(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldBoolean)(env, JRI_SetStaticFieldBoolean_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldByte(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldByte)(env, JRI_SetStaticFieldByte_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldChar(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldChar)(env, JRI_SetStaticFieldChar_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldShort(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldShort)(env, JRI_SetStaticFieldShort_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldInt(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldInt)(env, JRI_SetStaticFieldInt_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldLong(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldLong)(env, JRI_SetStaticFieldLong_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldFloat(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldFloat)(env, JRI_SetStaticFieldFloat_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldDouble(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldDouble)(env, JRI_SetStaticFieldDouble_op, clazz, fieldID, value)) + +#define JRI_NewString(env, unicode, len) \ + (((*(env))->NewString)(env, JRI_NewString_op, unicode, len)) + +#define JRI_GetStringLength(env, string) \ + (((*(env))->GetStringLength)(env, JRI_GetStringLength_op, string)) + +#define JRI_GetStringChars(env, string) \ + (((*(env))->GetStringChars)(env, JRI_GetStringChars_op, string)) + +#define JRI_NewStringUTF(env, utf, len) \ + (((*(env))->NewStringUTF)(env, JRI_NewStringUTF_op, utf, len)) + +#define JRI_GetStringUTFLength(env, string) \ + (((*(env))->GetStringUTFLength)(env, JRI_GetStringUTFLength_op, string)) + +#define JRI_GetStringUTFChars(env, string) \ + (((*(env))->GetStringUTFChars)(env, JRI_GetStringUTFChars_op, string)) + +#define JRI_NewScalarArray(env, length, elementSig, initialElements) \ + (((*(env))->NewScalarArray)(env, JRI_NewScalarArray_op, length, elementSig, initialElements)) + +#define JRI_GetScalarArrayLength(env, array) \ + (((*(env))->GetScalarArrayLength)(env, JRI_GetScalarArrayLength_op, array)) + +#define JRI_GetScalarArrayElements(env, array) \ + (((*(env))->GetScalarArrayElements)(env, JRI_GetScalarArrayElements_op, array)) + +#define JRI_NewObjectArray(env, length, elementClass, initialElement) \ + (((*(env))->NewObjectArray)(env, JRI_NewObjectArray_op, length, elementClass, initialElement)) + +#define JRI_GetObjectArrayLength(env, array) \ + (((*(env))->GetObjectArrayLength)(env, JRI_GetObjectArrayLength_op, array)) + +#define JRI_GetObjectArrayElement(env, array, index) \ + (((*(env))->GetObjectArrayElement)(env, JRI_GetObjectArrayElement_op, array, index)) + +#define JRI_SetObjectArrayElement(env, array, index, value) \ + (((*(env))->SetObjectArrayElement)(env, JRI_SetObjectArrayElement_op, array, index, value)) + +#define JRI_RegisterNatives(env, clazz, nameAndSigArray, nativeProcArray) \ + (((*(env))->RegisterNatives)(env, JRI_RegisterNatives_op, clazz, nameAndSigArray, nativeProcArray)) + +#define JRI_UnregisterNatives(env, clazz) \ + (((*(env))->UnregisterNatives)(env, JRI_UnregisterNatives_op, clazz)) + +#define JRI_NewStringPlatform(env, string, len, encoding, encodingLength) \ + (((*(env))->NewStringPlatform)(env, JRI_NewStringPlatform_op, string, len, encoding, encodingLength)) + +#define JRI_GetStringPlatformChars(env, string, encoding, encodingLength) \ + (((*(env))->GetStringPlatformChars)(env, JRI_GetStringPlatformChars_op, string, encoding, encodingLength)) + + +/******************************************************************************* + * JRIEnv Interface + ******************************************************************************/ + +struct java_lang_ClassLoader; +struct java_lang_Class; +struct java_lang_Throwable; +struct java_lang_Object; +struct java_lang_String; + +struct JRIEnvInterface { + void* reserved0; + void* reserved1; + void* reserved2; + void* reserved3; + struct java_lang_Class* (*FindClass)(JRIEnv* env, jint op, const char* a); + void (*Throw)(JRIEnv* env, jint op, struct java_lang_Throwable* a); + void (*ThrowNew)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b); + struct java_lang_Throwable* (*ExceptionOccurred)(JRIEnv* env, jint op); + void (*ExceptionDescribe)(JRIEnv* env, jint op); + void (*ExceptionClear)(JRIEnv* env, jint op); + jglobal (*NewGlobalRef)(JRIEnv* env, jint op, void* a); + void (*DisposeGlobalRef)(JRIEnv* env, jint op, jglobal a); + void* (*GetGlobalRef)(JRIEnv* env, jint op, jglobal a); + void (*SetGlobalRef)(JRIEnv* env, jint op, jglobal a, void* b); + jbool (*IsSameObject)(JRIEnv* env, jint op, void* a, void* b); + void* (*NewObject)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + void* (*NewObjectV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + void* (*NewObjectA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + struct java_lang_Class* (*GetObjectClass)(JRIEnv* env, jint op, void* a); + jbool (*IsInstanceOf)(JRIEnv* env, jint op, void* a, struct java_lang_Class* b); + jint (*GetMethodID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c); + void* (*CallMethod)(JRIEnv* env, jint op, void* a, jint b, ...); + void* (*CallMethodV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + void* (*CallMethodA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jbool (*CallMethodBoolean)(JRIEnv* env, jint op, void* a, jint b, ...); + jbool (*CallMethodBooleanV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jbool (*CallMethodBooleanA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jbyte (*CallMethodByte)(JRIEnv* env, jint op, void* a, jint b, ...); + jbyte (*CallMethodByteV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jbyte (*CallMethodByteA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jchar (*CallMethodChar)(JRIEnv* env, jint op, void* a, jint b, ...); + jchar (*CallMethodCharV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jchar (*CallMethodCharA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jshort (*CallMethodShort)(JRIEnv* env, jint op, void* a, jint b, ...); + jshort (*CallMethodShortV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jshort (*CallMethodShortA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jint (*CallMethodInt)(JRIEnv* env, jint op, void* a, jint b, ...); + jint (*CallMethodIntV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jint (*CallMethodIntA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jlong (*CallMethodLong)(JRIEnv* env, jint op, void* a, jint b, ...); + jlong (*CallMethodLongV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jlong (*CallMethodLongA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jfloat (*CallMethodFloat)(JRIEnv* env, jint op, void* a, jint b, ...); + jfloat (*CallMethodFloatV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jfloat (*CallMethodFloatA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jdouble (*CallMethodDouble)(JRIEnv* env, jint op, void* a, jint b, ...); + jdouble (*CallMethodDoubleV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jdouble (*CallMethodDoubleA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jint (*GetFieldID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c); + void* (*GetField)(JRIEnv* env, jint op, void* a, jint b); + jbool (*GetFieldBoolean)(JRIEnv* env, jint op, void* a, jint b); + jbyte (*GetFieldByte)(JRIEnv* env, jint op, void* a, jint b); + jchar (*GetFieldChar)(JRIEnv* env, jint op, void* a, jint b); + jshort (*GetFieldShort)(JRIEnv* env, jint op, void* a, jint b); + jint (*GetFieldInt)(JRIEnv* env, jint op, void* a, jint b); + jlong (*GetFieldLong)(JRIEnv* env, jint op, void* a, jint b); + jfloat (*GetFieldFloat)(JRIEnv* env, jint op, void* a, jint b); + jdouble (*GetFieldDouble)(JRIEnv* env, jint op, void* a, jint b); + void (*SetField)(JRIEnv* env, jint op, void* a, jint b, void* c); + void (*SetFieldBoolean)(JRIEnv* env, jint op, void* a, jint b, jbool c); + void (*SetFieldByte)(JRIEnv* env, jint op, void* a, jint b, jbyte c); + void (*SetFieldChar)(JRIEnv* env, jint op, void* a, jint b, jchar c); + void (*SetFieldShort)(JRIEnv* env, jint op, void* a, jint b, jshort c); + void (*SetFieldInt)(JRIEnv* env, jint op, void* a, jint b, jint c); + void (*SetFieldLong)(JRIEnv* env, jint op, void* a, jint b, jlong c); + void (*SetFieldFloat)(JRIEnv* env, jint op, void* a, jint b, jfloat c); + void (*SetFieldDouble)(JRIEnv* env, jint op, void* a, jint b, jdouble c); + jbool (*IsSubclassOf)(JRIEnv* env, jint op, struct java_lang_Class* a, struct java_lang_Class* b); + jint (*GetStaticMethodID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c); + void* (*CallStaticMethod)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + void* (*CallStaticMethodV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + void* (*CallStaticMethodA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jbool (*CallStaticMethodBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jbool (*CallStaticMethodBooleanV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jbool (*CallStaticMethodBooleanA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jbyte (*CallStaticMethodByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jbyte (*CallStaticMethodByteV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jbyte (*CallStaticMethodByteA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jchar (*CallStaticMethodChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jchar (*CallStaticMethodCharV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jchar (*CallStaticMethodCharA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jshort (*CallStaticMethodShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jshort (*CallStaticMethodShortV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jshort (*CallStaticMethodShortA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jint (*CallStaticMethodInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jint (*CallStaticMethodIntV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jint (*CallStaticMethodIntA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jlong (*CallStaticMethodLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jlong (*CallStaticMethodLongV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jlong (*CallStaticMethodLongA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jfloat (*CallStaticMethodFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jfloat (*CallStaticMethodFloatV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jfloat (*CallStaticMethodFloatA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jdouble (*CallStaticMethodDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jdouble (*CallStaticMethodDoubleV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jdouble (*CallStaticMethodDoubleA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jint (*GetStaticFieldID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c); + void* (*GetStaticField)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jbool (*GetStaticFieldBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jbyte (*GetStaticFieldByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jchar (*GetStaticFieldChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jshort (*GetStaticFieldShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jint (*GetStaticFieldInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jlong (*GetStaticFieldLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jfloat (*GetStaticFieldFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jdouble (*GetStaticFieldDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + void (*SetStaticField)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, void* c); + void (*SetStaticFieldBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jbool c); + void (*SetStaticFieldByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jbyte c); + void (*SetStaticFieldChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jchar c); + void (*SetStaticFieldShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jshort c); + void (*SetStaticFieldInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jint c); + void (*SetStaticFieldLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jlong c); + void (*SetStaticFieldFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jfloat c); + void (*SetStaticFieldDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jdouble c); + struct java_lang_String* (*NewString)(JRIEnv* env, jint op, const jchar* a, jint b); + jint (*GetStringLength)(JRIEnv* env, jint op, struct java_lang_String* a); + const jchar* (*GetStringChars)(JRIEnv* env, jint op, struct java_lang_String* a); + struct java_lang_String* (*NewStringUTF)(JRIEnv* env, jint op, const jbyte* a, jint b); + jint (*GetStringUTFLength)(JRIEnv* env, jint op, struct java_lang_String* a); + const jbyte* (*GetStringUTFChars)(JRIEnv* env, jint op, struct java_lang_String* a); + void* (*NewScalarArray)(JRIEnv* env, jint op, jint a, const char* b, const jbyte* c); + jint (*GetScalarArrayLength)(JRIEnv* env, jint op, void* a); + jbyte* (*GetScalarArrayElements)(JRIEnv* env, jint op, void* a); + void* (*NewObjectArray)(JRIEnv* env, jint op, jint a, struct java_lang_Class* b, void* c); + jint (*GetObjectArrayLength)(JRIEnv* env, jint op, void* a); + void* (*GetObjectArrayElement)(JRIEnv* env, jint op, void* a, jint b); + void (*SetObjectArrayElement)(JRIEnv* env, jint op, void* a, jint b, void* c); + void (*RegisterNatives)(JRIEnv* env, jint op, struct java_lang_Class* a, char** b, void** c); + void (*UnregisterNatives)(JRIEnv* env, jint op, struct java_lang_Class* a); + struct java_lang_Class* (*DefineClass)(JRIEnv* env, jint op, struct java_lang_ClassLoader* a, jbyte* b, jsize bLen); + struct java_lang_String* (*NewStringPlatform)(JRIEnv* env, jint op, const jbyte* a, jint b, const jbyte* c, jint d); + const jbyte* (*GetStringPlatformChars)(JRIEnv* env, jint op, struct java_lang_String* a, const jbyte* b, jint c); +}; + +/* +** **************************************************************************** +** JRIEnv Operation IDs +** *************************************************************************** +*/ + +typedef enum JRIEnvOperations { + JRI_Reserved0_op, + JRI_Reserved1_op, + JRI_Reserved2_op, + JRI_Reserved3_op, + JRI_FindClass_op, + JRI_Throw_op, + JRI_ThrowNew_op, + JRI_ExceptionOccurred_op, + JRI_ExceptionDescribe_op, + JRI_ExceptionClear_op, + JRI_NewGlobalRef_op, + JRI_DisposeGlobalRef_op, + JRI_GetGlobalRef_op, + JRI_SetGlobalRef_op, + JRI_IsSameObject_op, + JRI_NewObject_op, + JRI_NewObject_op_va_list, + JRI_NewObject_op_array, + JRI_GetObjectClass_op, + JRI_IsInstanceOf_op, + JRI_GetMethodID_op, + JRI_CallMethod_op, + JRI_CallMethod_op_va_list, + JRI_CallMethod_op_array, + JRI_CallMethodBoolean_op, + JRI_CallMethodBoolean_op_va_list, + JRI_CallMethodBoolean_op_array, + JRI_CallMethodByte_op, + JRI_CallMethodByte_op_va_list, + JRI_CallMethodByte_op_array, + JRI_CallMethodChar_op, + JRI_CallMethodChar_op_va_list, + JRI_CallMethodChar_op_array, + JRI_CallMethodShort_op, + JRI_CallMethodShort_op_va_list, + JRI_CallMethodShort_op_array, + JRI_CallMethodInt_op, + JRI_CallMethodInt_op_va_list, + JRI_CallMethodInt_op_array, + JRI_CallMethodLong_op, + JRI_CallMethodLong_op_va_list, + JRI_CallMethodLong_op_array, + JRI_CallMethodFloat_op, + JRI_CallMethodFloat_op_va_list, + JRI_CallMethodFloat_op_array, + JRI_CallMethodDouble_op, + JRI_CallMethodDouble_op_va_list, + JRI_CallMethodDouble_op_array, + JRI_GetFieldID_op, + JRI_GetField_op, + JRI_GetFieldBoolean_op, + JRI_GetFieldByte_op, + JRI_GetFieldChar_op, + JRI_GetFieldShort_op, + JRI_GetFieldInt_op, + JRI_GetFieldLong_op, + JRI_GetFieldFloat_op, + JRI_GetFieldDouble_op, + JRI_SetField_op, + JRI_SetFieldBoolean_op, + JRI_SetFieldByte_op, + JRI_SetFieldChar_op, + JRI_SetFieldShort_op, + JRI_SetFieldInt_op, + JRI_SetFieldLong_op, + JRI_SetFieldFloat_op, + JRI_SetFieldDouble_op, + JRI_IsSubclassOf_op, + JRI_GetStaticMethodID_op, + JRI_CallStaticMethod_op, + JRI_CallStaticMethod_op_va_list, + JRI_CallStaticMethod_op_array, + JRI_CallStaticMethodBoolean_op, + JRI_CallStaticMethodBoolean_op_va_list, + JRI_CallStaticMethodBoolean_op_array, + JRI_CallStaticMethodByte_op, + JRI_CallStaticMethodByte_op_va_list, + JRI_CallStaticMethodByte_op_array, + JRI_CallStaticMethodChar_op, + JRI_CallStaticMethodChar_op_va_list, + JRI_CallStaticMethodChar_op_array, + JRI_CallStaticMethodShort_op, + JRI_CallStaticMethodShort_op_va_list, + JRI_CallStaticMethodShort_op_array, + JRI_CallStaticMethodInt_op, + JRI_CallStaticMethodInt_op_va_list, + JRI_CallStaticMethodInt_op_array, + JRI_CallStaticMethodLong_op, + JRI_CallStaticMethodLong_op_va_list, + JRI_CallStaticMethodLong_op_array, + JRI_CallStaticMethodFloat_op, + JRI_CallStaticMethodFloat_op_va_list, + JRI_CallStaticMethodFloat_op_array, + JRI_CallStaticMethodDouble_op, + JRI_CallStaticMethodDouble_op_va_list, + JRI_CallStaticMethodDouble_op_array, + JRI_GetStaticFieldID_op, + JRI_GetStaticField_op, + JRI_GetStaticFieldBoolean_op, + JRI_GetStaticFieldByte_op, + JRI_GetStaticFieldChar_op, + JRI_GetStaticFieldShort_op, + JRI_GetStaticFieldInt_op, + JRI_GetStaticFieldLong_op, + JRI_GetStaticFieldFloat_op, + JRI_GetStaticFieldDouble_op, + JRI_SetStaticField_op, + JRI_SetStaticFieldBoolean_op, + JRI_SetStaticFieldByte_op, + JRI_SetStaticFieldChar_op, + JRI_SetStaticFieldShort_op, + JRI_SetStaticFieldInt_op, + JRI_SetStaticFieldLong_op, + JRI_SetStaticFieldFloat_op, + JRI_SetStaticFieldDouble_op, + JRI_NewString_op, + JRI_GetStringLength_op, + JRI_GetStringChars_op, + JRI_NewStringUTF_op, + JRI_GetStringUTFLength_op, + JRI_GetStringUTFChars_op, + JRI_NewScalarArray_op, + JRI_GetScalarArrayLength_op, + JRI_GetScalarArrayElements_op, + JRI_NewObjectArray_op, + JRI_GetObjectArrayLength_op, + JRI_GetObjectArrayElement_op, + JRI_SetObjectArrayElement_op, + JRI_RegisterNatives_op, + JRI_UnregisterNatives_op, + JRI_DefineClass_op, + JRI_NewStringPlatform_op, + JRI_GetStringPlatformChars_op +} JRIEnvOperations; + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ + +#endif /* JRI_H */ +/******************************************************************************/ diff --git a/nsplugins/sdk/jri_md.h b/nsplugins/sdk/jri_md.h new file mode 100644 index 000000000..5ae741ed3 --- /dev/null +++ b/nsplugins/sdk/jri_md.h @@ -0,0 +1,565 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** 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.org 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 ***** */ + +/******************************************************************************* + * Java Runtime Interface - Machine Dependent Types + ******************************************************************************/ + +#ifndef JRI_MD_H +#define JRI_MD_H + +#include <assert.h> +#include "prtypes.h" /* Needed for HAS_LONG_LONG ifdefs & _declspec */ + +#ifdef __cplusplus +extern "C" { +#endif + +/******************************************************************************* + * WHAT'S UP WITH THIS FILE? + * + * This is where we define the mystical JRI_PUBLIC_API macro that works on all + * platforms. If you're running with Visual C++, Symantec C, or Borland's + * development environment on the PC, you're all set. Or if you're on the Mac + * with Metrowerks, Symantec or MPW with SC you're ok too. For UNIX it shouldn't + * matter. + * + * On UNIX though you probably care about a couple of other symbols though: + * IS_LITTLE_ENDIAN must be defined for little-endian systems + * HAVE_LONG_LONG must be defined on systems that have 'long long' integers + * HAVE_ALIGNED_LONGLONGS must be defined if long-longs must be 8 byte aligned + * HAVE_ALIGNED_DOUBLES must be defined if doubles must be 8 byte aligned + * IS_64 must be defined on 64-bit machines (like Dec Alpha) + ******************************************************************************/ + +/* DLL Entry modifiers... */ + +/* PC */ +#if defined(XP_OS2) +# ifdef XP_OS2_VACPP +# define JRI_PUBLIC_API(ResultType) ResultType _Optlink +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_CALLBACK +# else +# define JRI_PUBLIC_API(ResultType) ResultType +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_CALLBACK +# endif +#elif defined(XP_WIN) || defined(_WINDOWS) || defined(WIN32) || defined(_WIN32) +# include <windows.h> +# if defined(_MSC_VER) || defined(__GNUC__) +# if defined(WIN32) || defined(_WIN32) +# define JRI_PUBLIC_API(ResultType) _declspec(dllexport) ResultType +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) _declspec(dllexport) VarType +# define JRI_PUBLIC_VAR_IMP(VarType) _declspec(dllimport) VarType +# define JRI_NATIVE_STUB(ResultType) _declspec(dllexport) ResultType +# define JRI_CALLBACK +# else /* !_WIN32 */ +# if defined(_WINDLL) +# define JRI_PUBLIC_API(ResultType) ResultType __cdecl __export __loadds +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_NATIVE_STUB(ResultType) ResultType __cdecl __loadds +# define JRI_CALLBACK __loadds +# else /* !WINDLL */ +# define JRI_PUBLIC_API(ResultType) ResultType __cdecl __export +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_NATIVE_STUB(ResultType) ResultType __cdecl __export +# define JRI_CALLBACK __export +# endif /* !WINDLL */ +# endif /* !_WIN32 */ +# elif defined(__BORLANDC__) +# if defined(WIN32) || defined(_WIN32) +# define JRI_PUBLIC_API(ResultType) __export ResultType +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) __export VarType +# define JRI_PUBLIC_VAR_IMP(VarType) __import VarType +# define JRI_NATIVE_STUB(ResultType) __export ResultType +# define JRI_CALLBACK +# else /* !_WIN32 */ +# define JRI_PUBLIC_API(ResultType) ResultType _cdecl _export _loadds +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) __cdecl __export VarType +# define JRI_PUBLIC_VAR_IMP(VarType) __cdecl __import VarType +# define JRI_NATIVE_STUB(ResultType) ResultType _cdecl _loadds +# define JRI_CALLBACK _loadds +# endif +# else +# error Unsupported PC development environment. +# endif +# ifndef IS_LITTLE_ENDIAN +# define IS_LITTLE_ENDIAN +# endif + +/* Mac */ +#elif defined (macintosh) || defined(Macintosh) || defined(THINK_C) +# if defined(__MWERKS__) /* Metrowerks */ +# if !__option(enumsalwaysint) +# error You need to define 'Enums Always Int' for your project. +# endif +# if defined(TARGET_CPU_68K) && !TARGET_RT_MAC_CFM +# if !__option(fourbyteints) +# error You need to define 'Struct Alignment: 68k' for your project. +# endif +# endif /* !GENERATINGCFM */ +# define JRI_PUBLIC_API(ResultType) __declspec(export) ResultType +# define JRI_PUBLIC_VAR(VarType) JRI_PUBLIC_API(VarType) +# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_API(VarType) +# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_API(VarType) +# define JRI_NATIVE_STUB(ResultType) JRI_PUBLIC_API(ResultType) +# elif defined(__SC__) /* Symantec */ +# error What are the Symantec defines? (warren@netscape.com) +# elif macintosh && applec /* MPW */ +# error Please upgrade to the latest MPW compiler (SC). +# else +# error Unsupported Mac development environment. +# endif +# define JRI_CALLBACK + +/* Unix or else */ +#else +# define JRI_PUBLIC_API(ResultType) ResultType +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_NATIVE_STUB(ResultType) ResultType +# define JRI_CALLBACK +#endif + +#ifndef FAR /* for non-Win16 */ +#define FAR +#endif + +/******************************************************************************/ + +/* Java Scalar Types */ + +#if 0 /* now in jni.h */ +typedef short jchar; +typedef short jshort; +typedef float jfloat; +typedef double jdouble; +typedef juint jsize; +#endif + +/* moved from jni.h -- Sun's new jni.h doesn't have this anymore */ +#ifdef __cplusplus +typedef class _jobject *jref; +#else +typedef struct _jobject *jref; +#endif + +typedef unsigned char jbool; +typedef signed char jbyte; +#ifdef IS_64 /* XXX ok for alpha, but not right on all 64-bit architectures */ +typedef unsigned int juint; +typedef int jint; +#else +typedef unsigned long juint; +typedef long jint; +#endif + +/******************************************************************************* + * jlong : long long (64-bit signed integer type) support. + ******************************************************************************/ + +/* +** Bit masking macros. (n must be <= 31 to be portable) +*/ +#define JRI_BIT(n) ((juint)1 << (n)) +#define JRI_BITMASK(n) (JRI_BIT(n) - 1) + +#ifdef HAVE_LONG_LONG + +#ifdef OSF1 + +/* long is default 64-bit on OSF1, -std1 does not allow long long */ +typedef long jlong; +typedef unsigned long julong; +#define jlong_MAXINT 0x7fffffffffffffffL +#define jlong_MININT 0x8000000000000000L +#define jlong_ZERO 0x0L + +#elif (defined(WIN32) || defined(_WIN32)) + +typedef LONGLONG jlong; +typedef DWORDLONG julong; +#define jlong_MAXINT 0x7fffffffffffffffi64 +#define jlong_MININT 0x8000000000000000i64 +#define jlong_ZERO 0x0i64 + +#else + +typedef long long jlong; +typedef unsigned long long julong; +#define jlong_MAXINT 0x7fffffffffffffffLL +#define jlong_MININT 0x8000000000000000LL +#define jlong_ZERO 0x0LL + +#endif + +#define jlong_IS_ZERO(a) ((a) == 0) +#define jlong_EQ(a, b) ((a) == (b)) +#define jlong_NE(a, b) ((a) != (b)) +#define jlong_GE_ZERO(a) ((a) >= 0) +#define jlong_CMP(a, op, b) ((a) op (b)) + +#define jlong_AND(r, a, b) ((r) = (a) & (b)) +#define jlong_OR(r, a, b) ((r) = (a) | (b)) +#define jlong_XOR(r, a, b) ((r) = (a) ^ (b)) +#define jlong_OR2(r, a) ((r) = (r) | (a)) +#define jlong_NOT(r, a) ((r) = ~(a)) + +#define jlong_NEG(r, a) ((r) = -(a)) +#define jlong_ADD(r, a, b) ((r) = (a) + (b)) +#define jlong_SUB(r, a, b) ((r) = (a) - (b)) + +#define jlong_MUL(r, a, b) ((r) = (a) * (b)) +#define jlong_DIV(r, a, b) ((r) = (a) / (b)) +#define jlong_MOD(r, a, b) ((r) = (a) % (b)) + +#define jlong_SHL(r, a, b) ((r) = (a) << (b)) +#define jlong_SHR(r, a, b) ((r) = (a) >> (b)) +#define jlong_USHR(r, a, b) ((r) = (julong)(a) >> (b)) +#define jlong_ISHL(r, a, b) ((r) = ((jlong)(a)) << (b)) + +#define jlong_L2I(i, l) ((i) = (int)(l)) +#define jlong_L2UI(ui, l) ((ui) =(unsigned int)(l)) +#define jlong_L2F(f, l) ((f) = (l)) +#define jlong_L2D(d, l) ((d) = (l)) + +#define jlong_I2L(l, i) ((l) = (i)) +#define jlong_UI2L(l, ui) ((l) = (ui)) +#define jlong_F2L(l, f) ((l) = (f)) +#define jlong_D2L(l, d) ((l) = (d)) + +#define jlong_UDIVMOD(qp, rp, a, b) \ + (*(qp) = ((julong)(a) / (b)), \ + *(rp) = ((julong)(a) % (b))) + +#else /* !HAVE_LONG_LONG */ + +typedef struct { +#ifdef IS_LITTLE_ENDIAN + juint lo, hi; +#else + juint hi, lo; +#endif +} jlong; +typedef jlong julong; + +extern jlong jlong_MAXINT, jlong_MININT, jlong_ZERO; + +#define jlong_IS_ZERO(a) (((a).hi == 0) && ((a).lo == 0)) +#define jlong_EQ(a, b) (((a).hi == (b).hi) && ((a).lo == (b).lo)) +#define jlong_NE(a, b) (((a).hi != (b).hi) || ((a).lo != (b).lo)) +#define jlong_GE_ZERO(a) (((a).hi >> 31) == 0) + +/* + * NB: jlong_CMP and jlong_UCMP work only for strict relationals (<, >). + */ +#define jlong_CMP(a, op, b) (((int32)(a).hi op (int32)(b).hi) || \ + (((a).hi == (b).hi) && ((a).lo op (b).lo))) +#define jlong_UCMP(a, op, b) (((a).hi op (b).hi) || \ + (((a).hi == (b).hi) && ((a).lo op (b).lo))) + +#define jlong_AND(r, a, b) ((r).lo = (a).lo & (b).lo, \ + (r).hi = (a).hi & (b).hi) +#define jlong_OR(r, a, b) ((r).lo = (a).lo | (b).lo, \ + (r).hi = (a).hi | (b).hi) +#define jlong_XOR(r, a, b) ((r).lo = (a).lo ^ (b).lo, \ + (r).hi = (a).hi ^ (b).hi) +#define jlong_OR2(r, a) ((r).lo = (r).lo | (a).lo, \ + (r).hi = (r).hi | (a).hi) +#define jlong_NOT(r, a) ((r).lo = ~(a).lo, \ + (r).hi = ~(a).hi) + +#define jlong_NEG(r, a) ((r).lo = -(int32)(a).lo, \ + (r).hi = -(int32)(a).hi - ((r).lo != 0)) +#define jlong_ADD(r, a, b) { \ + jlong _a, _b; \ + _a = a; _b = b; \ + (r).lo = _a.lo + _b.lo; \ + (r).hi = _a.hi + _b.hi + ((r).lo < _b.lo); \ +} + +#define jlong_SUB(r, a, b) { \ + jlong _a, _b; \ + _a = a; _b = b; \ + (r).lo = _a.lo - _b.lo; \ + (r).hi = _a.hi - _b.hi - (_a.lo < _b.lo); \ +} \ + +/* + * Multiply 64-bit operands a and b to get 64-bit result r. + * First multiply the low 32 bits of a and b to get a 64-bit result in r. + * Then add the outer and inner products to r.hi. + */ +#define jlong_MUL(r, a, b) { \ + jlong _a, _b; \ + _a = a; _b = b; \ + jlong_MUL32(r, _a.lo, _b.lo); \ + (r).hi += _a.hi * _b.lo + _a.lo * _b.hi; \ +} + +/* XXX _jlong_lo16(a) = ((a) << 16 >> 16) is better on some archs (not on mips) */ +#define _jlong_lo16(a) ((a) & JRI_BITMASK(16)) +#define _jlong_hi16(a) ((a) >> 16) + +/* + * Multiply 32-bit operands a and b to get 64-bit result r. + * Use polynomial expansion based on primitive field element (1 << 16). + */ +#define jlong_MUL32(r, a, b) { \ + juint _a1, _a0, _b1, _b0, _y0, _y1, _y2, _y3; \ + _a1 = _jlong_hi16(a), _a0 = _jlong_lo16(a); \ + _b1 = _jlong_hi16(b), _b0 = _jlong_lo16(b); \ + _y0 = _a0 * _b0; \ + _y1 = _a0 * _b1; \ + _y2 = _a1 * _b0; \ + _y3 = _a1 * _b1; \ + _y1 += _jlong_hi16(_y0); /* can't carry */ \ + _y1 += _y2; /* might carry */ \ + if (_y1 < _y2) _y3 += 1 << 16; /* propagate */ \ + (r).lo = (_jlong_lo16(_y1) << 16) + _jlong_lo16(_y0); \ + (r).hi = _y3 + _jlong_hi16(_y1); \ +} + +/* + * Divide 64-bit unsigned operand a by 64-bit unsigned operand b, setting *qp + * to the 64-bit unsigned quotient, and *rp to the 64-bit unsigned remainder. + * Minimize effort if one of qp and rp is null. + */ +#define jlong_UDIVMOD(qp, rp, a, b) jlong_udivmod(qp, rp, a, b) + +extern JRI_PUBLIC_API(void) +jlong_udivmod(julong *qp, julong *rp, julong a, julong b); + +#define jlong_DIV(r, a, b) { \ + jlong _a, _b; \ + juint _negative = (int32)(a).hi < 0; \ + if (_negative) { \ + jlong_NEG(_a, a); \ + } else { \ + _a = a; \ + } \ + if ((int32)(b).hi < 0) { \ + _negative ^= 1; \ + jlong_NEG(_b, b); \ + } else { \ + _b = b; \ + } \ + jlong_UDIVMOD(&(r), 0, _a, _b); \ + if (_negative) \ + jlong_NEG(r, r); \ +} + +#define jlong_MOD(r, a, b) { \ + jlong _a, _b; \ + juint _negative = (int32)(a).hi < 0; \ + if (_negative) { \ + jlong_NEG(_a, a); \ + } else { \ + _a = a; \ + } \ + if ((int32)(b).hi < 0) { \ + jlong_NEG(_b, b); \ + } else { \ + _b = b; \ + } \ + jlong_UDIVMOD(0, &(r), _a, _b); \ + if (_negative) \ + jlong_NEG(r, r); \ +} + +/* + * NB: b is a juint, not jlong or julong, for the shift ops. + */ +#define jlong_SHL(r, a, b) { \ + if (b) { \ + jlong _a; \ + _a = a; \ + if ((b) < 32) { \ + (r).lo = _a.lo << (b); \ + (r).hi = (_a.hi << (b)) | (_a.lo >> (32 - (b))); \ + } else { \ + (r).lo = 0; \ + (r).hi = _a.lo << ((b) & 31); \ + } \ + } else { \ + (r) = (a); \ + } \ +} + +/* a is an int32, b is int32, r is jlong */ +#define jlong_ISHL(r, a, b) { \ + if (b) { \ + jlong _a; \ + _a.lo = (a); \ + _a.hi = 0; \ + if ((b) < 32) { \ + (r).lo = (a) << (b); \ + (r).hi = ((a) >> (32 - (b))); \ + } else { \ + (r).lo = 0; \ + (r).hi = (a) << ((b) & 31); \ + } \ + } else { \ + (r).lo = (a); \ + (r).hi = 0; \ + } \ +} + +#define jlong_SHR(r, a, b) { \ + if (b) { \ + jlong _a; \ + _a = a; \ + if ((b) < 32) { \ + (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b)); \ + (r).hi = (int32)_a.hi >> (b); \ + } else { \ + (r).lo = (int32)_a.hi >> ((b) & 31); \ + (r).hi = (int32)_a.hi >> 31; \ + } \ + } else { \ + (r) = (a); \ + } \ +} + +#define jlong_USHR(r, a, b) { \ + if (b) { \ + jlong _a; \ + _a = a; \ + if ((b) < 32) { \ + (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b)); \ + (r).hi = _a.hi >> (b); \ + } else { \ + (r).lo = _a.hi >> ((b) & 31); \ + (r).hi = 0; \ + } \ + } else { \ + (r) = (a); \ + } \ +} + +#define jlong_L2I(i, l) ((i) = (l).lo) +#define jlong_L2UI(ui, l) ((ui) = (l).lo) +#define jlong_L2F(f, l) { double _d; jlong_L2D(_d, l); (f) = (float) _d; } + +#define jlong_L2D(d, l) { \ + int32 _negative; \ + jlong _absval; \ + \ + _negative = (l).hi >> 31; \ + if (_negative) { \ + jlong_NEG(_absval, l); \ + } else { \ + _absval = l; \ + } \ + (d) = (double)_absval.hi * 4.294967296e9 + _absval.lo; \ + if (_negative) \ + (d) = -(d); \ +} + +#define jlong_I2L(l, i) ((l).hi = (i) >> 31, (l).lo = (i)) +#define jlong_UI2L(l, ui) ((l).hi = 0, (l).lo = (ui)) +#define jlong_F2L(l, f) { double _d = (double) f; jlong_D2L(l, _d); } + +#define jlong_D2L(l, d) { \ + int _negative; \ + double _absval, _d_hi; \ + jlong _lo_d; \ + \ + _negative = ((d) < 0); \ + _absval = _negative ? -(d) : (d); \ + \ + (l).hi = (juint)(_absval / 4.294967296e9); \ + (l).lo = 0; \ + jlong_L2D(_d_hi, l); \ + _absval -= _d_hi; \ + _lo_d.hi = 0; \ + if (_absval < 0) { \ + _lo_d.lo = (juint) -_absval; \ + jlong_SUB(l, l, _lo_d); \ + } else { \ + _lo_d.lo = (juint) _absval; \ + jlong_ADD(l, l, _lo_d); \ + } \ + \ + if (_negative) \ + jlong_NEG(l, l); \ +} + +#endif /* !HAVE_LONG_LONG */ + +/******************************************************************************/ + +#ifdef HAVE_ALIGNED_LONGLONGS +#define JRI_GET_INT64(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \ + ((_t).x[1] = ((jint*)(_addr))[1]), \ + (_t).l ) +#define JRI_SET_INT64(_t, _addr, _v) ( (_t).l = (_v), \ + ((jint*)(_addr))[0] = (_t).x[0], \ + ((jint*)(_addr))[1] = (_t).x[1] ) +#else +#define JRI_GET_INT64(_t,_addr) (*(jlong*)(_addr)) +#define JRI_SET_INT64(_t, _addr, _v) (*(jlong*)(_addr) = (_v)) +#endif + +/* If double's must be aligned on doubleword boundaries then define this */ +#ifdef HAVE_ALIGNED_DOUBLES +#define JRI_GET_DOUBLE(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \ + ((_t).x[1] = ((jint*)(_addr))[1]), \ + (_t).d ) +#define JRI_SET_DOUBLE(_t, _addr, _v) ( (_t).d = (_v), \ + ((jint*)(_addr))[0] = (_t).x[0], \ + ((jint*)(_addr))[1] = (_t).x[1] ) +#else +#define JRI_GET_DOUBLE(_t,_addr) (*(jdouble*)(_addr)) +#define JRI_SET_DOUBLE(_t, _addr, _v) (*(jdouble*)(_addr) = (_v)) +#endif + +/******************************************************************************/ +#ifdef __cplusplus +} +#endif +#endif /* JRI_MD_H */ +/******************************************************************************/ diff --git a/nsplugins/sdk/jritypes.h b/nsplugins/sdk/jritypes.h new file mode 100644 index 000000000..ddeb6331c --- /dev/null +++ b/nsplugins/sdk/jritypes.h @@ -0,0 +1,243 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** 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.org 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 ***** */ + +/******************************************************************************* + * Java Runtime Interface + ******************************************************************************/ + +#ifndef JRITYPES_H +#define JRITYPES_H + +#include "jri_md.h" +#include "jni.h" +#include <stddef.h> +#include <stdlib.h> +#include <stdarg.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/******************************************************************************* + * Types + ******************************************************************************/ + +struct JRIEnvInterface; + +typedef void* JRIRef; +typedef void* JRIGlobalRef; + +typedef jint JRIFieldID; +typedef jint JRIMethodID; + +/* synonyms: */ +typedef JRIGlobalRef jglobal; + +typedef union JRIValue { + jbool z; + jbyte b; + jchar c; + jshort s; + jint i; + jlong l; + jfloat f; + jdouble d; + jref r; +} JRIValue; + +typedef enum JRIBoolean { + JRIFalse = 0, + JRITrue = 1 +} JRIBoolean; + +typedef enum JRIConstant { + JRIUninitialized = -1 +} JRIConstant; + +/* convenience types (these must be distinct struct types for c++ overloading): */ +#if 0 /* now in jni.h */ +typedef struct jbooleanArrayStruct* jbooleanArray; +typedef struct jbyteArrayStruct* jbyteArray; +typedef struct jcharArrayStruct* jcharArray; +typedef struct jshortArrayStruct* jshortArray; +typedef struct jintArrayStruct* jintArray; +typedef struct jlongArrayStruct* jlongArray; +typedef struct jfloatArrayStruct* jfloatArray; +typedef struct jdoubleArrayStruct* jdoubleArray; +typedef struct jobjectArrayStruct* jobjectArray; +#endif +typedef struct jstringArrayStruct* jstringArray; +typedef struct jarrayArrayStruct* jarrayArray; + +#define JRIConstructorMethodName "<init>" + +/******************************************************************************* + * Signature Construction Macros + ******************************************************************************/ + +/* +** These macros can be used to construct signature strings. Hopefully their names +** are a little easier to remember than the single character they correspond to. +** For example, to specify the signature of the method: +** +** public int read(byte b[], int off, int len); +** +** you could write something like this in C: +** +** char* readSig = JRISigMethod(JRISigArray(JRISigByte) +** JRISigInt +** JRISigInt) JRISigInt; +** +** Of course, don't put commas between the types. +*/ +#define JRISigArray(T) "[" T +#define JRISigByte "B" +#define JRISigChar "C" +#define JRISigClass(name) "L" name ";" +#define JRISigFloat "F" +#define JRISigDouble "D" +#define JRISigMethod(args) "(" args ")" +#define JRISigNoArgs "" +#define JRISigInt "I" +#define JRISigLong "J" +#define JRISigShort "S" +#define JRISigVoid "V" +#define JRISigBoolean "Z" + +/******************************************************************************* + * Environments + ******************************************************************************/ + +extern JRI_PUBLIC_API(const struct JRIEnvInterface**) +JRI_GetCurrentEnv(void); + +/******************************************************************************* + * Specific Scalar Array Types + ******************************************************************************/ + +/* +** The JRI Native Method Interface does not support boolean arrays. This +** is to allow Java runtime implementations to optimize boolean array +** storage. Using the ScalarArray operations on boolean arrays is bound +** to fail, so convert any boolean arrays to byte arrays in Java before +** passing them to a native method. +*/ + +#define JRI_NewByteArray(env, length, initialValues) \ + JRI_NewScalarArray(env, length, JRISigByte, (jbyte*)(initialValues)) +#define JRI_GetByteArrayLength(env, array) \ + JRI_GetScalarArrayLength(env, array) +#define JRI_GetByteArrayElements(env, array) \ + JRI_GetScalarArrayElements(env, array) + +#define JRI_NewCharArray(env, length, initialValues) \ + JRI_NewScalarArray(env, ((length) * sizeof(jchar)), JRISigChar, (jbyte*)(initialValues)) +#define JRI_GetCharArrayLength(env, array) \ + JRI_GetScalarArrayLength(env, array) +#define JRI_GetCharArrayElements(env, array) \ + ((jchar*)JRI_GetScalarArrayElements(env, array)) + +#define JRI_NewShortArray(env, length, initialValues) \ + JRI_NewScalarArray(env, ((length) * sizeof(jshort)), JRISigShort, (jbyte*)(initialValues)) +#define JRI_GetShortArrayLength(env, array) \ + JRI_GetScalarArrayLength(env, array) +#define JRI_GetShortArrayElements(env, array) \ + ((jshort*)JRI_GetScalarArrayElements(env, array)) + +#define JRI_NewIntArray(env, length, initialValues) \ + JRI_NewScalarArray(env, ((length) * sizeof(jint)), JRISigInt, (jbyte*)(initialValues)) +#define JRI_GetIntArrayLength(env, array) \ + JRI_GetScalarArrayLength(env, array) +#define JRI_GetIntArrayElements(env, array) \ + ((jint*)JRI_GetScalarArrayElements(env, array)) + +#define JRI_NewLongArray(env, length, initialValues) \ + JRI_NewScalarArray(env, ((length) * sizeof(jlong)), JRISigLong, (jbyte*)(initialValues)) +#define JRI_GetLongArrayLength(env, array) \ + JRI_GetScalarArrayLength(env, array) +#define JRI_GetLongArrayElements(env, array) \ + ((jlong*)JRI_GetScalarArrayElements(env, array)) + +#define JRI_NewFloatArray(env, length, initialValues) \ + JRI_NewScalarArray(env, ((length) * sizeof(jfloat)), JRISigFloat, (jbyte*)(initialValues)) +#define JRI_GetFloatArrayLength(env, array) \ + JRI_GetScalarArrayLength(env, array) +#define JRI_GetFloatArrayElements(env, array) \ + ((jfloat*)JRI_GetScalarArrayElements(env, array)) + +#define JRI_NewDoubleArray(env, length, initialValues) \ + JRI_NewScalarArray(env, ((length) * sizeof(jdouble)), JRISigDouble, (jbyte*)(initialValues)) +#define JRI_GetDoubleArrayLength(env, array) \ + JRI_GetScalarArrayLength(env, array) +#define JRI_GetDoubleArrayElements(env, array) \ + ((jdouble*)JRI_GetScalarArrayElements(env, array)) + +/******************************************************************************/ +/* +** JDK Stuff -- This stuff is still needed while we're using the JDK +** dynamic linking strategy to call native methods. +*/ + +typedef union JRI_JDK_stack_item { + /* Non pointer items */ + jint i; + jfloat f; + jint o; + /* Pointer items */ + void *h; + void *p; + unsigned char *addr; +#ifdef IS_64 + double d; + long l; /* == 64bits! */ +#endif +} JRI_JDK_stack_item; + +typedef union JRI_JDK_Java8Str { + jint x[2]; + jdouble d; + jlong l; + void *p; + float f; +} JRI_JDK_Java8; + +/******************************************************************************/ +#ifdef __cplusplus +} +#endif +#endif /* JRITYPES_H */ +/******************************************************************************/ diff --git a/nsplugins/sdk/npapi.h b/nsplugins/sdk/npapi.h new file mode 100644 index 000000000..16c71b97a --- /dev/null +++ b/nsplugins/sdk/npapi.h @@ -0,0 +1,730 @@ +/* -*- Mode: C; tab-width: 4; 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.org 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 ***** */ + + +/* + * npapi.h + * Netscape client plug-in API spec + */ + +#ifndef _NPAPI_H_ +#define _NPAPI_H_ + +#ifdef __OS2__ +#pragma pack(1) +#endif + +#include "prtypes.h" +/* Copied from xp_core.h */ +/* removed #ifdef for hpux defined in /usr/include/model.h */ +#ifndef XP_MAC +#ifndef _INT16 +#define _INT16 +#endif +#ifndef _INT32 +#define _INT32 +#endif +#ifndef _UINT16 +#define _UINT16 +#endif +#ifndef _UINT32 +#define _UINT32 +#endif +#endif + +/* + * NO_NSPR_10_SUPPORT disables the inclusion + * of obsolete/protypes.h, whose int16, uint16, + * int32, and uint32 typedefs conflict with those + * in this file. + */ +#ifndef NO_NSPR_10_SUPPORT +#define NO_NSPR_10_SUPPORT +#endif +#ifdef OJI +#include "jri.h" /* Java Runtime Interface */ +#endif + +#if defined (__OS2__ ) || defined (OS2) +# ifndef XP_OS2 +# define XP_OS2 1 +# endif /* XP_OS2 */ +#endif /* __OS2__ */ + +#ifdef _WINDOWS +# include <windef.h> +# ifndef XP_WIN +# define XP_WIN 1 +# endif /* XP_WIN */ +#endif /* _WINDOWS */ + +#ifdef __MWERKS__ +# define _declspec __declspec +# ifdef macintosh +# ifndef XP_MAC +# define XP_MAC 1 +# endif /* XP_MAC */ +# endif /* macintosh */ +# ifdef __INTEL__ +# undef NULL +# ifndef XP_WIN +# define XP_WIN 1 +# endif /* XP_WIN */ +# endif /* __INTEL__ */ +#endif /* __MWERKS__ */ + +#if defined(XP_MAC) || defined(XP_MACOSX) + #include <Quickdraw.h> + #include <Events.h> +#endif + +#if defined(XP_UNIX) +# include <stdio.h> +# if defined(MOZ_X11) +# include <X11/Xlib.h> +# include <X11/Xutil.h> +# endif +#endif + +/*----------------------------------------------------------------------*/ +/* Plugin Version Constants */ +/*----------------------------------------------------------------------*/ + +#define NP_VERSION_MAJOR 0 +#define NP_VERSION_MINOR 13 + + +/* The OS/2 version of Netscape uses RC_DATA to define the + mime types, file extensions, etc that are required. + Use a vertical bar to separate types, end types with \0. + FileVersion and ProductVersion are 32bit ints, all other + entries are strings the MUST be terminated wwith a \0. + +AN EXAMPLE: + +RCDATA NP_INFO_ProductVersion { 1,0,0,1,} + +RCDATA NP_INFO_MIMEType { "video/x-video|", + "video/x-flick\0" } +RCDATA NP_INFO_FileExtents { "avi|", + "flc\0" } +RCDATA NP_INFO_FileOpenName{ "MMOS2 video player(*.avi)|", + "MMOS2 Flc/Fli player(*.flc)\0" } + +RCDATA NP_INFO_FileVersion { 1,0,0,1 } +RCDATA NP_INFO_CompanyName { "Netscape Communications\0" } +RCDATA NP_INFO_FileDescription { "NPAVI32 Extension DLL\0" +RCDATA NP_INFO_InternalName { "NPAVI32\0" ) +RCDATA NP_INFO_LegalCopyright { "Copyright Netscape Communications \251 1996\0" +RCDATA NP_INFO_OriginalFilename { "NVAPI32.DLL" } +RCDATA NP_INFO_ProductName { "NPAVI32 Dynamic Link Library\0" } + +*/ + + +/* RC_DATA types for version info - required */ +#define NP_INFO_ProductVersion 1 +#define NP_INFO_MIMEType 2 +#define NP_INFO_FileOpenName 3 +#define NP_INFO_FileExtents 4 + +/* RC_DATA types for version info - used if found */ +#define NP_INFO_FileDescription 5 +#define NP_INFO_ProductName 6 + +/* RC_DATA types for version info - optional */ +#define NP_INFO_CompanyName 7 +#define NP_INFO_FileVersion 8 +#define NP_INFO_InternalName 9 +#define NP_INFO_LegalCopyright 10 +#define NP_INFO_OriginalFilename 11 + +#ifndef RC_INVOKED + + + +/*----------------------------------------------------------------------*/ +/* Definition of Basic Types */ +/*----------------------------------------------------------------------*/ + +#ifndef _UINT16 +typedef unsigned short uint16; +#endif + +#ifndef _UINT32 +# if defined(__alpha) || defined(_AIX) || defined(__x86_64__) || defined(__LP64__) || defined(__amd64__) +typedef unsigned int uint32; +# else +typedef unsigned long uint32; +# endif +#endif + +/* + * AIX defines these in sys/inttypes.h included from sys/types.h + */ +#ifndef AIX +#ifndef _INT16 +typedef short int16; +#endif + +#ifndef _INT32 +# if defined(__alpha) || defined(_AIX) || defined(__x86_64__) || defined(__LP64__) || defined(__amd64__) +typedef int int32; +# else +typedef long int32; +# endif +#endif +#endif + +#ifndef FALSE +#define FALSE (0) +#endif +#ifndef TRUE +#define TRUE (1) +#endif +#ifndef NULL +#define NULL (0L) +#endif + +typedef unsigned char NPBool; +typedef int16 NPError; +typedef int16 NPReason; +typedef char* NPMIMEType; + + + +/*----------------------------------------------------------------------*/ +/* Structures and definitions */ +/*----------------------------------------------------------------------*/ + +#ifdef XP_MAC +#pragma options align=mac68k +#endif + +/* + * NPP is a plug-in's opaque instance handle + */ +typedef struct _NPP +{ + void* pdata; /* plug-in private data */ + void* ndata; /* netscape private data */ +} NPP_t; + +typedef NPP_t* NPP; + + +typedef struct _NPStream +{ + void* pdata; /* plug-in private data */ + void* ndata; /* netscape private data */ + const char* url; + uint32 end; + uint32 lastmodified; + void* notifyData; + const char* headers; /* Response headers from host. + * Exists only for >= NPVERS_HAS_RESPONSE_HEADERS. + * Used for HTTP only; NULL for non-HTTP. + * Available from NPP_NewStream onwards. + * Plugin should copy this data before storing it. + * Includes HTTP status line and all headers, + * preferably verbatim as received from server, + * headers formatted as in HTTP ("Header: Value"), + * and newlines (\n, NOT \r\n) separating lines. + * Terminated by \n\0 (NOT \n\n\0). */ +} NPStream; + + +typedef struct _NPByteRange +{ + int32 offset; /* negative offset means from the end */ + uint32 length; + struct _NPByteRange* next; +} NPByteRange; + + +typedef struct _NPSavedData +{ + int32 len; + void* buf; +} NPSavedData; + + +typedef struct _NPRect +{ + uint16 top; + uint16 left; + uint16 bottom; + uint16 right; +} NPRect; + +typedef struct _NPSize +{ + int32 width; + int32 height; +} NPSize; + +#ifdef XP_UNIX +/* + * Unix specific structures and definitions + */ + +/* + * Callback Structures. + * + * These are used to pass additional platform specific information. + */ +enum { + NP_SETWINDOW = 1, + NP_PRINT +}; + +typedef struct +{ + int32 type; +} NPAnyCallbackStruct; + +typedef struct +{ + int32 type; +#ifdef MOZ_X11 + Display* display; + Visual* visual; + Colormap colormap; + unsigned int depth; +#endif +} NPSetWindowCallbackStruct; + +typedef struct +{ + int32 type; + FILE* fp; +} NPPrintCallbackStruct; + +#endif /* XP_UNIX */ + + +/* + * The following masks are applied on certain platforms to NPNV and + * NPPV selectors that pass around pointers to COM interfaces. Newer + * compilers on some platforms may generate vtables that are not + * compatible with older compilers. To prevent older plugins from + * not understanding a new browser's ABI, these masks change the + * values of those selectors on those platforms. To remain backwards + * compatible with differenet versions of the browser, plugins can + * use these masks to dynamically determine and use the correct C++ + * ABI that the browser is expecting. This does not apply to Windows + * as Microsoft's COM ABI will likely not change. + */ + +#define NP_ABI_GCC3_MASK 0x10000000 +/* + * gcc 3.x generated vtables on UNIX and OSX are incompatible with + * previous compilers. + */ +#if (defined (XP_UNIX) && defined(__GNUC__) && (__GNUC__ >= 3)) +#define _NP_ABI_MIXIN_FOR_GCC3 NP_ABI_GCC3_MASK +#else +#define _NP_ABI_MIXIN_FOR_GCC3 0 +#endif + + +#define NP_ABI_MACHO_MASK 0x01000000 +/* + * On OSX, the Mach-O executable format is significantly + * different than CFM. In addition to having a different + * C++ ABI, it also has has different C calling convention. + * You must use glue code when calling between CFM and + * Mach-O C functions. + */ +#if (defined(TARGET_RT_MAC_MACHO)) +#define _NP_ABI_MIXIN_FOR_MACHO NP_ABI_MACHO_MASK +#else +#define _NP_ABI_MIXIN_FOR_MACHO 0 +#endif + + +#define NP_ABI_MASK (_NP_ABI_MIXIN_FOR_GCC3 | _NP_ABI_MIXIN_FOR_MACHO) + +/* + * List of variable names for which NPP_GetValue shall be implemented + */ +typedef enum { + NPPVpluginNameString = 1, + NPPVpluginDescriptionString, + NPPVpluginWindowBool, + NPPVpluginTransparentBool, + NPPVjavaClass, /* Not implemented in Mozilla 1.0 */ + NPPVpluginWindowSize, + NPPVpluginTimerInterval, + + NPPVpluginScriptableInstance = (10 | NP_ABI_MASK), + NPPVpluginScriptableIID = 11, + + /* 12 and over are available on Mozilla builds starting with 0.9.9 */ + NPPVjavascriptPushCallerBool = 12, + NPPVpluginKeepLibraryInMemory = 13, /* available in Mozilla 1.0 */ + NPPVpluginNeedsXEmbed = 14 +} NPPVariable; + +/* + * List of variable names for which NPN_GetValue is implemented by Mozilla + */ +typedef enum { + NPNVxDisplay = 1, + NPNVxtAppContext, + NPNVnetscapeWindow, + NPNVjavascriptEnabledBool, + NPNVasdEnabledBool, + NPNVisOfflineBool, + + /* 10 and over are available on Mozilla builds starting with 0.9.4 */ + NPNVserviceManager = (10 | NP_ABI_MASK), + NPNVDOMElement = (11 | NP_ABI_MASK), /* available in Mozilla 1.2 */ + NPNVDOMWindow = (12 | NP_ABI_MASK), + NPNVToolkit = (13 | NP_ABI_MASK), + NPNVSupportsXEmbedBool = 14 +} NPNVariable; + +/* + * The type of Tookkit the widgets use + */ +typedef enum { + NPNVGtk12 = 1, + NPNVGtk2 +} NPNToolkitType; + +/* + * The type of a NPWindow - it specifies the type of the data structure + * returned in the window field. + */ +typedef enum { + NPWindowTypeWindow = 1, + NPWindowTypeDrawable +} NPWindowType; + +typedef struct _NPWindow +{ + void* window; /* Platform specific window handle */ + /* OS/2: x - Position of bottom left corner */ + /* OS/2: y - relative to visible netscape window */ + int32 x; /* Position of top left corner relative */ + int32 y; /* to a netscape page. */ + uint32 width; /* Maximum window size */ + uint32 height; + NPRect clipRect; /* Clipping rectangle in port coordinates */ + /* Used by MAC only. */ +#if defined(XP_UNIX) && !defined(XP_MACOSX) + void * ws_info; /* Platform-dependent additional data */ +#endif /* XP_UNIX */ + NPWindowType type; /* Is this a window or a drawable? */ +} NPWindow; + + +typedef struct _NPFullPrint +{ + NPBool pluginPrinted;/* Set TRUE if plugin handled fullscreen printing */ + NPBool printOne; /* TRUE if plugin should print one copy to default printer */ + void* platformPrint; /* Platform-specific printing info */ +} NPFullPrint; + +typedef struct _NPEmbedPrint +{ + NPWindow window; + void* platformPrint; /* Platform-specific printing info */ +} NPEmbedPrint; + +typedef struct _NPPrint +{ + uint16 mode; /* NP_FULL or NP_EMBED */ + union + { + NPFullPrint fullPrint; /* if mode is NP_FULL */ + NPEmbedPrint embedPrint; /* if mode is NP_EMBED */ + } print; +} NPPrint; + +#if defined(XP_MAC) || defined(XP_MACOSX) +typedef EventRecord NPEvent; +#elif defined(XP_WIN) +typedef struct _NPEvent +{ + uint16 event; + uint32 wParam; + uint32 lParam; +} NPEvent; +#elif defined(XP_OS2) +typedef struct _NPEvent +{ + uint32 event; + uint32 wParam; + uint32 lParam; +} NPEvent; +#elif defined (XP_UNIX) && defined(MOZ_X11) +typedef XEvent NPEvent; +#else +typedef void* NPEvent; +#endif /* XP_MAC */ + +#if defined(XP_MAC) || defined(XP_MACOSX) +typedef RgnHandle NPRegion; +#elif defined(XP_WIN) +typedef HRGN NPRegion; +#elif defined(XP_UNIX) && defined(MOZ_X11) +typedef Region NPRegion; +#else +typedef void *NPRegion; +#endif /* XP_MAC */ + +#if defined(XP_MAC) || defined(XP_MACOSX) +/* + * Mac-specific structures and definitions. + */ + +typedef struct NP_Port +{ + CGrafPtr port; /* Grafport */ + int32 portx; /* position inside the topmost window */ + int32 porty; +} NP_Port; + +/* + * Non-standard event types that can be passed to HandleEvent + */ + +enum NPEventType { + NPEventType_GetFocusEvent = (osEvt + 16), + NPEventType_LoseFocusEvent, + NPEventType_AdjustCursorEvent, + NPEventType_MenuCommandEvent, + NPEventType_ClippingChangedEvent, + NPEventType_ScrollingBeginsEvent = 1000, + NPEventType_ScrollingEndsEvent +}; + +#ifdef OBSOLETE +#define getFocusEvent (osEvt + 16) +#define loseFocusEvent (osEvt + 17) +#define adjustCursorEvent (osEvt + 18) +#endif +#endif /* XP_MAC */ + +/* + * Values for mode passed to NPP_New: + */ +#define NP_EMBED 1 +#define NP_FULL 2 + +/* + * Values for stream type passed to NPP_NewStream: + */ +#define NP_NORMAL 1 +#define NP_SEEK 2 +#define NP_ASFILE 3 +#define NP_ASFILEONLY 4 + +#define NP_MAXREADY (((unsigned)(~0)<<1)>>1) + +#ifdef XP_MAC +#pragma options align=reset +#endif + + +/*----------------------------------------------------------------------*/ +/* Error and Reason Code definitions */ +/*----------------------------------------------------------------------*/ + +/* + * Values of type NPError: + */ +#define NPERR_BASE 0 +#define NPERR_NO_ERROR (NPERR_BASE + 0) +#define NPERR_GENERIC_ERROR (NPERR_BASE + 1) +#define NPERR_INVALID_INSTANCE_ERROR (NPERR_BASE + 2) +#define NPERR_INVALID_FUNCTABLE_ERROR (NPERR_BASE + 3) +#define NPERR_MODULE_LOAD_FAILED_ERROR (NPERR_BASE + 4) +#define NPERR_OUT_OF_MEMORY_ERROR (NPERR_BASE + 5) +#define NPERR_INVALID_PLUGIN_ERROR (NPERR_BASE + 6) +#define NPERR_INVALID_PLUGIN_DIR_ERROR (NPERR_BASE + 7) +#define NPERR_INCOMPATIBLE_VERSION_ERROR (NPERR_BASE + 8) +#define NPERR_INVALID_PARAM (NPERR_BASE + 9) +#define NPERR_INVALID_URL (NPERR_BASE + 10) +#define NPERR_FILE_NOT_FOUND (NPERR_BASE + 11) +#define NPERR_NO_DATA (NPERR_BASE + 12) +#define NPERR_STREAM_NOT_SEEKABLE (NPERR_BASE + 13) + +/* + * Values of type NPReason: + */ +#define NPRES_BASE 0 +#define NPRES_DONE (NPRES_BASE + 0) +#define NPRES_NETWORK_ERR (NPRES_BASE + 1) +#define NPRES_USER_BREAK (NPRES_BASE + 2) + +/* + * Don't use these obsolete error codes any more. + */ +#define NP_NOERR NP_NOERR_is_obsolete_use_NPERR_NO_ERROR +#define NP_EINVAL NP_EINVAL_is_obsolete_use_NPERR_GENERIC_ERROR +#define NP_EABORT NP_EABORT_is_obsolete_use_NPRES_USER_BREAK + +/* + * Version feature information + */ +#define NPVERS_HAS_STREAMOUTPUT 8 +#define NPVERS_HAS_NOTIFICATION 9 +#define NPVERS_HAS_LIVECONNECT 9 +#define NPVERS_WIN16_HAS_LIVECONNECT 9 +#define NPVERS_68K_HAS_LIVECONNECT 11 +#define NPVERS_HAS_WINDOWLESS 11 +#define NPVERS_HAS_XPCONNECT_SCRIPTING 13 +// Trinity note: we claim 13 right now, though we do +// have response_headers. +#define NPVERS_HAS_NPRUNTIME_SCRIPTING 14 +#define NPVERS_HAS_FORM_VALUES 15 +#define NPVERS_HAS_POPUPS_ENABLED_STATE 16 +#define NPVERS_HAS_RESPONSE_HEADERS 17 +#define NPVERS_HAS_NPOBJECT_ENUM 18 +#define NPVERS_HAS_PLUGIN_THREAD_ASYNC_CALL 19 +#define NPVERS_HAS_ALL_NETWORK_STREAMS 20 +#define NPVERS_HAS_URL_AND_AUTH_INFO 21 +#define NPVERS_HAS_PRIVATE_MODE 22 +#define NPVERS_MACOSX_HAS_COCOA_EVENTS 23 +#define NPVERS_HAS_ADVANCED_KEY_HANDLING 25 +#define NPVERS_HAS_URL_REDIRECT_HANDLING 26 +#define NPVERS_HAS_CLEAR_SITE_DATA 27 + +/*----------------------------------------------------------------------*/ +/* Function Prototypes */ +/*----------------------------------------------------------------------*/ + +#if defined(_WINDOWS) && !defined(WIN32) +#define NP_LOADDS _loadds +#else +#if defined(__OS2__) +#define NP_LOADDS _System +#else +#define NP_LOADDS +#endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * NPP_* functions are provided by the plugin and called by the navigator. + */ + +#ifdef XP_UNIX +char* NPP_GetMIMEDescription(void); +#endif /* XP_UNIX */ + +NPError NP_LOADDS NPP_Initialize(void); +void NP_LOADDS NPP_Shutdown(void); +NPError NP_LOADDS NPP_New(NPMIMEType pluginType, NPP instance, + uint16 mode, int16 argc, char* argn[], + char* argv[], NPSavedData* saved); +NPError NP_LOADDS NPP_Destroy(NPP instance, NPSavedData** save); +NPError NP_LOADDS NPP_SetWindow(NPP instance, NPWindow* window); +NPError NP_LOADDS NPP_NewStream(NPP instance, NPMIMEType type, + NPStream* stream, NPBool seekable, + uint16* stype); +NPError NP_LOADDS NPP_DestroyStream(NPP instance, NPStream* stream, + NPReason reason); +int32 NP_LOADDS NPP_WriteReady(NPP instance, NPStream* stream); +int32 NP_LOADDS NPP_Write(NPP instance, NPStream* stream, int32 offset, + int32 len, void* buffer); +void NP_LOADDS NPP_StreamAsFile(NPP instance, NPStream* stream, + const char* fname); +void NP_LOADDS NPP_Print(NPP instance, NPPrint* platformPrint); +int16 NP_LOADDS NPP_HandleEvent(NPP instance, void* event); +void NP_LOADDS NPP_URLNotify(NPP instance, const char* url, + NPReason reason, void* notifyData); +#ifdef OJI +jref NP_LOADDS NPP_GetJavaClass(void); +#endif +NPError NP_LOADDS NPP_GetValue(NPP instance, NPPVariable variable, void *value); +NPError NP_LOADDS NPP_SetValue(NPP instance, NPNVariable variable, void *value); + +/* + * NPN_* functions are provided by the navigator and called by the plugin. + */ +void NP_LOADDS NPN_Version(int* plugin_major, int* plugin_minor, + int* netscape_major, int* netscape_minor); +NPError NP_LOADDS NPN_GetURLNotify(NPP instance, const char* url, + const char* target, void* notifyData); +NPError NP_LOADDS NPN_GetURL(NPP instance, const char* url, + const char* target); +NPError NP_LOADDS NPN_PostURLNotify(NPP instance, const char* url, + const char* target, uint32 len, + const char* buf, NPBool file, + void* notifyData); +NPError NP_LOADDS NPN_PostURL(NPP instance, const char* url, + const char* target, uint32 len, + const char* buf, NPBool file); +NPError NP_LOADDS NPN_RequestRead(NPStream* stream, NPByteRange* rangeList); +NPError NP_LOADDS NPN_NewStream(NPP instance, NPMIMEType type, + const char* target, NPStream** stream); +int32 NP_LOADDS NPN_Write(NPP instance, NPStream* stream, int32 len, void* buffer); +NPError NP_LOADDS NPN_DestroyStream(NPP instance, NPStream* stream, NPReason reason); +void NP_LOADDS NPN_Status(NPP instance, const char* message); +const char* NP_LOADDS NPN_UserAgent(NPP instance); +void* NP_LOADDS NPN_MemAlloc(uint32 size); +void NP_LOADDS NPN_MemFree(void* ptr); +uint32 NP_LOADDS NPN_MemFlush(uint32 size); +void NP_LOADDS NPN_ReloadPlugins(NPBool reloadPages); +#ifdef OJI +JRIEnv* NP_LOADDS NPN_GetJavaEnv(void); +jref NP_LOADDS NPN_GetJavaPeer(NPP instance); +#endif +NPError NP_LOADDS NPN_GetValue(NPP instance, NPNVariable variable, void *value); +NPError NP_LOADDS NPN_SetValue(NPP instance, NPPVariable variable, void *value); +void NP_LOADDS NPN_InvalidateRect(NPP instance, NPRect *invalidRect); +void NP_LOADDS NPN_InvalidateRegion(NPP instance, NPRegion invalidRegion); +void NP_LOADDS NPN_ForceRedraw(NPP instance); + +#ifdef __cplusplus +} /* end extern "C" */ +#endif + +#endif /* RC_INVOKED */ +#ifdef __OS2__ +#pragma pack() +#endif + +#endif /* _NPAPI_H_ */ diff --git a/nsplugins/sdk/npruntime.h b/nsplugins/sdk/npruntime.h new file mode 100644 index 000000000..45f3f0a9a --- /dev/null +++ b/nsplugins/sdk/npruntime.h @@ -0,0 +1,399 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Copyright � 2004, Apple Computer, Inc. and The Mozilla Foundation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the names of Apple Computer, Inc. ("Apple") or The Mozilla + * Foundation ("Mozilla") nor the names of their contributors may be used + * to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY APPLE, MOZILLA AND THEIR CONTRIBUTORS "AS + * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE, MOZILLA OR + * THEIR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Revision 1 (March 4, 2004): + * Initial proposal. + * + * Revision 2 (March 10, 2004): + * All calls into script were made asynchronous. Results are + * provided via the NPScriptResultFunctionPtr callback. + * + * Revision 3 (March 10, 2004): + * Corrected comments to not refer to class retain/release FunctionPtrs. + * + * Revision 4 (March 11, 2004): + * Added additional convenience NPN_SetExceptionWithUTF8(). + * Changed NPHasPropertyFunctionPtr and NPHasMethodFunctionPtr to take NPClass + * pointers instead of NPObject pointers. + * Added NPIsValidIdentifier(). + * + * Revision 5 (March 17, 2004): + * Added context parameter to result callbacks from ScriptObject functions. + * + * Revision 6 (March 29, 2004): + * Renamed functions implemented by user agent to NPN_*. Removed _ from + * type names. + * Renamed "JavaScript" types to "Script". + * + * Revision 7 (April 21, 2004): + * NPIdentifier becomes a void*, was int32_t + * Remove NP_IsValidIdentifier, renamed NP_IdentifierFromUTF8 to NP_GetIdentifier + * Added NPVariant and modified functions to use this new type. + * + * Revision 8 (July 9, 2004): + * Updated to joint Apple-Mozilla license. + * + */ +#ifndef _NP_RUNTIME_H_ +#define _NP_RUNTIME_H_ + +#include <tqglobal.h> +typedef TQ_UINT32 uint32_t; + +#ifdef __cplusplus +extern "C" { +#endif + + +/* + This API is used to facilitate binding code written in C to script + objects. The API in this header does not assume the presence of a + user agent. That is, it can be used to bind C code to scripting + environments outside of the context of a user agent. + + However, the normal use of the this API is in the context of a + scripting environment running in a browser or other user agent. + In particular it is used to support the extended Netscape + script-ability API for plugins (NP-SAP). NP-SAP is an extension + of the Netscape plugin API. As such we have adopted the use of + the "NP" prefix for this API. + + The following NP{N|P}Variables were added to the Netscape plugin + API (in npapi.h): + + NPNVWindowNPObject + NPNVPluginElementNPObject + NPPVpluginScriptableNPObject + + These variables are exposed through NPN_GetValue() and + NPP_GetValue() (respectively) and are used to establish the + initial binding between the user agent and native code. The DOM + objects in the user agent can be examined and manipulated using + the NPN_ functions that operate on NPObjects described in this + header. + + To the extent possible the assumptions about the scripting + language used by the scripting environment have been minimized. +*/ + +#define NP_BEGIN_MACRO do { +#define NP_END_MACRO } while (0) + +/* + Objects (non-primitive data) passed between 'C' and script is + always wrapped in an NPObject. The 'interface' of an NPObject is + described by an NPClass. +*/ +typedef struct NPObject NPObject; +typedef struct NPClass NPClass; + +typedef char NPUTF8; +typedef struct _NPString { + const NPUTF8 *utf8characters; + uint32_t utf8length; +} NPString; + +typedef enum { + NPVariantType_Void, + NPVariantType_Null, + NPVariantType_Bool, + NPVariantType_Int32, + NPVariantType_Double, + NPVariantType_String, + NPVariantType_Object +} NPVariantType; + +typedef struct _NPVariant { + NPVariantType type; + union { + bool boolValue; + uint32_t intValue; + double doubleValue; + NPString stringValue; + NPObject *objectValue; + } value; +} NPVariant; + +/* + NPN_ReleaseVariantValue is called on all 'out' parameters + references. Specifically it is to be called on variants that own + their value, as is the case with all non-const NPVariant* + arguments after a successful call to any methods (except this one) + in this API. + + After calling NPN_ReleaseVariantValue, the type of the variant + will be NPVariantType_Void. +*/ +void NPN_ReleaseVariantValue(NPVariant *variant); + +#define NPVARIANT_IS_VOID(_v) ((_v).type == NPVariantType_Void) +#define NPVARIANT_IS_NULL(_v) ((_v).type == NPVariantType_Null) +#define NPVARIANT_IS_BOOLEAN(_v) ((_v).type == NPVariantType_Bool) +#define NPVARIANT_IS_INT32(_v) ((_v).type == NPVariantType_Int32) +#define NPVARIANT_IS_DOUBLE(_v) ((_v).type == NPVariantType_Double) +#define NPVARIANT_IS_STRING(_v) ((_v).type == NPVariantType_String) +#define NPVARIANT_IS_OBJECT(_v) ((_v).type == NPVariantType_Object) + +#define NPVARIANT_TO_BOOLEAN(_v) ((_v).value.boolValue) +#define NPVARIANT_TO_INT32(_v) ((_v).value.intValue) +#define NPVARIANT_TO_DOUBLE(_v) ((_v).value.doubleValue) +#define NPVARIANT_TO_STRING(_v) ((_v).value.stringValue) +#define NPVARIANT_TO_OBJECT(_v) ((_v).value.objectValue) + +#define VOID_TO_NPVARIANT(_v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_Void; \ + (_v).value.objectValue = NULL; \ +NP_END_MACRO + +#define NULL_TO_NPVARIANT(_v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_Null; \ + (_v).value.objectValue = NULL; \ +NP_END_MACRO + +#define BOOLEAN_TO_NPVARIANT(_val, _v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_Bool; \ + (_v).value.boolValue = !!(_val); \ +NP_END_MACRO + +#define INT32_TO_NPVARIANT(_val, _v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_Int32; \ + (_v).value.intValue = _val; \ +NP_END_MACRO + +#define DOUBLE_TO_NPVARIANT(_val, _v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_Double; \ + (_v).value.doubleValue = _val; \ +NP_END_MACRO + +#define STRINGZ_TO_NPVARIANT(_val, _v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_String; \ + NPString str = { _val, strlen(_val) }; \ + (_v).value.stringValue = str; \ +NP_END_MACRO + +#define STRINGN_TO_NPVARIANT(_val, _len, _v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_String; \ + NPString str = { _val, _len }; \ + (_v).value.stringValue = str; \ +NP_END_MACRO + +#define OBJECT_TO_NPVARIANT(_val, _v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_Object; \ + (_v).value.objectValue = _val; \ +NP_END_MACRO + + +/* + Type mappings (JavaScript types have been used for illustration + purposes): + + JavaScript to C (NPVariant with type:) + undefined NPVariantType_Void + null NPVariantType_Null + Boolean NPVariantType_Bool + Number NPVariantType_Double or NPVariantType_Int32 + String NPVariantType_String + Object NPVariantType_Object + + C (NPVariant with type:) to JavaScript + NPVariantType_Void undefined + NPVariantType_Null null + NPVariantType_Bool Boolean + NPVariantType_Int32 Number + NPVariantType_Double Number + NPVariantType_String String + NPVariantType_Object Object +*/ + +typedef void *NPIdentifier; + +/* + NPObjects have methods and properties. Methods and properties are + identified with NPIdentifiers. These identifiers may be reflected + in script. NPIdentifiers can be either strings or integers, IOW, + methods and properties can be identified by either strings or + integers (i.e. foo["bar"] vs foo[1]). NPIdentifiers can be + compared using ==. In case of any errors, the requested + NPIdentifier(s) will be NULL. +*/ +NPIdentifier NPN_GetStringIdentifier(const NPUTF8 *name); +void NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount, + NPIdentifier *identifiers); +NPIdentifier NPN_GetIntIdentifier(int32_t intid); +bool NPN_IdentifierIsString(NPIdentifier identifier); + +/* + The NPUTF8 returned from NPN_UTF8FromIdentifier SHOULD be freed. +*/ +NPUTF8 *NPN_UTF8FromIdentifier(NPIdentifier identifier); + +/* + Get the integer represented by identifier. If identifier is not an + integer identifier, the behaviour is undefined. +*/ +int32_t NPN_IntFromIdentifier(NPIdentifier identifier); + +/* + NPObject behavior is implemented using the following set of + callback functions. + + The NPVariant *result argument of these functions (where + applicable) should be released using NPN_ReleaseVariantValue(). +*/ +typedef NPObject *(*NPAllocateFunctionPtr)(NPP npp, NPClass *aClass); +typedef void (*NPDeallocateFunctionPtr)(NPObject *npobj); +typedef void (*NPInvalidateFunctionPtr)(NPObject *npobj); +typedef bool (*NPHasMethodFunctionPtr)(NPObject *npobj, NPIdentifier name); +typedef bool (*NPInvokeFunctionPtr)(NPObject *npobj, NPIdentifier name, + const NPVariant *args, uint32_t argCount, + NPVariant *result); +typedef bool (*NPInvokeDefaultFunctionPtr)(NPObject *npobj, + const NPVariant *args, + uint32_t argCount, + NPVariant *result); +typedef bool (*NPHasPropertyFunctionPtr)(NPObject *npobj, NPIdentifier name); +typedef bool (*NPGetPropertyFunctionPtr)(NPObject *npobj, NPIdentifier name, + NPVariant *result); +typedef bool (*NPSetPropertyFunctionPtr)(NPObject *npobj, NPIdentifier name, + const NPVariant *value); +typedef bool (*NPRemovePropertyFunctionPtr)(NPObject *npobj, + NPIdentifier name); + +/* + NPObjects returned by create, retain, invoke, and getProperty pass + a reference count to the caller. That is, the callee adds a + reference count which passes to the caller. It is the caller's + responsibility to release the returned object. + + NPInvokeFunctionPtr function may return 0 to indicate a void + result. + + NPInvalidateFunctionPtr is called by the scripting environment + when the native code is shutdown. Any attempt to message a + NPObject instance after the invalidate callback has been + called will result in undefined behavior, even if the native code + is still retaining those NPObject instances. (The runtime + will typically return immediately, with 0 or NULL, from an attempt + to dispatch to a NPObject, but this behavior should not be + depended upon.) +*/ +struct NPClass +{ + uint32_t structVersion; + NPAllocateFunctionPtr allocate; + NPDeallocateFunctionPtr deallocate; + NPInvalidateFunctionPtr invalidate; + NPHasMethodFunctionPtr hasMethod; + NPInvokeFunctionPtr invoke; + NPInvokeDefaultFunctionPtr invokeDefault; + NPHasPropertyFunctionPtr hasProperty; + NPGetPropertyFunctionPtr getProperty; + NPSetPropertyFunctionPtr setProperty; + NPRemovePropertyFunctionPtr removeProperty; +}; + +#define NP_CLASS_STRUCT_VERSION 1 + +struct NPObject { + NPClass *_class; + uint32_t referenceCount; + /* + * Additional space may be allocated here by types of NPObjects + */ +}; + +/* + If the class has an allocate function, NPN_CreateObject invokes + that function, otherwise a NPObject is allocated and + returned. This method will initialize the referenceCount member of + the NPObject to 1. +*/ +NPObject *NPN_CreateObject(NPP npp, NPClass *aClass); + +/* + Increment the NPObject's reference count. +*/ +NPObject *NPN_RetainObject(NPObject *npobj); + +/* + Decremented the NPObject's reference count. If the reference + count goes to zero, the class's destroy function is invoke if + specified, otherwise the object is freed directly. +*/ +void NPN_ReleaseObject(NPObject *npobj); + +/* + Functions to access script objects represented by NPObject. + + Calls to script objects are synchronous. If a function returns a + value, it will be supplied via the result NPVariant + argument. Successful calls will return true, false will be + returned in case of an error. + + Calls made from plugin code to script must be made from the thread + on which the plugin was initialized. +*/ + +bool NPN_Invoke(NPP npp, NPObject *npobj, NPIdentifier methodName, + const NPVariant *args, uint32_t argCount, NPVariant *result); +bool NPN_InvokeDefault(NPP npp, NPObject *npobj, const NPVariant *args, + uint32_t argCount, NPVariant *result); +bool NPN_Evaluate(NPP npp, NPObject *npobj, NPString *script, + NPVariant *result); +bool NPN_GetProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName, + NPVariant *result); +bool NPN_SetProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName, + const NPVariant *value); +bool NPN_RemoveProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName); +bool NPN_HasProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName); +bool NPN_HasMethod(NPP npp, NPObject *npobj, NPIdentifier methodName); + +/* + NPN_SetException may be called to trigger a script exception upon + return from entry points into NPObjects. Typical usage: + + NPN_SetException (npobj, message); +*/ +void NPN_SetException(NPObject *npobj, const NPUTF8 *message); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/nsplugins/sdk/npupp.h b/nsplugins/sdk/npupp.h new file mode 100644 index 000000000..dff545d9f --- /dev/null +++ b/nsplugins/sdk/npupp.h @@ -0,0 +1,1889 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * 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 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 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 ***** */ + + +/* + * npupp.h + * function call mecahnics needed by platform specific glue code. + */ + + +#ifndef _NPUPP_H_ +#define _NPUPP_H_ + +#if defined(__OS2__) +#pragma pack(1) +#endif + +#ifndef GENERATINGCFM +#define GENERATINGCFM 0 +#endif + +#ifndef _NPAPI_H_ +#include "npapi.h" +#endif + +#include "npruntime.h" + +#include "jri.h" + +/****************************************************************************************** + plug-in function table macros + for each function in and out of the plugin API we define + typedef NPP_FooUPP + #define NewNPP_FooProc + #define CallNPP_FooProc + for mac, define the UPP magic for PPC/68K calling + *******************************************************************************************/ + + +/* NPP_Initialize */ + +#define _NPUPP_USE_UPP_ 0 + +#if _NPUPP_USE_UPP_ +typedef UniversalProcPtr NPP_InitializeUPP; + +enum { + uppNPP_InitializeProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0)) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPP_InitializeProc(FUNC) \ + (NPP_InitializeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_InitializeProcInfo, GetCurrentArchitecture()) +#define CallNPP_InitializeProc(FUNC) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_InitializeProcInfo) + +#else + +typedef void (* NP_LOADDS NPP_InitializeUPP)(void); +#define NewNPP_InitializeProc(FUNC) \ + ((NPP_InitializeUPP) (FUNC)) +#define CallNPP_InitializeProc(FUNC) \ + (*(FUNC))() + +#endif + + +/* NPP_Shutdown */ + +#if _NPUPP_USE_UPP_ +typedef UniversalProcPtr NPP_ShutdownUPP; + +enum { + uppNPP_ShutdownProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0)) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPP_ShutdownProc(FUNC) \ + (NPP_ShutdownUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_ShutdownProcInfo, GetCurrentArchitecture()) +#define CallNPP_ShutdownProc(FUNC) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_ShutdownProcInfo) + +#else + +typedef void (* NP_LOADDS NPP_ShutdownUPP)(void); +#define NewNPP_ShutdownProc(FUNC) \ + ((NPP_ShutdownUPP) (FUNC)) +#define CallNPP_ShutdownProc(FUNC) \ + (*(FUNC))() + +#endif + + +/* NPP_New */ + +#if _NPUPP_USE_UPP_ +typedef UniversalProcPtr NPP_NewUPP; + +enum { + uppNPP_NewProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPMIMEType))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(uint16))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int16))) + | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(char **))) + | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(char **))) + | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(NPSavedData *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; + +#define NewNPP_NewProc(FUNC) \ + (NPP_NewUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_NewProcInfo, GetCurrentArchitecture()) +#define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_NewProcInfo, \ + (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) +#else + +typedef NPError (* NP_LOADDS NPP_NewUPP)(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved); +#define NewNPP_NewProc(FUNC) \ + ((NPP_NewUPP) (FUNC)) +#define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) + +#endif + + +/* NPP_Destroy */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_DestroyUPP; +enum { + uppNPP_DestroyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPSavedData **))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPP_DestroyProc(FUNC) \ + (NPP_DestroyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_DestroyProcInfo, GetCurrentArchitecture()) +#define CallNPP_DestroyProc(FUNC, ARG1, ARG2) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_DestroyProcInfo, (ARG1), (ARG2)) +#else + +typedef NPError (* NP_LOADDS NPP_DestroyUPP)(NPP instance, NPSavedData** save); +#define NewNPP_DestroyProc(FUNC) \ + ((NPP_DestroyUPP) (FUNC)) +#define CallNPP_DestroyProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) + +#endif + + +/* NPP_SetWindow */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_SetWindowUPP; +enum { + uppNPP_SetWindowProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPWindow *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPP_SetWindowProc(FUNC) \ + (NPP_SetWindowUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_SetWindowProcInfo, GetCurrentArchitecture()) +#define CallNPP_SetWindowProc(FUNC, ARG1, ARG2) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_SetWindowProcInfo, (ARG1), (ARG2)) + +#else + +typedef NPError (* NP_LOADDS NPP_SetWindowUPP)(NPP instance, NPWindow* window); +#define NewNPP_SetWindowProc(FUNC) \ + ((NPP_SetWindowUPP) (FUNC)) +#define CallNPP_SetWindowProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) + +#endif + + +/* NPP_NewStream */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_NewStreamUPP; +enum { + uppNPP_NewStreamProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPMIMEType))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPStream *))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPBool))) + | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(uint16 *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPP_NewStreamProc(FUNC) \ + (NPP_NewStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_NewStreamProcInfo, GetCurrentArchitecture()) +#define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_NewStreamProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5)) +#else + +typedef NPError (* NP_LOADDS NPP_NewStreamUPP)(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16* stype); +#define NewNPP_NewStreamProc(FUNC) \ + ((NPP_NewStreamUPP) (FUNC)) +#define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5)) +#endif + + +/* NPP_DestroyStream */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_DestroyStreamUPP; +enum { + uppNPP_DestroyStreamProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPP_DestroyStreamProc(FUNC) \ + (NPP_DestroyStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_DestroyStreamProcInfo, GetCurrentArchitecture()) +#define CallNPP_DestroyStreamProc(FUNC, NPParg, NPStreamPtr, NPReasonArg) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_DestroyStreamProcInfo, (NPParg), (NPStreamPtr), (NPReasonArg)) + +#else + +typedef NPError (* NP_LOADDS NPP_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason); +#define NewNPP_DestroyStreamProc(FUNC) \ + ((NPP_DestroyStreamUPP) (FUNC)) +#define CallNPP_DestroyStreamProc(FUNC, NPParg, NPStreamPtr, NPReasonArg) \ + (*(FUNC))((NPParg), (NPStreamPtr), (NPReasonArg)) + +#endif + + +/* NPP_WriteReady */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_WriteReadyUPP; +enum { + uppNPP_WriteReadyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) + | RESULT_SIZE(SIZE_CODE(sizeof(int32))) +}; +#define NewNPP_WriteReadyProc(FUNC) \ + (NPP_WriteReadyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_WriteReadyProcInfo, GetCurrentArchitecture()) +#define CallNPP_WriteReadyProc(FUNC, NPParg, NPStreamPtr) \ + (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_WriteReadyProcInfo, (NPParg), (NPStreamPtr)) + +#else + +typedef int32 (* NP_LOADDS NPP_WriteReadyUPP)(NPP instance, NPStream* stream); +#define NewNPP_WriteReadyProc(FUNC) \ + ((NPP_WriteReadyUPP) (FUNC)) +#define CallNPP_WriteReadyProc(FUNC, NPParg, NPStreamPtr) \ + (*(FUNC))((NPParg), (NPStreamPtr)) + +#endif + + +/* NPP_Write */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_WriteUPP; +enum { + uppNPP_WriteProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int32))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int32))) + | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(void*))) + | RESULT_SIZE(SIZE_CODE(sizeof(int32))) +}; +#define NewNPP_WriteProc(FUNC) \ + (NPP_WriteUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_WriteProcInfo, GetCurrentArchitecture()) +#define CallNPP_WriteProc(FUNC, NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr) \ + (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_WriteProcInfo, (NPParg), (NPStreamPtr), (offsetArg), (lenArg), (bufferPtr)) + +#else + +typedef int32 (* NP_LOADDS NPP_WriteUPP)(NPP instance, NPStream* stream, int32 offset, int32 len, void* buffer); +#define NewNPP_WriteProc(FUNC) \ + ((NPP_WriteUPP) (FUNC)) +#define CallNPP_WriteProc(FUNC, NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr) \ + (*(FUNC))((NPParg), (NPStreamPtr), (offsetArg), (lenArg), (bufferPtr)) + +#endif + + +/* NPP_StreamAsFile */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_StreamAsFileUPP; +enum { + uppNPP_StreamAsFileProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char *))) + | RESULT_SIZE(SIZE_CODE(0)) +}; +#define NewNPP_StreamAsFileProc(FUNC) \ + (NPP_StreamAsFileUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_StreamAsFileProcInfo, GetCurrentArchitecture()) +#define CallNPP_StreamAsFileProc(FUNC, ARG1, ARG2, ARG3) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_StreamAsFileProcInfo, (ARG1), (ARG2), (ARG3)) + +#else + +typedef void (* NP_LOADDS NPP_StreamAsFileUPP)(NPP instance, NPStream* stream, const char* fname); +#define NewNPP_StreamAsFileProc(FUNC) \ + ((NPP_StreamAsFileUPP) (FUNC)) +#define CallNPP_StreamAsFileProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) +#endif + + +/* NPP_Print */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_PrintUPP; +enum { + uppNPP_PrintProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPrint *))) + | RESULT_SIZE(SIZE_CODE(0)) +}; +#define NewNPP_PrintProc(FUNC) \ + (NPP_PrintUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_PrintProcInfo, GetCurrentArchitecture()) +#define CallNPP_PrintProc(FUNC, NPParg, voidPtr) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_PrintProcInfo, (NPParg), (voidPtr)) + +#else + +typedef void (* NP_LOADDS NPP_PrintUPP)(NPP instance, NPPrint* platformPrint); +#define NewNPP_PrintProc(FUNC) \ + ((NPP_PrintUPP) (FUNC)) +#define CallNPP_PrintProc(FUNC, NPParg, NPPrintArg) \ + (*(FUNC))((NPParg), (NPPrintArg)) + +#endif + + +/* NPP_HandleEvent */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_HandleEventUPP; +enum { + uppNPP_HandleEventProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *))) + | RESULT_SIZE(SIZE_CODE(sizeof(int16))) +}; +#define NewNPP_HandleEventProc(FUNC) \ + (NPP_HandleEventUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_HandleEventProcInfo, GetCurrentArchitecture()) +#define CallNPP_HandleEventProc(FUNC, NPParg, voidPtr) \ + (int16)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_HandleEventProcInfo, (NPParg), (voidPtr)) + +#else + +typedef int16 (* NP_LOADDS NPP_HandleEventUPP)(NPP instance, void* event); +#define NewNPP_HandleEventProc(FUNC) \ + ((NPP_HandleEventUPP) (FUNC)) +#define CallNPP_HandleEventProc(FUNC, NPParg, voidPtr) \ + (*(FUNC))((NPParg), (voidPtr)) + +#endif + + +/* NPP_URLNotify */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_URLNotifyUPP; +enum { + uppNPP_URLNotifyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*))) + | RESULT_SIZE(SIZE_CODE(SIZE_CODE(0))) +}; +#define NewNPP_URLNotifyProc(FUNC) \ + (NPP_URLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_URLNotifyProcInfo, GetCurrentArchitecture()) +#define CallNPP_URLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_URLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4)) + +#else + +typedef void (* NP_LOADDS NPP_URLNotifyUPP)(NPP instance, const char* url, NPReason reason, void* notifyData); +#define NewNPP_URLNotifyProc(FUNC) \ + ((NPP_URLNotifyUPP) (FUNC)) +#define CallNPP_URLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4)) + +#endif + + +/* NPP_GetValue */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_GetValueUPP; +enum { + uppNPP_GetValueProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPVariable))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPP_GetValueProc(FUNC) \ + (NPP_GetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_GetValueProcInfo, GetCurrentArchitecture()) +#define CallNPP_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_GetValueProcInfo, (ARG1), (ARG2), (ARG3)) +#else + +typedef NPError (* NP_LOADDS NPP_GetValueUPP)(NPP instance, NPPVariable variable, void *ret_alue); +#define NewNPP_GetValueProc(FUNC) \ + ((NPP_GetValueUPP) (FUNC)) +#define CallNPP_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) +#endif + + +/* NPP_SetValue */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_SetValueUPP; +enum { + uppNPP_SetValueProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPNVariable))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPP_SetValueProc(FUNC) \ + (NPP_SetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_SetValueProcInfo, GetCurrentArchitecture()) +#define CallNPP_SetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_SetValueProcInfo, (ARG1), (ARG2), (ARG3)) +#else + +typedef NPError (* NP_LOADDS NPP_SetValueUPP)(NPP instance, NPNVariable variable, void *ret_alue); +#define NewNPP_SetValueProc(FUNC) \ + ((NPP_SetValueUPP) (FUNC)) +#define CallNPP_SetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) +#endif + + +/* + * Netscape entry points + */ + + +/* NPN_GetValue */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetValueUPP; +enum { + uppNPN_GetValueProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPNVariable))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_GetValueProc(FUNC) \ + (NPN_GetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetValueProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetValueProcInfo, (ARG1), (ARG2), (ARG3)) +#else + +typedef NPError (* NP_LOADDS NPN_GetValueUPP)(NPP instance, NPNVariable variable, void *ret_alue); +#define NewNPN_GetValueProc(FUNC) \ + ((NPN_GetValueUPP) (FUNC)) +#define CallNPN_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) +#endif + + +/* NPN_SetValue */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_SetValueUPP; +enum { + uppNPN_SetValueProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPVariable))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_SetValueProc(FUNC) \ + (NPN_SetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_SetValueProcInfo, GetCurrentArchitecture()) +#define CallNPN_SetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_SetValueProcInfo, (ARG1), (ARG2), (ARG3)) +#else + +typedef NPError (* NP_LOADDS NPN_SetValueUPP)(NPP instance, NPPVariable variable, void *ret_alue); +#define NewNPN_SetValueProc(FUNC) \ + ((NPN_SetValueUPP) (FUNC)) +#define CallNPN_SetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) +#endif + + +/* NPN_GetUrlNotify */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetURLNotifyUPP; +enum { + uppNPN_GetURLNotifyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_GetURLNotifyProc(FUNC) \ + (NPN_GetURLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetURLNotifyProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetURLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4)) +#else + +typedef NPError (* NP_LOADDS NPN_GetURLNotifyUPP)(NPP instance, const char* url, const char* window, void* notifyData); +#define NewNPN_GetURLNotifyProc(FUNC) \ + ((NPN_GetURLNotifyUPP) (FUNC)) +#define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4)) +#endif + + +/* NPN_PostUrlNotify */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_PostURLNotifyUPP; +enum { + uppNPN_PostURLNotifyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(uint32))) + | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPBool))) + | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(void*))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_PostURLNotifyProc(FUNC) \ + (NPN_PostURLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PostURLNotifyProcInfo, GetCurrentArchitecture()) +#define CallNPN_PostURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PostURLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) +#else + +typedef NPError (* NP_LOADDS NPN_PostURLNotifyUPP)(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file, void* notifyData); +#define NewNPN_PostURLNotifyProc(FUNC) \ + ((NPN_PostURLNotifyUPP) (FUNC)) +#define CallNPN_PostURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) +#endif + + +/* NPN_GetUrl */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetURLUPP; +enum { + uppNPN_GetURLProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_GetURLProc(FUNC) \ + (NPN_GetURLUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetURLProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetURLProcInfo, (ARG1), (ARG2), (ARG3)) +#else + +typedef NPError (* NP_LOADDS NPN_GetURLUPP)(NPP instance, const char* url, const char* window); +#define NewNPN_GetURLProc(FUNC) \ + ((NPN_GetURLUPP) (FUNC)) +#define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) +#endif + + +/* NPN_PostUrl */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_PostURLUPP; +enum { + uppNPN_PostURLProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(uint32))) + | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPBool))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_PostURLProc(FUNC) \ + (NPN_PostURLUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PostURLProcInfo, GetCurrentArchitecture()) +#define CallNPN_PostURLProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PostURLProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6)) +#else + +typedef NPError (* NP_LOADDS NPN_PostURLUPP)(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file); +#define NewNPN_PostURLProc(FUNC) \ + ((NPN_PostURLUPP) (FUNC)) +#define CallNPN_PostURLProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6)) +#endif + + +/* NPN_RequestRead */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_RequestReadUPP; +enum { + uppNPN_RequestReadProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPStream *))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPByteRange *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_RequestReadProc(FUNC) \ + (NPN_RequestReadUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_RequestReadProcInfo, GetCurrentArchitecture()) +#define CallNPN_RequestReadProc(FUNC, stream, range) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_RequestReadProcInfo, (stream), (range)) + +#else + +typedef NPError (* NP_LOADDS NPN_RequestReadUPP)(NPStream* stream, NPByteRange* rangeList); +#define NewNPN_RequestReadProc(FUNC) \ + ((NPN_RequestReadUPP) (FUNC)) +#define CallNPN_RequestReadProc(FUNC, stream, range) \ + (*(FUNC))((stream), (range)) + +#endif + + +/* NPN_NewStream */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_NewStreamUPP; +enum { + uppNPN_NewStreamProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPMIMEType))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char *))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPStream **))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_NewStreamProc(FUNC) \ + (NPN_NewStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_NewStreamProcInfo, GetCurrentArchitecture()) +#define CallNPN_NewStreamProc(FUNC, npp, type, window, stream) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_NewStreamProcInfo, (npp), (type), (window), (stream)) + +#else + +typedef NPError (* NP_LOADDS NPN_NewStreamUPP)(NPP instance, NPMIMEType type, const char* window, NPStream** stream); +#define NewNPN_NewStreamProc(FUNC) \ + ((NPN_NewStreamUPP) (FUNC)) +#define CallNPN_NewStreamProc(FUNC, npp, type, window, stream) \ + (*(FUNC))((npp), (type), (window), (stream)) + +#endif + + +/* NPN_Write */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_WriteUPP; +enum { + uppNPN_WriteProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int32))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*))) + | RESULT_SIZE(SIZE_CODE(sizeof(int32))) +}; +#define NewNPN_WriteProc(FUNC) \ + (NPN_WriteUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_WriteProcInfo, GetCurrentArchitecture()) +#define CallNPN_WriteProc(FUNC, npp, stream, len, buffer) \ + (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_WriteProcInfo, (npp), (stream), (len), (buffer)) + +#else + +typedef int32 (* NP_LOADDS NPN_WriteUPP)(NPP instance, NPStream* stream, int32 len, void* buffer); +#define NewNPN_WriteProc(FUNC) \ + ((NPN_WriteUPP) (FUNC)) +#define CallNPN_WriteProc(FUNC, npp, stream, len, buffer) \ + (*(FUNC))((npp), (stream), (len), (buffer)) + +#endif + + +/* NPN_DestroyStream */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_DestroyStreamUPP; +enum { + uppNPN_DestroyStreamProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP ))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_DestroyStreamProc(FUNC) \ + (NPN_DestroyStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, GetCurrentArchitecture()) +#define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, (npp), (stream), (reason)) + +#else + +typedef NPError (* NP_LOADDS NPN_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason); +#define NewNPN_DestroyStreamProc(FUNC) \ + ((NPN_DestroyStreamUPP) (FUNC)) +#define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason) \ + (*(FUNC))((npp), (stream), (reason)) + +#endif + + +/* NPN_Status */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_StatusUPP; +enum { + uppNPN_StatusProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char *))) +}; + +#define NewNPN_StatusProc(FUNC) \ + (NPN_StatusUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_StatusProcInfo, GetCurrentArchitecture()) +#define CallNPN_StatusProc(FUNC, npp, msg) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_StatusProcInfo, (npp), (msg)) + +#else + +typedef void (* NP_LOADDS NPN_StatusUPP)(NPP instance, const char* message); +#define NewNPN_StatusProc(FUNC) \ + ((NPN_StatusUPP) (FUNC)) +#define CallNPN_StatusProc(FUNC, npp, msg) \ + (*(FUNC))((npp), (msg)) + +#endif + + +/* NPN_UserAgent */ +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_UserAgentUPP; +enum { + uppNPN_UserAgentProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | RESULT_SIZE(SIZE_CODE(sizeof(const char *))) +}; + +#define NewNPN_UserAgentProc(FUNC) \ + (NPN_UserAgentUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_UserAgentProcInfo, GetCurrentArchitecture()) +#define CallNPN_UserAgentProc(FUNC, ARG1) \ + (const char*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_UserAgentProcInfo, (ARG1)) + +#else + +typedef const char* (* NP_LOADDS NPN_UserAgentUPP)(NPP instance); +#define NewNPN_UserAgentProc(FUNC) \ + ((NPN_UserAgentUPP) (FUNC)) +#define CallNPN_UserAgentProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + + +/* NPN_MemAlloc */ +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_MemAllocUPP; +enum { + uppNPN_MemAllocProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(uint32))) + | RESULT_SIZE(SIZE_CODE(sizeof(void *))) +}; + +#define NewNPN_MemAllocProc(FUNC) \ + (NPN_MemAllocUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemAllocProcInfo, GetCurrentArchitecture()) +#define CallNPN_MemAllocProc(FUNC, ARG1) \ + (void*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemAllocProcInfo, (ARG1)) + +#else + +typedef void* (* NP_LOADDS NPN_MemAllocUPP)(uint32 size); +#define NewNPN_MemAllocProc(FUNC) \ + ((NPN_MemAllocUPP) (FUNC)) +#define CallNPN_MemAllocProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + + +/* NPN__MemFree */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_MemFreeUPP; +enum { + uppNPN_MemFreeProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(void *))) +}; + +#define NewNPN_MemFreeProc(FUNC) \ + (NPN_MemFreeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemFreeProcInfo, GetCurrentArchitecture()) +#define CallNPN_MemFreeProc(FUNC, ARG1) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFreeProcInfo, (ARG1)) + +#else + +typedef void (* NP_LOADDS NPN_MemFreeUPP)(void* ptr); +#define NewNPN_MemFreeProc(FUNC) \ + ((NPN_MemFreeUPP) (FUNC)) +#define CallNPN_MemFreeProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + + +/* NPN_MemFlush */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_MemFlushUPP; +enum { + uppNPN_MemFlushProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(uint32))) + | RESULT_SIZE(SIZE_CODE(sizeof(uint32))) +}; + +#define NewNPN_MemFlushProc(FUNC) \ + (NPN_MemFlushUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemFlushProcInfo, GetCurrentArchitecture()) +#define CallNPN_MemFlushProc(FUNC, ARG1) \ + (uint32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFlushProcInfo, (ARG1)) + +#else + +typedef uint32 (* NP_LOADDS NPN_MemFlushUPP)(uint32 size); +#define NewNPN_MemFlushProc(FUNC) \ + ((NPN_MemFlushUPP) (FUNC)) +#define CallNPN_MemFlushProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + + + +/* NPN_ReloadPlugins */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_ReloadPluginsUPP; +enum { + uppNPN_ReloadPluginsProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPBool))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_ReloadPluginsProc(FUNC) \ + (NPN_ReloadPluginsUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, GetCurrentArchitecture()) +#define CallNPN_ReloadPluginsProc(FUNC, ARG1) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, (ARG1)) + +#else + +typedef void (* NP_LOADDS NPN_ReloadPluginsUPP)(NPBool reloadPages); +#define NewNPN_ReloadPluginsProc(FUNC) \ + ((NPN_ReloadPluginsUPP) (FUNC)) +#define CallNPN_ReloadPluginsProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_GetJavaEnv */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetJavaEnvUPP; +enum { + uppNPN_GetJavaEnvProcInfo = kThinkCStackBased + | RESULT_SIZE(SIZE_CODE(sizeof(JRIEnv*))) +}; + +#define NewNPN_GetJavaEnvProc(FUNC) \ + (NPN_GetJavaEnvUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetJavaEnvProc(FUNC) \ + (JRIEnv*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo) + +#else +typedef JRIEnv* (* NP_LOADDS NPN_GetJavaEnvUPP)(void); +#define NewNPN_GetJavaEnvProc(FUNC) \ + ((NPN_GetJavaEnvUPP) (FUNC)) +#define CallNPN_GetJavaEnvProc(FUNC) \ + (*(FUNC))() + +#endif + + +/* NPN_GetJavaPeer */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetJavaPeerUPP; +enum { + uppNPN_GetJavaPeerProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | RESULT_SIZE(SIZE_CODE(sizeof(jref))) +}; + +#define NewNPN_GetJavaPeerProc(FUNC) \ + (NPN_GetJavaPeerUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetJavaPeerProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, (ARG1)) + +#else + +typedef jref (* NP_LOADDS NPN_GetJavaPeerUPP)(NPP instance); +#define NewNPN_GetJavaPeerProc(FUNC) \ + ((NPN_GetJavaPeerUPP) (FUNC)) +#define CallNPN_GetJavaPeerProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_InvalidateRect */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_InvalidateRectUPP; +enum { + uppNPN_InvalidateRectProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPRect *))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_InvalidateRectProc(FUNC) \ + (NPN_InvalidateRectUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_InvalidateRectProcInfo, GetCurrentArchitecture()) +#define CallNPN_InvalidateRectProc(FUNC, ARG1, ARG2) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvalidateRectProcInfo, (ARG1), (ARG2)) + +#else + +typedef void (* NP_LOADDS NPN_InvalidateRectUPP)(NPP instance, NPRect *rect); +#define NewNPN_InvalidateRectProc(FUNC) \ + ((NPN_InvalidateRectUPP) (FUNC)) +#define CallNPN_InvalidateRectProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) + +#endif + + +/* NPN_InvalidateRegion */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_InvalidateRegionUPP; +enum { + uppNPN_InvalidateRegionProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPRegion))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_InvalidateRegionProc(FUNC) \ + (NPN_InvalidateRegionUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_InvalidateRegionProcInfo, GetCurrentArchitecture()) +#define CallNPN_InvalidateRegionProc(FUNC, ARG1, ARG2) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvalidateRegionProcInfo, (ARG1), (ARG2)) + +#else + +typedef void (* NP_LOADDS NPN_InvalidateRegionUPP)(NPP instance, NPRegion region); +#define NewNPN_InvalidateRegionProc(FUNC) \ + ((NPN_InvalidateRegionUPP) (FUNC)) +#define CallNPN_InvalidateRegionProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) + +#endif + +/* NPN_ForceRedraw */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_ForceRedrawUPP; +enum { + uppNPN_ForceRedrawProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | RESULT_SIZE(SIZE_CODE(sizeof(0))) +}; + +#define NewNPN_ForceRedrawProc(FUNC) \ + (NPN_ForceRedrawUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ForceRedrawProcInfo, GetCurrentArchitecture()) +#define CallNPN_ForceRedrawProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ForceRedrawProcInfo, (ARG1)) + +#else + +typedef void (* NP_LOADDS NPN_ForceRedrawUPP)(NPP instance); +#define NewNPN_ForceRedrawProc(FUNC) \ + ((NPN_ForceRedrawUPP) (FUNC)) +#define CallNPN_ForceRedrawProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_GetStringIdentifier */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetStringIdentifierUPP; +enum { + uppNPN_GetStringIdentifierProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(const NPUTF8*))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPIdentifier))) +}; + +#define NewNPN_GetStringIdentifierProc(FUNC) \ + (NPN_GetStringIdentifierUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetStringIdentifierProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetStringIdentifierProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetStringIdentifierProcInfo, (ARG1)) + +#else + +typedef NPIdentifier (* NP_LOADDS NPN_GetStringIdentifierUPP)(const NPUTF8* name); +#define NewNPN_GetStringIdentifierProc(FUNC) \ + ((NPN_GetStringIdentifierUPP) (FUNC)) +#define CallNPN_GetStringIdentifierProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_GetStringIdentifiers */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetStringIdentifiersUPP; +enum { + uppNPN_GetStringIdentifiersProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(const NPUTF8**))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(int32_t))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier*))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_GetStringIdentifiersProc(FUNC) \ + (NPN_GetStringIdentifiersUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetStringIdentifiersProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetStringIdentifiersProc(FUNC, ARG1, ARG2, ARG3) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetStringIdentifiersProcInfo, (ARG1), (ARG2), (ARG3)) + +#else + +typedef void (* NP_LOADDS NPN_GetStringIdentifiersUPP)(const NPUTF8** names, + int32_t nameCount, + NPIdentifier* identifiers); +#define NewNPN_GetStringIdentifiersProc(FUNC) \ + ((NPN_GetStringIdentifiersUPP) (FUNC)) +#define CallNPN_GetStringIdentifiersProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) + +#endif + +/* NPN_GetIntIdentifier */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetIntIdentifierUPP; +enum { + uppNPN_GetIntIdentifierProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int32_t))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPIdentifier))) +}; + +#define NewNPN_GetIntIdentifierProc(FUNC) \ + (NPN_GetIntIdentifierUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetIntIdentifierProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetIntIdentifierProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetIntIdentifierProcInfo, (ARG1)) + +#else + +typedef NPIdentifier (* NP_LOADDS NPN_GetIntIdentifierUPP)(int32_t intid); +#define NewNPN_GetIntIdentifierProc(FUNC) \ + ((NPN_GetIntIdentifierUPP) (FUNC)) +#define CallNPN_GetIntIdentifierProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_IdentifierIsString */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_IdentifierIsStringUPP; +enum { + uppNPN_IdentifierIsStringProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPIdentifier identifier))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_IdentifierIsStringProc(FUNC) \ + (NPN_IdentifierIsStringUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_IdentifierIsStringProcInfo, GetCurrentArchitecture()) +#define CallNPN_IdentifierIsStringProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_IdentifierIsStringProcInfo, (ARG1)) + +#else + +typedef bool (* NP_LOADDS NPN_IdentifierIsStringUPP)(NPIdentifier identifier); +#define NewNPN_IdentifierIsStringProc(FUNC) \ + ((NPN_IdentifierIsStringUPP) (FUNC)) +#define CallNPN_IdentifierIsStringProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_UTF8FromIdentifier */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_UTF8FromIdentifierUPP; +enum { + uppNPN_UTF8FromIdentifierProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPIdentifier))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPUTF8*))) +}; + +#define NewNPN_UTF8FromIdentifierProc(FUNC) \ + (NPN_UTF8FromIdentifierUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_UTF8FromIdentifierProcInfo, GetCurrentArchitecture()) +#define CallNPN_UTF8FromIdentifierProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_UTF8FromIdentifierProcInfo, (ARG1)) + +#else + +typedef NPUTF8* (* NP_LOADDS NPN_UTF8FromIdentifierUPP)(NPIdentifier identifier); +#define NewNPN_UTF8FromIdentifierProc(FUNC) \ + ((NPN_UTF8FromIdentifierUPP) (FUNC)) +#define CallNPN_UTF8FromIdentifierProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_IntFromIdentifier */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_IntFromIdentifierUPP; +enum { + uppNPN_IntFromIdentifierProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPIdentifier))) + | RESULT_SIZE(SIZE_CODE(sizeof(int32_t))) +}; + +#define NewNPN_IntFromIdentifierProc(FUNC) \ + (NPN_IntFromIdentifierUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_IntFromIdentifierProcInfo, GetCurrentArchitecture()) +#define CallNPN_IntFromIdentifierProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_IntFromIdentifierProcInfo, (ARG1)) + +#else + +typedef int32_t (* NP_LOADDS NPN_IntFromIdentifierUPP)(NPIdentifier identifier); +#define NewNPN_IntFromIdentifierProc(FUNC) \ + ((NPN_IntFromIdentifierUPP) (FUNC)) +#define CallNPN_IntFromIdentifierProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_CreateObject */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_CreateObjectUPP; +enum { + uppNPN_CreateObjectProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPClass*))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPObject*))) +}; + +#define NewNPN_CreateObjectProc(FUNC) \ + (NPN_CreateObjectUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_CreateObjectProcInfo, GetCurrentArchitecture()) +#define CallNPN_CreateObjectProc(FUNC, ARG1, ARG2) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_CreateObjectProcInfo, (ARG1), (ARG2)) + +#else + +typedef NPObject* (* NP_LOADDS NPN_CreateObjectUPP)(NPP npp, NPClass *aClass); +#define NewNPN_CreateObjectProc(FUNC) \ + ((NPN_CreateObjectUPP) (FUNC)) +#define CallNPN_CreateObjectProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) + +#endif + +/* NPN_RetainObject */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_RetainObjectUPP; +enum { + uppNPN_RetainObjectProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPObject*))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPObject*))) +}; + +#define NewNPN_RetainObjectProc(FUNC) \ + (NPN_RetainObjectUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_RetainObjectProcInfo, GetCurrentArchitecture()) +#define CallNPN_RetainObjectProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_RetainObjectProcInfo, (ARG1)) + +#else + +typedef NPObject* (* NP_LOADDS NPN_RetainObjectUPP)(NPObject *obj); +#define NewNPN_RetainObjectProc(FUNC) \ + ((NPN_RetainObjectUPP) (FUNC)) +#define CallNPN_RetainObjectProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_ReleaseObject */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_ReleaseObjectUPP; +enum { + uppNPN_ReleaseObjectProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPObject*))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_ReleaseObjectProc(FUNC) \ + (NPN_ReleaseObjectUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ReleaseObjectProcInfo, GetCurrentArchitecture()) +#define CallNPN_ReleaseObjectProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ReleaseObjectProcInfo, (ARG1)) + +#else + +typedef void (* NP_LOADDS NPN_ReleaseObjectUPP)(NPObject *obj); +#define NewNPN_ReleaseObjectProc(FUNC) \ + ((NPN_ReleaseObjectUPP) (FUNC)) +#define CallNPN_ReleaseObjectProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_Invoke */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_InvokeUPP; +enum { + uppNPN_InvokeProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(const NPVariant*))) + | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(uint32_t))) + | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPVariant*))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_InvokeProc(FUNC) \ + (NPN_InvokeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_InvokeProcInfo, GetCurrentArchitecture()) +#define CallNPN_InvokeProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvokeProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6)) + +#else + +typedef bool (* NP_LOADDS NPN_InvokeUPP)(NPP npp, NPObject* obj, NPIdentifier methodName, const NPVariant *args, uint32_t argCount, NPVariant *result); +#define NewNPN_InvokeProc(FUNC) \ + ((NPN_InvokeUPP) (FUNC)) +#define CallNPN_InvokeProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6)) + +#endif + +/* NPN_InvokeDefault */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_InvokeDefaultUPP; +enum { + uppNPN_InvokeDefaultProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(const NPVariant*))) + | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(uint32_t))) + | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPVariant*))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_InvokeDefaultProc(FUNC) \ + (NPN_InvokeDefaultUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_InvokeDefaultProcInfo, GetCurrentArchitecture()) +#define CallNPN_InvokeDefaultProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvokeDefaultProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5)) + +#else + +typedef bool (* NP_LOADDS NPN_InvokeDefaultUPP)(NPP npp, NPObject* obj, const NPVariant *args, uint32_t argCount, NPVariant *result); +#define NewNPN_InvokeDefaultProc(FUNC) \ + ((NPN_InvokeDefaultUPP) (FUNC)) +#define CallNPN_InvokeDefaultProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5)) + +#endif + +/* NPN_Evaluate */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_EvaluateUPP; +enum { + uppNPN_EvaluateProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPString*))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPVariant*))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_EvaluateProc(FUNC) \ + (NPN_EvaluateUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_EvaluateProcInfo, GetCurrentArchitecture()) +#define CallNPN_EvaluateProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_EvaluateProcInfo, (ARG1), (ARG2), (ARG3), (ARG4)) + +#else + +typedef bool (* NP_LOADDS NPN_EvaluateUPP)(NPP npp, NPObject *obj, NPString *script, NPVariant *result); +#define NewNPN_EvaluateProc(FUNC) \ + ((NPN_EvaluateUPP) (FUNC)) +#define CallNPN_EvaluateProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4)) + +#endif + +/* NPN_GetProperty */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetPropertyUPP; +enum { + uppNPN_GetPropertyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPVariant*))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_GetPropertyProc(FUNC) \ + (NPN_GetPropertyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetPropertyProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetPropertyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetPropertyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4)) + +#else + +typedef bool (* NP_LOADDS NPN_GetPropertyUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName, NPVariant *result); +#define NewNPN_GetPropertyProc(FUNC) \ + ((NPN_GetPropertyUPP) (FUNC)) +#define CallNPN_GetPropertyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4)) + +#endif + +/* NPN_SetProperty */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_SetPropertyUPP; +enum { + uppNPN_SetPropertyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(const NPVariant*))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_SetPropertyProc(FUNC) \ + (NPN_SetPropertyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_SetPropertyProcInfo, GetCurrentArchitecture()) +#define CallNPN_SetPropertyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_SetPropertyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4)) + +#else + +typedef bool (* NP_LOADDS NPN_SetPropertyUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName, const NPVariant *value); +#define NewNPN_SetPropertyProc(FUNC) \ + ((NPN_SetPropertyUPP) (FUNC)) +#define CallNPN_SetPropertyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4)) + +#endif + +/* NPN_RemoveProperty */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_RemovePropertyUPP; +enum { + uppNPN_RemovePropertyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_RemovePropertyProc(FUNC) \ + (NPN_RemovePropertyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_RemovePropertyProcInfo, GetCurrentArchitecture()) +#define CallNPN_RemovePropertyProc(FUNC, ARG1, ARG2, ARG3) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_RemovePropertyProcInfo, (ARG1), (ARG2), (ARG3)) + +#else + +typedef bool (* NP_LOADDS NPN_RemovePropertyUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName); +#define NewNPN_RemovePropertyProc(FUNC) \ + ((NPN_RemovePropertyUPP) (FUNC)) +#define CallNPN_RemovePropertyProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) + +#endif + +/* NPN_HasProperty */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_HasPropertyUPP; +enum { + uppNPN_HasPropertyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_HasPropertyProc(FUNC) \ + (NPN_HasPropertyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_HasPropertyProcInfo, GetCurrentArchitecture()) +#define CallNPN_HasPropertyProc(FUNC, ARG1, ARG2, ARG3) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_HasPropertyProcInfo, (ARG1), (ARG2), (ARG3)) + +#else + +typedef bool (* NP_LOADDS NPN_HasPropertyUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName); +#define NewNPN_HasPropertyProc(FUNC) \ + ((NPN_HasPropertyUPP) (FUNC)) +#define CallNPN_HasPropertyProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) + +#endif + +/* NPN_HasMethod */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_HasMethodUPP; +enum { + uppNPN_HasMethodProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_HasMethodProc(FUNC) \ + (NPN_HasMethodUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_HasMethodProcInfo, GetCurrentArchitecture()) +#define CallNPN_HasMethodProc(FUNC, ARG1, ARG2, ARG3) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_HasMethodProcInfo, (ARG1), (ARG2), (ARG3)) + +#else + +typedef bool (* NP_LOADDS NPN_HasMethodUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName); +#define NewNPN_HasMethodProc(FUNC) \ + ((NPN_HasMethodUPP) (FUNC)) +#define CallNPN_HasMethodProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) + +#endif + +/* NPN_ReleaseVariantValue */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_ReleaseVariantValue; +enum { + uppNPN_ReleaseVariantValueProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPVariant*))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_ReleaseVariantValueProc(FUNC) \ + (NPN_ReleaseVariantValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ReleaseVariantValueProcInfo, GetCurrentArchitecture()) +#define CallNPN_ReleaseVariantValueProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ReleaseVariantValueProcInfo, (ARG1)) + +#else + +typedef void (* NP_LOADDS NPN_ReleaseVariantValueUPP)(NPVariant *variant); +#define NewNPN_ReleaseVariantValueProc(FUNC) \ + ((NPN_ReleaseVariantValueUPP) (FUNC)) +#define CallNPN_ReleaseVariantValueProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_SetException */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_SetExceptionUPP; +enum { + uppNPN_SetExceptionProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const NPUTF8*))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_SetExceptionProc(FUNC) \ + (NPN_SetExceptionUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_SetExceptionProcInfo, GetCurrentArchitecture()) +#define CallNPN_SetExceptionProc(FUNC, ARG1, ARG2) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_SetExceptionProcInfo, (ARG1), (ARG2)) + +#else + +typedef void (* NP_LOADDS NPN_SetExceptionUPP)(NPObject *obj, const NPUTF8 *message); +#define NewNPN_SetExceptionProc(FUNC) \ + ((NPN_SetExceptionUPP) (FUNC)) +#define CallNPN_SetExceptionProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) + +#endif + +/* NPN_PushPopupsEnabledStateUPP */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_PushPopupsEnabledStateUPP; +enum { + uppNPN_PushPopupsEnabledStateProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPBool))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_PushPopupsEnabledStateProc(FUNC) \ + (NPN_PushPopupsEnabledStateUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PushPopupsEnabledStateProcInfo, GetCurrentArchitecture()) +#define CallNPN_PushPopupsEnabledStateProc(FUNC, ARG1, ARG2) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PushPopupsEnabledStateProcInfo, (ARG1), (ARG2)) + +#else + +typedef bool (* NP_LOADDS NPN_PushPopupsEnabledStateUPP)(NPP npp, NPBool enabled); +#define NewNPN_PushPopupsEnabledStateProc(FUNC) \ + ((NPN_PushPopupsEnabledStateUPP) (FUNC)) +#define CallNPN_PushPopupsEnabledStateProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) + +#endif + +/* NPN_PopPopupsEnabledState */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_PopPopupsEnabledStateUPP; +enum { + uppNPN_PopPopupsEnabledStateProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_PopPopupsEnabledStateProc(FUNC) \ + (NPN_PopPopupsEnabledStateUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PopPopupsEnabledStateProcInfo, GetCurrentArchitecture()) +#define CallNPN_PopPopupsEnabledStateProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PopPopupsEnabledStateProcInfo, (ARG1)) + +#else + +typedef bool (* NP_LOADDS NPN_PopPopupsEnabledStateUPP)(NPP npp); +#define NewNPN_PopPopupsEnabledStateProc(FUNC) \ + ((NPN_PopPopupsEnabledStateUPP) (FUNC)) +#define CallNPN_PopPopupsEnabledStateProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + + + +/****************************************************************************************** + * The actual plugin function table definitions + *******************************************************************************************/ + +#ifdef XP_MAC +#if PRAGMA_STRUCT_ALIGN +#pragma options align=mac68k +#endif +#endif + +typedef struct _NPPluginFuncs { + uint16 size; + uint16 version; + NPP_NewUPP newp; + NPP_DestroyUPP destroy; + NPP_SetWindowUPP setwindow; + NPP_NewStreamUPP newstream; + NPP_DestroyStreamUPP destroystream; + NPP_StreamAsFileUPP asfile; + NPP_WriteReadyUPP writeready; + NPP_WriteUPP write; + NPP_PrintUPP print; + NPP_HandleEventUPP event; + NPP_URLNotifyUPP urlnotify; + JRIGlobalRef javaClass; + NPP_GetValueUPP getvalue; + NPP_SetValueUPP setvalue; +} NPPluginFuncs; + +typedef struct _NPNetscapeFuncs { + uint16 size; + uint16 version; + NPN_GetURLUPP geturl; + NPN_PostURLUPP posturl; + NPN_RequestReadUPP requestread; + NPN_NewStreamUPP newstream; + NPN_WriteUPP write; + NPN_DestroyStreamUPP destroystream; + NPN_StatusUPP status; + NPN_UserAgentUPP uagent; + NPN_MemAllocUPP memalloc; + NPN_MemFreeUPP memfree; + NPN_MemFlushUPP memflush; + NPN_ReloadPluginsUPP reloadplugins; + NPN_GetJavaEnvUPP getJavaEnv; + NPN_GetJavaPeerUPP getJavaPeer; + NPN_GetURLNotifyUPP geturlnotify; + NPN_PostURLNotifyUPP posturlnotify; + NPN_GetValueUPP getvalue; + NPN_SetValueUPP setvalue; + NPN_InvalidateRectUPP invalidaterect; + NPN_InvalidateRegionUPP invalidateregion; + NPN_ForceRedrawUPP forceredraw; + NPN_GetStringIdentifierUPP getstringidentifier; + NPN_GetStringIdentifiersUPP getstringidentifiers; + NPN_GetIntIdentifierUPP getintidentifier; + NPN_IdentifierIsStringUPP identifierisstring; + NPN_UTF8FromIdentifierUPP utf8fromidentifier; + NPN_IntFromIdentifierUPP intfromidentifier; + NPN_CreateObjectUPP createobject; + NPN_RetainObjectUPP retainobject; + NPN_ReleaseObjectUPP releaseobject; + NPN_InvokeUPP invoke; + NPN_InvokeDefaultUPP invokeDefault; + NPN_EvaluateUPP evaluate; + NPN_GetPropertyUPP getproperty; + NPN_SetPropertyUPP setproperty; + NPN_RemovePropertyUPP removeproperty; + NPN_HasPropertyUPP hasproperty; + NPN_HasMethodUPP hasmethod; + NPN_ReleaseVariantValueUPP releasevariantvalue; + NPN_SetExceptionUPP setexception; + NPN_PushPopupsEnabledStateUPP pushpopupsenabledstate; + NPN_PopPopupsEnabledStateUPP poppopupsenabledstate; +} NPNetscapeFuncs; + +#ifdef XP_MAC +#if PRAGMA_STRUCT_ALIGN +#pragma options align=reset +#endif +#endif + + +#if defined(XP_MAC) || defined(XP_MACOSX) +/****************************************************************************************** + * Mac platform-specific plugin glue stuff + *******************************************************************************************/ + +/* + * Main entry point of the plugin. + * This routine will be called when the plugin is loaded. The function + * tables are passed in and the plugin fills in the NPPluginFuncs table + * and NPPShutdownUPP for Netscape's use. + */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_MainEntryUPP; +enum { + uppNPP_MainEntryProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPNetscapeFuncs*))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPluginFuncs*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPP_ShutdownUPP*))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPP_MainEntryProc(FUNC) \ + (NPP_MainEntryUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_MainEntryProcInfo, GetCurrentArchitecture()) +#define CallNPP_MainEntryProc(FUNC, netscapeFunc, pluginFunc, shutdownUPP) \ + CallUniversalProc((UniversalProcPtr)(FUNC), (ProcInfoType)uppNPP_MainEntryProcInfo, (netscapeFunc), (pluginFunc), (shutdownUPP)) + +#else + +typedef NPError (* NP_LOADDS NPP_MainEntryUPP)(NPNetscapeFuncs*, NPPluginFuncs*, NPP_ShutdownUPP*); +#define NewNPP_MainEntryProc(FUNC) \ + ((NPP_MainEntryUPP) (FUNC)) +#define CallNPP_MainEntryProc(FUNC, netscapeFunc, pluginFunc, shutdownUPP) \ + (*(FUNC))((netscapeFunc), (pluginFunc), (shutdownUPP)) + +#endif + + +/* + * Mac version(s) of NP_GetMIMEDescription(const char *) + * These can be called to retreive MIME information from the plugin dynamically + * + * Note: For compatibility with Quicktime, BPSupportedMIMEtypes is another way + * to get mime info from the plugin only on OSX and may not be supported + * in furture version--use NP_GetMIMEDescription instead + */ + +enum +{ + kBPSupportedMIMETypesStructVers_1 = 1 +}; + +typedef struct _BPSupportedMIMETypes +{ + SInt32 structVersion; /* struct version */ + Handle typeStrings; /* STR# formated handle, allocated by plug-in */ + Handle infoStrings; /* STR# formated handle, allocated by plug-in */ +} BPSupportedMIMETypes; +OSErr BP_GetSupportedMIMETypes(BPSupportedMIMETypes *mimeInfo, UInt32 flags); + +#if _NPUPP_USE_UPP_ + +#define NP_GETMIMEDESCRIPTION_NAME "NP_GetMIMEDescriptionRD" +typedef UniversalProcPtr NP_GetMIMEDescriptionUPP; +enum { + uppNP_GetMIMEDescEntryProc = kThinkCStackBased + | RESULT_SIZE(SIZE_CODE(sizeof(const char *))) +}; +#define NewNP_GetMIMEDescEntryProc(FUNC) \ + (NP_GetMIMEDescriptionUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNP_GetMIMEDescEntryProc, GetCurrentArchitecture()) +#define CallNP_GetMIMEDescEntryProc(FUNC) \ + (const char *)CallUniversalProc((UniversalProcPtr)(FUNC), (ProcInfoType)uppNP_GetMIMEDescEntryProc) + + +#else /* !_NPUPP_USE_UPP_ */ + + /* NP_GetMIMEDescription */ +#define NP_GETMIMEDESCRIPTION_NAME "NP_GetMIMEDescription" +typedef const char* (* NP_LOADDS NP_GetMIMEDescriptionUPP)(); +#define NewNP_GetMIMEDescEntryProc(FUNC) \ + ((NP_GetMIMEDescriptionUPP) (FUNC)) +#define CallNP_GetMIMEDescEntryProc(FUNC) \ + (*(FUNC))() +/* BP_GetSupportedMIMETypes */ +typedef OSErr (* NP_LOADDS BP_GetSupportedMIMETypesUPP)(BPSupportedMIMETypes*, UInt32); +#define NewBP_GetSupportedMIMETypesEntryProc(FUNC) \ + ((BP_GetSupportedMIMETypesUPP) (FUNC)) +#define CallBP_GetMIMEDescEntryProc(FUNC, mimeInfo, flags) \ + (*(FUNC))((mimeInfo), (flags)) + +#endif +#endif /* MAC */ + +#if defined(_WINDOWS) +#define OSCALL WINAPI +#else +#if defined(__OS2__) +#define OSCALL _System +#else +#define OSCALL +#endif +#endif + +#if defined( _WINDOWS ) || defined (__OS2__) + +#ifdef __cplusplus +extern "C" { +#endif + +/* plugin meta member functions */ +#if defined(__OS2__) + +typedef struct _NPPluginData { /* Alternate OS2 Plugin interface */ + char *pMimeTypes; + char *pFileExtents; + char *pFileOpenTemplate; + char *pProductName; + char *pProductDescription; + unsigned long dwProductVersionMS; + unsigned long dwProductVersionLS; +} NPPluginData; + +NPError OSCALL NP_GetPluginData(NPPluginData * pPluginData); + +#endif + +NPError OSCALL NP_GetEntryPoints(NPPluginFuncs* pFuncs); + +NPError OSCALL NP_Initialize(NPNetscapeFuncs* pFuncs); + +NPError OSCALL NP_Shutdown(); + +char* NP_GetMIMEDescription(); + +#ifdef __cplusplus +} +#endif + +#endif /* _WINDOWS || __OS2__ */ + +#if defined(__OS2__) +#pragma pack() +#endif + +#ifdef XP_UNIX + +#ifdef __cplusplus +extern "C" { +#endif + +/* plugin meta member functions */ + +char* NP_GetMIMEDescription(void); +NPError NP_Initialize(NPNetscapeFuncs*, NPPluginFuncs*); +NPError NP_Shutdown(void); +NPError NP_GetValue(void *future, NPPVariable aVariable, void *aValue); + +#ifdef __cplusplus +} +#endif + +#endif /* XP_UNIX */ + +#endif /* _NPUPP_H_ */ diff --git a/nsplugins/sdk/obsolete/protypes.h b/nsplugins/sdk/obsolete/protypes.h new file mode 100644 index 000000000..e96cfcf67 --- /dev/null +++ b/nsplugins/sdk/obsolete/protypes.h @@ -0,0 +1,251 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * 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 the Netscape Portable Runtime (NSPR). + * + * The Initial Developer of the Original Code is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998-2000 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 or later (the + * "GPL"), in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your + * version of this file only under the terms of the GPL and not to + * allow others to use your version of this file under the MPL, + * indicate your decision by deleting the provisions above and + * replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient + * may use your version of this file under either the MPL or the + * GPL. + */ + +/* + * This header typedefs the old 'native' types to the new PR<type>s. + * These definitions are scheduled to be eliminated at the earliest + * possible time. The NSPR API is implemented and documented using + * the new definitions. + */ + +#if !defined(PROTYPES_H) +#define PROTYPES_H + +typedef PRUintn uintn; +#ifndef _XP_Core_ +typedef PRIntn intn; +#endif + +/* + * It is trickier to define uint, int8, uint8, int16, uint16, + * int32, uint32, int64, and uint64 because some of these int + * types are defined by standard header files on some platforms. + * Our strategy here is to include all such standard headers + * first, and then define these int types only if they are not + * defined by those standard headers. + */ + +/* + * BeOS defines all the int types below in its standard header + * file SupportDefs.h. + */ +#ifdef XP_BEOS +#include <support/SupportDefs.h> +#endif + +/* + * OpenVMS defines all the int types below in its standard + * header files ints.h and types.h. + */ +#ifdef VMS +#include <ints.h> +#include <types.h> +#endif + +/* + * SVR4 typedef of uint is commonly found on UNIX machines. + * + * On AIX 4.3, sys/inttypes.h (which is included by sys/types.h) + * defines the types int8, int16, int32, and int64. + */ +#ifdef XP_UNIX +#include <sys/types.h> +#endif + +/* model.h on HP-UX defines int8, int16, and int32. */ +#ifdef HPUX +#include <model.h> +#endif + +/* + * uint + */ + +#if !defined(XP_BEOS) && !defined(VMS) \ + && !defined(XP_UNIX) || defined(NTO) +typedef PRUintn uint; +#endif + +/* + * uint64 + */ + +#if !defined(XP_BEOS) && !defined(VMS) +typedef PRUint64 uint64; +#endif + +/* + * uint32 + */ + +#if !defined(XP_BEOS) && !defined(VMS) +#if !defined(XP_MAC) && !defined(_WIN32) && !defined(XP_OS2) && !defined(NTO) +typedef PRUint32 uint32; +#else +typedef unsigned long uint32; +#endif +#endif + +/* + * uint16 + */ + +#if !defined(XP_BEOS) && !defined(VMS) +typedef PRUint16 uint16; +#endif + +/* + * uint8 + */ + +#if !defined(XP_BEOS) && !defined(VMS) +typedef PRUint8 uint8; +#endif + +/* + * int64 + */ + +#if !defined(XP_BEOS) && !defined(VMS) \ + && !defined(_PR_AIX_HAVE_BSD_INT_TYPES) +typedef PRInt64 int64; +#endif + +/* + * int32 + */ + +#if !defined(XP_BEOS) && !defined(VMS) \ + && !defined(_PR_AIX_HAVE_BSD_INT_TYPES) \ + && !defined(HPUX) +#if !defined(WIN32) || !defined(_WINSOCK2API_) /* defines its own "int32" */ +#if !defined(XP_MAC) && !defined(_WIN32) && !defined(XP_OS2) && !defined(NTO) +typedef PRInt32 int32; +#else +typedef long int32; +#endif +#endif +#endif + +/* + * int16 + */ + +#if !defined(XP_BEOS) && !defined(VMS) \ + && !defined(_PR_AIX_HAVE_BSD_INT_TYPES) \ + && !defined(HPUX) +typedef PRInt16 int16; +#endif + +/* + * int8 + */ + +#if !defined(XP_BEOS) && !defined(VMS) \ + && !defined(_PR_AIX_HAVE_BSD_INT_TYPES) \ + && !defined(HPUX) +typedef PRInt8 int8; +#endif + +typedef PRFloat64 float64; +typedef PRUptrdiff uptrdiff_t; +typedef PRUword uprword_t; +typedef PRWord prword_t; + + +/* Re: prbit.h */ +#define TEST_BIT PR_TEST_BIT +#define SET_BIT PR_SET_BIT +#define CLEAR_BIT PR_CLEAR_BIT + +/* Re: prarena.h->plarena.h */ +#define PRArena PLArena +#define PRArenaPool PLArenaPool +#define PRArenaStats PLArenaStats +#define PR_ARENA_ALIGN PL_ARENA_ALIGN +#define PR_INIT_ARENA_POOL PL_INIT_ARENA_POOL +#define PR_ARENA_ALLOCATE PL_ARENA_ALLOCATE +#define PR_ARENA_GROW PL_ARENA_GROW +#define PR_ARENA_MARK PL_ARENA_MARK +#define PR_CLEAR_UNUSED PL_CLEAR_UNUSED +#define PR_CLEAR_ARENA PL_CLEAR_ARENA +#define PR_ARENA_RELEASE PL_ARENA_RELEASE +#define PR_COUNT_ARENA PL_COUNT_ARENA +#define PR_ARENA_DESTROY PL_ARENA_DESTROY +#define PR_InitArenaPool PL_InitArenaPool +#define PR_FreeArenaPool PL_FreeArenaPool +#define PR_FinishArenaPool PL_FinishArenaPool +#define PR_CompactArenaPool PL_CompactArenaPool +#define PR_ArenaFinish PL_ArenaFinish +#define PR_ArenaAllocate PL_ArenaAllocate +#define PR_ArenaGrow PL_ArenaGrow +#define PR_ArenaRelease PL_ArenaRelease +#define PR_ArenaCountAllocation PL_ArenaCountAllocation +#define PR_ArenaCountInplaceGrowth PL_ArenaCountInplaceGrowth +#define PR_ArenaCountGrowth PL_ArenaCountGrowth +#define PR_ArenaCountRelease PL_ArenaCountRelease +#define PR_ArenaCountRetract PL_ArenaCountRetract + +/* Re: prhash.h->plhash.h */ +#define PRHashEntry PLHashEntry +#define PRHashTable PLHashTable +#define PRHashNumber PLHashNumber +#define PRHashFunction PLHashFunction +#define PRHashComparator PLHashComparator +#define PRHashEnumerator PLHashEnumerator +#define PRHashAllocOps PLHashAllocOps +#define PR_NewHashTable PL_NewHashTable +#define PR_HashTableDestroy PL_HashTableDestroy +#define PR_HashTableRawLookup PL_HashTableRawLookup +#define PR_HashTableRawAdd PL_HashTableRawAdd +#define PR_HashTableRawRemove PL_HashTableRawRemove +#define PR_HashTableAdd PL_HashTableAdd +#define PR_HashTableRemove PL_HashTableRemove +#define PR_HashTableEnumerateEntries PL_HashTableEnumerateEntries +#define PR_HashTableLookup PL_HashTableLookup +#define PR_HashTableDump PL_HashTableDump +#define PR_HashString PL_HashString +#define PR_CompareStrings PL_CompareStrings +#define PR_CompareValues PL_CompareValues + +#if defined(XP_MAC) +#ifndef TRUE /* Mac standard is lower case true */ + #define TRUE 1 +#endif +#ifndef FALSE /* Mac standard is lower case false */ + #define FALSE 0 +#endif +#endif + +#endif /* !defined(PROTYPES_H) */ diff --git a/nsplugins/sdk/prcpucfg.h b/nsplugins/sdk/prcpucfg.h new file mode 100644 index 000000000..b2d1cebdb --- /dev/null +++ b/nsplugins/sdk/prcpucfg.h @@ -0,0 +1,663 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * 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 the Netscape Portable Runtime (NSPR). + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998-2000 + * 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 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 ***** */ + +#ifndef nspr_cpucfg___ +#define nspr_cpucfg___ + +#ifndef XP_UNIX +#define XP_UNIX +#endif + +#ifndef LINUX +#define LINUX +#endif + +#define PR_AF_INET6 10 /* same as AF_INET6 */ + +#ifdef __powerpc__ + +#undef IS_LITTLE_ENDIAN +#define IS_BIG_ENDIAN 1 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__alpha) + +#define IS_LITTLE_ENDIAN 1 +#undef IS_BIG_ENDIAN +#define IS_64 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 8 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 8 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 64 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 64 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 6 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 6 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 8 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 8 +#define PR_ALIGN_OF_WORD 8 + +#define PR_BYTES_PER_WORD_LOG2 3 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__ia64__) + +#define IS_LITTLE_ENDIAN 1 +#undef IS_BIG_ENDIAN +#define IS_64 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 8 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 8 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 64 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 64 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 6 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 6 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 8 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 8 +#define PR_ALIGN_OF_WORD 8 + +#define PR_BYTES_PER_WORD_LOG2 3 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__x86_64__) + +#define IS_LITTLE_ENDIAN 1 +#undef IS_BIG_ENDIAN +#define IS_64 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 8 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 8 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 64 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 64 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 6 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 6 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 8 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 8 +#define PR_ALIGN_OF_WORD 8 + +#define PR_BYTES_PER_WORD_LOG2 3 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__mc68000__) + +#undef IS_LITTLE_ENDIAN +#define IS_BIG_ENDIAN 1 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 2 +#define PR_ALIGN_OF_LONG 2 +#define PR_ALIGN_OF_INT64 2 +#define PR_ALIGN_OF_FLOAT 2 +#define PR_ALIGN_OF_DOUBLE 2 +#define PR_ALIGN_OF_POINTER 2 +#define PR_ALIGN_OF_WORD 2 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__sparc__) || (defined(__SUNPRO_CC) && defined(__sparc)) + +#undef IS_LITTLE_ENDIAN +#define IS_BIG_ENDIAN 1 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__i386__) || (defined(__SUNPRO_CC) && defined(__i386)) + +#define IS_LITTLE_ENDIAN 1 +#undef IS_BIG_ENDIAN + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 4 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 4 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__mips__) + +#ifdef __MIPSEB__ +#define IS_BIG_ENDIAN 1 +#undef IS_LITTLE_ENDIAN +#elif defined(__MIPSEL__) +#define IS_LITTLE_ENDIAN 1 +#undef IS_BIG_ENDIAN +#else +#error "Unknown MIPS endianness." +#endif + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__arm__) + +#define IS_LITTLE_ENDIAN 1 +#undef IS_BIG_ENDIAN + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 4 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 4 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__hppa__) + +#undef IS_LITTLE_ENDIAN +#define IS_BIG_ENDIAN 1 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__s390x__) + +#define IS_BIG_ENDIAN 1 +#undef IS_LITTLE_ENDIAN +#define IS_64 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 8 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 8 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 64 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 64 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 6 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 6 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 8 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 8 +#define PR_ALIGN_OF_WORD 8 + +#define PR_BYTES_PER_WORD_LOG2 3 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__s390__) + +#define IS_BIG_ENDIAN 1 +#undef IS_LITTLE_ENDIAN + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 4 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 4 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#else + +#error "Unknown CPU architecture" + +#endif + +#define HAVE_LONG_LONG 1 +#if PR_ALIGN_OF_DOUBLE == 8 +#define HAVE_ALIGNED_DOUBLES +#endif +#if PR_ALIGN_OF_INT64 == 8 +#define HAVE_ALIGNED_LONGLONGS +#endif + +#ifndef NO_NSPR_10_SUPPORT + +#define BYTES_PER_BYTE PR_BYTES_PER_BYTE +#define BYTES_PER_SHORT PR_BYTES_PER_SHORT +#define BYTES_PER_INT PR_BYTES_PER_INT +#define BYTES_PER_INT64 PR_BYTES_PER_INT64 +#define BYTES_PER_LONG PR_BYTES_PER_LONG +#define BYTES_PER_FLOAT PR_BYTES_PER_FLOAT +#define BYTES_PER_DOUBLE PR_BYTES_PER_DOUBLE +#define BYTES_PER_WORD PR_BYTES_PER_WORD +#define BYTES_PER_DWORD PR_BYTES_PER_DWORD + +#define BITS_PER_BYTE PR_BITS_PER_BYTE +#define BITS_PER_SHORT PR_BITS_PER_SHORT +#define BITS_PER_INT PR_BITS_PER_INT +#define BITS_PER_INT64 PR_BITS_PER_INT64 +#ifndef BITS_PER_LONG +#define BITS_PER_LONG PR_BITS_PER_LONG +#endif +#define BITS_PER_FLOAT PR_BITS_PER_FLOAT +#define BITS_PER_DOUBLE PR_BITS_PER_DOUBLE +#define BITS_PER_WORD PR_BITS_PER_WORD + +#define BITS_PER_BYTE_LOG2 PR_BITS_PER_BYTE_LOG2 +#define BITS_PER_SHORT_LOG2 PR_BITS_PER_SHORT_LOG2 +#define BITS_PER_INT_LOG2 PR_BITS_PER_INT_LOG2 +#define BITS_PER_INT64_LOG2 PR_BITS_PER_INT64_LOG2 +#define BITS_PER_LONG_LOG2 PR_BITS_PER_LONG_LOG2 +#define BITS_PER_FLOAT_LOG2 PR_BITS_PER_FLOAT_LOG2 +#define BITS_PER_DOUBLE_LOG2 PR_BITS_PER_DOUBLE_LOG2 +#define BITS_PER_WORD_LOG2 PR_BITS_PER_WORD_LOG2 + +#define ALIGN_OF_SHORT PR_ALIGN_OF_SHORT +#define ALIGN_OF_INT PR_ALIGN_OF_INT +#define ALIGN_OF_LONG PR_ALIGN_OF_LONG +#define ALIGN_OF_INT64 PR_ALIGN_OF_INT64 +#define ALIGN_OF_FLOAT PR_ALIGN_OF_FLOAT +#define ALIGN_OF_DOUBLE PR_ALIGN_OF_DOUBLE +#define ALIGN_OF_POINTER PR_ALIGN_OF_POINTER +#define ALIGN_OF_WORD PR_ALIGN_OF_WORD + +#define BYTES_PER_WORD_LOG2 PR_BYTES_PER_WORD_LOG2 +#define BYTES_PER_DWORD_LOG2 PR_BYTES_PER_DWORD_LOG2 +#define WORDS_PER_DWORD_LOG2 PR_WORDS_PER_DWORD_LOG2 + +#endif /* NO_NSPR_10_SUPPORT */ + +#endif /* nspr_cpucfg___ */ diff --git a/nsplugins/sdk/prtypes.h b/nsplugins/sdk/prtypes.h new file mode 100644 index 000000000..b68361082 --- /dev/null +++ b/nsplugins/sdk/prtypes.h @@ -0,0 +1,543 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * 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 the Netscape Portable Runtime (NSPR). + * + * The Initial Developer of the Original Code is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998-2000 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 or later (the + * "GPL"), in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your + * version of this file only under the terms of the GPL and not to + * allow others to use your version of this file under the MPL, + * indicate your decision by deleting the provisions above and + * replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient + * may use your version of this file under either the MPL or the + * GPL. + */ + +/* +** File: prtypes.h +** Description: Definitions of NSPR's basic types +** +** Prototypes and macros used to make up for deficiencies in ANSI environments +** that we have found. +** +** Since we do not wrap <stdlib.h> and all the other standard headers, authors +** of portable code will not know in general that they need these definitions. +** Instead of requiring these authors to find the dependent uses in their code +** and take the following steps only in those C files, we take steps once here +** for all C files. +**/ + +#ifndef prtypes_h___ +#define prtypes_h___ + +#ifdef MDCPUCFG +#include MDCPUCFG +#else +#include "prcpucfg.h" +#endif + +#include <stddef.h> + +/*********************************************************************** +** MACROS: PR_EXTERN +** PR_IMPLEMENT +** DESCRIPTION: +** These are only for externally visible routines and globals. For +** internal routines, just use "extern" for type checking and that +** will not export internal cross-file or forward-declared symbols. +** Define a macro for declaring procedures return types. We use this to +** deal with windoze specific type hackery for DLL definitions. Use +** PR_EXTERN when the prototype for the method is declared. Use +** PR_IMPLEMENT for the implementation of the method. +** +** Example: +** in dowhim.h +** PR_EXTERN( void ) DoWhatIMean( void ); +** in dowhim.c +** PR_IMPLEMENT( void ) DoWhatIMean( void ) { return; } +** +** +***********************************************************************/ +#if defined(WIN32) + +#if defined(__GNUC__) +#undef _declspec +#define _declspec(x) __declspec(x) +#endif + +#define PR_EXPORT(__type) extern _declspec(dllexport) __type +#define PR_EXPORT_DATA(__type) extern _declspec(dllexport) __type +#define PR_IMPORT(__type) _declspec(dllimport) __type +#define PR_IMPORT_DATA(__type) _declspec(dllimport) __type + +#define PR_EXTERN(__type) extern _declspec(dllexport) __type +#define PR_IMPLEMENT(__type) _declspec(dllexport) __type +#define PR_EXTERN_DATA(__type) extern _declspec(dllexport) __type +#define PR_IMPLEMENT_DATA(__type) _declspec(dllexport) __type + +#define PR_CALLBACK +#define PR_CALLBACK_DECL +#define PR_STATIC_CALLBACK(__x) static __x + +#elif defined(XP_BEOS) + +#define PR_EXPORT(__type) extern __declspec(dllexport) __type +#define PR_EXPORT_DATA(__type) extern __declspec(dllexport) __type +#define PR_IMPORT(__type) extern __declspec(dllexport) __type +#define PR_IMPORT_DATA(__type) extern __declspec(dllexport) __type + +#define PR_EXTERN(__type) extern __declspec(dllexport) __type +#define PR_IMPLEMENT(__type) __declspec(dllexport) __type +#define PR_EXTERN_DATA(__type) extern __declspec(dllexport) __type +#define PR_IMPLEMENT_DATA(__type) __declspec(dllexport) __type + +#define PR_CALLBACK +#define PR_CALLBACK_DECL +#define PR_STATIC_CALLBACK(__x) static __x + +#elif defined(WIN16) + +#define PR_CALLBACK_DECL __cdecl + +#if defined(_WINDLL) +#define PR_EXPORT(__type) extern __type _cdecl _export _loadds +#define PR_IMPORT(__type) extern __type _cdecl _export _loadds +#define PR_EXPORT_DATA(__type) extern __type _export +#define PR_IMPORT_DATA(__type) extern __type _export + +#define PR_EXTERN(__type) extern __type _cdecl _export _loadds +#define PR_IMPLEMENT(__type) __type _cdecl _export _loadds +#define PR_EXTERN_DATA(__type) extern __type _export +#define PR_IMPLEMENT_DATA(__type) __type _export + +#define PR_CALLBACK __cdecl __loadds +#define PR_STATIC_CALLBACK(__x) static __x PR_CALLBACK + +#else /* this must be .EXE */ +#define PR_EXPORT(__type) extern __type _cdecl _export +#define PR_IMPORT(__type) extern __type _cdecl _export +#define PR_EXPORT_DATA(__type) extern __type _export +#define PR_IMPORT_DATA(__type) extern __type _export + +#define PR_EXTERN(__type) extern __type _cdecl _export +#define PR_IMPLEMENT(__type) __type _cdecl _export +#define PR_EXTERN_DATA(__type) extern __type _export +#define PR_IMPLEMENT_DATA(__type) __type _export + +#define PR_CALLBACK __cdecl __loadds +#define PR_STATIC_CALLBACK(__x) __x PR_CALLBACK +#endif /* _WINDLL */ + +#elif defined(XP_MAC) + +#define PR_EXPORT(__type) extern __declspec(export) __type +#define PR_EXPORT_DATA(__type) extern __declspec(export) __type +#define PR_IMPORT(__type) extern __declspec(export) __type +#define PR_IMPORT_DATA(__type) extern __declspec(export) __type + +#define PR_EXTERN(__type) extern __declspec(export) __type +#define PR_IMPLEMENT(__type) __declspec(export) __type +#define PR_EXTERN_DATA(__type) extern __declspec(export) __type +#define PR_IMPLEMENT_DATA(__type) __declspec(export) __type + +#define PR_CALLBACK +#define PR_CALLBACK_DECL +#define PR_STATIC_CALLBACK(__x) static __x + +#elif defined(XP_OS2_VACPP) + +#define PR_EXPORT(__type) extern __type +#define PR_EXPORT_DATA(__type) extern __type +#define PR_IMPORT(__type) extern __type +#define PR_IMPORT_DATA(__type) extern __type + +#define PR_EXTERN(__type) extern __type +#define PR_IMPLEMENT(__type) __type +#define PR_EXTERN_DATA(__type) extern __type +#define PR_IMPLEMENT_DATA(__type) __type +#define PR_CALLBACK _Optlink +#define PR_CALLBACK_DECL +#define PR_STATIC_CALLBACK(__x) static __x PR_CALLBACK + +#else /* Unix */ + +#define PR_EXPORT(__type) extern __type +#define PR_EXPORT_DATA(__type) extern __type +#define PR_IMPORT(__type) extern __type +#define PR_IMPORT_DATA(__type) extern __type + +#define PR_EXTERN(__type) extern __type +#define PR_IMPLEMENT(__type) __type +#define PR_EXTERN_DATA(__type) extern __type +#define PR_IMPLEMENT_DATA(__type) __type +#define PR_CALLBACK +#define PR_CALLBACK_DECL +#define PR_STATIC_CALLBACK(__x) static __x + +#endif + +#if defined(_NSPR_BUILD_) +#define NSPR_API(__type) PR_EXPORT(__type) +#define NSPR_DATA_API(__type) PR_EXPORT_DATA(__type) +#else +#define NSPR_API(__type) PR_IMPORT(__type) +#define NSPR_DATA_API(__type) PR_IMPORT_DATA(__type) +#endif + +/*********************************************************************** +** MACROS: PR_BEGIN_MACRO +** PR_END_MACRO +** DESCRIPTION: +** Macro body brackets so that macros with compound statement definitions +** behave syntactically more like functions when called. +***********************************************************************/ +#define PR_BEGIN_MACRO do { +#define PR_END_MACRO } while (0) + +/*********************************************************************** +** MACROS: PR_BEGIN_EXTERN_C +** PR_END_EXTERN_C +** DESCRIPTION: +** Macro shorthands for conditional C++ extern block delimiters. +***********************************************************************/ +#ifdef __cplusplus +#define PR_BEGIN_EXTERN_C extern "C" { +#define PR_END_EXTERN_C } +#else +#define PR_BEGIN_EXTERN_C +#define PR_END_EXTERN_C +#endif + +/*********************************************************************** +** MACROS: PR_BIT +** PR_BITMASK +** DESCRIPTION: +** Bit masking macros. XXX n must be <= 31 to be portable +***********************************************************************/ +#define PR_BIT(n) ((PRUint32)1 << (n)) +#define PR_BITMASK(n) (PR_BIT(n) - 1) + +/*********************************************************************** +** MACROS: PR_ROUNDUP +** PR_MIN +** PR_MAX +** PR_ABS +** DESCRIPTION: +** Commonly used macros for operations on compatible types. +***********************************************************************/ +#define PR_ROUNDUP(x,y) ((((x)+((y)-1))/(y))*(y)) +#define PR_MIN(x,y) ((x)<(y)?(x):(y)) +#define PR_MAX(x,y) ((x)>(y)?(x):(y)) +#define PR_ABS(x) ((x)<0?-(x):(x)) + +PR_BEGIN_EXTERN_C + +/************************************************************************ +** TYPES: PRUint8 +** PRInt8 +** DESCRIPTION: +** The int8 types are known to be 8 bits each. There is no type that +** is equivalent to a plain "char". +************************************************************************/ +#if PR_BYTES_PER_BYTE == 1 +typedef unsigned char PRUint8; +/* +** Some cfront-based C++ compilers do not like 'signed char' and +** issue the warning message: +** warning: "signed" not implemented (ignored) +** For these compilers, we have to define PRInt8 as plain 'char'. +** Make sure that plain 'char' is indeed signed under these compilers. +*/ +#if (defined(HPUX) && defined(__cplusplus) \ + && !defined(__GNUC__) && __cplusplus < 199707L) \ + || (defined(SCO) && defined(__cplusplus) \ + && !defined(__GNUC__) && __cplusplus == 1L) +typedef char PRInt8; +#else +typedef signed char PRInt8; +#endif +#else +#error No suitable type for PRInt8/PRUint8 +#endif + +/************************************************************************ + * MACROS: PR_INT8_MAX + * PR_INT8_MIN + * PR_UINT8_MAX + * DESCRIPTION: + * The maximum and minimum values of a PRInt8 or PRUint8. +************************************************************************/ + +#define PR_INT8_MAX 127 +#define PR_INT8_MIN (-128) +#define PR_UINT8_MAX 255U + +/************************************************************************ +** TYPES: PRUint16 +** PRInt16 +** DESCRIPTION: +** The int16 types are known to be 16 bits each. +************************************************************************/ +#if PR_BYTES_PER_SHORT == 2 +typedef unsigned short PRUint16; +typedef short PRInt16; +#else +#error No suitable type for PRInt16/PRUint16 +#endif + +/************************************************************************ + * MACROS: PR_INT16_MAX + * PR_INT16_MIN + * PR_UINT16_MAX + * DESCRIPTION: + * The maximum and minimum values of a PRInt16 or PRUint16. +************************************************************************/ + +#define PR_INT16_MAX 32767 +#define PR_INT16_MIN (-32768) +#define PR_UINT16_MAX 65535U + +/************************************************************************ +** TYPES: PRUint32 +** PRInt32 +** DESCRIPTION: +** The int32 types are known to be 32 bits each. +************************************************************************/ +#if PR_BYTES_PER_INT == 4 +typedef unsigned int PRUint32; +typedef int PRInt32; +#define PR_INT32(x) x +#define PR_UINT32(x) x ## U +#elif PR_BYTES_PER_LONG == 4 +typedef unsigned long PRUint32; +typedef long PRInt32; +#define PR_INT32(x) x ## L +#define PR_UINT32(x) x ## UL +#else +#error No suitable type for PRInt32/PRUint32 +#endif + +/************************************************************************ + * MACROS: PR_INT32_MAX + * PR_INT32_MIN + * PR_UINT32_MAX + * DESCRIPTION: + * The maximum and minimum values of a PRInt32 or PRUint32. +************************************************************************/ + +#define PR_INT32_MAX PR_INT32(2147483647) +#define PR_INT32_MIN (-PR_INT32_MAX - 1) +#define PR_UINT32_MAX PR_UINT32(4294967295) + +/************************************************************************ +** TYPES: PRUint64 +** PRInt64 +** DESCRIPTION: +** The int64 types are known to be 64 bits each. Care must be used when +** declaring variables of type PRUint64 or PRInt64. Different hardware +** architectures and even different compilers have varying support for +** 64 bit values. The only guaranteed portability requires the use of +** the LL_ macros (see prlong.h). +************************************************************************/ +#ifdef HAVE_LONG_LONG +#if PR_BYTES_PER_LONG == 8 +typedef long PRInt64; +typedef unsigned long PRUint64; +#elif defined(WIN16) +typedef __int64 PRInt64; +typedef unsigned __int64 PRUint64; +#elif defined(WIN32) && !defined(__GNUC__) +typedef __int64 PRInt64; +typedef unsigned __int64 PRUint64; +#else +typedef long long PRInt64; +typedef unsigned long long PRUint64; +#endif /* PR_BYTES_PER_LONG == 8 */ +#else /* !HAVE_LONG_LONG */ +typedef struct { +#ifdef IS_LITTLE_ENDIAN + PRUint32 lo, hi; +#else + PRUint32 hi, lo; +#endif +} PRInt64; +typedef PRInt64 PRUint64; +#endif /* !HAVE_LONG_LONG */ + +/************************************************************************ +** TYPES: PRUintn +** PRIntn +** DESCRIPTION: +** The PRIntn types are most appropriate for automatic variables. They are +** guaranteed to be at least 16 bits, though various architectures may +** define them to be wider (e.g., 32 or even 64 bits). These types are +** never valid for fields of a structure. +************************************************************************/ +#if PR_BYTES_PER_INT >= 2 +typedef int PRIntn; +typedef unsigned int PRUintn; +#else +#error 'sizeof(int)' not sufficient for platform use +#endif + +/************************************************************************ +** TYPES: PRFloat64 +** DESCRIPTION: +** NSPR's floating point type is always 64 bits. +************************************************************************/ +typedef double PRFloat64; + +/************************************************************************ +** TYPES: PRSize +** DESCRIPTION: +** A type for representing the size of objects. +************************************************************************/ +typedef size_t PRSize; + + +/************************************************************************ +** TYPES: PROffset32, PROffset64 +** DESCRIPTION: +** A type for representing byte offsets from some location. +************************************************************************/ +typedef PRInt32 PROffset32; +typedef PRInt64 PROffset64; + +/************************************************************************ +** TYPES: PRPtrDiff +** DESCRIPTION: +** A type for pointer difference. Variables of this type are suitable +** for storing a pointer or pointer sutraction. +************************************************************************/ +typedef ptrdiff_t PRPtrdiff; + +/************************************************************************ +** TYPES: PRUptrdiff +** DESCRIPTION: +** A type for pointer difference. Variables of this type are suitable +** for storing a pointer or pointer sutraction. +************************************************************************/ +typedef unsigned long PRUptrdiff; + +/************************************************************************ +** TYPES: PRBool +** DESCRIPTION: +** Use PRBool for variables and parameter types. Use PR_FALSE and PR_TRUE +** for clarity of target type in assignments and actual arguments. Use +** 'if (bool)', 'while (!bool)', '(bool) ? x : y' etc., to test booleans +** juast as you would C int-valued conditions. +************************************************************************/ +typedef PRIntn PRBool; +#define PR_TRUE 1 +#define PR_FALSE 0 + +/************************************************************************ +** TYPES: PRPackedBool +** DESCRIPTION: +** Use PRPackedBOol within structs where bitfields are not desireable +** but minimum and consistant overhead matters. +************************************************************************/ +typedef PRUint8 PRPackedBool; + +/* +** Status code used by some routines that have a single point of failure or +** special status return. +*/ +typedef enum { PR_FAILURE = -1, PR_SUCCESS = 0 } PRStatus; + +#ifdef MOZ_UNICODE +/* + * EXPERIMENTAL: This type may be removed in a future release. + */ +#ifndef __PRUNICHAR__ +#define __PRUNICHAR__ +#if defined(WIN32) || defined(XP_MAC) +typedef wchar_t PRUnichar; +#else +typedef PRUint16 PRUnichar; +#endif +#endif +#endif /* MOZ_UNICODE */ + +/* +** WARNING: The undocumented data types PRWord and PRUword are +** only used in the garbage collection and arena code. Do not +** use PRWord and PRUword in new code. +** +** A PRWord is an integer that is the same size as a void*. +** It implements the notion of a "word" in the Java Virtual +** Machine. (See Sec. 3.4 "Words", The Java Virtual Machine +** Specification, Addison-Wesley, September 1996. +** http://java.sun.com/docs/books/vmspec/index.html.) +*/ +typedef long PRWord; +typedef unsigned long PRUword; + +#if defined(NO_NSPR_10_SUPPORT) +#else +/********* ???????????????? FIX ME ??????????????????????????? *****/ +/********************** Some old definitions until pr=>ds transition is done ***/ +/********************** Also, we are still using NSPR 1.0. GC ******************/ +/* +** Fundamental NSPR macros, used nearly everywhere. +*/ + +#define PR_PUBLIC_API PR_IMPLEMENT + +/* +** Macro body brackets so that macros with compound statement definitions +** behave syntactically more like functions when called. +*/ +#define NSPR_BEGIN_MACRO do { +#define NSPR_END_MACRO } while (0) + +/* +** Macro shorthands for conditional C++ extern block delimiters. +*/ +#ifdef NSPR_BEGIN_EXTERN_C +#undef NSPR_BEGIN_EXTERN_C +#endif +#ifdef NSPR_END_EXTERN_C +#undef NSPR_END_EXTERN_C +#endif + +#ifdef __cplusplus +#define NSPR_BEGIN_EXTERN_C extern "C" { +#define NSPR_END_EXTERN_C } +#else +#define NSPR_BEGIN_EXTERN_C +#define NSPR_END_EXTERN_C +#endif + +#ifdef XP_MAC +#include "protypes.h" +#else +#include "obsolete/protypes.h" +#endif + +/********* ????????????? End Fix me ?????????????????????????????? *****/ +#endif /* NO_NSPR_10_SUPPORT */ + +PR_END_EXTERN_C + +#endif /* prtypes_h___ */ + diff --git a/nsplugins/tdehtml_plugins.desktop b/nsplugins/tdehtml_plugins.desktop new file mode 100644 index 000000000..b79fa3100 --- /dev/null +++ b/nsplugins/tdehtml_plugins.desktop @@ -0,0 +1,233 @@ +[Desktop Entry] +Type=Application +DocPath=kcontrol/tdehtml/index.html#kbrowse-plugins +Icon=konqueror +Exec=tdecmshell tdehtml_plugins + +X-TDE-ModuleType=Library +X-TDE-Library=konqhtml +X-TDE-FactoryName=tdehtml_plugins +X-TDE-Init-Library=nsplugins +X-TDE-Init=nsplugin +X-TDE-ParentApp=kcontrol + +Name=Plugins +Name[af]=Inprop modules +Name[az]=Əlavələr +Name[be]=Утулкі +Name[bg]=Приставки +Name[bn]=প্লাগ-ইন +Name[br]=Lugantoù +Name[bs]=Dodaci +Name[ca]=Connectors +Name[cs]=Moduly +Name[csb]=Pluginsë +Name[cy]=Ategion +Name[da]=Plugin +Name[el]=Πρόσθετα +Name[eo]=Kromaĵoj +Name[es]=Complementos +Name[et]=Pluginad +Name[eu]=Pluginak +Name[fa]=وصلهها +Name[fi]=Liitännäiset +Name[fr]=Modules externes +Name[ga]=Breiseáin +Name[he]=תוספים +Name[hi]=प्लगइन्स +Name[hr]=Dodaci +Name[hu]=Bővítőmodulok +Name[is]=Íforrit +Name[it]=Plugin +Name[ja]=プラグイン +Name[ka]=პლაგინები +Name[kk]=Модульдер +Name[km]=កម្មវិធីជំនួយ +Name[ko]=플러그인 +Name[lo]=ລງບ +Name[lt]=Priedai +Name[lv]=Spraudņi +Name[mk]=Приклучоци +Name[mn]=Плугин +Name[ms]=Plugin +Name[mt]=Plagins +Name[nb]=Programtillegg +Name[ne]=प्लगइन +Name[nn]=Programtillegg +Name[nso]=Ditsenyo +Name[pa]=ਪਲੱਗਇਨ +Name[pl]=Wtyczki +Name[pt]='Plugins' +Name[pt_BR]=Plug-ins +Name[ro]=Module +Name[ru]=Модули +Name[rw]=Amacomeka +Name[se]=Lassemoduvllat +Name[sk]=Moduly +Name[sl]=Vstavki +Name[sr]=Прикључци +Name[sr@Latn]=Priključci +Name[ss]=Ema- Plugin +Name[sv]=Insticksprogram +Name[ta]=செருகல்கள் +Name[te]=ప్లగిన్లు +Name[tg]=Мутассалкунандаҳо +Name[th]=ปลั๊กอิน +Name[tr]=Eklentiler +Name[tt]=Quşımta +Name[uk]=Втулки +Name[uz]=Plaginlar +Name[uz@cyrillic]=Плагинлар +Name[vi]=Các trình bổ sung +Name[wa]=Tchôke-divins +Name[xh]=Iiplagi ezingaphakathi +Name[zh_CN]=插件 +Name[zh_TW]=外掛程式 +Name[zu]=Ama-Plugin +Comment=Configure the browser plugins +Comment[af]=Konfigureer die blaaier inprop modules +Comment[az]=Səyyah əlavələrini quraşdırın +Comment[be]=Настаўленні модуляў вандроўніка +Comment[bg]=Настройване приставките на браузъра +Comment[bn]=বিভিন্ন ব্রাউজার প্লাগ-ইন কনফিগার করুন +Comment[br]=Kefluniañ lugantoù ar furcher +Comment[bs]=Podesite dodatke preglednika (browser plugins) +Comment[ca]=Aquí podeu configurar els connectors del navegador +Comment[cs]=Nastavení modulů prohlížeče (pluginy) +Comment[csb]=Kònfigùracëjô pluginsów przezérnika +Comment[cy]=Ffurfweddu ategion y porydd +Comment[da]=Indstil browserens plugin +Comment[de]=Plugins für Webbrowser einrichten +Comment[el]=Ρυθμίστε τα πρόσθετα του περιηγητή +Comment[eo]=Agordu la foliumilajn kromaĵojn +Comment[es]=Configurar los complementos del navegador +Comment[et]=Veebilehitseja pluginate seadistamine +Comment[eu]=Konfiguratu arakatzailearen pluginak +Comment[fa]=پیکربندی وصلههای مرورگر +Comment[fi]=Muokkaa selaimen liitännäisasetuksia +Comment[fr]=Configuration des modules externes du navigateur +Comment[fy]=Hjir kinne jo de blêder-plugins ynstelle +Comment[ga]=Cumraigh na Breiseáin Brabhsálaithe +Comment[gl]=Configurar os plugins do navegador +Comment[he]=שינוי הגדרות התוספים של הדפדפן +Comment[hi]=ब्राउज़र प्लगइन कॉन्फ़िगर करें +Comment[hr]=Konfiguriranje dodataka preglednika +Comment[hu]=A böngésző bővítőmoduljainak beállításai +Comment[is]=Stilla íforrit vafra +Comment[it]=Configura i plugin del browser +Comment[ja]=ブラウザのプラグインの設定 +Comment[ka]=ბრაუზერის პლაგინების კონფიგურაცია +Comment[kk]=Браузер модульдерінің баптауы +Comment[km]=កំណត់រចនាសម្ព័ន្ធកម្មវិធីជំនួយរបស់កម្មវិធីរុករក +Comment[ko]=브라우저 플러그인 설정 +Comment[lo]=ປັກອິນສອດສອ່ງຊີພີຍູ +Comment[lt]=Konfigūruoti naršyklės priedus +Comment[lv]=Konfigurēt pārlūka spaudņus +Comment[mk]=Конфигурација на приклучоците на прелистувачот +Comment[mn]=Вэб хөтөчийн плугин тохируулга +Comment[ms]=Tetapkan plugin pelayar +Comment[mt]=Ikkonfigura l-plugins tal-browser +Comment[nb]=Sett opp programtillegg for nettleseren +Comment[nds]=Kiekerplugins instellen +Comment[ne]=प्लगइन ब्राउजर कन्फिगर गर्नुहोस् +Comment[nl]=Hier kunt u de browser-plugins instellen +Comment[nn]=Set opp programtillegg for nettlesaren +Comment[nso]=Beakanya ditsenyo tsa seinyakisi +Comment[pa]=ਝਲਕਾਰਾ ਪਲੱਗਇਨ ਸੰਰਚਨਾ +Comment[pl]=Konfiguracja wtyczek przeglądarki +Comment[pt]=Configurar os 'plugins' do navegador +Comment[pt_BR]=Configura os plug-ins do navegador +Comment[ro]=Configurează modulele de navigator de web +Comment[ru]=Настройка модулей браузера +Comment[rw]=Kuboneza Amacomeka ya Mucukumbuzi +Comment[se]=Heivet fierpmádatlogana lassemoduvllaid +Comment[sk]=Nastavenie modulov prehliadača +Comment[sl]=Tu lahko nastavite predpomnilnik +Comment[sr]=Подешавање прикључака прегледача +Comment[sr@Latn]=Podešavanje priključaka pregledača +Comment[sv]=Anpassa insticksprogram för webbläsare +Comment[ta]= மேலோடியின் செருகல்களை வடிவமைக்கலாம் +Comment[tg]=Танзими мутассалкунандаҳои тафсир +Comment[th]=ปรับแต่งปลั้กอินของบราวเซอร์ +Comment[tr]=Tarayıcı eklentilerini yapılandırın +Comment[tt]=Gizgeç östämälären caylaw +Comment[uk]=Налаштування втулків навігатора +Comment[uz]=Brauzerning plaginlarini moslash +Comment[uz@cyrillic]=Браузернинг плагинларини мослаш +Comment[ven]=Dzudzanyani plugins ya burausa +Comment[vi]=Cấu hình trình bổ sung cho trình duyệt +Comment[wa]=Apontyî les tchôke-divins do betchteu +Comment[xh]=Qwalasela umkhangheli zincwadi zeplagi ezingaphakathi +Comment[zh_CN]=配置浏览器插件 +Comment[zh_TW]=設定瀏覽器外掛程式 +Comment[zu]=Hlanganisela ama-plugin omcingi +Keywords=konqueror,kfm,browser,html,web,www,fonts,plugins +Keywords[az]=konqueror,kfm,browser,html,web,www,fonts,plugins,konqueror,kfm,səyyah,html,şəbəkə,www,yazı növləri,rənglər,java,javascript,hərf,hərf dəstəsi,kodlama,bağlantılar,rəsmlər,ox +Keywords[be]=Вандроўнік,Сеціва,Шрыфты,Утулкі,konqueror,kfm,browser,html,web,www,fonts,plugins +Keywords[bg]=приставки, настройване, браузър, уеб, шрифтове, Интернет, приставка, модул, konqueror, kfm, browser, html, web, www, fonts, plugins +Keywords[br]=konqueror,kfm,furcher,html,web,gwiad,livioù,java,javascript +Keywords[ca]=konqueror,kfm,navegador,html,web,www,lletres,connectors +Keywords[cs]=Konqueror,Kfm,Prohlížeč,HTML,Web,WWW,Písma,Moduly +Keywords[csb]=konqueror,kfm,przezérnik,html,séc,www,fòntë,pluginsë +Keywords[cy]=konqueror,kfm,porwr,porydd,html,gwe,www,wynebfathau,ffontiau,ategion +Keywords[da]=konqueror,kfm,browser,html,net,www,skrifttyper,plugin +Keywords[de]=Konqueror,kfm,Browser,HTML,Web,WWW,Schriften,Plugins +Keywords[el]=konqueror,kfm,περιηγητής,html,ιστός,www,γραμματοσειρές,πρόσθετα +Keywords[eo]=Konkeranto,Kfm,TTT,HTML,WWW,tiparo,koloro,Javo,Javoskripto,kursoro, kursilo,ligo,referenco,bildo,signaro,kodo +Keywords[es]=konqueror,kfm,navegador,html,web,www,tipos de letra,complementos +Keywords[et]=konqueror,kfm,veebilehitseja,html,veeb,www,fondid,pluginad +Keywords[eu]=konqueror,kfm,arakatzailea,html,web,www,letra-tipoak,pluginak +Keywords[fa]=konqueror، kfm، مرورگر، html، وب، www، قلمها، وصلهها +Keywords[fi]=konqueror,kfm,selain,html,web,www,kirjasimet,liitännäiset +Keywords[fr]=konqueror,kfm,navigateur,html,web,www,polices,plugins,modules externe +Keywords[fy]=konqueror,kfm,browser,blêder,html,web,www,fonts,lettertypen,plugins,internet,ynternet,netscape plugins +Keywords[ga]=konqueror,kfm,brabhsálaí,html,idirlíon,www,clófhoirne,breiseáin +Keywords[gl]=konqueror,kfm,navegador,html,web,www,fontes,plugins +Keywords[he]=konqueror,kfm,דפדפן,html,web,www,אינטרנט,גופנים,תוספים, fonts,plugins +Keywords[hi]=कॉन्करर केएफएम,ब्राउजर,एचटीएमएल,वेब,डब्ल्यूडब्ल्यूडब्ल्यू,फ़ॉन्ट्स,प्लगइन्स +Keywords[hr]=konqueror,kfm,preglednik,html,web,www,fontovi,dodaci,mreža +Keywords[hu]=Konqueror,kfm,böngésző,HTML,web,WWW,betűtípusok,bővítőmodulok +Keywords[is]=konqueror,kfm,flakkari,html,web,www,letur,íforrit,vefur +Keywords[it]=konqueror,kfm,browser,html,web,www,caratteri,plugin +Keywords[ja]=konqueror,kfm,ブラウザ,html,web,ウェブ,www,フォント,プラグイン +Keywords[km]=konqueror,kfm,កម្មវិធីរុករក,html,បណ្ដាញ,វើលវ៉ាយវិប,ពុម្ពអក្សរ,កម្មវិធីជំនួយ +Keywords[lt]=konqueror,kfm,browser,html,web,www,fonts,plugins. naršyklė,tinklalapiai,šriftai,priedai +Keywords[lv]=iekarotājs,kfm,pārlūks,html,web,www,fonti,spraudņi +Keywords[mk]=konqueror,kfm,browser,html,web,www,fonts,plugins, прелистувач,веб,фонтови,приклучоци +Keywords[mn]=Конкюрор,kfm,Хөтөч,HTML,Вэб,WWW,Бичиг,Плугин +Keywords[ms]=konqueror,kfm,pelayar,html,web,www,font,plugin +Keywords[mt]=konqueror,kfm,browser,html,web,www,fonts,plugins,plagins +Keywords[nb]=Konqueror,KFM,nettleser,HTML,verdensveven,WWW,Internett,skrifter,programtillegg +Keywords[nds]=Konqueror,kfm,Nettkieker,HTML,web,www,Schriftoorden,Plugins +Keywords[ne]=कन्क्वेरर,kfm, ब्राउजर,html, वेब,www, फन्ट, प्लगइन +Keywords[nl]=konqueror,kfm,browser,html,web,www,fonts,lettertypen,plugins,internet,netscape plugins +Keywords[nn]=Konqueror,KFM,nettlesar,HTML,verdsveven,WWW,skrifter,programtillegg +Keywords[nso]=konqueror,kfm,senyakisi,html,web,www,difonto,ditsenyo +Keywords[pa]=konqueror,kfm,browser,html,web,www,ਫੋਂਟ,ਪਲੱਗਇਨ,ਕੋਨਕਿਉਰਰ,ਝਲਕਾਰਾ,ਵੈਬ +Keywords[pl]=konqueror,kfm,przeglądarka,html,sieć,www,czcionki,wtyczki +Keywords[pt]=konqueror,kfm,navegador,HTML,web,WWW,tipos de letra,'plugins' +Keywords[pt_BR]=konqueror,kfm,navegador,html,web,www,fontes,plug-ins +Keywords[ro]=konqueror,kfm,navigator,html,web,www,fonturi,module +Keywords[rw]= Konqueror,Mucukumbuzi,html,Urubuga,www,Imyandikire, Amacomeka +Keywords[se]=konqueror,kfm,fierpmádatlogan,html,web,www,fonttat,lassemoduvllat +Keywords[sk]=konqueror,kfm,prehliadač,html,web,www,písma,moduly +Keywords[sl]=konqueror,kfm,brskalnik,html,splet,web,pisave,www,vstavki +Keywords[sr]=konqueror,kfm,прегледач,html,web,www,фонтови,додаци +Keywords[sr@Latn]=konqueror,kfm,pregledač,html,web,www,fontovi,dodaci +Keywords[ss]=konqueror,kfm,brawuza,html,web,www,timo tetinhlamvu temagama,ema-plugin +Keywords[sv]=konqueror,kfm,webbläsare,html,webb,www,teckensnitt,insticksprogram +Keywords[ta]=கான்கொரர், கோப்பு மேலாளர், மேலோடி, உலாவி, html, இணையம், வலையம், வலை, எழுத்துரு, www, செருகல்கள் +Keywords[th]=คอนเควอร์เรอร์,kfm,บราวเซอร์,html,เว็บ,www,แบบอักษร,ปลั้กอิน +Keywords[tr]=konqueror,kfm,browser,html,web,www,yazıtipleri,eklentiler,tarayıcı +Keywords[tt]=konqueror,kfm,browser,html,web,www,fonts,plugins,quşımta,şäkel,päräwez,çeltär +Keywords[uk]=konqueror,kfm,навігатор,html,тенета,www,шрифти,втулки +Keywords[uz]=konqueror,kfm,html,www,brauzer,veb,shriftlar,plaginlar +Keywords[uz@cyrillic]=konqueror,kfm,html,www,браузер,веб,шрифтлар,плагинлар +Keywords[vi]=konqueror,kfm,trình duyệt,html,web;www,phông chữ,trình bổ sung +Keywords[wa]=konqueror,kfm,foyteuse,betchteu,html,waibe,www,fontes,tchôke-divins +Keywords[xh]=konqueror,kfm,umkhangeli zincwadi,html,web, www,imigca,iplagi ezingaphakathi +Keywords[zh_CN]=konqueror,kfm,browser,html,web,www,fonts,plugins,浏览器,字体,插件 +Keywords[zh_TW]=konqueror,kfm,browser,html,web,www,fonts,plugins,征服家,瀏覽器,網頁,字型,外掛程式 +Keywords[zu]=komqueror,kfm,umcingi,html,web,www,izinhlobo zamagama, ama-plugin + +Categories=Qt;TDE;X-TDE-settings-webbrowsing; diff --git a/nsplugins/test/Makefile.am b/nsplugins/test/Makefile.am new file mode 100644 index 000000000..af17ade48 --- /dev/null +++ b/nsplugins/test/Makefile.am @@ -0,0 +1,11 @@ +INCLUDES = -I$(top_srcdir)/libltdl -I.. $(all_includes) +METASOURCES = AUTO +noinst_HEADERS = testnsplugin.h + +check_PROGRAMS = testnsplugin +testnsplugin_SOURCES = testnsplugin.cpp +testnsplugin_LDFLAGS = $(all_libraries) $(KDE_RPATH) $(LIB_QT) -lDCOP $(LIB_TDECORE) $(LIB_TDEUI) -ltdefx $(LIB_TDEIO) -ltdetexteditor +testnsplugin_LDADD = $(LIB_TDEUI) ../libnsplugin.la + +$(srcdir)/testnsplugin.cpp: ../NSPluginClassIface_stub.h + diff --git a/nsplugins/test/testnsplugin.cpp b/nsplugins/test/testnsplugin.cpp new file mode 100644 index 000000000..daccd1bcf --- /dev/null +++ b/nsplugins/test/testnsplugin.cpp @@ -0,0 +1,143 @@ +/* + This is an encapsulation of the Netscape plugin API. + + Copyright (c) 2000 Stefan Schimanski <1Stein@gmx.de> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ +#include <stdio.h> + +#include <tqstring.h> +#include <tdeapplication.h> +#include <tdecmdlineargs.h> +#include <dcopclient.h> +#include <kdebug.h> +#include <kstdaction.h> +#include <tdeaction.h> + +#include "testnsplugin.h" +#include "../NSPluginClassIface_stub.h" +#include "../nspluginloader.h" + + +TestNSPlugin::TestNSPlugin() +{ + m_loader = NSPluginLoader::instance(); + + // client area + m_client = new TQWidget( this, "m_client" ); + setCentralWidget( m_client ); + m_client->show(); + m_layout = new TQHBoxLayout( m_client ); + + // file menu + KStdAction::openNew( this, TQT_SLOT(newView()), actionCollection()); + KStdAction::close( this, TQT_SLOT(closeView()), actionCollection()); + KStdAction::quit( kapp, TQT_SLOT(quit()), actionCollection()); + + createGUI( "testnspluginui.rc" ); +} + + +TestNSPlugin::~TestNSPlugin() +{ + kdDebug() << "-> TestNSPlugin::~TestNSPlugin" << endl; + m_loader->release(); + kdDebug() << "<- TestNSPlugin::~TestNSPlugin" << endl; +} + + +void TestNSPlugin::newView() +{ + TQStringList _argn, _argv; + + //TQString src = "file:/home/sschimanski/kimble_themovie.swf"; + //TQString src = "file:/home/sschimanski/in_ani.swf"; + //TQString src = "http://homepages.tig.com.au/~dkl/swf/promo.swf"; + //TQString mime = "application/x-shockwave-flash"; + + _argn << "name" << "controls" << "console"; + _argv << "audio" << "ControlPanel" << "Clip1"; + TQString src = "http://welt.is-kunden.de:554/ramgen/welt/avmedia/realaudio/0701lw177135.rm"; +// TQString src = "nothing"; + TQString mime = "audio/x-pn-realaudio-plugin"; + + _argn << "SRC" << "TYPE" << "WIDTH" << "HEIGHT"; + _argv << src << mime << "400" << "100"; + TQWidget *win = m_loader->newInstance( m_client, src, mime, 1, _argn, _argv, "appid", "callbackid" ); + +/* + _argn << "TYPE" << "WIDTH" << "HEIGHT" << "java_docbase" << "CODE"; + _argv << "application/x-java-applet" << "450" << "350" << "file:///none" << "sun/plugin/panel/ControlPanelApplet.class"; + TQWidget *win = loader->NewInstance(0, "", "application/x-java-applet", 1, _argn, _argv); +*/ + + if ( win ) + { + m_plugins.append( win ); + connect( win, TQT_SIGNAL(destroyed(NSPluginInstance *)), + this, TQT_SLOT(viewDestroyed(NSPluginInstance *)) ); + m_layout->addWidget( win ); + win->show(); + } else + { + kdDebug() << "No widget created" << endl; + } +} + +void TestNSPlugin::closeView() +{ + kdDebug() << "closeView" << endl; + TQWidget *win = m_plugins.last(); + if ( win ) + { + m_plugins.remove( win ); + delete win; + } else + { + kdDebug() << "No widget available" << endl; + } +} + + +void TestNSPlugin::viewDestroyed( NSPluginInstance *inst ) +{ + kdDebug() << "TestNSPlugin::viewDestroyed" << endl; + m_plugins.remove( inst ); +} + + +int main(int argc, char *argv[]) +{ + kdDebug() << "main" << endl; + setvbuf( stderr, NULL, _IONBF, 0 ); + TDECmdLineArgs::init(argc, argv, "nsplugin", "A Netscape Plugin test program", "0.1"); + + TDEApplication app("nsplugin"); + + app.dcopClient()->attach(); + app.dcopClient()->registerAs(app.name()); + app.dcopClient()->setNotifications(true); + + TestNSPlugin *win = new TestNSPlugin; + app.setMainWidget( win ); + win->show(); + app.exec(); + + delete win; +} + +#include "testnsplugin.moc" diff --git a/nsplugins/test/testnsplugin.h b/nsplugins/test/testnsplugin.h new file mode 100644 index 000000000..252cea2c8 --- /dev/null +++ b/nsplugins/test/testnsplugin.h @@ -0,0 +1,56 @@ +/* + This is an encapsulation of the Netscape plugin API. + + Copyright (c) 2000 Stefan Schimanski <1Stein@gmx.de> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ + + +#ifndef __TESTNSPLUGIN_H__ +#define __TESTNSPLUGIN_H__ + +#include <tqstring.h> +#include <tqwidget.h> +#include <tdemainwindow.h> +#include <tqlayout.h> +#include <tqptrlist.h> + +class NSPluginLoader; +class NSPluginInstance; + +class TestNSPlugin : public TDEMainWindow +{ + Q_OBJECT + +public: + TestNSPlugin(); + virtual ~TestNSPlugin(); + +public slots: + void newView(); + void closeView(); + void viewDestroyed( NSPluginInstance *inst ); + +protected: + NSPluginLoader *m_loader; + TQPtrList<TQWidget> m_plugins; + TQWidget *m_client; + TQBoxLayout *m_layout; +}; + + +#endif diff --git a/nsplugins/test/testnsplugin.rc b/nsplugins/test/testnsplugin.rc new file mode 100644 index 000000000..46bb5f86a --- /dev/null +++ b/nsplugins/test/testnsplugin.rc @@ -0,0 +1,15 @@ +<!DOCTYPE kpartgui> +<kpartgui name="testnsplugin"> + +<MenuBar> + <Menu name="file"><text>&File</text> + </Menu> +</MenuBar> + +<ToolBar noMerge="1" name="mainToolBar"> + <Action name="file_new"/> + <Action name="file_close"/> + <Action name="file_quit"/> +</ToolBar> + +</kpartgui> diff --git a/nsplugins/viewer/CMakeLists.txt b/nsplugins/viewer/CMakeLists.txt new file mode 100644 index 000000000..89e0ef32b --- /dev/null +++ b/nsplugins/viewer/CMakeLists.txt @@ -0,0 +1,35 @@ +################################################# +# +# (C) 2010-2011 Serghei Amelian +# serghei (DOT) amelian (AT) gmail.com +# +# Improvements and feedback are welcome +# +# This file is released under GPL >= 2 +# +################################################# + +include_directories( + ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_BINARY_DIR} + ${CMAKE_SOURCE_DIR}/nsplugins + ${TDE_INCLUDE_DIR} + ${TQT_INCLUDE_DIRS} + ${GLIB2_INCLUDE_DIRS} +) + +link_directories( + ${TQT_LIBRARY_DIRS} +) + + +##### nspluginviewer (executable) ############### + +tde_add_executable( nspluginviewer AUTOMOC + SOURCES + ../NSPluginCallbackIface.stub NSPluginClassIface.skel + nsplugin.cpp viewer.cpp qxteventloop.cpp + glibevents.cpp + LINK tdeparts-shared tdeio-shared ${GLIB2_LIBRARIES} Xt dl + DESTINATION ${BIN_INSTALL_DIR} +) diff --git a/nsplugins/viewer/Makefile.am b/nsplugins/viewer/Makefile.am new file mode 100644 index 000000000..d8597321f --- /dev/null +++ b/nsplugins/viewer/Makefile.am @@ -0,0 +1,11 @@ +INCLUDES = -I$(top_srcdir)/nsplugins -I$(top_builddir)/nsplugins $(all_includes) `pkg-config --cflags glib-2.0` +METASOURCES = AUTO + +bin_PROGRAMS = nspluginviewer + +nspluginviewer_SOURCES = NSPluginCallbackIface.stub NSPluginClassIface.skel \ + nsplugin.cpp viewer.cpp qxteventloop.cpp glibevents.cpp +nspluginviewer_LDFLAGS = $(all_libraries) $(KDE_RPATH) -export-dynamic `pkg-config --libs glib-2.0` +nspluginviewer_LDADD = $(LIB_TDEIO) $(LIB_TDEPARTS) -lXt + +NSPluginCallbackIface_DIR = $(srcdir)/.. diff --git a/nsplugins/viewer/NSPluginClassIface.h b/nsplugins/viewer/NSPluginClassIface.h new file mode 100644 index 000000000..c9051821d --- /dev/null +++ b/nsplugins/viewer/NSPluginClassIface.h @@ -0,0 +1,83 @@ +/* + + Copyright (c) 2000 Matthias Hoelzer-Kluepfel <mhk@caldera.de> + Stefan Schimanski <1Stein@gmx.de> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ + + + +#ifndef __NSPluginClassIface_h__ +#define __NSPluginClassIface_h__ + + +#include <tqstringlist.h> +#include <tqcstring.h> +#include <dcopobject.h> +#include <dcopref.h> + + +class NSPluginViewerIface : virtual public DCOPObject +{ + K_DCOP + +k_dcop: + virtual void shutdown() = 0; + virtual DCOPRef newClass(TQString plugin) = 0; +}; + + +class NSPluginClassIface : virtual public DCOPObject +{ + K_DCOP + +k_dcop: + + virtual DCOPRef newInstance(TQString url, TQString mimeType, TQ_INT8 embed, + TQStringList argn, TQStringList argv, + TQString appId, TQString callbackId, TQ_INT8 reload, + TQ_INT8 doPost, TQByteArray postData, TQ_UINT32 xembed) = 0; + virtual TQString getMIMEDescription() = 0; + +}; + + +class NSPluginInstanceIface : virtual public DCOPObject +{ + K_DCOP + +k_dcop: + + virtual void shutdown() = 0; + + virtual int winId() = 0; + + virtual int setWindow(TQ_INT8 remove=0) = 0; + + virtual void resizePlugin(TQ_INT32 w, TQ_INT32 h) = 0; + + virtual void javascriptResult(TQ_INT32 id, TQString result) = 0; + + virtual void displayPlugin() = 0; + + virtual void gotFocusIn() = 0; + virtual void gotFocusOut() = 0; +}; + + +#endif + diff --git a/nsplugins/viewer/glibevents.cpp b/nsplugins/viewer/glibevents.cpp new file mode 100644 index 000000000..fe059d1ee --- /dev/null +++ b/nsplugins/viewer/glibevents.cpp @@ -0,0 +1,43 @@ +/* + Copyright (c) 2007 Lubos Lunak <l.lunak@suse.cz> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ + +#include "glibevents.h" + +#include <tqapplication.h> + +GlibEvents::GlibEvents() + { + g_main_context_ref( g_main_context_default()); + connect( &timer, TQT_SIGNAL( timeout()), TQT_SLOT( process())); + // TODO Poll for now + timer.start( 10 ); + } + +GlibEvents::~GlibEvents() + { + g_main_context_unref( g_main_context_default()); + } + +void GlibEvents::process() + { + while( g_main_context_pending( g_main_context_default())) + g_main_context_iteration( g_main_context_default(), false ); + } + +#include "glibevents.moc" diff --git a/nsplugins/viewer/glibevents.h b/nsplugins/viewer/glibevents.h new file mode 100644 index 000000000..396273a85 --- /dev/null +++ b/nsplugins/viewer/glibevents.h @@ -0,0 +1,41 @@ +/* + Copyright (c) 2007 Lubos Lunak <l.lunak@suse.cz> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ + +#ifndef GLIBEVENTS_H +#define GLIBEVENTS_H + +#include <tqwidget.h> +#include <tqtimer.h> + +#include <glib.h> + +class GlibEvents + : public QWidget + { + Q_OBJECT + public: + GlibEvents(); + virtual ~GlibEvents(); + private slots: + void process(); + private: + TQTimer timer; + }; + +#endif diff --git a/nsplugins/viewer/nsplugin.cpp b/nsplugins/viewer/nsplugin.cpp new file mode 100644 index 000000000..4f3cb3094 --- /dev/null +++ b/nsplugins/viewer/nsplugin.cpp @@ -0,0 +1,2002 @@ +/* + + This is an encapsulation of the Netscape plugin API. + + + Copyright (c) 2000 Matthias Hoelzer-Kluepfel <hoelzer@kde.org> + Stefan Schimanski <1Stein@gmx.de> + 2003-2005 George Staikos <staikos@kde.org> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ + + +#include "NSPluginCallbackIface_stub.h" + + +#include <stdlib.h> +#include <unistd.h> + +#include <tqdict.h> +#include <tqdir.h> +#include <tqfile.h> +#include <tqtimer.h> + +#include "nsplugin.h" +#include "resolve.h" + +#ifdef Bool +#undef Bool +#endif + +#include <dcopclient.h> +#include <tdeconfig.h> +#include <kdebug.h> +#include <tdeglobal.h> +#include <tdeio/netaccess.h> +#include <klibloader.h> +#include <tdelocale.h> +#include <kprocess.h> +#include <tdeprotocolmanager.h> +#include <kstandarddirs.h> +#include <tdetempfile.h> +#include <kurl.h> + +#include <X11/Intrinsic.h> +#include <X11/Composite.h> +#include <X11/Constraint.h> +#include <X11/Shell.h> +#include <X11/StringDefs.h> + +// provide these symbols when compiling with gcc 3.x + +#if defined __GNUC__ && defined __GNUC_MINOR__ +# define KDE_GNUC_PREREQ(maj, min) \ + ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) +#else +# define KDE_GNUC_PREREQ(maj, min) 0 +#endif + + +#if defined(__GNUC__) && KDE_GNUC_PREREQ(3,0) +extern "C" void* __builtin_new(size_t s) +{ + return operator new(s); +} + +extern "C" void __builtin_delete(void* p) +{ + operator delete(p); +} + +extern "C" void* __builtin_vec_new(size_t s) +{ + return operator new[](s); +} + +extern "C" void __builtin_vec_delete(void* p) +{ + operator delete[](p); +} + +extern "C" void __pure_virtual() +{ + abort(); +} +#endif + +// server side functions ----------------------------------------------------- + +// allocate memory +void *g_NPN_MemAlloc(uint32 size) +{ + void *mem = ::malloc(size); + + //kdDebug(1431) << "g_NPN_MemAlloc(), size=" << size << " allocated at " << mem << endl; + + return mem; +} + + +// free memory +void g_NPN_MemFree(void *ptr) +{ + //kdDebug(1431) << "g_NPN_MemFree() at " << ptr << endl; + if (ptr) + ::free(ptr); +} + +uint32 g_NPN_MemFlush(uint32 size) +{ + Q_UNUSED(size); + //kdDebug(1431) << "g_NPN_MemFlush()" << endl; + // MAC OS only.. we don't use this + return 0; +} + + +// redraw +void g_NPN_ForceRedraw(NPP /*instance*/) +{ + // http://devedge.netscape.com/library/manuals/2002/plugin/1.0/npn_api3.html#999401 + // FIXME + kdDebug(1431) << "g_NPN_ForceRedraw() [unimplemented]" << endl; +} + + +// invalidate rect +void g_NPN_InvalidateRect(NPP /*instance*/, NPRect* /*invalidRect*/) +{ + // http://devedge.netscape.com/library/manuals/2002/plugin/1.0/npn_api7.html#999503 + // FIXME + kdDebug(1431) << "g_NPN_InvalidateRect() [unimplemented]" << endl; +} + + +// invalidate region +void g_NPN_InvalidateRegion(NPP /*instance*/, NPRegion /*invalidRegion*/) +{ + // http://devedge.netscape.com/library/manuals/2002/plugin/1.0/npn_api8.html#999528 + // FIXME + kdDebug(1431) << "g_NPN_InvalidateRegion() [unimplemented]" << endl; +} + + +// get value +NPError g_NPN_GetValue(NPP /*instance*/, NPNVariable variable, void *value) +{ + kdDebug(1431) << "g_NPN_GetValue(), variable=" << static_cast<int>(variable) << endl; + + switch (variable) + { + case NPNVxDisplay: + *(void**)value = tqt_xdisplay(); + return NPERR_NO_ERROR; + case NPNVxtAppContext: + *(void**)value = XtDisplayToApplicationContext(tqt_xdisplay()); + return NPERR_NO_ERROR; + case NPNVjavascriptEnabledBool: + *(bool*)value = true; + return NPERR_NO_ERROR; + case NPNVasdEnabledBool: + // SmartUpdate - we don't do this + *(bool*)value = false; + return NPERR_NO_ERROR; + case NPNVisOfflineBool: + // Offline browsing - no thanks + *(bool*)value = false; + return NPERR_NO_ERROR; + case NPNVToolkit: + *(NPNToolkitType*)value = NPNVGtk2; + return NPERR_NO_ERROR; + case NPNVSupportsXEmbedBool: + *(bool*)value = true; + return NPERR_NO_ERROR; + default: + return NPERR_INVALID_PARAM; + } +} + + +NPError g_NPN_DestroyStream(NPP instance, NPStream* stream, + NPReason reason) +{ + // FIXME: is this correct? I imagine it is not. (GS) + kdDebug(1431) << "g_NPN_DestroyStream()" << endl; + + NSPluginInstance *inst = (NSPluginInstance*) instance->ndata; + inst->streamFinished( (NSPluginStream *)stream->ndata ); + + switch (reason) { + case NPRES_DONE: + return NPERR_NO_ERROR; + case NPRES_USER_BREAK: + // FIXME: notify the user + case NPRES_NETWORK_ERR: + // FIXME: notify the user + default: + return NPERR_GENERIC_ERROR; + } +} + + +NPError g_NPN_RequestRead(NPStream* /*stream*/, NPByteRange* /*rangeList*/) +{ + // http://devedge.netscape.com/library/manuals/2002/plugin/1.0/npn_api16.html#999734 + kdDebug(1431) << "g_NPN_RequestRead() [unimplemented]" << endl; + + // FIXME + return NPERR_GENERIC_ERROR; +} + +NPError g_NPN_NewStream(NPP /*instance*/, NPMIMEType /*type*/, + const char* /*target*/, NPStream** /*stream*/) +{ + // http://devedge.netscape.com/library/manuals/2002/plugin/1.0/npn_api12.html#999628 + kdDebug(1431) << "g_NPN_NewStream() [unimplemented]" << endl; + + // FIXME + // This creates a stream from the plugin to the browser of type "type" to + // display in "target" + return NPERR_GENERIC_ERROR; +} + +int32 g_NPN_Write(NPP /*instance*/, NPStream* /*stream*/, int32 /*len*/, void* /*buf*/) +{ + // http://devedge.netscape.com/library/manuals/2002/plugin/1.0/npn_api21.html#999859 + kdDebug(1431) << "g_NPN_Write() [unimplemented]" << endl; + + // FIXME + return 0; +} + + +// URL functions +NPError g_NPN_GetURL(NPP instance, const char *url, const char *target) +{ + kdDebug(1431) << "g_NPN_GetURL: url=" << url << " target=" << target << endl; + + NSPluginInstance *inst = static_cast<NSPluginInstance*>(instance->ndata); + if (inst) { + inst->requestURL( TQString::fromLatin1(url), TQString::null, + TQString::fromLatin1(target), 0 ); + } + + return NPERR_NO_ERROR; +} + + +NPError g_NPN_GetURLNotify(NPP instance, const char *url, const char *target, + void* notifyData) +{ + kdDebug(1431) << "g_NPN_GetURLNotify: url=" << url << " target=" << target << " inst=" << (void*)instance << endl; + NSPluginInstance *inst = static_cast<NSPluginInstance*>(instance->ndata); + if (inst) { + kdDebug(1431) << "g_NPN_GetURLNotify: ndata=" << (void*)inst << endl; + inst->requestURL( TQString::fromLatin1(url), TQString::null, + TQString::fromLatin1(target), notifyData, true ); + } + + return NPERR_NO_ERROR; +} + + +NPError g_NPN_PostURLNotify(NPP instance, const char* url, const char* target, + uint32 len, const char* buf, NPBool file, void* notifyData) +{ +// http://devedge.netscape.com/library/manuals/2002/plugin/1.0/npn_api14.html + kdDebug(1431) << "g_NPN_PostURLNotify() [incomplete]" << endl; + kdDebug(1431) << "url=[" << url << "] target=[" << target << "]" << endl; + TQByteArray postdata; + KParts::URLArgs args; + + if (len == 0) { + return NPERR_NO_DATA; + } + + if (file) { // buf is a filename + TQFile f(buf); + if (!f.open(IO_ReadOnly)) { + return NPERR_FILE_NOT_FOUND; + } + + // FIXME: this will not work because we need to strip the header out! + postdata = f.readAll(); + f.close(); + } else { // buf is raw data + // First strip out the header + const char *previousStart = buf; + uint32 l; + bool previousCR = true; + + for (l = 1;; l++) { + if (l == len) { + break; + } + + if (buf[l-1] == '\n' || (previousCR && buf[l-1] == '\r')) { + if (previousCR) { // header is done! + if ((buf[l-1] == '\r' && buf[l] == '\n') || + (buf[l-1] == '\n' && buf[l] == '\r')) + l++; + l++; + previousStart = &buf[l-1]; + break; + } + + TQString thisLine = TQString::fromLatin1(previousStart, &buf[l-1] - previousStart).stripWhiteSpace(); + + previousStart = &buf[l]; + previousCR = true; + + kdDebug(1431) << "Found header line: [" << thisLine << "]" << endl; + if (thisLine.startsWith("Content-Type: ")) { + args.setContentType(thisLine); + } + } else { + previousCR = false; + } + } + + postdata.duplicate(previousStart, len - l + 1); + } + + kdDebug(1431) << "Post data: " << postdata.size() << " bytes" << endl; +#if 0 + TQFile f("/tmp/nspostdata"); + f.open(IO_WriteOnly); + f.writeBlock(postdata); + f.close(); +#endif + + if (!target || !*target) { + // Send the results of the post to the plugin + // (works by default) + } else if (!strcmp(target, "_current") || !strcmp(target, "_self") || + !strcmp(target, "_top")) { + // Unload the plugin, put the results in the frame/window that the + // plugin was loaded in + // FIXME + } else if (!strcmp(target, "_new") || !strcmp(target, "_blank")){ + // Open a new browser window and write the results there + // FIXME + } else { + // Write the results to the specified frame + // FIXME + } + + NSPluginInstance *inst = static_cast<NSPluginInstance*>(instance->ndata); + if (inst && !inst->normalizedURL(TQString::fromLatin1(url)).isNull()) { + inst->postURL( TQString::fromLatin1(url), postdata, args.contentType(), + TQString::fromLatin1(target), notifyData, args, true ); + } else { + // Unsupported / insecure + return NPERR_INVALID_URL; + } + + return NPERR_NO_ERROR; +} + + +NPError g_NPN_PostURL(NPP instance, const char* url, const char* target, + uint32 len, const char* buf, NPBool file) +{ +// http://devedge.netscape.com/library/manuals/2002/plugin/1.0/npn_api13.html + kdDebug(1431) << "g_NPN_PostURL()" << endl; + kdDebug(1431) << "url=[" << url << "] target=[" << target << "]" << endl; + TQByteArray postdata; + KParts::URLArgs args; + + if (len == 0) { + return NPERR_NO_DATA; + } + + if (file) { // buf is a filename + TQFile f(buf); + if (!f.open(IO_ReadOnly)) { + return NPERR_FILE_NOT_FOUND; + } + + // FIXME: this will not work because we need to strip the header out! + postdata = f.readAll(); + f.close(); + } else { // buf is raw data + // First strip out the header + const char *previousStart = buf; + uint32 l; + bool previousCR = true; + + for (l = 1;; l++) { + if (l == len) { + break; + } + + if (buf[l-1] == '\n' || (previousCR && buf[l-1] == '\r')) { + if (previousCR) { // header is done! + if ((buf[l-1] == '\r' && buf[l] == '\n') || + (buf[l-1] == '\n' && buf[l] == '\r')) + l++; + l++; + previousStart = &buf[l-1]; + break; + } + + TQString thisLine = TQString::fromLatin1(previousStart, &buf[l-1] - previousStart).stripWhiteSpace(); + + previousStart = &buf[l]; + previousCR = true; + + kdDebug(1431) << "Found header line: [" << thisLine << "]" << endl; + if (thisLine.startsWith("Content-Type: ")) { + args.setContentType(thisLine); + } + } else { + previousCR = false; + } + } + + postdata.duplicate(previousStart, len - l + 1); + } + + kdDebug(1431) << "Post data: " << postdata.size() << " bytes" << endl; +#if 0 + TQFile f("/tmp/nspostdata"); + f.open(IO_WriteOnly); + f.writeBlock(postdata); + f.close(); +#endif + + if (!target || !*target) { + // Send the results of the post to the plugin + // (works by default) + } else if (!strcmp(target, "_current") || !strcmp(target, "_self") || + !strcmp(target, "_top")) { + // Unload the plugin, put the results in the frame/window that the + // plugin was loaded in + // FIXME + } else if (!strcmp(target, "_new") || !strcmp(target, "_blank")){ + // Open a new browser window and write the results there + // FIXME + } else { + // Write the results to the specified frame + // FIXME + } + + NSPluginInstance *inst = static_cast<NSPluginInstance*>(instance->ndata); + if (inst && !inst->normalizedURL(TQString::fromLatin1(url)).isNull()) { + inst->postURL( TQString::fromLatin1(url), postdata, args.contentType(), + TQString::fromLatin1(target), 0L, args, false ); + } else { + // Unsupported / insecure + return NPERR_INVALID_URL; + } + + return NPERR_NO_ERROR; +} + + +// display status message +void g_NPN_Status(NPP instance, const char *message) +{ + kdDebug(1431) << "g_NPN_Status(): " << message << endl; + + if (!instance) + return; + + // turn into an instance signal + NSPluginInstance *inst = (NSPluginInstance*) instance->ndata; + + inst->emitStatus(message); +} + + +// inquire user agent +const char *g_NPN_UserAgent(NPP /*instance*/) +{ + KProtocolManager kpm; + TQString agent = kpm.userAgentForHost("nspluginviewer"); + kdDebug(1431) << "g_NPN_UserAgent() = " << agent << endl; + // flash crashes without Firefox UA + agent = "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.1.10) Gecko/2007101500 Firefox/2.0.0.10"; + return agent.latin1(); +} + + +// inquire version information +void g_NPN_Version(int *plugin_major, int *plugin_minor, int *browser_major, int *browser_minor) +{ + kdDebug(1431) << "g_NPN_Version()" << endl; + + // FIXME: Use the sensible values + *browser_major = NP_VERSION_MAJOR; + *browser_minor = NP_VERSION_MINOR; + + *plugin_major = NP_VERSION_MAJOR; + *plugin_minor = NP_VERSION_MINOR; +} + + +void g_NPN_ReloadPlugins(NPBool reloadPages) +{ + // http://devedge.netscape.com/library/manuals/2002/plugin/1.0/npn_api15.html#999713 + kdDebug(1431) << "g_NPN_ReloadPlugins()" << endl; + TDEProcess p; + p << TDEGlobal::dirs()->findExe("nspluginscan"); + + if (reloadPages) { + // This is the proper way, but it cannot be done because we have no + // handle to the caller! How stupid! We cannot force all konqi windows + // to reload - that would be evil. + //p.start(TDEProcess::Block); + // Let's only allow the caller to be reloaded, not everything. + //if (_callback) + // _callback->reloadPage(); + p.start(TDEProcess::DontCare); + } else { + p.start(TDEProcess::DontCare); + } +} + + +// JAVA functions +JRIEnv *g_NPN_GetJavaEnv() +{ + kdDebug(1431) << "g_NPN_GetJavaEnv() [unimplemented]" << endl; + // FIXME - what do these do? I can't find docs, and even Mozilla doesn't + // implement them + return 0; +} + + +jref g_NPN_GetJavaPeer(NPP /*instance*/) +{ + kdDebug(1431) << "g_NPN_GetJavaPeer() [unimplemented]" << endl; + // FIXME - what do these do? I can't find docs, and even Mozilla doesn't + // implement them + return 0; +} + + +NPError g_NPN_SetValue(NPP /*instance*/, NPPVariable variable, void* /*value*/) +{ + kdDebug(1431) << "g_NPN_SetValue() [unimplemented]" << endl; + switch (variable) { + case NPPVpluginWindowBool: + // FIXME + // If true, the plugin is windowless. If false, it is in a window. + case NPPVpluginTransparentBool: + // FIXME + // If true, the plugin is displayed transparent + default: + return NPERR_GENERIC_ERROR; + } +} + + + + + +/******************************************************************/ + +void +NSPluginInstance::forwarder(Widget w, XtPointer cl_data, XEvent * event, Boolean * cont) +{ + Q_UNUSED(w); + NSPluginInstance *inst = (NSPluginInstance*)cl_data; + *cont = True; + if (inst->_form == 0 || event->xkey.window == XtWindow(inst->_form)) + return; + *cont = False; + event->xkey.window = XtWindow(inst->_form); + event->xkey.subwindow = None; + XtDispatchEvent(event); +} + + +NSPluginInstance::NSPluginInstance(NPP privateData, NPPluginFuncs *pluginFuncs, + KLibrary *handle, int width, int height, + TQString src, TQString /*mime*/, + TQString appId, TQString callbackId, + bool embed, WId xembed, + TQObject *parent, const char* name ) + : DCOPObject(), TQObject( parent, name ) +{ + Q_UNUSED(embed); + _visible = false; + _npp = privateData; + _npp->ndata = this; + _destroyed = false; + _handle = handle; + _width = width; + _height = height; + _tempFiles.setAutoDelete( true ); + _streams.setAutoDelete( true ); + _waitingRequests.setAutoDelete( true ); + _callback = new NSPluginCallbackIface_stub( appId.latin1(), callbackId.latin1() ); + _xembed_window = xembed; + _toplevel = _form = 0; + + KURL base(src); + base.setFileName( TQString::null ); + _baseURL = base.url(); + + memcpy(&_pluginFuncs, pluginFuncs, sizeof(_pluginFuncs)); + + _timer = new TQTimer( this ); + connect( _timer, TQT_SIGNAL(timeout()), TQT_SLOT(timer()) ); + + kdDebug(1431) << "NSPluginInstance::NSPluginInstance" << endl; + kdDebug(1431) << "pdata = " << _npp->pdata << endl; + kdDebug(1431) << "ndata = " << _npp->ndata << endl; + + if (width == 0) + width = 1600; + + if (height == 0) + height = 1200; + + if( _xembed_window == 0 ) { + // create drawing area + Arg args[7]; + Cardinal nargs = 0; + XtSetArg(args[nargs], XtNwidth, width); nargs++; + XtSetArg(args[nargs], XtNheight, height); nargs++; + XtSetArg(args[nargs], XtNborderWidth, 0); nargs++; + + String n, c; + XtGetApplicationNameAndClass(tqt_xdisplay(), &n, &c); + + _toplevel = XtAppCreateShell("drawingArea", c, applicationShellWidgetClass, + tqt_xdisplay(), args, nargs); + + // What exactly does widget mapping mean? Without this call the widget isn't + // embedded correctly. With it the viewer doesn't show anything in standalone mode. + //if (embed) + XtSetMappedWhenManaged(_toplevel, False); + XtRealizeWidget(_toplevel); + + // Create form window that is searched for by flash plugin + _form = XtVaCreateWidget("form", compositeWidgetClass, _toplevel, NULL); + XtSetArg(args[nargs], XtNvisual, TQPaintDevice::x11AppVisual()); nargs++; + XtSetArg(args[nargs], XtNdepth, TQPaintDevice::x11AppDepth()); nargs++; + XtSetArg(args[nargs], XtNcolormap, TQPaintDevice::x11AppColormap()); nargs++; + XtSetValues(_form, args, nargs); + XSync(tqt_xdisplay(), false); + + // From mozilla - not sure if it's needed yet, nor what to use for embedder +#if 0 + /* this little trick seems to finish initializing the widget */ +#if XlibSpecificationRelease >= 6 + XtRegisterDrawable(tqt_xdisplay(), embedderid, _toplevel); +#else + _XtRegisterWindow(embedderid, _toplevel); +#endif +#endif + XtRealizeWidget(_form); + XtManageChild(_form); + + // Register forwarder + XtAddEventHandler(_toplevel, (KeyPressMask|KeyReleaseMask), + False, forwarder, (XtPointer)this ); + XtAddEventHandler(_form, (KeyPressMask|KeyReleaseMask), + False, forwarder, (XtPointer)this ); + XSync(tqt_xdisplay(), false); + } +} + +NSPluginInstance::~NSPluginInstance() +{ + kdDebug(1431) << "-> ~NSPluginInstance" << endl; + destroy(); + kdDebug(1431) << "<- ~NSPluginInstance" << endl; +} + + +void NSPluginInstance::destroy() +{ + if ( !_destroyed ) { + + kdDebug(1431) << "delete streams" << endl; + _waitingRequests.clear(); + + shutdown(); + + for( NSPluginStreamBase *s=_streams.first(); s!=0; ) { + NSPluginStreamBase *next = _streams.next(); + s->stop(); + s = next; + } + + _streams.clear(); + + kdDebug(1431) << "delete callbacks" << endl; + delete _callback; + _callback = 0; + + kdDebug(1431) << "destroy plugin" << endl; + NPSavedData *saved = 0; + + // As of 7/31/01, nsplugin crashes when used with Qt + // linked with libGL if the destroy function is called. + // A patch on that date hacked out the following call. + // On 11/17/01, Jeremy White has reenabled this destroy + // in a an attempt to better understand why this crash + // occurs so that the real problem can be found and solved. + // It's possible that a flaw in the SetWindow call + // caused the crash and it is now fixed. + if ( _pluginFuncs.destroy ) + _pluginFuncs.destroy( _npp, &saved ); + + if (saved && saved->len && saved->buf) + g_NPN_MemFree(saved->buf); + if (saved) + g_NPN_MemFree(saved); + + if( _form != 0 ) { + XtRemoveEventHandler(_form, (KeyPressMask|KeyReleaseMask), + False, forwarder, (XtPointer)this); + XtRemoveEventHandler(_toplevel, (KeyPressMask|KeyReleaseMask), + False, forwarder, (XtPointer)this); + XtDestroyWidget(_form); + _form = 0; + XtDestroyWidget(_toplevel); + _toplevel = 0; + } + + if (_npp) { + ::free(_npp); // matched with malloc() in newInstance + } + + _destroyed = true; + } +} + + +void NSPluginInstance::shutdown() +{ + NSPluginClass *cls = dynamic_cast<NSPluginClass*>(parent()); + //destroy(); + if (cls) { + cls->destroyInstance( this ); + } +} + + +void NSPluginInstance::timer() +{ + if (!_visible) { + _timer->start( 100, true ); + return; + } + + //_streams.clear(); + + // start queued requests + kdDebug(1431) << "looking for waiting requests" << endl; + while ( _waitingRequests.head() ) { + kdDebug(1431) << "request found" << endl; + Request req( *_waitingRequests.head() ); + _waitingRequests.remove(); + + TQString url; + + // make absolute url + if ( req.url.left(11).lower()=="javascript:" ) + url = req.url; + else if ( KURL::isRelativeURL(req.url) ) { + KURL bu( _baseURL ); + KURL absUrl( bu, req.url ); + url = absUrl.url(); + } else if ( req.url[0]=='/' && KURL(_baseURL).hasHost() ) { + KURL absUrl( _baseURL ); + absUrl.setPath( req.url ); + url = absUrl.url(); + } else + url = req.url; + + // non empty target = frame target + if ( !req.target.isEmpty()) + { + if (_callback) + { + if ( req.post ) { + _callback->postURL( url, req.target, req.data, req.mime ); + } else { + _callback->requestURL( url, req.target ); + } + if ( req.notify ) { + NPURLNotify( req.url, NPRES_DONE, req.notify ); + } + } + } else { + if (!url.isEmpty()) + { + kdDebug(1431) << "Starting new stream " << req.url << endl; + + if (req.post) { + // create stream + NSPluginStream *s = new NSPluginStream( this ); + connect( s, TQT_SIGNAL(finished(NSPluginStreamBase*)), + TQT_SLOT(streamFinished(NSPluginStreamBase*)) ); + _streams.append( s ); + + kdDebug() << "posting to " << url << endl; + + emitStatus( i18n("Submitting data to %1").arg(url) ); + s->post( url, req.data, req.mime, req.notify, req.args ); + } else if (url.lower().startsWith("javascript:")){ + if (_callback) { + static TQ_INT32 _jsrequestid = 0; + _jsrequests.insert(_jsrequestid, new Request(req)); + _callback->evalJavaScript(_jsrequestid++, url.mid(11)); + } else { + kdDebug() << "No callback for javascript: url!" << endl; + } + } else { + // create stream + NSPluginStream *s = new NSPluginStream( this ); + connect( s, TQT_SIGNAL(finished(NSPluginStreamBase*)), + TQT_SLOT(streamFinished(NSPluginStreamBase*)) ); + _streams.append( s ); + + kdDebug() << "getting " << url << endl; + + emitStatus( i18n("Requesting %1").arg(url) ); + s->get( url, req.mime, req.notify, req.reload ); + } + + //break; + } + } + } +} + + +TQString NSPluginInstance::normalizedURL(const TQString& url) const { + KURL bu( _baseURL ); + KURL inURL(bu, url); + TDEConfig cfg("kcmnspluginrc", true); + cfg.setGroup("Misc"); + + if (!cfg.readBoolEntry("HTTP URLs Only", false) || + inURL.protocol() == "http" || + inURL.protocol() == "https" || + inURL.protocol() == "javascript") { + return inURL.url(); + } + + // Allow: javascript:, http, https, or no protocol (match loading) + kdDebug(1431) << "NSPluginInstance::normalizedURL - I don't think so. http or https only!" << endl; + return TQString::null; +} + + +void NSPluginInstance::requestURL( const TQString &url, const TQString &mime, + const TQString &target, void *notify, bool forceNotify, bool reload ) +{ + // Generally this should already be done, but let's be safe for now. + TQString nurl = normalizedURL(url); + if (nurl.isNull()) { + return; + } + + kdDebug(1431) << "NSPluginInstance::requestURL url=" << nurl << " target=" << target << " notify=" << notify << endl; + _waitingRequests.enqueue( new Request( nurl, mime, target, notify, forceNotify, reload ) ); + _timer->start( 100, true ); +} + + +void NSPluginInstance::postURL( const TQString &url, const TQByteArray& data, + const TQString &mime, + const TQString &target, void *notify, + const KParts::URLArgs& args, bool forceNotify ) +{ + // Generally this should already be done, but let's be safe for now. + TQString nurl = normalizedURL(url); + if (nurl.isNull()) { + return; + } + + kdDebug(1431) << "NSPluginInstance::postURL url=" << nurl << " target=" << target << " notify=" << notify << endl; + _waitingRequests.enqueue( new Request( nurl, data, mime, target, notify, args, forceNotify) ); + _timer->start( 100, true ); +} + + +void NSPluginInstance::emitStatus(const TQString &message) +{ + if( _callback ) + _callback->statusMessage( message ); +} + + +void NSPluginInstance::streamFinished( NSPluginStreamBase* strm ) +{ + kdDebug(1431) << "-> NSPluginInstance::streamFinished" << endl; + emitStatus( TQString::null ); + _streams.setAutoDelete(false); // Don't delete it yet!! we get called from + // its slot! + _streams.remove(strm); + _streams.setAutoDelete(true); + strm->deleteLater(); + _timer->start( 100, true ); +} + +int NSPluginInstance::setWindow(TQ_INT8 remove) +{ + if (remove) + { + NPSetWindow(0); + return NPERR_NO_ERROR; + } + + kdDebug(1431) << "-> NSPluginInstance::setWindow" << endl; + + _win.x = 0; + _win.y = 0; + _win.height = _height; + _win.width = _width; + _win.type = NPWindowTypeWindow; + + // Well, the docu says sometimes, this is only used on the + // MAC, but sometimes it says it's always. Who knows... + _win.clipRect.top = 0; + _win.clipRect.left = 0; + _win.clipRect.bottom = _height; + _win.clipRect.right = _width; + + if( _xembed_window ) { + _win.window = (void*) _xembed_window; + _win_info.type = NP_SETWINDOW; + _win_info.display = tqt_xdisplay(); + _win_info.visual = DefaultVisualOfScreen(DefaultScreenOfDisplay(tqt_xdisplay())); + _win_info.colormap = DefaultColormapOfScreen(DefaultScreenOfDisplay(tqt_xdisplay())); + _win_info.depth = DefaultDepthOfScreen(DefaultScreenOfDisplay(tqt_xdisplay())); + } else { + _win.window = (void*) XtWindow(_form); + + _win_info.type = NP_SETWINDOW; + _win_info.display = XtDisplay(_form); + _win_info.visual = DefaultVisualOfScreen(XtScreen(_form)); + _win_info.colormap = DefaultColormapOfScreen(XtScreen(_form)); + _win_info.depth = DefaultDepthOfScreen(XtScreen(_form)); + } + + kdDebug(1431) << "Window ID = " << _win.window << endl; + + _win.ws_info = &_win_info; + + NPError error = NPSetWindow( &_win ); + + kdDebug(1431) << "<- NSPluginInstance::setWindow = " << error << endl; + return error; +} + + +static void resizeWidgets(Window w, int width, int height) { + Window rroot, parent, *children; + unsigned int nchildren = 0; + + if (XQueryTree(tqt_xdisplay(), w, &rroot, &parent, &children, &nchildren)) { + for (unsigned int i = 0; i < nchildren; i++) { + XResizeWindow(tqt_xdisplay(), children[i], width, height); + } + XFree(children); + } +} + + +void NSPluginInstance::resizePlugin(TQ_INT32 w, TQ_INT32 h) +{ + if (w == _width && h == _height) + return; + + kdDebug(1431) << "-> NSPluginInstance::resizePlugin( w=" << w << ", h=" << h << " ) " << endl; + + _width = w; + _height = h; + + if( _form != 0 ) { + XResizeWindow(tqt_xdisplay(), XtWindow(_form), w, h); + XResizeWindow(tqt_xdisplay(), XtWindow(_toplevel), w, h); + + Arg args[7]; + Cardinal nargs = 0; + XtSetArg(args[nargs], XtNwidth, _width); nargs++; + XtSetArg(args[nargs], XtNheight, _height); nargs++; + XtSetArg(args[nargs], XtNvisual, TQPaintDevice::x11AppVisual()); nargs++; + XtSetArg(args[nargs], XtNdepth, TQPaintDevice::x11AppDepth()); nargs++; + XtSetArg(args[nargs], XtNcolormap, TQPaintDevice::x11AppColormap()); nargs++; + XtSetArg(args[nargs], XtNborderWidth, 0); nargs++; + + XtSetValues(_toplevel, args, nargs); + XtSetValues(_form, args, nargs); + + resizeWidgets(XtWindow(_form), _width, _height); + } + + // If not visible yet, displayWindow() will call setWindow() again anyway, so avoid this. + // This also handled plugins that are broken and cannot handle repeated setWindow() calls + // very well. + if (!_visible) + return; + + setWindow(); + + kdDebug(1431) << "<- NSPluginInstance::resizePlugin" << endl; +} + + +void NSPluginInstance::javascriptResult(TQ_INT32 id, TQString result) { + TQMap<int, Request*>::iterator i = _jsrequests.find( id ); + if (i != _jsrequests.end()) { + Request *req = i.data(); + _jsrequests.remove( i ); + NSPluginStream *s = new NSPluginStream( this ); + connect( s, TQT_SIGNAL(finished(NSPluginStreamBase*)), + TQT_SLOT(streamFinished(NSPluginStreamBase*)) ); + _streams.append( s ); + + int len = result.length(); + s->create( req->url, TQString("text/plain"), req->notify, req->forceNotify ); + kdDebug(1431) << "javascriptResult has been called with: "<<result<<endl; + if (len > 0) { + TQByteArray data(len + 1); + memcpy(data.data(), result.latin1(), len); + data[len] = 0; + s->process(data, 0); + } else { + len = 7; // "unknown" + TQByteArray data(len + 1); + memcpy(data.data(), "unknown", len); + data[len] = 0; + s->process(data, 0); + } + s->finish(false); + + delete req; + } +} + + +NPError NSPluginInstance::NPGetValue(NPPVariable variable, void *value) +{ + if( value==0 ) { + kdDebug() << "FIXME: value==0 in NSPluginInstance::NPGetValue" << endl; + return NPERR_GENERIC_ERROR; + } + + if (!_pluginFuncs.getvalue) + return NPERR_GENERIC_ERROR; + + NPError error = _pluginFuncs.getvalue(_npp, variable, value); + + CHECK(GetValue,error); +} + + +NPError NSPluginInstance::NPSetValue(NPNVariable variable, void *value) +{ + if( value==0 ) { + kdDebug() << "FIXME: value==0 in NSPluginInstance::NPSetValue" << endl; + return NPERR_GENERIC_ERROR; + } + + if (!_pluginFuncs.setvalue) + return NPERR_GENERIC_ERROR; + + NPError error = _pluginFuncs.setvalue(_npp, variable, value); + + CHECK(SetValue,error); +} + + +NPError NSPluginInstance::NPSetWindow(NPWindow *window) +{ + if( window==0 ) { + kdDebug() << "FIXME: window==0 in NSPluginInstance::NPSetWindow" << endl; + return NPERR_GENERIC_ERROR; + } + + if (!_pluginFuncs.setwindow) + return NPERR_GENERIC_ERROR; + + NPError error = _pluginFuncs.setwindow(_npp, window); + + CHECK(SetWindow,error); +} + + +NPError NSPluginInstance::NPDestroyStream(NPStream *stream, NPReason reason) +{ + if( stream==0 ) { + kdDebug() << "FIXME: stream==0 in NSPluginInstance::NPDestroyStream" << endl; + return NPERR_GENERIC_ERROR; + } + + if (!_pluginFuncs.destroystream) + return NPERR_GENERIC_ERROR; + + NPError error = _pluginFuncs.destroystream(_npp, stream, reason); + + CHECK(DestroyStream,error); +} + + +NPError NSPluginInstance::NPNewStream(NPMIMEType type, NPStream *stream, NPBool seekable, uint16 *stype) +{ + if( stream==0 ) { + kdDebug() << "FIXME: stream==0 in NSPluginInstance::NPNewStream" << endl; + return NPERR_GENERIC_ERROR; + } + + if( stype==0 ) { + kdDebug() << "FIXME: stype==0 in NSPluginInstance::NPNewStream" << endl; + return NPERR_GENERIC_ERROR; + } + + if (!_pluginFuncs.newstream) + return NPERR_GENERIC_ERROR; + + NPError error = _pluginFuncs.newstream(_npp, type, stream, seekable, stype); + + CHECK(NewStream,error); +} + + +void NSPluginInstance::NPStreamAsFile(NPStream *stream, const char *fname) +{ + if( stream==0 ) { + kdDebug() << "FIXME: stream==0 in NSPluginInstance::NPStreamAsFile" << endl; + return; + } + + if( fname==0 ) { + kdDebug() << "FIXME: fname==0 in NSPluginInstance::NPStreamAsFile" << endl; + return; + } + + if (!_pluginFuncs.asfile) + return; + + _pluginFuncs.asfile(_npp, stream, fname); +} + + +int32 NSPluginInstance::NPWrite(NPStream *stream, int32 offset, int32 len, void *buf) +{ + if( stream==0 ) { + kdDebug() << "FIXME: stream==0 in NSPluginInstance::NPWrite" << endl; + return 0; + } + + if( buf==0 ) { + kdDebug() << "FIXME: buf==0 in NSPluginInstance::NPWrite" << endl; + return 0; + } + + if (!_pluginFuncs.write) + return 0; + + return _pluginFuncs.write(_npp, stream, offset, len, buf); +} + + +int32 NSPluginInstance::NPWriteReady(NPStream *stream) +{ + if( stream==0 ) { + kdDebug() << "FIXME: stream==0 in NSPluginInstance::NPWriteReady" << endl; + return 0; + } + + if (!_pluginFuncs.writeready) + return 0; + + return _pluginFuncs.writeready(_npp, stream); +} + + +void NSPluginInstance::NPURLNotify(TQString url, NPReason reason, void *notifyData) +{ + if (!_pluginFuncs.urlnotify) + return; + + _pluginFuncs.urlnotify(_npp, url.ascii(), reason, notifyData); +} + + +void NSPluginInstance::addTempFile(KTempFile *tmpFile) +{ + _tempFiles.append(tmpFile); +} + +/* + * We have to call this after we reparent the widget otherwise some plugins + * like the ones based on WINE get very confused. (their coordinates are not + * adjusted for the mouse at best) + */ +void NSPluginInstance::displayPlugin() +{ + // display plugin + setWindow(); + + _visible = true; + kdDebug(1431) << "<- NSPluginInstance::displayPlugin = " << (void*)this << endl; +} + +static bool has_focus = false; + +void NSPluginInstance::gotFocusIn() +{ + has_focus = true; +} + +void NSPluginInstance::gotFocusOut() +{ + has_focus = false; +} + +#include <dlfcn.h> +// Prevent plugins from polling the keyboard regardless of focus. +static int (*real_xquerykeymap)( Display*, char[32] ) = NULL; + +extern "C" KDE_EXPORT +int XQueryKeymap( Display* dpy, char k[32] ) +{ + if( real_xquerykeymap == NULL ) + real_xquerykeymap = (int (*)( Display*, char[32] )) dlsym( RTLD_NEXT, "XQueryKeymap" ); + if( has_focus ) + return real_xquerykeymap( dpy, k ); + memset( k, 0, 32 ); + return 1; +} + + + +/***************************************************************************/ + +NSPluginViewer::NSPluginViewer( TQCString dcopId, + TQObject *parent, const char *name ) + : DCOPObject(dcopId), TQObject( parent, name ) +{ + _classes.setAutoDelete( true ); + connect(TDEApplication::dcopClient(), + TQT_SIGNAL(applicationRemoved(const TQCString&)), + this, + TQT_SLOT(appUnregistered(const TQCString&))); +} + + +NSPluginViewer::~NSPluginViewer() +{ + kdDebug(1431) << "NSPluginViewer::~NSPluginViewer" << endl; +} + + +void NSPluginViewer::appUnregistered(const TQCString& id) { + if (id.isEmpty()) { + return; + } + + TQDictIterator<NSPluginClass> it(_classes); + NSPluginClass *c; + while ( (c = it.current()) ) { + TQString key = it.currentKey(); + ++it; + if (c->app() == id) { + _classes.remove(key); + } + } + + if (_classes.isEmpty()) { + shutdown(); + } +} + + +void NSPluginViewer::shutdown() +{ + kdDebug(1431) << "NSPluginViewer::shutdown" << endl; + _classes.clear(); +#if TQT_VERSION < 0x030100 + quitXt(); +#else + tqApp->quit(); +#endif +} + + +DCOPRef NSPluginViewer::newClass( TQString plugin ) +{ + kdDebug(1431) << "NSPluginViewer::NewClass( " << plugin << ")" << endl; + + // search existing class + NSPluginClass *cls = _classes[ plugin ]; + if ( !cls ) { + // create new class + cls = new NSPluginClass( plugin, this ); + TQCString id = ""; + DCOPClient *dc = callingDcopClient(); + if (dc) { + id = dc->senderId(); + } + cls->setApp(id); + if ( cls->error() ) { + kdError(1431) << "Can't create plugin class" << endl; + delete cls; + return DCOPRef(); + } + + _classes.insert( plugin, cls ); + } + + return DCOPRef( kapp->dcopClient()->appId(), cls->objId() ); +} + + +/****************************************************************************/ + +bool NSPluginClass::s_initedGTK = false; + +typedef void gtkInitFunc(int *argc, char ***argv); + +NSPluginClass::NSPluginClass( const TQString &library, + TQObject *parent, const char *name ) + : DCOPObject(), TQObject( parent, name ) +{ + // initialize members + _handle = KLibLoader::self()->library(TQFile::encodeName(library)); + _libname = library; + _constructed = false; + _error = true; + _instances.setAutoDelete( true ); + _NP_GetMIMEDescription = 0; + _NP_Initialize = 0; + _NP_Shutdown = 0; + + _timer = new TQTimer( this ); + connect( _timer, TQT_SIGNAL(timeout()), TQT_SLOT(timer()) ); + + // check lib handle + if (!_handle) { + kdDebug(1431) << "Could not dlopen " << library << endl; + return; + } + + // get exported lib functions + _NP_GetMIMEDescription = (NP_GetMIMEDescriptionUPP *)_handle->symbol("NP_GetMIMEDescription"); + _NP_Initialize = (NP_InitializeUPP *)_handle->symbol("NP_Initialize"); + _NP_Shutdown = (NP_ShutdownUPP *)_handle->symbol("NP_Shutdown"); + + // check for valid returned ptrs + if (!_NP_GetMIMEDescription) { + kdDebug(1431) << "Could not get symbol NP_GetMIMEDescription" << endl; + return; + } + + if (!_NP_Initialize) { + kdDebug(1431) << "Could not get symbol NP_Initialize" << endl; + return; + } + + if (!_NP_Shutdown) { + kdDebug(1431) << "Could not get symbol NP_Shutdown" << endl; + return; + } + + // initialize plugin + kdDebug(1431) << "Plugin library " << library << " loaded!" << endl; + + // see if it uses gtk + if (!s_initedGTK) { + gtkInitFunc* gtkInit = (gtkInitFunc*)_handle->symbol("gtk_init"); + if (gtkInit) { + kdDebug(1431) << "Calling gtk_init for the plugin" << endl; + // Prevent gtk_init() from replacing the X error handlers, since the Gtk + // handlers abort when they receive an X error, thus killing the viewer. + int (*old_error_handler)(Display*,XErrorEvent*) = XSetErrorHandler(0); + int (*old_io_error_handler)(Display*) = XSetIOErrorHandler(0); + gtkInit(0, 0); + XSetErrorHandler(old_error_handler); + XSetIOErrorHandler(old_io_error_handler); + s_initedGTK = true; + } + } + + _constructed = true; + _error = initialize()!=NPERR_NO_ERROR; +} + + +NSPluginClass::~NSPluginClass() +{ + _instances.clear(); + _trash.clear(); + shutdown(); + if (_handle) + _handle->unload(); +} + + +void NSPluginClass::timer() +{ + // delete instances + for ( NSPluginInstance *it=_trash.first(); it!=0; it=_trash.next() ) + _instances.remove(it); + + _trash.clear(); +} + + +int NSPluginClass::initialize() +{ + kdDebug(1431) << "NSPluginClass::Initialize()" << endl; + + if ( !_constructed ) + return NPERR_GENERIC_ERROR; + + // initialize nescape exported functions + memset(&_pluginFuncs, 0, sizeof(_pluginFuncs)); + memset(&_nsFuncs, 0, sizeof(_nsFuncs)); + + _pluginFuncs.size = sizeof(_pluginFuncs); + _nsFuncs.size = sizeof(_nsFuncs); + _nsFuncs.version = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR; + _nsFuncs.geturl = g_NPN_GetURL; + _nsFuncs.posturl = g_NPN_PostURL; + _nsFuncs.requestread = g_NPN_RequestRead; + _nsFuncs.newstream = g_NPN_NewStream; + _nsFuncs.write = g_NPN_Write; + _nsFuncs.destroystream = g_NPN_DestroyStream; + _nsFuncs.status = g_NPN_Status; + _nsFuncs.uagent = g_NPN_UserAgent; + _nsFuncs.memalloc = g_NPN_MemAlloc; + _nsFuncs.memfree = g_NPN_MemFree; + _nsFuncs.memflush = g_NPN_MemFlush; + _nsFuncs.reloadplugins = g_NPN_ReloadPlugins; + _nsFuncs.getJavaEnv = g_NPN_GetJavaEnv; + _nsFuncs.getJavaPeer = g_NPN_GetJavaPeer; + _nsFuncs.geturlnotify = g_NPN_GetURLNotify; + _nsFuncs.posturlnotify = g_NPN_PostURLNotify; + _nsFuncs.getvalue = g_NPN_GetValue; + _nsFuncs.setvalue = g_NPN_SetValue; + _nsFuncs.invalidaterect = g_NPN_InvalidateRect; + _nsFuncs.invalidateregion = g_NPN_InvalidateRegion; + _nsFuncs.forceredraw = g_NPN_ForceRedraw; + + // initialize plugin + NPError error = _NP_Initialize(&_nsFuncs, &_pluginFuncs); + CHECK(Initialize,error); +} + + +TQString NSPluginClass::getMIMEDescription() +{ + return _NP_GetMIMEDescription(); +} + + +void NSPluginClass::shutdown() +{ + kdDebug(1431) << "NSPluginClass::shutdown error=" << _error << endl; + if( _NP_Shutdown && !_error ) + _NP_Shutdown(); +} + + +DCOPRef NSPluginClass::newInstance( TQString url, TQString mimeType, TQ_INT8 embed, + TQStringList argn, TQStringList argv, + TQString appId, TQString callbackId, + TQ_INT8 reload, TQ_INT8 doPost, TQByteArray postData, TQ_UINT32 xembed ) +{ + kdDebug(1431) << "-> NSPluginClass::NewInstance" << endl; + + if ( !_constructed ) + return DCOPRef(); + + // copy parameters over + unsigned int argc = argn.count(); + char **_argn = new char*[argc]; + char **_argv = new char*[argc]; + TQString src = url; + int width = 0; + int height = 0; + TQString baseURL = url; + + for (unsigned int i=0; i<argc; i++) + { + TQCString encN = argn[i].utf8(); + TQCString encV = argv[i].utf8(); + + const char *n = encN; + const char *v = encV; + + _argn[i] = strdup(n); + _argv[i] = strdup(v); + + if (!strcasecmp(_argn[i], "WIDTH")) width = argv[i].toInt(); + if (!strcasecmp(_argn[i], "HEIGHT")) height = argv[i].toInt(); + if (!strcasecmp(_argn[i], "__TDEHTML__PLUGINBASEURL")) baseURL = _argv[i]; + kdDebug(1431) << "argn=" << _argn[i] << " argv=" << _argv[i] << endl; + } + + // create plugin instance + char mime[256]; + strncpy(mime, mimeType.ascii(), 255); + mime[255] = 0; + NPP npp = (NPP)malloc(sizeof(NPP_t)); // I think we should be using + // malloc here, just to be safe, + // since the nsplugin plays with + // this thing + memset(npp, 0, sizeof(NPP_t)); + npp->ndata = NULL; + + // create plugin instance + NPError error = _pluginFuncs.newp(mime, npp, embed ? NP_EMBED : NP_FULL, + argc, _argn, _argv, 0); + kdDebug(1431) << "NPP_New = " << (int)error << endl; + + // don't use bool here, it can be 1 byte, but some plugins write it as int, and I can't find what the spec says + int wants_xembed = false; + if (_pluginFuncs.getvalue) { + NPError error = _pluginFuncs.getvalue(npp, (NPPVariable)14/*NPPVpluginNeedsXEmbed*/, &wants_xembed ); + if( error != NPERR_NO_ERROR ) + wants_xembed = false; + } + kdDebug(1431) << "Plugin requires XEmbed:" << (bool)wants_xembed << endl; + + // Create plugin instance object + NSPluginInstance *inst = new NSPluginInstance( npp, &_pluginFuncs, _handle, + width, height, baseURL, mimeType, + appId, callbackId, embed, wants_xembed ? xembed : 0, this ); + + // free arrays with arguments + delete [] _argn; + delete [] _argv; + + // check for error + if ( error!=NPERR_NO_ERROR) + { + delete inst; + //delete npp; double delete! + kdDebug(1431) << "<- PluginClass::NewInstance = 0" << endl; + return DCOPRef(); + } + + // create source stream + if ( !src.isEmpty() ) { + if (doPost) { + inst->postURL(src, postData, mimeType, TQString::null, 0, KParts::URLArgs(), false); + } else { + inst->requestURL( src, mimeType, TQString::null, 0, false, reload ); + } + } + + _instances.append( inst ); + return DCOPRef(kapp->dcopClient()->appId(), inst->objId()); +} + + +void NSPluginClass::destroyInstance( NSPluginInstance* inst ) +{ + // mark for destruction + _trash.append( inst ); + timer(); //_timer->start( 0, TRUE ); +} + +/****************************************************************************/ + +NSPluginStreamBase::NSPluginStreamBase( NSPluginInstance *instance ) + : TQObject( instance ), _instance(instance), _stream(0), _tempFile(0L), + _pos(0), _queue(0), _queuePos(0), _error(false) +{ + _informed = false; +} + + +NSPluginStreamBase::~NSPluginStreamBase() +{ + if (_stream) { + _instance->NPDestroyStream( _stream, NPRES_USER_BREAK ); + if (_stream && _stream->url) + free(const_cast<char*>(_stream->url)); + delete _stream; + _stream = 0; + } + + delete _tempFile; + _tempFile = 0; +} + + +void NSPluginStreamBase::stop() +{ + finish( true ); +} + +void NSPluginStreamBase::inform() +{ + + if (! _informed) + { + KURL src(_url); + + _informed = true; + + // inform the plugin + _instance->NPNewStream( _mimeType.isEmpty() ? (char *) "text/plain" : (char*)_mimeType.ascii(), + _stream, false, &_streamType ); + kdDebug(1431) << "NewStream stype=" << _streamType << " url=" << _url << " mime=" << _mimeType << endl; + + // prepare data transfer + _tempFile = 0L; + + if ( _streamType==NP_ASFILE || _streamType==NP_ASFILEONLY ) { + _onlyAsFile = _streamType==NP_ASFILEONLY; + if ( KURL(_url).isLocalFile() ) { + kdDebug(1431) << "local file" << endl; + // local file can be passed directly + _fileURL = KURL(_url).path(); + + // without streaming stream is finished already + if ( _onlyAsFile ) { + kdDebug() << "local file AS_FILE_ONLY" << endl; + finish( false ); + } + } else { + kdDebug() << "remote file" << endl; + + // stream into temporary file (use lower() in case the + // filename as an upper case X in it) + _tempFile = new KTempFile; + _tempFile->setAutoDelete( TRUE ); + _fileURL = _tempFile->name(); + kdDebug() << "saving into " << _fileURL << endl; + } + } + } + +} + +bool NSPluginStreamBase::create( const TQString& url, const TQString& mimeType, void *notify, bool forceNotify) +{ + if ( _stream ) + return false; + + _url = url; + _notifyData = notify; + _pos = 0; + _tries = 0; + _onlyAsFile = false; + _streamType = NP_NORMAL; + _informed = false; + _forceNotify = forceNotify; + + // create new stream + _stream = new NPStream; + _stream->ndata = this; + _stream->url = strdup(url.ascii()); + _stream->end = 0; + _stream->pdata = 0; + _stream->lastmodified = 0; + _stream->notifyData = _notifyData; + _stream->headers = 0; + + _mimeType = mimeType; + + return true; +} + +void NSPluginStreamBase::updateURL( const KURL& newURL ) +{ + _url = newURL; + free(const_cast<char*>(_stream->url)); + _stream->url = strdup(_url.url().ascii()); +} + +int NSPluginStreamBase::process( const TQByteArray &data, int start ) +{ + int32 max, sent, to_sent, len; + char *d = const_cast<TQByteArray&>(data).data() + start; + + to_sent = data.size() - start; + while (to_sent > 0) + { + inform(); + + max = _instance->NPWriteReady(_stream); + //kdDebug(1431) << "to_sent == " << to_sent << " and max = " << max << endl; + len = TQMIN(max, to_sent); + + //kdDebug(1431) << "-> Feeding stream to plugin: offset=" << _pos << ", len=" << len << endl; + sent = _instance->NPWrite( _stream, _pos, len, d ); + //kdDebug(1431) << "<- Feeding stream: sent = " << sent << endl; + + if (sent == 0) // interrupt the stream for a few ms + break; + + if (sent < 0) { + // stream data rejected/error + kdDebug(1431) << "stream data rejected/error" << endl; + _error = true; + break; + } + + if (_tempFile) { + _tempFile->dataStream()->writeRawBytes(d, sent); + } + + to_sent -= sent; + _pos += sent; + d += sent; + } + + return data.size() - to_sent; +} + + +bool NSPluginStreamBase::pump() +{ + //kdDebug(1431) << "queue pos " << _queuePos << ", size " << _queue.size() << endl; + + inform(); + + if ( _queuePos<_queue.size() ) { + unsigned newPos; + + // handle AS_FILE_ONLY streams + if ( _onlyAsFile ) { + if (_tempFile) { + _tempFile->dataStream()->writeRawBytes( _queue, _queue.size() ); + } + newPos = _queuePos+_queue.size(); + } else { + // normal streams + newPos = process( _queue, _queuePos ); + } + + // count tries + if ( newPos==_queuePos ) + _tries++; + else + _tries = 0; + + _queuePos = newPos; + } + + // return true if queue finished + return _queuePos>=_queue.size(); +} + + +void NSPluginStreamBase::queue( const TQByteArray &data ) +{ + _queue = data; + _queue.detach(); + _queuePos = 0; + _tries = 0; + +/* + kdDebug(1431) << "new queue size=" << data.size() + << " data=" << (void*)data.data() + << " queue=" << (void*)_queue.data() << " qsize=" + << _queue.size() << endl; +*/ +} + + +void NSPluginStreamBase::finish( bool err ) +{ + kdDebug(1431) << "finish error=" << err << endl; + + _queue.resize( 0 ); + _pos = 0; + _queuePos = 0; + + inform(); + + if ( !err ) { + if ( _tempFile ) { + _tempFile->close(); + _instance->addTempFile( _tempFile ); + _tempFile = 0; + } + + if ( !_fileURL.isEmpty() ) { + kdDebug() << "stream as file " << _fileURL << endl; + _instance->NPStreamAsFile( _stream, _fileURL.ascii() ); + } + + _instance->NPDestroyStream( _stream, NPRES_DONE ); + if (_notifyData || _forceNotify) + _instance->NPURLNotify( _url.url(), NPRES_DONE, _notifyData ); + } else { + // close temp file + if ( _tempFile ) { + _tempFile->close(); + } + + // destroy stream + _instance->NPDestroyStream( _stream, NPRES_NETWORK_ERR ); + if (_notifyData || _forceNotify) + _instance->NPURLNotify( _url.url(), NPRES_NETWORK_ERR, _notifyData ); + } + + // delete stream + if (_stream && _stream->url) + free(const_cast<char *>(_stream->url)); + delete _stream; + _stream = 0; + + // destroy NSPluginStream object + emit finished( this ); +} + + +/****************************************************************************/ + +NSPluginBufStream::NSPluginBufStream( class NSPluginInstance *instance ) + : NSPluginStreamBase( instance ) +{ + _timer = new TQTimer( this ); + connect( _timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(timer()) ); +} + + +NSPluginBufStream::~NSPluginBufStream() +{ + +} + + +bool NSPluginBufStream::get( const TQString& url, const TQString& mimeType, + const TQByteArray &buf, void *notifyData, + bool singleShot ) +{ + _singleShot = singleShot; + if ( create( url, mimeType, notifyData ) ) { + queue( buf ); + _timer->start( 100, true ); + } + + return false; +} + + +void NSPluginBufStream::timer() +{ + bool finished = pump(); + if ( _singleShot ) + finish( false ); + else { + + if ( !finished && tries()<=8 ) + _timer->start( 100, true ); + else + finish( error() || tries()>8 ); + } +} + + + +/****************************************************************************/ + +NSPluginStream::NSPluginStream( NSPluginInstance *instance ) + : NSPluginStreamBase( instance ), _job(0) +{ + _resumeTimer = new TQTimer( this ); + connect(_resumeTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(resume())); +} + + +NSPluginStream::~NSPluginStream() +{ + if ( _job ) + _job->kill( true ); +} + + +bool NSPluginStream::get( const TQString& url, const TQString& mimeType, + void *notify, bool reload ) +{ + // create new stream + if ( create( url, mimeType, notify ) ) { + // start the tdeio job + _job = TDEIO::get(KURL( url ), false, false); + _job->addMetaData("errorPage", "false"); + _job->addMetaData("AllowCompressedPage", "false"); + _job->addMetaData("PropagateHttpHeader", "true"); + if (reload) { + _job->addMetaData("cache", "reload"); + } + connect(_job, TQT_SIGNAL(data(TDEIO::Job *, const TQByteArray &)), + TQT_SLOT(data(TDEIO::Job *, const TQByteArray &))); + connect(_job, TQT_SIGNAL(result(TDEIO::Job *)), TQT_SLOT(result(TDEIO::Job *))); + connect(_job, TQT_SIGNAL(totalSize(TDEIO::Job *, TDEIO::filesize_t )), + TQT_SLOT(totalSize(TDEIO::Job *, TDEIO::filesize_t))); + connect(_job, TQT_SIGNAL(mimetype(TDEIO::Job *, const TQString &)), + TQT_SLOT(mimetype(TDEIO::Job *, const TQString &))); + connect(_job, TQT_SIGNAL(redirection(TDEIO::Job *, const KURL&)), + TQT_SLOT(redirection(TDEIO::Job *, const KURL&))); + } + + return false; +} + + +bool NSPluginStream::post( const TQString& url, const TQByteArray& data, + const TQString& mimeType, void *notify, const KParts::URLArgs& args ) +{ + // create new stream + if ( create( url, mimeType, notify ) ) { + // start the tdeio job + _job = TDEIO::http_post(KURL( url ), data, false); + _job->addMetaData("content-type", args.contentType()); + _job->addMetaData("errorPage", "false"); + _job->addMetaData("PropagateHttpHeader", "true"); + _job->addMetaData("AllowCompressedPage", "false"); + connect(_job, TQT_SIGNAL(data(TDEIO::Job *, const TQByteArray &)), + TQT_SLOT(data(TDEIO::Job *, const TQByteArray &))); + connect(_job, TQT_SIGNAL(result(TDEIO::Job *)), TQT_SLOT(result(TDEIO::Job *))); + connect(_job, TQT_SIGNAL(totalSize(TDEIO::Job *, TDEIO::filesize_t )), + TQT_SLOT(totalSize(TDEIO::Job *, TDEIO::filesize_t))); + connect(_job, TQT_SIGNAL(mimetype(TDEIO::Job *, const TQString &)), + TQT_SLOT(mimetype(TDEIO::Job *, const TQString &))); + connect(_job, TQT_SIGNAL(redirection(TDEIO::Job *, const KURL&)), + TQT_SLOT(redirection(TDEIO::Job *, const KURL&))); + } + + return false; +} + + +void NSPluginStream::data(TDEIO::Job * job, const TQByteArray &data) +{ + //kdDebug(1431) << "NSPluginStream::data - job=" << (void*)job << " data size=" << data.size() << endl; + queue( data ); + if ( !pump() ) { + _job->suspend(); + _resumeTimer->start( 100, TRUE ); + } +} + +void NSPluginStream::redirection(TDEIO::Job * /*job*/, const KURL& url) +{ + updateURL( url ); +} + +void NSPluginStream::totalSize(TDEIO::Job * job, TDEIO::filesize_t size) +{ + kdDebug(1431) << "NSPluginStream::totalSize - job=" << (void*)job << " size=" << TDEIO::number(size) << endl; + _stream->end = size; +} + +void NSPluginStream::mimetype(TDEIO::Job * job, const TQString &mimeType) +{ + kdDebug(1431) << "NSPluginStream::mimetype - job=" << (void*)job << " mimeType=" << mimeType << endl; + _mimeType = mimeType; + TQString tmp_headers = job->metaData()["HTTP-Headers"]; + _headers.duplicate(tmp_headers.latin1(), tmp_headers.length()); + _stream->headers = _headers.data(); +} + +void NSPluginStream::resume() +{ + if ( error() || tries()>8 ) { + _job->kill( true ); + finish( true ); + return; + } + + if ( pump() ) { + kdDebug(1431) << "resume job" << endl; + _job->resume(); + } else { + kdDebug(1431) << "restart timer" << endl; + _resumeTimer->start( 100, TRUE ); + } +} + + +void NSPluginStream::result(TDEIO::Job *job) +{ + int err = job->error(); + _job = 0; + finish( err!=0 || error() ); +} + +#include "nsplugin.moc" +// vim: ts=4 sw=4 et diff --git a/nsplugins/viewer/nsplugin.h b/nsplugins/viewer/nsplugin.h new file mode 100644 index 000000000..96bb1da15 --- /dev/null +++ b/nsplugins/viewer/nsplugin.h @@ -0,0 +1,344 @@ +/* + + This is an encapsulation of the Netscape plugin API. + + Copyright (c) 2000 Matthias Hoelzer-Kluepfel <hoelzer@kde.org> + Stefan Schimanski <1Stein@gmx.de> + Copyright (c) 2003-2005 George Staikos <staikos@kde.org> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ + + +#ifndef __NS_PLUGIN_H__ +#define __NS_PLUGIN_H__ + + +#include <dcopobject.h> +#include "NSPluginClassIface.h" +#include "NSPluginCallbackIface_stub.h" + + +#include <tqobject.h> +#include <tqstring.h> +#include <tqstringlist.h> +#include <tqptrqueue.h> +#include <tqdict.h> +#include <tqmap.h> +#include <tqintdict.h> +#include <tqguardedptr.h> + +#include <tdeparts/browserextension.h> // for URLArgs +#include <tdeio/job.h> + + +#define XP_UNIX +#define MOZ_X11 +#include "sdk/npupp.h" + +typedef char* NP_GetMIMEDescriptionUPP(void); +typedef NPError NP_InitializeUPP(NPNetscapeFuncs*, NPPluginFuncs*); +typedef NPError NP_ShutdownUPP(void); + + +#include <X11/Intrinsic.h> + + +void quitXt(); + +class KLibrary; +class TQTimer; + + +class NSPluginStreamBase : public TQObject +{ +Q_OBJECT +friend class NSPluginInstance; +public: + NSPluginStreamBase( class NSPluginInstance *instance ); + ~NSPluginStreamBase(); + + KURL url() { return _url; } + int pos() { return _pos; } + void stop(); + +signals: + void finished( NSPluginStreamBase *strm ); + +protected: + void finish( bool err ); + bool pump(); + bool error() { return _error; } + void queue( const TQByteArray &data ); + bool create( const TQString& url, const TQString& mimeType, void *notify, bool forceNotify = false ); + int tries() { return _tries; } + void inform( ); + void updateURL( const KURL& newURL ); + + class NSPluginInstance *_instance; + uint16 _streamType; + NPStream *_stream; + void *_notifyData; + KURL _url; + TQString _fileURL; + TQString _mimeType; + TQByteArray _headers; + TQByteArray _data; + class KTempFile *_tempFile; + +private: + int process( const TQByteArray &data, int start ); + + unsigned int _pos; + TQByteArray _queue; + unsigned int _queuePos; + int _tries; + bool _onlyAsFile; + bool _error; + bool _informed; + bool _forceNotify; +}; + + +class NSPluginStream : public NSPluginStreamBase +{ + Q_OBJECT + +public: + NSPluginStream( class NSPluginInstance *instance ); + ~NSPluginStream(); + + bool get(const TQString& url, const TQString& mimeType, void *notifyData, bool reload = false); + bool post(const TQString& url, const TQByteArray& data, const TQString& mimeType, void *notifyData, const KParts::URLArgs& args); + +protected slots: + void data(TDEIO::Job *job, const TQByteArray &data); + void totalSize(TDEIO::Job *job, TDEIO::filesize_t size); + void mimetype(TDEIO::Job * job, const TQString &mimeType); + void result(TDEIO::Job *job); + void redirection(TDEIO::Job *job, const KURL& url); + void resume(); + +protected: + TQGuardedPtr<TDEIO::TransferJob> _job; + TQTimer *_resumeTimer; +}; + + +class NSPluginBufStream : public NSPluginStreamBase +{ + Q_OBJECT + +public: + NSPluginBufStream( class NSPluginInstance *instance ); + ~NSPluginBufStream(); + + bool get( const TQString& url, const TQString& mimeType, const TQByteArray &buf, void *notifyData, bool singleShot=false ); + +protected slots: + void timer(); + +protected: + TQTimer *_timer; + bool _singleShot; +}; + + +class NSPluginInstance : public TQObject, public virtual NSPluginInstanceIface +{ + Q_OBJECT + +public: + + // constructor, destructor + NSPluginInstance( NPP privateData, NPPluginFuncs *pluginFuncs, KLibrary *handle, + int width, int height, TQString src, TQString mime, + TQString appId, TQString callbackId, bool embed, WId xembed, + TQObject *parent, const char* name=0 ); + ~NSPluginInstance(); + + // DCOP functions + void shutdown(); + int winId() { return _form != 0 ? XtWindow(_form) : 0; } + int setWindow(TQ_INT8 remove=0); + void resizePlugin(TQ_INT32 w, TQ_INT32 h); + void javascriptResult(TQ_INT32 id, TQString result); + void displayPlugin(); + void gotFocusIn(); + void gotFocusOut(); + + // value handling + NPError NPGetValue(NPPVariable variable, void *value); + NPError NPSetValue(NPNVariable variable, void *value); + + // window handling + NPError NPSetWindow(NPWindow *window); + + // stream functions + NPError NPDestroyStream(NPStream *stream, NPReason reason); + NPError NPNewStream(NPMIMEType type, NPStream *stream, NPBool seekable, uint16 *stype); + void NPStreamAsFile(NPStream *stream, const char *fname); + int32 NPWrite(NPStream *stream, int32 offset, int32 len, void *buf); + int32 NPWriteReady(NPStream *stream); + + // URL functions + void NPURLNotify(TQString url, NPReason reason, void *notifyData); + + // Event handling + uint16 HandleEvent(void *event); + + // signal emitters + void emitStatus( const TQString &message); + void requestURL( const TQString &url, const TQString &mime, + const TQString &target, void *notify, bool forceNotify = false, bool reload = false ); + void postURL( const TQString &url, const TQByteArray& data, const TQString &mime, + const TQString &target, void *notify, const KParts::URLArgs& args, bool forceNotify = false ); + + TQString normalizedURL(const TQString& url) const; + +public slots: + void streamFinished( NSPluginStreamBase *strm ); + +private slots: + void timer(); + +private: + friend class NSPluginStreamBase; + + static void forwarder(Widget, XtPointer, XEvent *, Boolean*); + + void destroy(); + + bool _destroyed; + bool _visible; + void addTempFile(KTempFile *tmpFile); + TQPtrList<KTempFile> _tempFiles; + NSPluginCallbackIface_stub *_callback; + TQPtrList<NSPluginStreamBase> _streams; + KLibrary *_handle; + TQTimer *_timer; + + NPP _npp; + NPPluginFuncs _pluginFuncs; + + Widget _area, _form, _toplevel; + WId _xembed_window; + TQString _baseURL; + int _width, _height; + + struct Request + { + // A GET request + Request( const TQString &_url, const TQString &_mime, + const TQString &_target, void *_notify, bool _forceNotify = false, + bool _reload = false) + { url=_url; mime=_mime; target=_target; notify=_notify; post=false; forceNotify = _forceNotify; reload = _reload; } + + // A POST request + Request( const TQString &_url, const TQByteArray& _data, + const TQString &_mime, const TQString &_target, void *_notify, + const KParts::URLArgs& _args, bool _forceNotify = false) + { url=_url; mime=_mime; target=_target; + notify=_notify; post=true; data=_data; args=_args; + forceNotify = _forceNotify; } + + TQString url; + TQString mime; + TQString target; + TQByteArray data; + bool post; + bool forceNotify; + bool reload; + void *notify; + KParts::URLArgs args; + }; + + NPWindow _win; + NPSetWindowCallbackStruct _win_info; + TQPtrQueue<Request> _waitingRequests; + TQMap<int, Request*> _jsrequests; +}; + + +class NSPluginClass : public TQObject, virtual public NSPluginClassIface +{ + Q_OBJECT +public: + + NSPluginClass( const TQString &library, TQObject *parent, const char *name=0 ); + ~NSPluginClass(); + + TQString getMIMEDescription(); + DCOPRef newInstance(TQString url, TQString mimeType, TQ_INT8 embed, + TQStringList argn, TQStringList argv, + TQString appId, TQString callbackId, TQ_INT8 reload, TQ_INT8 post, + TQByteArray postData, TQ_UINT32 xembed ); + void destroyInstance( NSPluginInstance* inst ); + bool error() { return _error; } + + void setApp(const TQCString& app) { _app = app; } + const TQCString& app() const { return _app; } + +protected slots: + void timer(); + +private: + int initialize(); + void shutdown(); + + KLibrary *_handle; + TQString _libname; + bool _constructed; + bool _error; + TQTimer *_timer; + + NP_GetMIMEDescriptionUPP *_NP_GetMIMEDescription; + NP_InitializeUPP *_NP_Initialize; + NP_ShutdownUPP *_NP_Shutdown; + + NPPluginFuncs _pluginFuncs; + NPNetscapeFuncs _nsFuncs; + + TQPtrList<NSPluginInstance> _instances; + TQPtrList<NSPluginInstance> _trash; + + TQCString _app; + + // If plugins use gtk, we call the gtk_init function for them --- + // but only do it once. + static bool s_initedGTK; +}; + + +class NSPluginViewer : public TQObject, virtual public NSPluginViewerIface +{ + Q_OBJECT +public: + NSPluginViewer( TQCString dcopId, TQObject *parent, const char *name=0 ); + virtual ~NSPluginViewer(); + + void shutdown(); + DCOPRef newClass( TQString plugin ); + +private slots: + void appUnregistered(const TQCString& id); + +private: + TQDict<NSPluginClass> _classes; +}; + + +#endif diff --git a/nsplugins/viewer/qxteventloop.cpp b/nsplugins/viewer/qxteventloop.cpp new file mode 100644 index 000000000..1f112ba08 --- /dev/null +++ b/nsplugins/viewer/qxteventloop.cpp @@ -0,0 +1,472 @@ +/**************************************************************************** +** Implementation of TQWidget class +** +** Created : 931031 +** +** Copyright (C) 1992-2000 Trolltech AS. All rights reserved. +** +** This file is part of the Xt extension of the Qt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.QPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition +** licenses may use this file in accordance with the Qt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about Qt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for QPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#include <config.h> + +#include "qxteventloop.h" + +#if TQT_VERSION >= 0x030100 + +#include <tqapplication.h> +#include <tqwidgetintdict.h> +#include <tdeglobal.h> + +// resolve the conflict between X11's FocusIn and TQEvent::FocusIn +const int XFocusOut = FocusOut; +const int XFocusIn = FocusIn; +#undef FocusOut +#undef FocusIn + +const int XKeyPress = KeyPress; +const int XKeyRelease = KeyRelease; +#undef KeyPress +#undef KeyRelease + +Boolean qmotif_event_dispatcher( XEvent *event ); + +class QXtEventLoopPrivate +{ +public: + QXtEventLoopPrivate(); + + void hookMeUp(); + void unhook(); + + XtAppContext appContext, ownContext; + TQMemArray<XtEventDispatchProc> dispatchers; + TQWidgetIntDict mapper; + + TQIntDict<TQSocketNotifier> socknotDict; + bool activate_timers; + XtIntervalId timerid; + + // arguments for Xt display initialization + const char* applicationClass; + XrmOptionDescRec* options; + int numOptions; +}; +static QXtEventLoopPrivate *static_d = 0; +static XEvent* last_xevent = 0; + + +/*! \internal + Redeliver the given XEvent to Xt. + + Rationale: An XEvent handled by Qt does not go through the Xt event + handlers, and the internal state of Xt/Motif widgets will not be + updated. This function should only be used if an event delivered by + Qt to a TQWidget needs to be sent to an Xt/Motif widget. +*/ +bool QXtEventLoop::redeliverEvent( XEvent *event ) +{ + // redeliver the event to Xt, NOT through Qt + if ( static_d->dispatchers[ event->type ]( event ) ) + return TRUE; + return FALSE; +} + + +/*!\internal + */ +XEvent* QXtEventLoop::lastEvent() +{ + return last_xevent; +} + + +QXtEventLoopPrivate::QXtEventLoopPrivate() + : appContext(NULL), ownContext(NULL), + activate_timers(FALSE), timerid(0) +{ +} + +void QXtEventLoopPrivate::hookMeUp() +{ + // worker to plug Qt into Xt (event dispatchers) + // and Xt into Qt (QXtEventLoopEventLoop) + + // ### TODO extensions? + dispatchers.resize( LASTEvent ); + dispatchers.fill( 0 ); + int et; + for ( et = 2; et < LASTEvent; et++ ) + dispatchers[ et ] = + XtSetEventDispatcher( TQPaintDevice::x11AppDisplay(), + et, ::qmotif_event_dispatcher ); +} + +void QXtEventLoopPrivate::unhook() +{ + // unhook Qt from Xt (event dispatchers) + // unhook Xt from Qt? (QXtEventLoopEventLoop) + + // ### TODO extensions? + int et; + for ( et = 2; et < LASTEvent; et++ ) + (void) XtSetEventDispatcher( TQPaintDevice::x11AppDisplay(), + et, dispatchers[ et ] ); + dispatchers.resize( 0 ); + + /* + We cannot destroy the app context here because it closes the X + display, something TQApplication does as well a bit later. + if ( ownContext ) + XtDestroyApplicationContext( ownContext ); + */ + appContext = ownContext = 0; +} + +extern bool tqt_try_modal( TQWidget *, XEvent * ); // defined in qapplication_x11.cpp +Boolean qmotif_event_dispatcher( XEvent *event ) +{ + TQApplication::sendPostedEvents(); + + TQWidgetIntDict *mapper = &static_d->mapper; + TQWidget* qMotif = mapper->find( event->xany.window ); + if ( !qMotif && TQWidget::find( event->xany.window) == 0 ) { + // event is not for Qt, try Xt + Display* dpy = TQPaintDevice::x11AppDisplay(); + Widget w = XtWindowToWidget( dpy, event->xany.window ); + while ( w && ! ( qMotif = mapper->find( XtWindow( w ) ) ) ) { + if ( XtIsShell( w ) ) { + break; + } + w = XtParent( w ); + } + + if ( qMotif && + ( event->type == XKeyPress || event->type == XKeyRelease ) ) { + // remap key events + event->xany.window = qMotif->winId(); + } + } + + last_xevent = event; + bool delivered = ( tqApp->x11ProcessEvent( event ) != -1 ); + last_xevent = 0; + if ( qMotif ) { + switch ( event->type ) { + case EnterNotify: + case LeaveNotify: + event->xcrossing.focus = False; + delivered = FALSE; + break; + case XKeyPress: + case XKeyRelease: + delivered = TRUE; + break; + case XFocusIn: + case XFocusOut: + delivered = FALSE; + break; + default: + delivered = FALSE; + break; + } + } + + if ( delivered ) + return True; + + + if ( TQApplication::activePopupWidget() ) + // we get all events through the popup grabs. discard the event + return True; + + if ( qMotif && TQApplication::activeModalWidget() ) { + if ( !tqt_try_modal(qMotif, event) ) + return True; + + } + + if ( static_d->dispatchers[ event->type ]( event ) ) + // Xt handled the event. + return True; + + return False; +} + + + +/*! + \class QXtEventLoop + \brief The QXtEventLoop class is the core behind the Motif Extension. + + \extension Motif + + QXtEventLoop only provides a few public functions, but is the brains + behind the integration. QXtEventLoop is responsible for initializing + the Xt toolkit and the Xt application context. It does not open a + connection to the X server, this is done by using TQApplication. + + The only member function in QXtEventLoop that depends on an X server + connection is QXtEventLoop::initialize(). QXtEventLoop must be created before + TQApplication. + + Example usage of QXtEventLoop and TQApplication: + + \code + static char *resources[] = { + ... + }; + + int main(int argc, char **argv) + { + QXtEventLoop integrator( "AppClass" ); + XtAppSetFallbackResources( integrator.applicationContext(), + resources ); + TQApplication app( argc, argv ); + + ... + + return app.exec(); + } + \endcode +*/ + +/*! + Creates QXtEventLoop, which allows Qt and Xt/Motif integration. + + If \a context is NULL, QXtEventLoop creates a default application context + itself. The context is accessible through applicationContext(). + + All arguments passed to this function (\a applicationClass, \a + options and \a numOptions) are used to call XtDisplayInitialize() + after TQApplication has been constructed. +*/ + + + +QXtEventLoop::QXtEventLoop( const char *applicationClass, XtAppContext context, XrmOptionDescRec *options , int numOptions) +{ +#if defined(QT_CHECK_STATE) + if ( static_d ) + tqWarning( "QXtEventLoop: should only have one QXtEventLoop instance!" ); +#endif + + d = static_d = new QXtEventLoopPrivate; + XtToolkitInitialize(); + if ( context ) + d->appContext = context; + else + d->ownContext = d->appContext = XtCreateApplicationContext(); + + d->applicationClass = applicationClass; + d->options = options; + d->numOptions = numOptions; +} + + +/*! + Destroys QXtEventLoop. +*/ +QXtEventLoop::~QXtEventLoop() +{ + // d->unhook(); + delete d; +} + +/*! + Returns the application context. +*/ +XtAppContext QXtEventLoop::applicationContext() const +{ + return d->appContext; +} + + +void QXtEventLoop::appStartingUp() +{ + int argc = tqApp->argc(); + XtDisplayInitialize( d->appContext, + TQPaintDevice::x11AppDisplay(), + tqApp->name(), + d->applicationClass, + d->options, + d->numOptions, + &argc, + tqApp->argv() ); + d->hookMeUp(); +} + +void QXtEventLoop::appClosingDown() +{ + d->unhook(); +} + + +/*!\internal + */ +void QXtEventLoop::registerWidget( TQWidget* w ) +{ + if ( !static_d ) + return; + static_d->mapper.insert( w->winId(), w ); +} + + +/*!\internal + */ +void QXtEventLoop::unregisterWidget( TQWidget* w ) +{ + if ( !static_d ) + return; + static_d->mapper.remove( w->winId() ); +} + + +/*! \internal + */ +void qmotif_socknot_handler( XtPointer pointer, int *, XtInputId *id ) +{ + QXtEventLoop *eventloop = (QXtEventLoop *) pointer; + TQSocketNotifier *socknot = static_d->socknotDict.find( *id ); + if ( ! socknot ) // this shouldn't happen + return; + eventloop->setSocketNotifierPending( socknot ); +} + +/*! \reimp + */ +void QXtEventLoop::registerSocketNotifier( TQSocketNotifier *notifier ) +{ + XtInputMask mask; + switch ( notifier->type() ) { + case TQSocketNotifier::Read: + mask = XtInputReadMask; + break; + + case TQSocketNotifier::Write: + mask = XtInputWriteMask; + break; + + case TQSocketNotifier::Exception: + mask = XtInputExceptMask; + break; + + default: + tqWarning( "QXtEventLoopEventLoop: socket notifier has invalid type" ); + return; + } + + XtInputId id = XtAppAddInput( d->appContext, + notifier->socket(), (XtPointer) mask, + qmotif_socknot_handler, this ); + d->socknotDict.insert( id, notifier ); + + TQEventLoop::registerSocketNotifier( notifier ); +} + +/*! \reimp + */ +void QXtEventLoop::unregisterSocketNotifier( TQSocketNotifier *notifier ) +{ + TQIntDictIterator<TQSocketNotifier> it( d->socknotDict ); + while ( it.current() && notifier != it.current() ) + ++it; + if ( ! it.current() ) { + // this shouldn't happen + tqWarning( "QXtEventLoopEventLoop: failed to unregister socket notifier" ); + return; + } + + XtRemoveInput( it.currentKey() ); + d->socknotDict.remove( it.currentKey() ); + + TQEventLoop::unregisterSocketNotifier( notifier ); +} + +/*! \internal + */ +void qmotif_timeout_handler( XtPointer, XtIntervalId * ) +{ + static_d->activate_timers = TRUE; + static_d->timerid = 0; +} + +/*! \reimp + */ +bool QXtEventLoop::processEvents( ProcessEventsFlags flags ) +{ + // Qt uses posted events to do lots of delayed operations, like repaints... these + // need to be delivered before we go to sleep + TQApplication::sendPostedEvents(); + + // make sure we fire off Qt's timers + int ttw = timeToWait(); + if ( d->timerid != 0 ) { + XtRemoveTimeOut( d->timerid ); + } + d->timerid = 0; + if ( ttw != -1 ) { + d->timerid = + XtAppAddTimeOut( d->appContext, ttw, + qmotif_timeout_handler, 0 ); + } + + // get the pending event mask from Xt and process the next event + XtInputMask pendingmask = XtAppPending( d->appContext ); + XtInputMask mask = pendingmask; + if ( pendingmask & XtIMTimer ) { + mask &= ~XtIMTimer; + // zero timers will starve the Xt X event dispatcher... so process + // something *instead* of a timer first... + if ( mask != 0 ) + XtAppProcessEvent( d->appContext, mask ); + // and process a timer afterwards + mask = pendingmask & XtIMTimer; + } + + if ( ( flags & WaitForMore ) ) + XtAppProcessEvent( d->appContext, XtIMAll ); + else + XtAppProcessEvent( d->appContext, mask ); + + int nevents = 0; + if ( ! ( flags & ExcludeSocketNotifiers ) ) + nevents += activateSocketNotifiers(); + + if ( d->activate_timers ) { + nevents += activateTimers(); + } + d->activate_timers = FALSE; + + return ( (flags & WaitForMore) || ( pendingmask != 0 ) || nevents > 0 ); +} + +#include "qxteventloop.moc" + +#endif + diff --git a/nsplugins/viewer/qxteventloop.h b/nsplugins/viewer/qxteventloop.h new file mode 100644 index 000000000..230c8a32c --- /dev/null +++ b/nsplugins/viewer/qxteventloop.h @@ -0,0 +1,81 @@ +/**************************************************************************** +** +** Implementation of TQWidget class +** +** Created : 931031 +** +** Copyright (C) 1992-2000 Trolltech AS. All rights reserved. +** +** This file is part of the xt extension of the Qt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.QPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition +** licenses may use this file in accordance with the Qt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about Qt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for QPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ +#ifndef QXTEVENTLOOP_H +#define QXTEVENTLOOP_H + +#include <tqglobal.h> + +// #if TQT_VERSION >= 0x030100 +#include <tqeventloop.h> + + + +#include <X11/Intrinsic.h> + +class QXtEventLoopPrivate; + +class QXtEventLoop : public TQEventLoop +{ + Q_OBJECT + + +public: + QXtEventLoop( const char *applicationClass, XtAppContext context = NULL, XrmOptionDescRec *options = 0, int numOptions = 0); + ~QXtEventLoop(); + + XtAppContext applicationContext() const; + + void registerSocketNotifier( TQSocketNotifier * ); + void unregisterSocketNotifier( TQSocketNotifier * ); + + static void registerWidget( TQWidget* ); + static void unregisterWidget( TQWidget* ); + static bool redeliverEvent( XEvent *event ); + static XEvent* lastEvent(); + +protected: + bool processEvents( ProcessEventsFlags flags ); + +private: + void appStartingUp(); + void appClosingDown(); + QXtEventLoopPrivate *d; + +}; + +// #endif + +#endif // QMOTIF_H diff --git a/nsplugins/viewer/resolve.h b/nsplugins/viewer/resolve.h new file mode 100644 index 000000000..d3c747ed2 --- /dev/null +++ b/nsplugins/viewer/resolve.h @@ -0,0 +1,46 @@ +/* + Copyright (c) 2000 Matthias Hoelzer-Kluepfel <hoelzer@kde.org> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ + + +#define RESOLVE_RETVAL(fname,error) \ + kdDebug() << "NSPluginInstance::" << endl; \ + \ + if (!_handle) \ + return error; \ + \ + if (!func_ ## fname) \ + func_ ## fname = _handle->symbol("NPP_"#fname); \ + \ + if (!func_ ## fname) \ + { \ + kdDebug() << "Failed: NPP_" << endl; \ + return error; \ + } \ + kdDebug() << "Resolved NPP_" << endl; + + +#define RESOLVE(fname) RESOLVE_RETVAL(fname, NPERR_GENERIC_ERROR) +#define RESOLVE_VOID(fname) RESOLVE_RETVAL(fname, ;) + + +#define CHECK(fname,error) \ + kdDebug() << "Result of " << #fname << ":" << error << endl; \ + return error; + + diff --git a/nsplugins/viewer/viewer.cpp b/nsplugins/viewer/viewer.cpp new file mode 100644 index 000000000..6007e5b0e --- /dev/null +++ b/nsplugins/viewer/viewer.cpp @@ -0,0 +1,289 @@ +/* + + This is a standalone application that executes Netscape plugins. + + + Copyright (c) 2000 Matthias Hoelzer-Kluepfel <mhk@caldera.de> + Stefan Schimanski <1Stein@gmx.de> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ + + +#include <config.h> + +#include "nsplugin.h" + +#include <dcopclient.h> +#include <tdeapplication.h> +#include <tdecmdlineargs.h> +#include <kdebug.h> +#include <tdeglobal.h> +#include <tdelocale.h> +#include <tdemessagebox.h> +#include <tqptrlist.h> +#include <tqsocketnotifier.h> +#include <stdlib.h> +#include <sys/resource.h> +#include <sys/time.h> +#include <unistd.h> + +#ifdef Bool +#undef Bool +#endif +#include <tdeconfig.h> + +#include "qxteventloop.h" +#include "glibevents.h" + +/** + * Use RLIMIT_DATA on systems that don't define RLIMIT_AS, + * such as FreeBSD 4. + */ + +#ifndef RLIMIT_AS +#define RLIMIT_AS RLIMIT_DATA +#endif + +/** + * The error handler catches all X errors, writes the error + * message to the debug log and continues. + * + * This is done to prevent abortion of the plugin viewer + * in case the plugin does some invalid X operation. + * + */ +static int x_errhandler(Display *dpy, XErrorEvent *error) +{ + char errstr[256]; + XGetErrorText(dpy, error->error_code, errstr, 256); + kdDebug(1430) << "Detected X Error: " << errstr << endl; + return 1; +} + +/* + * As the plugin viewer needs to be a motif application, I give in to + * the "old style" and keep lot's of global vars. :-) + */ + +static TQCString g_dcopId; + +/** + * parseCommandLine - get command line parameters + * + */ +void parseCommandLine(int argc, char *argv[]) +{ + for (int i=0; i<argc; i++) + { + if (!strcmp(argv[i], "-dcopid") && (i+1 < argc)) + { + g_dcopId = argv[i+1]; + i++; + } + } +} + +#if TQT_VERSION < 0x030100 + +static XtAppContext g_appcon; +static bool g_quit = false; + +void quitXt() +{ + g_quit = true; +} + + +/** + * socket notifier handling + * + */ + +struct SocketNot +{ + int fd; + TQObject *obj; + XtInputId id; +}; + +TQPtrList<SocketNot> _notifiers[3]; + +/** + * socketCallback - send event to the socket notifier + * + */ +void socketCallback(void *client_data, int* /*source*/, XtInputId* /*id*/) +{ + kdDebug(1430) << "-> socketCallback( client_data=" << client_data << " )" << endl; + + TQEvent event( TQEvent::SockAct ); + SocketNot *socknot = (SocketNot *)client_data; + kdDebug(1430) << "obj=" << (void*)socknot->obj << endl; + TQApplication::sendEvent( socknot->obj, &event ); + + kdDebug(1430) << "<- socketCallback" << endl; +} + + +/** + * qt_set_socket_handler - redefined internal qt function to register sockets + * The linker looks in the main binary first and finds this implementation before + * the original one in Qt. I hope this works with every dynamic library loader on any OS. + * + */ +extern bool qt_set_socket_handler( int, int, TQObject *, bool ); +bool qt_set_socket_handler( int sockfd, int type, TQObject *obj, bool enable ) +{ + if ( sockfd < 0 || type < 0 || type > 2 || obj == 0 ) { +#if defined(CHECK_RANGE) + tqWarning( "TQSocketNotifier: Internal error" ); +#endif + return FALSE; + } + + XtPointer inpMask = 0; + + switch (type) { + case TQSocketNotifier::Read: inpMask = (XtPointer)XtInputReadMask; break; + case TQSocketNotifier::Write: inpMask = (XtPointer)XtInputWriteMask; break; + case TQSocketNotifier::Exception: inpMask = (XtPointer)XtInputExceptMask; break; + default: return FALSE; + } + + if (enable) { + SocketNot *sn = new SocketNot; + sn->obj = obj; + sn->fd = sockfd; + + if( _notifiers[type].isEmpty() ) { + _notifiers[type].insert( 0, sn ); + } else { + SocketNot *p = _notifiers[type].first(); + while ( p && p->fd > sockfd ) + p = _notifiers[type].next(); + +#if defined(CHECK_STATE) + if ( p && p->fd==sockfd ) { + static const char *t[] = { "read", "write", "exception" }; + tqWarning( "TQSocketNotifier: Multiple socket notifiers for " + "same socket %d and type %s", sockfd, t[type] ); + } +#endif + if ( p ) + _notifiers[type].insert( _notifiers[type].at(), sn ); + else + _notifiers[type].append( sn ); + } + + sn->id = XtAppAddInput( g_appcon, sockfd, inpMask, socketCallback, sn ); + + } else { + + SocketNot *sn = _notifiers[type].first(); + while ( sn && !(sn->obj == obj && sn->fd == sockfd) ) + sn = _notifiers[type].next(); + if ( !sn ) // not found + return FALSE; + + XtRemoveInput( sn->id ); + _notifiers[type].remove(); + } + + return TRUE; +} +#endif + + +int main(int argc, char** argv) +{ + // nspluginviewer is a helper app, it shouldn't do session management at all + setenv( "SESSION_MANAGER", "", 1 ); + + // trap X errors + kdDebug(1430) << "1 - XSetErrorHandler" << endl; + XSetErrorHandler(x_errhandler); + setvbuf( stderr, NULL, _IONBF, 0 ); + + kdDebug(1430) << "2 - parseCommandLine" << endl; + parseCommandLine(argc, argv); + + kdDebug(1430) << "3 - create QXtEventLoop" << endl; + QXtEventLoop integrator( "nspluginviewer" ); + parseCommandLine(argc, argv); + TDELocale::setMainCatalogue("nsplugin"); + + kdDebug(1430) << "4 - create TDEApplication" << endl; + TDEApplication app( argc, argv, "nspluginviewer", true, true, true ); + GlibEvents glibevents; + + { + TDEConfig cfg("kcmnspluginrc", true); + cfg.setGroup("Misc"); + int v = KCLAMP(cfg.readNumEntry("Nice Level", 0), 0, 19); + if (v > 0) { + nice(v); + } + v = cfg.readNumEntry("Max Memory", 0); + if (v > 0) { + rlimit rl; + memset(&rl, 0, sizeof(rl)); + if (0 == getrlimit(RLIMIT_AS, &rl)) { + rl.rlim_cur = kMin(v, int(rl.rlim_max)); + setrlimit(RLIMIT_AS, &rl); + } + } + } + + // initialize the dcop client + kdDebug(1430) << "5 - app.dcopClient" << endl; + DCOPClient *dcop = app.dcopClient(); + if (!dcop->attach()) + { + KMessageBox::error(NULL, + i18n("There was an error connecting to the Desktop " + "communications server. Please make sure that " + "the 'dcopserver' process has been started, and " + "then try again."), + i18n("Error Connecting to DCOP Server")); + exit(1); + } + + kdDebug(1430) << "6 - dcop->registerAs" << endl; + if (g_dcopId != 0) + g_dcopId = dcop->registerAs( g_dcopId, false ); + else + g_dcopId = dcop->registerAs("nspluginviewer"); + + dcop->setNotifications(true); + + // create dcop interface + kdDebug(1430) << "7 - new NSPluginViewer" << endl; + NSPluginViewer *viewer = new NSPluginViewer( "viewer", 0 ); + + // start main loop +#if TQT_VERSION < 0x030100 + kdDebug(1430) << "8 - XtAppProcessEvent" << endl; + while (!g_quit) + XtAppProcessEvent( g_appcon, XtIMAll); +#else + kdDebug(1430) << "8 - app.exec()" << endl; + app.exec(); +#endif + + // delete viewer + delete viewer; +} diff --git a/nsplugins/wrapper/Makefile.am b/nsplugins/wrapper/Makefile.am new file mode 100644 index 000000000..b4cd8e019 --- /dev/null +++ b/nsplugins/wrapper/Makefile.am @@ -0,0 +1,4 @@ +lib_LTLIBRARIES = libnswrapper.la +libnswrapper_la_SOURCES = wrapper.c +INCLUDES = -I$(top_srcdir)/nsplugins + diff --git a/nsplugins/wrapper/wrapper.c b/nsplugins/wrapper/wrapper.c new file mode 100644 index 000000000..965868426 --- /dev/null +++ b/nsplugins/wrapper/wrapper.c @@ -0,0 +1,749 @@ +#include <stdio.h> +#include <string.h> + +#include <X11/Xlib.h> +#include <X11/Xlibint.h> + +#ifdef __hpux +#include <dl.h> +#else +#include <dlfcn.h> +#endif + +#define XP_UNIX 1 +#include "sdk/npupp.h" + + +NPNetscapeFuncs gNetscapeFuncs; /* Netscape Function table */ +NPNetscapeFuncs gExtNetscapeFuncs; /* table that is passed to the plugin*/ +NPPluginFuncs gPluginFuncs; + +typedef char* NP_GetMIMEDescription_t(void); +typedef NPError NP_Initialize_t(NPNetscapeFuncs*, NPPluginFuncs*); +typedef NPError NP_Shutdown_t(void); +typedef NPError NP_GetValue_t(void *future, NPPVariable variable, void *value); + +NP_GetMIMEDescription_t *gNP_GetMIMEDescription = NULL; +NP_Initialize_t *gNP_Initialize = NULL; +NP_Shutdown_t *gNP_Shutdown = NULL; +NP_GetValue_t *gNP_GetValue = NULL; + +#ifdef __hpux +shl_t gLib; +#else +void *gLib = 0L; +#endif +FILE *ef = 0L; + +#define DEB fprintf + +static +void UnloadPlugin() { +#ifdef __hpux + if (gLib) { + DEB( ef, "-> UnloadPlugin\n" ); + shl_unload(gLib); + DEB( ef, "<- UnloadPlugin\n" ); + + gLib=0L; + } +#else + if ( gLib ) { + DEB( ef, "-> UnloadPlugin\n" ); + dlclose( gLib ); + gLib = 0L; + + DEB( ef, "<- UnloadPlugin\n" ); + + if (ef) fclose( ef ); + } +#endif +} + +static +void LoadPlugin() { + if ( !gLib ) { + ef = fopen( "/tmp/plugin.log", "a" ); + DEB( ef, "-------------------------------\n" ); + fclose( ef ); + ef = fopen( "/tmp/plugin.log", "a" ); + setvbuf( ef, NULL, _IONBF, 0 ); + DEB( ef, "-> LoadPlugin\n" ); + +#ifdef __hpux + gLib = shl_load("/tmp/plugin.so", BIND_IMMEDIATE, 0L); + if (shl_findsym(&gLib, "/tmp/plugin.so", (short) TYPE_PROCEDURE, (void *) &gNP_GetMIMEDescription)) + gNP_GetMIMEDescription = NULL; + if (shl_findsym(&gLib, "/tmp/plugin.so", (short) TYPE_PROCEDURE, (void *) &gNP_Initialize)) + gNP_Initialize = NULL; + if (shl_findsym(&gLib, "/tmp/plugin.so", (short) TYPE_PROCEDURE, (void *) &gNP_Shutdown)) + gNP_Shutdown = NULL; + if (shl_findsym(&gLib, "/tmp/plugin.so", (short) TYPE_PROCEDURE, (void *) &gNP_GetValue)) + gNP_GetValue = NULL; +#else + gLib = dlopen( "/tmp/plugin.so", RTLD_NOW ); + DEB( ef, "gLib = %x\n", gLib ); + + gNP_GetMIMEDescription = dlsym( gLib, "NP_GetMIMEDescription" ); + gNP_Initialize = dlsym( gLib, "NP_Initialize" ); + gNP_Shutdown = dlsym( gLib, "NP_Shutdown" ); + gNP_GetValue = dlsym( gLib, "NP_GetValue" ); +#endif + DEB( ef, "gNP_GetMIMEDescription = %x\n", NP_GetMIMEDescription ); + DEB( ef, "gNP_Initialize = %x\n", gNP_Initialize ); + DEB( ef, "gNP_Shutdown = %x\n", gNP_Shutdown ); + DEB( ef, "gNP_GetValue = %x\n", gNP_GetValue ); + + if ( !gNP_GetMIMEDescription || !gNP_Initialize || !gNP_Initialize || !gNP_GetValue ) { + DEB( ef, "<- LoadPlugin - will unload before\n" ); + UnloadPlugin(); + } else + DEB( ef, "<- LoadPlugin\n" ); + } +} + +extern char *NP_GetMIMEDescription(void); +char *NP_GetMIMEDescription(void) +{ + char * ret; + + LoadPlugin(); + if ( !gLib ) return NULL; + DEB(ef, "-> NP_GetMIMEDescription()\n" ); + + ret = gNP_GetMIMEDescription(); + DEB(ef, "<- NP_GetMIMEDescription = %s\n", ret ); + return ret; +} + +/*static +NPError MyNPP_Initialize(void) +{ + NPError err; + DEB(ef, "-> NPP_Initialize( )\n"); + + err = gPluginFuncs.initialize( ); + DEB(ef, "<- NPP_Initialize = %d\n", err); + return err; +}*/ + +/*static +void MyNPP_Shutdown(void) +{ + DEB(ef, "-> NPP_Shutdown( )\n"); + gPluginFuncs.shutdown( ); + DEB(ef, "<- NPP_Shutdown\n"); +} */ + +static +NPError MyNPP_New(NPMIMEType pluginType, NPP instance, + uint16 mode, int16 argc, char* argn[], + char* argv[], NPSavedData* saved) +{ + NPError err; + int n; + DEB(ef, "-> NPP_New( %s, 0x%x, %d, %d, .., .., 0x%x )\n", pluginType, instance, mode, argc, saved); + + for ( n=0; n<argc; n++ ) { + DEB(ef, "%s=%s\n", argn[n], argv[n] ); + } + + err = gPluginFuncs.newp( pluginType, instance, mode, argc, argn, argv, saved ); + DEB(ef, "<- NPP_New = %d\n", err); + return err; +} + +static +NPError MyNPP_Destroy(NPP instance, NPSavedData** save) +{ + NPError err; + DEB(ef, "-> NPP_Destrpy( %x, 0x%x )\n", instance, save); + + err = gPluginFuncs.destroy( instance, save ); + DEB(ef, "<- NPP_Destroy = %d\n", err); + return err; +} + +static +NPError MyNPP_SetWindow(NPP instance, NPWindow* window) +{ + NPError err; + NPSetWindowCallbackStruct *win_info; + DEB(ef, "-> NPP_SetWindow( %x, 0x%x )\n", instance, window); + + DEB(ef, "window->window = 0x%x\n", window->window); + DEB(ef, "window->x = %d\n", window->x); + DEB(ef, "window->y = %d\n", window->y); + DEB(ef, "window->width = %d\n", window->width); + DEB(ef, "window->height = %d\n", window->height); + DEB(ef, "window->ws_info = 0x%x\n", window->ws_info); + DEB(ef, "window->type = 0x%x\n", window->type); + + win_info = (NPSetWindowCallbackStruct*)window->ws_info; + DEB(ef, "win_info->type = %d\n", win_info->type); + DEB(ef, "win_info->display = 0x%x\n", win_info->display); + DEB(ef, "win_info->visual = 0x%x\n", win_info->visual); + DEB(ef, "win_info->colormap = 0x%x\n", win_info->colormap); + DEB(ef, "win_info->depth = %d\n", win_info->depth); + + err = gPluginFuncs.setwindow( instance, window ); + DEB(ef, "<- NPP_SetWindow = %d\n", err); + return err; +} + +static +NPError MyNPP_NewStream(NPP instance, NPMIMEType type, + NPStream* stream, NPBool seekable, + uint16* stype) +{ + NPError err; + DEB(ef, "-> NPP_NewStream( %x, %s, 0x%x, %d, 0x%x )\n", instance, type, stream, seekable, stype); + + DEB(ef, "stream->ndata = 0x%x\n", stream->ndata); + DEB(ef, "stream->url = %s\n", stream->url ); + DEB(ef, "stream->end = %d\n", stream->end ); + DEB(ef, "stream->pdata = 0x%x\n", stream->pdata ); + DEB(ef, "stream->lastmodified = %d\n", stream->lastmodified ); + DEB(ef, "stream->notifyData = 0x%x\n", stream->notifyData ); + + err = gPluginFuncs.newstream( instance, type, stream, seekable, stype ); + DEB(ef, "<- NPP_NewStream = %d\n", err); + DEB(ef, "stype = %d\n", *stype); + return err; +} + +static +NPError MyNPP_DestroyStream(NPP instance, NPStream* stream, + NPReason reason) +{ + NPError err; + DEB(ef, "-> NPP_DestroyStream( %x, 0x%x, %d )\n", instance, stream, reason); + + err = gPluginFuncs.destroystream( instance, stream, reason ); + DEB(ef, "<- NPP_DestroyStream = %d\n", err); + return err; +} + +static +int32 MyNPP_WriteReady(NPP instance, NPStream* stream) +{ + int32 ret; + DEB(ef, "-> NPP_WriteReady( %x, 0x%x )\n", instance, stream); + + ret = gPluginFuncs.writeready( instance, stream ); + DEB(ef, "<- NPP_WriteReady = %d\n", ret); + return ret; +} + +static +int32 MyNPP_Write(NPP instance, NPStream* stream, int32 offset, + int32 len, void* buffer) +{ + int32 ret; + DEB(ef, "-> NPP_Write( %x, 0x%x, %d, %d, 0x%x )\n", instance, stream, offset, len, buffer); + + ret = gPluginFuncs.write( instance, stream, offset, len, buffer ); + DEB(ef, "<- NPP_Write = %d\n", ret); + return ret; +} + +static +void MyNPP_StreamAsFile(NPP instance, NPStream* stream, + const char* fname) +{ + DEB(ef, "-> NPP_StreamAsFile( %x, 0x%x, %s )\n", instance, stream, fname); + + gPluginFuncs.asfile( instance, stream, fname ); + DEB(ef, "<- NPP_StreamAsFile\n"); +} + +static +void MyNPP_Print(NPP instance, NPPrint* platformPrint) +{ + DEB(ef, "-> NPP_Print( %x, 0x%x )\n", instance, platformPrint ); + gPluginFuncs.print( instance, platformPrint ); + DEB(ef, "<- NPP_Print\n"); +} + +static +int16 MyNPP_HandleEvent(NPP instance, void* event) +{ + int16 ret; + DEB(ef, "-> NPP_HandleEvent( %x, 0x%x )\n", instance, event); + + ret = gPluginFuncs.event( instance, event ); + DEB(ef, "<- NPP_HandleEvent = %d\n", ret); + return ret; +} + +static +void MyNPP_URLNotify(NPP instance, const char* url, + NPReason reason, void* notifyData) +{ + DEB(ef, "-> NPP_URLNotify( %x, %s, %d, 0x%x )\n", instance, url, reason, notifyData ); + gPluginFuncs.urlnotify( instance, url, reason, notifyData ); + DEB(ef, "<- NPP_URLNotify\n"); +} + +#if 0 +static +jref MyNPP_GetJavaClass(void) +{ + jref ret; + DEB(ef, "-> NPP_GetJavaClass( )\n" ); + +/* ret = gPluginFuncs.javaClass( );*/ + DEB(ef, "<- NPP_GetJavaClass = %d\n", ret); + return ret; +} +#endif + +static +NPError MyNPP_GetValue(void *instance, NPPVariable variable, void *value) +{ + NPError err; + DEB(ef, "-> NPP_GetValue( %x, %d, 0x%x )\n", instance, variable, value); + + err = gPluginFuncs.getvalue( instance, variable, value ); + DEB(ef, "<- NPP_GetValue = %d\n", err); + return err; +} + +static +NPError MyNPP_SetValue(void *instance, NPNVariable variable, void *value) +{ + NPError err; + DEB(ef, "-> NPP_SetValue( %x, %d, 0x%x )\n", instance, variable, value); + + err = gPluginFuncs.getvalue( instance, variable, value ); + DEB(ef, "<- NPP_SetValue = %d\n", err); + return err; +} + +/*static +void MyNPN_Version(int* plugin_major, int* plugin_minor, + int* netscape_major, int* netscape_minor) +{ + DEB(ef, "-> NPN_Version( %d, %d, %d, %d )\n", *plugin_major, *plugin_minor, *netscape_major, *netscape_minor); + + gNetscapeFuncs.version( plugin_major, plugin_minor, netscape_major, netscape_minor ); + DEB(ef, "<- NPN_Version\n"); + DEB(ef, "plugin_major = %d\n", *plugin_major); + DEB(ef, "plugin_minor = %d\n", *plugin_minor); + DEB(ef, "netscape_major = %d\n", *plugin_major); + DEB(ef, "netscape_minor = %d\n", *plugin_minor); +}*/ + +static +NPError MyNPN_GetURLNotify(NPP instance, const char* url, + const char* target, void* notifyData) +{ + NPError err; + DEB(ef, "-> NPN_GetURLNotify( %x, %s, %s, 0x%x )\n", instance, url, target, notifyData); + + err = gNetscapeFuncs.geturlnotify( instance, url, target, notifyData ); + DEB(ef, "<- NPN_GetURLNotify = %d\n", err); + return err; +} + +static +NPError MyNPN_GetURL(NPP instance, const char* url, + const char* target) +{ + NPError err; + DEB(ef, "-> NPN_GetURL( %x, %s, %s )\n", instance, url, target ); + + err = gNetscapeFuncs.geturl( instance, url, target ); + DEB(ef, "<- NPN_GetURL = %d\n", err); + return err; +} + +static +NPError MyNPN_PostURLNotify(NPP instance, const char* url, + const char* target, uint32 len, + const char* buf, NPBool file, + void* notifyData) +{ + NPError err; + DEB(ef, "-> NPN_PostURLNotify( %x, %s, %s, %d, 0x%x, %d, 0x%x )\n", instance, url, target, len, buf, file, notifyData); + + err = gNetscapeFuncs.posturlnotify( instance, url, target, len, buf, file, notifyData ); + DEB(ef, "<- NPN_PostURLNotify = %d\n", err); + return err; +} + +static +NPError MyNPN_PostURL(NPP instance, const char* url, + const char* target, uint32 len, + const char* buf, NPBool file) +{ + NPError err; + DEB(ef, "-> NPN_PostURL( %x, %s, %s, %d, 0x%x, %d )\n", instance, url, target, len, buf, file ); + + err = gNetscapeFuncs.posturl( instance, url, target, len, buf, file ); + DEB(ef, "<- NPN_PostURL = %d\n", err); + return err; +} + +static +NPError MyNPN_RequestRead(NPStream* stream, NPByteRange* rangeList) +{ + NPError err; + DEB(ef, "-> NPN_RequestRead( %x, 0x%x )\n", stream, rangeList ); + DEB(ef, "rangeList->offset = %d\n", rangeList->offset); + DEB(ef, "rangeList->length = %d\n", rangeList->length); + DEB(ef, "rangeList->next = 0x%x\n", rangeList->next); + + err = gNetscapeFuncs.requestread( stream, rangeList ); + DEB(ef, "<- NPN_RequestRead = %d\n", err); + DEB(ef, "rangeList->offset = %d\n", rangeList->offset); + DEB(ef, "rangeList->length = %d\n", rangeList->length); + DEB(ef, "rangeList->next = 0x%x\n", rangeList->next); + return err; +} + +static +NPError MyNPN_NewStream(NPP instance, NPMIMEType type, + const char* target, NPStream** stream) +{ + NPError err; + DEB(ef, "-> NPN_NewStream( %x, %s, %s, 0x%x )\n", instance, type, target, stream); + + err = gNetscapeFuncs.newstream( instance, type, target, stream ); + DEB(ef, "<- NPN_NewStream = %d\n", err); + return err; +} + +static +int32 MyNPN_Write(NPP instance, NPStream* stream, int32 len, + void* buffer) +{ + int32 ret; + DEB(ef, "-> NPN_Write( %x, 0x%x, %d, 0x%x )\n", instance, stream, len, buffer); + + ret = gNetscapeFuncs.write( instance, stream, len, buffer ); + DEB(ef, "<- NPN_Write = %d\n", ret); + return ret; +} + +static +NPError MyNPN_DestroyStream(NPP instance, NPStream* stream, + NPReason reason) +{ + NPError err; + DEB(ef, "-> NPN_DestroyStream( %x, 0x%x, %d )\n", instance, stream, reason); + + err = gNetscapeFuncs.destroystream( instance, stream, reason ); + DEB(ef, "<- NPN_DestroyStream = %d\n", err); + return err; +} + +static +void MyNPN_Status(NPP instance, const char* message) +{ + DEB(ef, "-> NPN_Status( %x, %s )\n", instance, message); + gNetscapeFuncs.status( instance, message ); + DEB(ef, "<- NPN_Status\n"); +} + +static +const char* MyNPN_UserAgent(NPP instance) +{ + const char *ret; + DEB(ef, "-> NPN_UserAgent( %x )\n", instance); + + ret = gNetscapeFuncs.uagent( instance ); + DEB(ef, "<- NPN_UserAgent = %s\n", ret); + return ret; +} + +static +void* MyNPN_MemAlloc(uint32 size) +{ + void *ret; + DEB(ef, "-> NPN_MemAlloc( %d )\n", size); + + ret = gNetscapeFuncs.memalloc( size ); + DEB(ef, "<- NPN_MemAlloc = 0x%x\n", ret); + return ret; +} + +static +void MyNPN_MemFree(void* ptr) +{ + DEB(ef, "-> NPN_MemFree( 0x%x )\n", ptr); + gNetscapeFuncs.memfree( ptr ); + DEB(ef, "<- NPN_MemFree\n"); +} + +static +uint32 MyNPN_MemFlush(uint32 size) +{ + uint ret; + DEB(ef, "-> NPN_MemFlush( %d )\n", size); + + ret = gNetscapeFuncs.memflush( size ); + DEB(ef, "<- NPN_MemFlush = %d\n", ret); + return ret; +} + +static +void MyNPN_ReloadPlugins(NPBool reloadPages) +{ + DEB(ef, "-> NPN_ReloadPlugins( %d )\n", reloadPages); + gNetscapeFuncs.reloadplugins( reloadPages ); + DEB(ef, "<- NPN_ReloadPlugins\n"); +} + +static +JRIEnv* MyNPN_GetJavaEnv(void) +{ + JRIEnv *ret; + DEB(ef, "-> NPN_GetJavaEnv( )\n"); + + ret = gNetscapeFuncs.getJavaEnv( ); + DEB(ef, "<- NPN_GetJavaEnv = 0x%x\n", ret); + return ret; +} + +static +jref MyNPN_GetJavaPeer(NPP instance) +{ + jref ret; + DEB(ef, "-> NPN_GetJavaPeer( %x )\n", instance); + + ret = gNetscapeFuncs.getJavaPeer( instance ); + DEB(ef, "<- NPN_GetJavaPeer = 0x%x\n", ret); + return ret; +} + +static +NPError MyNPN_GetValue(NPP instance, NPNVariable variable, + void *value) +{ + NPError ret; + DEB(ef, "-> NPN_GetValue( %x, %d, 0x%x)\n", instance, variable, value); + ret = gNetscapeFuncs.getvalue( instance, variable, value ); + DEB(ef, "<- NPN_GetValue = %d\n", ret); + return ret; +} + +static +NPError MyNPN_SetValue(NPP instance, NPPVariable variable, + void *value) +{ + NPError ret; + DEB(ef, "-> NPN_SetValue( %x, %d, 0x%x)\n", instance, variable, value); + + ret = gNetscapeFuncs.setvalue( instance, variable, value ); + DEB(ef, "<- NPN_SetValue = %d\n", ret); + return ret; +} + +static +void MyNPN_InvalidateRect(NPP instance, NPRect *invalidRect) +{ + DEB(ef, "-> NPN_InvalidateRect( %x, 0x%x )\n", instance, invalidRect); + gNetscapeFuncs.invalidaterect( instance, invalidRect ); + DEB(ef, "<- NPN_InvalidateRect\n"); +} + +static +void MyNPN_InvalidateRegion(NPP instance, NPRegion invalidRegion) +{ + DEB(ef, "-> NPN_InvalidateRegion( %x, 0x%x )\n", instance, invalidRegion); + gNetscapeFuncs.invalidateregion( instance, invalidRegion ); + DEB(ef, "<- NPN_InvalidateRegion\n"); +} + +static +void MyNPN_ForceRedraw(NPP instance) +{ + DEB(ef, "-> NPN_ForceRedraw( %x )\n", instance); + gNetscapeFuncs.forceredraw( instance ); + DEB(ef, "<- NPN_ForceRedraw\n"); +} + +extern NPError NP_GetValue(void *future, NPPVariable variable, void *value); +NPError NP_GetValue(void *future, NPPVariable variable, void *value) +{ + NPError err; + LoadPlugin(); + if ( !gLib ) return NPERR_GENERIC_ERROR; + DEB(ef, "-> NP_GetValue( %x, %d, %x )\n", future, variable, value ); + + err = gNP_GetValue( future, variable, value ); + DEB(ef, "<- NP_GetValue = %d\n", err ); + return err; +} + +extern NPError NP_Initialize(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs); +NPError NP_Initialize(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs) +{ + NPError err; + LoadPlugin(); + if ( !gLib ) return NPERR_GENERIC_ERROR; + DEB(ef, "-> NP_Initialize( %x, %x )\n", nsTable, pluginFuncs ); + + DEB(ef, "nsTable->size = %d\n", nsTable->size); + DEB(ef, "nsTable->version = 0x%x\n", nsTable->version); + DEB(ef, "nsTable->geturl = 0x%x\n", nsTable->geturl); + DEB(ef, "nsTable->posturl = 0x%x\n", nsTable->posturl); + DEB(ef, "nsTable->requestread = 0x%x\n", nsTable->requestread); + DEB(ef, "nsTable->newstream = 0x%x\n", nsTable->newstream); + DEB(ef, "nsTable->write = 0x%x\n", nsTable->write); + DEB(ef, "nsTable->destroystream = 0x%x\n", nsTable->destroystream); + DEB(ef, "nsTable->status = 0x%x\n", nsTable->status); + DEB(ef, "nsTable->uagent = 0x%x\n", nsTable->uagent); + DEB(ef, "nsTable->memalloc = 0x%x\n", nsTable->memalloc); + DEB(ef, "nsTable->memfree = 0x%x\n", nsTable->memfree); + DEB(ef, "nsTable->memflush = 0x%x\n", nsTable->memflush); + DEB(ef, "nsTable->reloadplugins = 0x%x\n", nsTable->reloadplugins); + DEB(ef, "nsTable->getJavaEnv = 0x%x\n", nsTable->getJavaEnv); + DEB(ef, "nsTable->getJavaPeer = 0x%x\n", nsTable->getJavaPeer); + DEB(ef, "nsTable->geturlnotify = 0x%x\n", nsTable->geturlnotify); + DEB(ef, "nsTable->posturlnotify = 0x%x\n", nsTable->posturlnotify); + DEB(ef, "nsTable->getvalue = 0x%x\n", nsTable->getvalue); + DEB(ef, "nsTable->setvalue = 0x%x\n", nsTable->setvalue); + DEB(ef, "nsTable->invalidaterect = 0x%x\n", nsTable->invalidaterect); + DEB(ef, "nsTable->invalidateregion = 0x%x\n", nsTable->invalidateregion); + DEB(ef, "nsTable->forceredraw = 0x%x\n", nsTable->forceredraw); + + DEB(ef, "pluginFuncs->size = %d\n", pluginFuncs->size); + DEB(ef, "pluginFuncs->version = 0x%x\n", pluginFuncs->version); + DEB(ef, "pluginFuncs->newp = 0x%x\n", pluginFuncs->newp); + DEB(ef, "pluginFuncs->destroy = 0x%x\n", pluginFuncs->destroy); + DEB(ef, "pluginFuncs->setwindow = 0x%x\n", pluginFuncs->setwindow); + DEB(ef, "pluginFuncs->newstream = 0x%x\n", pluginFuncs->newstream); + DEB(ef, "pluginFuncs->destroystream = 0x%x\n", pluginFuncs->destroystream); + DEB(ef, "pluginFuncs->asfile = 0x%x\n", pluginFuncs->asfile); + DEB(ef, "pluginFuncs->writeready = 0x%x\n", pluginFuncs->writeready); + DEB(ef, "pluginFuncs->write = 0x%x\n", pluginFuncs->write); + DEB(ef, "pluginFuncs->print = 0x%x\n", pluginFuncs->print); + DEB(ef, "pluginFuncs->event = 0x%x\n", pluginFuncs->event); + DEB(ef, "pluginFuncs->urlnotify = 0x%x\n", pluginFuncs->urlnotify); + DEB(ef, "pluginFuncs->javaClass = 0x%x\n", pluginFuncs->javaClass); + DEB(ef, "pluginFuncs->getvalue = 0x%x\n", pluginFuncs->getvalue); + DEB(ef, "pluginFuncs->setvalue = 0x%x\n", pluginFuncs->setvalue); + + if ( pluginFuncs->size>sizeof(gPluginFuncs) ) + { + DEB(ef, "Plugin function table too big\n"); + return NPERR_GENERIC_ERROR; + } + + if ( nsTable->size>sizeof(gNetscapeFuncs) ) + { + DEB(ef, "Netscape function table too big\n"); + return NPERR_GENERIC_ERROR; + } + + memcpy(&gNetscapeFuncs, nsTable, sizeof(gNetscapeFuncs)); + memcpy(&gExtNetscapeFuncs, nsTable, sizeof(gExtNetscapeFuncs)); + + gExtNetscapeFuncs.geturl = MyNPN_GetURL; + gExtNetscapeFuncs.posturl = MyNPN_PostURL; + gExtNetscapeFuncs.requestread = MyNPN_RequestRead; + gExtNetscapeFuncs.newstream = MyNPN_NewStream; + gExtNetscapeFuncs.write = MyNPN_Write; + gExtNetscapeFuncs.destroystream = MyNPN_DestroyStream; + gExtNetscapeFuncs.status = MyNPN_Status; + gExtNetscapeFuncs.uagent = MyNPN_UserAgent; + /*gExtNetscapeFuncs.memalloc = MyNPN_MemAlloc; + gExtNetscapeFuncs.memfree = MyNPN_MemFree; + gExtNetscapeFuncs.memflush = MyNPN_MemFlush;*/ + gExtNetscapeFuncs.reloadplugins = MyNPN_ReloadPlugins; + gExtNetscapeFuncs.getJavaEnv = MyNPN_GetJavaEnv; + gExtNetscapeFuncs.getJavaPeer = MyNPN_GetJavaPeer; + gExtNetscapeFuncs.geturlnotify = MyNPN_GetURLNotify; + gExtNetscapeFuncs.posturlnotify = MyNPN_PostURLNotify; + gExtNetscapeFuncs.getvalue = MyNPN_GetValue; + gExtNetscapeFuncs.setvalue = MyNPN_SetValue; + gExtNetscapeFuncs.invalidaterect = MyNPN_InvalidateRect; + gExtNetscapeFuncs.invalidateregion = MyNPN_InvalidateRegion; + gExtNetscapeFuncs.forceredraw = MyNPN_ForceRedraw; + + gPluginFuncs.size = sizeof( gPluginFuncs ); + + DEB(ef, "call\n"); + + err = gNP_Initialize( &gExtNetscapeFuncs, &gPluginFuncs ); + + if (!err) { + /*memcpy(&pluginFuncs, gPluginFuncs, sizeof(gPluginFuncs));*/ + + /*pluginFuncs->initialize = MyNPP_Initialize; + pluginFuncs->shutdown = MyNPP_Shutdown;*/ + pluginFuncs->newp = MyNPP_New; + pluginFuncs->destroy = MyNPP_Destroy; + pluginFuncs->setwindow = MyNPP_SetWindow; + pluginFuncs->newstream = MyNPP_NewStream; + pluginFuncs->destroystream = MyNPP_DestroyStream; + pluginFuncs->asfile = MyNPP_StreamAsFile; + pluginFuncs->writeready = MyNPP_WriteReady; + pluginFuncs->write = MyNPP_Write; + pluginFuncs->print = MyNPP_Print; + pluginFuncs->event = MyNPP_HandleEvent; + pluginFuncs->urlnotify = MyNPP_URLNotify; + pluginFuncs->javaClass = 0; /* MyNPP_GetJavaClass; */ + pluginFuncs->getvalue = (NPP_GetValueUPP)MyNPP_GetValue; + pluginFuncs->setvalue = (NPP_SetValueUPP)MyNPP_SetValue; + + DEB(ef, "nsTable->size = %d\n", gExtNetscapeFuncs.size); + DEB(ef, "nsTable->version = 0x%x\n", gExtNetscapeFuncs.version); + DEB(ef, "nsTable->geturl = 0x%x\n", gExtNetscapeFuncs.geturl); + DEB(ef, "nsTable->posturl = 0x%x\n", gExtNetscapeFuncs.posturl); + DEB(ef, "nsTable->requestread = 0x%x\n", gExtNetscapeFuncs.requestread); + DEB(ef, "nsTable->newstream = 0x%x\n", gExtNetscapeFuncs.newstream); + DEB(ef, "nsTable->write = 0x%x\n", gExtNetscapeFuncs.write); + DEB(ef, "nsTable->destroystream = 0x%x\n", gExtNetscapeFuncs.destroystream); + DEB(ef, "nsTable->status = 0x%x\n", gExtNetscapeFuncs.status); + DEB(ef, "nsTable->uagent = 0x%x\n", gExtNetscapeFuncs.uagent); + DEB(ef, "nsTable->memalloc = 0x%x\n", gExtNetscapeFuncs.memalloc); + DEB(ef, "nsTable->memfree = 0x%x\n", gExtNetscapeFuncs.memfree); + DEB(ef, "nsTable->memflush = 0x%x\n", gExtNetscapeFuncs.memflush); + DEB(ef, "nsTable->reloadplugins = 0x%x\n", gExtNetscapeFuncs.reloadplugins); + DEB(ef, "nsTable->getJavaEnv = 0x%x\n", gExtNetscapeFuncs.getJavaEnv); + DEB(ef, "nsTable->getJavaPeer = 0x%x\n", gExtNetscapeFuncs.getJavaPeer); + DEB(ef, "nsTable->geturlnotify = 0x%x\n", gExtNetscapeFuncs.geturlnotify); + DEB(ef, "nsTable->posturlnotify = 0x%x\n", gExtNetscapeFuncs.posturlnotify); + DEB(ef, "nsTable->getvalue = 0x%x\n", gExtNetscapeFuncs.getvalue); + DEB(ef, "nsTable->setvalue = 0x%x\n", gExtNetscapeFuncs.setvalue); + DEB(ef, "nsTable->invalidaterect = 0x%x\n", gExtNetscapeFuncs.invalidaterect); + DEB(ef, "nsTable->invalidateregion = 0x%x\n", gExtNetscapeFuncs.invalidateregion); + DEB(ef, "nsTable->forceredraw = 0x%x\n", gExtNetscapeFuncs.forceredraw); + + DEB(ef, "pluginFuncs->size = %d\n", pluginFuncs->size); + DEB(ef, "pluginFuncs->version = 0x%x\n", pluginFuncs->version); + DEB(ef, "pluginFuncs->newp = 0x%x\n", pluginFuncs->newp); + DEB(ef, "pluginFuncs->destroy = 0x%x\n", pluginFuncs->destroy); + DEB(ef, "pluginFuncs->setwindow = 0x%x\n", pluginFuncs->setwindow); + DEB(ef, "pluginFuncs->newstream = 0x%x\n", pluginFuncs->newstream); + DEB(ef, "pluginFuncs->destroystream = 0x%x\n", pluginFuncs->destroystream); + DEB(ef, "pluginFuncs->asfile = 0x%x\n", pluginFuncs->asfile); + DEB(ef, "pluginFuncs->writeready = 0x%x\n", pluginFuncs->writeready); + DEB(ef, "pluginFuncs->write = 0x%x\n", pluginFuncs->write); + DEB(ef, "pluginFuncs->print = 0x%x\n", pluginFuncs->print); + DEB(ef, "pluginFuncs->event = 0x%x\n", pluginFuncs->event); + DEB(ef, "pluginFuncs->urlnotify = 0x%x\n", pluginFuncs->urlnotify); + DEB(ef, "pluginFuncs->javaClass = 0x%x\n", pluginFuncs->javaClass); + DEB(ef, "pluginFuncs->getvalue = 0x%x\n", pluginFuncs->getvalue); + DEB(ef, "pluginFuncs->setvalue = 0x%x\n", pluginFuncs->setvalue); + } + + DEB(ef, "<- NP_Initialize = %d\n", err ); + return err; +} + +extern NPError NP_Shutdown(void); +NPError NP_Shutdown(void) +{ + NPError err; + LoadPlugin(); + if ( !gLib ) return NPERR_GENERIC_ERROR; + DEB(ef, "-> NP_Shutdown()\n" ); + + err = gNP_Shutdown( ); + DEB(ef, "<- NP_Shutdown = %d\n", err ); + return err; +} |