all: backported mozilla plugin from trunk to 0.8.5

configure.ac

@@ -5009,10 +5009,13 @@ then
     then
       AC_MSG_ERROR([Please install the Mozilla development tools, mozilla-config was not found.])
     else
-      if test "${SYS}" != "mingw32"; then
+      if ${MOZILLA_CONFIG} --defines | grep -q 'MOZ_X11=1'; then
         LDFLAGS="${LDFLAGS_save} ${X_LIBS} ${X_PRE_LIBS}"
         AC_CHECK_LIB(Xt,XtStrings,
-         [VLC_ADD_LDFLAGS([mozilla],[${X_LIBS} ${X_PRE_LIBS} -lXt -lX11 -lSM -lICE])],
+         [
+             VLC_ADD_CPPFLAGS([mozilla],[${X_CFLAGS}])
+             VLC_ADD_LDFLAGS([mozilla],[${X_LIBS} ${X_PRE_LIBS} -lXt -lX11 -lSM -lICE])
+         ],
          [],
          [[${X_LIBS} ${X_PRE_LIBS} -lX11 -lSM -lICE]
         ])

mozilla/Makefile.am

@@ -14,6 +14,8 @@ SOURCES_mozilla_common = \
 	vlcplugin.h \
 	vlcpeer.cpp \
 	vlcpeer.h \
+	vlcruntime.cpp \
+	vlcruntime.h \
 	support/classinfo.h
 
 DIST_sources = $(SOURCES_mozilla_common) \
@@ -70,21 +72,59 @@ CPPFLAGS_mozilla_EXTRA = -I. -I$(top_builddir) -I$(srcdir)/../include -c \
 	-DNO_X11=1 -DUSE_SYSTEM_CONSOLE=1 -pipe -fmessage-length=0 -g \
 	-include mozilla-config.h
 LDFLAGS_npvlc = -arch ppc -bundle -read_only_relocs suppress \
-	$(LIBRARIES_libvlc) -dylib
+	$(LIBRARIES_libvlc) -dylib -headerpad_max_install_names 
 
 npvlc.rsrc: $(srcdir)/vlc.r
 	/Developer/Tools/Rez -useDF /Developer/Headers/FlatCarbon/Types.r $< -o $@
 
+#
+# Plugin uses shared libraries that are located relatively through @executable_path,
+# which unfortunately references the path of the App using the Plugin, rather than the
+# Plugin itself. Since this Plugin should always be installed in '/Library/Internet Plug-Ins',
+# it is safer to force dylibs to locate dependants through a fixed path
+#
+define FIXEXECPATH
+	otool -L "$$dylib" | \
+	awk -v libdylib="$$dylib" ' \
+	/@executable_path/ { \
+	    newpath=$$1 ; \
+	    sub("@executable_path","/Library/Internet Plug-Ins/VLC Plugin.plugin/Contents/MacOS",newpath) ; \
+	    print "install_name_tool -change \""$$1"\" \""newpath"\" \""libdylib"\"" ; \
+	}' | sh -x
+endef
+
 VLC\ Plugin.plugin: npvlc.rsrc npvlc.dylib
-	rm -rf "$@"
-	mkdir -p "./$@/Contents/MacOS"
-	cp npvlc.dylib "./$@/Contents/MacOS/VLC Plugin"
-	mkdir -p ./"$@"/Contents/Resources
-	cp npvlc.rsrc "./$@/Contents/Resources/VLC Plugin.rsrc"
-	cp -r $(top_srcdir)/extras/MacOSX/plugin/English.lproj "./$@/Contents/Resources/"
-	cp $(top_srcdir)/extras/MacOSX/plugin/Info.plist "./$@/Contents/Info.plist"
-	(cd $(top_builddir)/VLC.app/Contents/MacOS/; tar cf - modules)| \
-	(cd "./$@/Contents/MacOS"; tar xf -)
+	rm -Rf "$@"
+	$(INSTALL) -d "./$@/Contents/MacOS"
+	$(INSTALL) npvlc.dylib "./$@/Contents/MacOS/VLC Plugin"
+	dylib="./$@/Contents/MacOS/VLC Plugin"; $(FIXEXECPATH) ;
+	$(INSTALL) -d "./$@/Contents/Resources"
+	$(INSTALL) npvlc.rsrc "./$@/Contents/Resources/VLC Plugin.rsrc"
+	cp -r "$(top_srcdir)/extras/MacOSX/plugin/English.lproj" "./$@/Contents/Resources/"
+	$(INSTALL) "$(top_srcdir)/extras/MacOSX/plugin/Info.plist" "./$@/Contents/Info.plist"
+	$(INSTALL) -d "./$@/Contents/MacOS/modules"
+	for i in "" `$(VLC_CONFIG) --target plugin` ; do \
+	  if test -n "$$i" ; then \
+	    dylib="./$@/Contents/MacOS/modules/`basename $$i$(LIBEXT)`"; \
+	    $(INSTALL) "$$i$(LIBEXT)" "$$dylib"; \
+	    $(FIXEXECPATH) ; \
+	  fi ; \
+	done
+	if test -d $(top_srcdir)/extras/contrib/vlc-lib; then \
+	  $(INSTALL) -d "./$@/Contents/MacOS/lib"; \
+	  for i in $(top_srcdir)/extras/contrib/vlc-lib/*.dylib ; do \
+	    dylib="./$@/Contents/MacOS/lib/`basename $${i}`" ; \
+	    $(INSTALL) -m 644 "$${i}" "$$dylib" ; \
+	    $(FIXEXECPATH); \
+	  done ; \
+	fi
+	if test -d "$(MOZILLA_SDK_PATH)/lib"; then \
+	  for i in "$(MOZILLA_SDK_PATH)"/lib/*.dylib ; do \
+	    dylib="./$@/Contents/MacOS/`basename $${i}`" ; \
+	    $(INSTALL) -m 644 "$${i}" "$$dylib" ; \
+	    $(FIXEXECPATH); \
+	  done ; \
+	fi
 
 else
 

mozilla/support/npwin.cpp

@@ -115,8 +115,9 @@ NP_GetEntryPoints(NPPluginFuncs* pFuncs)
     pFuncs->writeready    = NPP_WriteReady;
     pFuncs->write         = NPP_Write;
     pFuncs->print         = NPP_Print;
-    pFuncs->getvalue	  = NPP_GetValue;
     pFuncs->event         = 0;       /// reserved 
+    pFuncs->getvalue	  = NPP_GetValue;
+    //pFuncs->setvalue	  = NPP_SetValue;
 
 	g_pluginFuncs		  = pFuncs;
 
@@ -206,12 +207,6 @@ void NPN_Version(int* plugin_major, int* plugin_minor, int* netscape_major, int*
     *netscape_minor = LOBYTE(g_pNavigatorFuncs->version);
 }
 
-NPError NPN_GetValue(NPP instance, NPNVariable variable, void *result)
-{
-    return g_pNavigatorFuncs->getvalue(instance, variable, result);
-}
-
-
 /* causes the specified URL to be fetched and streamed in
 */
 NPError NPN_GetURLNotify(NPP instance, const char *url, const char *target, void* notifyData)
@@ -362,3 +357,214 @@ jref NPN_GetJavaPeer(NPP instance)
 	return g_pNavigatorFuncs->getJavaPeer(instance);
 }
 
+NPError NPN_GetValue(NPP instance, NPNVariable variable, void *result)
+{
+    return g_pNavigatorFuncs->getvalue(instance, variable, result);
+}
+
+NPError NPN_SetValue(NPP instance, NPPVariable variable, void *value)
+{
+    return g_pNavigatorFuncs->setvalue(instance, variable, value);
+}
+
+void NPN_InvalidateRect(NPP instance, NPRect *rect)
+{
+    g_pNavigatorFuncs->invalidaterect(instance, rect);
+}
+
+void NPN_InvalidateRegion(NPP instance, NPRegion region)
+{
+    g_pNavigatorFuncs->invalidateregion(instance, region);
+}
+
+void NPN_ForceRedraw(NPP instance)
+{
+    g_pNavigatorFuncs->forceredraw(instance);
+}
+
+NPIdentifier NPN_GetStringIdentifier(const NPUTF8 *name)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->getstringidentifier(name);
+    }
+    return NULL;
+}
+
+void NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount, NPIdentifier *identifiers)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	g_pNavigatorFuncs->getstringidentifiers(names, nameCount, identifiers);
+    }
+}
+
+NPIdentifier NPN_GetIntIdentifier(int32_t intid)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->getintidentifier(intid);
+    }
+    return NULL;
+}
+
+bool NPN_IdentifierIsString(NPIdentifier identifier)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->identifierisstring(identifier);
+    }
+    return false;
+}
+
+NPUTF8 *NPN_UTF8FromIdentifier(NPIdentifier identifier)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->utf8fromidentifier(identifier);
+    }
+    return NULL;
+}
+
+int32_t NPN_IntFromIdentifier(NPIdentifier identifier)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->intfromidentifier(identifier);
+    }
+    return 0;
+}
+
+NPObject *NPN_CreateObject(NPP instance, NPClass *aClass)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->createobject(instance, aClass);
+    }
+    return NULL;
+}
+
+NPObject *NPN_RetainObject(NPObject *npobj)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->retainobject(npobj);
+    }
+    return NULL;
+}
+
+void NPN_ReleaseObject(NPObject *npobj)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	g_pNavigatorFuncs->releaseobject(npobj);
+    }
+}
+
+bool NPN_Invoke(NPP instance, NPObject *npobj, NPIdentifier methodName, const NPVariant *args, uint32_t argCount, NPVariant *result)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->invoke(instance, npobj, methodName, args, argCount, result);
+    }
+    return false;
+}
+
+bool NPN_InvokeDefault(NPP instance, NPObject *npobj, const NPVariant *args, uint32_t argCount, NPVariant *result)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->invokeDefault(instance, npobj, args, argCount, result);
+    }
+    return false;
+}
+
+bool NPN_Evaluate(NPP instance, NPObject *npobj, NPString *script, NPVariant *result)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->evaluate(instance, npobj, script, result);
+    }
+    return false;
+}
+
+bool NPN_GetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, NPVariant *result)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->getproperty(instance, npobj, propertyName, result);
+    }
+    return false;
+}
+
+bool NPN_SetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, const NPVariant *value)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->setproperty(instance, npobj, propertyName, value);
+    }
+    return false;
+}
+
+bool NPN_RemoveProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->removeproperty(instance, npobj, propertyName);
+    }
+    return false;
+}
+
+bool NPN_HasProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->hasproperty(instance, npobj, propertyName);
+    }
+    return false;
+}
+
+bool NPN_HasMethod(NPP instance, NPObject *npobj, NPIdentifier methodName)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	return g_pNavigatorFuncs->hasmethod(instance, npobj, methodName);
+    }
+    return false;
+}
+
+void NPN_ReleaseVariantValue(NPVariant *variant)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	g_pNavigatorFuncs->releasevariantvalue(variant);
+    }
+}
+
+void NPN_SetException(NPObject *npobj, const NPUTF8 *message)
+{
+    int navMinorVers = g_pNavigatorFuncs->version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+	g_pNavigatorFuncs->setexception(npobj, message);
+    }
+}
+

mozilla/vlc.r

@@ -4,13 +4,17 @@
 
 /* Definitions of system resource types */
 
+data 'carb' (0)
+{
+};
+
 /* The first string in the array is a plugin description,
  * the second is the plugin name */
 resource 'STR#' (126)
 {
     {
-        "A VLC test plugin... hope it goes somewhere",
-        "VLC plugin"
+        "VideoLAN WWW: http://videolan.org"
+        "VLC multimedia plugin"
     };
 };
 
@@ -18,7 +22,26 @@ resource 'STR#' (126)
 resource 'STR#' (127)
 {
     {
-        "Invoke scriptable sample plugin"
+        "MPEG audio",
+        "MPEG audio",
+        "MPEG video",
+        "MPEG video",
+        "MPEG video",
+        "MPEG video",
+        "MPEG-4 video",
+        "MPEG-4 audio",
+        "MPEG-4 video",
+        "MPEG-4 video",
+        "AVI video",
+        "QuickTime video",
+        "Ogg stream",
+        "Ogg stream",
+        "VLC plugin",
+        "ASF stream",
+        "ASF stream",
+        "",
+        "",
+        "Google VLC Plugin"
     };
 };
 
@@ -26,7 +49,26 @@ resource 'STR#' (127)
 resource 'STR#' (128,"MIME Type")
 {
     {
-        "application/vlc-plugin", ""
+        "audio/mpeg", "mp2,mp3,mpga,mpega",
+        "audio/x-mpeg", "mp2,mp3,mpga,mpega",
+        "video/mpeg", "mpg,mpeg,mpe",
+        "video/x-mpeg", "mpg,mpeg,mpe",
+        "video/mpeg-system", "mpg,mpeg,vob",
+        "video/x-mpeg-system", "mpg,mpeg,vob",
+        "video/mpeg4", "mp4,mpg4",
+        "audio/mpeg4", "mp4,mpg4",
+        "application/mpeg4-iod", "mp4,mpg4",
+        "application/mpeg4-muxcodetable", "mp4,mpg4",
+        "video/x-msvideo", "avi",
+        "video/quicktime", "mov, qt",
+        "application/ogg", "ogg",
+        "application/x-ogg", "ogg",
+        "application/x-vlc-plugin", "vlc",
+        "video/x-ms-asf-plugin", "",
+        "video/x-ms-asf", "",
+        "application/x-mplayer2", "",
+        "video/x-ms-wmv", "",
+        "video/x-google-vlc-plugin", "",
     };
 };
 

mozilla/vlcpeer.h

@@ -20,6 +20,8 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  *****************************************************************************/
+#ifndef __VLCPEER_H__
+#define __VLCPEER_H__
 
 #include "vlcintf.h"
 #include "support/classinfo.h"
@@ -56,3 +58,4 @@ private:
     VlcPlugin * p_plugin;
 };
 
+#endif

mozilla/vlcplugin.cpp

@@ -41,7 +41,6 @@
 #undef XP_UNIX
 #endif
 
-#include "vlcpeer.h"
 #include "vlcplugin.h"
 
 /*****************************************************************************
@@ -96,36 +95,3 @@ VlcIntf* VlcPlugin::GetPeer()
     return p_peer;
 }
 
-void VlcPlugin::SetFileName(const char * filename)
-{
-#if 0
-    FILE * fh;
-    fh = fopen(filename, "rb");
-    if(!fh)
-    {
-        fprintf(stderr, "Error while opening %s.\n", filename);
-        return;
-    }
-    fseek(fh, 0, SEEK_END);
-    m_lSize = ftell(fh);
-    m_szSound = (char*) malloc(m_lSize);
-    if(!m_szSound)
-    {
-        fprintf(stderr, "Error while allocating memory.\n");
-        fclose(fh);
-        return;
-    }
-    rewind(fh);
-    long pos = 0;
-    do
-    {
-        pos += fread(m_szSound + pos, 1, m_lSize - pos, fh);
-        fprintf(stderr, "pos = %d\n", pos);
-    }
-    while (pos < m_lSize -1);
-    fclose (fh);
-    fprintf(stderr, "File loaded\n");
-#endif
-    return;
-}
-

mozilla/vlcplugin.h

@@ -24,6 +24,32 @@
 /*******************************************************************************
  * Instance state information about the plugin.
  ******************************************************************************/
+#ifndef __VLCPLUGIN_H__
+#define __VLCPLUGIN_H__
+
+#include "vlcpeer.h"
+
+#if !defined(XP_MACOSX) && !defined(XP_UNIX) && !defined(XP_WIN)
+#define XP_UNIX 1
+#elif defined(XP_MACOSX)
+#undef XP_UNIX
+#endif
+
+#ifdef XP_WIN
+    /* Windows stuff */
+#endif
+
+#ifdef XP_MACOSX
+    /* Mac OS X stuff */
+#   include <Quickdraw.h>
+#endif
+
+#ifdef XP_UNIX
+    /* X11 stuff */
+#   include <X11/Xlib.h>
+#   include <X11/Intrinsic.h>
+#   include <X11/StringDefs.h>
+#endif
 
 class VlcPlugin
 {
@@ -35,8 +61,6 @@ public:
     NPP      GetInstance();
     VlcIntf* GetPeer();
 
-    void     SetFileName( const char* );
-
     /* Window settings */
     NPWindow* p_npwin;
     uint16    i_npmode;
@@ -114,3 +138,4 @@ private:
     "audio/wav::WAV audio" \
     "audio/x-wav::WAV audio" \
 
+#endif

mozilla/vlcruntime.cpp

+/*****************************************************************************
+ * vlcruntime.cpp: support for NPRuntime API for Netscape Script-able plugins
+ *                 FYI: http://www.mozilla.org/projects/plugins/npruntime.html
+ *****************************************************************************
+ * Copyright (C) 2005 the VideoLAN team
+ *
+ * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
+ *
+ * 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 <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+/* vlc stuff */
+#ifdef USE_LIBVLC
+#   include <vlc/vlc.h>
+#endif
+
+/* Mozilla stuff */
+#ifdef HAVE_MOZILLA_CONFIG_H
+#   include <mozilla-config.h>
+#endif
+#include <nsISupports.h>
+#include <nsMemory.h>
+#include <npapi.h>
+#include <npruntime.h>
+
+#include "vlcplugin.h"
+#include "vlcruntime.h"
+
+/*
+** utility functions
+*/
+
+static PRInt64 NPVariantToPRInt64(const NPVariant &v)
+{
+    switch( v.type ) {
+	case NPVariantType_Bool:
+	    return static_cast<PRInt64>(NPVARIANT_TO_BOOLEAN(v));
+	case NPVariantType_Int32:
+	    return static_cast<PRInt64>(NPVARIANT_TO_INT32(v));
+	case NPVariantType_Double:
+	    return static_cast<PRInt64>(NPVARIANT_TO_DOUBLE(v));
+	default:
+	    return 0;
+    }
+}
+
+/*
+** implementation root object
+*/
+
+const NPUTF8 * const VlcRuntimeRootObject::propertyNames[] = { };
+const NPUTF8 * const VlcRuntimeRootObject::methodNames[] =
+{
+    "play",
+    "pause",
+    "stop",
+    "fullscreen",
+    "set_volume",
+    "get_volume",
+    "mute",
+    "get_int_variable",
+    "set_int_variable",
+    "get_bool_variable",
+    "set_bool_variable",
+    "get_str_variable",
+    "set_str_variable",
+    "clear_playlist",
+    "add_item",
+    "next",
+    "previous",
+    "isplaying",
+    "get_length",
+    "get_position",
+    "get_time",
+    "seek",
+};
+
+enum VlcRuntimeRootObjectMethodIds
+{
+    ID_play = 0,
+    ID_pause,
+    ID_stop,
+    ID_fullscreen,
+    ID_set_volume,
+    ID_get_volume,
+    ID_mute,
+    ID_get_int_variable,
+    ID_set_int_variable,
+    ID_get_bool_variable,
+    ID_set_bool_variable,
+    ID_get_str_variable,
+    ID_set_str_variable,
+    ID_clear_playlist,
+    ID_add_item,
+    ID_next,
+    ID_previous,
+    ID_isplaying,
+    ID_get_length,
+    ID_get_position,
+    ID_get_time,
+    ID_seek,
+};
+
+const int VlcRuntimeRootObject::propertyCount = sizeof(VlcRuntimeRootObject::propertyNames)/sizeof(NPUTF8 *);
+const int VlcRuntimeRootObject::methodCount = sizeof(VlcRuntimeRootObject::methodNames)/sizeof(NPUTF8 *);
+
+bool VlcRuntimeRootObject::getProperty(int index, NPVariant *result)
+{
+    return false;
+}
+
+bool VlcRuntimeRootObject::setProperty(int index, const NPVariant *value)
+{
+    return false;
+}
+
+bool VlcRuntimeRootObject::removeProperty(int index)
+{
+    return false;
+}
+
+bool VlcRuntimeRootObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant *result)
+{
+    VlcPlugin *plugin = (VlcPlugin *)(_instance->pdata);
+    if( plugin )
+    {
+	VlcIntf *peer = plugin->GetPeer();
+	switch( index )
+	{
+	    case ID_play:
+		peer->Play();
+		VOID_TO_NPVARIANT(*result);
+		return true;
+	    case ID_pause:
+		peer->Pause();
+		VOID_TO_NPVARIANT(*result);
+		return true;
+	    case ID_stop:
+		peer->Stop();
+		VOID_TO_NPVARIANT(*result);
+		return true;
+	    case ID_fullscreen:
+		peer->Fullscreen();
+		VOID_TO_NPVARIANT(*result);
+		return true;
+	    case ID_set_volume:
+		if( argCount == 1 )
+		{
+		    peer->Set_volume(NPVariantToPRInt64(args[0]));
+		    VOID_TO_NPVARIANT(*result);
+		    return true;
+		}
+		return false;
+	    case ID_get_volume:
+		{
+		    PRInt64 val;
+		    peer->Get_volume(&val);
+		    INT32_TO_NPVARIANT(val, *result);
+		    return true;
+		}
+	    case ID_mute:
+		peer->Mute();
+		VOID_TO_NPVARIANT(*result);
+		return true;
+	    case ID_get_int_variable:
+		if( (argCount == 1)
+		    && NPVARIANT_IS_STRING(args[0]) )
+		{
+		    const NPString &name = NPVARIANT_TO_STRING(args[0]);
+		    NPUTF8 *s = new NPUTF8[name.utf8length+1];
+		    if( s )
+		    {
+			PRInt64 val;
+			strncpy(s, name.utf8characters, name.utf8length);
+			s[name.utf8length] = '\0';
+			peer->Get_int_variable(s, &val);
+			INT32_TO_NPVARIANT(val, *result);
+			delete s;
+			return true;
+		    }
+		}
+		return false;
+	    case ID_set_int_variable:
+		if( (argCount == 2)
+		    && NPVARIANT_IS_STRING(args[0]) )
+		{
+		    const NPString &name = NPVARIANT_TO_STRING(args[0]);
+		    NPUTF8 *s = new NPUTF8[name.utf8length+1];
+		    if( s )
+		    {
+			strncpy(s, name.utf8characters, name.utf8length);
+			s[name.utf8length] = '\0';
+			peer->Set_int_variable(s, NPVariantToPRInt64(args[1]));
+			delete s;
+			VOID_TO_NPVARIANT(*result);
+			return true;
+		    }
+		}
+		return false;
+	    case ID_get_bool_variable:
+		if( (argCount == 1)
+		    && NPVARIANT_IS_STRING(args[0]) )
+		{
+		    const NPString &name = NPVARIANT_TO_STRING(args[0]);
+		    NPUTF8 *s = new NPUTF8[name.utf8length+1];
+		    if( s )
+		    {
+			PRBool val;
+			strncpy(s, name.utf8characters, name.utf8length);
+			s[name.utf8length] = '\0';
+			peer->Get_bool_variable(s, &val);
+			BOOLEAN_TO_NPVARIANT(val, *result);
+			delete s;
+			return true;
+		    }
+		}
+		return false;
+	    case ID_set_bool_variable:
+		if( (argCount == 2)
+		    && NPVARIANT_IS_STRING(args[0])
+		    && NPVARIANT_IS_BOOLEAN(args[1]) )
+		{
+		    const NPString &name = NPVARIANT_TO_STRING(args[0]);
+		    NPUTF8 *s = new NPUTF8[name.utf8length+1];
+		    if( s )
+		    {
+			strncpy(s, name.utf8characters, name.utf8length);
+			s[name.utf8length] = '\0';
+			peer->Set_bool_variable(s, NPVARIANT_TO_BOOLEAN(args[1]));
+			delete s;
+			VOID_TO_NPVARIANT(*result);
+			return true;
+		    }
+		}
+		return false;
+	    case ID_get_str_variable:
+		if( (argCount == 1)
+		    && NPVARIANT_IS_STRING(args[0]) )
+		{
+		    const NPString &name = NPVARIANT_TO_STRING(args[0]);
+		    NPUTF8 *s = new NPUTF8[name.utf8length+1];
+		    if( s )
+		    {
+			char *val;
+			strncpy(s, name.utf8characters, name.utf8length);
+			s[name.utf8length] = '\0';
+			peer->Get_str_variable(s, &val);
+			delete s;
+			int len = strlen(val);
+			NPUTF8 *retval = (NPUTF8 *)NPN_MemAlloc(len);
+			if( retval )
+			{
+			    memcpy(retval, val, len);
+			    STRINGN_TO_NPVARIANT(retval, len, *result);
+			    free(val);
+			    return true;
+			}
+			free(val);
+		    }
+		}
+		return false;
+	    case ID_set_str_variable:
+		if( (argCount == 2)
+		    && NPVARIANT_IS_STRING(args[0])
+		    && NPVARIANT_IS_STRING(args[1]) )
+		{
+		    const NPString &name = NPVARIANT_TO_STRING(args[0]);
+		    NPUTF8 *s = new NPUTF8[name.utf8length+1];
+		    if( s )
+		    {
+			strncpy(s, name.utf8characters, name.utf8length);
+			s[name.utf8length] = '\0';
+			const NPString &val = NPVARIANT_TO_STRING(args[1]);
+			NPUTF8 *v = new NPUTF8[val.utf8length+1];
+			if( v )
+			{
+			    strncpy(v, val.utf8characters, val.utf8length);
+			    v[val.utf8length] = '\0';
+			    peer->Set_str_variable(s, v);
+			    delete s;
+			    delete v;
+			    VOID_TO_NPVARIANT(*result);
+			    return true;
+			}
+			delete s;
+		    }
+		}
+		return false;
+	    case ID_clear_playlist:
+		peer->Clear_playlist();
+		VOID_TO_NPVARIANT(*result);
+		return true;
+	    case ID_add_item:
+		if( (argCount == 1)
+		    && NPVARIANT_IS_STRING(args[0]) )
+		{
+		    const NPString &name = NPVARIANT_TO_STRING(args[0]);
+		    NPUTF8 *s = new NPUTF8[name.utf8length+1];
+		    if( s )
+		    {
+			strncpy(s, name.utf8characters, name.utf8length);
+			s[name.utf8length] = '\0';
+			peer->Add_item(s);
+			delete s;
+			return true;
+		    }
+		}
+		return false;
+	    case ID_next:
+		peer->Next();
+		VOID_TO_NPVARIANT(*result);
+		return true;
+	    case ID_previous:
+		peer->Previous();
+		VOID_TO_NPVARIANT(*result);
+		return true;
+	    case ID_isplaying:
+		{
+		    PRBool val;
+		    peer->Isplaying(&val);
+		    BOOLEAN_TO_NPVARIANT(val, *result);
+		    return true;
+		}
+	    case ID_get_length:
+		{
+		    PRInt64 val;
+		    peer->Get_length(&val);
+		    DOUBLE_TO_NPVARIANT(val, *result);
+		    return true;
+		}
+	    case ID_get_position:
+		{
+		    PRInt64 val;
+		    peer->Get_position(&val);
+		    INT32_TO_NPVARIANT(val, *result);
+		    return true;
+		}
+	    case ID_get_time:
+		{
+		    PRInt64 val;
+		    peer->Get_time(&val);
+		    INT32_TO_NPVARIANT(val, *result);
+		    return true;
+		}
+	    case ID_seek:
+		if( argCount == 2 )
+		{
+		    peer->Seek(NPVariantToPRInt64(args[0]), NPVariantToPRInt64(args[1]));
+		    VOID_TO_NPVARIANT(*result);
+		    return true;
+		}
+		return false;
+	}
+	NS_RELEASE(peer);
+    }
+    return false;
+}
+
+bool VlcRuntimeRootObject::invokeDefault(const NPVariant *args, uint32_t argCount, NPVariant *result)
+{
+    return false;
+}
+

mozilla/vlcruntime.h

+/*****************************************************************************
+ * vlcruntime.h: a VLC plugin for Mozilla
+ *****************************************************************************
+ * Copyright (C) 2002-2005 the VideoLAN team
+ * $Id: vlcruntime.h 14466 2006-02-22 23:34:54Z dionoea $
+ *
+ * Authors: Damien Fouilleul <damien.fouilleul@laposte.net>
+ *
+ * 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.
+ *****************************************************************************/
+
+/*
+** support framework for runtime script objects
+*/
+
+class VlcRuntimeObject : public NPObject
+{
+public:
+    VlcRuntimeObject(NPP instance, const NPClass *aClass) :
+        _instance(instance)
+    {
+        _class = const_cast<NPClass *>(aClass);
+        referenceCount = 1;
+    };
+    virtual ~VlcRuntimeObject() {};
+
+    virtual bool getProperty(int index, NPVariant *result) = 0;
+    virtual bool setProperty(int index, const NPVariant *value) = 0;
+    virtual bool removeProperty(int index) = 0;
+    virtual bool invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant *result) = 0;
+    virtual bool invokeDefault(const NPVariant *args, uint32_t argCount, NPVariant *result) = 0;
+    NPP _instance;
+};
+
+template<class T> class VlcRuntimeClass : public NPClass
+{
+public:
+    VlcRuntimeClass();
+    virtual ~VlcRuntimeClass();
+
+    VlcRuntimeObject *create(NPP instance) const;
+
+    int indexOfMethod(NPIdentifier name) const;
+    int indexOfProperty(NPIdentifier name) const;
+
+private:
+    NPIdentifier *propertyIdentifiers;
+    NPIdentifier *methodIdentifiers;
+};
+
+template<class T>
+static NPObject *vlcRuntimeClassAllocate(NPP instance, NPClass *aClass)
+{
+    const VlcRuntimeClass<T> *vClass = static_cast<VlcRuntimeClass<T> *>(aClass);
+    return (NPObject *)vClass->create(instance);
+}
+
+template<class T>
+static void vlcRuntimeClassDeallocate(NPObject *npobj)
+{
+    VlcRuntimeObject *vObj = static_cast<VlcRuntimeObject *>(npobj);
+    delete vObj;
+}
+
+template<class T>
+static void vlcRuntimeClassInvalidate(NPObject *npobj)
+{
+    VlcRuntimeObject *vObj = static_cast<VlcRuntimeObject *>(npobj);
+    vObj->_instance = NULL;
+}
+
+template<class T>
+bool vlcRuntimeClassHasMethod(NPObject *npobj, NPIdentifier name)
+{
+    const VlcRuntimeClass<T> *vClass = static_cast<VlcRuntimeClass<T> *>(npobj->_class);
+    return vClass->indexOfMethod(name) != -1;
+}
+
+template<class T>
+bool vlcRuntimeClassHasProperty(NPObject *npobj, NPIdentifier name)
+{
+    const VlcRuntimeClass<T> *vClass = static_cast<VlcRuntimeClass<T> *>(npobj->_class);
+    return vClass->indexOfProperty(name) != -1;
+}
+
+template<class T>
+bool vlcRuntimeClassGetProperty(NPObject *npobj, NPIdentifier name, NPVariant *result)
+{
+    const VlcRuntimeClass<T> *vClass = static_cast<VlcRuntimeClass<T> *>(npobj->_class);
+    int index = vClass->indexOfProperty(name);
+    if( index != -1 )
+    {
+        VlcRuntimeObject *vObj = static_cast<VlcRuntimeObject *>(npobj);
+        return vObj->getProperty(index, result);
+    }
+    return false;
+}
+
+template<class T>
+bool vlcRuntimeClassSetProperty(NPObject *npobj, NPIdentifier name, const NPVariant *value)
+{
+    const VlcRuntimeClass<T> *vClass = static_cast<VlcRuntimeClass<T> *>(npobj->_class);
+    int index = vClass->indexOfProperty(name);
+    if( index != -1 )
+    {
+        VlcRuntimeObject *vObj = static_cast<VlcRuntimeObject *>(npobj);
+        return vObj->setProperty(index, value);
+    }
+    return false;
+}
+
+template<class T>
+bool vlcRuntimeClassRemoveProperty(NPObject *npobj, NPIdentifier name)
+{
+    const VlcRuntimeClass<T> *vClass = static_cast<VlcRuntimeClass<T> *>(npobj->_class);
+    int index = vClass->indexOfProperty(name);
+    if( index != -1 )
+    {
+        VlcRuntimeObject *vObj = static_cast<VlcRuntimeObject *>(npobj);
+        return vObj->removeProperty(index);
+    }
+    return false;
+}
+
+template<class T>
+static bool vlcRuntimeClassInvoke(NPObject *npobj, NPIdentifier name,
+                                    const NPVariant *args, uint32_t argCount,
+                                    NPVariant *result)
+{
+    const VlcRuntimeClass<T> *vClass = static_cast<VlcRuntimeClass<T> *>(npobj->_class);
+    int index = vClass->indexOfMethod(name);
+    if( index != -1 )
+    {
+        VlcRuntimeObject *vObj = static_cast<VlcRuntimeObject *>(npobj);
+        return vObj->invoke(index, args, argCount, result);
+    }
+    return false;
+}
+
+template<class T>
+static bool vlcRuntimeClassInvokeDefault(NPObject *npobj,
+                                           const NPVariant *args,
+                                           uint32_t argCount,
+                                           NPVariant *result)
+{
+    VlcRuntimeObject *vObj = static_cast<VlcRuntimeObject *>(npobj);
+    return vObj->invokeDefault(args, argCount, result);
+}
+
+template<class T>
+VlcRuntimeClass<T>::VlcRuntimeClass()
+{
+    // retreive property identifiers from names
+    if( T::propertyCount > 0 )
+    {
+	propertyIdentifiers = new NPIdentifier[T::propertyCount];
+	if( propertyIdentifiers )
+	    NPN_GetStringIdentifiers(const_cast<const NPUTF8**>(T::propertyNames),
+		    T::propertyCount, propertyIdentifiers);
+    }
+
+    // retreive method identifiers from names
+    if( T::methodCount > 0 )
+    {
+	methodIdentifiers = new NPIdentifier[T::methodCount];
+	if( methodIdentifiers )
+	    NPN_GetStringIdentifiers(const_cast<const NPUTF8**>(T::methodNames),
+		    T::methodCount, methodIdentifiers);
+    }
+
+    // fill in NPClass structure
+    structVersion  = NP_CLASS_STRUCT_VERSION;
+    allocate       = vlcRuntimeClassAllocate<T>;
+    deallocate     = vlcRuntimeClassDeallocate<T>;
+    invalidate     = vlcRuntimeClassInvalidate<T>;
+    hasMethod      = vlcRuntimeClassHasMethod<T>;
+    invoke         = vlcRuntimeClassInvoke<T>;
+    invokeDefault  = vlcRuntimeClassInvokeDefault<T>;
+    hasProperty    = vlcRuntimeClassHasProperty<T>;
+    getProperty    = vlcRuntimeClassGetProperty<T>;
+    setProperty    = vlcRuntimeClassSetProperty<T>;
+    removeProperty = vlcRuntimeClassRemoveProperty<T>;
+}
+
+template<class T>
+VlcRuntimeClass<T>::~VlcRuntimeClass()
+{
+    delete propertyIdentifiers;
+    delete methodIdentifiers;
+}
+
+template<class T>
+VlcRuntimeObject *VlcRuntimeClass<T>::create(NPP instance) const
+{
+    return new T(instance, this);
+}
+
+template<class T>
+int VlcRuntimeClass<T>::indexOfMethod(NPIdentifier name) const
+{
+    if( methodIdentifiers )
+    {
+        for(int c=0; c< T::methodCount; ++c )
+        {
+            if( name == methodIdentifiers[c] )
+                return c;
+        }
+    }
+    return -1;
+}
+
+template<class T>
+int VlcRuntimeClass<T>::indexOfProperty(NPIdentifier name) const
+{
+    if( propertyIdentifiers )
+    {
+        for(int c=0; c< T::propertyCount; ++c )
+        {
+            if( name == propertyIdentifiers[c] )
+                return c;
+        }
+    }
+    return -1;
+}
+
+/*
+** defined runtime script objects
+*/
+
+class VlcRuntimeRootObject: public VlcRuntimeObject
+{
+public:
+    VlcRuntimeRootObject(NPP instance, const NPClass *aClass) :
+        VlcRuntimeObject(instance, aClass) {};
+    virtual ~VlcRuntimeRootObject() {};
+
+    static const int propertyCount;
+    static const NPUTF8 * const propertyNames[];
+
+    static const int methodCount;
+    static const NPUTF8 * const methodNames[];
+
+    virtual bool getProperty(int index, NPVariant *result);
+    virtual bool setProperty(int index, const NPVariant *value);
+    virtual bool removeProperty(int index);
+    virtual bool invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant *result);
+    virtual bool invokeDefault(const NPVariant *args, uint32_t argCount, NPVariant *result);
+};
+

mozilla/vlcshell.cpp

@@ -45,36 +45,15 @@
 #include <nsISupports.h>
 #include <nsMemory.h>
 #include <npapi.h>
+#include <npruntime.h>
 
 /* This is from mozilla java, do we really need it? */
 #if 0
 #include <jri.h>
 #endif
 
-#if !defined(XP_MACOSX) && !defined(XP_UNIX) && !defined(XP_WIN)
-#define XP_UNIX 1
-#elif defined(XP_MACOSX)
-#undef XP_UNIX
-#endif
-
-#ifdef XP_WIN
-    /* Windows stuff */
-#endif
-
-#ifdef XP_MACOSX
-    /* Mac OS X stuff */
-#   include <Quickdraw.h>
-#endif
-
-#ifdef XP_UNIX
-    /* X11 stuff */
-#   include <X11/Xlib.h>
-#   include <X11/Intrinsic.h>
-#   include <X11/StringDefs.h>
-#endif
-
-#include "vlcpeer.h"
 #include "vlcplugin.h"
+#include "vlcruntime.h"
 
 #if USE_LIBVLC
 #   define WINDOW_TEXT "(no picture)"
@@ -103,8 +82,8 @@ static void Resize( Widget w, XtPointer closure, XEvent *event );
  * MacOS-only declarations
 ******************************************************************************/
 #ifdef XP_MACOSX
-#   define VOUT_PLUGINS "macosx"
-#   define AOUT_PLUGINS "macosx"
+#   define VOUT_PLUGINS "macosx,dummy"
+#   define AOUT_PLUGINS "auhal,macosx,dummy"
 
 #endif
 
@@ -181,6 +160,15 @@ NPError NPP_GetValue( NPP instance, NPPVariable variable, void *value )
             **(nsIID**)value = nsid;
             break;
 
+        case NPPVpluginScriptableNPObject:
+            static VlcRuntimeClass<VlcRuntimeRootObject> *rootClass = new VlcRuntimeClass<VlcRuntimeRootObject>;
+            *(NPObject**)value = NPN_CreateObject(instance, rootClass);
+            if( *(NPObject**)value == NULL )
+            {
+                return NPERR_OUT_OF_MEMORY_ERROR;
+            }
+            break;
+
         default:
             return NPERR_GENERIC_ERROR;
     }
@@ -194,26 +182,67 @@ NPError NPP_GetValue( NPP instance, NPPVariable variable, void *value )
 #ifdef XP_MACOSX
 int16 NPP_HandleEvent( NPP instance, void * event )
 {
-    VlcPlugin *p_plugin = (VlcPlugin*)instance->pdata;
-    vlc_value_t value;
-
     if( instance == NULL )
     {
         return false;
     }
 
-    EventRecord *pouetEvent = (EventRecord*)event;
+    VlcPlugin *p_plugin = (VlcPlugin*)instance->pdata;
+    EventRecord *myEvent = (EventRecord*)event;
 
-    if (pouetEvent->what == 6)
+    switch( myEvent->what )
     {
-        value.i_int = 1;
-        VLC_VariableSet( p_plugin->i_vlc, "drawableredraw", value );
-        return true;
-    }
+        case nullEvent:
+            break;
+        case mouseDown:
+        case mouseUp:
+            return true;
+        case keyUp:
+        case keyDown:
+        case autoKey:
+            return true;
+        case updateEvt:
+        {
+            NPWindow *npwindow = p_plugin->window;
+            NP_Port *npport = (NP_Port *)(npwindow->window);
+
+            SetPort( npport->port );
+            //SetOrigin( npport->portx , npport->porty);
+
+            /* draw the beautiful "No Picture" */
+
+            ForeColor(blackColor);
+            PenMode( patCopy );
 
-    Boolean eventHandled = false;
+	    Rect rect;
+            rect.left = 0;
+            rect.top = 0;
+            rect.right = npwindow->width;
+            rect.bottom = npwindow->height;
+            PaintRect( &rect );
 
-    return eventHandled;
+            ForeColor(whiteColor);
+            char *text = strdup( WINDOW_TEXT );
+            MoveTo( (npwindow->width-80)/ 2  , npwindow->height / 2 );
+            DrawText( text , 0 , strlen(text) );
+            free(text);
+
+            return true;
+        }
+        case activateEvt:
+            return false;
+        case NPEventType_GetFocusEvent:
+        case NPEventType_LoseFocusEvent:
+            return true;
+        case NPEventType_AdjustCursorEvent:
+            return false;
+	case NPEventType_ScrollingBeginsEvent:
+	case NPEventType_ScrollingEndsEvent:
+            return true;
+        default:
+            ;
+    }
+    return false;
 }
 #endif /* XP_MACOSX */
 
@@ -287,20 +316,14 @@ NPError NPP_New( NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc,
 
     {
 #ifdef XP_MACOSX
-        char *home_user;
-        char *directory;
-        char *plugin_path;
-        char *ppsz_argv[] = { "vlc", "--plugin-path", NULL };
-
-        home_user = strdup( getenv("HOME") );
-        directory = strdup( "/Library/Internet Plug-Ins/VLC Plugin.plugin/"
-                            "Contents/MacOS/modules" );
-        plugin_path = (char *)malloc( strlen( directory ) + strlen( home_user ) );
-        memcpy( plugin_path , home_user , strlen(home_user) );
-        memcpy( plugin_path + strlen( home_user ) , directory ,
-                strlen( directory ) );
-
-        ppsz_argv[2] = plugin_path;
+        char *ppsz_argv[] =
+        {
+            "vlc",
+            "-vvvv",
+            "--plugin-path",
+            "/Library/Internet Plug-Ins/VLC Plugin.plugin/"
+            "Contents/MacOS/modules"
+        };
 
 #elif defined(XP_WIN)
         char *ppsz_argv[] = { NULL, "-vv" };
@@ -328,7 +351,8 @@ NPError NPP_New( NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc,
         char *ppsz_argv[] =
         {
             "vlc"
-            /*, "--plugin-path", "/home/sam/videolan/vlc_MAIN/plugins"*/
+            "-vvvv"
+            /*, "--plugin-path", ""*/
         };
 
 #endif /* XP_MACOSX */
@@ -350,11 +374,6 @@ NPError NPP_New( NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc,
         i_ret = VLC_Init( p_plugin->i_vlc, sizeof(ppsz_argv)/sizeof(char*),
                           ppsz_argv );
 
-#ifdef XP_MACOSX
-        free( home_user );
-        free( directory );
-        free( plugin_path );
-#endif /* XP_MACOSX */
     }
 
     if( i_ret )
@@ -519,8 +538,7 @@ NPError NPP_SetWindow( NPP instance, NPWindow* window )
     vlc_value_t valuer;
     vlc_value_t valueportx;
     vlc_value_t valueporty;
-    Rect black_rect;
-    char * text;
+    vlc_value_t valueredraw;
 #endif /* XP_MACOSX */
 
     if( instance == NULL )
@@ -562,29 +580,14 @@ NPError NPP_SetWindow( NPP instance, NPWindow* window )
 
     p_plugin->window = window;
 
-    /* draw the beautiful "No Picture" */
-
-    black_rect.top = valuet.i_int - valuey.i_int;
-    black_rect.left = valuel.i_int - valuex.i_int;
-    black_rect.bottom = valueb.i_int - valuey.i_int;
-    black_rect.right = valuer.i_int - valuex.i_int;
-
-    SetPort( (GrafPtr)value.i_int );
-    SetOrigin( valueportx.i_int , valueporty.i_int );
-    ForeColor(blackColor);
-    PenMode( patCopy );
-    PaintRect( &black_rect );
-
-    ForeColor(whiteColor);
-    text = strdup( WINDOW_TEXT );
-    MoveTo( valuew.i_int / 2 - 40 , valueh.i_int / 2 );
-    DrawText( text , 0 , strlen(text) );
-    free(text);
+    valueredraw.i_int = 1;
+    VLC_VariableSet( p_plugin->i_vlc, "drawableredraw", valueredraw );
 
 #else /* XP_MACOSX */
     /* FIXME: this cast sucks */
     value.i_int = (int) (ptrdiff_t) (void *) window->window;
     VLC_VariableSet( p_plugin->i_vlc, "drawable", value );
+
 #endif /* XP_MACOSX */
 
 #endif /* USE_LIBVLC */