path: root/src/evbp.c

/*
 * Copyright (C) 2011, 2012  Dan Nicholson <dbn.lists@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.

 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301 USA.
 */

#include <config.h>
#include "evbp-viewer.h"
#include "evbp-mime.h"

#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <npapi.h>
#include <npfunctions.h>
#include <prtypes.h>
#include <glib.h>
#include <gtk/gtk.h>
#if GTK_MAJOR_VERSION > 2
#include <gtk/gtkx.h>
#endif
#include <gdk/gdkx.h>
#include <evince-document.h>
#include <evince-view.h>

#define EVBP_VERSION PACKAGE_VERSION
#define EVBP_NAME "Evince Plugin"
#define EVBP_DESCRIPTION "Evince Browser Plugin " EVBP_VERSION

typedef struct evbp_priv {
    NPP npp;
    NPWindow *window;
    GtkWidget *viewer;
} evbp_priv_t;

static char *evbp_mime_string = NULL;
static const NPNetscapeFuncs *npn_funcs = NULL;
static gboolean ev_is_initialized = FALSE;

static void
no_debug(const gchar *domain, GLogLevelFlags level,
         const gchar *message, gpointer data)
{
}

static void
setup_logging(void)
{
    if (!getenv("EVBP_DEBUG"))
        g_log_set_handler(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, no_debug, NULL);
}

static gboolean
ev_initialize(void)
{
    g_debug("%s", __func__);

    /* Some backends don't handle repeated init */
    if (ev_is_initialized) {
        g_debug("evince already initialized");
        return TRUE;
    } else
        g_debug("initializing evince");

    /* Init g_type and g_thread asap */
    g_type_init();
    if (!g_thread_supported())
        g_thread_init(NULL);

    /* Initialize evince */
    if (!ev_init()) {
        g_critical("evince failed to initialize");
        return FALSE;
    }

    ev_is_initialized = TRUE;
    return TRUE;
}

static gboolean
evbp_initialize(void)
{
    g_debug("%s", __func__);

    if (!ev_initialize())
        return FALSE;

#ifdef ENABLE_NLS
    /* Initialize the i18n stuff */
    bindtextdomain(GETTEXT_PACKAGE, GNOMELOCALEDIR);
    bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
    textdomain(GETTEXT_PACKAGE);
#endif

    /* Initialize gtk and evince icons */
    gtk_init(NULL, NULL);
    ev_stock_icons_init();

    return TRUE;
}

static void
evbp_shutdown(void)
{
    g_debug("%s", __func__);

    if (!ev_is_initialized)
        return;

    ev_shutdown();
    ev_stock_icons_shutdown();

    ev_is_initialized = FALSE;
}

static NPError
evbp_new(NPMIMEType pluginType, NPP instance, uint16_t mode,
         int16_t argc, char *argn[], char *argv[],
         NPSavedData *saved)
{
    evbp_priv_t *priv;

    g_debug("%s", __func__);

    /* create new private data */
    priv = npn_funcs->memalloc(sizeof(*priv));
    if (!priv) {
        g_critical("failed to allocate plugin private");
        return NPERR_OUT_OF_MEMORY_ERROR;
    }
    memset(priv, 0, sizeof(*priv));

    /* link the structures */
    priv->npp = instance;
    instance->pdata = priv;

    /* create new viewer */
    priv->viewer = evbp_viewer_new();

    return NPERR_NO_ERROR;
}

static NPError
evbp_destroy(NPP instance, NPSavedData **save)
{
    g_debug("%s", __func__);

    npn_funcs->memfree(instance->pdata);
    instance->pdata = NULL;

    return NPERR_NO_ERROR;
}

static NPError
evbp_set_window(NPP instance, NPWindow *window)
{
    evbp_priv_t *priv = instance->pdata;
    Window id;
    GtkWidget *plug;

    g_debug("%s", __func__);

    /* If this is the same window we already have, don't create a
       new plug */
    if (window == priv->window) {
        g_debug("window to set is the same, returning");
        return NPERR_NO_ERROR;
    }
    priv->window = window;

    /* Create a plug from the window id we were told about */
    id = (Window)window->window;
    g_debug("plugging into window id %lu", (unsigned long)id);
    plug = gtk_plug_new(id);
    gtk_container_add(GTK_CONTAINER(plug), priv->viewer);
    gtk_widget_show_all(plug);

    return NPERR_NO_ERROR;
}

static NPError
evbp_new_stream(NPP instance, NPMIMEType type, NPStream *stream,
                NPBool seekable, uint16_t *stype)
{
    g_debug("%s", __func__);

    /* fetch the url to a local file only */
    *stype = NP_ASFILEONLY;

    return NPERR_NO_ERROR;
}

static NPError
evbp_destroy_stream(NPP instance, NPStream *stream, NPReason reason)
{
    g_debug("%s", __func__);

    return NPERR_NO_ERROR;
}

static int32_t
evbp_write_ready(NPP instance, NPStream *stream)
{
    g_debug("%s", __func__);

    return 0;
}

static int32_t
evbp_write(NPP instance, NPStream *stream, int32_t offset, int32_t len,
           void *buffer)
{
    g_debug("%s", __func__);

    return 0;
}

static void
evbp_stream_as_file(NPP instance, NPStream *stream, const char *fname)
{
    evbp_priv_t *priv = instance->pdata;
    GFile *file;
    gchar *uri;
    GError *error = NULL;

    g_debug("%s", __func__);

    if (!g_file_test(fname, G_FILE_TEST_IS_REGULAR)) {
        g_warning("filename \"%s\" does not exist or is not a regular file",
                  fname);
        return;
    }

    /* convert the filename to a uri */
    file = g_file_new_for_commandline_arg(fname);
    uri = g_file_get_uri(file);
    g_object_unref(file);

    /* load the document */
    if (!evbp_viewer_load_uri(EVBP_VIEWER(priv->viewer), uri, &error)) {
        g_warning("failed to load document \"%s\": %s\n", uri,
                  error->message);
        g_error_free(error);
        return;
    }
}

static void
evbp_print(NPP instance, NPPrint *platformPrint)
{
    g_debug("%s", __func__);
}

static int16_t
evbp_handle_event(NPP instance, void *event)
{
    g_debug("%s", __func__);

    return 0;
}

static void
evbp_url_notify(NPP instance, const char *url, NPReason reason,
                void *notifyData)
{
    g_debug("%s", __func__);
}

static NPError
evbp_get_value(NPP instance, NPPVariable variable, void *value)
{
    NPError err = NPERR_NO_ERROR;

    g_debug("%s", __func__);

    switch (variable) {
    case NPPVpluginNameString:
        *((char **)value) = EVBP_NAME;
        break;
    case NPPVpluginDescriptionString:
        *((char **)value) = EVBP_DESCRIPTION;
        break;
    case NPPVpluginNeedsXEmbed:
        /* Require XEmbed */
        *((PRBool *)value) = PR_TRUE;
        break;
    case NPPVpluginWantsAllNetworkStreams:
        /* Don't require all network streams */
        *((NPBool *)value) = false;
        break;
    default:
        g_warning("cannot get value for NPPVariable %d", variable);
        err = NPERR_GENERIC_ERROR;
    }

    return err;
}

static NPError
evbp_set_value(NPP instance, NPNVariable variable, void *value)
{
    g_debug("%s", __func__);

    return NPERR_GENERIC_ERROR;
}

static NPError
save_npn_funcs(const NPNetscapeFuncs *funcs)
{
    g_debug("%s", __func__);

    /* Check for valid structure and compatibility */
    if (!funcs) {
        g_critical("NPNetscapeFuncs NULL");
        return NPERR_INVALID_FUNCTABLE_ERROR;
    }
    if (funcs->version >> 8 > NP_VERSION_MAJOR) {
        g_critical("incompatible NPAPI version %d", funcs->version >> 8);
        return NPERR_INCOMPATIBLE_VERSION_ERROR;
    }
    if (funcs->size < sizeof(npn_funcs)) {
        g_critical("size of NPN funtion table does not match NPNetscapeFuncs");
        return NPERR_INVALID_FUNCTABLE_ERROR;
    }

    npn_funcs = funcs;
    return NPERR_NO_ERROR;
}

static NPError
fill_npp_funcs(NPPluginFuncs *funcs)
{
    g_debug("%s", __func__);

    if (!funcs) {
        g_critical("NPPluginFuncs NULL");
        return NPERR_INVALID_FUNCTABLE_ERROR;
    }

    /* Fill the browser's table */
    funcs->version       = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR;
    funcs->size          = sizeof(*funcs);
    funcs->newp          = evbp_new;
    funcs->destroy       = evbp_destroy;
    funcs->setwindow     = evbp_set_window;
    funcs->newstream     = evbp_new_stream;
    funcs->destroystream = evbp_destroy_stream;
    funcs->asfile        = evbp_stream_as_file;
    funcs->writeready    = evbp_write_ready;
    funcs->write         = evbp_write;
    funcs->print         = evbp_print;
    funcs->event         = evbp_handle_event;
    funcs->urlnotify     = evbp_url_notify;
    funcs->getvalue      = evbp_get_value;
    funcs->setvalue      = evbp_set_value;

    return NPERR_NO_ERROR;
}

NPError
NP_Initialize(NPNetscapeFuncs *nfuncs, NPPluginFuncs *pfuncs)
{
    NPError ret;
    PRBool xembed = PR_FALSE;
    NPNToolkitType toolkit = 0;

    g_debug("%s", __func__);

    ret = save_npn_funcs(nfuncs);
    if (ret != NPERR_NO_ERROR) {
        g_critical("failed to initialize NPNetscapeFuncs");
        return ret;
    }

    ret = fill_npp_funcs(pfuncs);
    if (ret != NPERR_NO_ERROR) {
        g_critical("failed to initialize NPPluginFuncs");
        return ret;
    }

    /* Check that the browser supports XEmbed */
    ret = npn_funcs->getvalue(NULL, NPNVSupportsXEmbedBool,
                              (void *)&xembed);
    if (ret != NPERR_NO_ERROR || xembed != PR_TRUE) {
        g_critical("browser does not support XEmbed");
        return NPERR_INCOMPATIBLE_VERSION_ERROR;
    }

    /* Check that the toolkit is Gtk2 */
    ret = npn_funcs->getvalue(NULL, NPNVToolkit, (void *)&toolkit);
    if (ret != NPERR_NO_ERROR || toolkit != NPNVGtk2) {
        g_critical("toolkit is not Gtk2");
        return NPERR_INCOMPATIBLE_VERSION_ERROR;
    }

    if (!evbp_initialize()) {
        g_critical("failed to initialize plugin");
        return NPERR_MODULE_LOAD_FAILED_ERROR;
    }

    return NPERR_NO_ERROR;
}

char *
NP_GetPluginVersion(void)
{
    setup_logging();
    g_debug("%s", __func__);

    return EVBP_VERSION;
}

const char *
NP_GetMIMEDescription(void)
{
    GString *mimes;

    setup_logging();
    g_debug("%s", __func__);

    if (!ev_initialize()) {
        g_critical("failed to initialize evince; can't get MIME types");
        return NULL;
    }

    mimes = evbp_mime_get_description();
    if (evbp_mime_string)
        g_free(evbp_mime_string);
    evbp_mime_string = g_string_free(mimes, FALSE);

    return evbp_mime_string;
}

NPError
NP_Shutdown(void)
{
    g_debug("%s", __func__);

    if (evbp_mime_string) {
        g_free(evbp_mime_string);
        evbp_mime_string = NULL;
    }
    npn_funcs = NULL;

    evbp_shutdown();

    return NPERR_NO_ERROR;
}

NPError
NP_GetValue(void *instance, NPPVariable variable, void *value)
{
    g_debug("%s", __func__);

    return evbp_get_value(NULL, variable, value);
}