From 32f545cdf031ebe3718791f18e8fb6b6141fd081 Mon Sep 17 00:00:00 2001 From: Matthew Barnes Date: Fri, 28 Aug 2009 20:21:54 -0400 Subject: Simplify EPlugin loading at startup. - Require all EPlugin and EPluginHook subtypes be registered before loading plugins. This drastically simplifies the EPlugin/EPluginHook negotiation. - Turn most EPluginHook subtypes into GTypeModules and register their types from an e_module_load() function (does not include shell hooks). - Convert EPluginLib and the Mono and Python bindings to GTypeModules and register their types from an e_module_load() function, and kill EPluginTypeHook. --- modules/mail/e-mail-junk-hook.c | 323 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 323 insertions(+) create mode 100644 modules/mail/e-mail-junk-hook.c (limited to 'modules/mail/e-mail-junk-hook.c') diff --git a/modules/mail/e-mail-junk-hook.c b/modules/mail/e-mail-junk-hook.c new file mode 100644 index 0000000000..2687223af9 --- /dev/null +++ b/modules/mail/e-mail-junk-hook.c @@ -0,0 +1,323 @@ +/* + * e-mail-junk-hook.c + * + * 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 + * + * + * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com) + * + */ + +#include "e-mail-junk-hook.h" + +#include +#include + +#include "e-util/e-error.h" +#include "mail/em-junk.h" +#include "mail/em-utils.h" +#include "mail/mail-session.h" + +#define E_MAIL_JUNK_HOOK_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE \ + ((obj), E_TYPE_MAIL_JUNK_HOOK, EMailJunkHookPrivate)) + +struct _EMailJunkHookPrivate { + EMJunkInterface interface; +}; + +struct ErrorData { + const gchar *error_message; + GError *error; +}; + +static gpointer parent_class; +static GType mail_junk_hook_type; + +static gboolean +mail_junk_hook_idle_cb (struct ErrorData *data) +{ + GtkWidget *widget; + + widget = e_error_new ( + NULL, data->error_message, data->error->message, NULL); + em_utils_show_error_silent (widget); + + g_error_free (data->error); + g_slice_free (struct ErrorData, data); + + return FALSE; +} + +static void +mail_junk_hook_error (const gchar *error_message, + GError *error) +{ + struct ErrorData *data; + + g_return_if_fail (error != NULL); + + data = g_slice_new (struct ErrorData); + data->error_message = error_message; + data->error = error; + + g_idle_add ((GSourceFunc) mail_junk_hook_idle_cb, data); +} + +static const gchar * +mail_junk_hook_get_name (CamelJunkPlugin *junk_plugin) +{ + EMJunkInterface *interface; + + interface = (EMJunkInterface *) junk_plugin; + + if (!interface->hook->plugin->enabled) + return _("None"); + + return interface->hook->plugin->name; +} + +static void +mail_junk_hook_plugin_init (CamelJunkPlugin *junk_plugin) +{ + EMJunkInterface *interface; + EPluginClass *class; + + interface = (EMJunkInterface *) junk_plugin; + + class = E_PLUGIN_GET_CLASS (interface->hook->plugin); + g_return_if_fail (class->enable != NULL); + + class->enable (interface->hook->plugin, 1); +} + +static gboolean +mail_junk_hook_check_junk (CamelJunkPlugin *junk_plugin, + CamelMimeMessage *mime_message) +{ + EMJunkTarget target = { mime_message, NULL }; + EMJunkInterface *interface; + gpointer result; + + interface = (EMJunkInterface *) junk_plugin; + + if (!interface->hook->plugin->enabled) + return FALSE; + + result = e_plugin_invoke ( + interface->hook->plugin, + interface->check_junk, &target); + + if (target.error != NULL) + mail_junk_hook_error ("mail:junk-check-error", target.error); + + return (result != NULL); +} + +static void +mail_junk_hook_report_junk (CamelJunkPlugin *junk_plugin, + CamelMimeMessage *mime_message) +{ + EMJunkTarget target = { mime_message, NULL }; + EMJunkInterface *interface; + + interface = (EMJunkInterface *) junk_plugin; + + if (!interface->hook->plugin->enabled) + return; + + e_plugin_invoke ( + interface->hook->plugin, + interface->report_junk, &target); + + if (target.error != NULL) + mail_junk_hook_error ("mail:junk-report-error", target.error); +} + +static void +mail_junk_hook_report_notjunk (CamelJunkPlugin *junk_plugin, + CamelMimeMessage *mime_message) +{ + EMJunkTarget target = { mime_message, NULL }; + EMJunkInterface *interface; + + interface = (EMJunkInterface *) junk_plugin; + + if (!interface->hook->plugin->enabled) + return; + + e_plugin_invoke ( + interface->hook->plugin, + interface->report_notjunk, &target); + + if (target.error != NULL) + mail_junk_hook_error ( + "mail:junk-not-report-error", target.error); +} + +static void +mail_junk_hook_commit_reports (CamelJunkPlugin *junk_plugin) +{ + EMJunkInterface *interface; + + interface = (EMJunkInterface *) junk_plugin; + + if (!interface->hook->plugin->enabled) + return; + + e_plugin_invoke ( + interface->hook->plugin, + interface->commit_reports, NULL); +} + +static void +mail_junk_hook_finalize (GObject *object) +{ + EMailJunkHookPrivate *priv; + + priv = E_MAIL_JUNK_HOOK_GET_PRIVATE (object); + + g_free (priv->interface.check_junk); + g_free (priv->interface.report_junk); + g_free (priv->interface.report_notjunk); + g_free (priv->interface.commit_reports); + g_free (priv->interface.validate_binary); + g_free (priv->interface.plugin_name); + + /* Chain up to parent's finalize() method. */ + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static gint +mail_junk_hook_construct (EPluginHook *hook, + EPlugin *plugin, + xmlNodePtr node) +{ + EMailJunkHookPrivate *priv; + gchar *property; + + priv = E_MAIL_JUNK_HOOK_GET_PRIVATE (hook); + + /* Chain up to parent's construct() method. */ + if (E_PLUGIN_HOOK_CLASS (parent_class)->construct (hook, plugin, node) == -1) + return -1; + + if (!plugin->enabled) + return -1; + + node = xmlFirstElementChild (node); + + if (node == NULL) + return -1; + + if (g_strcmp0 ((gchar *) node->name, "interface") != 0) + return -1; + + property = e_plugin_xml_prop (node, "check_junk"); + priv->interface.check_junk = property; + + property = e_plugin_xml_prop (node, "report_junk"); + priv->interface.report_junk = property; + + property = e_plugin_xml_prop (node, "report_non_junk"); + priv->interface.report_notjunk = property; + + property = e_plugin_xml_prop (node, "commit_reports"); + priv->interface.commit_reports = property; + + property = e_plugin_xml_prop (node, "validate_binary"); + priv->interface.validate_binary = property; + + property = e_plugin_xml_prop (node, "name"); + priv->interface.plugin_name = property; + + if (priv->interface.check_junk == NULL) + return -1; + + if (priv->interface.report_junk == NULL) + return -1; + + if (priv->interface.report_notjunk == NULL) + return -1; + + if (priv->interface.commit_reports == NULL) + return -1; + + mail_session_add_junk_plugin ( + priv->interface.plugin_name, &priv->interface.camel); + + return 0; +} + +static void +mail_junk_hook_class_init (EMailJunkHookClass *class) +{ + GObjectClass *object_class; + EPluginHookClass *plugin_hook_class; + + parent_class = g_type_class_peek_parent (class); + g_type_class_add_private (class, sizeof (EMailJunkHookPrivate)); + + object_class = G_OBJECT_CLASS (class); + object_class->finalize = mail_junk_hook_finalize; + + plugin_hook_class = E_PLUGIN_HOOK_CLASS (class); + plugin_hook_class->construct = mail_junk_hook_construct; + plugin_hook_class->id = "org.gnome.evolution.mail.junk:1.0"; +} + +static void +mail_junk_hook_init (EMailJunkHook *mail_junk_hook) +{ + EMJunkInterface *interface; + + mail_junk_hook->priv = E_MAIL_JUNK_HOOK_GET_PRIVATE (mail_junk_hook); + + interface = &mail_junk_hook->priv->interface; + interface->camel.get_name = mail_junk_hook_get_name; + interface->camel.api_version = 1; + interface->camel.check_junk = mail_junk_hook_check_junk; + interface->camel.report_junk = mail_junk_hook_report_junk; + interface->camel.report_notjunk = mail_junk_hook_report_notjunk; + interface->camel.commit_reports = mail_junk_hook_commit_reports; + interface->camel.init = mail_junk_hook_plugin_init; + interface->hook = E_PLUGIN_HOOK (mail_junk_hook); +} + +GType +e_mail_junk_hook_get_type (void) +{ + return mail_junk_hook_type; +} + +void +e_mail_junk_hook_register_type (GTypeModule *type_module) +{ + const GTypeInfo type_info = { + sizeof (EMailJunkHookClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) mail_junk_hook_class_init, + (GClassFinalizeFunc) NULL, + NULL, /* class_data */ + sizeof (EMailJunkHook), + 0, /* n_preallocs */ + (GInstanceInitFunc) mail_junk_hook_init, + NULL /* value_table */ + }; + + mail_junk_hook_type = g_type_module_register_type ( + type_module, E_TYPE_PLUGIN_HOOK, + "EMailJunkHook", &type_info, 0); +} -- cgit v1.2.3