From 4ef6544ecca1803b48985882b1e0e769257b1c93 Mon Sep 17 00:00:00 2001 From: Marco Pesenti Gritti Date: Fri, 13 Mar 2009 20:59:34 +0000 Subject: Add a browser plugin implementation. --- (limited to 'browser-plugin/glue.cpp') diff --git a/browser-plugin/glue.cpp b/browser-plugin/glue.cpp new file mode 100644 index 0000000..f7df522 --- /dev/null +++ b/browser-plugin/glue.cpp @@ -0,0 +1,477 @@ +/* this file is part of evince, a gnome document viewer + * + * Copyright (C) 2009 litl, LLC + * + * Evince 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. + * + * Evince is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include + +#include "evince-view.h" +#include "plugin.h" + +#ifndef HIBYTE +#define HIBYTE(x) ((((uint32_t)(x)) & 0xff00) >> 8) +#endif + +#ifndef LOBYTE +#define LOBYTE(W) ((W) & 0xFF) +#endif + +NPNetscapeFuncs NPNFuncs; + +char * +NP_GetMIMEDescription (void) +{ + ev_init (); + + GString *desc = g_string_new (NULL); + GList *all_types = ev_backends_manager_get_all_types_info (); + + for (GList *l = all_types; l; l = g_list_next (l)){ + EvTypeInfo *info = (EvTypeInfo *)l->data; + const char *mime; + int i = 0; + + while ((mime = info->mime_types[i++])) { + g_string_append_printf (desc, "%s:%s:;", mime, info->desc); + } + } + + return g_string_free (desc, FALSE); +} + +NPError +NP_Initialize (NPNetscapeFuncs *aNPNFuncs, NPPluginFuncs *aNPPFuncs) +{ + /* We need to force libevview to stay in memory because unloading breaks + gobject type registration and possibly other things. */ + void *handle; + handle = dlopen ("libevview.so.1.0.0", RTLD_NOW | RTLD_NODELETE); + if (!handle) { + return NPERR_MODULE_LOAD_FAILED_ERROR; + } + dlclose (handle); + + ev_init (); + + if (aNPNFuncs == NULL || aNPPFuncs == NULL) { + return NPERR_INVALID_FUNCTABLE_ERROR; + } + + if ((aNPNFuncs->version >> 8) > NP_VERSION_MAJOR) { + return NPERR_INCOMPATIBLE_VERSION_ERROR; + } + + if (aNPNFuncs->size < sizeof (NPNetscapeFuncs)) { + return NPERR_INVALID_FUNCTABLE_ERROR; + } + + if (aNPPFuncs->size < sizeof (NPPluginFuncs)) { + return NPERR_INVALID_FUNCTABLE_ERROR; + } + + memcpy (&NPNFuncs, aNPNFuncs, sizeof (NPNetscapeFuncs)); + NPNFuncs.size = sizeof (NPNetscapeFuncs); + + aNPPFuncs->size = sizeof (NPPluginFuncs); + aNPPFuncs->version = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR; + aNPPFuncs->newp = NewNPP_NewProc (NPP_New); + aNPPFuncs->getvalue = NewNPP_GetValueProc (NPP_GetValue); + aNPPFuncs->setvalue = NewNPP_SetValueProc (NPP_SetValue); + aNPPFuncs->setwindow = NewNPP_SetWindowProc (NPP_SetWindow); + aNPPFuncs->destroy = NewNPP_DestroyProc (NPP_Destroy); + aNPPFuncs->newstream = NewNPP_NewStreamProc (NPP_NewStream); + aNPPFuncs->destroystream = NewNPP_DestroyStreamProc (NPP_DestroyStream); + aNPPFuncs->asfile = NewNPP_StreamAsFileProc (NPP_StreamAsFile); + aNPPFuncs->writeready = NewNPP_WriteReadyProc (NPP_WriteReady); + aNPPFuncs->write = NewNPP_WriteProc (NPP_Write); + aNPPFuncs->print = NewNPP_PrintProc (NPP_Print); + aNPPFuncs->event = NewNPP_HandleEventProc (NPP_HandleEvent); + aNPPFuncs->urlnotify = NewNPP_URLNotifyProc (NPP_URLNotify); + + return NPERR_NO_ERROR; +} + +NPError +NP_Shutdown (void) +{ + return NPERR_NO_ERROR; +} + +NPError +NPP_NewStream (NPP instance, NPMIMEType type, + NPStream* stream, NPBool seekable, + uint16* stype) +{ + *stype = NP_ASFILEONLY; + + return NPERR_NO_ERROR; +} + +NPError +NPP_DestroyStream (NPP instance, NPStream* stream, NPReason reason) +{ + return NPERR_NO_ERROR; +} + +int32 +NPP_WriteReady (NPP instance, NPStream* stream) +{ + return -1; +} + +int32 NPP_Write (NPP instance, NPStream* stream, + int32 offset, int32 len, void* buffer) +{ + return -1; +} + +void NPP_StreamAsFile (NPP instance, NPStream* stream, const char* fname) +{ + Plugin *plugin = reinterpret_cast (instance->pdata); + plugin->Load (fname); +} + +void NPP_Print (NPP instance, NPPrint* platformPrint) +{ +} + +int16 NPP_HandleEvent (NPP instance, void* event) +{ + return FALSE; +} + +void +NPP_URLNotify (NPP instance, const char* url, NPReason reason, void* notifyData) +{ +} + +NPError NPP_SetValue (NPP instance, NPNVariable variable, void *value) +{ + return NPERR_NO_ERROR; +} + +NPError +NPP_New (NPMIMEType mimetype, + NPP instance, + uint16_t mode, + int16_t argc, + char *argn[], + char *argv[], + NPSavedData *savedData) +{ + Plugin *plugin = new Plugin (instance); + instance->pdata = reinterpret_cast (plugin); + + return NPERR_NO_ERROR; +} + +NPError +NPP_Destroy (NPP instance, NPSavedData** save) +{ + Plugin *plugin = reinterpret_cast (instance->pdata); + + delete plugin; + + return NPERR_NO_ERROR; +} + +NPError +NPP_GetValue(NPP instance, NPPVariable variable, void *value) +{ + NPError err = NPERR_NO_ERROR; + Plugin *plugin = reinterpret_cast (instance->pdata); + + switch (variable) { + case NPPVpluginNeedsXEmbed: + *(PRBool *)value = PR_TRUE; + break; + case NPPVpluginScriptableNPObject: + *(NPObject **)value = plugin->GetScriptableNPObject (); + break; + + default: + err = NPERR_GENERIC_ERROR; + } + + return err; +} + +NPError +NPP_SetWindow (NPP instance, NPWindow *window) +{ + Plugin *plugin = reinterpret_cast (instance->pdata); + plugin->SetWindow ((GdkNativeWindow)window->window); + + return NPERR_NO_ERROR; +} + +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 = HIBYTE (NPNFuncs.version); + *netscape_minor = LOBYTE (NPNFuncs.version); +} + +NPError NPN_GetURLNotify (NPP instance, const char *url, + const char *target, void *notifyData) +{ + return NPNFuncs.geturlnotify (instance, url, target, notifyData); +} + +NPError NPN_GetURL (NPP instance, const char *url, const char *target) +{ + return NPNFuncs.geturl (instance, url, target); +} + +NPError NPN_PostURLNotify (NPP instance, const char *url, const char *window, + uint32_t len, const char *buf, NPBool file, + void *notifyData) +{ + return NPNFuncs.posturlnotify (instance, url, window, + len, buf, file, notifyData); +} + +NPError NPN_PostURL (NPP instance, const char *url, const char *window, + uint32_t len, const char *buf, NPBool file) +{ + return NPNFuncs.posturl (instance, url, window, len, buf, file); +} + +NPError NPN_RequestRead (NPStream* stream, NPByteRange* rangeList) +{ + return NPNFuncs.requestread (stream, rangeList); +} + +NPError NPN_NewStream (NPP instance, NPMIMEType type, + const char *target, NPStream **stream) +{ + return NPNFuncs.newstream (instance, type, target, stream); +} + +int32_t NPN_Write (NPP instance, NPStream *stream, int32_t len, void *buffer) +{ + return NPNFuncs.write (instance, stream, len, buffer); +} + +NPError NPN_DestroyStream (NPP instance, NPStream* stream, NPError reason) +{ + return NPNFuncs.destroystream (instance, stream, reason); +} + +void NPN_Status (NPP instance, const char *message) +{ + NPNFuncs.status (instance, message); +} + +const char* NPN_UserAgent(NPP instance) +{ + return NPNFuncs.uagent (instance); +} + +void* NPN_MemAlloc (uint32 size) +{ + return NPNFuncs.memalloc (size); +} + +void NPN_MemFree (void* ptr) +{ + /* Make it null-safe */ + if (!ptr) + return; + + NPNFuncs.memfree (ptr); +} + +uint32_t NPN_MemFlush (uint32_t size) +{ + return NPNFuncs.memflush (size); +} + +void NPN_ReloadPlugins (NPBool reloadPages) +{ + NPNFuncs.reloadplugins (reloadPages); +} + +JRIEnv* NPN_GetJavaEnv (void) +{ + return NPNFuncs.getJavaEnv (); +} + +jref NPN_GetJavaPeer (NPP instance) +{ + return NPNFuncs.getJavaPeer (instance); +} + +NPError NPN_GetValue (NPP instance, NPNVariable variable, void *value) +{ + return NPNFuncs.getvalue (instance, variable, value); +} + +NPError NPN_SetValue (NPP instance, NPPVariable variable, void *value) +{ + return NPNFuncs.setvalue (instance, variable, value); +} + +void NPN_InvalidateRect (NPP instance, NPRect *invalidRect) +{ + NPNFuncs.invalidaterect (instance, invalidRect); +} + +void NPN_InvalidateRegion (NPP instance, NPRegion invalidRegion) +{ + NPNFuncs.invalidateregion (instance, invalidRegion); +} + +void NPN_ForceRedraw (NPP instance) +{ + NPNFuncs.forceredraw (instance); +} + +NPIdentifier NPN_GetStringIdentifier (const NPUTF8 *name) +{ + return NPNFuncs.getstringidentifier (name); +} + +void NPN_GetStringIdentifiers (const NPUTF8 **names, int32_t nameCount, + NPIdentifier *identifiers) +{ + return NPNFuncs.getstringidentifiers (names, nameCount, identifiers); +} + +NPIdentifier NPN_GetStringIdentifier (int32_t intid) +{ + return NPNFuncs.getintidentifier (intid); +} + +bool NPN_IdentifierIsString (NPIdentifier identifier) +{ + return NPNFuncs.identifierisstring (identifier); +} + +NPUTF8 *NPN_UTF8FromIdentifier (NPIdentifier identifier) +{ + return NPNFuncs.utf8fromidentifier (identifier); +} + +int32_t NPN_IntFromIdentifier (NPIdentifier identifier) +{ + return NPNFuncs.intfromidentifier (identifier); +} + +NPObject *NPN_CreateObject (NPP npp, NPClass *aClass) +{ + return NPNFuncs.createobject (npp, aClass); +} + +NPObject *NPN_RetainObject (NPObject *obj) +{ + return NPNFuncs.retainobject (obj); +} + +void NPN_ReleaseObject(NPObject *obj) +{ + return NPNFuncs.releaseobject (obj); +} + +bool NPN_Invoke (NPP npp, NPObject *obj, NPIdentifier methodName, + const NPVariant *args, uint32_t argCount, NPVariant *result) +{ + return NPNFuncs.invoke (npp, obj, methodName, args, argCount, result); +} + +bool NPN_InvokeDefault (NPP npp, NPObject *obj, const NPVariant *args, + uint32_t argCount, NPVariant *result) +{ + return NPNFuncs.invokeDefault (npp, obj, args, argCount, result); +} + +bool NPN_Evaluate (NPP npp, NPObject *obj, NPString *script, + NPVariant *result) +{ + return NPNFuncs.evaluate (npp, obj, script, result); +} + +bool NPN_GetProperty (NPP npp, NPObject *obj, NPIdentifier propertyName, + NPVariant *result) +{ + return NPNFuncs.getproperty (npp, obj, propertyName, result); +} + +bool NPN_SetProperty (NPP npp, NPObject *obj, NPIdentifier propertyName, + const NPVariant *value) +{ + return NPNFuncs.setproperty (npp, obj, propertyName, value); +} + +bool NPN_RemoveProperty (NPP npp, NPObject *obj, NPIdentifier propertyName) +{ + return NPNFuncs.removeproperty (npp, obj, propertyName); +} + +bool NPN_Enumerate (NPP npp, NPObject *obj, NPIdentifier **identifier, + uint32_t *count) +{ + return NPNFuncs.enumerate (npp, obj, identifier, count); +} + +bool NPN_Construct (NPP npp, NPObject *obj, const NPVariant *args, + uint32_t argCount, NPVariant *result) +{ + return NPNFuncs.construct (npp, obj, args, argCount, result); +} + +bool NPN_HasProperty (NPP npp, NPObject *obj, NPIdentifier propertyName) +{ + return NPNFuncs.hasproperty (npp, obj, propertyName); +} + +bool NPN_HasMethod (NPP npp, NPObject *obj, NPIdentifier methodName) +{ + return NPNFuncs.hasmethod (npp, obj, methodName); +} + +void NPN_ReleaseVariantValue (NPVariant *variant) +{ + NPNFuncs.releasevariantvalue (variant); +} + +void NPN_SetException (NPObject *obj, const NPUTF8 *message) +{ + NPNFuncs.setexception (obj, message); +} + +void* NPN_MemDup (const void *aMem, uint32 aLen) +{ + if (!aMem || !aLen) { + return NULL; + } + + void *dup = NPN_MemAlloc (aLen); + if (!dup) { + return NULL; + } + + return memcpy (dup, aMem, aLen); +} + +char* NPN_StrDup (const char *aString) +{ + return (char *) NPN_MemDup(aString, strlen (aString) + 1); +} -- cgit v0.9.1