- the resurected mozilla plugin for Safari/Firefox on MacOS X
authorDamien Fouilleul <damienf@videolan.org>
Sat, 15 Apr 2006 11:51:45 +0000 (11:51 +0000)
committerDamien Fouilleul <damienf@videolan.org>
Sat, 15 Apr 2006 11:51:45 +0000 (11:51 +0000)
12 files changed:
extras/MacOSX/plugin/English.lproj/InfoPlist.strings
extras/MacOSX/plugin/Info.plist
modules/gui/macosx/voutqt.m
mozilla/Makefile.am
mozilla/support/npmac.cpp
mozilla/vlc.r
mozilla/vlcpeer.h
mozilla/vlcplugin.cpp
mozilla/vlcplugin.h
mozilla/vlcruntime.cpp [new file with mode: 0755]
mozilla/vlcruntime.h [new file with mode: 0755]
mozilla/vlcshell.cpp

index 54d2f49..b587908 100644 (file)
Binary files a/extras/MacOSX/plugin/English.lproj/InfoPlist.strings and b/extras/MacOSX/plugin/English.lproj/InfoPlist.strings differ
index 4c6f64d..7093f94 100644 (file)
@@ -6,16 +6,22 @@
        <string>English</string>
        <key>CFBundleExecutable</key>
        <string>VLC Plugin</string>
+       <key>CFBundleGetInfoString</key>
+       <string>Copyright 2002-2006 The VideoLAN Team. All Rights Reserved</string>
        <key>CFBundleIdentifier</key>
        <string>com.netscape.vlc</string>
        <key>CFBundleInfoDictionaryVersion</key>
        <string>6.0</string>
+       <key>CFBundleName</key>
+       <string>VideoLAN VLC Plug-in</string>
        <key>CFBundlePackageType</key>
        <string>BRPL</string>
        <key>CFBundleSignature</key>
        <string>MOSS</string>
        <key>CFBundleVersion</key>
        <string>0.12</string>
+       <key>CFBundleShortVersionString</key>
+       <string>0.12</string>
        <key>CSResourcesFileMapped</key>
        <true/>
 </dict>
index 70fd8f8..5f7f175 100644 (file)
@@ -72,10 +72,12 @@ struct vout_sys_t
     DecompressorComponent img_dc;
     ImageDescriptionHandle h_img_descr;
 
+    /* video geometry in port */
+    int i_origx, i_origy;
+    int i_width, i_height;
     /* Mozilla plugin-related variables */
     vlc_bool_t b_embedded;
-    Rect clipping_rect;
-    int portx, porty;
+    RgnHandle clip_mask;
 };
 
 struct picture_sys_t
@@ -98,6 +100,9 @@ static void DisplayVideo        ( vout_thread_t *, picture_t * );
 static int  ControlVideo        ( vout_thread_t *, int, va_list );
 
 static int CoToggleFullscreen( vout_thread_t *p_vout );
+static int DrawableRedraw( vlc_object_t *p_this, const char *psz_name,
+    vlc_value_t oval, vlc_value_t nval, void *param);
+static void UpdateEmbeddedGeometry( vout_thread_t *p_vout );
 static void QTScaleMatrix       ( vout_thread_t * );
 static int  QTCreateSequence    ( vout_thread_t * );
 static void QTDestroySequence   ( vout_thread_t * );
@@ -201,39 +206,19 @@ int E_(OpenVideoQT) ( vlc_object_t *p_this )
         return VLC_EGENERIC;        
     }
 
-#define o_qtview p_vout->p_sys->o_qtview
-    o_qtview = [[VLCQTView alloc] initWithVout: p_vout];
-    [o_qtview autorelease];
-
-    if( p_vout->p_sys->b_embedded )
-    {
-        /* Zero the clipping rectangle */
-        p_vout->p_sys->clipping_rect.left = 0;
-        p_vout->p_sys->clipping_rect.right = 0;
-        p_vout->p_sys->clipping_rect.top = 0;
-        p_vout->p_sys->clipping_rect.bottom = 0;
-    }
-    else
+    if( p_vout->b_fullscreen || !p_vout->p_sys->b_embedded )
     {
         /* Spawn window */
+#define o_qtview p_vout->p_sys->o_qtview
+        o_qtview = [[VLCQTView alloc] initWithVout: p_vout];
+        [o_qtview autorelease];
+
         p_vout->p_sys->o_vout_view = [VLCVoutView getVoutView: p_vout
                     subView: o_qtview frame: nil];
         if( !p_vout->p_sys->o_vout_view )
         {
             return VLC_EGENERIC;
         }
-    }
-
-    /* Retrieve the QuickDraw port */
-    if( p_vout->p_sys->b_embedded )
-    {
-        /* Don't need (nor want) to lock the focus, since otherwise we crash
-         * (presumably because we don't own the window, but I'm not sure
-         * if this is the exact reason)  -andrep */
-        p_vout->p_sys->p_qdport = [o_qtview qdPort];
-    }
-    else
-    {
         [o_qtview lockFocus];
         p_vout->p_sys->p_qdport = [o_qtview qdPort];
         [o_qtview unlockFocus];
@@ -251,7 +236,7 @@ void E_(CloseVideoQT) ( vlc_object_t *p_this )
     NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
     vout_thread_t * p_vout = (vout_thread_t *)p_this;
 
-    if( !p_vout->p_sys->b_embedded )
+    if( p_vout->b_fullscreen || !p_vout->p_sys->b_embedded )
         [p_vout->p_sys->o_vout_view closeVout];
 
     /* Clean Up Quicktime environment */
@@ -280,17 +265,27 @@ static int InitVideo    ( vout_thread_t *p_vout )
     p_vout->output.i_height = p_vout->render.i_height;
     p_vout->output.i_aspect = p_vout->render.i_aspect;
 
-    /* If we are embedded (e.g. running as a Mozilla plugin), use the pointer
-     * stored in the "drawable" value as the CGrafPtr for the QuickDraw
-     * graphics port */
-    if( p_vout->p_sys->b_embedded )
+    if( p_vout->b_fullscreen || !p_vout->p_sys->b_embedded )
     {
-        vlc_value_t val;
-        var_Get( p_vout->p_vlc, "drawable", &val );
-        p_vout->p_sys->p_qdport = (CGrafPtr) val.i_int;
+       Rect s_rect;
+        p_vout->p_sys->clip_mask = NULL;
+       GetPortBounds( p_vout->p_sys->p_qdport, &s_rect );
+       p_vout->p_sys->i_origx = s_rect.left;
+       p_vout->p_sys->i_origy = s_rect.top;
+       p_vout->p_sys->i_width = s_rect.right - s_rect.left;
+       p_vout->p_sys->i_height = s_rect.bottom - s_rect.top;
+    }
+    else
+    {
+       /* As we are embedded (e.g. running as a Mozilla plugin), use the pointer
+        * stored in the "drawable" value as the CGrafPtr for the QuickDraw
+        * graphics port */
+        /* Create the clipping mask */
+        p_vout->p_sys->clip_mask = NewRgn();
+       UpdateEmbeddedGeometry(p_vout);
+       var_AddCallback(p_vout->p_vlc, "drawableredraw", DrawableRedraw, p_vout);
     }
 
-    SetPort( p_vout->p_sys->p_qdport );
     QTScaleMatrix( p_vout );
 
     if( QTCreateSequence( p_vout ) )
@@ -338,6 +333,12 @@ static void EndVideo( vout_thread_t *p_vout )
 
     QTDestroySequence( p_vout );
 
+    if( !p_vout->b_fullscreen && p_vout->p_sys->b_embedded )
+    {
+       var_DelCallback(p_vout->p_vlc, "drawableredraw", DrawableRedraw, p_vout);
+       DisposeRgn(p_vout->p_sys->clip_mask);
+    }
+
     /* Free the direct buffers we allocated */
     for( i_index = I_OUTPUTPICTURES; i_index; )
     {
@@ -354,9 +355,6 @@ static void EndVideo( vout_thread_t *p_vout )
  *****************************************************************************/
 static int ManageVideo( vout_thread_t *p_vout )
 {
-    vlc_value_t val;
-    var_Get( p_vout->p_vlc, "drawableredraw", &val );
-
     if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE )
     {
         if( CoToggleFullscreen( p_vout ) )  
@@ -367,16 +365,25 @@ static int ManageVideo( vout_thread_t *p_vout )
         p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
     }
 
-    if( p_vout->p_sys->b_embedded && val.i_int == 1 )
+    if( p_vout->i_changes & VOUT_SIZE_CHANGE )
     {
-        /* If we're embedded, the application is expected to indicate a
-         * window change (move/resize/etc) via the "drawableredraw" value.
-         * If that's the case, set the VOUT_SIZE_CHANGE flag so we do
-         * actually handle the window change. */
-        val.i_int = 0;
-        var_Set( p_vout->p_vlc, "drawableredraw", val );
-
-        p_vout->i_changes |= VOUT_SIZE_CHANGE;
+       if( p_vout->b_fullscreen || !p_vout->p_sys->b_embedded )
+       {
+           /* get the geometry from NSQuickDrawView */
+           Rect s_rect;
+           GetPortBounds( p_vout->p_sys->p_qdport, &s_rect );
+           p_vout->p_sys->i_origx = s_rect.left;
+           p_vout->p_sys->i_origy = s_rect.top;
+           p_vout->p_sys->i_width = s_rect.right - s_rect.left;
+           p_vout->p_sys->i_height = s_rect.bottom - s_rect.top;
+       }
+       else 
+       {
+           /* As we're embedded, get the geometry from Mozilla/Safari NPWindow object */
+           UpdateEmbeddedGeometry( p_vout );
+           SetDSequenceMask(p_vout->p_sys->i_seq,
+               p_vout->p_sys->clip_mask);
+       }
     }
 
     if( p_vout->i_changes & VOUT_SIZE_CHANGE ||
@@ -394,6 +401,8 @@ static int ManageVideo( vout_thread_t *p_vout )
     {
         p_vout->i_changes &= ~VOUT_ASPECT_CHANGE;
     }
+
+    // can be nil
     [p_vout->p_sys->o_vout_view manage];
 
     return( 0 );
@@ -408,55 +417,34 @@ static void DisplayVideo( vout_thread_t *p_vout, picture_t *p_pic )
 {
     OSErr err;
     CodecFlags flags;
-
-    Rect saved_rect;
-    RgnHandle saved_clip;
-
-    saved_clip = NewRgn();
-
-    if( p_vout->p_sys->b_embedded )
-    {
-        /* In the Mozilla plugin, the browser also draws things in the windows.
-         * So, we have to update the origin and clipping rectangle for each
-         * picture.  FIXME: The vout should probably lock something ... */
-
-        /* Save the origin and clipping rectangle used by the host application
-         * (e.g. Mozilla), so we can restore it later */
-        GetPortBounds( p_vout->p_sys->p_qdport, &saved_rect );
-        GetClip( saved_clip );
-
-        /* The port gets unlocked at the end of this function */
-        LockPortBits( p_vout->p_sys->p_qdport );
-
-        /* Change the origin and clipping to the coordinates that the embedded
-         * window wants to draw at */
-        SetPort( p_vout->p_sys->p_qdport );
-        SetOrigin( p_vout->p_sys->portx , p_vout->p_sys->porty );
-        ClipRect( &p_vout->p_sys->clipping_rect );
-    }
-
-    if( ( err = DecompressSequenceFrameWhen(
-                    p_vout->p_sys->i_seq,
-                    p_pic->p_sys->p_data,
-                    p_pic->p_sys->i_size,
-                    codecFlagUseImageBuffer, &flags, NULL, NULL ) != noErr ) )
-    {
-        msg_Warn( p_vout, "QT failed to display the frame sequence: %d", err );
-    }
-    else
-    {
-        if( !p_vout->p_sys->b_embedded )
-            QDFlushPortBuffer( p_vout->p_sys->p_qdport, nil );
-    }
-
-    if( p_vout->p_sys->b_embedded )
-    {
-        /* Restore the origin and clipping rectangle to the settings used
-         * by the host application */
-        SetOrigin( saved_rect.left, saved_rect.top );
-        SetClip( saved_clip );
-
-        UnlockPortBits( p_vout->p_sys->p_qdport );
+    if( (NULL == p_vout->p_sys->clip_mask) || !EmptyRgn(p_vout->p_sys->clip_mask) )
+    {
+       //CGrafPtr oldPort;
+       //Rect oldBounds;
+
+       /* since there is not way to lock a QuickDraw port for exclusive use
+          there is a potential problem that the frame will be displayed
+          in the wrong place if other embedded plugins redraws as the port
+          origin may be changed */
+       //GetPort(&oldPort);
+       //GetPortBounds(p_vout->p_sys->p_qdport, &oldBounds);
+       SetPort(p_vout->p_sys->p_qdport);
+       SetOrigin(p_vout->p_sys->i_origx, p_vout->p_sys->i_origy);
+       if( ( err = DecompressSequenceFrameWhen(
+                       p_vout->p_sys->i_seq,
+                       p_pic->p_sys->p_data,
+                       p_pic->p_sys->i_size,
+                       codecFlagUseImageBuffer, &flags, NULL, NULL ) == noErr ) )
+       {
+           QDFlushPortBuffer( p_vout->p_sys->p_qdport, p_vout->p_sys->clip_mask );
+           //QDFlushPortBuffer( p_vout->p_sys->p_qdport, NULL );
+       }
+       else
+       {
+           msg_Warn( p_vout, "QT failed to display the frame sequence: %d", err );
+       }
+       //SetPortBounds(p_vout->p_sys->p_qdport, &oldBounds);
+       //SetPort(oldPort);
     }
 }
 
@@ -494,40 +482,63 @@ static int CoToggleFullscreen( vout_thread_t *p_vout )
 
     if( !p_vout->b_fullscreen )
     {
-        /* Save window size and position */
-        p_vout->p_sys->s_frame.size =
-            [p_vout->p_sys->o_vout_view frame].size;
-        p_vout->p_sys->s_frame.origin =
-            [[p_vout->p_sys->o_vout_view getWindow] frame].origin;
-        p_vout->p_sys->b_saved_frame = VLC_TRUE;
+       if( !p_vout->p_sys->b_embedded )
+       {
+           /* Save window size and position */
+           p_vout->p_sys->s_frame.size =
+               [p_vout->p_sys->o_vout_view frame].size;
+           p_vout->p_sys->s_frame.origin =
+               [[p_vout->p_sys->o_vout_view getWindow] frame].origin;
+           p_vout->p_sys->b_saved_frame = VLC_TRUE;
+       }
+       else
+       {
+           var_DelCallback(p_vout->p_vlc, "drawableredraw", DrawableRedraw, p_vout);
+           DisposeRgn(p_vout->p_sys->clip_mask);
+       }
     }
     [p_vout->p_sys->o_vout_view closeVout];
 
     p_vout->b_fullscreen = !p_vout->b_fullscreen;
 
-#define o_qtview p_vout->p_sys->o_qtview
-    o_qtview = [[VLCQTView alloc] initWithVout: p_vout];
-    [o_qtview autorelease];
-    
-    if( p_vout->p_sys->b_saved_frame )
+    if( p_vout->b_fullscreen || !p_vout->p_sys->b_embedded )
     {
-        p_vout->p_sys->o_vout_view = [VLCVoutView getVoutView: p_vout
-            subView: o_qtview
-            frame: &p_vout->p_sys->s_frame];
+       Rect s_rect;
+        p_vout->p_sys->clip_mask = NULL;
+#define o_qtview p_vout->p_sys->o_qtview
+       o_qtview = [[VLCQTView alloc] initWithVout: p_vout];
+       [o_qtview autorelease];
+       
+       if( p_vout->p_sys->b_saved_frame )
+       {
+           p_vout->p_sys->o_vout_view = [VLCVoutView getVoutView: p_vout
+               subView: o_qtview
+               frame: &p_vout->p_sys->s_frame];
+       }
+       else
+       {
+           p_vout->p_sys->o_vout_view = [VLCVoutView getVoutView: p_vout
+               subView: o_qtview frame: nil];
+       }
+
+       /* Retrieve the QuickDraw port */
+       [o_qtview lockFocus];
+       p_vout->p_sys->p_qdport = [o_qtview qdPort];
+       [o_qtview unlockFocus];
+#undef o_qtview
+       GetPortBounds( p_vout->p_sys->p_qdport, &s_rect );
+       p_vout->p_sys->i_origx = s_rect.left;
+       p_vout->p_sys->i_origy = s_rect.top;
+       p_vout->p_sys->i_width = s_rect.right - s_rect.left;
+       p_vout->p_sys->i_height = s_rect.bottom - s_rect.top;
     }
     else
     {
-        p_vout->p_sys->o_vout_view = [VLCVoutView getVoutView: p_vout
-            subView: o_qtview frame: nil];
+        /* Create the clipping mask */
+        p_vout->p_sys->clip_mask = NewRgn();
+       UpdateEmbeddedGeometry(p_vout);
+       var_AddCallback(p_vout->p_vlc, "drawableredraw", DrawableRedraw, p_vout);
     }
-
-    /* Retrieve the QuickDraw port */
-    [o_qtview lockFocus];
-    p_vout->p_sys->p_qdport = [o_qtview qdPort];
-    [o_qtview unlockFocus];
-#undef o_qtview
-
-    SetPort( p_vout->p_sys->p_qdport );
     QTScaleMatrix( p_vout );
 
     if( QTCreateSequence( p_vout ) )
@@ -540,55 +551,84 @@ static int CoToggleFullscreen( vout_thread_t *p_vout )
     return 0;
 }
 
+/* If we're embedded, the application is expected to indicate a
+ * window change (move/resize/etc) via the "drawableredraw" value.
+ * If that's the case, set the VOUT_SIZE_CHANGE flag so we do
+ * actually handle the window change. */
+
+static int DrawableRedraw( vlc_object_t *p_this, const char *psz_name,
+    vlc_value_t oval, vlc_value_t nval, void *param)
+{
+    /* ignore changes until we are ready for them */
+    if( (oval.i_int != nval.i_int) && (nval.i_int == 1) )
+    {
+       vout_thread_t *p_vout = (vout_thread_t *)param;
+       /* prevent QT from rendering any more video until we have updated
+          the geometry */
+       SetEmptyRgn(p_vout->p_sys->clip_mask);
+       SetDSequenceMask(p_vout->p_sys->i_seq,
+           p_vout->p_sys->clip_mask);
+
+       p_vout->i_changes |= VOUT_SIZE_CHANGE;
+    }
+    return VLC_SUCCESS;
+}
+
+/* Embedded video get their drawing region from the host application
+ * by the drawable values here.  Read those variables, and store them
+ * in the p_vout->p_sys structure so that other functions (such as
+ * DisplayVideo and ManageVideo) can use them later. */
+
+static void UpdateEmbeddedGeometry( vout_thread_t *p_vout )
+{
+    vlc_value_t val;
+    vlc_value_t valt, vall, valb, valr, valx, valy, valw, valh,
+               valportx, valporty;
+
+    var_Get( p_vout->p_vlc, "drawable", &val );
+    var_Get( p_vout->p_vlc, "drawablet", &valt );
+    var_Get( p_vout->p_vlc, "drawablel", &vall );
+    var_Get( p_vout->p_vlc, "drawableb", &valb );
+    var_Get( p_vout->p_vlc, "drawabler", &valr );
+    var_Get( p_vout->p_vlc, "drawablex", &valx );
+    var_Get( p_vout->p_vlc, "drawabley", &valy );
+    var_Get( p_vout->p_vlc, "drawablew", &valw );
+    var_Get( p_vout->p_vlc, "drawableh", &valh );
+    var_Get( p_vout->p_vlc, "drawableportx", &valportx );
+    var_Get( p_vout->p_vlc, "drawableporty", &valporty );
+
+    /* portx, porty contains values for SetOrigin() function
+       which isn't used, instead use QT Translate matrix */
+    p_vout->p_sys->i_origx = valportx.i_int;
+    p_vout->p_sys->i_origy = valporty.i_int;
+    p_vout->p_sys->p_qdport = (CGrafPtr) val.i_int;
+    p_vout->p_sys->i_width = valw.i_int;
+    p_vout->p_sys->i_height = valh.i_int;
+
+    /* update video clipping mask */
+    /*SetRectRgn( p_vout->p_sys->clip_mask , vall.i_int ,
+               valt.i_int, valr.i_int, valb.i_int );*/
+    SetRectRgn( p_vout->p_sys->clip_mask , vall.i_int + valportx.i_int ,
+               valt.i_int + valporty.i_int , valr.i_int + valportx.i_int ,
+               valb.i_int + valporty.i_int );
+
+    /* reset drawableredraw variable indicating we are ready
+       to take changes in video geometry */
+    val.i_int=0;
+    var_Set( p_vout->p_vlc, "drawableredraw", val );
+}
+
 /*****************************************************************************
  * QTScaleMatrix: scale matrix 
  *****************************************************************************/
 static void QTScaleMatrix( vout_thread_t *p_vout )
 {
-    Rect s_rect;
     vlc_value_t val;
-    unsigned int i_width, i_height;
     Fixed factor_x, factor_y;
     unsigned int i_offset_x = 0;
     unsigned int i_offset_y = 0;
-
-    GetPortBounds( p_vout->p_sys->p_qdport, &s_rect );
-
-    i_width = s_rect.right - s_rect.left;
-    i_height = s_rect.bottom - s_rect.top;
-
-    if( p_vout->p_sys->b_embedded )
-    {
-        /* Embedded video get their drawing region from the host application
-         * by the drawable values here.  Read those variables, and store them
-         * in the p_vout->p_sys structure so that other functions (such as
-         * DisplayVideo and ManageVideo) can use them later. */
-        vlc_value_t valt, vall, valb, valr, valx, valy, valw, valh,
-                    valportx, valporty;
-
-        var_Get( p_vout->p_vlc, "drawable", &val );
-        var_Get( p_vout->p_vlc, "drawablet", &valt );
-        var_Get( p_vout->p_vlc, "drawablel", &vall );
-        var_Get( p_vout->p_vlc, "drawableb", &valb );
-        var_Get( p_vout->p_vlc, "drawabler", &valr );
-        var_Get( p_vout->p_vlc, "drawablex", &valx );
-        var_Get( p_vout->p_vlc, "drawabley", &valy );
-        var_Get( p_vout->p_vlc, "drawablew", &valw );
-        var_Get( p_vout->p_vlc, "drawableh", &valh );
-        var_Get( p_vout->p_vlc, "drawableportx", &valportx );
-        var_Get( p_vout->p_vlc, "drawableporty", &valporty );
-
-        p_vout->p_sys->portx = valportx.i_int;
-        p_vout->p_sys->porty = valporty.i_int;
-        p_vout->p_sys->p_qdport = (CGrafPtr) val.i_int;
-        i_width = valw.i_int;
-        i_height = valh.i_int;
-
-        p_vout->p_sys->clipping_rect.top = 0;
-        p_vout->p_sys->clipping_rect.left = 0;
-        p_vout->p_sys->clipping_rect.bottom = valb.i_int - valt.i_int;
-        p_vout->p_sys->clipping_rect.right = valr.i_int - vall.i_int;
-    }
+    int i_width = p_vout->p_sys->i_width;
+    int i_height = p_vout->p_sys->i_height;
 
     var_Get( p_vout, "macosx-stretch", &val );
     if( val.b_bool )
@@ -679,7 +719,7 @@ static int QTCreateSequence( vout_thread_t *p_vout )
                               p_vout->p_sys->p_qdport,
                               NULL, NULL,
                               p_vout->p_sys->p_matrix,
-                              srcCopy, NULL,
+                              srcCopy, p_vout->p_sys->clip_mask,
                               codecFlagUseImageBuffer,
                               codecLosslessQuality,
                               bestSpeedCodec ) ) )
index 850717a..74ed52e 100644 (file)
@@ -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
 
index 96a1116..fee124f 100644 (file)
@@ -13,7 +13,8 @@
 #include <Resources.h>
 #include <ToolUtils.h>
 
-#define XP_MAC 1
+#define XP_MACOSX 1
+#undef TARGET_RT_MAC_CFM
 
 //
 // A4Stuff.h contains the definition of EnterCodeResource and 
@@ -25,8 +26,8 @@
 //
 
 #if (defined(__MWERKS__) && (__MWERKS__ >= 0x2400)) || defined(__GNUC__)
-       #define EnterCodeResource()
-       #define ExitCodeResource()
+    #define EnterCodeResource()
+    #define ExitCodeResource()
 #else
     #include <A4Stuff.h>
 #endif
 #endif
 #endif
 
+#ifdef XP_UNIX
+#undef XP_UNIX
+#endif
+
 #include "npupp.h"
 
 #ifdef __MWERKS__
 // incompatibility with some parts of PowerPlant, was submitted by 
 // Jan Ulbrich.
 #ifdef __MWERKS__
-       #ifdef __cplusplus
-       extern "C" {
-       #endif
-               #ifndef powerc
-                       extern void     __InitCode__(void);
-               #else
-                       extern void __sinit(void);
-                       #define __InitCode__ __sinit
-               #endif
-               extern void     __destroy_global_chain(void);
-       #ifdef __cplusplus
-       }
-       #endif // __cplusplus
+    #ifdef __cplusplus
+    extern "C" {
+    #endif
+        #ifndef powerc
+            extern void __InitCode__(void);
+        #else
+            extern void __sinit(void);
+            #define __InitCode__ __sinit
+        #endif
+        extern void __destroy_global_chain(void);
+    #ifdef __cplusplus
+    }
+    #endif // __cplusplus
 #endif // __MWERKS__
 
 //
 // Define PLUGIN_TRACE to 1 to have the wrapper functions emit
 // DebugStr messages whenever they are called.
 //
-//#define PLUGIN_TRACE 1
+#define PLUGIN_TRACE 0
 
 #if PLUGIN_TRACE
-#define PLUGINDEBUGSTR(msg)            ::DebugStr(msg)
+#define PLUGINDEBUGSTR(msg)     ::DebugStr(msg)
 #else
-#define PLUGINDEBUGSTR
+#define PLUGINDEBUGSTR(msg) {}
 #endif
 
 
-#ifdef XP_MACOSX
+#ifdef XP_MACOSX && !TARGET_RT_MAC_CFM
 
 // glue for mapping outgoing Macho function pointers to TVectors
 struct TFPtoTVGlue{
     void* glue[2];
 };
 
-struct {
+static struct {
     TFPtoTVGlue     newp;
     TFPtoTVGlue     destroy;
     TFPtoTVGlue     setwindow;
@@ -128,7 +133,7 @@ struct TTVtoFPGlue {
     uint32 glue[6];
 };
 
-struct {
+static struct {
     TTVtoFPGlue             geturl;
     TTVtoFPGlue             posturl;
     TTVtoFPGlue             requestread;
@@ -150,6 +155,26 @@ struct {
     TTVtoFPGlue             invalidaterect;
     TTVtoFPGlue             invalidateregion;
     TTVtoFPGlue             forceredraw;
+    // NPRuntime support
+    TTVtoFPGlue             getstringidentifier;
+    TTVtoFPGlue             getstringidentifiers;
+    TTVtoFPGlue             getintidentifier;
+    TTVtoFPGlue             identifierisstring;
+    TTVtoFPGlue             utf8fromidentifier;
+    TTVtoFPGlue             intfromidentifier;
+    TTVtoFPGlue             createobject;
+    TTVtoFPGlue             retainobject;
+    TTVtoFPGlue             releaseobject;
+    TTVtoFPGlue             invoke;
+    TTVtoFPGlue             invokeDefault;
+    TTVtoFPGlue             evaluate;
+    TTVtoFPGlue             getproperty;
+    TTVtoFPGlue             setproperty;
+    TTVtoFPGlue             removeproperty;
+    TTVtoFPGlue             hasproperty;
+    TTVtoFPGlue             hasmethod;
+    TTVtoFPGlue             releasevariantvalue;
+    TTVtoFPGlue             setexception;
 } gNetscapeFuncsGlueTable;
 
 static void* SetupTVtoFPGlue(TTVtoFPGlue* functionGlue, void* tvp)
@@ -183,10 +208,10 @@ static void* SetupTVtoFPGlue(TTVtoFPGlue* functionGlue, void* tvp)
 //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 
 #if !TARGET_API_MAC_CARBON
-QDGlobals*             gQDPtr;                         // Pointer to Netscape’s QuickDraw globals
+QDGlobals*      gQDPtr;             // Pointer to Netscape’s QuickDraw globals
 #endif
-short                  gResFile;                       // Refnum of the plugin’s resource file
-NPNetscapeFuncs        gNetscapeFuncs;         // Function table for procs in Netscape called by plugin
+short           gResFile;           // Refnum of the plugin’s resource file
+NPNetscapeFuncs    gNetscapeFuncs;      // Function table for procs in Netscape called by plugin
 
 //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 //
@@ -200,173 +225,359 @@ NPNetscapeFuncs gNetscapeFuncs;         // Function table for procs in Netscape called
 
 void NPN_Version(int* plugin_major, int* plugin_minor, int* netscape_major, int* netscape_minor)
 {
-       *plugin_major = NP_VERSION_MAJOR;
-       *plugin_minor = NP_VERSION_MINOR;
-       *netscape_major = gNetscapeFuncs.version >> 8;          // Major version is in high byte
-       *netscape_minor = gNetscapeFuncs.version & 0xFF;        // Minor version is in low byte
+    *plugin_major = NP_VERSION_MAJOR;
+    *plugin_minor = NP_VERSION_MINOR;
+    *netscape_major = gNetscapeFuncs.version >> 8;      // Major version is in high byte
+    *netscape_minor = gNetscapeFuncs.version & 0xFF;    // Minor version is in low byte
 }
 
 NPError NPN_GetURLNotify(NPP instance, const char* url, const char* window, void* notifyData)
 {
-       int navMinorVers = gNetscapeFuncs.version & 0xFF;
-       NPError err;
-       
-       if( navMinorVers >= NPVERS_HAS_NOTIFICATION )
-       {
-               err = CallNPN_GetURLNotifyProc(gNetscapeFuncs.geturlnotify, instance, url, window, notifyData);
-       }
-       else
-       {
-               err = NPERR_INCOMPATIBLE_VERSION_ERROR;
-       }
-       return err;
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    NPError err;
+    
+    if( navMinorVers >= NPVERS_HAS_NOTIFICATION )
+    {
+        err = CallNPN_GetURLNotifyProc(gNetscapeFuncs.geturlnotify, instance, url, window, notifyData);
+    }
+    else
+    {
+        err = NPERR_INCOMPATIBLE_VERSION_ERROR;
+    }
+    return err;
 }
 
 NPError NPN_GetURL(NPP instance, const char* url, const char* window)
 {
-       return CallNPN_GetURLProc(gNetscapeFuncs.geturl, instance, url, window);
+    return CallNPN_GetURLProc(gNetscapeFuncs.geturl, instance, url, window);
 }
 
 NPError NPN_PostURLNotify(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file, void* notifyData)
 {
-       int navMinorVers = gNetscapeFuncs.version & 0xFF;
-       NPError err;
-       
-       if( navMinorVers >= NPVERS_HAS_NOTIFICATION )
-       {
-               err = CallNPN_PostURLNotifyProc(gNetscapeFuncs.posturlnotify, instance, url, 
-                                                                                                               window, len, buf, file, notifyData);
-       }
-       else
-       {
-               err = NPERR_INCOMPATIBLE_VERSION_ERROR;
-       }
-       return err;
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    NPError err;
+    
+    if( navMinorVers >= NPVERS_HAS_NOTIFICATION )
+    {
+        err = CallNPN_PostURLNotifyProc(gNetscapeFuncs.posturlnotify, instance, url, 
+                                                        window, len, buf, file, notifyData);
+    }
+    else
+    {
+        err = NPERR_INCOMPATIBLE_VERSION_ERROR;
+    }
+    return err;
 }
 
 NPError NPN_PostURL(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file)
 {
-       return CallNPN_PostURLProc(gNetscapeFuncs.posturl, instance, url, window, len, buf, file);
+    return CallNPN_PostURLProc(gNetscapeFuncs.posturl, instance, url, window, len, buf, file);
 }
 
 NPError NPN_RequestRead(NPStream* stream, NPByteRange* rangeList)
 {
-       return CallNPN_RequestReadProc(gNetscapeFuncs.requestread, stream, rangeList);
+    return CallNPN_RequestReadProc(gNetscapeFuncs.requestread, stream, rangeList);
 }
 
 NPError NPN_NewStream(NPP instance, NPMIMEType type, const char* window, NPStream** stream)
 {
-       int navMinorVers = gNetscapeFuncs.version & 0xFF;
-       NPError err;
-       
-       if( navMinorVers >= NPVERS_HAS_STREAMOUTPUT )
-       {
-               err = CallNPN_NewStreamProc(gNetscapeFuncs.newstream, instance, type, window, stream);
-       }
-       else
-       {
-               err = NPERR_INCOMPATIBLE_VERSION_ERROR;
-       }
-       return err;
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    NPError err;
+    
+    if( navMinorVers >= NPVERS_HAS_STREAMOUTPUT )
+    {
+        err = CallNPN_NewStreamProc(gNetscapeFuncs.newstream, instance, type, window, stream);
+    }
+    else
+    {
+        err = NPERR_INCOMPATIBLE_VERSION_ERROR;
+    }
+    return err;
 }
 
 int32 NPN_Write(NPP instance, NPStream* stream, int32 len, void* buffer)
 {
-       int navMinorVers = gNetscapeFuncs.version & 0xFF;
-       NPError err;
-       
-       if( navMinorVers >= NPVERS_HAS_STREAMOUTPUT )
-       {
-               err = CallNPN_WriteProc(gNetscapeFuncs.write, instance, stream, len, buffer);
-       }
-       else
-       {
-               err = NPERR_INCOMPATIBLE_VERSION_ERROR;
-       }
-       return err;
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    NPError err;
+    
+    if( navMinorVers >= NPVERS_HAS_STREAMOUTPUT )
+    {
+        err = CallNPN_WriteProc(gNetscapeFuncs.write, instance, stream, len, buffer);
+    }
+    else
+    {
+        err = NPERR_INCOMPATIBLE_VERSION_ERROR;
+    }
+    return err;
 }
 
-NPError        NPN_DestroyStream(NPP instance, NPStream* stream, NPError reason)
+NPError    NPN_DestroyStream(NPP instance, NPStream* stream, NPError reason)
 {
-       int navMinorVers = gNetscapeFuncs.version & 0xFF;
-       NPError err;
-       
-       if( navMinorVers >= NPVERS_HAS_STREAMOUTPUT )
-       {
-               err = CallNPN_DestroyStreamProc(gNetscapeFuncs.destroystream, instance, stream, reason);
-       }
-       else
-       {
-               err = NPERR_INCOMPATIBLE_VERSION_ERROR;
-       }
-       return err;
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    NPError err;
+    
+    if( navMinorVers >= NPVERS_HAS_STREAMOUTPUT )
+    {
+        err = CallNPN_DestroyStreamProc(gNetscapeFuncs.destroystream, instance, stream, reason);
+    }
+    else
+    {
+        err = NPERR_INCOMPATIBLE_VERSION_ERROR;
+    }
+    return err;
 }
 
 void NPN_Status(NPP instance, const char* message)
 {
-       CallNPN_StatusProc(gNetscapeFuncs.status, instance, message);
+    CallNPN_StatusProc(gNetscapeFuncs.status, instance, message);
 }
 
 const char* NPN_UserAgent(NPP instance)
 {
-       return CallNPN_UserAgentProc(gNetscapeFuncs.uagent, instance);
+    return CallNPN_UserAgentProc(gNetscapeFuncs.uagent, instance);
 }
 
 void* NPN_MemAlloc(uint32 size)
 {
-       return CallNPN_MemAllocProc(gNetscapeFuncs.memalloc, size);
+    return CallNPN_MemAllocProc(gNetscapeFuncs.memalloc, size);
 }
 
 void NPN_MemFree(void* ptr)
 {
-       CallNPN_MemFreeProc(gNetscapeFuncs.memfree, ptr);
+    CallNPN_MemFreeProc(gNetscapeFuncs.memfree, ptr);
 }
 
 uint32 NPN_MemFlush(uint32 size)
 {
-       return CallNPN_MemFlushProc(gNetscapeFuncs.memflush, size);
+    return CallNPN_MemFlushProc(gNetscapeFuncs.memflush, size);
 }
 
 void NPN_ReloadPlugins(NPBool reloadPages)
 {
-       CallNPN_ReloadPluginsProc(gNetscapeFuncs.reloadplugins, reloadPages);
+    CallNPN_ReloadPluginsProc(gNetscapeFuncs.reloadplugins, reloadPages);
 }
 
 #ifdef OJI
 JRIEnv* NPN_GetJavaEnv(void)
 {
-       return CallNPN_GetJavaEnvProc( gNetscapeFuncs.getJavaEnv );
+    return CallNPN_GetJavaEnvProc( gNetscapeFuncs.getJavaEnv );
 }
 
 jobject  NPN_GetJavaPeer(NPP instance)
 {
-       return CallNPN_GetJavaPeerProc( gNetscapeFuncs.getJavaPeer, instance );
+    return CallNPN_GetJavaPeerProc( gNetscapeFuncs.getJavaPeer, instance );
 }
 #endif
 
 NPError NPN_GetValue(NPP instance, NPNVariable variable, void *value)
 {
-       return CallNPN_GetValueProc( gNetscapeFuncs.getvalue, instance, variable, value);
+    return CallNPN_GetValueProc( gNetscapeFuncs.getvalue, instance, variable, value);
 }
 
 NPError NPN_SetValue(NPP instance, NPPVariable variable, void *value)
 {
-       return CallNPN_SetValueProc( gNetscapeFuncs.setvalue, instance, variable, value);
+    return CallNPN_SetValueProc( gNetscapeFuncs.setvalue, instance, variable, value);
 }
 
 void NPN_InvalidateRect(NPP instance, NPRect *rect)
 {
-       CallNPN_InvalidateRectProc( gNetscapeFuncs.invalidaterect, instance, rect);
+    CallNPN_InvalidateRectProc( gNetscapeFuncs.invalidaterect, instance, rect);
 }
 
 void NPN_InvalidateRegion(NPP instance, NPRegion region)
 {
-       CallNPN_InvalidateRegionProc( gNetscapeFuncs.invalidateregion, instance, region);
+    CallNPN_InvalidateRegionProc( gNetscapeFuncs.invalidateregion, instance, region);
 }
 
 void NPN_ForceRedraw(NPP instance)
 {
-       CallNPN_ForceRedrawProc( gNetscapeFuncs.forceredraw, instance);
+    CallNPN_ForceRedrawProc( gNetscapeFuncs.forceredraw, instance);
+}
+
+NPIdentifier NPN_GetStringIdentifier(const NPUTF8 *name)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_GetStringIdentifierProc( gNetscapeFuncs.getstringidentifier, name);
+    }
+    return NULL;
+}
+
+void NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount, NPIdentifier *identifiers)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       CallNPN_GetStringIdentifiersProc( gNetscapeFuncs.getstringidentifiers, names, nameCount, identifiers);
+    }
+}
+
+NPIdentifier NPN_GetIntIdentifier(int32_t intid)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_GetIntIdentifierProc( gNetscapeFuncs.getintidentifier, intid);
+    }
+    return NULL;
+}
+
+bool NPN_IdentifierIsString(NPIdentifier identifier)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_IdentifierIsStringProc( gNetscapeFuncs.identifierisstring, identifier);
+    }
+    return false;
+}
+
+NPUTF8 *NPN_UTF8FromIdentifier(NPIdentifier identifier)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_UTF8FromIdentifierProc( gNetscapeFuncs.utf8fromidentifier, identifier);
+    }
+    return NULL;
+}
+
+int32_t NPN_IntFromIdentifier(NPIdentifier identifier)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_IntFromIdentifierProc( gNetscapeFuncs.intfromidentifier, identifier);
+    }
+    return 0;
+}
+
+NPObject *NPN_CreateObject(NPP instance, NPClass *aClass)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_CreateObjectProc( gNetscapeFuncs.createobject, instance, aClass);
+    }
+    return NULL;
+}
+
+NPObject *NPN_RetainObject(NPObject *npobj)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_RetainObjectProc( gNetscapeFuncs.retainobject, npobj);
+    }
+    return NULL;
+}
+
+void NPN_ReleaseObject(NPObject *npobj)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       CallNPN_ReleaseObjectProc( gNetscapeFuncs.releaseobject, npobj);
+    }
+}
+
+bool NPN_Invoke(NPP instance, NPObject *npobj, NPIdentifier methodName, const NPVariant *args, uint32_t argCount, NPVariant *result)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_InvokeProc( gNetscapeFuncs.invoke, instance, npobj, methodName, args, argCount, result);
+    }
+    return false;
+}
+
+bool NPN_InvokeDefault(NPP instance, NPObject *npobj, const NPVariant *args, uint32_t argCount, NPVariant *result)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_InvokeDefaultProc( gNetscapeFuncs.invokeDefault, instance, npobj, args, argCount, result);
+    }
+    return false;
+}
+
+bool NPN_Evaluate(NPP instance, NPObject *npobj, NPString *script, NPVariant *result)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_EvaluateProc( gNetscapeFuncs.evaluate, instance, npobj, script, result);
+    }
+    return false;
+}
+
+bool NPN_GetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, NPVariant *result)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_GetPropertyProc( gNetscapeFuncs.getproperty, instance, npobj, propertyName, result);
+    }
+    return false;
+}
+
+bool NPN_SetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, const NPVariant *value)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_SetPropertyProc( gNetscapeFuncs.setproperty, instance, npobj, propertyName, value);
+    }
+    return false;
+}
+
+bool NPN_RemoveProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_RemovePropertyProc( gNetscapeFuncs.removeproperty, instance, npobj, propertyName);
+    }
+    return false;
+}
+
+bool NPN_HasProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_HasPropertyProc( gNetscapeFuncs.hasproperty, instance, npobj, propertyName);
+    }
+    return false;
+}
+
+bool NPN_HasMethod(NPP instance, NPObject *npobj, NPIdentifier methodName)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       return CallNPN_HasMethodProc( gNetscapeFuncs.hasmethod, instance, npobj, methodName);
+    }
+    return false;
+}
+
+void NPN_ReleaseVariantValue(NPVariant *variant)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       CallNPN_ReleaseVariantValueProc( gNetscapeFuncs.releasevariantvalue, variant);
+    }
+}
+
+void NPN_SetException(NPObject *npobj, const NPUTF8 *message)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+    if( navMinorVers >= 14 )
+    {   
+       CallNPN_SetExceptionProc( gNetscapeFuncs.setexception, npobj, message);
+    }
 }
 
 #pragma mark -
@@ -381,173 +592,184 @@ void NPN_ForceRedraw(NPP instance)
 //
 //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 
-NPError        Private_Initialize(void);
-void           Private_Shutdown(void);
-NPError                Private_New(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved);
-NPError        Private_Destroy(NPP instance, NPSavedData** save);
-NPError                Private_SetWindow(NPP instance, NPWindow* window);
-NPError        Private_GetValue( NPP instance, NPPVariable variable, void *value );
-NPError                Private_NewStream(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16* stype);
-NPError                Private_DestroyStream(NPP instance, NPStream* stream, NPError reason);
-int32          Private_WriteReady(NPP instance, NPStream* stream);
-int32          Private_Write(NPP instance, NPStream* stream, int32 offset, int32 len, void* buffer);
-void           Private_StreamAsFile(NPP instance, NPStream* stream, const char* fname);
-void           Private_Print(NPP instance, NPPrint* platformPrint);
-int16          Private_HandleEvent(NPP instance, void* event);
+NPError     Private_Initialize(void);
+void        Private_Shutdown(void);
+NPError     Private_New(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved);
+NPError     Private_Destroy(NPP instance, NPSavedData** save);
+NPError     Private_SetWindow(NPP instance, NPWindow* window);
+NPError     Private_GetValue( NPP instance, NPPVariable variable, void *value );
+NPError     Private_SetValue( NPP instance, NPPVariable variable, void *value );
+NPError     Private_NewStream(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16* stype);
+NPError     Private_DestroyStream(NPP instance, NPStream* stream, NPError reason);
+int32       Private_WriteReady(NPP instance, NPStream* stream);
+int32       Private_Write(NPP instance, NPStream* stream, int32 offset, int32 len, void* buffer);
+void        Private_StreamAsFile(NPP instance, NPStream* stream, const char* fname);
+void        Private_Print(NPP instance, NPPrint* platformPrint);
+int16       Private_HandleEvent(NPP instance, void* event);
 void        Private_URLNotify(NPP instance, const char* url, NPReason reason, void* notifyData);
-jobject                Private_GetJavaClass(void);
+jobject     Private_GetJavaClass(void);
 
 
 NPError Private_Initialize(void)
 {
-       NPError err;
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pInitialize;g;");
-       err = NPP_Initialize();
-       ExitCodeResource();
-       return err;
+    NPError err;
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pInitialize;g;");
+    err = NPP_Initialize();
+    ExitCodeResource();
+    return err;
 }
 
 void Private_Shutdown(void)
 {
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pShutdown;g;");
-       NPP_Shutdown();
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pShutdown;g;");
+    NPP_Shutdown();
 
 #ifdef __MWERKS__
-       __destroy_global_chain();
+    __destroy_global_chain();
 #endif
 
-       ExitCodeResource();
+    ExitCodeResource();
 }
 
 
-NPError        Private_New(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved)
+NPError    Private_New(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved)
 {
-       EnterCodeResource();
-       NPError ret = NPP_New(pluginType, instance, mode, argc, argn, argv, saved);
-       PLUGINDEBUGSTR("\pNew;g;");
-       ExitCodeResource();
-       return ret;     
+    EnterCodeResource();
+    NPError ret = NPP_New(pluginType, instance, mode, argc, argn, argv, saved);
+    PLUGINDEBUGSTR("\pNew;g;");
+    ExitCodeResource();
+    return ret; 
 }
 
 NPError Private_Destroy(NPP instance, NPSavedData** save)
 {
-       NPError err;
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pDestroy;g;");
-       err = NPP_Destroy(instance, save);
-       ExitCodeResource();
-       return err;
+    NPError err;
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pDestroy;g;");
+    err = NPP_Destroy(instance, save);
+    ExitCodeResource();
+    return err;
 }
 
 NPError Private_SetWindow(NPP instance, NPWindow* window)
 {
-       NPError err;
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pSetWindow;g;");
-       err = NPP_SetWindow(instance, window);
-       ExitCodeResource();
-       return err;
+    NPError err;
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pSetWindow;g;");
+    err = NPP_SetWindow(instance, window);
+    ExitCodeResource();
+    return err;
 }
 
 NPError Private_GetValue( NPP instance, NPPVariable variable, void *value )
 {
-       NPError err;
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pGetValue;g;");
-       err = NPP_GetValue( instance, variable, value);
-       ExitCodeResource();
-       return err;
+    NPError err;
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pGetValue;g;");
+    err = NPP_GetValue( instance, variable, value);
+    ExitCodeResource();
+    return err;
+}
+
+NPError Private_SetValue( NPP instance, NPNVariable variable, void *value )
+{
+    NPError err;
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pSetValue;g;");
+    err = NPERR_NO_ERROR; //NPP_SetValue( instance, variable, value);
+    ExitCodeResource();
+    return err;
 }
 
 NPError Private_NewStream(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16* stype)
 {
-       NPError err;
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pNewStream;g;");
-       err = NPP_NewStream(instance, type, stream, seekable, stype);
-       ExitCodeResource();
-       return err;
+    NPError err;
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pNewStream;g;");
+    err = NPP_NewStream(instance, type, stream, seekable, stype);
+    ExitCodeResource();
+    return err;
 }
 
 int32 Private_WriteReady(NPP instance, NPStream* stream)
 {
-       int32 result;
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pWriteReady;g;");
-       result = NPP_WriteReady(instance, stream);
-       ExitCodeResource();
-       return result;
+    int32 result;
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pWriteReady;g;");
+    result = NPP_WriteReady(instance, stream);
+    ExitCodeResource();
+    return result;
 }
 
 int32 Private_Write(NPP instance, NPStream* stream, int32 offset, int32 len, void* buffer)
 {
-       int32 result;
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pWrite;g;");
-       result = NPP_Write(instance, stream, offset, len, buffer);
-       ExitCodeResource();
-       return result;
+    int32 result;
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pWrite;g;");
+    result = NPP_Write(instance, stream, offset, len, buffer);
+    ExitCodeResource();
+    return result;
 }
 
 void Private_StreamAsFile(NPP instance, NPStream* stream, const char* fname)
 {
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pStreamAsFile;g;");
-       NPP_StreamAsFile(instance, stream, fname);
-       ExitCodeResource();
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pStreamAsFile;g;");
+    NPP_StreamAsFile(instance, stream, fname);
+    ExitCodeResource();
 }
 
 
 NPError Private_DestroyStream(NPP instance, NPStream* stream, NPError reason)
 {
-       NPError err;
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pDestroyStream;g;");
-       err = NPP_DestroyStream(instance, stream, reason);
-       ExitCodeResource();
-       return err;
+    NPError err;
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pDestroyStream;g;");
+    err = NPP_DestroyStream(instance, stream, reason);
+    ExitCodeResource();
+    return err;
 }
 
 int16 Private_HandleEvent(NPP instance, void* event)
 {
-       int16 result;
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pHandleEvent;g;");
-       result = NPP_HandleEvent(instance, event);
-       ExitCodeResource();
-       return result;
+    int16 result;
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pHandleEvent;g;");
+    result = NPP_HandleEvent(instance, event);
+    ExitCodeResource();
+    return result;
 }
 
 void Private_Print(NPP instance, NPPrint* platformPrint)
 {
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pPrint;g;");
-       NPP_Print(instance, platformPrint);
-       ExitCodeResource();
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pPrint;g;");
+    NPP_Print(instance, platformPrint);
+    ExitCodeResource();
 }
 
 void Private_URLNotify(NPP instance, const char* url, NPReason reason, void* notifyData)
 {
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pURLNotify;g;");
-       NPP_URLNotify(instance, url, reason, notifyData);
-       ExitCodeResource();
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pURLNotify;g;");
+    NPP_URLNotify(instance, url, reason, notifyData);
+    ExitCodeResource();
 }
 
 #ifdef OJI
 jobject Private_GetJavaClass(void)
 {
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pGetJavaClass;g;");
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pGetJavaClass;g;");
 
     jobject clazz = NPP_GetJavaClass();
     ExitCodeResource();
     if (clazz)
     {
-               JRIEnv* env = NPN_GetJavaEnv();
-               return (jobject)JRI_NewGlobalRef(env, clazz);
+        JRIEnv* env = NPN_GetJavaEnv();
+        return (jobject)JRI_NewGlobalRef(env, clazz);
     }
     return NULL;
 }
@@ -557,93 +779,93 @@ void SetUpQD(void);
 void SetUpQD(void)
 {
 #if !TARGET_API_MAC_CARBON
-       ProcessSerialNumber PSN;
-       FSSpec                          myFSSpec;
-       Str63                           name;
-       ProcessInfoRec          infoRec;
-       OSErr                           result = noErr;
-       CFragConnectionID       connID;
-       Str255                          errName;
-#endif 
-
-       //
-       // Memorize the plugin’s resource file 
-       // refnum for later use.
-       //
-       gResFile = CurResFile();
-       
+    ProcessSerialNumber PSN;
+    FSSpec              myFSSpec;
+    Str63               name;
+    ProcessInfoRec      infoRec;
+    OSErr               result = noErr;
+    CFragConnectionID   connID;
+    Str255              errName;
+#endif    
+
+    //
+    // Memorize the plugin’s resource file 
+    // refnum for later use.
+    //
+    gResFile = CurResFile();
+    
 #if !TARGET_API_MAC_CARBON
-       //
-       // Ask the system if CFM is available.
-       //
-       long response;
-       OSErr err = Gestalt(gestaltCFMAttr, &response);
-       Boolean hasCFM = BitTst(&response, 31-gestaltCFMPresent);
-
-       ProcessInfoRec infoRec;
-       if (hasCFM)
-       {
-               //
-               // GetProcessInformation takes a process serial number and 
-               // will give us back the name and FSSpec of the application.
-               // See the Process Manager in IM.
-               //
-               Str63 name;
-               FSSpec myFSSpec;
-               infoRec.processInfoLength = sizeof(ProcessInfoRec);
-               infoRec.processName = name;
-               infoRec.processAppSpec = &myFSSpec;
-               
-               ProcessSerialNumber PSN;
-               PSN.highLongOfPSN = 0;
-               PSN.lowLongOfPSN = kCurrentProcess;
-               
-               result = GetProcessInformation(&PSN, &infoRec);
-               if (result != noErr)
-                       PLUGINDEBUGSTR("\pFailed in GetProcessInformation");
-               }
-       else
-               //
-               // If no CFM installed, assume it must be a 68K app.
-               //
-               result = -1;            
-               
-       CFragConnectionID connID;
-       if (result == noErr)
-       {
-               //
-               // Now that we know the app name and FSSpec, we can call GetDiskFragment
-               // to get a connID to use in a subsequent call to FindSymbol (it will also
-               // return the address of “main” in app, which we ignore).  If GetDiskFragment 
-               // returns an error, we assume the app must be 68K.
-               //
-               Ptr mainAddr;   
-               Str255 errName;
-               result =  GetDiskFragment(infoRec.processAppSpec, 0L, 0L, infoRec.processName,
-                                                                 kLoadCFrag, &connID, (Ptr*)&mainAddr, errName);
-       }
+    //
+    // Ask the system if CFM is available.
+    //
+    long response;
+    OSErr err = Gestalt(gestaltCFMAttr, &response);
+    Boolean hasCFM = BitTst(&response, 31-gestaltCFMPresent);
+
+    ProcessInfoRec infoRec;
+    if (hasCFM)
+    {
+        //
+        // GetProcessInformation takes a process serial number and 
+        // will give us back the name and FSSpec of the application.
+        // See the Process Manager in IM.
+        //
+        Str63 name;
+        FSSpec myFSSpec;
+        infoRec.processInfoLength = sizeof(ProcessInfoRec);
+        infoRec.processName = name;
+        infoRec.processAppSpec = &myFSSpec;
+        
+        ProcessSerialNumber PSN;
+        PSN.highLongOfPSN = 0;
+        PSN.lowLongOfPSN = kCurrentProcess;
+        
+        result = GetProcessInformation(&PSN, &infoRec);
+        if (result != noErr)
+            PLUGINDEBUGSTR("\pFailed in GetProcessInformation");
+    }
+    else
+        //
+        // If no CFM installed, assume it must be a 68K app.
+        //
+        result = -1;        
+        
+    CFragConnectionID connID;
+    if (result == noErr)
+    {
+        //
+        // Now that we know the app name and FSSpec, we can call GetDiskFragment
+        // to get a connID to use in a subsequent call to FindSymbol (it will also
+        // return the address of “main” in app, which we ignore).  If GetDiskFragment 
+        // returns an error, we assume the app must be 68K.
+        //
+        Ptr mainAddr;   
+        Str255 errName;
+        result =  GetDiskFragment(infoRec.processAppSpec, 0L, 0L, infoRec.processName,
+                                  kLoadCFrag, &connID, (Ptr*)&mainAddr, errName);
+    }
 
-       if (result == noErr) 
-       {
-               //
-               // The app is a PPC code fragment, so call FindSymbol
-               // to get the exported “qd” symbol so we can access its
-               // QuickDraw globals.
-               //
-               CFragSymbolClass symClass;
-               result = FindSymbol(connID, "\pqd", (Ptr*)&gQDPtr, &symClass);
-               if (result != noErr) {  // this fails if we are in NS 6
-                       gQDPtr = &qd;           // so we default to the standard QD globals
-               }
-       }
-       else
-       {
-               //
-               // The app is 68K, so use its A5 to compute the address
-               // of its QuickDraw globals.
-               //
-               gQDPtr = (QDGlobals*)(*((long*)SetCurrentA5()) - (sizeof(QDGlobals) - sizeof(GrafPtr)));
-       }
+    if (result == noErr) 
+    {
+        //
+        // The app is a PPC code fragment, so call FindSymbol
+        // to get the exported “qd” symbol so we can access its
+        // QuickDraw globals.
+        //
+        CFragSymbolClass symClass;
+        result = FindSymbol(connID, "\pqd", (Ptr*)&gQDPtr, &symClass);
+        if (result != noErr) {  // this fails if we are in NS 6
+            gQDPtr = &qd;       // so we default to the standard QD globals
+        }
+    }
+    else
+    {
+        //
+        // The app is 68K, so use its A5 to compute the address
+        // of its QuickDraw globals.
+        //
+        gQDPtr = (QDGlobals*)(*((long*)SetCurrentA5()) - (sizeof(QDGlobals) - sizeof(GrafPtr)));
+    }
 #endif
 }
 
@@ -657,9 +879,13 @@ NPError main(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs, NPP_ShutdownU
 
 #if !TARGET_API_MAC_CARBON
 #pragma export on
-#if GENERATINGCFM
+
+#if TARGET_RT_MAC_CFM
+
 RoutineDescriptor mainRD = BUILD_ROUTINE_DESCRIPTOR(uppNPP_MainEntryProcInfo, main);
+
 #endif
+
 #pragma export off
 #endif /* !TARGET_API_MAC_CARBON */
 
@@ -669,113 +895,300 @@ DEFINE_API_C(int) main(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs, NPP
 DEFINE_API_C(NPError) main(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs, NPP_ShutdownUPP* unloadUpp)
 #endif
 {
-       EnterCodeResource();
-       PLUGINDEBUGSTR("\pmain");
+    EnterCodeResource();
+    PLUGINDEBUGSTR("\pmain");
 
 #ifdef __MWERKS__
-       __InitCode__();
+    __InitCode__();
 #endif
 
-       NPError err = NPERR_NO_ERROR;
-       
-       //
-       // Ensure that everything Netscape passed us is valid!
-       //
-       if ((nsTable == NULL) || (pluginFuncs == NULL) || (unloadUpp == NULL))
-               err = NPERR_INVALID_FUNCTABLE_ERROR;
-       
-       //
-       // Check the “major” version passed in Netscape’s function table.
-       // We won’t load if the major version is newer than what we expect.
-       // Also check that the function tables passed in are big enough for
-       // all the functions we need (they could be bigger, if Netscape added
-       // new APIs, but that’s OK with us -- we’ll just ignore them).
-       //
-       if (err == NPERR_NO_ERROR)
-       {
-               if ((nsTable->version >> 8) > NP_VERSION_MAJOR)         // Major version is in high byte
-                       err = NPERR_INCOMPATIBLE_VERSION_ERROR;
+    NPError err = NPERR_NO_ERROR;
+    
+    //
+    // Ensure that everything Netscape passed us is valid!
+    //
+    if ((nsTable == NULL) || (pluginFuncs == NULL) || (unloadUpp == NULL))
+        err = NPERR_INVALID_FUNCTABLE_ERROR;
+    
+    //
+    // Check the “major” version passed in Netscape’s function table.
+    // We won’t load if the major version is newer than what we expect.
+    // Also check that the function tables passed in are big enough for
+    // all the functions we need (they could be bigger, if Netscape added
+    // new APIs, but that’s OK with us -- we’ll just ignore them).
+    //
+    if (err == NPERR_NO_ERROR)
+    {
+        if ((nsTable->version >> 8) > NP_VERSION_MAJOR)     // Major version is in high byte
+            err = NPERR_INCOMPATIBLE_VERSION_ERROR;
+    }
+        
+    
+    if (err == NPERR_NO_ERROR)
+    {
+        //
+        // Copy all the fields of Netscape’s function table into our
+        // copy so we can call back into Netscape later.  Note that
+        // we need to copy the fields one by one, rather than assigning
+        // the whole structure, because the Netscape function table
+        // could actually be bigger than what we expect.
+        //
+        
+        int navMinorVers = nsTable->version & 0xFF;
+
+        gNetscapeFuncs.version          = nsTable->version;
+        gNetscapeFuncs.size             = nsTable->size;
+        gNetscapeFuncs.posturl          = (NPN_PostURLUPP)HOST_TO_PLUGIN_GLUE(posturl, nsTable->posturl);
+        gNetscapeFuncs.geturl           = (NPN_GetURLUPP)HOST_TO_PLUGIN_GLUE(geturl, nsTable->geturl);
+        gNetscapeFuncs.requestread      = (NPN_RequestReadUPP)HOST_TO_PLUGIN_GLUE(requestread, nsTable->requestread);
+        gNetscapeFuncs.newstream        = (NPN_NewStreamUPP)HOST_TO_PLUGIN_GLUE(newstream, nsTable->newstream);
+        gNetscapeFuncs.write            = (NPN_WriteUPP)HOST_TO_PLUGIN_GLUE(write, nsTable->write);
+        gNetscapeFuncs.destroystream    = (NPN_DestroyStreamUPP)HOST_TO_PLUGIN_GLUE(destroystream, nsTable->destroystream);
+        gNetscapeFuncs.status           = (NPN_StatusUPP)HOST_TO_PLUGIN_GLUE(status, nsTable->status);
+        gNetscapeFuncs.uagent           = (NPN_UserAgentUPP)HOST_TO_PLUGIN_GLUE(uagent, nsTable->uagent);
+        gNetscapeFuncs.memalloc         = (NPN_MemAllocUPP)HOST_TO_PLUGIN_GLUE(memalloc, nsTable->memalloc);
+        gNetscapeFuncs.memfree          = (NPN_MemFreeUPP)HOST_TO_PLUGIN_GLUE(memfree, nsTable->memfree);
+        gNetscapeFuncs.memflush         = (NPN_MemFlushUPP)HOST_TO_PLUGIN_GLUE(memflush, nsTable->memflush);
+        gNetscapeFuncs.reloadplugins    = (NPN_ReloadPluginsUPP)HOST_TO_PLUGIN_GLUE(reloadplugins, nsTable->reloadplugins);
+        if( navMinorVers >= NPVERS_HAS_LIVECONNECT )
+        {
+            gNetscapeFuncs.getJavaEnv   = (NPN_GetJavaEnvUPP)HOST_TO_PLUGIN_GLUE(getJavaEnv, nsTable->getJavaEnv);
+            gNetscapeFuncs.getJavaPeer  = (NPN_GetJavaPeerUPP)HOST_TO_PLUGIN_GLUE(getJavaPeer, nsTable->getJavaPeer);
+        }
+        if( navMinorVers >= NPVERS_HAS_NOTIFICATION )
+        {   
+            gNetscapeFuncs.geturlnotify = (NPN_GetURLNotifyUPP)HOST_TO_PLUGIN_GLUE(geturlnotify, nsTable->geturlnotify);
+            gNetscapeFuncs.posturlnotify    = (NPN_PostURLNotifyUPP)HOST_TO_PLUGIN_GLUE(posturlnotify, nsTable->posturlnotify);
+        }
+        gNetscapeFuncs.getvalue         = (NPN_GetValueUPP)HOST_TO_PLUGIN_GLUE(getvalue, nsTable->getvalue);
+        gNetscapeFuncs.setvalue         = (NPN_SetValueUPP)HOST_TO_PLUGIN_GLUE(setvalue, nsTable->setvalue);
+        gNetscapeFuncs.invalidaterect   = (NPN_InvalidateRectUPP)HOST_TO_PLUGIN_GLUE(invalidaterect, nsTable->invalidaterect);
+        gNetscapeFuncs.invalidateregion = (NPN_InvalidateRegionUPP)HOST_TO_PLUGIN_GLUE(invalidateregion, nsTable->invalidateregion);
+        gNetscapeFuncs.forceredraw      = (NPN_ForceRedrawUPP)HOST_TO_PLUGIN_GLUE(forceredraw, nsTable->forceredraw);
+        if( navMinorVers >= 14 )
+        {   
+           // NPRuntime support 
+           gNetscapeFuncs.getstringidentifier  = (NPN_GetStringIdentifierUPP)HOST_TO_PLUGIN_GLUE(getstringidentifier, nsTable->getstringidentifier);
+           gNetscapeFuncs.getstringidentifiers = (NPN_GetStringIdentifiersUPP)HOST_TO_PLUGIN_GLUE(getstringidentifiers, nsTable->getstringidentifiers);
+           gNetscapeFuncs.getintidentifier     = (NPN_GetIntIdentifierUPP)HOST_TO_PLUGIN_GLUE(getintidentifier, nsTable->getintidentifier);
+           gNetscapeFuncs.identifierisstring   = (NPN_IdentifierIsStringUPP)HOST_TO_PLUGIN_GLUE(identifierisstring, nsTable->identifierisstring);
+           gNetscapeFuncs.utf8fromidentifier   = (NPN_UTF8FromIdentifierUPP)HOST_TO_PLUGIN_GLUE(utf8fromidentifier, nsTable->utf8fromidentifier);
+           gNetscapeFuncs.intfromidentifier    = (NPN_IntFromIdentifierUPP)HOST_TO_PLUGIN_GLUE(intfromidentifier, nsTable->intfromidentifier);
+           gNetscapeFuncs.createobject         = (NPN_CreateObjectUPP)HOST_TO_PLUGIN_GLUE(createobject, nsTable->createobject);
+           gNetscapeFuncs.retainobject         = (NPN_RetainObjectUPP)HOST_TO_PLUGIN_GLUE(retainobject, nsTable->retainobject);
+           gNetscapeFuncs.releaseobject        = (NPN_ReleaseObjectUPP)HOST_TO_PLUGIN_GLUE(releaseobject, nsTable->releaseobject);
+           gNetscapeFuncs.invoke               = (NPN_InvokeUPP)HOST_TO_PLUGIN_GLUE(invoke, nsTable->invoke);
+           gNetscapeFuncs.invokeDefault        = (NPN_InvokeDefaultUPP)HOST_TO_PLUGIN_GLUE(invokeDefault, nsTable->invokeDefault);
+           gNetscapeFuncs.evaluate             = (NPN_EvaluateUPP)HOST_TO_PLUGIN_GLUE(evaluate, nsTable->evaluate);
+           gNetscapeFuncs.getproperty          = (NPN_GetPropertyUPP)HOST_TO_PLUGIN_GLUE(getproperty, nsTable->getproperty);
+           gNetscapeFuncs.setproperty          = (NPN_SetPropertyUPP)HOST_TO_PLUGIN_GLUE(setproperty, nsTable->setproperty);
+           gNetscapeFuncs.removeproperty       = (NPN_RemovePropertyUPP)HOST_TO_PLUGIN_GLUE(removeproperty, nsTable->removeproperty);
+           gNetscapeFuncs.hasproperty          = (NPN_HasPropertyUPP)HOST_TO_PLUGIN_GLUE(hasproperty, nsTable->hasproperty);
+           gNetscapeFuncs.hasmethod            = (NPN_HasMethodUPP)HOST_TO_PLUGIN_GLUE(hasmethod, nsTable->hasmethod);
+           gNetscapeFuncs.releasevariantvalue  = (NPN_ReleaseVariantValueUPP)HOST_TO_PLUGIN_GLUE(releasevariantvalue, nsTable->releasevariantvalue);
+           gNetscapeFuncs.setexception         = (NPN_SetExceptionUPP)HOST_TO_PLUGIN_GLUE(setexception, nsTable->setexception);
        }
-               
-       
-       if (err == NPERR_NO_ERROR)
-       {
-               //
-               // Copy all the fields of Netscape’s function table into our
-               // copy so we can call back into Netscape later.  Note that
-               // we need to copy the fields one by one, rather than assigning
-               // the whole structure, because the Netscape function table
-               // could actually be bigger than what we expect.
-               //
-               
-               int navMinorVers = nsTable->version & 0xFF;
-
-               gNetscapeFuncs.version          = nsTable->version;
-               gNetscapeFuncs.size             = nsTable->size;
-               gNetscapeFuncs.posturl          = (NPN_PostURLUPP)HOST_TO_PLUGIN_GLUE(posturl, nsTable->posturl);
-               gNetscapeFuncs.geturl           = (NPN_GetURLUPP)HOST_TO_PLUGIN_GLUE(geturl, nsTable->geturl);
-               gNetscapeFuncs.requestread      = (NPN_RequestReadUPP)HOST_TO_PLUGIN_GLUE(requestread, nsTable->requestread);
-               gNetscapeFuncs.newstream        = (NPN_NewStreamUPP)HOST_TO_PLUGIN_GLUE(newstream, nsTable->newstream);
-               gNetscapeFuncs.write            = (NPN_WriteUPP)HOST_TO_PLUGIN_GLUE(write, nsTable->write);
-               gNetscapeFuncs.destroystream    = (NPN_DestroyStreamUPP)HOST_TO_PLUGIN_GLUE(destroystream, nsTable->destroystream);
-               gNetscapeFuncs.status           = (NPN_StatusUPP)HOST_TO_PLUGIN_GLUE(status, nsTable->status);
-               gNetscapeFuncs.uagent           = (NPN_UserAgentUPP)HOST_TO_PLUGIN_GLUE(uagent, nsTable->uagent);
-               gNetscapeFuncs.memalloc         = (NPN_MemAllocUPP)HOST_TO_PLUGIN_GLUE(memalloc, nsTable->memalloc);
-               gNetscapeFuncs.memfree          = (NPN_MemFreeUPP)HOST_TO_PLUGIN_GLUE(memfree, nsTable->memfree);
-               gNetscapeFuncs.memflush         = (NPN_MemFlushUPP)HOST_TO_PLUGIN_GLUE(memflush, nsTable->memflush);
-               gNetscapeFuncs.reloadplugins    = (NPN_ReloadPluginsUPP)HOST_TO_PLUGIN_GLUE(reloadplugins, nsTable->reloadplugins);
-               if( navMinorVers >= NPVERS_HAS_LIVECONNECT )
-               {
-                       gNetscapeFuncs.getJavaEnv   = (NPN_GetJavaEnvUPP)HOST_TO_PLUGIN_GLUE(getJavaEnv, nsTable->getJavaEnv);
-                       gNetscapeFuncs.getJavaPeer  = (NPN_GetJavaPeerUPP)HOST_TO_PLUGIN_GLUE(getJavaPeer, nsTable->getJavaPeer);
-               }
-               if( navMinorVers >= NPVERS_HAS_NOTIFICATION )
-               {       
-                       gNetscapeFuncs.geturlnotify     = (NPN_GetURLNotifyUPP)HOST_TO_PLUGIN_GLUE(geturlnotify, nsTable->geturlnotify);
-                       gNetscapeFuncs.posturlnotify    = (NPN_PostURLNotifyUPP)HOST_TO_PLUGIN_GLUE(posturlnotify, nsTable->posturlnotify);
-               }
-               gNetscapeFuncs.getvalue         = (NPN_GetValueUPP)HOST_TO_PLUGIN_GLUE(getvalue, nsTable->getvalue);
-               gNetscapeFuncs.setvalue         = (NPN_SetValueUPP)HOST_TO_PLUGIN_GLUE(setvalue, nsTable->setvalue);
-               gNetscapeFuncs.invalidaterect   = (NPN_InvalidateRectUPP)HOST_TO_PLUGIN_GLUE(invalidaterect, nsTable->invalidaterect);
-               gNetscapeFuncs.invalidateregion = (NPN_InvalidateRegionUPP)HOST_TO_PLUGIN_GLUE(invalidateregion, nsTable->invalidateregion);
-               gNetscapeFuncs.forceredraw      = (NPN_ForceRedrawUPP)HOST_TO_PLUGIN_GLUE(forceredraw, nsTable->forceredraw);
-               
-               //
-               // Set up the plugin function table that Netscape will use to
-               // call us.  Netscape needs to know about our version and size
-               // and have a UniversalProcPointer for every function we implement.
-               //
-               pluginFuncs->version        = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR;
-               pluginFuncs->size           = sizeof(NPPluginFuncs);
-               pluginFuncs->newp           = NewNPP_NewProc(PLUGIN_TO_HOST_GLUE(newp, Private_New));
-               pluginFuncs->destroy        = NewNPP_DestroyProc(PLUGIN_TO_HOST_GLUE(destroy, Private_Destroy));
-               pluginFuncs->setwindow      = NewNPP_SetWindowProc(PLUGIN_TO_HOST_GLUE(setwindow, Private_SetWindow));
-               pluginFuncs->newstream      = NewNPP_NewStreamProc(PLUGIN_TO_HOST_GLUE(newstream, Private_NewStream));
-               pluginFuncs->destroystream  = NewNPP_DestroyStreamProc(PLUGIN_TO_HOST_GLUE(destroystream, Private_DestroyStream));
-               pluginFuncs->asfile         = NewNPP_StreamAsFileProc(PLUGIN_TO_HOST_GLUE(asfile, Private_StreamAsFile));
-               pluginFuncs->writeready     = NewNPP_WriteReadyProc(PLUGIN_TO_HOST_GLUE(writeready, Private_WriteReady));
-               pluginFuncs->write          = NewNPP_WriteProc(PLUGIN_TO_HOST_GLUE(write, Private_Write));
-               pluginFuncs->print          = NewNPP_PrintProc(PLUGIN_TO_HOST_GLUE(print, Private_Print));
-               pluginFuncs->event          = NewNPP_HandleEventProc(PLUGIN_TO_HOST_GLUE(event, Private_HandleEvent));  
-               pluginFuncs->getvalue       = NewNPP_GetValueProc(PLUGIN_TO_HOST_GLUE(getvalue, Private_GetValue));     
-               if( navMinorVers >= NPVERS_HAS_NOTIFICATION )
-               {       
-                       pluginFuncs->urlnotify = NewNPP_URLNotifyProc(PLUGIN_TO_HOST_GLUE(urlnotify, Private_URLNotify));                       
-               }
+
+        //
+        // Set up the plugin function table that Netscape will use to
+        // call us.  Netscape needs to know about our version and size
+        // and have a UniversalProcPointer for every function we implement.
+        //
+        pluginFuncs->version        = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR;
+        pluginFuncs->size           = sizeof(NPPluginFuncs);
+        pluginFuncs->newp           = NewNPP_NewProc(PLUGIN_TO_HOST_GLUE(newp, Private_New));
+        pluginFuncs->destroy        = NewNPP_DestroyProc(PLUGIN_TO_HOST_GLUE(destroy, Private_Destroy));
+        pluginFuncs->setwindow      = NewNPP_SetWindowProc(PLUGIN_TO_HOST_GLUE(setwindow, Private_SetWindow));
+        pluginFuncs->newstream      = NewNPP_NewStreamProc(PLUGIN_TO_HOST_GLUE(newstream, Private_NewStream));
+        pluginFuncs->destroystream  = NewNPP_DestroyStreamProc(PLUGIN_TO_HOST_GLUE(destroystream, Private_DestroyStream));
+        pluginFuncs->asfile         = NewNPP_StreamAsFileProc(PLUGIN_TO_HOST_GLUE(asfile, Private_StreamAsFile));
+        pluginFuncs->writeready     = NewNPP_WriteReadyProc(PLUGIN_TO_HOST_GLUE(writeready, Private_WriteReady));
+        pluginFuncs->write          = NewNPP_WriteProc(PLUGIN_TO_HOST_GLUE(write, Private_Write));
+        pluginFuncs->print          = NewNPP_PrintProc(PLUGIN_TO_HOST_GLUE(print, Private_Print));
+        pluginFuncs->event          = NewNPP_HandleEventProc(PLUGIN_TO_HOST_GLUE(event, Private_HandleEvent));  
+        pluginFuncs->getvalue       = NewNPP_GetValueProc(PLUGIN_TO_HOST_GLUE(getvalue, Private_GetValue)); 
+        if( navMinorVers >= NPVERS_HAS_NOTIFICATION )
+        {   
+            pluginFuncs->urlnotify = NewNPP_URLNotifyProc(PLUGIN_TO_HOST_GLUE(urlnotify, Private_URLNotify));           
+        }
 #ifdef OJI
-               if( navMinorVers >= NPVERS_HAS_LIVECONNECT )
-               {
-                       pluginFuncs->javaClass  = (JRIGlobalRef) Private_GetJavaClass();
-               }
+        if( navMinorVers >= NPVERS_HAS_LIVECONNECT )
+        {
+            pluginFuncs->javaClass  = (JRIGlobalRef) Private_GetJavaClass();
+        }
 #else
-                pluginFuncs->javaClass = NULL;
+        pluginFuncs->javaClass = NULL;
 #endif
-               *unloadUpp = NewNPP_ShutdownProc(PLUGIN_TO_HOST_GLUE(shutdown, Private_Shutdown));
+        *unloadUpp = NewNPP_ShutdownProc(PLUGIN_TO_HOST_GLUE(shutdown, Private_Shutdown));
 
-               SetUpQD();
-               err = Private_Initialize();
-       }
-       
-       ExitCodeResource();
-       return err;
+        SetUpQD();
+        err = Private_Initialize();
+    }
+    
+    ExitCodeResource();
+    return err;
 }
+
+#ifdef __MACH__
+
+/*
+** netscape plugins functions when building Mach-O binary
+*/
+
+extern "C" {
+    NPError NP_Initialize(NPNetscapeFuncs* nsTable);
+    NPError NP_GetEntryPoints(NPPluginFuncs* pluginFuncs);
+    NPError NP_Shutdown(void);
+}
+
+/*
+** netscape plugins functions when using Mach-O binary
+*/
+
+NPError NP_Initialize(NPNetscapeFuncs* nsTable)
+{
+    PLUGINDEBUGSTR("\pNP_Initialize");
+    
+    /* validate input parameters */
+
+    if( NULL == nsTable  )
+        return NPERR_INVALID_FUNCTABLE_ERROR;
+    
+    /*
+     * Check the major version passed in Netscape's function table.
+     * We won't load if the major version is newer than what we expect.
+     * Also check that the function tables passed in are big enough for
+     * all the functions we need (they could be bigger, if Netscape added
+     * new APIs, but that's OK with us -- we'll just ignore them).
+     *
+     */
+
+    if ((nsTable->version >> 8) > NP_VERSION_MAJOR)
+        return NPERR_INCOMPATIBLE_VERSION_ERROR;
+
+    if (nsTable->size < sizeof(NPNetscapeFuncs))
+        return NPERR_INVALID_FUNCTABLE_ERROR;
+        
+    
+    int navMinorVers = nsTable->version & 0xFF;
+
+    /*
+     * Copy all the fields of Netscape function table into our
+     * copy so we can call back into Netscape later.  Note that
+     * we need to copy the fields one by one, rather than assigning
+     * the whole structure, because the Netscape function table
+     * could actually be bigger than what we expect.
+     */
+    gNetscapeFuncs.version       = nsTable->version;
+    gNetscapeFuncs.size          = nsTable->size;
+    gNetscapeFuncs.posturl       = nsTable->posturl;
+    gNetscapeFuncs.geturl        = nsTable->geturl;
+    gNetscapeFuncs.requestread   = nsTable->requestread;
+    gNetscapeFuncs.newstream     = nsTable->newstream;
+    gNetscapeFuncs.write         = nsTable->write;
+    gNetscapeFuncs.destroystream = nsTable->destroystream;
+    gNetscapeFuncs.status        = nsTable->status;
+    gNetscapeFuncs.uagent        = nsTable->uagent;
+    gNetscapeFuncs.memalloc      = nsTable->memalloc;
+    gNetscapeFuncs.memfree       = nsTable->memfree;
+    gNetscapeFuncs.memflush      = nsTable->memflush;
+    gNetscapeFuncs.reloadplugins = nsTable->reloadplugins;
+    if( navMinorVers >= NPVERS_HAS_LIVECONNECT )
+    {
+        gNetscapeFuncs.getJavaEnv   = nsTable->getJavaEnv;
+        gNetscapeFuncs.getJavaPeer  = nsTable->getJavaPeer;
+    }
+    if( navMinorVers >= NPVERS_HAS_NOTIFICATION )
+    {    
+        gNetscapeFuncs.geturlnotify     = nsTable->geturlnotify;
+        gNetscapeFuncs.posturlnotify    = nsTable->posturlnotify;
+    }
+
+    gNetscapeFuncs.getvalue         = nsTable->getvalue;
+    gNetscapeFuncs.setvalue         = nsTable->setvalue;
+    gNetscapeFuncs.invalidaterect   = nsTable->invalidaterect;
+    gNetscapeFuncs.invalidateregion = nsTable->invalidateregion;
+    gNetscapeFuncs.forceredraw      = nsTable->forceredraw;
+    if( navMinorVers >= 14 )
+    {   
+       // NPRuntime support 
+       gNetscapeFuncs.getstringidentifier  = nsTable->getstringidentifier;
+       gNetscapeFuncs.getstringidentifiers = nsTable->getstringidentifiers;
+       gNetscapeFuncs.getintidentifier     = nsTable->getintidentifier;
+       gNetscapeFuncs.identifierisstring   = nsTable->identifierisstring;
+       gNetscapeFuncs.utf8fromidentifier   = nsTable->utf8fromidentifier;
+       gNetscapeFuncs.intfromidentifier    = nsTable->intfromidentifier;
+       gNetscapeFuncs.createobject         = nsTable->createobject;
+       gNetscapeFuncs.retainobject         = nsTable->retainobject;
+       gNetscapeFuncs.releaseobject        = nsTable->releaseobject;
+       gNetscapeFuncs.invoke               = nsTable->invoke;
+       gNetscapeFuncs.invokeDefault        = nsTable->invokeDefault;
+       gNetscapeFuncs.evaluate             = nsTable->evaluate;
+       gNetscapeFuncs.getproperty          = nsTable->getproperty;
+       gNetscapeFuncs.setproperty          = nsTable->setproperty;
+       gNetscapeFuncs.removeproperty       = nsTable->removeproperty;
+       gNetscapeFuncs.hasproperty          = nsTable->hasproperty;
+       gNetscapeFuncs.hasmethod            = nsTable->hasmethod;
+       gNetscapeFuncs.releasevariantvalue  = nsTable->releasevariantvalue;
+       gNetscapeFuncs.setexception         = nsTable->setexception;
+    }
+    return NPP_Initialize();
+}
+
+NPError NP_GetEntryPoints(NPPluginFuncs* pluginFuncs)
+{
+    int navMinorVers = gNetscapeFuncs.version & 0xFF;
+
+    PLUGINDEBUGSTR("\pNP_GetEntryPoints");
+
+    if( pluginFuncs == NULL )
+        return NPERR_INVALID_FUNCTABLE_ERROR;
+
+    /*if (pluginFuncs->size < sizeof(NPPluginFuncs)) 
+    return NPERR_INVALID_FUNCTABLE_ERROR;*/
+
+    /*
+     * Set up the plugin function table that Netscape will use to
+     * call us.  Netscape needs to know about our version and size
+     * and have a UniversalProcPointer for every function we
+     * implement.
+     */
+
+    pluginFuncs->version    = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR;
+    pluginFuncs->size       = sizeof(NPPluginFuncs);
+    pluginFuncs->newp       = Private_New;
+    pluginFuncs->destroy    = NewNPP_DestroyProc(Private_Destroy);
+    pluginFuncs->setwindow  = NewNPP_SetWindowProc(Private_SetWindow);
+    pluginFuncs->newstream  = NewNPP_NewStreamProc(Private_NewStream);
+    pluginFuncs->destroystream = NewNPP_DestroyStreamProc(Private_DestroyStream);
+    pluginFuncs->asfile     = NewNPP_StreamAsFileProc(Private_StreamAsFile);
+    pluginFuncs->writeready = NewNPP_WriteReadyProc(Private_WriteReady);
+    pluginFuncs->write      = NewNPP_WriteProc(Private_Write);
+    pluginFuncs->print      = NewNPP_PrintProc(Private_Print);
+    pluginFuncs->event      = NewNPP_HandleEventProc(Private_HandleEvent);
+    pluginFuncs->getvalue   = NewNPP_GetValueProc(Private_GetValue);
+    pluginFuncs->setvalue   = NewNPP_SetValueProc(Private_SetValue);
+    if( navMinorVers >= NPVERS_HAS_NOTIFICATION )
+    {    
+        pluginFuncs->urlnotify = Private_URLNotify;         
+    }
+#ifdef OJI
+    if( navMinorVers >= NPVERS_HAS_LIVECONNECT )
+    {
+        pluginFuncs->javaClass  = (JRIGlobalRef) Private_GetJavaClass();
+    }
+#else
+    pluginFuncs->javaClass = NULL;
+#endif
+
+    return NPERR_NO_ERROR;
+}
+
+NPError NP_Shutdown(void)
+{
+    PLUGINDEBUGSTR("\pNP_Shutdown");
+    NPP_Shutdown();
+    return NPERR_NO_ERROR;
+}
+
+#endif
index 804395e..83ad927 100644 (file)
@@ -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", "",
     };
 };
 
index 3446e6b..c5ee26a 100644 (file)
@@ -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
index 5310ef2..1c9d2fe 100644 (file)
@@ -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;
-}
-
index 4a96cca..4ff52ef 100644 (file)
 /*******************************************************************************
  * 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
diff --git a/mozilla/vlcruntime.cpp b/mozilla/vlcruntime.cpp
new file mode 100755 (executable)
index 0000000..40927a8
--- /dev/null
@@ -0,0 +1,358 @@
+#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;
+}
+
diff --git a/mozilla/vlcruntime.h b/mozilla/vlcruntime.h
new file mode 100755 (executable)
index 0000000..654d8a9
--- /dev/null
@@ -0,0 +1,261 @@
+/*****************************************************************************
+ * 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);
+};
+
index 73ff4b8..0ee8f90 100644 (file)
 #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 */