static
NPError MyNPP_SetWindow(NPP instance, NPWindow* window)
{
NPError err;
NPSetWindowCallbackStruct *win_info;
DEB(ef, "-> NPP_SetWindow( %x, 0x%x )\n", instance, window);
DEB(ef, "window->window = 0x%x\n", window->window);
DEB(ef, "window->x = %d\n", window->x);
DEB(ef, "window->y = %d\n", window->y);
DEB(ef, "window->width = %d\n", window->width);
DEB(ef, "window->height = %d\n", window->height);
DEB(ef, "window->ws_info = 0x%x\n", window->ws_info);
DEB(ef, "window->type = 0x%x\n", window->type);
win_info = (NPSetWindowCallbackStruct*)window->ws_info;
DEB(ef, "win_info->type = %d\n", win_info->type);
DEB(ef, "win_info->display = 0x%x\n", win_info->display);
DEB(ef, "win_info->visual = 0x%x\n", win_info->visual);
DEB(ef, "win_info->colormap = 0x%x\n", win_info->colormap);
DEB(ef, "win_info->depth = %d\n", win_info->depth);
err = gPluginFuncs.setwindow( instance, window );
DEB(ef, "<- NPP_SetWindow = %d\n", err);
return err;
}
static
void MyNPP_Print(NPP instance, NPPrint* platformPrint)
{
DEB(ef, "-> NPP_Print( %x, 0x%x )\n", instance, platformPrint );
gPluginFuncs.print( instance, platformPrint );
DEB(ef, "<- NPP_Print\n");
}
static
void MyNPP_URLNotify(NPP instance, const char* url,
NPReason reason, void* notifyData)
{
DEB(ef, "-> NPP_URLNotify( %x, %s, %d, 0x%x )\n", instance, url, reason, notifyData );
gPluginFuncs.urlnotify( instance, url, reason, notifyData );
DEB(ef, "<- NPP_URLNotify\n");
}
static
void MyNPP_StreamAsFile(NPP instance, NPStream* stream,
const char* fname)
{
DEB(ef, "-> NPP_StreamAsFile( %x, 0x%x, %s )\n", instance, stream, fname);
gPluginFuncs.asfile( instance, stream, fname );
DEB(ef, "<- NPP_StreamAsFile\n");
}
static
NPError MyNPP_SetValue(void *instance, NPNVariable variable, void *value)
{
NPError err;
DEB(ef, "-> NPP_SetValue( %x, %d, 0x%x )\n", instance, variable, value);
err = gPluginFuncs.getvalue( instance, variable, value );
DEB(ef, "<- NPP_SetValue = %d\n", err);
return err;
}
static
int16 MyNPP_HandleEvent(NPP instance, void* event)
{
int16 ret;
DEB(ef, "-> NPP_HandleEvent( %x, 0x%x )\n", instance, event);
ret = gPluginFuncs.event( instance, event );
DEB(ef, "<- NPP_HandleEvent = %d\n", ret);
return ret;
}
static
int32 MyNPP_WriteReady(NPP instance, NPStream* stream)
{
int32 ret;
DEB(ef, "-> NPP_WriteReady( %x, 0x%x )\n", instance, stream);
ret = gPluginFuncs.writeready( instance, stream );
DEB(ef, "<- NPP_WriteReady = %d\n", ret);
return ret;
}
static
NPError MyNPP_Destroy(NPP instance, NPSavedData** save)
{
NPError err;
DEB(ef, "-> NPP_Destrpy( %x, 0x%x )\n", instance, save);
err = gPluginFuncs.destroy( instance, save );
DEB(ef, "<- NPP_Destroy = %d\n", err);
return err;
}
static
int32 MyNPP_Write(NPP instance, NPStream* stream, int32 offset,
int32 len, void* buffer)
{
int32 ret;
DEB(ef, "-> NPP_Write( %x, 0x%x, %d, %d, 0x%x )\n", instance, stream, offset, len, buffer);
ret = gPluginFuncs.write( instance, stream, offset, len, buffer );
DEB(ef, "<- NPP_Write = %d\n", ret);
return ret;
}
static
NPError MyNPP_DestroyStream(NPP instance, NPStream* stream,
NPReason reason)
{
NPError err;
DEB(ef, "-> NPP_DestroyStream( %x, 0x%x, %d )\n", instance, stream, reason);
err = gPluginFuncs.destroystream( instance, stream, reason );
DEB(ef, "<- NPP_DestroyStream = %d\n", err);
return err;
}
static
NPError MyNPP_New(NPMIMEType pluginType, NPP instance,
uint16 mode, int16 argc, char* argn[],
char* argv[], NPSavedData* saved)
{
NPError err;
int n;
DEB(ef, "-> NPP_New( %s, 0x%x, %d, %d, .., .., 0x%x )\n", pluginType, instance, mode, argc, saved);
for ( n=0; n<argc; n++ ) {
DEB(ef, "%s=%s\n", argn[n], argv[n] );
}
err = gPluginFuncs.newp( pluginType, instance, mode, argc, argn, argv, saved );
DEB(ef, "<- NPP_New = %d\n", err);
return err;
}
static
NPError MyNPP_NewStream(NPP instance, NPMIMEType type,
NPStream* stream, NPBool seekable,
uint16* stype)
{
NPError err;
DEB(ef, "-> NPP_NewStream( %x, %s, 0x%x, %d, 0x%x )\n", instance, type, stream, seekable, stype);
DEB(ef, "stream->ndata = 0x%x\n", stream->ndata);
DEB(ef, "stream->url = %s\n", stream->url );
DEB(ef, "stream->end = %d\n", stream->end );
DEB(ef, "stream->pdata = 0x%x\n", stream->pdata );
DEB(ef, "stream->lastmodified = %d\n", stream->lastmodified );
DEB(ef, "stream->notifyData = 0x%x\n", stream->notifyData );
err = gPluginFuncs.newstream( instance, type, stream, seekable, stype );
DEB(ef, "<- NPP_NewStream = %d\n", err);
DEB(ef, "stype = %d\n", *stype);
return err;
}
void nsPluginThread::dispatch()
{
dbgOut2("nsPluginThread::dispatch: %s", FormatAction(mAction));
switch (mAction) {
case action_npp_new:
pluginNPPFuncs.newp((NPMIMEType)mP1, (NPP)mP2, (uint16)mP3, (int16)mP4, (char**)mP5, (char**)mP6, (NPSavedData*)mP7);
break;
case action_npp_destroy:
pluginNPPFuncs.destroy((NPP)mP1, (NPSavedData**)mP2);
break;
case action_npp_set_window:
pluginNPPFuncs.setwindow((NPP)mP1, (NPWindow*)mP2);
break;
case action_npp_new_stream:
pluginNPPFuncs.newstream((NPP)mP1, (NPMIMEType)mP2, (NPStream*)mP3, (NPBool)mP4, (uint16*)mP5);
break;
case action_npp_destroy_stream:
{
NPStream * stream = (NPStream *)mP2;
pluginNPPFuncs.destroystream((NPP)mP1, stream, (NPError)mP3);
break;
}
case action_npp_stream_as_file:
{
NPStream * stream = (NPStream *)mP2;
pluginNPPFuncs.asfile((NPP)mP1, stream, (char*)mP3);
break;
}
case action_npp_write_ready:
pluginNPPFuncs.writeready((NPP)mP1, (NPStream *)mP2);
break;
case action_npp_write:
pluginNPPFuncs.write((NPP)mP1, (NPStream *)mP2, (int32)mP3, (int32)mP4, (void *)mP5);
break;
case action_npp_print:
pluginNPPFuncs.print((NPP)mP1, (NPPrint*)mP2);
break;
case action_npp_handle_event:
pluginNPPFuncs.event((NPP)mP1, (void *)mP2);
break;
case action_npp_url_notify:
pluginNPPFuncs.urlnotify((NPP)mP1, (const char*)mP2, (NPReason)mP3, (void*)mP4);
break;
case action_npp_get_java_class:
//pluginNPPFuncs.javaClass;
break;
case action_npp_get_value:
pluginNPPFuncs.getvalue((NPP)mP1, (NPPVariable)mP2, (void *)mP3);
break;
case action_npp_set_value:
pluginNPPFuncs.setvalue((NPP)mP1, (NPNVariable)mP2, (void *)mP3);
break;
default:
dbgOut1("Unexpected action!");
break;
}
}
