diff options
Diffstat (limited to 'extra/vlc-plugin/vlc-1.0.4-new-xulrunner.patch')
| -rw-r--r-- | extra/vlc-plugin/vlc-1.0.4-new-xulrunner.patch | 1079 |
1 files changed, 1079 insertions, 0 deletions
diff --git a/extra/vlc-plugin/vlc-1.0.4-new-xulrunner.patch b/extra/vlc-plugin/vlc-1.0.4-new-xulrunner.patch new file mode 100644 index 000000000..a91835fb5 --- /dev/null +++ b/extra/vlc-plugin/vlc-1.0.4-new-xulrunner.patch @@ -0,0 +1,1079 @@ +diff -p -up vlc-1.0.4/projects/mozilla/control/npolibvlc.cpp~ vlc-1.0.4/projects/mozilla/control/npolibvlc.cpp +--- vlc-1.0.4/projects/mozilla/control/npolibvlc.cpp~ 2009-12-07 22:12:58.000000000 +0100 ++++ vlc-1.0.4/projects/mozilla/control/npolibvlc.cpp 2010-01-06 15:50:32.000000000 +0100 +@@ -949,7 +949,7 @@ LibvlcPlaylistNPObject::invoke(int index + void LibvlcPlaylistNPObject::parseOptions(const NPString &nps, + int *i_options, char*** ppsz_options) + { +- if( nps.utf8length ) ++ if( nps.UTF8Length ) + { + char *s = stringValue(nps); + char *val = s; +@@ -961,7 +961,7 @@ void LibvlcPlaylistNPObject::parseOption + { + int nOptions = 0; + +- char *end = val + nps.utf8length; ++ char *end = val + nps.UTF8Length; + while( val < end ) + { + // skip leading blanks +diff -p -up vlc-1.0.4/projects/mozilla/control/nporuntime.cpp~ vlc-1.0.4/projects/mozilla/control/nporuntime.cpp +--- vlc-1.0.4/projects/mozilla/control/nporuntime.cpp~ 2009-12-07 22:12:58.000000000 +0100 ++++ vlc-1.0.4/projects/mozilla/control/nporuntime.cpp 2010-01-06 15:51:12.000000000 +0100 +@@ -37,11 +37,11 @@ + + char* RuntimeNPObject::stringValue(const NPString &s) + { +- NPUTF8 *val = static_cast<NPUTF8*>(malloc((s.utf8length+1) * sizeof(*val))); ++ NPUTF8 *val = static_cast<NPUTF8*>(malloc((s.UTF8Length+1) * sizeof(*val))); + if( val ) + { +- strncpy(val, s.utf8characters, s.utf8length); +- val[s.utf8length] = '\0'; ++ strncpy(val, s.UTF8Characters, s.UTF8Length); ++ val[s.UTF8Length] = '\0'; + } + return val; + } +diff -p -up vlc-1.0.4/projects/mozilla/support/npunix.c~ vlc-1.0.4/projects/mozilla/support/npunix.c +--- vlc-1.0.4/projects/mozilla/support/npunix.c~ 2009-12-05 10:03:25.000000000 +0100 ++++ vlc-1.0.4/projects/mozilla/support/npunix.c 2010-01-06 15:43:03.000000000 +0100 +@@ -1,21 +1,17 @@ + /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * +- * Mozilla/Firefox plugin for VLC +- * Copyright (C) 2009, Jean-Paul Saman <jpsaman@videolan.org> ++ * ***** BEGIN LICENSE BLOCK ***** ++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * +- * This library is free software; you can redistribute it and/or +- * modify it under the terms of the GNU Lesser General Public +- * License as published by the Free Software Foundation; either +- * version 2.1 of the License, or (at your option) any later version. +- * +- * This library is distributed in the hope that it will be useful, +- * but WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * Lesser General Public License for more details. +- * +- * You should have received a copy of the GNU Lesser General Public +- * License along with this library; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ * 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. + * +@@ -27,7 +23,19 @@ + * Contributor(s): + * Stephen Mak <smak@sun.com> + * +- */ ++ * Alternatively, the contents of this file may be used under the terms of ++ * either of the GNU General Public License Version 2 or later (the "GPL"), ++ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), ++ * in which case the provisions of the GPL or the LGPL are applicable instead ++ * of those above. If you wish to allow use of your version of this file only ++ * under the terms of either the GPL or the LGPL, and not to allow others to ++ * use your version of this file under the terms of the MPL, indicate your ++ * decision by deleting the provisions above and replace them with the notice ++ * and other provisions required by the GPL or the LGPL. If you do not delete ++ * the provisions above, a recipient may use your version of this file under ++ * the terms of any one of the MPL, the GPL or the LGPL. ++ * ++ * ***** END LICENSE BLOCK ***** */ + + /* + * npunix.c +@@ -43,19 +51,11 @@ + *---------------------------------------------------------------------- + */ + +-#include "config.h" +- + #define XP_UNIX 1 +-#define OJI 1 +- +-#include <npapi.h> +-#ifdef HAVE_NPFUNCTIONS_H +-#include <npfunctions.h> +-#else +-#include <npupp.h> +-#endif + +-#include "../vlcshell.h" ++#include <stdio.h> ++#include "npapi.h" ++#include "npfunctions.h" + + /* + * Define PLUGIN_TRACE to have the wrapper functions print +@@ -69,6 +69,7 @@ + #define PLUGINDEBUGSTR(msg) + #endif + ++ + /*********************************************************************** + * + * Globals +@@ -77,6 +78,7 @@ + + static NPNetscapeFuncs gNetscapeFuncs; /* Netscape Function table */ + ++ + /*********************************************************************** + * + * Wrapper functions : plugin calling Netscape Navigator +@@ -103,502 +105,229 @@ NPN_Version(int* plugin_major, int* plug + NPError + NPN_GetValue(NPP instance, NPNVariable variable, void *r_value) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_GetValueProc(gNetscapeFuncs.getvalue, +- instance, variable, r_value); +-#else + return (*gNetscapeFuncs.getvalue)(instance, variable, r_value); +-#endif + } + + NPError + NPN_SetValue(NPP instance, NPPVariable variable, void *value) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_SetValueProc(gNetscapeFuncs.setvalue, +- instance, variable, value); +-#else + return (*gNetscapeFuncs.setvalue)(instance, variable, value); +-#endif + } + + NPError + NPN_GetURL(NPP instance, const char* url, const char* window) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_GetURLProc(gNetscapeFuncs.geturl, instance, url, window); +-#else + return (*gNetscapeFuncs.geturl)(instance, url, window); +-#endif + } + + NPError + NPN_GetURLNotify(NPP instance, const char* url, const char* window, void* notifyData) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_GetURLNotifyProc(gNetscapeFuncs.geturlnotify, instance, url, window, notifyData); +-#else + return (*gNetscapeFuncs.geturlnotify)(instance, url, window, notifyData); +-#endif + } + + NPError + NPN_PostURL(NPP instance, const char* url, const char* window, + uint32_t len, const char* buf, NPBool file) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_PostURLProc(gNetscapeFuncs.posturl, instance, +- url, window, len, buf, file); +-#else + return (*gNetscapeFuncs.posturl)(instance, url, window, len, buf, file); +-#endif + } + + NPError + NPN_PostURLNotify(NPP instance, const char* url, const char* window, uint32_t len, + const char* buf, NPBool file, void* notifyData) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_PostURLNotifyProc(gNetscapeFuncs.posturlnotify, +- instance, url, window, len, buf, file, notifyData); +-#else + return (*gNetscapeFuncs.posturlnotify)(instance, url, window, len, buf, file, notifyData); +- +-#endif + } + + NPError + NPN_RequestRead(NPStream* stream, NPByteRange* rangeList) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_RequestReadProc(gNetscapeFuncs.requestread, +- stream, rangeList); +-#else + return (*gNetscapeFuncs.requestread)(stream, rangeList); +-#endif + } + + NPError + NPN_NewStream(NPP instance, NPMIMEType type, const char *window, + NPStream** stream_ptr) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_NewStreamProc(gNetscapeFuncs.newstream, instance, +- type, window, stream_ptr); +-#else + return (*gNetscapeFuncs.newstream)(instance, type, window, stream_ptr); +-#endif + } + + int32_t + NPN_Write(NPP instance, NPStream* stream, int32_t len, void* buffer) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_WriteProc(gNetscapeFuncs.write, instance, +- stream, len, buffer); +-#else + return (*gNetscapeFuncs.write)(instance, stream, len, buffer); +-#endif + } + + NPError + NPN_DestroyStream(NPP instance, NPStream* stream, NPError reason) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_DestroyStreamProc(gNetscapeFuncs.destroystream, +- instance, stream, reason); +-#else + return (*gNetscapeFuncs.destroystream)(instance, stream, reason); +-#endif + } + + void + NPN_Status(NPP instance, const char* message) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- CallNPN_StatusProc(gNetscapeFuncs.status, instance, message); +-#else + (*gNetscapeFuncs.status)(instance, message); +-#endif + } + + const char* + NPN_UserAgent(NPP instance) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_UserAgentProc(gNetscapeFuncs.uagent, instance); +-#else + return (*gNetscapeFuncs.uagent)(instance); +-#endif + } + +-void *NPN_MemAlloc(uint32_t size) ++void* ++NPN_MemAlloc(uint32_t size) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_MemAllocProc(gNetscapeFuncs.memalloc, size); +-#else + return (*gNetscapeFuncs.memalloc)(size); +-#endif + } + + void NPN_MemFree(void* ptr) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- CallNPN_MemFreeProc(gNetscapeFuncs.memfree, ptr); +-#else + (*gNetscapeFuncs.memfree)(ptr); +-#endif + } + + uint32_t NPN_MemFlush(uint32_t size) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_MemFlushProc(gNetscapeFuncs.memflush, size); +-#else + return (*gNetscapeFuncs.memflush)(size); +-#endif + } + + void NPN_ReloadPlugins(NPBool reloadPages) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- CallNPN_ReloadPluginsProc(gNetscapeFuncs.reloadplugins, reloadPages); +-#else + (*gNetscapeFuncs.reloadplugins)(reloadPages); +-#endif +-} +- +-#ifdef OJI +-JRIEnv* NPN_GetJavaEnv() +-{ +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_GetJavaEnvProc(gNetscapeFuncs.getJavaEnv); +-#else +- return (*gNetscapeFuncs.getJavaEnv); +-#endif + } + +-jref NPN_GetJavaPeer(NPP instance) +-{ +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_GetJavaPeerProc(gNetscapeFuncs.getJavaPeer, +- instance); +-#else +- return (*gNetscapeFuncs.getJavaPeer)(instance); +-#endif +-} +-#endif +- + void + NPN_InvalidateRect(NPP instance, NPRect *invalidRect) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- CallNPN_InvalidateRectProc(gNetscapeFuncs.invalidaterect, instance, +- invalidRect); +-#else + (*gNetscapeFuncs.invalidaterect)(instance, invalidRect); +-#endif + } + + void + NPN_InvalidateRegion(NPP instance, NPRegion invalidRegion) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- CallNPN_InvalidateRegionProc(gNetscapeFuncs.invalidateregion, instance, +- invalidRegion); +-#else + (*gNetscapeFuncs.invalidateregion)(instance, invalidRegion); +-#endif + } + + void + NPN_ForceRedraw(NPP instance) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- CallNPN_ForceRedrawProc(gNetscapeFuncs.forceredraw, instance); +-#else + (*gNetscapeFuncs.forceredraw)(instance); +-#endif + } + + void NPN_PushPopupsEnabledState(NPP instance, NPBool enabled) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- CallNPN_PushPopupsEnabledStateProc(gNetscapeFuncs.pushpopupsenabledstate, +- instance, enabled); +-#else + (*gNetscapeFuncs.pushpopupsenabledstate)(instance, enabled); +-#endif + } + + void NPN_PopPopupsEnabledState(NPP instance) + { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- CallNPN_PopPopupsEnabledStateProc(gNetscapeFuncs.poppopupsenabledstate, +- instance); +-#else + (*gNetscapeFuncs.poppopupsenabledstate)(instance); +-#endif + } + + NPIdentifier NPN_GetStringIdentifier(const NPUTF8 *name) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +- { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_GetStringIdentifierProc( +- gNetscapeFuncs.getstringidentifier, name); +-#else +- return (*gNetscapeFuncs.getstringidentifier)(name); +-#endif +- } +- return NULL; ++ return (*gNetscapeFuncs.getstringidentifier)(name); + } + + void NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount, + NPIdentifier *identifiers) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +- { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- CallNPN_GetStringIdentifiersProc(gNetscapeFuncs.getstringidentifiers, +- names, nameCount, identifiers); +-#else +- (*gNetscapeFuncs.getstringidentifiers)(names, nameCount, identifiers); +-#endif +- } ++ (*gNetscapeFuncs.getstringidentifiers)(names, nameCount, identifiers); + } + + NPIdentifier NPN_GetIntIdentifier(int32_t intid) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +- { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_GetIntIdentifierProc(gNetscapeFuncs.getintidentifier, intid); +-#else +- return (*gNetscapeFuncs.getintidentifier)(intid); +-#endif +- } +- return NULL; ++ return (*gNetscapeFuncs.getintidentifier)(intid); + } + + bool NPN_IdentifierIsString(NPIdentifier identifier) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +- { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_IdentifierIsStringProc( +- gNetscapeFuncs.identifierisstring, +- identifier); +-#else +- return (*gNetscapeFuncs.identifierisstring)(identifier); +-#endif +- } +- return false; ++ return (*gNetscapeFuncs.identifierisstring)(identifier); + } + + NPUTF8 *NPN_UTF8FromIdentifier(NPIdentifier identifier) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +- { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_UTF8FromIdentifierProc( +- gNetscapeFuncs.utf8fromidentifier, +- identifier); +-#else +- return (*gNetscapeFuncs.utf8fromidentifier)(identifier); +-#endif +- } +- return NULL; ++ return (*gNetscapeFuncs.utf8fromidentifier)(identifier); + } + + int32_t NPN_IntFromIdentifier(NPIdentifier identifier) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +- { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_IntFromIdentifierProc( +- gNetscapeFuncs.intfromidentifier, +- identifier); +-#else +- return (*gNetscapeFuncs.intfromidentifier)(identifier); +-#endif +- } +- return 0; ++ return (*gNetscapeFuncs.intfromidentifier)(identifier); + } + + NPObject *NPN_CreateObject(NPP npp, NPClass *aClass) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_CreateObjectProc(gNetscapeFuncs.createobject, npp, aClass); +-#else +- return (*gNetscapeFuncs.createobject)(npp, aClass); +-#endif +- return NULL; ++ return (*gNetscapeFuncs.createobject)(npp, aClass); + } + + NPObject *NPN_RetainObject(NPObject *obj) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_RetainObjectProc(gNetscapeFuncs.retainobject, obj); +-#else +- return (*gNetscapeFuncs.retainobject)(obj); +-#endif +- return NULL; ++ return (*gNetscapeFuncs.retainobject)(obj); + } + + void NPN_ReleaseObject(NPObject *obj) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- CallNPN_ReleaseObjectProc(gNetscapeFuncs.releaseobject, obj); +-#else +- (*gNetscapeFuncs.releaseobject)(obj); +-#endif ++ (*gNetscapeFuncs.releaseobject)(obj); + } + + bool NPN_Invoke(NPP npp, NPObject* obj, NPIdentifier methodName, + const NPVariant *args, uint32_t argCount, NPVariant *result) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_InvokeProc(gNetscapeFuncs.invoke, npp, obj, methodName, +- args, argCount, result); +-#else +- return (*gNetscapeFuncs.invoke)(npp, obj, methodName, args, argCount, result); +-#endif +- return false; ++ return (*gNetscapeFuncs.invoke)(npp, obj, methodName, args, argCount, result); + } + + bool NPN_InvokeDefault(NPP npp, NPObject* obj, const NPVariant *args, + uint32_t argCount, NPVariant *result) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_InvokeDefaultProc(gNetscapeFuncs.invokeDefault, npp, obj, +- args, argCount, result); +-#else +- return (*gNetscapeFuncs.invokeDefault)(npp, obj, args, argCount, result); +-#endif +- return false; ++ return (*gNetscapeFuncs.invokeDefault)(npp, obj, args, argCount, result); + } + + bool NPN_Evaluate(NPP npp, NPObject* obj, NPString *script, + NPVariant *result) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_EvaluateProc(gNetscapeFuncs.evaluate, npp, obj, +- script, result); +-#else +- return (*gNetscapeFuncs.evaluate)(npp, obj, script, result); +-#endif +- return false; ++ return (*gNetscapeFuncs.evaluate)(npp, obj, script, result); + } + + bool NPN_GetProperty(NPP npp, NPObject* obj, NPIdentifier propertyName, + NPVariant *result) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_GetPropertyProc(gNetscapeFuncs.getproperty, npp, obj, +- propertyName, result); +-#else +- return (*gNetscapeFuncs.getproperty)(npp, obj, propertyName, result); +-#endif +- return false; ++ return (*gNetscapeFuncs.getproperty)(npp, obj, propertyName, result); + } + + bool NPN_SetProperty(NPP npp, NPObject* obj, NPIdentifier propertyName, + const NPVariant *value) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_SetPropertyProc(gNetscapeFuncs.setproperty, npp, obj, +- propertyName, value); +-#else +- return (*gNetscapeFuncs.setproperty)(npp, obj, propertyName, value); +-#endif +- return false; ++ return (*gNetscapeFuncs.setproperty)(npp, obj, propertyName, value); + } + + bool NPN_RemoveProperty(NPP npp, NPObject* obj, NPIdentifier propertyName) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_RemovePropertyProc(gNetscapeFuncs.removeproperty, npp, obj, +- propertyName); +-#else +- return (*gNetscapeFuncs.removeproperty)(npp, obj, propertyName); +-#endif +- return false; ++ return (*gNetscapeFuncs.removeproperty)(npp, obj, propertyName); + } + + bool NPN_HasProperty(NPP npp, NPObject* obj, NPIdentifier propertyName) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_HasPropertyProc(gNetscapeFuncs.hasproperty, npp, obj, +- propertyName); +-#else +- return (*gNetscapeFuncs.hasproperty)(npp, obj, propertyName); +-#endif +- return false; ++ return (*gNetscapeFuncs.hasproperty)(npp, obj, propertyName); + } + + bool NPN_HasMethod(NPP npp, NPObject* obj, NPIdentifier methodName) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- return CallNPN_HasMethodProc(gNetscapeFuncs.hasmethod, npp, +- obj, methodName); +-#else +- return (*gNetscapeFuncs.hasmethod)(npp, obj, methodName); +-#endif +- return false; ++ return (*gNetscapeFuncs.hasmethod)(npp, obj, methodName); + } + + void NPN_ReleaseVariantValue(NPVariant *variant) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- CallNPN_ReleaseVariantValueProc(gNetscapeFuncs.releasevariantvalue, variant); +-#else +- (*gNetscapeFuncs.releasevariantvalue)(variant); +-#endif ++ (*gNetscapeFuncs.releasevariantvalue)(variant); + } + + void NPN_SetException(NPObject* obj, const NPUTF8 *message) + { +- int minor = gNetscapeFuncs.version & 0xFF; +- if( minor >= 14 ) +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- CallNPN_SetExceptionProc(gNetscapeFuncs.setexception, obj, message); +-#else +- (*gNetscapeFuncs.setexception)(obj, message); +-#endif ++ (*gNetscapeFuncs.setexception)(obj, message); + } + ++ + /*********************************************************************** + * + * Wrapper functions : Netscape Navigator -> plugin +@@ -610,28 +339,6 @@ void NPN_SetException(NPObject* obj, con + * + ***********************************************************************/ + +-/* Function prototypes */ +-NPError Private_New(NPMIMEType pluginType, NPP instance, uint16_t mode, +- int16_t argc, char* argn[], char* argv[], NPSavedData* saved); +-NPError Private_Destroy(NPP instance, NPSavedData** save); +-NPError Private_SetWindow(NPP instance, NPWindow* window); +-NPError Private_NewStream(NPP instance, NPMIMEType type, NPStream* stream, +- NPBool seekable, uint16_t* stype); +-int32_t Private_WriteReady(NPP instance, NPStream* stream); +-int32_t Private_Write(NPP instance, NPStream* stream, int32_t offset, +- int32_t len, void* buffer); +-void Private_StreamAsFile(NPP instance, NPStream* stream, const char* fname); +-NPError Private_DestroyStream(NPP instance, NPStream* stream, NPError reason); +-void Private_URLNotify(NPP instance, const char* url, +- NPReason reason, void* notifyData); +-void Private_Print(NPP instance, NPPrint* platformPrint); +-NPError Private_GetValue(NPP instance, NPPVariable variable, void *r_value); +-NPError Private_SetValue(NPP instance, NPPVariable variable, void *r_value); +-#ifdef OJI +-JRIGlobalRef Private_GetJavaClass(void); +-#endif +- +-/* function implementations */ + NPError + Private_New(NPMIMEType pluginType, NPP instance, uint16_t mode, + int16_t argc, char* argn[], char* argv[], NPSavedData* saved) +@@ -707,11 +414,14 @@ Private_DestroyStream(NPP instance, NPSt + void + Private_URLNotify(NPP instance, const char* url, + NPReason reason, void* notifyData) ++ + { + PLUGINDEBUGSTR("URLNotify"); + NPP_URLNotify(instance, url, reason, notifyData); + } + ++ ++ + void + Private_Print(NPP instance, NPPrint* platformPrint) + { +@@ -719,33 +429,6 @@ Private_Print(NPP instance, NPPrint* pla + NPP_Print(instance, platformPrint); + } + +-NPError +-Private_GetValue(NPP instance, NPPVariable variable, void *r_value) +-{ +- PLUGINDEBUGSTR("GetValue"); +- return NPP_GetValue(instance, variable, r_value); +-} +- +-NPError +-Private_SetValue(NPP instance, NPPVariable variable, void *r_value) +-{ +- PLUGINDEBUGSTR("SetValue"); +- return NPP_SetValue(instance, variable, r_value); +-} +- +-#ifdef OJI +-JRIGlobalRef +-Private_GetJavaClass(void) +-{ +- jref clazz = NPP_GetJavaClass(); +- if (clazz) { +- JRIEnv* env = NPN_GetJavaEnv(); +- return JRI_NewGlobalRef(env, clazz); +- } +- return NULL; +-} +-#endif +- + /*********************************************************************** + * + * These functions are located automagically by netscape. +@@ -753,6 +436,17 @@ Private_GetJavaClass(void) + ***********************************************************************/ + + /* ++ * NP_GetPluginVersion [optional] ++ * - The browser uses the return value to indicate to the user what version of ++ * this plugin is installed. ++ */ ++char * ++NP_GetPluginVersion(void) ++{ ++ return "1.0.0.15"; ++} ++ ++/* + * NP_GetMIMEDescription + * - Netscape needs to know about this symbol + * - Netscape uses the return value to identify when an object instance +@@ -799,11 +493,12 @@ NP_Initialize(NPNetscapeFuncs* nsTable, + NPError err = NPERR_NO_ERROR; + + PLUGINDEBUGSTR("NP_Initialize"); +- ++ + /* validate input parameters */ ++ + if ((nsTable == NULL) || (pluginFuncs == NULL)) + err = NPERR_INVALID_FUNCTABLE_ERROR; +- ++ + /* + * Check the major version passed in Netscape's function table. + * We won't load if the major version is newer than what we expect. +@@ -812,17 +507,18 @@ NP_Initialize(NPNetscapeFuncs* nsTable, + * new APIs, but that's OK with us -- we'll just ignore them). + * + */ ++ + if (err == NPERR_NO_ERROR) { + if ((nsTable->version >> 8) > NP_VERSION_MAJOR) + err = NPERR_INCOMPATIBLE_VERSION_ERROR; + if (nsTable->size < ((char *)&nsTable->posturlnotify - (char *)nsTable)) + err = NPERR_INVALID_FUNCTABLE_ERROR; +- if (pluginFuncs->size < sizeof(NPPluginFuncs)) ++ if (pluginFuncs->size < sizeof(NPPluginFuncs)) + err = NPERR_INVALID_FUNCTABLE_ERROR; + } +- +- if (err == NPERR_NO_ERROR) +- { ++ ++ ++ if (err == NPERR_NO_ERROR) { + /* + * Copy all the fields of Netscape function table into our + * copy so we can call back into Netscape later. Note that +@@ -830,12 +526,11 @@ NP_Initialize(NPNetscapeFuncs* nsTable, + * the whole structure, because the Netscape function table + * could actually be bigger than what we expect. + */ +- int minor = nsTable->version & 0xFF; +- + gNetscapeFuncs.version = nsTable->version; + gNetscapeFuncs.size = nsTable->size; + gNetscapeFuncs.posturl = nsTable->posturl; + gNetscapeFuncs.geturl = nsTable->geturl; ++ gNetscapeFuncs.geturlnotify = nsTable->geturlnotify; + gNetscapeFuncs.requestread = nsTable->requestread; + gNetscapeFuncs.newstream = nsTable->newstream; + gNetscapeFuncs.write = nsTable->write; +@@ -846,85 +541,69 @@ NP_Initialize(NPNetscapeFuncs* nsTable, + gNetscapeFuncs.memfree = nsTable->memfree; + gNetscapeFuncs.memflush = nsTable->memflush; + gNetscapeFuncs.reloadplugins = nsTable->reloadplugins; +-#ifdef OJI +- if( minor >= NPVERS_HAS_LIVECONNECT ) +- { +- gNetscapeFuncs.getJavaEnv = nsTable->getJavaEnv; +- gNetscapeFuncs.getJavaPeer = nsTable->getJavaPeer; +- } +-#endif + gNetscapeFuncs.getvalue = nsTable->getvalue; + gNetscapeFuncs.setvalue = nsTable->setvalue; +- +- if( minor >= NPVERS_HAS_NOTIFICATION ) +- { +- gNetscapeFuncs.geturlnotify = nsTable->geturlnotify; +- gNetscapeFuncs.posturlnotify = nsTable->posturlnotify; +- } ++ gNetscapeFuncs.posturlnotify = nsTable->posturlnotify; + + if (nsTable->size >= ((char *)&nsTable->setexception - (char *)nsTable)) + { +- gNetscapeFuncs.invalidaterect = nsTable->invalidaterect; +- gNetscapeFuncs.invalidateregion = nsTable->invalidateregion; +- gNetscapeFuncs.forceredraw = nsTable->forceredraw; +- /* npruntime support */ +- if (minor >= 14) +- { +- gNetscapeFuncs.getstringidentifier = nsTable->getstringidentifier; +- gNetscapeFuncs.getstringidentifiers = nsTable->getstringidentifiers; +- gNetscapeFuncs.getintidentifier = nsTable->getintidentifier; +- gNetscapeFuncs.identifierisstring = nsTable->identifierisstring; +- gNetscapeFuncs.utf8fromidentifier = nsTable->utf8fromidentifier; +- gNetscapeFuncs.intfromidentifier = nsTable->intfromidentifier; +- gNetscapeFuncs.createobject = nsTable->createobject; +- gNetscapeFuncs.retainobject = nsTable->retainobject; +- gNetscapeFuncs.releaseobject = nsTable->releaseobject; +- gNetscapeFuncs.invoke = nsTable->invoke; +- gNetscapeFuncs.invokeDefault = nsTable->invokeDefault; +- gNetscapeFuncs.evaluate = nsTable->evaluate; +- gNetscapeFuncs.getproperty = nsTable->getproperty; +- gNetscapeFuncs.setproperty = nsTable->setproperty; +- gNetscapeFuncs.removeproperty = nsTable->removeproperty; +- gNetscapeFuncs.hasproperty = nsTable->hasproperty; +- gNetscapeFuncs.hasmethod = nsTable->hasmethod; +- gNetscapeFuncs.releasevariantvalue = nsTable->releasevariantvalue; +- gNetscapeFuncs.setexception = nsTable->setexception; +- } ++ gNetscapeFuncs.invalidaterect = nsTable->invalidaterect; ++ gNetscapeFuncs.invalidateregion = nsTable->invalidateregion; ++ gNetscapeFuncs.forceredraw = nsTable->forceredraw; ++ gNetscapeFuncs.getstringidentifier = nsTable->getstringidentifier; ++ gNetscapeFuncs.getstringidentifiers = nsTable->getstringidentifiers; ++ gNetscapeFuncs.getintidentifier = nsTable->getintidentifier; ++ gNetscapeFuncs.identifierisstring = nsTable->identifierisstring; ++ gNetscapeFuncs.utf8fromidentifier = nsTable->utf8fromidentifier; ++ gNetscapeFuncs.intfromidentifier = nsTable->intfromidentifier; ++ gNetscapeFuncs.createobject = nsTable->createobject; ++ gNetscapeFuncs.retainobject = nsTable->retainobject; ++ gNetscapeFuncs.releaseobject = nsTable->releaseobject; ++ gNetscapeFuncs.invoke = nsTable->invoke; ++ gNetscapeFuncs.invokeDefault = nsTable->invokeDefault; ++ gNetscapeFuncs.evaluate = nsTable->evaluate; ++ gNetscapeFuncs.getproperty = nsTable->getproperty; ++ gNetscapeFuncs.setproperty = nsTable->setproperty; ++ gNetscapeFuncs.removeproperty = nsTable->removeproperty; ++ gNetscapeFuncs.hasproperty = nsTable->hasproperty; ++ gNetscapeFuncs.hasmethod = nsTable->hasmethod; ++ gNetscapeFuncs.releasevariantvalue = nsTable->releasevariantvalue; ++ gNetscapeFuncs.setexception = nsTable->setexception; + } +- else ++ else + { +- gNetscapeFuncs.invalidaterect = NULL; +- gNetscapeFuncs.invalidateregion = NULL; +- gNetscapeFuncs.forceredraw = NULL; +- gNetscapeFuncs.getstringidentifier = NULL; +- gNetscapeFuncs.getstringidentifiers = NULL; +- gNetscapeFuncs.getintidentifier = NULL; +- gNetscapeFuncs.identifierisstring = NULL; +- gNetscapeFuncs.utf8fromidentifier = NULL; +- gNetscapeFuncs.intfromidentifier = NULL; +- gNetscapeFuncs.createobject = NULL; +- gNetscapeFuncs.retainobject = NULL; +- gNetscapeFuncs.releaseobject = NULL; +- gNetscapeFuncs.invoke = NULL; +- gNetscapeFuncs.invokeDefault = NULL; +- gNetscapeFuncs.evaluate = NULL; +- gNetscapeFuncs.getproperty = NULL; +- gNetscapeFuncs.setproperty = NULL; +- gNetscapeFuncs.removeproperty = NULL; +- gNetscapeFuncs.hasproperty = NULL; +- gNetscapeFuncs.releasevariantvalue = NULL; +- gNetscapeFuncs.setexception = NULL; ++ gNetscapeFuncs.invalidaterect = NULL; ++ gNetscapeFuncs.invalidateregion = NULL; ++ gNetscapeFuncs.forceredraw = NULL; ++ gNetscapeFuncs.getstringidentifier = NULL; ++ gNetscapeFuncs.getstringidentifiers = NULL; ++ gNetscapeFuncs.getintidentifier = NULL; ++ gNetscapeFuncs.identifierisstring = NULL; ++ gNetscapeFuncs.utf8fromidentifier = NULL; ++ gNetscapeFuncs.intfromidentifier = NULL; ++ gNetscapeFuncs.createobject = NULL; ++ gNetscapeFuncs.retainobject = NULL; ++ gNetscapeFuncs.releaseobject = NULL; ++ gNetscapeFuncs.invoke = NULL; ++ gNetscapeFuncs.invokeDefault = NULL; ++ gNetscapeFuncs.evaluate = NULL; ++ gNetscapeFuncs.getproperty = NULL; ++ gNetscapeFuncs.setproperty = NULL; ++ gNetscapeFuncs.removeproperty = NULL; ++ gNetscapeFuncs.hasproperty = NULL; ++ gNetscapeFuncs.releasevariantvalue = NULL; ++ gNetscapeFuncs.setexception = NULL; + } + if (nsTable->size >= + ((char *)&nsTable->poppopupsenabledstate - (char *)nsTable)) + { +- gNetscapeFuncs.pushpopupsenabledstate = nsTable->pushpopupsenabledstate; +- gNetscapeFuncs.poppopupsenabledstate = nsTable->poppopupsenabledstate; ++ gNetscapeFuncs.pushpopupsenabledstate = nsTable->pushpopupsenabledstate; ++ gNetscapeFuncs.poppopupsenabledstate = nsTable->poppopupsenabledstate; + } +- else ++ else + { +- gNetscapeFuncs.pushpopupsenabledstate = NULL; +- gNetscapeFuncs.poppopupsenabledstate = NULL; ++ gNetscapeFuncs.pushpopupsenabledstate = NULL; ++ gNetscapeFuncs.poppopupsenabledstate = NULL; + } + + /* +@@ -935,19 +614,6 @@ NP_Initialize(NPNetscapeFuncs* nsTable, + */ + pluginFuncs->version = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR; + pluginFuncs->size = sizeof(NPPluginFuncs); +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- pluginFuncs->newp = NewNPP_NewProc(Private_New); +- pluginFuncs->destroy = NewNPP_DestroyProc(Private_Destroy); +- pluginFuncs->setwindow = NewNPP_SetWindowProc(Private_SetWindow); +- pluginFuncs->newstream = NewNPP_NewStreamProc(Private_NewStream); +- pluginFuncs->destroystream = NewNPP_DestroyStreamProc(Private_DestroyStream); +- pluginFuncs->asfile = NewNPP_StreamAsFileProc(Private_StreamAsFile); +- pluginFuncs->writeready = NewNPP_WriteReadyProc(Private_WriteReady); +- pluginFuncs->write = NewNPP_WriteProc(Private_Write); +- pluginFuncs->print = NewNPP_PrintProc(Private_Print); +- pluginFuncs->getvalue = NewNPP_GetValueProc(Private_GetValue); +- pluginFuncs->setvalue = NewNPP_SetValueProc(Private_SetValue); +-#else + pluginFuncs->newp = (NPP_NewProcPtr)(Private_New); + pluginFuncs->destroy = (NPP_DestroyProcPtr)(Private_Destroy); + pluginFuncs->setwindow = (NPP_SetWindowProcPtr)(Private_SetWindow); +@@ -957,30 +623,17 @@ NP_Initialize(NPNetscapeFuncs* nsTable, + pluginFuncs->writeready = (NPP_WriteReadyProcPtr)(Private_WriteReady); + pluginFuncs->write = (NPP_WriteProcPtr)(Private_Write); + pluginFuncs->print = (NPP_PrintProcPtr)(Private_Print); +- pluginFuncs->getvalue = (NPP_GetValueProcPtr)(Private_GetValue); +- pluginFuncs->setvalue = (NPP_SetValueProcPtr)(Private_SetValue); +-#endif ++ pluginFuncs->urlnotify = (NPP_URLNotifyProcPtr)(Private_URLNotify); + pluginFuncs->event = NULL; +- if( minor >= NPVERS_HAS_NOTIFICATION ) +- { +-#if (((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR) < 20) +- pluginFuncs->urlnotify = NewNPP_URLNotifyProc(Private_URLNotify); +-#else +- pluginFuncs->urlnotify = (NPP_URLNotifyProcPtr)(Private_URLNotify); +-#endif +- } +-#ifdef OJI +- if( minor >= NPVERS_HAS_LIVECONNECT ) +- pluginFuncs->javaClass = Private_GetJavaClass(); +- else +- pluginFuncs->javaClass = NULL; +-#else +- pluginFuncs->javaClass = NULL; +-#endif ++ pluginFuncs->javaClass = NULL; ++ ++ // This function is supposedly loaded magically, but that doesn't ++ // seem to be true. ++ pluginFuncs->getvalue = (NPP_GetValueProcPtr)(NP_GetValue); + + err = NPP_Initialize(); + } +- ++ + return err; + } + +diff -p -up vlc-1.0.4/projects/mozilla/vlcplugin.cpp~ vlc-1.0.4/projects/mozilla/vlcplugin.cpp +--- vlc-1.0.4/projects/mozilla/vlcplugin.cpp~ 2009-12-07 22:12:58.000000000 +0100 ++++ vlc-1.0.4/projects/mozilla/vlcplugin.cpp 2010-01-06 15:49:38.000000000 +0100 +@@ -35,6 +35,7 @@ + #include "vlcplugin.h" + #include "control/npolibvlc.h" + ++#include <cstdlib> + #include <ctype.h> + + /***************************************************************************** +@@ -227,8 +228,8 @@ NPError VlcPlugin::init(int argc, char* + NPString script; + NPVariant result; + +- script.utf8characters = docLocHref; +- script.utf8length = sizeof(docLocHref)-1; ++ script.UTF8Characters = docLocHref; ++ script.UTF8Length = sizeof(docLocHref)-1; + + if( NPN_Evaluate(p_browser, plugin, &script, &result) ) + { +@@ -236,11 +237,11 @@ NPError VlcPlugin::init(int argc, char* + { + NPString &location = NPVARIANT_TO_STRING(result); + +- psz_baseURL = (char *) malloc(location.utf8length+1); ++ psz_baseURL = (char *) malloc(location.UTF8Length+1); + if( psz_baseURL ) + { +- strncpy(psz_baseURL, location.utf8characters, location.utf8length); +- psz_baseURL[location.utf8length] = '\0'; ++ strncpy(psz_baseURL, location.UTF8Characters, location.UTF8Length); ++ psz_baseURL[location.UTF8Length] = '\0'; + } + } + NPN_ReleaseVariantValue(&result); +diff -p -up vlc-1.0.4/projects/mozilla/vlcplugin.h~ vlc-1.0.4/projects/mozilla/vlcplugin.h +--- vlc-1.0.4/projects/mozilla/vlcplugin.h~ 2009-12-07 22:12:58.000000000 +0100 ++++ vlc-1.0.4/projects/mozilla/vlcplugin.h 2010-01-06 15:46:25.000000000 +0100 +@@ -30,6 +30,8 @@ + #define __VLCPLUGIN_H__ + + #include <vlc/vlc.h> ++#include <nspr/prtypes.h> ++#include <nspr/obsolete/protypes.h> + #include <npapi.h> + #include "control/nporuntime.h" + +diff -p -up vlc-1.0.4/projects/mozilla/vlcshell.cpp~ vlc-1.0.4/projects/mozilla/vlcshell.cpp +--- vlc-1.0.4/projects/mozilla/vlcshell.cpp~ 2009-12-17 19:01:36.000000000 +0100 ++++ vlc-1.0.4/projects/mozilla/vlcshell.cpp 2010-01-06 15:46:13.000000000 +0100 +@@ -265,10 +265,10 @@ NPError NPP_Initialize( void ) + return NPERR_NO_ERROR; + } + +-jref NPP_GetJavaClass( void ) ++/* jref NPP_GetJavaClass( void ) + { + return NULL; +-} ++}*/ + + void NPP_Shutdown( void ) + { +diff -p -up vlc-1.0.4/projects/mozilla/vlcshell.h~ vlc-1.0.4/projects/mozilla/vlcshell.h +--- vlc-1.0.4/projects/mozilla/vlcshell.h~ 2009-12-17 19:03:54.000000000 +0100 ++++ vlc-1.0.4/projects/mozilla/vlcshell.h 2010-01-06 15:43:23.000000000 +0100 +@@ -27,7 +27,7 @@ + char * NPP_GetMIMEDescription( void ); + + NPError NPP_Initialize( void ); +-jref NPP_GetJavaClass( void ); ++//jref NPP_GetJavaClass( void ); + void NPP_Shutdown( void ); + + NPError NPP_New( NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, |