/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) version 3.
*
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with the program; if not, see <http://www.gnu.org/licenses/>
*
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*/
#include <config.h>
#include <sys/types.h>
#include <string.h>
#include <glib/gi18n.h>
#include <gconf/gconf-client.h>
#include <libedataserver/e-data-server-util.h>
#include <libedataserver/e-xml-utils.h>
#include "e-plugin.h"
#include "e-util-private.h"
#include "e-util.h"
/* plugin debug */
#define pd(x)
/* plugin hook debug */
#define phd(x)
/*
<camel-plugin
class="org.gnome.camel.plugin.provider:1.0"
id="org.gnome.camel.provider.imap:1.0"
type="shlib"
location="/opt/gnome2/lib/camel/1.0/libcamelimap.so"
factory="camel_imap_provider_new">
<name>imap</name>
<description>IMAP4 and IMAP4v1 mail store</description>
<class-data class="org.gnome.camel.plugin.provider:1.0"
protocol="imap"
domain="mail"
flags="remote,source,storage,ssl"/>
</camel-plugin>
<camel-plugin
class="org.gnome.camel.plugin.sasl:1.0"
id="org.gnome.camel.sasl.plain:1.0"
type="shlib"
location="/opt/gnome2/lib/camel/1.0/libcamelsasl.so"
factory="camel_sasl_plain_new">
<name>PLAIN</name>
<description>SASL PLAIN authentication mechanism</description>
</camel-plugin>
*/
/* EPlugin stuff */
static gpointer ep_parent_class;
/* global table of plugin types by pluginclass.type */
static GHashTable *ep_types;
/* plugin load path */
static GSList *ep_path;
/* global table of plugins by plugin.id */
static GHashTable *ep_plugins;
/* the list of disabled plugins from gconf */
static GSList *ep_disabled;
/* All classes which implement EPluginHooks, by class.id */
static GHashTable *eph_types;
struct _plugin_doc {
struct _plugin_doc *next;
struct _plugin_doc *prev;
gchar *filename;
xmlDocPtr doc;
GSList *plugin_hooks; /* EPlugin objects with pending hooks */
GSList *plugins; /* xmlNodePtr's of plugins with unknown type (mono,etc) */
};
enum {
EP_PROP_0,
EP_PROP_ENABLED
};
static gboolean
ep_check_enabled (const gchar *id)
{
/* Return TRUE if 'id' is NOT in the disabled list. */
return !g_slist_find_custom (ep_disabled, id, (GCompareFunc) strcmp);
}
static void
ep_set_enabled (const gchar *id, gint state)
{
GConfClient *client;
/* Bail out if no change to state, when expressed as a boolean: */
if ((state == 0) == (ep_check_enabled(id) == 0))
return;
if (state) {
GSList *link;
link = g_slist_find_custom (
ep_disabled, id, (GCompareFunc) strcmp);
if (link != NULL) {
g_free (link->data);
ep_disabled = g_slist_remove_link (ep_disabled, link);
}
} else
ep_disabled = g_slist_prepend (ep_disabled, g_strdup (id));
client = gconf_client_get_default ();
gconf_client_set_list (
client, "/apps/evolution/eplugin/disabled",
GCONF_VALUE_STRING, ep_disabled, NULL);
g_object_unref (client);
}
static gint
ep_construct (EPlugin *ep, xmlNodePtr root)
{
xmlNodePtr node;
gint res = -1;
gchar *localedir;
ep->domain = e_plugin_xml_prop(root, "domain");
if (ep->domain
&& (localedir = e_plugin_xml_prop(root, "localedir"))) {
#ifdef G_OS_WIN32
gchar *mapped_localedir =
e_util_replace_prefix (EVOLUTION_PREFIX,
e_util_get_prefix (),
localedir);
g_free (localedir);
localedir = mapped_localedir;
#endif
bindtextdomain(ep->domain, localedir);
g_free(localedir);
}
ep->name = e_plugin_xml_prop_domain(root, "name", ep->domain);
pd(printf("creating plugin '%s' '%s'\n", ep->name?ep->name:"un-named", ep->id));
node = root->children;
while (node) {
if (strcmp((gchar *)node->name, "hook") == 0) {
struct _EPluginHook *hook;
EPluginHookClass *type;
gchar *class = e_plugin_xml_prop(node, "class");
if (class == NULL) {
g_warning (
"Plugin '%s' load failed in '%s', "
"missing class property for hook",
ep->id, ep->path);
goto fail;
}
if (ep->enabled
&& eph_types != NULL
&& (type = g_hash_table_lookup(eph_types, class)) != NULL) {
g_free(class);
hook = g_object_new(G_OBJECT_CLASS_TYPE(type), NULL);
res = type->construct(hook, ep, node);
if (res == -1) {
g_warning("Plugin '%s' failed to load hook", ep->name);
g_object_unref(hook);
goto fail;
} else {
ep->hooks = g_slist_append(ep->hooks, hook);
}
} else {
g_free (class);
}
} else if (strcmp((gchar *)node->name, "description") == 0) {
ep->description = e_plugin_xml_content_domain(node, ep->domain);
} else if (strcmp((gchar *)node->name, "author") == 0) {
gchar *name = e_plugin_xml_prop(node, "name");
gchar *email = e_plugin_xml_prop(node, "email");
if (name || email) {
EPluginAuthor *epa = g_malloc0(sizeof(*epa));
epa->name = name;
epa->email = email;
ep->authors = g_slist_append(ep->authors, epa);
}
}
node = node->next;
}
res = 0;
fail:
return res;
}
static void
ep_enable (EPlugin *ep, gint state)
{
GSList *iter;
ep->enabled = state;
for (iter = ep->hooks; iter != NULL; iter = iter->next) {
EPluginHook *hook = iter->data;
e_plugin_hook_enable (hook, state);
}
ep_set_enabled(ep->id, state);
}
static void
ep_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
switch (property_id) {
case EP_PROP_ENABLED:
e_plugin_enable (
E_PLUGIN (object),
g_value_get_boolean (value));
return;
}
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
static void
ep_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
EPlugin *ep = E_PLUGIN (object);
switch (property_id) {
case EP_PROP_ENABLED:
g_value_set_boolean (value, ep->enabled);
return;
}
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
static void
ep_finalize (GObject *object)
{
EPlugin *ep = E_PLUGIN (object);
g_free (ep->id);
g_free (ep->description);
g_free (ep->name);
g_free (ep->domain);
g_slist_foreach (ep->hooks, (GFunc) g_object_unref, NULL);
g_slist_free (ep->hooks);
/* Chain up to parent's finalize() method. */
G_OBJECT_CLASS (ep_parent_class)->finalize (object);
}
static void
ep_class_init (EPluginClass *class)
{
GObjectClass *object_class;
ep_parent_class = g_type_class_peek_parent (class);
object_class = G_OBJECT_CLASS (class);
object_class->set_property = ep_set_property;
object_class->get_property = ep_get_property;
object_class->finalize = ep_finalize;
class->construct = ep_construct;
class->enable = ep_enable;
g_object_class_install_property (
object_class,
EP_PROP_ENABLED,
g_param_spec_boolean (
"enabled",
_("Enabled"),
_("Whether the plugin is enabled"),
TRUE,
G_PARAM_READWRITE));
}
static void
ep_init (EPlugin *ep)
{
ep->enabled = TRUE;
}
/**
* e_plugin_get_type:
*
* Standard GObject type function. This is only an abstract class, so
* you can only use this to subclass EPlugin.
*
* Return value: The type.
**/
GType
e_plugin_get_type (void)
{
static GType type = 0;
if (G_UNLIKELY (type == 0)) {
gchar *path, *col, *p;
static const GTypeInfo type_info = {
sizeof (EPluginClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) ep_class_init,
(GClassFinalizeFunc) NULL,
NULL, /* class_data */
sizeof (EPlugin),
0, /* n_preallocs */
(GInstanceInitFunc) ep_init,
NULL /* value_table */
};
type = g_type_register_static (
G_TYPE_OBJECT, "EPlugin", &type_info, 0);
/* Add paths in the environment variable or default global
* and user specific paths */
path = g_strdup(g_getenv("EVOLUTION_PLUGIN_PATH"));
if (path == NULL) {
/* Add the global path */
e_plugin_add_load_path(EVOLUTION_PLUGINDIR);
path = g_build_filename(g_get_home_dir(), ".eplugins", NULL);
}
p = path;
while ((col = strchr(p, G_SEARCHPATH_SEPARATOR))) {
*col++ = 0;
e_plugin_add_load_path(p);
p = col;
}
e_plugin_add_load_path(p);
g_free(path);
}
return type;
}
static EPlugin *
ep_load_plugin(xmlNodePtr root, struct _plugin_doc *pdoc)
{
gchar *prop, *id;
EPluginClass *class;
EPlugin *ep;
id = e_plugin_xml_prop(root, "id");
if (id == NULL) {
g_warning("Invalid e-plugin entry in '%s': no id", pdoc->filename);
return NULL;
}
if (g_hash_table_lookup(ep_plugins, id)) {
g_warning("Plugin '%s' already defined", id);
g_free(id);
return NULL;
}
prop = (gchar *)xmlGetProp(root, (const guchar *)"type");
if (prop == NULL) {
g_free(id);
g_warning("Invalid e-plugin entry in '%s': no type", pdoc->filename);
return NULL;
}
/* If we can't find a plugin, add it to a pending list
* which is checked when a new type is registered. */
class = g_hash_table_lookup(ep_types, prop);
if (class == NULL) {
pd(printf("Delaying loading of plugin '%s' unknown type '%s'\n", id, prop));
g_free(id);
xmlFree(prop);
pdoc->plugins = g_slist_prepend(pdoc->plugins, root);
return NULL;
}
xmlFree(prop);
ep = g_object_new(G_TYPE_FROM_CLASS(class), NULL);
ep->id = id;
ep->path = g_strdup(pdoc->filename);
ep->enabled = ep_check_enabled(id);
if (e_plugin_construct(ep, root) == -1)
e_plugin_enable(ep, FALSE);
g_hash_table_insert(ep_plugins, ep->id, ep);
return ep;
}
static gint
ep_load(const gchar *filename, gint load_level)
{
xmlDocPtr doc;
xmlNodePtr root;
EPlugin *ep = NULL;
struct _plugin_doc *pdoc;
doc = e_xml_parse_file (filename);
if (doc == NULL)
return -1;
root = xmlDocGetRootElement(doc);
if (strcmp((gchar *)root->name, "e-plugin-list") != 0) {
g_warning("No <e-plugin-list> root element: %s", filename);
xmlFreeDoc(doc);
return -1;
}
pdoc = g_malloc0(sizeof(*pdoc));
pdoc->doc = doc;
pdoc->filename = g_strdup(filename);
for (root = root->children; root; root = root->next) {
if (strcmp((gchar *)root->name, "e-plugin") == 0) {
gchar *plugin_load_level, *is_system_plugin;
plugin_load_level = NULL;
plugin_load_level = e_plugin_xml_prop (root, "load_level");
if (plugin_load_level) {
if ((atoi (plugin_load_level) == load_level) ) {
ep = ep_load_plugin(root, pdoc);
if (ep) {
if (load_level == 1)
e_plugin_invoke (ep, "load_plugin_type_register_function", NULL);
}
}
} else if (load_level == 2) {
ep = ep_load_plugin(root, pdoc);
}
if (ep) {
pd(printf ("\nloading plugin [%s] at load_level [%d]\n", ep->name, load_level));
/* README: May be we can use load_levels to achieve the same thing.
But it may be confusing for a plugin writer */
is_system_plugin = e_plugin_xml_prop (root, "system_plugin");
if (is_system_plugin && !strcmp (is_system_plugin, "true")) {
e_plugin_enable (ep, TRUE);
ep->flags |= E_PLUGIN_FLAGS_SYSTEM_PLUGIN;
} else
ep->flags &= ~E_PLUGIN_FLAGS_SYSTEM_PLUGIN;
g_free (is_system_plugin);
pdoc->plugin_hooks = g_slist_prepend(pdoc->plugin_hooks, ep);
ep = NULL;
}
}
}
xmlFreeDoc (pdoc->doc);
g_free (pdoc->filename);
g_free (pdoc);
return 0;
}
/**
* e_plugin_add_load_path:
* @path: The path to add to search for plugins.
*
* Add a path to be searched when e_plugin_load_plugins() is called.
* By default the system plugin directory and ~/.eplugins is used as
* the search path unless overriden by the environmental variable
* %EVOLUTION_PLUGIN_PATH.
*
* %EVOLUTION_PLUGIN_PATH is a : separated list of paths to search for
* plugin definitions in order.
*
* Plugin definitions are XML files ending in the extension ".eplug".
**/
void
e_plugin_add_load_path(const gchar *path)
{
ep_path = g_slist_append(ep_path, g_strdup(path));
}
static void
plugin_load_subclass (GType type,
GHashTable *hash_table)
{
EPluginClass *class;
class = g_type_class_ref (type);
g_hash_table_insert (hash_table, (gpointer) class->type, class);
}
static void
plugin_hook_load_subclass (GType type,
GHashTable *hash_table)
{
EPluginHookClass *hook_class;
EPluginHookClass *dupe_class;
gpointer key;
hook_class = g_type_class_ref (type);
/* Sanity check the hook class. */
if (hook_class->id == NULL || *hook_class->id == '\0') {
g_warning (
"%s has no hook ID, so skipping",
G_OBJECT_CLASS_NAME (hook_class));
g_type_class_unref (hook_class);
return;
}
/* Check for class ID collisions. */
dupe_class = g_hash_table_lookup (hash_table, hook_class->id);
if (dupe_class != NULL) {
g_warning (
"%s and %s have the same hook "
"ID ('%s'), so skipping %s",
G_OBJECT_CLASS_NAME (dupe_class),
G_OBJECT_CLASS_NAME (hook_class),
hook_class->id,
G_OBJECT_CLASS_NAME (hook_class));
g_type_class_unref (hook_class);
return;
}
key = (gpointer) hook_class->id;
g_hash_table_insert (hash_table, key, hook_class);
}
/**
* e_plugin_load_plugins:
*
* Scan the search path, looking for plugin definitions, and load them
* into memory.
*
* Return value: Returns -1 if an error occurred.
**/
gint
e_plugin_load_plugins(void)
{
GConfClient *client;
GSList *l;
gint i;
if (eph_types != NULL)
return 0;
ep_types = g_hash_table_new (g_str_hash, g_str_equal);
eph_types = g_hash_table_new (g_str_hash, g_str_equal);
ep_plugins = g_hash_table_new (g_str_hash, g_str_equal);
/* We require that all GTypes for EPlugin and EPluginHook
* subclasses be registered prior to loading any plugins.
* It greatly simplifies the loading process. */
e_type_traverse (
E_TYPE_PLUGIN, (ETypeFunc)
plugin_load_subclass, ep_types);
e_type_traverse (
E_TYPE_PLUGIN_HOOK, (ETypeFunc)
plugin_hook_load_subclass, eph_types);
client = gconf_client_get_default ();
ep_disabled = gconf_client_get_list (
client, "/apps/evolution/eplugin/disabled",
GCONF_VALUE_STRING, NULL);
g_object_unref (client);
for (i=0; i < 3; i++) {
for (l = ep_path;l;l = g_slist_next(l)) {
GDir *dir;
const gchar *d;
gchar *path = l->data;
pd(printf("scanning plugin dir '%s'\n", path));
dir = g_dir_open(path, 0, NULL);
if (dir == NULL) {
/*g_warning("Could not find plugin path: %s", path);*/
continue;
}
while ((d = g_dir_read_name(dir))) {
if (g_str_has_suffix (d, ".eplug")) {
gchar * name = g_build_filename(path, d, NULL);
ep_load(name, i);
g_free(name);
}
}
g_dir_close(dir);
}
}
return 0;
}
static void
ep_list_plugin(gpointer key, gpointer val, gpointer dat)
{
GSList **l = (GSList **)dat;
*l = g_slist_prepend(*l, g_object_ref(val));
}
/**
* e_plugin_list_plugins: List all plugins.
*
* Static class method to retrieve a list of all current plugins. They
* are listed in no particular order.
*
* Return value: A GSList of all plugins, they must be
* g_object_unref'd and the list freed.
**/
GSList *
e_plugin_list_plugins(void)
{
GSList *l = NULL;
if (ep_plugins)
g_hash_table_foreach(ep_plugins, ep_list_plugin, &l);
return l;
}
/**
* e_plugin_construct:
* @ep: an #EPlugin
* @root: The XML root node of the sub-tree containing the plugin
* definition.
*
* Helper to invoke the construct virtual method.
*
* Return value: The return from the construct virtual method.
**/
gint
e_plugin_construct(EPlugin *ep, xmlNodePtr root)
{
EPluginClass *class;
g_return_val_if_fail (E_IS_PLUGIN (ep), -1);
class = E_PLUGIN_GET_CLASS (ep);
g_return_val_if_fail (class->construct != NULL, -1);
return class->construct (ep, root);
}
/**
* e_plugin_invoke:
* @ep: an #EPlugin
* @name: The name of the function to invoke. The format of this name
* will depend on the EPlugin type and its language conventions.
* @data: The argument to the function. Its actual type depends on
* the hook on which the function resides. It is up to the called
* function to get this right.
*
* Helper to invoke the invoke virtual method.
*
* Return value: The return of the plugin invocation.
**/
gpointer
e_plugin_invoke(EPlugin *ep, const gchar *name, gpointer data)
{
EPluginClass *class;
g_return_val_if_fail (E_IS_PLUGIN (ep), NULL);
g_return_val_if_fail (name != NULL, NULL);
/* Prevent invocation on a disabled plugin. */
g_return_val_if_fail (ep->enabled, NULL);
class = E_PLUGIN_GET_CLASS (ep);
g_return_val_if_fail (class->invoke != NULL, NULL);
return class->invoke (ep, name, data);
}
/**
* e_plugin_get_symbol:
* @ep: an #EPlugin
* @name: The name of the symbol to fetch. The format of this name
* will depend on the EPlugin type and its language conventions.
*
* Helper to fetch a symbol name from a plugin.
*
* Return value: the symbol value, or %NULL if not found
**/
gpointer
e_plugin_get_symbol(EPlugin *ep, const gchar *name)
{
EPluginClass *class;
g_return_val_if_fail (E_IS_PLUGIN (ep), NULL);
class = E_PLUGIN_GET_CLASS (ep);
g_return_val_if_fail (class->get_symbol != NULL, NULL);
return class->get_symbol (ep, name);
}
/**
* e_plugin_enable:
* @ep: an #EPlugin
* @state: %TRUE to enable, %FALSE to disable
*
* Set the enable state of a plugin.
*
* THIS IS NOT FULLY IMPLEMENTED YET
**/
void
e_plugin_enable(EPlugin *ep, gint state)
{
EPluginClass *class;
g_return_if_fail (E_IS_PLUGIN (ep));
if ((ep->enabled == 0) == (state == 0))
return;
class = E_PLUGIN_GET_CLASS (ep);
g_return_if_fail (class->enable != NULL);
class->enable (ep, state);
g_object_notify (G_OBJECT (ep), "enabled");
}
/**
* e_plugin_get_configure_widget
* @ep: an #EPlugin
*
* Plugin itself should have implemented "e_plugin_lib_get_configure_widget"
* function * of prototype EPluginLibGetConfigureWidgetFunc.
*
* Returns: Configure widget or %NULL
**/
GtkWidget *
e_plugin_get_configure_widget (EPlugin *ep)
{
EPluginClass *class;
g_return_val_if_fail (E_IS_PLUGIN (ep), NULL);
class = E_PLUGIN_GET_CLASS (ep);
if (class->get_configure_widget == NULL)
return NULL;
return class->get_configure_widget (ep);
}
/**
* e_plugin_xml_prop:
* @node: An XML node.
* @id: The name of the property to retrieve.
*
* A static helper function to look up a property on an XML node, and
* ensure it is allocated in GLib system memory. If GLib isn't using
* the system malloc then it must copy the property value.
*
* Return value: The property, allocated in GLib memory, or NULL if no
* such property exists.
**/
gchar *
e_plugin_xml_prop(xmlNodePtr node, const gchar *id)
{
gchar *p = (gchar *)xmlGetProp(node, (const guchar *)id);
if (g_mem_is_system_malloc()) {
return p;
} else {
gchar * out = g_strdup(p);
if (p)
xmlFree(p);
return out;
}
}
/**
* e_plugin_xml_prop_domain:
* @node: An XML node.
* @id: The name of the property to retrieve.
* @domain: The translation domain for this string.
*
* A static helper function to look up a property on an XML node, and
* translate it based on @domain.
*
* Return value: The property, allocated in GLib memory, or NULL if no
* such property exists.
**/
gchar *
e_plugin_xml_prop_domain(xmlNodePtr node, const gchar *id, const gchar *domain)
{
gchar *p, *out;
p = (gchar *)xmlGetProp(node, (const guchar *)id);
if (p == NULL)
return NULL;
out = g_strdup(dgettext(domain, p));
xmlFree(p);
return out;
}
/**
* e_plugin_xml_int:
* @node: An XML node.
* @id: The name of the property to retrieve.
* @def: A default value if the property doesn't exist. Can be used
* to determine if the property isn't set.
*
* A static helper function to look up a property on an XML node as an
* integer. If the property doesn't exist, then @def is returned as a
* default value instead.
*
* Return value: The value if set, or @def if not.
**/
gint
e_plugin_xml_int(xmlNodePtr node, const gchar *id, gint def)
{
gchar *p = (gchar *)xmlGetProp(node, (const guchar *)id);
if (p)
return atoi(p);
else
return def;
}
/**
* e_plugin_xml_content:
* @node:
*
* A static helper function to retrieve the entire textual content of
* an XML node, and ensure it is allocated in GLib system memory. If
* GLib isn't using the system malloc them it must copy the content.
*
* Return value: The node content, allocated in GLib memory.
**/
gchar *
e_plugin_xml_content(xmlNodePtr node)
{
gchar *p = (gchar *)xmlNodeGetContent(node);
if (g_mem_is_system_malloc()) {
return p;
} else {
gchar * out = g_strdup(p);
if (p)
xmlFree(p);
return out;
}
}
/**
* e_plugin_xml_content_domain:
* @node:
* @domain:
*
* A static helper function to retrieve the entire textual content of
* an XML node, and ensure it is allocated in GLib system memory. If
* GLib isn't using the system malloc them it must copy the content.
*
* Return value: The node content, allocated in GLib memory.
**/
gchar *
e_plugin_xml_content_domain(xmlNodePtr node, const gchar *domain)
{
gchar *p, *out;
p = (gchar *)xmlNodeGetContent(node);
if (p == NULL)
return NULL;
out = g_strdup(dgettext(domain, p));
xmlFree(p);
return out;
}
/* ********************************************************************** */
static gpointer eph_parent_class;
static gint
eph_construct(EPluginHook *eph, EPlugin *ep, xmlNodePtr root)
{
eph->plugin = ep;
return 0;
}
static void
eph_enable(EPluginHook *eph, gint state)
{
/* NOOP */
}
static void
eph_class_init(EPluginHookClass *class)
{
eph_parent_class = g_type_class_peek_parent (class);
class->construct = eph_construct;
class->enable = eph_enable;
}
/**
* e_plugin_hook_get_type:
*
* Standard GObject function to retrieve the EPluginHook type. Since
* EPluginHook is an abstract class, this is only used to subclass it.
*
* Return value: The EPluginHook type.
**/
GType
e_plugin_hook_get_type(void)
{
static GType type = 0;
if (G_UNLIKELY (type == 0)) {
static const GTypeInfo type_info = {
sizeof (EPluginHookClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) eph_class_init,
(GClassFinalizeFunc) NULL,
NULL, /* class_data */
sizeof (EPluginHook),
0, /* n_preallocs */
(GInstanceInitFunc) NULL,
NULL /* value_table */
};
type = g_type_register_static (
G_TYPE_OBJECT, "EPluginHook", &type_info, 0);
}
return type;
}
/**
* e_plugin_hook_enable: Set hook enabled state.
* @eph:
* @state:
*
* Set the enabled state of the plugin hook. This is called by the
* plugin code.
*
* THIS IS NOT FULY IMEPLEMENTED YET
**/
void
e_plugin_hook_enable (EPluginHook *eph, gint state)
{
EPluginHookClass *class;
g_return_if_fail (E_IS_PLUGIN_HOOK (eph));
class = E_PLUGIN_HOOK_GET_CLASS (eph);
g_return_if_fail (class->enable != NULL);
class->enable (eph, state);
}
/**
* e_plugin_hook_mask:
* @root: An XML node.
* @map: A zero-fill terminated array of EPluginHookTargeKeys used to
* map a string with a bit value.
* @prop: The property name.
*
* This is a static helper function which looks up a property @prop on
* the XML node @root, and then uses the @map table to convert it into
* a bitmask. The property value is a comma separated list of
* enumeration strings which are indexed into the @map table.
*
* Return value: A bitmask representing the inclusive-or of all of the
* integer values of the corresponding string id's stored in the @map.
**/
guint32
e_plugin_hook_mask (xmlNodePtr root,
const struct _EPluginHookTargetKey *map,
const gchar *prop)
{
gchar *val, *p, *start, c;
guint32 mask = 0;
val = (gchar *)xmlGetProp(root, (const guchar *)prop);
if (val == NULL)
return 0;
p = val;
do {
start = p;
while (*p && *p != ',')
p++;
c = *p;
*p = 0;
if (start != p) {
gint i;
for (i=0;map[i].key;i++) {
if (!strcmp(map[i].key, start)) {
mask |= map[i].value;
break;
}
}
}
*p++ = c;
} while (c);
xmlFree(val);
return mask;
}
/**
* e_plugin_hook_id:
* @root:
* @map:
* @prop:
*
* This is a static helper function which looks up a property @prop on
* the XML node @root, and then uses the @map table to convert it into
* an integer.
*
* This is used as a helper wherever you need to represent an
* enumerated value in the XML.
*
* Return value: If the @prop value is in @map, then the corresponding
* integer value, if not, then ~0.
**/
guint32
e_plugin_hook_id (xmlNodePtr root,
const struct _EPluginHookTargetKey *map,
const gchar *prop)
{
gchar *val;
gint i;
val = (gchar *)xmlGetProp(root, (const guchar *)prop);
if (val == NULL)
return ~0;
for (i=0;map[i].key;i++) {
if (!strcmp(map[i].key, val)) {
xmlFree(val);
return map[i].value;
}
}
xmlFree(val);
return ~0;
}
