NNTPGrab

/* 

    Copyright (C) 2005-2010  Erik van Pienbroek

    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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#include 

#include "gui.h"

#include "config_gui.h"

#ifdef HAVE_LIBPEAS

#include 

static PeasExtensionSet *extension_set = NULL;

#endif

enum {

    FIELD_PLUGIN_NAME,

    FIELD_ENABLED,

    FIELD_AUTO_LOAD,

    LAST_FIELD

};

static GtkTreeViewColumn *columns[LAST_FIELD] = { 0, 0, 0 };

G_MODULE_EXPORT void

on_btnWindowPluginsClose_clicked(GtkWidget *caller, gpointer data)

{

    GtkWidget *windowPlugins = nntpgrab_gui_base_get_widget("windowPlugins");

    gtk_widget_hide(windowPlugins);

}

G_MODULE_EXPORT gboolean

on_windowPlugins_delete_event(GtkWidget *widget, GdkEvent *event, gpointer user_data)

{

    gtk_widget_hide(widget);

    return TRUE;

}

static void

on_tree_view_select (GtkTreeSelection *selection, gpointer user_data)

{

    NNTPGrabPluginInfo info;

    char *plugin_name = NULL;

    GtkTreeModel *model = NULL;

    GtkTreeIter iter;

    GtkWidget *labelPluginName = nntpgrab_gui_base_get_widget("labelPluginName");

    GtkWidget *labelPluginAuthor = nntpgrab_gui_base_get_widget("labelPluginAuthor");

    GtkWidget *labelPluginVersion = nntpgrab_gui_base_get_widget("labelPluginVersion");

    GtkWidget *linkbuttonPluginURL = nntpgrab_gui_base_get_widget("linkbuttonPluginURL");

    GtkWidget *labelPluginDesc = nntpgrab_gui_base_get_widget("labelPluginDesc");

    char name[128];

    if (gtk_tree_selection_count_selected_rows(selection) == 0) {

        // No items selected, blank everything

        gtk_label_set_text(GTK_LABEL(labelPluginName), "");

        gtk_label_set_text(GTK_LABEL(labelPluginAuthor), "");

        gtk_label_set_text(GTK_LABEL(labelPluginVersion), "");

        gtk_widget_set_sensitive(linkbuttonPluginURL, FALSE);

        gtk_button_set_label(GTK_BUTTON(linkbuttonPluginURL), "");

        gtk_label_set_text(GTK_LABEL(labelPluginDesc), "");

        return;

    }

    gtk_tree_selection_get_selected(selection, &model, &iter);

    gtk_tree_model_get(model, &iter, FIELD_PLUGIN_NAME, &plugin_name, -1);

    memset(&info, 0, sizeof(info));

    if (!nntpgrab_glue_plugins_get_plugin_info(glue, plugin_name, &info)) {

        g_print(__FILE__ ":%i Unable to retrieve plugin information for plugin '%s'\n", __LINE__, plugin_name);

        g_free(plugin_name);

        return;

    }

    memset(&name, 0, sizeof(name));

    snprintf(name, sizeof(name) - 1, "%s", info.name);

    gtk_label_set_markup(GTK_LABEL(labelPluginName), name);

    gtk_label_set_text(GTK_LABEL(labelPluginAuthor), info.author);

    gtk_label_set_text(GTK_LABEL(labelPluginVersion), info.version);

    gtk_widget_set_sensitive(linkbuttonPluginURL, TRUE);

    gtk_link_button_set_uri(GTK_LINK_BUTTON(linkbuttonPluginURL), info.url);

    gtk_button_set_label(GTK_BUTTON(linkbuttonPluginURL), info.url);

    gtk_label_set_text(GTK_LABEL(labelPluginDesc), info.description);

}

#ifdef HAVE_LIBPEAS

static void

try_to_load_gtk_plugin(const char *plugin_name)

{

    const GList *plugins_list;

    g_return_if_fail(plugin_name != NULL);

    /* Check if there's also an GTK plugin for this Core plugin */

    plugins_list = peas_engine_get_plugin_list(peas_engine_get_default());

    while (plugins_list) {

        PeasPluginInfo *info = plugins_list->data;

        if (!g_strcmp0(peas_plugin_info_get_name(info), plugin_name)) {

            /* Matching plugin found. Load it if it wasn't loaded already */

            if (!peas_plugin_info_is_loaded(info)) {

                if (!peas_engine_load_plugin(peas_engine_get_default(), info)) {

                    char msg[1024];

                    GtkWidget *windowPlugins = nntpgrab_gui_base_get_widget("windowPlugins");

                    memset(&msg, 0, sizeof(msg));

                    snprintf(msg, sizeof(msg) - 1, _("Unable to load GTK plugin '%s'"), plugin_name);

                    nntpgrab_gui_base_dialog_show(windowPlugins, msg, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK);

                }

            }

            break;

        }

        plugins_list = g_list_next(plugins_list);

    }

}

static void

on_extension_added (PeasExtensionSet *set,

                    PeasPluginInfo *info,

                    PeasExtension *exten,

                    gpointer data)

{

    peas_activatable_activate (PEAS_ACTIVATABLE (exten));

}

static void

on_extension_removed (PeasExtensionSet *set,

                      PeasPluginInfo *info,

                      PeasExtension *exten,

                      gpointer data)

{

    peas_activatable_deactivate (PEAS_ACTIVATABLE (exten));

}

#endif

static void

on_plugin_loaded (NntpgrabGlue *obj, const char *plugin_name, gboolean is_persistent)

{

    GtkWidget *treePlugins = nntpgrab_gui_base_get_widget("treePlugins");

    GtkTreeModel *store = gtk_tree_view_get_model(GTK_TREE_VIEW(treePlugins));

    GtkTreeIter iter;

    if (!gtk_tree_model_get_iter_first(store, &iter)) {

        /* Huh? Empty tree */

        return;

    }

    do {

        char *plugin_name_store = NULL;

        gtk_tree_model_get(store, &iter, FIELD_PLUGIN_NAME, &plugin_name_store, -1);

        if (!strcmp(plugin_name, plugin_name_store)) {

            gtk_list_store_set(GTK_LIST_STORE(store), &iter, FIELD_ENABLED, TRUE, -1);

            g_free(plugin_name_store);

#ifdef HAVE_LIBPEAS

            try_to_load_gtk_plugin(plugin_name);

#endif

            return;

        }

        g_free(plugin_name_store);

    } while (gtk_tree_model_iter_next(store, &iter));

}

static void

on_plugin_unloaded (NntpgrabGlue *obj, const char *plugin_name)

{

    GtkWidget *treePlugins = nntpgrab_gui_base_get_widget("treePlugins");

    GtkTreeModel *store = gtk_tree_view_get_model(GTK_TREE_VIEW(treePlugins));

    GtkTreeIter iter;

    if (!gtk_tree_model_get_iter_first(store, &iter)) {

        /* Huh? Empty tree */

        return;

    }

    do {

        char *plugin_name_store = NULL;

        gtk_tree_model_get(store, &iter, FIELD_PLUGIN_NAME, &plugin_name_store, -1);

        if (!strcmp(plugin_name, plugin_name_store)) {

            gtk_list_store_set(GTK_LIST_STORE(store), &iter, FIELD_ENABLED, FALSE, -1);

            g_free(plugin_name_store);

            return;

        }

        g_free(plugin_name_store);

    } while (gtk_tree_model_iter_next(store, &iter));

}

static void

enabled_check_toggled(GtkWidget *caller, gchar *path, gpointer data)

{

    gboolean value;

    GtkTreeIter iter;

    GtkWidget *treePlugins;

    GtkWidget *windowPlugins;

    GtkTreeModel *model;

    char *plugin_name = NULL;

    char *errmsg = NULL;

    treePlugins = nntpgrab_gui_base_get_widget("treePlugins");

    windowPlugins = nntpgrab_gui_base_get_widget("windowPlugins");

    model = gtk_tree_view_get_model(GTK_TREE_VIEW(treePlugins));

    if (gtk_tree_model_get_iter_from_string(model, &iter, path)) {

        gtk_tree_model_get(model, &iter, FIELD_ENABLED, &value, FIELD_PLUGIN_NAME, &plugin_name, -1);

        if (value) {

            /* Unload the plugin */

            if (!nntpgrab_glue_plugins_unload_plugin(glue, plugin_name, &errmsg)) {

                char msg[1024];

                memset(&msg, 0, sizeof(msg));

                snprintf(msg, sizeof(msg) - 1, _("Unable to unload plugin '%s': %s"), plugin_name, errmsg);

                nntpgrab_gui_base_dialog_show(windowPlugins, msg, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK);

                g_free(errmsg);

            }

        } else {

            /* Load the plugin */

            if (!nntpgrab_glue_plugins_load_plugin(glue, plugin_name, &errmsg)) {

                char msg[1024];

                memset(&msg, 0, sizeof(msg));

                snprintf(msg, sizeof(msg) - 1, _("Unable to load plugin '%s': %s"), plugin_name, errmsg);

                nntpgrab_gui_base_dialog_show(windowPlugins, msg, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK);

                g_free(errmsg);

            }

        }

        /* There's no need to update the store here as it will happen automatically when an event is emit */

        g_free(plugin_name);

    }

}

static void

persistent_check_toggled(GtkWidget *caller, gchar *path, gpointer data)

{

    gboolean value;

    GtkTreeIter iter;

    GtkWidget *treePlugins;

    GtkTreeModel *model;

    treePlugins = nntpgrab_gui_base_get_widget("treePlugins");

    model = gtk_tree_view_get_model(GTK_TREE_VIEW(treePlugins));

    if (gtk_tree_model_get_iter_from_string(model, &iter, path)) {

        char *plugin_name = NULL;

        ConfigGUIOpts opts;

        GList *list;

        opts = config_gui_get_opts();

        gtk_tree_model_get(model, &iter, FIELD_AUTO_LOAD, &value, FIELD_PLUGIN_NAME, &plugin_name, -1);

        if (value) {

            list = opts.auto_load_plugins;

            while (list) {

                char *plugin_name2 = list->data;

                if (!strcmp(plugin_name, plugin_name2)) {

                    opts.auto_load_plugins = g_list_remove(opts.auto_load_plugins, plugin_name2);

                    g_free(plugin_name2);

                    break;

                }

                list = g_list_next(list);

            }

            value = FALSE;

        } else {

            opts.auto_load_plugins = g_list_append(opts.auto_load_plugins, g_strdup(plugin_name));

            value = TRUE;

        }

        config_gui_set_opts(opts);

        gtk_list_store_set(GTK_LIST_STORE(model), &iter, FIELD_AUTO_LOAD, value, -1);

        g_free(plugin_name);

    }

}

static gboolean

foreach_mark_auto_load_func(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)

{

    char *plugin_name = NULL;

    char *plugin_name2 = data;

    gtk_tree_model_get(model, iter, FIELD_PLUGIN_NAME, &plugin_name, -1);

    if (!strcmp(plugin_name, plugin_name2)) {

        gtk_list_store_set(GTK_LIST_STORE(model), iter, FIELD_AUTO_LOAD, TRUE, -1);

        return TRUE;

    }

    return FALSE;

}

void

gui_plugins_initialize(void)

{

    GtkListStore *store;

    GtkCellRenderer *cellRenderer;

    GtkTreeSelection *selection;

    NGList *plugins, *list;

    GtkWidget *treePlugins = nntpgrab_gui_base_get_widget("treePlugins");

    ngboolean beenhere = FALSE;

    ConfigGUIOpts opts;

    GList *list2;

    cellRenderer = gtk_cell_renderer_toggle_new();

    columns[FIELD_ENABLED] = gtk_tree_view_column_new_with_attributes(_("Enabled"), cellRenderer, "active", FIELD_ENABLED, NULL);

    gtk_tree_view_column_set_resizable(columns[FIELD_ENABLED], TRUE);

    gtk_tree_view_column_set_reorderable(columns[FIELD_ENABLED], TRUE);

    gtk_tree_view_insert_column(GTK_TREE_VIEW(treePlugins), columns[FIELD_ENABLED], -1);

    g_signal_connect((gpointer) cellRenderer, "toggled", G_CALLBACK(enabled_check_toggled), NULL);

    cellRenderer = gtk_cell_renderer_toggle_new();

    columns[FIELD_AUTO_LOAD] = gtk_tree_view_column_new_with_attributes(_("Load on startup"), cellRenderer, "active", FIELD_AUTO_LOAD, NULL);

    gtk_tree_view_column_set_resizable(columns[FIELD_AUTO_LOAD], TRUE);

    gtk_tree_view_column_set_reorderable(columns[FIELD_AUTO_LOAD], TRUE);

    gtk_tree_view_insert_column(GTK_TREE_VIEW(treePlugins), columns[FIELD_AUTO_LOAD], -1);

    g_signal_connect((gpointer) cellRenderer, "toggled", G_CALLBACK(persistent_check_toggled), NULL);

    cellRenderer = gtk_cell_renderer_text_new();

    columns[FIELD_PLUGIN_NAME] = gtk_tree_view_column_new_with_attributes(_("Plugin name"), cellRenderer, "text", FIELD_PLUGIN_NAME, NULL);

    gtk_tree_view_column_set_resizable(columns[FIELD_PLUGIN_NAME], TRUE);

    gtk_tree_view_column_set_reorderable(columns[FIELD_PLUGIN_NAME], TRUE);

    gtk_tree_view_insert_column(GTK_TREE_VIEW(treePlugins), columns[FIELD_PLUGIN_NAME], -1);

    store = gtk_list_store_new( LAST_FIELD,

                                G_TYPE_STRING    /* FIELD_PLUGIN_NAME */,

                                G_TYPE_BOOLEAN   /* FIELD_ENABLED */,

                                G_TYPE_BOOLEAN); /* FIELD_AUTO_LOAD */

    gtk_tree_view_set_model(GTK_TREE_VIEW(treePlugins), GTK_TREE_MODEL(store));

    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treePlugins));

    gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);

#ifdef HAVE_LIBPEAS

    extension_set = peas_extension_set_new(peas_engine_get_default (),

                                           PEAS_TYPE_ACTIVATABLE,

                                           "object", glue,

                                           NULL);

    //peas_extension_set_call(extension_set, "activate");

    g_signal_connect(extension_set, "extension-added", G_CALLBACK (on_extension_added), NULL);

    g_signal_connect(extension_set, "extension-removed", G_CALLBACK (on_extension_removed), NULL);

#endif

    /* Fill the tree view with items */

    list = plugins = nntpgrab_glue_plugins_get_avail_plugins(glue);

    while (list) {

        const char *plugin_name = list->data;

        NNTPGrabPluginInfo info;

        GtkTreeIter iter;

        memset(&info, 0, sizeof(info));

        if (!nntpgrab_glue_plugins_get_plugin_info(glue, plugin_name, &info)) {

            g_print(__FILE__ ":%i Unable to retrieve plugin information for plugin '%s'\n", __LINE__, plugin_name);

            list = ng_list_next(list);

            continue;

        }

        gtk_list_store_append(store, &iter);

        gtk_list_store_set( GTK_LIST_STORE(store), &iter,

                            FIELD_PLUGIN_NAME, info.name,

                            FIELD_ENABLED, info.is_loaded,

                            FIELD_AUTO_LOAD, info.is_persistent,

                            -1);

        if (!beenhere) {

            beenhere = TRUE;

            gtk_tree_selection_select_iter(selection, &iter);

        }

#ifdef HAVE_LIBPEAS

        if (info.is_loaded) {

            try_to_load_gtk_plugin(plugin_name);

        }

#endif

        list = ng_list_next(list);

    }

    nntpgrab_glue_plugins_free_avail_plugins(glue, plugins);

    /* Mark the auto-load plugins */

    opts = config_gui_get_opts();

    list2 = opts.auto_load_plugins;

    while (list2) {

        char *plugin_name = list2->data;

        gtk_tree_model_foreach(GTK_TREE_MODEL(store), foreach_mark_auto_load_func, plugin_name);

        list2 = g_list_next(list2);

    }

    g_signal_connect(selection, "changed", G_CALLBACK(on_tree_view_select), NULL);

    on_tree_view_select(selection, NULL);

    nntpgrab_glue_signal_connect(glue, "plugin_loaded", NG_CALLBACK(on_plugin_loaded), NULL);

    nntpgrab_glue_signal_connect(glue, "plugin_unloaded", NG_CALLBACK(on_plugin_unloaded), NULL);

}

void

gui_plugins_cleanup(void)

{

#ifdef HAVE_LIBPEAS

    if (extension_set != NULL) {

        g_object_unref(extension_set);

        extension_set = NULL;

    }

#endif

}