* ./mozilla/*: added hooks so that the vlc plugin is scriptable from

    javascript. It's also in C++, but we didn't have the choice.

configure.in

@@ -2028,9 +2028,9 @@ then
       LDFLAGS="${save_LDFLAGS}"
     fi
     MOZILLA=1
-    mozilla_CFLAGS="${mozilla_CFLAGS} `${MOZILLA_CONFIG} --cflags plugin java --defines | xargs`"
     dnl Workaround for http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=150490
-    mozilla_LDFLAGS="${mozilla_LDFLAGS} `${MOZILLA_CONFIG} --libs | sed 's#-I\(.*\)/mozilla/\([^ ]*\)#-I\1/\2 -I\1/mozilla/\2#g'`"
+    [mozilla_CFLAGS="${CPPFLAGS_mozilla} `${MOZILLA_CONFIG} --cflags plugin xpcom java | sed 's,-I\([^ ]*\)/mozilla/\([^ ]*\),-I\1/\2 -I\1/mozilla/\2,g' | xargs`"]
+    mozilla_LDFLAGS="${mozilla_LDFLAGS} `${MOZILLA_CONFIG} --libs plugin xpcom`"
   fi
 fi
 

mozilla/.cvsignore

+vlcintf.h
+vlcintf.xpt

mozilla/Makefile

@@ -6,10 +6,13 @@
 #
 # Source objects
 #
-C_SRC = vlcplugin.c npunix.c
+CPP_SRC = vlcplugin.cpp vlcpeer.cpp vlcshell.cpp
+C_SRC = npunix.c
+CPP_OBJ = $(CPP_SRC:%.cpp=%.o)
 C_OBJ = $(C_SRC:%.c=%.o)
 
 PLUGIN_OBJ = libvlcplugin.so
+COMPONENT = vlcintf.xpt
 
 #
 # Virtual targets
@@ -25,20 +28,35 @@ clean:
 install:
 	mkdir -p $(DESTDIR)$(libdir)/mozilla/plugins
 	$(INSTALL) -m 644 $(PLUGIN_OBJ) $(DESTDIR)$(libdir)/mozilla/plugins
+	mkdir -p $(DESTDIR)$(libdir)/mozilla/components
+	$(INSTALL) -m 644 $(COMPONENT) $(DESTDIR)$(libdir)/mozilla/components
 
 uninstall:
 	rm -f $(DESTDIR)$(libdir)/mozilla/plugins/$(PLUGIN_OBJ)
 	-rmdir $(DESTDIR)$(libdir)/mozilla/plugins
+	rm -f $(DESTDIR)$(libdir)/mozilla/components/$(COMPONENT)
+	-rmdir $(DESTDIR)$(libdir)/mozilla/components
 	-rmdir $(DESTDIR)$(libdir)/mozilla
 
 FORCE:
 
-$(PLUGIN_OBJ): Makefile ../lib/libvlc.a $(BUILTIN_OBJ:%=../%) $(C_OBJ)
-	$(CC) -shared $(LDFLAGS) -L../lib $(mozilla_LDFLAGS) $(C_OBJ) -lvlc $(BUILTIN_OBJ:%=../%) $(builtins_LDFLAGS) -o $@
+$(PLUGIN_OBJ): Makefile ../lib/libvlc.a $(BUILTIN_OBJ:%=../%) $(C_OBJ) $(CPP_OBJ) $(COMPONENT)
+	$(CC) -shared $(LDFLAGS) -L../lib $(mozilla_LDFLAGS) $(C_OBJ) $(CPP_OBJ) -lvlc $(BUILTIN_OBJ:%=../%) $(builtins_LDFLAGS) -o $@
 
-$(C_OBJ): %.o: %.c vlcplugin.h
+$(CPP_OBJ): %.o: %.cpp vlcplugin.h vlcpeer.h vlcintf.h classinfo.h
 	$(CC) $(CFLAGS) -I.. -I../include $(mozilla_CFLAGS) -c $< -o $@
 
+$(C_OBJ): %.o: %.c vlcplugin.h vlcpeer.h vlcintf.h classinfo.h
+	$(CC) $(CFLAGS) -I.. -I../include $(mozilla_CFLAGS) -c $< -o $@
+
+vlcintf.xpt: vlcintf.idl
+	/usr/lib/mozilla/xpidl -I/usr/share/idl/mozilla -m typelib \
+		-o vlcintf vlcintf.idl
+
+vlcintf.h: vlcintf.idl
+	/usr/lib/mozilla/xpidl -I/usr/share/idl/mozilla -m header \
+		-o vlcintf vlcintf.idl
+
 ../%:
 	@cd .. && $(MAKE) $(@:../%=%)
 

mozilla/classinfo.h

+#include "nsIClassInfo.h"
+
+// helper class to implement all necessary nsIClassInfo method stubs
+// and to set flags used by the security system
+class  ClassInfo : public nsIClassInfo
+{
+  // These flags are used by the DOM and security systems to signal that 
+  // JavaScript callers are allowed to call this object's scritable methods.
+  NS_IMETHOD GetFlags(PRUint32 *aFlags)
+    {*aFlags = nsIClassInfo::PLUGIN_OBJECT | nsIClassInfo::DOM_OBJECT;
+     return NS_OK;}
+  NS_IMETHOD GetImplementationLanguage(PRUint32 *aImplementationLanguage)
+    {*aImplementationLanguage = nsIProgrammingLanguage::CPLUSPLUS;
+     return NS_OK;}
+
+  // The rest of the methods can safely return error codes...
+  NS_IMETHOD GetInterfaces(PRUint32 *count, nsIID * **array)
+    {return NS_ERROR_NOT_IMPLEMENTED;}
+  NS_IMETHOD GetHelperForLanguage(PRUint32 language, nsISupports **_retval)
+    {return NS_ERROR_NOT_IMPLEMENTED;}
+  NS_IMETHOD GetContractID(char * *aContractID)
+    {return NS_ERROR_NOT_IMPLEMENTED;}
+  NS_IMETHOD GetClassDescription(char * *aClassDescription)
+    {return NS_ERROR_NOT_IMPLEMENTED;}
+  NS_IMETHOD GetClassID(nsCID * *aClassID)
+    {return NS_ERROR_NOT_IMPLEMENTED;}
+  NS_IMETHOD GetClassIDNoAlloc(nsCID *aClassIDNoAlloc)
+    {return NS_ERROR_NOT_IMPLEMENTED;}
+};
+

mozilla/npunix.c

+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ * Stephen Mak <smak@sun.com>
+ */
+
 /*
  * npunix.c
  *
@@ -70,12 +93,25 @@ NPN_GetValue(NPP instance, NPNVariable variable, void *r_value)
                     instance, variable, r_value);
 }
 
+NPError
+NPN_SetValue(NPP instance, NPPVariable variable, void *value)
+{
+    return CallNPN_SetValueProc(gNetscapeFuncs.setvalue,
+                    instance, variable, value);
+}
+
 NPError
 NPN_GetURL(NPP instance, const char* url, const char* window)
 {
     return CallNPN_GetURLProc(gNetscapeFuncs.geturl, instance, url, window);
 }
 
+NPError
+NPN_GetURLNotify(NPP instance, const char* url, const char* window, void* notifyData)
+{
+    return CallNPN_GetURLNotifyProc(gNetscapeFuncs.geturlnotify, instance, url, window, notifyData);
+}
+
 NPError
 NPN_PostURL(NPP instance, const char* url, const char* window,
          uint32 len, const char* buf, NPBool file)
@@ -84,6 +120,14 @@ NPN_PostURL(NPP instance, const char* url, const char* window,
                     url, window, len, buf, file);
 }
 
+NPError
+NPN_PostURLNotify(NPP instance, const char* url, const char* window, uint32 len,
+                  const char* buf, NPBool file, void* notifyData)
+{
+    return CallNPN_PostURLNotifyProc(gNetscapeFuncs.posturlnotify,
+            instance, url, window, len, buf, file, notifyData);
+}
+
 NPError
 NPN_RequestRead(NPStream* stream, NPByteRange* rangeList)
 {
@@ -157,6 +201,27 @@ jref NPN_GetJavaPeer(NPP instance)
                        instance);
 }
 
+void
+NPN_InvalidateRect(NPP instance, NPRect *invalidRect)
+{
+    CallNPN_InvalidateRectProc(gNetscapeFuncs.invalidaterect, instance,
+        invalidRect);
+}
+
+void
+NPN_InvalidateRegion(NPP instance, NPRegion invalidRegion)
+{
+    CallNPN_InvalidateRegionProc(gNetscapeFuncs.invalidateregion, instance,
+        invalidRegion);
+}
+
+void
+NPN_ForceRedraw(NPP instance)
+{
+    CallNPN_ForceRedrawProc(gNetscapeFuncs.forceredraw, instance);
+}
+
+
 
 /***********************************************************************
  *
@@ -241,6 +306,16 @@ Private_DestroyStream(NPP instance, NPStream* stream, NPError reason)
     return err;
 }
 
+void
+Private_URLNotify(NPP instance, const char* url,
+                NPReason reason, void* notifyData)
+                
+{
+    PLUGINDEBUGSTR("URLNotify");
+    NPP_URLNotify(instance, url, reason, notifyData);
+}
+
+
 
 void
 Private_Print(NPP instance, NPPrint* platformPrint)
@@ -249,6 +324,13 @@ Private_Print(NPP instance, NPPrint* platformPrint)
     NPP_Print(instance, platformPrint);
 }
 
+NPError
+Private_GetValue(NPP instance, NPPVariable variable, void *r_value)
+{
+    PLUGINDEBUGSTR("GetValue");
+return NPP_GetValue(instance, variable, r_value);
+}
+
 JRIGlobalRef
 Private_GetJavaClass(void)
 {
@@ -285,7 +367,7 @@ NP_GetMIMEDescription(void)
  *    that the navigator needs.
  */
 NPError
-NP_GetValue(void *future, NPPVariable variable, void *value)
+NP_GetValue(NPP future, NPPVariable variable, void *value)
 {
     return NPP_GetValue(future, variable, value);
 }
@@ -350,6 +432,7 @@ NP_Initialize(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs)
         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;
@@ -381,8 +464,10 @@ NP_Initialize(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs)
         pluginFuncs->writeready = NewNPP_WriteReadyProc(Private_WriteReady);
         pluginFuncs->write      = NewNPP_WriteProc(Private_Write);
         pluginFuncs->print      = NewNPP_PrintProc(Private_Print);
+        pluginFuncs->urlnotify  = NewNPP_URLNotifyProc(Private_URLNotify);
         pluginFuncs->event      = NULL;
         pluginFuncs->javaClass  = Private_GetJavaClass();
+        pluginFuncs->getvalue   = NewNPP_GetValueProc(Private_GetValue);
         
         err = NPP_Initialize();
     }

mozilla/vlcintf.idl

+
+#include "nsISupports.idl"
+
+[scriptable, uuid(ea92ef52-afe4-4212-bacb-dfe9fca94cd6)]
+
+interface VlcIntf : nsISupports
+{
+    void play();
+    void pause();
+    void stop();
+};
+

mozilla/vlcpeer.cpp

+/*****************************************************************************
+ * vlcpeer.cpp: a VideoLAN Client plugin for Mozilla
+ *****************************************************************************
+ * Copyright (C) 2002 VideoLAN
+ * $Id: vlcpeer.cpp,v 1.1 2002/09/17 08:18:24 sam Exp $
+ *
+ * Authors: Samuel Hocevar <sam@zoy.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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+#include <vlc/vlc.h>
+
+#include "npapi.h"
+#include "vlcpeer.h"
+#include "vlcplugin.h"
+
+#include "nsMemory.h"
+
+
+NS_IMPL_ISUPPORTS2( VlcPeer, VlcIntf, nsIClassInfo )
+
+VlcPeer::VlcPeer()
+{
+    NS_INIT_ISUPPORTS();
+}
+
+VlcPeer::VlcPeer( VlcPlugin * plugin )
+{
+    NS_INIT_ISUPPORTS();
+    p_plugin = plugin;
+}
+
+VlcPeer::~VlcPeer()
+{
+    ;
+}
+
+NS_IMETHODIMP VlcPeer::Play()
+{
+    if( p_plugin )
+    {
+        p_plugin->Play();
+    }
+    return NS_OK;
+}
+
+NS_IMETHODIMP VlcPeer::Pause()
+{
+    if( p_plugin )
+    {
+        p_plugin->Pause();
+    }
+    return NS_OK;
+}
+
+NS_IMETHODIMP VlcPeer::Stop()
+{
+    if( p_plugin )
+    {
+        p_plugin->Stop();
+    }
+    return NS_OK;
+}
+

mozilla/vlcpeer.h

+/*****************************************************************************
+ * vlcpeer.h: a VideoLAN plugin for Mozilla
+ *****************************************************************************
+ * Copyright (C) 2002 VideoLAN
+ * $Id: vlcpeer.h,v 1.1 2002/09/17 08:18:24 sam Exp $
+ *
+ * Authors: Samuel Hocevar <sam@zoy.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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include "vlcintf.h"
+#include "classinfo.h"
+
+#include "nsMemory.h"
+
+class VlcPlugin;
+
+class VlcPeer : public VlcIntf, public ClassInfo
+{
+public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_VLCINTF
+
+    VlcPeer();
+    VlcPeer( VlcPlugin * );
+
+    void Disable() { p_plugin = NULL; }
+          
+    virtual ~VlcPeer();
+    /* additional members */
+
+private:
+    VlcPlugin * p_plugin;
+};
+

mozilla/vlcplugin.cpp

+/*****************************************************************************
+ * vlcplugin.cpp: a VideoLAN Client plugin for Mozilla
+ *****************************************************************************
+ * Copyright (C) 2002 VideoLAN
+ * $Id: vlcplugin.cpp,v 1.1 2002/09/17 08:18:24 sam Exp $
+ *
+ * Authors: Samuel Hocevar <sam@zoy.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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+#include <npapi.h>
+
+#include <vlc/vlc.h>
+
+#include "vlcpeer.h"
+#include "vlcplugin.h"
+
+/*****************************************************************************
+ * VlcPlugin methods
+ *****************************************************************************/
+VlcPlugin::VlcPlugin( NPP instance )
+{
+    p_instance = instance; 
+    p_peer = NULL;
+}
+
+
+VlcPlugin::~VlcPlugin()
+{
+    if( p_peer )
+    {
+        p_peer->Disable();
+        p_peer->Release();
+    }
+}
+
+
+void VlcPlugin::SetInstance( NPP instance )
+{
+    p_instance = instance;
+}
+
+
+NPP VlcPlugin::GetInstance()
+{
+    return p_instance;
+}
+
+
+void VlcPlugin::SetFileName(const char * filename)
+{
+fprintf(stderr, "VlcPlugin::SetFilename %s\n", 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; 
+}
+
+void VlcPlugin::Play()
+{
+fprintf(stderr, "VlcPlugin::Play\n");
+}
+
+void VlcPlugin::Pause()
+{
+fprintf(stderr, "VlcPlugin::Pause\n");
+}
+
+void VlcPlugin::Stop()
+{
+fprintf(stderr, "VlcPlugin::Stop\n");
+}
+
+VlcIntf* VlcPlugin::getScriptable()
+{
+    if( !p_peer )
+    {
+        p_peer = new VlcPeer( this );
+        if( p_peer == NULL ) 
+        {
+            return NULL;
+        }
+        
+        NS_ADDREF( p_peer );
+    }
+    // a getter should addref for its caller.
+    NS_ADDREF( p_peer );
+    return p_peer;
+}
+

mozilla/vlcplugin.h

 /*****************************************************************************
- * videolan.c: a VideoLAN plugin for Mozilla
+ * vlcplugin.h: a VideoLAN plugin for Mozilla
  *****************************************************************************
  * Copyright (C) 2002 VideoLAN
- * $Id: vlcplugin.h,v 1.2 2002/07/23 20:12:55 sam Exp $
+ * $Id: vlcplugin.h,v 1.3 2002/09/17 08:18:24 sam Exp $
  *
  * Authors: Samuel Hocevar <sam@zoy.org>
  *
@@ -24,8 +24,23 @@
 /*******************************************************************************
  * Instance state information about the plugin.
  ******************************************************************************/
-typedef struct _PluginInstance
+class VlcPlugin
 {
+public:
+             VlcPlugin( NPP ); 
+    virtual ~VlcPlugin();
+
+    void     SetInstance( NPP );
+    NPP      GetInstance();
+
+    void     SetFileName( const char* );
+    void     Play();
+    void     Pause();
+    void     Stop();
+
+    VlcIntf* getScriptable();
+
+    /* Window settings */
     NPWindow* fWindow;
     uint16 fMode;
 
@@ -36,11 +51,14 @@ typedef struct _PluginInstance
     uint32 width, height;
 
     /* vlc data members */
-    vlc_t *p_vlc;
+    vlc_t *  p_vlc;
     int      b_stream;
-    char *psz_target;
+    char *   psz_target;
 
-} PluginInstance;
+private:
+    NPP      p_instance;
+    VlcPeer* p_peer;
+};
 
 /*******************************************************************************
  * Plugin properties.
@@ -49,7 +67,7 @@ typedef struct _PluginInstance
 #define PLUGIN_DESCRIPTION \
     "VideoLAN Client Multimedia Player Plugin <br>" \
     " <br>" \
-    COPYRIGHT_MESSAGE " <br>" \
+    /*COPYRIGHT_MESSAGE*/ " <br>" \
     "VideoLAN WWW: <a href=\"http://www.videolan.org/\">http://www.videolan.org/</a>"
 
 #define PLUGIN_MIMETYPES \

mozilla/vlcplugin.c → mozilla/vlcshell.cpp

 /*****************************************************************************
- * vlcplugin.c: a VideoLAN Client plugin for Mozilla
+ * vlcshell.c: a VideoLAN Client plugin for Mozilla
  *****************************************************************************
  * Copyright (C) 2002 VideoLAN
- * $Id: vlcplugin.c,v 1.5 2002/08/20 18:08:51 sam Exp $
+ * $Id: vlcshell.cpp,v 1.1 2002/09/17 08:18:24 sam Exp $
  *
  * Authors: Samuel Hocevar <sam@zoy.org>
  *
@@ -37,59 +37,119 @@
 
 /* vlc stuff */
 #include <vlc/vlc.h>
+#include "config.h"
 
+#include "vlcpeer.h"
 #include "vlcplugin.h"
 
-/*******************************************************************************
+/******************************************************************************
  * Unix-only declarations
  ******************************************************************************/
+#ifndef WIN32
 static void Redraw( Widget w, XtPointer closure, XEvent *event );
+#endif
+
+/******************************************************************************
+ * Windows-only declarations
+ *****************************************************************************/
+#ifdef WIN32
+HINSTANCE g_hDllInstance = NULL;
 
-/*******************************************************************************
+BOOL WINAPI
+DllMain( HINSTANCE  hinstDLL,                   // handle of DLL module
+                    DWORD  fdwReason,       // reason for calling function
+                    LPVOID  lpvReserved)
+{
+        switch (fdwReason) {
+                case DLL_PROCESS_ATTACH:
+                  g_hDllInstance = hinstDLL;
+                  break;
+                case DLL_THREAD_ATTACH:
+                case DLL_PROCESS_DETACH:
+                case DLL_THREAD_DETACH:
+                break;
+        }
+        return TRUE;
+}
+#endif
+
+/******************************************************************************
  * UNIX-only API calls
- ******************************************************************************/
-char* NPP_GetMIMEDescription( void )
+ *****************************************************************************/
+char * NPP_GetMIMEDescription( void )
 {
-    return( PLUGIN_MIMETYPES );
+    return PLUGIN_MIMETYPES;
 }
 
-NPError NPP_GetValue(NPP instance, NPPVariable variable, void *value)
+NPError NPP_GetValue( NPP instance, NPPVariable variable, void *value )
 {
-    NPError err = NPERR_NO_ERROR;
-    if (variable == NPPVpluginNameString)
+    static nsIID nsid = VLCINTF_IID;
+
+    switch( variable )
+    {
+        case NPPVpluginNameString:
             *((char **)value) = PLUGIN_NAME;
-    else if (variable == NPPVpluginDescriptionString)
+            return NPERR_NO_ERROR;
+
+        case NPPVpluginDescriptionString:
             *((char **)value) = PLUGIN_DESCRIPTION;
-    else
-        err = NPERR_GENERIC_ERROR;
+            return NPERR_NO_ERROR;
+    }
 
-    return err;
+    if( instance == NULL )
+    {
+        return NPERR_INVALID_INSTANCE_ERROR;
+    }
+
+    VlcPlugin* p_plugin = (VlcPlugin*) instance->pdata;
+
+    switch( variable )
+    {
+        case NPPVpluginScriptableInstance:
+            *(nsISupports**)value = p_plugin->getScriptable();
+            if( *(nsISupports**)value == NULL )
+            {
+                return NPERR_OUT_OF_MEMORY_ERROR;
+            }
+            break;
+
+        case NPPVpluginScriptableIID:
+            *(nsIID**)value = (nsIID*)NPN_MemAlloc( sizeof(nsIID) );
+            if( *(nsIID**)value == NULL )
+            {
+                return NPERR_OUT_OF_MEMORY_ERROR;
+            }
+            **(nsIID**)value = nsid;
+            break;
+
+        default:
+            return NPERR_GENERIC_ERROR;
+    }
+
+    return NPERR_NO_ERROR;
 }
 
-/*******************************************************************************
+/******************************************************************************
  * General Plug-in Calls
- ******************************************************************************/
+ *****************************************************************************/
 NPError NPP_Initialize( void )
 {
-    fprintf(stderr, "NPP_Initialize\n");
     return NPERR_NO_ERROR;
 }
 
 jref NPP_GetJavaClass( void )
 {
-    return NULL;		/* Java disabled */
+    return NULL;
 }
 
 void NPP_Shutdown( void )
 {
-    /* Java disabled */
+    ;
 }
 
 NPError NPP_New( NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc,
                  char* argn[], char* argv[], NPSavedData* saved )
 {
-    NPError result = NPERR_NO_ERROR;
-    PluginInstance* This;
     int i_ret;
     int i;
 
@@ -98,122 +158,130 @@ NPError NPP_New( NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc,
         "vlc"
         /*, "--plugin-path", "/home/sam/videolan/vlc_MAIN/plugins"*/
         , "--vout", "xvideo,x11,dummy"
+        /*, "--aout", "none"*/
         , "--intf", "dummy"
-        , "--noaudio"
+        /*, "--noaudio"*/
+        , "-q"
         /*, "-v"*/
     };
 
-    fprintf(stderr, "NPP_New\n");
-
-    if (instance == NULL)
+    if( instance == NULL )
+    {
         return NPERR_INVALID_INSTANCE_ERROR;
+    }
 
-    instance->pdata = NPN_MemAlloc(sizeof(PluginInstance));
-    
-    This = (PluginInstance*) instance->pdata;
+    VlcPlugin * p_plugin = new VlcPlugin( instance );
 
-    if (This == NULL)
+    if( p_plugin == NULL )
+    {
         return NPERR_OUT_OF_MEMORY_ERROR;
+    }
 
-    {
-        /* mode is NP_EMBED, NP_FULL, or NP_BACKGROUND (see npapi.h) */
-        This->fMode = mode;
-        This->fWindow = NULL;
+    instance->pdata = p_plugin;
 
-        This->window = 0;
-    }
+    p_plugin->fMode = mode;
+    p_plugin->fWindow = NULL;
+    p_plugin->window = 0;
 
-    This->p_vlc = vlc_create_r();
-    if( This->p_vlc == NULL )
+    p_plugin->p_vlc = vlc_create_r();
+    if( p_plugin->p_vlc == NULL )
     {
+        delete p_plugin;
+        p_plugin = NULL;
         return NPERR_GENERIC_ERROR;
     }
 
-    i_ret = vlc_init_r( This->p_vlc, sizeof(ppsz_foo)/sizeof(char*), ppsz_foo );
+    i_ret = vlc_init_r( p_plugin->p_vlc, sizeof(ppsz_foo)/sizeof(char*), ppsz_foo );
     if( i_ret )
     {
-        vlc_destroy_r( This->p_vlc );
-        This->p_vlc = NULL;
+        vlc_destroy_r( p_plugin->p_vlc );
+        p_plugin->p_vlc = NULL;
+        delete p_plugin;
+        p_plugin = NULL;
         return NPERR_GENERIC_ERROR;
     }
 
-    vlc_set_r( This->p_vlc, "vout", "xvideo,x11,dummy" );
-    vlc_set_r( This->p_vlc, "intf", "dummy" );
-    vlc_set_r( This->p_vlc, "audio", 0 );
+    vlc_set_r( p_plugin->p_vlc, "vout", "xvideo,x11,dummy" );
+    vlc_set_r( p_plugin->p_vlc, "intf", "dummy" );
+    vlc_set_r( p_plugin->p_vlc, "audio", "0" );
 
-    i_ret = vlc_run_r( This->p_vlc );
+    i_ret = vlc_run_r( p_plugin->p_vlc );
     if( i_ret )
     {
-        vlc_destroy_r( This->p_vlc );
-        This->p_vlc = NULL;
+        vlc_destroy_r( p_plugin->p_vlc );
+        p_plugin->p_vlc = NULL;
+        delete p_plugin;
+        p_plugin = NULL;
         return NPERR_GENERIC_ERROR;
     }
 
-    This->b_stream = 0;
-    This->psz_target = NULL;
+    p_plugin->b_stream = 0;
+    p_plugin->psz_target = NULL;
 
     for( i = 0; i < argc ; i++ )
     {
         fprintf(stderr, "arg %i: '%s' = '%s'\n", i, argn[i], argv[i]);
-        if(!strcmp(argn[i],"target"))
+        if( !strcmp(argn[i],"target") )
         {
             fprintf(stderr, "target specified: %s\n", argv[i]);
-            This->psz_target = strdup( argv[i] );
+            p_plugin->psz_target = strdup( argv[i] );
         }
         else
         {
-            /*vlc_set_r( This->psz_target, argn[i], argv[i] );*/
+            /*vlc_set_r( p_plugin->psz_target, argn[i], argv[i] );*/
         }
     }
 
-    return result;
+    return NPERR_NO_ERROR;
 }
 
 NPError NPP_Destroy( NPP instance, NPSavedData** save )
 {
-    PluginInstance* This;
-
-    fprintf(stderr, "NPP_Destroy\n");
-
-    if (instance == NULL)
+    if( instance == NULL )
+    {
         return NPERR_INVALID_INSTANCE_ERROR;
+    }
 
-    This = (PluginInstance*) instance->pdata;
+    VlcPlugin* p_plugin = (VlcPlugin*)instance->pdata;
 
-    if( This->p_vlc != NULL )
+    if( p_plugin != NULL )
+    {
+        if( p_plugin->p_vlc != NULL )
         {
-        vlc_destroy_r( This->p_vlc );
-        This->p_vlc = NULL;
+            vlc_destroy_r( p_plugin->p_vlc );
+            p_plugin->p_vlc = NULL;
         }
 
-    if( This->psz_target )
+        if( p_plugin->psz_target )
         {
-        free( This->psz_target );
-        This->psz_target = NULL;
+            free( p_plugin->psz_target );
+            p_plugin->psz_target = NULL;
         }
 
-    if (This != NULL) {
-        NPN_MemFree(instance->pdata);
-        instance->pdata = NULL;
+        delete p_plugin;
     }
 
+    instance->pdata = NULL;
+
     return NPERR_NO_ERROR;
 }
 
 NPError NPP_SetWindow( NPP instance, NPWindow* window )
 {
-    NPError result = NPERR_NO_ERROR;
-    PluginInstance* This;
-
-    fprintf(stderr, "NPP_SetWindow\n");
+    char psz_window[32];
 
-    if (instance == NULL)
+    if( instance == NULL )
+    {
         return NPERR_INVALID_INSTANCE_ERROR;
+    }
+
+    VlcPlugin* p_plugin = (VlcPlugin*)instance->pdata;
 
-    This = (PluginInstance*) instance->pdata;
+    /* Write the window ID for vlc */
+    sprintf( psz_window, "%li", (long int)window->window );
+    vlc_set_r( p_plugin->p_vlc, "x11-drawable", psz_window );
+    vlc_set_r( p_plugin->p_vlc, "xvideo-drawable", psz_window );
 
-    vlc_set_r( This->p_vlc, "x11-drawable", window->window );
-    vlc_set_r( This->p_vlc, "xvideo-drawable", window->window );
     /*
      * PLUGIN DEVELOPERS:
      *  Before setting window to point to the
@@ -222,78 +290,64 @@ NPError NPP_SetWindow( NPP instance, NPWindow* window )
      *  size changes, etc.
      */
 
-    {
     Widget netscape_widget;
 
-        This->window = (Window) window->window;
-        This->x = window->x;
-        This->y = window->y;
-        This->width = window->width;
-        This->height = window->height;
-        This->display = ((NPSetWindowCallbackStruct *)window->ws_info)->display;
+    p_plugin->window = (Window) window->window;
+    p_plugin->x = window->x;
+    p_plugin->y = window->y;
+    p_plugin->width = window->width;
+    p_plugin->height = window->height;
+    p_plugin->display = ((NPSetWindowCallbackStruct *)window->ws_info)->display;
 
-        netscape_widget = XtWindowToWidget(This->display, This->window);
-        XtAddEventHandler(netscape_widget, ExposureMask, FALSE, (XtEventHandler)Redraw, This);
-        Redraw(netscape_widget, (XtPointer)This, NULL);
-    }
+    netscape_widget = XtWindowToWidget(p_plugin->display, p_plugin->window);
+    XtAddEventHandler(netscape_widget, ExposureMask, FALSE, (XtEventHandler)Redraw, p_plugin);
+    Redraw(netscape_widget, (XtPointer)p_plugin, NULL);
 
-    This->fWindow = window;
+    p_plugin->fWindow = window;
 
 #if 1
-    if( !This->b_stream )
+    if( !p_plugin->b_stream )
     {
-        This->b_stream = 1;
-        if( This->psz_target )
+        p_plugin->b_stream = 1;
+        if( p_plugin->psz_target )
         {
-            vlc_add_target_r( This->p_vlc, This->psz_target, PLAYLIST_APPEND, PLAYLIST_END );
-                    /* We loop, dude */
-            vlc_add_target_r( This->p_vlc, "vlc:loop", PLAYLIST_APPEND, PLAYLIST_END );
+            vlc_add_target_r( p_plugin->p_vlc, p_plugin->psz_target,
+                              PLAYLIST_APPEND, PLAYLIST_END );
+            vlc_add_target_r( p_plugin->p_vlc, "vlc:loop",
+                              PLAYLIST_APPEND, PLAYLIST_END );
         }
     }
 #endif
 
-    return result;
+    return NPERR_NO_ERROR;
 }
 
-
 NPError NPP_NewStream( NPP instance, NPMIMEType type, NPStream *stream,
                        NPBool seekable, uint16 *stype )
 {
-    PluginInstance* This;
-
-    fprintf(stderr, "NPP_NewStream - FILE mode !!\n");
-
-    if (instance == NULL)
+    if( instance == NULL )
+    {
         return NPERR_INVALID_INSTANCE_ERROR;
+    }
 
-    This = (PluginInstance*) instance->pdata;
+    VlcPlugin* p_plugin = (VlcPlugin*)instance->pdata;
+
+    fprintf(stderr, "NPP_NewStream - FILE mode !!\n");
 
     /* We want a *filename* ! */
     *stype = NP_ASFILE;
 
 #if 0
-    if( This->b_stream == 0 )
+    if( p_plugin->b_stream == 0 )
     {
-        This->psz_target = strdup( stream->url );
-        This->b_stream = 1;
+        p_plugin->psz_target = strdup( stream->url );
+        p_plugin->b_stream = 1;
     }
 #endif
 
     return NPERR_NO_ERROR;
 }
 
-
-/* PLUGIN DEVELOPERS:
- *	These next 2 functions are directly relevant in a plug-in which
- *	handles the data in a streaming manner. If you want zero bytes
- *	because no buffer space is YET available, return 0. As long as
- *	the stream has not been written to the plugin, Navigator will
- *	continue trying to send bytes.  If the plugin doesn't want them,
- *	just return some large number from NPP_WriteReady(), and
- *	ignore them in NPP_Write().  For a NP_ASFILE stream, they are
- *	still called but can safely be ignored using this strategy.
- */
-
 int32 STREAMBUFSIZE = 0X0FFFFFFF; /* If we are reading from a file in NPAsFile
                    * mode so we can take any size stream in our
                    * write call (since we ignore it) */
@@ -302,13 +356,13 @@ int32 STREAMBUFSIZE = 0X0FFFFFFF; /* If we are reading from a file in NPAsFile
 
 int32 NPP_WriteReady( NPP instance, NPStream *stream )
 {
-    PluginInstance* This;
+    VlcPlugin* p_plugin;
 
     fprintf(stderr, "NPP_WriteReady\n");
 
     if (instance != NULL)
     {
-        This = (PluginInstance*) instance->pdata;
+        p_plugin = (VlcPlugin*) instance->pdata;
         /* Muahahahahahahaha */
         return STREAMBUFSIZE;
         /*return SARASS_SIZE;*/
@@ -327,7 +381,7 @@ int32 NPP_Write( NPP instance, NPStream *stream, int32 offset,
 
     if (instance != NULL)
     {
-        /*PluginInstance* This = (PluginInstance*) instance->pdata;*/
+        /*VlcPlugin* p_plugin = (VlcPlugin*) instance->pdata;*/
     }
 
     return len;         /* The number of bytes accepted */
@@ -336,12 +390,12 @@ int32 NPP_Write( NPP instance, NPStream *stream, int32 offset,
 
 NPError NPP_DestroyStream( NPP instance, NPStream *stream, NPError reason )
 {
-    PluginInstance* This;
-    fprintf(stderr, "NPP_DestroyStream\n");
-
-    if (instance == NULL)
+    if( instance == NULL )
+    {
         return NPERR_INVALID_INSTANCE_ERROR;
-    This = (PluginInstance*) instance->pdata;
+    }
+
+    VlcPlugin* p_plugin = (VlcPlugin*) instance->pdata;
 
     return NPERR_NO_ERROR;
 }
@@ -349,27 +403,50 @@ NPError NPP_DestroyStream( NPP instance, NPStream *stream, NPError reason )
 
 void NPP_StreamAsFile( NPP instance, NPStream *stream, const char* fname )
 {
-    PluginInstance* This;
-    fprintf(stderr, "NPP_StreamAsFile\n");
-    if (instance != NULL)
+    if( instance == NULL )
     {
-        This = (PluginInstance*) instance->pdata;
-        vlc_add_target_r( This->p_vlc, fname, PLAYLIST_APPEND, PLAYLIST_END );
-                /* We loop, dude */
-        vlc_add_target_r( This->p_vlc, "vlc:loop", PLAYLIST_APPEND, PLAYLIST_END );
+        return;
     }
+
+    VlcPlugin* p_plugin = (VlcPlugin*)instance->pdata;
+
+    fprintf(stderr, "NPP_StreamAsFile\n");
+    vlc_add_target_r( p_plugin->p_vlc, fname, PLAYLIST_APPEND, PLAYLIST_END );
+    vlc_add_target_r( p_plugin->p_vlc, "vlc:loop", 
+                      PLAYLIST_APPEND, PLAYLIST_END );
 }
 
+#if 0
+void NPP_StreamAsFile( NPP instance, NPStream *stream, const char* fname )
+{
+    fprintf(stderr,"filename : %s\n", fname);
+    ((VlcPlugin*) instance->pdata)->SetFileName(fname);
 
-void NPP_Print( NPP instance, NPPrint* printInfo )
+    fprintf(stderr,"SetFileNeme ok. \n");
+}
+#endif
+
+
+void NPP_URLNotify( NPP instance, const char* url,
+                    NPReason reason, void* notifyData )
 {
-    fprintf(stderr, "NPP_Print\n");
+    /***** Insert NPP_URLNotify code here *****\
+    PluginInstance* p_plugin;
+    if (instance != NULL)
+        p_plugin = (PluginInstance*) instance->pdata;
+    \*********************************************/
+}
+
 
+void NPP_Print( NPP instance, NPPrint* printInfo )
+{
     if(printInfo == NULL)
         return;
 
     if (instance != NULL) {
-        PluginInstance* This = (PluginInstance*) instance->pdata;
+    /***** Insert NPP_Print code here *****\
+        PluginInstance* p_plugin = (PluginInstance*) instance->pdata;
+    \**************************************/
 
         if (printInfo->mode == NP_FULL) {
             /*
@@ -389,10 +466,12 @@ void NPP_Print( NPP instance, NPPrint* printInfo )
              *  etc.
              */
 
+    /***** Insert NPP_Print code here *****\
             void* platformPrint =
                 printInfo->print.fullPrint.platformPrint;
             NPBool printOne =
                 printInfo->print.fullPrint.printOne;
+    \**************************************/
 
             /* Do the default*/
             printInfo->print.fullPrint.pluginPrinted = FALSE;
@@ -410,56 +489,37 @@ void NPP_Print( NPP instance, NPPrint* printInfo )
              *  device context.
              */
 
+    /***** Insert NPP_Print code here *****\
             NPWindow* printWindow =
                 &(printInfo->print.embedPrint.window);
             void* platformPrint =
                 printInfo->print.embedPrint.platformPrint;
+    \**************************************/
         }
     }
 }
 
-/*******************************************************************************
-// NPP_URLNotify:
-// Notifies the instance of the completion of a URL request. 
-// 
-// NPP_URLNotify is called when Netscape completes a NPN_GetURLNotify or
-// NPN_PostURLNotify request, to inform the plug-in that the request,
-// identified by url, has completed for the reason specified by reason. The most
-// common reason code is NPRES_DONE, indicating simply that the request
-// completed normally. Other possible reason codes are NPRES_USER_BREAK,
-// indicating that the request was halted due to a user action (for example,
-// clicking the "Stop" button), and NPRES_NETWORK_ERR, indicating that the
-// request could not be completed (for example, because the URL could not be
-// found). The complete list of reason codes is found in npapi.h. 
-// 
-// The parameter notifyData is the same plug-in-private value passed as an
-// argument to the corresponding NPN_GetURLNotify or NPN_PostURLNotify
-// call, and can be used by your plug-in to uniquely identify the request. 
- ******************************************************************************/
-void NPP_URLNotify( NPP instance, const char* url, NPReason reason,
-                    void* notifyData )
-{
-}
-
-/*******************************************************************************
+/******************************************************************************
  * UNIX-only methods
- ******************************************************************************/
+ *****************************************************************************/
+#ifndef WIN32
 static void Redraw( Widget w, XtPointer closure, XEvent *event )
 {
-    PluginInstance* This = (PluginInstance*)closure;
+    VlcPlugin* p_plugin = (VlcPlugin*)closure;
     GC gc;
     XGCValues gcv;
     const char* text = "hello d00dZ, I'm in void Redraw()";
 
     XtVaGetValues(w, XtNbackground, &gcv.background,
                   XtNforeground, &gcv.foreground, 0);
-    gc = XCreateGC(This->display, This->window, 
+    gc = XCreateGC(p_plugin->display, p_plugin->window,
                    GCForeground|GCBackground, &gcv);
-    XDrawRectangle(This->display, This->window, gc, 
-                   0, 0, This->width-1, This->height-1);
-    XDrawString(This->display, This->window, gc, 
-                This->width/2 - 100, This->height/2,
+    XDrawRectangle(p_plugin->display, p_plugin->window, gc,
+                   0, 0, p_plugin->width-1, p_plugin->height-1);
+    XDrawString(p_plugin->display, p_plugin->window, gc,
+                p_plugin->width/2 - 100, p_plugin->height/2,
                 text, strlen(text));
     return;
 }
+#endif